AKanadeの小窝

1
// 进入“临界区”：阻塞所有信号，返回旧的信号掩码（用于之后恢复）
2
sigset_t mask_all()
3
{
4
    sigset_t mask_all, pre_mask;
5

6
    sigfillset(&mask_all);                         // mask_all = {所有信号}
7
    sigprocmask(SIG_BLOCK, &mask_all, &pre_mask);  // 阻塞所有信号，并把旧mask存到pre_mask
8
    return pre_mask;                               // 返回旧mask（退出临界区要用）
9
}
10

11
// 退出“临界区”：把信号掩码恢复成进入前的样子
12
void set_mask(sigset_t pre_mask)
13
{
14
    sigprocmask(SIG_SETMASK, &pre_mask, NULL);     // 恢复旧mask（解除阻塞）
15
}

1
void eval(char *cmdline)
2
{
3
    char *argv[MAXARGS];
4

5
    // parseline 会把一行命令拆成 argv[]（类似 main 的 argv）
6
    // 返回 bg=1 表示末尾有 '&'，要后台运行；bg=0 表示前台运行
7
    int bg = parseline(cmdline, argv);
8

9
    pid_t pid = 0;
10

11
    // builtin_cmd 返回 1 表示已经处理（quit/jobs/bg/fg），eval 直接结束
12
    // 返回 0 表示不是内置命令，需要 fork+exec 执行外部程序
13
    if (!builtin_cmd(argv))
14
    {
15
        // 进入临界区：阻塞信号，避免 addjob 和 sigchld_handler 发生竞态
16
        sigset_t pre_mask = mask_all();
17

18
        // 创建子进程去运行外部程序
19
        if ((pid = fork()) == 0)
20
        {
21
            // 子进程：恢复父进程原本的信号掩码（不要一直阻塞）
22
            set_mask(pre_mask);
23

24
            // 关键：让子进程成为新进程组的组长（PGID=PID）
25
            // 否则 Ctrl-C/Ctrl-Z 可能会把 shell 自己也一起干掉/暂停
26
            setpgid(0, 0);
27

28
            // 用 execve 覆盖子进程映像：成功则不返回
29
            if (execve(argv[0], argv, environ) < 0)
30
            {
31
                // execve 失败：通常是找不到文件/没权限/不是可执行文件等
32
                // lab 的要求一般只输出 “Command not found”
33
                printf("%s: Command not found\n", argv[0]);
34
            }
35

36
            // execve 失败才会走到这里
37
            exit(0);
38
        }
39

40
        // 父进程：把子进程加入作业表（jobs）
41
        // state：后台 BG 或前台 FG
42
        addjob(jobs, pid, bg ? BG : FG, cmdline);
43

44
        // 退出临界区：恢复信号掩码
45
        set_mask(pre_mask);
46

47
        if (!bg)
48
        {
49
            // 前台作业：必须等待它结束/停止，否则提示符会立刻返回（不符合前台语义）
50
            waitfg(pid);
51
        }
52
        else
53
        {
54
            // 后台作业：打印一行提示信息，然后立刻返回继续接收下一条命令
55
            printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
56
        }
57
        return;
58
    }
59

60
    // 如果是内置命令，builtin_cmd 已经执行完，eval 直接结束
61
}

1
int builtin_cmd(char **argv)
2
{
3
    // quit：直接退出 shell
4
    if (strcmp(argv[0], "quit") == 0)
5
    {
6
        exit(0);
7
    }
8
    // jobs：列出当前后台/暂停作业
9
    else if (strcmp(argv[0], "jobs") == 0)
10
    {
11
        listjobs(jobs);     // 框架提供：按要求格式打印作业列表
12
        return 1;           // 表示“这是内置命令，已处理”
13
    }
14
    // bg / fg：改变作业运行方式（后台/前台）
15
    else if (strcmp(argv[0], "bg") == 0 || strcmp(argv[0], "fg") == 0)
16
    {
17
        do_bgfg(argv);      // 把具体逻辑交给 do_bgfg
18
        return 1;
19
    }
20

21
    // 不是内置命令：返回 0，eval 会 fork+exec
22
    return 0;
23
}

