Skip to content

01 · shell 与文件描述符:那一行字是被谁分拣的 ​

您敲下一行命令,按下回车,程序跑起来了。中间这一步咱们平时根本不会去想:在真正的程序拿到控制权之前,已经有别的东西把这一行读过一遍了。它替咱们把字拆成词,把通配符摊开,再把文件接到几个小小的号码上。文件名、参数、重定向,这一整篇讲的都是这一段路。

笔者把自己机器的底细交出来,因为后面好几处现象会被它改掉。咱们坐在一个受限的机器里:当前 uid 是 1000,没有 root,而且 / 挂的是只读(touch /x 会当场回一句 Read-only file system,这不是笔误)。所以凡是会落到根目录的操作,咱们都得换成自己名下的目录,改属主那段内容也只能照着书看。ps -e 拉出来只有个位数的几条,进程号都是个位到三位数,因为这儿有一份自己的 PID 名字空间。最后一条跟重定向关系最近:默认没有任何控制终端,tty 直接答 not a tty。下面好几处要读 1 号、2 号指向哪儿,在这机器上它们指的是个普通文件。您坐在自己的终端前敲,1 号和 2 号指的就是那个终端。这三条您记在心里,差别出在哪儿,咱们每读到一处就说一处。

shell 认名字,认不了才去磁盘上找 ​

您敲的每个字,shell 自己都看一眼。type 这个内建干的活,就是把同一个名字的所有身份摆出来:

bash
type -a echo
type -a cd
type -a ls
text
$ type -a echo
echo is a shell builtin
echo is /usr/sbin/echo
echo is /usr/bin/echo
echo is /sbin/echo
echo is /bin/echo
$ type -a cd
cd is a shell builtin
$ type -a ls
ls is /usr/sbin/ls
ls is /usr/bin/ls
ls is /sbin/ls
ls is /bin/ls

咱们看这一屏,echo 有好几个身份:一个住在 shell 自己身体里,另外几个是磁盘上的可执行文件,身份有几个跟着发行版走。cd 只报出一行,它没有磁盘上的那一半。ls 反过来,只有磁盘文件那一重身份,没有内建。内建永远排在候选的第一位,这是 bash 的做法。想让那个内建让位,command 帮不上忙 —— 它只压函数和别名,echo 照样走内建。真要让位,得把内建关掉,enable -n echo,或者干脆写绝对路径 /usr/bin/echo。

您那边 ls 可能只列两条路径,也可能多出一行别名排在前面,因为存可执行文件的目录各发行版不完全一样。真正稳的形状只有一句:名字由 shell 自己认,认不了才去磁盘上找。

那 cd 为什么不能换个身份,躺到磁盘上当个普通程序?咱们把它挪进一个子进程,看它改的是谁的目录:

bash
sh -c "cd /; pwd"
pwd
text
$ sh -c "cd /; pwd"
/
$ pwd
(您此刻所在的那个目录)

子进程打出来的 /,是它自己的目录变了。轮到当前这个 shell 打 pwd,打出来的是您此刻所在的那个目录,一点没挪窝。您看一个程序换掉自己的目录,换完自己也退场了,父 shell 手里那些东西一点没动。所以 cd 这件事只能由 shell 亲手办,它没有内建以外的选项。

还有一句方言提示:上面那句里的引号在您手上怎么写都行,sh 只是我随手起的一个子进程。咱们待会儿还会用到同样的手法好几次。

文件描述符就是一个非负整数 ​

内核要记一个进程开着哪些文件,它不看文件名。APUE 那句定义写得很干净,打开的文件在内核眼里一律由文件描述符来指,而文件描述符是一个非负整数。整数有几个,一个进程就同时开着几样东西。咱们下面看到的每一格,都是这个意义上的一个整数。

咱们让一个进程刚起来的时候,把手里三个格子读出来看看。proc 里那个 fd 目录就是它的族谱,一格一行:

bash
ls -l /proc/$$/fd
text
total 0
lr-x------ 1 您 您 64 Oct  2 16:09 0 -> /dev/null
l-wx------ 1 您 您 64 Oct  2 16:09 1 -> .../一份捕获文件
l-wx------ 1 您 您 64 Oct  2 16:09 2 -> .../一份捕获文件

