实验介绍
完成一个简单的shell程序，总体的框架和辅助代码都已经提供好了，我们需要完成的函数主要以下几个：
- eval: 主要功能是解析cmdline，并且运行. [70 lines]
- builtin cmd: 辨识和解析出bulidin命令: quit, fg, bg, and jobs. [25lines]
- do bgfg: 实现bg和fg命令. [50 lines]
- waitfg: 实现等待前台程序运行结束. [20 lines]
- sigchld handler: 响应SIGCHLD. 80 lines]
- sigint handler: 响应 SIGINT (ctrl-c) 信号. [15 lines]
- sigtstp handler: 响应 SIGTSTP (ctrl-z) 信号. [15 lines]
难点主要在于对信号的处理，需要我们捕获信号，改变其对应的处理方式。
其他需要注意的地方：
- 系统函数的返回值检查，一定要多注意有可能出错的地方；
- 竞争条件，fork子进程之后，如果子进程很快就结束了，而此时主进程还没addjob就会有问题，总之就是不能假设进程之间以安全的顺序执行，这里利用互斥量的思路，主进程会阻塞子进程的信号，直到addjob之后；
- SIGCHLD信号处理函数，考虑多个子进程结束，以及非正常结束时waitpid的返回值，后面结合课本里详细说。
有关Shell
我们要实现的shell有两种执行模式
- 如果用户输入的命令是内置命令，那么 shell 会直接在当前进程执行（例如 jobs）
- 如果用户输入的是一个可执行程序的路径，那么 shell 会 fork 出一个新进程，并且在这个子进程中执行该程序（例如 /bin/ls -l -d）
第二种情况中，如果命令以& 结束，那么这个job在后台执行
需要支持的功能：
- job control：允许用户更改进程的前台/后台状态以及京城的状态(running, stopped, or terminated)
- ctrl-c 会触发 SIGINT 信号并发送给每个前台进程，默认的动作是终止该进程
- ctrl-z 会触发 SIGTSTP 信号并发送给每个前台进程，默认的动作是挂起该进程，直到再收到 SIGCONT 信号才继续
- jobs 命令会列出正在执行和被挂起的后台任务
- bg job 命令可以让一个被挂起的后台任务继续执行 ，fg job 命令同理
参考课本代码
先来看看课本上我们可以参考的代码有哪些
P525 eval()函数原型
void eval(char *cmdline)
{
char *argv[MAXARGS]; /* Argument list execve() */
char buf[MAXLINE]; /* Holds modified command line */
int bg; /* Should the job run in bg or fg? */
pid_t pid; /* Process id */
strcpy(buf, cmdline);
bg = parseline(buf, argv); //解析命令行函数都提供好了
if (argv[0] == NULL)
return; /* Ignore empty lines */
if (!builtin_command(argv)) {
if ((pid = Fork()) == 0) { /* 子进程来执行job */
if (execve(argv[0], argv, environ) < 0) {
printf("%s: Command not found.\n", argv[0]);
exit(0);
}
}
/* 如果是前台作业，主进程需要等待子进程运行完毕 */
if (!bg) {
int status;
if (waitpid(pid, &status, 0) < 0)
unix_error("waitfg: waitpid error");
}
else
printf("%d %s", pid, cmdline);
}
return;
}
基本功能都完成了，唯一的不足就是由于joblist的存在，需要考虑竞争条件，也就是主进程一定要先addjob，然后才能deletejob
然后看一下信号处理函数，实验代码里已经要求了，需要对以下三个信号进行处理
Signal(SIGINT, sigint_handler); /* ctrl-c /
Signal(SIGTSTP, sigtstp_handler); / ctrl-z /
Signal(SIGCHLD, sigchld_handler); / Terminated or stopped child */
那么就来看看书上P532的示例：
#include "csapp.h"
void sigint_handler(int sig) /* SIGINT handler */ //line:ecf:sigint:beginhandler
{
printf("Caught SIGINT!\n"); //line:ecf:sigint:printhandler
exit(0); //line:ecf:sigint:exithandler
} //line:ecf:sigint:endhandler
int main()
{
/* Install the SIGINT handler */
if (signal(SIGINT, sigint_handler) == SIG_ERR) //line:ecf:sigint:begininstall
unix_error("signal error"); //line:ecf:sigint:endinstall
pause(); /* Wait for the receipt of a signal */ //line:ecf:sigint:pause
return 0;
}
嗯，SIGINT就是我们想自己处理的信号，然后通过sigint_handler来进行自定义的处理。（当然这示例也忒简单了）
还有一个重要的信号不排队问题，涉及到父进程回收子进程：
- 子进程结束的时候向父进程发生信号，但是内核的规矩是这样的：
在任何时刻，一种类型至多只会有一个待处理信号（内核中负责维护待处理信号的pending位向量对应的特定信号类型只有一位），也就是说信号是不会排队的，如果处理信号A的过程中又来了信号B，信号B是会被阻塞的，此时又来信号C，那么信号C就被丢弃了，处理办法也很简单，每次处理信号的时候，用while循环尽可能多接收几个信号。
书上的对应代码P539
void handler2(int sig)
{
int olderrno = errno;
while (waitpid(-1, NULL, 0) > 0) {
Sio_puts("Handler reaped child\n");
}
if (errno != ECHILD)
Sio_error("waitpid error");
Sleep(1);
errno = olderrno;
}
接下来再看信号阻塞，也就是要避免父进程和子进程多job列表操作的竞争
linux提供阻塞信号的隐式机制和显式机制
- 隐式：默认阻塞当前处理程序正在处理的信号类型
- 显式：使用sigprocmask函数
具体怎么使用可以参考课本P543的promask2.c
#include "csapp.h"
void handler(int sig)
{
int olderrno = errno;
sigset_t mask_all, prev_all;
pid_t pid;
Sigfillset(&mask_all);
while ((pid = waitpid(-1, NULL, 0)) > 0) { /* Reap a zombie child */
Sigprocmask(SIG_BLOCK, &mask_all, &prev_all); //阻塞所有信号
deletejob(pid); /* 对joblist安全删除 */
Sigprocmask(SIG_SETMASK, &prev_all, NULL); //恢复所有信号
}
if (errno != ECHILD)
Sio_error("waitpid error");
errno = olderrno;
}
int main(int argc, char **argv)
{
int pid;
sigset_t mask_all, mask_one, prev_one;
Sigfillset(&mask_all);
Sigemptyset(&mask_one);
Sigaddset(&mask_one, SIGCHLD);
Signal(SIGCHLD, handler);
initjobs(); /* Initialize the job list */
while (1) {
Sigprocmask(SIG_BLOCK, &mask_one, &prev_one); /* 阻塞 SIGCHLD */
if ((pid = Fork()) == 0) { /* Child process */
Sigprocmask(SIG_SETMASK, &prev_one, NULL); /* 子进程解除阻塞 SIGCHLD */
Execve("/bin/date", argv, NULL);
}
Sigprocmask(SIG_BLOCK, &mask_all, NULL); /* 阻塞所有信号*/
addjob(pid); /* 对job列表的操作安全了 */
Sigprocmask(SIG_SETMASK, &prev_one, NULL); /* 父进程解除阻塞 SIGCHLD */
}
exit(0);
}
看起来挺麻烦，实际我们可以简化的，实际写的时候只阻塞SIGCHLD即可。
课本里面还提到一点，主程序显式等待某个信号处理程序进行，尤其是shell创建前台作业的时候，基本思路是用循环，当接收到信号时，在信号处理程序中把while条件更改来跳出循环，这样做存在资源浪费以及无法精准唤醒的问题，比较好的解决方法是sigsuspend，相当于一个原子操作，可以暂时取消阻塞SIGCHLD，然后pause接收信号，紧接着恢复阻塞。
否则的话，本来的pause(）是挂起进程直到收到信号，那么下面的代码有可能永远休眠
while(!pid)
pause(); //如果在while判断之后和pause之前收到信号，那就错过啦，所以需要原子操作
实验代码
经过上面对课本代码的复习，实际上好多功能都已经给出了实现方法，实验代码自然也就不难给出啦。
1. eval()
主要功能是对用户输入的参数进行解析并运行计算。如果用户输入内建的命令行（quit，bg，fg，jobs）那么立即执行。 否则，fork一个新的子进程并且将该任务在子进程的上下文中运行。如果该任务是前台任务那么需要等到它运行结束才返回。
- 注意每个子进程必须用户自己独一无二的进程组id，要不然就没有前台后台区分啦
- 在fork()新进程前后要阻塞SIGCHLD信号，防止出现竞争（race）这种经典的同步错误
void eval(char *cmdline)
{
char* argv[MAXARGS];
pid_t pid;
sigset_t mask;
int fgorbg = parseline(cmdline,argv);
if(argv[0] == NULL)
return;
sigemptyset(&mask);
sigaddset(&mask,SIGCHLD);
sigprocmask(SIG_BLOCK,&mask,NULL);
if(!builtin_cmd(argv)){
if((pid = fork()) == 0){
sigprocmask(SIG_UNBLOCK,&mask,NULL); //子进程也是要解除阻塞的
if(setpgid(0,0)<0)
unix_error("eval: setgpid failed.\n");
if(execve(argv[0],argv,environ)<0){
printf("%s: Command not found.\n",argv[0]);
exit(0);
}
}
if(!fgorbg)
addjob(jobs,pid,FG,cmdline);
else
addjob(jobs,pid,BG,cmdline);
sigprocmask(SIG_UNBLOCK,&mask,NULL); //这里一定要addjob之后再解除阻塞
if(!fgorbg) // FG job
waitfg(pid);
else
printf("[%d] (%d) %s\n",pid2jid(pid),pid,cmdline);
}
return;
}
2. builtin_cmd()
判断命令是否是内置指令，是的话立即执行，不是则返回，对单独的‘&’无视
int builtin_cmd(char **argv)
{
if(strcmp(argv[0],"quit")==0)
{printf("exit\n");exit(0);}
if(strcmp(argv[0],"jobs")==0)
{
listjobs(jobs);
return 1;
}
if(strcmp(argv[0],"bg")==0 || strcmp(argv[0],"fg")==0)
{
do_bgfg(argv);
return 1;
}
return 0; /* not a builtin command */
}
3. do_bgfg()
执行bg和fg指令功能
void do_bgfg(char **argv)
{
char *id = argv[1];
struct job_t *job;
int jobid;
if(id == NULL){
printf("%s command requires PID of jobid argument.\n",argv[0]);
return;
}
if(id[0] == '%')
jobid = atoi(id+1);
if((job = getjobjid(jobs,jobid))==NULL){
printf("Job does not exist.\n");
return;
}
if(strcmp(argv[0],"bg")==0){
job->state = BG;
kill(-(job->pid),SIGCONT);
}
if(strcmp(argv[0],"fg")==0){
job->state = FG;
kill(-(job->pid),SIGCONT);
waitfg(job->pid);
}
return;
}
kill函数的用法，向任何进程组或进程发送信号
int kill(pid_t pid, int sig);
参数pid的可能选择：
- pid大于零时，pid是信号欲送往的进程的标识。
- pid等于零时，信号将送往所有与调用kill()的那个进程属同一个使用组的进程。
- pid等于-1时，信号将送往所有调用进程有权给其发送信号的进程，除了进程1(init)。
- pid小于-1时，信号将送往以-pid为组标识的进程。
4. waitfg()
等待前台进程完成，这里偷懒了，没用sigsuspend，还是用了比较消耗资源的方法哈哈哈。。。
void waitfg(pid_t pid)
{
while(pid == fgpid(jobs));
return;
}
5. 几个信号处理函数
SIGINT处理比较简单，就是截获CTRL+C然后发给前台程序嘛
void sigint_handler(int sig)
{
pid_t pid = fgpid(jobs);
int jid = pid2jid(pid);
if(pid!=0){
printf("Job [%d] terminated by SIGINT.\n",jid);
deletejob(jobs,pid);
kill(-pid,sig);
}
return;
}
SIGTSTP就是把CTRL+Z发给前台
void sigtstp_handler(int sig)
{
pid_t pid = fgpid(jobs);
int jid = pid2jid(pid);
if(pid!=0){
printf("Job [%d] stopped by SIGINT.\n",jid);
(*getjobpid(jobs,pid)).state = ST;;
kill(-pid,sig);
}
return;
}
SIGCHLD是最麻烦的了，参考网上大牛的方法，需要考虑子进程返回的原因
运用waitpid（）函数并且用WNOHANG|WUNTRACED参数，该参数的作用是判断当前进程中是否存在已经停止或者终止的进程，如果存在则返回pid，不存在则立即返回
通过另外一个&status参数，我们可以判断返回的进程是由于什么原因停止或暂停的。
- WIFEXITED(status):
如果进程是正常返回即为true，什么是正常返回呢？就是通过调用exit（）或者return返回的 - WIFSIGNALED(status)：
如果进程因为捕获一个信号而终止的，则返回true - WTERMSIG(status)：
当WIFSIGNALED(status)为真时，设置该值，返回导致当前状态的信号编号 - WIFSTOPPED(status)：
如果返回的进程当前是被停止，则为true - WSTOPSIG(status)：
返回引起进程停止的信号
void sigchld_handler(int sig)
{
pid_t pid;
int status,child_sig;
while((pid = waitpid(-1, &status, WUNTRACED | WNOHANG)) > 0 ){
printf("Handling chlid proess %d\n", (int)pid);
/*handle SIGTSTP*/
if( WIFSTOPPED(status) )
sigtstp_handler( WSTOPSIG(status) );
/*handle child process interrupt by uncatched signal*/
else if( WIFSIGNALED(status) ) {
child_sig = WTERMSIG(status);
if(child_sig == SIGINT)
sigint_handler(child_sig);
}
else
deletejob(jobs, pid);
}
return;
}
总结
本次Shell Lab的收获有以下几点
- 对Shell有了更加深刻的理解，借助实验代码实现了不带重定向的简单shell
- 掌握信号的正确接收处理，阻塞和解除阻塞机制，写出避免竞争的代码
- 父进程和子进程的fork，回收，信号传递等
- linux下编程规范，以及进程相关函数的使用，学到了学到了
