绑定完请刷新页面
取消
刷新
登录 | 注册

分享好友

×
取消 复制
60行C代码实现一个shell
2021-01-26 15:23:56

继 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

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

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

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

640?wx_fmt=png

我们把运算符加号，乘号，除号(暂不考虑括号，稍后解释为什么)这些看作是程序(事实上它们也真的是)，那么类似数字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

  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() > ) {
  7.             // 父进程递归解析下一个
  8.             exec_cmd(cmd->next, pp);
  9.             return ;
  10.         }
  11.         // 子进程执行
  12.         dup_in_out(pp);
  13.         exec(cmd->cmdline);
  14.     }
  15.     if (fork() > ) {
  16.         wait_all_child();
  17.         return ;
  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] = {};
  10.  
  11. void fork_and_exec(char *cmd, int pin, int pout)
  12. {
  13.     if (fork() == ) {
  14.         if (pin != -1) {
  15.             dup2 (pin, );
  16.             close(pin);
  17.         }
  18.         if (pout != -1) {
  19.             dup2 (pout, 1);
  20.             close(pout);
  21.         }
  22.         system(cmd);
  23.         exit();
  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++ = ;
  41. 			pipe(pipefd);
  42. 			fork_and_exec(cmd, in, pipefd[1]);
  43. 			execute_cmd(p, pipefd[]);
  44. 			return ;
  45. 		default:
  46. 			p++;
  47. 		}
  48. 	}
  49. 	fork_and_exec(cmd, in, -1);
  50. 	while(waitpid(-1, &status, WNOHANG) != -1);
  51. 	return ;
  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();
  61. 		} else {
  62. 			execute_cmd(cmd, -1);
  63. 		}
  64. 	}
  65. 	return ;
  66. }

下面是执行tinysh的结果：

  1. [root@10 test]# ls -l
  2. 总用量 28
  3. -rw-r--r-- 1 root root     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     9月   1 05:39 b
  6. -rw-r--r-- 1 root root     9月   1 05:39 c
  7. -rw-r--r-- 1 root root     9月   1 05:39 d
  8. -rw-r--r-- 1 root root     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

的计算，我需要写表示四则混合运算符的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这个如何组合。

首先在标准的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

根号怎么办？

按照非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=pngThe Evolution of the Unix Time-sharing System ：

                                                                                                                                                                                                                  文章来源：Linux阅码场



上一篇：9i迁移到12C实施流程
下一篇：切记！MySQL中order by与limit不要一起用！
分享好友

分享这个小栈给你的朋友们，一起进步吧。

数据架构
创建时间：2020-05-20 11:23:41
有关数据架构的小栈里面全都有
展开
订阅须知

• 所有用户可根据关注领域订阅专区或所有专区

• 付费订阅：虚拟交易，一经交易不退款；若特殊情况，可3日内客服咨询

• 专区发布评论属默认订阅所评论专区（除付费小栈外）

技术专家

查看更多
  • 小雨滴
    专家
戳我，来吐槽～

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8  北京市公安局海淀分局网监中心备案编号：11010802021510  未成年人举报专区

违法不良信息举报电话:18101376593   广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员