【Linux】自主 Shell

作者:H.莓飛日期:2026/10/22

【Linux】自主 Shell


🔥 H.莓飛: 个人主页

❄️个人专栏:「C++」「数据结构」「Linux系统编程」

✨ 心不畏死,踏屍前行。

📦 代码仓库:cocatrice_csdn_code


📖 博主简介:


概览

  • shell、提示符、命令
  • 参数表与外部命令
  • cd 与 export 等内建命令
  • 退出码与 $?
  • 环境表、导出与继承

核心知识

一、shell是什么

前面三篇把进程创建、进程等待、程序替换拆开讲过了,fork 造出子进程,exec 把子进程换成新程序,wait 把退出码收回来。这三件事单独看都不复杂,麻烦的是把它们按顺序摆好,并且摆在正确的进程里。命令行解释器正好是这三件事凑在一起的地方,它自己不能换程序,也不能替子进程切目录,还得记住上一个命令跑成什么样。

这一篇从零写一个小 shell,功能不多,能跑通 ls、pwd 这类外部命令,也能处理 cd、export、env、echo、exit 这几个必须自己动手的内建命令。写完之后拿同一串命令和 bash 对一遍,差别在哪里就看得清楚了。

图 1 shell 的死循环骨架

从命令行上收到的每一次回车开始,shell 要做的就是四件事:把提示符打到屏幕上,等用户敲完一行,把那行切成一张参数表,然后执行。执行完之后回到开头接着打提示符,这个过程没有终点,除非读到输入结束或者用户敲了 exit,所以骨架就是一个死循环。

1int main(void)
2{
3    char line[MAX_LINE];
4
5    init_env();
6    while (1) {
7        print_prompt();
8        if (read_line(line, sizeof(line)) != 1)
9            continue;
10        if (parse_line(line) == 0)
11            continue;
12        if (check_builtin())
13            continue;
14        run_external();
15    }
16    return 0;
17}
18

四个函数各管一段,读一行、切表、看是不是内建、不是内建就走外部命令那条路。真正干活的只有最后一步,前三步都在准备材料。

执行外部命令的时候,shell 自己留在原地不动,fork 出一个子进程去换程序,父进程用 waitpid 停在原地等。这一点可以在真机上看到,让这个小 shell 跑一条 sleep 2,另开一个会话用 ps 看这两个进程:

1$ ps -o pid,ppid,pgid,stat,wchan:20,comm -p 3841,3842
2  PID  PPID  PGID STAT WCHAN                COMMAND
3 3841  3839  3839 S    do_wait              myshell_stage2
4 3842  3841  3841 S    hrtimer_nanosleep    sleep
5

父进程的状态是 S,蹲在内核的 do_wait 上,子进程同样不占 CPU,蹲在 hrtimer_nanosleep 上等定时器。父子两个的进程组号都是 3839,也就是它们和启动它的那个会话在同一组里。这两个读数说明一件事,shell 等命令的时候是睡着的,不烧 CPU。

二、提示符

提示符看起来是三个词拼起来的,[用户名@主机名 目录]#。用户名从 USER 这个环境变量里拿,主机名从 HOSTNAME 里拿,目录用 getcwd 取当前工作目录,再取最后一个斜杠之后的部分。

1static const char *user_name(void)
2{
3    char *v = getenv("USER");
4    return (v == NULL || v[0] == '\0') ? "None" : v;
5}
6
7static const char *host_name(void)
8{
9    char *v = getenv("HOSTNAME");
10    return (v == NULL || v[0] == '\0') ? "None" : v;
11}
12
13static const char *last_dir(void)
14{
15    const char *p = cur_dir();
16    const char *s;
17
18    if (strcmp(p, "/") == 0 || strcmp(p, "None") == 0)
19        return p;
20    s = strrchr(p, '/');
21    return (s == NULL) ? p : s + 1;
22}
23

这里藏着一个真机上才看得见的问题,用 ssh 跑非交互命令的时候,环境表里根本没有 HOSTNAME 这一条:

1$ env | grep -c '^HOSTNAME='
20
3$ bash -lc 'echo $HOSTNAME'
4hcss-ecs-4cd1
5$ bash -lc 'env | grep -c "^HOSTNAME="'
60
7

bash 自己的变量 HOSTNAME 是有值的,但它没有导出,所以子进程的 getenv 拿不到。最后拼出来的提示符就成了 [cocatrice@None src]#,主机名那一格是 None。这不是代码写错了,是提示符依赖了一个通常不存在的环境变量。要主机名的话,用 gethostname 更稳当,同一台机器上它给的是 hcss-ecs-4cd1。

提示符拼好之后必须刷出去,这一点在重定向到文件的时候特别明显。把 fflush(stdout) 那一行删掉,两个版本同时跑一条 sleep 3,标准输入用管道撑着不让它断:

1$ ( printf 'sleep 3\n'; sleep 8 ) | ./bin/myshell_withflush > out/with.txt
2$ ( printf 'sleep 3\n'; sleep 8 ) | ./bin/myshell_noflush  > out/no.txt
3
4第 1 秒:with.txt 22 字节,no.txt 0 字节
5第 4 秒:with.txt 82 字节,no.txt 0 字节
6

带 fflush 的那一份在第 1 秒就已经有内容了,不带的那一份要等到缓冲区攒满或者程序退出才吐出来。终端上两者看起来差不多,重定向到文件就变成一个看得见一个看不见。

图 2 提示符的三样东西

三、读入命令

读一行用 fgets,它读满一行就停,行尾的换行符会一起带进来,所以要把最后那个换行符改成结束符。听起来只有三步,真机上跑起来有四种情况要分开:正常读到一行、读到文件结尾、读到一个空行、读到一行长到装不下。

第一版的读法只有成与不成两种回音,读到结尾就回到循环开头,结果提示符开始疯狂刷屏。只喂一行 ls,两秒钟吐出来 25397770 字节,而 wc -l 数出来只有 2 行,因为那些提示符全挤在同一行里没有换行。把读到的结尾改成跳出循环,刷屏停了,但空行也被当成了收工信号,输完一个空白行 shell 就退出了。

1/* 三种回音:-1 读到尾巴了,0 是空行或者一行长到装不下,1 是真有一行 */
2static int read_line(char *buf, int size)
3{
4    char *nl;
5    int   c;
6
7    if (fgets(buf, size, stdin) == NULL)
8        return -1;
9    nl = strchr(buf, '\n');
10    if (nl == NULL && !feof(stdin)) {
11        while ((c = getchar()) != '\n' && c != EOF)
12            ;
13        printf("这一行超过 %d 个字节,丢掉了\n", size - 1);
14        return 0;
15    }
16    if (nl != NULL)
17        *nl = '\0';
18    return (strlen(buf) == 0) ? 0 : 1;
19}
20

分开之后这一趟就干净了,只喂一行 ls,输出 92 字节,shell 打完收工两个字退出,退出码 0。同样是这一行输入,前面那一版吐了 2500 多万字节。

换行符的处理还有一个边界,行尾没有换行符的时候,buf[strlen(buf) - 1] 指向的是最后一个有效字符而不是换行符,那一刀砍下去就把命令的最后一个字符切没了。喂进去 ls -a,切出来的参数表里第二个词变成了一个减号:

1$ printf 'ls -a' | ./bin/myshell_stage1
2argv[0] = [ls]
3argv[1] = [-]
4

