// **********************************************************************
// system kill task
//
static int sysKillTask(int taskId)
{
Semaphore* sem = semaphoreList;
Semaphore** semLink = &semaphoreList;
// assert that you are not pulling the rug out from under yourself!
assert("sysKillTask Error" && tcb[taskId].name && superMode);
// printf("\nKill Task %s", tcb[taskId].name);
// signal task terminated
semSignal(taskSems[taskId]);
// look for any semaphores created by this task
while(sem = *semLink)
{
if(sem->taskNum == taskId)
{
// semaphore found, delete from list, release memory
deleteSemaphore(semLink);
}
else
{
// move to next semaphore
semLink = (Semaphore**)&sem->semLink;
}
}
takeout(taskId, &READY_QUEUE);
// ?? delete task from system queues
tcb[taskId].name = 0; // release tcb slot
return 0;
} // end killTask
int queueTest(int argc, char* argv[])
{
debug = TRUE;
char buff[32];
Queue newQueue;
initQueue(&newQueue);
int i;
for(i = 1; i < 10; i++)
{
int id = i;
int priority = 5; //rand() % 100;
sprintf(buff, "task %d, priority %d", id, priority);
enqueue(id , &newQueue);
dumpQueue(&newQueue);
}
printf("\nInitial Queue:");
dumpQueue(&newQueue);
for(i = 0; i < 10; i--)
{
sprintf(buff, "\n Removing taskid %d...", i);
takeout(i, &newQueue);
printf(buff);
dumpQueue(&newQueue);
}
debug = FALSE;
return 0;
}
int semWait(Semaphore* s)
{
assert("semWait Error" && s); // assert semaphore
assert("semWait Error" && ((s->type == 0) || (s->type == 1))); // assert legal type
assert("semWait Error" && !superMode); // assert user mode
// check semaphore type
if (s->type == BINARY)
{
if (s->state == 0)
{
tcb[curTask].event = s; // block task
tcb[curTask].state = S_BLOCKED;
takeout(curTask, &READY_QUEUE);
enqueue(curTask, &(s->bq));
swapTask(); // reschedule the tasks
return 1;
}
s->state = 0; // reset state, and don't block
return 0;
}
else if(s->type == COUNTING)
{
if(s->state <= 0)
{
s->state = s->state - 1;
tcb[curTask].event = s; // block task
tcb[curTask].state = S_BLOCKED;
takeout(curTask, &READY_QUEUE);
enqueue(curTask, &(s->bq));
swapTask(); // reschedule the tasks
return 1;
}
else
{
s->state = s->state - 1;
return 0;
}
}
return 0;
} // end semWait
static void exitTask(int taskId)
{
assert("exitTaskError" && tcb[taskId].name);
if(tcb[taskId].event)
{
takeout(taskId, &(tcb[taskId].event->bq));
tcb[taskId].event->state = tcb[taskId].event->state + 1;
}
// 1. find task in system queue
// 2. if blocked, unblock (handle semaphore)
// 3. set state to exit
// ?? add code here...
tcb[taskId].state = S_EXIT; // EXIT task state
enqueue(taskId, &READY_QUEUE);
// enqueue(taskId, HIGHEST_PRIORITY, &READY_QUEUE);
return;
} // end exitTask
/*ARGSUSED*/
void
vyankit(int unused)
{
register int cnt;
if (wdot) {
if ((cnt = xdw()) < 0)
return;
vremote(cnt, yank, 0);
setpk();
notenam = "yank";
if (FIXUNDO)
vundkind = VNONE;
DEL[0] = 0;
wdot = NOLINE;
if (notecnt <= vcnt - vcline && notecnt < value(REPORT))
notecnt = 0;
vrepaint(cursor);
return;
}
takeout(DEL);
}
// **********************************************************************
// **********************************************************************
// signal semaphore
//
// if task blocked by semaphore, then clear semaphore and wakeup task
// else signal semaphore
//
void semSignal(Semaphore* s)
{
assert("semSignal Error" && s && ((s->type == 0) || (s->type == 1)));
int taskId = dequeue(&s->bq);
if (s->type == BINARY)
{
int i;
for (i=0; i<MAX_TASKS; i++) // look for suspended task
{
if (tcb[i].event == s)
{
s->state = 0; // clear semaphore
tcb[i].event = 0; // clear event pointer
tcb[i].state = S_READY; // unblock task
takeout(i, &(s->bq));
enqueue(i, &READY_QUEUE);
if (!superMode) swapTask();
return;
}
}
s->state = 1; // nothing waiting, signal
if (!superMode) swapTask();
return;
}
else if(s->type == COUNTING)
{
s->state = s->state + 1;
if(taskId != -1)
{
tcb[taskId].state = S_READY;
tcb[taskId].event = 0;
enqueue(taskId, &READY_QUEUE);
}
if (!superMode) swapTask();
return;
}
} // end semSignal
