Linux 内核学习笔记：进程通信之“管道”

Linux 0.11 支持的进程通信方式只有管道和信号。这篇文章只关注前者。

每个管道允许两个进程交互数据，一个进程向管道写入数据，一个进程从管道读出数据。如下图所示：
图片来源：《Linux 内核设计的艺术》

操作系统在内存中为每个管道开辟一页内存，给这一页赋予了文件的属性。这一页内存由两个进程共享，但不会分配给任何进程，只由内核掌控。

管道创建

从技术上看，管道就是一页内存，但进程要以操作文件的方式对其进行操作，这就要求这页内存具备一些文件属性并减少页属性。

具备一些文件属性表现为，创建管道相当于创建一个文件，如进程 task_struct 中 *filp[20] 和 file_table[64] 挂接、新建 i 节点、file_table[64] 和文件 i 节点挂接等工作要在创建管道过程中完成，最终使进程只要知道自己在操作管道类型的文件就可以了，其他的都不用关心。

减少页属性表现为，这页内存毕竟要当作一个文件使用，进程不能像访问自己用户空间的数据一样访问它，不能映射到进程的线性地址空间内。另外，两个进程操作这个页面，一个读一个写，也不能产生页写保护异常吧页面另复制一份，否则无法共享管道。

典型例子

一个典型的利用管道进行通信的例子如下： 

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
#include <stdlib.h>
#include <unistd.h>
#define MAXLINE 1024

int main(void)
{
    int n;
    int fd[2];
    pid_t pid;
    char line[MAXLINE];

    if (pipe(fd) < 0)	// 创建管道
    {
        printf("pipe error\n");
        exit(1);
    }

    pid = fork();	// 进程派生
    if (pid < 0) 
    {
        printf("fork error\n");
        exit(1);
    }
    else if (pid > 0)   /* parent */
    { 
        close(fd[0]);   // 关闭读端
        write(fd[1], "hello world\n", 12);
    } 
    else                /* child */
    {       
        close(fd[1]);   // 关闭写端
        n = read(fd[0], line, MAXLINE);
        write(STDOUT_FILENO, line, n);
    }

    return 0;
}

上述程序中的管道继承可用下图表示：
图片来源：APUE

注：该例子为突出重点，假设 close、write、read 函数都成功执行。

sys_pipe 函数

创建管道文件的函数是 pipe。该函数经过映射最终调用的是 sys_pipe 函数。下边详细介绍管道创建过程。

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// fs/pipe.c -----------------------------------
int sys_pipe(unsigned long * fildes)	// *fildes -> fildes[2]
{
	struct m_inode * inode;
	struct file * f[2];
	int fd[2];
	int i,j;

// ** 步骤 1：在内核 file_table[64] 申请两个空闲项，一个给父进程用，另一个给子进程用 **

	j=0;
	for(i=0;j<2 && i<NR_FILE;i++)
		if (!file_table[i].f_count)
			(f[j++]=i+file_table)->f_count++;
	if (j==1)
		f[0]->f_count=0;
	if (j<2)
		return -1;

// ** 步骤 2：在进程 *filp[20] 申请两个空闲项，一个给父进程用，另一个给子进程用 **

	j=0;
	for(i=0;j<2 && i<NR_OPEN;i++)
		if (!current->filp[i]) {
			current->filp[ fd[j]=i ] = f[j];
			j++;
		}
	if (j==1)
		current->filp[fd[0]]=NULL;
	if (j<2) {
		f[0]->f_count=f[1]->f_count=0;
		return -1;
	}

// ** 步骤 3：在内核 inode_table[32] 申请管道文件 i 节点（其中涉及到申请空闲物理页面） **

	if (!(inode=get_pipe_inode())) {
		current->filp[fd[0]] =
			current->filp[fd[1]] = NULL;
		f[0]->f_count = f[1]->f_count = 0;
		return -1;
	}

// ** 步骤 4：将管道文件 i 节点挂接到在 file_table[64] 申请到的两个空闲项 **

	f[0]->f_inode = f[1]->f_inode = inode;
	f[0]->f_pos = f[1]->f_pos = 0;
	f[0]->f_mode = 1;		/* read */	// 读模式一般是子进程使用
	f[1]->f_mode = 2;		/* write */	// 写模式一般是父进程使用

// ** 步骤 5：设置（传入）读写管道文件句柄 **

	put_fs_long(fd[0],0+fildes);	// 设置读管道文件句柄（文件描述符），一般是子进程使用
	put_fs_long(fd[1],1+fildes);	// 设置写管道文件句柄（文件描述符），一般是父进程使用

	return 0;
}

// fs/inode.c ----------------------------------
struct m_inode * get_pipe_inode(void)
{
	struct m_inode * inode;

	if (!(inode = get_empty_inode()))	// 在内核 inode_table[32] 申请一个空闲项
		return NULL;
	if (!(inode->i_size=get_free_page())) {	// 此时，inode->size 不再表示文件大小，而是表示管道文件所在物理页面的内存地址
		inode->i_count = 0;
		return NULL;
	}
	inode->i_count = 2;	/* sum of readers/writers */	// 管道文件默认只有两个进程引用
	PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;		// PIPE_HEAD ->	写管道指针；PIPE_TAIL -> 读管道指针
	inode->i_pipe = 1;	// 设置该节点为管道型节点
	return inode;
}

// include/linux/fs.h --------------------------
#define PIPE_HEAD(inode) ((inode).i_zone[0])
#define PIPE_TAIL(inode) ((inode).i_zone[1])

