1. Lock and IPC (Inter-Process Communication) (Chap 12, 14 in the book “Advanced Programming in the UNIX Environment”)
Acknowledgement : Prof. Y. Moon at Kangwon Nat’l Univ.

2. Lock
a synchronization mechanism for enforcing limits on access to a resource in an environment where there are many threads of execution
Advisory lock
Other processes can still access (read or write) to a locked resource
There is a way to check whether a resource is locked
Mandatory lock
Prevent access to a locked resource

3. Advisory Locking
#include <fcntl.h>
int flock(int fd, int operation);
Returns: 0 if OK, -1 otherwise
Applies or removes an advisory lock on the file associated with the file descriptor fd
Operation can be
LOCK_SH
LOCK_EX
LOCK_NB : non-blocking mode. Use together with other lock modes by OR ‘|’
LOCK_UN
Locks entire file

4. Advisory Record Locking
#include <fcntl.h>
int fcntl(int fd, int cmd, struct flock* lock);
Returns: depends on cmd if OK, -1 on error
struct flock {
short l_type; /* F_RDLCK, F_WRLCK, or F_UNLCK */
off_t l_start; /* offset in bytes from l_whence */
short l_whence; /* SEEK_SET, SEEK_CUR, SEEK_END */
off_t l_len; /* length, in bytes; 0 means “lock to EOF */
pid_t l_pid; /* returned by F_GETLK */ }
Lock types are :
F_RDLCK : non-exclusive (read) lock; fails if write lock exists
F_WRLCK : exclusive (write) lock; fails if any lock exists
F_UNLCK : releases our lock on specified range

5. Setting and Clearing a lock
struct flock fl;
int fd;
fl.l_type = F_WRLCK; /* F_RDLCK, F_WRLCK, F_UNLCK */
fl.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */
fl.l_start = 0; /* Offset from l_whence */
fl.l_len = 0; /* length, 0 = to EOF */
fl.l_pid = getpid(); /* our PID */
fd = open("filename", O_WRONLY);
fcntl(fd, F_SETLKW, &fl); /* F_GETLK, F_SETLK, F_SETLKW */
fl.l_type = F_UNLCK; /* tell it to unlock the region */
fcntl(fd, F_SETLK, &fl); /* set the region to unlocked */
cmd
F_SETLKW: obtain lock
F_SETLK: obtain lock but no wait if it cannot obtain the lock
F_GETLK: only check to see if there is a lock

6. Non-Blocking(Asynchronous) I/O
A form of I/O that permits subsequent processing to continue before current processing has finished.
Non Blocking I/O function returns immediately
Two ways for specifying non-blocking I/O
When calling “open” and specify O_NONBLOCK flag
For a file descriptor that is already open, call fcntl to turn on O_NONBLOCK file status flag.

7. IPC (Inter-Process Communication)
Pipes
FIFOs
Message Queue
Shared Memory
Semaphores