这不是拼错了命令,是行尾少了那个换行符,去掉换行的写法却照砍不误。改过的版本用 strchr 找换行符,找到了才替换成结束符,没找到就原样留着。

还有一件跟缓冲区有关的事,fgets 一次最多读 size - 1 个字节,超出的部分留在输入流里,下一次调用接着读。所以一行 1104 字节的命令会被切成两条:前面 1023 字节当一条命令,剩下的当另一条。修好的版本在发现这一行没读到换行符时把整行剩下的字符读走丢掉,这一行整条丢弃并说一声:

1$ python -c "print('echo ' + 'A'*1200)" > in_long.txt
2$ printf 'echo 短句\n' >> in_long.txt
3这一行超过 1023 个字节,丢掉了
4短句
5

图 3 读一行的三条岔路

四、把一行切成一张表

切参数用的是 strtok,第一次调用传缓冲区,之后每传一个空指针就接着往下切。切出来的每个词是一个字符串,装进一张指针数组,这张表必须在末尾放一个空指针,因为 exec 系列函数就是靠这个空指针来判断参数到哪里结束的。

1/* 空格和制表符都算分隔,返回切出几个词 */
2static int parse_line(char *buf)
3{
4    char *tok;
5    int   n = 0;
6
7    memset(g_argv, 0, sizeof(g_argv));
8    for (tok = strtok(buf, " \t"); tok != NULL && n < MAX_ARG - 1; tok = strtok(NULL, " \t"))
9        g_argv[n++] = tok;
10    g_argc = n;
11    return n;
12}
13

分隔符只写一个空格的时候,制表符就不算分隔。喂一行用制表符隔开的 ls 进去,切出来只有 1 个词,里面还夹着那个制表符:

1$ printf 'ls\t-a\t-l\n' | ./bin/myshell_stage1
2argv[0] = [ls	-a	-l]
3argc = 1
4
5$ printf 'ls -a -l -n\n' | ./bin/myshell_stage1
6argv[0] = [ls] argv[1] = [-a] argv[2] = [-l] argv[3] = [-n]
7argc = 4
8

连续多个空格不算多切,strtok 会把连续的分隔符当成一个。喂四个空格隔开的两个词,切出来是 2 个,不是 5 个。

空行和全空格行要小心,strtok 在全是分隔符的串上返回空指针,如果直接把这个值当成命令名用,argv[0] 就是个空指针,再往下走一步程序就崩了。修好的版本让 parse_line 返回词的个数,主循环看到 0 就直接跳过。

图 4 切成以空指针收尾的参数表

五、执行外部命令

外部命令没法在 shell 自己身上执行,因为 exec 一执行成功,shell 这个进程就变成那条命令了,命令跑完进程结束,提示符再也不会出现。所以要先 fork,让子进程去换程序,父进程留在原地等它结束。

1static void run_external(void)
2{
3    pid_t id;
4    int   status = 0;
5
6    id = fork();
7    if (id < 0) {
8        printf("fork 失败:%s\n", strerror(errno));
9        g_last = 1;
10        return;
11    }
12    if (id == 0) {
13        execvp(g_argv[0], g_argv);
14        printf("myshell: 找不到命令 %s\n", g_argv[0]);
15        fflush(stdout);
16        _exit(127);
17    }
18    if (waitpid(id, &status, 0) > 0) {
19        if (WIFEXITED(status))
20            g_last = WEXITSTATUS(status);
21        else if (WIFSIGNALED(status))
22            g_last = 128 + WTERMSIG(status);
23        else
24            g_last = 100;
25    }
26}
27

用 strace 跟着看一遍,一条命令在系统调用层就是三行。第一条 clone 造出子进程,第二条 execve 把子进程换成新程序,第三条 wait4 收回结果:

1$ strace -f -e trace=clone,execve,wait4 ./bin/myshell_stage2
2clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, ...) = 2976
3wait4(2977, <unfinished ...>)
4execve("/home/cocatrice/lab15/bin/argprint", ["argprint", "一"], 23 vars) = 0
5wait4 resumed [{WIFEXITED(s) && WEXITSTATUS(s) == 0}] = 2977
6--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_status=0, si_utime=0, si_stime=0} ---
7

wait4 那一行的 unfinished 和 resumed 两段是同一个调用被打断过一次的痕迹,父进程在等的时候让出了 CPU。想要更细的现场,可以让 gdb 跟着子进程走,断在 exec 上:

