void Kernel(tf_t *tf_p) // kernel begins its control upon/after interrupt
{
   int pid;

   pcbs[ cur_pid ].tf_p = tf_p; // save for cur_pid which may change

   switch( tf_p->intr_id )
   {
      case TIMER_INTR:
         TimerISR();
         break;
      case IRQ7_INTR:
         IRQ7ISR(); // service parallel printer port event
         break;
      case GETPID_INTR:
         tf_p->eax = cur_pid;
         break;
      case SLEEP_INTR:
         SleepISR();
         break;
      case SPAWN_INTR:
         pid = DeQ( &avail_q ); // get pid and put in ebx can be in Kernel()
         pcbs[ cur_pid ].tf_p->ebx = pid; // child PID, could be -1
         if( pid == -1 ) break; // no more process
         SpawnISR(pid, (func_ptr_t) pcbs[ cur_pid ].tf_p->eax);
         break;
      case SEMINIT_INTR:
         SemInitISR();
         break;
      case SEMWAIT_INTR:
         SemWaitISR(tf_p->eax);
         break;
      case SEMPOST_INTR:
         SemPostISR(tf_p->eax);
         break;
      case MSGSND_INTR:
         MsgSndISR();
         break;
      case MSGRCV_INTR:
         MsgRcvISR();
         break;
      case IRQ3_INTR:	
      case IRQ4_INTR:
         IRQ34ISR();	
         break;
      case FORK_INTR:
         pid = DeQ( &avail_q );
         ForkISR(pid);
         pcbs[ cur_pid ].tf_p->ebx = pid;
         break;
      case WAIT_INTR: //cons_printf("Wait Intr\n");
         WaitISR(); 
         break;
      case EXIT_INTR: //cons_printf("Exit Intr\n");
         ExitISR();
         break;
   }
   Scheduler();                  // find same/new process to run
   Loader(pcbs[ cur_pid ].tf_p); // load it to run
} // Kernel()
Exemple #2
0
void KernelMain(TF_t *TF_ptr) 
{
	int new_pid, i, pid, len;	

	pcb[running_pid].TF_ptr = TF_ptr;	//save TF_ptr to PCB of running process
	
	switch(TF_ptr->intr_id)			//switch on TF_ptr->intr_id
	{
		case TIMER_INTR:
				TimerISR();	//call TimerISR()
				outportb(0x20, 0x60);	//dismiss timer event
				OS_clock++;
				len = sleep_q.len;

				for(i = 0; i < len; i++)
				{
					pid = DeQ(&sleep_q);
					if(OS_clock == pcb[pid].wake_time)
					{
						EnQ(pid, &ready_q);
						pcb[pid].state = READY;
					}
					else
					{
						EnQ(pid, &sleep_q);
					}	
				}
				break;
		case GETPID_INTR:
				GetPidISR();
				break;
		case SLEEP_INTR:
				SleepISR();
				break;
		//phase 3 new switch() cases		
		case STARTPROC_INTR:
				new_pid = DeQ(&free_q);	//dequeue free_q for a new pid
				if (new_pid == -1)	//indicates no ID left
				{				
					cons_printf("Panic: no more available process ID left!\n");	//show msg on target PC			
				}
				else
				{
					StartProcISR(new_pid, TF_ptr->eax);
				}
				break;
		case SEMGET_INTR:
				SemGetISR(TF_ptr->eax);
				break;
		case SEMWAIT_INTR:
				SemWaitISR(TF_ptr->eax);
				break;
		case SEMPOST_INTR:
				SemPostISR(TF_ptr->eax);
				break;
		//phase 4
		case MSGSND_INTR:
				MsgSndISR(TF_ptr->eax);	//Check if parameter 
				break;
		case MSGRCV_INTR:
				MsgRcvISR(TF_ptr->eax);
				break;
		//phae 5
		case IRQ7_INTR:
				SemPostISR(printing_semaphore);
				outportb(0x20, 0x67);	//dismiss IRQ7
				break;
		//phase 6
		case IRQ3_INTR:
				IRQ3ISR();
				outportb(0x20, 0x63);	//dismiss IRQ3
				break; 

		//phase 8
		case FORK_INTR:
				ForkISR(TF_ptr->eax, TF_ptr->ebx);
				break;
		case WAIT_INTR:
				WaitISR(TF_ptr->eax);
				break;
		case EXIT_INTR:
				ExitISR(TF_ptr->eax);
				break;
		default:
				cons_printf("Panic: unknown intr ID (%d)!\n", TF_ptr->intr_id);
				breakpoint();		//fallback to GDB
	}

	Scheduler();		//call scheduler() to process to load/run if needed
	LoadRun(pcb[running_pid].TF_ptr);	//load/run selected proc
}