Shell

Source: CS:APP3e, Bryant and O’Hallaron, Shell Lab (from Lab Assignments), using the downloadable self-study “handout.”

The task is to implement the following unimplemented functions in the file tsh.c:

void eval(char *cmdline);
int builtin_cmd(char **argv);
void do_bgfg(char **argv);
void waitfg(pid_t pid);

Plus three signal handlers:

void sigchld_handler(int sig);
void sigtstp_handler(int sig);
void sigint_handler(int sig);

Other constraints: check the return value of every system call.

Models for eval(), builtin_cmd(), and waitfg() are provided in CSAPP.

Implemented functions
Testing
Entirety of shell code, including both provided and implemented functions

Implemented functions

eval()

Evaluate the command line that the user has just typed in.

If the user has requested a built-in command (quit, jobs, bg or fg) then execute it immediately. Otherwise, fork a child process and run the job in the context of the child. If the job is running in the foreground, wait for it to terminate and then return. Note: each child process must have a unique process group ID so that our background children don’t receive SIGINT (SIGTSTP) from the kernel when we type Ctrl-c (Ctrl-z) at the keyboard.

void eval(char * cmdline) {
    char * argv[MAXARGS]; // Holds result of `parseline(buf, arg)`
    char buf[MAXLINE];    // Buffer for command line
    int bg;               // Foreground/background status
    pid_t pid;            // Process ID

    // Setup for using `sigprocmask` to block SIGCHLD signals before
    // forking.
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, SIGCHLD);

    // Parse `cmdline` to produce an argument array. `parseline()`
    // detects the ampersand '&' character used to signify a
    // background job and returns true (1) in that case, otherwise 
    // false (0). We assign that return value to our own local 
    // variable `bg`, which also indicates foreground or background
    // status.
    strcpy(buf, cmdline);
    bg = parseline(buf, argv);

    // Terminate on EOF.
    if (argv[0] == NULL) return;

    // Execute `builtin_cmd(argv)` and test its return status. If
    // false (0), we're not dealing with a built-in shell command,
    // so we need to create a job for this command line and a child
    // process to execute it.
    if (!builtin_cmd(argv)) {

        // Block SIGCHLD signals before forking the child, to avoid a
        // a race condition in which the child is reaped before the
        // parent calls `addjob`.
        if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
            unix_error("sigprocmask: error blocking SIGCHLD signals");
            return;
        }

        // Now fork, creating a child process.
        int pid_ret = (pid = fork());
        if (pid_ret == -1) {
            unix_error("fork error");
            exit(0);
        } 

        // If the child process was successfully created, invoke
        // `execve()` to run the program invoked by the shell command
        // line.
        if (pid_ret == 0) {

            // First, create a new process group whose group ID is
            // identical to the child's PID, and put the child process
            // in this new process group. We do this to prevent
            // Ctrl-c from sending a SIGINT signal to the shell plus every
            // process the shell has created. Instead, the SIGINT signal
            // will be sent only to the process group containing the 
            // foreground job.
            if (setpgid(0, 0) == -1) {
                unix_error("setpgid error");
            }

            // Now we can run the program invoked by the shell command
            // in our new child process. Test the return value so we
            // notify the shell user when a non-existent command has
            // been invoked.
            if (execve(argv[0], argv, environ) == -1) {
                printf("%s: Command not found\n", argv[0]);
                exit(0);
            }
        }


        // Add the job with the foreground/background status indicated
        // by `parseline`.
        addjob(jobs, pid, (bg ? BG : FG), cmdline);

        // Now that the job has been added, the danger of a race
        // condition has passed. We can unblock SIGCHLD signals, 
        // then manage the job as follows:
        // - If job is a foreground job, wait for it to terminate.
        // - If job is a background job, print its job and process IDs
        // along with the string representing it as a command.
        if (sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1) {
            unix_error("sigprocmask: error unblocking SIGCHLD signals");
        }
        if (!bg) waitfg(pid);
        else printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
    }

    return;
}

builtin_cmd()

If the user has typed a built-in command then execute it immediately.

Based on the model in CSAPP3E §8.4. eval() forks a process if the command is not a built-in command, so we need to return an integer value of 1 in the case of “jobs”, “bg”, and “fg”.

