exec.c File Reference

---

Detailed Description

Provides the BeeOS multithreaded time sharing scheduler features.

Definition in file exec.c.

#include "../include/beeos.h"
#include "../include/bstring.h"
#include "../include/bmalloc.h"
#include "../include/exec.h"
#include <stdarg.h>
#include "../include/bprintf.h"
#include "../include/asm/ports.h"
#include "../include/ect.h"

Include dependency graph for exec.c:

Go to the source code of this file.

Defines
#define	IN_EXEC
Functions
void	idle_task (void)
void	task_dumpinfo (regs_t *regs)
task_t *	create_task (void(*func)(void), schar priority, ushort nextrun, ushort stacksize)
	Alloc and init task_t struct with params passed in.
void	unlink_time (task_t *pTask)
	Unlinks pTask from the time list.
void	unlink_prior (task_t *pTask)
	Unlinks pTask from the priority list.
task_t *	find_priority_lte (task_t *pTask, schar priority)
	Find a task with prior <= priority starting \p pTask, walking prior.
task_t *	find_nextrun_lte (task_t *pTask, ushort time)
	Find a task with nextrun <= time starting at pTask, walking time.
void	insert_task_prior (task_t *pPrior, task_t *pTask)
	Insert pTask @ just after pPrior in the prior list.
void	insert_task_time (task_t *pTime, task_t *pTask)
	Insert pTask @ just after pTime in the time list.
__inline__ void	context_save2 (task_t *pTask)
	Save tempregs into pTask for CONTEXT_SAVE macro.
__inline__ void	context_restore2 (task_t *pTask)
	Load tempregs with pTask->regs for CONTEXT_RESTORE macro.
__inline__ slong	now_cmp (ushort a, ushort b, ushort now)
	Handles comparisons between continuously wrapping ushort counters.
__inline__ task_t *	find_imperative_task (task_t *pCurrent)
	Finds task soonest to run, with ->priority > pCurrent->priority.
__inline__ task_t *	find_urgent_task (ushort now)
	Finds the highest priority task that is behind schedule.
ushort	task_select (void)
	Prepares tempregs for isr_exec(), calc's new exec timer alarm.
void	addtask (void(*func)(void), schar priority, ushort nextrun, ushort stacksize)
	Creates & inserts (@ sorted positions) a task into exec task list.
void	bsleep (ushort sleeptime)
	Voluntarily give up CPU time, sleep for sleeptime ms.
void	isr_exec_stuff (void)
	Extra code that wants to be in isr_exec().
void	isr_exec (void)
	BeeOS Real Time task scheduler interrupt service routine (ISR).
void	execprep (void)
	Prepares the global execbase_t exec struct; creates idle task.
void	exec_idle (void)
	isr_exec() can't restore a NULL context if no tasks are scheduled to run, so this is it.
Variables
execbase_t	exec
regs_t	tempregs

---

Define Documentation

#define IN_EXEC

Definition at line 26 of file exec.c.

---

Function Documentation

void addtask (  void(*  func)(void), schar  priority, ushort  nextrun, ushort  stacksize )

Creates & inserts (@ sorted positions) a task into exec task list. After creating & initialising the new task, finds where the task should be inserted into in both the priorty and time exec list. Parameters: func  Function pointer to task being added priority  A signed char value representing a unique priority, determines location in the exec priority list. nextrun  The first time this task should be scheduled to run, determines location in the exec time list. stacksize  The initial stack size for this task. Warning: Does not check for func \== NULL. Also assumes that if exec.head_time is NULL, then so must be exec.head_prior. Definition at line 277 of file exec.c. References create_task(), exec, find_nextrun_lte(), find_priority_lte(), execbase_struct::head_prior, execbase_struct::head_time, insert_task_prior(), insert_task_time(), NULL, execbase_struct::numtasks, schar, task_t, and ushort. { task_t *new_task = create_task(func, priority, nextrun, stacksize); task_t *pPrior, *pTime; if (NULL != exec.head_time) { /* Assume head_time reflects head_prior */ pPrior = find_priority_lte(exec.head_prior, priority); /* NULL state. */ pTime = find_nextrun_lte(exec.head_time, nextrun); } else { pPrior = NULL; pTime = NULL; } insert_task_prior(pPrior, new_task); insert_task_time(pTime, new_task); exec.numtasks++; return; }

Here is the call graph for this function:

void bsleep (  ushort  sleeptime  )

