60行C代码实现一个shell

蔚落 2023-01-05 01:24 159阅读 0赞

继 [**300来行代码带你实现一个能跑的最小Linux文件系统**][300_Linux]之后，我们来看看如何60行C代码实现一个shell！

在实现它之前，先看看这样做的意义。

美是有目共睹的。Unix之美，稍微体会，便能得到。

1969年，Unix初始，没有fork，没有exec，没有pipe，没有 *“一切皆文件”* ，但是那时它已经是Unix了。它简单，可塑。

Melvin Conway在1963年的论文中叙述fork思想时就解释说并行路径要用结果来交互，也就是在汇合的join点来同步结果。这个同步点所得到的，就是一个并行进程的 *输出* 。

在此之外，Unix还有另一个原则，就是 *组合小程序！*

Unix把一系列功能单一的小程序组合成一个复杂的逻辑，这个原则有以下优势：

*  每一个小程序都很容易编写。
 *  每一个小程序可以分别完成。
 *  每一个小程序可以分别迭代修复。
 *  多个小程序可以自由组合。
 *  …

这是典型的模块化思想，小到统筹佐餐烧饭，大到组成生命的嘌呤嘧啶，都不自觉地和这种模块化思想相契机，原来这就是真理。 *程序尽量小，只做一件事并且做好它。*

Unix程序在自身的逻辑之外对外暴露的只有输入和输出。那么 *用输出连接另一个程序输入* 就是一种好的方法。所谓Conway的join点对于Unix进程指的就是输出。

> 对外暴露的越少，程序越内聚。这是一种范式，类似RISC处理器也是抽象出仅有的load和store来和内存交互。

简单来讲，Unix程序通过输入和输出来彼此连接。下面是一幅来自Wiki的图示：![640?wx\_fmt=png][640_wx_fmt_png]

Unix的另一个原则，即著名的 *“一切皆文件！”* 连接输出和输入的那个管道在Unix中被实现为Pipe，显然，它也是文件，一个FIFO文件。

说实话，协作几个小程序形成一个大逻辑的思想还是来自于Convey，在Convey的论文里，他称为 *协程，* Pile可以说是直接实现了 *Convey协程* 之间的交互。有关这段历史，请看：

用Pipe连接作为输出和输入连接Unix进程可以做成什么事情呢？让我们去感受一个再熟悉不过的实例，即数学式子：

![640?wx\_fmt=png][640_wx_fmt_png 1]

我们把运算符加号，乘号，除号(暂不考虑括号，稍后解释为什么)这些看作是程序(事实上它们也真的是)，那么类似数字3，5，7，6就是这些程序的输入了，这个式子最终需要一个输出，获得这个输出的过程如下：

1.  数字3，5是加号程序的输入，3+5执行，它获得输出8.
2.  第1步中的输出8连同数字7作为乘号程序的输入，8 × 7执行，获得输出56.
3.  第2步中的输出56连同数字6作为除号的输入，…

这个数学式子的求值过程和pipe连接的Unix程序组合获得最终结果的过程完全一致。

如果你相信数学可以描述整个世界，那么Pipe连同Unix程序同样是描述这个世界的语言 。

在数学领域，*程序* 就是所有的运算符，加号，减号，乘号，除号，乘方，开方，求和，积分，求导…它们无一例外， *只做一件事。*

在Unix看来也同样。它做的事情和下面的应该差不多，而且更多：![640?wx\_fmt=png][640_wx_fmt_png 2]

1.  `// plus.c`
2.  `#include <stdio.h>`
3.  `int main(int argc, char **argv)`
4.  `{`
5.  `int a, b;`
6.  
7.  `a = atoi(argv[1]);`
8.  `b = atoi(argv[2]);`
9.  
10. `a = a + b;`
11. `printf("%d\n", a);`
12. `}`

同样，我们可以写出除法，直到偏导的程序。然后我们通过pipe就能将它们组合成任意的数学式子。

现在谈谈Unix组合程序的具体写法，如果我们要化简薛定谔方程，我们应该如何用Unix命令写出与上述式子等价的组合程序命令行呢？我们无法像数学家手写那样随意使用括号，显然，计算机并不认识它。我们能够使用的只有两个符号：

