MIT6.S081学习笔记 Chapter 1

Chapter 1 Operating system interfaces

一方面，我们希望界面简单，另一方面，我们可能为应用程序提供许多复杂的功能解决这种矛盾的诀窍是设计依赖于少数几种机制的界面，这些机制可以组合在一起，提供更多的通用性。

但程序需要内核操作时，调用system call (系统调用)，system call 进入内核，内核执行操作后返回

内核使用CPU提供的硬件保护机制，使得进程只能访问自己的内存

Processes and memory

一些相关系统调用的使用

fork()

fork创建子进程，父进程中fork返回子进程的pid，子进程中fork返回0

fork的使用模板：

int pid;
if(pid > 0){
	// 父进程
}
else if(pid == 0){
  // 子进程
}else{
  // error
}

exit(int)

exit(0)表示成功，exit(1)表示是失败。

*wait(int wstatus)

wait 返回当前进程的一个子进程的PID，将子进程的退出状态复制到wstatus指向的地址

使用方法：wait(&status)

• 当前进程没有子进程退出，等待其中一个退出
• 当前进程没有子进程，return -1

如果不关心子进程的退出状态，则使用 wait(0)

exec()

The exec system call replaces the calling process’s memory with a new memory image loaded
from a file stored in the file system

exec 将调用进程的内存替换为从文件系统中加载的新内存映像

该文件必须具有特定的格式，该格式指定文件的哪个部分包含指令，哪个部分是数据，从哪个指令开始等。Xv6 使用 ELF 格式。exec执行成功不会返回调用程序，而是从ELF头文件中声明的入口点开始执行

exec 有两个参数：包含可执行文件的文件名和字符串参数数组

// 当前进程执行 echo hello 
char *argv[3];
 argv[0] = "echo";
 argv[1] = "hello";
 argv[2] = 0;
 exec("/bin/echo", argv);
 printf("exec error\n");

shell执行命令的过程：main循环通过withgetcmd读取命令，调用fork创建子进程，父进程调用wait，子进程调用exec执行命令

sbrk()

内存不足的进程可以调用sbrk(n)来分配n个字节的新内存

I/O

💡 A file descriptor is a small integer representing a kernel-managed object that a process may read from or write to. （fd 是一个整数，代表一个进程读写的内核管理对象）

一个进程可以通过打开文件、文件夹、设备、创建管道等方式获取fd

fd接口将抽象化文件、管道、设备，让它们看起来都是字符流

xv6中fd作为每个进程中 ofile[] 的索引，每个进程都有自己的 ofile[] ，索引从0开始

struct proc{
	...
	struct file *ofile[NOFILE];  // Open files
	...
}

一般的，进程从 0(标准输入) 读取，向 1(标准输出) 写入，向 2(标准错误) 写入错误信息

read()

read(fd, buf, n) 从fd读取最多n个字节到buf，返回读取的字节数

每一个文件fd都有一个关联的偏移量，read从偏移量位置读取数据并更新偏移量

当没有更多字节要读取时，read 返回零以指示文件的结束

write()

write(fd, buf, n) 向将buf中最多n个字节写入fd中，返回写入的字节数

close()

close(fd) 释放一个fd，以便之后重新使用

dup()

dup 系统调用复制一个现有的fd

可以指定新分配的fd，也可以不指定，系统将自动分配当前最小未使用的fd

dup 允许 shell 实现如下命令：ls existing-file non-existing-file > tmp1 2>&1。

2>&1 告诉 shell 为命令提供一个文件描述符 2，该描述符 2 是描述符 1 的副本。

现有文件的名称和不存在文件的错误消息都将显示在文件 tmp1 中。

I/O redirection（IO重定位）

fork的子进程拥有与父进程相同的文件描述表ofile[]

exec系统调用替换内存镜像，但文件表依然会被保留

这使得shell可以通过fork，在子进程中修改fd，然后再调用exec运行新的程序来实现I/O重定向

以下是cat < input.txt 的过程代码，cat 负责从标准输入(fd=0)中读取，输出至标准输出(fd=1)，现在要求从文件中读取

 char *argv[2];
 argv[0] = "cat";
 argv[1] = 0;
 if(fork() == 0) { 
 close(0); // 关闭标准输入fd
 open("input.txt", O_RDONLY); // 打开文件，此时该文件被分配的fd为0
 exec("cat", argv); // 执行cat，cat从fd(0)中读取，而fd(0)对应文件
 }

