Linux 从文件描述符到管道

文件描述符

文件描述符的本质是数组元素的下标:

image

右侧的表成为i节点表,该数组的一个元素对应于一个物理文件。

中间的表称为文件表,一个结构体中有很多字段,其中3个字段比较重要:

  • file status flags:用于记录文件被打开来读的,还是写的。其实记录的就是open调用中用户指定的第2个参数
  • current file offset:用于记录文件的当前读写位置(指针)。
  • v-node ptr:该字段是指针,指向右侧表的一个元素,从而关联了物理文件。

左侧的表成为文件描述符,每个进程只有一张,数组的元素指向文件表的一个元素,数组元素的下标就是文件描述符

open系统调用执行的操作:新建一个i节点表元素,让其对应打开的物理文件(如果对应的i节点元素已建立,不做操作)。新建一个文件表的元素,根据open第2个参数设置file status flags字段,将current file offset字段置0,将v-node ptr指向刚建立的i节点表元素。在文件描述符表中,寻找1个尚未使用的元素,在该元素中填入一个指针值,让其指向刚刚建立的文件表元素。并将该元素的下标作为open的返回值返回。

fork与文件描述符

fork会导致子进程继承父进程打开的文件描述符,本质是将父进程的整个文件描述符表复制一份,放到子进程的PCB中。因此父子进程中有相同的文件描述符指向同一个文件表元素。导致父(子)进程读取文件后,子(父)进程将读取同一文件的后续内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#import <stdio.h>
#import <fcntl.h>
#import <stdlib.h>
#import <sys/types.h>
#import <unistd.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
int fd,pid,status;
char buf[10];
if((fd = open("./test.txt",O_RDONLY)) < 0){
perror("open");
exit(-1);
}
if((pid = fork()) < 0){
perror("fork");
exit(-1);
}else if(pid == 0){
read(fd,buf,2);
write(STDOUT_FILENO,buf,2);
close(fd);
exit(0);
}else{
wait(&status);
lseek(fd,SEEK_CUR,1);
read(fd,buf,3);
write(STDOUT_FILENO,buf,3);
write(STDOUT_FILENO,"\n",1);
close(fd);
}
}
return 0;
}

test.txt的内容为123456789,上面代码运行结果为12456。因为父进程调用wait等待子进程结束,所以子进程开始执行,读到字符12,由于父子进程的文件描述符fd都指向同一个文件表元素,因此当父进程执行时,fd对应的文件读写指针将移动到字符4,而不是字符2。所以父进程读到的是456,而不是234

如果是两个独立进程调用open去打开同一个物理文件,就会有2个文件表元素被创建,并且他们都指向同一个i节点表元素。两个文件表元素都有自己独立的current file offset字段,这将导致2个进程独立的对同一个物理文件进行读写。

还有一点,当子进程读写完文件后,关闭了文件描述符,父进程还是能继续读取,并且在原子进程读取的偏移上。因为fork后,文件表的引用将变为2,子进程关闭了文件描述符后,只是使文件表的引用变成了1,并不会影响父进程的读取结果。

但是如果我写成这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#import <stdio.h>
#import <fcntl.h>
#import <stdlib.h>
#import <sys/types.h>
#import <unistd.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
int fd,pid,status;
char buf[10];
if((fd = open("./test.txt",O_RDONLY)) < 0){
perror("open");
exit(-1);
}
if((pid = fork()) < 0){
perror("fork");
exit(-1);
}else if(pid == 0){
close(fd);
fd = open("./test.txt", O_RDONLY);
read(fd,buf,2);
write(STDOUT_FILENO,buf,2);
close(fd);
exit(0);
}else{
wait(&status);
lseek(fd,SEEK_CUR,1);
read(fd,buf,3);
write(STDOUT_FILENO,buf,3);
write(STDOUT_FILENO,"\n",1);
close(fd);
}
}
return 0;
}

那么输出的结构就是12234,因为子进程先关闭了文件描述符,然后重新生成了一个自己的文件描述符,指向一个新的文件表,并没有改变父进程文件表的current file offset。所以父进程读取的就是234

管道

管道作为进程间通信的方式之一,指的是从一个进程连接数据流到另一个进程。管道有以下特点:

  • 管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道;
  • 只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程);
  • 单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,但它不是普通的文件,它不属于某种文件系统,而是自立门户,单独构成一种文件系统,并且只存在与内存中;
  • 数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾,并且每次都是从缓冲区的头部读出数据。

pip进程管道

利用pipe创建的管道包含两个文件描述符fd[0]以及fd[1],需要注意的是,该处是文件描述符而不是文件流,对该文件描述符进行读写必须采用read和write系统调用,管道的两端是固定了任务的。即一端只能用于读,由描述字fd[0]表示,称其为管道读端;另一端则只能用于写,由描述字fd[1]来表示,称其为管道写端。如果试图从管道写端读取数据,或者向管道读端写入数据都将导致错误发生。

  1. 父进程调用pipe开辟管道,得到两个文件描述符指向管道的两端。
  2. 父进程调用fork创建子进程,那么子进程也有两个文件描述符指向同一管道。
  3. 父进程关闭管道读端,子进程关闭管道写端。父进程可以往管道里写,子进程可以从管道里读。

