添加以前的作业

exp0.5/.claude/settings.local.json

@@ -0,0 +1,21 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gcc -Wall -o task53 task53.c)",
+      "Bash(./task53 test *)",
+      "Bash(gcc -Wall -o task54 task54.c)",
+      "Bash(timeout 10 bash -c ' *)",
+      "Bash(./task54)",
+      "Bash(timeout 15 bash /tmp/test_task54.sh)",
+      "Bash(python3 *)",
+      "Bash(pkill -9 -f \"task54\")",
+      "Bash(kill -9 38680 38681 38682 38944 38946 39691 39693 39694 39986 39987 40628)",
+      "Bash(pandoc \"/home/cho/C/exp2/Linux进程控制编程\\(2\\).docx\" -o /tmp/doc_output.md)",
+      "Bash(mkdir -p \"/home/cho/吕锦中202441429012405\")",
+      "Bash(cp /home/cho/C/exp2/task51.c \"/home/cho/吕锦中202441429012405/\")",
+      "Bash(cp /home/cho/C/exp2/task52.c \"/home/cho/吕锦中202441429012405/\")",
+      "Bash(cp /home/cho/C/exp2/task53.c \"/home/cho/吕锦中202441429012405/\")",
+      "Bash(cp /home/cho/C/exp2/task54.c \"/home/cho/吕锦中202441429012405/\")"
+    ]
+  }
+}

exp0.5/.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: gcc 生成活动文件",
+            "command": "/usr/bin/gcc",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}/${fileBasenameNoExtension}"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "调试器生成的任务。"
+        }
+    ],
+    "version": "2.0.0"
+}

exp0.5/task51.c

@@ -0,0 +1,54 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+
+int main(){
+    __pid_t pid;
+
+    //父进程输出
+    
+    printf("P1:I am father process,PID=%d,PPID=%d\n", getpid(), getppid());
+
+    //生成子进程
+    pid = fork();
+
+    //父进程
+    if(pid != 0){
+        //pid判断归零
+        pid = 0;
+        pid = fork();
+        
+        //子进程
+        if (pid == 0){
+            printf("P12:I am young brother process,PID=%d,PPID=%d\n", getpid(), getppid());
+            
+            //此时pid为0，继续生成子进程
+            pid = fork();
+            if (pid == 0){
+                printf("P121:我的学号是2024414290124,PID=%d,PPID=%d\n", getpid(), getppid());
+            }
+            //父进程
+            else{
+                //pid判断归零
+                pid = 0;
+                pid = fork();
+                //子进程
+                if (pid == 0){
+                    printf("P122:我的姓名是吕锦中,PID=%d,PPID=%d\n", getpid(), getppid());
+                }
+                //父进程
+                else{
+                }
+            }
+        }
+        //父进程
+        else{
+        }    
+    }
+    //子进程
+    else{
+        time_t t = time(NULL);
+        printf("P11:当前时间是：%s,PID=%d,PPID=%d\n", ctime(&t), getpid(), getppid());
+    }
+}

exp0.5/task52.c

