CS:APP shell lab 记录

Introduction

任务目的是使您更加熟悉过程控制和信号通知的概念。 为此，您需要编写一个简单的Unix Shell程序来支持作业控制。

 

Hand Out Instructions

首先将文件shlab-handout.tar复制到计划在其中进行保护的受保护目录（实验室目录）。 然后执行以下操作：

1.输入命令tar xvf shlab-handout.tar展开tarfile。

2.输入命令make进行编译并链接一些测试例程

 

查看tsh.c（tiny shell）文件，您将看到它包含一个简单的Unix shell的功能框架。 为了帮助您入门，我们已经实现了一些不太有趣的功能。 您的任务是完成下面列出的其余空功能。 为方便起见，我们在参考解决方案中列出了每个功能的大概代码行数（其中包含很多注释）。

1.eval：解析和解释命令行的主例程。 [70行]

2.builtin cm：：识别并解释内置命令：quit，fg，bg和job。 [25行]

3.do_bgfg：实现bg和fg内置命令。[50行]

4.waitfg：等待前台作业完成。[20行]

5.sigchld_handler：捕捉SIGCHILD信号。[80行]

6.sigint_handler：捕捉SIGINT信号。[15行]

7.sigtstp_handler：捕捉SIGTSTP信号。[15行]

 

每次修改tsh.c文件时，键入make即可重新编译它。 要运行您的shell，请在命令行输入tsh。

 

General Overview of Unix

Shell是一个交互式命令行解释器，它代表用户运行程序。 Shell会重复打印提示，在stdin上等待命令行，然后按照命令的内容指示执行一些操作。

命令行是由空格分隔的ASCII文本单词序列。 命令行中的第一个单词是内置命令的名称或可执行文件的路径名。 其余的单词是命令行参数。 如果第一个单词是内置命令，则shell程序将在当前进程中立即执行该命令。 否则，假定该单词为可执行程序的路径名。 在这种情况下，shell会派生一个子进程，然后在该子进程的上下文中加载并运行该程序。 由于解释单个命令行而创建的子进程统称为作业。 通常，一个作业可以包含多个通过Unix连接的子进程。

如果命令行以“＆”号结尾，则作业在后台运行，这意味着shell程序在打印提示并等待下一个命令行之前，不会等待作业终止。 否则，作业将在前台运行，这意味着shell程序在等待下一个命令行之前等待作业终止。 因此，在任何时间点，前台最多只能运行一项作业。 但是，后台可以运行任意数量的作业。

例如，输入下面的命令。

使shell执行内置作业命令。 输入命令行

在前台运行ls程序。 按照约定，shell确保程序开始执行其主例程时。

argc和argv参数具有以下值：

或者，输入命令

在后台运行ls程序。

Unix shell支持作业控制的概念，该概念允许用户在后台和前台之间来回移动作业，并更改作业中进程的进程状态（运行，停止或终止）。 键入ctrl-c会使SIGINT信号传递到前台作业中的每个进程。 SIGINT的默认操作是终止该过程。 同样，键入ctrl-z会使SIGTSTP信号传递到前台作业中的每个进程。 SIGTSTP的默认操作是将进程置于停止状态，该进程一直保持到收到SIGCONT信号将其唤醒为止。 Unix Shell还提供了各种支持作业控制的内置命令。 例如：

1.jobs：列出正在运行和已停止的后台作业。

2.bg  <job>：将已停止的后台作业更改为正在运行的后台。

3.fg  <job> ：将停止运行或正在运行的后台作业更改为在前台运行。

4.kill <job>：终止作业。

 

the tsh specification

你的tsh shell应该具有以下特征。

1.提示符应该是一串字符串 "tsh>"。

2.用户输入的命令行应由名称和零个或多个参数组成，所有参数均由一个或多个空格分隔。 如果name是内置命令，则tsh应该立即处理它并等待下一个命令行。 否则，tsh应该假定名称是可执行文件的路径，该文件将在初始子进程的上下文中加载并运行（在此上下文中，术语“作业”指的是该初始子进程）。

3.tsh不需要支持管道（|）或I / O重定向（<和>）。

4.输入ctrl-c（ctrl-z）应该会导致SIGINT（SIGTSTP）信号发送到当前前台作业以及该作业的后代（例如，它派生的任何子进程）。 如果没有前台作业，则该信号应该无效。

