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

void handleLeftDoubleClick(){  WindowQueue *pwindowQueue;  Widget *pwidget;  pwindowQueue = getClickedWindowQueue();  if (pwindowQueue)  {    focusDismiss();    switchuvm(pwindowQueue->proc);    pwidget = getClickedWidget(pwindowQueue->window);    if (pwidget)    {      switch (pwidget->type)      {      case iconView:        pwidget->context.iconView->onLeftDoubleClickHandler.triggered = 1;        break;      default:        break;      }    }  }  if (proc == 0)    switchkvm();  else    switchuvm(proc);}

void handleMouseDrag(){  if (drag_state == 0)  {    pwque = getDraggedWindowQueue();    if (pwque)    {      drag_state = 1;      if (pwque != lastWindow && pwque != &windowLine[0])        reorderQueue(pwque);    }    else      drag_state = 2;  }  else  if (drag_state == 1)  {    switchuvm(pwque->proc);    counter = (counter + 1) % 20;    if (counter == 0)      isdraw = 1;    else      isdraw = 0;    moveWindow(pwque->window, mouse_info.x_position, mouse_info.y_position, down_pos_x, down_pos_y, isdraw);  }  if (proc == 0)    switchkvm();  else    switchuvm(proc);}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){  uint sz;  struct proc *p;  sz = proc->sz;  if(n > 0){    if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  } else if(n < 0){    if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  }  proc->sz = sz;  //other threads  int tid = proc->tid;  acquire(&ptable.lock);  for( p = ptable.proc; p < &ptable.proc[NPROC]; p++)    if(p->tid == tid)      p->sz = sz;  release(&ptable.lock);  switchuvm(proc);  return 0;}

//PAGEBREAK: 42// Per-CPU process scheduler.// Each CPU calls scheduler() after setting itself up.// Scheduler never returns.  It loops, doing://  - choose a process to run//  - swtch to start running that process//  - eventually that process transfers control//      via swtch back to the scheduler.voidscheduler(void){  struct proc *p;  for(;;){    // Enable interrupts on this processor.    sti();    // Loop over process table looking for process to run.    acquire(&ptable.lock);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){      if(p->state != RUNNABLE)        continue;      // Switch to chosen process.  It is the process's job      // to release ptable.lock and then reacquire it      // before jumping back to us.      proc = p;      switchuvm(p);      p->state = RUNNING;      swtch(&cpu->scheduler, proc->context);      switchkvm();      // Process is done running for now.      // It should have changed its p->state before coming back.      proc = 0;    }    release(&ptable.lock);  }}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure./// Need to add locks to this function to make it work with threads!intgrowproc(int n){  uint sz;        sz = proc->sz;  if(n > 0){    if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  } else if(n < 0){    if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  }  proc->sz = sz;  switchuvm(proc);    acquire(&ptable.lock);  // Now update the sz variable for all other processes sharing this address space    struct proc *p;  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++) {      if(p->pgdir == proc->pgdir && p != proc) {		p->sz = proc->sz;      }  }   release(&ptable.lock);  return 0;}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){  uint sz;  struct proc* p;    sz = proc->sz;  if(n > 0){    if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  } else if(n < 0){    if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  }  proc->sz = sz;  acquire(&ptable.lock);  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){	  if(p->state == UNUSED || p->pgdir != proc->pgdir)		  continue;	  p->sz = sz;  }  release(&ptable.lock);    switchuvm(proc);  return 0;}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){    uint sz;    sz = proc->sz;    if(n > 0) {        //prevent heap from overwriting our stack        int se=proc->se;        int page_n = PGROUNDUP(n);        int heap_size = PGROUNDUP(proc->sz);        if((heap_size + page_n) > (se - PGSIZE)) {            //panic("Heap is overwriting stack!"); //just return -1 is sufficient. No need to panic!            return -1;        }        if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)            return -1;    } else if(n < 0) {        if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)            return -1;    }    proc->sz = sz;    switchuvm(proc);    return 0;}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){    uint sz;    // struct proc *p;    sz = proc->sz;    acquire(&ptable.lock);    // if(proc->thread == 1){    //     for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    //         if(proc->parent == p || p->parent == proc->parent){    //             if(n > 0){    //                 if((sz = allocuvm(p->pgdir, sz, sz + n)) == 0)    //                     return -1;    //             }else if(n < 0){    //                 if((sz = deallocuvm(p->pgdir, sz, sz + n)) == 0)    //                     return -1;    //             }    //         }    //     }    // }    if(n > 0){        if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)            return -1;    }else if(n < 0){        if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)            return -1;    }    proc->sz = sz;    release(&ptable.lock);    switchuvm(proc);    return 0;}

void scheduler(){	struct proc *p;		while(1){		/* set interrupts ??? */		for(p=ptable.proc;p<&ptable.proc[NPROC];p++){			if(p->state!=RUNNABLE){				continue;			}			/* switch to this process. */			proc=p;			switchuvm(p);			p->state=RUNNING;			swtch(&cpu.scheduler,p->context);			/* __asm__ volatile( */			/* 		"movq %0,%%rsp;" */			/* 		: */			/* 		:"r"((char *)(proc->tf) - 8) */			/* 		: */			/* 				 ); */			/* __asm__ volatile("retq;"); */					}	}}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){  uint sz;  struct proc * p;  acquire(&sbrklock);  sz = proc->sz;  if(n > 0){    if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  } else if(n < 0){    if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  }  acquire(&ptable.lock);  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){      if(p->pgdir == proc->pgdir)        p->sz = sz;  }  release(&ptable.lock);  switchuvm(proc);  release(&sbrklock);  return 0;}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){  uint sz;    sz = proc->sz;  uint stack;  stack = proc->stack;//  cprintf("/n/n/n/nStack %x/t Size: %x/n",(uint)PGROUNDDOWN(stack-PGSIZE),sz);  cprintf("Heap needs: [%x] more/t Stack: %x/t Process size: %x/n",n,(uint)PGROUNDDOWN(stack-PGSIZE),sz);  if (n > (uint)PGROUNDDOWN(stack-PGSIZE) - sz){//	  cprintf("Heap needs: [%x] more/t Stack: %x/t Process size: %x/n",n,(uint)PGROUNDDOWN(stack-PGSIZE),sz);	  cprintf("Heap growing too much!/n");//	  proc->killed=1;	  return -1;   }  if(n > 0){    if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  } else if(n < 0){    if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)      return -1;  }  proc->sz = sz;  switchuvm(proc);  return 0;}

intclone(void(*fcn)(void*), void *arg, void *stack){  int i, pid;  struct proc *np;  uint * sp;// ALLOCATES A NEW THREAD //  // Allocate process.  if((np = allocproc()) == 0)    return -1;  //if a thread calls clone it makes its parent the parent of the new thread  if(proc->isThread == 1){    np->parent = proc->parent;    *np->tf = *proc->parent->tf;    np->sz = proc->parent->sz;    np->pgdir = proc->parent->pgdir;  }  else{      np->parent = proc;    *np->tf = *proc->tf;    np->sz = proc->sz;    np->pgdir = proc->pgdir;  }    np->isThread = 1;  np->state = RUNNABLE;  // Clear %eax so that fork returns 0 in the child.  np->tf->eax = 0;  pid = np->pid;  for(i = 0; i < NOFILE; i++)    if(proc->ofile[i])      np->ofile[i] = filedup(proc->ofile[i]);  np->cwd = idup(proc->cwd);  safestrcpy(np->name, proc->name, sizeof(proc->name));  //safestrcpy(np->name, "ThreadChildren", sizeof("ThreadChildren"));  // Push argument strings, prepare rest of stack in ustack.  sp = (uint *) ((char *)stack + PGSIZE);  sp -= 2;  sp[0] = 0xffffffff;  // fake return PC  sp[1] = (uint) arg;  // Commit to the user image.s  np->tf->eip = (uint) fcn;  // main  np->tf->esp = (uint) sp;  //cprintf("[proc clone]-pid-%d/n",pid);  switchuvm(np);  //return pid on success not 0 yo  return pid;}

int clone(void(*fcn)(void*), void *arg, void *stack) { // FIX THIS !  int pid;  struct proc *newtask;  // Copy process state from p.  /*if((np->pgdir = copyuvm(proc->pgdir, proc->sz)) == 0){    kfree(np->kstack);    np->kstack = 0;    np->state = UNUSED;    return -1;  }*/    // Allocate process.  if((newtask = allocproc()) == 0)    return -1;  newtask->isThread = 1; // labelling as thread  newtask->sz = proc->sz;  newtask->parent = proc;  *newtask->tf = *proc->tf;  // Clear %eax so that clone returns 0 in the child.  newtask->tf->eax = 0;  /*for(i = 0; i < NOFILE; i++)    if(proc->ofile[i])      np->ofile[i] = filedup(proc->ofile[i]);  np->cwd = idup(proc->cwd);*/  safestrcpy(newtask->name, proc->name, sizeof(proc->name));   pid = newtask->pid;  // lock to force the compiler to emit the np->state write last.  /*  acquire(&ptable.lock);  np->state = RUNNABLE;  release(&ptable.lock);*/       // temporary array to copy into the bottom of new stack   // for the thread (i.e., to the high address in stack  // page, since the stack grows downward)  uint ustack[2];  uint sp = (uint)stack+PGSIZE;  ustack[0] = 0xffffffff; // fake return PC  ustack[1] = (uint)arg;  sp -= 8; // stack grows down by 2 ints/8 bytes  if (copyout(newtask->pgdir, sp, ustack, 8) < 0) {    // failed to copy bottom of stack into new task    return -1;  }  newtask->tf->eip = (uint)fcn;  newtask->tf->esp = sp;  switchuvm(newtask);  newtask->state = RUNNABLE;    return pid;}

// Per-CPU process scheduler.// Each CPU calls scheduler() after setting itself up.// Scheduler never returns.  It loops, doing://  - choose a process to run//  - swtch to start running that process//  - eventually that process transfers control//      via swtch back to the scheduler.voidscheduler(void){  struct proc *p;  initlock(&tlock, "time");  for(;;){    // Enable interrupts on this processor.    sti();    // Loop over process table looking for process to run.    acquire(&ptable.lock);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){      if(p->state != RUNNABLE)        continue;      if(count_high_pri() != 0 && p->priority == 1)		continue;      // Switch to chosen process.  It is the process's job      // to release ptable.lock and then reacquire it      // before jumping back to us.      proc = p;      switchuvm(p);      p->state = RUNNING;	  //swtch(&cpu->scheduler, proc->context);	  //switchkvm();	  uint ticks0 = 0, ticks1 = 0;	  	  acquire(&tlock);//Acquire the timer lock      ticks0 = ticks;//Start timer	  release(&tlock);	  swtch(&cpu->scheduler, proc->context);      acquire(&tlock);//Acquire the timer lock      ticks1 = ticks;//Stop timer and add the ticks to htick or ltick depending upon the priority of the process.      release(&tlock);	  if (p->priority == 1) {		p->ltick = p->ltick + (ticks1 - ticks0);      } else {		p->htick = p->htick + (ticks1 - ticks0);	  }	        switchkvm();      // Process is done running for now.      // It should have changed its p->state before coming back.      proc = 0;    }    release(&ptable.lock);  }}

//PAGEBREAK: 42// Per-CPU process scheduler.// Each CPU calls scheduler() after setting itself up.// Scheduler never returns.  It loops, doing://  - choose a process to run//  - swtch to start running that process//  - eventually that process transfers control//      via swtch back to the scheduler.voidscheduler(void){  struct proc *p;  int makeShiftTimer = 0;  for(;;){    // Enable interrupts on this processor.    sti();        makeShiftTimer++;	if (makeShiftTimer >= 10000){		for (p = ptable.proc; p < &ptable.proc[NPROC]; p++){			if (p->pri != 1){				continue;			}				p->pri = 0;			//cprintf("Bumping up: %s", p->name);		}		makeShiftTimer = 0;	} 	int zeroCount = 0;	for (p = ptable.proc; p < &ptable.proc[NPROC]; p++){		zeroCount++;	}	//	cprintf("Number of process on queue 0: %d/n", zeroCount);	//don't uncomment this if you want to be able to use the terminal. At all.    // Loop over process table looking for process to run.    acquire(&ptable.lock);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){      if((p->state != RUNNABLE) || (zeroCount != 0 && p->pri == 1))	//im pretty sure the case for there being nothing on the 0 queue and stuff on the 1 queue is implicit here	//we'll wait and see I guess        continue;      // Switch to chosen process.  It is the process's job      // to release ptable.lock and then reacquire it      // before jumping back to us.      proc = p;      switchuvm(p);      p->state = RUNNING;      swtch(&cpu->scheduler, proc->context);      switchkvm();      // Process is done running for now.      // It should have changed its p->state before coming back.      proc = 0;    }    release(&ptable.lock);  }}

void handleLeftClick(){  WindowQueue *pwindowQueue;  Widget *pwidget;  pwindowQueue = getClickedWindowQueue();  if (pwindowQueue)  {    if (pwindowQueue != lastWindow && pwindowQueue == &windowLine[0])    {      if (proc == 0)        switchkvm();      else        switchuvm(proc);      return;    }    if (pwindowQueue != lastWindow  && pwindowQueue != &windowLine[0])    {      focusDismiss();      reorderQueue(pwindowQueue);      switchuvm(pwindowQueue->proc);    }    pwidget = getClickedWidget(pwindowQueue->window);    if (pwidget)    {      switch (pwidget->type)      {      case button:        focusDismiss();        switchuvm(pwindowQueue->proc);        pwidget->context.button->onLeftClickHandler.triggered = 1;        break;      case imageView:        focusDismiss();        switchuvm(pwindowQueue->proc);        pwidget->context.imageView->onLeftClickHandler.triggered = 1;        break;      case iconView:        focusIconView(pwidget->context.iconView);        break;      default:        focusDismiss();        switchuvm(pwindowQueue->proc);        break;      }    }    else    {        focusDismiss();        switchuvm(pwindowQueue->proc);    }  }  if (proc == 0)    switchkvm();  else    switchuvm(proc);}

//PAGEBREAK: 42// Per-CPU process scheduler.// Each CPU calls scheduler() after setting itself up.// Scheduler never returns.  It loops, doing://  - choose a process to run//  - swtch to start running that process//  - eventually that process transfers control//      via swtch back to the scheduler.voidscheduler(void){  struct proc *p;  int i;#if 0  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){    if(p->state != UNUSED)      cprintf("proc %d has priority  %d/n", p->pid, p->priority);  }#endif  for(;;){    // Enable interrupts on this processor.    sti();    acquire(&ptable.lock);    // Loop through priority queues looking for runnable processe    for(i = 0; i < 32; i++) {      if(priority_q[i] != NULL) {        p = priority_q[i];#if 0      }    }    // Loop over process table looking for process to run.    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){#endif        if(p->state != RUNNABLE)          panic("Not runnable in ready queue");        // Switch to chosen process.  It is the process's job        // to release ptable.lock and then reacquire it        // before jumping back to us.        proc = p;        switchuvm(p);        p->state = RUNNING;        //**** remove        //cprintf("remove in scheduler/n");        removefromq(p);        //****        swtch(&cpu->scheduler, proc->context);        switchkvm();        // Process is done running for now.        // It should have changed its p->state before coming back.        proc = 0;      }    }  release(&ptable.lock);  }

void SwitchToProccess(struct proc* process){	proc = process;	switchuvm(process);	process->state = RUNNING;	swtch(&cpu->scheduler, proc->context);	switchkvm();	// Process is done running for now.	// It should have changed its p->state before coming back.	proc = 0;}

int clone(void(*fcn)(void*), void *arg, void *stack) {  int i, pid;	//cprintf("proc.c void *arg print: %d/n", &arg);  struct proc *newtask;	// Allocate process.  if ((newtask = allocproc()) == 0) return -1;    //newtask->kstack = stack;  newtask->isThread = 1; // labelling as thread  newtask->sz = proc->sz;	if (proc->isThread) {		newtask->parent = proc->parent;	}	else {  	newtask->parent = proc;	}  *newtask->tf = *proc->tf;  newtask->pgdir = proc->pgdir;  for(i = 0; i < NOFILE; i++)    if(proc->ofile[i])      newtask->ofile[i] = filedup(proc->ofile[i]);  newtask->cwd = idup(proc->cwd);  safestrcpy(newtask->name, proc->name, sizeof(proc->name));  // Clear %eax so that clone returns 0 in the child.  newtask->tf->eax = 0;  pid = newtask->pid;      // temporary array to copy into the bottom of new stack   // for the thread (i.e., to the high address in stack  // page, since the stack grows downward)  uint ustack[2];  uint sp = (uint)stack+PGSIZE;  ustack[0] = 0xffffffff; // fake return PC  ustack[1] = (uint)arg;  sp -= 8; // stack grows down by 2 ints/8 bytes  if (copyout(newtask->pgdir, sp, ustack, 8) < 0) {    // failed to copy bottom of stack into new task    cprintf("I'm crashing...");    return -1;  }  newtask->tf->eip = (uint)fcn;  newtask->tf->esp = sp;  switchuvm(newtask);  newtask->state = RUNNABLE;    return pid;}

int clone(void (*fcn)(void*), void *arg, void *stack){    int i, pid;    struct proc *np;    if ((int)stack % PGSIZE != 0) {        return -1;    }    if ((np = allocproc()) == 0) {        return -1;    }    np->pgdir = proc->pgdir;    np->sz = proc->sz;    if (proc->is_thread == 1) {        np->parent = proc->parent;    }    else {        np->parent = proc;    }    *np->tf = *proc->tf;    np->is_thread = 1;    np->tf->eax = 0;    for(i = 0; i < NOFILE; i++) {        if(proc->ofile[i]) {            np->ofile[i] = filedup(proc->ofile[i]);        }    }    np->cwd = idup(proc->cwd);    safestrcpy(np->name, proc->name, sizeof(proc->name));    pid = np->pid;    uint ustack[2];    uint sp = (uint)stack+PGSIZE;    ustack[0] = 0xffffffff;    ustack[1] = (uint)arg;    sp -= 8;    if (copyout(np->pgdir, sp, ustack, 8) < 0) {        return -1;    }    np->tf->eip = (uint)fcn;    np->tf->esp = sp;    switchuvm(np);    np->state = RUNNABLE;    return pid;}

voidscheduler(void){  struct proc *p;  ptable.timeToReset = MAX_TIME_TO_RESET;  for(;;){    // Enable interrupts on this processor.    sti();    // Check for procs in ready list    int pri = 0;    for (;;) {      acquire(&ptable.lock);      if(ptable.pPriQ[pri] != 0) {         // Switch to chosen process.  It is the process's job        // to release ptable.lock and then reacquire it        // before jumping back to us.        p = ptable.pPriQ[pri];	if (p->state != RUNNABLE)	  panic("scheduled unready process");        proc = p;        switchuvm(p);        p->state = RUNNING;        ptable.pPriQ[pri] = ptable.pPriQ[pri]->next;	p->next = 0;	ptable.timeToReset--;        if (ptable.timeToReset == 0)          resetPri();   // Run priority-reset function        swtch(&cpu->scheduler, proc->context);        switchkvm();        // Process is done running for now.        // It should have changed its p->state before coming back.        proc = 0;        release(&ptable.lock);	pri = 0;        break;      }      else {        release(&ptable.lock);        if (pri == N_PRI-1)          pri = 0;        else	  pri++;      }    }  }}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){  uint sz = proc->sz;  if(n > 0){    if(!(sz = allocuvm(proc->pgdir, sz, sz + n)))      return -1;  } else if(n < 0){    if(!(sz = deallocuvm(proc->pgdir, sz, sz + n)))      return -1;  }  proc->sz = sz;  switchuvm(proc);  return 0;}

//PAGEBREAK: 42// Per-CPU process scheduler.// Each CPU calls scheduler() after setting itself up.// Scheduler never returns.  It loops, doing://  - choose a process to run//  - swtch to start running that process//  - eventually that process transfers control//      via swtch back to the scheduler.void scheduler(void) {	struct proc *p, *q;	unsigned long long min  ;		for(;;){		// Enable interrupts on this processor.		sti();				// Loop over process table looking for process to run.		acquire(&ptable.lock);		p = 0;		min = INFINITO ;		for(q = ptable.proc; q < &ptable.proc[NPROC]; q++){			if (q->state == RUNNABLE){				if (min > q->curr_pass){ 					p = q;					min = q->curr_pass;				}			}		}		if (p!=0){			/*Testes			if (p->pid > 3){				for(q = ptable.proc; q < &ptable.proc[NPROC]; q++){					cprintf("%d %d %d/n", q->pid, q->Ntickts, q->slices);				}				cprintf("/n/n/n/n");			}			End */						p->slices++; 			proc = p;			switchuvm(p);			p->state = RUNNING;						swtch(&cpu->scheduler, proc->context);			switchkvm();			// Process is done running for now.			p->curr_pass+=p->pass;						// It should have changed its p->state before coming back.			proc = 0;		}				release(&ptable.lock);	}}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){  uint sz;    sz = proc->sz;  if(n > 0){    if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)  // allocate  the page      return -1;  } else if(n < 0){    if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0) // deallocate the page      return -1;  }  proc->sz = sz;  switchuvm(proc);  return 0;}

WindowQueue* getClickedWindowQueue(){  WindowQueue *p = lastWindow;  int x = mouse_info.x_position;  int y = mouse_info.y_position;  //get clicked window  while (p)  {    switchuvm(p->proc);    if (inWindowRange(p->window, x, y))    {      return (p);    }    p = p->prev;  }  return 0;}

//PAGEBREAK: 42// Per-CPU process scheduler.// Each CPU calls scheduler() after setting itself up.// Scheduler never returns.  It loops, doing://  - choose a process to run//  - swtch to start running that process//  - eventually that process transfers control//      via swtch back to the scheduler.voidscheduler(void){    struct proc *p;    for(;;) {        // Enable interrupts on this processor.        sti();        // Loop over process table looking for process to run.        acquire(&ptable.lock);        uint min_order = 1<<30;        uint idx = -1;        for (p = ptable.proc; p < &ptable.proc[NPROC]; p++)            if (p->state == RUNNABLE && p->order < min_order) {                min_order = p->order;                idx = p - ptable.proc;            }        if (idx == -1)        {            release(&ptable.lock);            continue;        }        //for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){        //  if(p->state != RUNNABLE)        //    continue;        // Switch to chosen process.  It is the process's job        // to release ptable.lock and then reacquire it        // before jumping back to us.        p = ptable.proc + idx;        proc = p;        switchuvm(p);        p->state = RUNNING;        swtch(&cpu->scheduler, proc->context);        switchkvm();        // Process is done running for now.        // It should have changed its p->state before coming back.        proc = 0;        //break;        //}        release(&ptable.lock);    }}

//PAGEBREAK: 42// Per-CPU process scheduler.// Each CPU calls scheduler() after setting itself up.// Scheduler never returns.  It loops, doing://  - choose a process to run//  - swtch to start running that process//  - eventually that process transfers control//      via swtch back to the scheduler.voidscheduler(void){  struct proc *p;  for(;;){    // Enable interrupts on this processor.    sti();    // Loop over process table looking for process to run.    acquire(&ptable.lock);    /*    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){      if(p->state != RUNNABLE)        continue;    */    int i;    for(i = 0; i < PRIORITIES; i ++)      {	p = ready[i];	if(p == 0)	  continue;      // Switch to chosen process.  It is the process's job      // to release ptable.lock and then reacquire it      // before jumping back to us.      proc = p;      switchuvm(p);      p->state = RUNNING;      remove_from_ready(p);      swtch(&cpu->scheduler, proc->context);      switchkvm();      // Process is done running for now.      // It should have changed its p->state before coming back.      proc = p = 0;      /*      if(current_priority == 31)	current_priority = 0;      else      current_priority = i + 1; */    }    release(&ptable.lock);  }}

// Grow current process's memory by n bytes.// Return 0 on success, -1 on failure.intgrowproc(int n){  uint sz;//  cprintf("Before acquire/n");   acquire(&locksbrk);  // cprintf("After acquire/n");    sz = proc->sz;  if(n > 0){    if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)      {        release(&locksbrk);        return -1;      }  } else if(n < 0){    if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)      {  release(&locksbrk);	  return -1;      }  }  proc->sz = sz;    struct proc *p;  acquire(&ptable.lock);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){       if(/*p->parent == proc &&*/ p->pgdir == proc->pgdir)        	p->sz=proc->sz;      }    release(&ptable.lock); // cprintf("Before release/n");  release(&locksbrk); // cprintf("After release/n");    switchuvm(proc);  //release(&locksbrk);  return 0;}

voidscheduler(void){  struct proc *p;  for(;;){    // Enable interrupts on this processor.    sti();    // Loop over process table looking for process to run.    acquire(&ptable.lock);    for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){      if(p->state != RUNNABLE)        continue;      // Switch to chosen process.  It is the process's job      // to release ptable.lock and then reacquire it      // before jumping back to us.      if (p->allowed_cpu > -1 && p->allowed_cpu == cpu->id) {        //cprintf("/n Processing prod %d, at cpu %d", p->pid, cpu->id);      } else if (p->allowed_cpu > -1) {        //cprintf("/nSkipping proc %d at cpu %d, proc->allowed_cpu %d", p->pid, cpu->id, p->allowed_cpu);          continue;      }rerun:      proc = p;      switchuvm(p);      p->state = RUNNING;      swtch(&cpu->scheduler, proc->context);      switchkvm();      // Process is done running for now.      // It should have changed its p->state before coming back.      if (cpu->preempt_disable_count > 0) {          // Go back and reschedule the same process          goto rerun;      }      proc = 0;    }    release(&ptable.lock);  }}

void handleRightClick(){  WindowQueue *pwindowQueue;  Widget *pwidget;  pwindowQueue = getClickedWindowQueue();  if (pwindowQueue)  {    pwidget = getClickedWidget(pwindowQueue->window);    if (pwidget)    {    }  }  if (proc == 0)    switchkvm();  else    switchuvm(proc);}