@@ -0,0 +1,259 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <ctype.h>
+
+#define MAX_CMD   1024
+#define MAX_ARGS  64
+#define MAX_PIPES 32
+
+char *trim(char *s) {
+    while (isspace((unsigned char)*s)) s++;
+    if (*s == '\0') return s;
+    char *end = s + strlen(s) - 1;
+    while (end > s && isspace((unsigned char)*end)) end--;
+    *(end + 1) = '\0';
+    return s;
+}
+
+int parse_args(char *cmd, char **args) {
+    int argc = 0;
+    char *token = strtok(cmd, " \t");
+    while (token != NULL && argc < MAX_ARGS - 1) {
+        args[argc++] = token;
+        token = strtok(NULL, " \t");
+    }
+    args[argc] = NULL;
+    return argc;
+}
+
+int split_pipeline(char *buf, char *segments[], int max_segs) {
+    int   nseg      = 0;
+    char *seg_start = buf;   /* 当前段的起始位置 */
+    char *p         = buf;
+
+    while (*p != '\0') {
+        if (*p == '|') {
+            /* 找到管道符：截断当前段，保存去空格后的指针 */
+            *p = '\0';
+            char *seg = trim(seg_start);
+            if (seg[0] != '\0') {          /* 跳过空段 */
+                if (nseg >= max_segs) {
+                    fprintf(stderr, "shell: too many pipes (max %d)\n", max_segs);
+                    return -1;
+                }
+                segments[nseg++] = seg;
+            }
+            seg_start = p + 1;             /* 下一段从 '|' 后面开始 */
+        }
+        p++;
+    }
+
+    /* 保存最后一段（'|' 后面，或整个命令没有 '|' 时） */
+    char *last = trim(seg_start);
+    if (last[0] != '\0') {
+        segments[nseg++] = last;
+    }
+
+    return nseg;
+}
+
+static void exec_cmd_in_child(char **args, int argc, int in_fd, int out_fd) {
+    char *infile    = NULL;
+    char *outfile   = NULL;
+    char *clean_args[MAX_ARGS];
+    int   clean_argc = 0;
+
+    for (int i = 0; i < argc; i++) {
+        if (strcmp(args[i], "<") == 0 && i + 1 < argc) {
+            infile = args[++i];                  /* 记录输入文件，跳过文件名 */
+        } else if (strcmp(args[i], ">") == 0 && i + 1 < argc) {
+            outfile = args[++i];                 /* 记录输出文件，跳过文件名 */
+        } else {
+            clean_args[clean_argc++] = args[i];  /* 普通参数保留 */
+        }
+    }
+    clean_args[clean_argc] = NULL;
+
+    if (clean_argc == 0) 
+    {
+        exit(0);
+    }
+
+    if (infile) {
+        if (in_fd != STDIN_FILENO) 
+            close(in_fd); /* 管道读端不再需要，关掉 */
+
+        int fd = open(infile, O_RDONLY);
+
+        if (fd < 0) { 
+            perror("open"); exit(1); 
+        }
+        dup2(fd, STDIN_FILENO);
+        close(fd);
+    } else if (in_fd != STDIN_FILENO) {
+        dup2(in_fd, STDIN_FILENO);
+        close(in_fd);
+    }
+
+    if (outfile) {
+        if (out_fd != STDOUT_FILENO) 
+            close(out_fd);
+        int fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+        if (fd < 0) { 
+            perror("open"); exit(1); 
+        }
+        dup2(fd, STDOUT_FILENO);
+        close(fd);
+    } else if (out_fd != STDOUT_FILENO) {
+        dup2(out_fd, STDOUT_FILENO);
+        close(out_fd);
+    }
+
+    execvp(clean_args[0], clean_args);
+    fprintf(stderr, "shell: command not found: %s\n", clean_args[0]);
+    exit(127);
+}
+
+static void run_single(char *seg) {
+    char  buf[MAX_CMD];
+    strncpy(buf, seg, MAX_CMD - 1);
+    buf[MAX_CMD - 1] = '\0';
+
+    char *args[MAX_ARGS];
+    int   argc = parse_args(buf, args);
+    if (argc == 0) return;
+
+    pid_t pid = fork();
+    if (pid < 0) { perror("fork"); return; }
+    if (pid == 0) {
+        /* 子进程：从终端 stdin 读，输出到终端 stdout */
+        exec_cmd_in_child(args, argc, STDIN_FILENO, STDOUT_FILENO);
+    }
+    /* 父进程：等待子进程结束 */
+    waitpid(pid, NULL, 0);
+}
+
+static void run_pipeline(char *segments[], int nseg) {
+    int npipes = nseg - 1;
+
+    /* --- 1. 一次性创建所有管道 --- */
+    int pipes[MAX_PIPES][2];
+    for (int i = 0; i < npipes; i++) {
+        if (pipe(pipes[i]) < 0) {
+            perror("pipe");
+            /* 出错：关闭已创建的管道后返回 */
+            for (int j = 0; j < i; j++) {
+                close(pipes[j][0]);
+                close(pipes[j][1]);
+            }
+            return;
+        }
+    }
+
+    /* --- 2. 依次 fork 每段命令的子进程 --- */
+    pid_t pids[MAX_PIPES + 1];
+
+    for (int i = 0; i < nseg; i++) {
+
+        /* 确定本段从哪里读、往哪里写：
+         *   第一段：从终端 stdin 读
+         *   中间段：从上一个管道的读端读，向下一个管道的写端写
+         *   最后段：向终端 stdout 写                              */
+        int in_fd  = (i == 0)        ? STDIN_FILENO  : pipes[i - 1][0];
+        int out_fd = (i == nseg - 1) ? STDOUT_FILENO : pipes[i][1];
+
+        /* 解析本段命令的参数 */
+        char  cbuf[MAX_CMD];
+        strncpy(cbuf, segments[i], MAX_CMD - 1);
+        cbuf[MAX_CMD - 1] = '\0';
+        char *args[MAX_ARGS];
+        int   argc = parse_args(cbuf, args);
+
+        pid_t pid = fork();
+        if (pid < 0) {
+            perror("fork");
+            /* fork 失败：关闭所有管道，等待已启动的子进程 */
+            for (int j = 0; j < npipes; j++) {
+                close(pipes[j][0]);
+                close(pipes[j][1]);
+            }
+            for (int j = 0; j < i; j++) waitpid(pids[j], NULL, 0);
+            return;
+        }
+
+        if (pid == 0) {
+            /* 子进程：
+             *   关闭所有"不是自己用"的管道端，
+             *   防止 EOF 永远不到达读端。         */
+            for (int j = 0; j < npipes; j++) {
+                if (pipes[j][0] != in_fd)  
+                    close(pipes[j][0]);
+                if (pipes[j][1] != out_fd) 
+                    close(pipes[j][1]);
+            }
+            if (argc == 0) 
+                exit(0);
+            exec_cmd_in_child(args, argc, in_fd, out_fd);
+            /* exec_cmd_in_child 内部会 exit，永远不会走到这里 */
+        }
+
+        pids[i] = pid;   /* 父进程记录子进程 PID */
+    }
+
+    /* --- 3. 父进程关闭所有管道端，再统一等待子进程 ---
+     *   必须先全部关闭，否则最后一段命令永远读不到 EOF。 */
+    for (int i = 0; i < npipes; i++) {
+        close(pipes[i][0]);
+        close(pipes[i][1]);
+    }
+    for (int i = 0; i < nseg; i++) {
+        waitpid(pids[i], NULL, 0);
+    }
+}
+
+void execute(char *cmdline) {
+    char  buf[MAX_CMD];
+    strncpy(buf, cmdline, MAX_CMD - 1);
+    buf[MAX_CMD - 1] = '\0';
+
+    char *segments[MAX_PIPES + 1];
+    int   nseg = split_pipeline(buf, segments, MAX_PIPES);
+
+    if (nseg <= 0) return;          /* 空命令或出错 */
+
+    if (nseg == 1) {
+        run_single(segments[0]);    /* 普通命令，无管道 */
+    } else {
+        run_pipeline(segments, nseg); /* 多段管道命令 */
+    }
+}
+
+int main() {
+    char cmdline[MAX_CMD];
+
+    while (1) {
+        printf("%% ");
+        fflush(stdout);
+
+        if (fgets(cmdline, MAX_CMD, stdin) == NULL) {
+            printf("\n");
+            break;
+        }
+
+        char *cmd = trim(cmdline);
+        if (strlen(cmd) == 0) continue;
+
+        if (strcmp(cmd, "exit") == 0 || strcmp(cmd, "logout") == 0) {
+            printf("Goodbye!\n");
+            break;
+        }
+
+        execute(cmd);
+    }
+    return 0;
+}

exp0.5/task52_readable.c

