Lab Assignment 6:  Unix Shell

DUE DATES:

For the “trivia” assignment: 11:59 p.m., Monday, November 16. 

For the main assignment: 11:59pm, Wednesday, November 25Extended to Monday, November 30

If you want to use slip days you have to tell us before the deadline by emailing Sudhanshu Gupta.

Introduction

The purpose of this assignment is to become more familiar with the concepts of process control and signaling.  You’ll do this by writing a simple Unix shell program that supports job control. 

Logistics

As usual, you may work in a group of up to two people in solving the problems for this assignment.  Any clarifications and revisions to the assignment will be posted to the class discussion board on Blackboard.

Hand Out Instructions

Copy the file /u/cs252/labf20/shlab/shlab-handout.tar to the protected directory in which you plan to do your work.  Then do the following:

Looking at the tsh.c (tiny shell) file, you will see that it contains a functional skeleton of a simple Unix shell.  To help you get started, we have already implemented the less interesting functions.  Your assignment is to complete the remaining empty functions.  As a sanity check for you, we’ve listed the approximate number of lines of code for each of these functions in our reference solution (which includes lots of comments). 

Each time you modify your tsh.c file, type make to recompile it.  To run your shell, type ./tsh to the command line:

    unix> ./tsh
    tsh> [type commands to your shell here]
If you want to exit your shell, but have not implemented the appropriate commands, you can type ctrl-D to kill your shell. 

General Overview of Unix Shells

A shell is an interactive command-line interpreter that runs programs on behalf of the user.  A shell repeatedly prints a prompt, waits for a command line on stdin, and then carries out some action, as directed by the contents of the command line. 

The command line is a sequence of ASCII text words delimited by whitespace.  The first word in the command line is either the name of a built-in command or the pathname of an executable file.  The remaining words are command-line arguments.  If the first word is a built-in command, the shell immediately executes the command in the current process.  Otherwise, the word is assumed to be the pathname of an executable program.  In this case, the shell forks a child process, then loads and runs the program in the context of the child.  The child processes created as a result of interpreting a single command line are known collectively as a job.  In general, a job can consist of multiple child processes connected by Unix pipes. 

If the command line ends with an ampersand &, then the job runs in the background, which means that the shell does not wait for the job to terminate before printing the prompt and awaiting the next command line.  Otherwise, the job runs in the foreground, which means that the shell waits for the job to terminate before prompting for the next command line.  Thus, at any point in time, at most one job can be running in the foreground.  However, an arbitrary number of jobs can run in the background. 

For example, typing the command line

    tsh> jobs
causes the shell to execute the built-in jobs command.  Typing the command line
    tsh> /bin/ls -l -d
runs the ls program in the foreground.  By convention, the shell ensures that when ls begins executing its main routine:
    int main(int argc, char *argv[])
the argc and argv arguments have the following values: Alternatively, typing the command line
    tsh> /bin/ls -l -d &
runs the ls program in the background. 

Unix shells support the notion of job control, which allows users to move jobs back and forth between background and foreground, and to change the process state (running, stopped, or terminated) of the processes in a job.  Typing ctrl-c causes a SIGINT signal to be delivered to each process in the foreground job.  The default action for SIGINT is to terminate the process.  Similarly, typing ctrl-z causes a SIGTSTP signal to be delivered to each process in the foreground job.  The default action for SIGTSTP is to place a process in the stopped state, where it remains until it is awakened by the receipt of a SIGCONT signal.  Unix shells also provide various built-in commands that support job control.  For example:

The tsh Specification

Your tsh shell should have the following features:

Checking Your Work

We have provided some tools to help you check your work. 

Reference solution. The Linux executable tshref is the reference solution for the shell.  Run this program to resolve any questions you have about how your shell should behave.  Your shell should emit output that is identical to the reference solution (except PIDs, of course, which change from run to run). 

Shell driver. The sdriver.pl program executes a shell as a child process, sends it commands and signals as directed by a trace file, and captures and displays the output from the shell. 

Use the -h argument to find out the usage of sdriver.pl:  

    unix> ./sdriver.pl -h
    Usage: sdriver.pl [-hv] -t <trace> -s <shellprog> -a <args>
    Options:
      -h            Print this message
      -v            Be more verbose
      -t <trace>    Trace file
      -s <shell>    Shell program to test
      -a <args>     Shell arguments
      -g            Generate output for autograder

