实现过程
首先实现 函数，由于 函数实现了内建指令的执行，所以 里面主要负责创建子进程来执行外部程序，并将子进程登记到 数组中。为了避免父子进程间的竞争引发的同步问题，需要在创建子进程前屏蔽掉 信号，由于子进程会复制父进程中的所有变量，所以子进程在执行外部程序之前应该解除屏蔽。同时 使得子进程的进程组编号和不同于父进程 tsh，不然按下ctrl+c会直接退出终端。
void eval(char* cmdline {
char* argv[MAXARGS];
pid_t pid;
sigset_t mask_all, mask_one, prev_mask;
sigfillset(&mask_all;
sigemptyset(&mask_one;
sigaddset(&mask_one, SIGCHLD;
int bg = parseline(cmdline, argv;
// 忽略空行
if (argv[0] == NULL
return;
if (builtin_cmd(argv
return;
sigprocmask(SIG_BLOCK, &mask_one, &prev_mask;
if ((pid = Fork( == 0 {
sigprocmask(SIG_SETMASK, &prev_mask, NULL;
setpgid(0, 0;
Execve(argv[0], argv, environ;
}
sigprocmask(SIG_BLOCK, &mask_one, NULL;
addjob(jobs, pid, bg ? BG : FG, cmdline;
if (!bg {
waitfg(pid;
} else {
printf("[%d] (%d %s", pid2jid(pid, pid, cmdline;
}
sigprocmask(SIG_SETMASK, &prev_mask, NULL;
}上述程序对 和 做了封装，可以让 看起来更加简洁，代码如下所示：
pid_t Fork( {
pid_t pid = fork(;
if (pid < 0
unix_error("Fork error";
return pid;
}
int Execve(const char* __path, char* const* __argv, char* const* __envp {
int result = execve(__path, __argv, __envp;
if (result < 0 {
printf("%s: Command not found\n", __argv[0];
exit(1;
}
return result;
}如果遇到前台作业，终端应该调用 函数并处于阻塞状态，这里使用 函数而不使用 函数的原因是不好确定要 多长时间，间隔太短浪费处理器资源，间隔太长速度就太慢了：
void waitfg(pid_t pid {
sigset_t mask;
sigemptyset(&mask;
while (fgpid(jobs {
sigsuspend(&mask;
}
}的具体代码如下所示，只要使用 函数来比对指令就行了：
int builtin_cmd(char** argv {
int is_buildin = 1;
if (!strcmp(argv[0], "quit" {
exit(0;
} else if (!strcmp(argv[0], "fg" || !strcmp(argv[0], "bg" {
do_bgfg(argv;
} else if (!strcmp(argv[0], "jobs" {
listjobs(jobs;
} else {
is_buildin = 0;
}
return is_buildin; /* not a builtin command */
}在 中最重要的就是 函数，负责作业的状态转换，如下图所示：
void do_bgfg(char** argv {
char* cmd = argv[0];
char* id = argv[1];
struct job_t* job;
if (id == NULL {
printf("%s command requires PID or %%jobid argument\n", cmd;
return;
}
// 根据 jid/pid 获取作业
if (id[0] == '%' {
if ((job = getjobjid(jobs, atoi(id + 1 == NULL {
printf("%s: No such job\n", id;
return;
}
} else if (atoi(id > 0 {
if ((job = getjobpid(jobs, atoi(id == NULL {
printf("(%d: No such process\n", atoi(id;
return;
}
} else {
printf("%s: argument must be a PID or %%jobid\n", cmd;
return;
}
// 状态转移
if (!strcmp(cmd, "fg" {
job->state = FG;
kill(-job->pid, SIGCONT;
waitfg(job->pid;
} else if (!strcmp(cmd, "bg" {
job->state = BG;
kill(-job->pid, SIGCONT;
printf("[%d] (%d %s", job->jid, job->pid, job->cmdline;
}
}最后就是进行信号的处理了，由于同一种信号无法排队，需要使用 来 ，同时使用 来处理终止和停止的情况。停止作业后需要修改 的状态为 ，不然 中的循环会一直进行下去：
void sigchld_handler(int sig {
int old_errno = errno;
pid_t pid;
int status;
sigset_t mask_all, prev_mask;
sigfillset(&mask_all;
while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED > 0 {
// 终止作业
if (WIFEXITED(status || WIFSIGNALED(status {
sigprocmask(SIG_BLOCK, &mask_all, &prev_mask;
// ctrl-c 终止
if (WIFSIGNALED(status {
printf("Job [%d] (%d terminated by signal 2\n", pid2jid(pid, pid;
}
deletejob(jobs, pid;
sigprocmask(SIG_SETMASK, &prev_mask, NULL;
}
// 停止作业
else if (WIFSTOPPED(status {
sigprocmask(SIG_BLOCK, &mask_all, &prev_mask;
struct job_t* job = getjobpid(jobs, pid;
job->state = ST;
printf("Job [%d] (%d stopped by signal 20\n", job->jid, job->pid;
sigprocmask(SIG_SETMASK, &prev_mask, NULL;
}
}
errno = old_errno;
}
void sigint_handler(int sig {
int old_errno = errno;
pid_t pid = fgpid(jobs;
if (pid > 0
kill(-pid, SIGKILL;
errno = old_errno;
}
void sigtstp_handler(int sig {
int old_errno = errno;
pid_t pid = fgpid(jobs;
if (pid > 0
kill(-pid, SIGTSTP;
errno = old_errno;
}最后来测试一下 tsh 好不好使，这里使用看起来最复杂的 trace15.txt：
总结
通过这次实验，可以加深对进程控制和信号处理的理解，同时对于并发现象有了更直观的认识，以上~~