哈工大计算机系统实验之TinyShell

进程是一个执行程序中的实例，提供给人一种错觉，即程序好像是系统当前运行的唯一程序，独占处理器和内存，处理器无间断地执行程序中的指令。用户通过shell输入一个可执行目标文件的名字，运行程序时，shell就会创建一个新的进程，然后在这个新进程的上下文中执行这个可执行目标文件。应用程序也能够创建新进程，并且在这个新进程的上下文中运行它们自己的代码或其他应用程序。进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。

创建：

fork函数：父进程调用fork函数创建一个新的运行的子进程，子进程得到和父进程用户及虚拟地址空间完全相同的一个副本。
exec系列：一个进程创建另一个进程，会直接用新进程覆盖原有进程的代码段。
system函数：不常用。

回收：

当一个进程由于某种原因终止时，进程保持在一种已经终止的状态，直到被它的父进程回收，当父进程回收了它的子进程时，内核将子进程的退出状态传递给父进程，然后抛弃已经终止的进程，则该进程就不存在了。其中一个僵死了但未被回收的进程称为僵死进程。
如果一个父进程终止了，内核会安排init进程去回收它的孤儿进程。
使用waitpid函数来等待子进程终止或者停止。

2.2信号的机制、种类（5分）

一个信号就是一条消息，它通知进程系统中发生了一种类型的事件，每种信号类型都对应某种系统的事件，其中信号类型用整数ID来标识，每个信号对应唯一ID。

发送信号：内核通过更新目的进程上下文的某种状态，发送一个信号给目的进程。

接收信号：内核强迫目的进程以某种方式对信号的发送做出反应，即接收。

信号种类：

2.3 信号的发送方法、阻塞方法、处理程序的设置方法（5分）

发送：

用/bin/kill程序可以向另外的进程发送任意的信号。
通过键盘发送信号，如输入Ctrl+C会导致内核发送一个SIGINT信号到前台进程中的每个进程，默认终止前台作业。而输入Ctrl+Z会导致内核发送一个SIGTSTP信号到前台进程中的每个进程，默认挂起前台作业。
用kill函数发送信号给其他进程，包括它们自己。
使用alarm函数在指定secs秒后发送一个SIGALRM信号给调用进程。

阻塞：

隐式阻塞机制：内核默认阻塞任何当前处理程序正在处理信号和待处理信号。
显式阻塞机制：应用程序可以调用sigprocmask函数及其辅助函数来明确地阻塞和解除阻塞选定信号。

设置：

进程可以通过signal函数来修改和信号相关联的默认行为，但SIGSTOP和SIGKILL的默认行为是不能修改的。

signal函数可以通过下列方法来改变和信号signum相关联的行为

handler为SIG_IGN，那么忽略类型为signum的信号
handler为SIG_DFL，那么类型为signum的信号行为恢复为默认行为
否则handler就是用户定义的函数地址，这个函数称为信号处理程序，只要进程接收到一个类型为signum的信号，就会调动这个程序，通过把该函数地址传递到signal函数来改变默认行为，即设置信号处理程序。调用信号处理程序被称为捕获信号，而执行信号处理程序被称为处理程序。

当一个进程捕获一个类型为k的信号时，会调用信号k所设置的处理程序，一个整数参数被设置为k，这个参数允许同一个处理函数去捕获不同类型的信号。

而因为signal的语义各有不同，系统调用可以被中断，定义了sigaction函数，允许用户在设置信号处理时，可以明确地指定想要的信号处理语义。

2.4 什么是shell，简述其功能和处理流程（5分）

shell：是用户使用linux的桥梁，shell既是一种命令语言，又是一种程序设计语言，它是一种应用程序。

功能：提供了一个界面，用户可以通过访问这个界面来访问操作系统内核的服务。

处理流程：

从终端读入输入的命令
将输入字符串切分获得所有的参数、
如果是内置命令，则立即执行
否则调用相应的程序执行
shell应该接收键盘输入信号，并对其进行相应处理

第3章 TinyShell的设计与实现

总分45分

3.1 设计（35分）

3.1.1 void eval(char *cmdline)函数（10分）

函数功能：解析和解释命令行的主例程

参数：char *cmdline

