Exchange Data between Processes
Inter-Process Communication (IPC)
Lecture 9
After fork() is called we end up with two independent processes We cannot use variables to communicate between processes since they each have separate address spaces, and separate memory locations One easy way to communicate is to use files, where process A writes to a file and process B reads from it Another way is to use pipes
1 2
Acknowledgement: adapted from Karen Reids lecture slides for CSC209 winter 2007
File Objects and Descriptors
The stdio library provides FILE structure which handle operations on files (see stdio.h and libio.h) FILE objects are built on top of file descriptors A file descriptor is an index into a per-process table of open file descriptors We will also use file descriptors for other communications such as pipes and sockets
File Descriptors
Used by low-level I/O
open(), close(), read(), write()
Declared as an integer
int fd;
A system call to convert a FILE object to a file descriptor
int fileno(FILE *fp);
You can also create a FILE object from a file descriptor
FILE *fdopen(int fd, const char *mode);
3
4
Example
#include <stdio.h> #include <fcntl.h> #include <unistd.h> #include <string.h> reading from one file and #define MAX 130 copying to another file int main() { FILE *ifp; /* input file handle */ int ofd; /* output file descriptor */ char buf[MAX]; int i, j, nread=0, nwritten=0; if((ifp = fopen("a.ics", "r")) == NULL) perror("fopen"); if((ofd = open("b.ics", O_WRONLY|O_CREAT|O_TRUNC)) < 0) perror("open"); while((fgets(buf, MAX, ifp)) != NULL) { i = strlen(buf); j = write(ofd, buf, i); nread += i; nwritten += j; } printf("%d read, %d written\n", nread, nwritten); }
Process State
high address
stack
Process control block (PCB) sp (stack pointer) pc (program counter)
fd table entry file status flags current file offset vnode pointer
heap uninit. data init. data text
low address 5 fd 0 fd 1 fd 2 fd 3
fd table
...
6
Buffering
File Buffering
Buffering can be set after stream is opened but before any I/O operation takes place
void setbuf(FILE *fp, char *buf); turn buffering off with buf == NULL turn on with buf pointing to buffer of length >=BUFSIZ
un-buffered output appears immediately
stderr is not buffered
line buffered output appears when a full line has been written
stdout is line buffered when going to the screen
block buffered output appears when a buffer is filled or a buffer is flushed (on close or explicit flush)
For greater control:
int setvbuf(FILE *fp,char *buf,int mode,size_t size);
normally output to a file is block buffered stdout is block buffered when redirected to a file
set mode to _IOFBF, _IOLBF, or _IONBF for fully buffered, line buffered, or unbuffered buf points to user buffer, or NULL for system buffer
Flush a buffer: int fflush(FILE *fp);
7 8
File Buffering
#include <stdio.h> #include <stdlib.h> #define MAX 128 int main(int argc, char **argv) { FILE *ifp, *ofp; char line[MAX]; if(argc != 3) { printf("Usage: myappend infile outfile\n"); exit(1); } if((ifp=fopen(argv[1], "r"))==NULL) { perror("open infile"); exit(2); } Append one file to another file if((ofp=fopen(argv[2], "a"))==NULL) { perror("open outfile"); exit(3); } $ tail f outfile to check output while(fgets(line, MAX, ifp)!=NULL) { block file buffer (default) fprintf(ofp, line); sleep(1); buffer flushed when the file } is closed fclose(ifp); fclose(ofp); return 0; }
File Buffering
#include <stdio.h> #include <stdlib.h> #define MAX 128 int main(int argc, char **argv) { FILE *ifp, *ofp; char line[MAX]; if(argc != 3) { printf("Usage: myappend infile outfile\n"); exit(1); } if((ifp=fopen(argv[1], "r"))==NULL) { perror("open infile"); exit(2); } no buffer if((ofp=fopen(argv[2], "a"))==NULL) { perror("open outfile"); exit(3); output written }
to file immediately
setbuf(ofp, NULL);
while(fgets(line, MAX, ifp)!=NULL) { fprintf(ofp, line); sleep(1); } fclose(ifp); fclose(ofp); return 0; } 9 10
File Buffering
#include <stdio.h> #include <stdlib.h> #define MAX 128 int main(int argc, char **argv) { FILE *ifp, *ofp; char line[MAX]; if(argc != 3) { printf("Usage: myappend infile outfile\n"); exit(1); } if((ifp=fopen(argv[1], "r"))==NULL) { perror("open infile"); exit(2); block file buffer (default) } use fflush to force writing if((ofp=fopen(argv[2], "a"))==NULL) { line by line perror("open outfile"); exit(3); } while(fgets(line, MAX, ifp)!=NULL) { fprintf(ofp, line);
File Buffering
#include <stdio.h> #include <stdlib.h> #define MAX 128 int main(int argc, char **argv) { FILE *ifp, *ofp; int i=1; char line[MAX], my_line_buf[1024]; if(argc != 3) { printf("Usage: myappend infile outfile\n"); exit(1); } if((ifp=fopen(argv[1], "r"))==NULL) { perror("open infile"); exit(2); set line buffer } if((ofp=fopen(argv[2], "a"))==NULL) { output written perror("open outfile"); exit(3); }
to file
to file line-by-line
fflush(ofp);
sleep(1); } fclose(ifp); fclose(ofp); return 0; } 11 }
setvbuf(ofp, my_line_buf, _IOLBF, 1024);
while(fgets(line, MAX, ifp)!=NULL) { printf("output line %d\n", i++); fprintf(ofp, line); sleep(1); } fclose(ifp); fclose(ofp); return 0; 12
Unix Pipelines
Simple example: wc l *.c | egrep 30 Both processes execute concurrently Pipe implemented as an internal OS buffer
shared resource - concurrent access by the reader and the writer, so it must be managed carefully producer/consumer problem
process A: wc process B: egrep
Pipes
Anonymous pipe
simplex FIFO channel allows one-way communication two pipes needed for two-way communication created by process, closed when process dies created by system call pipe()
Named pipe
allows two-way communication (full-duplex) created by unix command mkfifo or C function mkfifo() persists as a special device file
13 14
stdin
stdout
stderr
keyboard
display
pipe() System Call
int pipe(int fildes[2]); Functionality
creates a pair of file descriptors and stores them into fildes[0] and fildes[1] fildes[0] is used for reading from the pipe fildes[1] is used for writing to the pipe reading with fildes[1] and writing to fildes[0] undefined
pipe() Example
#include <unistd.h> Send one message through #include <stdlib.h> pipe: half-duplex (one-way) #include <stdio.h> communication #include <string.h> #define MSGSIZE 1024 char msg1[] = "hello, world!"; int main() { char buf[MSGSIZE]; int fildes[2], i, j; if(pipe(fildes) == -1) { perror("pipe call"); exit(1); } if((i=write(fildes[1],msg1,strlen(msg1)))<0){ perror("write call"); exit(2); } if((j= read(fildes[0], buf, MSGSIZE)) < 0) { perror("read call"); exit(3); }
user p rocess
fl [0 ides ] read
fl [1 ides ] wr te i
Return value
return 0 on success, return -1 on error
p ipe kerne l
errno
EFAULT, EMFILE, ENFILE (see manpage)
15
printf("%d bytes written, %d bytes read: %s\n", i, j, buf); return 0; }
16
Pipes and File Descriptors
pipe(int fildes[2]) creates an internal system buffer and two file descriptors, one for reading and one for writing A forked child inherits file descriptors from parent After the pipe call, the parent and child should close the file descriptors for the opposite direction Create two pipes if you want to achieve fullduplex communication
17
What Happens after fork?
paren p t rocess ch ld p i rocess
f [0 d ]
f [1 d ]
f [0 d ]
f [1 d ]
p ipe
kerne l
18
Direction of Data Flow
paren t ch ld i
Direction of Data Flow
paren t ch ld i
f [0 d ]
f [1 d ]
f [0 d ]
f [1 d ]
f [0 d ]
f [1 d ]
f [0 d ]
f [1 d ]
child to parent (close fd[1] in parent and fd[0] in child)
p ipe
p ipe
parent to child (close fd[0] in parent and fd[1] in child)
kerne l
19
kerne l
20
Full-Duplex Data Flow
paren p t rocess ch ld p i rocess
f [1 d2 ] f [0 d2 ]
This is the sample pipe communication model in A3
f [0 d1 ] f [1 d1 ]
f [1 d1 ] f [0 d1 ]
f [0 d2 ] f [1 d2 ]
p ipe2
fd1 used for parent-to-child communication (close fd1[0] in parent and fd1[1] in child)
p ipe1 kerne l
fd2 used for child-to-parent communication (close fd2[1] in parent and fd2[0] in child)
21
#include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <sys/wait.h> #define MSGSIZE 1024 char msg1[] = "hello, world!"; int main() { char buf[MSGSIZE]; int fildes[2], i; pid_t pid; if(pipe(fildes) == -1) { Child process sends one perror("pipe call"); exit(1); } message to parent process pid = fork(); switch(pid) { case -1: perror("fork call"); exit(2); break; case 0: /* child */ close(fildes[0]); if((i=write(fildes[1], msg1, strlen(msg1))) < 0) { perror("write call"); exit(3); } printf("%d bytes written\n", i); break; default: /* parent */ close(fildes[1]); if((i=read(fildes[0], buf, MSGSIZE)) < 0) { perror("read call"); exit(4); } printf("%d bytes read: %s\n", i, buf); wait(NULL); } return 0; }
pipe() Example with fork()
22
Size of a Pipe
Minimum size of pipe is normally 512 bytes
check with int
fpathconf(fd[0], _PC_PIPE_BUF);
Reading and Writing of a Pipe
A read on an empty pipe will block until there is something to read A write on a full pipe will block until there is more space. (Pipes have a finite size) Writing to a pipe that has been closed at the read end will result in a SIGPIPE or Broken Pipe message Reading of pipe will return 0 if the write end of the pipe is closed
23 24
#include <stdio.h> #include <stdlib.h> #include <unistd.h> int main() { int fd[2], pipe_size; if(pipe(fd) == -1) { perror("pipe call"); exit(1); } pipe_size = fpathconf(fd[0], _PC_PIPE_BUF); printf(size of pipe: %d bytes \n", pipe_size); return 0; }
Behaviors of Pipe Reading
Blocked reading of a pipe
returns the number of bytes read by default blocked (waiting) if pipe is empty returns 0 if writing end is closed returns -1 if error happens returns the number of bytes read by default returns -1 with errno EAGAIN if pipe is empty returns 0 if writing end is closed returns -1 if error happens
Behaviors of Pipe Writing
Blocked writing of a pipe
returns the number of bytes written by default blocked (waiting) if pipe is full returns -1 with errno EPIPE if reading end is closed returns -1 if error happens returns the number of bytes written by default returns -1 with errno EAGAIN if pipe is full returns -1 with errno EPIPE if reading end is returns closed -1 if error happens
Non-blocked reading of a pipe
Non-blocked writing of a pipe
25
26
Non-block Reading/Writing
Set the O_NONBLOCK flag using fcntl()
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <errno.h> #include <fcntl.h> #include <string.h> #define MSGSIZE 130 char msg1[] = "hello", msg2[] = "bye!"; int main() { int fildes[2]; void child(int p[2]); void parent(int p[2]); if(pipe(fildes) == -1) { perror("pipe call"); exit(1); } if(fcntl(fildes[0], F_SETFL, O_NONBLOCK) == -1) { perror("nonblock setting"); exit(2); } switch(fork()) { case -1: perror("fork call"); exit(3); case 0: child(fildes); break; default: parent(fildes); } return 0; }
Non-block Reading/Writing
void parent(int p[2]) { int nread; char buf[MSGSIZE]; close(p[1]); for(;;) { switch(nread=read(p[0],buf,MSGSIZE)){ case -1: if(errno==EAGAIN) { printf("(pipe empty)\n"); sleep(1); } else { perror("read call"); exit(4); } break; case 0: printf("write end closed\n"); exit(5); default: printf("MSG=%s\n", buf); } } } 27 void child(int p[2]) { int count; close(p[0]); for(count=0; count<3; count++) { write(p[1], msg1, strlen(msg1)+1); sleep(3); } write(p[1], msg2, MSGSIZE); }
Child process sends 3 messages, with 3-second break Parent does non-block reading of pipe, and pauses 1 second if pipe empty
28
Implementation of Unix Pipeline
$ sort < f1 | uniq We want the stdin of the sort process to be connected to f1 We want the stdout of the sort process to be connected to the stdin of the uniq process Duplicate an open FD using dup() or dup2()
dup() and dup2()
int dup(oldfd);
duplicate oldfd return the duplicated FD, return -1 on error equivalent to:
fcntl(oldfd, F_DUPFD, 0);
int dup2(oldfd, newfd);
29
newfd and oldfd now refer to the same file if newfd is open, it is first automatically closed return newfd, return -1 on error equivalent to:
close(newfd); fcntl(oldfd, F_DUPFD, newfd);
30
Example
Process
f1
Example
Process
f1
f d1 f d2 0 1 2
f2
picture after line 2
stdin stdout
f d1 f d2 0 1 2
f2
picture after line 4
stdin stdout
1) 2) 3) 4) 5) 6)
fd1 = open(f1, O_RDONLY); fd2 = open(f2, O_WRONLY); dup2(fd1, fileno(stdin)); dup2(fd2, fileno(stdout)); close(fd1); close(fd2);
stderr
1) 2) 3) 4) 5) 6)
31
fd1 = open(f1, O_RDONLY); fd2 = open(f2, O_WRONLY); dup2(fd1, fileno(stdin)); dup2(fd2, fileno(stdout)); close(fd1); close(fd2);
stderr
32
Example
Process
f1 f2
Pipeline Example
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> int main() { int fd[2], pid; int ifd = open("f1", O_RDONLY); dup2(ifd, fileno(stdin)); close(ifd); pipe(fd); if((pid=fork()) == 0) { /* child */ dup2(fd[1], fileno(stdout)); close(fd[0]); close(fd[1]); execl("/usr/bin/sort", "sort", (char *)0); } else if(pid > 0){ /* parent */ dup2(fd[0], fileno(stdin)); close(fd[1]); close(fd[0]); execl("/usr/bin/uniq", "uniq", (char *)0); } else { perror("fork"); exit(1); } return 0; }
Equivalent to: sort < f1 | uniq
0 1 2
picture after line 6
stdin stdout
1) 2) 3) 4) 5) 6)
fd1 = open(f1, O_RDONLY); fd2 = open(f2, O_WRONLY); dup2(fd1, fileno(stdin)); dup2(fd2, fileno(stdout)); close(fd1); close(fd2);
stderr
33
34
paren t
ifd 0 (stdin) 1 (stdout) 2 (stderr) fd[0] fd[1]
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> int main() { int fd[2], pid; int ifd = open("f1", O_RDONLY); dup2(ifd, fileno(stdin)); close(ifd); pipe(fd); if((pid=fork()) == 0) { /* child */ dup2(fd[1], fileno(stdout)); close(fd[0]); close(fd[1]); execl("/usr/bin/sort","sort",(char *)0); } else if(pid > 0){ /* parent */ dup2(fd[0], fileno(stdin)); close(fd[1]); close(fd[0]); execl("/usr/bin/uniq","uniq",(char *)0); } else { perror("fork"); exit(1); } return 0; }
paren t
ifd 0 1 (stdout) 2 (stderr) fd[0] fd[1]
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> int main() { int fd[2], pid; int ifd = open("f1", O_RDONLY); dup2(ifd, fileno(stdin)); close(ifd); pipe(fd); if((pid=fork()) == 0) { /* child */ dup2(fd[1], fileno(stdout)); close(fd[0]); close(fd[1]); execl("/usr/bin/sort","sort",(char *)0); } else if(pid > 0){ /* parent */ dup2(fd[0], fileno(stdin)); close(fd[1]); close(fd[0]); execl("/usr/bin/uniq","uniq",(char *)0); } else { perror("fork"); exit(1); } return 0; }
f1
f1
35
36
paren t
ifd 0 1 (stdout) 2 (stderr) fd[0] fd[1]
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> int main() { int fd[2], pid; int ifd = open("f1", O_RDONLY); dup2(ifd, fileno(stdin)); close(ifd); pipe(fd); if((pid=fork()) == 0) { /* child */ dup2(fd[1], fileno(stdout)); close(fd[0]); close(fd[1]); execl("/usr/bin/sort","sort",(char *)0); } else if(pid > 0){ /* parent */ dup2(fd[0], fileno(stdin)); close(fd[1]); close(fd[0]); execl("/usr/bin/uniq","uniq",(char *)0); } else { perror("fork"); exit(1); } return 0; }
paren t
ifd 0 1 (stdout) 2 (stderr) fd[0] fd[1]
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> int main() { int fd[2], pid; int ifd = open("f1", O_RDONLY); dup2(ifd, fileno(stdin)); close(ifd); pipe(fd); if((pid=fork()) == 0) { /* child */ dup2(fd[1], fileno(stdout)); close(fd[0]); close(fd[1]); execl("/usr/bin/sort","sort",(char *)0); } else if(pid > 0){ /* parent */ dup2(fd[0], fileno(stdin)); close(fd[1]); close(fd[0]); execl("/usr/bin/uniq","uniq",(char *)0); } else { perror("fork"); exit(1); } return 0; }
pipe f1
f1
37
38
paren t
ifd 0 1 (stdout) 2 (stderr) fd[0] fd[1]
ch ld i
ifd 0 (stdout) 1 (stderr) 2 fd[0] fd[1]
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> int main() { int fd[2], pid; int ifd = open("f1", O_RDONLY); dup2(ifd, fileno(stdin)); close(ifd); pipe(fd); if((pid=fork()) == 0) { /* child */ dup2(fd[1], fileno(stdout)); close(fd[0]); close(fd[1]); execl("/usr/bin/sort","sort",(char *)0); } else if(pid > 0){ /* parent */ dup2(fd[0], filen...