pull upstream changes, add auto formatting

1 files changed, 247 insertions, 267 deletions

diff --git a/kernel/procs.c b/kernel/procs.c
index 96bb3fd..64edb49 100644
--- a/kernel/procs.c
+++ b/kernel/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
@@ -75,32 +75,28 @@ pcb_t *init_pcb;
 
 // table of state name strings
 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"
+	[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] = {
-	[ 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] = {
-	[ 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
@@ -125,16 +121,16 @@ const char *ord_str[N_PRIOS] = {
 ** @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;
 	}
@@ -142,16 +138,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;
 	}
@@ -159,16 +155,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;
 	}
@@ -181,10 +177,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); \
 	}
 
 /**
@@ -192,22 +188,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
@@ -218,8 +214,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;
 	}
 }
@@ -233,14 +229,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;
 	}
 
@@ -255,20 +251,19 @@ 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);
 		}
 	}
 }
@@ -282,15 +277,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
@@ -306,26 +301,24 @@ 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
@@ -333,7 +326,6 @@ void pcb_zombify( register pcb_t *victim ) {
 				// collected when 'init' loops
 				zchild = curr;
 			}
-
 		}
 	}
 
@@ -353,20 +345,19 @@ void pcb_zombify( register pcb_t *victim ) {
 	** 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.
@@ -379,8 +370,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);
 	}
 
 	/*
@@ -394,14 +385,12 @@ 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);
-
-		if( target == 0 || target == vicpid ) {
+		uint32_t target = ARG(parent, 1);
 
+		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.
 
@@ -409,9 +398,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.
@@ -424,8 +413,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;
 		}
@@ -443,7 +432,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
@@ -459,23 +448,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);
 }
 
 /**
@@ -487,18 +476,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;
 		}
 	}
@@ -516,19 +505,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;
 		}
 	}
@@ -548,13 +537,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;
 	}
 
@@ -575,10 +564,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);
 }
@@ -592,16 +581,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;
 	}
@@ -619,41 +608,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?
@@ -662,29 +651,25 @@ 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;
@@ -700,14 +685,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;
 	}
 
@@ -719,7 +704,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;
 	}
@@ -744,14 +729,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;
 	}
 
@@ -759,7 +744,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;
 	}
@@ -773,15 +758,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;
@@ -793,7 +778,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;
@@ -806,10 +791,8 @@ 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;
 }
@@ -824,13 +807,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;
 	}
 
@@ -849,13 +832,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;
 	}
@@ -864,8 +847,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");
 	}
 }
 
@@ -874,16 +857,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
@@ -891,7 +874,6 @@ void dispatch( void ) {
 	current->ticks = QUANTUM_STANDARD;
 }
 
-
 /*
 ** Debugging/tracing routines
 */
@@ -904,32 +886,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);
 }
 
 /**
@@ -939,19 +921,19 @@ 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);
 		}
 	}
 }
@@ -965,47 +947,46 @@ 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", pcb->pid );
-	cio_printf( " %s",
-			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');
 }
 
 /**
@@ -1017,36 +998,36 @@ void pcb_dump( const char *msg, register pcb_t *pcb, bool_t all ) {
 ** @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');
 	}
 }
 
@@ -1058,50 +1039,48 @@ 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);
 	}
 }
 
@@ -1111,14 +1090,15 @@ 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];
@@ -1127,10 +1107,10 @@ void ptable_dump_counts( void ) {
 		++ptr;
 	}
 
-	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_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');
 }