The document discusses different methods of inter-process communication (IPC) in Unix systems. It describes process tracing which allows a debugger process to control the execution of a traced process using the ptrace system call. It also describes the three main IPC mechanisms in Unix - messages, shared memory, and semaphores. Messages allow processes to exchange data streams using message queues. Shared memory allows processes to share parts of virtual memory. Semaphores allow processes to synchronize using integer values.

1. Inter Process
Communication
Mrs. Sowmya Jyothi, Faculty, Mangalore
References:
The Design of the UNIX Operating System
by Maurice J. Bach

2. • Inter Process Communication is a
mechanism whereby one process
communicates with another process.
• Communication means exchange of
data.
• The directions can be unidirectional,
bidirectional or multidirectional.
Inter Process Communication

4. Process Tracing:-
The unix system provides a primitive form of interprocess
communication for tracing processes, useful for debugging.
A debugger process takes as an input a process to be traced
and controls its execution with the PTRACE SYSTEM
CALL, setting and clearing break points, and reading and
writing data in its virtual address space.
Process tracing thus consists of synchronization of the
debugger process and the traced process and controlling
the execution of the traced process.
The ptrace() system call provides tracing and debugging
facilities.

5. The debugger takes as an input a child process,
which involves the ptrace system call and as a
result, the kernel sets a trace bit in the child
process table entry. The child now execs the
program being traced.
The trace bit is set in its process table entry, the
child awakens the parent from its sleep in the wait
system call, enters a special trace state similar to
the sleep state and does a context switch.
When the traced process awakens the debugger,
the debugger returns from wait, reads user input
commands, and converts them to a series of ptrace
calls to control the child(traced) process.

6. The syntax of the ptrace system call is
ptrace(cmd, pid, addr, data)
where cmd specifies various commands such as
reading data, writing data, resuming execution
and so on,
pid is the process ID of the traced process,
 addr is the Virtual address to be read or written
in the child process,
and data is an integer value to be written.

7. Unix Versions

8. System V IPC:-
The Unix system IPC package consists of 3
mechanisms.
1. Messages allow processes to send formatted
data streams to arbitrary processes.
2. Shared memory allow processes to share parts
of their virtual address space
3. Semaphores allow processes to synchronize
execution.

9. Common properties shared by the mechanisms are:
1. Each mechanism contains a table whose entries
describe all instances of the mechanism.
2. Each entry contains a numeric key.
3. Each mechanism contains a “get” system call to create a
new entry or to retrieve an existing one and parameters
to the calls include a key and flags..
4. For each IPC mechanism, the kernel uses the
following formula to find the index into the table of
data structures from the descriptor:
Index=descriptormodulo(number of entries in the
table).

10. 5. Each IPC entry has a permissions structure that
includes the User ID and group ID of the process that
created the entry, a user and group ID set by the
“control” system call and a set of read-write-execute
permissions for user, group, and others similar to the
file permission modes.
6. Each entry contains other status information such as
the process ID of the last process to update the entry
(send a message, receive a message, attach shared
memory and so on) and the time of last access or
update.
7. Each mechanism contains a “control” system call to
query status of an entry, to set status information, or
to remove the entry from the system.

13. MESSAGES
There are four system calls for messages:
msgget returns (and possibly creates) a message
descriptor.
msgctl has options to set and return parameters
associated with a message descriptor and an
option to remove descriptors.
msgsnd sends a message.
msgrcv receives a message.

14. 1. Message Passing
IPC facility provides two operations for fixed or
variable sized message:
◦send(message)
◦receive(message)
If processes P and Q wish to communicate, they
need to:
◦establish a communication link
◦exchange messages via send and receive
View of communication link:
◦physical (hardware bus, network links, shared
memory, etc.)
◦logical (syntax and semantics, abstractions)
14

