pipe函数内核实现

pipe源码分析

本文基于linux kernel 4.13 分析，与通用的2.6差距较大。请读者自行甄别本文的特性，是否符合自己当前环境。

本文要解决的问题

1：pipe源码分析

2：pipe大小限制

3：如果没有读（写）端了，那么我写（读）操作会发生什么。

父子进程之间通信，首先想到的是pipe函数，pipe函数返回2个fd。通常，fork前先调用pipe，fd[0]负责读，fd[1]负责写。

示例程序往往是这样

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

main()
{
  int pipefd[2];
  int pid;
  int i, line;
  char s[100]={0};

  if (pipe(pipefd) < 0) {
    perror("pipe");
    exit(1);
  }

  pid = fork();

  if (pid > 0)//父进程
   {
      printf("fater writing....\n");
      memcpy(s,"helloworld\n",strlen("helloworld\n"));
      write(pipefd[1], s, strlen(s));
      close(pipefd[1]);
  }
  else//子进程
  {
        printf("child reading....\n");
        read(pipefd[0],s,1000);
        printf("read result: %s\n",s);
        close(pipefd[0]);
  }
}

通常，还有人告诉你，上面程序中，父进程还需要关闭pipefd[0]，子进程还需要关闭pipefd[1]。因为fork后，“子进程继承父进程文件描述符”，这里就不纠结细节了。

第一节：fd的创建以及关联

pipe() 系统调用对应的内核函数是sys_pipe，它由SYSCALL_DEFINE1宏来生成，由下面函数可以看到，sys_pipe实际调用了sys_pipe2函数。

fs/pipe.c(kernel 4.13)

SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)
{
	struct file *files[2];
	int fd[2];
	int error;
	/*
	__do_pipe_flags函数生成fd和files
	*/
	error = __do_pipe_flags(fd, files, flags);
	if (!error) {
		/*我们不关心错误处理*/
		if (unlikely(copy_to_user(fildes, fd, sizeof(fd)))) {
			fput(files[0]);
			fput(files[1]);
			put_unused_fd(fd[0]);
			put_unused_fd(fd[1]);
			error = -EFAULT;
		} else {
			/*这里是核心，将一个int 型的 fd 和  一个struct file型的files关联起来*/

			fd_install(fd[0], files[0]);
			fd_install(fd[1], files[1]);
		}
	}
	return error;
}

SYSCALL_DEFINE1(pipe, int __user *, fildes)
{
	return sys_pipe2(fildes, 0);
}

我们先看fd_install的实现，在看看__do_pipe_flags如何创建fd和files的。
fs/file.c
void fd_install(unsigned int fd, struct file *file)
{
	__fd_install(current->files, fd, file);
}

void __fd_install(struct files_struct *files, unsigned int fd,
		struct file *file)
{
	struct fdtable *fdt;
	spin_lock(&files->file_lock);
	fdt = files_fdtable(files);
	BUG_ON(fdt->fd[fd] != NULL);
	rcu_assign_pointer(fdt->fd[fd], file);
	spin_unlock(&files->file_lock);
}

current用来描述当前进程，是一个struct task_struct类型的结构体。

每个current进程都有一个 文件描述符表，即 current->files->fdt

所以 上面的代码中，__fd_install 函数核心功能就是执行 current->files->fdt[fd] = files。这样，一个int 的fd和一个struct file的files对应起来了，当前进程的任何一个fd就能找到唯一个files。

fd我们都知道，但是 struct file 是上面东西？那 现在我们来看看__do_pipe_flags函数，上面说了，它创建了一对fd和一对files。根据pipe的用法，我们知道能猜到，这两个fd肯定是有关系的，否则不可能一个fd写，另一个fd能读，而且只有亲属关系的进程间才能这样。

又因为一个fd能关联到一个files，那么也就是说，我们需要实现两个files有关联，这样，两个fd就自然有关联了。