1$ gdb -q -batch -ex "set follow-fork-mode child" -ex "catch exec" \
2      -ex "run < out/in_one_cmd.txt" ./bin/myshell_stage2
3Attaching after process 3160 fork to child process 3160.
4Catchpoint 1 (exec'd /usr/bin/ls), 0x00007ffff7ddc140 in _start () from /lib64/ld-linux-x86-64.so.2
5

停下来的时候已经在新程序里了,栈顶那个 _start 是动态链接器准备的入口,原来的 myshell 代码一行都不在了。

命令找不到的时候,子进程里 exec 失败会返回,所以需要一个兜底的出口。素材那一版直接在子进程里 exit(1),父进程收回来就是 1,看起来和命令真的失败没区别。bash 在这个场景上给的是 127,改过的版本跟着 127 走,并且在冒号后面把命令名打出来,方便对账。

图 5 执行一条外部命令

六、内建命令

有几条命令没法交给子进程,cd 改的是进程自己的工作目录,子进程 chdir 成功之后,改变的是子进程的记录,子进程一退出就没了,父进程还在原来的目录里。写一个小程序 cd_ext 试一次就很清楚:

1$ cd_ext /home
2cd_ext: 我这个进程现在在 [/home]
3[子进程 4831 退出,退出码 0]
4
5$ /bin/pwd
6/home/cocatrice/lab15/src
7

子进程确实到了 /home,父进程问下来还是原来那个目录。所以 cd 必须在 shell 这个进程里自己做,它是内建命令。同样的道理适用于 export、env、exit,它们改的都是 shell 自己的状态。

1static int builtin_cd(void)
2{
3    char buf[MAX_LINE];
4    char old[MAX_LINE];
5    char *p;
6
7    if (g_argc != 2) {
8        printf("用法:cd 目录\n");
9        g_last = 1;
10        return 1;
11    }
12    p = getcwd(old, sizeof(old));
13    if (chdir(g_argv[1]) != 0) {
14        printf("cd 失败:%s(errno = %d)\n", strerror(errno), errno);
15        g_last = 1;
16        return 1;
17    }
18    if (getcwd(g_pwd, sizeof(g_pwd)) == NULL) {
19        g_last = 1;
20        return 1;
21    }
22    if (p != NULL) {
23        snprintf(buf, sizeof(buf), "OLDPWD=%s", old);
24        set_env(buf);
25    }
26    snprintf(buf, sizeof(buf), "PWD=%s", g_pwd);
27    set_env(buf);
28    g_last = 0;
29    return 1;
30}
31

这里比素材那一版多了两件事,chdir 的返回值要看,切换目录成功之后把 PWD 和 OLDPWD 同步进环境表。素材那一版 chdir 之后不看返回值,就算目录不存在也把退出码置成 0,试一次就露馅:

1$ cd /nonexistent
2$ echo $?
30
4$ /bin/pwd
5/home/cocatrice/lab15/src
6

目录没换,退出码却是 0,脚本里用它做判断就会走错分支。改过之后这一趟给的是 cd 失败:No such file or directory(errno = 2),退出码 1。

图 6 内建命令与外部命令的分界

七、echo $?

上一条命令跑成什么样,shell 得记着,记的地方是一个全局的整数。每次外部命令结束,父进程从 waitpid 拿回来的状态里取出退出码存进去;每次内建命令结束,由它自己把这个数写好。echo $? 做的事就是把存的这个数打出来,然后把清零。

1static int builtin_echo(void)
2{
3    if (g_argc == 2) {
4        if (g_argv[1][0] == 36 && g_argv[1][1] == 63) {   /* 那个词就是 $? */
5            printf("%d\n", g_last);
6            g_last = 0;
7        } else {
8            printf("%s\n", g_argv[1]);
9            g_last = 0;
10        }
11    } else {
12        printf("echo 这里一次只认一个词\n");
13        g_last = 3;
14    }
15    return 1;
16}
17

这里有个容易想偏的地方,$? 不是内核提供的东西,它是 shell 自己的一个变量。子进程的退出码只有父进程通过 wait 能拿到,别的进程拿不到,所以想把上一个命令的结果告诉下一个命令,shell 只能自己记一份。

只认这一个 $- 开头的词,别的照原样打出来。四种写法在真机上的表现是这样的:

1$ echo hello
2hello
3$ echo $?
40
5$ echo $PATH
6
7$ echo a b
8echo 这里一次只认一个词
9$ echo $?
103
11

第二个 $PATH 那一格什么都没有,因为代码只判断了这个词的头两个字符是不是 $ 和 ?,是别的字母就既不展开也不打印。参数给了两个词的情况把退出码置成 3 并提示一句,这样 $? 有迹可循,不会静悄悄地什么也不做。

八、环境变量表

环境变量在这个小程序里有两条路可走,一条是直接改进程自己的 environ,另一条是自己拷一份数组,exec 的时候把这一份传下去,两条路都试过,各自的坑不一样。

先说不拷的那一路,putenv 的参数是指针,它不复制字符串,只是把指针塞进 environ 里。如果传进去的是一个循环里的局部缓冲区,下一条命令一执行,那块内存就被覆盖了,环境表里那一条也跟着变成别的东西:

1$ export MARK=hello
2$ env_child MARK
3env_child: MARK=(没有这个变量)
4

明明刚导出,子进程却问不到,原因就出在那块缓冲区上,第二条命令把里头的字覆盖掉之后,environ 里那一条已经不是完整的赋值语句了,getenv 按名字去匹配自然匹配不上。要避掉这个坑,set_env 里必须自己做一份拷贝,并且把拷贝的地址交给 putenv。

再说拷一份的那一路,素材那一版在开局把 environ 逐条拷进 g_env,导出新变量往 g_env 后面追加,exec 的时候用 execvpe 把 g_env 传下去。这条路能让子进程看见新导出的变量,实测是成功的:

1$ export MARK=hello
2$ env_child MARK
3env_child: MARK=hello
4
5$ env_child PWD
6env_child: PWD=/home/cocatrice/lab15/src
7

麻烦在于这份拷贝和 environ 是两份东西。putenv 改的是 environ,g_env 里那条不会跟着动。素材那一版的 cur_dir 里就用了 putenv 同步 PWD,结果 cd /home 之后 /bin/pwd 报的是 /home,而 env 内建打出来的 PWD 还是旧目录:

1$ cd /home
2$ /bin/pwd
3/home
4$ env | grep PWD
5PWD=/home/cocatrice/lab15/src
6

三处读数对不上,脚本里按环境变量判断目录就会走错。改过的版本改成先改自己的那一份,再把同一份拷贝交给 putenv,两边共用同一份拷贝:

1static int set_env(const char *item)
2{
3    char   name[256];
4    const char *eq = strchr(item, '=');
5    size_t nlen;
6    int    i;
7
8    if (eq == NULL) {
9        printf("export 要写成 名字=值 的样子\n");
10        return -1;
11    }
12    nlen = (size_t)(eq - item);
13    if (nlen >= sizeof(name))
14        nlen = sizeof(name) - 1;
15    memcpy(name, item, nlen);
16    name[nlen] = '\0';
17
18    for (i = 0; i < g_envcount; i++) {
19        if (strncmp(g_env[i], name, nlen) == 0 && g_env[i][nlen] == '=') {
20            free(g_env[i]);
21            g_env[i] = strdup(item);
22            putenv(g_env[i]);
23            printf("改掉了已有的 %s\n", name);
24            return 0;
25        }
26    }
27    if (g_envcount >= MAX_ENV - 1) {
28        printf("环境表只剩 %d 格,%s 塞不进去了\n", MAX_ENV - 1, name);
29        return -1;
30    }
31    g_env[g_envcount] = strdup(item);
32    putenv(g_env[g_envcount]);
33    g_envcount++;
34    g_env[g_envcount] = NULL;
35    printf("新加了一条 %s,现在 %d 条\n", name, g_envcount);
36    return 0;
37}
38

这个函数比素材那一版多做三件事,同名变量先找出来覆盖,而不是一路往后追加,实测同名 export 两次之后 env 里 MARK 只有一条,值是两次里后一次的那个。加之前看表满不满,满了就打印还剩几格并且拒绝这一条,不再往下写。每次改动都把同一份拷贝交给 putenv,environ 与 g_env 从此同步。

边界那一段值得单独看一眼,素材那一版没有检查,往 64 格的表里塞 70 条 export,计数会从 23 一路涨到 93,越界写把数组后面的内存改了却没有立刻崩。改过的版本在同样的输入下新加 40 条、拒掉 30 条,从 V59 起提示环境表只剩 63 格:

1$ for i in $(seq 0 69); do echo "export V$i=x"; done > in_full.txt
2$ ./bin/myshell_fixed < in_full.txt | grep -a '塞不进去' | head -3
3环境表只剩 63 格,V59 塞不进去了
4环境表只剩 63 格,V60 塞不进去了
5环境表只剩 63 格,V61 塞不进去了
6

cd 之后三处读数也一致了,/bin/pwd 是 /home,env 里 OLDPWD 与 PWD 都是新值,子进程问到的 PWD 也是 /home。

图 7 环境变量表的两条路

九、export 与本地变量的分界

在 bash 里随手赋一个值,子进程是看不见的,加上 export 才看得见。这个小程序里没有变量这个概念,凡是交给 export 的都直接进环境表,所以这个分界要靠使用者自己守。拿同一个脚本在 bash 上跑一遍,两个读数的差别很清楚:

1$ cat local_var.sh
2#!/bin/bash
3LOCAL_ONLY=abc
4export EXPORTED_ONLY=xyz
5env_child LOCAL_ONLY
6env_child EXPORTED_ONLY
7
8$ ./local_var.sh
9env_child: LOCAL_ONLY=(没有这个变量)
10env_child: EXPORTED_ONLY=xyz
11

bash 里没导出的那个变量只活在 shell 自己的变量表里,导出的那个才会出现在子进程的环境表里。自己写的这个小 shell 只有环境表这一张表,谈不上本地变量,所以 export 和赋值在这里是同一件事。想要区分,得再加一张本地变量表,查找的时候先看本地再看环境,这个扩展留到后面。

十、完整源码逐段走

把前面这些拼起来是一份 298 行的程序,编译出来 18912 字节,零告警。文件从上到下的分段是清楚的,头部是宏和全局变量,接着是提示符相关的四个小函数,然后是读一行与切表,再然后是环境表那三个函数,接着是五条内建命令,最后是执行外部命令和主循环。

顶上的全局变量一共六个,两个数组分别是参数表和环境表,配套的计数跟上,再加上退出码和一块装当前目录的缓冲:

1#define MAX_LINE 1024
2#define MAX_ARG  64
3#define MAX_ENV  64
4
5static char *g_env[MAX_ENV];
6static int   g_envcount = 0;
7static char *g_argv[MAX_ARG];
8static int   g_argc = 0;
9static int   g_last = 0;
10static char  g_pwd[MAX_LINE];
11

环境表这一段有三件套,init_env 开局把进程自己的 environ 拷进来,顺便把条数打出来,set_env 负责改和加,free_env 在程序退出时把申请过的每一块都还回去:

1static void init_env(void)
2{
3    int i = 0;
4
5    while (environ[i] != NULL && i < MAX_ENV - 1) {
6        g_env[i] = strdup(environ[i]);
7        i++;
8    }
9    g_env[i] = NULL;
10    g_envcount = i;
11    printf("g_env 里拷了 %d 条环境变量\n", g_envcount);
12}
13

开局那句打印在真机上给的是 23 条,和 bash 的 env 数出来一样多,说明拷贝这一步没漏东西。释放这一块交给 atexit 注册,退出路径不论是 break 出去还是 exit 内建直接结束,都会走到:

1    init_env();
2    atexit(free_env);
3

主循环是整个程序的调度台,六行判断按顺序排好,从读一行到执行,每一步失败都回到开头。退出码为负表示读到输入结束了,这时候打印收工两个字再跳出循环:

1int main(void)
2{
3    char line[MAX_LINE];
4    int  n;
5
6    init_env();
7    atexit(free_env);
8    while (1) {
9        print_prompt();
10        n = read_line(line, sizeof(line));
11        if (n < 0) {
12            printf("收工\n");
13            break;
14        }
15        if (n == 0)
16            continue;
17        if (parse_line(line) == 0)
18            continue;
19        if (check_builtin())
20            continue;
21        run_external();
22    }
23    return 0;
24}
25

内建命令的分发是一个按名字比较的链表,顺序不影响结果,因为这几条名字互不相同。命中一条就执行它并返回 1,主循环看到非零就跳过后面的外部命令那一步:

1static int check_builtin(void)
2{
3    if (strcmp(g_argv[0], "cd") == 0)
4        return builtin_cd();
5    if (strcmp(g_argv[0], "export") == 0)
6        return builtin_export();
7    if (strcmp(g_argv[0], "env") == 0)
8        return builtin_env();
9    if (strcmp(g_argv[0], "echo") == 0)
10        return builtin_echo();
11    if (strcmp(g_argv[0], "exit") == 0)
12        return builtin_exit();
13    return 0;
14}
15

整套源码在下面的实例代码一节里完整贴出,编译命令只有一行,不需要额外的库:

1$ gcc -o bin/myshell_fixed src/myshell_fixed.c
2$ ls -l bin/myshell_fixed
3-rwxr-xr-x. 1 cocatrice cocatrice 18912 bin/myshell_fixed
4

十一、和 bash 的差距

把同一串十二行命令分别喂给这个小 shell 和 bash,输出逐行对下来,绝大多数地方是一样的。这串命令里有列目录、打印、切目录、取退出码、导出变量、问子进程、故意敲一个不存在的命令:

1$ cat out/cmp_in.txt
2pwd
3echo hello
4cd /home
5pwd
6echo $?
7exit_code 5
8echo $?
9export MARK=hello
10env_child MARK
11nosuchcmd
12echo $?
13exit
14

两边最后那个 $? 都是 127,整串输出里只有三处不一样:提示符的形状不一样,命令跑完那一行提示只有自己写的这个版本才有,找不到命令时的说法不一样。bash 给的原话是 /home/cocatrice/lab15/out/cmp_in.txt: line 10: nosuchcmd: command not found,自己写的版本给的是 myshell: 找不到命令 nosuchcmd。

差别不止这三处,功能上的缺口列出来更清楚。这个 shell 不认管道与重定向,>>、| 这些符号会被当成普通参数传给命令;不认通配符,星号原样交给 exec;不认引号与转义,参数全靠空格和制表符切;没有命令历史、没有 Tab 补全、没有作业控制,Ctrl+C 直接把整个 shell 一起带走;变量展开只认 $? 这一个词;错误提示走的是标准输出而不是标准错误,重定向之后会混在一起。

这些缺口里有几个是能补的,补法就在前面的篇章里。重定向要 dup2 把描述符换掉,管道要 pipe 加两次 dup2,前后台要进程组和终端控制,引号与转义要一个真正的词法分析。素材后面那一版已经开始做重定向,把 > 与 < 从参数里挑出来,在 fork 之后、exec 之前打开文件并替换描述符。

图 8 和 bash 的差距

十二、还差什么

写到这里,这个 shell 已经能干活了,敲 ls 能列出文件,敲 cd 能换目录,敲 echo $? 能看到上一条命令的结果,敲 exit 能退出。它离一个能日常使用的 shell 还有距离,缺的东西按补起来的难度排一排,大概是这个顺序。

第一层是输入输出那几件,重定向与管道。这两个都建立在描述符上,fork 之后在子进程里把标准输入或者标准输出换掉,命令本身完全不知道。管道要多一步,先 pipe 拿到一对描述符,左边那条命令的标准输出接到写端,右边那条的标准输入接到读端。

第二层是命令行本身的解析,引号、转义、通配符。现在切参数只按空格和制表符,双引号里的空格会被切开,星号会被原样传给命令。这三件事都需要把这一行先做一遍词法分析,识别出引号的范围,再把通配符交给 glob 去展开。

第三层是交互体验,命令历史、方向键、Tab 补全,还有一条命令跑到一半按 Ctrl+C 只打断命令而不退出 shell。第三条要用到信号和前台进程组,shell 得把自己放到一个单独的进程组里,让终端把 Ctrl+C 送给前台那一组。

第四层是脚本能力,变量赋值与展开、条件判断、循环、函数。这一层做完之后,评测它的方式也跟着变了,因为它已经算得上一门小语言。

实例代码

工程结构

1lab15/
2├── src/                       源码
3│   ├── myshell_stage1.c       第一段:提示符、读一行、切表
4│   ├── myshell_stage1eof.c    第一段把 continue 换成 break 的对照版
5│   ├── myshell_stage2.c       第二段:加上 fork 与 exec 与 waitpid
6│   ├── myshell_stage3.c       第三段:加上 cd 与 export 与 env 与 echo 与 exit
7│   ├── myshell_material.c     照素材那一版写全的版本,用来对照
8│   ├── myshell_noflush.c      删掉 fflush 那一行的对照版
9│   ├── myshell_fixed.c        改过边界与错误处理的定稿版,本篇主讲这一份
10│   ├── argprint.c             打印自己的参数与环境表条数
11│   ├── exit_code.c            按参数返回一个退出码
12│   ├── env_child.c            问一个环境变量,顺带打出自己的 pid
13│   ├── env_probe.c            打印 environ 指针与环境表条数
14│   ├── cd_ext.c               在子进程里 chdir,用来证明 cd 不能外派
15│   ├── prompt_test.c          打印提示符那三个要素各自的来路
16│   ├── overflow_demo.c        环境表越界写的演示
17│   ├── asan_bad.c             故意写坏堆内存,留给地址消毒器
18│   └── asan_try.c             地址消毒器的编译试探
19├── bin/                       编译出来的可执行文件
20└── out/                       输入脚本、输出、日志、编译产物
21

编译每份源码都是一行 gcc,不需要额外的库:

1$ gcc -o ../bin/myshell_fixed myshell_fixed.c
2$ gcc -o ../bin/argprint argprint.c
3$ gcc -o ../bin/exit_code exit_code.c
4$ gcc -o ../bin/env_child env_child.c
5$ gcc -o ../bin/env_probe env_probe.c
6$ gcc -o ../bin/cd_ext cd_ext.c
7$ gcc -o ../bin/prompt_test prompt_test.c
8

完整代码

下面是定稿的那一份,298 行,编译出来 18912 字节,零告警:

1
2#define _GNU_SOURCE
3#include <stdio.h>
4#include <stdlib.h>
5#include <string.h>
6#include <ctype.h>
7#include <errno.h>
8#include <unistd.h>
9#include <sys/types.h>
10#include <sys/wait.h>
11
12#define MAX_LINE 1024
13#define MAX_ARG  64
14#define MAX_ENV  64
15
16extern char **environ;
17
18static char *g_env[MAX_ENV];
19static int   g_envcount = 0;
20static char *g_argv[MAX_ARG];
21static int   g_argc = 0;
22static int   g_last = 0;
23static char  g_pwd[MAX_LINE];
24
25static const char *user_name(void)
26{
27    char *v = getenv("USER");
28    return (v == NULL || v[0] == '\0') ? "None" : v;
29}
30
31static const char *host_name(void)
32{
33    char *v = getenv("HOSTNAME");
34    return (v == NULL || v[0] == '\0') ? "None" : v;
35}
36
37static const char *cur_dir(void)
38{
39    if (getcwd(g_pwd, sizeof(g_pwd)) == NULL)
40        return "None";
41    return g_pwd;
42}
43
44static const char *last_dir(void)
45{
46    const char *p = cur_dir();
47    const char *s;
48
49    if (strcmp(p, "/") == 0 || strcmp(p, "None") == 0)
50        return p;
51    s = strrchr(p, '/');
52    return (s == NULL) ? p : s + 1;
53}
54
55static void print_prompt(void)
56{
57    printf("[%s@%s %s]# ", user_name(), host_name(), last_dir());
58    fflush(stdout);
59}
60
61/* 三种回音:-1 读到尾巴了,0 是空行或者一行长到装不下,1 是真有一行 */
62static int read_line(char *buf, int size)
63{
64    char *nl;
65    int   c;
66
67    if (fgets(buf, size, stdin) == NULL)
68        return -1;
69    nl = strchr(buf, '\n');
70    if (nl == NULL && !feof(stdin)) {
71        while ((c = getchar()) != '\n' && c != EOF)
72            ;
73        printf("这一行超过 %d 个字节,丢掉了\n", size - 1);
74        return 0;
75    }
76    if (nl != NULL)
77        *nl = '\0';
78    return (strlen(buf) == 0) ? 0 : 1;
79}
80
81/* 空格和制表符都算分隔,返回切出几个词 */
82static int parse_line(char *buf)
83{
84    char *tok;
85    int   n = 0;
86
87    memset(g_argv, 0, sizeof(g_argv));
88    for (tok = strtok(buf, " \t"); tok != NULL && n < MAX_ARG - 1; tok = strtok(NULL, " \t"))
89        g_argv[n++] = tok;
90    g_argc = n;
91    return n;
92}
93
94static void free_env(void)
95{
96    int i;
97
98    for (i = 0; i < g_envcount; i++) {
99        free(g_env[i]);
100        g_env[i] = NULL;
101    }
102    g_envcount = 0;
103}
104
105static void init_env(void)
106{
107    int i = 0;
108
109    while (environ[i] != NULL && i < MAX_ENV - 1) {
110        g_env[i] = strdup(environ[i]);
111        i++;
112    }
113    g_env[i] = NULL;
114    g_envcount = i;
115    printf("g_env 里拷了 %d 条环境变量\n", g_envcount);
116}
117
118/* 同名就改那一条,表满了就报一声,绝不写到数组外面 */
119static int set_env(const char *item)
120{
121    char   name[256];
122    const char *eq = strchr(item, '=');
123    size_t nlen;
124    int    i;
125
126    if (eq == NULL) {
127        printf("export 要写成 名字=值 的样子\n");
128        return -1;
129    }
130    nlen = (size_t)(eq - item);
131    if (nlen >= sizeof(name))
132        nlen = sizeof(name) - 1;
133    memcpy(name, item, nlen);
134    name[nlen] = '\0';
135
136    for (i = 0; i < g_envcount; i++) {
137        if (strncmp(g_env[i], name, nlen) == 0 && g_env[i][nlen] == '=') {
138            free(g_env[i]);
139            g_env[i] = strdup(item);
140            putenv(g_env[i]);
141            printf("改掉了已有的 %s\n", name);
142            return 0;
143        }
144    }
145    if (g_envcount >= MAX_ENV - 1) {
146        printf("环境表只剩 %d 格,%s 塞不进去了\n", MAX_ENV - 1, name);
147        return -1;
148    }
149    g_env[g_envcount] = strdup(item);
150    putenv(g_env[g_envcount]);
151    g_envcount++;
152    g_env[g_envcount] = NULL;
153    printf("新加了一条 %s,现在 %d 条\n", name, g_envcount);
154    return 0;
155}
156
157static int builtin_cd(void)
158{
159    char buf[MAX_LINE];
160    char old[MAX_LINE];
161    char *p;
162
163    if (g_argc != 2) {
164        printf("用法:cd 目录\n");
165        g_last = 1;
166        return 1;
167    }
168    p = getcwd(old, sizeof(old));
169    if (chdir(g_argv[1]) != 0) {
170        printf("cd 失败:%s(errno = %d)\n", strerror(errno), errno);
171        g_last = 1;
172        return 1;
173    }
174    if (getcwd(g_pwd, sizeof(g_pwd)) == NULL) {
175        g_last = 1;
176        return 1;
177    }
178    if (p != NULL) {
179        snprintf(buf, sizeof(buf), "OLDPWD=%s", old);
180        set_env(buf);
181    }
182    snprintf(buf, sizeof(buf), "PWD=%s", g_pwd);
183    set_env(buf);
184    g_last = 0;
185    return 1;
186}
187
188static int builtin_export(void)
189{
190    if (g_argc != 2) {
191        printf("用法:export 名字=值\n");
192        g_last = 2;
193        return 1;
194    }
195    g_last = (set_env(g_argv[1]) == 0) ? 0 : 4;
196    return 1;
197}
198
199static int builtin_env(void)
200{
201    int i;
202
203    for (i = 0; i < g_envcount; i++)
204        printf("%s\n", g_env[i]);
205    g_last = 0;
206    return 1;
207}
208
209static int builtin_echo(void)
210{
211    if (g_argc == 2) {
212        if (g_argv[1][0] == 36 && g_argv[1][1] == 63) {
213            printf("%d\n", g_last);
214            g_last = 0;
215        } else {
216            printf("%s\n", g_argv[1]);
217            g_last = 0;
218        }
219    } else {
220        printf("echo 这里一次只认一个词\n");
221        g_last = 3;
222    }
223    return 1;
224}
225
226static int builtin_exit(void)
227{
228    printf("收工\n");
229    exit(g_last);
230}
231
232static int check_builtin(void)
233{
234    if (strcmp(g_argv[0], "cd") == 0)
235        return builtin_cd();
236    if (strcmp(g_argv[0], "export") == 0)
237        return builtin_export();
238    if (strcmp(g_argv[0], "env") == 0)
239        return builtin_env();
240    if (strcmp(g_argv[0], "echo") == 0)
241        return builtin_echo();
242    if (strcmp(g_argv[0], "exit") == 0)
243        return builtin_exit();
244    return 0;
245}
246
247static void run_external(void)
248{
249    pid_t id;
250    int   status = 0;
251
252    id = fork();
253    if (id < 0) {
254        printf("fork 失败:%s\n", strerror(errno));
255        g_last = 1;
256        return;
257    }
258    if (id == 0) {
259        execvp(g_argv[0], g_argv);
260        printf("myshell: 找不到命令 %s\n", g_argv[0]);
261        fflush(stdout);
262        _exit(127);
263    }
264    if (waitpid(id, &status, 0) > 0) {
265        if (WIFEXITED(status))
266            g_last = WEXITSTATUS(status);
267        else if (WIFSIGNALED(status))
268            g_last = 128 + WTERMSIG(status);
269        else
270            g_last = 100;
271    }
272}
273
274int main(void)
275{
276    char line[MAX_LINE];
277    int  n;
278
279    init_env();
280    atexit(free_env);
281    while (1) {
282        print_prompt();
283        n = read_line(line, sizeof(line));
284        if (n < 0) {
285            printf("收工\n");
286            break;
287        }
288        if (n == 0)
289            continue;
290        if (parse_line(line) == 0)
291            continue;
292        if (check_builtin())
293            continue;
294        run_external();
295    }
296    return 0;
297}
298

正常情况

把一串命令写进一个文件,用重定向喂给这个 shell,就是一次完整的会话。开头它会报一句自己拷了多少条环境变量,之后每条命令的输出按顺序排下来,最后一行是收工:

1$ cat out/in_normal.txt
2pwd
3echo hello
4ls -l /home/cocatrice/lab15/out/cmp_in.txt
5cd /home
6pwd
7echo $?
8cd /home/cocatrice/lab15
9export MARK=demo
10env_child MARK
11env_probe
12true
13echo $?
14nosuchcmd
15echo $?
16exit
17
18$ ./bin/myshell_fixed < out/in_normal.txt
19g_env 里拷了 23 条环境变量
20/home/cocatrice/lab15
21hello
22-rw-rw-r-- 1 cocatrice cocatrice 110 Oct 11 22:15 /home/cocatrice/lab15/out/cmp_in.txt
23改掉了已有的 OLDPWD
24改掉了已有的 PWD
25/home
260
27改掉了已有的 OLDPWD
28改掉了已有的 PWD
29新加了一条 MARK,现在 24 条
30env_child: pid = 6926,问的是 [MARK]
31env_child: MARK = [demo]
32env_child: PWD = [/home/cocatrice/lab15]
33env_probe: environ 这个指针的值 = 0x7ffca5c507e8,pid = 6927
34env_probe: 环境表里有 24 条
35env_probe: 第一条是 [XDG_SESSION_ID=8150]
360
37myshell: 找不到命令 nosuchcmd
38127
39收工
40

这一串里有几处值得留意,cd 到 /home 之后接着问 $? 得到 0,这一次命令真的成功了。子进程 env_child 问到的 PWD 是新目录,说明环境表那一份也跟着切过去了。env_probe 报出 24 条,比开局的 23 条多一条,多的那条就是刚导出的 MARK。最后两条命令分别是成功的 true 和找不到的 nosuchcmd,退出码 0 与 127 各自对得上。

常见报错

把最容易撞上的几种情况凑成一串,一次看完:

1$ cat out/in_err.txt
2nosuchcmd
3echo $?
4cd /nonexistent
5echo $?
6export FOO
7echo $?
8echo a b
9echo $?
10exit
11
12$ ./bin/myshell_fixed < out/in_err.txt
13g_env 里拷了 23 条环境变量
14myshell: 找不到命令 nosuchcmd
15127
16cd 失败:No such file or directory(errno = 2)
171
18export 要写成 名字=值 的样子
194
20echo 这里一次只认一个词
213
22收工
23

四种情况的退出码各自是一个数,命令找不到是 127,目录切不过去是 1。这两个数跟 bash 对得上;export 没写等号给 4,echo 给两个词给 3,这两个是自己定的,约定成什么样都行,关键是别一声不吭地把错咽下去。

边界情况

边界那几处分散在前面的小节里,这里凑一段一次跑完。换成根目录,目录末段的取法走的是那个特判分支;接着送一行全是空格的行和一行带制表符的行,前面那种在旧版本里会让程序崩,现在被挡在切表那一步:

1$ cat out/in_edge.txt
2cd /
3/bin/pwd
4ls -l
5(一行三个空格)
6(一个制表符)
7echo 空格行没有把我怎么样
8exit
9
10$ ./bin/myshell_fixed < out/in_edge.txt
11g_env 里拷了 23 条环境变量
12改掉了已有的 OLDPWD
13改掉了已有的 PWD
14/
15total 72
16lrwxrwxrwx.   1 root root     7 Jul 26  2024 bin -> usr/bin
17dr-xr-xr-x.   5 root root  4096 Dec  6  2025 boot
18drwxr-xr-x    7 root root  4096 Jul 26  2024 CloudrResetPwdAgent
19...
20空格行没有把我怎么样
21收工
22

切到根目录之后提示符那一格取的是第一个分支,因为目录末段没有斜杠可取,特判直接返回全串。做法是拿最后一段之前先比一次,串就是斜杠本身的时候不再往下走 strrchr,不然会取到空的一段。

超长行的处理也在这一层,fgets 一次最多读 1023 个字节,多出来的部分留在输入流里,下一轮会被当成一条新命令。修好的版本发现这一行没读到换行符时把剩下的字符读走丢掉,并且说一声,后面那条短命令照跑。

还有一处是表满,环境表固定在 64 格,最后留一格放结束的空指针,所以最多装 63 条。往 63 格的表里连塞 70 条 export,新加 40 条之后开始拒绝,一共拒掉 30 条:

1$ for i in $(seq 0 69); do echo "export V$i=x"; done > out/in_full2.txt
2$ ./bin/myshell_fixed < out/in_full2.txt | grep -c '塞不进去了'
330
4$ ./bin/myshell_fixed < out/in_full2.txt | grep '塞不进去了' | head -1
5环境表只剩 63 格,V40 塞不进去了
6$ ./bin/myshell_fixed < out/in_full2.txt | grep '塞不进去了' | tail -1
7环境表只剩 63 格,V69 塞不进去了
8

被拒的每一条都有记录,退出码走 4,调用方知道这一次没成功。

实测数据

下面这张表是各个用例在真机上的读数,测试机是 CentOS 7 的 3.10 内核、gcc 4.8.5:

读数项结果
开局环境表条数23 条,与 bash 的 env 一致
提示符里的主机名None,非交互 ssh 的 HOSTNAME 没有导出
提示符带 fflush 的第 1 秒22 字节
提示符不带 fflush 的第 1 秒0 字节
只喂一行 ls(第一段)两秒吐 25397770 字节,wc -l 只有 2 行
只喂一行 ls(定稿版)92 字节,退出码 0
参数表 ls -a -l -nargc = 4
制表符分隔的一行argc = 1,制表符留在词里
超长行 1206 字节整行丢弃并提示,后面的短命令照跑
命令找不到的退出码127
ls /root 的退出码2
cd 到不存在的目录(定稿版)errno = 2,退出码 1
cd 到不存在的目录(素材版)目录没换,退出码 0
环境表塞 70 条 export新加 40 条,拒掉 30 条,首拒 V40
同名 export 两次env 里只剩一条,值是后一次那个
改后版本的 valgrindin use at exit 0 bytes in 0 blocks
素材版本的 valgrindin use at exit 2,148 bytes in 25 blocks,definitely lost 0
全局数组越界写给 valgrind 看Invalid write 0 行,ERROR SUMMARY 0 errors
越界写之后隔壁缓冲的头八个字节90 c0 0d 01 00 00 00 00
结构体里三个成员的地址&g.count = 0x601080,&g.env = 0x601088,&g.guard = 0x6010a8
guard 与 env 的间距32 字节,正好是那个四格指针数组的大小
地址消毒器用不了,链接期报 cannot find /usr/lib64/libasan.so.0.0.0
bash 对照那一串十二行命令输出几乎一致,最后那个 $? 两边都是 127

实例

拿这个 shell 自己编一个小程序并跑起来,从切目录一路做到取退出码,一条外部命令接一条外部命令:

1$ cat out/in_build.txt
2cd /home/cocatrice/lab15/out
3gcc -o hello hello.c
4ls -l hello
5./hello
6echo $?
7exit
8
9$ ./bin/myshell_fixed < out/in_build.txt
10g_env 里拷了 23 条环境变量
11改掉了已有的 OLDPWD
12改掉了已有的 PWD
13-rwxrwxr-x 1 cocatrice cocatrice 8360 Oct 11 22:20 hello
14你好,这里是被 shell 拉起来的程序
157
16收工
17

一句一句对下来,切目录那一步换了 shell 自己的工作目录,所以后面 gcc 生成的 hello 落在 out 目录里。ls 看到的是刚编出来的那个文件,8360 字节。跑起来打印了程序里那句话,最后 echo $? 打出 7,就是小程序的 return 值。整条链路走通,说明这个 shell 已经能当命令的搬运工用了。

踩坑点

  • 去换行的时候直接砍最后一个字符,行尾没有换行符的那一行会少掉最后一个字母,ls -a 变成只有一个减号。换成 strchr 找换行符,找到才替换。
  • 读到文件结尾还用 continue 回到循环开头,提示符会疯狂刷屏,只喂一行 ls 两秒钟吐了 25397770 字节,wc -l 却只有 2 行。
  • 把结尾当成空行处理也不行,输入一个空行 shell 就退出了。读一行要分成读到尾巴、空行、真有一行三种回音。
  • 一行超过 1023 字节时,fgets 把剩下的留在输入流里,下一轮会当成一条新命令执行。要么读干净丢掉,要么加一块更大的缓冲。
  • strtok 的分隔符表里只写空格,制表符就不算分隔,整行会当成一个词。分隔表写成两个字符就够了。
  • 全是空格的行切出来一个词都没有,g_argv[0] 是空指针,拿它去 strcmp 或者 exec 就会崩。切完先看词的个数。
  • 参数表末尾必须放一个空指针,exec 是靠它判断参数到哪里结束的。少放一个,内核会一路读下去,读到什么完全看运气。
  • 子进程里 exec 失败之后要 _exit 而不是 exit,exit 会把从父进程继承来的标准输入输出缓冲区再刷一遍,同一句话打两遍。
  • 子进程 exec 失败时的退出码定成 127,和 bash 对齐。定成 1 的话,命令不存在和执行失败在返回值上分不出来。
  • cd 交给子进程去做等于白做,子进程 chdir 成功之后自己退出了,父进程还在原来的目录里。cd 与 export 与 exit 只能自己动手。
  • chdir 的返回值不看,目录切不过去也把退出码置成 0,脚本里按这个数做判断就会走错分支。
  • putenv 存的是指针不是内容,把一个循环里的局部缓冲传进去,下一条命令一执行,那块内存被覆盖,环境表里那一条也跟着坏掉,export 过的变量马上问不到。
  • 自己拷一份 g_env 又把 putenv 当成同步手段,两份数据会分家,cd 之后 env 里打的 PWD 还是旧目录,子进程问到的也是旧的。
  • 环境表没有边界检查时越界写不会立刻崩,64 格的表塞 70 条,计数能涨到 93,坏的是数组后面的内存。
  • 全局数组越界写这件事,valgrind 报 0 errors,它只给堆上申请的内存设红区,数据段里的越界它不管。要证明越界,得把两张数组放进同一个结构体,再用 gdb 看地址。
  • gdb 里没加 -g 编译的程序,类型信息不全,同一个表达式能给出莫名其妙的结果,sizeof 一个结构体给出 4 就是这么来的。
  • 地址消毒器在这台机器上装不上,链接期报 cannot find /usr/lib64/libasan.so.0.0.0,只能退回去用 valgrind 加肉眼读数。
  • 提示符拼好之后不 fflush,重定向到文件的时候什么都看不到,终端上看起来却是正常的。输出要落到文件或者管道里,这一行不能省。
  • 非交互 ssh 会话里 HOSTNAME 不在环境表里,getenv 拿不到,提示符主机名那一格会显示 None。要主机名用 gethostname 更稳当。
  • 没有前台进程组,跑一条会一直输出的命令,按 Ctrl+C 会把整个 shell 一起带走,命令和解释器同时结束。

本篇总结(模拟面试问题)

问:自己写一个 shell,最少需要哪几件事?

核心要点:一个循环把提示符、读一行、切参数、执行串起来。外部命令要靠 fork 加 exec 加 wait 三件事配合,内建命令在 shell 自己的进程里做。参数表必须以空指针收尾,退出码自己记一份,这两条决定了程序能不能跑对其他命令。

问:为什么 cd 必须是内建命令?

核心要点:chdir 改的是调用进程自己的工作目录记录。交给子进程执行,改变的只是子进程那一份,子进程退出之后什么都没留下。export、exit 这些改的也是 shell 自己的状态,同样只能自己做。

问:$? 是哪来的?

核心要点:它是 shell 自己的一个变量,不是内核提供的。子进程的退出码只由父进程通过 wait 拿得到,别的进程拿不到,所以 shell 收到之后存在自己的一个整数里,echo $? 读它的时候把它置回 0。

问:putenv 有什么坑?

核心要点:它只存指针,不复制字符串。参数必须是一块生命周期足够长的内存,否则那块内存被覆盖之后环境表里那条就坏了。同时它改的是进程自己的 environ,如果代码里另外维护了一份拷贝,两份就会分家。

问:环境变量有哪几种做法,各自的代价是什么?

核心要点:一种直接改进程自己的 environ,改动少但要求传进去的字符串一直有效;另一种自己拷一份数组,exec 的时候通过带 e 的接口传下去,可控但要自己维护同步与边界。写 shell 的时候两条路都得想清楚哪一份是准的。

问:参数表为什么必须以空指针收尾?

核心要点:exec 系列接口拿到的只是一个指针,数组长度不跟着传,判断结束只能靠末尾那个空指针。少一个空指针,内核会一直读下去。同理环境表也要以空指针收尾。

问:怎么验证一个越界写真的发生了?

核心要点:valgrind 只管堆上申请的内存,数据段里的全局数组越界它报不出来。可行的办法是把相关的数组放进同一个结构体,布局就固定了,再用 gdb 打出各成员的地址算出间距,越界那一刻写进去的内容在隔壁缓冲里能看见。

参考


参考文档


《【Linux】自主 Shell》 是转载文章,点击查看原文。


相关推荐


分布式唯一 性ID生成方法
一只小猪妖2026/10/17

分布式唯一 ID 背景 日常开发中,我们需要对系统中的各种数据使用 ID 唯一表示。 比如用户 ID 对应且仅对应一个人,商品 ID 对应且仅对应一件商品,订单 ID 对应且仅对应一个订单。我们现实生活中也有各种 ID,比如身份证 ID 对应且仅对应一个人。简单来说,ID 就是数据的唯一标识。 一般情况下,会使用数据库的自增主键作为数据 ID。但在大数据量场景下,往往会引入分布式、分库分表等手段来应对。很明显,对数据分库分表后我们依然需要有一个唯一 ID 来标识一条数据或消息,数据库的自增 ID


当 Build in Public 重新转入地下 -- 肘子的 Swift 周报 #157
东坡肘子2026/10/13

当 Build in Public 重新转入地下 过去一段时间,社区里频繁出现用 AI 快速逆向商业产品或像素级复刻热门应用的案例。只要 Token 充足,搭建一个免费的“影子版本”似乎已不再是难事。 与此同时,许多坚持“公开构建”(Build in Public)的独立开发者也遭遇了新的挑战:原创产品尚在打磨之中,一些仿制者仅凭作者在社交媒体上披露的设计截图和思路,便借助 AI 抢先一步上线了“克隆品”。有的源于技术探索与好奇,有的只是想展示 AI 工具的生产力,但也不乏投机取巧的捷径心态。


Linux 网络编程基础:网络分类、分层模型与数据封装
一条破秋裤2026/10/4

Linux 网络编程基础:网络分类、分层模型与数据封装 课程:尚硅谷《嵌入式 Linux 应用层开发》第 6 章 Socket 编程 依据:2026-09-29 20:21 录音转写;课程 PDF 第 244—254 页。 本节边界:这是 Socket 编程的理论入口,暂未讲 socket()、bind()、listen()、connect() 等代码接口。 1. 本节在网络编程路线中的位置 录音首先说明:计算机网络范围很大,本课程不会完整讲完所有网络技术,而是先建立后续 Soc


兰亭妙微UI设计公司分享:Fintora AI智能金融操作系统UI/UX设计深度解析
兰亭妙微UI设计公司2026/9/27

北京兰亭妙微 UI 设计公司,成立 16 年来,始终保持着对国内外优秀设计作品的学习与研究。我们持续追踪全球前沿的 UI/UX 设计趋势,从中提炼可落地的设计方法论,分享给同样热爱设计的你。 导读 从语音交互、多维卡片管理到智能分析仪表盘,构建以AI为核心的现代金融体验闭环。本文不止评价画面风格,而是从产品目标、信息组织、行为路径、视觉语义和落地风险五个层面拆解这套方案。 一、产品定位:先回答系统替谁解决什么问题 Fintora并没有把自己仅仅定位为一款传统的记账工具或简单的银


一套审批流要写多少代码:13 个框架的接入 diff 我数了一遍,最少 422 行,最多 1798 行
mldong2026/9/20

问"加一套审批流要写多少代码",很少有人能给出可信答案。原因不是大家懒得算,而是这句问话里其实混着三件事:给现有项目接一个现成引擎、从零做一套带审批的后台、自己造一个引擎。这三档的工期差两个数量级,却被同一句话压在一起。 这次我把第一档的数拿实了:jeeflow 已经在 13 个框架上各接入过一次,每一层的 diff 都还在 git 里。我把它们一个一个数了一遍,包括我自己数错的两次。 一、先交代我数错的两次 第一轮,我用集成壳里留着的 master 引用取合并基线。结果 NestJS 报出


我做了一个 Chrome 扩展,把 YouTube 播放列表批量变成 AI 可读的本地 Markdown
嘉琪coder2026/9/12

现在的 AI 已经很擅长总结、分类和问答,但在真正使用它整理知识时,我经常卡在更前面的一步: 怎样把散落在视频里的内容,变成 AI 可以稳定读取的资料? 我平时会在 YouTube 上看课程、访谈和播客。看完时觉得收获很多,过一段时间想找其中一个观点,却只能重新打开视频、拖动进度条。 如果是一套几十集的课程或一个持续更新的频道,逐个打开视频、复制字幕、创建文件,光是准备资料就足以让人放弃。 所以我做了 Transcriptly。 它是一款免费、开源的 Chrome 扩展,可以把 YouTube


流程图上没画人,单子却走对了:工作流引擎内置处理人解析器
mldong2026/9/4

一、流程图上没画人,单子却走对了 用流程设计器画一张最简单的请假审批流:开始 → 部门领导审批 → 结束,三个节点两条线。 画完之后你检查一遍这张图:节点上没有任何人的名字。没有"张三",没有"李四",连"审批人"三个字都是你自己写的节点显示名。从图上看,这张流程不知道该把单子交给谁。 然后你发起了一笔请假。几秒后,你部门领导的待办列表里,多了这条单子。 它怎么知道该去找领导的? 你可能会说:节点名不是写着"部门领导审批"吗——但节点显示名只是个标签,引擎不会拿它去组织架构里搜人;就算你把节点改


Next.js 全栈笔记系统实战:RSC 组件架构、Redis 数据层与规范驱动开发
浮生望2026/8/27

摘要 以Next.js笔记系统为例,深入RSC异步组件直接查询Redis、Server/Client组件边界、BEM命名规范、路径别名及组件驱动开发流程,展示从需求分析到技术方案到组件拆分的全栈落地路径。 一个笔记系统的需求并不复杂:左侧笔记列表,右侧 Markdown 编辑预览,支持 CRUD 和搜索。但用 Next.js 全栈实现它,涉及的技术决策覆盖了 RSC 组件边界、数据层选型、组件拆分策略和项目结构规范——这些正是 Next.js 工程化的核心议题。 技术选型:为什么是 Redis


JavaScript实战技巧总结
阿橙的百宝箱2026/8/19

JavaScript实战技巧总结* 引言 JavaScript作为现代Web开发的基石,其灵活性和强大的功能使其成为开发者必备的技能之一。然而,随着ECMAScript标准的不断演进和前端生态的日益复杂,如何高效、优雅地编写JavaScript代码成为开发者面临的重要课题。本文将从实际出发,总结一系列经过实战检验的JavaScript技巧,涵盖性能优化、代码简洁性、异步处理、模块化等多个关键领域,帮助开发者提升代码质量和开发效率。 一、性能优化技巧 1. 减少DOM操作 DOM操作是Java


篇2-bitsandbytes-具体观-算法与实现剖析
happyprince2026/8/4

三部曲之二 · 看懂:潜入水下的技术细节 本篇承接整体观建立的认知地图,潜入水下逐一审视 bitsandbytes 的核心技术实现——LLM.int8()、QLoRA/NF4、8-bit 优化器,以及支撑它们的极致工程。每个技术点遵循"原理(论文)→ 代码 → 例子"三段式剖析,让读者真正"看懂"代码背后的学术根源与工程取舍。 一、总述:三大算法支柱 + 一条工程脊梁 bitsandbytes 的技术内核可拆成三大算法支柱 + 一条工程脊梁。三大算法支柱是:① LLM.int

首页编辑器站点地图

本站内容在 CC BY-SA 4.0 协议下发布

Copyright © 2026 聚合阅读