EmbLogic » deepak.aggarwal https://www.emblogic.com/blog Embedded System and ARM Training Tue, 03 Mar 2020 13:00:06 +0000 en-US hourly 1 http://wordpress.org/?v=3.9.1 An introduction to block device drivers https://www.emblogic.com/blog/01/an-introduction-to-block-device-drivers-issue-9-from-issue-9-january-1995/ https://www.emblogic.com/blog/01/an-introduction-to-block-device-drivers-issue-9-from-issue-9-january-1995/#comments Sat, 11 Jan 2014 04:07:27 +0000 http://www.emblogic.com/blog/?p=8099 Continue reading →]]> It is customary for authors explaining device drivers to start with a complete explanation of character devices, saving block device drivers for a later chapter. To explain why this is, I need to briefly introduce character devices as well. To do that, I’ll give a little history.

When Unix was written 25 years ago, its design was eclectic. One unusual design feature was that every physical device connected to the computer was represented as a file. This was a bold decision, because many devices are very different from one another, especially at first glance. Why use the same interface to talk to a printer as to talk to a disk drive?

The short answer is that while the devices are very much different, they can be thought of as having most of the same characteristics as files. The entire system is then kept smaller and simpler by only using one interface with a few extensions.
A practical effect of the difference is that filesystems can only be mounted on block devices, not on character ones. For example, most tapes are character devices. It is possible to copy the contents of a raw, quiescent (unmounted and not being modified) filesystem to a tape, but you will not be able to mount the tape, even though it contains the same information as the disk.

Most textbooks and tutorials start by explaining character devices, the sequential-access ones, because a minimal character device driver is easier to write than a minimal block device driver. My own Linux Kernel Hackers’ Guide (the KHG) is written the same way.

]]> https://www.emblogic.com/blog/01/an-introduction-to-block-device-drivers-issue-9-from-issue-9-january-1995/feed/ 0 SOCKET IMPLIMENTATION https://www.emblogic.com/blog/12/socket-implimentation/ https://www.emblogic.com/blog/12/socket-implimentation/#comments Mon, 30 Dec 2013 01:18:11 +0000 http://www.emblogic.com/blog/?p=7899 Continue reading →]]> RCS LOG FILE

SERVER.C
head
1.1;
access;
symbols;
locks
deepak:1.1; strict;
comment @ * @;

1.1
date 2013.12.30.01.10.12; author deepak; state Exp;
branches;
next ;

desc
@server is created to test socket.
@

1.1
log
@Initial revision
________________________________________________________________________
CLIENT.C
head 1.1;
access;
symbols;
locks
deepak:1.1; strict;
comment @ * @;

1.1
date 2013.12.30.00.55.28; author deepak; state Exp;
branches;
next ;

desc
@client for socket is creted.
@

1.1
log
@Initial revision
________________________________________________________________________
HED.H

head 1.1;
access;
symbols;
locks
deepak:1.1; strict;
comment @ * @;

1.1
date 2013.12.30.00.56.46; author deepak; state Exp;
branches;
next ;

desc
@header file common for server and client is created.
@

1.1
log

]]> https://www.emblogic.com/blog/12/socket-implimentation/feed/ 0 BRIEF INTRODUCTION OF TCP/IP USED IN SOCKETS https://www.emblogic.com/blog/12/brief-introduction-of-tcpip-used-in-sockets/ https://www.emblogic.com/blog/12/brief-introduction-of-tcpip-used-in-sockets/#comments Mon, 30 Dec 2013 00:39:27 +0000 http://www.emblogic.com/blog/?p=7836 Continue reading →]]> The Internet protocol suite is the networking model and a set of communications protocols used for the Internet and similar networks. It is commonly known as TCP/IP, because its most important protocols, the Transmission Control Protocol (TCP) and the Internet Protocol (IP), were the first networking protocols defined in this standard. It is occasionally known as the DoD model, because the development of the networking model was funded by DARPA, an agency of the United States Department of Defense.

