From 403580e95b4472f24581ef92e2c997b430d77606 Mon Sep 17 00:00:00 2001 From: Jorrit Herder Date: Mon, 20 Jun 2005 11:26:48 +0000 Subject: [PATCH] Removed unused code in proc.c. New message passing code with pointer pointers is now in use. Rewrote ready() and unready() fuctions. --- kernel/Makefile | 10 ++- kernel/main.c | 6 +- kernel/proc.c | 167 +++++++++--------------------------------------- 3 files changed, 36 insertions(+), 147 deletions(-) diff --git a/kernel/Makefile b/kernel/Makefile index 4bfdd52b9..c8051449f 100755 --- a/kernel/Makefile +++ b/kernel/Makefile @@ -14,21 +14,19 @@ g = $n/gen CC = exec cc CPP = $l/cpp LD = $(CC) -.o -CFLAGS = -I$i +CFLAGS = -I$i LDFLAGS = -i -LIBS = -lsys -lutils -ltimers HEAD = mpx.o - OBJS = start.o protect.o klibc.o klib.o table.o main.o proc.o \ - i8259.o exception.o system.o clock.o misc.o \ - + i8259.o exception.o system.o clock.o misc.o SYS = system/system.a +LIBS = -ltimers # What to make. kernel build: $(HEAD) $(OBJS) $(SYS) - $(LD) $(LDFLAGS) -o kernel $(HEAD) $(OBJS) $(SYS) $(CLOCK) $(LIBS) + $(LD) $(CFLAGS) $(LDFLAGS) -o kernel $(HEAD) $(OBJS) $(SYS) $(LIBS) install -S 0 kernel $(SYS): diff --git a/kernel/main.c b/kernel/main.c index 4cec0e484..32c104f31 100755 --- a/kernel/main.c +++ b/kernel/main.c @@ -39,15 +39,13 @@ FORWARD _PROTOTYPE( void shutdown, (timer_t *tp)); PUBLIC void main() { /* Start the ball rolling. */ - register struct proc *rp; register int i; int hdrindex; /* index to array of a.out headers */ - phys_clicks text_base, bootdev_base; - vir_clicks text_clicks, bootdev_clicks; + phys_clicks text_base; + vir_clicks text_clicks; vir_clicks data_clicks; reg_t ktsb; /* kernel task stack base */ - struct memory *memp; struct system_image *ttp; struct exec e_hdr; /* for a copy of an a.out header */ diff --git a/kernel/proc.c b/kernel/proc.c index ece2bb7a6..6e60af384 100755 --- a/kernel/proc.c +++ b/kernel/proc.c @@ -1,7 +1,3 @@ -#define NEW_ELOCKED_CHECK 1 -#define NEW_SCHED_Q 0 -#define OLD_SEND 0 -#define OLD_RECV 0 /* This file contains essentially all of the process and message handling. * Together with "mpx.s" it forms the lowest layer of the MINIX kernel. * There is one entry point from the outside: @@ -199,37 +195,16 @@ unsigned flags; /* system call flags */ * for this message, copy the message to it and unblock 'dst'. If 'dst' is * not waiting at all, or is waiting for another source, queue 'caller_ptr'. */ - register struct proc *dst_ptr; -#if OLD_SEND - register struct proc *next_ptr; - register struct proc *xp; -#else + register struct proc *dst_ptr = proc_addr(dst); register struct proc **xpp; register struct proc *xp; -#endif - - dst_ptr = proc_addr(dst); /* pointer to destination's proc entry */ - /* Check for deadlock by 'caller_ptr' and 'dst' sending to each other. */ -#if NEW_ELOCKED_CHECK xp = dst_ptr; while (xp->p_flags & SENDING) { /* check while sending */ xp = proc_addr(xp->p_sendto); /* get xp's destination */ if (xp == caller_ptr) return(ELOCKED); /* deadlock if cyclic */ } -#else - if (dst_ptr->p_flags & SENDING) { - next_ptr = proc_addr(dst_ptr->p_sendto); - while (TRUE) { - if (next_ptr == caller_ptr) return(ELOCKED); - if (next_ptr->p_flags & SENDING) - next_ptr = proc_addr(next_ptr->p_sendto); - else - break; - } - } -#endif /* Check if 'dst' is blocked waiting for this message. The destination's * SENDING flag may be set when its SENDREC call blocked while sending. @@ -248,19 +223,9 @@ unsigned flags; /* system call flags */ caller_ptr->p_sendto = dst; /* Process is now blocked. Put in on the destination's queue. */ -#if OLD_SEND - if ( (next_ptr = dst_ptr->p_caller_q) == NIL_PROC) - dst_ptr->p_caller_q = caller_ptr; - else { - while (next_ptr->p_q_link != NIL_PROC) - next_ptr = next_ptr->p_q_link; - next_ptr->p_q_link = caller_ptr; - } -#else xpp = &dst_ptr->p_caller_q; /* find end of list */ while (*xpp != NIL_PROC) xpp = &(*xpp)->p_q_link; *xpp = caller_ptr; /* add caller to end */ -#endif caller_ptr->p_q_link = NIL_PROC; /* mark new end of list */ } else { return(ENOTREADY); @@ -281,12 +246,7 @@ unsigned flags; /* system call flags */ * acquire it and deblock the sender. If no message from the desired source * is available block the caller, unless the flags don't allow blocking. */ -#if OLD_RECV - register struct proc *sender_ptr; - register struct proc *previous_ptr; -#else register struct proc **xpp; -#endif register struct notification **ntf_q_pp; message m; int bit_nr; @@ -298,23 +258,6 @@ unsigned flags; /* system call flags */ if (!(caller_ptr->p_flags & SENDING)) { /* Check caller queue. Use pointer pointers to keep code simple. */ -#if OLD_RECV /* to hairy, unreadable */ - for (sender_ptr = caller_ptr->p_caller_q; sender_ptr != NIL_PROC; - previous_ptr = sender_ptr, sender_ptr = sender_ptr->p_q_link) { - if (src == ANY || src == proc_nr(sender_ptr)) { - /* An acceptable message has been found. */ - CopyMess(sender_ptr->p_nr, sender_ptr, - sender_ptr->p_messbuf, caller_ptr, m_ptr); - if (sender_ptr == caller_ptr->p_caller_q) - caller_ptr->p_caller_q = sender_ptr->p_q_link; - else - previous_ptr->p_q_link = sender_ptr->p_q_link; - if ((sender_ptr->p_flags &= ~SENDING) == 0) - ready(sender_ptr); /* deblock sender */ - return(OK); - } - } -#else xpp = &caller_ptr->p_caller_q; while (*xpp != NIL_PROC) { if (src == ANY || src == proc_nr(*xpp)) { @@ -326,7 +269,6 @@ unsigned flags; /* system call flags */ } xpp = &(*xpp)->p_q_link; /* proceed to next */ } -#endif /* Check if there are pending notifications, except for SENDREC. */ if (! (flags & FRESH_ANSWER)) { @@ -507,33 +449,19 @@ register struct proc *rp; /* this process is now runnable */ * user processes are added in front of the queue, because this is a bit * fairer to I/O bound processes. */ -#if NEW_SCHED_Q - if (isuserp(rp)) { /* add to front of queue */ - rp->p_nextready = rdy_head[q]; /* chain current front */ - rdy_head[q] = rp; /* rp becomes new front */ - } - else { /* add to end of queue */ - xpp = &rdy_head[q]; /* find pointer to end */ - while (*xpp != NIL_PROC) xpp = &(*xpp)->p_nextready; - *xpp = rp; /* replace end with rp */ - rp->p_nextready = NIL_PROC; /* mark end of queue */ - } -#else - if (isuserp(rp)) { /* add to front of queue */ - if (rdy_head[q] == NIL_PROC) - rdy_tail[q] = rp; - rp->p_nextready = rdy_head[q]; /* add to front of queue */ - rdy_head[q] = rp; + if (rdy_head[q] == NIL_PROC) { /* add to empty queue */ + rdy_head[q] = rdy_tail[q] = rp; /* create a new queue */ + rp->p_nextready = NIL_PROC; /* mark new end */ } - else { - if (rdy_head[q] != NIL_PROC) - rdy_tail[q]->p_nextready = rp; /* add to end of queue */ - else - rdy_head[q] = rp; /* add to empty queue */ - rdy_tail[q] = rp; - rp->p_nextready = NIL_PROC; + else if (isuserp(rp)) { /* add to head of queue */ + rp->p_nextready = rdy_head[q]; /* chain head of queue */ + rdy_head[q] = rp; /* set new queue head */ + } + else { /* add to tail of queue */ + rdy_tail[q]->p_nextready = rp; /* chain tail of queue */ + rdy_tail[q] = rp; /* set new queue tail */ + rp->p_nextready = NIL_PROC; /* mark new end */ } -#endif /* Run 'rp' next if it has a higher priority than 'proc_ptr' or 'next_ptr'. * This actually should be done via pick_proc(), but the message passing @@ -552,12 +480,8 @@ register struct proc *rp; /* this process is no longer runnable */ /* A process has blocked. See ready for a description of the queues. */ register int q = rp->p_priority; /* queue to use */ -#if NEW_SCHED_Q register struct proc **xpp; /* iterate over queue */ -#else - register struct proc **qtail; /* queue's rdy_tail */ - register struct proc *xp; -#endif + register struct proc *prev_xp; #if ENABLE_K_DEBUGGING if(!rp->p_ready) { @@ -576,71 +500,40 @@ register struct proc *rp; /* this process is no longer runnable */ * process if it is found. A process can be made unready even if it is not * running by being sent a signal that kills it. */ -#if NEW_SCHED_Q - xpp = &rdy_head[q]; - while (*xpp != NIL_PROC) { /* check entire queue */ - if (*xpp == rp) { /* lookup unready process */ - *xpp = (*xpp)->p_nextready; /* replace it with next */ - if (rp == proc_ptr || rp == next_ptr) /* current process removed */ + prev_xp = NIL_PROC; + for (xpp = &rdy_head[q]; *xpp != NIL_PROC; xpp = &(*xpp)->p_nextready) { + + if (*xpp == rp) { /* found process to remove */ + *xpp = (*xpp)->p_nextready; /* replace with next chain */ + if (rp == rdy_tail[q]) /* queue tail removed */ + rdy_tail[q] = prev_xp; /* set new tail */ + if (rp == proc_ptr || rp == next_ptr) /* active process removed */ pick_proc(); /* pick new process to run */ break; } - xpp = &(*xpp)->p_nextready; /* proceed to next */ + prev_xp = *xpp; /* save previous in chain */ } -#else - if ( (xp = rdy_head[q]) != NIL_PROC) { /* ready queue is empty */ - if (xp == rp) { /* check head of queue */ - rdy_head[q] = xp->p_nextready; /* new head of queue */ - if (rp == proc_ptr || rp == next_ptr) /* current process removed */ - pick_proc(); /* pick new process to run */ - if(rp == rdy_tail[q]) - rdy_tail[q] = NIL_PROC; - } - else { /* check body of queue */ - while (xp->p_nextready != rp) /* stop if process is next */ - if ( (xp = xp->p_nextready) == NIL_PROC) - return; - xp->p_nextready = xp->p_nextready->p_nextready; - if (rdy_tail[q] == rp) /* possibly update tail */ - rdy_tail[q] = xp; - } - } -#endif - } /*===========================================================================* * sched * *===========================================================================*/ -PRIVATE void sched(queue) -int queue; +PRIVATE void sched(q) +int q; /* scheduling queue to use */ { /* The current process has run too long. If another low priority (user) * process is runnable, put the current process on the end of the user queue, * possibly promoting another user to head of the queue. */ - register struct proc **xpp; - register struct proc *xp; - - if (rdy_head[queue] == NIL_PROC) return; + if (rdy_head[q] == NIL_PROC) return; /* return for empty queue */ /* One or more user processes queued. */ -#if NEW_SCHED_Q + rdy_tail[q]->p_nextready = rdy_head[q]; /* add expired to end */ + rdy_tail[q] = rdy_head[q]; /* set new queue tail */ + rdy_head[q] = rdy_head[q]->p_nextready; /* set new queue head */ + rdy_tail[q]->p_nextready = NIL_PROC; /* mark new queue end */ - xp = rdy_head[queue]; /* save expired process */ - rdy_head[queue] = xp->p_nextready; /* advance to next process */ - xpp = &rdy_head[queue]; /* find end of queue */ - while (*xpp != NIL_PROC) xpp = &(*xpp)->p_nextready; - *xpp = xp; /* add expired to end */ - xp->p_nextready = NIL_PROC; /* mark new end of queue */ - -#else - rdy_tail[queue]->p_nextready = rdy_head[queue]; /* add expired to end */ - rdy_tail[queue] = rdy_head[queue]; /* set new tail */ - rdy_head[queue] = rdy_head[queue]->p_nextready; /* set new head */ - rdy_tail[queue]->p_nextready = NIL_PROC; /* mark new end */ -#endif - pick_proc(); + pick_proc(); /* select next to run */ }