在xv6中创建线程时注册指针

Question

I want to create a thread in xv6 by using a system call "clone()", but I am confused about the stack creation, since if I want to create a thread, I need to create the corresponding register pointer such like ebp, esp, eip. But I don't know how to set the value of these register pointer.

Here is a code of clone() in xv6, I don't know why we need to set the value of the register pointer like this.......

int clone(void(*fcn)(void*), void *arg, void*stack){

  int i, pid;
  struct proc *np;
  int *ustack = stack + PGSIZE - sizeof(void*);
  //allocate process.
  if((np=allocproc()) == 0)
    return -1;

  //copy process state from p
  np->pgdir = proc->pgdir;
  np->sz = proc->sz;
  np->parent = 0;
  np->pthread = proc;
  *np->tf = *proc->tf;
  np->ustack = stack;

  //initialize stack variables 
  //void *stackArg, *stackRet;
  //stackRet = stack + PGSIZE -2*sizeof(void*);
  //*(uint *)stackRet = 0xffffffff;

  //stackArg = stack + PGSIZE -sizeof(void*);
  //*(uint *)stackArg = (uint)arg;
  *ustack = (int) arg;
  *(ustack - 1) = 0xffffffff;
  *(ustack - 2) = 0xffffffff;


  //Set stack pinter register
  np->tf->eax = 0;
  np->tf->esp = (int) ustack - sizeof(void*);
  np->tf->ebp = np->tf->esp;
  np->tf->eip = (int)fcn;

  for(i = 0; i < NOFILE; i++) {
    if(proc->ofile[i])
      np->ofile[i] = filedup(proc->ofile[i]);
  }

  np->cwd = idup(proc->cwd);
  np->state = RUNNABLE;
  safestrcpy(np->name, proc->name, sizeof(proc->name));
  pid = np->pid;
  return pid;

}

Answer 1

You don't set these registers -- clone sets them for you. You need to provide a function (which clone uses to initialize ip) and a stack (which clone uses to initialize sp).

The function pointer is pretty straight-forward (its just a C function pointer), but the stack is trickier. For the clone implementation you show, you need to allocate some memory and provide a pointer PGSIZE below the end of that block. Linux's clone call is similar, but slightly different (you need to provide a pointer to the end of the block). If you want to catch stack overflows, you'll need to do more work (probably allocating a read/write protected guard page below the stack).

Answer 2

Of all the register values you set, the only useful ones are:

eip - Tells the thread where to start executing from when it returns to userspace

esp - This is points to the top of the stack. This means that if you did this right, 4 bytes stored at the top of the stack should contain your return address

---

eax is not really useful here seeing as the thread jumps to a new context and not the one where it was created. Otherwise, eax will store the return value of the last system call. See the implementation of fork if you are still confused about this one.

ebp is not manipulated by you, but rather by the x86 function call conventions and is usually set to the value of esp when the function is called. As such you will usually see this sort of thing in the disassembly of most function calls

push ebp      ; Preserve current frame pointer
mov ebp, esp  ; Create new frame pointer pointing to current stack top

ebp is also useful for stack tracing because it stores the top of the previous function's stack before it is then changed to point to the current stack top

---

You don't need this *(ustack - 2) = 0xffffffff;