从管道中读取数据

  • 如果管道的写端不存在,则认为已经读到了数据的末尾,读函数返回的读取字节数为0;
  • 当管道的写端存在时,如果请求的字节数目大于PIPE_BUF,则返回管道中现有的数据字节数,如果请求的字节数目不大于PIPE_BUF,则返回管道中现有数据字节数(此时,管道中数据量小于请求的数据量);或者返回请求的字节数(此时,管道中数据量不小于请求的数据量)。

向管道中写入数据

  • 向管道中写入数据时,linux将不保证写入的原子性(原子操作就是不可分割的操作,不保证就是说可以分几次完成管道写入),管道缓冲区一有空闲区域,写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据,那么写操作将一直阻塞。
  • 只有在管道的读端存在时,向管道中写入数据才有意义。否则,向管道中写入数据的进程将收到内核传来的SIFPIPE信号,应用程序可以处理该信号,也可以忽略(默认动作则是应用程序终止)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int main(int argc, const char * argv[]) {
@autoreleasepool {
int pipe_fd[2];
pid_t pid;
char w_buf[4096];
if(pipe(pipe_fd) < 0){
printf("pip crate error\n");
return -1;
}
if((pid = fork()) == 0){
//子进程关闭写端
close(pipe_fd[1]);
//直接把读端也关闭了
close(pipe_fd[0]);
exit(0);
}else if(pid > 0){
wait(0);
//父进程关闭读端
close(pipe_fd[0]);
write(pipe_fd[1], w_buf, 4096);
close(pipe_fd[1]);
}
}
return 0;
}

上面程序,子进程把读端也关闭了后,父进程再去写就会收到SIFPIPE信号。

使用管道的shell

考虑一个使用管道的shell命令行:

1
ls -l | grep test

则上面的进程A相当于shell,进程B执行grep test,而进程C执行ls -l。不过,在进程C中要将标准输出通道stdout重定向到管道的写端,而在进程B中则要将标准输入通道stdin重定向到管道的读端。看一个实例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
int main(int argc,char *argv[])
{
int child_B, child_C;
int pipfds[2];
char* args1[] = {"grep","test",NULL};
char* args2[] = {"ls","-l",NULL};
/*process A*/
pipe(pipfds);
if(!(child_B = fork())){ //fork process B
close(pipfds[1]); //close the write
close(0); //redirect stdin
dup2(pipfds[0], 0);
close(pipfds[0]);
execve("/usr/bin/grep", args1, NULL);
printf("pid %d: I am back,something is wrong!\n",getpid());
}
/*process A continues*/
close(pipfds[0]); //close the read
if(!(child_C = fork())){
/*process C*/
close(1);//redirect stdout
dup2(pipfds[1], 1);
close(pipfds[1]);
execve("/bin/ls", args2, NULL);
printf("pid %d: I am back, something is wrong!\n",getpid());
}
/*process A continues*/
close(pipfds[1]); //close the write
wait4(child_B, NULL, 0, NULL);
printf("Done !\n");
return 0;
}

上面就是父进程A fork出来两个子进程,然后两个子进程通过重定位自己的标准输入输出到读/写端,来实现进程间的通信,也就是shell中的管道通信。

管道的局限性

  • 只支持单向数据流;
  • 只能用于具有亲缘关系的进程之间;
  • 没有名字;
  • 管道的缓冲区是有限的(管道制存在于内存中,在管道创建时,为缓冲区分配一个页面大小);
  • 管道所传送的是无格式字节流,这就要求管道的读出方和写入方必须事先约定好数据的格式,比如多少字节算作一个消息(或命令、或记录)等等;

命名管道

管道应用的一个重大限制是它没有名字,因此,只能用于具有亲缘关系的进程间通信,在有名管道(named pipe或FIFO)提出后,该限制得到了克服。FIFO不同于管道之处在于它提供一个路径名与之关联,以FIFO的文件形式存在于文件系统中。这样,即使与FIFO的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过FIFO相互通信(能够访问该路径的进程以及FIFO的创建进程之间),因此,通过FIFO不相关的进程也能交换数据。值得注意的是,FIFO严格遵循先进先出(first in first out),对管道及FIFO的读总是从开始处返回数据,对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。对命名管道的操作和对文件操作相似,包括创建,打开,读写,和关闭操作。

命名管道的创建

1
2
3
4
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);

