Shell_Lab
前言：
这个实验如果是认认真真去做的话还是挺有难度的，完完全全把代码写出来感觉不是很现实，我个人建议是只要把代码的逻辑和思路看懂了就行，代码的话复制一下大佬的就好。
这篇文章是我实验报告的一部分，这篇文章不是从16个test或是要补充的7个函数入手的，主要思路是从main函数开始讲完整个tsh.c文件的逻辑。对这个实验无从下手、没有思路的同学可以参考一下，建议是一边放源码，一边放报告来看。至于验收的话，我们湖大的助教们都是很好说话的，你让他同意按照你自己的思路来讲完全没有问题。
tsh.c文件的内容我放在最后了。
一、实验目的
完善文件夹中tsh.c文件中的7个函数，实现一个支持任务功能的shell。
二、实验准备
要实现的七个函数如下：
void eval(char *cmdline);//解析命令(大概一个预处理的样子)
int builtin_cmd(char **argv);//解析和执行bulidin命令，包括quit,fg,bg,jobs
void do_bgfg(char **argv);//执行bg和fg操作
void waitfg(pid_t pid);//实现阻塞等待前台程序运行结束
void sigchld_handler(int sig);//SIGCHID信号处理函数
void sigtstp_handler(int sig);//响应 SIGINT (ctrl-c) 信号
void sigint_handler(int sig);//响应 SIGTSTP (ctrl-z) 信号
同时tsh.c中还提供了许多已经完善好的函数供我们使用：
//获取参数列表，判断是否为后台运行命令,将结果返还给eval函数。
int parseline(const char *cmdline, char **argv);
//处理SIGQUIT信号
void sigquit_handler(int sig);
//清除job结构体（全部置零）
void clearjob(struct job_t *job);
初始化任务列表jobs[]
void initjobs(struct job_t *jobs);
//返回jobs链表中最大的jid号
int maxjid(struct job_t *jobs);
//向任务列表添加一个任务
int addjob(struct job_t *jobs, pid_t pid, int state, char *cmdline);
//从任务列表中删除指定pid的任务
int deletejob(struct job_t *jobs, pid_t pid);
//返回当前前台运行job的pid号
pid_t fgpid(struct job_t *jobs);
//根据pid找到对应的job
struct job_t *getjobpid(struct job_t *jobs, pid_t pid);
//根据jid找到对应的job
struct job_t *getjobjid(struct job_t *jobs, int jid);
//根据pid找到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);
//sig***_hander函数的包装
handler_t *Signal(int signum, handler_t *handler);
接着tsh.c中还定义了一些其他内容：
宏：
/* 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 */
全局变量：
/* 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 */
job_t的任务的类，并且创建了jobs[]数组：
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 */
实验的具体操作流程：
编写完善tsh.c中的7个函数，执行make指令编译tsh.c得到可执行文件tsh。然后执行make rtest01和make test01进行比对，如果我们的执行结果与参考结果一致，则实现正确。我们的任务是通过所有16个test(test的内容见trace.txt)。
接着了解一下测试文件中（trace.txt）符号和命令的定义：
符号：
空格：分隔指令作用
&：如果命令以&结尾，表示标该作业在后台运行
#：直接打印#后一行的文本内容
%：后接一个整数，表示job的ID号。
命令：
jobs: 列出正在运行和停止的后台作业
bg <job>: 将停止的后台作业更改为正在运行的后台作业
fg <job>:将已停止或正在运行的后台作业更改为前台正在运行的作业
kill : 终止一个作业
用户程序：
myint程序：函数睡眠，使程序睡眠n秒，运行结束后不会自动退出，并会检测系统错误；
myspin程序：函数睡眠，使程序睡眠n秒，在睡眠结束后就自动退出，不检测系统错误；
mysplit程序：函数睡眠，使程序睡眠n秒，创建一个子进程进行睡眠，然后父进程等待子进程正常睡眠n秒后，继续运行；
mystop程序：让进程暂定n秒，并发送信号。
三、整体分析
根据我们填写的代码，我们能够得出下面的函数调用关系图：
接着，我们按着上面的流程图理一下程序是怎样运行的。
首先看到main函数部分
main函数的前面是在进行一些初始化的操作，不用管。接着是一个while循环，读取./tsh命令后的选项，并根据选项打印帮助信息或者设置全局变量verbose的值（是否打印信息）和局部变量emit_prompt（发出提示）的值。
接着main函数调用了4个signal函数:
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);
这些函数我们之后再讲，这里是安装信号处理函数。接着main函数调用initjobs函数，完成初始化任务列表的工作。initjobs函数不再详细分析。
接着进入一个while循环，这里就相当于已经进入了我们的tsh终端（shell），表示 Shell 的读取和执行命令的过程。第一个if就是打印tsh>这一行标志shell的提示并刷新输出缓冲区。
第二个if使用fgets函数从标准输入读取一行命令，并将其存储在 cmdline 数组中。
第三个if检查输入是否结束（Ctrl+D），如果是，则退出程序。
然后调用eval函数来解析和执行命令行。
刷新标准输出缓冲区，继续读取和执行下一个命令。
总的看来，main函数最重要的操作就是读取shell中的一行命令，并将其存储在 cmdline 数组中。之后调用了eval函数。
我们看到eval函数
eavl函数在完成一些初始化的操作后就立即调用了parseline函数，下面是parseline的具体代码：
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;
}
这里parseline传入的参数是我们获取的一行命令以及argv数组，用于存储分割处理的命令。
首先将传入的命令行复制到buf中，即将命令行存储在本地副本中。然后将 buf中的换行符替换为空格，以便后续处理。接着忽略前导空格，即跳过命令行开头的空格。
将参数计数器 argc 初始化为0。判断命令行是否以单引号开头。如果是，则将 buf向后移动一位，并使用 strchr函数查找下一个单引号位置，赋值给 delim。如果不是，则使用 strchr函数查找下一个空格位置，赋值给 delim。
while (delim)循环解析命令行，直到没有分隔符（空格或单引号）为止。
- 将 buf存储在argv中，并增加 argc的计数器。
- 将 delim设置为字符串结束符 \0，截断当前参数。
- 将 buf 指向delim的下一个字符，并跳过后续的空格。
argv[argc] = NULL;在参数列表的末尾添加一个空指针，表示参数的结束。
如果参数个数为0，表示输入的是空行，忽略处理，返回1。
检查最后一个参数是否为&，判断命令是否应该在后台运行。如果是，则将 bg 标志位置为1，表示应该在后台运行，并将最后一个参数设置为NULL。如果不是，则将 bg 标志位置为0。最后返回 bg，表示命令是否应该在后台运行。
简而言之，parseline这个函数的作用是判断传入进来的命令是否应该在后台运行，如果是就返回1，不是就返回0。并且完成了argv数组的填充，argv数组的内容是分割处理后的命令。例如：传入的命令是./myspin 1 &。那么argv数组第一项的内容是./myspin，第二项是1，第三项是&。
回到eval函数，调用完parseline函数后我们就已经设置好了当前命令的状态（否是在后台运行），并且拿到了argv数组的内容。
接着eval函数调用了builtin_cmd函数，这个函数是用来判断我们输入的命令是不是内置命令。
如果不是我们就进入if判断创建子进程执行命令，并调用addjob将当前进程添加进job中（无论是前台进程还是后台进程）和waitfg判断子进程类型并做处理；
如果是就直接在builtin_cmd中完成处理。
完成处理后envl函数return回到main函数，刷新输出缓冲区，继续读取和执行下一个命令。
接着我们来看命令不是内置命令的情况，即eval函数进入if判断。
接下来的3行if需要在fork前，将相关信号阻塞，防止并发错误竞争的发生。
首先，使用sigemptyset函数初始化信号集set。
然后使用 sigaddset 函数将 SIGINT、SIGTSTP 和 SIGCHLD 信号添加到 set中。
使用 sigprocmask 函数将 set中的信号阻塞，以防止并发错误竞争。
然后我们才使用fork创建子进程来执行命令。
接下来的if就是子进程要执行的内容：由于fork出来的子进程和父进程是完全一致的，于是我们调用execve加载并执行命令行参数，这样就算是在真正创建一个子进程执行非内置命令。接下来调用addjob函数将当前的子进程加入任务列表中（无论是前台进程还是后台进程）。
但存在一个问题：当从bash运行tsh时，tsh在bash前台进程组中运行，如果tsh随后创建了一个子进程，默认情况下，该子进程也将是bash前台进程组的成员。由于输入ctrl-c将向bash前台组中的每个进程发送一个SIGINT，因此输入ctrl-c将向tsh以及tsh创建的每个进程发送一个SIGINT，这显然是不正确的，我们输入的SIGINT信号不该作用于父进程（tsh），而应该只作用于子进程。
这里有一个解决方案:在fork之后，但在execve之前，子进程调用setpgid(0,0)，这将把子进程放入一个新的进程组中，该进程组的ID与子进程的PID相同。确保bash前台进程组中只有一个进程，即tsh进程。当键入ctrl-c时，tsh应该捕获结果SIGINT，然后将其转发到适当的前台作业(我们的子进程)。
if后的addjob就是父进程要执行的内容了，而子进程无法执行。因为子进程使用execve后加载了具体的执行方案（？），这将覆盖掉继承自父进程的设定，其中包括set中的信号阻塞以及调用addjob。完成addjob后，父进程才能够恢复恢复受阻塞的信号 SIGINT SIGTSTP SIGCHLD，这是为了防止父进程还没将子进程加进任务列表，子进程就完成了执行并返还了一个结束的信号，否则会引发错误。
如果子进程是前台进程，最后由父进程调用waitfg函数，作用是等待前台进程运行完毕。waitfg函数的具体代码如下：
void waitfg(pid_t pid)
{
struct job_t *job = getjobpid(jobs, pid);
if (!job)
return;
// 如果当前子进程的状态没有发生改变，则tsh继续休眠
while (job->state == FG)
// 使用sleep的这段代码会比较慢，最好使用sigsuspend
sleep(1);
if (verbose)
printf("waitfg: Process (%d) no longer the fg process\n", pid);
return;
}
waitfg函数传入的参数是子进程的pid，这里又调用了getjobpid，功能是根据pid找到对应的job，也就是我们处在任务列表中的子进程，如果子进程的状态没有发生改变，则tsh继续休眠（先睡一秒看看子进程状态变量没，没变接着睡一秒），睡醒了就打印信息说一下进程结束了，这时从waitfg回到eval再回到main，意味着我们在tsh中输入的那一条命令处理结束了（于前台进程执行的非内置命令）。刷新输出缓冲区，继续读取和执行下一个命令。
这里还要说明一下，这里的前台进程并不是tsh，我们做的只是让tsh睡眠，然后让子进程伪装成前台进程。
如果子进程是后台进程，最后由父进程调用 pid2jid函数，作用是根据进程的pid找到jid。waitfg函数的具体代码如下：
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;
}
这时tsh打印这个进程的相关信息后，我们从eval再回到main，意味着我们在tsh中输入的那一条命令的处理结束了（于后台进程执行的非内置命令）。
这里还要说明一下，这里只是把子进程隐藏到了后台，让tsh变得可用，并不意味着这个进程就执行完毕了。
前面我们分析了不是内置命令的情况，接下来我们来分析是内置命令的情况，即eval函数进入builtin_cmd直接处理。
如果是内置命令（quit/bg/fg/jobs），我们直接跳到builtin_cmd函数处理，builtin_cmd的具体代码如下：
int builtin_cmd(char **argv)
{
if (!strcmp(argv[0], "quit"))
exit(0);
else if (!strcmp(argv[0], "bg") || !strcmp(argv[0], "fg"))
do_bgfg(argv);
else if (!strcmp(argv[0], "jobs"))
listjobs(jobs);
else
return 0; /* not a builtin command */
return 1;
}
如果输入的命令是quit，直接结束这个子进程，于是我们又回到经典的eval再回到main。
如果输入的命令是jobs，我们直接调用listjobs函数来打印任务列表。这里就不对listjobs函数进行详细分析了。
如果输入的命令是bg或者fg（bg：将停止的后台作业更改为正在运行的后台作业
fg :将已停止或正在运行的后台作业更改为前台正在运行的作业），我们调用do_bgfg函数来处理。do_bgfg函数的具体实现如下：
void do_bgfg(char **argv)
{
int parsed;
struct job_t *job;
// 没有参数的fg/bg应该被丢弃
if (!argv[1])
{
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
// 检测fg/bg参数，其中%开头的数字是JobID，纯数字的是PID
if (argv[1][0] == '%')
{
if ((parsed = strtol(&argv[1][1], NULL, 10)) <= 0)
{
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
if ((job = getjobjid(jobs, parsed)) == NULL)
{
printf("%%%d: No such job\n", parsed);
return;
}
}
else
{
if ((parsed = strtol(argv[1], NULL, 10)) <= 0)
{
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
if ((job = getjobpid(jobs, parsed)) == NULL)
{
printf("(%d): No such process\n", parsed);
return;
}
}
if (!strcmp(argv[0], "bg"))
{
// bg会启动子进程，并将其放置于后台执行
job->state = BG;
if (kill(-job->pid, SIGCONT) < 0)
unix_error("kill error");
printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
}
else if (!strcmp(argv[0], "fg"))
{
job->state = FG;
if (kill(-job->pid, SIGCONT) < 0)
unix_error("kill error");
// 当一个进程被设置为前台执行时，当前tsh应该等待该子进程结束
waitfg(job->pid);
}
else
{
puts("do_bgfg: Internal error");
exit(0);
}
return;
}
首先我们丢弃没有参数的fg/bg命令。然后检测fg/bg参数，其中%开头的数字是jid，纯数字的是pid，并参数中的数字部分解析为整数 parsed，如果通过pid无法找到对应的任务，则输出错误信息并返回。
然后我们需要根据命令是 bg 还是 fg 进行不同的处理：
如果是 bg 命令：
- 将作业状态设置为后台执行（bg）。
- 使用 kill 函数发送 SIGCONT 信号给任务的进程组（我们的子进程），以使其恢复执行。
- 输出作业的信息（jid、pid、命令）。
同之前分析的差不多，这里也是子进程（于后台进程执行的内置命令）隐藏到了后台，让tsh变得可用，并不意味着这个进程就执行完毕了。
如果是 fg 命令：
- 将作业状态设置为前台执行（fg）。
- 使用 kill函数发送 SIGCONT信号给任务的进程组（我们的子进程），以使其恢复执行。
- 调用 waitfg 函数等待前台作业完成。
关于我们的waitfg函数前面已经分析过了。在这里我们同样也是等待进程结束（于前台进程执行的内置命令），一旦进程结束，我们就从waitfg回到do_bgfg再回到builtin_cmd再回到eval最后回到main(很他妈牛逼)，然后就是经典的刷新输出缓冲区，继续读取和执行下一个命令。
如果命令既不是 bg 也不是 fg，则输出错误信息并退出。
至此，我们的主线任务就已经全部完成了，然后我们开始支线任务：信号处理
首先是我们的SIGCHILD信号，处理这个信号的函数是sigchld_handler。
这个信号在进程回收子进程的过程中出现：当一个子进程终止或者停止时，内核会发送一个SIGCHLD信号给父进程。因此父进程必须回收子进程，以避免在系统中留下僵死进程。父进程捕获这个SIGCHLD信号，回收一个子进程。一个进程可以通过调用 waitpid 函数来等待它的子进程终止或者停止。如果回收成功，则返回为子进程的 PID, 如果 WNOHANG, 则返回为 0, 如果其他错误，则为 -1。
下面是sigchld_handler函数的具体实现：
void sigchld_handler(int sig)
{
int status, jid;
pid_t pid;
struct job_t *job;
if (verbose)
puts("sigchld_handler: entering");
/*
以非阻塞方式等待所有子进程
waitpid 参数3：
1. 0 ： 执行waitpid时， 只有在子进程 **终止** 时才会返回。
2. WNOHANG : 若子进程仍然在运行，则返回0 。
注意只有设置了这个标志，waitpid才有可能返回0
3. WUNTRACED : 如果子进程由于传递信号而停止，则马上返回。
只有设置了这个标志，waitpid返回时，其WIFSTOPPED(status)才有可能返回true
*/
while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0)
{
// 如果当前这个子进程的job已经删除了，则表示有错误发生
if ((job = getjobpid(jobs, pid)) == NULL)
{
printf("Lost track of (%d)\n", pid);
return;
}
jid = job->jid;
// 如果这个子进程收到了一个暂停信号（还没退出
if (WIFSTOPPED(status))
{
printf("Job [%d] (%d) stopped by signal %d\n", jid, job->pid, WSTOPSIG(status));
job->state = ST;
}
// 如果这个子进程正常退出
else if (WIFEXITED(status))
{
if (deletejob(jobs, pid))
if (verbose)
{
printf("sigchld_handler: Job [%d] (%d) deleted\n", jid, pid);
printf("sigchld_handler: Job [%d] (%d) terminates OK (status %d)\n", jid, pid, WEXITSTATUS(status));
}
}
// 如果这个子进程因为其他的信号而异常退出，例如SIGKILL
else
{
if (deletejob(jobs, pid))
{
if (verbose)
printf("sigchld_handler: Job [%d] (%d) deleted\n", jid, pid);
}
printf("Job [%d] (%d) terminated by signal %d\n", jid, pid, WTERMSIG(status));
}
}
if (verbose)
puts("sigchld_handler: exiting");
return;
}
这个函数一开始的还是一些初始化的操作，打印调试信息。
接着使用 waitpid 函数以非阻塞方式等待所有子进程的状态变化：
- -1 表示等待任何子进程。
- 使用
WNOHANG标志告诉 waitpid 在没有可用子进程状态时立即返回。 - 使用
WUNTRACED标志告诉 waitpid 在子进程由于接收到信号而停止时立即返回。
那么这里的意思大概是是等待所有子进程，直到子进程结束。
然后进入循环，处理等待到的子进程：
- 如果 waitpid 返回的进程ID小于等于0，则表示没有更多的子进程需要处理，跳出循环。
- 如果通过进程ID无法找到对应的任务信息，则输出错误信息，并返回。
- 获取任务的 jid。
- 如果子进程收到了一个暂停信号（还没有退出）：
- 输出作业暂停的信息，包括作业ID、进程ID和接收到的信号。
- 将作业状态设置为停止（ST）。
- 如果子进程正常退出：
- 删除作业，并根据设置的 verbose 标志输出调试信息。
- 如果子进程因其他信号异常退出：
- 删除作业，并输出作业终止的信息，包括作业ID、进程ID和终止的信号。
接下来来看我们的SIGINT(ctrl-c)信号，处理这个信号的函数是sigint_handler。
我们在前面提到过这样一个问题：
当从bash运行tsh时，tsh在bash前台进程组中运行，如果tsh随后创建了一个子进程，默认情况下，该子进程也将是bash前台进程组的成员。由于输入ctrl-c将向bash前台组中的每个进程发送一个SIGINT，因此输入ctrl-c将向tsh以及tsh创建的每个进程发送一个SIGINT，这显然是不正确的，我们输入的SIGINT信号不该作用于父进程（tsh），而应该只作用于子进程。
也说到了对应的解决方案：
在fork之后，但在execve之前，子进程调用setpgid(0,0)，这将把子进程放入一个新的进程组中，该进程组的ID与子进程的PID相同。确保bash前台进程组中只有一个进程，即tsh进程。当键入ctrl-c时，tsh应该捕获结果SIGINT，然后将其转发到适当的前台作业(我们的子进程)。
这里我们要实现的sigint_handler函数就是： ‘tsh应该捕获结果SIGINT，然后将其转发到适当的前台作业’ 这一个过程。
sigint_handler函数的具体实现如下：
void sigint_handler(int sig)
{
if (verbose)
puts("sigint_handler: entering");
pid_t pid = fgpid(jobs);
if (pid)
{
// 发送SIGINT给前台进程组里的所有进程
// 需要注意的是，前台进程组内的进程除了当前前台进程以外，还包括前台进程的子进程。
// 最多只能存在一个前台进程，但前台进程组内可以存在多个进程
if (kill(-pid, SIGINT) < 0)
unix_error("kill (sigint) error");
if (verbose)
{
printf("sigint_handler: Job (%d) killed\n", pid);
}
}
if (verbose)
puts("sigint_handler: exiting");
return;
}
首先输出调试信息，并使用 fgpid 函数获取当前前台任务的pid。
如果 pid 不为0，表示存在前台作业（前台进程组）：
- 使用 kill 函数向前台进程组中的所有进程发送 SIGINT 信号。
- 通过传递负的进程ID参数 -pid，将信号发送给进程组中的所有进程。
- 如果 kill 函数返回值小于0，则表示发送信号失败，输出错误信息。
- 如果设置了verbose标志，输出调试信息：被杀死的作业的进程ID。
最后打印"sigint_handler: exiting"，提一嘴这个SIGINT 信号已经处理完毕。
我们来看一个例子：如果我们的父进程(tsh)收到了一个ctrl-c的信号，父进程会将这个信号转给子进程，子进程收到这个信号后子进程所在的进程组的所有进程都会被终止，相当于父进程诛连了子进程九族（？按常理来说，父亲应该是在九族中的），然后子进程被自杀（？其实是终止或者停止）时，子进程通过内核给父进程发送一个SIGCHLD信号，然后就跳到我们的sigchld_handler函数，父进程要对子进程进行一些处理了。首先父进程要判断等待处理的子进程的状态，这里我们的子进程是被暂停了，sigchld_handler中就会打印提示信息说该任务被暂停了，随后将子进程的状态设置成stopped(ST)。
如果子进程不是被暂停了，而是运行结束或者运行出错了，那么在上面的基础上，sigchld_handler还会调用deletejob删除子进程的任务。
最后是我们的SIGTSTP(ctrl-z)信号，处理这个信号的函数是sigtstp_handler。
SIGTSTP的作用：SIGTSPT信号默认行为是停止直到下一个 SIGCONT，是来自终端的停止信号，在键盘上输入 CTR+Z会导致一个 SIGTSPT信号被发送到外壳。外壳捕获该信号，然后发送SIGTSPT信号到这个前台进程组中的每个进程。在默认情况下，结果是停止或挂起前台作业。下面是sigtstp_handler函数的具体实现：
void sigtstp_handler(int sig)
{
if (verbose)
puts("sigstp_handler: entering");
pid_t pid = fgpid(jobs);
struct job_t *job = getjobpid(jobs, pid);
if (pid)
{
if (kill(-pid, SIGTSTP) < 0)
unix_error("kill (tstp) error");
if (verbose)
{
printf("sigstp_handler: Job [%d] (%d) stopped\n", job->jid, pid);
}
}
if (verbose)
puts("sigstp_handler: exiting");
return;
}
其实sigtstp_handler和sigint_handler的具体组成完全可以说是一模一样，唯一的区别就是调用kill函数时的参数，sigtstp_handler中kill的参数是SIGTSTP，完成将SIGTSTP信号传给父进程（tsh）。接下来的步骤就和上面一样了，父进程把信号传给子进程，子进程作出反应后把信号传给父进程，父进程处理子进程，结束。
以上就是信号处理的全部部分了，也算是把tsh.c文件完整地过了一遍。
设置成stopped(ST)。
如果子进程不是被暂停了，而是运行结束或者运行出错了，那么在上面的基础上，sigchld_handler还会调用deletejob删除子进程的任务。
最后是我们的SIGTSTP(ctrl-z)信号，处理这个信号的函数是sigtstp_handler。
SIGTSTP的作用：SIGTSPT信号默认行为是停止直到下一个 SIGCONT，是来自终端的停止信号，在键盘上输入 CTR+Z会导致一个 SIGTSPT信号被发送到外壳。外壳捕获该信号，然后发送SIGTSPT信号到这个前台进程组中的每个进程。在默认情况下，结果是停止或挂起前台作业。下面是sigtstp_handler函数的具体实现：
void sigtstp_handler(int sig)
{
if (verbose)
puts("sigstp_handler: entering");
pid_t pid = fgpid(jobs);
struct job_t *job = getjobpid(jobs, pid);
if (pid)
{
if (kill(-pid, SIGTSTP) < 0)
unix_error("kill (tstp) error");
if (verbose)
{
printf("sigstp_handler: Job [%d] (%d) stopped\n", job->jid, pid);
}
}
if (verbose)
puts("sigstp_handler: exiting");
return;
}
其实sigtstp_handler和sigint_handler的具体组成完全可以说是一模一样，唯一的区别就是调用kill函数时的参数，sigtstp_handler中kill的参数是SIGTSTP，完成将SIGTSTP信号传给父进程（tsh）。接下来的步骤就和上面一样了，父进程把信号传给子进程，子进程作出反应后把信号传给父进程，父进程处理子进程，结束。
以上就是信号处理的全部部分了，也算是把tsh.c文件完整地过了一遍。
tsh.c的内容：
/*
* 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 <setjmp.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)
{
char *argv[MAXARGS];
int state = UNDEF;
sigset_t set;
pid_t pid;
// 处理输入的数据
if (parseline(cmdline, argv) == 1)
state = BG;
else
state = FG;
if (argv[0] == NULL)
return;
// 如果不是内置命令
if (!builtin_cmd(argv))
{
if (sigemptyset(&set) < 0)
unix_error("sigemptyset error");
if (sigaddset(&set, SIGINT) < 0 || sigaddset(&set, SIGTSTP) < 0 || sigaddset(&set, SIGCHLD) < 0)
unix_error("sigaddset error");
// 在fork前，将SIGCHLD信号阻塞，防止并发错误竞争的发生
if (sigprocmask(SIG_BLOCK, &set, NULL) < 0)
unix_error("sigprocmask error");
if ((pid = fork()) < 0)
unix_error("fork error");
else if (pid == 0)
{
/* 把新建立的进程添加到新的进程组:
当从bash运行tsh时，tsh在bash前台进程组中运行。
如果tsh随后创建了一个子进程，默认情况下，该子进程也将是bash前台进程组的成员。
由于输入ctrl-c将向bash前台组中的每个进程发送一个SIGINT，
因此输入ctrl-c将向tsh以及tsh创建的每个进程发送一个SIGINT，这显然是不正确的。
这里有一个解决方案:在fork之后，但在execve之前，子进程应该调用setpgid(0,0)，
这将把子进程放入一个新的进程组中，该进程组的ID与子进程的PID相同。
这确保bash前台进程组中只有一个进程，即tsh进程。
当键入ctrl-c时，tsh应该捕获结果SIGINT，然后将其转发到适当的前台作业
*/
// 子进程的控制流开始
if (sigprocmask(SIG_UNBLOCK, &set, NULL) < 0)
unix_error("sigprocmask error");
if (setpgid(0, 0) < 0)
unix_error("setpgid error");
if (execve(argv[0], argv, environ) < 0)
{
printf("%s: command not found\n", argv[0]);
exit(0);
}
}
// 将当前进程添加进job中，无论是前台进程还是后台进程
addjob(jobs, pid, state, cmdline);
// 恢复受阻塞的信号 SIGINT SIGTSTP SIGCHLD
if (sigprocmask(SIG_UNBLOCK, &set, NULL) < 0)
unix_error("sigprocmask error");
// 判断子进程类型并做处理
if (state == FG)
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 == ' ')) /* 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], "bg") || !strcmp(argv[0], "fg"))
do_bgfg(argv);
else if (!strcmp(argv[0], "jobs"))
listjobs(jobs);
else
return 0; /* not a builtin command */
return 1;
}
/*
* do_bgfg - Execute the builtin bg and fg commands
*/
void do_bgfg(char **argv)
{
int parsed;
struct job_t *job;
// 没有参数的fg/bg应该被丢弃
if (!argv[1])
{
printf("%s command requires PID or %%jobid argument\n", argv[0]);
return;
}
// 检测fg/bg参数，其中%开头的数字是JobID，纯数字的是PID
if (argv[1][0] == '%')
{
if ((parsed = strtol(&argv[1][1], NULL, 10)) <= 0)
{
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
if ((job = getjobjid(jobs, parsed)) == NULL)
{
printf("%%%d: No such job\n", parsed);
return;
}
}
else
{
if ((parsed = strtol(argv[1], NULL, 10)) <= 0)
{
printf("%s: argument must be a PID or %%jobid\n", argv[0]);
return;
}
if ((job = getjobpid(jobs, parsed)) == NULL)
{
printf("(%d): No such process\n", parsed);
return;
}
}
if (!strcmp(argv[0], "bg"))
{
// bg会启动子进程，并将其放置于后台执行
job->state = BG;
if (kill(-job->pid, SIGCONT) < 0)
unix_error("kill error");
printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
}
else if (!strcmp(argv[0], "fg"))
{
job->state = FG;
if (kill(-job->pid, SIGCONT) < 0)
unix_error("kill error");
// 当一个进程被设置为前台执行时，当前tsh应该等待该子进程结束
waitfg(job->pid);
}
else
{
puts("do_bgfg: Internal error");
exit(0);
}
return;
}
/*
* waitfg - Block until process pid is no longer the foreground process
*/
void waitfg(pid_t pid)
{
struct job_t *job = getjobpid(jobs, pid);
if (!job)
return;
// 如果当前子进程的状态没有发生改变，则tsh继续休眠
while (job->state == FG)
// 使用sleep的这段代码会比较慢，最好使用sigsuspend
sleep(1);
if (verbose)
printf("waitfg: Process (%d) no longer the fg process\n", pid);
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)
{
int status, jid;
pid_t pid;
struct job_t *job;
if (verbose)
puts("sigchld_handler: entering");
/*
以非阻塞方式等待所有子进程
waitpid 参数3：
1. 0 ： 执行waitpid时， 只有在子进程 **终止** 时才会返回。
2. WNOHANG : 若子进程仍然在运行，则返回0 。
注意只有设置了这个标志，waitpid才有可能返回0
3. WUNTRACED : 如果子进程由于传递信号而停止，则马上返回。
只有设置了这个标志，waitpid返回时，其WIFSTOPPED(status)才有可能返回true
*/
while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0)
{
// 如果当前这个子进程的job已经删除了，则表示有错误发生
if ((job = getjobpid(jobs, pid)) == NULL)
{
printf("Lost track of (%d)\n", pid);
return;
}
jid = job->jid;
// 如果这个子进程收到了一个暂停信号（还没退出
if (WIFSTOPPED(status))
{
printf("Job [%d] (%d) stopped by signal %d\n", jid, job->pid, WSTOPSIG(status));
job->state = ST;
}
// 如果这个子进程正常退出
else if (WIFEXITED(status))
{
if (deletejob(jobs, pid))
if (verbose)
{
printf("sigchld_handler: Job [%d] (%d) deleted\n", jid, pid);
printf("sigchld_handler: Job [%d] (%d) terminates OK (status %d)\n", jid, pid, WEXITSTATUS(status));
}
}
// 如果这个子进程因为其他的信号而异常退出，例如SIGKILL
else
{
if (deletejob(jobs, pid))
{
if (verbose)
printf("sigchld_handler: Job [%d] (%d) deleted\n", jid, pid);
}
printf("Job [%d] (%d) terminated by signal %d\n", jid, pid, WTERMSIG(status));
}
}
if (verbose)
puts("sigchld_handler: exiting");
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)
{
if (verbose)
puts("sigint_handler: entering");
pid_t pid = fgpid(jobs);
if (pid)
{
// 发送SIGINT给前台进程组里的所有进程
// 需要注意的是，前台进程组内的进程除了当前前台进程以外，还包括前台进程的子进程。
// 最多只能存在一个前台进程，但前台进程组内可以存在多个进程
if (kill(-pid, SIGINT) < 0)
unix_error("kill (sigint) error");
if (verbose)
{
printf("sigint_handler: Job (%d) killed\n", pid);
}
}
if (verbose)
puts("sigint_handler: exiting");
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)
{
if (verbose)
puts("sigstp_handler: entering");
pid_t pid = fgpid(jobs);
struct job_t *job = getjobpid(jobs, pid);
if (pid)
{
if (kill(-pid, SIGTSTP) < 0)
unix_error("kill (tstp) error");
if (verbose)
{
printf("sigstp_handler: Job [%d] (%d) stopped\n", job->jid, pid);
}
}
if (verbose)
puts("sigstp_handler: exiting");
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);
}
3786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