int builtin_cmd(char ** argv) {
    if (!strcmp(argv[0], "&")) return 1;   // ignore singleton `&`

    if (!strcmp(argv[0], "quit")) exit(0);

    if (!strcmp(argv[0], "jobs")) {
        listjobs(jobs);
        return 1;
    }

    if (!strcmp(argv[0], "bg") || !strcmp(argv[0], "fg")) {
        do_bgfg(argv);
        return 1;
    }

    return 0; // if `argv` is not a built-in command
}

do_bgfg()

Execute the builtin bg and fg commands.

First, since a job can be identifed by either a job ID or a process ID, we need to detect each format. Either ID will consist of string input from the shell command line, which we must convert to an integer. Once we have the job ID or process ID, we use getjobjid() or getjobpid() to retrieve the job from the jobs list, and kill() to restart any stopped jobs. Finally, we update the job state and perform other actions as appropriate.

void do_bgfg(char ** argv) {
    struct job_t * j;

    // If "fg" or "bg" is missing, print an error and return.
    if (!argv[1]) {
        printf("%s command requires PID or %%jobid argument\n", argv[0]);
        return;
    }

    // If the argument begins with '%', it denotes a job ID.
    if (argv[1][0] == '%') {

        // Convert the string representing the job id to an integer.
        int jid = strtol(argv[1] + 1, NULL, 10);
        if (!jid) {
            printf("%s command requires PID or %%jobid argument\n", argv[0]);
            return;
        }

        // Retrieve the job from the jobs list.
        j = getjobjid(jobs, jid);
        if (!j) {
            printf("%s: No such job\n", argv[1]);
            return;
        }

    // Otherwise, assume we're dealing with a process ID.
    } else {
        int pid = strtol(argv[1], NULL, 10);
        if (!pid) {
            printf("%s: argument must be a PID or %%jobid\n", argv[0]);
            return;
        }

        j = getjobpid(jobs, pid);
        if (!j) {
            printf("(%s): No such process\n", argv[1]);
            return;
        }
    }

    // Send a SIGCONT signal to the entire process group of the process
    // assigned to that job. This will restart a stopped process, performing 
    // the function associated with the `fg` command. (If the process is not 
    // stopped, the signal will be ignored.)
    if (kill(-(j->pid), SIGCONT) == -1) unix_error("kill (SIGCONT) error");

    // Set the job state and perform other actions, depending on which
    // command was selected, `bg` or `fg`.
    if (!strcmp(argv[0], "fg")) {
        j->state = FG;
        waitfg(j->pid);             // Block until no longer a foreground job.
        if (j->state == ST) return; // Don't delete a stopped job.
        deletejob(jobs, j->pid);    // Delete a finished foreground job.
    } else {
        j->state = BG;

        // Print info for a background job.
        printf("[%d] (%d) %s", j->jid, j->pid, j->cmdline);
    }
}

waitfg()

Block until process pid is no longer the foreground process. Get the job with pid and test its status periodically, until it’s no longer a foreground job. (I am following the recommendation in the assignment hints that we use sleep() here, and waitpid() in sigchld_handler().)

void waitfg(pid_t pid) {
    struct job_t * j = getjobpid(jobs, pid);
    while (j->state == FG) sleep(1);
}

sigchld_handler()

The kernel sends a SIGCHLD to the shell whenever a child job terminates (becomes a zombie), or stops because it received a SIGSTOP or SIGTSTP signal. The handler reaps all available zombie children, but doesn’t wait for any other currently running children to terminate.

void sigchld_handler(int sig) {
    int status;
    pid_t pid;

    // Invoke `waitpid()` with the arguments -1 (wait for ALL child
    // processes), a local variable to store the process status, and
    // the expression `WUNTRACED | WNOHANG`, which will detect stopped
    // processes or zombie processes (processes that have terminated 
    // but have not yet been reaped) without blocking.
    while ((pid = waitpid(-1, &status, WUNTRACED | WNOHANG)) > 0) {

        // Handle a stopped process.
        if (WIFSTOPPED(status)) {

            // Get the job and set its status to `ST` (stopped).
            struct job_t * j = getjobpid(jobs, pid);
            j->state = ST;

            // If you print the handler function's argument `sig` here, 
            // instead of `SIGTSTP`, you will print a different signal 
            // value than the reference implementation does in test #16.
            // Using `SIGTSTP` instead of the argument `sig` here gives
            // you the same behavior as the reference implementation, but
            // you aren't catching the signal itself properly.
            printf("Job [%d] (%d) stopped by signal %d\n", pid2jid(pid), pid, SIGTSTP);
        }

        // Return information about a job terminated by a signal, then
        // delete it.
        else if (WIFSIGNALED(status)) {
            printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, SIGINT);
            deletejob(jobs, pid);
        }

        // If a job was terminated normally, just delete it.
        else if (WIFEXITED(status)) {
            deletejob(jobs, pid);
        }

        else unix_error("waitfg: waitpid error");
    }
}