Voluntarily give up CPU time, sleep for sleeptime ms. Unlinks exec.current from the time list, then calculates nextrun using sleeptime. Finds new location in time list and inserts it there. Sets exec.idle, clears exec.blocked, and then invokes isr_exec with an SWI. Parameters: sleeptime  The length of time to sleep for, relative to NOW. sleeptime is approx. millisecond units. Blocking Tasks Does not re-enable exec timer when called by tasks during blocked state; bsleep() clears exec.blocked flag and then invokes isr_exec() using an SWI. isr_exec() will enable the exec timer apon seeing that exec.blocked is false. Definition at line 314 of file exec.c. References ASM_CLI, ASM_SEI, ASM_SWI, execbase_struct::blocked, execbase_struct::current, exec, find_nextrun_lte(), execbase_struct::head_time, execbase_struct::idle, insert_task_time(), MSEC2TCNT, task_struct::nextrun, task_t, TCNT_H, TOUSHORT, unlink_time(), and ushort. Referenced by btnscan_chk(), lbdrv_chg(), and misc(). { task_t *pTime; exec.current->nextrun = TOUSHORT(TCNT_H) + (ushort) MSEC2TCNT(sleeptime); ASM_SEI; /* Don't want other tasks mangling the list in mid-search. */ unlink_time(exec.current); pTime = find_nextrun_lte(exec.head_time, exec.current->nextrun); insert_task_time(pTime, exec.current); ASM_CLI; exec.idle = true; exec.blocked = false; /* If a blocking task just finished, */ /* clear flag so isr_exec() can re-enable exec timer. */ ASM_SWI; /* Trigger an INTR to enter isr_exec() */ return; }

Here is the call graph for this function:

__inline__ void context_restore2 (  task_t *  pTask  )

Load tempregs with pTask->regs for CONTEXT_RESTORE macro. Definition at line 345 of file exec.c. References bmemcpy(), task_struct::regs, task_t, and tempregs. Referenced by task_select(). { bmemcpy((char *)&tempregs, (char *)&(pTask->regs), sizeof(tempregs)); return; }

Here is the call graph for this function:

__inline__ void context_save2 (  task_t *  pTask  )

Save tempregs into pTask for CONTEXT_SAVE macro. Definition at line 335 of file exec.c. References bmemcpy(), task_struct::regs, task_t, and tempregs. Referenced by task_select(). { bmemcpy((char *)&(pTask->regs), (char *)&tempregs, sizeof(tempregs)); return; }

Here is the call graph for this function:

task_t * create_task (  void(*  func)(void), schar  priority, ushort  nextrun, ushort  stacksize )

Alloc and init task_t struct with params passed in. Also sets regs to consecutive values to assist stack debugging. Alloc's task_t struct. Alloc's task_t->stack. Alloc'd stack is zeroed by using bremalloc(). Parameters: func  Function pointer for new task. priority  Unique priority level for the new task. nextrun  The initial nextrun value; can be used to delay execution. stacksize  The number of bytes to allocate for the stack. Return values: pTask  The newly created and initialised task node. next_*, prev_* linked list pointers are NULL. insert_task_*() func's should be used to place pTask in the exec task list, or just call addtask(). Note: Used by addtask(), and also execprep() for exec_idle task. Definition at line 104 of file exec.c. References regs_struct::_d, regs_struct::_tmp, regs_struct::_xy, regs_struct::_z, bremalloc(), regs_struct::CCR, regs_struct::D, task_struct::func, GCC_SOFTREGCOUNT, regs_struct::IX, regs_struct::IY, MSEC2TCNT, task_struct::nextrun, NULL, regs_struct::PC, task_struct::priority, task_struct::regs, schar, regs_struct::SP, task_struct::stack, task_struct::stacksize, task_t, TCNT_H, TOUSHORT, uchar, and ushort. Referenced by addtask(), and execprep(). { uchar i; task_t *pTask = (task_t *) bremalloc(sizeof(task_t), NULL); pTask->func = func; pTask->priority = priority; pTask->nextrun = TOUSHORT(TCNT_H) + (ushort) MSEC2TCNT(nextrun); pTask->stacksize = stacksize; pTask->stack = (char *) bremalloc(stacksize, NULL); pTask->regs.SP = TOUSHORT(pTask->stack) + stacksize; pTask->regs.PC = (ushort) func; pTask->regs.IY = 0x1918; /* Non-zero for stack debugging. */ pTask->regs.IX = 0x1716; pTask->regs.D = 0x1514; pTask->regs.CCR = 0x13; pTask->regs._tmp = 0x12; pTask->regs._z = 0x11; pTask->regs._xy = 0x10; for (i = 0; i < GCC_SOFTREGCOUNT; i++) pTask->regs._d[i] = i; /*bmemset((char *) &(task_ptr->regs), '\0', sizeof(regs_t));*/ return pTask; }