static int __do_pipe_flags(int *fd, struct file **files, int flags)
{
	int error;
	int fdw, fdr;

	if (flags & ~(O_CLOEXEC | O_NONBLOCK | O_DIRECT))
		return -EINVAL;

	error = create_pipe_files(files, flags);
	if (error)
		return error;

	error = get_unused_fd_flags(flags);
	if (error < 0)
		goto err_read_pipe;
	fdr = error;

	error = get_unused_fd_flags(flags);
	if (error < 0)
		goto err_fdr;
	fdw = error;

	audit_fd_pair(fdr, fdw);
	fd[0] = fdr;
	fd[1] = fdw;
	return 0;

 err_fdr:
	put_unused_fd(fdr);
 err_read_pipe:
	fput(files[0]);
	fput(files[1]);
	return error;
}

__do_pipe_flags函数关键是 create_pipe_files，而其他的函数例如get_unused_fd_flags，顾名思义，获取一个可用的fd号而已，通过这个函数获取一个fdr和fdw。

着重讲create_pipe_files函数，他创建了2个有关联的struct file 的 files。

int create_pipe_files(struct file **res, int flags)
{
	int err;
	struct inode *inode = get_pipe_inode();
	struct file *f;
	struct path path;
	static struct qstr name = { .name = "" };

	if (!inode)
		return -ENFILE;

	err = -ENOMEM;
	path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name);
	if (!path.dentry)
		goto err_inode;
	path.mnt = mntget(pipe_mnt);

	d_instantiate(path.dentry, inode);

	err = -ENFILE;
	f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);
	if (IS_ERR(f))
		goto err_dentry;

	f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT));
	f->private_data = inode->i_pipe;

	res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops);
	if (IS_ERR(res[0]))
		goto err_file;

	path_get(&path);
	res[0]->private_data = inode->i_pipe;
	res[0]->f_flags = O_RDONLY | (flags & O_NONBLOCK);
	res[1] = f;
	return 0;

err_file:
	put_filp(f);
err_dentry:
	free_pipe_info(inode->i_pipe);
	path_put(&path);
	return err;

err_inode:
	free_pipe_info(inode->i_pipe);
	iput(inode);
	return err;
}

上面涉及到了文件系统的各个方面，所以比较复杂，我们这里不详细说各个数据结构的作用，

inode很重要，通过get_pipe_inode函数获取。

inode->i_fop = &pipefifo_fops；//指定了一对操作函数，告诉vfs如何读写等操作。

inode->i_pipe = pipe；

后续我们会关注，pipe中的数据结构。

pipe->bufs

pipe->tmp_page

files创建：

files[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops);

files[1] = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);

从第二个参数就知道，这两个file限制了各自的功能，也就意味着，对应的两个fd也限制了各自的功能。

d_instantiate(path.dentry, inode); 相当于执行了 path.dentry->d_inode = inode；

这样，alloc_file函数中，file->f_path = *path，就相当于file[x]->f_path.dentry->d_inode = inode，也即两个file指向了一个inode。

这个就是所谓的两个file关联。

下面这句话，简单的把pipe放在file中，方便取值，否则给定一个files，如果需要获取pipe，就需要从file->f_path.dentry->d_inode->i_pipe去的取得，这显然不合适。

files[0]->private_data = inode->i_pipe;

files[1]->private_data = inode->i_pipe;

至此sys_pipe函数执行完毕，它创建了2个互相关联的file，然后创建了2个fd，fd与file一一对应。

其次file都指向了同一个inode，我们可以想象，如果自己接下去实现读写，那么写的数据，肯定放在inode中了，事实也是如此。

第二节 通过fd[0]读和通过fd[1]写

读写操作，在用户态，都是read和write，其对于的内核函数分别是sys_read和sys_write。我们先看写操作，

fs/read_write.c

SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
		size_t, count)
{
	struct fd f = fdget_pos(fd);
	ssize_t ret = -EBADF;

	if (f.file) {
		loff_t pos = file_pos_read(f.file);
		ret = vfs_write(f.file, buf, count, &pos);
		if (ret >= 0)
			file_pos_write(f.file, pos);
		fdput_pos(f);
	}

	return ret;
}

入参很简单，一个fd，一个存放数据的buf，一个想要存放数据的长度值len。

fdget_pos 函数返回值是一个struct fd，不要被表面疑惑，他和fd没有任何关系。

这个函数通过fd，然后返回一个file结构，以及一些flag。通过第一节我们知道，一个fd如何和一个file关联的，我们也能想到，取得方法也很简单，current->files->fdt[fd]，这样我们就能取到fd对应的file了。找到file后，执行了vfs_write，这里不像多谈虚拟文件系统，说白了就是一个中间层。

ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
	ssize_t ret;

	if (!(file->f_mode & FMODE_WRITE))
		return -EBADF;
	if (!(file->f_mode & FMODE_CAN_WRITE))
		return -EINVAL;
	if (unlikely(!access_ok(VERIFY_READ, buf, count)))
		return -EFAULT;

	ret = rw_verify_area(WRITE, file, pos, count);
	if (ret >= 0) {
		count = ret;
		file_start_write(file);
		ret = __vfs_write(file, buf, count, pos);
		if (ret > 0) {
			fsnotify_modify(file);
			add_wchar(current, ret);
		}
		inc_syscw(current);
		file_end_write(file);
	}

	return ret;
}

首先判断，这个fd对于的file是否可写，这与第一节中：

files[1] = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);

这句话相辅相成，所以pipe创建的两个fd一个只能读，一个只能写，就是这个道理。

接着调用__vfs_write，也即调用 file->f_op->write，这个f_op，就是第一节中，alloc_file函数设置的pipefifo_fops。f_op->write 也就是 pipe_write 函数。

pipe_write函数比较长，就不一一列举了，我们需要知道的是，write之后的数据，被放进了哪里：

struct pipe_inode_info *pipe = filp->private_data;//取出pipe，这个第一节中说过。

pipe中有一个字段，用来管理写入的数据：

/**

*struct pipe_inode_info - a linux kernel pipe

*@mutex: mutex protecting the whole thing

*@wait: reader/writer wait point in case of empty/full pipe

*@nrbufs: the number of non-empty pipe buffers in this pipe

*@buffers: total number of buffers (should be a power of 2)

*@curbuf: the current pipe buffer entry

*@tmp_page: cached released page

*@readers: number of current readers of this pipe

*@writers: number of current writers of this pipe

*@files: number of struct file referring this pipe (protected by ->i_lock)

*@waiting_writers: number of writers blocked waiting for room

*@r_counter: reader counter

*@w_counter: writer counter

*@fasync_readers: reader side fasync

*@fasync_writers: writer side fasync

*@bufs: the circular array of pipe buffers

*@user: the user who created this pipe

**/

struct pipe_inode_info {

struct mutex mutex;

wait_queue_head_t wait;

unsigned int nrbufs, curbuf, buffers;

unsigned int readers;

unsigned int writers;

unsigned int files;

unsigned int waiting_writers;

unsigned int r_counter;

unsigned int w_counter;

struct page *tmp_page;

struct fasync_struct *fasync_readers;

struct fasync_struct *fasync_writers;

struct pipe_buffer *bufs;//用来存放write的数据，他是一个链表。

struct user_struct *user;

};

pipe_write中，有个大循环，就是不断往buf中写数据的功能：