文件偏移量

struct file {
  enum { FD_NONE, FD_PIPE, FD_INODE, FD_DEVICE } type;
  int ref;
  char readable;
  char writable;
  struct pipe *pipe; 
  struct inode *ip;  
  uint off;					// 文件偏移量
  short major;
};

文件偏移量由文件对象维护，多个文件描述符可以通过共享文件对象来共享文件偏移量

fork 复制了文件描述符表 ofile[] ，父进程子进程指向同一个文件对象，因此共享每个文件的偏移量。这保证了shell的顺序输出，如(echo hello; echo world) >output.txt

如果两个文件描述符是通过一系列 fork 和 dup 调用从同一原始文件描述符派生的，则它们共享一个偏移量。否则，文件描述符不会共享偏移量，即使它们是由对同一文件的打开调用产生的

当关闭文件对象文件偏移量也会消失，再次打开文件会产生新的偏移量，想要追加内容可以
以 O_APPEND 模式打开文件，系统会将文件偏移量自动设置为文件末尾（EOF）

pipe

💡 A pipe is a small kernel buffer exposed to processes as a pair of file descriptors, one for reading and one for writing.

管道是一个小的内存缓冲区，作为一对fd用于读写。

管道为进程提供了一种通信方式

标准输入连接到管道的读取端代码示例

int p[2]； //数组 p 中记录读写文件描述符
char* argv[2]；
argv[0] = "wc";
argv[1] = 0；
pipe(p);
if(fork() == 0)
{
	// 使文件描述符 0 指向管道的读取端p[0]
	close(0); // 关闭子进程的标准输入fd:0
	dup(p[0]); //复制管道的读取端p[0]到fd 0
	// 关闭 p 中的文件描述符，并调用exec 运行 wc
	close(p[0])；
	close(p[1]);
	exec("/bin/wc", argv);
} 
else {
	close(p[0]);
	write(p[1], "hello world\n", 12);
	close(p[1])；
}

子进程运行的wc默认从fd 0读入，在这之前将p[0]赋值给fd 0，使wc从管道的输入读取数据

为什么不能直接修改argv[1]为p[0]这样wc就可以直接从管道读取数据？

原因是exec只接受字符串参数

File system

不以 / 开头的路径是相对路径

同一底层文件(inode)可以拥有多个名称，称为链接(links)，每个链接包含一个文件名和一个inode引用。

fstat系统调用从文件描述符指向的 inode 中获取信息

取消链接系统调用会从文件系统中删除一个文件名。只有当文件的链接数为零且没有文件描述符指向该文件时，才会释放该文件的 inode 和存放其内容的磁盘空间。

源码阅读

提示：源代码涉及到后面要学习的知识

exit

void
exit(int status)
{
  struct proc *p = myproc();

  if(p == initproc)
    panic("init exiting");

  // Close all open files.
  for(int fd = 0; fd < NOFILE; fd++){
    if(p->ofile[fd]){
      struct file *f = p->ofile[fd];
      fileclose(f);
      p->ofile[fd] = 0;
    }
  }

  begin_op();
  iput(p->cwd);
  end_op();
  p->cwd = 0;

  acquire(&wait_lock);

  // Give any children to init.
  reparent(p);

  // Parent might be sleeping in wait().
  // 唤醒可能正在睡眠等待的父进程
  wakeup(p->parent);
  
  // 如果父进程不处于wait中则将自己设为僵尸状态等待父进程发现
  acquire(&p->lock);
  p->xstate = status;
  p->state = ZOMBIE;
  release(&wait_lock);

  // Jump into the scheduler, never to return.
  sched();
  panic("zombie exit");
}

wait

// Wait for a child process to exit and return its pid.
// Return -1 if this process has no children.
int
wait(uint64 addr)
{
  struct proc *np;
  int havekids, pid;
  struct proc *p = myproc();

  acquire(&wait_lock);

  for(;;){
    // Scan through table looking for exited children.
    havekids = 0;
    for(np = proc; np < &proc[NPROC]; np++){ // 遍历进程表
      if(np->parent == p){ // 检测是否为p的子进程
        // make sure the child isn't still in exit() or swtch().
        acquire(&np->lock);

        havekids = 1;
        if(np->state == ZOMBIE){ // 检测子进程是否为僵尸状态
          // Found one.
          pid = np->pid;
          // 复制出子进程的退出状态到参数addr地址
          if(addr != 0 && copyout(p->pagetable, addr, (char *)&np->xstate,
                                  sizeof(np->xstate)) < 0) {
            release(&np->lock);
            release(&wait_lock);
            return -1;
          }
          freeproc(np); // 释放子进程
          release(&np->lock);
          release(&wait_lock); // 释放子进程申请的wait_lock
          return pid;
        }
        release(&np->lock);
      }
    }

    // No point waiting if we don't have any children.
    // 没有子进程
    if(!havekids || p->killed){
      release(&wait_lock);
      return -1;
    }
    
    // 有子进程，但没有子进程处于僵尸状态，调用sleep睡眠
    // Wait for a child to exit.
    sleep(p, &wait_lock);  //DOC: wait-sleep
  }
}