@@ -0,0 +1,294 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <ctype.h>
+
+#define MAX_CMD   1024
+#define MAX_ARGS  64
+#define MAX_PIPES 32
+
+/* =========================================================
+ * 工具函数
+ * ========================================================= */
+
+/* 去除字符串首尾空白字符（在原字符串上修改） */
+char *trim(char *s) {
+    while (isspace((unsigned char)*s)) s++;
+    if (*s == '\0') return s;
+    char *end = s + strlen(s) - 1;
+    while (end > s && isspace((unsigned char)*end)) end--;
+    *(end + 1) = '\0';
+    return s;
+}
+
+/* 把命令字符串按空格拆成 args[]，返回参数个数 */
+int parse_args(char *cmd, char **args) {
+    int argc = 0;
+    char *token = strtok(cmd, " \t");
+    while (token != NULL && argc < MAX_ARGS - 1) {
+        args[argc++] = token;
+        token = strtok(NULL, " \t");
+    }
+    args[argc] = NULL;
+    return argc;
+}
+
+/* =========================================================
+ * 第一步辅助函数：split_pipeline
+ *   把 "cmd1 | cmd2 | cmd3" 按 '|' 拆成若干段，
+ *   存入 segments[]，返回段数。
+ *   注意：会修改 buf 的内容（把 '|' 替换为 '\0'）。
+ * ========================================================= */
+int split_pipeline(char *buf, char *segments[], int max_segs) {
+    int   nseg      = 0;
+    char *seg_start = buf;   /* 当前段的起始位置 */
+    char *p         = buf;
+
+    while (*p != '\0') {
+        if (*p == '|') {
+            /* 找到管道符：截断当前段，保存去空格后的指针 */
+            *p = '\0';
+            char *seg = trim(seg_start);
+            if (seg[0] != '\0') {          /* 跳过空段 */
+                if (nseg >= max_segs) {
+                    fprintf(stderr, "shell: too many pipes (max %d)\n", max_segs);
+                    return -1;
+                }
+                segments[nseg++] = seg;
+            }
+            seg_start = p + 1;             /* 下一段从 '|' 后面开始 */
+        }
+        p++;
+    }
+
+    /* 保存最后一段（'|' 后面，或整个命令没有 '|' 时） */
+    char *last = trim(seg_start);
+    if (last[0] != '\0') {
+        segments[nseg++] = last;
+    }
+
+    return nseg;
+}
+
+/* =========================================================
+ * 第二步辅助函数：exec_cmd_in_child
+ *   在子进程里执行一条命令，处理 < 和 > 重定向。
+ *   in_fd / out_fd 来自管道（或 STDIN/STDOUT_FILENO）。
+ *   此函数只能在 fork() 后的子进程里调用，内部会 exit()。
+ * ========================================================= */
+static void exec_cmd_in_child(char **args, int argc, int in_fd, int out_fd) {
+    /* --- 解析重定向符，把 < file 和 > file 从参数里剥离 --- */
+    char *infile    = NULL;
+    char *outfile   = NULL;
+    char *clean_args[MAX_ARGS];
+    int   clean_argc = 0;
+
+    for (int i = 0; i < argc; i++) {
+        if (strcmp(args[i], "<") == 0 && i + 1 < argc) {
+            infile = args[++i];                  /* 记录输入文件，跳过文件名 */
+        } else if (strcmp(args[i], ">") == 0 && i + 1 < argc) {
+            outfile = args[++i];                 /* 记录输出文件，跳过文件名 */
+        } else {
+            clean_args[clean_argc++] = args[i];  /* 普通参数保留 */
+        }
+    }
+    clean_args[clean_argc] = NULL;
+
+    if (clean_argc == 0) exit(0);
+
+    /* --- 设置标准输入 ---
+     *   优先级：< 文件重定向  >  管道读端  >  默认终端 stdin */
+    if (infile) {
+        if (in_fd != STDIN_FILENO) close(in_fd); /* 管道读端不再需要，关掉 */
+        int fd = open(infile, O_RDONLY);
+        if (fd < 0) { perror("open"); exit(1); }
+        dup2(fd, STDIN_FILENO);
+        close(fd);
+    } else if (in_fd != STDIN_FILENO) {
+        dup2(in_fd, STDIN_FILENO);
+        close(in_fd);
+    }
+
+    /* --- 设置标准输出 ---
+     *   优先级：> 文件重定向  >  管道写端  >  默认终端 stdout */
+    if (outfile) {
+        if (out_fd != STDOUT_FILENO) close(out_fd);
+        int fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+        if (fd < 0) { perror("open"); exit(1); }
+        dup2(fd, STDOUT_FILENO);
+        close(fd);
+    } else if (out_fd != STDOUT_FILENO) {
+        dup2(out_fd, STDOUT_FILENO);
+        close(out_fd);
+    }
+
+    execvp(clean_args[0], clean_args);
+    fprintf(stderr, "shell: command not found: %s\n", clean_args[0]);
+    exit(127);
+}
+
+/* =========================================================
+ * 第三步辅助函数：run_single
+ *   执行单条命令（无管道），fork 一个子进程并等待它结束。
+ * ========================================================= */
+static void run_single(char *seg) {
+    char  buf[MAX_CMD];
+    strncpy(buf, seg, MAX_CMD - 1);
+    buf[MAX_CMD - 1] = '\0';
+
+    char *args[MAX_ARGS];
+    int   argc = parse_args(buf, args);
+    if (argc == 0) return;
+
+    pid_t pid = fork();
+    if (pid < 0) { perror("fork"); return; }
+    if (pid == 0) {
+        /* 子进程：从终端 stdin 读，输出到终端 stdout */
+        exec_cmd_in_child(args, argc, STDIN_FILENO, STDOUT_FILENO);
+    }
+    /* 父进程：等待子进程结束 */
+    waitpid(pid, NULL, 0);
+}
+
+/* =========================================================
+ * 第四步辅助函数：run_pipeline
+ *   执行多段管道命令。
+ *
+ *   核心思路（以 "A | B | C" 为例）：
+ *
+ *     终端stdin ──> [A] ──pipe0──> [B] ──pipe1──> [C] ──> 终端stdout
+ *
+ *   1. 创建 nseg-1 个管道（pipe0, pipe1, ...）
+ *   2. 依次 fork 每段命令的子进程，子进程拿到自己的 in_fd/out_fd
+ *   3. 父进程关闭所有管道端，然后等待全部子进程结束
+ * ========================================================= */
+static void run_pipeline(char *segments[], int nseg) {
+    int npipes = nseg - 1;
+
+    /* --- 1. 一次性创建所有管道 --- */
+    int pipes[MAX_PIPES][2];
+    for (int i = 0; i < npipes; i++) {
+        if (pipe(pipes[i]) < 0) {
+            perror("pipe");
+            /* 出错：关闭已创建的管道后返回 */
+            for (int j = 0; j < i; j++) {
+                close(pipes[j][0]);
+                close(pipes[j][1]);
+            }
+            return;
+        }
+    }
+
+    /* --- 2. 依次 fork 每段命令的子进程 --- */
+    pid_t pids[MAX_PIPES + 1];
+
+    for (int i = 0; i < nseg; i++) {
+
+        /* 确定本段从哪里读、往哪里写：
+         *   第一段：从终端 stdin 读
+         *   中间段：从上一个管道的读端读，向下一个管道的写端写
+         *   最后段：向终端 stdout 写                              */
+        int in_fd  = (i == 0)        ? STDIN_FILENO  : pipes[i - 1][0];
+        int out_fd = (i == nseg - 1) ? STDOUT_FILENO : pipes[i][1];
+
+        /* 解析本段命令的参数 */
+        char  cbuf[MAX_CMD];
+        strncpy(cbuf, segments[i], MAX_CMD - 1);
+        cbuf[MAX_CMD - 1] = '\0';
+        char *args[MAX_ARGS];
+        int   argc = parse_args(cbuf, args);
+
+        pid_t pid = fork();
+        if (pid < 0) {
+            perror("fork");
+            /* fork 失败：关闭所有管道，等待已启动的子进程 */
+            for (int j = 0; j < npipes; j++) {
+                close(pipes[j][0]);
+                close(pipes[j][1]);
+            }
+            for (int j = 0; j < i; j++) waitpid(pids[j], NULL, 0);
+            return;
+        }
+
+        if (pid == 0) {
+            /* 子进程：
+             *   关闭所有"不是自己用"的管道端，
+             *   防止 EOF 永远不到达读端。         */
+            for (int j = 0; j < npipes; j++) {
+                if (pipes[j][0] != in_fd)  close(pipes[j][0]);
+                if (pipes[j][1] != out_fd) close(pipes[j][1]);
+            }
+            if (argc == 0) exit(0);
+            exec_cmd_in_child(args, argc, in_fd, out_fd);
+            /* exec_cmd_in_child 内部会 exit，永远不会走到这里 */
+        }
+
+        pids[i] = pid;   /* 父进程记录子进程 PID */
+    }
+
+    /* --- 3. 父进程关闭所有管道端，再统一等待子进程 ---
+     *   必须先全部关闭，否则最后一段命令永远读不到 EOF。 */
+    for (int i = 0; i < npipes; i++) {
+        close(pipes[i][0]);
+        close(pipes[i][1]);
+    }
+    for (int i = 0; i < nseg; i++) {
+        waitpid(pids[i], NULL, 0);
+    }
+}
+
+/* =========================================================
+ * 顶层入口：execute
+ *   只做"分流"：
+ *     - 把命令行按 '|' 分段
+ *     - 1 段 → run_single
+ *     - 多段 → run_pipeline
+ * ========================================================= */
+void execute(char *cmdline) {
+    char  buf[MAX_CMD];
+    strncpy(buf, cmdline, MAX_CMD - 1);
+    buf[MAX_CMD - 1] = '\0';
+
+    char *segments[MAX_PIPES + 1];
+    int   nseg = split_pipeline(buf, segments, MAX_PIPES);
+
+    if (nseg <= 0) return;          /* 空命令或出错 */
+
+    if (nseg == 1) {
+        run_single(segments[0]);    /* 普通命令，无管道 */
+    } else {
+        run_pipeline(segments, nseg); /* 多段管道命令 */
+    }
+}
+
+/* =========================================================
+ * main：读取命令行，循环执行
+ * ========================================================= */
+int main() {
+    char cmdline[MAX_CMD];
+
+    while (1) {
+        printf("%% ");
+        fflush(stdout);
+
+        if (fgets(cmdline, MAX_CMD, stdin) == NULL) {
+            printf("\n");
+            break;
+        }
+
+        char *cmd = trim(cmdline);
+        if (strlen(cmd) == 0) continue;
+
+        if (strcmp(cmd, "exit") == 0 || strcmp(cmd, "logout") == 0) {
+            printf("Goodbye!\n");
+            break;
+        }
+
+        execute(cmd);
+    }
+    return 0;
+}