Here is the call graph for this function:

void exec_idle (  void   )

isr_exec() can't restore a NULL context if no tasks are scheduled to run, so this is it. See also: isr_exec, task_select Definition at line 577 of file exec.c. References execbase_struct::activetasks, bprintf(), bputs(), exec, and uchar. Referenced by execprep(). { uchar temp; bputs("exec_idle().\r\n"); while (1 == 1) { if (temp != exec.activetasks) { bprintf(10, "idle: activetasks=%i, was %i.\r\n", exec.activetasks, temp); temp = exec.activetasks; } } return; }

Here is the call graph for this function:

void execprep (  void   )

Prepares the global execbase_t exec struct; creates idle task. MUST be called before isr_exec is first invoked. See also: isr_exec, task_select, add_task Definition at line 561 of file exec.c. References bfree(), bmemset(), create_task(), exec, exec_idle(), execbase_struct::idle_task, and task_struct::stack. { bmemset((char *)&exec, 0, sizeof(exec)); exec.idle_task = create_task (exec_idle, -127, 0, 0); bfree(exec.idle_task->stack); exec.idle_task->stack = (void *)0x3FFF; return; }

Here is the call graph for this function:

__inline__ task_t * find_imperative_task (  task_t *  pCurrent  )

Finds task soonest to run, with ->priority > pCurrent->priority. Walks the time list, working towards exec.tail_time (since the idea is that a task in the future will interrupt pCurrent), starting at pCurrent, comparing priority values with pCurrent->priority as it goes. Parameters: pCurrent  The "current" task in the time list. It's envisaged that this task would almost always match exec.head_time. Return values: pImperative  If no suitable task is found, returns NULL, otherwise it returns the "imperative" task. See also: task_select Definition at line 387 of file exec.c. References task_struct::next_time, NULL, task_struct::priority, and task_t. Referenced by task_select(). { task_t *pImperative = pCurrent; bool searching = true; while ((NULL != pImperative->next_time) && (searching)) { pImperative = pImperative->next_time; if (pImperative->priority > pCurrent->priority) searching = false; } if (!searching) return pImperative; else return NULL; }

task_t * find_nextrun_lte (  task_t *  pTask, ushort  time )

Find a task with nextrun <= time starting at pTask, walking time. Parameters: pTask  The task node at which to start searching time list. time  The time to compare each pTask's ->nextrun with. Return values: pTask  Will == original pTask passed in if search hits the end. Warning: Does not check for pTask == NULL. Definition at line 194 of file exec.c. References task_struct::next_time, task_struct::nextrun, now_cmp(), NULL, task_t, and ushort. Referenced by addtask(), and bsleep(). { bool searching = true; while ( (NULL != pTask->next_time) && (searching) ) { /* if (pTask->nextrun <= time) searching = false; */ if (now_cmp(pTask->nextrun, time, time) <= 0) searching = false; else pTask = pTask->next_time; } return pTask; }

Here is the call graph for this function:

task_t * find_priority_lte (  task_t *  pTask, schar  priority )

Find a task with prior <= priority starting \p pTask, walking prior. Parameters: pTask  The task node at which to start searching prior list. priority  The priority to compare each pTask's ->priority with. Return values: pTask  Will == original pTask passed in if search hits the end. Warning: Does not check for pTask == NULL. Definition at line 175 of file exec.c. References task_struct::next_prior, NULL, task_struct::priority, schar, and task_t. Referenced by addtask(). { bool searching = true; while ( (NULL != pTask->next_prior) && (searching) ) { if (pTask->priority <= priority) searching = false; else pTask = pTask->next_prior; } return pTask; }

__inline__ task_t * find_urgent_task (  ushort  now  )