1.  代表具体Unix小程序的命令。
2.  Pipe符号"|"。

换句话说，我们需要写出一个 *链式组合表达式。* 这时就要用到前缀表达式了。

> 数学式子里的括号，其实它无关紧要，括号只是给人看的，它规定一些运算的优先级顺序，这叫 *中缀表达式* ，一个中缀表达式可以轻松被转换为 *前缀表达式，后缀表达式* ，从而消除括号。事实上，Unix的Pipe最初也面临过这样的问题，到底是中缀好呢，还是前/后缀好呢？

我们现在使用的Unix/Linux命令，以cp举例：

cp $in $out

这是一个典型的前缀表达式，但是当pipe的发明者McIlroy最初引入pipe试图组合各个程序时，最初上面的命令行被建议成：

$in cp $out

就像我们的(3 + 5) × 8 一样。但是这非常不适合计算机处理的风格，计算机不得不首先扫描解析这个式子，试图：

1.  理解 *“括号括起来的要优先处理”* 这句复杂的话；
2.  区分哪些是输入，哪些是操作符…

对于式子(3 + 5) × 8 的求值，计算机更适合用一种在简单规则下非常直接的方式去 *顺序执行* 求解，这就是前缀表达式的优势。

× 8 + 35就是(3 + 5) × 8 的前缀表达式，可以看到，没有了括号。对于pipe组合程序而言，同样适用于这个原则。于是前缀命令成了pipe组合命令的首选，现如今，我们可以用：

pro1 $stdin|pro2|pro3|pro4|...|proX $stdout

轻松组合成任意复杂的逻辑。

*Pipe协同组合程序的Unix原则是一个创举，程序就是一个加工过滤器，它把一系列的输入经过自己的程序逻辑生成了一系列的输出，该输出又可以作为其它程序的输入。*

在Unix/Linux中，各种shell本身就实现了这样的功能，但是为了彻底理解这种处理方式的本质，只能自己写一个才行。来写一个微小的shell吧。

再次看上面提到的Unix Pipe的处理序列：

pro1 $stdin|pro2|pro3|pro4|...|proX $stdout

如果让一个shell处理以上组合命令，要想代码量少，典型方案就是递归，然后用Pipe把这些递归调用过程给串起来，基本逻辑如下：

1.  `int exec_cmd(CMD *cmd, PIPE pipe)`
2.  `{`
3.  `// 持续解析命令行，以pipe符号|分割每一个命令`
4.  `while (cmd->next) {`
5.  `PIPE pp = pipe_create();`
6.  `if (fork() > 0) {`
7.  `// 父进程递归解析下一个`
8.  `exec_cmd(cmd->next, pp);`
9.  `return 0;`
10. `}`
11. `// 子进程执行`
12. `dup_in_out(pp);`
13. `exec(cmd->cmdline);`
14. `}`
15. `if (fork() > 0) {`
16. `wait_all_child();`
17. `return 0;`
18. `} else {`
19. `dup_in_out(pp);`
20. `exec(cmd->cmdline);`
21. `}`
22. `}`

按照上面的思路实现出来，大概60行左右代码就可以：

1.  `// tinysh.c`
2.  `// gcc tinysh.c -o tinysh`
3.  `#include <stdio.h>`
4.  `#include <stdlib.h>`
5.  `#include <unistd.h>`
6.  `#include <sys/wait.h>`
7.  
8.  `#define CMD_BUF_LEN 512`
9.  `char cmd[CMD_BUF_LEN] = {0};`
10. 
11. `void fork_and_exec(char *cmd, int pin, int pout)`
12. `{`
13. `if (fork() == 0) {`
14. `if (pin != -1) {`
15. `dup2 (pin, 0);`
16. `close(pin);`
17. `}`
18. `if (pout != -1) {`
19. `dup2 (pout, 1);`
20. `close(pout);`
21. `}`
22. `system(cmd);`
23. `exit(0);`
24. `}`
25. `if (pin != -1)`
26. `close(pin);`
27. `if (pout != -1)`
28. `close(pout);`
29. `}`
30. 
31. `int execute_cmd(char *cmd, int in)`
32. `{`
33. `int status;`
34. `char *p = cmd;`
35. `int pipefd[2];`
36. 
37. `while (*p) {`
38. `switch (*p) {`
39. `case '|':`
40. `*p++ = 0;`
41. `pipe(pipefd);`
42. `fork_and_exec(cmd, in, pipefd[1]);`
43. `execute_cmd(p, pipefd[0]);`
44. `return 0;`
45. `default:`
46. `p++;`
47. `}`
48. `}`
49. `fork_and_exec(cmd, in, -1);`
50. `while(waitpid(-1, &status, WNOHANG) != -1);`
51. `return 0;`
52. `}`
53. 
54. `int main(int argc, char **argv)`
55. `{`
56. `while (1) {`
57. `printf("tiny sh>>");`
58. `gets(cmd);`
59. `if (!strcmp(cmd, "q")) {`
60. `exit(0);`
61. `} else {`
62. `execute_cmd(cmd, -1);`
63. `}`
64. `}`
65. `return 0;`
66. `}`