exp0.5/task53.c

@@ -0,0 +1,197 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#define INTERVAL_SEC 10
+#define LOG_FILE "log"
+
+static unsigned int compute_hash(const char *data, size_t len)
+{
+    unsigned int hash =0;
+    const unsigned char *p = (const unsigned char *)data;
+    size_t i,n = len /4;
+
+    for ( i = 0; i < n; i++)
+    {
+        unsigned int val = (unsigned int)p[i * 4] | ((unsigned int)p[i * 4 + 1] << 8) 
+                         | ((unsigned int)p[i * 4 + 2] << 16) | ((unsigned int)p[i * 4 + 3] << 24);
+        hash += val;    
+    }
+    
+    size_t rem = len % 4,base = n*4;
+    for ( i = 0; i < rem; i++)
+    {
+        hash += (unsigned int)p[base + i];
+    }
+    return hash;
+}
+
+
+static char *read_file(const char *path,size_t *out_len)
+{
+    int fd = open(path,O_RDONLY);
+    if (fd < 0)
+    {
+        return NULL;
+    }
+    
+    off_t size = lseek(fd,0,SEEK_END);
+    if (size < 0)
+    {
+        close(fd);
+        return NULL;
+    }
+    lseek(fd,0,SEEK_SET);
+
+    char *buf = malloc((size_t)size + 1);
+    if (!buf)
+    {
+        close(fd);
+        return NULL;
+    }
+    
+    ssize_t n = read(fd,buf,(size_t)size);
+    if (n < 0)
+    {
+        free(buf);
+        close(fd);
+        return NULL;
+    }
+
+    buf[n] = '\0';
+    *out_len = (size_t)n;
+    close(fd);
+    return buf;   
+}
+
+static void write_log(unsigned int hash)
+{
+    FILE *fp = fopen(LOG_FILE,"a");
+    if (!fp)
+    {
+        return;
+    }
+    
+    time_t now = time(NULL);
+    struct tm *tm_info = localtime(&now);
+    char time_str[20];
+    strftime(time_str,sizeof(time_str),"%Y-%m-%d %H:%M:%S",tm_info);
+
+    fprintf(fp,"%s  hash=%u\n",time_str,hash);
+    fclose(fp);
+}
+
+static void daemonize(void)
+{
+    pid_t pid = fork();
+    if (pid < 0)
+    {
+        exit(1);
+    }
+    if (pid > 0)
+    {
+        exit(0);
+    }
+
+    setsid();
+    umask(0);
+
+    close(STDIN_FILENO);
+    close(STDOUT_FILENO);
+    close(STDERR_FILENO);
+}
+
+
+int main(int argc,char *argv[])
+{
+    //自检模式
+    if (argc > 1 && strcmp(argv[1],"test") == 0)
+    {
+        /* 测试1: 不同内容应产生不同hash值 */
+        printf("自检模式\n");
+
+        const char *test_str = "Hello, World!";
+        unsigned int h1 = compute_hash(test_str,strlen(test_str));
+        
+        const char *test_str2 = "Hello, world!"; // 注意 'W' 和 'w'
+        unsigned int h2 = compute_hash(test_str2,strlen(test_str2));
+
+        printf("测试1: hash1=%u, hash2=%u\n",h1,h2);
+        if (h1 != h2)
+            printf("通过: 不同内容 -> 不同hash值\n");
+        else
+            printf("失败: 不同内容应产生不同的hash值\n");
+
+        
+            /* 测试2: 相同内容应产生相同hash值 */
+        unsigned int h3 = compute_hash(test_str,strlen(test_str));
+        printf("测试2: hash3=%u\n",h3);
+        if (h1 == h3)
+            printf("通过: 相同内容 -> 相同hash值\n");
+        else
+            printf("失败: 相同内容应产生相同的hash值\n");
+
+        /* 测试3: 读取自身并计算hash */
+        size_t len;
+        char *self = read_file("task53.c",&len);
+        if (self)
+        {
+            unsigned int hself = compute_hash(self,len);
+            printf("测试3: 自身hash=%u, 文件大小=%zu字节\n",hself,len);
+            free(self);
+        }
+        return 0;
+    }
+
+    /*
+     * 守护进程模式
+     * -f 表示前台运行(不调用daemonize), 便于测试
+     * 第二个参数可指定检查间隔秒数
+     */
+    int foreground = (argc > 1 && strcmp(argv[1],"-f") == 0);
+    int interval = INTERVAL_SEC;
+    if (argc > 2) interval = atoi(argv[2]);
+    if (interval <= 0) interval = INTERVAL_SEC;
+
+    if (!foreground) 
+    {
+        daemonize();
+    }
+
+    size_t len;
+    char *prev_data = read_file("test.log",&len);
+    if (!prev_data) return 1;
+    unsigned int prev_hash = compute_hash(prev_data,len);
+    
+    while (1)
+    {
+        sleep(interval);
+
+        size_t cur_len;
+        char *cur_data = read_file("test.log",&cur_len);
+        if (!cur_data)
+        {
+            continue;
+        }
+
+        unsigned int cur_hash = compute_hash(cur_data,cur_len);
+        if (cur_hash != prev_hash)
+        {
+            write_log(cur_hash);
+            free(prev_data);
+            prev_data = cur_data;
+            prev_hash = cur_hash;
+        }
+        else
+        {
+            free(cur_data);
+        }
+    }
+    free(prev_data);
+    return 0;
+}

