fork函数详解

fork函数详解(附代码)

虽然篇幅很长，但大多是易懂的代码，不用担心看不完

这里的所有 *** 作，都将在下面的代码中有所体现

fork会拷贝当前进程的内存，并创建一个新的进程。

如上图，fork函数会将整个进程的内存镜像拷贝到新的内存地址，包括代码段、数据段、堆栈以及寄存器内容。

之后，我们就有了两个拥有完全一样内存的进程。

fork系统调用在两个进程中都会返回，在父进程中，fork系统调用会返回子进程的pid。

而在新创建的进程中，fork系统调用会返回0。

所以即使两个进程的内存是完全一样的，我们还是可以通过fork的返回值区分旧进程和新进程。

某种程度上来说这里的拷贝 *** 作浪费了，因为所有拷贝的内存都被丢弃并被exec替换。

在大型程序中这里的影响会比较明显。

实际上 *** 作系统会对其进行优化。

(比如使用COW(copy on write)技术)

fork创建的新进程从fork语句后开始执行，因为新进程也继承了父进程的PC程序计数器。

在xv6中唯一不是通过fork创建进程的场景就是创建第一个进程的时候，之后的所有进程都是通过fork创建的。

以下内容以xv6(教学用Linux *** 作系统)源代码为例

代码解析

// Create a new process, copying the parent.

// Sets up child kernel stack to return as if from fork() system call.

int

fork(void)

{

  int i, pid;

  struct proc *np;

  //获取当前进程(进程只运行在用户态)

  //fork函数是系统调用，实际上运行在内核态，用户态的寄存器内容、内存状态都会被保留下来，所以不用担心fork函数的运行影响原进程

  struct proc *p = myproc();

  // Allocate process.

  //allocproc实际上从 *** 作系统进程队列中找到一个未在使用状态的空进程，

  //为其分配trapframe(用来存储寄存器内容)，page table页表，并设置了一些寄存器状态。

代码见附

  if((np = allocproc()) == 0){

    return -1;

  }

  // Copy user memory from parent to child.

  //将父进程的页表内容拷贝到子进程页表中

  //uvmcopy user virtual memory copy

  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.

  //a0为返回值寄存器，fork函数结束会将a0的值返回，因此子进程fork的返回值为0

  np->trapframe->a0 = 0;

  // 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));

  //在这里实现了父进程fork返回子进程pid

  pid = np->pid;

	//下面设置子进程的父进程，将子进程的状态设置为可运行

  //之后， *** 作系统会在进程调度时，执行子进程

  release(&np->lock);

  acquire(&wait_lock);

  np->parent = p;

  release(&wait_lock);

  acquire(&np->lock);

  np->state = RUNNABLE;

  release(&np->lock);

  return pid;

}

附：

alloproc代码

static struct proc*

allocproc(void)

{

  struct proc *p;

  for(p = proc; p < &proc[NPROC]; p++) {

    acquire(&p->lock);

    if(p->state == UNUSED) {

      goto found;

    } else {

      release(&p->lock);

    }

  }

  return 0;

found:

  p->pid = allocpid();

  p->state = USED;

  // Allocate a trapframe page.

  if((p->trapframe = (struct trapframe *)kalloc()) == 0){

    freeproc(p);

    release(&p->lock);

    return 0;

  }

  // An empty user page table.

  p->pagetable = proc_pagetable(p);

  if(p->pagetable == 0){

    freeproc(p);

    release(&p->lock);

    return 0;

  }

  // Set up new context to start executing at forkret,

  // which returns to user space.

  memset(&p->context, 0, sizeof(p->context));

  p->context.ra = (uint64)forkret;

  p->context.sp = p->kstack + PGSIZE;

  return p;

}

Trapframe代码：

struct trapframe {

  /*   0 */ uint64 kernel_satp;   // kernel page table

  /*   8 */ uint64 kernel_sp;     // top of process's kernel stack

  /*  16 */ uint64 kernel_trap;   // usertrap()

  /*  24 */ uint64 epc;           // saved user program counter

  /*  32 */ uint64 kernel_hartid; // saved kernel tp

  /*  40 */ uint64 ra;

  /*  48 */ uint64 sp;

  /*  56 */ uint64 gp;

  /*  64 */ uint64 tp;

  /*  72 */ uint64 t0;

  /*  80 */ uint64 t1;

  /*  88 */ uint64 t2;

  /*  96 */ uint64 s0;

  /* 104 */ uint64 s1;

  /* 112 */ uint64 a0;

  /* 120 */ uint64 a1;

  /* 128 */ uint64 a2;

  /* 136 */ uint64 a3;

  /* 144 */ uint64 a4;

  /* 152 */ uint64 a5;

  /* 160 */ uint64 a6;

  /* 168 */ uint64 a7;

  /* 176 */ uint64 s2;

  /* 184 */ uint64 s3;

  /* 192 */ uint64 s4;

  /* 200 */ uint64 s5;

  /* 208 */ uint64 s6;

  /* 216 */ uint64 s7;

  /* 224 */ uint64 s8;

  /* 232 */ uint64 s9;

  /* 240 */ uint64 s10;

  /* 248 */ uint64 s11;

  /* 256 */ uint64 t3;

  /* 264 */ uint64 t4;

  /* 272 */ uint64 t5;

  /* 280 */ uint64 t6;

};