Lec1: Understand OS concepts w/ the shell

Lecture notes courtesy of MIT 6.828 staff (Frans Kaashoek, Robert Morris)

• Shell is a user program (used to be part of O/S, not anymore!). Many varieties: sh, bash, tcsh
• Used for interactive command execution and as a programming language
• Typically handles login session, runs other processes
• Shell makes extensive use of O/S abstractions. Let's see some example O/S abstractions and how they fit together.

Here's the simple pseudo-code for a shell:

while (1) {
  write (1, "$ ", 2); //print command prompt
  readcommand (command, args);   // parse user input
  if ((pid = fork ()) == 0) {  // fork a new process, if child
    exec (command, args, 0);
  } else if (pid > 0) {   // if parent
    wait (0);   // wait for child to terminate
  } else {
    perror ("Failed to fork\n");
  }
}

O/S process abstractions

• O/S offers its abstractions to user programs via system calls. (will be discussed later in lecture)
• What are system calls used? (read, write, fork, exec, wait)
  conventions: 0 is success, -1 signals error, error code stored in errno, perror prints out a descriptive error message based on errno.
• What's the shell doing?
  fork, exec, wait: process diagram showing PID, address space, parent links. fork returns twice, in some sense!
  The split of process creation into fork and exec makes each primitive simple to implement. see the assigned paper for today.
• why "wait"?
  Shell needs to waits for the child (the foreground command) to terminate and collect its exit status.
  What if child finishes first?
  When a child finishes, it becomes a zombie until parent calls wait.
• How to put a process in the background?

  $ sort file.txt &
  

• How does the shell implement "&", backgrounding? (Don't call wait immediately).

O/S I/O abstractions

• An example command in shell:

  $ ls 

• how does "ls" know which directory to look at?
• how does "ls" know where to send its output?
• I/O: process has file descriptors, numbered starting from 0.
• I/O related system calls: open, read, write, close
• UNIX file descriptor numbering conventions:
  • file descriptor 0 for input (e.g., keyboard), e.g. the readcommand implementation

    void 
    readcommand(char *command, char *args)
    {
      ...
      read (0, buf, bufsize);
      ...
    }
    

  • file descriptor 1 for output (e.g., terminal)

    write (1, "hello\n", strlen("hello\n"));
    

  • file descriptor 2 for error (e.g., terminal)
• on fork, child inherits open file descriptors from parent (show in process diagram).
• on exec, process retains file descriptors, except those specifically marked as close-on-exec: fcntl(fd, F_SETFD, FD_CLOEXEC)

I/O redirection

$ ls > tmp1

close(1);
creat("tmp1", 0666);   // fd will be 1
exec (command, args, 0);

$ sh < script > tmp1

echo one
echo two

$ ls f1 f2 nonexistant-f3 > tmp1 2> tmp1

close(2);
creat("tmp1", 0666);   // fd will be 2

close(2);
dup(1);		       // fd will be 2

$ ls f1 f2 nonexistant-f3 > tmp1 2>&1

$ sort < file.txt > tmp1
$ uniq tmp1 > tmp2
$ wc -l tmp2
$ rm tmp1 tmp2

$ sort < file.txt | uniq | wc

int fdarray[2];
char buf[512];
int n;

pipe(fdarray);
write(fdarray[1], "hello", 5);
n = read(fdarray[0], buf, sizeof(buf));
// buf[] now contains 'h', 'e', 'l', 'l', 'o'

int fdarray[2];
char buf[512];
int n, pid;

pipe(fdarray);
pid = fork();
if(pid > 0){
  write(fdarray[1], "hello", 5);
} else {
  n = read(fdarray[0], buf, sizeof(buf));
}

int fdarray[2];

if (pipe(fdarray) < 0) panic ("error");
if ((pid = fork ()) == 0) {  child (left end of pipe)
  close (1);
  tmp = dup (fdarray[1]);   // fdarray[1] is the write end, tmp will be 1
  close (fdarray[0]);       // close read end
  close (fdarray[1]);       // close fdarray[1]
  exec (command1, args1, 0);
} else if (pid > 0) {        // parent (right end of pipe)
  close (0);
  tmp = dup (fdarray[0]);   // fdarray[0] is the read end, tmp will be 0
  close (fdarray[0]);
  close (fdarray[1]);       // close write end
  exec (command2, args2, 0);
} else {
  printf ("Unable to fork\n");
}