TCP/IP provides end-to-end connectivity specifying how data should be formatted, addressed, transmitted, routed and received at the destination. This functionality has been organized into four abstraction layers which are used to sort all related protocols according to the scope of networking involved.[1][2] From lowest to highest, the layers are the link layer, containing communication technologies for a single network segment (link), the internet layer, connecting independent networks, thus establishing internetworking, the transport layer handling process-to-process communication, and the application layer, which interfaces to the user and provides support services.

KEY ARCHITECTURE

1.> End-to-end principle: This principle has evolved over time. Its original expression put the maintenance of state and overall intelligence at the edges, and assumed the Internet that connected the edges retained no state and concentrated on speed and simplicity. Real-world needs for firewalls, network address translators, web content caches and the like have forced changes in this principle.[13]
2.> Robustness Principle: “In general, an implementation must be conservative in its sending behavior, and liberal in its receiving behavior. That is, it must be careful to send well-formed datagrams, but must accept any datagram that it can interpret (e.g., not object to technical errors where the meaning is still clear).” [14] “The second part of the principle is almost as important: software on other hosts may contain deficiencies that make it unwise to exploit legal but obscure protocol features.

]]> https://www.emblogic.com/blog/12/brief-introduction-of-tcpip-used-in-sockets/feed/ 0 implementation of IPC project with threads is completed https://www.emblogic.com/blog/12/implementation-of-ipc-project-with-threads-is-completed/ https://www.emblogic.com/blog/12/implementation-of-ipc-project-with-threads-is-completed/#comments Sat, 28 Dec 2013 08:16:00 +0000 http://www.emblogic.com/blog/?p=7852 Continue reading →]]> THE LOG FILE PROJECT IS:

head    1.1;
access;
symbols;
locks; strict;
comment    @ * @;

1.1
date    2013.12.28.07.56.32;    author emblogic;    state Exp;
branches;
next    ;

desc
@server with thread is created.
data from client to thread .
@

1.1
log
@Initial revision

head    1.1;
access;
symbols;
locks
emblogic:1.1; strict;
comment    @ * @;

1.1
date    2013.12.28.07.58.32;    author emblogic;    state Exp;
branches;
next    ;

desc
@requesting client using semaphore and shared memory sucssecfully created.
@

1.1

 

]]> https://www.emblogic.com/blog/12/implementation-of-ipc-project-with-threads-is-completed/feed/ 0 IPC Project completed with shared memory https://www.emblogic.com/blog/12/ipc-project-completed-with-shared-memory/ https://www.emblogic.com/blog/12/ipc-project-completed-with-shared-memory/#comments Thu, 26 Dec 2013 21:43:08 +0000 http://www.emblogic.com/blog/?p=7850 Continue reading →]]> here the log file the project.

 

head   1.2;

access;

symbols;

locks

deepak:1.2; strict;

comment       @ * @;

 

 

1.2

date    2013.12.26.20.55.33; author deepak;         state Exp;

branches;

next    1.1;

 

1.1

date    2013.12.26.19.24.38; author deepak;         state Exp;

branches;

next    ;

 

 

desc

@server is created .

data from client side is recieved.

@

 

 

1.2

log

@now new shared memory is craeted .

for server and processing client.

 

 

head   1.2;

access;

symbols;

locks

deepak:1.2; strict;

comment       @ * @;

 

 

1.2

date    2013.12.26.19.39.40; author deepak;         state Exp;

branches;

next    1.1;

 

1.1

date    2013.12.26.19.26.26; author deepak;         state Exp;

branches;

next    ;

 

 

desc

@client is created.

data send to server.

@

 

 

1.2

log

@removing bugs and warning.

@

text

head   1.1;

access;

symbols;

locks

deepak:1.1; strict;

comment       @ * @;

 

 

1.1

date    2013.12.26.20.39.24; author deepak;         state Exp;

branches;

next    ;

 

 

desc

@processing client is formed.

result is sent to server.

@

 

 

1.1

log

@Initial revision

@

]]> https://www.emblogic.com/blog/12/ipc-project-completed-with-shared-memory/feed/ 0 message queue log file https://www.emblogic.com/blog/12/message-queue-log-file/ https://www.emblogic.com/blog/12/message-queue-log-file/#comments Tue, 24 Dec 2013 11:09:14 +0000 http://www.emblogic.com/blog/?p=7837 Continue reading →]]> Log File For Server:

head    1.2;
access;
symbols;
locks
root:1.2; strict;
comment    @ * @;

1.2
date    2013.12.24.10.09.27;    author root;    state Exp;
branches;
next    1.1;

1.1
date    2013.12.24.09.32.25;    author root;    state Exp;
branches;
next    ;

desc
@This is the main server source file for client server project using message queue.
@

1.2
log
@This is the final source code of server.
change the value of msg_id of msg_st.
————————————————————————————————

Log File For Req_add
head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

1.1
date    2013.12.24.09.38.26;    author root;    state Exp;
branches;
next    ;

desc
@This is the request client for addition.
@

1.1
log
@Initial revision

 

—————————————————————————————-

Log file for Req_sub

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

1.1
date    2013.12.24.10.06.30;    author root;    state Exp;
branches;
next    ;

desc
@This is the source code of requesting client for substration.
@

1.1
log
@Initial revision

 

—————————————————————————————-

log file for Req_Mul

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

1.1
date    2013.12.24.10.07.13;    author root;    state Exp;
branches;
next    ;

desc
@This is source code of requesting client for multiplication.
@

1.1
log
@Initial revision

—————————————————————————————

Log file For Proccesing_Add

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

1.1
date    2013.12.24.09.54.10;    author root;    state Exp;
branches;
next    ;

desc
@This is the source code of processing client for addition.
@

1.1
log
@Initial revision

—————————————————————————————

Log file For Proccesing_Sub

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

1.1
date    2013.12.24.10.08.22;    author root;    state Exp;
branches;
next    ;

desc
@This is source code of processing client for substraction.
@

1.1
log
@Initial revision

—————————————————————————————

Log file For Proccesing_Mul

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

1.1
date    2013.12.24.10.09.14;    author root;    state Exp;
branches;
next    ;

desc
@This is source code of processing client for multiplcation.
@

1.1
log
@Initial revision

]]> https://www.emblogic.com/blog/12/message-queue-log-file/feed/ 0 SEMAPHORE PROGRAMING https://www.emblogic.com/blog/12/semaphore-programing/ https://www.emblogic.com/blog/12/semaphore-programing/#comments Sat, 21 Dec 2013 04:33:03 +0000 http://www.emblogic.com/blog/?p=7817 Continue reading →]]> In computer science, particularly in operating systems, a semaphore is a variable or abstract data type that is used for controlling access, by multiple processes, to a common resource in a parallel programming or a multi userenvironment.

Semantics and implementation

Counting semaphores are equipped with two operations, historically denoted as V (also known as signal()) and P (or wait())(see below). Operation V increments the semaphore S, and operation P decrements it. The semantics of these operations are shown below. Square brackets are used to indicate atomic operations, i.e., operations which appear indivisible from the perspective of other processes.

The value of the semaphore S is the number of units of the resource that are currently available. The P operation wastes time or sleeps until a resource protected by the semaphore becomes available, at which time the resource is immediately claimed. The V operation is the inverse: it makes a resource available again after the process has finished using it. One important property of semaphore S is that its value cannot be changed except by using the V signal() and P wait() operations.

A simple way to understand wait() and signal() operations is:

  • wait(): Decrements the value of semaphore variable by 1. If the value becomes negative, the process executing wait() is blocked, i.e., added to the semaphore’s queue.
  • signal(): Increments the value of semaphore variable by 1. After the increment, if the pre-increment value was negative (meaning there are processes waiting for a resource), it transfers a blocked process from the semaphore’s waiting queue to the ready queue.

Many operating systems provide efficient semaphore primitives that unblock a waiting process when the semaphore is incremented. This means that processes do not waste time checking the semaphore value unnecessarily.

 

]]> https://www.emblogic.com/blog/12/semaphore-programing/feed/ 0 project 1 https://www.emblogic.com/blog/09/project-1-14/ https://www.emblogic.com/blog/09/project-1-14/#comments Sat, 14 Sep 2013 15:05:58 +0000 http://www.emblogic.com/blog/?p=7186 multiple data compression successfully done

]]> https://www.emblogic.com/blog/09/project-1-14/feed/ 0