//大循环，以为每个循环最多处理一个page_size大小的数据
	for (;;) {
		int bufs;

		//没有读端了直接发送sigpipe信号给进程。
		if (!pipe->readers) {
			send_sig(SIGPIPE, current, 0);
			if (!ret)
				ret = -EPIPE;
			break;
		}
		bufs = pipe->nrbufs;
		//如果当前有可用的buf，则进入判断
		if (bufs < pipe->buffers) {
			int newbuf = (pipe->curbuf + bufs) & (pipe->buffers-1);
			struct pipe_buffer *buf = pipe->bufs + newbuf;
			struct page *page = pipe->tmp_page;
			int copied;

			//page为空，说明，之前拷贝的数据满了一个page_size，page不能接着用了。需要重新申请一个。
			if (!page) {
				page = alloc_page(GFP_HIGHUSER | __GFP_ACCOUNT);
				if (unlikely(!page)) {
					ret = ret ? : -ENOMEM;
					break;
				}
				pipe->tmp_page = page;
			}
			/* Always wake up, even if the copy fails. Otherwise
			 * we lock up (O_NONBLOCK-)readers that sleep due to
			 * syscall merging.
			 * FIXME! Is this really true?
			 */
			do_wakeup = 1;
			copied = copy_page_from_iter(page, 0, PAGE_SIZE, from);
			if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) {
				if (!ret)
					ret = -EFAULT;
				//page未写满，意味着送入的数据已经全部拷贝完成，就break退出。
				break;
			}
			ret += copied;

			/* Insert it into the buffer array */
			//到这里，全部记录在buf中。
			buf->page = page;
			buf->ops = &anon_pipe_buf_ops;
			buf->offset = 0;
			buf->len = copied;
			buf->flags = 0;
			if (is_packetized(filp)) {
				buf->ops = &packet_pipe_buf_ops;
				buf->flags = PIPE_BUF_FLAG_PACKET;
			}
			pipe->nrbufs = ++bufs;
			pipe->tmp_page = NULL;

			//没有要写的数据了，回去了。
			if (!iov_iter_count(from))
				break;
		}
		if (bufs < pipe->buffers)
			continue;
		//走到这，说明pipe 中可用的buf全部满了，如果设置了非阻塞，则回到用户态
		if (filp->f_flags & O_NONBLOCK) {
			if (!ret)
				ret = -EAGAIN;
			break;
		}
		if (signal_pending(current)) {
			if (!ret)
				ret = -ERESTARTSYS;
			break;
		}
		if (do_wakeup) {
			wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
			kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
			do_wakeup = 0;
		}
		pipe->waiting_writers++;
		pipe_wait(pipe);
		pipe->waiting_writers--;
	}

任何读写操作的逻辑近乎类似，无论socket的读写还是pipe的读写，上面的逻辑其实几句话就可以概括：

1：每次write调用，就在一个pipe->buffs队列中申请一个可用的buf，以及申请一个page。

2：拷贝数据至page，然后page放入buf中。

3：如果write的数据全部处理完毕，则return。

4：如果write的数据没有被处理完毕，判断当前buf是否够用，够用则执行1，不够用，判断当前fd是否是阻塞的，阻塞的就睡眠进程，非阻塞的，就范围EAGAIN。

所以，问题来了

问题1：一个pipe最大能写多大的数据？

答案是pipe->buffers*PAGE_SIZE超过该数之后，write将被阻塞。

pipe->buffers*PAGE_SIZE = 16 * 4k = 65536字节

不过pipe->buffers值往往不都是16个，详情请看get_pipe_inode中，对该队列申请大小的判断条件，这里不再展开。

对于网上说的PIPE_BUF限制，当前内核版本已经不存在了。

问题2：如果每次write 1字节，那么write16次，buf队列就不够用了

非也，pipe_write在你实际写操作前，有个merge的操作

