Chapter 14: Interprocess Communication CMPS 105: Systems Programming Prof. Scott Brandt T Th 2-3:45 Soc Sci 2, Rm. 167 Plans This week: Chapter 14 Next week: Networked IPC Other? Last week Something Review Introduction Interprocess Communication (IPC) enables processes to communicate with each other to share information Pipes (half duplex) FIFOs (named pipes) Stream pipes (full duplex) Named stream pipes Message queues Semaphores Shared Memory Sockets Streams Pipes Oldest (and perhaps simplest) form of UNIX IPC Half duplex Data flows in only one direction Only usable between processes with a common ancestor Usually parent-child Also child-child Pipes (cont.) #include int pipe(int fildes[2]); fildes[0] is open for reading and fildes[1] is open for writing The output of fildes[1] is the input for fildes[0] Understanding Pipes Within a process Writes to fildes[1] can be read on fildes[0] Not very useful Between processes After a fork() Writes to fildes[1] by one process can be read on fildes[0] by the other Understanding Pipes (cont.) Even more useful: two pipes, fildes_a and fildes_b After a fork() Writes to fildes_a[1] by one process can be read on fildes_a[0] by the other, and Writes to fildes_b[1] by that process can be read on fildes_b[0] by the first process Using Pipes Usually, the unused end of the pipe is closed by the process If process A is writing and process B is reading, then process A would close fildes[0] and process B would close fildes[1] Reading from a pipe whose write end has been closed returns 0 (end of file) Writing to a pipe whose read end has been closed generates SIGPIPE PIPE_BUF specifies kernel pipe buffer size Example int main(void) { int n, fd[2]; pid_t pid; char line[maxline]; if(pipe(fd) < 0) err_sys(“pipe error”); if( (pid = fork()) < 0) err_sys(“fork error”); else if(pid > 0) { close(fd[0]); write(fd[1], “hello\n”, 6); } else { close(fd[1]); n = read(fd[0], line, MAXLINE); write(STDOUT_FILENO, line, n); } Example: Piping output to child process’ input int fd[2]; pid_t pid; pipe(fd); pid = fork(); if(pid == 0) { dup2(fd[0], STDIN_FILENO); exec(); } Using Pipes for synchronization and communication Once you have a pipe or pair of pipes set up, you can use it/them to Signal events (one pipe) Synchronize (one or two pipes) Wait for a message Wait for a message or set of messages You send me a message when you are ready, then I’ll send you a message when I am ready Communicate (one or two pipes) Send messages back and forth popen() #include FILE *popen(const char *cmdstring, const char *type); Encapsulates a lot of system calls Creates a pipe Forks Sets up pipe between parent and child (type specifies direction) Closes unused ends of pipes Turns pipes into FILE pointers for use with STDIO functions (fread, fwrite, printf, scanf, etc.) Execs shell to run cmdstring on child popen() and pclose() Popen() details Directs output/input to stdin/stdout “r” -> parent reads, “w” -> parent writes int pclose(FILE *fp); Closes the STDIO stream Waits for command to terminate Returns termination status of shell Assignment Simulated audio player with shared memory and semaphores We will discuss this at the end of class today FIFOs First: Coprocesses – Nothing more than a process whose input and output are both redirected from another process FIFOs – named pipes With regular pipes, only processes with a common ancestor can communicate With FIFOs, any two processes can communicate Creating and opening a FIFO is just like creating and opening a file FIFO details #include #include int mkfifo(const char *pathname, mode_t mode); The mode argument is just like in open() Can be opened just like a file When opened, O_NONBLOCK bit is important Not specified: open() for reading blocks until the FIFO is opened by a writer (same for writing) Specified: open() returns immediately, but returns an error if opened for writing and no reader exists Example: Using FIFOs to Duplicate Output Streams Send program 1’s output to both program2 and program3 (p. 447) mkfifo fifo1 prog3 < fifo1 & prog1 < infile | tee fifo1 | prog2 Example: Client-Server Communication Using FIFOs Server contacted by multiple clients (p.448) Server creates a FIFO in a well-known place Clients send requests on this FIFO And opens it read/write Must be < PIP_BUF bytes Issue: How to respond to clients Solution: Clients send PID, server creates per-client FIFOs for responses System V IPC IPC structures for message queues, semaphores, and shared memory segments Each structure is represented by an identifier The identifier specifies which IPC object we are using The identifier is returned when the corresponding structure is created with msgget(), semget(), or shmget() Whenever an IPC structure is created, a key must be specified Matching keys refer to matching objects This is how two processes can coordinate to use a single IPC mechanism to communicate Rendezvousing with IPC Structures Process 1 can specify a key of IPC_PRIVATE This creates a unique IPC structure Process 1 then stores the IPC structure somewhere that Process 2 can read Process 1 and Process 2 can agree on a key ahead of time Process 1 and Process 2 can agree on a pathname and project ID ahead of time and use ftok to generate a unique key IPC Permissions System V associates an ipc_perm structure with each IPC structure: struct ipc_perm { uid_t uid; // owner’s eff. user ID gid_t gid; // owner’s eff. group ID uid_t cuid; // creator’s eff. user ID gid_t cgid; // creator’s eff. group ID mode_t mode; // access modes ulong seq; // slot usage sequence nbr key_t key; // key } Issues w/System V IPC They are equivalent to global variables They live beyond the processes that create them They don’t use file descriptors Can’t be named in the file system Can’t use select() and poll() Message Queues Linked list of messages stored in the kernel Identifier by a message queue identifier Created or opened with msgget() Messages are added to the queue with msgsnd() Specifies type, length, and data of msg Messages are read with msgrcv() Can be fetched based on type msqid_ds Each message queue has a msqid_ds data 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_srtime; // last msgsnd() time time_t msg_rtime; // last msgrcv() time time_t msg_ctime; // last change time }; Limits MSGMAX – size of largest message MSGMNB – Max size in bytes of queue Usually 4096 MSGMNI – Max # of msg queues Usually 2048 Usually 50 MSGTQL – Max # of messages, systemwide Usually 40 msgget() #include #include #include int msgget(key_t key, int flag); flag specifies mode bits returns msg queue ID msgctl() int msgctl(int msquid, int cmd, struct msqid_ds *buf); Depends on cmd IPC_STAT – fills buf with msqid_ds IPC_SET – sets various fields of msqid_ds IPC_RMID – removes message queue from system msgsnd() int msgsnd(int msqid, const void *ptr, size_t nbytes, int flag); ptr points to the data of the message, with type: struct mymesg { } long mtype; char mtext[512]; msgrcv() int msgrcv(int msqid, void *ptr, size_t nbytes, long type, int flag); type == 0: return the first message type > 0: return first message with specified type type < 0: return first message whose type is lowest with value <= specified type Semaphores Create semaphore: semget() Test value: semop() If > 0, decrement and continue if < 0, sleep till > 0 Increment value: semop() semid_ds struct semid_ds { struct ipc_perm; // struct sem *sem_base;// ptr to 1st sem in set ushort sem_nsems; // # of sems in set time_t sem_otime; // last-semop() time time_t sem_ctime; // last-change time }; struct sem { ushort semval; // semphore value pid_t sempid; // pid for last operation ushort semncnt; // # of procs awaiting semval > curval ushort semzcnt; // # of procs awaiting semval = 0 } semget() #include #include #include int semget(key_t key, int nsems, int flag); nsems is the number of semaphores in the set semctl() int semctl(int semid, int semnum, int cmd, union semun arg); union semun { int val; // for setval struct semid_ds *buf; // for IPC_STAT and IPC_SET ushort *array; // for GETALL and SETALL } IPC_STAT: get the semid_ds IPC_SET: set semid_ds fields IPC_RMID: remove semaphore GETVAL: return the value of semval for semnum SETVAL: set the value of semval for semnum GETPID: return the value of sempid for semnum GETNCNT: return the value of semcnt for semnum GETZCNT: return the value of semzcnt for semnum GETALL: fetch all semaphores values in the set SETALL: set all semaphore values in the set semop() int semop(int semid, struct sembuf semoparray[], size_t nops); struct sembuf { ushort sem_num; // member # short sem_op; // operation short sem_flg; // IPC_NOWAIT, SEM_UNDO }; sem_op > 0: sem_op is added to sems value sem_op < 0: reduce sem by sem_op (if possible), otherwise block depending upon IPC_NOWAIT value sem_op == 0: wait until value becomes 0 semop is atomic Shared Memory See p. 464