头一行那个 total 0 说的是这些条目合起来占的块数是零,这几个号都不落在磁盘上。头一列那个 l 是符号链接。r-x 与 -wx 说的是这个号开成了读、还是开成了写。0 号的开法只读,1 号和 2 号的开法只写,同一个目标换一种开法,这几个字母就跟着变,它记的是开法,不是目标本身。箭头前面那几段是链接数、属主与属组、大小、时间,它们在每一格上长得一模一样,真正变的只有箭头后面那个目标。那一屏里的 1 号与 2 号箭头后面是同一条路,因为那一跑把整屏都写进了同一个文件。箭头后面是机器上的绝对路径,咱们掐成 ... 只留形状。号码后面的用户名当然要换成您自己的,时间戳和那几列数字也是读出来的。

0 是读进来的入口,1 是写出去的出口,2 是报错走的路。TLPI 说一个进程从 shell 那里继承三格的副本,而交互式 shell 里三个格子通常都指着它脚下的终端。上面那一屏是本机此刻读出来的:它没有终端,0 号从 /dev/null 读,1 号和 2 号写进了同一份捕获文件。您在自己的终端上敲同一条命令,读出来的是 /dev/pts/N,而且三格指向同一个号,那才是坐在终端前的样子。N 每次不同。

再开一格看看。您看 exec 后面跟一个重定向,shell 不会去起新进程,它只是把这个重定向装在自己身上,而且装完一直留着。这一手会真的在您当前目录里建出 scratch.txt,别在大热目录里试,挑一个自己认得的临时目录下手。这一段的几拍要按顺序走完,咱们写成一个脚本再跑:

bash
exec 3> scratch.txt
ls -l /proc/$$/fd
echo "写进 3 号" >&3
exec 3>&-
ls -l /proc/$$/fd
cat scratch.txt
text
total 0
lr-x------ 1 您 您 64 Oct  2 16:09 0 -> /dev/null
l-wx------ 1 您 您 64 Oct  2 16:09 1 -> .../一份捕获文件
l-wx------ 1 您 您 64 Oct  2 16:09 2 -> .../一份捕获文件
lr-x------ 1 您 您 64 Oct  2 16:09 255 -> .../一个脚本文件
l-wx------ 1 您 您 64 Oct  2 16:09 3 -> .../out/scratch.txt
total 0
lr-x------ 1 您 您 64 Oct  2 16:09 0 -> /dev/null
l-wx------ 1 您 您 64 Oct  2 16:09 1 -> .../一份捕获文件
l-wx------ 1 您 您 64 Oct  2 16:09 2 -> .../一份捕获文件
lr-x------ 1 您 您 64 Oct  2 16:09 255 -> .../一个脚本文件
写进 3 号

第一张表里多出一行,号码那一列写着 3,右箭头后面跟着 scratch.txt 的落点。接着 exec 3>&- 把它关掉,第二张表里 3 就没影了。脚本最后那一步是把文件读回来,屏幕上那行 写进 3 号 就是当初从 3 号写进去的内容:exec 3>&- 关掉的是这个进程手里那个编号,文件里那行字一个字都没少。表里还有一行 255 -> .../一个脚本文件,那是 bash 自己占着脚本文件的一格,和您开的号无关。换个 shell,这一行的号在不在、是几号,都可能不一样,别把它当成定数。ls -l /proc/$$/fd 里的 $$ 指的是当前这个 shell 的进程号。上面列出的表都是 ls -l 的原样,头一行 total 0 也在。等到讲 fd 号来路的地方,有三块用 awk 挑过的表,只留号、箭头和指向,ls -l 行首的权限字母、链接数、属主与属组、大小和时间那几段就没跟过来。

上面那几张表里箭头后面的目标,是本机此刻的指向,可能是一个终端设备,也可能是一个普通文件,您那边读出来的就跟这儿不一样。真正不会变的是那两步:开一格就多一行,关一格就少一行。proc 里那个 fd 目录还有个口径要说清,您照着敲的 ls -l /proc/$$/fd 问的是当前这个 shell 手里有哪些号,它和您自己的进程号绑在一起,同一台机器上换一个进程,读出来的号就不一样。

2>&1 >f 和 >f 2>&1,同一串字符两个结果 ​