sigint_handler()

The kernel sends a SIGINT to the shell whenver the user types Ctrl-c at the keyboard. Catch it and send it along to the foreground job.

Get the process ID of the foreground job and use kill() to send a SIGINT signal to its entire process group.

void sigint_handler(int sig) {
    pid_t pid = fgpid(jobs);
    if (!pid) return;
    if (kill(-pid, SIGINT) == -1) unix_error("kill (SIGINT) error");
}

sigtstp_handler()

The kernel sends a SIGTSTP to the shell whenever the user types Ctrl-z at the keyboard. Catch it and suspend the foreground job by sending it a SIGTSTP.

Get the process ID of the foreground job and use kill() to send a SIGTSTP signal to its entire process group.

void sigtstp_handler(int sig) {
    pid_t pid = fgpid(jobs);
    if (!pid) return;
    if (kill(-pid, SIGTSTP) == -1) unix_error("kill (SIGTSTP) error");
}

Testing

Bash one-liner to compare output of all tests with output of tests of the reference implementation:

tests=("01" "02" "03" "04" "05" "06" "07" "08" \
"09" "10" "11" "12" "13" "14" "15" "16"); \
clear; \
for t in ${tests[@]}; \
  do \
    echo -e "***** TEST $t *****\n"; \
    sdiff -I "^\.\/sdriver.*" -s <(make rtest$t) <(make test$t); \
    echo -e "\n\n\n"; \
  done

Entirety of shell code, including both provided and implemented functions

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>


// Misc constants
// ==============
#define MAXLINE    1024   // max line size
#define MAXARGS     128   // max args on a command line
#define MAXJOBS      16   // max jobs at any point in time
#define MAXJID    1<<16   // max job ID

// Job states
// ==========
// Job state transitions and enabling actions:
// - FG -> ST: ctrl-z
// - ST -> FG: fg command
// - ST -> BG: bg command
// - BG -> FG: fg command
// At most 1 job can be in the FG state.
#define UNDEF 0
#define FG 1   // running in foreground
#define BG 2   // running in background
#define ST 3   // stopped


// Global variables
// ================
extern char **environ;      // defined in `libc`
char prompt[] = "tsh> ";    // command line prompt (DO NOT CHANGE)
int verbose = 0;            // if true, print additional output
int nextjid = 1;            // next job ID to allocate
char sbuf[MAXLINE];         // for composing sprintf messages

struct job_t {              // The job struct
    pid_t pid;              // job PID
    int jid;                // job ID [1, 2, ...]
    int state;              // UNDEF, BG, FG, or ST
    char cmdline[MAXLINE];  // command line
};

struct job_t jobs[MAXJOBS]; // The job list


// Function prototypes
// ===================

// Functions to be implemented for this project.
void eval(char * cmdline);
int builtin_cmd(char ** argv);
void do_bgfg(char ** argv);
void waitfg(pid_t pid);

void sigchld_handler(int sig);
void sigtstp_handler(int sig);
void sigint_handler(int sig);

// Helper routines provided.
int parseline(const char * cmdline, char ** argv); 
void sigquit_handler(int sig);

void clearjob(struct job_t * job);
void initjobs(struct job_t * jobs);
int maxjid(struct job_t * jobs); 
int addjob(struct job_t * jobs, pid_t pid, int state, char * cmdline);
int deletejob(struct job_t * jobs, pid_t pid); 
pid_t fgpid(struct job_t * jobs);
struct job_t * getjobpid(struct job_t * jobs, pid_t pid);
struct job_t * getjobjid(struct job_t * jobs, int jid); 
int pid2jid(pid_t pid); 
void listjobs(struct job_t * jobs);

void usage(void);
void unix_error(char * msg);
void app_error(char * msg);
typedef void handler_t(int);
handler_t *Signal(int signum, handler_t * handler);