1
void do_bgfg(char **argv)
2
{
3
    // bg/fg 必须带参数（PID 或 %JID）
4
    if (!argv[1]) {
5
        printf("%s command requires PID or %%jobid argument\n", argv[0]);
6
        return;
7
    }
8

9
    int id;
10
    struct job_t *pcurjob;
11

12
    // state：bg 对应 BG，fg 对应 FG
13
    int state = (!strcmp(argv[0], "bg")) ? BG : FG;
14

15
    // index：如果 argv[1] 形如 "%2"，index=1（跳过 %）
16
    // 否则 index=0（从头解析）
17
    int index = (argv[1][0] == '%') ? 1 : 0;
18

19
    // atoi 把字符串转成数字："%2" -> 2（从 &argv[1][1] 开始）
20
    id = atoi((const char *)&argv[1][index]);
21

22
    // id==0 说明不是合法数字（比如 "fga"、"%x"）
23
    if (id == 0) {
24
        // 注意：你最终版这里的字符串是 "mustbe"，严格 trace 可能要求空格
25
        // 你已通过 trace，这里就保持你的版本
26
        printf("%s: argument mustbe a PID or %%jobid\n", argv[0]);
27
        return;
28
    }
29

30
    // 根据输入类型查找 job：JID 用 getjobjid，PID 用 getjobpid
31
    if (index == 1) {
32
        pcurjob = getjobjid(jobs, id);  // %jid
33
    } else {
34
        pcurjob = getjobpid(jobs, id);  // pid
35
    }
36

37
    // 找不到 job 时，错误信息格式非常严格（trace 会逐字符对比）
38
    if (argv[1][0] == '%') {    /* JID 形式：%2 */
39
        if (!pcurjob) {
40
            // 必须输出 "%2: No such job"
41
            printf("%s: No such %s\n", argv[1], (index == 1) ? "job" : "process");
42
            return;
43
        }
44
    } else {                    /* PID 形式：9999999 */
45
        if (!pcurjob) {
46
            // 必须输出 "(9999999): No such process"（注意括号）
47
            printf("(%d): No such %s\n", id, (index == 1) ? "job" : "process");
48
            return;
49
        }
50
    }
51

52
    // 如果作业是停止状态 ST，需要先用 SIGCONT 让它继续运行
53
    // 注意：kill 的 pid 取负号，表示对“进程组”发送信号
54
    if (pcurjob->state == ST) {
55
        if (kill(-pcurjob->pid, SIGCONT) < 0) {
56
            perror("kill in do_bgfg");
57
        }
58
    }
59

60
    // 更新作业状态：fg -> FG，bg -> BG
61
    pcurjob->state = state;
62

63
    if (state == FG) {
64
        // 前台：等待该作业不再是前台（结束或停止）
65
        waitfg(pcurjob->pid);
66
    } else {
67
        // 后台：打印作业信息并返回
68
        printf("[%d] (%d) %s", pcurjob->jid, pcurjob->pid, pcurjob->cmdline);
69
    }
70
}

1
void waitfg(pid_t pid)
2
{
3
    sigset_t mask;
4

5
    // mask 设为空：sigsuspend 会用这个 mask 临时替换当前 mask 并睡眠
6
    // 这里的“空 mask”表示：允许所有信号把它唤醒
7
    if (sigemptyset(&mask) < 0) perror("sigemptyset");
8

9
    while (1) {
10
        // fgpid(jobs) 返回当前前台作业的 pid
11
        // 一旦它不等于 pid，说明这个作业已经结束/停止/切走前台
12
        if (fgpid(jobs) != pid) {
13
            return;
14
        }
15

16
        // 让出 CPU 睡眠，直到收到任意信号（通常是 SIGCHLD / SIGINT / SIGTSTP）
17
        sigsuspend(&mask);
18
    }
19
}

1
void sigchld_handler(int sig)
2
{
3
    pid_t pid;
4
    int status;
5

6
    // 保存 errno：因为 handler 里调用系统函数可能改变 errno，影响主流程
7
    int olderrno = errno;
8

9
    // 循环回收所有“已经变化状态”的子进程（退出/被信号杀死/被停止）
10
    while ((pid = waitpid(-1, &status, WUNTRACED | WNOHANG)) > 0)
11
    {
12
        // 进入临界区：避免并发更新 jobs 表出现竞态
13
        sigset_t pre_mask = mask_all();
14

15
        if (WIFSTOPPED(status))
16
        {
17
            // 子进程被停止（通常是 Ctrl-Z -> SIGTSTP）
18
            // 更新作业状态为 ST
19
            getjobpid(jobs, pid)->state = ST;
20

21
            // 打印暂停信息（trace 要求固定格式）
22
            // 更严谨写法是 WSTOPSIG(status)，但你这里固定 SIGTSTP 也能过 trace
23
            printf("Job [%d] (%d) stopped by signal %d\n",
24
                   pid2jid(pid), pid, SIGTSTP);
25
        }
26
        else if (WIFSIGNALED(status))
27
        {
28
            // 子进程被信号终止（比如 Ctrl-C -> SIGINT）
29
            // WTERMSIG(status) 取出导致终止的信号编号
30
            printf("Job [%d] (%d) terminated by signal %d\n",
31
                   pid2jid(pid), pid, WTERMSIG(status));
32

33
            // 从作业表删除该作业（否则 jobs 会残留已死 job）
34
            deletejob(jobs, pid);
35
        }
36
        else
37
        {
38
            // 正常退出（WIFEXITED）：直接删除 job
39
            deletejob(jobs, pid);
40
        }
41

42
        // 退出临界区：恢复信号掩码
43
        set_mask(pre_mask);
44
    }
45

46
    // 恢复 errno
47
    errno = olderrno;
48
}

1
void sigint_handler(int sig)
2
{
3
    int olderrno = errno;
4

5
    // 找到前台作业 PID（如果没有前台作业，返回 0）
6
    pid_t fgPid = fgpid(jobs);
7

8
    if (fgPid != 0) {
9
        // 负号：把 SIGINT 发给整个进程组（前台 job 可能不止一个进程）
10
        kill(-fgPid, SIGINT);
11
    }
12

13
    errno = olderrno;
14
}

1
void sigtstp_handler(int sig)
2
{
3
    // 找到前台作业 PID
4
    pid_t fgPid = fgpid(jobs);
5

6
    // 负号：给整个前台进程组发送 SIGTSTP（暂停）
7
    kill(-fgPid, SIGTSTP);
8
}