void MsgSndISR()
{
int mid,pid,head;
msg_t *source, *destination;
mid = pcbs[cur_pid].tf_p ->eax;
source = (msg_t*)pcbs[cur_pid].tf_p -> ebx;
if(!EmptyQ(&mboxes[mid].wait_q))
{
pid = DeQ(&mboxes[mid].wait_q);
EnQ(pid,&ready_q);
pcbs[pid].state = READY;
destination = (msg_t *)pcbs[pid].tf_p -> ebx;
MyMemCpy((char*)destination,(char*)source,sizeof(msg_t));
}
else
{
EnQMsg(source, &mboxes[mid].msg_q);
head = mboxes[mid].msg_q.head;
destination = &mboxes[mid].msg_q.msgs[head];
}
destination->sender = cur_pid;
destination->send_tick = sys_tick;
}
void Reload(char *commandline, blobStatus *status)
{
u32 *src = 0;
u32 *dst = 0;
int numWords;
if(MyStrNCmp(commandline, "kernel", 6) == 0) {
src = (u32 *)KERNEL_RAM_BASE;
dst = (u32 *)KERNEL_START;
numWords = KERNEL_LEN / 4;
status->kernelSize = 0;
status->kernelType = fromFlash;
SerialOutputString("Loading kernel from flash ");
} else if(MyStrNCmp(commandline, "ramdisk", 7) == 0) {
src = (u32 *)RAMDISK_RAM_BASE;
dst = (u32 *)INITRD_START;
numWords = INITRD_LEN / 4;
status->ramdiskSize = 0;
status->ramdiskType = fromFlash;
SerialOutputString("Loading ramdisk from flash ");
} else {
SerialOutputString("*** Don't know how to reload \"");
SerialOutputString(commandline);
SerialOutputString("\"\r");
return;
}
MyMemCpy(src, dst, numWords);
SerialOutputString(" done\r");
}
void Delta_Decode(Byte *state, unsigned delta, Byte *data, Size_T size)
{
Byte buf[DELTA_STATE_SIZE];
unsigned j = 0;
MyMemCpy(buf, state, delta);
{
Size_T i;
for (i = 0; i < size;)
{
for (j = 0; j < delta && i < size; i++, j++)
{
buf[j] = data[i] = (Byte)(buf[j] + data[i]);
}
}
}
if (j == delta)
j = 0;
MyMemCpy(state, buf + j, delta - j);
MyMemCpy(state + delta - j, buf, j);
}
void EnQMsg(msg_t *p, msg_q_t *q)
{
int t_p = q->tail;
if (MsgQFull(q)) {
cons_printf("Message queue is full, can't enqueue!\n");
return;
}
MyMemCpy((char*)&(q->msgs[t_p]),(char*)p,sizeof(msg_t));
q->tail++;
if(q->tail >= NUM_MSG)
q->tail = 0;
q->count++;
}
void MsgRcvISR()
{
int mid = pcbs[cur_pid].tf_p ->eax;
msg_t *source, *destination = (msg_t *)pcbs[cur_pid].tf_p->ebx;
if(!MsgQEmpty(&mboxes[mid].msg_q))
{
source = DeQMsg(&mboxes[mid].msg_q);
MyMemCpy((char*)destination,(char*)source,sizeof(msg_t));
}
else
{
EnQ(cur_pid, &mboxes[mid].wait_q);
pcbs[cur_pid].state = WAIT;
cur_pid=-1;
}
}
void ForkISR(int pid, int* addr, int size, int value)
{
// Only thing new for ForkISR
int i;
int * p;
for(i=0;i<NUM_PAGE;i++)
{
if(pages[i].owner == -1)
break;
}
// The rest was a copy from spwnisr.
pages[i].owner = pid;
MyBzero((char *)pages[i].addr, USER_STACK_SIZE);
MyBzero((void *)user_stacks[pid], USER_STACK_SIZE);
MyBzero(&mboxes[pid], sizeof(mbox_t));
p = (int *) (pages[i].addr + USER_STACK_SIZE);
p--;
*p = value;
pcbs[pid].tf_p = (tf_t*) p;
pcbs[pid].tf_p--; // points to trap frame
MyMemCpy((char *)(pages[i].addr), (char *)(addr), size);
pcbs[pid].tf_p->eflags = EF_DEFAULT_VALUE|EF_INTR;
pcbs[pid].tf_p->eip = pages[i].addr;
pcbs[pid].tf_p->cs = get_cs();
pcbs[pid].tf_p->ds = get_ds();
pcbs[pid].tf_p->es = get_es();
pcbs[pid].tf_p->fs = get_fs();
pcbs[pid].tf_p->gs = get_gs();
pcbs[pid].tick_count = pcbs[pid].total_tick_count = 0;
pcbs[pid].state = READY;
pcbs[pid].ppid = cur_pid;
EnQ(pid, &ready_q);
}
void SleepISR()
{
q_t tmp_q;
InitQ( &tmp_q ); // empty temp q
// calc the future wake_tick of cur_pid
pcbs[cur_pid].wake_tick = sys_tick + 100 * pcbs[cur_pid].tf_p->eax;
// WHILE sleep_q not empty AND the 1st one in it has a wake_tick <=
// wake_tick of cur_pid: move that 1st one from sleep_q to tmp_q
while(!EmptyQ(&sleep_q)
&&
pcbs[ sleep_q.q[ sleep_q.head ] ].wake_tick
<= pcbs[ cur_pid ].wake_tick
)
{
EnQ(DeQ(&sleep_q), &tmp_q); // append it to tmp_q
}
// insertion point is reached as either sleep_q is now empty or the
// wake_tick of cur_pid is smaller than the 1st one in the sleep_q
EnQ( cur_pid, &tmp_q ); // append cur_pid to tmp_q
// append the rest of sleep_q to tmp_q
while( ! EmptyQ( &sleep_q ) )
{
EnQ( DeQ( &sleep_q ), &tmp_q );
}
// update sleep_q with the now ordered tmp_q, fastest:
MyMemCpy((char *)&sleep_q, (char *)&tmp_q, sizeof(q_t));
pcbs[cur_pid].state = SLEEP;
cur_pid = -1; // need to get a different proc to run now
}