// main()
// ======
int main(int argc, char ** argv) {
    char c;
    char cmdline[MAXLINE];
    int emit_prompt = 1; // emit prompt (default)

    // Redirect stderr to stdout (so that driver will get all output
    // on the pipe connected to stdout).
    dup2(1, 2);

    // Parse the command line.
    while ((c = getopt(argc, argv, "hvp")) != EOF) {
        switch (c) {
            case 'h':             // print help message
                usage();
                break;
            case 'v':             // emit additional diagnostic info
                verbose = 1;
                break;
            case 'p':             // don't print a prompt
                emit_prompt = 0;  // handy for automatic testing
                break;
            default:
                usage();
        }
    }

    // Install the signal handlers

    // These are the ones you will need to implement
    Signal(SIGINT,  sigint_handler);   // ctrl-c
    Signal(SIGTSTP, sigtstp_handler);  // ctrl-z
    Signal(SIGCHLD, sigchld_handler);  // Terminated or stopped child

    // This one provides a clean way to kill the shell
    Signal(SIGQUIT, sigquit_handler); 

    // Initialize the job list
    initjobs(jobs);

    // Execute the shell's read/eval loop
    while (1) {

        // Read command line
        if (emit_prompt) {
            printf("%s", prompt);
            fflush(stdout);
        }

        if ((fgets(cmdline, MAXLINE, stdin) == NULL) && ferror(stdin)) {
            app_error("fgets error");
        }

        if (feof(stdin)) { // End of file (ctrl-d)
            fflush(stdout);
            exit(0);
        }

        // Evaluate the command line
        eval(cmdline);
        fflush(stdout);
        fflush(stdout);
    } 

    exit(0); // control never reaches here
}


// eval()
// ======
// Evaluate the command line that the user has just typed in
// 
// If the user has requested a built-in command (quit, jobs, bg or fg)
// then execute it immediately. Otherwise, fork a child process and
// run the job in the context of the child. If the job is running in
// the foreground, wait for it to terminate and then return.  Note:
// each child process must have a unique process group ID so that our
// background children don't receive SIGINT (SIGTSTP) from the kernel
// when we type ctrl-c (ctrl-z) at the keyboard.
//
void eval(char * cmdline) {
    char * argv[MAXARGS]; // Holds result of `parseline(buf, arg)`
    char buf[MAXLINE];    // Buffer for command line
    int bg;               // Foreground/background status
    pid_t pid;            // Process ID

    // Setup for using `sigprocmask` to block SIGCHLD signals before
    // forking.
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, SIGCHLD);

    // Parse `cmdline` to produce an argument array. `parseline()`
    // detects the ampersand '&' character used to signify a
    // background job and returns true (1) in that case, otherwise 
    // false (0). We assign that return value to our own local 
    // variable `bg`, which also indicates foreground or background
    // status.
    strcpy(buf, cmdline);
    bg = parseline(buf, argv);

    // Terminate on EOF.
    if (argv[0] == NULL) return;

    // Execute `builtin_cmd(argv)` and test its return status. If
    // false (0), we're not dealing with a built-in shell command,
    // so we need to create a job for this command line and a child
    // process to execute it.
    if (!builtin_cmd(argv)) {

        // Block SIGCHLD signals before forking the child, to avoid a
        // a race condition in which the child is reaped before the
        // parent calls `addjob`.
        if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
            unix_error("sigprocmask: error blocking SIGCHLD signals");
            return;
        }

        // Now fork, creating a child process.
        int pid_ret = (pid = fork());
        if (pid_ret == -1) {
            unix_error("fork error");
            exit(0);
        } 

        // If the child process was successfully created, invoke
        // `execve()` to run the program invoked by the shell command
        // line.
        if (pid_ret == 0) {

            // First, create a new process group whose group ID is
            // identical to the child's PID, and put the child process
            // in this new process group. We do this to prevent
            // Ctrl-c from sending a SIGINT signal to the shell plus every
            // process the shell has created. Instead, the SIGINT signal
            // will be sent only to the process group containing the 
            // foreground job.
            if (setpgid(0, 0) == -1) {
                unix_error("setpgid error");
            }

            // Now we can run the program invoked by the shell command
            // in our new child process. Test the return value so we
            // notify the shell user when a non-existent command has
            // been invoked.
            if (execve(argv[0], argv, environ) == -1) {
                printf("%s: Command not found\n", argv[0]);
                exit(0);
            }
        }


        // Add the job with the foreground/background status indicated
        // by `parseline`.
        addjob(jobs, pid, (bg ? BG : FG), cmdline);

        // Now that the job has been added, the danger of a race
        // condition has passed. We can unblock SIGCHLD signals, 
        // then manage the job as follows:
        // - If job is a foreground job, wait for it to terminate.
        // - If job is a background job, print its job and process IDs
        // along with the string representing it as a command.
        if (sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1) {
            unix_error("sigprocmask: error unblocking SIGCHLD signals");
        }
        if (!bg) waitfg(pid);
        else printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
    }

    return;
}