现在咱们让一个必失败的命令出来说话,顺便把错误和输出分头安置。bash 的手册页有一句话很硬:重定向按它出现的次序,从左往右一个换一个地办。

bash
ls nope 2>&1 >o1.txt
ls nope >o2.txt 2>&1
ls nope &>o3.txt
wc -c o1.txt o2.txt o3.txt
text
$ ls nope 2>&1 >o1.txt
ls: cannot access 'nope': No such file or directory

$ ls nope >o2.txt 2>&1

$ ls nope &>o3.txt

$ wc -c o1.txt o2.txt o3.txt
  0 o1.txt
 52 o2.txt
 52 o3.txt
104 total

第一条命令里,2>&1 排在前面。它动手的那一刻,1 号还指着它原来的目标(这机器上是个普通文件,您的终端上就是那个终端),所以 2 号并过去,也就并到了那个目标上。等这一手办完,>o1.txt 才把 1 号挪到文件上,可 2 号已经安顿好了,不会再跟着走。于是咱们看到报错上了屏,而 o1.txt 是 0 字节。

第二条命令把顺序倒过来。咱们看 >o2.txt 走在前面,1 号落到文件上,2>&1 再办的时候,2 号并的就成了那个文件。o2.txt 拿到的正好是报错那一行,52 字节,连同收尾的换行一起算。

第三条 &>o3.txt 是 bash 的扩展,它把 1 号和 2 号一把写进同一个文件,POSIX 不认这个写法。咱们拿它来跟前面两条对照,o3.txt 里也是那一行报错,同样 52 字节。

104 是三行数据加起来,0、52、52,这里没什么花样。可咱们也看清了一件事:wc -c 数的是字节,不是行。

屏幕上那 0、52、52 只属于本机此刻的状态。那行报错的字数跟着文件名的长短走,您把 nope 换成别的名字,数字立刻变。跟着形状走的是另一部分:谁前谁后,谁并到哪个号上。

fd 号从哪来:两条路,不是一个东西 ​

咱们看同一张 fd 表,号码的来路却有两条,分不清就会把 bash 的习惯当成内核的规则。

bash 在 {名字}> 里给自己挑号,这个是 bash 自己的写法,POSIX 的 sh 不认。这一段要连着读三次表,写成一个脚本,awk 那半句是为了把 ls 的长行裁短,只留号、箭头和指向。咱们把三次读数按顺序排开:

bash
exec 3> f3.txt
ls -l /proc/$$/fd | awk '{print $9, $10, $11}'
exec {n}> auto.txt
ls -l /proc/$$/fd | awk '{print $9, $10, $11}'
exec 3>&-
exec {m}> auto2.txt
ls -l /proc/$$/fd | awk '{print $9, $10, $11}'

咱们读到的第一张表,是在 exec 3> f3.txt 之后:

text
0 -> /dev/null
1 -> .../一份捕获文件
2 -> .../一份捕获文件
255 -> .../一个脚本文件
3 -> .../out/f3.txt

咱们接着看第二张表,它在 exec {n}> auto.txt 之后:

text
0 -> /dev/null
1 -> .../一份捕获文件
10 -> .../out/auto.txt
2 -> .../一份捕获文件
255 -> .../一个脚本文件
3 -> .../out/f3.txt

第三张表在 exec 3>&- 再 exec {m}> auto2.txt 之后,咱们看号码落在哪儿:

text
0 -> /dev/null
1 -> .../一份捕获文件
10 -> .../out/auto.txt
11 -> .../out/auto2.txt
2 -> .../一份捕获文件
255 -> .../一个脚本文件

3 号是咱们亲手点的号。轮到 {n}>,bash 一次挑出 10,第二张表里多出 auto.txt 那一行,号码是 10。您看咱们把 3 号关掉了,第三张表里 3 号那一行没了,auto2.txt 那一行却读作 11。它明明可以把刚空出来的 3 号再拿来用,它偏不。bash 手册页把分配规则写明了:shell 分配一个大于或等于 10 的描述符,把它交给那个变量,而且这个重定向在命令结束之后依然有效。这也是为什么咱们能用它开、能留到最后再关。

三张表读起来有点乱,是因为 ls 按字典序排。第二张表里 10 排在 2 前面,0、10、2、255、3 一路下来,2 不是不见了,它只是排到了后面。乱的只是顺序,号一直在表里。上面那几行箭头后面的路也是机器上的绝对路径,咱们掐成 ... 只留形状。