Finds the highest priority task that is behind schedule. Walks the priority list, starting at exec.head_prior. Stops walking when the first task that is behind schedule relative to now is found. Parameters: now  Current exec timer value used to determine if a task node is behind schedule, according to the ->nextrun values. Return values: pUrgent  If no suitable task is found, returns NULL; otherwise returns the "urgent" pTask. Definition at line 412 of file exec.c. References exec, execbase_struct::head_prior, task_struct::next_prior, task_struct::nextrun, now_cmp(), NULL, task_t, and ushort. Referenced by task_select(). { task_t *pUrgent = exec.head_prior; bool searching = true; while ((NULL != pUrgent->next_prior) && (searching)) { /* if (pUrgent->nextrun <= now) */ if (0 >= now_cmp(pUrgent->nextrun, now, now)) searching = false; else pUrgent = pUrgent->next_prior; } if (!searching) return pUrgent; else return NULL; }

Here is the call graph for this function:

void idle_task (  void   )

void insert_task_prior (  task_t *  pPrior, task_t *  pTask )

Insert pTask @ just after pPrior in the prior list. If pPrior is NULL, assigns exec.head_prior = pTask. If pPrior->next_prior is NULL, assigns exec.tail_prior = pTask. Parameters: pPrior  The task node in the priority list that pTask will be inserted after. pTask  The task node to insert into the priority list. Warning: Does not check for pTask == NULL. Definition at line 217 of file exec.c. References exec, execbase_struct::head_prior, task_struct::next_prior, NULL, task_struct::prev_prior, execbase_struct::tail_prior, and task_t. Referenced by addtask(). { if (NULL == pPrior) { /* Make pTask head_prior. */ pTask->prev_prior = NULL; /* Not necessary, probably already NULL.. */ pTask->next_prior = exec.head_prior; if (NULL != exec.head_prior) exec.head_prior->prev_prior = pTask; exec.head_prior = pTask; } else { if (NULL != pPrior->next_prior) pPrior->next_prior->prev_prior = pTask; else exec.tail_prior = pTask; pTask->next_prior = pPrior->next_prior; pTask->prev_prior = pPrior; pPrior->next_prior = pTask; } return; }

void insert_task_time (  task_t *  pTime, task_t *  pTask )

Insert pTask @ just after pTime in the time list. If pTime is NULL, assigns exec.head_time = pTask. If pTime->next_prior is NULL, assigns exec.tail_time = pTask. Parameters: pTime  The task node in the time list that pTask will be inserted after. pTask  The task node to insert into the time list. Warning: Does not check for pTask == NULL. Definition at line 245 of file exec.c. References exec, execbase_struct::head_time, task_struct::next_time, NULL, task_struct::prev_time, execbase_struct::tail_time, and task_t. Referenced by addtask(), and bsleep(). { if (NULL == pTime) { /* Make pTask head_time. */ pTask->prev_time = NULL; /* Not necessary, probably already NULL.. */ pTask->next_time = exec.head_time; if (NULL != exec.head_time) exec.head_time->prev_time = pTask; exec.head_time = pTask; } else { if (NULL != pTime->next_time) pTime->next_time->prev_time = pTask; else exec.tail_time = pTask; pTask->next_time = pTime->next_time; pTask->prev_time = pTime; pTime->next_time = pTask; } return; }

void isr_exec (  void   )

BeeOS Real Time task scheduler interrupt service routine (ISR). 1. Block interrupts 2. Save context 3. Prep new context 4. Set exec timer 5. Restore new context 6. Enable interrupts Note: See notes in isr_exec_stuff() regarding the proper place to add code. See also: task_select, isr_exec_stuff Definition at line 541 of file exec.c. References ASM_CLI, ASM_SEI, isr_exec_stuff(), task_select(), TC7_H, and TOUSHORT. { ASM_SEI; CONTEXT_SAVE(); /* MUST be as close as possible to start; preserve stack/regs */ TOUSHORT(TC7_H) = task_select(); /* Get new task, set isr_exec timer TC7. */ isr_exec_stuff(); /* Extra code should go in this func; lest GCC dare use * _d0.._dn softregisters and invalidate CONTEXT_RESTORE/CONTEXT_SAVE. */ CONTEXT_RESTORE(); /* As close as possible to end; preserve stack/regs */ ASM_CLI; return; }

Here is the call graph for this function:

void isr_exec_stuff (  void   )