fork

int
fork(void)
{
  int i, pid;
  struct proc *np;
  struct proc *p = myproc();

  // Allocate process. 返回上锁的np
  if((np = allocproc()) == 0){
    return -1;
  }

  // Copy user memory from parent to child.
  if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
    freeproc(np);
    release(&np->lock);
    return -1;
  }
  np->sz = p->sz;

  // copy saved user registers.
  *(np->trapframe) = *(p->trapframe);

  // Cause fork to return 0 in the child.
  np->trapframe->a0 = 0; // a0是返回值

  // increment reference counts on open file descriptors.
  for(i = 0; i < NOFILE; i++)
    if(p->ofile[i])
      np->ofile[i] = filedup(p->ofile[i]);
  np->cwd = idup(p->cwd);

  safestrcpy(np->name, p->name, sizeof(p->name));

  pid = np->pid;

  release(&np->lock); // 避免死锁

  acquire(&wait_lock);
  np->parent = p;
  release(&wait_lock);

  acquire(&np->lock);
  np->state = RUNNABLE;
  release(&np->lock);
	
	// copy mask from parent to child
	np->mask = p->mask;

  return pid; // 返沪子进程pid
}

exec

数据结构

struct elfhdr {
  uint magic;  // must equal ELF_MAGIC
  uchar elf[12];
  ushort type;
  ushort machine;
  uint version;
  uint64 entry;
  uint64 phoff; // 程序头偏移量
  uint64 shoff;
  uint flags;
  ushort ehsize;
  ushort phentsize;
  ushort phnum; // 程序头数量
  ushort shentsize;
  ushort shnum;
  ushort shstrndx;
};

// Program section header
struct proghdr {
  uint32 type;
  uint32 flags;
  uint64 off; // 该段在elf文件中的偏移量
  uint64 vaddr; // 段虚拟地址
  uint64 paddr; // 段物理地址
  uint64 filesz; // 段在elf文件中的大小
  uint64 memsz; // 段在内存中的大小
  uint64 align;
};

段在内存中的大小可能比段在文件中的大小更大，如.bss段存放了未初始化的变量，文件中不存储实际数据，而内存中需初始化为0

sys_exec

uint64
sys_exec(void)
{
  char path[MAXPATH], *argv[MAXARG]; // argv为字符串指针
  int i;
  uint64 uargv, uarg;

  if(argstr(0, path, MAXPATH) < 0 || argaddr(1, &uargv) < 0){
    return -1;
  }
  memset(argv, 0, sizeof(argv));
  for(i=0;; i++){
    if(i >= NELEM(argv)){
      goto bad;
    }
    //获取uargv中的地址保存到局部变量uarg中
    if(fetchaddr(uargv+sizeof(uint64)*i, (uint64*)&uarg) < 0){ 
      goto bad;
    } 
    if(uarg == 0){ //检查是否读取完成
      argv[i] = 0;
      break;
    }
    //为每个argv字符串分配一页并将其从用户空间复制到该页中
    argv[i] = kalloc();
    if(argv[i] == 0)
      goto bad;
    if(fetchstr(uarg, argv[i], PGSIZE) < 0)
      goto bad;
  }

  int ret = exec(path, argv); // 调用exec，返回值为argc

  for(i = 0; i < NELEM(argv) && argv[i] != 0; i++)
    kfree(argv[i]);

  return ret; // 返回，argc将保存在a0中，pc将加载修改后的epc

 bad:
  for(i = 0; i < NELEM(argv) && argv[i] != 0; i++)
    kfree(argv[i]);
  return -1;
}

exec