下面是执行tinysh的结果：

1.  `[root@10 test]# ls -l`
2.  `总用量 28`
3.  `-rw-r--r-- 1 root root 0 9月 1 05:39 a`
4.  `-rwxr-xr-x 1 root root 9000 9月 1 05:38 a.out`
5.  `-rw-r--r-- 1 root root 0 9月 1 05:39 b`
6.  `-rw-r--r-- 1 root root 0 9月 1 05:39 c`
7.  `-rw-r--r-- 1 root root 0 9月 1 05:39 d`
8.  `-rw-r--r-- 1 root root 0 9月 1 05:39 e`
9.  `-rwxr-xr-x 1 root root 9000 9月 1 05:38 tinysh`
10. `-rw-r--r-- 1 root root 1167 9月 1 05:38 tinysh.c`
11. `[root@10 test]# ./tinysh`
12. `tiny sh>>ls -l |wc -l`
13. `9`
14. `tiny sh>>cat /etc/inittab |grep init`
15. `# inittab is no longer used when using systemd.`
16. `tiny sh>>cat /etc/inittab |grep init|wc -l`
17. `1`
18. `tiny sh>>q`
19. `[root@10 test]#`

递归解析的过程中fork/exec，一气呵成，这就是一个最简单shell实现。它可完成组合程序的执行并给出结果。

这个tiny shell命令解析器的逻辑可以表示如下：![640?wx\_fmt=png][640_wx_fmt_png 3]

![640?wx\_fmt=png][640_wx_fmt_png 4]

的计算，我需要写表示四则混合运算符的Unix程序，首先看加号运算符程序，将上文中plus.c改成从标准输入读取加数即可：

1.  `// plus.c`
2.  `// gcc plus.c -o plus`
3.  `#include <stdio.h>`
4.  `#include <stdlib.h>`
5.  
6.  `int main(int argc, char **argv)`
7.  `{`
8.  `float a, b;`
9.  
10. `a = atof(argv[1]);`
11. `scanf("%f", &b);`
12. 
13. `b = b + a;`
14. `printf("%f\n", b);`
15. `}`

再看减法运算符程序代码：

1.  `// sub.c`
2.  `// gcc sub.c -o sub`
3.  `#include <stdio.h>`
4.  `#include <stdio.h>`
5.  
6.  `int main(int argc, char **argv)`
7.  `{`
8.  `float a, b;`
9.  
10. `a = atof(argv[1]);`
11. `scanf("%f", &b);`
12. 
13. `b = b - a;`
14. `printf("%f\n", b);`
15. `}`

接下来是乘法和除法的代码：

1.  `// times.c`
2.  `// gcc times.c -o times`
3.  `#include <stdio.h>`
4.  `#include <stdio.h>`
5.  
6.  `int main(int argc, char **argv)`
7.  `{`
8.  `float a, b;`
9.  
10. `a = atof(argv[1]);`
11. `scanf("%f", &b);`
12. 
13. `b = b*a;`
14. `printf("%f\n", b);`
15. `}`

1.  `// div.c`
2.  `// gcc div.c -o div`
3.  `#include <stdio.h>`
4.  `#include <stdio.h>`
5.  
6.  `int main(int argc, char **argv)`
7.  `{`
8.  `int a, b;`
9.  
10. `a = atof(argv[1]);`
11. `scanf("%d", &b);`
12. 
13. `b = b/a;`
14. `printf("%d\n", b);`
15. `}`