Extra code that wants to be in isr_exec(). Extra code that wants to be in isr_exec() should live in here, so that GCC doesn't try to push extra softregs on entry of isr_exec(). Note: Exec timer is TC7. TCNT prescaler is set to max. (128). See also: isr_exec Definition at line 520 of file exec.c. References BIT7, execbase_struct::blocked, ECT_TOF, exec, PORTA, TFLG1, TFLG2, and TIE. Referenced by isr_exec(). { TFLG1 |= BIT7; /* Clear TC7 interrupt */ if (TFLG2 & ~ECT_TOF) TFLG2 |= ECT_TOF; /* Clear overflow flag if set */ if (exec.blocked) TIE &= ~BIT7; /* If current task is not to be interrupted, */ /* disable exec timer. Only an SWI from bsleep() can invoke exec. */ else TIE |= BIT7; /* Else re-enable exec timer. */ PORTA ^= 0x01; /* ... "debug" output */ return; }

__inline__ slong now_cmp (  ushort  a, ushort  b, ushort  now )

Handles comparisons between continuously wrapping ushort counters. Compares two ushorts that may have wrapped. Uses now for a reference point; numbers less than now are considered as being in the future, IE. of greater value than numbers more than now. Parameters: a  Counter value a b  Counter value b now  Reference counter value Return values: (A-B)  Essentially returns a - b. Definition at line 363 of file exec.c. References slong, and ushort. Referenced by find_nextrun_lte(), find_urgent_task(), and task_select(). { slong A = (slong) a, B = (slong) b; if (a < now) A += (slong) 65535; if (b < now) B += (slong) 65535; return A - B; }

void task_dumpinfo (  regs_t *  regs  )

Definition at line 65 of file exec.c. References regs_struct::_d, regs_struct::_tmp, regs_struct::_xy, regs_struct::_z, bprintf(), bputs(), regs_struct::CCR, regs_struct::D, regs_struct::IX, regs_struct::IY, regs_struct::PC, regs_t, and regs_struct::SP. { bputs("taskdump:\r\n"); /*bprintf(10, " nextrun: %x.\r\n", (sshort) pTask->nextrun); bprintf(10, " stacksize: %x.\r\n", (sshort) pTask->stacksize); bprintf(10, " func: %x.\r\n", (sshort) pTask->func); bprintf(10, " stack: %x.\r\n", (sshort) pTask->stack); bprintf(10, " priority: %x.\r\n", (sshort) pTask->priority);*/ bprintf(10, " SP: %x.\r\n", regs->SP); bprintf(10, " pc: %x.\r\n", regs->PC); bprintf(10, " iy: %x.\r\n", regs->IY); bprintf(10, " ix: %x.\r\n", regs->IX); bprintf(10, " d: %x.\r\n", regs->D); bprintf(10, " _ccr: %x.\r\n", regs->CCR); bprintf(10, " _tmp: %x.\r\n", regs->_tmp); bprintf(10, " _z: %x.\r\n", regs->_z); bprintf(10, " _xy: %x.\r\n", regs->_xy); bprintf(10, " _d1: %x.\r\n", regs->_d[0]); bprintf(10, " _d2: %x.\r\n", regs->_d[1]); return; }

Here is the call graph for this function:

ushort task_select (  void   )