exp0.5/task53_ai.c

@@ -0,0 +1,205 @@
+/*
+ * task53.c — 关键文件内容监控守护进程
+ *
+ * 功能: 每隔5分钟读取自身文件内容并计算hash值(数字指纹),
+ *       若hash值发生变化(文件被篡改), 则将检测时间和新hash值
+ *       写入日志文件 log。
+ *
+ * 用法:
+ *   ./task53           以守护进程方式后台运行(每5分钟检查一次)
+ *   ./task53 -f <秒>   前台运行, 可自定义检查间隔(便于测试)
+ *   ./task53 test      自检模式: 验证hash算法正确性
+ *
+ * hash算法: 将文件按4字节切分, 每段视为一个无符号整数(小端序),
+ *           累加各段得到hash值。不足4字节的剩余部分按单字节累加。
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#define INTERVAL_SEC (5 * 60)   /* 默认检查间隔: 5分钟 */
+#define LOG_FILE "log"          /* 日志文件名 */
+
+/*
+ * 计算数据的hash值(数字指纹)
+ * data: 文件内容指针, len: 数据长度(字节)
+ * 返回: 32位无符号hash值
+ */
+static unsigned int compute_hash(const char *data, size_t len)
+{
+    unsigned int hash = 0;
+    const unsigned char *p = (const unsigned char *)data;
+    size_t i, n = len / 4;   /* 完整的4字节段个数 */
+
+    /* 每4个字节拼成一个无符号整数(小端序: 低地址为低字节) */
+    for (i = 0; i < n; i++) {
+        unsigned int val = (unsigned int)p[i * 4]
+                         | ((unsigned int)p[i * 4 + 1] << 8)
+                         | ((unsigned int)p[i * 4 + 2] << 16)
+                         | ((unsigned int)p[i * 4 + 3] << 24);
+        hash += val;          /* 累加到hash值 */
+    }
+
+    /* 处理末尾不足4字节的剩余部分, 逐字节累加 */
+    size_t rem = len % 4, base = n * 4;
+    for (i = 0; i < rem; i++)
+        hash += (unsigned int)p[base + i];
+
+    return hash;
+}
+
+/*
+ * 读取整个文件到内存
+ * path: 文件路径, out_len: 输出参数, 返回文件长度
+ * 返回: 动态分配的缓冲区指针(调用者负责free), 失败返回NULL
+ */
+static char *read_file(const char *path, size_t *out_len)
+{
+    int fd = open(path, O_RDONLY);
+    if (fd < 0) return NULL;                /* 文件打开失败 */
+
+    /* 通过lseek获取文件大小 */
+    off_t size = lseek(fd, 0, SEEK_END);
+    if (size < 0) { close(fd); return NULL; }
+    lseek(fd, 0, SEEK_SET);                 /* 回到文件开头 */
+
+    char *buf = malloc((size_t)size + 1);    /* 多分配1字节放'\0' */
+    if (!buf) { close(fd); return NULL; }
+
+    ssize_t n = read(fd, buf, (size_t)size);
+    if (n < 0) { free(buf); close(fd); return NULL; }
+
+    buf[n] = '\0';                           /* 字符串结尾 */
+    *out_len = (size_t)n;
+    close(fd);
+    return buf;
+}
+
+/*
+ * 将篡改检测记录写入日志文件
+ * hash: 检测到的新hash值
+ * 日志格式: YYYY-MM-DD HH:MM:SS  hash=<值>
+ */
+static void write_log(unsigned int hash)
+{
+    FILE *fp = fopen(LOG_FILE, "a");        /* 追加模式打开日志 */
+    if (!fp) return;
+
+    time_t now = time(NULL);                 /* 获取当前时间 */
+    char ts[64];
+    strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S", localtime(&now));
+
+    fprintf(fp, "%s  hash=%u\n", ts, hash);  /* 写入时间和hash */
+    fclose(fp);
+}
+
+/*
+ * 将进程转为守护进程(daemon)
+ * 步骤: fork子进程并退出父进程 -> 创建新会话 -> 关闭标准IO
+ */
+static void daemonize(void)
+{
+    pid_t pid = fork();
+    if (pid < 0) exit(1);                   /* fork失败 */
+    if (pid > 0) exit(0);                   /* 父进程退出, 子进程继续 */
+
+    setsid();                                 /* 创建新会话, 脱离控制终端 */
+    umask(0);                                 /* 重置文件权限掩码 */
+
+    /* 关闭标准输入、输出、错误, 守护进程不需要终端IO */
+    close(STDIN_FILENO);
+    close(STDOUT_FILENO);
+    close(STDERR_FILENO);
+}
+
+int main(int argc, char *argv[])
+{
+    /*
+     * 自检模式: ./task53 test
+     * 验证hash算法 — 不同内容产生不同hash, 相同内容产生相同hash
+     */
+    if (argc > 1 && strcmp(argv[1], "test") == 0) {
+        printf("=== 自检模式 ===\n");
+
+        /* 测试1: 不同内容应产生不同hash值 */
+        const char *data1 = "hello world";
+        unsigned int h1 = compute_hash(data1, strlen(data1));
+        printf("hash(\"%s\") = %u\n", data1, h1);
+
+        const char *data2 = "hello worlD";   /* 仅一个字节不同 */
+        unsigned int h2 = compute_hash(data2, strlen(data2));
+        printf("hash(\"%s\") = %u\n", data2, h2);
+
+        if (h1 != h2)
+            printf("通过: 不同内容 -> 不同hash值\n");
+        else
+            printf("失败: 不同内容应产生不同的hash值\n");
+
+        /* 测试2: 相同内容应产生相同hash值 */
+        unsigned int h3 = compute_hash(data1, strlen(data1));
+        if (h1 == h3)
+            printf("通过: 相同内容 -> 相同hash值\n");
+        else
+            printf("失败: 相同内容应产生相同的hash值\n");
+
+        /* 测试3: 读取自身并计算hash */
+        size_t len;
+        char *self = read_file("task53.c", &len);
+        if (self) {
+            unsigned int hself = compute_hash(self, len);
+            printf("自身hash = %u, 文件大小 = %zu 字节\n", hself, len);
+            free(self);
+        }
+        return 0;
+    }
+
+    /*
+     * 守护进程模式
+     * -f 表示前台运行(不调用daemonize), 便于测试
+     * 第二个参数可指定检查间隔秒数
+     */
+    int foreground = (argc > 1 && strcmp(argv[1], "-f") == 0);
+    int interval = INTERVAL_SEC;
+    if (argc > 2) interval = atoi(argv[2]);   /* 自定义检查间隔 */
+    if (interval <= 0) interval = INTERVAL_SEC;
+
+    if (!foreground) daemonize();             /* 后台模式则转为守护进程 */
+
+    /* 读取文件初始快照, 计算基准hash值 */
+    size_t len;
+    char *prev_data = read_file("task53.c", &len);
+    if (!prev_data) return 1;                 /* 读取失败则退出 */
+    unsigned int prev_hash = compute_hash(prev_data, len);
+
+    /* 主循环: 每隔interval秒检查一次 */
+    while (1) {
+        sleep(interval);
+
+        /* 重新读取文件内容 */
+        size_t cur_len;
+        char *cur_data = read_file("task53.c", &cur_len);
+        if (!cur_data) continue;              /* 读取失败则跳过本次 */
+
+        /* 计算当前hash并与基准hash比较 */
+        unsigned int cur_hash = compute_hash(cur_data, cur_len);
+        if (cur_hash != prev_hash) {
+            /* 检测到篡改: 写入日志 */
+            write_log(cur_hash);
+            /* 更新基准快照, 避免同一修改被重复记录 */
+            free(prev_data);
+            prev_data = cur_data;
+            prev_hash = cur_hash;
+        } else {
+            free(cur_data);                   /* 未变化则释放当前数据 */
+        }
+    }
+
+    free(prev_data);
+    return 0;
+}