int
exec(char *path, char **argv)
{
  char *s, *last;
  int i, off;
  uint64 argc, sz = 0, sp, ustack[MAXARG], stackbase;
  struct elfhdr elf;
  struct inode *ip;
  struct proghdr ph;
  pagetable_t pagetable = 0, oldpagetable;
  struct proc *p = myproc();

  begin_op();
	// 获取锁定ip
  if((ip = namei(path)) == 0){
    end_op();
    return -1;
  }
  ilock(ip);

  // 读取elf文件头
  if(readi(ip, 0, (uint64)&elf, 0, sizeof(elf)) != sizeof(elf))
    goto bad;
  if(elf.magic != ELF_MAGIC) // 检查 magic number
    goto bad;

  if((pagetable = proc_pagetable(p)) == 0) // 创建新的页表
    goto bad;

  // Load program into memory.
  // 遍历读取所有程序头
  for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
    if(readi(ip, 0, (uint64)&ph, off, sizeof(ph)) != sizeof(ph))
      goto bad;
    if(ph.type != ELF_PROG_LOAD) // 检查类型
      continue;
    if(ph.memsz < ph.filesz) // 检查大小
      goto bad;
    if(ph.vaddr + ph.memsz < ph.vaddr) // 检查溢出
      goto bad;
    uint64 sz1;
    // 为每个段分配页表
    if((sz1 = uvmalloc(pagetable, sz, ph.vaddr + ph.memsz)) == 0) 
      goto bad;
    sz = sz1;
    if((ph.vaddr % PGSIZE) != 0)
      goto bad;
    // 读取段到内存
    if(loadseg(pagetable, ph.vaddr, ip, ph.off, ph.filesz) < 0)
      goto bad;
  }
  iunlockput(ip);
  end_op();
  ip = 0;

  p = myproc();
  uint64 oldsz = p->sz;

  // Allocate two pages at the next page boundary.
  // Use the second as the user stack.
  sz = PGROUNDUP(sz);
  uint64 sz1;
  if((sz1 = uvmalloc(pagetable, sz, sz + 2*PGSIZE)) == 0)
    goto bad;
  sz = sz1;
  uvmclear(pagetable, sz-2*PGSIZE);
  // 设置栈指针
  sp = sz;
  stackbase = sp - PGSIZE;
  // new_page1
  // new_page2 <-- sp
  // sz

  // Push argument strings, prepare rest of stack in ustack.
  // 将命令行参数 argv 字符串拷贝到用户栈上
  for(argc = 0; argv[argc]; argc++) {
    if(argc >= MAXARG)
      goto bad;
    sp -= strlen(argv[argc]) + 1;
    sp -= sp % 16; // riscv sp must be 16-byte aligned
    if(sp < stackbase)
      goto bad;
    if(copyout(pagetable, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
      goto bad;
    ustack[argc] = sp; // 记录字符串位置
  }
  ustack[argc] = 0;

  // push the array of argv[] pointers.
  // 将记录 argv 字符串的数组拷贝到栈上
  sp -= (argc+1) * sizeof(uint64);
  sp -= sp % 16;
  if(sp < stackbase)
    goto bad;
  if(copyout(pagetable, sp, (char *)ustack, (argc+1)*sizeof(uint64)) < 0)
    goto bad;

  // arguments to user main(argc, argv)
  // 要求 argc 保存在 a0 中，argv 保存在 a1 中
  // exec 系统调用返回时，返回值自然会传递到 a0 中，这里只需设置 a1
  p->trapframe->a1 = sp;

  // Save program name for debugging.
  for(last=s=path; *s; s++) // 使s指向最后一个'/'
    if(*s == '/')
      last = s+1;
  safestrcpy(p->name, last, sizeof(p->name));
    
  // Commit to the user image.
  oldpagetable = p->pagetable;
  p->pagetable = pagetable;
  p->sz = sz;
  p->trapframe->epc = elf.entry;  // initial program counter = main
  p->trapframe->sp = sp; // initial stack pointer
  proc_freepagetable(oldpagetable, oldsz);

  return argc; // this ends up in a0, the first argument to main(argc, argv)

 bad:
  if(pagetable)
    proc_freepagetable(pagetable, sz);
  if(ip){
    iunlockput(ip);
    end_op();
  }
  return -1;
}

loadseg

// Load a program segment into pagetable at virtual address va.
// va must be page-aligned
// and the pages from va to va+sz must already be mapped.
// Returns 0 on success, -1 on failure.
static int
loadseg(pagetable_t pagetable, uint64 va, struct inode *ip, uint offset, uint sz)
{
  uint i, n;
  uint64 pa;

  for(i = 0; i < sz; i += PGSIZE){
    pa = walkaddr(pagetable, va + i);
    if(pa == 0)
      panic("loadseg: address should exist");
    if(sz - i < PGSIZE)
      n = sz - i;
    else
      n = PGSIZE;
    if(readi(ip, 0, (uint64)pa, offset+i, n) != n)
      return -1;
  }
  
  return 0;
}

pipe

数据结构

struct pipe {
  struct spinlock lock;
  char data[PIPESIZE];
  uint nread;     // number of bytes read
  uint nwrite;    // number of bytes written
  int readopen;   // read fd is still open
  int writeopen;  // write fd is still open
};

struct file {
  enum { FD_NONE, FD_PIPE, FD_INODE, FD_DEVICE } type;
  int ref; // reference count
  char readable;
  char writable;
  struct pipe *pipe; // FD_PIPE
  struct inode *ip;  // FD_INODE and FD_DEVICE
  uint off;          // FD_INODE
  short major;       // FD_DEVICE
};

sys_pipe

uint64
sys_pipe(void)
{
  uint64 fdarray; // user pointer to array of two integers
  struct file *rf, *wf;
  int fd0, fd1;
  struct proc *p = myproc();

  if(argaddr(0, &fdarray) < 0)
    return -1;
  
  // 调用pipealloc，申请pipe空间和读写文件空间
  if(pipealloc(&rf, &wf) < 0)
    return -1;
  
  fd0 = -1;
  // 申请fd
  if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
    if(fd0 >= 0)
      p->ofile[fd0] = 0;
    fileclose(rf);
    fileclose(wf);
    return -1;
  }
  
  // 将用户传入的fd赋值给新分配的fd0和fd1
  if(copyout(p->pagetable, fdarray, (char*)&fd0, sizeof(fd0)) < 0 ||
     copyout(p->pagetable, fdarray+sizeof(fd0), (char *)&fd1, sizeof(fd1)) < 0){
    p->ofile[fd0] = 0;
    p->ofile[fd1] = 0;
    fileclose(rf);
    fileclose(wf);
    return -1;
  }
  return 0;
}