Prepares tempregs for isr_exec(), calc's new exec timer alarm. Returns the timer value that will trigger the next isr_exec() INTR Sets up the tempregs global context struct for isr_exec() to restore. Scheduler description The BeeOS scheduler uses a Real Time philiosphy. isr_exec() is never invoked if it doesn't need to be; there is no fixed time slice or quantum. This scheduler keeps task nodes in two doubly-linked lists. One list is sorted by time, with the next task wanting to be run at the head of the queue. The other is sorted by priority, with the highest priority task at the head of the queue. When deciding which task should next be run, task_select() will try to choose the task at the head of the time list (if its time is now), and set the isr_exec() timer "alarm" to trigger for the next task in the time list. However, if things are behind schedule, task_select() will always use the highest priority task that is behind schedule. Tasks are re-positioned in the time list when they call bsleep(). If the highest priority task never calls bsleep(), it will never be interrupted for a lower priority task and no other tasks will run. bsleep() is useful for making use of delay periods. Note: It seems that the task/priority lists only have to be single linked lists. Will fix later. Doesn't bother modifying tempregs if the context to be restored was already loaded. Problem: TCNT timer wraps too fast, max. < 1 sec delays? Return values: nextswitch  New exec timer value to trigger next interrupt. If the highest priority task is already running, sets exec.blocked, which causes isr_exec() to disable the exec timer. This prevents isr_exec() being invoked until the current task is finished; task_select() then returns zero. isr_exec() can only then be invoked by a bsleep() call. See also: isr_exec, bsleep, addtask Definition at line 472 of file exec.c. References execbase_struct::activetasks, execbase_struct::blocked, context_restore2(), context_save2(), execbase_struct::current, exec, find_imperative_task(), find_urgent_task(), execbase_struct::head_time, execbase_struct::idle, execbase_struct::idle_task, task_struct::next_time, task_struct::nextrun, now_cmp(), NULL, task_struct::sleeping, task_t, TCNT_H, TOUSHORT, and ushort. Referenced by isr_exec(). { ushort now = TOUSHORT(TCNT_H); /* Need to substitute for slower timer... */ ushort nextswitch = 0; /* Return value */ task_t *lastrun = exec.current; /* Used to check if tempregs needs update */ task_t *pImperative = NULL; /* Task that needs to intr current task */ exec.current = exec.head_time; /* Head of time list, ie. soonest to run. */ /* if (exec.current->nextrun <= now) */ /* Is a task scheduled */ if (now_cmp(exec.current->nextrun, now, now) <= 0) { /* right now? */ /* Initially, exec.current is simply head_time. */ /* if (exec.current->next_time->nextrun <= now) {*/ /* Behind schedule? */ if (now_cmp(exec.current->next_time->nextrun, now, now) <= 0) { /* Here, at least first two tasks @ head_time are behind schedule; */ /* head_time is ignored and instead the highest priority, behind */ /* schedule task shall become the current task. */ exec.current = find_urgent_task(now); } /* Now find out which task should interrupt the new current task */ pImperative = find_imperative_task(exec.current); /* Poss. NULL */ if (NULL != pImperative) nextswitch = pImperative->nextrun; else exec.blocked = true; /* Inhibit exec timer; highest pri. run */ if (exec.current != lastrun) { /* Don't bother saving/loading context */ context_save2(lastrun); /* if current was already loaded */ context_restore2(exec.current); if (false != exec.current->sleeping) { exec.current->sleeping = false; exec.activetasks++; } } exec.idle = false; /* Purpose unclear ... should reflect activetasks */ } else { /* This is now idle time; just set the alarm for head_time. */ nextswitch = exec.current->nextrun; exec.idle = true; /* Not sure what this does yet... */ context_restore2(exec.idle_task); } return nextswitch; }

Here is the call graph for this function:

void unlink_prior (  task_t *  pTask  )

Unlinks pTask from the priority list. Parameters: pTask  The task to unlink; it becomes orphaned from the priority list. Warning: Does not check for pTask == NULL. Definition at line 153 of file exec.c. References exec, execbase_struct::head_prior, task_struct::next_prior, NULL, task_struct::prev_prior, execbase_struct::tail_prior, and task_t. { /* If pTask was the head task, reassign exec.head_prior. */ if (NULL == pTask->prev_prior) exec.head_prior = pTask->next_prior; else pTask->prev_prior->next_prior = pTask->next_prior; /* If pTask was the tail task, reassign exec.tail_time. */ if (NULL == pTask->next_prior) exec.tail_prior = pTask->prev_prior; else pTask->next_prior->prev_prior = pTask->prev_prior; pTask->prev_prior = NULL; pTask->next_prior = NULL; return; }

void unlink_time (  task_t *  pTask  )

Unlinks pTask from the time list. Parameters: pTask  The task to unlink; it becomes orphaned from the time list. Warning: Does not check for pTask == NULL. Definition at line 134 of file exec.c. References exec, execbase_struct::head_time, task_struct::next_time, NULL, task_struct::prev_time, execbase_struct::tail_time, and task_t. Referenced by bsleep(). { /* If pTask was the head task, reassign exec.head_time. */ if (NULL == pTask->prev_time) exec.head_time = pTask->next_time; else pTask->prev_time->next_time = pTask->next_time; /* If pTask was the tail task, reassign exec.tail_time. */ if (NULL == pTask->next_time) exec.tail_time = pTask->prev_time; else pTask->next_time->prev_time = pTask->prev_time; pTask->prev_time = NULL; pTask->next_time = NULL; return; }

---

Variable Documentation

execbase_t exec

Definition at line 38 of file exec.c. Referenced by addtask(), bsleep(), exec_idle(), execprep(), find_urgent_task(), insert_task_prior(), insert_task_time(), isr_exec_stuff(), task_select(), unlink_prior(), and unlink_time().

regs_t tempregs

Definition at line 39 of file exec.c. Referenced by context_restore2(), and context_save2().

---