exp0.5/task54.c

@@ -0,0 +1,243 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <errno.h>
+
+#define MAX_CHILDREN 1024
+#define MAX_LINE     256
+
+static pid_t child_pids[MAX_CHILDREN];
+static int   child_count = 0;
+
+static void sigchld_handler(int sig){
+    int saved_errno = errno;
+    pid_t pid;
+    int   status;
+
+    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
+        printf("[SIGCHLD] 子进程 %d 已终止", pid);
+        if (WIFEXITED(status))
+            printf(", 退出码=%d", WEXITSTATUS(status));
+        if (WIFSIGNALED(status))
+            printf(", 被信号 %d (%s) 终止", WTERMSIG(status),
+                   (WTERMSIG(status) == SIGTERM) ? "SIGTERM" : "");
+        printf("\n");
+
+        for (int i = 0; i < child_count; i++) {
+            if (child_pids[i] == pid) {
+                child_pids[i] = child_pids[child_count - 1];
+                child_count--;
+                break;
+            }
+        }
+    }
+    errno = saved_errno;
+}
+
+static void child_main(void)
+{
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = SIG_DFL;
+    sigemptyset(&sa.sa_mask);
+
+    sigset_t mask;
+    sigemptyset(&mask);
+    sigaddset(&mask, SIGTERM);
+    sigprocmask(SIG_BLOCK, &mask, NULL);
+
+    printf("子进程 %d 启动\n", getpid());
+
+    /* 等待 SIGTERM 信号 */
+    int sig;
+    sigwait(&mask, &sig);
+
+    printf("killed by parent\n");
+    exit(100);
+}
+
+static void cmd_create(int n)
+{
+    sigset_t block_mask, old_mask;
+
+    sigemptyset(&block_mask);
+    sigaddset(&block_mask, SIGCHLD);
+    sigprocmask(SIG_BLOCK, &block_mask, &old_mask);
+
+    int created = 0;
+    for (int i = 0; i < n; i++) {
+        if (child_count >= MAX_CHILDREN) {
+            printf("子进程数已达上限 %d\n", MAX_CHILDREN);
+            break;
+        }
+        pid_t pid = fork();
+        if (pid < 0) {
+            perror("fork");
+            break;
+        }
+        if (pid == 0) {
+            sigprocmask(SIG_SETMASK, &old_mask, NULL);
+            child_main();
+        }
+        child_pids[child_count++] = pid;
+        created++;
+    }
+
+    sigprocmask(SIG_SETMASK, &old_mask, NULL);
+
+    if (created > 0) {
+        printf("已创建 %d 个子进程:", created);
+        for (int i = child_count - created; i < child_count; i++)
+            printf(" %d", child_pids[i]);
+        printf("\n");
+    }
+}
+
+static void cmd_kill(int n, pid_t *pids)
+{
+    for (int i = 0; i < n; i++) {
+        int found = 0;
+        for (int j = 0; j < child_count; j++) {
+            if (child_pids[j] == pids[i]) {
+                found = 1;
+                break;
+            }
+        }
+        if (!found) {
+            printf("PID %d 不是当前管理的子进程, 跳过\n", pids[i]);
+            continue;
+        }
+        if (kill(pids[i], SIGTERM) == 0) {
+            printf("已向子进程 %d 发送终止信号\n", pids[i]);
+        } else {
+            perror("kill");
+        }
+    }
+}
+
+static void cmd_ps(void)
+{
+    sigset_t block_mask, old_mask;
+
+    sigemptyset(&block_mask);
+    sigaddset(&block_mask, SIGCHLD);
+    sigprocmask(SIG_BLOCK, &block_mask, &old_mask);
+
+    if (child_count == 0) {
+        printf("当前无子进程\n");
+    } else {
+        printf("当前子进程 (%d 个):", child_count);
+        for (int i = 0; i < child_count; i++)
+            printf(" %d", child_pids[i]);
+        printf("\n");
+    }
+
+    sigprocmask(SIG_SETMASK, &old_mask, NULL);
+}
+
+static void process_command(char *line)
+{
+    size_t len = strlen(line);
+    if (len > 0 && line[len - 1] == '\n')
+    {
+        line[len - 1] = '\0';
+    }
+    if (len == 0)
+    {
+        return;
+    }
+
+    char *cmd = strtok(line, " ");
+    if (!cmd)
+    {
+        return;
+    }
+    
+    if (strcmp(cmd, "create") == 0) {
+        char *arg = strtok(NULL, " ");
+        if (!arg) {
+            printf("用法: create <n>\n");
+            return;
+        }
+        int n = atoi(arg);
+        if (n <= 0) {
+            printf("无效的子进程数量: %s\n", arg);
+            return;
+        }
+        cmd_create(n);
+
+    }
+    else if (strcmp(cmd, "kill") == 0) {
+        pid_t pids[256];
+        int n = 0;
+        char *arg;
+        while ((arg = strtok(NULL, " ")) && n < 256) {
+            pids[n++] = atoi(arg);
+        }
+        if (n == 0) {
+            printf("用法: kill <P1> <P2> ...\n");
+            return;
+        }
+        cmd_kill(n, pids);
+
+    } else if (strcmp(cmd, "ps") == 0) {
+        char *arg = strtok(NULL, " ");
+        if (!arg || strcmp(arg, "-u") != 0) {
+            printf("用法: ps -u\n");
+            return;
+        }
+        cmd_ps();
+
+    } else if (strcmp(cmd, "exit") == 0) {
+        sigset_t block_mask, old_mask;
+        sigemptyset(&block_mask);
+        sigaddset(&block_mask, SIGCHLD);
+        sigprocmask(SIG_BLOCK, &block_mask, &old_mask);
+        int remaining = child_count;
+        sigprocmask(SIG_SETMASK, &old_mask, NULL);
+
+        if (remaining > 0) {
+            printf("还有 %d 个子进程未终止, 请先 kill 或等待其结束\n", remaining);
+            return;
+        }
+        printf("所有子进程已结束, 父进程退出\n");
+        exit(0);
+
+    } else {
+        printf("未知命令: %s\n", cmd);
+        printf("支持: create <n> | kill <P1> ... | ps -u | exit\n");
+    }
+}
+
+int main(void)
+{
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = sigchld_handler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
+        sigaction(SIGCHLD, &sa, NULL);
+
+    /* 忽略 SIGTERM, 父进程不会被意外终止 */
+    signal(SIGTERM, SIG_IGN);
+
+    printf("=== 子进程管理程序 ===\n");
+    printf("命令: create <n> | kill <P1> <P2> ... | ps -u | exit\n");
+
+    char line[MAX_LINE];
+    while (1) {
+        printf("> ");
+        fflush(stdout);
+        if (!fgets(line, sizeof(line), stdin)) 
+        {
+            break;  /* EOF */
+        }
+        process_command(line);
+    }
+
+    printf("父进程退出\n");
+    return 0;
+}

