summaryrefslogtreecommitdiff
path: root/kernel/old/procs.c
diff options
context:
space:
mode:
Diffstat (limited to 'kernel/old/procs.c')
-rw-r--r--kernel/old/procs.c524
1 files changed, 272 insertions, 252 deletions
diff --git a/kernel/old/procs.c b/kernel/old/procs.c
index 82c4c98..96bb3fd 100644
--- a/kernel/old/procs.c
+++ b/kernel/old/procs.c
@@ -6,7 +6,7 @@
** @brief Process-related implementations
*/
-#define KERNEL_SRC
+#define KERNEL_SRC
#include <common.h>
@@ -18,7 +18,7 @@
*/
// determine if a queue is empty; assumes 'q' is a valid pointer
-#define PCB_QUEUE_EMPTY(q) ((q)->head == NULL)
+#define PCB_QUEUE_EMPTY(q) ((q)->head == NULL)
/*
** PRIVATE DATA TYPES
@@ -74,29 +74,33 @@ uint_t next_pid;
pcb_t *init_pcb;
// table of state name strings
-const char state_str[N_STATES][4] = {
- [STATE_UNUSED] = "Unu", // "Unused"
- [STATE_NEW] = "New",
- [STATE_READY] = "Rdy", // "Ready"
- [STATE_RUNNING] = "Run", // "Running"
- [STATE_SLEEPING] = "Slp", // "Sleeping"
- [STATE_BLOCKED] = "Blk", // "Blocked"
- [STATE_WAITING] = "Wat", // "Waiting"
- [STATE_KILLED] = "Kil", // "Killed"
- [STATE_ZOMBIE] = "Zom" // "Zombie"
+const char *state_str[N_STATES] = {
+ [ STATE_UNUSED ] = "Unu", // "Unused"
+ [ STATE_NEW ] = "New",
+ [ STATE_READY ] = "Rdy", // "Ready"
+ [ STATE_RUNNING ] = "Run", // "Running"
+ [ STATE_SLEEPING ] = "Slp", // "Sleeping"
+ [ STATE_BLOCKED ] = "Blk", // "Blocked"
+ [ STATE_WAITING ] = "Wat", // "Waiting"
+ [ STATE_KILLED ] = "Kil", // "Killed"
+ [ STATE_ZOMBIE ] = "Zom" // "Zombie"
};
// table of priority name strings
-const char prio_str[N_PRIOS][5] = { [PRIO_HIGH] = "High",
- [PRIO_STD] = "User",
- [PRIO_LOW] = "Low ",
- [PRIO_DEFERRED] = "Def " };
+const char *prio_str[N_PRIOS] = {
+ [ PRIO_HIGH ] = "High",
+ [ PRIO_STD ] = "User",
+ [ PRIO_LOW ] = "Low ",
+ [ PRIO_DEFERRED ] = "Def "
+};
// table of queue ordering name strings
-const char ord_str[N_PRIOS][5] = { [O_FIFO] = "FIFO",
- [O_PRIO] = "PRIO",
- [O_PID] = "PID ",
- [O_WAKEUP] = "WAKE" };
+const char *ord_str[N_PRIOS] = {
+ [ O_FIFO ] = "FIFO",
+ [ O_PRIO ] = "PRIO",
+ [ O_PID ] = "PID ",
+ [ O_WAKEUP ] = "WAKE"
+};
/*
** PRIVATE FUNCTIONS
@@ -121,16 +125,16 @@ const char ord_str[N_PRIOS][5] = { [O_FIFO] = "FIFO",
** @return a pointer to the predecessor in the queue, or NULL if
** this PCB would be at the beginning of the queue.
*/
-static pcb_t *find_prev_wakeup(pcb_queue_t queue, pcb_t *pcb)
-{
+static pcb_t *find_prev_wakeup( pcb_queue_t queue, pcb_t *pcb ) {
+
// sanity checks!
- assert1(queue != NULL);
- assert1(pcb != NULL);
+ assert1( queue != NULL );
+ assert1( pcb != NULL );
pcb_t *prev = NULL;
pcb_t *curr = queue->head;
- while (curr != NULL && curr->wakeup <= pcb->wakeup) {
+ while( curr != NULL && curr->wakeup <= pcb->wakeup ) {
prev = curr;
curr = curr->next;
}
@@ -138,16 +142,16 @@ static pcb_t *find_prev_wakeup(pcb_queue_t queue, pcb_t *pcb)
return prev;
}
-static pcb_t *find_prev_priority(pcb_queue_t queue, pcb_t *pcb)
-{
+static pcb_t *find_prev_priority( pcb_queue_t queue, pcb_t *pcb ) {
+
// sanity checks!
- assert1(queue != NULL);
- assert1(pcb != NULL);
+ assert1( queue != NULL );
+ assert1( pcb != NULL );
pcb_t *prev = NULL;
pcb_t *curr = queue->head;
- while (curr != NULL && curr->priority <= pcb->priority) {
+ while( curr != NULL && curr->priority <= pcb->priority ) {
prev = curr;
curr = curr->next;
}
@@ -155,16 +159,16 @@ static pcb_t *find_prev_priority(pcb_queue_t queue, pcb_t *pcb)
return prev;
}
-static pcb_t *find_prev_pid(pcb_queue_t queue, pcb_t *pcb)
-{
+static pcb_t *find_prev_pid( pcb_queue_t queue, pcb_t *pcb ) {
+
// sanity checks!
- assert1(queue != NULL);
- assert1(pcb != NULL);
+ assert1( queue != NULL );
+ assert1( pcb != NULL );
pcb_t *prev = NULL;
pcb_t *curr = queue->head;
- while (curr != NULL && curr->pid <= pcb->pid) {
+ while( curr != NULL && curr->pid <= pcb->pid ) {
prev = curr;
curr = curr->next;
}
@@ -177,10 +181,10 @@ static pcb_t *find_prev_pid(pcb_queue_t queue, pcb_t *pcb)
*/
// a macro to simplify queue setup
-#define QINIT(q, s) \
- q = &q##_queue; \
- if (pcb_queue_reset(q, s) != SUCCESS) { \
- PANIC(0, "pcb_init can't reset " #q); \
+#define QINIT(q,s) \
+ q = &q##_queue; \
+ if( pcb_queue_reset(q,s) != SUCCESS ) { \
+ PANIC( 0, "pcb_init can't reset " # q ); \
}
/**
@@ -188,22 +192,22 @@ static pcb_t *find_prev_pid(pcb_queue_t queue, pcb_t *pcb)
**
** Initialization for the Process module.
*/
-void pcb_init(void)
-{
+void pcb_init( void ) {
+
#if TRACING_INIT
- cio_puts(" Procs");
+ cio_puts( " Procs" );
#endif
// there is no current process
current = NULL;
// set up the external links to the queues
- QINIT(pcb_freelist, O_FIFO);
- QINIT(ready, O_PRIO);
- QINIT(waiting, O_PID);
- QINIT(sleeping, O_WAKEUP);
- QINIT(zombie, O_PID);
- QINIT(sioread, O_FIFO);
+ QINIT( pcb_freelist, O_FIFO );
+ QINIT( ready, O_PRIO );
+ QINIT( waiting, O_PID );
+ QINIT( sleeping, O_WAKEUP );
+ QINIT( zombie, O_PID );
+ QINIT( sioread, O_FIFO );
/*
** We statically allocate our PCBs, so we need to add them
@@ -214,8 +218,8 @@ void pcb_init(void)
*/
pcb_t *ptr = ptable;
- for (int i = 0; i < N_PROCS; ++i) {
- pcb_free(ptr);
+ for( int i = 0; i < N_PROCS; ++i ) {
+ pcb_free( ptr );
++ptr;
}
}
@@ -229,14 +233,14 @@ void pcb_init(void)
**
** @return status of the allocation attempt
*/
-int pcb_alloc(pcb_t **pcb)
-{
+int pcb_alloc( pcb_t **pcb ) {
+
// sanity check!
- assert1(pcb != NULL);
+ assert1( pcb != NULL );
// remove the first PCB from the free list
pcb_t *tmp;
- if (pcb_queue_remove(pcb_freelist, &tmp) != SUCCESS) {
+ if( pcb_queue_remove(pcb_freelist,&tmp) != SUCCESS ) {
return E_NO_PCBS;
}
@@ -251,19 +255,20 @@ int pcb_alloc(pcb_t **pcb)
**
** @param pcb Pointer to the PCB to be deallocated.
*/
-void pcb_free(pcb_t *pcb)
-{
- if (pcb != NULL) {
+void pcb_free( pcb_t *pcb ) {
+
+ if( pcb != NULL ) {
// mark the PCB as available
pcb->state = STATE_UNUSED;
// add it to the free list
- int status = pcb_queue_insert(pcb_freelist, pcb);
+ int status = pcb_queue_insert( pcb_freelist, pcb );
// if that failed, we're in trouble
- if (status != SUCCESS) {
- sprint(b256, "pcb_free(0x%08x) status %d", (uint32_t)pcb, status);
- PANIC(0, b256);
+ if( status != SUCCESS ) {
+ sprint( b256, "pcb_free(0x%08x) status %d", (uint32_t) pcb,
+ status );
+ PANIC( 0, b256 );
}
}
}
@@ -277,15 +282,15 @@ void pcb_free(pcb_t *pcb)
**
** @param pcb Pointer to the newly-undead PCB
*/
-void pcb_zombify(register pcb_t *victim)
-{
+void pcb_zombify( register pcb_t *victim ) {
+
// should this be an error?
- if (victim == NULL) {
+ if( victim == NULL ) {
return;
}
// every process must have a parent, even if it's 'init'
- assert(victim->parent != NULL);
+ assert( victim->parent != NULL );
/*
** We need to locate the parent of this process. We also need
@@ -301,24 +306,26 @@ void pcb_zombify(register pcb_t *victim)
// speed up access to the process table entries
register pcb_t *curr = ptable;
- for (int i = 0; i < N_PROCS; ++i, ++curr) {
+ for( int i = 0; i < N_PROCS; ++i, ++curr ) {
+
// make sure this is a valid entry
- if (curr->state == STATE_UNUSED) {
+ if( curr->state == STATE_UNUSED ) {
continue;
}
// if this is our parent, just keep going - we continue
// iterating to find all the children of this process.
- if (curr == parent) {
+ if( curr == parent ) {
continue;
}
- if (curr->parent == victim) {
+ if( curr->parent == victim ) {
+
// found a child - reparent it
curr->parent = init_pcb;
// see if this child is already undead
- if (curr->state == STATE_ZOMBIE) {
+ if( curr->state == STATE_ZOMBIE ) {
// if it's already a zombie, remember it, so we
// can pass it on to 'init'; also, if there are
// two or more zombie children, it doesn't matter
@@ -326,6 +333,7 @@ void pcb_zombify(register pcb_t *victim)
// collected when 'init' loops
zchild = curr;
}
+
}
}
@@ -339,25 +347,26 @@ void pcb_zombify(register pcb_t *victim)
**
** Also note: it's possible that the exiting process' parent is
** also init, which means we're letting one of zombie children
- ** of the exiting process be cleaned up by init before the
+ ** of the exiting process be cleaned up by init before the
** existing process itself is cleaned up by init. This will work,
** because after init cleans up the zombie, it will loop and
** call waitpid() again, by which time this exiting process will
** be marked as a zombie.
*/
- if (zchild != NULL && init_pcb->state == STATE_WAITING) {
+ if( zchild != NULL && init_pcb->state == STATE_WAITING ) {
+
// dequeue the zombie
- assert(pcb_queue_remove_this(zombie, zchild) == SUCCESS);
+ assert( pcb_queue_remove_this(zombie,zchild) == SUCCESS );
- assert(pcb_queue_remove_this(waiting, init_pcb) == SUCCESS);
+ assert( pcb_queue_remove_this(waiting,init_pcb) == SUCCESS );
// intrinsic return value is the PID
RET(init_pcb) = zchild->pid;
// may also want to return the exit status
- int32_t *ptr = (int32_t *)ARG(init_pcb, 2);
+ int32_t *ptr = (int32_t *) ARG(init_pcb,2);
- if (ptr != NULL) {
+ if( ptr != NULL ) {
// ********************************************************
// ** Potential VM issue here! This code assigns the exit
// ** status into a variable in the parent's address space.
@@ -370,8 +379,8 @@ void pcb_zombify(register pcb_t *victim)
}
// all done - schedule 'init', and clean up the zombie
- schedule(init_pcb);
- pcb_cleanup(zchild);
+ schedule( init_pcb );
+ pcb_cleanup( zchild );
}
/*
@@ -385,12 +394,14 @@ void pcb_zombify(register pcb_t *victim)
** worry about it being scheduled twice.
*/
- if (parent->state == STATE_WAITING) {
+ if( parent->state == STATE_WAITING ) {
+
// verify that the parent is either waiting for this process
// or is waiting for any of its children
- uint32_t target = ARG(parent, 1);
+ uint32_t target = ARG(parent,1);
+
+ if( target == 0 || target == vicpid ) {
- if (target == 0 || target == vicpid) {
// the parent is waiting for this child or is waiting
// for any of its children, so we can wake it up.
@@ -398,9 +409,9 @@ void pcb_zombify(register pcb_t *victim)
RET(parent) = vicpid;
// may also want to return the exit status
- int32_t *ptr = (int32_t *)ARG(parent, 2);
+ int32_t *ptr = (int32_t *) ARG(parent,2);
- if (ptr != NULL) {
+ if( ptr != NULL ) {
// ********************************************************
// ** Potential VM issue here! This code assigns the exit
// ** status into a variable in the parent's address space.
@@ -413,8 +424,8 @@ void pcb_zombify(register pcb_t *victim)
}
// all done - schedule the parent, and clean up the zombie
- schedule(parent);
- pcb_cleanup(victim);
+ schedule( parent );
+ pcb_cleanup( victim );
return;
}
@@ -432,7 +443,7 @@ void pcb_zombify(register pcb_t *victim)
*/
victim->state = STATE_ZOMBIE;
- assert(pcb_queue_insert(zombie, victim) == SUCCESS);
+ assert( pcb_queue_insert(zombie,victim) == SUCCESS );
/*
** Note: we don't call _dispatch() here - we leave that for
@@ -448,23 +459,23 @@ void pcb_zombify(register pcb_t *victim)
**
** @param pcb The PCB to reclaim
*/
-void pcb_cleanup(pcb_t *pcb)
-{
+void pcb_cleanup( pcb_t *pcb ) {
+
#if TRACING_PCB
- cio_printf("** pcb_cleanup(0x%08x)\n", (uint32_t)pcb);
+ cio_printf( "** pcb_cleanup(0x%08x)\n", (uint32_t) pcb );
#endif
// avoid deallocating a NULL pointer
- if (pcb == NULL) {
+ if( pcb == NULL ) {
// should this be an error?
return;
}
// we need to release all the VM data structures and frames
- user_cleanup(pcb);
+ user_cleanup( pcb );
// release the PCB itself
- pcb_free(pcb);
+ pcb_free( pcb );
}
/**
@@ -476,18 +487,18 @@ void pcb_cleanup(pcb_t *pcb)
**
** @return Pointer to the PCB, or NULL
*/
-pcb_t *pcb_find_pid(uint_t pid)
-{
+pcb_t *pcb_find_pid( uint_t pid ) {
+
// must be a valid PID
- if (pid < 1) {
+ if( pid < 1 ) {
return NULL;
}
// scan the process table
pcb_t *p = ptable;
- for (int i = 0; i < N_PROCS; ++i, ++p) {
- if (p->pid == pid && p->state != STATE_UNUSED) {
+ for( int i = 0; i < N_PROCS; ++i, ++p ) {
+ if( p->pid == pid && p->state != STATE_UNUSED ) {
return p;
}
}
@@ -505,19 +516,19 @@ pcb_t *pcb_find_pid(uint_t pid)
**
** @return Pointer to the PCB, or NULL
*/
-pcb_t *pcb_find_ppid(uint_t pid)
-{
+pcb_t *pcb_find_ppid( uint_t pid ) {
+
// must be a valid PID
- if (pid < 1) {
+ if( pid < 1 ) {
return NULL;
}
// scan the process table
pcb_t *p = ptable;
- for (int i = 0; i < N_PROCS; ++i, ++p) {
- assert1(p->parent != NULL);
- if (p->parent->pid == pid && p->parent->state != STATE_UNUSED) {
+ for( int i = 0; i < N_PROCS; ++i, ++p ) {
+ assert1( p->parent != NULL );
+ if( p->parent->pid == pid && p->parent->state != STATE_UNUSED ) {
return p;
}
}
@@ -537,13 +548,13 @@ pcb_t *pcb_find_ppid(uint_t pid)
**
** @return status of the init request
*/
-int pcb_queue_reset(pcb_queue_t queue, enum pcb_queue_order_e style)
-{
+int pcb_queue_reset( pcb_queue_t queue, enum pcb_queue_order_e style ) {
+
// sanity check
- assert1(queue != NULL);
+ assert1( queue != NULL );
// make sure the style is valid
- if (style < O_FIRST_STYLE || style > O_LAST_STYLE) {
+ if( style < O_FIRST_STYLE || style > O_LAST_STYLE ) {
return E_BAD_PARAM;
}
@@ -564,10 +575,10 @@ int pcb_queue_reset(pcb_queue_t queue, enum pcb_queue_order_e style)
**
** @return true if the queue is empty, else false
*/
-bool_t pcb_queue_empty(pcb_queue_t queue)
-{
+bool_t pcb_queue_empty( pcb_queue_t queue ) {
+
// if there is no queue, blow up
- assert1(queue != NULL);
+ assert1( queue != NULL );
return PCB_QUEUE_EMPTY(queue);
}
@@ -581,16 +592,16 @@ bool_t pcb_queue_empty(pcb_queue_t queue)
**
** @return the count (0 if the queue is empty)
*/
-uint_t pcb_queue_length(const pcb_queue_t queue)
-{
+uint_t pcb_queue_length( const pcb_queue_t queue ) {
+
// sanity check
- assert1(queue != NULL);
+ assert1( queue != NULL );
// this is pretty simple
register pcb_t *tmp = queue->head;
register int num = 0;
-
- while (tmp != NULL) {
+
+ while( tmp != NULL ) {
++num;
tmp = tmp->next;
}
@@ -608,41 +619,41 @@ uint_t pcb_queue_length(const pcb_queue_t queue)
**
** @return status of the insertion request
*/
-int pcb_queue_insert(pcb_queue_t queue, pcb_t *pcb)
-{
+int pcb_queue_insert( pcb_queue_t queue, pcb_t *pcb ) {
+
// sanity checks
- assert1(queue != NULL);
- assert1(pcb != NULL);
+ assert1( queue != NULL );
+ assert1( pcb != NULL );
// if this PCB is already in a queue, we won't touch it
- if (pcb->next != NULL) {
+ if( pcb->next != NULL ) {
// what to do? we let the caller decide
return E_BAD_PARAM;
}
// is the queue empty?
- if (queue->head == NULL) {
+ if( queue->head == NULL ) {
queue->head = queue->tail = pcb;
return SUCCESS;
}
- assert1(queue->tail != NULL);
+ assert1( queue->tail != NULL );
// no, so we need to search it
pcb_t *prev = NULL;
// find the predecessor node
- switch (queue->order) {
+ switch( queue->order ) {
case O_FIFO:
prev = queue->tail;
break;
case O_PRIO:
- prev = find_prev_priority(queue, pcb);
+ prev = find_prev_priority(queue,pcb);
break;
case O_PID:
- prev = find_prev_pid(queue, pcb);
+ prev = find_prev_pid(queue,pcb);
break;
case O_WAKEUP:
- prev = find_prev_wakeup(queue, pcb);
+ prev = find_prev_wakeup(queue,pcb);
break;
default:
// do we need something more specific here?
@@ -651,25 +662,29 @@ int pcb_queue_insert(pcb_queue_t queue, pcb_t *pcb)
// OK, we found the predecessor node; time to do the insertion
- if (prev == NULL) {
+ if( prev == NULL ) {
+
// there is no predecessor, so we're
// inserting at the front of the queue
pcb->next = queue->head;
- if (queue->head == NULL) {
+ if( queue->head == NULL ) {
// empty queue!?! - should we panic?
queue->tail = pcb;
}
queue->head = pcb;
- } else if (prev->next == NULL) {
+ } else if( prev->next == NULL ) {
+
// append at end
prev->next = pcb;
queue->tail = pcb;
} else {
+
// insert between prev & prev->next
pcb->next = prev->next;
prev->next = pcb;
+
}
return SUCCESS;
@@ -685,14 +700,14 @@ int pcb_queue_insert(pcb_queue_t queue, pcb_t *pcb)
**
** @return status of the removal request
*/
-int pcb_queue_remove(pcb_queue_t queue, pcb_t **pcb)
-{
+int pcb_queue_remove( pcb_queue_t queue, pcb_t **pcb ) {
+
//sanity checks
- assert1(queue != NULL);
- assert1(pcb != NULL);
+ assert1( queue != NULL );
+ assert1( pcb != NULL );
// can't get anything if there's nothing to get!
- if (PCB_QUEUE_EMPTY(queue)) {
+ if( PCB_QUEUE_EMPTY(queue) ) {
return E_EMPTY_QUEUE;
}
@@ -704,7 +719,7 @@ int pcb_queue_remove(pcb_queue_t queue, pcb_t **pcb)
tmp->next = NULL;
// was this the last thing in the queue?
- if (queue->head == NULL) {
+ if( queue->head == NULL ) {
// yes, so clear the tail pointer for consistency
queue->tail = NULL;
}
@@ -729,14 +744,14 @@ int pcb_queue_remove(pcb_queue_t queue, pcb_t **pcb)
**
** @return status of the removal request
*/
-int pcb_queue_remove_this(pcb_queue_t queue, pcb_t *pcb)
-{
+int pcb_queue_remove_this( pcb_queue_t queue, pcb_t *pcb ) {
+
//sanity checks
- assert1(queue != NULL);
- assert1(pcb != NULL);
+ assert1( queue != NULL );
+ assert1( pcb != NULL );
// can't get anything if there's nothing to get!
- if (PCB_QUEUE_EMPTY(queue)) {
+ if( PCB_QUEUE_EMPTY(queue) ) {
return E_EMPTY_QUEUE;
}
@@ -744,7 +759,7 @@ int pcb_queue_remove_this(pcb_queue_t queue, pcb_t *pcb)
pcb_t *prev = NULL;
pcb_t *curr = queue->head;
- while (curr != NULL && curr != pcb) {
+ while( curr != NULL && curr != pcb ) {
prev = curr;
curr = curr->next;
}
@@ -758,15 +773,15 @@ int pcb_queue_remove_this(pcb_queue_t queue, pcb_t *pcb)
// 5. !0 !0 0 removing from end
// 6. !0 !0 !0 removing from middle
- if (curr == NULL) {
+ if( curr == NULL ) {
// case 1
- assert(prev != NULL);
+ assert( prev != NULL );
// case 4
return E_NOT_FOUND;
}
// connect predecessor to successor
- if (prev != NULL) {
+ if( prev != NULL ) {
// not the first element
// cases 5 and 6
prev->next = curr->next;
@@ -778,7 +793,7 @@ int pcb_queue_remove_this(pcb_queue_t queue, pcb_t *pcb)
// if this was the last node (cases 2 and 5),
// also need to reset the tail pointer
- if (curr->next == NULL) {
+ if( curr->next == NULL ) {
// if this was the only entry (2), prev is NULL,
// so this works for that case, too
queue->tail = prev;
@@ -791,8 +806,10 @@ int pcb_queue_remove_this(pcb_queue_t queue, pcb_t *pcb)
// one of the queue pointers is NULL and the other one
// is not NULL
- assert1((queue->head == NULL && queue->tail == NULL) ||
- (queue->head != NULL && queue->tail != NULL));
+ assert1(
+ (queue->head == NULL && queue->tail == NULL) ||
+ (queue->head != NULL && queue->tail != NULL)
+ );
return SUCCESS;
}
@@ -807,13 +824,13 @@ int pcb_queue_remove_this(pcb_queue_t queue, pcb_t *pcb)
**
** @return the PCB poiner, or NULL if the queue is empty
*/
-pcb_t *pcb_queue_peek(const pcb_queue_t queue)
-{
+pcb_t *pcb_queue_peek( const pcb_queue_t queue ) {
+
//sanity check
- assert1(queue != NULL);
+ assert1( queue != NULL );
// can't get anything if there's nothing to get!
- if (PCB_QUEUE_EMPTY(queue)) {
+ if( PCB_QUEUE_EMPTY(queue) ) {
return NULL;
}
@@ -832,13 +849,13 @@ pcb_t *pcb_queue_peek(const pcb_queue_t queue)
**
** @param pcb Pointer to the PCB of the process to be scheduled
*/
-void schedule(pcb_t *pcb)
-{
+void schedule( pcb_t *pcb ) {
+
// sanity check
- assert1(pcb != NULL);
+ assert1( pcb != NULL );
// check for a killed process
- if (pcb->state == STATE_KILLED) {
+ if( pcb->state == STATE_KILLED ) {
// TODO figure out what to do now
return;
}
@@ -847,8 +864,8 @@ void schedule(pcb_t *pcb)
pcb->state = STATE_READY;
// add it to the ready queue
- if (pcb_queue_insert(ready, pcb) != SUCCESS) {
- PANIC(0, "schedule insert fail");
+ if( pcb_queue_insert(ready,pcb) != SUCCESS ) {
+ PANIC( 0, "schedule insert fail" );
}
}
@@ -857,16 +874,16 @@ void schedule(pcb_t *pcb)
**
** Select the next process to receive the CPU
*/
-void dispatch(void)
-{
+void dispatch( void ) {
+
// verify that there is no current process
- assert(current == NULL);
+ assert( current == NULL );
// grab whoever is at the head of the queue
- int status = pcb_queue_remove(ready, &current);
- if (status != SUCCESS) {
- sprint(b256, "dispatch queue remove failed, code %d", status);
- PANIC(0, b256);
+ int status = pcb_queue_remove( ready, &current );
+ if( status != SUCCESS ) {
+ sprint( b256, "dispatch queue remove failed, code %d", status );
+ PANIC( 0, b256 );
}
// set the process up for success
@@ -874,6 +891,7 @@ void dispatch(void)
current->ticks = QUANTUM_STANDARD;
}
+
/*
** Debugging/tracing routines
*/
@@ -886,32 +904,32 @@ void dispatch(void)
** @param msg[in] An optional message to print before the dump
** @param c[in] The context to dump out
*/
-void ctx_dump(const char *msg, register context_t *c)
-{
+void ctx_dump( const char *msg, register context_t *c ) {
+
// first, the message (if there is one)
- if (msg) {
- cio_puts(msg);
+ if( msg ) {
+ cio_puts( msg );
}
// the pointer
- cio_printf(" @ %08x: ", (uint32_t)c);
+ cio_printf( " @ %08x: ", (uint32_t) c );
// if it's NULL, why did you bother calling me?
- if (c == NULL) {
- cio_puts(" NULL???\n");
+ if( c == NULL ) {
+ cio_puts( " NULL???\n" );
return;
}
// now, the contents
- cio_printf("ss %04x gs %04x fs %04x es %04x ds %04x cs %04x\n",
- c->ss & 0xff, c->gs & 0xff, c->fs & 0xff, c->es & 0xff,
- c->ds & 0xff, c->cs & 0xff);
- cio_printf(" edi %08x esi %08x ebp %08x esp %08x\n", c->edi, c->esi,
- c->ebp, c->esp);
- cio_printf(" ebx %08x edx %08x ecx %08x eax %08x\n", c->ebx, c->edx,
- c->ecx, c->eax);
- cio_printf(" vec %08x cod %08x eip %08x eflags %08x\n", c->vector, c->code,
- c->eip, c->eflags);
+ cio_printf( "ss %04x gs %04x fs %04x es %04x ds %04x cs %04x\n",
+ c->ss & 0xff, c->gs & 0xff, c->fs & 0xff,
+ c->es & 0xff, c->ds & 0xff, c->cs & 0xff );
+ cio_printf( " edi %08x esi %08x ebp %08x esp %08x\n",
+ c->edi, c->esi, c->ebp, c->esp );
+ cio_printf( " ebx %08x edx %08x ecx %08x eax %08x\n",
+ c->ebx, c->edx, c->ecx, c->eax );
+ cio_printf( " vec %08x cod %08x eip %08x eflags %08x\n",
+ c->vector, c->code, c->eip, c->eflags );
}
/**
@@ -921,25 +939,25 @@ void ctx_dump(const char *msg, register context_t *c)
**
** @param msg[in] Optional message to print
*/
-void ctx_dump_all(const char *msg)
-{
- if (msg != NULL) {
- cio_puts(msg);
+void ctx_dump_all( const char *msg ) {
+
+ if( msg != NULL ) {
+ cio_puts( msg );
}
int n = 0;
register pcb_t *pcb = ptable;
- for (int i = 0; i < N_PROCS; ++i, ++pcb) {
- if (pcb->state != STATE_UNUSED) {
+ for( int i = 0; i < N_PROCS; ++i, ++pcb ) {
+ if( pcb->state != STATE_UNUSED ) {
++n;
- cio_printf("%2d(%d): ", n, pcb->pid);
- ctx_dump(NULL, pcb->context);
+ cio_printf( "%2d(%d): ", n, pcb->pid );
+ ctx_dump( NULL, pcb->context );
}
}
}
/**
-** pcb_dump(msg,pcb,all)
+** _pcb_dump(msg,pcb)
**
** Dumps the contents of this PCB to the console
**
@@ -947,85 +965,88 @@ void ctx_dump_all(const char *msg)
** @param pcb[in] The PCB to dump
** @param all[in] Dump all the contents?
*/
-void pcb_dump(const char *msg, register pcb_t *pcb, bool_t all)
-{
+void pcb_dump( const char *msg, register pcb_t *pcb, bool_t all ) {
+
// first, the message (if there is one)
- if (msg) {
- cio_puts(msg);
+ if( msg ) {
+ cio_puts( msg );
}
// the pointer
- cio_printf(" @ %08x:", (uint32_t)pcb);
+ cio_printf( " @ %08x:", (uint32_t) pcb );
// if it's NULL, why did you bother calling me?
- if (pcb == NULL) {
- cio_puts(" NULL???\n");
+ if( pcb == NULL ) {
+ cio_puts( " NULL???\n" );
return;
}
- cio_printf(" %d %s", pcb->pid,
- pcb->state >= N_STATES ? "???" : state_str[pcb->state]);
+ cio_printf( " %d", pcb->pid );
+ cio_printf( " %s",
+ pcb->state >= N_STATES ? "???" : state_str[pcb->state] );
- if (!all) {
+ if( !all ) {
// just printing IDs and states on one line
return;
}
// now, the rest of the contents
- cio_printf(" %s",
- pcb->priority >= N_PRIOS ? "???" : prio_str[pcb->priority]);
+ cio_printf( " %s",
+ pcb->priority >= N_PRIOS ? "???" : prio_str[pcb->priority] );
- cio_printf(" ticks %u xit %d wake %08x\n", pcb->ticks, pcb->exit_status,
- pcb->wakeup);
+ cio_printf( " ticks %u xit %d wake %08x\n",
+ pcb->ticks, pcb->exit_status, pcb->wakeup );
- cio_printf(" parent %08x", (uint32_t)pcb->parent);
- if (pcb->parent != NULL) {
- cio_printf(" (%u)", pcb->parent->pid);
+ cio_printf( " parent %08x", (uint32_t)pcb->parent );
+ if( pcb->parent != NULL ) {
+ cio_printf( " (%u)", pcb->parent->pid );
}
- cio_printf(" next %08x context %08x pde %08x", (uint32_t)pcb->next,
- (uint32_t)pcb->context, (uint32_t)pcb->pdir);
+ cio_printf( " next %08x context %08x pde %08x", (uint32_t) pcb->next,
+ (uint32_t) pcb->context, (uint32_t) pcb->pdir );
- cio_putchar('\n');
+ cio_putchar( '\n' );
}
/**
** pcb_queue_dump(msg,queue,contents)
**
+** Dump the contents of the specified queue to the console
+**
** @param msg[in] Optional message to print
** @param queue[in] The queue to dump
** @param contents[in] Also dump (some) contents?
*/
-void pcb_queue_dump(const char *msg, pcb_queue_t queue, bool_t contents)
-{
+void pcb_queue_dump( const char *msg, pcb_queue_t queue, bool_t contents ) {
+
// report on this queue
- cio_printf("%s: ", msg);
- if (queue == NULL) {
- cio_puts("NULL???\n");
+ cio_printf( "%s: ", msg );
+ if( queue == NULL ) {
+ cio_puts( "NULL???\n" );
return;
}
// first, the basic data
- cio_printf("head %08x tail %08x", (uint32_t)queue->head,
- (uint32_t)queue->tail);
+ cio_printf( "head %08x tail %08x",
+ (uint32_t) queue->head, (uint32_t) queue->tail );
// next, how the queue is ordered
- cio_printf(" order %s\n",
- queue->order >= N_ORDERINGS ? "????" : ord_str[queue->order]);
+ cio_printf( " order %s\n",
+ queue->order >= N_ORDERINGS ? "????" : ord_str[queue->order] );
// if there are members in the queue, dump the first few PIDs
- if (contents && queue->head != NULL) {
- cio_puts(" PIDs: ");
+ if( contents && queue->head != NULL ) {
+ cio_puts( " PIDs: " );
pcb_t *tmp = queue->head;
- for (int i = 0; i < 5 && tmp != NULL; ++i, tmp = tmp->next) {
- cio_printf(" [%u]", tmp->pid);
+ for( int i = 0; i < 5 && tmp != NULL; ++i, tmp = tmp->next ) {
+ cio_printf( " [%u]", tmp->pid );
}
- if (tmp != NULL) {
- cio_puts(" ...");
+ if( tmp != NULL ) {
+ cio_puts( " ..." );
}
- cio_putchar('\n');
+ cio_putchar( '\n' );
}
}
@@ -1037,48 +1058,50 @@ void pcb_queue_dump(const char *msg, pcb_queue_t queue, bool_t contents)
** @param msg[in] Optional message to print
** @param all[in] Dump all or only part of the relevant data
*/
-void ptable_dump(const char *msg, bool_t all)
-{
- if (msg) {
- cio_puts(msg);
+void ptable_dump( const char *msg, bool_t all ) {
+
+ if( msg ) {
+ cio_puts( msg );
}
- cio_putchar(' ');
+ cio_putchar( ' ' );
int used = 0;
int empty = 0;
register pcb_t *pcb = ptable;
- for (int i = 0; i < N_PROCS; ++i) {
- if (pcb->state == STATE_UNUSED) {
+ for( int i = 0; i < N_PROCS; ++i ) {
+ if( pcb->state == STATE_UNUSED ) {
+
// an empty slot
++empty;
} else {
+
// a non-empty slot
++used;
// if not dumping everything, add commas if needed
- if (!all && used) {
- cio_putchar(',');
+ if( !all && used ) {
+ cio_putchar( ',' );
}
// report the table slot #
- cio_printf(" #%d:", i);
+ cio_printf( " #%d:", i );
// and dump the contents
- pcb_dump(NULL, pcb, all);
+ pcb_dump( NULL, pcb, all );
}
}
// only need this if we're doing one-line output
- if (!all) {
- cio_putchar('\n');
+ if( !all ) {
+ cio_putchar( '\n' );
}
// sanity check - make sure we saw the correct number of table slots
- if ((used + empty) != N_PROCS) {
- cio_printf("Table size %d, used %d + empty %d = %d???\n", N_PROCS, used,
- empty, used + empty);
+ if( (used + empty) != N_PROCS ) {
+ cio_printf( "Table size %d, used %d + empty %d = %d???\n",
+ N_PROCS, used, empty, used + empty );
}
}
@@ -1088,15 +1111,14 @@ void ptable_dump(const char *msg, bool_t all)
** Prints basic information about the process table (number of
** entries, number with each process state, etc.).
*/
-void ptable_dump_counts(void)
-{
+void ptable_dump_counts( void ) {
uint_t nstate[N_STATES] = { 0 };
uint_t unknown = 0;
int n = 0;
pcb_t *ptr = ptable;
- while (n < N_PROCS) {
- if (ptr->state < 0 || ptr->state >= N_STATES) {
+ while( n < N_PROCS ) {
+ if( ptr->state < 0 || ptr->state >= N_STATES ) {
++unknown;
} else {
++nstate[ptr->state];
@@ -1105,12 +1127,10 @@ void ptable_dump_counts(void)
++ptr;
}
- cio_printf("Ptable: %u ***", unknown);
- for (n = 0; n < N_STATES; ++n) {
- if (nstate[n]) {
- cio_printf(" %u %s", nstate[n],
- state_str[n] != NULL ? state_str[n] : "???");
- }
+ cio_printf( "Ptable: %u ***", unknown );
+ for( n = 0; n < N_STATES; ++n ) {
+ cio_printf( " %u %s", nstate[n],
+ state_str[n] != NULL ? state_str[n] : "???" );
}
- cio_putchar('\n');
+ cio_putchar( '\n' );
}
generated by cgit v1.2.3-freya (git 2.51.0) at 2025-09-22 21:00:37 +0000