pipe.c

TIP

包含 xv6 系统所需的核心头文件

#include "types.h"
#include "riscv.h"
#include "defs.h"
#include "param.h"
#include "spinlock.h"
#include "proc.h"
#include "fs.h"
#include "sleeplock.h"
#include "file.h"

TIP

定义管道缓冲区的大小。这是一个循环缓冲区。

#define PIPESIZE 512

TIP

管道结构体

struct pipe {
  struct spinlock lock;
  char data[PIPESIZE];
  uint nread;
  uint nwrite;
  int readopen;
  int writeopen;
};

TIP

分配一个管道，并返回两个文件描述符（一个用于读取，一个用于写入）。 f0: 用于读取的文件描述符 f1: 用于写入的文件描述符

int
pipealloc(struct file **f0, struct file **f1)
{
  struct pipe *pi;

  pi = 0;
  *f0 = *f1 = 0;

TIP

为管道的读端和写端分别分配一个文件结构体

  if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0)
    goto bad;

TIP

为管道本身分配内存

  if((pi = (struct pipe*)kalloc()) == 0)
    goto bad;
  

TIP

初始化管道状态

  pi->readopen = 1;
  pi->writeopen = 1;
  pi->nwrite = 0;
  pi->nread = 0;
  initlock(&pi->lock, "pipe");

TIP

配置读文件描述符

  (*f0)->type = FD_PIPE;
  (*f0)->readable = 1;
  (*f0)->writable = 0;
  (*f0)->pipe = pi;

TIP

配置写文件描述符

  (*f1)->type = FD_PIPE;
  (*f1)->readable = 0;
  (*f1)->writable = 1;
  (*f1)->pipe = pi;

  return 0;

bad:
  if(pi)
    kfree((char*)pi);
  if(*f0)
    fileclose(*f0);
  if(*f1)
    fileclose(*f1);
  return -1;
}

TIP

关闭管道的一端（读或写）。 pi: 指向管道的指针 writable: 指示被关闭的是否是写端

void
pipeclose(struct pipe *pi, int writable)
{
  acquire(&pi->lock);

  if(writable){
    pi->writeopen = 0;
    wakeup(&pi->nread);
  } else {
    pi->readopen = 0;
    wakeup(&pi->nwrite);
  }

TIP

如果读端和写端都已关闭，则释放管道资源

  if(pi->readopen == 0 && pi->writeopen == 0){
    release(&pi->lock);
    kfree((char*)pi);
  } else {
    release(&pi->lock);
  }
}

TIP

从用户空间地址 addr 处向管道写入 n 个字节。 pi: 指向管道的指针 addr: 用户空间源数据地址 n: 要写入的字节数

int
pipewrite(struct pipe *pi, uint64 addr, int n)
{
  int i = 0;
  struct proc *pr = myproc();

  acquire(&pi->lock);

  while(i < n){

TIP

如果读端已关闭或当前进程已被杀死，则无法写入

    if(pi->readopen == 0 || killed(pr)){
      release(&pi->lock);
      return -1;
    }
    

TIP

检查管道是否已满。nwrite 和 nread 的差值表示缓冲区中的数据量。

    if(pi->nwrite == pi->nread + PIPESIZE){

TIP

管道已满，唤醒可能在等待数据的读进程

      wakeup(&pi->nread);

TIP

让当前写进程休眠，等待读进程读取数据后唤醒

      sleep(&pi->nwrite, &pi->lock);
    } else {
      char ch;

TIP

从用户空间拷贝一个字节到内核

      if(copyin(pr->pagetable, &ch, addr + i, 1) == -1)
        break;

TIP

将字节写入管道的循环缓冲区

      pi->data[pi->nwrite % PIPESIZE] = ch;
      pi->nwrite++;
      i++;
    }
  }

  wakeup(&pi->nread);
  release(&pi->lock);

  return i;
}

TIP

从管道读取最多 n 个字节到用户空间地址 addr。 pi: 指向管道的指针 addr: 用户空间目标地址 n: 要读取的字节数

int
piperead(struct pipe *pi, uint64 addr, int n)
{
  int i;
  struct proc *pr = myproc();
  char ch;

  acquire(&pi->lock);

TIP

当管道为空（nread == nwrite）并且写端仍然打开时，等待数据。 如果写端关闭，则管道为空时读取将直接返回 0。

  while(pi->nread == pi->nwrite && pi->writeopen){

TIP

如果当前进程被杀死，则无法读取

    if(killed(pr)){
      release(&pi->lock);
      return -1;
    }

TIP

让当前读进程休眠，等待写进程写入数据后唤醒

    sleep(&pi->nread, &pi->lock);
  }

TIP

循环读取数据，最多读取 n 个字节

  for(i = 0; i < n; i++){

TIP

如果管道为空，则停止读取

    if(pi->nread == pi->nwrite)
      break;
    

TIP

从管道的循环缓冲区中读取一个字节

    ch = pi->data[pi->nread % PIPESIZE];
    pi->nread++;

TIP

将读取的字节拷贝到用户空间

    if(copyout(pr->pagetable, addr + i, &ch, 1) == -1)
      break;
  }

  wakeup(&pi->nwrite);
  release(&pi->lock);

  return i;
}