• Median grade was a perfect 56 out of 56.
• Average style grade was halfway between a 'solid' and a 'minor-problems'.
• Functionality counts five times as much as style in CS110.
  • I care about software engineering and code clarity, but..
  • I care about working code more.
  • Style grades translate as follows:
    • exceptional -> 105%
    • solid -> 95%
    • minor-problems -> 80%
    • major-problems -> 60%

• Finish reading B&O Chapter 2 (Chapter 10 of full textbook) so you can confirm that you know most of the material there, as I covered much of it during the first two weeks of lecture.
• Finish reading B&O Chapter 1 (Chapter 8 of the full textbook), focusing on Section 5, which covers process groups, signals, and signal handlers, all three of which are relevant to your next few assignments.

• We have a few lecture examples from last Wednesday to work through. In particular, we want to implement a collection of miniature shells to illustrate how fork, waitpid, and execvp work.
• I want to introduce the notion of a pipe, the pipe and dup2 functions, and how they can be used to foster more sophisticated communication between the different processes.
• Later today or first thing Wednesday, we'll begin our discussion of signals and signal handlers.

• Relies on fork, waitpid, and execvp.
• This first version operates as a read-eval-print loop (keyword: repl), responding to many things we type in by forking off child processes.
  • Each child process is initially a deep clone of the shell.
  • Each child proceeds to replace its own process image with the new one we specify (e.g. ls, cp, our own CS110 search (which we wrote the second day of class), or even emacs.
  • A trailing ampersand (&) (e.g. emacs &) is an instruction to execute in the background, without blocking access to the terminal.
• Implementation of simplesh is presented over the next three slides. Where helper functions don't rely on CS110 concepts, I omit their implementations (but will describe them in lecture).

• Here's the first half (full implementation right here)

int main(int argc, char *argv[]) {
  while (true) {
    char command[kMaxCommandLength + 1];
    readCommand(command, sizeof(command) - 1);
    if (feof(stdin)) break;
    char *arguments[kMaxArgumentCount + 1];
    int count = parseCommandLine(command, arguments, 
                                 sizeof(arguments)/sizeof(arguments[0]));
    if (count == 0) continue;
    bool builtin = handleBuiltin(arguments);
    if (builtin) continue; // it's been handled, move on
    bool isBackgroundProcess = strcmp(arguments[count - 1], "&") == 0;
    if (isBackgroundProcess) arguments[--count] = NULL; // overwrite "&"
    pid_t pid = forkProcess();

• Here's the second half

    if (pid == 0) {
      if (execvp(arguments[0], arguments) < 0) {
        printf("%s: Command not found\n", arguments[0]);
        exit(0);
      }
    }

    if (!isBackgroundProcess) {
      waitForChildProcess(pid);
    } else {
      printf("%d %s\n", pid, command);
    }
  }

  printf("\n");
  return 0;
}

• Here are a few helper routines that do rely on CS110 material:

static bool handleBuiltin(char *arguments[]) {
  if (strcasecmp(arguments[0], "quit") == 0) exit(0);
  return strcmp(arguments[0], "&") == 0;
}

static pid_t forkProcess() {
  pid_t pid = fork();
  exitIf(pid == -1, kForkFailed, stderr, "fork function failed.\n");
  return pid;
}

static void waitForChildProcess(pid_t pid) {
  exitUnless(waitpid(pid, NULL, 0) == pid, kWaitFailed,
             stderr, "Error waiting in foreground for process %d to exit", pid);
}

• The pipe system call takes an uninitialized array of two integers (let’s call this array fds) and populates it with two file descriptors such that everything written to fds[1] can be read from fds[0].

int pipe(int fds[]); // fds array should be of length 2, return -1 on error, 0 otherwise

• pipe is particularly useful for allowing parent processes to communicate with forked child processes. (Recall that fork clones the caller’s virtual address space and duplicates all open file descriptors as well).
• Using pipe, fork, dup2, execvp, close, and waitpid, we can implement the subprocess function, which relies on the following record definition and is implemented to the following prototype:

typedef struct {
  pid_t pid;
  int infd;
} subprocess_t;
subprocess_t subprocess(const char *command);

• The subprocess created by subprocess executes the provided command (guaranteed to be a '\0'-terminated C string) by calling "/bin/sh -c command". Rather than waiting for command to finish, the implementation returns a subprocess_t with the command process’s pid and a single file descriptor. In particular, arbitrary data can be published to the return value’s infd with the understanding that it’ll be read by command's standard input.

• The following client program and test run illustrate precisely how subprocess should work:

int main(int argc, char *argv[]) {
  subprocess_t sp = subprocess("/usr/bin/sort");
  const char *words[] = {
    "felicity", "umbrage", "susurration", "halcyon",
    "pulchritude", "ablution", "somnolent", "indefatigable"
  };      
  for (size_t i = 0; i < sizeof(words)/sizeof(words[0]); i++) { 
    dprintf(sp.infd, "%s\n", words[i]);
  }
  close(sp.infd); // effectively sends cntl-D to child process
  int status;
  pid_t pid = waitpid(sp.pid, &status, 0);
  return pid == sp.pid && WIFEXITED(status) ? WEXITSTATUS(status) : -1;
}

• The output of the above program, given a properly implemented subprocess routine, should look like so:

myth22> ./subprocess-test
ablution
felicity
halcyon
indefatigable
pulchritude
somnolent
susurration
umbrage

• Here is the implementation of subprocess (where I omit error checking so that the meat of the implementation is clear):

subprocess_t subprocess(const char *command) {
  int fds[2];
  pipe(fds);
  subprocess_t process = { fork(), fds[1] };
  if (process.pid == 0) {
    close(fds[1]);
    dup2(fds[0], STDIN_FILENO);
    close(fds[0]);
    char *argv[] = {"/bin/sh", "-c", (char *) command, NULL};
    execvp(argv[0], argv);
  }
  close(fds[0]);
  return process;
}

• Note that the write end of the pipe is embedded into the subprocess_t. That way, the parent knows where to publish text so that it flows to the other end of the pipe, across the parent process/child process boundary.
• Further note that the child process reassociates the read end of the pipe with its own standard input (using dup2).
• Once the dup2 reassociation has been made, the child process can close both ends of its copy of the pipe.
• The parent doesn't need the read end of the pipe, so it too can close its own copy of fds[0].
• Full implementation is right here.