Working with the Unix OS

Processes II
For every semop operation that specifies SEM_UNDO:
- if the semaphore value goes up, the adjustment values goes down by the same amount;
- if the semaphore values goes down, the adjustment values goes up by the same amount;
- kernel applies adjustment on exist.
Simpler Semaphore Operations
System V semaphore facility is not simple to understand or use.
There are problems:
- creation of a semaphore with semget is independent of its initialization using semctl. This can lead to race
conditions if not careful.
- unless a semaphore is explicitly removed, it exists within the system, using system resources, until the system
is rebooted.
Shared Memory
Normal steps in client-server file copying:
- The server reads from the input file. Data is read by kernel into its internal block buffers and copied to the
server's buffer.
- The server writes this data in a message (via a pipe, FIFO, or message queue). Data is copied from user's buffer
into the kernel.
- The client reads the data from the IPC channel. Data is copied from kernel's IPC buffer to client's buffer.
- Finally the data is copied from the client's buffer to the output buffer. This might involve just copying the data
into a kernel buffer and returning, with the kernel doing the actual write operation to the device at some later
time.
Most Unix implementations try to speed up these copies as much as possible expensive in time.
Movement of data between client and server
client
server
output
file
FIFO, pipe
or message
kernel
input
file
The problem with these forms of IPC - pipes, FIFOs and message queues - is that for processes to exchange data, it
has to go through the kernel.
Shared memory provides a way around this by letting two or more processes share a memory segment.
The steps for the client-server examples:
- The server gets access to a shared memory segment using a semaphore.
- The server reads from the input file into the shared memory segment. address to read into points into shared
memory.
- When the read is complete the server notifies the client, again using a semaphore.
- The client writes the data from the shared memory segment to the output file
Movement of data between client and server
client
shared memory
server
output
file
kernel
input
file
Data is only copied twice. Both of these copies involve the kernel's block buffers. For every shared memory
140