自学教程：C++ wakeup1函数代码示例

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){    struct proc *p;    int fd;    if(proc == initproc)        panic("init exiting");    // Close all open files.    for(fd = 0; fd < NOFILE; fd++) {        if(proc->ofile[fd]) {            fileclose(proc->ofile[fd]);            proc->ofile[fd] = 0;        }    }    begin_op();    iput(proc->cwd);    end_op();    proc->cwd = 0;    acquire(&ptable.lock);    // Parent might be sleeping in wait().    wakeup1(proc->parent);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) {        if(p->parent == proc && p->is_thread == 1) {            p->killed = 1;            if(p->state == SLEEPING) {                p->state = RUNNABLE;            }        }    }    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) {        if(p->parent == proc) {            if (p->state == ZOMBIE) {                p->killed = 1;            }            join(p->pid);        }    }    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) {        if(p->parent == proc) {            p->parent = initproc;            if(p->state == ZOMBIE)                wakeup1(initproc);        }    }    // Jump into the scheduler, never to return.    proc->state = ZOMBIE;    sched();    panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *p;  int fd;  if(proc == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  iput(proc->cwd);  proc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(proc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->pid == proc->pid && p->state != ZOMBIE){ //undead thread    p->state = ZOMBIE;        if(p->is_thread){//it is a thread	  if(p->parent->num_of_thread_child){	    p->parent->num_of_thread_child--;	  }	  //no more childran	  if(!p->parent->num_of_thread_child){	    wakeup1(p->parent->parent);	  }	}    else{//it is a proccees      p->num_of_thread_child--;      if(!p->num_of_thread_child){	 wakeup1(p->parent);       }     }    }    else if(p->parent == proc && p->is_thread !=1){// a proccess child      p->parent = initproc;      if(p->state == ZOMBIE){        wakeup1(initproc);      }    }  }    // Jump into the scheduler, never to return.  proc->state = ZOMBIE;  sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *p;  int fd;  if(proc == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  #ifndef SELECTION_NONE    #ifdef VERBOSE_PRINT_TRUE       char* state;      if(proc->state >= 0 && proc->state < NELEM(states) && states[proc->state])      state = states[proc->state];    else      state = "???";      print_proc_data(proc, state);      cprintf("/n");    #endif    free_proc_pgmd(proc,1); //remove swap file and pages metadata  #endif  begin_op();  iput(proc->cwd);  end_op();  proc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(proc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->parent == proc){      p->parent = initproc;      if(p->state == ZOMBIE)        wakeup1(initproc);    }  }  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;  sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){    struct proc *p;    int fd;    if(proc == initproc)        panic("init exiting");    // Close all open files.    for(fd = 0; fd < NOFILE; fd++){        if(proc->ofile[fd] && proc->thread == 0){              fileclose(proc->ofile[fd]);              proc->ofile[fd] = 0;        }    }    begin_op();    iput(proc->cwd);    end_op();    proc->cwd = 0;    acquire(&ptable.lock);    // Parent might be sleeping in wait().    wakeup1(proc->parent);    // Pass abandoned children to init.    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){        if(p->thread == 1 && p->parent == proc){            p->killed = 1;            if(p->state == SLEEPING)                        // Wake process from sleep if necessary                p->state = RUNNABLE;            release(&ptable.lock);            join(p->pid);            acquire(&ptable.lock);            p->parent = initproc;            if(p->state == ZOMBIE)                wakeup1(initproc);        }        else if(p->parent == proc){            p->parent = initproc;            if(p->state == ZOMBIE)                wakeup1(initproc);        }    }    // Jump into the scheduler, never to return.    proc->state = ZOMBIE;    sched();    panic("zombie exit");}

    voidtexit(void){    //  struct proc *p;    int fd;    if(proc == initproc)        panic("init exiting");    // Close all open files.    for(fd = 0; fd < NOFILE; fd++){        if(proc->ofile[fd]){            fileclose(proc->ofile[fd]);            proc->ofile[fd] = 0;        }    }    iput(proc->cwd);    proc->cwd = 0;    acquire(&ptable.lock);    // Parent might be sleeping in wait().    wakeup1(proc->parent);    // Pass abandoned children to init.    //  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    //    if(p->parent == proc){    //      p->parent = initproc;    //      if(p->state == ZOMBIE)    //        wakeup1(initproc);    //    }    //  }    // Jump into the scheduler, never to return.    proc->state = ZOMBIE;    sched();    panic("zombie exit");}

voidthread_exit(void* ret_val){    proc->ret_val=ret_val;    if(is_main_thread(proc)) {        // check if last running thread        if(proc->tcount <= 1) {            exit();        } else {            // Wait for children to exit            acquire(&ptable.lock);            sleep(proc, &ptable.lock);            release(&ptable.lock);            exit();        }    }    // Normal thread exit    acquire(&ptable.lock);    //iput(proc->cwd);    proc->parent->tcount--;    proc->cwd = 0;    // Parent might be sleeping in wait().    wakeup1(proc->parent);    // Jump into the scheduler, never to return.    proc->state = ZOMBIE;    sched();    panic("thread zombie exit");}

// Wake up all processes sleeping on chan.voidwakeup(void *chan){  acquire(&proc_table_lock);  wakeup1(chan);  release(&proc_table_lock);}

// Wake up all processes sleeping on chan.voidwakeup(void *chan){  acquire(&ptable.lock);  wakeup1(chan);  release(&ptable.lock);}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *p;  int fd;  if(proc == initproc)    panic("init exiting");//  cprintf("pid: %d is exiting/n",proc->pid);  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  // part 2  int j;  for(j=0 ; j < 200 ; j++)    unlockInodesTable[proc->pid][j] = 0;  iput(proc->cwd);  proc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(proc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->parent == proc){      p->parent = initproc;      if(p->state == ZOMBIE)        wakeup1(initproc);    }  }  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;  sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *p;  int fd;  if(proc == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  iput(proc->cwd);  proc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(proc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->parent == proc){      p->parent = initproc;      if(p->state == ZOMBIE)        wakeup1(initproc);    }  }  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;    //**** remove--this may be unneccessary  //cprintf("remove in exit/n");  removefromq(proc);  //****    sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *p;  int fd;  cprintf("Exiting process. System free pages is %d, replacement count is %d/n",kfreepagecount(),replacementcount());  if(proc == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  begin_op();  iput(proc->cwd);  end_op();  proc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(proc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->parent == proc){      p->parent = initproc;      if(p->state == ZOMBIE)        wakeup1(initproc);    }  }  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;  sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *curproc = myproc();  struct proc *p;  int fd;  if(curproc == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(curproc->ofile[fd]){      fileclose(curproc->ofile[fd]);      curproc->ofile[fd] = 0;    }  }  begin_op();  iput(curproc->cwd);  end_op();  curproc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(curproc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->parent == curproc){      p->parent = initproc;      if(p->state == ZOMBIE)        wakeup1(initproc);    }  }  // Jump into the scheduler, never to return.  curproc->state = ZOMBIE;  sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *p;  int fd;  int i;  for(i = 0; i < 22; i++)    proc->count[i]=0;		// set counts to 0s after termination  if(proc == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  iput(proc->cwd);  proc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(proc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->parent == proc){      p->parent = initproc;      if(p->state == ZOMBIE)        wakeup1(initproc);    }  }  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;  sched();  panic("zombie exit");}

void twakeup(int tid){    struct proc *p;    acquire(&ptable.lock);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){        if(p->state == SLEEPING && p->pid == tid && p->isthread == 1){            wakeup1(p);        }    }    release(&ptable.lock);}

// Exit the current process.  Does not return.// Exited processes remain in the zombie state// until their parent calls wait() to find out they exited.voidexit(void){  struct proc *p;  int fd;  if(cp == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(cp->ofile[fd]){      fileclose(cp->ofile[fd]);      cp->ofile[fd] = 0;    }  }  iput(cp->cwd);  cp->cwd = 0;  acquire(&proc_table_lock);  // Parent might be sleeping in wait().  wakeup1(cp->parent);  // Pass abandoned children to init.  for(p = proc; p < &proc[NPROC]; p++){    if(p->parent == cp){      p->parent = initproc;      if(p->state == ZOMBIE)        wakeup1(initproc);    }  }  // Jump into the scheduler, never to return.  cp->killed = 0;  setstate(cp, ZOMBIE);  sched();  panic("zombie exit");}

void cv_wake(int pid){  struct proc* p;  acquire(&ptable.lock);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)  {    if(p->pid == pid)    {      wakeup1(p);      break;    }  }    release(&ptable.lock);}

intbinary_semaphore_up(int binary_semaphore_ID){  acquire(&sem_table.sem_locks[binary_semaphore_ID]);  struct binary_semaphore* sem = &sem_table.binary_semaphore[binary_semaphore_ID];  if(sem->initialize){       struct proc *p;    struct proc* next = 0;    //looking for whom to wakeup who are sleeping and next    acquire(&ptable.lock);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){      if(p != proc && p->wait_for_sem == binary_semaphore_ID){	  p->sem_queue_pos--;	  if(p->sem_queue_pos == 0)	    next = p;      }    }             if(sem->waiting>0){	sem->waiting--;    }    sem->value = 1;//sem is available        //wake up the next thread    if(next && next->state == SLEEPING)      next->state = RUNNABLE;        release(&ptable.lock);    release(&sem_table.sem_locks[binary_semaphore_ID]);//realsing the sem            wakeup1(sem);    return 0;  }  else{    release(&sem_table.sem_locks[binary_semaphore_ID]);//realsing the sem    cprintf("we had problem at binary_semaphore_up: the semaphore wasn't initialize/n");     return -1;  }}

void thread_exit(void * ret_val){  acquire(&ptable.lock);    if(proc->is_thread){//not the main procces    if(proc->parent->num_of_thread_child==1){//the main thread already thread_exit and also all other thread      proc->parent->num_of_thread_child--;      release(&ptable.lock);      exit();    }          //this is not the last thread by any mean    proc->ret_val = ret_val;			// not main thread and not the last one    proc->parent->num_of_thread_child--;    proc->state = ZOMBIE;    if(proc->thread_joined){      wakeup1(proc);    }    sched();    release(&ptable.lock);  }      else if (proc->num_of_thread_child == 1){//this is the main thread and it is the last thread    proc->num_of_thread_child--;    release(&ptable.lock);    exit();  }      else{//this is the main thread but other thread are alive    proc->num_of_thread_child--;    proc->state = ZOMBIE;    sched();    release(&ptable.lock);  }}

void kthread_exit(){ 	struct proc *p;	   	int threadsCounter=0;	acquire(&ptable.lock);	  if(proc == initproc)		panic("init exiting");	int i=0;	for(;i<64;i++)	{		if(proc->sleepingThreads[i]!=0)								wakeup1(proc->sleepingThreads[i]);	}	 	for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)	{		if(p->pid==proc->pid  && p->state!=ZOMBIE && p->state!=UNUSED)		{			threadsCounter++;			}			}	if(threadsCounter==1)	{		for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)		if(p->state == ZOMBIE  && p->pid ==proc->pid && proc->threadId != p->threadId){									kfree(p->kstack);			p->kstack = 0;						p->state = UNUSED;			p->pid = 0;			p->parent = 0;			p->name[0] = 0;			p->killed = 0;								  }	   release(&ptable.lock);	   New_exit();	   return ; 	}	  // Jump into the scheduler, never to return.	  proc->state = ZOMBIE;	  sched();	  panic("zombie exit"); 	  }

// TODO(byan23): Set inuse[] to 0?// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  //cprintf("exit pid: %d./n", proc->pid);  struct proc *p;  int fd;  if(proc == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  iput(proc->cwd);  proc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(proc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->parent == proc){      p->parent = initproc;      if(p->state == ZOMBIE)	wakeup1(initproc);    }  }  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;  int slot_no;  for (slot_no = 0; slot_no < NPROC; ++slot_no) {    if (&ptable.proc[slot_no] == proc)      break;  }  //cprintf("found at slot: %d/n", slot_no);  int pri = proc_stat.priority[slot_no];  switch(pri) {    case 0:      remove_from_queue(&q0_head, &q0_tail, proc);      break;    case 1:      remove_from_queue(&q1_head, &q1_tail, proc);      break;    case 2:      remove_from_queue(&q2_head, &q2_tail, proc);      break;    case 3:      remove_from_queue(&q3_head, &q3_tail, proc);      break;    default:      cprintf("Wrong priority queue while exiting./n");  }  proc_stat.inuse[slot_no] = 0;  sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *p;  int fd;  if(proc == initproc)    panic("init exiting");	if(proc->isThread == 0) {		acquire(&ptable.lock);		for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) {      //should only kill p if child of this proc and is a thread			if(p->parent == proc && p->isThread == 1) {				release(&ptable.lock);				kill(p->pid);				join(p->pid);				acquire(&ptable.lock);			}		}		release(&ptable.lock);	}  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  iput(proc->cwd);  proc->cwd = 0;  acquire(&ptable.lock);  // Parent might be sleeping in wait().  wakeup1(proc->parent);  // Pass abandoned children to init.  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->parent == proc)    {      if(p->isThread == 1)      {        release(&ptable.lock);        kill(p->pid);        join(p->pid);        acquire(&ptable.lock);      }      else      {        p->parent = initproc;        if(p->state == ZOMBIE)          wakeup1(initproc);      }    }  }  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;  sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void) {  struct proc *p;  int fd;  // debug only  struct proc* test = proc;  if(test/*proc*/ == initproc)    panic("init exiting");      acquire(&ptable.lock);  // Close all open files. OG process only  if(!proc->thread)  {    for(fd = 0; fd < NOFILE; fd++){      if(proc->ofile[fd]){        fileclose(proc->ofile[fd]);        proc->ofile[fd] = 0;      }    }  }    iput(proc->cwd); // decrement ref count  if(!proc->thread) // only og process can wipe this out    proc->cwd = 0;  // Pass abandoned children to init, kill and join if thread  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)  {    if(p->parent == proc)    {      if(p->thread)      {        // kill        p->killed = 1;                // Wake process from sleep if necessary.        if(p->state == SLEEPING)          p->state = RUNNABLE;                  join_logic(p->pid);      }      else      {        p->parent = initproc;        if(p->state == ZOMBIE)          wakeup1(initproc);      }    }  }    // Parent might be sleeping in wait()/join().  wakeup1(proc->parent);  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;  sched();  panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){    struct proc *p;    int fd;    int rmBrothers=0;    if(!is_main_thread(proc)) {        // Kill main thread        proc->parent->killed=1;        if(proc->parent->state==SLEEPING)            proc->parent->state=RUNNABLE;        //clear_thread(proc);        rmBrothers=1;        //return;    }    if(proc == initproc)        panic("init exiting");    cprintf("#");    //release(&ptable.lock);    if(!holding(&ptable.lock)) {        cprintf("[ex%d]", proc->pid);        acquire(&ptable.lock);    }    cprintf("%");    // Pass abandoned proc children to init &    // kill all threads beneath (children who are not procs)    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) {        if(p->parent == proc) {            if(is_main_thread(p) && rmBrothers==0) {                p->parent = initproc;                if(p->state == ZOMBIE)                    wakeup1(initproc);            } else {                clear_thread(p);            }        }    }    if(rmBrothers)        goto end;    // Close all open files.    for(fd = 0; fd < NOFILE; fd++) {        if(proc->ofile[fd]) {            fileclose(proc->ofile[fd]);            proc->ofile[fd] = 0;        }    }    iput(proc->cwd);    proc->cwd = 0;end:    // Parent might be sleeping in wait().    wakeup1(proc->parent);    // Jump into the scheduler, never to return.    proc->state = ZOMBIE;    sched();    panic("zombie exit");}

// Exit the current process.  Does not return.// An exited process remains in the zombie state// until its parent calls wait() to find out it exited.voidexit(void){  struct proc *p;  int fd;  if(proc == initproc)    panic("init exiting");  // Close all open files.  for(fd = 0; fd < NOFILE; fd++){    if(proc->ofile[fd]){      fileclose(proc->ofile[fd]);      proc->ofile[fd] = 0;    }  }  iput(proc->cwd);  proc->cwd = 0;    acquire(&ptable.lock);  //cprintf("Lock acquired in exit/n");  // Parent might be sleeping in wait().  //      //wakeup1(proc->parent);  //cprintf("Wakeup the parent/n");  //acquire(&ptable.lock);  // Pass abandoned children to init.  //if(proc->isThread==0)  if(proc->isThread==0)  {  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){   if(p->parent == proc && p->isThread==1)     {    /*    cprintf("parent will kill children/n");	release(&ptable.lock);	cprintf("Lock released in exit/n");	kill(p->pid);	acquire(&ptable.lock);	cprintf("Thread killed in exit/n");	join(p->pid);	cprintf("Wait over for killed thread in exit/n");	acquire(&ptable.lock);	cprintf("Lock acquired in exit for loop/n");	*/        p->killed = 1;      // Wake process from sleep if necessary.             if(p->state == SLEEPING)                     p->state = RUNNABLE;	while(p->state!=ZOMBIE){		sleep(proc,&ptable.lock);	}	        //cprintf("Calling join/n");  	                          kfree(p->kstack);         p->kstack = 0;      //  freevm(p->pgdir);        p->state = UNUSED;        p->pid = 0;        p->parent = 0;        p->name[0] = 0;        p->killed = 0;          	/*release(&ptable.lock);	join(p->pid);         	acquire(&ptable.lock);       */                           	continue;     }   }  }    wakeup1(proc->parent);   if(proc->isThread==0)   {   for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){   if(p->parent == proc && p->isThread==0){      cprintf("Dealing with children process/n");      p->parent = initproc;      if(p->state == ZOMBIE)      {        wakeup1(initproc);      }   }  }  }  // Jump into the scheduler, never to return.  proc->state = ZOMBIE;//  cprintf("Calling schedule/n");  sched();  //release(&ptable.lock);   //cprintf("LOck released finally");  panic("zombie exit");//.........这里部分代码省略.........