exp0.5/task54_ai.c

@@ -0,0 +1,257 @@
+/*
+ * task54.c — 子进程管理程序
+ *
+ * 借鉴 sigmask.c 的信号掩码方法管理子进程:
+ *   1. 在操作子进程列表时阻塞 SIGCHLD, 防止信号处理程序并发修改
+ *   2. 通过 sigwait / signal handler 等待子进程终止
+ *
+ * 支持命令:
+ *   create <n>    创建 n 个子进程, 显示各子进程 PID
+ *   kill <P1> ... 终止指定 PID 的子进程, 子进程打印 "killed by parent" 后退出
+ *   ps -u         显示当前存活子进程列表
+ *   exit          等待所有子进程结束后退出父进程
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <errno.h>
+
+#define MAX_CHILDREN 1024
+#define MAX_LINE     256
+
+/* 子进程 PID 列表, 受 SIGCHLD 信号保护 */
+static pid_t child_pids[MAX_CHILDREN];
+static int   child_count = 0;
+
+/* ---------- SIGCHLD 信号处理程序 ---------- */
+static void sigchld_handler(int sig)
+{
+    int saved_errno = errno;
+    pid_t pid;
+    int   status;
+
+    /* 回收所有已终止的子进程, 不阻塞 */
+    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
+        printf("[SIGCHLD] 子进程 %d 已终止", pid);
+        if (WIFEXITED(status))
+            printf(", 退出码=%d", WEXITSTATUS(status));
+        if (WIFSIGNALED(status))
+            printf(", 被信号 %d (%s) 终止", WTERMSIG(status),
+                   (WTERMSIG(status) == SIGTERM) ? "SIGTERM" : "");
+        printf("\n");
+
+        /* 从列表中移除该 PID */
+        for (int i = 0; i < child_count; i++) {
+            if (child_pids[i] == pid) {
+                child_pids[i] = child_pids[child_count - 1];
+                child_count--;
+                break;
+            }
+        }
+    }
+    errno = saved_errno;
+}
+
+/* ---------- 子进程执行的代码 ---------- */
+static void child_main(void)
+{
+    /* 安装 SIGTERM 处理: 打印消息后退出 */
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = SIG_DFL;        /* 先恢复默认以便后续操作 */
+    sigemptyset(&sa.sa_mask);
+
+    /* 子进程: 等待 SIGTERM 信号后打印信息并退出 */
+    sigset_t mask;
+    sigemptyset(&mask);
+    sigaddset(&mask, SIGTERM);
+    sigprocmask(SIG_BLOCK, &mask, NULL);   /* 阻塞 SIGTERM, 用 sigwait 同步等待 */
+
+    int sig;
+    sigwait(&mask, &sig);                   /* 等待 SIGTERM */
+
+    printf("killed by parent\n");
+    exit(100);
+}
+
+/* ---------- 创建子进程 ---------- */
+static void cmd_create(int n)
+{
+    sigset_t block_mask, old_mask;
+
+    /* 阻塞 SIGCHLD, 防止 handler 并发修改 child_pids */
+    sigemptyset(&block_mask);
+    sigaddset(&block_mask, SIGCHLD);
+    sigprocmask(SIG_BLOCK, &block_mask, &old_mask);
+
+    int created = 0;
+    for (int i = 0; i < n; i++) {
+        if (child_count >= MAX_CHILDREN) {
+            printf("子进程数已达上限 %d\n", MAX_CHILDREN);
+            break;
+        }
+        pid_t pid = fork();
+        if (pid < 0) {
+            perror("fork");
+            break;
+        }
+        if (pid == 0) {
+            /* 子进程: 恢复默认信号掩码, 执行子进程代码 */
+            sigprocmask(SIG_SETMASK, &old_mask, NULL);
+            child_main();
+            /* child_main 不会返回 */
+        }
+        /* 父进程: 记录子进程 PID */
+        child_pids[child_count++] = pid;
+        created++;
+    }
+
+    /* 恢复信号掩码 */
+    sigprocmask(SIG_SETMASK, &old_mask, NULL);
+
+    if (created > 0) {
+        printf("已创建 %d 个子进程:", created);
+        /* 新创建的 PID 在列表末尾 */
+        for (int i = child_count - created; i < child_count; i++)
+            printf(" %d", child_pids[i]);
+        printf("\n");
+    }
+}
+
+/* ---------- 终止指定子进程 ---------- */
+static void cmd_kill(int n, pid_t *pids)
+{
+    for (int i = 0; i < n; i++) {
+        /* 检查 PID 是否在管理列表中 */
+        int found = 0;
+        for (int j = 0; j < child_count; j++) {
+            if (child_pids[j] == pids[i]) {
+                found = 1;
+                break;
+            }
+        }
+        if (!found) {
+            printf("PID %d 不是当前管理的子进程, 跳过\n", pids[i]);
+            continue;
+        }
+        /* 发送 SIGTERM, 子进程的 sigwait 会捕获并处理 */
+        if (kill(pids[i], SIGTERM) == 0) {
+            printf("已向子进程 %d 发送终止信号\n", pids[i]);
+        } else {
+            perror("kill");
+        }
+    }
+    /* SIGCHLD handler 会自动回收并清理列表 */
+}
+
+/* ---------- 显示当前子进程列表 ---------- */
+static void cmd_ps(void)
+{
+    sigset_t block_mask, old_mask;
+
+    /* 阻塞 SIGCHLD, 安全读取列表 */
+    sigemptyset(&block_mask);
+    sigaddset(&block_mask, SIGCHLD);
+    sigprocmask(SIG_BLOCK, &block_mask, &old_mask);
+
+    if (child_count == 0) {
+        printf("当前无子进程\n");
+    } else {
+        printf("当前子进程 (%d 个):", child_count);
+        for (int i = 0; i < child_count; i++)
+            printf(" %d", child_pids[i]);
+        printf("\n");
+    }
+
+    sigprocmask(SIG_SETMASK, &old_mask, NULL);
+}
+
+/* ---------- 命令行解析与执行 ---------- */
+static void process_command(char *line)
+{
+    /* 去掉末尾换行符 */
+    size_t len = strlen(line);
+    if (len > 0 && line[len - 1] == '\n') line[len - 1] = '\0';
+    if (len == 0) return;
+
+    /* 提取第一个 token */
+    char *cmd = strtok(line, " ");
+    if (!cmd) return;
+
+    if (strcmp(cmd, "create") == 0) {
+        char *arg = strtok(NULL, " ");
+        if (!arg) { printf("用法: create <进程数>\n"); return; }
+        int n = atoi(arg);
+        if (n <= 0) { printf("进程数必须为正整数\n"); return; }
+        cmd_create(n);
+
+    } else if (strcmp(cmd, "kill") == 0) {
+        pid_t pids[256];
+        int   n = 0;
+        char *arg;
+        while ((arg = strtok(NULL, " ")) && n < 256)
+            pids[n++] = atoi(arg);
+        if (n == 0) { printf("用法: kill <P1> <P2> ...\n"); return; }
+        cmd_kill(n, pids);
+
+    } else if (strcmp(cmd, "ps") == 0) {
+        char *arg = strtok(NULL, " ");
+        if (!arg || strcmp(arg, "-u") != 0) {
+            printf("用法: ps -u\n");
+            return;
+        }
+        cmd_ps();
+
+    } else if (strcmp(cmd, "exit") == 0) {
+        /* 检查是否还有子进程存活 */
+        sigset_t block_mask, old_mask;
+        sigemptyset(&block_mask);
+        sigaddset(&block_mask, SIGCHLD);
+        sigprocmask(SIG_BLOCK, &block_mask, &old_mask);
+        int remaining = child_count;
+        sigprocmask(SIG_SETMASK, &old_mask, NULL);
+
+        if (remaining > 0) {
+            printf("还有 %d 个子进程未终止, 请先 kill 或等待其结束\n", remaining);
+            return;
+        }
+        printf("所有子进程已结束, 父进程退出\n");
+        exit(0);
+
+    } else {
+        printf("未知命令: %s\n", cmd);
+        printf("支持: create <n> | kill <P1> ... | ps -u | exit\n");
+    }
+}
+
+int main(void)
+{
+    /* 安装 SIGCHLD 处理程序 */
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = sigchld_handler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;  /* 仅在子进程终止时通知, 自动重启慢速系统调用 */
+    sigaction(SIGCHLD, &sa, NULL);
+
+    /* 忽略 SIGTERM, 父进程不会被意外终止 */
+    signal(SIGTERM, SIG_IGN);
+
+    printf("=== 子进程管理程序 ===\n");
+    printf("命令: create <n> | kill <P1> <P2> ... | ps -u | exit\n");
+
+    char line[MAX_LINE];
+    while (1) {
+        printf("> ");
+        fflush(stdout);
+        if (!fgets(line, sizeof(line), stdin)) break;  /* EOF */
+        process_command(line);
+    }
+
+    printf("\n父进程退出\n");
+    return 0;
+}