5.如果命令行以＆结束，则tsh应该在后台运行作业。

6.每个作业都可以由进程ID（PID）或作业ID（JID）标识，该ID是tsh分配的正整数。 JID应在命令行上以前缀“％”表示。 例如，“％5”表示JID 5，“ 5”表示PID5。（我们为您提供了处理作业列表所需的所有例程。）

7.tsh应该支持以下内置命令。

– quit命令终止shell。
– jobs命令列出所有后台作业。
– bg <job>命令通过向其发送SIGCONT信号来重新启动<job>，然后在后台运行它。 <job>参数可以是PID或JID。
– fg <job>命令通过向其发送SIGCONT信号来重新启动<job>，然后在前台运行它。 <job>参数可以是PID或JID。

 

8.tsh应该收割所有僵尸孩子。 如果任何作业由于接收到未捕获的信号而终止，则tsh应该识别此事件并打印一条消息，其中包含该作业的PID和有问题的信号的描述。

 

Checking Your Work

我们提供了一些工具来帮助您检查工作。

参考解决方案。 Linux可执行文件tshref是Shell的参考解决方案。 运行该程序以解决一些有关shell的行为的问题。 您的shell程序应发出与参考解决方案相同的输出（当然，PID除外，其运行之间会发生变化）。

shell driver。 sdriver.pl程序将shell作为子进程执行，按照跟踪文件的指示向其发送命令和信号，并捕获并显示shell的输出。 使用-h参数找出sdriver.pl的用法。

我们还提供了16个跟踪文件（trace 01-16 .txt），您将这些文件与shell驱动程序结合使用以测试shell的正确性。 编号较低的跟踪文件执行非常简单的测试，编号较高的测试文件进行更复杂的测试。 您可以使用跟踪文件trace01.txt（例如）在shell程序上运行shell程序驱动程序，方法是输入：

或者

同样，要将结果与参考shell程序进行比较，可以通过输入以下内容在参考shell程序上运行跟踪驱动程序：

作为参考，tshref.out提供了所有的输出。 与手动在所有跟踪文件上运行Shell驱动程序相比，这可能更方便。 关于跟踪文件的巧妙之处在于，它们生成的输出与您以交互方式运行shell程序所获得的输出相同（除了标识跟踪的初始注释之外）。 例如：

代码如下：

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

/* Misc manifest 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 */
#define UNDEF 0 /* undefined */
#define FG 1    /* running in foreground */
#define BG 2    /* running in background */
#define ST 3    /* stopped */

/* 
 * Jobs states: FG (foreground), BG (background), ST (stopped)
 * 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.
 */

/* Global variables */
int fg_isfinish;
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 */
/* End global variables */


/* Function prototypes */

/* Here are the functions that you will implement */
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);

/* Here are helper routines that we've provided for you */
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 - The shell's main routine 
 */
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];
	char buf[MAXLINE];

	strcpy(buf, cmdline);
	int bg = parseline(buf, argv);
	if(!argv[0])
		return;

	if(!builtin_cmd(argv)){
		//如果不是内部命令
		//先阻塞sigchild信号
		sigset_t mask;
		sigemptyset(&mask);
		sigaddset(&mask, SIGCHLD);
		sigprocmask(SIG_BLOCK, &mask, NULL);

		pid_t pid = fork();
		if(!pid){
			//子进程运行程序
			//先解除信号阻塞
			sigprocmask(SIG_UNBLOCK, &mask, NULL);
			setpgid(0, 0);              //设置独立的进程组id
			if(execve(argv[0], argv, environ) < 0){
				printf("%s: Command not found.\n", argv[0]);
				exit(0);
			}
		}	
		if(!bg){
			//先addjob
			addjob(jobs, pid, FG, cmdline);
			waitfg(pid);   //等待回收
		}
		else{
			//跟前台运行差不多，只不过不用等待了，通过信号来处理
			addjob(jobs, pid, BG, cmdline);
			struct job_t *job = getjobpid(jobs, pid);
			printf("[%d] (%d) %s", job->jid, pid ,cmdline);
		}
		sigprocmask(SIG_UNBLOCK, &mask, NULL);
	}
}

/* 
 * 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 == ' ')) /* ignore leading spaces */
	buf++;

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

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

	if (*buf == '\'') {
	    buf++;
	    delim = strchr(buf, '\'');
	}
	else {
	    delim = strchr(buf, ' ');
	}
    }
    argv[argc] = NULL;
    
    if (argc == 0)  /* ignore blank line */
	return 1;

    /* 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.  
 */
