UNIX Pipes

• How does the shell do
• date > out
• The quick answer:
• We modify the file descriptor table
• We need to take a closer look at how the file descriptor table works

• Each Process has a file descriptor table in the kernel (in the Process Control Block)
• fork() duplicates the file descriptor table
• Draw picture of two file descriptor tables with stdin, stdout, stderr.

Modifying the FD Table

Redirection Example

redirect.c

• It is often useful and necessary to allow different processes to communicate with each other
• There are two basic types of IPC
• Explicit mechanisms: System call interface such as pipes, sockets, message passing, and remote procedure call (RPC)
• Shared memory: Using virtual memory, allow processes to share a portion of memory.  Processes communicate by accessing shared variables.
• Today we look at UNIX pipes; later we will look at shared memory, message passing, and RPC.

• A UNIX pipe is an IPC mechanism
• A pipe allows for the exchange of data between processes
• A pipe is used to send a stream of character data
• Basic idea
• Create a pipe using the pipe() system call
• At the user level, a pipe is just a pair of file descriptors
• One for reading (0)
• One for writing (1)
• Use read() and write() system calls to receive and send data
• Order: FIFO (First in, first out)

• General mechanism to allow related processes running on the same machine to communicate
• Note: we need something else to allow inter-machine communication (i.e., sockets)
• Use by the shell to "connect" programs
• ls | wc
• Gives the number of files in current directory
• who | wc
• Gives the number of users logged in
• who | sort | lpr  # prints a sorted list of users
• Note that shell pipes are unidirectional
• System pipes can be bidirectional

• int pipe(int filedes[2])
• Check return value for possible errors
• int filedes[2] is just an array of two ints
• filedes[0] is for reading (the "read end")
• filedes[1] is for writing (the "write end")
• Remember the read end is 0 (like stdin) and the write end is 1 (like stdout)
• Usage
  
  int filedes[2];
  pipe(filedes);
• Draw picture of a pipe with "hello world"

• Consider a parent that wants to send data to a child
• In Parent:
• create a pipe
• pipe(filedes)
• fork() a child
• close(filedes[0]) (don't leave open ends)
• write to child with
• write(filedes[1], ...)
• close(filedes[1]) on completion (important)
• In Child:
• close(filedes[1]) (don't leave open ends)
• optional: redirect stdin and use execl()
• read from parent with
• read(filedes[0], ...)
• close(filedes[0]) when done

• Can setup many configurations
• Parent writes to a child (1 pipe)
• Child writes to a parent (1 pipe)
• Parent writes to a child and child writes to parent (2 pipes)
• Parent connects to child (1 pipe, like the shell)
• Parent connects two children (1 pipe)
• One processes with a common parent can communicate with a standard pipe
• There is a "named" pipe that can exist in the filesystem
• You need to close the ends of the pipe to ensure correct termination
• Use dup() to redirect stdin or stdout to a pipe