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()
void Kernel(tf_t *tf_p) // kernel directly enters here when interrupt occurs
{
// Save "tf_p" to pcbs[cur_pid].tf_p for future resume of process runtime
pcbs[cur_pid].tf_p = tf_p;
// tf_p->intr_id tells what intr made CPU get here, pushed in entry.S
switch(tf_p->intr_id)
{
case TIMER_INTR:
TimerISR(); // this must include dismissal of timer interrupt
break;
case IRQ7_INTR:
IRQ7ISR();
break;
case SLEEP_INTR:
SleepISR(tf_p->eax);
break;
case GETPID_INTR:
tf_p->eax = cur_pid;
break;
case SPAWN_INTR:
if (EmptyQ(&avail_q)) {
cons_printf("No more available PIDs!\n");
tf_p->ebx = -1;
}
else {
tf_p->ebx = DeQ(&avail_q);
SpawnISR((int) tf_p->ebx, (func_ptr_t) tf_p->eax);
}
break;
case SEMINIT_INTR:
tf_p->ebx = SemInitISR(tf_p->eax);
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;
}
Scheduler(); // select a process to run
Loader(pcbs[cur_pid].tf_p); // run the process selected
}
void KernelMain(TF_t *TF_ptr) {
int new_pid;
pcb[running_pid].TF_ptr = TF_ptr;
switch(TF_ptr ->intr_id) {
case(TIMER_INTR):
TimerISR();
OS_clock++;
checkWait();
outportb(0x20, 0x60); //stops the timer pic with a code
break;
case(SLEEP_INTR):
Sleep_ISR(TF_ptr->eax);
break;
case(GETPID_INTR):
TF_ptr->eax = running_pid;
break;
case(STARTPROC_INTR):
new_pid = DeQ(&free_q);
StartProcISR(new_pid,TF_ptr->eax);
break;
case(SEMWAIT_INTR):
SemWaitISR(TF_ptr->eax);
break;
case(SEMPOST_INTR):
SemPostISR(TF_ptr->eax);
break;
case(SEMGET_INTR):
SemGetISR(TF_ptr->eax);
break;
case(MSGSND_INTR):
MsgSndISR(TF_ptr->eax);
break;
case(MSGRCV_INTR):
MsgRcvISR(TF_ptr->eax);
break;
default:
cons_printf("Panic: unknown intr ID (%d)!\n",TF_ptr->intr_id);
breakpoint();
}
Scheduler();
LoadRun(pcb[running_pid].TF_ptr);
}
void Kernel(tf_t *tf_p) // kernel begins its control upon/after interrupt
{
int pid, sid;
pcbs[cur_pid].tf_p = tf_p; // save for cur_pid which may change
switch(tf_p->intr_id)
{
case TIMER_INTR:
TimerISR(); // service the simulated timer interrupt
break;
case GETPID_INTR:
tf_p->eax = cur_pid;
break;
case SLEEP_INTR:
SleepISR();
break;
case SPAWN_INTR:
if(EmptyQ(&avail_q)) {
cons_printf("No more processes\n");
tf_p->eax = -1;
}
else {
pid = DeQ(&avail_q);
pcbs[pid].state = READY;
SpawnISR(pid, (func_ptr_t) tf_p->eax);
tf_p->eax = pid;
}
break;
case SEMINIT_INTR:
sid = SemInitISR(tf_p->eax);
tf_p->eax = sid;
break;
case SEMWAIT_INTR:
SemWaitISR();
break;
case SEMPOST_INTR:
SemPostISR();
break;
}
Scheduler(); // find same/new process to run
Loader(pcbs[cur_pid].tf_p); // load it to run
} // Kernel()
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: send PIC with a code
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);//create new proc
}
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 needed*********
break;
case MSGRCV_INTR:
MsgRcvISR(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); //call LoadRun(pcb[running_pid].TF_ptr) to load/run selected proc
}