处理流程：

调用parseline函数来将cmdline字符串切分为参数数组argv并返回整数bg来得知该操作是否要在后台运行
调用builtin_cmd函数来判断该命令是否为内置命令，如果是内置命令则立即执行，否则返回
如果不是内置命令则先设置阻塞信号集来阻塞预先识别的信号，防止shell去捕获并处理信号
调用fork函数来创建一个子进程并解锁子进程的阻塞，为子进程设置新的进程组ID来避免父进程接收到的控制信号影响到子进程，在子进程中调用execve函数来执行命令行指定的程序
父进程将新的子进程添加到任务列表中，并解除之前阻塞的信号
判断任务如果不是后台任务，则等待其完成，否则打印相关信息

要点分析：

将命令行的处理进行封装
阻塞shell的预识别信号，防止shell捕获并处理，避免竞争
父进程记录了addjob后解除阻塞，在阻塞期间未处理的SIGCHLD信号在此时被处理，同时在任务列表中被删除，避免了竞争
Ctrl+C会给shell下的前台进程组中所有进程发送SIGINT信号，这将包括tsh和tsh所创建的进程，这是需要解决的问题

可以考虑如下方法：

①在fork和execve之间，子进程通过setpgid(0,0)来将自己放到一个新的进程组中，即把自己所在的进程组ID设置为自己的ID。这样在前台进程组只有一个进程tsh

②当输入Ctrl+C后，shell将捕获SIGINT并转发给tsh，当tsh收到SIGINT后

会转发给特定的前台作业的进程组

3. 1.2 int builtin_cmd(char **argv)函数（5分）

函数功能：识别并解释内置命令：quit，fg，bg，jobs

参数：char **argv

处理流程：

通过一些if判断语句来确定是否为内置命令，如果是内置命令则运行相应函数并返回1，特殊的是quit则不用返回，如果非内置命令则返回0

要点分析：

使用函数模块化的思想

3. 1.3 void do_bgfg(char **argv) 函数（5分）

函数功能：实现内置命令bg和fg

参数：char **argv

处理流程：

首先判断是否有参数输入，没有的话直接输出提示信息并返回。有参数的话接着判断输入的是PID还是%JID，无论哪种都要在jobs中查询，在过程中出现问题则输出提示信息并返回。接下来匹配是后台运行还是前台运行，如果是后台运行，则向job所在的进程组发送SIGCONT信号，更改job的state为bg，如果是前台运行，则向job所在进程组发送SIGCONT信号，更改job的state为fg，然后等待当前的程序运行，直到当前的job不再是前台程序

要点分析：

区分传入的是PID还是%JID，按照bg和fg的特性来发送信号使得程序持续运行，fg需要将目标程序在前台运行，调用waitfg来等待程序终止

3. 1.4 void waitfg(pid_t pid) 函数（5分）

函数功能：等待一个前台作业结束

参数：pid_t pid

处理流程：

调用fgpid函数来判断所给进程是否结束，使用sigsuspend函数，不阻塞任何信号。

要点分析：

跳出循环的方式为通过fgpid来检测是否进程结束

3. 1.5 void sigchld_handler(int sig) 函数（10分）

函数功能：捕获SIGCHLD信号

参数：int sig

处理流程：

保存errno来防止过程中的改变影响进程上下文的运行，使用循环回收所有的子进程，防止僵死，对waitpid返回的情况匹配，如果正常退出则删除子任务，如果是未被捕获的信号终止，则输出提示信息并删除，最后恢复errno

要点分析：

使用循环来确保所有子进程回收，在删除子任务时时要阻塞所有信号，防止对进程的影响，防止调用去修改errno，在开始时保存，在结束时恢复

3.2 程序实现（tsh.c的全部内容）（10分）

重点检查代码风格：

用较好的代码注释说明——5分
检查每个系统调用的返回值——5分