可以看到，这些都是非常简单的程序，但是任意组合它们便可以实现任意四则运算，我们看看![640?wx\_fmt=png][640_wx_fmt_png 4]这个如何组合。

首先在标准的Linux bash中我们试一下：

1.  `[root@10 test]# ./plus 5|./times 7|./sub 20|./div 6`
2.  `3`
3.  `6.000000`
4.  `[root@10 test]#`

计算结果显然是正确的。现在我在自己实现的tinysh中去做类似的事情：

1.  `[root@10 test]# ./tinysh`
2.  `tiny sh>>./plus 5|./times 7|./sub 20|./div 6`
3.  `3`
4.  `6.000000`
5.  `tiny sh>>q`
6.  `[root@10 test]#`

可以看到，tinysh的行为和标准Linux bash的行为是一致的。

简单吧，简单！无聊吧，无聊！Pipe连接了若干小程序，每一个小程序只做一件事。

如果我们的系统中没有任何shell程序，比如我们没有bash，我们只有tinysh，加上以上这4个程序，一共5个程序，就可以完成任意算式的四则混合运算。

现在我们用以上的组合Unix程序的方法试试计算下面的式子：

![640?wx\_fmt=png][640_wx_fmt_png 5]

根号怎么办？

按照非Unix的编程风格，就要在程序里写函数计算开根号，但是用Unix的风格，则只需要再加个开根号的程序即可：

1.  `// sqrt.c`
2.  `// gcc sqrt.c -lm -o sqrt`
3.  `#include <stdio.h>`
4.  `#include <stdlib.h>`
5.  `#include <math.h>`
6.  
7.  `int main(int argc, char *argv[])`
8.  `{`
9.  `float b;`
10. 
11. `scanf("%f", &b);`
12. 
13. `b = sqrt(b);`
14. `printf("%f\n", b);`
15. `}`

有了这个开根号的程序，结合已经有的四则运算程序，让我们的tinysh用pipe将它们串起来，就成了。好了，现在让我们计算上面的式子：

1.  `./tinysh`
2.  `tiny sh>>./sqrt |./plus 3|./div 2`
3.  `9`
4.  `3.000000`
5.  `tiny sh>>q`

本文该结束了，后面要写的应该就是关于经典Unix IPC的内容了，是的，自从Pipe之后，Unix便开启了IPC，System V开始称为标准并持续引领着未来，但这是另一篇文章的话题了。

最后，来自Unix初创者之一Dennis M. Ritchie关于Unix的满满回忆，非常感人：![640?wx\_fmt=png][640_wx_fmt_png 6]*The Evolution of the Unix Time-sharing System* ：

[300_Linux]: http://mp.weixin.qq.com/s?__biz=MzAwMDUwNDgxOA==&mid=2652666186&idx=1&sn=df4f056f8fec86cb7a6a5eaec1c069cd&chksm=810f3fd7b678b6c1a16645b2f3f4c1ccc252718db2012421a2a5dd6853427e7cf6e87f12940a&scene=21#wechat_redirect
[640_wx_fmt_png]: /images/20221119/cbe9fa392b514196ad9ebd32e4a42715.png
[640_wx_fmt_png 1]: /images/20221119/c9d19e7bb5e247c188314e9001dd9ddb.png
[640_wx_fmt_png 2]: https://img-blog.csdnimg.cn/img_convert/b686c13aa9adebe4b372a5028467fd8c.png
[640_wx_fmt_png 3]: https://img-blog.csdnimg.cn/img_convert/349667797a9b77b1d07089b782009105.png
[640_wx_fmt_png 4]: https://img-blog.csdnimg.cn/img_convert/3daf8bd1c710e1ba1645418073cb36f8.png
[640_wx_fmt_png 5]: https://img-blog.csdnimg.cn/img_convert/5eb1a9f24409240d989c484e5bbab794.png
[640_wx_fmt_png 6]: https://img-blog.csdnimg.cn/img_convert/76e9a992a7c71888e40440c52724872f.png