8. Contents Pipes FIFOs System V IPC APUE (Interprocess Communication
Message Queues
Shared Memory
Semaphores

9. IPC using Pipes IPC using regular files IPC using pipes
unrelated processes can share
fixed size
lack of synchronization
IPC using pipes
for transmitting data between related processes
can transmit an unlimited amount of data
automatic synchronization on open()

10. Pipes in a UNIX Shell
In a UNIX shell, the pipe symbol is: | (the vertical bar)
In a shell, UNIX pipes look like:
$ ls -al | more
where the standard output of the program at the left (i.e., the producer) becomes the standard input of the program at the right (i.e., the consumer).
We can have longer pipes:
$ ls –l | grep *.c | wc > output.file

11. Example (1/2)
$ who | sort

12. Example (2/2)

13. Data transmitting Types of pipes IPC using Pipes
APUE (Interprocess Communication
Data transmitting
data is written into pipes using the write() system call
data is read from a pipe using the read() system call
automatic blocking when full or empty
Types of pipes
(unnamed) pipes
named pipes (FIFOs)

14. In UNIX, pipes are the oldest form of IPC.
Limitations of Pipes:
Half duplex (data flows in one direction)
Can only be used between processes that have a common ancestor (Usually used between the parent and child processes)
Processes cannot pass pipes and must inherit them from their parent
If a process creates a pipe, all its children will inherit it

15. Pipes (2/4) Two file descriptors are returned through the fd argument
APUE (Interprocess Communication
#include <unistd.h>
int pipe(int fd[2])
Returns: 0 if OK, -1 on error
Two file descriptors are returned through the fd argument
fd[0]: can be used to read from the pipe, and
fd[1]: can be used to write to the pipe
Anything that is written on fd[1] may be read by fd[0].
This is of no use in a single process.
However, between processes, it gives a method of communication
The pipe() system call gives parent-child processes a way to communicate with each other.

16. Pipes (3/4) parent child parent child pipe kernel pipe kernel fd[0]
parent closes fd[0]
child closes fd[1]
parent  child:
parent closes fd[1]
child closes fd[0]
parent
fd[0]
child
parent
fd[1]
child
fd[1]
fd[0]
pipe
kernel
pipe
kernel

17. Read from a pipe with write end closed: (fd[1]이 close된 경우)
Pipes (4/4)
Read from a pipe with write end closed: (fd[1]이 close된 경우)
returns 0 to indicate EOF
Write to a pipe with read end closed: (fd[0]가 close된 경우)
SIGPIPE generated,
write() returns error (errno == EPIPE)

18. example: pipe.c (1/2) #include <stdio.h> // pipe.c
#define READ 0
#define WRITE 1
char* phrase = "Stuff this in your pipe and smoke it";
main( ) {
int fd[2], bytesRead;
char message[100];
pipe(fd);
if (fork() == 0) { // child
close(fd[READ]);
write(fd[WRITE], phrase, strlen(phrase)+1);
fprintf(stdout, "[%d, child] write completed.\n", getpid());
close(fd[WRITE]); }
else { // parent
bytesRead = read(fd[READ], message, 100);
fprintf(stdout, "[%d, parent] read completed.\n", getpid());
printf("Read %d bytes: %s\n", bytesRead,message);

19. example: pipe.c (2/2)
실행 결과

20. Contents Pipes FIFOs System V IPC Message Queues Shared Memory
Semaphores

21. FIFOs are "named pipes" that can be used between unrelated processes.
APUE (Interprocess Communication
Pipes can be used only between related processes. (e.g., parent and child processes)
FIFOs are "named pipes" that can be used between unrelated processes.
A type of file
stat.st_mode == FIFO
Test with S_ISFIFO() macro

22. Creating FIFOs is similar to creating a file.
APUE (Interprocess Communication
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
Returns: 0 if OK, -1 on error
Creating FIFOs is similar to creating a file.
pathname: filename
mode: permissons, same as for open() function
Using a FIFO is similar to using a file.
we can open, close, read, write, unlink, etc., to the FIFO.

23. if FIFO opened without O_NONBLOCK flag
FIFOs (3/3)
if FIFO opened without O_NONBLOCK flag
an open for read-only blocks until some other process opens the FIFO for writing
an open for write-only blocks until some other process opens the FIFO for reading
if O_NONBLOCK is specified (nonblocking)
an open for read-only returns immediately if no process has the FIFO open for writing
an open for write-only returns an error (errno=ENXIO) if no process has the FIFO open for reading
Like a pipe, if we write to a FIFO that no process has open for reading, the signal SIGPIPE is generated.
When the last writer for a FIFO closes the FIFO, an end of file (EOF) is generated for the reader of the FIFO.

24. Uses of FIFOs
Used by shell commands to pass data from one shell pipeline to another, without creating intermediate files.
Used in client-server application to pass data between clients and server.

25. Using FIFOs to Duplicate Output Streams
tee(1) copies its standard input to both its standard output and to the file named on its command line.
$ mkfifo fifo1
$ prog3 < fifo1 &
$ prog1 < infile | tee fifo1 | prog2
fifo1
prog3
infile
prog1
tee
prog2

26. An Example using a FIFO
APUE (Interprocess Communication

27. Client-Server Communication Using a FIFO
Server creates a “well-known” FIFO to communicate with clients.
client
well-known
FIFO
read
request
server
write request .
Problem: Server can't reply clients using a single “well-known” FIFO

28. Contents Pipes FIFOs System V IPC Message Queues Shared Memory
Semaphores (간단히)

29. System V IPC Message Queues Shared Memory Semaphores
Send and receive amount of data called “messages”.
The sender classifies each message with a type.
Shared Memory
Shared memory allows two or more processes to share a given region of memory.
Readers and writers may use semaphore for synchronization.
Semaphores
Process synchronization and resource management
For example, a semaphore might be used to control access to a device like printer.

30. Identifiers & Keys
Identifier: each IPC structure has a nonnegative integer
Key: when creating an IPC structure, a key must be specified (key_t)
id = xxxget(key, …)
How to access the same IPC?  key in a common header
Define a key in a common header
Client and server agree to use that key
Server creates a new IPC structure using that key
Problem when the key is already in use
(msgget, semget, shmget returns error)
Solution: delete existing key, create a new one again!

31. IPC System Calls msg/sem/shm get msg/sem/shm ctl msg/sem/shm op
APUE (Interprocess Communication
msg/sem/shm get
Create new or open existing IPC structure.
Returns an IPC identifier
msg/sem/shm ctl
Determine status, set options and/or permissions
Remove an IPC identifier
msg/sem/shm op
Operate on an IPC identifier
For example(Message queue)
add new msg to a queue (msgsnd)
receive msg from a queue (msgrcv)

32. Permission Structure ipc_perm is associated with each IPC structure.
Defines the permissions and owner.
struct ipc_perm {
uid_t uid; /* owner's effective user id */
gid_t gid; /* owner's effective group id */
uid_t cuid; /* creator's effective user id */
gid_t cgid; /* creator’s effective group id */
mode_t mode; /* access modes */
ulong seq; /* slot usage sequence number */
key_t key; /* key */ };

33. Linked list of messages
Message Queues (1/2)
Linked list of messages
Stored in kernel
Identified by message queue identifier (in kernel)
msgget
Create a new queue or open existing queue.
msgsnd
Add a new message to a queue
msgrcv
Receive a message from a queue
Fetching order: based on type

34. Message Queues (2/2) Each queue has a structure
struct msqid_ds {
struct ipc_perm msg_perm;
struct msg *msg_first; /* ptr to first msg on queue */
struct msg *msg_last; /* ptr to last msg on queue */
ulong msg_cbytes; /* current # bytes on queue */
ulong msg_qnum; /* # msgs on queue */
ulong msg_qbytes; /* max # bytes on queue */
pid_t msg_lspid; /* pid of last msgsnd() */
pid_t msg_lrpid; /* pid of last msgrcv() */
time_t msg_stime; /* last-msgsnd() time */
time_t msg_rtime; /* last-msgrcv() time */
time_t msg_ctime; /* last-change time */ };
We can get the structure using msgctl() function.
Actually, however, we don’t need to know the structure in detail.

35. msgget() Create new or open existing queue flag : ipc_perm.mode
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int flag);
Returns: msg queue ID if OK, -1 on error
Create new or open existing queue
flag : ipc_perm.mode
Example
msg_qid = msgget(DEFINED_KEY, IPC_CREAT | 0666);

36. msgctl() Performs various operations on a queue
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
Returns: 0 if OK, -1 on error
Performs various operations on a queue
cmd = IPC_STAT: fetch the msqid_ds structure for this queue, storing it in buf
cmd = IPC_SET: set the following four fields from buf: msg_perm.uid, msg_perm.gid, msg_perm.mode, and msg_qbytes
cmd = IPC_RMID: remove the message queue.

37. msgsnd() msgsnd() places a message at the end of the queue.
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msqid, const void *ptr, size_t nbytes, int flag);
Returns: 0 if OK, -1 on error
msgsnd() places a message at the end of the queue.
ptr: pointer that points to a message
nbytes: length of message data
if flag = IPC_NOWAIT: IPC_NOWAIT is similar to the nonblocking I/O flag for file I/O.
Structure of messages
struct mymesg {
long mtype; /* positive message type */
char mtext[512]; /* message data, of length nbytes */ };

38. msgrcv() msgrcv() retrieves a message from a queue.
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv(int msqid, void *ptr, size_t nbytes, long type, int flag);
Returns: data size in message if OK, -1 on error
msgrcv() retrieves a message from a queue.
type == 0: the first message on the queue is returned
type > 0: the first message on the queue whose message type equals type is returned
type < 0: the first message on the queue whose message type is the lowest value less than or equal to the absolute value of type is returned
flag may be given by IPC_NOWAIT

39. example: sender.c receiver.c (1/4)
#include <stdio.h> // sender.c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define DEFINED_KEY 0x
main(int argc, char **argv) {
int msg_qid;
struct {
long mtype;
char content[256];
} msg;
fprintf(stdout, "=========SENDER==========\n");
if((msg_qid = msgget(DEFINED_KEY, IPC_CREAT | 0666)) < 0) {
perror("msgget: "); exit(-1); }
msg.mtype = 1;
while(1) {
memset(msg.content, 0x0, 256);
gets(msg.content);
if(msgsnd(msg_qid, &msg, sizeof(msg.content), 0) < 0) {
perror("msgsnd: "); exit(-1);

40. example: sender.c receiver.c (2/4)
#include <stdio.h> // receiver.c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define DEFINED_KEY 0x
main(int argc, char **argv) {
int msg_qid;
struct {
long mtype;
char content[256];
} msg;
fprintf(stdout, "=========RECEIVER==========\n");
if((msg_qid = msgget(DEFINED_KEY, IPC_CREAT | 0666)) < 0) {
perror("msgget: "); exit(-1); }
while(1) {
memset(msg.content, 0x0, 256);
if(msgrcv(msg_qid, &msg, 256, 0, 0) < 0) {
perror("msgrcv: "); exit(-1);
puts(msg.content);

41. example: sender.c receiver.c (3/4)
APUE (Interprocess Communication

42. example: sender.c receiver.c (4/4)

43. Allows multiple processes to share a region of memory
Shared Memory
Allows multiple processes to share a region of memory
Fastest form of IPC: no need of data copying between client & server
If a shared memory segment is attached
It become a part of a process data space, and shared among multiple processes
Readers and writers may use semaphore to
synchronize access to a shared memory segment

44. Shared Memory Segment Structure
APUE (Interprocess Communication
Each shared memory has a structure
struct shmid_ds {
struct ipc_perm shm_perm;
struct anon_map *shm_amp; /* pointer in kernel */
int shm_segsz; /* size of segment in bytes */
ushort shm_lkcnt; /* # of times segment is being locked */
pid_t shm_lpid; /* pid of last shmop() */
pid_t shm_cpid; /* pid of creator */
ulong shm_nattch; /* # of current attaches */
ulong shm_cnattch; /* used only for shminfo() */
time_t shm_atime; /* last-attach time */
time_t shm_dtime; /* last-detach time */
time_t shm_ctime; /* last-change time */ };
We can get the structure using shmctl() function.
Actually, however, we don’t need to know the structure in detail.

45. shmget() Obtain a shared memory identifier
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, int size, int flag);
Returns: shared memory ID if OK, -1 on error
Obtain a shared memory identifier
size: is the size of the shared memory segment
flag: ipc_perm.mode
Example
shmId = shmget(key, size, PERM|IPC_CREAT|IPC_EXCL|0666);

46. shmctl() Performs various shared memory operations
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
Returns: 0 if OK, -1 on error
Performs various shared memory operations
cmd = IPC_STAT: fetch the shmid_ds structure into buf
cmd = IPC_SET: set the following three fields from buf: shm_perm.uid, shm_perm.gid, and shm_perm.mode
cmd = IPC_RMID: remove the shared memory segment set from the system

47. shmat() Attached a shared memory to an address
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
void *shmat (int shmid, void *addr, int flag);
Returns: pointer to shared memory segment if OK, -1 on error
Attached a shared memory to an address
flag = SHM_RDONLY: the segment is read-only
addr==0: at the first address selected by the kernel (recommended!)
addr!=0: at the address given by addr

48. Memory Layout high address command-line arguments
and environment variables
stack
heap
0xf7fffb2c
0xf77e86a0
0xf77d0000
shared memory
shared memory of 100,000 bytes
0x0003d2c8
0x00024c28
malloc of 100,000 bytes
uninitialized data
(bss)
0x0003d2c8
0x00024c28
array[] of 40,000 bytes
initialized data
text
low address

49. shmdt() Detach a shared memory segment #include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
void shmdt (void *addr);
Returns: 0 if OK, -1 on error
Detach a shared memory segment

50. example: tshm.c (1/2) #include <sys/types.h> // tshm.c
#include <sys/ipc.h>
#include <sys/shm.h>
#define ARRAY_SIZE
#define MALLOC_SIZE
#define SHM_SIZE
err_sys(char *p) { perror(p); exit(-1); }
char array[ARRAY_SIZE]; /* uninitialized data = bss */
int main(void) {
int shmid; char *ptr, *shmptr;
printf("array[] from %x to %x\n", &array[0], &array[ARRAY_SIZE]);
printf("stack around %x\n", &shmid);
if ((ptr = malloc(MALLOC_SIZE)) == NULL) err_sys("malloc error");
printf("malloced from %x to %x\n", ptr, ptr+MALLOC_SIZE);
if ((shmid = shmget(0x , SHM_SIZE, IPC_CREAT | 0666)) < 0)
err_sys("shmget error");
if ((shmptr = shmat(shmid, 0, 0)) == (void *) -1) err_sys("shmat error");
printf("shared memory attached from %x to %x\n", shmptr, shmptr+SHM_SIZE);
// if (shmctl(shmid, IPC_RMID, 0) < 0) err_sys("shmctl error");
exit(0); }

51. example: tshm.c (2/2)

52. Semaphore a special variable (sv)
upon which only two operations are allowed
P(sv) : wait
if sv is greater than zero, decrement sv.
If sv is zero, suspend execution of the process
V(sv) : signal
If some other process has been suspended for waiting sv, make it resume execution
If no process is suspended waiting for sv, increment sv.
They are used to ensure that a single executing process has exclusive access to a resource.
Critical Section
Binary Semaphore

53. Semaphore
semaphore sv = 1; loop forever { P(sv); critical section code; V(sv); non-critical code section }

54. To obtain a shared resource:
Semaphores
A counter to provide access to shared data object for multiple processes
To obtain a shared resource:
1. Test semaphore that controls the resource
2. If value > 0, value--, grant use
3. If value == 0, sleep until value > 0
4. Release resource, value ++
Step 1, 2 must be an atomic operation

55. Semaphore Structure Each semaphore has a structure
struct semid_ds {
struct ipc_perm sem_perm;
struct sem *sem_base; /*ptr to first semaphore in set */
ushort sem_nsems; /* # of semaphors in set */
time_t sem_otime; /* last-semop() time */
time_t sem_ctime; /* last-change time */ };
struct sem {
ushort semval; /* semaphore value, always >= 0 */
pid_t sempid; /* pid for last operation */
ushort semncnt; /* # processes awaiting semval > currval */
ushort semzcnt; /* # processes awaiting semval = 0 */
We can get the structure using semctl() function.
Actually, however, we don’t need to know the structure in detail.

56. semget() Obtain a semaphore ID
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int flag);
Returns: semaphore ID if OK, -1 on error
Obtain a semaphore ID
nsems: sem_nsens (# of semaphores in set)
flag: ipc_perm.mode

57. semctl()
APUE (Interprocess Communication
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, union semun arg);
union semun {
int val; /* for SETVAL */
struct semid_ds *buf; /* for IPC_START and IPC_SET */
ushort *array; /* for GETALL and SETALL */ };
To use semaphore, please refer to the textbook and manuals related semaphore.

58. ipcs, ipcrm ipcs: checking status of System V IPC
APUE (Interprocess Communication
ipcs: checking status of System V IPC
$ ipcs // check information of IPC (q, m, s)
$ ipcs –q ($ ipcs –qa) // check information of Message Queue
$ ipcs –m ($ ipcs –ma) // check information of Shared Memory
$ ipcs –s ($ ipcs –sa) // check information of Semaphore
ipcrm: delete a defined IPC
$ ipcrm –q id // Delete Message Queue
$ ipcrm –m id // Delete Shared Memory
$ ipcrm –s id // Delete Semaphore

59. Memory mapped file I/O
APUE (Interprocess Communication
#include <sys/types.h>
#include <sys/mman.h>
caddr_t mmap (caddr_t addr, size_t len, int prot, int flag, int filedes, off_t off);
Returns: starting address of mapped region if OK, -1 on error
int munmap(caddr_t addr, size_t len);
Returns : 0 if OK, -1 on error
Memory mapped I/O lets us map a file on disk into a buffer in memory so that when we fetch bytes from the buffer, the corresponding bytes of the file are read. Similarly, when we store data in the buffer, the corresponding bytes are automatically written to the file. This lets us perform I/O without using read or write.
To use this feature we have to tell the kernel to map a given file to a region in memory.

60. Memory mapped file I/O flag argument
MAP_FIXED : the return value must equal addr
MAP_SHARED : store operation modify the mapped file. Thus shared by others.
MAP_PRIVATE: make a copy of original file and modify the copied file.
therefore, it does not affect others.
high address
command-line arguments
and environment variables
stack
heap
length
Memory-mapped
portion of file
Starting address
Memory-mapped
portion of file
file :
uninitialized data
(bss)
offset
initialized data
text
low address