// parseline()
// ===========
// Parse the command line and build the argv array.
// 
// Characters enclosed in single quotes are treated as a single
// argument. Return true if the user has requested a BG job, false if
// the user has requested a FG job.  
//
int parseline(const char * cmdline, char ** argv) {
    static char array[MAXLINE]; // holds local copy of command line
    char *buf = array;          // ptr that traverses command line
    char *delim;                // points to first space delimiter
    int argc;                   // number of args
    int bg;                     // background job?

    strcpy(buf, cmdline);
    buf[strlen(buf)-1] = ' ';  // replace trailing '\n' with space
    while (*buf && (*buf == ' ')) buf++; // ignore leading spaces

    // Build the argv list
    argc = 0;
    if (*buf == '\'') {
        buf++;
        delim = strchr(buf, '\'');
    } else {
        delim = strchr(buf, ' ');
    }

    while (argc < MAXARGS-1 && delim) {
        argv[argc++] = buf;
        *delim = '\0';
        buf = delim + 1;
        while (*buf && (*buf == ' ')) buf ++ // ignore spaces

        if (*buf == '\'') {
          buf++;
          delim = strchr(buf, '\'');
        } else {
            delim = strchr(buf, ' ');
        }
    }

    if (delim) {
        fprintf(stderr, "Too many arguments.\n");
        argc = 0; //treat it as an empty line.
    }
    argv[argc] = NULL;

    if (argc == 0) return 1; // ignore blank line

    // should the job run in the background?
    if ((bg = (*argv[argc-1] == '&')) != 0) argv[--argc] = NULL;
    return bg;
}


// builtin_cmd()
// =============
// If the user has typed a built-in command then execute
// it immediately.
//
// Based on the model in CSAPP3E §8.4. `eval()` forks a process if
// the command is not a built-in command, so we need to return an
// integer value of 1 in the case of "jobs", "bg", and "fg".
//
int builtin_cmd(char ** argv) {
    if (!strcmp(argv[0], "&")) return 1;   // ignore singleton `&`

    if (!strcmp(argv[0], "quit")) exit(0);

    if (!strcmp(argv[0], "jobs")) {
        listjobs(jobs);
        return 1;
    }

    if (!strcmp(argv[0], "bg") || !strcmp(argv[0], "fg")) {
        do_bgfg(argv);
        return 1;
    }

    return 0; // if `argv` is not a built-in command
}


// do_bgfg()
// =========
// Execute the builtin bg and fg commands.
//
// First, since a job can be identifed by either a job ID or a process
// ID, we need to detect each format. Either ID will consist of string
// input from the shell command line, which we must convert to an 
// integer. Once we have the job ID or process ID, we use `getjobjid()`
// or `getjobpid()` to retrieve the job from the jobs list, and `kill()`
// to restart any stopped jobs. Finally, we update the job state
// and perform other actions as appropriate.
//
void do_bgfg(char ** argv) {
    struct job_t * j;

    // If "fg" or "bg" is missing, print an error and return.
    if (!argv[1]) {
        printf("%s command requires PID or %%jobid argument\n", argv[0]);
        return;
    }

    // If the argument begins with '%', it denotes a job ID.
    if (argv[1][0] == '%') {

        // Convert the string representing the job id to an integer.
        int jid = strtol(argv[1] + 1, NULL, 10);
        if (!jid) {
            printf("%s command requires PID or %%jobid argument\n", argv[0]);
            return;
        }

        // Retrieve the job from the jobs list.
        j = getjobjid(jobs, jid);
        if (!j) {
            printf("%s: No such job\n", argv[1]);
            return;
        }

    // Otherwise, assume we're dealing with a process ID.
    } else {
        int pid = strtol(argv[1], NULL, 10);
        if (!pid) {
            printf("%s: argument must be a PID or %%jobid\n", argv[0]);
            return;
        }

        j = getjobpid(jobs, pid);
        if (!j) {
            printf("(%s): No such process\n", argv[1]);
            return;
        }
    }

    // Send a SIGCONT signal to the entire process group of the process
    // assigned to that job. This will restart a stopped process, performing 
    // the function associated with the `fg` command. (If the process is not 
    // stopped, the signal will be ignored.)
    if (kill(-(j->pid), SIGCONT) == -1) unix_error("kill (SIGCONT) error");

    // Set the job state and perform other actions, depending on which
    // command was selected, `bg` or `fg`.
    if (!strcmp(argv[0], "fg")) {
        j->state = FG;
        waitfg(j->pid);             // Block until no longer a foreground job.
        if (j->state == ST) return; // Don't delete a stopped job.
        deletejob(jobs, j->pid);    // Delete a finished foreground job.
    } else {
        j->state = BG;

        // Print info for a background job.
        printf("[%d] (%d) %s", j->jid, j->pid, j->cmdline);
    }
}