15. A MESSAGE QUEUE is a queue onto which messages
can be placed.
A MESSAGE is composed of a message type (which is a
number), and message data.
A message queue can be either PRIVATE, OR PUBLIC.
If it IS PRIVATE, it can be accessed only by its creating
process or child processes of that creator.
If it's PUBLIC, it can be accessed by any process that
knows the queue's key.
Several processes may write messages onto a
message queue, or read messages from the queue.
Messages may be read by type, and thus not have to
be read in a FIFO order as is the case with pipes.

16. MESSAGES:-
There are 4 system calls for messages.
1. msgget- In order to use a message queue, it has to be
created first. In order to create a new message queue, or
access an existing queue, the msgget() system call is used.
Returns a message descriptor that designates a message
queue for use in other system calls.
Syntax: msgqid=msgget(key, flag)
Where msgqid is the descriptor returned by the call.
The Kernel stores messages on a linked list (queue) per
descriptor and it uses msgqid as an index into an array
of message queue headers.

17. The queue structure contains the following fields, in
addition to the common fields:
1. Pointers to the first and last messages on a linked
list.
2. The number of messages and total number of data
bytes on the linked list.
3. The maximum number of bytes of data that can be
on the linked list.
4. The process IDs of the last processes to send and
receive messages.
5. Time stamps of the last msgsnd, msgrcv,
and msgctl operations.

18. 2. A process uses the msgsnd system call to
send a message.
msgsnd(msgqid, msg, count, flag);
1. Where msgqid is the descriptor of a message
queue typically returned by a msgget call,
2. Msg is a pointer to a structure consisting of a
user-chosen integer type and a character
array,
3. Count gives the size of the data array
4. Flag specifies the action the kernel should
take if it runs out of internal buffer space.
flags specifying how to send the message.

19. 3. Reading A Message From The Queue -msgrcv()
count = msgrcv(id, msg, maxcount, type, flag)
1. Where id- is the message descriptor
2. Msg-is the address of a user structure to contain
the received message
3. Maxcount-is the size of the data array in msg,
4. Type-specifies the message type the user wants to
read
5. Flag-specifies what the kernel should do if
messages are on the queue.
6. The return value count, is the number of bytes
returned to the user.

20. 4. A PROCESS can query the status of a message
descriptor, set its status and remove a message
descriptor with the msgctl system call.
The syntax of the call is msgctl(id, cmd, mstatbuf)
Where id-message descriptor
cmd specifies the type of command
mstatbuf is the address of a user data structure that
will contain control parameters or the result of query.

21. 2. Shared Memory
1. Allows two or more processes to share
some memory segments
2. With some control over read/write
permissions

22. 2. Shared Memory:-
Processes can communicate directly with each other by
sharing parts of their virtual address space and then reading
and writing data stored in the shared memory.
Sharing the part of virtual memory and reading to and
writing from it, is another way for the processes to
communicate. The system calls are:
1. shmget creates a new region of shared memory or returns
an existing one.
2. shmat logically attaches a region to the virtual address
space of a process.
3. shmdt logically detaches a region.
4. shmctl manipulates the parameters associated with the
region.

24. 1. The shmget system call creates a new region of shared
memory or returns an existing one.
Syntax: shmid=shmget(key, size, flag)
key: Identical to msgget
size: Size of the memory segment if a creating a new
segment, can use 0 if getting an existing segment. Is the
number of bytes in the region.
flags: Identical to msgget.
Just like msgget, shmget could:
1. Create a new memory segment.
2. Return the queue ID of an existing segment.
3. Signal an error.

25. 2. A process attaches a shared memory region to its virtual
address space with the shmat system call.
Syntax: virtaddr = shmat(id, addr, flags)
Before the memory can be used, it must be attached by the
process and assigned a memory address.
1. shmid: id of shared memory segment as returned by
shmget.
2. addr: If 0, address is selected by kernel (recommended).
Otherwise, segment is attached at supplied address.
3. flags: Control behavior of attachment. SHM_RDONLY makes
the segment read-only.
4. Returns a pointer to the shared memory segment.