该函数的第一个参数是一个普通的路径名,也就是创建后FIFO的名字。第二个参数与打开普通文件的open()函数中的mode 参数相同。如果mkfifo的第一个参数是一个已经存在的路径名时,会返回EEXIST错误,所以一般典型的调用代码首先会检查是否返回该错误,如果确实返回该错误,那么只要调用打开FIFO的函数就可以了。

1
2
3
4
5
6
7
8
if(access(FIFO_NAME,F_OK)==-1){
res=mkfifo(FIFO_NAME,0777);
if(res!=0){
fprintf(stderr,"Could not create fifo %s\n",FIFO_NAME);
exit(EXIT_FAILURE);
}
}
res=open(FIFO_NAME,open_mode);

命名管道的打开

打开的FIFO的限制是:由于FIFO是单向数据传输,程序不能以O_RDWR方式打开FIFO同时进行读写操作,只能是O_RDONLY或者O_WRONLY方式,打开函数如下:

1
2
3
4
5
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);

打开FIFO文件和普通文件的另外一个差别是:O_NONBLOCK选项对open的阻塞的影响,主要分为下面几种情况:

  • flags=O_RDONLY:open将会调用阻塞,除非有另外一个进程以写的方式打开同一个FIFO,否则一直等待。
  • flags=O_WRONLY:open将会调用阻塞,除非有另外一个进程以读的方式打开同一个FIFO,否则一直等待。
  • flags=O_RDONLY|O_NONBLOCK:如果此时没有其他进程以写的方式打开FIFO,此时open也会成功返回,此时FIFO被读打开,而不会返回错误。
  • flags=O_WRONLY|O_NONBLOCK:立即返回,如果此时没有其他进程以读的方式打开,open会失败打开,此时FIFO没有被打开,返回-1。

命名管道创建和打开测试程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include<sys/types.h>
#include<sys/stat.h>
#define FIFO_NAME "/tmp/my_fifo"
int main(int argc,char *argv[])
{
int res;
int open_mode=0;
if(argc < 2){
fprintf(stderr,"Usage:%s<some combination of \
O_RDONLY,O_WRONLY,O_NONBLOCK\n",*argv);
exit(EXIT_FAILURE);
}
argv++;
if(strncmp(*argv,"O_RDONLY",8)==0)open_mode|=O_RDONLY;
if(strncmp(*argv,"O_WRONLY",8)==0)open_mode|=O_WRONLY;
if(strncmp(*argv,"O_NONBLOCK",10)==0)open_mode|=O_NONBLOCK;
argv++;
if(*argv){
if(strncmp(*argv,"O_RDONLY",8)==0)open_mode|=O_RDONLY;
if(strncmp(*argv,"O_WRONLY",8)==0)open_mode|=O_WRONLY;
if(strncmp(*argv,"O_NONBLOCK",10)==0)open_mode|=O_NONBLOCK;
}
if(access(FIFO_NAME,F_OK)==-1){
res=mkfifo(FIFO_NAME,0777);
if(res!=0){
fprintf(stderr,"Could not create fifo %s\n",FIFO_NAME);
exit(EXIT_FAILURE);
}
}
printf("process %d open FIFO with %d\n",getpid(),open_mode);
res=open(FIFO_NAME,open_mode);
printf("process %d result %d\n",getpid(),res);
sleep(5);
if(res!=-1)close(res);
printf("process %d finished\n",getpid());
exit(EXIT_SUCCESS);
}

命名管道的读写

对命名管道的读写需要利用系统调用read函数:

1
2
3
4
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

在读取管道时,是否采用O_NONBLOCK非阻塞标志对管道的读有影响:

  • 对一个空的,阻塞的FIFO文件的read调用将会等待,直到有数据可以读时才继续执行。
  • 对一个空的,非阻塞的FIFO的read系统调用将会立即返回0字节。

在写管道时,需要考虑FIFO可以存在的数据长度是有限制的,在limits.h文件中由#definde PIPE_BUF语句定义,通常是4096字节。

对于设置了阻塞标志的写操作:

  • 当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数,则进入睡眠,直到当缓冲区中能够容纳要写入的字节数时,才开始进行一次性写操作。
  • 当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域,写进程就会试图向管道写入数据,写操作在写完所有请求写的数据后返回。

对于没有设置阻塞标志的写操作:

  • 当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后,写操作返回。
  • 当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数,写完后成功返回;如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数,则返回EAGAIN错误,提醒以后再写;

命名管道的关闭

1
2
3
#include <unistd.h>
int close(int fd);

总结

管道常用于两个方面:在shell中时常会用到管道(作为输入输入的重定向),在这种应用方式下,管道的创建对于用户来说是透明的;用于具有亲缘关系的进程间通信,用户自己创建管道,并完成读写操作。FIFO可以说是管道的推广,克服了管道无名字的限制,使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。管道和FIFO的数据是字节流,应用程序之间必须事先确定特定的传输”协议”,采用传播具有特定意义的消息。

AloneMonkey wechat
欢迎您扫一扫上面的微信公众号,订阅我的博客!