/* We try to merge small writes */
	chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
	if (pipe->nrbufs && chars != 0) {
		int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
							(pipe->buffers - 1);
		struct pipe_buffer *buf = pipe->bufs + lastbuf;
		int offset = buf->offset + buf->len;

		if (buf->ops->can_merge && offset + chars <= PAGE_SIZE) {
			ret = pipe_buf_confirm(pipe, buf);
			if (ret)
				goto out;

			ret = copy_page_from_iter(buf->page, offset, chars, from);
			if (unlikely(ret < chars)) {
				ret = -EFAULT;
				goto out;
			}
			do_wakeup = 1;
			buf->len += ret;
			if (!iov_iter_count(from))
				goto out;
		}

pipe_readd这里就不进行分析了，就是循环buf队列，得到想要的数据，如果只获取了一个buf中的部分数据，则记录下offset即可，下次从offset处接着获取。

第三节  pipe的另一端关闭了，会发生什么

首先，pipe如何判断有没有对端？

struct pipe_inode_info 有2个字段readers以及writers，创建pipe时，即在get_pipe_inode中，各自赋值为1。

我们把文章中的程序改成这样

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
void main()
{
  int pipefd[2];
  int pid,ret;
  int i, line;
  char s[4*1024*16+1]={0};

  if (pipe(pipefd) < 0) {
    perror("pipe");
    exit(1);
  }

  pid = fork();

  if (pid > 0)//父进程
   {
      close(pipefd[0]);
      sleep(1);
      //printf("fater writing....\n");
      //memcpy(s,"helloworld\n",strlen("helloworld\n"));
      ret = write(pipefd[1], s, sizeof(s));
      printf("ret:%d\n",ret);
      perror("");
      close(pipefd[1]);
  }
  else//子进程
  {
	close(pipefd[0]);
	close(pipefd[1]);
	return;
	#if 0
	sleep(10);
        printf("child reading....\n");
        //read(pipefd[0],s,1000);
        printf("read result: %s\n",s);
        close(pipefd[0]);
	#endif
  }
}

父进程关闭自己的读端，然后让出cpu，子进程关闭自己的读写两端。父进程再往写端数据。

我的系统什么都没有打出，显然write后面没有运行。

我们捕获一下SIGPIPE信号

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>

void handler()
{
	printf("sigpipe\n");
	perror("");
}

void main()
{
  int pipefd[2];
  int pid,ret;
  int i, line;
  char s[4*1024*16+1]={0};
  struct sigaction sig;

  sig.sa_handler = handler;
  sig.sa_flags = 0;
  sigaction(SIGPIPE, &sig, NULL);

  if (pipe(pipefd) < 0) {
    perror("pipe");
    exit(1);
  }

  pid = fork();

  if (pid > 0)//父进程
   {
      close(pipefd[0]);
      sleep(1);
      //printf("fater writing....\n");
      //memcpy(s,"helloworld\n",strlen("helloworld\n"));
      ret = write(pipefd[1], s, sizeof(s));
      printf("ret:%d\n",ret);
      perror("");
      close(pipefd[1]);
  }
  else//子进程
  {
	close(pipefd[0]);
	close(pipefd[1]);
	return;
	#if 0
	sleep(10);
        printf("child reading....\n");
        //read(pipefd[0],s,1000);
        printf("read result: %s\n",s);
        close(pipefd[0]);
	#endif
  }
}

果然，有结果了，提示 Broken pipe。

我回过头看看pipe_write发现有这么一段代码：

	if (!pipe->readers) {
		send_sig(SIGPIPE, current, 0);
		ret = -EPIPE;
		goto out;
	}

但是在pipe_read中，当发现write端不存在时，只是返回0，不会产生SIGPIPE。

看这个判断，核心就是pipe->readers字段，我们的示例程序父子进程全都执行了close(fd[0])，这样，pipe的read端就彻底关闭了。至于为什么，我会在后续的父子进程描述符继承中讲，这里就简单讲一下。

首先，fork前，fd[0] 对应的file，file中引用计数为1，fork后，子进程继承了父进程的描述符，copy_process函数中把file引用计数加1，这样，file的引用计数为2，所以父子进程需要各自执行close(fd[0])才能把读端file的引用计数减成0，file才能彻底释放对应的pipe->reader才能为0。