• CS:APP
• Sec. 10.5, Reading File Metadata
• Sec. 10.6, Sharing Files
• Sec. 10.7, I/O Redirection
  
• APUE, Sec. 3.10-12, 3.16, 15.1-3
  

• Descriptor table
• per process
• for each open file descriptor, a pointer to an entry in the file table
  
• File table
• per system
• for each open file among all processes,
• current file position
• reference count (how many descriptor table entries currently point to it)
• increment when a file is opened, decrement when closed
• if 0 then safe to delete this entry
  
• pointer to an entry in the v-node table
  
• V-node table
• per system
• information about the file
• stat(), fstat() and lstat() functions can retrieve much of this information
• Mac OS X stat command, for example

• See CS:APP Sec. 10.6 for examples of these tables, with two "normal" files in the same process, a file with two descriptors in the same process, and a file shared between parent and child after fork().

• a single operation composed of multiple steps
• either all steps are performed, or none are performed

• Atomic instruction (in processor design)
  
• A single machine instruction which may involve several memory actions, executed as a single uninterruptible unit.  No other instruction using the memory can be interleaved with an atomic instruction.
• Intel x86 (IA-32, Intel 64) instruction set architecture, lock prefix, not described in CS:APP
  
• Atomic operation (in processor design)
  
• One or more machine instructions executed as a single group.  This may involve executing the instructions without interruption, or by allowing interruption but ensuring that its effect is harmless.
• sometimes called an indivisible operation
• MIPS instruction set architecture, ll/sc instructions, see Patterson & Hennessy, Sec. 2.11, covered in CMPEN 431
• Atomic transaction (in database design)
  
• A single logical unit of work that either is performed in its entirety or it is not performed at all.  This may involve starting the work and then reversing the work if it is interrupted or otherwise cannot be completed.

• It's possible to build memory units using only atomic transactions, and these would be useful in multiprocessor systems.
• http://en.wikipedia.org/wiki/Transactional_memory
  

• support for multiple threads of execution including an improved memory sequencing model, atomic objects, and thread-local storage (<stdatomic.h> and <threads.h>)

• close(fd2)
• file descriptor fd2 is duplicated from file descriptor fd1
• return fd2
• except that it's an atomic operation

• Pipes (traditionally) are half-duplex -- data flows in only one direction.
• Pipes can only be used between processes with a common ancestor.
• Ancestry is determined by calls to fork(), yielding parent and child.
  
• For example, the command  prog1 | prog2  would cause the shell to create two child processes with a pipe between them.

• two file descriptors are created
• fd[0] is open for reading
• fd[1] is open for writing
• the output of fd[1] is the input for fd[0]
• there is a buffer maintained by the OS that holds not-yet-read bytes, and the OS will prevent over-filling the buffer
• You can use fstat() to help determine if a file descriptor is associated with a regular file or a pipe.
  

• create a pipe
• open two file descriptors, as above
  
• fork
• the file descriptors are copied from parent to child, and everything remains open
  
• close the unnecessary file descriptors
• one each in parent and child
  
• communicate parent to child via the pipe, as if ordinary I/O

// create a pipe from parent process to child process

// err_sys() prints a message and exits

int main(void)
{
  int 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) /* parent */
    {
      close(fd[0]);    /* close read end */
      write(fd[1], "hello world\n", 12);
    }
  else /* child */
    {
      close(fd[1]);    /* close write end */
      int n = read(fd[0], line, MAXLINE);
      write(STDOUT_FILENO, line, n);
    }

  exit(0);
}

• Exercise.  Why 12, and not 13?

• parent generates output, child runs the pager program
• essentially,   cat filename | more