内核那边走的是另一条路。C 程序里 open() 成功之后拿到的号,遵守 SUSv3 给出的一条保证,它总是取这个进程里最小的未使用号。咱们现写一个十几行的小文件,存成 fdopen.c,连开四个:

c
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int main(void) {
    const char *names[] = {"a.txt", "b.txt", "c.txt"};
    int fds[3];
    for (int i = 0; i < 3; i++) {
        fds[i] = open(names[i], O_WRONLY | O_CREAT | O_TRUNC, 0644);
        printf("open(\"%s\") -> fd %d\n", names[i], fds[i]);
    }
    close(fds[1]);
    int d = open("d.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    printf("open(\"d.txt\") -> fd %d\n", d);
    return 0;
}
bash
gcc -o fdopen fdopen.c
./fdopen
text
open("a.txt") -> fd 3
open("b.txt") -> fd 4
open("c.txt") -> fd 5
open("d.txt") -> fd 4

前三个依次拿走 3、4、5。咱们把 4 关掉,再开 d.txt,它回到 4。同一台机器上,exec {n}> 挑 10,open() 挑 4,两条路的差别就摆在这里。a.txt 到 d.txt 四个空文件是这一跑真的在您当前目录里建出来的,别忘了在临时目录里收拾。

变量与子进程之间那道墙 ​

一个普通变量,子进程就是看不见它,export 之后才看得见。咱们把这道界线摆出来:

bash
A=hello
bash -c "echo \$A"
export A
bash -c "echo \$A"
text
$ bash -c "echo \$A"

$ export A
$ bash -c "echo \$A"
hello

第一趟打出来的是一条空行,它不是报错。$A 在子进程里是一个未设置的变量,展开之后就是空串。POSIX 对未设置的参数就是这么处理的,咱们看不见它,可它也不吭声。export 把 A 塞进环境变量表之后,子进程启起来时会带着环境表,第二趟才打出 hello。

本篇开头那个子 shell 里的 cd,走的也是这道界线,咱们拼回来看。子进程是父 shell 的一份拷贝,它改自己的东西,父 shell 一动不动。文件描述符看着有点像例外,其实不是:1 号和 2 号能被子进程用上,是因为它们被继承过去了,不是因为谁共享了它们。

引号表:同一串字,三种引法 ​

引号这一道工序咱们得单独过一遍。下面的表是这一篇里最该动手跑一次的现场,咱们把同一样东西在单引号、双引号、反斜杠三种写法下的结果并排摆开看看。show 每次收下参数,报一个数,再把每个参数用方括号包起来。这一趟要在干净目录里跑,动手之前备好两样:一个空目录 cd "$(mktemp -d)"(出口是 cd -),再 touch a.txt b.txt c.dat 造出三个空文件。表里 * 的位置摊出来的就是 a.txt、b.txt、c.dat 三个名字,您目录里要是有别的东西,摊出来的就是别的名字,个数会变。函数和那十几行调用要贴在同一个 shell 里,n=3 也得设好。

展开代码收起代码共 23 行
bash
show() {
  printf '  shell 里写的 : %s\n' "$1"
  shift
  printf '  子进程收到 %d 个参数:\n' "$#"
  for a in "$@"; do printf '    [%s]\n' "$a"; done
}
n=3
show 'a\ b' a\ b
show '"a b"' "a b"
show '$n' $n
show '"$n"' "$n"
show "'\$n'" '$n'
show '\$n' \$n
show '"\$n"' "\$n"
show "'\\\$n'" '\$n'
show '*' *
show '"*"' "*"
show '\*' \*
show '$(printf "A\nB")' $(printf 'A\nB')
show '"$(printf "A\nB")"' "$(printf 'A\nB')"
show "'\$(printf \"A\\\\nB\")'" '$(printf "A\nB")'
show "'it'\\''s'" 'it'\''s'
show '"say \"hi\""' "say \"hi\""
展开代码收起代码共 52 行
text
  shell 里写的 : a\ b
  子进程收到 1 个参数:
    [a b]
  shell 里写的 : "a b"
  子进程收到 1 个参数:
    [a b]
  shell 里写的 : $n
  子进程收到 1 个参数:
    [3]
  shell 里写的 : "$n"
  子进程收到 1 个参数:
    [3]
  shell 里写的 : '$n'
  子进程收到 1 个参数:
    [$n]
  shell 里写的 : \$n
  子进程收到 1 个参数:
    [$n]
  shell 里写的 : "\$n"
  子进程收到 1 个参数:
    [$n]
  shell 里写的 : '\$n'
  子进程收到 1 个参数:
    [\$n]
  shell 里写的 : *
  子进程收到 3 个参数:
    [a.txt]
    [b.txt]
    [c.dat]
  shell 里写的 : "*"
  子进程收到 1 个参数:
    [*]
  shell 里写的 : \*
  子进程收到 1 个参数:
    [*]
  shell 里写的 : $(printf "A\nB")
  子进程收到 2 个参数:
    [A]
    [B]
  shell 里写的 : "$(printf "A\nB")"
  子进程收到 1 个参数:
    [A
B]
  shell 里写的 : '$(printf "A\\nB")'
  子进程收到 1 个参数:
    [$(printf "A\nB")]
  shell 里写的 : 'it'\''s'
  子进程收到 1 个参数:
    [it's]
  shell 里写的 : "say \"hi\""
  子进程收到 1 个参数:
    [say "hi"]

表里每一组都分成三段:头一段是您敲进去的字,接着是子进程收到几个参数,最后方括号里是它真正收到的内容。段数固定,行数不固定,参数一多,方括号就往下多排几行。咱们一组一组往下看。

单引号里什么都是字面。您写 '$n',子进程收到的就是美元号加一个 n 两个字符。反斜杠在单引号里也是普通字符,所以 '\$n' 交出去的是三个字符。POSIX 的原话还补了半句:单引号里面不可能再出现一个单引号。真要放一个,得把单引号合上,写一个反斜杠转义的单引号,再把单引号重新打开,三段接起来就是表里 it 那一行的形状。

双引号里活着的东西数得出来:反引号、美元号、反斜杠,再加上要写双引号本身时用的那个 \"。* 在里面不再通配,您看 "*" 交出去就是一个星号。反过来,参数展开和命令替换照常办:裸 $n 和 "$n" 都收下 3。反斜杠在双引号里只管一件事,让紧跟在它后面的那个 $、反引号、反斜杠或者换行别乱动,其余位置它就是个普通字符。"\$n" 前面的反斜杠正好跟在 $ 前面,于是交出去的是美元号加 n 两个字符。

最值钱的一组是 $(...) 那两行。不加引号的命令替换,结果会被切成字段,printf 打出来的两行断成两个参数,A 一行,B 一行。咱们加上双引号,整个结果算一个字段,连中间那个换行一起塞进来,方括号因此收在第二行才合上。那个换行就在这一个参数里面,是咱们要看的证据。

同样的切法还有一个开关叫 IFS,它决定字段在哪些字符上断开。您把 IFS=: 单独写成一句(用分号接在它后面也算),再敲 printf "[%s]\n" $(echo a:b:c),命令替换的结果就会在冒号上断开,一列切成三个。IFS 得单独成句才生效,它只影响您设置它之后的那几行。

展开:通配、算术、命令替换 ​

咱们让引号管的是别展开,而展开本身有四道,平时一起上,只是次序有讲究:切字段排在通配前面,所以 IFS 得单独成句才切得动。下面这几条就在上面那个干净目录里接着敲,a.txt、b.txt 还在那儿。

bash
echo *.txt
echo $((2+2))
echo "$(printf "x\ny")"
IFS=: ; printf "[%s]\n" $(echo a:b:c)
text
$ echo *.txt
a.txt b.txt
$ echo $((2+2))
4
$ echo "$(printf "x\ny")"
x
y
$ IFS=: ; printf "[%s]\n" $(echo a:b:c)
[a]
[b]
[c]

咱们看 *.txt 摊成两个名字,$((2+2)) 直接算成 4,命令替换把两行接进来,IFS 再把 a:b:c 切成三份。通配和算术都在 shell 里办完,交给 echo 的时候已经是成品了。

通配符有个默认脾气:它不吃隐藏文件。名字以一个点开头的文件,* 看不见,咱们得换个写法才够得着。这一趟也换到干净目录里做,cd "$(mktemp -d)",再 touch a.txt b.txt .hidden,让目录里同时有明有暗:

bash
printf "[%s]\n" *
printf "[%s]\n" .*
shopt -s dotglob; printf "[%s]\n" *
text
$ printf "[%s]\n" *
[a.txt]
[b.txt]
$ printf "[%s]\n" .*
[.hidden]
$ shopt -s dotglob; printf "[%s]\n" *
[.hidden]
[a.txt]
[b.txt]

上面这几行的名字都是这一趟自己造出来的:两个 .txt 明着摆在目录里,.hidden 带一个点,平时 * 根本不看它。您那边目录里要是还有别的东西,摊出来就多几个名字,形状不变。

.* 的结果要请您多看一眼:咱们手上这个 bash 是 5.3,只吐出 .hidden,没有 . 和 ..。TLCL 书页 70 写的是老版本的行为,原话说得很明白,说仔细看会发现 . 和 .. 两个名字也在结果里。同一个写法两种结果,差别落在这个 bash 的版本上,咱们坐在新的那一侧。管这件事的是一个叫 globskipdots 的开关,bash 5.2 起默认开着,5.2 以前的版本会照老版本的样子多出 . 和 .. 两个名字,看到别慌 —— 就算您手上是 5.2 以后的版本,把 shopt -u globskipdots 一敲,也立刻回到那个老样子。

上面那个 shopt -s dotglob 是 bash 的扩展,咱们开了它之后 * 连隐藏文件一起吃。POSIX 不认这个开关,所以能不用就不用。

改属主与改属组:本机没有 root,这一节只能照书看 ​

您看 ls -l 那一列里,所有者名字后面跟着组名,两个字段不是摆设,它们真的能改。TLCL 第 9 章给了两条命令,书页 101 到 106 那一段给了 chown 的调用形状,所有者与属组之间用冒号分隔,方括号表示可以省掉,file... 表示后面能跟一串文件。书里还单独提了 chgrp,它只改属组。

书里还交代了一句来历。老版本的 Unix 里 chown 只管所有者,不管组,改组这件事由单独的 chgrp 办,它沿用至今。换句话说,chown 现在能一把改两样,chgrp 专门留给组。落到具体的一条命令上,书的写法是 chown owner:group 文件,您只写 owner 就是光改所有者。

不过咱们这边没有 root,/ 还挂着只读,chown 和 chgrp 一条都跑不动,您试着敲也会被系统挡回来。所以这一幕在这儿给不出真输出,这一段只能按书上写的讲。您在自己的机器上做的时候,记得两条命令改的是文件系统的记录,得拿有权限的身份去办,书里讲拿到那个身份的办法在书页 101 到 104。

有一件相关的事咱们今天做不了:umask 怎么削掉新建文件的权限,这一篇没实测过,这里不给数字(新建文件的权限位会被它削掉几位,书页 98 到 100 给了两个常见取值和一张掩码算例)。想动权限位本身,chmod 的符号写法书页 94 到 100 讲得够细,咱们这一篇不重讲。

lseek 欠一笔,管道的事留给下一篇 ​

2>&1 和 > 谁前谁后,这一篇给了两组结果,谁前谁后的差别,还能往下挖。管道那边还有一整套东西没露面:一根竖线到底交回几个描述符,管道满了会怎么样,一头走掉之后另一头等的是什么。这些跟在重定向后面,咱们留给下一篇。

APUE 图 3.1 上那组 lseek 的偏移量实验,和配合它的 copy 程序四连跑,这一篇一个都没做,lseek 在这里也不编,这里欠着一笔。这一篇引到的来源得数清。APUE 那句 fd 的定义在第 3 章,书页 61。.* 摊开时多出 . 和 .. 那件事,TLCL 书页 70 有原话。chown 与 chgrp 两条命令在 TLCL 书页 101 到 106,umask 与 chmod 的页号就在上面权限那一段。TLPI 把三格从 shell 继承这件事放在第 4 章,书页 70。open() 的保证来自 SUSv3,重定向从左往右那句拿的是 bash 手册页。凡是只写到章节没给页号的,咱们就只写到章节,不凭记忆补一个数。

r35_gui_fin-7-gcb9e24e · cb9e24e · 2026-10-30