We have also provided 16 trace files (trace{01-16}.txt) that you will use in conjunction with the shell driver to test the correctness of your shell.  The lower-numbered trace files do very simple tests, and the higher-numbered tests do more complicated tests. 

You can run the shell driver on your shell using trace file trace01.txt (for instance) by typing:

    unix> ./sdriver.pl -t trace01.txt -s ./tsh -a "-p"
(the -a “-p” argument tells your shell not to emit a prompt),  or
    unix> make test01
Similarly, to compare your result with the reference shell, you can run the trace driver on the reference shell by typing:
    unix> ./sdriver.pl -t trace01.txt -s ./tshref -a "-p"
or
    unix> make rtest01
For your reference, tshref.out gives the output of the reference solution on all 16 traces.  This might be more convenient for you than running the shell driver on all trace files. 

The neat thing about the trace files is that they generate the same output you would have gotten had you run your shell interactively (except for an initial comment that identifies the trace).  For example:

    unix> make test15
    ./sdriver.pl -t trace15.txt -s ./tsh -a "-p"
    #
    # trace15.txt - Putting it all together
    #
    tsh> ./bogus
    ./bogus: Command not found.
    tsh> ./myspin 10
    Job (9721) terminated by signal 2
    tsh> ./myspin 3 &
    [1] (9723) ./myspin 3 &
    tsh> ./myspin 4 &
    [2] (9725) ./myspin 4 &
    tsh> jobs
    [1] (9723) Running    ./myspin 3 &
    [2] (9725) Running    ./myspin 4 &
    tsh> fg %1
    Job [1] (9723) stopped by signal 20
    tsh> jobs
    [1] (9723) Stopped    ./myspin 3 &
    [2] (9725) Running    ./myspin 4 &
    tsh> bg %3
    %3: No such job
    tsh> bg %1
    [1] (9723) ./myspin 3 &
    tsh> jobs
    [1] (9723) Running    ./myspin 3 &
    [2] (9725) Running    ./myspin 4 &
    tsh> fg %1
    tsh> quit
    unix>

Hints

Evaluation

Your score will be computed out of a maximum of 90 points based on the following distribution:

Your solution shell will be tested for correctness on a CSUG Linux machine (likely cycle1), using the same shell driver and trace files that were included in your lab directory.  Your shell should produce identical output on these traces as the reference shell, with only two exceptions: We reserve the right to run additional checks if we suspect that your program generates the “right” output for the wrong reason. 

Extra Credit

There are plenty of opportunities for extra credit on this assignment.  Possibilities of particular relevance to the current assignment include:

Read the man pages for your favorite shell for details and additional ideas. 

Because much of the grading for this assignment is automated, you will need to draw the TA’s attention explicitly to any extra credit features you implement.  To do this, include a README file in the directory in which you run the TURN_IN script. Extra credit will be limited to 20% of the assignment grade.  

Be sure that any extra credit you implement does not alter the behavior of your code on the standard test cases. 

“Trivia” Assignment

Before 11:59 p.m. on Monday 16th November, answer the following questions on blackboard

  1. Are you working alone or in a team of two?  If the latter, who is your partner? 
  2. What output do you get when you run the “trace driver” on the “reference shell”?  Use trace02.txt as the trace file. 
  3. Which of the following system calls does not return control to the calling point when completed: execve, fork, ioctl, or setjmp? 
  4. Where are the command line arguments supplied in a C program: in the stack, heap, data segment, or code segment? 
  5. Which of the following calls never returns an error: getpid, fork, ioctl, or open? 

Turn In Instructions

The “trivia” assignment will be submitted via blackboard.  The main assignment will be submitted using the script /u/cs252/bin/TURN_IN.  From the directory you wish to turn in type:

    /u/cs252/bin/TURN_IN .
Watch the Blackboard discussion forum for details, and for any clarifications or revisions to the assignment. 

Before running the TURN_IN script, be sure that you have

After the hand-in, if you discover a mistake and want to submit a revised copy, follow the instructions above. We’ll grade the latest version (up to the due date).