// waitfg()
// ========
// Block until process `pid` is no longer the foreground process.
// Get the job with `pid` and test its status periodically, until
// it's no longer a foreground job. (I am following the recommendation
// in the assignment hints that we use `sleep()` here, and `waitpid()` in 
// `sigchld_handler()`.)
//
void waitfg(pid_t pid) {
    struct job_t * j = getjobpid(jobs, pid);
    while (j->state == FG) sleep(1);
}


// Signal handlers
// ===============

// sigchld_handler()
// -----------------
// The kernel sends a SIGCHLD to the shell whenever a child job terminates
// (becomes a zombie), or stops because it received a SIGSTOP or SIGTSTP signal.
// The handler reaps all available zombie children, but doesn't wait for any
// other currently running children to terminate.
//
void sigchld_handler(int sig) {
    int status;
    pid_t pid;

    // Invoke `waitpid()` with the arguments -1 (wait for ALL child
    // processes), a local variable to store the process status, and
    // the expression `WUNTRACED | WNOHANG`, which will detect stopped
    // processes or zombie processes (processes that have terminated 
    // but have not yet been reaped) without blocking.
    while ((pid = waitpid(-1, &status, WUNTRACED | WNOHANG)) > 0) {

        // Handle a stopped process.
        if (WIFSTOPPED(status)) {

            // Get the job and set its status to `ST` (stopped).
            struct job_t * j = getjobpid(jobs, pid);
            j->state = ST;

            // If you print the handler function's argument `sig` here, 
            // instead of `SIGTSTP`, you will print a different signal 
            // value than the reference implementation does in test #16.
            printf("Job [%d] (%d) stopped by signal %d\n", pid2jid(pid), pid, SIGTSTP);
        }

        // Return information about a job terminated by a signal, then
        // delete it.
        else if (WIFSIGNALED(status)) {
            printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, SIGINT);
            deletejob(jobs, pid);
        }

        // If a job was terminated normally, just delete it.
        else if (WIFEXITED(status)) {
            deletejob(jobs, pid);
        }

        else unix_error("waitfg: waitpid error");
    }
}

// sigint_handler()
// ----------------
// The kernel sends a SIGINT to the shell whenver the user types ctrl-c at the
// keyboard.  Catch it and send it along to the foreground job.
//
// Get the process ID of the foreground job and use `kill()` to send
// a SIGINT signal to its entire process group.
//
void sigint_handler(int sig) {
    pid_t pid = fgpid(jobs);
    if (!pid) return;
    if (kill(-pid, SIGINT) == -1) unix_error("kill (SIGINT) error");
}

// sigtstp_handler()
// -----------------
// The kernel sends a SIGTSTP to the shell whenever the user types ctrl-z at the
// keyboard. Catch it and suspend the foreground job by sending it a SIGTSTP.
//
// Get the process ID of the foreground job and use `kill()` to send a SIGTSTP
// signal to its entire process group.
//
void sigtstp_handler(int sig) {
    pid_t pid = fgpid(jobs);
    if (!pid) return;
    if (kill(-pid, SIGTSTP) == -1) unix_error("kill (SIGTSTP) error");
}



// Helper routines
// ===============

// clearjob()
// ----------
// Clear the entries in a job struct.
void clearjob(struct job_t * job) {
    job->pid = 0;
    job->jid = 0;
    job->state = UNDEF;
    job->cmdline[0] = '\0';
}

