From: Jorrit Herder Date: Fri, 17 Jun 2005 09:09:54 +0000 (+0000) Subject: * Fixed bug relating to nested locking in interrupt handlers. The nested lock X-Git-Tag: v3.1.0~755 X-Git-Url: http://zhaoyanbai.com/repos/%22http:/www.isc.org/icons/host.html?a=commitdiff_plain;h=e0a98a4d655d1b04b69381d377fa127d5a38758c;p=minix.git * Fixed bug relating to nested locking in interrupt handlers. The nested lock caused interrupts to be reenabled (due to unlock), which caused a race. The problems were especially visible on slower machines. * Relocated free memory parsing to process manager. This saved quite some code at the kernel level. Text size was reduced by about 650 bytes. * Removed locks for updating the realtime in the clock's main loop and the get_uptime function. Interrupts are no longer reentrant, so realtime is immediately updated. --- diff --git a/kernel/clock.c b/kernel/clock.c index 8ca80f5a9..6615de3a0 100755 --- a/kernel/clock.c +++ b/kernel/clock.c @@ -1,3 +1,4 @@ +#define NEW_TIME_COUNT 1 /* The file contais the clock task, which handles all time related functions. * Important events that are handled by the CLOCK include alarm timers and * (re)scheduling user processes. @@ -84,7 +85,9 @@ PRIVATE clock_t realtime; /* real time clock */ /* Variables for and changed by the CLOCK's interrupt handler. */ PRIVATE irq_hook_t clock_hook; +#if ! NEW_TIME_COUNT PRIVATE clock_t pending_ticks; /* ticks seen by low level only */ +#endif PRIVATE int sched_ticks = SCHED_RATE; /* counter: when 0, call scheduler */ PRIVATE struct proc *prev_ptr; /* last user process run by clock */ @@ -107,11 +110,13 @@ PUBLIC void clock_task() /* Go get a message. */ receive(ANY, &m); +#if ! NEW_TIME_COUNT /* Transfer ticks seen by the low level handler. */ lock(8, "realtime"); realtime += pending_ticks; pending_ticks = 0; unlock(8); +#endif /* Handle the request. */ switch (m.m_type) { @@ -202,10 +207,12 @@ irq_hook_t *hook; * The variables which are changed require more care: * rp->p_user_time, rp->p_sys_time: * These are protected by explicit locks in system.c. +#if ! NEW_TIME_COUNT * pending_ticks: * This is protected by explicit locks in clock.c. Don't * update realtime directly, since there are too many * references to it to guard conveniently. +#endif * lost_ticks: * Clock ticks counted outside the clock task. * sched_ticks, prev_ptr: @@ -222,7 +229,9 @@ irq_hook_t *hook; register struct proc *rp; register unsigned ticks; message m; +#if ! NEW_TIME_COUNT clock_t now; +#endif /* Acknowledge the PS/2 clock interrupt. */ if (machine.ps_mca) outb(PORT_B, inb(PORT_B) | CLOCK_ACK_BIT); @@ -232,10 +241,16 @@ irq_hook_t *hook; * process is running, charge the billable process for system time as well. * Thus the unbillable process' user time is the billable user's system time. */ +#if NEW_TIME_COUNT + ticks = lost_ticks + 1; + lost_ticks = 0; + realtime += ticks; +#else ticks = lost_ticks + 1; lost_ticks = 0; pending_ticks += ticks; now = realtime + pending_ticks; +#endif /* Update administration. */ proc_ptr->p_user_time += ticks; @@ -244,11 +259,15 @@ irq_hook_t *hook; /* Check if do_clocktick() must be called. Done for alarms and scheduling. * If bill_ptr == prev_ptr, there are no ready users so don't need sched(). */ +#if NEW_TIME_COUNT + if (next_timeout <= realtime || (sched_ticks == 1 && bill_ptr == prev_ptr +#else if (next_timeout <= now || (sched_ticks == 1 && bill_ptr == prev_ptr +#endif && rdy_head[PPRI_USER] != NIL_PROC)) { m.NOTIFY_TYPE = HARD_INT; - lock_notify(CLOCK, &m); + int_notify(CLOCK, &m); } else if (--sched_ticks <= 0) { sched_ticks = SCHED_RATE; /* reset the quantum */ @@ -266,12 +285,16 @@ PUBLIC clock_t get_uptime() /* Get and return the current clock uptime in ticks. * Be careful about pending_ticks. */ +#if NEW_TIME_COUNT + return(realtime); +#else clock_t uptime; lock(9, "get_uptime"); uptime = realtime + pending_ticks; unlock(9); return(uptime); +#endif } diff --git a/kernel/exception.c b/kernel/exception.c index cdcbc0143..123995807 100755 --- a/kernel/exception.c +++ b/kernel/exception.c @@ -49,7 +49,7 @@ unsigned vec_nr; ep = &ex_data[vec_nr]; if (vec_nr == 2) { /* spurious NMI on some machines */ - kprintf("got spurious NMI\n",NO_ARG); + kprintf("got spurious NMI\n",NO_NUM); return; } @@ -68,19 +68,7 @@ unsigned vec_nr; kprintf("pc = %d:", (unsigned) saved_proc->p_reg.cs); kprintf("0x%x\n", (unsigned) saved_proc->p_reg.pc); - /* If the exception originates in the kernel, shut down MINIX. Otherwise, - * kill the process that caused it. If MINIX is shut down and the stop - * sequence is skipped, the kprintf() output cannot be flushed by the TTY - * driver. This leaves the user with a hanging system without proper - * notification ... - */ - if (istaskp(saved_proc)) { /* serious problem */ - kernel_exception = TRUE; /* directly shutdown */ - panic("exception in a kernel task", NO_NUM); - } else { - clear_proc(saved_proc->p_nr); - kprintf("%s was killed by MINIX due to an exception", - karg(saved_proc->p_name)); - } + kernel_exception = TRUE; /* directly shutdown */ + panic("exception in a kernel task", NO_NUM); } diff --git a/kernel/glo.h b/kernel/glo.h index 48cad66e0..7e1f08a5c 100755 --- a/kernel/glo.h +++ b/kernel/glo.h @@ -22,7 +22,6 @@ EXTERN struct kinfo kinfo; /* kernel information for users */ EXTERN struct machine machine; /* machine information for users */ EXTERN struct kmessages kmess; /* diagnostic messages in kernel */ EXTERN struct randomness krandom; /* gather kernel random information */ -EXTERN struct memory mem[NR_MEMS]; /* base and size of chunks of memory */ /* Process scheduling information and the kernel reentry count. */ EXTERN struct proc *proc_ptr; /* pointer to currently running process */ diff --git a/kernel/i8259.c b/kernel/i8259.c index 7f60aaac5..64f5041b0 100755 --- a/kernel/i8259.c +++ b/kernel/i8259.c @@ -45,7 +45,7 @@ int mine; /* Initialize the 8259s, finishing with all interrupts disabled. This is * only done in protected mode, in real mode we don't touch the 8259s, but * use the BIOS locations instead. The flag "mine" is set if the 8259s are - * to be programmed for Minix, or to be reset to what the BIOS expects. + * to be programmed for MINIX, or to be reset to what the BIOS expects. */ int i; diff --git a/kernel/klibc.c b/kernel/klibc.c index 0aab02056..07a5cb861 100644 --- a/kernel/klibc.c +++ b/kernel/klibc.c @@ -11,7 +11,6 @@ * kstrcmp: lexicographical comparison of two strings * kstrlen: get number of non-null characters in string * kstrncpy: copy string and pad or copy up to n chars - * kstrtoulb: convert string to unsigned long value * * This file contains the routines that take care of kernel messages, i.e., * diagnostic output within the kernel. Kernel messages are not directly @@ -152,7 +151,7 @@ PRIVATE void kputc(c) int c; /* character to append */ { /* Accumulate a single character for a kernel message. Send a notification - * the to TTY driver if the buffer if a END_OF_KMESS is encountered. + * the to TTY driver if an END_OF_KMESS is encountered. */ message m; if (c != END_OF_KMESS) { @@ -225,45 +224,3 @@ PUBLIC char *kstrncpy(char *ret, register const char *s2, register size_t n) } -/*=========================================================================* - * kstrtoul * - *=========================================================================*/ -PUBLIC unsigned long kstrtoul(strptr, endptr, base) -const char *strptr; /* pointer to string to be parsed */ -char ** const endptr; /* store pointer to end here */ -int base; -{ -/* A simplified version of strtoul() for the kernel to prevent including the - * one in the ASNI library. No whitespaces are skipped, the numeric value is - * expected at the start of 'string'. - */ - register unsigned long val = 0; - register int c; - register unsigned int v; - int overflow = 0; - - /* Get rid of 0x or 0X for hexidecimal values. */ - if (base==16 && *strptr=='0' && (*++strptr=='x' || *strptr=='X')) - strptr++; - - /* Now parse the actual unsigned long number. */ - for (;;) { - c = *strptr; - if ('0' <= c && c <= '9') v = c - '0'; - else if ('a' <= c && c <= 'z') v = c - 'a' + 0xa; - else if ('A' <= c && c <= 'Z') v = c - 'A' + 0xA; - else break; /* end of number */ - if (v >= base) break; /* end of number */ - if (val > (ULONG_MAX - v) / base) overflow = 1; - val = (val*base) + v; - strptr++; - } - - /* Tell caller where parsing ended unless a NULL pointer was passed. */ - if (endptr) *endptr = (char *) strptr; - - /* Done, return parsed value or maximum value on overflow. */ - return (overflow) ? ULONG_MAX : val; -} - - diff --git a/kernel/main.c b/kernel/main.c index a015d784e..ee6c27bd1 100755 --- a/kernel/main.c +++ b/kernel/main.c @@ -114,19 +114,6 @@ PUBLIC void main() rp->p_memmap[S].mem_phys = text_base + text_clicks + data_clicks; rp->p_memmap[S].mem_vir = data_clicks; /* empty - stack is in data */ - /* Remove server memory from the free memory list. The boot monitor - * promises to put processes at the start of memory chunks. The - * tasks all use same base address, so only the first task changes - * the memory lists. The servers and init have their own memory - * spaces and their memory will be removed from the list. - */ - for (memp = mem; memp < &mem[NR_MEMS]; memp++) { - if (memp->base == text_base) { - memp->base += text_clicks + data_clicks; - memp->size -= text_clicks + data_clicks; - } - } - /* Set initial register values. The processor status word for tasks * is different from that of other processes because tasks can * access I/O; this is not allowed to less-privileged processes @@ -144,7 +131,6 @@ PUBLIC void main() } /* Set ready. The HARDWARE task is never ready. */ - #if ENABLE_K_DEBUGGING rp->p_ready = 0; #endif @@ -163,30 +149,16 @@ PUBLIC void main() hdrindex ++; phys_copy(aout + hdrindex * A_MINHDR,vir2phys(&e_hdr),(phys_bytes) A_MINHDR); if (e_hdr.a_flags & A_IMG) { - kinfo.bootdev_base = e_hdr.a_syms; kinfo.bootdev_size = e_hdr.a_data; - - /* Remove from free list, to prevent being overwritten. */ - bootdev_base = e_hdr.a_syms >> CLICK_SHIFT; - bootdev_clicks = (e_hdr.a_total + CLICK_SIZE-1) >> CLICK_SHIFT; - for (memp = mem; memp < &mem[NR_MEMS]; memp++) { - if (memp->base == bootdev_base) { - memp->base += bootdev_clicks; - memp->size -= bootdev_clicks; - } - } } #endif - /* This actually is not needed, because ready() already set 'proc_ptr.' */ - lock_pick_proc(); - bill_ptr = proc_addr(IDLE); /* it has to point somewhere */ - - /* MINIX is now ready. Display the startup banner to the user and return - * to the assembly code to start running the current process. + /* MINIX is now ready. All boot image processes are on the ready queue. + * Return to the assembly code to start running the current process. */ - announce(); + bill_ptr = proc_addr(IDLE); /* it has to point somewhere */ + announce(); /* print MINIX startup banner */ restart(); } @@ -199,7 +171,7 @@ PRIVATE void announce(void) { /* Display the MINIX startup banner. */ kprintf("MINIX %s. Copyright 2001 Prentice-Hall, Inc.\n", - karg(kinfo.version)); + karg(OS_RELEASE "." OS_VERSION)); #if (CHIP == INTEL) /* Real mode, or 16/32-bit protected mode? */ @@ -249,10 +221,10 @@ int how; /* 0 = halt, 1 = reboot, 2 = panic!, ... */ shutting_down = TRUE; /* flag for sys_exit() */ tmr_arg(&shutdown_timer)->ta_int = how; /* pass how in timer */ if (kernel_exception) { /* set in exception() */ - kprintf("\nAn exception occured; skipping stop sequence.\n", NO_ARG); + kprintf("\nAn exception occured; skipping stop sequence.\n", NO_NUM); shutdown(&shutdown_timer); /* TTY isn't scheduled */ } else { - kprintf("\nNotifying system services about MINIX shutdown.\n", NO_ARG); + kprintf("\nNotifying system services about MINIX shutdown.\n", NO_NUM); set_timer(&shutdown_timer, get_uptime(), stop_sequence); } } diff --git a/kernel/misc.c b/kernel/misc.c index dc40c9e81..f8bf3edd0 100755 --- a/kernel/misc.c +++ b/kernel/misc.c @@ -25,7 +25,7 @@ int n; if (s != NULL) { kprintf("\nKernel panic: %s", karg(s)); if (n != NO_NUM) kprintf(" %d", n); - kprintf("\n",NO_ARG); + kprintf("\n",NO_NUM); } prepare_shutdown(RBT_PANIC); } diff --git a/kernel/proc.c b/kernel/proc.c index 94bf2c12c..54cb8ed09 100755 --- a/kernel/proc.c +++ b/kernel/proc.c @@ -1,5 +1,5 @@ #define NEW_ELOCKED_CHECK 1 -#define NEW_SCHED_Q 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. @@ -11,11 +11,11 @@ * As well as several entry points used from the interrupt and task level: * * lock_notify: send a notification to inform a process of a system event + * int_notify: same as above, but from an interrupt handler (no locking) * lock_send: send a message to a process * lock_ready: put a process on one of the ready queues so it can be run * lock_unready: remove a process from the ready queues * lock_sched: a process has run too long; schedule another one - * lock_pick_proc: pick a process to run (used by system initialization) * * Changes: * , 2005 better protection in sys_call() (Jorrit N. Herder) @@ -438,13 +438,12 @@ PUBLIC int lock_notify(dst, m_ptr) int dst; /* to whom is message being sent? */ message *m_ptr; /* pointer to message buffer */ { -/* Safe gateway to mini_notify() for tasks and interrupt handlers. This - * function checks if it is called from an interrupt handler and ensures - * that the correct message source is put on the notification. +/* Safe gateway to mini_notify() for tasks. Don't use this function from the + * interrupt level, as it will reenable interrupts (because of the unlock() + * call). For interrupt handlers, int_notify() is available. */ int result; - struct proc *caller_ptr; - + register struct proc *caller_ptr; lock(0, "notify"); caller_ptr = (k_reenter >= 0) ? proc_addr(HARDWARE) : proc_ptr; result = mini_notify(caller_ptr, dst, m_ptr); @@ -452,6 +451,24 @@ message *m_ptr; /* pointer to message buffer */ return(result); } + +/*==========================================================================* + * int_notify * + *==========================================================================*/ +PUBLIC int int_notify(dst, m_ptr) +int dst; /* to whom is message being sent? */ +message *m_ptr; /* pointer to message buffer */ +{ +/* Gateway to mini_notify() for interrupt handlers. This function doesn't + * use lock() and unlock() because interrupts are already disabled. + */ + int result; + register struct proc *caller_ptr = proc_addr(HARDWARE); + result = mini_notify(caller_ptr, dst, m_ptr); + return(result); +} + + /*===========================================================================* * pick_proc * *===========================================================================*/ @@ -627,25 +644,14 @@ int queue; xp->p_nextready = NIL_PROC; /* mark new end of queue */ #else - rdy_tail[queue]->p_nextready = rdy_head[queue]; - rdy_tail[queue] = rdy_head[queue]; - rdy_head[queue] = rdy_head[queue]->p_nextready; - rdy_tail[queue]->p_nextready = NIL_PROC; + 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(); } -/*==========================================================================* - * lock_pick_proc * - *==========================================================================*/ -PUBLIC void lock_pick_proc() -{ -/* Safe gateway to pick_proc() for tasks. */ - lock(1, "pick_proc"); - pick_proc(); - unlock(1); -} - /*==========================================================================* * lock_send * diff --git a/kernel/proto.h b/kernel/proto.h index 9f73710c1..32e6e1e1d 100755 --- a/kernel/proto.h +++ b/kernel/proto.h @@ -25,9 +25,6 @@ _PROTOTYPE( int kstrncmp, (register const char *s1, register const char *s2, register size_t n)); _PROTOTYPE( char *kstrncpy, (char *s1, register const char *s2, register const size_t n)); -_PROTOTYPE( unsigned long kstrtoul, - (const char *string, char ** const end, int base) ); -#define NO_ARG 0 #define karg(arg) (karg_t) (arg) _PROTOTYPE( void kprintf, (const char *fmt, karg_t arg) ); @@ -44,8 +41,8 @@ _PROTOTYPE( void free_bit, (bit_t nr, bitchunk_t *map, bit_t nr_bits) ); /* proc.c */ _PROTOTYPE( int sys_call, (int function, int src_dest, message *m_ptr) ); _PROTOTYPE( int lock_notify, (int dst, message *m_ptr) ); +_PROTOTYPE( int int_notify, (int dst, message *m_ptr) ); _PROTOTYPE( int lock_send, (int dst, message *m_ptr) ); -_PROTOTYPE( void lock_pick_proc, (void) ); _PROTOTYPE( void lock_ready, (struct proc *rp) ); _PROTOTYPE( void lock_sched, (int queue) ); _PROTOTYPE( void lock_unready, (struct proc *rp) ); diff --git a/kernel/start.c b/kernel/start.c index b2be5b83e..2f87cffc3 100755 --- a/kernel/start.c +++ b/kernel/start.c @@ -12,7 +12,6 @@ #include "protect.h" #include "proc.h" -FORWARD _PROTOTYPE( void mem_init, (_CONST char *params)); FORWARD _PROTOTYPE( char *get_value, (_CONST char *params, _CONST char *key)); /*==========================================================================* @@ -57,7 +56,8 @@ U16_t parmoff, parmsize; /* boot parameters offset and length */ /* Record miscellaneous information for user-space servers. */ kinfo.nr_procs = NR_PROCS; kinfo.nr_tasks = NR_TASKS; - kstrncpy(kinfo.version, OS_RELEASE "." OS_VERSION, 6); + kstrncpy(kinfo.release, OS_RELEASE, 4); + kstrncpy(kinfo.version, OS_VERSION, 4); kinfo.proc_addr = (vir_bytes) proc; kinfo.kmem_base = vir2phys(0); kinfo.kmem_size = (phys_bytes) &end; @@ -84,79 +84,12 @@ U16_t parmoff, parmsize; /* boot parameters offset and length */ if (kstrcmp(value, "ega") == 0) machine.vdu_ega = TRUE; if (kstrcmp(value, "vga") == 0) machine.vdu_vga = machine.vdu_ega = TRUE; - /* Initialize free memory list from size passed by boot monitor. */ - mem_init(params); - /* Return to assembler code to switch to protected mode (if 286), * reload selectors and call main(). */ } - -/* In real mode only 1M can be addressed, and in 16-bit protected we can go - * no further than we can count in clicks. (The 286 is further limited by - * its 24 bit address bus, but we can assume in that case that no more than - * 16M memory is reported by the BIOS.) - */ -#define MAX_REAL 0x00100000L -#define MAX_16BIT (0xFFF0L << CLICK_SHIFT) - -/*=========================================================================* - * mem_init * - *=========================================================================*/ -PRIVATE void mem_init(params) -_CONST char *params; /* boot monitor parameters */ -{ -/* Initialize the free memory list from the 'memory' boot variable. Translate - * the byte offsets and sizes in this list to clicks, properly truncated. Also - * make sure that we don't exceed the maximum address space of the 286 or the - * 8086, i.e. when running in 16-bit protected mode or real mode. - */ - long base, size, limit; - char *s, *end; /* use to parse boot variable */ - int i; - struct memory *memp; -#if _WORD_SIZE == 2 - unsigned long max_address; -#endif - - /* The available memory is determined by MINIX' boot loader as a list of - * (base:size)-pairs in boothead.s. The 'memory' boot variable is set in - * in boot.s. The format is "b0:s0,b1:s1,b2:s2", where b0:s0 is low mem, - * b1:s1 is mem between 1M and 16M, b2:s2 is mem above 16M. Pairs b1:s1 - * and b2:s2 are combined if the memory is adjacent. - */ - s = get_value(params, "memory"); /* get memory boot variable */ - for (i = 0; i < NR_MEMS; i++) { - memp = &mem[i]; /* next mem chunk is stored here */ - base = size = 0; /* initialize next base:size pair */ - if (*s != 0) { /* get fresh data, unless at end */ - - /* Read fresh base and expect colon as next char. */ - base = kstrtoul(s, &end, 0x10); /* get number */ - if (end != s && *end == ':') s = ++end; /* skip ':' */ - else *s=0; /* terminate, should not happen */ - - /* Read fresh size and expect comma or assume end. */ - size = kstrtoul(s, &end, 0x10); /* get number */ - if (end != s && *end == ',') s = ++end; /* skip ',' */ - else *s=0; /* found end */ - } - limit = base + size; /* limit is used for validity check */ -#if _WORD_SIZE == 2 - max_address = kinfo.protected ? MAX_16BIT : MAX_REAL; - if (limit > max_address) limit = max_address; -#endif - base = (base + CLICK_SIZE-1) & ~(long)(CLICK_SIZE-1); - limit &= ~(long)(CLICK_SIZE-1); - if (limit <= base) continue; - memp->base = base >> CLICK_SHIFT; - memp->size = (limit - base) >> CLICK_SHIFT; - } -} - - /*==========================================================================* * get_value * *==========================================================================*/ diff --git a/kernel/system.c b/kernel/system.c index ebb792258..a040d802a 100755 --- a/kernel/system.c +++ b/kernel/system.c @@ -296,7 +296,7 @@ irq_hook_t *hook; /* Build notification message and return. */ m.NOTIFY_TYPE = HARD_INT; m.NOTIFY_ARG = hook->irq; - lock_notify(hook->proc_nr, &m); + int_notify(hook->proc_nr, &m); return(hook->policy & IRQ_REENABLE); } @@ -308,11 +308,11 @@ PUBLIC void cause_sig(proc_nr, sig_nr) int proc_nr; /* process to be signalled */ int sig_nr; /* signal to be sent, 1 to _NSIG */ { -/* A task wants to send a signal to a process. Examples of such tasks are: +/* A system process wants to send a signal to a process. Examples are: * TTY wanting to cause SIGINT upon getting a DEL * CLOCK wanting to cause SIGALRM when timer expires - * FS also uses this to send a signal, via the SYS_KILL message. Signals are - * handled by sending a message to PM. This central function handles the + * FS wanting to cause SIGPIPE for a broken pipe + * Signals are handled by sending a message to PM. This function handles the * signals and makes sure the PM gets them by sending a notification. The * process being signaled is blocked while PM has not finished all signals * for it. These signals are counted in p_pendcount, and the SIG_PENDING @@ -487,7 +487,7 @@ vir_bytes bytes; /* # of bytes to copy */ /* Check copy count. */ if (bytes <= 0) { - kprintf("v_cp: copy count problem <= 0\n", NO_ARG); + kprintf("v_cp: copy count problem <= 0\n", NO_NUM); return(EDOM); } @@ -523,7 +523,7 @@ vir_bytes bytes; /* # of bytes to copy */ /* Check if mapping succeeded. */ if (phys_addr[i] <= 0 && vir_addr[i]->segment != PHYS_SEG) { - kprintf("v_cp: Mapping failed ... phys <= 0\n", NO_ARG); + kprintf("v_cp: Mapping failed ... phys <= 0\n", NO_NUM); return(EFAULT); } } diff --git a/kernel/system/copying.c b/kernel/system/copying.c index 566744bd2..1f34ccb79 100644 --- a/kernel/system/copying.c +++ b/kernel/system/copying.c @@ -45,7 +45,7 @@ register message *m_ptr; /* pointer to request message */ /* Check if process number was given implictly with SELF and is valid. */ if (vir_addr[i].proc_nr == SELF) vir_addr[i].proc_nr = m_ptr->m_source; if (! isokprocn(vir_addr[i].proc_nr) && vir_addr[i].segment != PHYS_SEG) { - kprintf("do_vircopy: illegal proc nr, while not phys addr\n",NO_ARG); + kprintf("do_vircopy: illegal proc nr, while not phys addr\n",NO_NUM); return(EINVAL); } @@ -58,7 +58,7 @@ register message *m_ptr; /* pointer to request message */ * vir_bytes. Especially copying by the PM on do_fork() is affected. */ if (bytes != (vir_bytes) bytes) { - kprintf("do_vircopy: overflow\n", NO_ARG); + kprintf("do_vircopy: overflow\n", NO_NUM); return(E2BIG); } diff --git a/kernel/system/misc.c b/kernel/system/misc.c index b985828d0..95a67f0a7 100644 --- a/kernel/system/misc.c +++ b/kernel/system/misc.c @@ -105,11 +105,6 @@ register message *m_ptr; /* pointer to request message */ src_phys = vir2phys(irq_hooks); break; } - case GET_MEMCHUNKS: { - length = sizeof(struct memory) * NR_MEMS; - src_phys = vir2phys(mem); - break; - } case GET_SCHEDINFO: { /* This is slightly complicated because we need two data structures * at once, otherwise the scheduling information may be incorrect.