/*
* tsh - A tiny shell program with job control
* <Put your name and login ID here>
*/
#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 */
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)
{
/* $begin handout */
char *argv[MAXARGS]; /* argv for execve() */
int bg; /* should the job run in bg or fg? */
pid_t pid; /* process id */
sigset_t mask; /* signal mask */
/* Parse command line */
bg = parseline(cmdline, argv);
if (argv[0] == NULL)
return; /* ignore empty lines */
if (!builtin_cmd(argv))
{
/*
* This is a little tricky. Block SIGCHLD, SIGINT, and SIGTSTP
* signals until we can add the job to the job list. This
* eliminates some nasty races between adding a job to the job
* list and the arrival of SIGCHLD, SIGINT, and SIGTSTP signals.
*/
if (sigemptyset(&mask) < 0)
unix_error("sigemptyset error");
if (sigaddset(&mask, SIGCHLD))
unix_error("sigaddset error");
if (sigaddset(&mask, SIGINT))
unix_error("sigaddset error");
if (sigaddset(&mask, SIGTSTP))
unix_error("sigaddset error");
if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0)
unix_error("sigprocmask error");
/* Create a child process */
if ((pid = fork()) < 0)
unix_error("fork error");
/*
* Child process
*/
if (pid == 0)
{
/* Child unblocks signals */
sigprocmask(SIG_UNBLOCK, &mask, NULL);
/* Each new job must get a new process group ID
so that the kernel doesn't send ctrl-c and ctrl-z
signals to all of the shell's jobs */
if (setpgid(0, 0) < 0)
unix_error("setpgid error");
/* Now load and run the program in the new job */
if (execve(argv[0], argv, environ) < 0)
{
printf("%s: Command not found\n", argv[0]);
exit(0);
}
}
/*
* Parent process
*/
/* Parent adds the job, and then unblocks signals so that
the signals handlers can run again */
addjob(jobs, pid, (bg == 1 ? BG : FG), cmdline);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
if (!bg)
waitfg(pid);
else
printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
}
/* $end handout */
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 == ' ')) /* 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)
{
/**
*判断是否是内置命令，如果是，执行并返回1；如果不是，返回0。
*/
if (!strcmp(argv[0], "quit"))
exit(0);
if (!strcmp(argv[0], "&"))
return 1;
if (!strcmp(argv[0], "fg") || !strcmp(argv[0], "bg"))
{
do_bgfg(argv);
return 1;
}
if (!strcmp(argv[0], "jobs"))
{
listjobs(jobs);
return 1;
}
return 0; /* not a builtin command */
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
/* $begin handout */
struct job_t *jobp = NULL;
/* Ignore command if no argument */
if (argv[1] == NULL)
{
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
/* Parse the required PID or %JID arg */
if (isdigit(argv[1][0]))
{
pid_t pid = atoi(argv[1]);
if (!(jobp = getjobpid(jobs, pid)))
{
printf("(%d): No such process\n", pid);
return;
}
}
else if (argv[1][0] == '%')
{
int jid = atoi(&argv[1][1]);
if (!(jobp = getjobjid(jobs, jid)))
{
printf("%s: No such job\n", argv[1]);
return;
}
}
else
{
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
/* bg command */
if (!strcmp(argv[0], "bg"))
{
if (kill(-(jobp->pid), SIGCONT) < 0)
unix_error("kill (bg) error");
jobp->state = BG;
printf("[%d] (%d) %s", jobp->jid, jobp->pid, jobp->cmdline);
}
/* fg command */
else if (!strcmp(argv[0], "fg"))
{
if (kill(-(jobp->pid), SIGCONT) < 0)
unix_error("kill (fg) error");
jobp->state = FG;
waitfg(jobp->pid);
}
else
{
printf("do_bgfg: Internal error\n");
exit(0);
}
/* $end handout */
return;
}
/*
* waitfg - Block until process pid is no longer the foreground process
*/
void waitfg(pid_t pid)
{
sigset_t mask, prev;
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_SETMASK, &mask, &prev);
while (fgpid(jobs) == pid)
sigsuspend(&prev);
sigprocmask(SIG_SETMASK, &prev, NULL);
return;
}
/*****************
* 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)
{
//记录下errno 防止在信号处理过程中调用函数出错而产生errno变化
int olderrno = errno;
int status;
sigset_t mask_all, prev_all;
pid_t pid;
sigfillset(&mask_all);
/*
循环回收所有僵死进程并显示导致退出的情况
其中WNOHANG | WUNTRACED表示立即返回，如果等待集合中的子进程都没有停止则返回0，否则返回PID
*/
while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0)
{
if (WIFEXITED(status))
{ //子进程通过调用exit或者一个返回正常终止
sigprocmask(SIG_BLOCK, &mask_all, &prev_all); //阻塞所有的信号
deletejob(jobs, pid); //在任务列表中删除任务
sigprocmask(SIG_SETMASK, &prev_all, NULL); //解除阻塞
}
//子进程是因为一个未被捕获的信号终止的
if (WIFSIGNALED(status))
{
printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, WTERMSIG(status));
sigprocmask(SIG_BLOCK, &mask_all, &prev_all);
deletejob(jobs, pid); //在任务列表中删除任务
sigprocmask(SIG_SETMASK, &prev_all, NULL);
}
}
errno = olderrno;
return;
}
/*
* 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)
{
int olderrno = errno; //保存errno
pid_t pid = fgpid(jobs);
if (pid == 0)
{
return;
}
//向处于foreground正在运行的进程所处的进程组发送SIGINT
kill(-pid, SIGINT);
errno = olderrno;
return;
}
/*
* 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)
{
int olderrno = errno; //保存errno
pid_t pid = fgpid(jobs);
if (pid == 0)
return;
//设置state为ST
getjobpid(jobs, pid)->state = ST;
kill(-pid, SIGTSTP);
printf("Job [%d] (%d) stopped by signal %d\n", pid2jid(pid), pid, sig);
errno = olderrno;
return;
}
/*********************
* 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);
}

第4章 TinyShell测试

总分15分

4.1 测试方法

针对tsh和参考shell程序tshref，完成测试项目4.1-4.15的对比测试，并将测试结果截图或者通过重定向保存到文本文件(例如：./sdriver.pl -t trace01.txt -s ./tsh -a "-p" > tshresult01.txt)。

4.2 测试结果评价

tsh与tshref的输出在一下两个方面可以不同：

（1）PID

（2）测试文件trace11.txt, trace12.txt和trace13.txt中的/bin/ps命令，每次运行的输出都会不同，但每个mysplit进程的运行状态应该相同。

除了上述两方面允许的差异，tsh与tshref的输出相同则判为正确，如不同则给出原因分析。

4.3 自测试结果(15分）

4.3.1测试用例trace01.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.2测试用例trace02.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.3测试用例trace03.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.4测试用例trace04.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.5测试用例trace05.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.6测试用例trace06.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.7测试用例trace07.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.8测试用例trace08.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.9测试用例trace09.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.10测试用例trace10.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.11测试用例trace11.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.12测试用例trace12.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.13测试用例trace13.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.14测试用例trace14.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.3.15测试用例trace15.txt的输出截图（1分）

tsh测试结果		tshref测试结果

测试结论	相同

4.4 自测试评分

根据节4.3的自测试结果，程序的测试评分为： 15 。

第4章总结

4.1 请总结本次实验的收获

在本次实验中，我可以体验和利用一些之前只在课堂讲过的函数，这使得我对进程有了更明确的了解，我认为这门课设计的非常完美，每次实验课都会之前学过的理论知识加以应用。

4.2 请给出对本次实验内容的建议

暂无

注：本章为酌情加分项。

参考文献

为完成本次实验你翻阅的书籍与网站等

[1] 林来兴. 空间控制技术[M]. 北京：中国宇航出版社，1992：25-42.

[2] 辛希孟. 信息技术与信息服务国际研讨会论文集：A集[C]. 北京：中国科学出版社，1999.

[3] 赵耀东. 新时代的工业工程师[M/OL]. 台北：天下文化出版社，1998 [1998-09-26]. http://www.ie.nthu.edu.tw/info/ie.newie.htm（Big5）.

[4] 谌颖. 空间交会控制理论与方法研究[D]. 哈尔滨：哈尔滨工业大学，1992：8-13.

[5] KANAMORI H. Shaking Without Quaking[J]. Science，1998，279（5359）：2063-2064.

[6] CHRISTINE M. Plant Physiology: Plant Biology in the Genome Era[J/OL]. Science，1998，281：331-332[1998-09-23]. http://www.sciencemag.org/cgi/ collection/anatmorp.