pipealloc

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

  pi = 0;
  *f0 = *f1 = 0;
  if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0) // f
    goto bad;
  
  // 分配一页给struct pipe
  // 这一页是有余量的，因为sizeof(struct pipe) < PGSIZE
  if((pi = (struct pipe*)kalloc()) == 0) 
    goto bad;
  
  // 初始化struct pipe的字段
  pi->readopen = 1;
  pi->writeopen = 1;
  pi->nwrite = 0;
  pi->nread = 0;
  initlock(&pi->lock, "pipe");
  
  // 设置文件字段
  (*f0)->type = FD_PIPE;
  (*f0)->readable = 1;
  (*f0)->writable = 0;
  (*f0)->pipe = pi;
  (*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;
}

piperead

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

  acquire(&pi->lock);
  // 检测当前缓冲区是否为空，空则睡眠
  while(pi->nread == pi->nwrite && pi->writeopen){  //DOC: pipe-empty
    if(pr->killed){
      release(&pi->lock);
      return -1;
    }
    sleep(&pi->nread, &pi->lock); //DOC: piperead-sleep
  }
  
  // 每次读取一个字节
  for(i = 0; i < n; i++){  //DOC: piperead-copy
    if(pi->nread == pi->nwrite)
      break;
    ch = pi->data[pi->nread++ % PIPESIZE];
    if(copyout(pr->pagetable, addr + i, &ch, 1) == -1)
      break;
  }
  wakeup(&pi->nwrite);  //DOC: piperead-wakeup
  release(&pi->lock);
  return i; // 返回读取字节数
}

pipewrite

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

  acquire(&pi->lock);
  while(i < n){
    if(pi->readopen == 0 || pr->killed){
      release(&pi->lock);
      return -1;
    }
    if(pi->nwrite == pi->nread + PIPESIZE){ //DOC: pipewrite-full
      wakeup(&pi->nread);
      sleep(&pi->nwrite, &pi->lock);
    } else {
      char ch;
      if(copyin(pr->pagetable, &ch, addr + i, 1) == -1)
        break;
      pi->data[pi->nwrite++ % PIPESIZE] = ch;
      i++;
    }
  }
  wakeup(&pi->nread);
  release(&pi->lock);

  return i;
}