// initjobs()
// ----------
// Initialize the job list.
void initjobs(struct job_t * jobs) {
    int i;
    for (i = 0; i < MAXJOBS; i++) clearjob(&jobs[i]);
}

// maxjid()
// --------
// Return the largest allocated job ID.
int maxjid(struct job_t * jobs) {
    int i, max = 0;

    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].jid > max) max = jobs[i].jid;
    }
    return max;
}

// addjob()
// --------
// Add a job to the job list.
int addjob(struct job_t * jobs, pid_t pid, int state, char * cmdline) {
    int i;
    if (pid < 1) return 0;

    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].pid == 0) {
            jobs[i].pid = pid;
            jobs[i].state = state;
            jobs[i].jid = nextjid++;
            if (nextjid > MAXJOBS) nextjid = 1;
            strcpy(jobs[i].cmdline, cmdline);
            if (verbose) {
                printf("Added job [%d] %d %s\n", jobs[i].jid, jobs[i].pid, jobs[i].cmdline);
            }
        return 1;
        }
    }
    printf("Tried to create too many jobs\n");
    return 0;
}

// deletejob()
// -----------
// Delete a job whose PID=pid from the job list.
int deletejob(struct job_t * jobs, pid_t pid) {
    int i;
    if (pid < 1) return 0;

    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].pid == pid) {
            clearjob(&jobs[i]);
            nextjid = maxjid(jobs)+1;
            return 1;
        }
    }
    return 0;
}

// fgpid()
// -------
// Return PID of current foreground job, 0 if no such job.
pid_t fgpid(struct job_t * jobs) {
    int i;
    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].state == FG) return jobs[i].pid;
    }
    return 0;
}

// getjobpid()
// -----------
// Find a job (by PID) on the job list.
struct job_t * getjobpid(struct job_t * jobs, pid_t pid) {
    int i;
    if (pid < 1) return NULL;
    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].pid == pid) return &jobs[i];
    }
    return NULL;
}

// getjobjid()
// -----------
// Find a job (by JID) on the job list.
struct job_t * getjobjid(struct job_t * jobs, int jid) {
    int i;
    if (jid < 1) return NULL;
    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].jid == jid) return &jobs[i];
    }
    return NULL;
}

// pid2jid - Map process ID to job ID
int pid2jid(pid_t pid) {
    int i;
    if (pid < 1) return 0;
    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].pid == pid) return jobs[i].jid;
    }
    return 0;
}

// listjobs()
// ----------
// Print the job list.
void listjobs(struct job_t * jobs) {
    int i;
    for (i = 0; i < MAXJOBS; i++) {
        if (jobs[i].pid != 0) {
            printf("[%d] (%d) ", jobs[i].jid, jobs[i].pid);
            switch (jobs[i].state) {
                case BG: 
                    printf("Running ");
                    break;
                case FG: 
                    printf("Foreground ");
                    break;
                case ST: 
                    printf("Stopped ");
                    break;
                default:
                    printf("listjobs: Internal error: job[%d].state=%d ", 
                        i, jobs[i].state);
            }
            printf("%s", jobs[i].cmdline);
        }
    }
}

// usage()
// -------
// Print a help message.
void usage(void) {
    printf("Usage: shell [-hvp]\n");
    printf("   -h   print this message\n");
    printf("   -v   print additional diagnostic information\n");
    printf("   -p   do not emit a command prompt\n");
    exit(1);
}

// unix_error()
// ------------
// Unix-style error routine.
void unix_error(char * msg) {
    fprintf(stdout, "%s: %s\n", msg, strerror(errno));
    exit(1);
}

// app_error()
// -----------
// Application-style error routine.
void app_error(char * msg) {
    fprintf(stdout, "%s\n", msg);
    exit(1);
}

// Signal()
// --------
// Wrapper for the sigaction function/
handler_t * Signal(int signum, handler_t * handler) {
    struct sigaction action, old_action;
    action.sa_handler = handler;  
    sigemptyset(&action.sa_mask); // block sigs of type being handled
    action.sa_flags = SA_RESTART; // restart syscalls if possible
    if (sigaction(signum, &action, &old_action) < 0) unix_error("Signal error");
    return (old_action.sa_handler);
}

// sigquit_handler()
// -----------------
// The driver program can gracefully terminate the child shell by sending it a
// SIGQUIT signal.
void sigquit_handler(int sig) {
    printf("Terminating after receipt of SIGQUIT signal\n");
    exit(1);
}