26. 3. Detaching Shared Memory Segments: Detaches
the shared memory segment located at the
address indicated by shmaddr.
The Syntax for shmdt: shmdt(addr);
where addr is the virtual address returned by a
prior shmat call.
4. shmctl manipulates the parameters associated
with the region.
Syntax of shmctl
shmctl(id, cmd, shmstatbuf);
which is similar to msgctl

27. 3. Semaphores:-
A semaphore is a resource that contains an integer value,
and allows processes to synchronize by testing and setting
this value in a single atomic operation.
A SEMAPHORE is UNIX System V consists of the following
elements:
1. The value of the semaphore.
2. The process ID of the last process to manipulate the
semaphore.
3. The number of processes waiting for semaphore value
to increase.
4. The number of processes waiting for the semaphore
value to equal 0.

28. The system calls are:
1. semget to create and gain access to a set of
semaphores.
2. semctl to do various control operations on the set.
3. semop to manipulate the values of semaphores.
1. Creation of a semaphore set - semget creates an array
of semaphores:
id = semget(key, count, flag);
Flag- used to define access permission mode and a few options
The kernel allocates an entry that points to an array of
semaphore structure with count elements

29. 2. Processes manipulate semaphores with
the semop system call:
oldval = semop(id, oplist, count);
where oplist is a pointer to an array of semaphore
operations, and
count is the size of the array.
The return value, oldval, is the value of the last
semaphore operated on in the set before the
operation was done.
The format of each element of oplist is,
•The semaphore number identifying the semaphore
array entry being operated on
•The operation
•Flags

30. Sockets
To provide common methods for interprocess
communication and to allow use of sophisticated
network protocols, the BSD system provides a
mechanism known as sockets.
A socket is an IPC channel with generated
endpoints.
Intended as building block for communication
Endpoints established by the source and
destination processes
The kernel structure consists of three parts:
the socket layer, the protocol layer, and the
device layer, as shown in the figure:

32. 1. The Socket layer provides the interface
between the system calls and the lower layers.
2. The Protocol layer contains the protocol
modules used for communication, and
3. The Device layer contains the device drivers
that control the network devices.
Sockets that share common communications
properties, such as naming conventions and
protocol address formats, are grouped
into domains.

33. 1. The socket system call establishes the
end point of a communications link.
sd = socket(format, type, protocol);
where format specifies the
communications domain,
type indicates the type of
communication over the socket,
 and protocol indicates a particular
protocol to control the communication.

34. 2. The close system call - closes sockets.
3. The bind system call associates a name
with the socket descriptor.
Binding prepares a socket for use by a process
bind(sd, address, length);
where address points to a structure that
specifies an identifier specific to the
communications domain and protocol
specified in the socket system call.
length is the length of the address structure.

35. 4. The connect system call requests
that the kernel make a connection to
an existing socket:
connect(sd, address, length);
where address is the address of the
target socket. Both sockets must use
the same communications domain and
protocol.

36. 5. The listen system call specifies the
maximum queue length:
listen(sd, qlength);
6. The accept call receives incoming requests
for a connection to a server process:
nsd = accept(sd, address, addrlen);
where address points to a user data array that
the kernel fills with the return address of the
connecting client, and
addrlen indicates the size of the user array.

37. 7. The send and recv system calls transmit data over
a connected socket:
count = send(sd, msg, length, flags);
count = recv(sd, buf, length, flags);
The datagram versions of these system
calls, sendto and recvfrom have additional parameters
for addresses.
Processes can also use read and write system calls on
stream (virtual circuit) sockets after the connection is
set up.

38. 8. The shutdown system call closes a socket
connection:
shutdown(sd, mode);
where mode indicates whether the sending side, the
receiving side, or both sides no longer allow data
transmission. After this call, the socket descriptors are
still intact.
9. The close system call frees the socket descriptor.

39. 10. The getsocketname system call gets the
name of a socket bound by a
previous bind call:
getsocketname(sd, name, length);
The getsockopt and setsockopt calls retrieve
and set various options associated with the
socket, according to the communications domain
and protocol of the socket.