Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. =================================================================== RCS file: /ftp/cvs/cvsroot/src/sys/arch/i386/i386/locore.S,v rcsdiff: /ftp/cvs/cvsroot/src/sys/arch/i386/i386/locore.S,v: warning: Unknown phrases like `commitid ...;' are present. retrieving revision 1.4.2.1 retrieving revision 1.45.2.3 diff -u -p -r1.4.2.1 -r1.45.2.3 --- src/sys/arch/i386/i386/locore.S 2002/12/18 05:00:59 1.4.2.1 +++ src/sys/arch/i386/i386/locore.S 2007/02/27 16:51:38 1.45.2.3 @@ -1,7 +1,7 @@ -/* $NetBSD: locore.S,v 1.4.2.1 2002/12/18 05:00:59 gmcgarry Exp $ */ +/* $NetBSD: locore.S,v 1.45.2.3 2007/02/27 16:51:38 yamt Exp $ */ /*- - * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc. + * Copyright (c) 1998, 2000, 2004 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation @@ -51,11 +51,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors + * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * @@ -74,63 +70,43 @@ * @(#)locore.s 7.3 (Berkeley) 5/13/91 */ +#include "opt_compat_netbsd.h" +#include "opt_compat_oldboot.h" #include "opt_cputype.h" #include "opt_ddb.h" #include "opt_ipkdb.h" -#include "opt_vm86.h" -#include "opt_user_ldt.h" -#include "opt_dummy_nops.h" -#include "opt_compat_oldboot.h" -#include "opt_multiprocessor.h" #include "opt_lockdebug.h" +#include "opt_multiprocessor.h" #include "opt_realmem.h" +#include "opt_user_ldt.h" +#include "opt_vm86.h" #include "npx.h" #include "assym.h" -#include "apm.h" #include "lapic.h" #include "ioapic.h" +#include "ksyms.h" #include #include #include -#include -#include #include #include #include -#include #if NLAPIC > 0 #include #endif +#include + /* LINTSTUB: include */ /* LINTSTUB: include */ /* LINTSTUB: include */ #include -#if defined(MULTIPROCESSOR) - -#define SET_CURPROC(proc,cpu) \ - movl CPUVAR(SELF),cpu ; \ - movl proc,CPUVAR(CURPROC) ; \ - movl cpu,P_CPU(proc) - -#else - -#define SET_CURPROC(proc,tcpu) movl proc,CPUVAR(CURPROC) -#define GET_CURPROC(reg) movl CPUVAR(CURPROC),reg - -#endif - -#define GET_CURPCB(reg) movl CPUVAR(CURPCB),reg -#define SET_CURPCB(reg) movl reg,CPUVAR(CURPCB) - -#define CLEAR_RESCHED(reg) movl reg,CPUVAR(RESCHED) - /* XXX temporary kluge; these should not be here */ /* Get definitions for IOM_BEGIN, IOM_END, and IOM_SIZE */ #include @@ -155,27 +131,6 @@ #ifdef MULTIPROCESSOR #include #endif - -/* - * PTmap is recursive pagemap at top of virtual address space. - * Within PTmap, the page directory can be found (third indirection). - * - * XXX 4 == sizeof pde - */ - .set _C_LABEL(PTmap),(PDSLOT_PTE << PDSHIFT) - .set _C_LABEL(PTD),(_C_LABEL(PTmap) + PDSLOT_PTE * NBPG) - .set _C_LABEL(PTDpde),(_C_LABEL(PTD) + PDSLOT_PTE * 4) - -/* - * APTmap, APTD is the alternate recursive pagemap. - * It's used when modifying another process's page tables. - * - * XXX 4 == sizeof pde - */ - .set _C_LABEL(APTmap),(PDSLOT_APTE << PDSHIFT) - .set _C_LABEL(APTD),(_C_LABEL(APTmap) + PDSLOT_APTE * NBPG) - .set _C_LABEL(APTDpde),(_C_LABEL(PTD) + PDSLOT_APTE * 4) - /* * Initialization @@ -183,63 +138,45 @@ .data .globl _C_LABEL(cpu) - .globl _C_LABEL(cpu_feature) - .globl _C_LABEL(esym),_C_LABEL(boothowto) - .globl _C_LABEL(bootinfo),_C_LABEL(atdevbase) -#ifdef COMPAT_OLDBOOT - .globl _C_LABEL(bootdev) -#endif - .globl _C_LABEL(proc0paddr),_C_LABEL(PTDpaddr) - .globl _C_LABEL(biosbasemem),_C_LABEL(biosextmem) + .globl _C_LABEL(esym) + .globl _C_LABEL(atdevbase) + .globl _C_LABEL(proc0uarea),_C_LABEL(PDPpaddr) .globl _C_LABEL(gdt) #ifdef I586_CPU .globl _C_LABEL(idt) #endif - .globl _C_LABEL(lapic_tpr) - + .globl _C_LABEL(lapic_tpr) + #if NLAPIC > 0 #ifdef __ELF__ - .align NBPG + .align PAGE_SIZE #else .align 12 #endif .globl _C_LABEL(local_apic), _C_LABEL(lapic_id) _C_LABEL(local_apic): .space LAPIC_ID -_C_LABEL(lapic_id): +_C_LABEL(lapic_id): .long 0x00000000 .space LAPIC_TPRI-(LAPIC_ID+4) -_C_LABEL(lapic_tpr): +_C_LABEL(lapic_tpr): .space LAPIC_PPRI-LAPIC_TPRI -_C_LABEL(lapic_ppr): +_C_LABEL(lapic_ppr): .space LAPIC_ISR-LAPIC_PPRI _C_LABEL(lapic_isr): - .space NBPG-LAPIC_ISR + .space PAGE_SIZE-LAPIC_ISR #else -_C_LABEL(lapic_tpr): +_C_LABEL(lapic_tpr): .long 0 #endif - + _C_LABEL(cpu): .long 0 # are we 386, 386sx, or 486, # or Pentium, or.. -_C_LABEL(cpu_feature): .long 0 # feature flags from 'cpuid' - # instruction -_C_LABEL(esym): .long 0 # ptr to end of syms _C_LABEL(atdevbase): .long 0 # location of start of iomem in virtual -_C_LABEL(proc0paddr): .long 0 -_C_LABEL(PTDpaddr): .long 0 # paddr of PTD, for libkvm -#ifndef REALBASEMEM -_C_LABEL(biosbasemem): .long 0 # base memory reported by BIOS -#else -_C_LABEL(biosbasemem): .long REALBASEMEM -#endif -#ifndef REALEXTMEM -_C_LABEL(biosextmem): .long 0 # extended memory reported by BIOS -#else -_C_LABEL(biosextmem): .long REALEXTMEM -#endif - +_C_LABEL(proc0uarea): .long 0 +_C_LABEL(PDPpaddr): .long 0 # paddr of PDP, for libkvm + .space 512 tmpstk: @@ -254,66 +191,47 @@ tmpstk: .globl start start: movw $0x1234,0x472 # warm boot - /* - * Load parameters from stack - * (howto, [bootdev], bootinfo, esym, basemem, extmem). - */ - movl 4(%esp),%eax - movl %eax,RELOC(boothowto) -#ifdef COMPAT_OLDBOOT - movl 8(%esp),%eax - movl %eax,RELOC(bootdev) -#endif - movl 12(%esp),%eax +#if defined(MULTIBOOT) + jmp 1f + + .align 4 + .globl Multiboot_Header +_C_LABEL(Multiboot_Header): +#define MULTIBOOT_HEADER_FLAGS (MULTIBOOT_HEADER_WANT_MEMORY) + .long MULTIBOOT_HEADER_MAGIC + .long MULTIBOOT_HEADER_FLAGS + .long -(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS) - testl %eax, %eax - jz 1f - movl (%eax), %ebx /* number of entries */ - movl $RELOC(bootinfo), %edi - movl %ebx, (%edi) - addl $4, %edi -2: - testl %ebx, %ebx - jz 1f - addl $4, %eax - movl (%eax), %ecx /* address of entry */ - pushl %eax - pushl (%ecx) /* len */ - pushl %ecx - pushl %edi - addl (%ecx), %edi /* update dest pointer */ - cmpl $_RELOC(_C_LABEL(bootinfo) + BOOTINFO_MAXSIZE), %edi - jg 2f - call _C_LABEL(memcpy) - addl $12, %esp - popl %eax - subl $1, %ebx - jmp 2b -2: /* cleanup for overflow case */ - addl $16, %esp - movl $RELOC(bootinfo), %edi - subl %ebx, (%edi) /* correct number of entries */ 1: + /* Check if we are being executed by a Multiboot-compliant boot + * loader. */ + cmpl $MULTIBOOT_INFO_MAGIC,%eax + jne 1f - movl 16(%esp),%eax - testl %eax,%eax - jz 1f - addl $KERNBASE,%eax -1: movl %eax,RELOC(esym) + /* + * Indeed, a multiboot-compliant boot loader executed us. We copy + * the received Multiboot information structure into kernel's data + * space to process it later -- after we are relocated. It will + * be safer to run complex C code than doing it at this point. + */ + pushl %ebx # Address of Multiboot information + call _C_LABEL(multiboot_pre_reloc) + addl $4,%esp + jmp 2f +#endif - movl RELOC(biosextmem),%eax - testl %eax,%eax - jnz 1f - movl 20(%esp),%eax - movl %eax,RELOC(biosextmem) -1: - movl RELOC(biosbasemem),%eax - testl %eax,%eax - jnz 1f - movl 24(%esp),%eax - movl %eax,RELOC(biosbasemem) 1: + /* + * At this point, we know that a NetBSD-specific boot loader + * booted this kernel. The stack carries the following parameters: + * (boothowto, [bootdev], bootinfo, esym, biosextmem, biosbasemem), + * 4 bytes each. + */ + addl $4,%esp # Discard return address to boot loader + call _C_LABEL(native_loader) + addl $24,%esp +2: /* First, reset the PSL. */ pushl $PSL_MBO popfl @@ -503,17 +421,17 @@ try586: /* Use the `cpuid' instruction. /* * Virtual address space of kernel: * - * text | data | bss | [syms] | page dir | proc0 kstack + * text | data | bss | [syms] | page dir | proc0 kstack * 0 1 2 3 */ -#define PROC0PDIR ((0) * NBPG) -#define PROC0STACK ((1) * NBPG) -#define SYSMAP ((1+UPAGES) * NBPG) -#define TABLESIZE ((1+UPAGES) * NBPG) /* + nkpde * NBPG */ +#define PROC0PDIR ((0) * PAGE_SIZE) +#define PROC0STACK ((1) * PAGE_SIZE) +#define SYSMAP ((1+UPAGES) * PAGE_SIZE) +#define TABLESIZE ((1+UPAGES) * PAGE_SIZE) /* + nkpde * PAGE_SIZE */ /* Find end of kernel image. */ movl $RELOC(end),%edi -#if defined(DDB) && !defined(SYMTAB_SPACE) +#if (NKSYMS || defined(DDB) || defined(LKM)) && !defined(SYMTAB_SPACE) /* Save the symbols (if loaded). */ movl RELOC(esym),%eax testl %eax,%eax @@ -530,17 +448,24 @@ try586: /* Use the `cpuid' instruction. /* * Calculate the size of the kernel page table directory, and - * how many entries it will have. + * how many entries it will have. Adjust nkpde to the actual + * kernel size automatically. Account for the bootstrap tables, + * round up, and add an extra 4MB. */ + leal TABLESIZE+NBPD+PDOFSET(%edi),%eax + shrl $PDSHIFT,%eax movl RELOC(nkpde),%ecx # get nkpde - cmpl $NKPTP_MIN,%ecx # larger than min? + cmpl %ecx,%eax + jb 1f + movl %eax,%ecx +1: cmpl $NKPTP_MIN,%ecx # larger than min? jge 1f movl $NKPTP_MIN,%ecx # set at min jmp 2f 1: cmpl $NKPTP_MAX,%ecx # larger than max? jle 2f movl $NKPTP_MAX,%ecx -2: +2: movl %ecx,RELOC(nkpde) /* Clear memory for bootstrap tables. */ shll $PGSHIFT,%ecx @@ -561,7 +486,7 @@ try586: /* Use the `cpuid' instruction. */ #define fillkpt \ 1: movl %eax,(%ebx) ; \ - addl $NBPG,%eax ; /* increment physical address */ \ + addl $PAGE_SIZE,%eax ; /* increment physical address */ \ addl $4,%ebx ; /* next pte */ \ loop 1b ; @@ -571,7 +496,7 @@ try586: /* Use the `cpuid' instruction. /* Calculate end of text segment, rounded to a page. */ leal (RELOC(etext)+PGOFSET),%edx andl $~PGOFSET,%edx - + /* Skip over the first 1MB. */ movl $_RELOC(KERNTEXTOFF),%eax movl %eax,%ecx @@ -619,8 +544,8 @@ try586: /* Use the `cpuid' instruction. leal (PROC0PDIR+PG_V|PG_KW)(%esi),%eax # pte for ptd movl %eax,(PROC0PDIR+PDSLOT_PTE*4)(%esi) # recursive PD slot - /* Save phys. addr of PTD, for libkvm. */ - movl %esi,RELOC(PTDpaddr) + /* Save phys. addr of PDP, for libkvm. */ + movl %esi,RELOC(PDPpaddr) /* Load base of page directory and enable mapping. */ movl %esi,%eax # phys address of ptd in proc 0 @@ -651,16 +576,24 @@ begin: /* Set up bootstrap stack. */ leal (PROC0STACK+KERNBASE)(%esi),%eax - movl %eax,_C_LABEL(proc0paddr) - leal (USPACE-FRAMESIZE)(%eax),%esp - movl %esi,PCB_CR3(%eax) # pcb->pcb_cr3 + movl %eax,_C_LABEL(proc0uarea) + leal (KSTACK_SIZE-FRAMESIZE)(%eax),%esp + movl %esi,(KSTACK_SIZE+PCB_CR3)(%eax) # pcb->pcb_cr3 xorl %ebp,%ebp # mark end of frames +#if defined(MULTIBOOT) + /* It is now safe to parse the Multiboot information structure + * we saved before from C code. Note that we cannot delay its + * parsing any more because initgdt (called below) needs to make + * use of this information. */ + call _C_LABEL(multiboot_post_reloc) +#endif + subl $NGDT*8, %esp # space for temporary gdt pushl %esp call _C_LABEL(initgdt) addl $4,%esp - + movl _C_LABEL(nkpde),%eax shll $PGSHIFT,%eax addl $TABLESIZE,%eax @@ -691,27 +624,29 @@ begin: call _C_LABEL(main) /* - * void proc_trampoline(void); + * void lwp_trampoline(void); * This is a trampoline function pushed onto the stack of a newly created * process in order to do some additional setup. The trampoline is entered by * cpu_switch()ing to the process, so we abuse the callee-saved registers used * by cpu_switch() to store the information about the stub to call. * NOTE: This function does not have a normal calling sequence! */ -/* LINTSTUB: Func: void proc_trampoline(void) */ -NENTRY(proc_trampoline) -#ifdef MULTIPROCESSOR - call _C_LABEL(proc_trampoline_mp) -#endif - movl $IPL_NONE,CPUVAR(ILEVEL) +/* LINTSTUB: Func: void lwp_trampoline(void) */ +NENTRY(lwp_trampoline) + pushl %ebp + xorl %ebp,%ebp + pushl %eax + call _C_LABEL(lwp_startup) + addl $8,%esp pushl %ebx call *%esi addl $4,%esp + DO_DEFERRED_SWITCH(%eax) INTRFASTEXIT /* NOTREACHED */ /*****************************************************************************/ - +#ifdef COMPAT_16 /* * Signal trampoline; copied to top of user stack. */ @@ -724,1349 +659,221 @@ NENTRY(sigcode) leal 12(%esp),%eax # get pointer to sigcontext movl %eax,4(%esp) # put it in the argument slot # fake return address already there - movl $SYS___sigreturn14,%eax + movl $SYS_compat_16___sigreturn14,%eax int $0x80 # enter kernel with args on stack movl $SYS_exit,%eax int $0x80 # exit if sigreturn fails .globl _C_LABEL(esigcode) _C_LABEL(esigcode): +#endif /*****************************************************************************/ /* - * The following primitives are used to fill and copy regions of memory. + * The following is i386-specific nonsense. */ /* - * XXX No section 9 man page for fillw. - * fillw seems to be very sparsely used (only in pccons it seems.) - * One wonders if it couldn't be done without. - * -- Perry Metzger, May 7, 2001 - */ -/* - * void fillw(short pattern, void *addr, size_t len); - * Write len copies of pattern at addr. + * void lgdt(struct region_descriptor *rdp); + * Load a new GDT pointer (and do any necessary cleanup). + * XXX It's somewhat questionable whether reloading all the segment registers + * is necessary, since the actual descriptor data is not changed except by + * process creation and exit, both of which clean up via task switches. OTOH, + * this only happens at run time when the GDT is resized. */ -/* LINTSTUB: Func: void fillw(short pattern, void *addr, size_t len) */ -ENTRY(fillw) - pushl %edi - movl 8(%esp),%eax - movl 12(%esp),%edi - movw %ax,%cx - rorl $16,%eax - movw %cx,%ax - cld - movl 16(%esp),%ecx - shrl %ecx # do longwords - rep - stosl - movl 16(%esp),%ecx - andl $1,%ecx # do remainder - rep - stosw - popl %edi - ret +/* LINTSTUB: Func: void lgdt(struct region_descriptor *rdp) */ +NENTRY(lgdt) + /* Reload the descriptor table. */ + movl 4(%esp),%eax + lgdt (%eax) + /* Flush the prefetch queue. */ + jmp 1f + nop +1: /* Reload "stale" selectors. */ + movl $GSEL(GDATA_SEL, SEL_KPL),%eax + movw %ax,%ds + movw %ax,%es + movw %ax,%gs + movw %ax,%ss + movl $GSEL(GCPU_SEL, SEL_KPL),%eax + movw %ax,%fs + /* Reload code selector by doing intersegment return. */ + popl %eax + pushl $GSEL(GCODE_SEL, SEL_KPL) + pushl %eax + lret + +NENTRY(x86_flush) + /* Reload code selector by doing intersegment return. */ + popl %eax + pushl $GSEL(GCODE_SEL, SEL_KPL) + pushl %eax + lret + +/*****************************************************************************/ /* - * int kcopy(const void *from, void *to, size_t len); - * Copy len bytes, abort on fault. + * These functions are primarily used by DDB. */ -/* LINTSTUB: Func: int kcopy(const void *from, void *to, size_t len) */ -ENTRY(kcopy) - pushl %esi - pushl %edi - GET_CURPCB(%eax) # load curpcb into eax and set on-fault - pushl PCB_ONFAULT(%eax) - movl $_C_LABEL(copy_fault), PCB_ONFAULT(%eax) - - movl 16(%esp),%esi - movl 20(%esp),%edi - movl 24(%esp),%ecx - movl %edi,%eax - subl %esi,%eax - cmpl %ecx,%eax # overlapping? - jb 1f - cld # nope, copy forward - shrl $2,%ecx # copy by 32-bit words - rep - movsl - movl 24(%esp),%ecx - andl $3,%ecx # any bytes left? - rep - movsb - GET_CURPCB(%edx) # XXX save curpcb? - popl PCB_ONFAULT(%edx) - popl %edi - popl %esi - xorl %eax,%eax +/* LINTSTUB: Func: int setjmp (label_t *l) */ +ENTRY(setjmp) + movl 4(%esp),%eax + movl %ebx,(%eax) # save ebx + movl %esp,4(%eax) # save esp + movl %ebp,8(%eax) # save ebp + movl %esi,12(%eax) # save esi + movl %edi,16(%eax) # save edi + movl (%esp),%edx # get rta + movl %edx,20(%eax) # save eip + xorl %eax,%eax # return (0); ret - ALIGN_TEXT -1: addl %ecx,%edi # copy backward - addl %ecx,%esi - std - andl $3,%ecx # any fractional bytes? - decl %edi - decl %esi - rep - movsb - movl 24(%esp),%ecx # copy remainder by 32-bit words - shrl $2,%ecx - subl $3,%esi - subl $3,%edi - rep - movsl - cld - - GET_CURPCB(%edx) - popl PCB_ONFAULT(%edx) - popl %edi - popl %esi - xorl %eax,%eax +/* LINTSTUB: Func: void longjmp (label_t *l) */ +ENTRY(longjmp) + movl 4(%esp),%eax + movl (%eax),%ebx # restore ebx + movl 4(%eax),%esp # restore esp + movl 8(%eax),%ebp # restore ebp + movl 12(%eax),%esi # restore esi + movl 16(%eax),%edi # restore edi + movl 20(%eax),%edx # get rta + movl %edx,(%esp) # put in return frame + xorl %eax,%eax # return (1); + incl %eax ret /*****************************************************************************/ -/* - * The following primitives are used to copy data in and out of the user's - * address space. - */ - -/* - * Default to the lowest-common-denominator. We will improve it - * later. - */ -#if defined(I386_CPU) -#define DEFAULT_COPYOUT _C_LABEL(i386_copyout) -#define DEFAULT_COPYIN _C_LABEL(i386_copyin) -#elif defined(I486_CPU) -#define DEFAULT_COPYOUT _C_LABEL(i486_copyout) -#define DEFAULT_COPYIN _C_LABEL(i386_copyin) -#elif defined(I586_CPU) -#define DEFAULT_COPYOUT _C_LABEL(i486_copyout) /* XXX */ -#define DEFAULT_COPYIN _C_LABEL(i386_copyin) /* XXX */ -#elif defined(I686_CPU) -#define DEFAULT_COPYOUT _C_LABEL(i486_copyout) /* XXX */ -#define DEFAULT_COPYIN _C_LABEL(i386_copyin) /* XXX */ -#endif - - .data - - .globl _C_LABEL(copyout_func) -_C_LABEL(copyout_func): - .long DEFAULT_COPYOUT - - .globl _C_LABEL(copyin_func) -_C_LABEL(copyin_func): - .long DEFAULT_COPYIN + .globl _C_LABEL(uvmexp),_C_LABEL(panic) - .text +#ifdef DIAGNOSTIC +NENTRY(switch_error) + pushl $1f + call _C_LABEL(panic) + /* NOTREACHED */ +1: .asciz "cpu_switch" +#endif /* DIAGNOSTIC */ /* - * int copyout(const void *from, void *to, size_t len); - * Copy len bytes into the user's address space. - * see copyout(9) + * struct lwp *cpu_switchto(struct lwp *oldlwp, struct newlwp) + * + * 1. if (oldlwp != NULL), save its context. + * 2. then, restore context of newlwp. + * + * Note that the stack frame layout is known to "struct switchframe" + * in and to the code in cpu_lwp_fork() which initializes + * it for a new lwp. */ -/* LINTSTUB: Func: int copyout(const void *kaddr, void *uaddr, size_t len) */ -ENTRY(copyout) - jmp *_C_LABEL(copyout_func) - -#if defined(I386_CPU) -/* LINTSTUB: Func: int i386_copyout(const void *kaddr, void *uaddr, size_t len) */ -ENTRY(i386_copyout) +ENTRY(cpu_switchto) + pushl %ebx pushl %esi pushl %edi - pushl $0 - - movl 16(%esp),%esi - movl 20(%esp),%edi - movl 24(%esp),%eax + + movl 16(%esp),%esi # oldlwp + movl 20(%esp),%edi # newlwp + + testl %esi,%esi + jz switch_skipsave /* - * We check that the end of the destination buffer is not past the end - * of the user's address space. If it's not, then we only need to - * check that each page is writable. The 486 will do this for us; the - * 386 will not. (We assume that pages in user space that are not - * writable by the user are not writable by the kernel either.) + * Save old context. */ - movl %edi,%edx - addl %eax,%edx - jc _C_LABEL(copy_efault) - cmpl $VM_MAXUSER_ADDRESS,%edx - ja _C_LABEL(copy_efault) - testl %eax,%eax # anything to do? - jz 3f + movl L_ADDR(%esi),%eax + movl %esp,PCB_ESP(%eax) + movl %ebp,PCB_EBP(%eax) + +switch_skipsave: /* - * We have to check each PTE for (write) permission, since the CPU - * doesn't do it for us. + * Switch to newlwp's stack. */ - /* Compute number of pages. */ - movl %edi,%ecx - andl $PGOFSET,%ecx - addl %eax,%ecx - decl %ecx - shrl $PGSHIFT,%ecx + movl L_ADDR(%edi),%ebx + movl PCB_EBP(%ebx),%ebp + movl PCB_ESP(%ebx),%esp - /* Compute PTE offset for start address. */ - shrl $PGSHIFT,%edi + /* + * Restore the rest of newlwp's context. + * + * Registers: + * %ebx - new pcb + * %edi - new lwp + */ - GET_CURPCB(%edx) - movl $2f,PCB_ONFAULT(%edx) +#if 0 + /* Don't bother with the rest if switching to a system process. */ + testl $LK_SYSTEM,L_FLAG(%edi); + jnz switch_restored +#endif -1: /* Check PTE for each page. */ - testb $PG_RW,_C_LABEL(PTmap)(,%edi,4) - jz 2f - -4: incl %edi - decl %ecx - jns 1b - - movl 20(%esp),%edi - movl 24(%esp),%eax - jmp 3f - -2: /* Simulate a trap. */ - pushl %ecx - movl %edi,%eax - shll $PGSHIFT,%eax - pushl %eax - call _C_LABEL(trapwrite) # trapwrite(addr) - addl $4,%esp # pop argument - popl %ecx - testl %eax,%eax # if not ok, return EFAULT - jz 4b - jmp _C_LABEL(copy_efault) + /* Switch TSS. Reset "task busy" flag before loading. */ + movl %cr3,%eax + movl %eax,PCB_CR3(%ebx) /* for TSS gates */ -3: GET_CURPCB(%edx) - movl $_C_LABEL(copy_fault),PCB_ONFAULT(%edx) +#ifdef MULTIPROCESSOR + movl CPUVAR(GDT),%eax +#else + /* Load TSS info. */ + movl _C_LABEL(gdt),%eax +#endif + movl L_MD_TSS_SEL(%edi),%edx - /* bcopy(%esi, %edi, %eax); */ - cld - movl %eax,%ecx - shrl $2,%ecx - rep - movsl - movl %eax,%ecx - andl $3,%ecx - rep - movsb + andl $~0x0200,4(%eax,%edx, 1) + ltr %dx - popl PCB_ONFAULT(%edx) - popl %edi - popl %esi - xorl %eax,%eax - ret -#endif /* I386_CPU */ +#if 0 +switch_restored: +#endif -#if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU) -/* LINTSTUB: Func: int i486_copyout(const void *kaddr, void *uaddr, size_t len) */ -ENTRY(i486_copyout) - pushl %esi - pushl %edi - pushl $0 - - movl 16(%esp),%esi - movl 20(%esp),%edi - movl 24(%esp),%eax + movl $0,CPUVAR(RESCHED) + /* Restore cr0 (including FPU state). */ + cli + movl PCB_CR0(%ebx),%ecx +#ifdef MULTIPROCESSOR /* - * We check that the end of the destination buffer is not past the end - * of the user's address space. + * If our floating point registers are on a different CPU, + * set CR0_TS so we'll trap rather than reuse bogus state. */ - movl %edi,%edx - addl %eax,%edx - jc _C_LABEL(copy_efault) - cmpl $VM_MAXUSER_ADDRESS,%edx - ja _C_LABEL(copy_efault) + movl PCB_FPCPU(%ebx),%eax + cmpl CPUVAR(SELF),%eax + jz 1f + orl $CR0_TS,%ecx +1: +#endif + movl %ecx,%cr0 - GET_CURPCB(%edx) - movl $_C_LABEL(copy_fault),PCB_ONFAULT(%edx) + /* Interrupts are okay again. */ + sti - /* bcopy(%esi, %edi, %eax); */ - cld - movl %eax,%ecx - shrl $2,%ecx - rep - movsl - movl %eax,%ecx - andl $3,%ecx - rep - movsb + /* + * Check for restartable atomic sequences (RAS) + */ + + movl L_PROC(%edi),%ebx + cmpl $0,P_RASLIST(%ebx) + jne check_ras - popl PCB_ONFAULT(%edx) +switch_return: + movl %esi,%eax # return 'oldlwp' popl %edi popl %esi - xorl %eax,%eax + popl %ebx ret -#endif /* I486_CPU || I586_CPU || I686_CPU */ -/* - * int copyin(const void *from, void *to, size_t len); - * Copy len bytes from the user's address space. - * see copyin(9) - */ -/* LINTSTUB: Func: int copyin(const void *uaddr, void *kaddr, size_t len) */ -ENTRY(copyin) - jmp *_C_LABEL(copyin_func) - -#if defined(I386_CPU) || defined(I486_CPU) || defined(I586_CPU) || \ - defined(I686_CPU) -/* LINTSTUB: Func: int i386_copyin(const void *uaddr, void *kaddr, size_t len) */ -ENTRY(i386_copyin) +check_ras: + movl L_MD_REGS(%edi),%ebx + movl TF_EIP(%ebx),%eax + pushl %eax pushl %esi - pushl %edi - GET_CURPCB(%eax) - pushl $0 - movl $_C_LABEL(copy_fault),PCB_ONFAULT(%eax) - - movl 16(%esp),%esi - movl 20(%esp),%edi - movl 24(%esp),%eax - - /* - * We check that the end of the destination buffer is not past the end - * of the user's address space. If it's not, then we only need to - * check that each page is readable, and the CPU will do that for us. - */ - movl %esi,%edx - addl %eax,%edx - jc _C_LABEL(copy_efault) - cmpl $VM_MAXUSER_ADDRESS,%edx - ja _C_LABEL(copy_efault) - - /* bcopy(%esi, %edi, %eax); */ - cld - movl %eax,%ecx - shrl $2,%ecx - rep - movsl - movl %eax,%ecx - andl $3,%ecx - rep - movsb - - GET_CURPCB(%edx) - popl PCB_ONFAULT(%edx) - popl %edi - popl %esi - xorl %eax,%eax - ret -#endif /* I386_CPU || I486_CPU || I586_CPU || I686_CPU */ - -/* LINTSTUB: Ignore */ -NENTRY(copy_efault) - movl $EFAULT,%eax - -/* LINTSTUB: Ignore */ -NENTRY(copy_fault) - GET_CURPCB(%edx) - popl PCB_ONFAULT(%edx) - popl %edi - popl %esi - ret - -/* - * int copyoutstr(const void *from, void *to, size_t maxlen, size_t *lencopied); - * Copy a NUL-terminated string, at most maxlen characters long, into the - * user's address space. Return the number of characters copied (including the - * NUL) in *lencopied. If the string is too long, return ENAMETOOLONG; else - * return 0 or EFAULT. - * see copyoutstr(9) - */ -/* LINTSTUB: Func: int copyoutstr(const void *kaddr, void *uaddr, size_t len, size_t *done) */ -ENTRY(copyoutstr) - pushl %esi - pushl %edi - - movl 12(%esp),%esi # esi = from - movl 16(%esp),%edi # edi = to - movl 20(%esp),%edx # edx = maxlen - -#if defined(I386_CPU) -#if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU) - cmpl $CPUCLASS_386,_C_LABEL(cpu_class) - jne 5f -#endif /* I486_CPU || I586_CPU || I686_CPU */ - - /* Compute number of bytes in first page. */ - movl %edi,%eax - andl $PGOFSET,%eax - movl $NBPG,%ecx - subl %eax,%ecx # ecx = NBPG - (src % NBPG) - - GET_CURPCB(%eax) - movl $6f,PCB_ONFAULT(%eax) - -1: /* - * Once per page, check that we are still within the bounds of user - * space, and check for a write fault. - */ - cmpl $VM_MAXUSER_ADDRESS,%edi - jae _C_LABEL(copystr_efault) - - /* Compute PTE offset. */ - movl %edi,%eax - shrl $PGSHIFT,%eax # calculate pte address - - testb $PG_RW,_C_LABEL(PTmap)(,%eax,4) - jnz 2f - -6: /* Simulate a trap. */ - pushl %edx - pushl %edi - call _C_LABEL(trapwrite) # trapwrite(addr) - addl $4,%esp # clear argument from stack - popl %edx - testl %eax,%eax - jnz _C_LABEL(copystr_efault) - -2: /* Copy up to end of this page. */ - subl %ecx,%edx # predecrement total count - jnc 3f - addl %edx,%ecx # ecx += (edx - ecx) = edx - xorl %edx,%edx - -3: decl %ecx - js 4f - lodsb - stosb - testb %al,%al - jnz 3b - - /* Success -- 0 byte reached. */ - addl %ecx,%edx # add back residual for this page - xorl %eax,%eax - jmp copystr_return - -4: /* Go to next page, if any. */ - movl $NBPG,%ecx - testl %edx,%edx - jnz 1b - - /* edx is zero -- return ENAMETOOLONG. */ - movl $ENAMETOOLONG,%eax - jmp copystr_return -#endif /* I386_CPU */ - -#if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU) -5: GET_CURPCB(%eax) - movl $_C_LABEL(copystr_fault),PCB_ONFAULT(%eax) - /* - * Get min(%edx, VM_MAXUSER_ADDRESS-%edi). - */ - movl $VM_MAXUSER_ADDRESS,%eax - subl %edi,%eax - cmpl %edx,%eax - jae 1f - movl %eax,%edx - movl %eax,20(%esp) - -1: incl %edx - cld - -1: decl %edx - jz 2f - lodsb - stosb - testb %al,%al - jnz 1b - - /* Success -- 0 byte reached. */ - decl %edx - xorl %eax,%eax - jmp copystr_return - -2: /* edx is zero -- return EFAULT or ENAMETOOLONG. */ - cmpl $VM_MAXUSER_ADDRESS,%edi - jae _C_LABEL(copystr_efault) - movl $ENAMETOOLONG,%eax - jmp copystr_return -#endif /* I486_CPU || I586_CPU || I686_CPU */ - -/* - * int copyinstr(const void *from, void *to, size_t maxlen, size_t *lencopied); - * Copy a NUL-terminated string, at most maxlen characters long, from the - * user's address space. Return the number of characters copied (including the - * NUL) in *lencopied. If the string is too long, return ENAMETOOLONG; else - * return 0 or EFAULT. - * see copyinstr(9) - */ -/* LINTSTUB: Func: int copyinstr(const void *uaddr, void *kaddr, size_t len, size_t *done) */ -ENTRY(copyinstr) - pushl %esi - pushl %edi - GET_CURPCB(%ecx) - movl $_C_LABEL(copystr_fault),PCB_ONFAULT(%ecx) - - movl 12(%esp),%esi # %esi = from - movl 16(%esp),%edi # %edi = to - movl 20(%esp),%edx # %edx = maxlen - - /* - * Get min(%edx, VM_MAXUSER_ADDRESS-%esi). - */ - movl $VM_MAXUSER_ADDRESS,%eax - subl %esi,%eax - cmpl %edx,%eax - jae 1f - movl %eax,%edx - movl %eax,20(%esp) - -1: incl %edx - cld - -1: decl %edx - jz 2f - lodsb - stosb - testb %al,%al - jnz 1b - - /* Success -- 0 byte reached. */ - decl %edx - xorl %eax,%eax - jmp copystr_return - -2: /* edx is zero -- return EFAULT or ENAMETOOLONG. */ - cmpl $VM_MAXUSER_ADDRESS,%esi - jae _C_LABEL(copystr_efault) - movl $ENAMETOOLONG,%eax - jmp copystr_return - -/* LINTSTUB: Ignore */ -NENTRY(copystr_efault) - movl $EFAULT,%eax - -/* LINTSTUB: Ignore */ -NENTRY(copystr_fault) -copystr_return: - /* Set *lencopied and return %eax. */ - GET_CURPCB(%ecx) - movl $0,PCB_ONFAULT(%ecx) - movl 20(%esp),%ecx - subl %edx,%ecx - movl 24(%esp),%edx - testl %edx,%edx - jz 8f - movl %ecx,(%edx) - -8: popl %edi - popl %esi - ret - -/* - * int copystr(const void *from, void *to, size_t maxlen, size_t *lencopied); - * Copy a NUL-terminated string, at most maxlen characters long. Return the - * number of characters copied (including the NUL) in *lencopied. If the - * string is too long, return ENAMETOOLONG; else return 0. - * see copystr(9) - */ -/* LINTSTUB: Func: int copystr(const void *kfaddr, void *kdaddr, size_t len, size_t *done) */ -ENTRY(copystr) - pushl %esi - pushl %edi - - movl 12(%esp),%esi # esi = from - movl 16(%esp),%edi # edi = to - movl 20(%esp),%edx # edx = maxlen - incl %edx - cld - -1: decl %edx - jz 4f - lodsb - stosb - testb %al,%al - jnz 1b - - /* Success -- 0 byte reached. */ - decl %edx - xorl %eax,%eax - jmp 6f - -4: /* edx is zero -- return ENAMETOOLONG. */ - movl $ENAMETOOLONG,%eax - -6: /* Set *lencopied and return %eax. */ - movl 20(%esp),%ecx - subl %edx,%ecx - movl 24(%esp),%edx - testl %edx,%edx - jz 7f - movl %ecx,(%edx) - -7: popl %edi - popl %esi - ret - -/* - * long fuword(const void *uaddr); - * Fetch an int from the user's address space. - * see fuword(9) - */ -/* LINTSTUB: Func: long fuword(const void *base) */ -ENTRY(fuword) - movl 4(%esp),%edx - cmpl $VM_MAXUSER_ADDRESS-4,%edx - ja _C_LABEL(fusuaddrfault) - GET_CURPCB(%ecx) - movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx) - movl (%edx),%eax - movl $0,PCB_ONFAULT(%ecx) - ret - -/* - * int fusword(const void *uaddr); - * Fetch a short from the user's address space. - * see fusword(9) - */ -/* LINTSTUB: Func: int fusword(const void *base) */ -ENTRY(fusword) - movl 4(%esp),%edx - cmpl $VM_MAXUSER_ADDRESS-2,%edx - ja _C_LABEL(fusuaddrfault) - GET_CURPCB(%ecx) - movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx) - movzwl (%edx),%eax - movl $0,PCB_ONFAULT(%ecx) - ret - -/* - * int fuswintr(const void *uaddr); - * Fetch a short from the user's address space. Can be called during an - * interrupt. - * see fuswintr(9) - */ -/* LINTSTUB: Func: int fuswintr(const void *base) */ -ENTRY(fuswintr) - movl 4(%esp),%edx - cmpl $VM_MAXUSER_ADDRESS-2,%edx - ja _C_LABEL(fusuaddrfault) - movl CPUVAR(CURPROC),%ecx - movl P_ADDR(%ecx),%ecx - movl $_C_LABEL(fusubail),PCB_ONFAULT(%ecx) - movzwl (%edx),%eax - movl $0,PCB_ONFAULT(%ecx) - ret - -/* - * int fubyte(const void *uaddr); - * Fetch a byte from the user's address space. - * see fubyte(9) - */ -/* LINTSTUB: Func: int fubyte(const void *base) */ -ENTRY(fubyte) - movl 4(%esp),%edx - cmpl $VM_MAXUSER_ADDRESS-1,%edx - ja _C_LABEL(fusuaddrfault) - GET_CURPCB(%ecx) - movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx) - movzbl (%edx),%eax - movl $0,PCB_ONFAULT(%ecx) - ret - -/* - * Handle faults from [fs]u*(). Clean up and return -1. - */ -/* LINTSTUB: Ignore */ -NENTRY(fusufault) - movl $0,PCB_ONFAULT(%ecx) - movl $-1,%eax - ret - -/* - * Handle faults from [fs]u*(). Clean up and return -1. This differs from - * fusufault() in that trap() will recognize it and return immediately rather - * than trying to page fault. - */ -/* LINTSTUB: Ignore */ -NENTRY(fusubail) - movl $0,PCB_ONFAULT(%ecx) - movl $-1,%eax - ret - -/* - * Handle earlier faults from [fs]u*(), due to our of range addresses. - */ -/* LINTSTUB: Ignore */ -NENTRY(fusuaddrfault) - movl $-1,%eax - ret - -/* - * int suword(void *uaddr, long x); - * Store an int in the user's address space. - * see suword(9) - */ -/* LINTSTUB: Func: int suword(void *base, long c) */ -ENTRY(suword) - movl 4(%esp),%edx - cmpl $VM_MAXUSER_ADDRESS-4,%edx - ja _C_LABEL(fusuaddrfault) - -#if defined(I386_CPU) -#if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU) - cmpl $CPUCLASS_386,_C_LABEL(cpu_class) - jne 2f -#endif /* I486_CPU || I586_CPU || I686_CPU */ - - GET_CURPCB(%eax) - movl $3f,PCB_ONFAULT(%eax) - - movl %edx,%eax - shrl $PGSHIFT,%eax # calculate pte address - testb $PG_RW,_C_LABEL(PTmap)(,%eax,4) - jnz 1f - -3: /* Simulate a trap. */ - pushl %edx - pushl %edx - call _C_LABEL(trapwrite) # trapwrite(addr) - addl $4,%esp # clear parameter from the stack - popl %edx - GET_CURPCB(%ecx) - testl %eax,%eax - jnz _C_LABEL(fusufault) - -1: /* XXX also need to check the following 3 bytes for validity! */ -#endif - -2: GET_CURPCB(%ecx) - movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx) - - movl 8(%esp),%eax - movl %eax,(%edx) - xorl %eax,%eax - movl %eax,PCB_ONFAULT(%ecx) - ret - -/* - * int susword(void *uaddr, short x); - * Store a short in the user's address space. - * see susword(9) - */ -/* LINTSTUB: Func: int susword(void *base, short c) */ -ENTRY(susword) - movl 4(%esp),%edx - cmpl $VM_MAXUSER_ADDRESS-2,%edx - ja _C_LABEL(fusuaddrfault) - -#if defined(I386_CPU) -#if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU) - cmpl $CPUCLASS_386,_C_LABEL(cpu_class) - jne 2f -#endif /* I486_CPU || I586_CPU || I686_CPU */ - - GET_CURPCB(%eax) - movl $3f,PCB_ONFAULT(%eax) - - movl %edx,%eax - shrl $PGSHIFT,%eax # calculate pte address - testb $PG_RW,_C_LABEL(PTmap)(,%eax,4) - jnz 1f - -3: /* Simulate a trap. */ - pushl %edx - pushl %edx - call _C_LABEL(trapwrite) # trapwrite(addr) - addl $4,%esp # clear parameter from the stack - popl %edx - GET_CURPCB(%ecx) - testl %eax,%eax - jnz _C_LABEL(fusufault) - -1: /* XXX also need to check the following byte for validity! */ -#endif - -2: GET_CURPCB(%ecx) - movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx) - - movl 8(%esp),%eax - movw %ax,(%edx) - xorl %eax,%eax - movl %eax,PCB_ONFAULT(%ecx) - ret - -/* - * int suswintr(void *uaddr, short x); - * Store a short in the user's address space. Can be called during an - * interrupt. - * see suswintr(9) - */ -/* LINTSTUB: Func: int suswintr(void *base, short c) */ -ENTRY(suswintr) - movl 4(%esp),%edx - cmpl $VM_MAXUSER_ADDRESS-2,%edx - ja _C_LABEL(fusuaddrfault) - movl CPUVAR(CURPROC),%ecx - movl P_ADDR(%ecx),%ecx - movl $_C_LABEL(fusubail),PCB_ONFAULT(%ecx) - -#if defined(I386_CPU) -#if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU) - cmpl $CPUCLASS_386,_C_LABEL(cpu_class) - jne 2f -#endif /* I486_CPU || I586_CPU || I686_CPU */ - - movl %edx,%eax - shrl $PGSHIFT,%eax # calculate pte address - testb $PG_RW,_C_LABEL(PTmap)(,%eax,4) - jnz 1f - - /* Simulate a trap. */ - jmp _C_LABEL(fusubail) - -1: /* XXX also need to check the following byte for validity! */ -#endif - -2: movl 8(%esp),%eax - movw %ax,(%edx) - xorl %eax,%eax - movl %eax,PCB_ONFAULT(%ecx) - ret - -/* - * int subyte(void *uaddr, char x); - * Store a byte in the user's address space. - * see subyte(9) - */ -/* LINTSTUB: Func: int subyte(void *base, int c) */ -ENTRY(subyte) - movl 4(%esp),%edx - cmpl $VM_MAXUSER_ADDRESS-1,%edx - ja _C_LABEL(fusuaddrfault) - -#if defined(I386_CPU) -#if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU) - cmpl $CPUCLASS_386,_C_LABEL(cpu_class) - jne 2f -#endif /* I486_CPU || I586_CPU || I686_CPU */ - - GET_CURPCB(%eax) - movl $3f,PCB_ONFAULT(%eax) - - movl %edx,%eax - shrl $PGSHIFT,%eax # calculate pte address - testb $PG_RW,_C_LABEL(PTmap)(,%eax,4) - jnz 1f - -3: /* Simulate a trap. */ - pushl %edx - pushl %edx - call _C_LABEL(trapwrite) # trapwrite(addr) - addl $4,%esp # clear parameter from the stack - popl %edx - GET_CURPCB(%ecx) - testl %eax,%eax - jnz _C_LABEL(fusufault) - -1: -#endif - -2: GET_CURPCB(%ecx) - movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx) - - movb 8(%esp),%al - movb %al,(%edx) - xorl %eax,%eax - movl %eax,PCB_ONFAULT(%ecx) - ret - -/*****************************************************************************/ - -/* - * The following is i386-specific nonsense. - */ - -/* - * void lgdt(struct region_descriptor *rdp); - * Load a new GDT pointer (and do any necessary cleanup). - * XXX It's somewhat questionable whether reloading all the segment registers - * is necessary, since the actual descriptor data is not changed except by - * process creation and exit, both of which clean up via task switches. OTOH, - * this only happens at run time when the GDT is resized. - */ -/* LINTSTUB: Func: void lgdt(struct region_descriptor *rdp) */ -NENTRY(lgdt) - /* Reload the descriptor table. */ - movl 4(%esp),%eax - lgdt (%eax) - /* Flush the prefetch queue. */ - jmp 1f - nop -1: /* Reload "stale" selectors. */ - movl $GSEL(GDATA_SEL, SEL_KPL),%eax - movw %ax,%ds - movw %ax,%es - movw %ax,%gs - movw %ax,%ss - movl $GSEL(GCPU_SEL, SEL_KPL),%eax - movw %ax,%fs - /* Reload code selector by doing intersegment return. */ - popl %eax - pushl $GSEL(GCODE_SEL, SEL_KPL) - pushl %eax - lret - -/*****************************************************************************/ - -/* - * These functions are primarily used by DDB. - */ - -/* LINTSTUB: Func: int setjmp (label_t *l) */ -ENTRY(setjmp) - movl 4(%esp),%eax - movl %ebx,(%eax) # save ebx - movl %esp,4(%eax) # save esp - movl %ebp,8(%eax) # save ebp - movl %esi,12(%eax) # save esi - movl %edi,16(%eax) # save edi - movl (%esp),%edx # get rta - movl %edx,20(%eax) # save eip - xorl %eax,%eax # return (0); - ret - -/* LINTSTUB: Func: void longjmp (label_t *l) */ -ENTRY(longjmp) - movl 4(%esp),%eax - movl (%eax),%ebx # restore ebx - movl 4(%eax),%esp # restore esp - movl 8(%eax),%ebp # restore ebp - movl 12(%eax),%esi # restore esi - movl 16(%eax),%edi # restore edi - movl 20(%eax),%edx # get rta - movl %edx,(%esp) # put in return frame - xorl %eax,%eax # return (1); - incl %eax - ret - -/*****************************************************************************/ - -/* - * void cpu_idle(void) - */ -ENTRY(cpu_idle) - pushl %ebx - pushl %esi - pushl %edi - - movl CPUVAR(CURPROC),%esi - - /* - * Clear curproc so that we don't accumulate system time while idle. - * This also insures that schedcpu() will move the old process to - * the correct queue if it happens to get called from the spllower() - * below and changes the priority. (See corresponding comment in - * userret()). - */ - movl $0,CPUVAR(CURPROC) - - /* - * Save old context. - * - * Registers: - * %eax, %ecx - scratch - * %esi - old process, then old pcb - * %edi - idle pcb - */ - - pushl %esi - call _C_LABEL(pmap_deactivate) # pmap_deactivate(oldproc) - addl $4,%esp - - movl P_ADDR(%esi),%edi - - /* Save stack pointers. */ - movl %esp,PCB_ESP(%edi) - movl %ebp,PCB_EBP(%edi) - - /* Find idle PCB for this CPU */ -#ifndef MULTIPROCESSOR - movl $_C_LABEL(proc0),%ebx - movl P_ADDR(%ebx),%edi - movl P_MD_TSS_SEL(%ebx),%edx -#else - movl CPUVAR(IDLE_PCB),%edi - movl CPUVAR(IDLE_TSS_SEL),%edx -#endif - movl $0,CPUVAR(CURPROC) /* In case we fault... */ - - /* Restore the idle context (avoid interrupts) */ - cli - - /* Restore stack pointers. */ - movl PCB_ESP(%edi),%esp - movl PCB_EBP(%edi),%ebp - - /* Switch address space. */ - movl PCB_CR3(%edi),%ecx - movl %ecx,%cr3 - - /* Switch TSS. Reset "task busy" flag before loading. */ -#ifdef MULTIPROCESSOR - movl CPUVAR(GDT),%eax -#else - movl _C_LABEL(gdt),%eax -#endif - andl $~0x0200,4-SEL_KPL(%eax,%edx,1) - ltr %dx - - /* We're always in the kernel, so we don't need the LDT. */ - - /* Restore cr0 (including FPU state). */ - movl PCB_CR0(%edi),%ecx - movl %ecx,%cr0 - - /* Record new pcb. */ - SET_CURPCB(%edi) - - pushl %esi - sti - -1: -#if defined(MULTIPROCESSOR) || defined(LOCKDEBUG) - call _C_LABEL(sched_unlock_idle) -#endif - /* Interrupts are okay again. */ - pushl $IPL_NONE # spl0() - call _C_LABEL(Xspllower) # process pending interrupts - addl $4,%esp - -NENTRY(mpidle) -idle_start: - cli - cmpl $0,_C_LABEL(sched_whichqs) - jnz idle_exit - - /* - * Try to zero some pages. - */ - movl _C_LABEL(uvm)+UVM_PAGE_IDLE_ZERO,%ecx - testl %ecx,%ecx - jnz idle_zero - - sti - hlt - jmp idle_start -idle_zero: - sti - call _C_LABEL(uvm_pageidlezero) - jmp idle_start - -idle_exit: - movl $IPL_HIGH,CPUVAR(ILEVEL) # splhigh -#if defined(MULTIPROCESSOR) || defined(LOCKDEBUG) - call _C_LABEL(sched_lock_idle) -#endif - - popl %edi - movl %edi,CPUVAR(CURPROC) - - movl P_ADDR(%edi),%esi - - /* Restore stack pointers. */ - movl PCB_ESP(%esi),%esp - movl PCB_EBP(%esi),%ebp - -#ifdef MULTIPROCESSOR - movl CPUVAR(GDT),%eax -#else - /* Load TSS info. */ - movl _C_LABEL(gdt),%eax -#endif - movl P_MD_TSS_SEL(%edi),%edx - - /* Switch TSS. Reset "task busy" flag before loading. */ - andl $~0x0200,4(%eax,%edx, 1) - ltr %dx - - pushl %edi - call _C_LABEL(pmap_activate) # pmap_activate(p) - addl $4,%esp - - /* Restore cr0 (including FPU state). */ - movl PCB_CR0(%esi),%ecx -#ifdef MULTIPROCESSOR - /* - * If our floating point registers are on a different cpu, - * clear CR0_TS so we'll trap rather than reuse bogus state. - */ - movl PCB_FPCPU(%esi),%ebx - cmpl CPUVAR(SELF),%ebx - jz 1f - orl $CR0_TS,%ecx -1: -#endif - movl %ecx,%cr0 - - /* Record new pcb. */ - SET_CURPCB(%esi) - - /* Interrupts are okay again. */ - sti - -cpu_idle_exit: - popl %edi - popl %esi - popl %ebx - ret - - -#ifdef DIAGNOSTIC -NENTRY(switch_error) - pushl $1f - call _C_LABEL(panic) - /* NOTREACHED */ -1: .asciz "cpu_switch" -#endif /* DIAGNOSTIC */ - -/* - * void cpu_switch(struct proc *oldp, struct proc *newp) - * Find a runnable process and switch to it. Wait if necessary. If the new - * process is the same as the old one, we short-circuit the context save and - * restore. - * - * Note that the stack frame layout is known to "struct switchframe" - * in and to the code in cpu_fork() which initializes - * it for a new process. - */ -ENTRY(cpu_switch) - pushl %ebx - pushl %esi - pushl %edi - - movl 20(%esp),%edi - movl 16(%esp),%esi - -#ifdef DEBUG - cmpl $IPL_SCHED,CPUVAR(ILEVEL) - jae 1f - pushl 2f - call _C_LABEL(panic) - /* NOTREACHED */ -2: .asciz "not splhigh() in cpu_switch!" - -1: -#endif /* DEBUG */ - -sw1: - -#ifdef DIAGNOSTIC - cmpl $0,P_WCHAN(%edi) # Waiting for something? - jne _C_LABEL(switch_error) # Yes; shouldn't be queued. - cmpb $SRUN,P_STAT(%edi) # In run state? - jne _C_LABEL(switch_error) # No; shouldn't be queued. -#endif /* DIAGNOSTIC */ - - /* Record new process. */ - movb $SONPROC,P_STAT(%edi) # p->p_stat = SONPROC - SET_CURPROC(%edi,%ecx) - - /* We just did it. */ - xorl %eax,%eax - CLEAR_RESCHED(%eax) - - /* If old process exited, don't bother. */ - testl %esi,%esi - jz 1f - - /* - * Save old context. - * - * Registers: - * %eax, %ecx - scratch - * %esi - old process, then old pcb - * %edi - new process - */ - - pushl %esi - call _C_LABEL(pmap_deactivate) # pmap_deactivate(oldproc) - addl $4,%esp - - movl P_ADDR(%esi),%esi - - /* Save stack pointers. */ - movl %esp,PCB_ESP(%esi) - movl %ebp,PCB_EBP(%esi) - -1: - /* - * Restore saved context. - * - * Registers: - * %eax, %ebx, %ecx, %edx - scratch - * %esi - new pcb - * %edi - new process - */ - - /* No interrupts while loading new state. */ - cli - movl P_ADDR(%edi),%esi - - /* Restore stack pointers. */ - movl PCB_ESP(%esi),%esp - movl PCB_EBP(%esi),%ebp - -#if 0 - /* Don't bother with the rest if switching to a system process. */ - testl $P_SYSTEM,P_FLAG(%edi) - jnz switch_restored -#endif - -#ifdef MULTIPROCESSOR - movl CPUVAR(GDT),%eax -#else - /* Load TSS info. */ - movl _C_LABEL(gdt),%eax -#endif - movl P_MD_TSS_SEL(%edi),%edx - - /* Switch TSS. Reset "task busy" flag before loading. */ - andl $~0x0200,4(%eax,%edx, 1) - ltr %dx - - pushl %edi - call _C_LABEL(pmap_activate) # pmap_activate(p) - addl $4,%esp - -#if 0 -switch_restored: -#endif - /* Restore cr0 (including FPU state). */ - movl PCB_CR0(%esi),%ecx -#ifdef MULTIPROCESSOR - /* - * If our floating point registers are on a different cpu, - * clear CR0_TS so we'll trap rather than reuse bogus state. - */ - movl PCB_FPCPU(%esi),%ebx - cmpl CPUVAR(SELF),%ebx - jz 1f - orl $CR0_TS,%ecx -1: -#endif - movl %ecx,%cr0 - - /* Record new pcb. */ - SET_CURPCB(%esi) - - /* Interrupts are okay again. */ - sti - - /* - * Check for restartable atomic sequences (RAS) - */ - movl CPUVAR(CURPROC),%edi - cmpl $0,P_NRAS(%edi) - je 1f - movl P_MD_REGS(%edi),%ebx - movl TF_EIP(%ebx),%eax - pushl %eax - pushl %edi - call _C_LABEL(ras_lookup) - addl $8,%esp - cmpl $-1,%eax - je 1f - movl %eax,TF_EIP(%ebx) -1: - -#if defined(MULTIPROCESSOR) || defined(LOCKDEBUG) - call _C_LABEL(sched_unlock_idle) -#endif - pushl $IPL_NONE # spl0() - call _C_LABEL(Xspllower) # process pending interrupts - addl $4,%esp - movl $IPL_HIGH,CPUVAR(ILEVEL) # splhigh() - - popl %edi - popl %esi - popl %ebx - ret - -/* - * void switch_exit(struct proc *p); - * switch_exit(struct proc *p); - * Switch to the appropriate idle context (proc0's if uniprocessor; the cpu's - * if multiprocessor) and deallocate the address space and kernel stack for p. - * Then jump into cpu_switch(), as if we were in the idle proc all along. - */ -#ifndef MULTIPROCESSOR - .globl _C_LABEL(proc0) -#endif - .globl _C_LABEL(uvmspace_free),_C_LABEL(kernel_map) - .globl _C_LABEL(uvm_km_free),_C_LABEL(tss_free) -/* LINTSTUB: Func: void switch_exit(struct proc *p) */ -ENTRY(switch_exit) - movl 4(%esp),%edi # old process -#ifndef MULTIPROCESSOR - movl $_C_LABEL(proc0),%ebx - movl P_ADDR(%ebx),%esi - movl P_MD_TSS_SEL(%ebx),%edx -#else - movl CPUVAR(IDLE_PCB),%esi - movl CPUVAR(IDLE_TSS_SEL),%edx -#endif - /* In case we fault... */ - movl $0,CPUVAR(CURPROC) - - /* Restore the idle context. */ - cli - - /* Restore stack pointers. */ - movl PCB_ESP(%esi),%esp - movl PCB_EBP(%esi),%ebp - - /* Load TSS info. */ -#ifdef MULTIPROCESSOR - movl CPUVAR(GDT),%eax -#else - /* Load TSS info. */ - movl _C_LABEL(gdt),%eax -#endif - - /* Switch address space. */ - movl PCB_CR3(%esi),%ecx - movl %ecx,%cr3 - - /* Switch TSS. */ - andl $~0x0200,4-SEL_KPL(%eax,%edx,1) - ltr %dx - - /* We're always in the kernel, so we don't need the LDT. */ - - /* Restore cr0 (including FPU state). */ - movl PCB_CR0(%esi),%ecx - movl %ecx,%cr0 - - /* Record new pcb. */ - SET_CURPCB(%esi) - - /* Interrupts are okay again. */ - sti - - /* - * Schedule the dead process's vmspace and stack to be freed. - */ - pushl %edi /* exit2(p) */ - call _C_LABEL(exit2) - addl $4,%esp - -#if defined(MULTIPROCESSOR) || defined(LOCKDEBUG) - call _C_LABEL(sched_lock_idle) -#endif - - call _C_LABEL(chooseproc) - movl %eax,%edi - - /* Jump into cpu_switch() with the right state. */ - xorl %esi,%esi - movl %esi,CPUVAR(CURPROC) - jmp sw1 + call _C_LABEL(ras_lookup) + addl $8,%esp + cmpl $-1,%eax + je switch_return + movl %eax,TF_EIP(%ebx) + jmp switch_return /* * void savectx(struct pcb *pcb); @@ -2074,8 +881,8 @@ ENTRY(switch_exit) */ /* LINTSTUB: Func: void savectx(struct pcb *pcb) */ ENTRY(savectx) - movl 4(%esp),%edx # edx = p->p_addr - + movl 4(%esp),%edx # edx = pcb + /* Save stack pointers. */ movl %esp,PCB_ESP(%edx) movl %ebp,PCB_EBP(%edx) @@ -2104,6 +911,12 @@ syscall1: INTRENTRY #ifdef DIAGNOSTIC + cmpl $0, CPUVAR(WANT_PMAPLOAD) + jz 1f + pushl $6f + call _C_LABEL(printf) + addl $4, %esp +1: movl CPUVAR(ILEVEL),%ebx testl %ebx,%ebx jz 1f @@ -2113,25 +926,33 @@ syscall1: #ifdef DDB int $3 #endif -1: +1: #endif /* DIAGNOSTIC */ - movl CPUVAR(CURPROC),%edx - movl %esp,P_MD_REGS(%edx) # save pointer to frame + movl CPUVAR(CURLWP),%edx + movl %esp,L_MD_REGS(%edx) # save pointer to frame + movl L_PROC(%edx),%edx + pushl %esp call *P_MD_SYSCALL(%edx) # get pointer to syscall() function -2: /* Check for ASTs on exit to user mode. */ + addl $4,%esp +.Lsyscall_checkast: + /* Check for ASTs on exit to user mode. */ cli - CHECK_ASTPENDING() + CHECK_ASTPENDING(%eax) je 1f /* Always returning to user mode here. */ - CLEAR_ASTPENDING() + CLEAR_ASTPENDING(%eax) sti /* Pushed T_ASTFLT into tf_trapno on entry. */ + pushl %esp call _C_LABEL(trap) - jmp 2b + addl $4,%esp + jmp .Lsyscall_checkast /* re-check ASTs */ +1: CHECK_DEFERRED_SWITCH(%eax) + jnz 9f #ifndef DIAGNOSTIC -1: INTRFASTEXIT + INTRFASTEXIT #else /* DIAGNOSTIC */ -1: cmpl $IPL_NONE,CPUVAR(ILEVEL) + cmpl $IPL_NONE,CPUVAR(ILEVEL) jne 3f INTRFASTEXIT 3: sti @@ -2144,8 +965,12 @@ syscall1: movl $IPL_NONE,CPUVAR(ILEVEL) jmp 2b 4: .asciz "WARNING: SPL NOT LOWERED ON SYSCALL EXIT\n" -5: .asciz "WARNING: SPL NOT ZERO ON SYSCALL ENTRY\n" +5: .asciz "WARNING: SPL NOT ZERO ON SYSCALL ENTRY\n" +6: .asciz "WARNING: WANT PMAPLOAD ON SYSCALL ENTRY\n" #endif /* DIAGNOSTIC */ +9: sti + call _C_LABEL(pmap_load) + jmp .Lsyscall_checkast /* re-check ASTs */ #if NNPX > 0 /*