int builtin_cmd(char **argv) 
{
	if(!strcmp(argv[0], "quit")){
		//退出
		exit(0);
	}
	else if(!strcmp(argv[0], "jobs")){
		//打印jobs
		//因为是读数据，就不阻塞信号了，可能会导致命令显示不对，概率很低，但是你可以再输一次命令，
		listjobs(jobs);
		return 1;
	}
	else if(!strcmp(argv[0], "bg") || !strcmp(argv[0], "fg")){
		//执行bg fg执行
		do_bgfg(argv);
		return 1;
	}
    return 0;     /* not a builtin command */
}

/* 
 * do_bgfg - Execute the builtin bg and fg commands
 */
void do_bgfg(char **argv) 
{
	if(!argv[1]){
		printf("do_bgfg command error\n");
		return;
	}
	pid_t pid;
	int jid;
	//阻塞所有信号
	sigset_t mask, pre_mask;
	sigfillset(&mask);
	sigprocmask(SIG_BLOCK, &mask, &pre_mask);
	struct job_t *job;
	if('%' == argv[1][0]){
		//参数是jobid
		jid = atoi(argv[1] + 1);
		job = getjobjid(jobs, jid);
		if(!job){
			printf("can not find this job\n");
			return;
		}
		pid = job->pid;
	}
	else{
		//参数是pid
		pid = atoi(argv[1]);
		job = getjobpid(jobs, pid);
		if(!job){
			printf("can not find this job\n");
			return;
		}
		jid = job->jid;
	}
	//发送信号
	if(kill(-pid, SIGCONT) < 0){
		printf("send SIGCONT error\n");
		return;
	}
	if(!strcmp(argv[0], "bg")){
		job->state = BG;	
		printf("[%d] (%d) %s", jid, pid, job->cmdline);
	}
	else{
		job->state = FG;
		waitfg(pid);		
	}
	sigprocmask(SIG_SETMASK, &pre_mask, NULL);
}

/* 
 * waitfg - Block until process pid is no longer the foreground process
 */
void waitfg(pid_t pid)
{
	fg_isfinish = 0; //初始化标记
	sigset_t mask;
	sigemptyset(&mask);
	while(!fg_isfinish){
		//没完成就阻塞等到有信号过来再检查一遍
		sigsuspend(&mask); //暂时解除阻塞
	}
}

/*****************
 * 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)
{
    pid_t pid;
    int status;
    while((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0){
        struct job_t *job = getjobpid(jobs, pid);
        if(FG == job->state)
            fg_isfinish = 1;
        if(WIFSIGNALED(status))
            printf("JID [%d] (%d) terminated by signal %d\n", job->jid, pid, SIGINT);
        if(!WIFSTOPPED(status))
            deletejob(jobs, pid);
        else
            job->state = ST;
    }
}

/* 
 * 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.  
 */
void sigint_handler(int sig) 
{
	pid_t pid = fgpid(jobs);
	if(kill(-pid, SIGINT) < 0){
		char *error_str = "sigint_handler: kill fail\n";
		write(STDOUT_FILENO, error_str, strlen(error_str));
	}
	struct job_t *job = getjobpid(jobs, pid);
	printf("JID [%d] (%d) terminated by signal %d\n", job->jid, pid, SIGINT);
}

/*
 * 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.  
 */
void sigtstp_handler(int sig) 
{
	pid_t pid = fgpid(jobs);
	if(kill(-pid, SIGTSTP) < 0){
		char *error_str = "sigtstp_handler: kill fail\n";
		write(STDOUT_FILENO, error_str, strlen(error_str));
	}
	struct job_t *job = getjobpid(jobs, pid);
	job->state = ST;
	fg_isfinish = 1; //使循环退出
	printf("JID [%d] (%d) stopped by signal %d\n", job->jid, pid, SIGTSTP);
}

/*********************
 * End signal handlers
 *********************/

/***********************************************
 * Helper routines that manipulate the job list
 **********************************************/

/* 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 - Returns 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);
	}
    }
}
/******************************
 * end job list helper routines
 ******************************/


/***********************
 * Other helper routines
 ***********************/

/*
 * 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);
}

 

可能哪里没处理好，有错请指出，信号处理难度确实颇高一点。。