需要注意的是，管道的创建工作都是由父进程完成，但子进程通过进程派生，继承了父进程的 *filp[20]。而在父进程中，*filp[20] 已经和 file_table[] 建立好关系，inode_table[] 也已经和 file_table[] 挂接好。子进程直接继承了这些关系。

管道读写操作

Linux 0.11 管道操作要实现的效果是，读管道进程执行时，如果管道中有未读数据，就读取数据，没有未读数据就挂起，这样就不会读取垃圾数据；写管道进程执行时，如果管道中有剩余空间，就写入数据，没有剩余空间了，就挂起，这样就不会覆盖尚未读取的数据。另外，管道大小只有一个页面，所以写或读到页面尾端后，读写指针要能够回滚到页面首端以便继续操作。

对于读管道操作，数据是从管道尾读出，并使管道尾指针前移‘读取字节数’个位置；对于写管道操作，数据是向管道头部写入，并使管道头指针前移‘写入字节数’个位置。可参见管道缓冲区操作示意图如下：
图片来源：《Linux 内核完全注释》

注：《Linux 内核设计的艺术》第 8.1.2 节“管道的操作”举了一个特别好的例子，值得参考！

读操作

读操作代码如下： 

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
45
46
47
48
49
50
51
52
53
54
55
56
57
// fs/read_write.c -----------------------------
int sys_read(unsigned int fd,char * buf,int count)
{
	struct file * file;
	struct m_inode * inode;

	......
	if (inode->i_pipe)
		return (file->f_mode&1)?read_pipe(inode,buf,count):-EIO;
	......
}

// fs/pipe.c -----------------------------------
int read_pipe(struct m_inode * inode, char * buf, int count)
{
	int chars, size, read = 0;

	while (count>0) {
		while (!(size=PIPE_SIZE(*inode))) {	// 如果管道没有未读数据
			wake_up(&inode->i_wait);	// 则唤醒等待该管道的进程（如写进程）
			if (inode->i_count != 2) /* are there any writers? */
				return read;
			sleep_on(&inode->i_wait);	// 当前进程挂起并开始任务调度
		}
		chars = PAGE_SIZE-PIPE_TAIL(*inode);	// PAGE_SIZE = 4096
		if (chars > count)
			chars = count;
		if (chars > size)
			chars = size;
		count -= chars;
		read += chars;
		size = PIPE_TAIL(*inode);

		PIPE_TAIL(*inode) += chars;	// 读多少数据，指针就偏移多少
		PIPE_TAIL(*inode) &= (PAGE_SIZE-1);	// 指针超过一个页面，（&= ）操作可以实现自动回滚

		while (chars-->0)
			put_fs_byte(((char *)inode->i_size)[size++],buf++);
	}
	wake_up(&inode->i_wait);	// 唤醒等待进程
	return read;
}

// include/linux/fs.h --------------------------
#define PIPE_HEAD(inode) ((inode).i_zone[0])
#define PIPE_TAIL(inode) ((inode).i_zone[1])
// 这个式子很有意思。即使 PIPE_HEAD(inode)-PIPE_TAIL(inode) < 0，跟 (PAGE_SIZE-1) 相与能够计算出管道未读数据的长度
#define PIPE_SIZE(inode) ((PIPE_HEAD(inode)-PIPE_TAIL(inode))&(PAGE_SIZE-1))	

// kernel/sched.c ------------------------------
void sleep_on(struct task_struct **p)
{
	......
	current->state = TASK_UNINTERRUPTIBLE;
	schedule();
	......
}

写操作

写操作代码如下： 

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
// fs/read_write.c -----------------------------
int sys_write(unsigned int fd,char * buf,int count)
{
	struct file * file;
	struct m_inode * inode;
	
	......
	if (inode->i_pipe)
		return (file->f_mode&2)?write_pipe(inode,buf,count):-EIO;
	......
}

// fs/pipe.c -----------------------------------
int write_pipe(struct m_inode * inode, char * buf, int count)
{
	int chars, size, written = 0;

	while (count>0) {
		while (!(size=(PAGE_SIZE-1)-PIPE_SIZE(*inode))) {	// 只要写 4095 个字节就算写满
			wake_up(&inode->i_wait);
			if (inode->i_count != 2) { /* no readers */
				current->signal |= (1<<(SIGPIPE-1));
				return written?written:-1;
			}
			sleep_on(&inode->i_wait);
		}
		chars = PAGE_SIZE-PIPE_HEAD(*inode);
		if (chars > count)
			chars = count;
		if (chars > size)
			chars = size;
		count -= chars;
		written += chars;
		size = PIPE_HEAD(*inode);

		PIPE_HEAD(*inode) += chars;	// 写多少数据就偏移多少
		PIPE_HEAD(*inode) &= (PAGE_SIZE-1);	// 指针超过一个页面，（&= ）操作可以实现自动回滚

		while (chars-->0)
			((char *)inode->i_size)[size++]=get_fs_byte(buf++);
	}
	wake_up(&inode->i_wait);	// 唤醒等待进程
	return written;
}

管道特性

管道特点如下：

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

管道的主要局限性正体现在它的特点上：

  • 只支持单向数据流（现在，某些系统提供全双工管道，但是为了最佳的可移植性，我们决不能预先假定系统提供此特性。）；
  • 只能用于具有亲缘关系的进程之间；
  • 没有名字（有名管道是 FIFO）；
  • 管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
  • 管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

谢宏峰，毕业于暨南大学（2009 - 2013）、中国科学院（2013 - 2016），现就职于深信服科技，从事 OpenStack 开发。