diff --git a/sys/amd64/amd64/locore.S b/sys/amd64/amd64/locore.S index 6e74dd033302..db6e252f7f6b 100644 --- a/sys/amd64/amd64/locore.S +++ b/sys/amd64/amd64/locore.S @@ -1,793 +1,794 @@ /*- * Copyright (c) 1990 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * William Jolitz. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 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 * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: @(#)locore.s 7.3 (Berkeley) 5/13/91 - * $Id: locore.s,v 1.34 1994/10/07 05:45:27 davidg Exp $ + * $Id: locore.s,v 1.35 1994/10/08 06:20:52 rgrimes Exp $ */ /* * locore.s: FreeBSD machine support for the Intel 386 * originally from: locore.s, by William F. Jolitz * * Substantially rewritten by David Greenman, Rod Grimes, * Bruce Evans, Wolfgang Solfrank, and many others. */ #include "npx.h" /* for NNPX */ #include "assym.s" /* system definitions */ #include /* processor status longword defs */ #include /* page table entry definitions */ #include /* error return codes */ #include /* x86 special registers */ #include /* x86 cpu type definitions */ #include /* system call numbers */ #include /* miscellaneous asm macros */ -#ifdef APM +#include "apm.h" +#if NAPM > 0 #define ASM #include #include -#endif +#endif /* NAPM */ /* * XXX * * Note: This version greatly munged to avoid various assembler errors * that may be fixed in newer versions of gas. Perhaps newer versions * will have more pleasant appearance. */ /* * PTmap is recursive pagemap at top of virtual address space. * Within PTmap, the page directory can be found (third indirection). */ .globl _PTmap,_PTD,_PTDpde,_Sysmap .set _PTmap,PTDPTDI << PDRSHIFT .set _PTD,_PTmap + (PTDPTDI * NBPG) .set _PTDpde,_PTD + (PTDPTDI * PDESIZE) /* Sysmap is the base address of the kernel page tables */ .set _Sysmap,_PTmap + (KPTDI * NBPG) /* * APTmap, APTD is the alternate recursive pagemap. * It's used when modifying another process's page tables. */ .globl _APTmap,_APTD,_APTDpde .set _APTmap,APTDPTDI << PDRSHIFT .set _APTD,_APTmap + (APTDPTDI * NBPG) .set _APTDpde,_PTD + (APTDPTDI * PDESIZE) /* * Access to each processes kernel stack is via a region of * per-process address space (at the beginning), immediatly above * the user process stack. */ .set _kstack,USRSTACK .globl _kstack /* * Globals */ .data .globl _boothowto,_bootdev,_curpcb .globl _cpu,_cold,_atdevbase,_cpu_vendor,_cpu_id .globl _video_mode_ptr _cpu: .long 0 /* are we 386, 386sx, or 486 */ _cpu_id: .long 0 /* stepping ID */ _cpu_vendor: .space 20 /* CPU origin code */ _video_mode_ptr: .long 0 _cold: .long 1 /* cold till we are not */ _atdevbase: .long 0 /* location of start of iomem in virtual */ _atdevphys: .long 0 /* location of device mapping ptes (phys) */ .globl _KERNend _KERNend: .long 0 /* phys addr end of kernel (just after bss) */ .globl _IdlePTD,_KPTphys _IdlePTD: .long 0 /* phys addr of kernel PTD */ _KPTphys: .long 0 /* phys addr of kernel page tables */ .globl _proc0paddr _proc0paddr: .long 0 /* address of proc 0 address space */ #ifdef BDE_DEBUGGER .globl _bdb_exists /* flag to indicate BDE debugger is available */ _bdb_exists: .long 0 #endif -#ifdef APM +#if NAPM > 0 .globl _apm_current_gdt_pdesc /* current GDT pseudo desc. */ _apm_current_gdt_pdesc: .word 0, 0, 0 .globl _bootstrap_gdt _bootstrap_gdt: .space SIZEOF_GDT * BOOTSTRAP_GDT_NUM -#endif /* APM */ +#endif /* NAPM */ .globl tmpstk .space 0x1000 tmpstk: /* * System Initialization */ .text /* * btext: beginning of text section. * Also the entry point (jumped to directly from the boot blocks). */ NON_GPROF_ENTRY(btext) movw $0x1234,0x472 /* warm boot */ jmp 1f /* * XXX now that we load at 1MB is this still really used? */ .org 0x500 /* space for BIOS variables */ 1: /* Set up a real frame, some day we will be doing returns */ pushl %ebp movl %esp, %ebp /* Don't trust what the BIOS gives for eflags. */ pushl $PSL_MBO popfl /* * This code is called in different ways depending on what loaded * and started the kernel. This is used to detect how we get the * arguments from the other code and what we do with them. * * Old disk boot blocks: * (*btext)(howto, bootdev, cyloffset, esym); * [return address == 0, and can NOT be returned to] * [cyloffset was not supported by the FreeBSD boot code * and always passed in as 0] * [esym is also known as total in the boot code, and * was never properly supported by the FreeBSD boot code] * * Old diskless netboot code: * (*btext)(0,0,0,0,&nfsdiskless,0,0,0); * [return address != 0, and can NOT be returned to] * If we are being booted by this code it will NOT work, * so we are just going to halt if we find this case. * * New uniform boot code: * (*btext)(howto, bootdev, 0, 0, 0, &bootinfo) * [return address != 0, and can be returned to] * * There may seem to be a lot of wasted arguments in here, but * that is so the newer boot code can still load very old kernels * and old boot code can load new kernels. */ /* * The old style disk boot blocks fake a frame on the stack and * did an lret to get here. The frame on the stack has a return * address of 0. */ cmpl $0,4(%ebp) je 2f /* olddiskboot: */ /* * We have some form of return address, so this is either the * old diskless netboot code, or the new uniform code. That can * be detected by looking at the 5th argument, it if is 0 we * we are being booted by the new unifrom boot code. */ cmpl $0,24(%ebp) je 1f /* newboot: */ /* * Seems we have been loaded by the old diskless boot code, we * don't stand a chance of running as the diskless structure * changed considerably between the two, so just halt. */ hlt /* * We have been loaded by the new uniform boot code. * Lets check the bootinfo version, and if we do not understand * it we return to the loader with a status of 1 to indicate this error */ 1: /* newboot: */ movl 28(%ebp),%ebx /* &bootinfo.version */ movl BOOTINFO_VERSION(%ebx),%eax cmpl $1,%eax /* We only understand version 1 */ je 1f movl $1,%eax /* Return status */ leave ret 1: /* * If we have a kernelname copy it in */ movl BOOTINFO_KERNELNAME(%ebx),%esi cmpl $0,%esi je 1f /* No kernelname */ lea _kernelname-KERNBASE,%edi movl $MAXPATHLEN,%ecx /* Brute force!!! */ cld rep movsb 1: #ifdef NFS /* * If we have a nfs_diskless structure copy it in */ movl BOOTINFO_NFS_DISKLESS(%ebx),%esi cmpl $0,%esi je 2f lea _nfs_diskless-KERNBASE,%edi movl $NFSDISKLESS_SIZE,%ecx cld rep movsb #endif /* * The old style disk boot. * (*btext)(howto, bootdev, cyloffset, esym); * Note that the newer boot code just falls into here to pick * up howto and bootdev, cyloffset and esym are no longer used */ 2: /* olddiskboot: */ movl 8(%ebp),%eax movl %eax,_boothowto-KERNBASE movl 12(%ebp),%eax movl %eax,_bootdev-KERNBASE /* get the BIOS video mode pointer */ movl $0x4a8, %ecx movl (%ecx), %eax movl %eax, %ecx shrl $12, %ecx andl $0xffff0000, %ecx andl $0x0000ffff, %eax orl %ecx, %eax movl (%eax), %eax movl %eax, %ecx shrl $12, %ecx andl $0xffff0000, %ecx andl $0x0000ffff, %eax orl %ecx, %eax addl $KERNBASE, %eax movl %eax, _video_mode_ptr-KERNBASE -#ifdef APM +#if NAPM > 0 /* * Setup APM BIOS: * * APM BIOS initialization should be done from real mode or V86 mode. * * (by HOSOKAWA, Tatsumi ) */ /* * Copy APM initializer under 1MB boundary: * * APM initializer program must switch the CPU to real mode. * But FreeBSD kernel runs above 1MB boundary. So we must * copy the initializer code to conventional memory. */ movl _apm_init_image_size-KERNBASE, %ecx /* size */ lea _apm_init_image-KERNBASE, %esi /* source */ movl $ APM_OURADDR, %edi /* destination */ cld rep movsb /* get GDT base */ sgdt _apm_current_gdt_pdesc-KERNBASE /* copy GDT to _bootstrap_gdt */ xorl %ecx, %ecx movw _apm_current_gdt_pdesc-KERNBASE, %cx movl _apm_current_gdt_pdesc-KERNBASE+2, %esi lea _bootstrap_gdt-KERNBASE, %edi cld rep movsb /* setup GDT pseudo descriptor */ movw $(SIZEOF_GDT*BOOTSTRAP_GDT_NUM), %ax movw %ax, _apm_current_gdt_pdesc-KERNBASE leal _bootstrap_gdt-KERNBASE, %eax movl %eax, _apm_current_gdt_pdesc-KERNBASE+2 /* load new GDTR */ lgdt _apm_current_gdt_pdesc-KERNBASE /* setup GDT for APM initializer */ lea _bootstrap_gdt-KERNBASE, %ecx movl $(APM_OURADDR), %eax /* use %ax for 15..0 */ movl %eax, %ebx shrl $16, %ebx /* use %bl for 23..16 */ /* use %bh for 31..24 */ #define APM_SETUP_GDT(index, attrib) \ movl $(index), %si ; \ lea 0(%ecx,%esi,8), %edx ; \ movw $0xffff, (%edx) ; \ movw %ax, 2(%edx) ; \ movb %bl, 4(%edx) ; \ movw $(attrib), 5(%edx) ; \ movb %bh, 7(%edx) APM_SETUP_GDT(APM_INIT_CS_INDEX , CS32_ATTRIB) APM_SETUP_GDT(APM_INIT_DS_INDEX , DS32_ATTRIB) APM_SETUP_GDT(APM_INIT_CS16_INDEX, CS16_ATTRIB) /* * Call the initializer: * * direct intersegment call to conventional memory code */ .byte 0x9a /* actually, lcall $APM_INIT_CS_SEL, $0 */ .long 0 .word APM_INIT_CS_SEL movw %ax, _apm_version-KERNBASE movl %ebx, _apm_cs_entry-KERNBASE movw %cx, _apm_cs32_base-KERNBASE shrl $16, %ecx movw %cx, _apm_cs16_base-KERNBASE movw %dx, _apm_ds_base-KERNBASE movw %si, _apm_cs_limit-KERNBASE shrl $16, %esi movw %si, _apm_ds_limit-KERNBASE movw %di, _apm_flags-KERNBASE -#endif /* APM */ +#endif /* NAPM */ /* Find out our CPU type. */ /* Try to toggle alignment check flag; does not exist on 386. */ pushfl popl %eax movl %eax,%ecx orl $PSL_AC,%eax pushl %eax popfl pushfl popl %eax xorl %ecx,%eax andl $PSL_AC,%eax pushl %ecx popfl testl %eax,%eax jnz 1f movl $CPU_386,_cpu-KERNBASE jmp 2f 1: /* Try to toggle identification flag; does not exist on early 486s. */ pushfl popl %eax movl %eax,%ecx xorl $PSL_ID,%eax pushl %eax popfl pushfl popl %eax xorl %ecx,%eax andl $PSL_ID,%eax pushl %ecx popfl testl %eax,%eax jnz 1f movl $CPU_486,_cpu-KERNBASE /* check for Cyrix 486DLC -- based on check routine */ /* documented in "Cx486SLC/e SMM Programmer's Guide" */ xorw %dx,%dx cmpw %dx,%dx # set flags to known state pushfw popw %cx # store flags in ecx movw $0xffff,%ax movw $0x0004,%bx divw %bx pushfw popw %ax andw $0x08d5,%ax # mask off important bits andw $0x08d5,%cx cmpw %ax,%cx jnz 2f # if flags changed, Intel chip movl $CPU_486DLC,_cpu-KERNBASE # set CPU value for Cyrix movl $0x69727943,_cpu_vendor-KERNBASE # store vendor string movw $0x0078,_cpu_vendor-KERNBASE+4 invd # Start with guaranteed clean cache /* Disable caching of the ISA hole only. */ movb $CCR0,%al # Configuration Register index (CCR0) outb %al,$0x22 inb $0x23,%al orb $(CCR0_NC1|CCR0_BARB),%al outb %al,$0x23 invd jmp 2f 1: /* Use the `cpuid' instruction. */ xorl %eax,%eax .byte 0x0f,0xa2 # cpuid 0 movl %ebx,_cpu_vendor-KERNBASE # store vendor string movl %edx,_cpu_vendor+4-KERNBASE movl %ecx,_cpu_vendor+8-KERNBASE movb $0,_cpu_vendor+12-KERNBASE movl $1,%eax .byte 0x0f,0xa2 # cpuid 1 movl %eax,_cpu_id-KERNBASE # store cpu_id rorl $8,%eax # extract family type andl $15,%eax cmpl $5,%eax jae 1f /* less than Pentium; must be 486 */ movl $CPU_486,_cpu-KERNBASE jmp 2f 1: movl $CPU_586,_cpu-KERNBASE 2: /* * Finished with old stack; load new %esp now instead of later so * we can trace this code without having to worry about the trace * trap clobbering the memory test or the zeroing of the bss+bootstrap * page tables. * * XXX - wdboot clears the bss after testing that this is safe. * This is too wasteful - memory below 640K is scarce. The boot * program should check: * text+data <= &stack_variable - more_space_for_stack * text+data+bss+pad+space_for_page_tables <= end_of_memory * Oops, the gdt is in the carcass of the boot program so clearing * the rest of memory is still not possible. */ movl $tmpstk-KERNBASE,%esp /* bootstrap stack end location */ /* * Virtual address space of kernel: * * text | data | bss | [syms] | page dir | proc0 kernel stack | usr stk map | Sysmap * pages: 1 UPAGES (2) 1 NKPT (7) */ /* find end of kernel image */ movl $_end-KERNBASE,%ecx addl $NBPG-1,%ecx /* page align up */ andl $~(NBPG-1),%ecx movl %ecx,%esi /* esi = start of free memory */ movl %ecx,_KERNend-KERNBASE /* save end of kernel */ /* clear bss */ movl $_edata-KERNBASE,%edi subl %edi,%ecx /* get amount to clear */ xorl %eax,%eax /* specify zero fill */ cld rep stosb /* * The value in esi is both the end of the kernel bss and a pointer to * the kernel page directory, and is used by the rest of locore to build * the tables. * esi + 1(page dir) + 2(UPAGES) + 1(p0stack) + NKPT(number of kernel * page table pages) is then passed on the stack to init386(first) as * the value first. esi should ALWAYS be page aligned!! */ movl %esi,%ecx /* Get current first availiable address */ /* clear pagetables, page directory, stack, etc... */ movl %esi,%edi /* base (page directory) */ movl $((1+UPAGES+1+NKPT)*NBPG),%ecx /* amount to clear */ xorl %eax,%eax /* specify zero fill */ cld rep stosb /* physical address of Idle proc/kernel page directory */ movl %esi,_IdlePTD-KERNBASE /* * fillkpt * eax = (page frame address | control | status) == pte * ebx = address of page table * ecx = how many pages to map */ #define fillkpt \ 1: movl %eax,(%ebx) ; \ addl $NBPG,%eax ; /* increment physical address */ \ addl $4,%ebx ; /* next pte */ \ loop 1b ; /* * Map Kernel * * First step - build page tables */ #if defined (KGDB) || defined (BDE_DEBUGGER) movl _KERNend-KERNBASE,%ecx /* this much memory, */ shrl $PGSHIFT,%ecx /* for this many PTEs */ #ifdef BDE_DEBUGGER cmpl $0xa0,%ecx /* XXX - cover debugger pages */ jae 1f movl $0xa0,%ecx 1: #endif /* BDE_DEBUGGER */ movl $PG_V|PG_KW,%eax /* kernel R/W, valid */ lea ((1+UPAGES+1)*NBPG)(%esi),%ebx /* phys addr of kernel PT base */ movl %ebx,_KPTphys-KERNBASE /* save in global */ fillkpt #else /* !KGDB && !BDE_DEBUGGER */ /* write protect kernel text (doesn't do a thing for 386's - only 486's) */ movl $_etext-KERNBASE,%ecx /* get size of text */ shrl $PGSHIFT,%ecx /* for this many PTEs */ movl $PG_V|PG_KR,%eax /* specify read only */ lea ((1+UPAGES+1)*NBPG)(%esi),%ebx /* phys addr of kernel PT base */ movl %ebx,_KPTphys-KERNBASE /* save in global */ fillkpt /* data and bss are r/w */ andl $PG_FRAME,%eax /* strip to just addr of bss */ movl _KERNend-KERNBASE,%ecx /* calculate size */ subl %eax,%ecx shrl $PGSHIFT,%ecx orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ fillkpt #endif /* KGDB || BDE_DEBUGGER */ /* now initialize the page dir, upages, p0stack PT, and page tables */ movl $(1+UPAGES+1+NKPT),%ecx /* number of PTEs */ movl %esi,%eax /* phys address of PTD */ andl $PG_FRAME,%eax /* convert to PFN, should be a NOP */ orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ movl %esi,%ebx /* calculate pte offset to ptd */ shrl $PGSHIFT-2,%ebx addl %esi,%ebx /* address of page directory */ addl $((1+UPAGES+1)*NBPG),%ebx /* offset to kernel page tables */ fillkpt /* map I/O memory map */ movl _KPTphys-KERNBASE,%ebx /* base of kernel page tables */ lea (0xa0 * PTESIZE)(%ebx),%ebx /* hardwire ISA hole at KERNBASE + 0xa0000 */ movl $0x100-0xa0,%ecx /* for this many pte s, */ movl $(0xa0000|PG_V|PG_KW|PG_N),%eax /* valid, kernel read/write, non-cacheable */ movl %ebx,_atdevphys-KERNBASE /* save phys addr of ptes */ fillkpt /* map proc 0's kernel stack into user page table page */ movl $UPAGES,%ecx /* for this many pte s, */ lea (1*NBPG)(%esi),%eax /* physical address in proc 0 */ lea (KERNBASE)(%eax),%edx /* change into virtual addr */ movl %edx,_proc0paddr-KERNBASE /* save VA for proc 0 init */ orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ lea ((1+UPAGES)*NBPG)(%esi),%ebx /* addr of stack page table in proc 0 */ addl $(KSTKPTEOFF * PTESIZE),%ebx /* offset to kernel stack PTE */ fillkpt /* * Initialize kernel page table directory */ /* install a pde for temporary double map of bottom of VA */ movl _KPTphys-KERNBASE,%eax orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ movl %eax,(%esi) /* which is where temp maps! */ /* initialize kernel pde's */ movl $(NKPT),%ecx /* for this many PDEs */ lea (KPTDI*PDESIZE)(%esi),%ebx /* offset of pde for kernel */ fillkpt /* install a pde recursively mapping page directory as a page table! */ movl %esi,%eax /* phys address of ptd in proc 0 */ orl $PG_V|PG_KW,%eax /* pde entry is valid */ movl %eax,PTDPTDI*PDESIZE(%esi) /* which is where PTmap maps! */ /* install a pde to map kernel stack for proc 0 */ lea ((1+UPAGES)*NBPG)(%esi),%eax /* physical address of pt in proc 0 */ orl $PG_V|PG_KW,%eax /* pde entry is valid */ movl %eax,KSTKPTDI*PDESIZE(%esi) /* which is where kernel stack maps! */ #ifdef BDE_DEBUGGER /* copy and convert stuff from old gdt and idt for debugger */ cmpl $0x0375c339,0x96104 /* XXX - debugger signature */ jne 1f movb $1,_bdb_exists-KERNBASE 1: pushal subl $2*6,%esp sgdt (%esp) movl 2(%esp),%esi /* base address of current gdt */ movl $_gdt-KERNBASE,%edi movl %edi,2(%esp) movl $8*18/4,%ecx cld rep /* copy gdt */ movsl movl $_gdt-KERNBASE,-8+2(%edi) /* adjust gdt self-ptr */ movb $0x92,-8+5(%edi) sidt 6(%esp) movl 6+2(%esp),%esi /* base address of current idt */ movl 8+4(%esi),%eax /* convert dbg descriptor to ... */ movw 8(%esi),%ax movl %eax,bdb_dbg_ljmp+1-KERNBASE /* ... immediate offset ... */ movl 8+2(%esi),%eax movw %ax,bdb_dbg_ljmp+5-KERNBASE /* ... and selector for ljmp */ movl 24+4(%esi),%eax /* same for bpt descriptor */ movw 24(%esi),%ax movl %eax,bdb_bpt_ljmp+1-KERNBASE movl 24+2(%esi),%eax movw %ax,bdb_bpt_ljmp+5-KERNBASE movl $_idt-KERNBASE,%edi movl %edi,6+2(%esp) movl $8*4/4,%ecx cld rep /* copy idt */ movsl lgdt (%esp) lidt 6(%esp) addl $2*6,%esp popal #endif /* BDE_DEBUGGER */ /* load base of page directory and enable mapping */ movl %esi,%eax /* phys address of ptd in proc 0 */ movl %eax,%cr3 /* load ptd addr into mmu */ movl %cr0,%eax /* get control word */ orl $CR0_PE|CR0_PG,%eax /* enable paging */ movl %eax,%cr0 /* and let's page NOW! */ pushl $begin /* jump to high mem */ ret begin: /* now running relocated at KERNBASE where the system is linked to run */ .globl _Crtat /* XXX - locore should not know about */ movl _Crtat,%eax /* variables of device drivers (pccons)! */ subl $(KERNBASE+0xA0000),%eax movl _atdevphys,%edx /* get pte PA */ subl _KPTphys,%edx /* remove base of ptes, now have phys offset */ shll $PGSHIFT-2,%edx /* corresponding to virt offset */ addl $KERNBASE,%edx /* add virtual base */ movl %edx,_atdevbase addl %eax,%edx movl %edx,_Crtat /* set up bootstrap stack - 48 bytes */ movl $_kstack+UPAGES*NBPG-4*12,%esp /* bootstrap stack end location */ xorl %eax,%eax /* mark end of frames */ movl %eax,%ebp movl _proc0paddr,%eax movl %esi,PCB_CR3(%eax) #ifdef BDE_DEBUGGER /* relocate debugger gdt entries */ movl $_gdt+8*9,%eax /* adjust slots 9-17 */ movl $9,%ecx reloc_gdt: movb $KERNBASE>>24,7(%eax) /* top byte of base addresses, was 0, */ addl $8,%eax /* now KERNBASE>>24 */ loop reloc_gdt cmpl $0,_bdb_exists je 1f int $3 1: #endif /* BDE_DEBUGGER */ /* * Skip over the page tables and the kernel stack */ lea ((1+UPAGES+1+NKPT)*NBPG)(%esi),%esi pushl %esi /* value of first for init386(first) */ call _init386 /* wire 386 chip for unix operation */ popl %esi .globl __ucodesel,__udatasel pushl $0 /* unused */ pushl __udatasel /* ss */ pushl $0 /* esp - filled in by execve() */ pushl $PSL_USERSET /* eflags (ring 0, int enab) */ pushl __ucodesel /* cs */ pushl $0 /* eip - filled in by execve() */ subl $(12*4),%esp /* space for rest of registers */ pushl %esp /* call main with frame pointer */ call _main /* autoconfiguration, mountroot etc */ addl $(13*4),%esp /* back to a frame we can return with */ /* * now we've run main() and determined what cpu-type we are, we can * enable WP mode on i486 cpus and above. */ #if defined(I486_CPU) || defined(I586_CPU) cmpl $CPUCLASS_386,_cpu_class je 1f movl %cr0,%eax /* get control word */ orl $CR0_WP,%eax /* enable write protect for all modes */ movl %eax,%cr0 /* and do it */ #endif /* * on return from main(), we are process 1 * set up address space and stack so that we can 'return' to user mode */ 1: movl __ucodesel,%eax movl __udatasel,%ecx movl %cx,%ds movl %cx,%es movl %ax,%fs /* double map cs to fs */ movl %cx,%gs /* and ds to gs */ iret /* goto user! */ #define LCALL(x,y) .byte 0x9a ; .long y ; .word x NON_GPROF_ENTRY(sigcode) call SIGF_HANDLER(%esp) lea SIGF_SC(%esp),%eax /* scp (the call may have clobbered the */ /* copy at 8(%esp)) */ pushl %eax pushl %eax /* junk to fake return address */ movl $103,%eax /* XXX sigreturn() */ LCALL(0x7,0) /* enter kernel with args on stack */ hlt /* never gets here */ .globl _szsigcode _szsigcode: .long _szsigcode-_sigcode diff --git a/sys/amd64/amd64/locore.s b/sys/amd64/amd64/locore.s index 6e74dd033302..db6e252f7f6b 100644 --- a/sys/amd64/amd64/locore.s +++ b/sys/amd64/amd64/locore.s @@ -1,793 +1,794 @@ /*- * Copyright (c) 1990 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * William Jolitz. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 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 * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: @(#)locore.s 7.3 (Berkeley) 5/13/91 - * $Id: locore.s,v 1.34 1994/10/07 05:45:27 davidg Exp $ + * $Id: locore.s,v 1.35 1994/10/08 06:20:52 rgrimes Exp $ */ /* * locore.s: FreeBSD machine support for the Intel 386 * originally from: locore.s, by William F. Jolitz * * Substantially rewritten by David Greenman, Rod Grimes, * Bruce Evans, Wolfgang Solfrank, and many others. */ #include "npx.h" /* for NNPX */ #include "assym.s" /* system definitions */ #include /* processor status longword defs */ #include /* page table entry definitions */ #include /* error return codes */ #include /* x86 special registers */ #include /* x86 cpu type definitions */ #include /* system call numbers */ #include /* miscellaneous asm macros */ -#ifdef APM +#include "apm.h" +#if NAPM > 0 #define ASM #include #include -#endif +#endif /* NAPM */ /* * XXX * * Note: This version greatly munged to avoid various assembler errors * that may be fixed in newer versions of gas. Perhaps newer versions * will have more pleasant appearance. */ /* * PTmap is recursive pagemap at top of virtual address space. * Within PTmap, the page directory can be found (third indirection). */ .globl _PTmap,_PTD,_PTDpde,_Sysmap .set _PTmap,PTDPTDI << PDRSHIFT .set _PTD,_PTmap + (PTDPTDI * NBPG) .set _PTDpde,_PTD + (PTDPTDI * PDESIZE) /* Sysmap is the base address of the kernel page tables */ .set _Sysmap,_PTmap + (KPTDI * NBPG) /* * APTmap, APTD is the alternate recursive pagemap. * It's used when modifying another process's page tables. */ .globl _APTmap,_APTD,_APTDpde .set _APTmap,APTDPTDI << PDRSHIFT .set _APTD,_APTmap + (APTDPTDI * NBPG) .set _APTDpde,_PTD + (APTDPTDI * PDESIZE) /* * Access to each processes kernel stack is via a region of * per-process address space (at the beginning), immediatly above * the user process stack. */ .set _kstack,USRSTACK .globl _kstack /* * Globals */ .data .globl _boothowto,_bootdev,_curpcb .globl _cpu,_cold,_atdevbase,_cpu_vendor,_cpu_id .globl _video_mode_ptr _cpu: .long 0 /* are we 386, 386sx, or 486 */ _cpu_id: .long 0 /* stepping ID */ _cpu_vendor: .space 20 /* CPU origin code */ _video_mode_ptr: .long 0 _cold: .long 1 /* cold till we are not */ _atdevbase: .long 0 /* location of start of iomem in virtual */ _atdevphys: .long 0 /* location of device mapping ptes (phys) */ .globl _KERNend _KERNend: .long 0 /* phys addr end of kernel (just after bss) */ .globl _IdlePTD,_KPTphys _IdlePTD: .long 0 /* phys addr of kernel PTD */ _KPTphys: .long 0 /* phys addr of kernel page tables */ .globl _proc0paddr _proc0paddr: .long 0 /* address of proc 0 address space */ #ifdef BDE_DEBUGGER .globl _bdb_exists /* flag to indicate BDE debugger is available */ _bdb_exists: .long 0 #endif -#ifdef APM +#if NAPM > 0 .globl _apm_current_gdt_pdesc /* current GDT pseudo desc. */ _apm_current_gdt_pdesc: .word 0, 0, 0 .globl _bootstrap_gdt _bootstrap_gdt: .space SIZEOF_GDT * BOOTSTRAP_GDT_NUM -#endif /* APM */ +#endif /* NAPM */ .globl tmpstk .space 0x1000 tmpstk: /* * System Initialization */ .text /* * btext: beginning of text section. * Also the entry point (jumped to directly from the boot blocks). */ NON_GPROF_ENTRY(btext) movw $0x1234,0x472 /* warm boot */ jmp 1f /* * XXX now that we load at 1MB is this still really used? */ .org 0x500 /* space for BIOS variables */ 1: /* Set up a real frame, some day we will be doing returns */ pushl %ebp movl %esp, %ebp /* Don't trust what the BIOS gives for eflags. */ pushl $PSL_MBO popfl /* * This code is called in different ways depending on what loaded * and started the kernel. This is used to detect how we get the * arguments from the other code and what we do with them. * * Old disk boot blocks: * (*btext)(howto, bootdev, cyloffset, esym); * [return address == 0, and can NOT be returned to] * [cyloffset was not supported by the FreeBSD boot code * and always passed in as 0] * [esym is also known as total in the boot code, and * was never properly supported by the FreeBSD boot code] * * Old diskless netboot code: * (*btext)(0,0,0,0,&nfsdiskless,0,0,0); * [return address != 0, and can NOT be returned to] * If we are being booted by this code it will NOT work, * so we are just going to halt if we find this case. * * New uniform boot code: * (*btext)(howto, bootdev, 0, 0, 0, &bootinfo) * [return address != 0, and can be returned to] * * There may seem to be a lot of wasted arguments in here, but * that is so the newer boot code can still load very old kernels * and old boot code can load new kernels. */ /* * The old style disk boot blocks fake a frame on the stack and * did an lret to get here. The frame on the stack has a return * address of 0. */ cmpl $0,4(%ebp) je 2f /* olddiskboot: */ /* * We have some form of return address, so this is either the * old diskless netboot code, or the new uniform code. That can * be detected by looking at the 5th argument, it if is 0 we * we are being booted by the new unifrom boot code. */ cmpl $0,24(%ebp) je 1f /* newboot: */ /* * Seems we have been loaded by the old diskless boot code, we * don't stand a chance of running as the diskless structure * changed considerably between the two, so just halt. */ hlt /* * We have been loaded by the new uniform boot code. * Lets check the bootinfo version, and if we do not understand * it we return to the loader with a status of 1 to indicate this error */ 1: /* newboot: */ movl 28(%ebp),%ebx /* &bootinfo.version */ movl BOOTINFO_VERSION(%ebx),%eax cmpl $1,%eax /* We only understand version 1 */ je 1f movl $1,%eax /* Return status */ leave ret 1: /* * If we have a kernelname copy it in */ movl BOOTINFO_KERNELNAME(%ebx),%esi cmpl $0,%esi je 1f /* No kernelname */ lea _kernelname-KERNBASE,%edi movl $MAXPATHLEN,%ecx /* Brute force!!! */ cld rep movsb 1: #ifdef NFS /* * If we have a nfs_diskless structure copy it in */ movl BOOTINFO_NFS_DISKLESS(%ebx),%esi cmpl $0,%esi je 2f lea _nfs_diskless-KERNBASE,%edi movl $NFSDISKLESS_SIZE,%ecx cld rep movsb #endif /* * The old style disk boot. * (*btext)(howto, bootdev, cyloffset, esym); * Note that the newer boot code just falls into here to pick * up howto and bootdev, cyloffset and esym are no longer used */ 2: /* olddiskboot: */ movl 8(%ebp),%eax movl %eax,_boothowto-KERNBASE movl 12(%ebp),%eax movl %eax,_bootdev-KERNBASE /* get the BIOS video mode pointer */ movl $0x4a8, %ecx movl (%ecx), %eax movl %eax, %ecx shrl $12, %ecx andl $0xffff0000, %ecx andl $0x0000ffff, %eax orl %ecx, %eax movl (%eax), %eax movl %eax, %ecx shrl $12, %ecx andl $0xffff0000, %ecx andl $0x0000ffff, %eax orl %ecx, %eax addl $KERNBASE, %eax movl %eax, _video_mode_ptr-KERNBASE -#ifdef APM +#if NAPM > 0 /* * Setup APM BIOS: * * APM BIOS initialization should be done from real mode or V86 mode. * * (by HOSOKAWA, Tatsumi ) */ /* * Copy APM initializer under 1MB boundary: * * APM initializer program must switch the CPU to real mode. * But FreeBSD kernel runs above 1MB boundary. So we must * copy the initializer code to conventional memory. */ movl _apm_init_image_size-KERNBASE, %ecx /* size */ lea _apm_init_image-KERNBASE, %esi /* source */ movl $ APM_OURADDR, %edi /* destination */ cld rep movsb /* get GDT base */ sgdt _apm_current_gdt_pdesc-KERNBASE /* copy GDT to _bootstrap_gdt */ xorl %ecx, %ecx movw _apm_current_gdt_pdesc-KERNBASE, %cx movl _apm_current_gdt_pdesc-KERNBASE+2, %esi lea _bootstrap_gdt-KERNBASE, %edi cld rep movsb /* setup GDT pseudo descriptor */ movw $(SIZEOF_GDT*BOOTSTRAP_GDT_NUM), %ax movw %ax, _apm_current_gdt_pdesc-KERNBASE leal _bootstrap_gdt-KERNBASE, %eax movl %eax, _apm_current_gdt_pdesc-KERNBASE+2 /* load new GDTR */ lgdt _apm_current_gdt_pdesc-KERNBASE /* setup GDT for APM initializer */ lea _bootstrap_gdt-KERNBASE, %ecx movl $(APM_OURADDR), %eax /* use %ax for 15..0 */ movl %eax, %ebx shrl $16, %ebx /* use %bl for 23..16 */ /* use %bh for 31..24 */ #define APM_SETUP_GDT(index, attrib) \ movl $(index), %si ; \ lea 0(%ecx,%esi,8), %edx ; \ movw $0xffff, (%edx) ; \ movw %ax, 2(%edx) ; \ movb %bl, 4(%edx) ; \ movw $(attrib), 5(%edx) ; \ movb %bh, 7(%edx) APM_SETUP_GDT(APM_INIT_CS_INDEX , CS32_ATTRIB) APM_SETUP_GDT(APM_INIT_DS_INDEX , DS32_ATTRIB) APM_SETUP_GDT(APM_INIT_CS16_INDEX, CS16_ATTRIB) /* * Call the initializer: * * direct intersegment call to conventional memory code */ .byte 0x9a /* actually, lcall $APM_INIT_CS_SEL, $0 */ .long 0 .word APM_INIT_CS_SEL movw %ax, _apm_version-KERNBASE movl %ebx, _apm_cs_entry-KERNBASE movw %cx, _apm_cs32_base-KERNBASE shrl $16, %ecx movw %cx, _apm_cs16_base-KERNBASE movw %dx, _apm_ds_base-KERNBASE movw %si, _apm_cs_limit-KERNBASE shrl $16, %esi movw %si, _apm_ds_limit-KERNBASE movw %di, _apm_flags-KERNBASE -#endif /* APM */ +#endif /* NAPM */ /* Find out our CPU type. */ /* Try to toggle alignment check flag; does not exist on 386. */ pushfl popl %eax movl %eax,%ecx orl $PSL_AC,%eax pushl %eax popfl pushfl popl %eax xorl %ecx,%eax andl $PSL_AC,%eax pushl %ecx popfl testl %eax,%eax jnz 1f movl $CPU_386,_cpu-KERNBASE jmp 2f 1: /* Try to toggle identification flag; does not exist on early 486s. */ pushfl popl %eax movl %eax,%ecx xorl $PSL_ID,%eax pushl %eax popfl pushfl popl %eax xorl %ecx,%eax andl $PSL_ID,%eax pushl %ecx popfl testl %eax,%eax jnz 1f movl $CPU_486,_cpu-KERNBASE /* check for Cyrix 486DLC -- based on check routine */ /* documented in "Cx486SLC/e SMM Programmer's Guide" */ xorw %dx,%dx cmpw %dx,%dx # set flags to known state pushfw popw %cx # store flags in ecx movw $0xffff,%ax movw $0x0004,%bx divw %bx pushfw popw %ax andw $0x08d5,%ax # mask off important bits andw $0x08d5,%cx cmpw %ax,%cx jnz 2f # if flags changed, Intel chip movl $CPU_486DLC,_cpu-KERNBASE # set CPU value for Cyrix movl $0x69727943,_cpu_vendor-KERNBASE # store vendor string movw $0x0078,_cpu_vendor-KERNBASE+4 invd # Start with guaranteed clean cache /* Disable caching of the ISA hole only. */ movb $CCR0,%al # Configuration Register index (CCR0) outb %al,$0x22 inb $0x23,%al orb $(CCR0_NC1|CCR0_BARB),%al outb %al,$0x23 invd jmp 2f 1: /* Use the `cpuid' instruction. */ xorl %eax,%eax .byte 0x0f,0xa2 # cpuid 0 movl %ebx,_cpu_vendor-KERNBASE # store vendor string movl %edx,_cpu_vendor+4-KERNBASE movl %ecx,_cpu_vendor+8-KERNBASE movb $0,_cpu_vendor+12-KERNBASE movl $1,%eax .byte 0x0f,0xa2 # cpuid 1 movl %eax,_cpu_id-KERNBASE # store cpu_id rorl $8,%eax # extract family type andl $15,%eax cmpl $5,%eax jae 1f /* less than Pentium; must be 486 */ movl $CPU_486,_cpu-KERNBASE jmp 2f 1: movl $CPU_586,_cpu-KERNBASE 2: /* * Finished with old stack; load new %esp now instead of later so * we can trace this code without having to worry about the trace * trap clobbering the memory test or the zeroing of the bss+bootstrap * page tables. * * XXX - wdboot clears the bss after testing that this is safe. * This is too wasteful - memory below 640K is scarce. The boot * program should check: * text+data <= &stack_variable - more_space_for_stack * text+data+bss+pad+space_for_page_tables <= end_of_memory * Oops, the gdt is in the carcass of the boot program so clearing * the rest of memory is still not possible. */ movl $tmpstk-KERNBASE,%esp /* bootstrap stack end location */ /* * Virtual address space of kernel: * * text | data | bss | [syms] | page dir | proc0 kernel stack | usr stk map | Sysmap * pages: 1 UPAGES (2) 1 NKPT (7) */ /* find end of kernel image */ movl $_end-KERNBASE,%ecx addl $NBPG-1,%ecx /* page align up */ andl $~(NBPG-1),%ecx movl %ecx,%esi /* esi = start of free memory */ movl %ecx,_KERNend-KERNBASE /* save end of kernel */ /* clear bss */ movl $_edata-KERNBASE,%edi subl %edi,%ecx /* get amount to clear */ xorl %eax,%eax /* specify zero fill */ cld rep stosb /* * The value in esi is both the end of the kernel bss and a pointer to * the kernel page directory, and is used by the rest of locore to build * the tables. * esi + 1(page dir) + 2(UPAGES) + 1(p0stack) + NKPT(number of kernel * page table pages) is then passed on the stack to init386(first) as * the value first. esi should ALWAYS be page aligned!! */ movl %esi,%ecx /* Get current first availiable address */ /* clear pagetables, page directory, stack, etc... */ movl %esi,%edi /* base (page directory) */ movl $((1+UPAGES+1+NKPT)*NBPG),%ecx /* amount to clear */ xorl %eax,%eax /* specify zero fill */ cld rep stosb /* physical address of Idle proc/kernel page directory */ movl %esi,_IdlePTD-KERNBASE /* * fillkpt * eax = (page frame address | control | status) == pte * ebx = address of page table * ecx = how many pages to map */ #define fillkpt \ 1: movl %eax,(%ebx) ; \ addl $NBPG,%eax ; /* increment physical address */ \ addl $4,%ebx ; /* next pte */ \ loop 1b ; /* * Map Kernel * * First step - build page tables */ #if defined (KGDB) || defined (BDE_DEBUGGER) movl _KERNend-KERNBASE,%ecx /* this much memory, */ shrl $PGSHIFT,%ecx /* for this many PTEs */ #ifdef BDE_DEBUGGER cmpl $0xa0,%ecx /* XXX - cover debugger pages */ jae 1f movl $0xa0,%ecx 1: #endif /* BDE_DEBUGGER */ movl $PG_V|PG_KW,%eax /* kernel R/W, valid */ lea ((1+UPAGES+1)*NBPG)(%esi),%ebx /* phys addr of kernel PT base */ movl %ebx,_KPTphys-KERNBASE /* save in global */ fillkpt #else /* !KGDB && !BDE_DEBUGGER */ /* write protect kernel text (doesn't do a thing for 386's - only 486's) */ movl $_etext-KERNBASE,%ecx /* get size of text */ shrl $PGSHIFT,%ecx /* for this many PTEs */ movl $PG_V|PG_KR,%eax /* specify read only */ lea ((1+UPAGES+1)*NBPG)(%esi),%ebx /* phys addr of kernel PT base */ movl %ebx,_KPTphys-KERNBASE /* save in global */ fillkpt /* data and bss are r/w */ andl $PG_FRAME,%eax /* strip to just addr of bss */ movl _KERNend-KERNBASE,%ecx /* calculate size */ subl %eax,%ecx shrl $PGSHIFT,%ecx orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ fillkpt #endif /* KGDB || BDE_DEBUGGER */ /* now initialize the page dir, upages, p0stack PT, and page tables */ movl $(1+UPAGES+1+NKPT),%ecx /* number of PTEs */ movl %esi,%eax /* phys address of PTD */ andl $PG_FRAME,%eax /* convert to PFN, should be a NOP */ orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ movl %esi,%ebx /* calculate pte offset to ptd */ shrl $PGSHIFT-2,%ebx addl %esi,%ebx /* address of page directory */ addl $((1+UPAGES+1)*NBPG),%ebx /* offset to kernel page tables */ fillkpt /* map I/O memory map */ movl _KPTphys-KERNBASE,%ebx /* base of kernel page tables */ lea (0xa0 * PTESIZE)(%ebx),%ebx /* hardwire ISA hole at KERNBASE + 0xa0000 */ movl $0x100-0xa0,%ecx /* for this many pte s, */ movl $(0xa0000|PG_V|PG_KW|PG_N),%eax /* valid, kernel read/write, non-cacheable */ movl %ebx,_atdevphys-KERNBASE /* save phys addr of ptes */ fillkpt /* map proc 0's kernel stack into user page table page */ movl $UPAGES,%ecx /* for this many pte s, */ lea (1*NBPG)(%esi),%eax /* physical address in proc 0 */ lea (KERNBASE)(%eax),%edx /* change into virtual addr */ movl %edx,_proc0paddr-KERNBASE /* save VA for proc 0 init */ orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ lea ((1+UPAGES)*NBPG)(%esi),%ebx /* addr of stack page table in proc 0 */ addl $(KSTKPTEOFF * PTESIZE),%ebx /* offset to kernel stack PTE */ fillkpt /* * Initialize kernel page table directory */ /* install a pde for temporary double map of bottom of VA */ movl _KPTphys-KERNBASE,%eax orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ movl %eax,(%esi) /* which is where temp maps! */ /* initialize kernel pde's */ movl $(NKPT),%ecx /* for this many PDEs */ lea (KPTDI*PDESIZE)(%esi),%ebx /* offset of pde for kernel */ fillkpt /* install a pde recursively mapping page directory as a page table! */ movl %esi,%eax /* phys address of ptd in proc 0 */ orl $PG_V|PG_KW,%eax /* pde entry is valid */ movl %eax,PTDPTDI*PDESIZE(%esi) /* which is where PTmap maps! */ /* install a pde to map kernel stack for proc 0 */ lea ((1+UPAGES)*NBPG)(%esi),%eax /* physical address of pt in proc 0 */ orl $PG_V|PG_KW,%eax /* pde entry is valid */ movl %eax,KSTKPTDI*PDESIZE(%esi) /* which is where kernel stack maps! */ #ifdef BDE_DEBUGGER /* copy and convert stuff from old gdt and idt for debugger */ cmpl $0x0375c339,0x96104 /* XXX - debugger signature */ jne 1f movb $1,_bdb_exists-KERNBASE 1: pushal subl $2*6,%esp sgdt (%esp) movl 2(%esp),%esi /* base address of current gdt */ movl $_gdt-KERNBASE,%edi movl %edi,2(%esp) movl $8*18/4,%ecx cld rep /* copy gdt */ movsl movl $_gdt-KERNBASE,-8+2(%edi) /* adjust gdt self-ptr */ movb $0x92,-8+5(%edi) sidt 6(%esp) movl 6+2(%esp),%esi /* base address of current idt */ movl 8+4(%esi),%eax /* convert dbg descriptor to ... */ movw 8(%esi),%ax movl %eax,bdb_dbg_ljmp+1-KERNBASE /* ... immediate offset ... */ movl 8+2(%esi),%eax movw %ax,bdb_dbg_ljmp+5-KERNBASE /* ... and selector for ljmp */ movl 24+4(%esi),%eax /* same for bpt descriptor */ movw 24(%esi),%ax movl %eax,bdb_bpt_ljmp+1-KERNBASE movl 24+2(%esi),%eax movw %ax,bdb_bpt_ljmp+5-KERNBASE movl $_idt-KERNBASE,%edi movl %edi,6+2(%esp) movl $8*4/4,%ecx cld rep /* copy idt */ movsl lgdt (%esp) lidt 6(%esp) addl $2*6,%esp popal #endif /* BDE_DEBUGGER */ /* load base of page directory and enable mapping */ movl %esi,%eax /* phys address of ptd in proc 0 */ movl %eax,%cr3 /* load ptd addr into mmu */ movl %cr0,%eax /* get control word */ orl $CR0_PE|CR0_PG,%eax /* enable paging */ movl %eax,%cr0 /* and let's page NOW! */ pushl $begin /* jump to high mem */ ret begin: /* now running relocated at KERNBASE where the system is linked to run */ .globl _Crtat /* XXX - locore should not know about */ movl _Crtat,%eax /* variables of device drivers (pccons)! */ subl $(KERNBASE+0xA0000),%eax movl _atdevphys,%edx /* get pte PA */ subl _KPTphys,%edx /* remove base of ptes, now have phys offset */ shll $PGSHIFT-2,%edx /* corresponding to virt offset */ addl $KERNBASE,%edx /* add virtual base */ movl %edx,_atdevbase addl %eax,%edx movl %edx,_Crtat /* set up bootstrap stack - 48 bytes */ movl $_kstack+UPAGES*NBPG-4*12,%esp /* bootstrap stack end location */ xorl %eax,%eax /* mark end of frames */ movl %eax,%ebp movl _proc0paddr,%eax movl %esi,PCB_CR3(%eax) #ifdef BDE_DEBUGGER /* relocate debugger gdt entries */ movl $_gdt+8*9,%eax /* adjust slots 9-17 */ movl $9,%ecx reloc_gdt: movb $KERNBASE>>24,7(%eax) /* top byte of base addresses, was 0, */ addl $8,%eax /* now KERNBASE>>24 */ loop reloc_gdt cmpl $0,_bdb_exists je 1f int $3 1: #endif /* BDE_DEBUGGER */ /* * Skip over the page tables and the kernel stack */ lea ((1+UPAGES+1+NKPT)*NBPG)(%esi),%esi pushl %esi /* value of first for init386(first) */ call _init386 /* wire 386 chip for unix operation */ popl %esi .globl __ucodesel,__udatasel pushl $0 /* unused */ pushl __udatasel /* ss */ pushl $0 /* esp - filled in by execve() */ pushl $PSL_USERSET /* eflags (ring 0, int enab) */ pushl __ucodesel /* cs */ pushl $0 /* eip - filled in by execve() */ subl $(12*4),%esp /* space for rest of registers */ pushl %esp /* call main with frame pointer */ call _main /* autoconfiguration, mountroot etc */ addl $(13*4),%esp /* back to a frame we can return with */ /* * now we've run main() and determined what cpu-type we are, we can * enable WP mode on i486 cpus and above. */ #if defined(I486_CPU) || defined(I586_CPU) cmpl $CPUCLASS_386,_cpu_class je 1f movl %cr0,%eax /* get control word */ orl $CR0_WP,%eax /* enable write protect for all modes */ movl %eax,%cr0 /* and do it */ #endif /* * on return from main(), we are process 1 * set up address space and stack so that we can 'return' to user mode */ 1: movl __ucodesel,%eax movl __udatasel,%ecx movl %cx,%ds movl %cx,%es movl %ax,%fs /* double map cs to fs */ movl %cx,%gs /* and ds to gs */ iret /* goto user! */ #define LCALL(x,y) .byte 0x9a ; .long y ; .word x NON_GPROF_ENTRY(sigcode) call SIGF_HANDLER(%esp) lea SIGF_SC(%esp),%eax /* scp (the call may have clobbered the */ /* copy at 8(%esp)) */ pushl %eax pushl %eax /* junk to fake return address */ movl $103,%eax /* XXX sigreturn() */ LCALL(0x7,0) /* enter kernel with args on stack */ hlt /* never gets here */ .globl _szsigcode _szsigcode: .long _szsigcode-_sigcode diff --git a/sys/amd64/amd64/machdep.c b/sys/amd64/amd64/machdep.c index 0fff0aa89461..1701db1d725a 100644 --- a/sys/amd64/amd64/machdep.c +++ b/sys/amd64/amd64/machdep.c @@ -1,1647 +1,1620 @@ /*- * Copyright (c) 1992 Terrence R. Lambert. * Copyright (c) 1982, 1987, 1990 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * William Jolitz. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 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 * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: @(#)machdep.c 7.4 (Berkeley) 6/3/91 - * $Id: machdep.c,v 1.70 1994/10/04 18:44:21 ache Exp $ + * $Id: machdep.c,v 1.71 1994/10/09 07:34:29 davidg Exp $ */ #include "npx.h" #include "isa.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef SYSVSHM #include #endif #ifdef SYSVMSG #include #endif #ifdef SYSVSEM #include #endif #include #include #include #include #include #include extern vm_offset_t avail_start, avail_end; #include #include #include #include #include #include #include #include #include static void identifycpu(void); static void initcpu(void); static int test_page(int *, int); char machine[] = "i386"; char cpu_model[sizeof("Cy486DLC") + 1]; #ifndef PANIC_REBOOT_WAIT_TIME #define PANIC_REBOOT_WAIT_TIME 15 /* default to 15 seconds */ #endif /* * Declare these as initialized data so we can patch them. */ int nswbuf = 0; #ifdef NBUF int nbuf = NBUF; #else int nbuf = 0; #endif #ifdef BUFPAGES int bufpages = BUFPAGES; #else int bufpages = 0; #endif #ifdef BOUNCE_BUFFERS extern char *bouncememory; extern int maxbkva; #ifdef BOUNCEPAGES int bouncepages = BOUNCEPAGES; #else int bouncepages = 0; #endif #endif /* BOUNCE_BUFFERS */ extern int freebufspace; int msgbufmapped = 0; /* set when safe to use msgbuf */ int _udatasel, _ucodesel; extern int adjkerntz, disable_rtc_set; /* from clock.c */ /* * Machine-dependent startup code */ int boothowto = 0, Maxmem = 0, badpages = 0, physmem = 0; long dumplo; extern int bootdev; int biosmem; vm_offset_t phys_avail[6]; int cpu_class; void dumpsys __P((void)); vm_offset_t buffer_sva, buffer_eva; vm_offset_t clean_sva, clean_eva; vm_offset_t pager_sva, pager_eva; extern int pager_map_size; #define offsetof(type, member) ((size_t)(&((type *)0)->member)) void cpu_startup() { register unsigned i; register caddr_t v; extern void (*netisrs[32])(void); - vm_offset_t minaddr, maxaddr; + vm_offset_t maxaddr; vm_size_t size = 0; int firstaddr; /* * Initialize error message buffer (at end of core). */ /* avail_end was pre-decremented in init_386() to compensate */ for (i = 0; i < btoc(sizeof (struct msgbuf)); i++) pmap_enter(pmap_kernel(), (vm_offset_t)msgbufp, avail_end + i * NBPG, VM_PROT_ALL, TRUE); msgbufmapped = 1; /* * Good {morning,afternoon,evening,night}. */ printf(version); startrtclock(); identifycpu(); printf("real memory = %d (%d pages)\n", ptoa(physmem), physmem); if (badpages) printf("bad memory = %d (%d pages)\n", ptoa(badpages), badpages); /* * Quickly wire in netisrs. */ #define DONET(isr, n) do { extern void isr(void); netisrs[n] = isr; } while(0) #ifdef INET #if NETHER > 0 DONET(arpintr, NETISR_ARP); #endif DONET(ipintr, NETISR_IP); #endif #ifdef NS DONET(nsintr, NETISR_NS); #endif #ifdef ISO DONET(clnlintr, NETISR_ISO); #endif #ifdef CCITT DONET(ccittintr, NETISR_CCITT); #endif #undef DONET /* * Allocate space for system data structures. * The first available kernel virtual address is in "v". * As pages of kernel virtual memory are allocated, "v" is incremented. * As pages of memory are allocated and cleared, * "firstaddr" is incremented. * An index into the kernel page table corresponding to the * virtual memory address maintained in "v" is kept in "mapaddr". */ /* * Make two passes. The first pass calculates how much memory is * needed and allocates it. The second pass assigns virtual * addresses to the various data structures. */ firstaddr = 0; again: v = (caddr_t)firstaddr; #define valloc(name, type, num) \ (name) = (type *)v; v = (caddr_t)((name)+(num)) #define valloclim(name, type, num, lim) \ (name) = (type *)v; v = (caddr_t)((lim) = ((name)+(num))) valloc(callout, struct callout, ncallout); #ifdef SYSVSHM valloc(shmsegs, struct shmid_ds, shminfo.shmmni); #endif #ifdef SYSVSEM valloc(sema, struct semid_ds, seminfo.semmni); valloc(sem, struct sem, seminfo.semmns); /* This is pretty disgusting! */ valloc(semu, int, (seminfo.semmnu * seminfo.semusz) / sizeof(int)); #endif #ifdef SYSVMSG valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); valloc(msqids, struct msqid_ds, msginfo.msgmni); #endif /* * Determine how many buffers to allocate. * Use 20% of memory of memory beyond the first 2MB * Insure a minimum of 16 fs buffers. * We allocate 1/2 as many swap buffer headers as file i/o buffers. */ if (bufpages == 0) bufpages = ((physmem << PGSHIFT) - 2048*1024) / NBPG / 5; if (bufpages < 64) bufpages = 64; /* * We must still limit the maximum number of buffers to be no * more than 2/5's of the size of the kernal malloc region, this * will only take effect for machines with lots of memory */ bufpages = min(bufpages, (VM_KMEM_SIZE / NBPG) * 2 / 5); if (nbuf == 0) { nbuf = bufpages / 2; if (nbuf < 32) nbuf = 32; } freebufspace = bufpages * NBPG; if (nswbuf == 0) { nswbuf = (nbuf / 2) &~ 1; /* force even */ if (nswbuf > 64) nswbuf = 64; /* sanity */ } valloc(swbuf, struct buf, nswbuf); valloc(buf, struct buf, nbuf); #ifdef BOUNCE_BUFFERS /* * If there is more than 16MB of memory, allocate some bounce buffers */ if (Maxmem > 4096) { if (bouncepages == 0) bouncepages = 96; /* largest physio size + extra */ v = (caddr_t)((vm_offset_t)((vm_offset_t)v + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)); valloc(bouncememory, char, bouncepages * PAGE_SIZE); } #endif /* * End of first pass, size has been calculated so allocate memory */ if (firstaddr == 0) { size = (vm_size_t)(v - firstaddr); firstaddr = (int)kmem_alloc(kernel_map, round_page(size)); if (firstaddr == 0) panic("startup: no room for tables"); goto again; } /* * End of second pass, addresses have been assigned */ if ((vm_size_t)(v - firstaddr) != size) panic("startup: table size inconsistency"); #ifdef BOUNCE_BUFFERS clean_map = kmem_suballoc(kernel_map, &clean_sva, &clean_eva, (nbuf*MAXBSIZE) + (nswbuf*MAXPHYS) + maxbkva + pager_map_size, TRUE); io_map = kmem_suballoc(clean_map, &minaddr, &maxaddr, maxbkva, FALSE); #else clean_map = kmem_suballoc(kernel_map, &clean_sva, &clean_eva, (nbuf*MAXBSIZE) + (nswbuf*MAXPHYS) + pager_map_size, TRUE); #endif buffer_map = kmem_suballoc(clean_map, &buffer_sva, &buffer_eva, (nbuf*MAXBSIZE), TRUE); pager_map = kmem_suballoc(clean_map, &pager_sva, &pager_eva, (nswbuf*MAXPHYS) + pager_map_size, TRUE); /* * Finally, allocate mbuf pool. Since mclrefcnt is an off-size * we use the more space efficient malloc in place of kmem_alloc. */ mclrefcnt = (char *)malloc(NMBCLUSTERS+CLBYTES/MCLBYTES, M_MBUF, M_NOWAIT); bzero(mclrefcnt, NMBCLUSTERS+CLBYTES/MCLBYTES); mb_map = kmem_suballoc(kmem_map, (vm_offset_t *)&mbutl, &maxaddr, VM_MBUF_SIZE, FALSE); /* * Initialize callouts */ callfree = callout; for (i = 1; i < ncallout; i++) callout[i-1].c_next = &callout[i]; printf("avail memory = %d (%d pages)\n", ptoa(cnt.v_free_count), cnt.v_free_count); printf("using %d buffers containing %d bytes of memory\n", nbuf, bufpages * CLBYTES); #ifdef BOUNCE_BUFFERS /* * init bounce buffers */ vm_bounce_init(); #endif /* * Set up CPU-specific registers, cache, etc. */ initcpu(); /* * Set up buffers, so they can be used to read disk labels. */ bufinit(); vm_pager_bufferinit(); /* * Configure the system. */ configure(); } struct cpu_nameclass i386_cpus[] = { { "Intel 80286", CPUCLASS_286 }, /* CPU_286 */ { "i386SX", CPUCLASS_386 }, /* CPU_386SX */ { "i386DX", CPUCLASS_386 }, /* CPU_386 */ { "i486SX", CPUCLASS_486 }, /* CPU_486SX */ { "i486DX", CPUCLASS_486 }, /* CPU_486 */ { "Pentium", CPUCLASS_586 }, /* CPU_586 */ { "Cy486DLC", CPUCLASS_486 }, /* CPU_486DLC */ }; static void identifycpu() { extern u_long cpu_id; extern char cpu_vendor[]; printf("CPU: "); if (cpu >= 0 && cpu < (sizeof i386_cpus/sizeof(struct cpu_nameclass))) { printf("%s", i386_cpus[cpu].cpu_name); cpu_class = i386_cpus[cpu].cpu_class; strncpy(cpu_model, i386_cpus[cpu].cpu_name, sizeof cpu_model); } else { printf("unknown cpu type %d\n", cpu); panic("startup: bad cpu id"); } printf(" ("); switch(cpu_class) { case CPUCLASS_286: printf("286"); break; case CPUCLASS_386: printf("386"); break; case CPUCLASS_486: printf("486"); break; case CPUCLASS_586: printf("Pentium"); break; default: printf("unknown"); /* will panic below... */ } printf("-class CPU)"); #ifdef I586_CPU if(cpu_class == CPUCLASS_586) { extern void calibrate_cyclecounter(); extern int pentium_mhz; calibrate_cyclecounter(); printf(" %d MHz", pentium_mhz); } #endif if(cpu_id) printf(" Id = 0x%lx",cpu_id); if(*cpu_vendor) printf(" Origin = \"%s\"",cpu_vendor); printf("\n"); /* cpu speed would be nice, but how? */ /* * Now that we have told the user what they have, * let them know if that machine type isn't configured. */ switch (cpu_class) { case CPUCLASS_286: /* a 286 should not make it this far, anyway */ #if !defined(I386_CPU) && !defined(I486_CPU) && !defined(I586_CPU) #error This kernel is not configured for one of the supported CPUs #endif #if !defined(I386_CPU) case CPUCLASS_386: #endif #if !defined(I486_CPU) case CPUCLASS_486: #endif #if !defined(I586_CPU) case CPUCLASS_586: #endif panic("CPU class not configured"); default: break; } } #ifdef PGINPROF /* * Return the difference (in microseconds) * between the current time and a previous * time as represented by the arguments. * If there is a pending clock interrupt * which has not been serviced due to high * ipl, return error code. */ /*ARGSUSED*/ vmtime(otime, olbolt, oicr) register int otime, olbolt, oicr; { return (((time.tv_sec-otime)*60 + lbolt-olbolt)*16667); } #endif extern int kstack[]; /* * Send an interrupt to process. * * Stack is set up to allow sigcode stored * in u. to call routine, followed by kcall * to sigreturn routine below. After sigreturn * resets the signal mask, the stack, and the * frame pointer, it returns to the user * specified pc, psl. */ void sendsig(catcher, sig, mask, code) sig_t catcher; int sig, mask; unsigned code; { register struct proc *p = curproc; register int *regs; register struct sigframe *fp; struct sigacts *psp = p->p_sigacts; int oonstack; regs = p->p_md.md_regs; oonstack = psp->ps_sigstk.ss_flags & SA_ONSTACK; /* * Allocate and validate space for the signal handler * context. Note that if the stack is in P0 space, the * call to grow() is a nop, and the useracc() check * will fail if the process has not already allocated * the space with a `brk'. */ if ((psp->ps_flags & SAS_ALTSTACK) && (psp->ps_sigstk.ss_flags & SA_ONSTACK) == 0 && (psp->ps_sigonstack & sigmask(sig))) { fp = (struct sigframe *)(psp->ps_sigstk.ss_base + psp->ps_sigstk.ss_size - sizeof(struct sigframe)); psp->ps_sigstk.ss_flags |= SA_ONSTACK; } else { fp = (struct sigframe *)(regs[tESP] - sizeof(struct sigframe)); } /* * grow() will return FALSE if the fp will not fit inside the stack * and the stack can not be grown. useracc will return FALSE * if access is denied. */ if ((grow(p, (int)fp) == FALSE) || (useracc((caddr_t)fp, sizeof (struct sigframe), B_WRITE) == FALSE)) { /* * Process has trashed its stack; give it an illegal * instruction to halt it in its tracks. */ SIGACTION(p, SIGILL) = SIG_DFL; sig = sigmask(SIGILL); p->p_sigignore &= ~sig; p->p_sigcatch &= ~sig; p->p_sigmask &= ~sig; psignal(p, SIGILL); return; } /* * Build the argument list for the signal handler. */ if (p->p_sysent->sv_sigtbl) { if (sig < p->p_sysent->sv_sigsize) sig = p->p_sysent->sv_sigtbl[sig]; else sig = p->p_sysent->sv_sigsize + 1; } fp->sf_signum = sig; fp->sf_code = code; fp->sf_scp = &fp->sf_sc; fp->sf_addr = (char *) regs[tERR]; fp->sf_handler = catcher; /* save scratch registers */ fp->sf_sc.sc_eax = regs[tEAX]; fp->sf_sc.sc_ebx = regs[tEBX]; fp->sf_sc.sc_ecx = regs[tECX]; fp->sf_sc.sc_edx = regs[tEDX]; fp->sf_sc.sc_esi = regs[tESI]; fp->sf_sc.sc_edi = regs[tEDI]; fp->sf_sc.sc_cs = regs[tCS]; fp->sf_sc.sc_ds = regs[tDS]; fp->sf_sc.sc_ss = regs[tSS]; fp->sf_sc.sc_es = regs[tES]; fp->sf_sc.sc_isp = regs[tISP]; /* * Build the signal context to be used by sigreturn. */ fp->sf_sc.sc_onstack = oonstack; fp->sf_sc.sc_mask = mask; fp->sf_sc.sc_sp = regs[tESP]; fp->sf_sc.sc_fp = regs[tEBP]; fp->sf_sc.sc_pc = regs[tEIP]; fp->sf_sc.sc_ps = regs[tEFLAGS]; regs[tESP] = (int)fp; regs[tEIP] = (int)((struct pcb *)kstack)->pcb_sigc; regs[tEFLAGS] &= ~PSL_VM; regs[tCS] = _ucodesel; regs[tDS] = _udatasel; regs[tES] = _udatasel; regs[tSS] = _udatasel; } /* * System call to cleanup state after a signal * has been taken. Reset signal mask and * stack state from context left by sendsig (above). * Return to previous pc and psl as specified by * context left by sendsig. Check carefully to * make sure that the user has not modified the * psl to gain improper privileges or to cause * a machine fault. */ struct sigreturn_args { struct sigcontext *sigcntxp; }; int sigreturn(p, uap, retval) struct proc *p; struct sigreturn_args *uap; int *retval; { register struct sigcontext *scp; register struct sigframe *fp; register int *regs = p->p_md.md_regs; int eflags; /* * (XXX old comment) regs[tESP] points to the return address. * The user scp pointer is above that. * The return address is faked in the signal trampoline code * for consistency. */ scp = uap->sigcntxp; fp = (struct sigframe *) ((caddr_t)scp - offsetof(struct sigframe, sf_sc)); if (useracc((caddr_t)fp, sizeof (*fp), 0) == 0) return(EINVAL); eflags = scp->sc_ps; if ((eflags & PSL_USERCLR) != 0 || (eflags & PSL_USERSET) != PSL_USERSET || (eflags & PSL_IOPL) < (regs[tEFLAGS] & PSL_IOPL)) { #ifdef DEBUG printf("sigreturn: eflags=0x%x\n", eflags); #endif return(EINVAL); } /* * Sanity check the user's selectors and error if they * are suspect. */ #define max_ldt_sel(pcb) \ ((pcb)->pcb_ldt ? (pcb)->pcb_ldt_len : (sizeof(ldt) / sizeof(ldt[0]))) #define valid_ldt_sel(sel) \ (ISLDT(sel) && ISPL(sel) == SEL_UPL && \ IDXSEL(sel) < max_ldt_sel(&p->p_addr->u_pcb)) #define null_sel(sel) \ (!ISLDT(sel) && IDXSEL(sel) == 0) if (((scp->sc_cs&0xffff) != _ucodesel && !valid_ldt_sel(scp->sc_cs)) || ((scp->sc_ss&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_ss)) || ((scp->sc_ds&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_ds) && !null_sel(scp->sc_ds)) || ((scp->sc_es&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_es) && !null_sel(scp->sc_es))) { #ifdef DEBUG printf("sigreturn: cs=0x%x ss=0x%x ds=0x%x es=0x%x\n", scp->sc_cs, scp->sc_ss, scp->sc_ds, scp->sc_es); #endif trapsignal(p, SIGBUS, T_PROTFLT); return(EINVAL); } #undef max_ldt_sel #undef valid_ldt_sel #undef null_sel /* restore scratch registers */ regs[tEAX] = scp->sc_eax; regs[tEBX] = scp->sc_ebx; regs[tECX] = scp->sc_ecx; regs[tEDX] = scp->sc_edx; regs[tESI] = scp->sc_esi; regs[tEDI] = scp->sc_edi; regs[tCS] = scp->sc_cs; regs[tDS] = scp->sc_ds; regs[tES] = scp->sc_es; regs[tSS] = scp->sc_ss; regs[tISP] = scp->sc_isp; if (useracc((caddr_t)scp, sizeof (*scp), 0) == 0) return(EINVAL); if (scp->sc_onstack & 01) p->p_sigacts->ps_sigstk.ss_flags |= SA_ONSTACK; else p->p_sigacts->ps_sigstk.ss_flags &= ~SA_ONSTACK; p->p_sigmask = scp->sc_mask &~ (sigmask(SIGKILL)|sigmask(SIGCONT)|sigmask(SIGSTOP)); regs[tEBP] = scp->sc_fp; regs[tESP] = scp->sc_sp; regs[tEIP] = scp->sc_pc; regs[tEFLAGS] = eflags; return(EJUSTRETURN); } /* * a simple function to make the system panic (and dump a vmcore) * in a predictable fashion */ void diediedie() { panic("because you said to!"); } int waittime = -1; struct pcb dumppcb; __dead void boot(arghowto) int arghowto; { register long dummy; /* r12 is reserved */ register int howto; /* r11 == how to boot */ register int devtype; /* r10 == major of root dev */ extern int cold; if (cold) { printf("hit reset please"); for(;;); } howto = arghowto; if ((howto&RB_NOSYNC) == 0 && waittime < 0) { register struct buf *bp; int iter, nbusy; waittime = 0; printf("\nsyncing disks... "); /* * Release inodes held by texts before update. */ if (panicstr == 0) vnode_pager_umount(NULL); sync(curproc, NULL, NULL); for (iter = 0; iter < 20; iter++) { nbusy = 0; for (bp = &buf[nbuf]; --bp >= buf; ) if ((bp->b_flags & (B_BUSY|B_INVAL)) == B_BUSY) nbusy++; if (nbusy == 0) break; printf("%d ", nbusy); DELAY(40000 * iter); } if (nbusy) { /* * Failed to sync all blocks. Indicate this and don't * unmount filesystems (thus forcing an fsck on reboot). */ printf("giving up\n"); } else { printf("done\n"); /* * Unmount filesystems */ if (panicstr == 0) vfs_unmountall(); } DELAY(100000); /* wait for console output to finish */ } splhigh(); devtype = major(rootdev); if (howto&RB_HALT) { printf("\n"); printf("The operating system has halted.\n"); printf("Please press any key to reboot.\n\n"); cngetc(); } else { if (howto & RB_DUMP) { savectx(&dumppcb, 0); dumppcb.pcb_ptd = rcr3(); dumpsys(); if (PANIC_REBOOT_WAIT_TIME != 0) { if (PANIC_REBOOT_WAIT_TIME != -1) { int loop; printf("Automatic reboot in %d seconds - press a key on the console to abort\n", PANIC_REBOOT_WAIT_TIME); for (loop = PANIC_REBOOT_WAIT_TIME; loop > 0; --loop) { DELAY(1000 * 1000); /* one second */ if (sgetc(1)) /* Did user type a key? */ break; } if (!loop) goto die; } } else { /* zero time specified - reboot NOW */ goto die; } printf("--> Press a key on the console to reboot <--\n"); cngetc(); } } #ifdef lint dummy = 0; dummy = dummy; printf("howto %d, devtype %d\n", arghowto, devtype); #endif die: printf("Rebooting...\n"); DELAY(1000000); /* wait 1 sec for printf's to complete and be read */ cpu_reset(); for(;;) ; /* NOTREACHED */ } unsigned long dumpmag = 0x8fca0101UL; /* magic number for savecore */ int dumpsize = 0; /* also for savecore */ /* * Doadump comes here after turning off memory management and * getting on the dump stack, either when called above, or by * the auto-restart code. */ void dumpsys() { if (dumpdev == NODEV) return; if ((minor(dumpdev)&07) != 1) return; dumpsize = Maxmem; printf("\ndumping to dev %lx, offset %ld\n", dumpdev, dumplo); printf("dump "); switch ((*bdevsw[major(dumpdev)].d_dump)(dumpdev)) { case ENXIO: printf("device bad\n"); break; case EFAULT: printf("device not ready\n"); break; case EINVAL: printf("area improper\n"); break; case EIO: printf("i/o error\n"); break; case EINTR: printf("aborted from console\n"); break; default: printf("succeeded\n"); break; } } #ifdef HZ /* * If HZ is defined we use this code, otherwise the code in * /sys/i386/i386/microtime.s is used. The othercode only works * for HZ=100. */ microtime(tvp) register struct timeval *tvp; { int s = splhigh(); *tvp = time; tvp->tv_usec += tick; while (tvp->tv_usec > 1000000) { tvp->tv_sec++; tvp->tv_usec -= 1000000; } splx(s); } #endif /* HZ */ static void initcpu() { } /* * Clear registers on exec */ void setregs(p, entry, stack) struct proc *p; u_long entry; u_long stack; { p->p_md.md_regs[tEBP] = 0; /* bottom of the fp chain */ p->p_md.md_regs[tEIP] = entry; p->p_md.md_regs[tESP] = stack; p->p_md.md_regs[tSS] = _udatasel; p->p_md.md_regs[tDS] = _udatasel; p->p_md.md_regs[tES] = _udatasel; p->p_md.md_regs[tCS] = _ucodesel; p->p_addr->u_pcb.pcb_flags = 0; /* no fp at all */ load_cr0(rcr0() | CR0_TS); /* start emulating */ #if NNPX > 0 npxinit(__INITIAL_NPXCW__); #endif /* NNPX > 0 */ } /* * machine dependent system variables. */ int cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) int *name; u_int namelen; void *oldp; size_t *oldlenp; void *newp; size_t newlen; struct proc *p; { /* all sysctl names at this level are terminal */ if (namelen != 1) return (ENOTDIR); /* overloaded */ switch (name[0]) { case CPU_CONSDEV: return (sysctl_rdstruct(oldp, oldlenp, newp, &cn_tty->t_dev, sizeof cn_tty->t_dev)); case CPU_ADJKERNTZ: return (sysctl_int(oldp, oldlenp, newp, newlen, &adjkerntz)); case CPU_DISRTCSET: return (sysctl_int(oldp, oldlenp, newp, newlen, &disable_rtc_set)); default: return (EOPNOTSUPP); } /* NOTREACHED */ } /* * Initialize 386 and configure to run kernel */ /* * Initialize segments & interrupt table */ union descriptor gdt[NGDT]; union descriptor ldt[NLDT]; /* local descriptor table */ struct gate_descriptor idt[NIDT]; /* interrupt descriptor table */ int _default_ldt, currentldt; struct i386tss tss, panic_tss; extern struct user *proc0paddr; /* software prototypes -- in more palatable form */ struct soft_segment_descriptor gdt_segs[] = { - /* Null Descriptor */ +/* GNULL_SEL 0 Null Descriptor */ { 0x0, /* segment base address */ 0x0, /* length */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* Code Descriptor for kernel */ +/* GCODE_SEL 1 Code Descriptor for kernel */ { 0x0, /* segment base address */ 0xfffff, /* length - all address space */ SDT_MEMERA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ 1 /* limit granularity (byte/page units)*/ }, - /* Data Descriptor for kernel */ +/* GDATA_SEL 2 Data Descriptor for kernel */ { 0x0, /* segment base address */ 0xfffff, /* length - all address space */ SDT_MEMRWA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ 1 /* limit granularity (byte/page units)*/ }, - /* LDT Descriptor */ -{ (int) ldt, /* segment base address */ +/* GLDT_SEL 3 LDT Descriptor */ +{ (int) ldt, /* segment base address */ sizeof(ldt)-1, /* length - all address space */ SDT_SYSLDT, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* unused - default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* Null Descriptor - Placeholder */ +/* GTGATE_SEL 4 Null Descriptor - Placeholder */ { 0x0, /* segment base address */ 0x0, /* length - all address space */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* Panic Tss Descriptor */ -{ (int) &panic_tss, /* segment base address */ +/* GPANIC_SEL 5 Panic Tss Descriptor */ +{ (int) &panic_tss, /* segment base address */ sizeof(tss)-1, /* length - all address space */ SDT_SYS386TSS, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* unused - default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* Proc 0 Tss Descriptor */ -{ (int) kstack, /* segment base address */ +/* GPROC0_SEL 6 Proc 0 Tss Descriptor */ +{ (int) kstack, /* segment base address */ sizeof(tss)-1, /* length - all address space */ SDT_SYS386TSS, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* unused - default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* User LDT Descriptor per process */ +/* GUSERLDT_SEL 7 User LDT Descriptor per process */ { (int) ldt, /* segment base address */ (512 * sizeof(union descriptor)-1), /* length */ SDT_SYSLDT, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* unused - default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, -#ifdef APM - /* APM BIOS 32-bit interface (32bit Code) */ +/* GAPMCODE32_SEL 8 APM BIOS 32-bit interface (32bit Code) */ { 0, /* segment base address (overwritten by APM) */ - 0xffff, /* length */ + 0xfffff, /* length */ SDT_MEMERA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, - /* APM BIOS 32-bit interface (16bit Code) */ + 1 /* limit granularity (byte/page units)*/ }, +/* GAPMCODE16_SEL 9 APM BIOS 32-bit interface (16bit Code) */ { 0, /* segment base address (overwritten by APM) */ - 0xffff, /* length */ + 0xfffff, /* length */ SDT_MEMERA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, - /* APM BIOS 32-bit interface (Data) */ + 1 /* limit granularity (byte/page units)*/ }, +/* GAPMDATA_SEL 10 APM BIOS 32-bit interface (Data) */ { 0, /* segment base address (overwritten by APM) */ - 0xffff, /* length */ + 0xfffff, /* length */ SDT_MEMRWA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, -#else /* APM */ -{ 0, /* segment base address */ - 0, /* length */ - 0, /* segment type */ - 0, /* segment descriptor priority level */ - 0, /* segment descriptor present */ - 0, 0, - 0, /* unused - default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, -{ 0, /* segment base address */ - 0, /* length */ - 0, /* segment type */ - 0, /* segment descriptor priority level */ - 0, /* segment descriptor present */ - 0, 0, - 0, /* unused - default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, -{ 0, /* segment base address */ - 0, /* length */ - 0, /* segment type */ - 0, /* segment descriptor priority level */ - 0, /* segment descriptor present */ - 0, 0, - 0, /* unused - default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, -#endif /* APMBIOS */ + 1 /* limit granularity (byte/page units)*/ }, }; struct soft_segment_descriptor ldt_segs[] = { /* Null Descriptor - overwritten by call gate */ { 0x0, /* segment base address */ 0x0, /* length - all address space */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, /* Null Descriptor - overwritten by call gate */ { 0x0, /* segment base address */ 0x0, /* length - all address space */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, /* Null Descriptor - overwritten by call gate */ { 0x0, /* segment base address */ 0x0, /* length - all address space */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, /* Code Descriptor for user */ { 0x0, /* segment base address */ 0xfffff, /* length - all address space */ SDT_MEMERA, /* segment type */ SEL_UPL, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ 1 /* limit granularity (byte/page units)*/ }, /* Data Descriptor for user */ { 0x0, /* segment base address */ 0xfffff, /* length - all address space */ SDT_MEMRWA, /* segment type */ SEL_UPL, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ 1 /* limit granularity (byte/page units)*/ } }; void setidt(idx, func, typ, dpl) int idx; void (*func)(); int typ; int dpl; { struct gate_descriptor *ip = idt + idx; ip->gd_looffset = (int)func; ip->gd_selector = 8; ip->gd_stkcpy = 0; ip->gd_xx = 0; ip->gd_type = typ; ip->gd_dpl = dpl; ip->gd_p = 1; ip->gd_hioffset = ((int)func)>>16 ; } #define IDTVEC(name) __CONCAT(X,name) typedef void idtvec_t(); extern idtvec_t IDTVEC(div), IDTVEC(dbg), IDTVEC(nmi), IDTVEC(bpt), IDTVEC(ofl), IDTVEC(bnd), IDTVEC(ill), IDTVEC(dna), IDTVEC(dble), IDTVEC(fpusegm), IDTVEC(tss), IDTVEC(missing), IDTVEC(stk), IDTVEC(prot), IDTVEC(page), IDTVEC(rsvd), IDTVEC(fpu), IDTVEC(rsvd0), IDTVEC(rsvd1), IDTVEC(rsvd2), IDTVEC(rsvd3), IDTVEC(rsvd4), IDTVEC(rsvd5), IDTVEC(rsvd6), IDTVEC(rsvd7), IDTVEC(rsvd8), IDTVEC(rsvd9), IDTVEC(rsvd10), IDTVEC(rsvd11), IDTVEC(rsvd12), IDTVEC(rsvd13), IDTVEC(rsvd14), IDTVEC(syscall); int _gsel_tss; /* added sdtossd() by HOSOKAWA Tatsumi */ int sdtossd(sd, ssd) struct segment_descriptor *sd; struct soft_segment_descriptor *ssd; { ssd->ssd_base = (sd->sd_hibase << 24) | sd->sd_lobase; ssd->ssd_limit = (sd->sd_hilimit << 16) | sd->sd_lolimit; ssd->ssd_type = sd->sd_type; ssd->ssd_dpl = sd->sd_dpl; ssd->ssd_p = sd->sd_p; ssd->ssd_def32 = sd->sd_def32; ssd->ssd_gran = sd->sd_gran; return 0; } void init386(first) int first; { extern lgdt(), lidt(), lldt(); int x; unsigned biosbasemem, biosextmem; struct gate_descriptor *gdp; extern int sigcode,szsigcode; /* table descriptors - used to load tables by microp */ struct region_descriptor r_gdt, r_idt; int pagesinbase, pagesinext; int target_page; extern struct pte *CMAP1; extern caddr_t CADDR1; proc0.p_addr = proc0paddr; /* * Initialize the console before we print anything out. */ cninit (); /* * make gdt memory segments, the code segment goes up to end of the * page with etext in it, the data segment goes to the end of * the address space */ gdt_segs[GCODE_SEL].ssd_limit = i386_btop(0) - 1 /* i386_btop(i386_round_page(&etext)) - 1 */; gdt_segs[GDATA_SEL].ssd_limit = i386_btop(0) - 1; for (x=0; x < NGDT; x++) ssdtosd(gdt_segs+x, gdt+x); /* make ldt memory segments */ /* * The data segment limit must not cover the user area because we * don't want the user area to be writable in copyout() etc. (page * level protection is lost in kernel mode on 386's). Also, we * don't want the user area to be writable directly (page level * protection of the user area is not available on 486's with * CR0_WP set, because there is no user-read/kernel-write mode). * * XXX - VM_MAXUSER_ADDRESS is an end address, not a max. And it * should be spelled ...MAX_USER... */ #define VM_END_USER_RW_ADDRESS VM_MAXUSER_ADDRESS /* * The code segment limit has to cover the user area until we move * the signal trampoline out of the user area. This is safe because * the code segment cannot be written to directly. */ #define VM_END_USER_R_ADDRESS (VM_END_USER_RW_ADDRESS + UPAGES * NBPG) ldt_segs[LUCODE_SEL].ssd_limit = i386_btop(VM_END_USER_R_ADDRESS) - 1; ldt_segs[LUDATA_SEL].ssd_limit = i386_btop(VM_END_USER_RW_ADDRESS) - 1; /* Note. eventually want private ldts per process */ for (x=0; x < 5; x++) ssdtosd(ldt_segs+x, ldt+x); /* exceptions */ setidt(0, &IDTVEC(div), SDT_SYS386TGT, SEL_KPL); setidt(1, &IDTVEC(dbg), SDT_SYS386TGT, SEL_KPL); setidt(2, &IDTVEC(nmi), SDT_SYS386TGT, SEL_KPL); setidt(3, &IDTVEC(bpt), SDT_SYS386TGT, SEL_UPL); setidt(4, &IDTVEC(ofl), SDT_SYS386TGT, SEL_UPL); setidt(5, &IDTVEC(bnd), SDT_SYS386TGT, SEL_KPL); setidt(6, &IDTVEC(ill), SDT_SYS386TGT, SEL_KPL); setidt(7, &IDTVEC(dna), SDT_SYS386TGT, SEL_KPL); setidt(8, &IDTVEC(dble), SDT_SYS386TGT, SEL_KPL); setidt(9, &IDTVEC(fpusegm), SDT_SYS386TGT, SEL_KPL); setidt(10, &IDTVEC(tss), SDT_SYS386TGT, SEL_KPL); setidt(11, &IDTVEC(missing), SDT_SYS386TGT, SEL_KPL); setidt(12, &IDTVEC(stk), SDT_SYS386TGT, SEL_KPL); setidt(13, &IDTVEC(prot), SDT_SYS386TGT, SEL_KPL); setidt(14, &IDTVEC(page), SDT_SYS386TGT, SEL_KPL); setidt(15, &IDTVEC(rsvd), SDT_SYS386TGT, SEL_KPL); setidt(16, &IDTVEC(fpu), SDT_SYS386TGT, SEL_KPL); setidt(17, &IDTVEC(rsvd0), SDT_SYS386TGT, SEL_KPL); setidt(18, &IDTVEC(rsvd1), SDT_SYS386TGT, SEL_KPL); setidt(19, &IDTVEC(rsvd2), SDT_SYS386TGT, SEL_KPL); setidt(20, &IDTVEC(rsvd3), SDT_SYS386TGT, SEL_KPL); setidt(21, &IDTVEC(rsvd4), SDT_SYS386TGT, SEL_KPL); setidt(22, &IDTVEC(rsvd5), SDT_SYS386TGT, SEL_KPL); setidt(23, &IDTVEC(rsvd6), SDT_SYS386TGT, SEL_KPL); setidt(24, &IDTVEC(rsvd7), SDT_SYS386TGT, SEL_KPL); setidt(25, &IDTVEC(rsvd8), SDT_SYS386TGT, SEL_KPL); setidt(26, &IDTVEC(rsvd9), SDT_SYS386TGT, SEL_KPL); setidt(27, &IDTVEC(rsvd10), SDT_SYS386TGT, SEL_KPL); setidt(28, &IDTVEC(rsvd11), SDT_SYS386TGT, SEL_KPL); setidt(29, &IDTVEC(rsvd12), SDT_SYS386TGT, SEL_KPL); setidt(30, &IDTVEC(rsvd13), SDT_SYS386TGT, SEL_KPL); setidt(31, &IDTVEC(rsvd14), SDT_SYS386TGT, SEL_KPL); #include "isa.h" #if NISA >0 isa_defaultirq(); #endif r_gdt.rd_limit = sizeof(gdt) - 1; r_gdt.rd_base = (int) gdt; lgdt(&r_gdt); r_idt.rd_limit = sizeof(idt) - 1; r_idt.rd_base = (int) idt; lidt(&r_idt); _default_ldt = GSEL(GLDT_SEL, SEL_KPL); lldt(_default_ldt); currentldt = _default_ldt; #ifdef DDB kdb_init(); if (boothowto & RB_KDB) Debugger("Boot flags requested debugger"); #endif /* Use BIOS values stored in RTC CMOS RAM, since probing * breaks certain 386 AT relics. */ biosbasemem = rtcin(RTC_BASELO)+ (rtcin(RTC_BASEHI)<<8); biosextmem = rtcin(RTC_EXTLO)+ (rtcin(RTC_EXTHI)<<8); /* * If BIOS tells us that it has more than 640k in the basemem, * don't believe it - set it to 640k. */ if (biosbasemem > 640) biosbasemem = 640; /* * Some 386 machines might give us a bogus number for extended * mem. If this happens, stop now. */ #ifndef LARGEMEM if (biosextmem > 65536) { panic("extended memory beyond limit of 64MB"); /* NOTREACHED */ } #endif pagesinbase = biosbasemem * 1024 / NBPG; pagesinext = biosextmem * 1024 / NBPG; /* * Special hack for chipsets that still remap the 384k hole when * there's 16MB of memory - this really confuses people that * are trying to use bus mastering ISA controllers with the * "16MB limit"; they only have 16MB, but the remapping puts * them beyond the limit. * XXX - this should be removed when bounce buffers are * implemented. */ /* * If extended memory is between 15-16MB (16-17MB phys address range), * chop it to 15MB. */ if ((pagesinext > 3840) && (pagesinext < 4096)) pagesinext = 3840; /* * Maxmem isn't the "maximum memory", it's the highest page of * of the physical address space. It should be "Maxphyspage". */ Maxmem = pagesinext + 0x100000/PAGE_SIZE; #ifdef MAXMEM if (MAXMEM/4 < Maxmem) Maxmem = MAXMEM/4; #endif /* * Calculate number of physical pages, but account for Maxmem * limitation above. */ physmem = pagesinbase + (min(pagesinext + 0x100000/PAGE_SIZE, Maxmem) - 0x100000/PAGE_SIZE); /* call pmap initialization to make new kernel address space */ pmap_bootstrap (first, 0); /* * Do simple memory test over range of extended memory that BIOS * indicates exists. Adjust Maxmem to the highest page of * good memory. */ printf("Testing memory (%dMB)...", ptoa(Maxmem)/1024/1024); for (target_page = Maxmem - 1; target_page >= atop(first); target_page--) { /* * map page into kernel: valid, read/write, non-cacheable */ *(int *)CMAP1 = PG_V | PG_KW | PG_N | ptoa(target_page); pmap_update(); /* * Test for alternating 1's and 0's */ filli(0xaaaaaaaa, CADDR1, PAGE_SIZE/sizeof(int)); if (test_page((int *)CADDR1, 0xaaaaaaaa)) { Maxmem = target_page; badpages++; continue; } /* * Test for alternating 0's and 1's */ filli(0x55555555, CADDR1, PAGE_SIZE/sizeof(int)); if (test_page((int *)CADDR1, 0x55555555)) { Maxmem = target_page; badpages++; continue; } /* * Test for all 1's */ filli(0xffffffff, CADDR1, PAGE_SIZE/sizeof(int)); if (test_page((int *)CADDR1, 0xffffffff)) { Maxmem = target_page; badpages++; continue; } /* * Test zeroing of page */ bzero(CADDR1, PAGE_SIZE); if (test_page((int *)CADDR1, 0)) { /* * test of page failed */ Maxmem = target_page; badpages++; continue; } } printf("done.\n"); *(int *)CMAP1 = 0; pmap_update(); avail_end = (Maxmem << PAGE_SHIFT) - i386_round_page(sizeof(struct msgbuf)); /* * Initialize pointers to the two chunks of memory; for use * later in vm_page_startup. */ /* avail_start is initialized in pmap_bootstrap */ x = 0; if (pagesinbase > 1) { phys_avail[x++] = NBPG; /* skip first page of memory */ phys_avail[x++] = pagesinbase * NBPG; /* memory up to the ISA hole */ } phys_avail[x++] = avail_start; /* memory up to the end */ phys_avail[x++] = avail_end; phys_avail[x++] = 0; /* no more chunks */ phys_avail[x++] = 0; /* now running on new page tables, configured,and u/iom is accessible */ /* make a initial tss so microp can get interrupt stack on syscall! */ proc0.p_addr->u_pcb.pcb_tss.tss_esp0 = (int) kstack + UPAGES*NBPG; proc0.p_addr->u_pcb.pcb_tss.tss_ss0 = GSEL(GDATA_SEL, SEL_KPL) ; _gsel_tss = GSEL(GPROC0_SEL, SEL_KPL); ((struct i386tss *)gdt_segs[GPROC0_SEL].ssd_base)->tss_ioopt = (sizeof(tss))<<16; ltr(_gsel_tss); /* make a call gate to reenter kernel with */ gdp = &ldt[LSYS5CALLS_SEL].gd; x = (int) &IDTVEC(syscall); gdp->gd_looffset = x++; gdp->gd_selector = GSEL(GCODE_SEL,SEL_KPL); gdp->gd_stkcpy = 1; gdp->gd_type = SDT_SYS386CGT; gdp->gd_dpl = SEL_UPL; gdp->gd_p = 1; gdp->gd_hioffset = ((int) &IDTVEC(syscall)) >>16; /* transfer to user mode */ _ucodesel = LSEL(LUCODE_SEL, SEL_UPL); _udatasel = LSEL(LUDATA_SEL, SEL_UPL); /* setup proc 0's pcb */ bcopy(&sigcode, proc0.p_addr->u_pcb.pcb_sigc, szsigcode); proc0.p_addr->u_pcb.pcb_flags = 0; proc0.p_addr->u_pcb.pcb_ptd = IdlePTD; } int test_page(address, pattern) int *address; int pattern; { int *x; for (x = address; x < (int *)((char *)address + PAGE_SIZE); x++) { if (*x != pattern) return (1); } return(0); } /* * The registers are in the frame; the frame is in the user area of * the process in question; when the process is active, the registers * are in "the kernel stack"; when it's not, they're still there, but * things get flipped around. So, since p->p_md.md_regs is the whole address * of the register set, take its offset from the kernel stack, and * index into the user block. Don't you just *love* virtual memory? * (I'm starting to think seymour is right...) */ int ptrace_set_pc (struct proc *p, unsigned int addr) { void *regs = (char*)p->p_addr + ((char*) p->p_md.md_regs - (char*) kstack); ((struct trapframe *)regs)->tf_eip = addr; return 0; } int ptrace_single_step (struct proc *p) { void *regs = (char*)p->p_addr + ((char*) p->p_md.md_regs - (char*) kstack); ((struct trapframe *)regs)->tf_eflags |= PSL_T; return 0; } /* * Copy the registers to user-space. */ int ptrace_getregs (struct proc *p, unsigned int *addr) { int error; struct reg regs = {0}; error = fill_regs (p, ®s); if (error) return error; return copyout (®s, addr, sizeof (regs)); } int ptrace_setregs (struct proc *p, unsigned int *addr) { int error; struct reg regs = {0}; error = copyin (addr, ®s, sizeof(regs)); if (error) return error; return set_regs (p, ®s); } int fill_regs(struct proc *p, struct reg *regs) { struct trapframe *tp; void *ptr = (char*)p->p_addr + ((char*) p->p_md.md_regs - (char*) kstack); tp = ptr; regs->r_es = tp->tf_es; regs->r_ds = tp->tf_ds; regs->r_edi = tp->tf_edi; regs->r_esi = tp->tf_esi; regs->r_ebp = tp->tf_ebp; regs->r_ebx = tp->tf_ebx; regs->r_edx = tp->tf_edx; regs->r_ecx = tp->tf_ecx; regs->r_eax = tp->tf_eax; regs->r_eip = tp->tf_eip; regs->r_cs = tp->tf_cs; regs->r_eflags = tp->tf_eflags; regs->r_esp = tp->tf_esp; regs->r_ss = tp->tf_ss; return 0; } int set_regs (struct proc *p, struct reg *regs) { struct trapframe *tp; void *ptr = (char*)p->p_addr + ((char*) p->p_md.md_regs - (char*) kstack); tp = ptr; tp->tf_es = regs->r_es; tp->tf_ds = regs->r_ds; tp->tf_edi = regs->r_edi; tp->tf_esi = regs->r_esi; tp->tf_ebp = regs->r_ebp; tp->tf_ebx = regs->r_ebx; tp->tf_edx = regs->r_edx; tp->tf_ecx = regs->r_ecx; tp->tf_eax = regs->r_eax; tp->tf_eip = regs->r_eip; tp->tf_cs = regs->r_cs; tp->tf_eflags = regs->r_eflags; tp->tf_esp = regs->r_esp; tp->tf_ss = regs->r_ss; return 0; } #ifndef DDB void Debugger(const char *msg) { printf("Debugger(\"%s\") called.\n", msg); } #endif /* no DDB */ #include #define b_cylin b_resid #define dkpart(dev) (minor(dev) & 7) /* * Determine the size of the transfer, and make sure it is * within the boundaries of the partition. Adjust transfer * if needed, and signal errors or early completion. */ int bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel) { struct partition *p = lp->d_partitions + dkpart(bp->b_dev); int labelsect = lp->d_partitions[0].p_offset; int maxsz = p->p_size, sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT; /* overwriting disk label ? */ /* XXX should also protect bootstrap in first 8K */ if (bp->b_blkno + p->p_offset <= LABELSECTOR + labelsect && #if LABELSECTOR != 0 bp->b_blkno + p->p_offset + sz > LABELSECTOR + labelsect && #endif (bp->b_flags & B_READ) == 0 && wlabel == 0) { bp->b_error = EROFS; goto bad; } #if defined(DOSBBSECTOR) && defined(notyet) /* overwriting master boot record? */ if (bp->b_blkno + p->p_offset <= DOSBBSECTOR && (bp->b_flags & B_READ) == 0 && wlabel == 0) { bp->b_error = EROFS; goto bad; } #endif /* beyond partition? */ if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz) { /* if exactly at end of disk, return an EOF */ if (bp->b_blkno == maxsz) { bp->b_resid = bp->b_bcount; return(0); } /* or truncate if part of it fits */ sz = maxsz - bp->b_blkno; if (sz <= 0) { bp->b_error = EINVAL; goto bad; } bp->b_bcount = sz << DEV_BSHIFT; } /* calculate cylinder for disksort to order transfers with */ bp->b_pblkno = bp->b_blkno + p->p_offset; bp->b_cylin = bp->b_pblkno / lp->d_secpercyl; return(1); bad: bp->b_flags |= B_ERROR; return(-1); } diff --git a/sys/i386/i386/locore.s b/sys/i386/i386/locore.s index 6e74dd033302..db6e252f7f6b 100644 --- a/sys/i386/i386/locore.s +++ b/sys/i386/i386/locore.s @@ -1,793 +1,794 @@ /*- * Copyright (c) 1990 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * William Jolitz. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 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 * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: @(#)locore.s 7.3 (Berkeley) 5/13/91 - * $Id: locore.s,v 1.34 1994/10/07 05:45:27 davidg Exp $ + * $Id: locore.s,v 1.35 1994/10/08 06:20:52 rgrimes Exp $ */ /* * locore.s: FreeBSD machine support for the Intel 386 * originally from: locore.s, by William F. Jolitz * * Substantially rewritten by David Greenman, Rod Grimes, * Bruce Evans, Wolfgang Solfrank, and many others. */ #include "npx.h" /* for NNPX */ #include "assym.s" /* system definitions */ #include /* processor status longword defs */ #include /* page table entry definitions */ #include /* error return codes */ #include /* x86 special registers */ #include /* x86 cpu type definitions */ #include /* system call numbers */ #include /* miscellaneous asm macros */ -#ifdef APM +#include "apm.h" +#if NAPM > 0 #define ASM #include #include -#endif +#endif /* NAPM */ /* * XXX * * Note: This version greatly munged to avoid various assembler errors * that may be fixed in newer versions of gas. Perhaps newer versions * will have more pleasant appearance. */ /* * PTmap is recursive pagemap at top of virtual address space. * Within PTmap, the page directory can be found (third indirection). */ .globl _PTmap,_PTD,_PTDpde,_Sysmap .set _PTmap,PTDPTDI << PDRSHIFT .set _PTD,_PTmap + (PTDPTDI * NBPG) .set _PTDpde,_PTD + (PTDPTDI * PDESIZE) /* Sysmap is the base address of the kernel page tables */ .set _Sysmap,_PTmap + (KPTDI * NBPG) /* * APTmap, APTD is the alternate recursive pagemap. * It's used when modifying another process's page tables. */ .globl _APTmap,_APTD,_APTDpde .set _APTmap,APTDPTDI << PDRSHIFT .set _APTD,_APTmap + (APTDPTDI * NBPG) .set _APTDpde,_PTD + (APTDPTDI * PDESIZE) /* * Access to each processes kernel stack is via a region of * per-process address space (at the beginning), immediatly above * the user process stack. */ .set _kstack,USRSTACK .globl _kstack /* * Globals */ .data .globl _boothowto,_bootdev,_curpcb .globl _cpu,_cold,_atdevbase,_cpu_vendor,_cpu_id .globl _video_mode_ptr _cpu: .long 0 /* are we 386, 386sx, or 486 */ _cpu_id: .long 0 /* stepping ID */ _cpu_vendor: .space 20 /* CPU origin code */ _video_mode_ptr: .long 0 _cold: .long 1 /* cold till we are not */ _atdevbase: .long 0 /* location of start of iomem in virtual */ _atdevphys: .long 0 /* location of device mapping ptes (phys) */ .globl _KERNend _KERNend: .long 0 /* phys addr end of kernel (just after bss) */ .globl _IdlePTD,_KPTphys _IdlePTD: .long 0 /* phys addr of kernel PTD */ _KPTphys: .long 0 /* phys addr of kernel page tables */ .globl _proc0paddr _proc0paddr: .long 0 /* address of proc 0 address space */ #ifdef BDE_DEBUGGER .globl _bdb_exists /* flag to indicate BDE debugger is available */ _bdb_exists: .long 0 #endif -#ifdef APM +#if NAPM > 0 .globl _apm_current_gdt_pdesc /* current GDT pseudo desc. */ _apm_current_gdt_pdesc: .word 0, 0, 0 .globl _bootstrap_gdt _bootstrap_gdt: .space SIZEOF_GDT * BOOTSTRAP_GDT_NUM -#endif /* APM */ +#endif /* NAPM */ .globl tmpstk .space 0x1000 tmpstk: /* * System Initialization */ .text /* * btext: beginning of text section. * Also the entry point (jumped to directly from the boot blocks). */ NON_GPROF_ENTRY(btext) movw $0x1234,0x472 /* warm boot */ jmp 1f /* * XXX now that we load at 1MB is this still really used? */ .org 0x500 /* space for BIOS variables */ 1: /* Set up a real frame, some day we will be doing returns */ pushl %ebp movl %esp, %ebp /* Don't trust what the BIOS gives for eflags. */ pushl $PSL_MBO popfl /* * This code is called in different ways depending on what loaded * and started the kernel. This is used to detect how we get the * arguments from the other code and what we do with them. * * Old disk boot blocks: * (*btext)(howto, bootdev, cyloffset, esym); * [return address == 0, and can NOT be returned to] * [cyloffset was not supported by the FreeBSD boot code * and always passed in as 0] * [esym is also known as total in the boot code, and * was never properly supported by the FreeBSD boot code] * * Old diskless netboot code: * (*btext)(0,0,0,0,&nfsdiskless,0,0,0); * [return address != 0, and can NOT be returned to] * If we are being booted by this code it will NOT work, * so we are just going to halt if we find this case. * * New uniform boot code: * (*btext)(howto, bootdev, 0, 0, 0, &bootinfo) * [return address != 0, and can be returned to] * * There may seem to be a lot of wasted arguments in here, but * that is so the newer boot code can still load very old kernels * and old boot code can load new kernels. */ /* * The old style disk boot blocks fake a frame on the stack and * did an lret to get here. The frame on the stack has a return * address of 0. */ cmpl $0,4(%ebp) je 2f /* olddiskboot: */ /* * We have some form of return address, so this is either the * old diskless netboot code, or the new uniform code. That can * be detected by looking at the 5th argument, it if is 0 we * we are being booted by the new unifrom boot code. */ cmpl $0,24(%ebp) je 1f /* newboot: */ /* * Seems we have been loaded by the old diskless boot code, we * don't stand a chance of running as the diskless structure * changed considerably between the two, so just halt. */ hlt /* * We have been loaded by the new uniform boot code. * Lets check the bootinfo version, and if we do not understand * it we return to the loader with a status of 1 to indicate this error */ 1: /* newboot: */ movl 28(%ebp),%ebx /* &bootinfo.version */ movl BOOTINFO_VERSION(%ebx),%eax cmpl $1,%eax /* We only understand version 1 */ je 1f movl $1,%eax /* Return status */ leave ret 1: /* * If we have a kernelname copy it in */ movl BOOTINFO_KERNELNAME(%ebx),%esi cmpl $0,%esi je 1f /* No kernelname */ lea _kernelname-KERNBASE,%edi movl $MAXPATHLEN,%ecx /* Brute force!!! */ cld rep movsb 1: #ifdef NFS /* * If we have a nfs_diskless structure copy it in */ movl BOOTINFO_NFS_DISKLESS(%ebx),%esi cmpl $0,%esi je 2f lea _nfs_diskless-KERNBASE,%edi movl $NFSDISKLESS_SIZE,%ecx cld rep movsb #endif /* * The old style disk boot. * (*btext)(howto, bootdev, cyloffset, esym); * Note that the newer boot code just falls into here to pick * up howto and bootdev, cyloffset and esym are no longer used */ 2: /* olddiskboot: */ movl 8(%ebp),%eax movl %eax,_boothowto-KERNBASE movl 12(%ebp),%eax movl %eax,_bootdev-KERNBASE /* get the BIOS video mode pointer */ movl $0x4a8, %ecx movl (%ecx), %eax movl %eax, %ecx shrl $12, %ecx andl $0xffff0000, %ecx andl $0x0000ffff, %eax orl %ecx, %eax movl (%eax), %eax movl %eax, %ecx shrl $12, %ecx andl $0xffff0000, %ecx andl $0x0000ffff, %eax orl %ecx, %eax addl $KERNBASE, %eax movl %eax, _video_mode_ptr-KERNBASE -#ifdef APM +#if NAPM > 0 /* * Setup APM BIOS: * * APM BIOS initialization should be done from real mode or V86 mode. * * (by HOSOKAWA, Tatsumi ) */ /* * Copy APM initializer under 1MB boundary: * * APM initializer program must switch the CPU to real mode. * But FreeBSD kernel runs above 1MB boundary. So we must * copy the initializer code to conventional memory. */ movl _apm_init_image_size-KERNBASE, %ecx /* size */ lea _apm_init_image-KERNBASE, %esi /* source */ movl $ APM_OURADDR, %edi /* destination */ cld rep movsb /* get GDT base */ sgdt _apm_current_gdt_pdesc-KERNBASE /* copy GDT to _bootstrap_gdt */ xorl %ecx, %ecx movw _apm_current_gdt_pdesc-KERNBASE, %cx movl _apm_current_gdt_pdesc-KERNBASE+2, %esi lea _bootstrap_gdt-KERNBASE, %edi cld rep movsb /* setup GDT pseudo descriptor */ movw $(SIZEOF_GDT*BOOTSTRAP_GDT_NUM), %ax movw %ax, _apm_current_gdt_pdesc-KERNBASE leal _bootstrap_gdt-KERNBASE, %eax movl %eax, _apm_current_gdt_pdesc-KERNBASE+2 /* load new GDTR */ lgdt _apm_current_gdt_pdesc-KERNBASE /* setup GDT for APM initializer */ lea _bootstrap_gdt-KERNBASE, %ecx movl $(APM_OURADDR), %eax /* use %ax for 15..0 */ movl %eax, %ebx shrl $16, %ebx /* use %bl for 23..16 */ /* use %bh for 31..24 */ #define APM_SETUP_GDT(index, attrib) \ movl $(index), %si ; \ lea 0(%ecx,%esi,8), %edx ; \ movw $0xffff, (%edx) ; \ movw %ax, 2(%edx) ; \ movb %bl, 4(%edx) ; \ movw $(attrib), 5(%edx) ; \ movb %bh, 7(%edx) APM_SETUP_GDT(APM_INIT_CS_INDEX , CS32_ATTRIB) APM_SETUP_GDT(APM_INIT_DS_INDEX , DS32_ATTRIB) APM_SETUP_GDT(APM_INIT_CS16_INDEX, CS16_ATTRIB) /* * Call the initializer: * * direct intersegment call to conventional memory code */ .byte 0x9a /* actually, lcall $APM_INIT_CS_SEL, $0 */ .long 0 .word APM_INIT_CS_SEL movw %ax, _apm_version-KERNBASE movl %ebx, _apm_cs_entry-KERNBASE movw %cx, _apm_cs32_base-KERNBASE shrl $16, %ecx movw %cx, _apm_cs16_base-KERNBASE movw %dx, _apm_ds_base-KERNBASE movw %si, _apm_cs_limit-KERNBASE shrl $16, %esi movw %si, _apm_ds_limit-KERNBASE movw %di, _apm_flags-KERNBASE -#endif /* APM */ +#endif /* NAPM */ /* Find out our CPU type. */ /* Try to toggle alignment check flag; does not exist on 386. */ pushfl popl %eax movl %eax,%ecx orl $PSL_AC,%eax pushl %eax popfl pushfl popl %eax xorl %ecx,%eax andl $PSL_AC,%eax pushl %ecx popfl testl %eax,%eax jnz 1f movl $CPU_386,_cpu-KERNBASE jmp 2f 1: /* Try to toggle identification flag; does not exist on early 486s. */ pushfl popl %eax movl %eax,%ecx xorl $PSL_ID,%eax pushl %eax popfl pushfl popl %eax xorl %ecx,%eax andl $PSL_ID,%eax pushl %ecx popfl testl %eax,%eax jnz 1f movl $CPU_486,_cpu-KERNBASE /* check for Cyrix 486DLC -- based on check routine */ /* documented in "Cx486SLC/e SMM Programmer's Guide" */ xorw %dx,%dx cmpw %dx,%dx # set flags to known state pushfw popw %cx # store flags in ecx movw $0xffff,%ax movw $0x0004,%bx divw %bx pushfw popw %ax andw $0x08d5,%ax # mask off important bits andw $0x08d5,%cx cmpw %ax,%cx jnz 2f # if flags changed, Intel chip movl $CPU_486DLC,_cpu-KERNBASE # set CPU value for Cyrix movl $0x69727943,_cpu_vendor-KERNBASE # store vendor string movw $0x0078,_cpu_vendor-KERNBASE+4 invd # Start with guaranteed clean cache /* Disable caching of the ISA hole only. */ movb $CCR0,%al # Configuration Register index (CCR0) outb %al,$0x22 inb $0x23,%al orb $(CCR0_NC1|CCR0_BARB),%al outb %al,$0x23 invd jmp 2f 1: /* Use the `cpuid' instruction. */ xorl %eax,%eax .byte 0x0f,0xa2 # cpuid 0 movl %ebx,_cpu_vendor-KERNBASE # store vendor string movl %edx,_cpu_vendor+4-KERNBASE movl %ecx,_cpu_vendor+8-KERNBASE movb $0,_cpu_vendor+12-KERNBASE movl $1,%eax .byte 0x0f,0xa2 # cpuid 1 movl %eax,_cpu_id-KERNBASE # store cpu_id rorl $8,%eax # extract family type andl $15,%eax cmpl $5,%eax jae 1f /* less than Pentium; must be 486 */ movl $CPU_486,_cpu-KERNBASE jmp 2f 1: movl $CPU_586,_cpu-KERNBASE 2: /* * Finished with old stack; load new %esp now instead of later so * we can trace this code without having to worry about the trace * trap clobbering the memory test or the zeroing of the bss+bootstrap * page tables. * * XXX - wdboot clears the bss after testing that this is safe. * This is too wasteful - memory below 640K is scarce. The boot * program should check: * text+data <= &stack_variable - more_space_for_stack * text+data+bss+pad+space_for_page_tables <= end_of_memory * Oops, the gdt is in the carcass of the boot program so clearing * the rest of memory is still not possible. */ movl $tmpstk-KERNBASE,%esp /* bootstrap stack end location */ /* * Virtual address space of kernel: * * text | data | bss | [syms] | page dir | proc0 kernel stack | usr stk map | Sysmap * pages: 1 UPAGES (2) 1 NKPT (7) */ /* find end of kernel image */ movl $_end-KERNBASE,%ecx addl $NBPG-1,%ecx /* page align up */ andl $~(NBPG-1),%ecx movl %ecx,%esi /* esi = start of free memory */ movl %ecx,_KERNend-KERNBASE /* save end of kernel */ /* clear bss */ movl $_edata-KERNBASE,%edi subl %edi,%ecx /* get amount to clear */ xorl %eax,%eax /* specify zero fill */ cld rep stosb /* * The value in esi is both the end of the kernel bss and a pointer to * the kernel page directory, and is used by the rest of locore to build * the tables. * esi + 1(page dir) + 2(UPAGES) + 1(p0stack) + NKPT(number of kernel * page table pages) is then passed on the stack to init386(first) as * the value first. esi should ALWAYS be page aligned!! */ movl %esi,%ecx /* Get current first availiable address */ /* clear pagetables, page directory, stack, etc... */ movl %esi,%edi /* base (page directory) */ movl $((1+UPAGES+1+NKPT)*NBPG),%ecx /* amount to clear */ xorl %eax,%eax /* specify zero fill */ cld rep stosb /* physical address of Idle proc/kernel page directory */ movl %esi,_IdlePTD-KERNBASE /* * fillkpt * eax = (page frame address | control | status) == pte * ebx = address of page table * ecx = how many pages to map */ #define fillkpt \ 1: movl %eax,(%ebx) ; \ addl $NBPG,%eax ; /* increment physical address */ \ addl $4,%ebx ; /* next pte */ \ loop 1b ; /* * Map Kernel * * First step - build page tables */ #if defined (KGDB) || defined (BDE_DEBUGGER) movl _KERNend-KERNBASE,%ecx /* this much memory, */ shrl $PGSHIFT,%ecx /* for this many PTEs */ #ifdef BDE_DEBUGGER cmpl $0xa0,%ecx /* XXX - cover debugger pages */ jae 1f movl $0xa0,%ecx 1: #endif /* BDE_DEBUGGER */ movl $PG_V|PG_KW,%eax /* kernel R/W, valid */ lea ((1+UPAGES+1)*NBPG)(%esi),%ebx /* phys addr of kernel PT base */ movl %ebx,_KPTphys-KERNBASE /* save in global */ fillkpt #else /* !KGDB && !BDE_DEBUGGER */ /* write protect kernel text (doesn't do a thing for 386's - only 486's) */ movl $_etext-KERNBASE,%ecx /* get size of text */ shrl $PGSHIFT,%ecx /* for this many PTEs */ movl $PG_V|PG_KR,%eax /* specify read only */ lea ((1+UPAGES+1)*NBPG)(%esi),%ebx /* phys addr of kernel PT base */ movl %ebx,_KPTphys-KERNBASE /* save in global */ fillkpt /* data and bss are r/w */ andl $PG_FRAME,%eax /* strip to just addr of bss */ movl _KERNend-KERNBASE,%ecx /* calculate size */ subl %eax,%ecx shrl $PGSHIFT,%ecx orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ fillkpt #endif /* KGDB || BDE_DEBUGGER */ /* now initialize the page dir, upages, p0stack PT, and page tables */ movl $(1+UPAGES+1+NKPT),%ecx /* number of PTEs */ movl %esi,%eax /* phys address of PTD */ andl $PG_FRAME,%eax /* convert to PFN, should be a NOP */ orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ movl %esi,%ebx /* calculate pte offset to ptd */ shrl $PGSHIFT-2,%ebx addl %esi,%ebx /* address of page directory */ addl $((1+UPAGES+1)*NBPG),%ebx /* offset to kernel page tables */ fillkpt /* map I/O memory map */ movl _KPTphys-KERNBASE,%ebx /* base of kernel page tables */ lea (0xa0 * PTESIZE)(%ebx),%ebx /* hardwire ISA hole at KERNBASE + 0xa0000 */ movl $0x100-0xa0,%ecx /* for this many pte s, */ movl $(0xa0000|PG_V|PG_KW|PG_N),%eax /* valid, kernel read/write, non-cacheable */ movl %ebx,_atdevphys-KERNBASE /* save phys addr of ptes */ fillkpt /* map proc 0's kernel stack into user page table page */ movl $UPAGES,%ecx /* for this many pte s, */ lea (1*NBPG)(%esi),%eax /* physical address in proc 0 */ lea (KERNBASE)(%eax),%edx /* change into virtual addr */ movl %edx,_proc0paddr-KERNBASE /* save VA for proc 0 init */ orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ lea ((1+UPAGES)*NBPG)(%esi),%ebx /* addr of stack page table in proc 0 */ addl $(KSTKPTEOFF * PTESIZE),%ebx /* offset to kernel stack PTE */ fillkpt /* * Initialize kernel page table directory */ /* install a pde for temporary double map of bottom of VA */ movl _KPTphys-KERNBASE,%eax orl $PG_V|PG_KW,%eax /* valid, kernel read/write */ movl %eax,(%esi) /* which is where temp maps! */ /* initialize kernel pde's */ movl $(NKPT),%ecx /* for this many PDEs */ lea (KPTDI*PDESIZE)(%esi),%ebx /* offset of pde for kernel */ fillkpt /* install a pde recursively mapping page directory as a page table! */ movl %esi,%eax /* phys address of ptd in proc 0 */ orl $PG_V|PG_KW,%eax /* pde entry is valid */ movl %eax,PTDPTDI*PDESIZE(%esi) /* which is where PTmap maps! */ /* install a pde to map kernel stack for proc 0 */ lea ((1+UPAGES)*NBPG)(%esi),%eax /* physical address of pt in proc 0 */ orl $PG_V|PG_KW,%eax /* pde entry is valid */ movl %eax,KSTKPTDI*PDESIZE(%esi) /* which is where kernel stack maps! */ #ifdef BDE_DEBUGGER /* copy and convert stuff from old gdt and idt for debugger */ cmpl $0x0375c339,0x96104 /* XXX - debugger signature */ jne 1f movb $1,_bdb_exists-KERNBASE 1: pushal subl $2*6,%esp sgdt (%esp) movl 2(%esp),%esi /* base address of current gdt */ movl $_gdt-KERNBASE,%edi movl %edi,2(%esp) movl $8*18/4,%ecx cld rep /* copy gdt */ movsl movl $_gdt-KERNBASE,-8+2(%edi) /* adjust gdt self-ptr */ movb $0x92,-8+5(%edi) sidt 6(%esp) movl 6+2(%esp),%esi /* base address of current idt */ movl 8+4(%esi),%eax /* convert dbg descriptor to ... */ movw 8(%esi),%ax movl %eax,bdb_dbg_ljmp+1-KERNBASE /* ... immediate offset ... */ movl 8+2(%esi),%eax movw %ax,bdb_dbg_ljmp+5-KERNBASE /* ... and selector for ljmp */ movl 24+4(%esi),%eax /* same for bpt descriptor */ movw 24(%esi),%ax movl %eax,bdb_bpt_ljmp+1-KERNBASE movl 24+2(%esi),%eax movw %ax,bdb_bpt_ljmp+5-KERNBASE movl $_idt-KERNBASE,%edi movl %edi,6+2(%esp) movl $8*4/4,%ecx cld rep /* copy idt */ movsl lgdt (%esp) lidt 6(%esp) addl $2*6,%esp popal #endif /* BDE_DEBUGGER */ /* load base of page directory and enable mapping */ movl %esi,%eax /* phys address of ptd in proc 0 */ movl %eax,%cr3 /* load ptd addr into mmu */ movl %cr0,%eax /* get control word */ orl $CR0_PE|CR0_PG,%eax /* enable paging */ movl %eax,%cr0 /* and let's page NOW! */ pushl $begin /* jump to high mem */ ret begin: /* now running relocated at KERNBASE where the system is linked to run */ .globl _Crtat /* XXX - locore should not know about */ movl _Crtat,%eax /* variables of device drivers (pccons)! */ subl $(KERNBASE+0xA0000),%eax movl _atdevphys,%edx /* get pte PA */ subl _KPTphys,%edx /* remove base of ptes, now have phys offset */ shll $PGSHIFT-2,%edx /* corresponding to virt offset */ addl $KERNBASE,%edx /* add virtual base */ movl %edx,_atdevbase addl %eax,%edx movl %edx,_Crtat /* set up bootstrap stack - 48 bytes */ movl $_kstack+UPAGES*NBPG-4*12,%esp /* bootstrap stack end location */ xorl %eax,%eax /* mark end of frames */ movl %eax,%ebp movl _proc0paddr,%eax movl %esi,PCB_CR3(%eax) #ifdef BDE_DEBUGGER /* relocate debugger gdt entries */ movl $_gdt+8*9,%eax /* adjust slots 9-17 */ movl $9,%ecx reloc_gdt: movb $KERNBASE>>24,7(%eax) /* top byte of base addresses, was 0, */ addl $8,%eax /* now KERNBASE>>24 */ loop reloc_gdt cmpl $0,_bdb_exists je 1f int $3 1: #endif /* BDE_DEBUGGER */ /* * Skip over the page tables and the kernel stack */ lea ((1+UPAGES+1+NKPT)*NBPG)(%esi),%esi pushl %esi /* value of first for init386(first) */ call _init386 /* wire 386 chip for unix operation */ popl %esi .globl __ucodesel,__udatasel pushl $0 /* unused */ pushl __udatasel /* ss */ pushl $0 /* esp - filled in by execve() */ pushl $PSL_USERSET /* eflags (ring 0, int enab) */ pushl __ucodesel /* cs */ pushl $0 /* eip - filled in by execve() */ subl $(12*4),%esp /* space for rest of registers */ pushl %esp /* call main with frame pointer */ call _main /* autoconfiguration, mountroot etc */ addl $(13*4),%esp /* back to a frame we can return with */ /* * now we've run main() and determined what cpu-type we are, we can * enable WP mode on i486 cpus and above. */ #if defined(I486_CPU) || defined(I586_CPU) cmpl $CPUCLASS_386,_cpu_class je 1f movl %cr0,%eax /* get control word */ orl $CR0_WP,%eax /* enable write protect for all modes */ movl %eax,%cr0 /* and do it */ #endif /* * on return from main(), we are process 1 * set up address space and stack so that we can 'return' to user mode */ 1: movl __ucodesel,%eax movl __udatasel,%ecx movl %cx,%ds movl %cx,%es movl %ax,%fs /* double map cs to fs */ movl %cx,%gs /* and ds to gs */ iret /* goto user! */ #define LCALL(x,y) .byte 0x9a ; .long y ; .word x NON_GPROF_ENTRY(sigcode) call SIGF_HANDLER(%esp) lea SIGF_SC(%esp),%eax /* scp (the call may have clobbered the */ /* copy at 8(%esp)) */ pushl %eax pushl %eax /* junk to fake return address */ movl $103,%eax /* XXX sigreturn() */ LCALL(0x7,0) /* enter kernel with args on stack */ hlt /* never gets here */ .globl _szsigcode _szsigcode: .long _szsigcode-_sigcode diff --git a/sys/i386/i386/machdep.c b/sys/i386/i386/machdep.c index 0fff0aa89461..1701db1d725a 100644 --- a/sys/i386/i386/machdep.c +++ b/sys/i386/i386/machdep.c @@ -1,1647 +1,1620 @@ /*- * Copyright (c) 1992 Terrence R. Lambert. * Copyright (c) 1982, 1987, 1990 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * William Jolitz. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 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 * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: @(#)machdep.c 7.4 (Berkeley) 6/3/91 - * $Id: machdep.c,v 1.70 1994/10/04 18:44:21 ache Exp $ + * $Id: machdep.c,v 1.71 1994/10/09 07:34:29 davidg Exp $ */ #include "npx.h" #include "isa.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef SYSVSHM #include #endif #ifdef SYSVMSG #include #endif #ifdef SYSVSEM #include #endif #include #include #include #include #include #include extern vm_offset_t avail_start, avail_end; #include #include #include #include #include #include #include #include #include static void identifycpu(void); static void initcpu(void); static int test_page(int *, int); char machine[] = "i386"; char cpu_model[sizeof("Cy486DLC") + 1]; #ifndef PANIC_REBOOT_WAIT_TIME #define PANIC_REBOOT_WAIT_TIME 15 /* default to 15 seconds */ #endif /* * Declare these as initialized data so we can patch them. */ int nswbuf = 0; #ifdef NBUF int nbuf = NBUF; #else int nbuf = 0; #endif #ifdef BUFPAGES int bufpages = BUFPAGES; #else int bufpages = 0; #endif #ifdef BOUNCE_BUFFERS extern char *bouncememory; extern int maxbkva; #ifdef BOUNCEPAGES int bouncepages = BOUNCEPAGES; #else int bouncepages = 0; #endif #endif /* BOUNCE_BUFFERS */ extern int freebufspace; int msgbufmapped = 0; /* set when safe to use msgbuf */ int _udatasel, _ucodesel; extern int adjkerntz, disable_rtc_set; /* from clock.c */ /* * Machine-dependent startup code */ int boothowto = 0, Maxmem = 0, badpages = 0, physmem = 0; long dumplo; extern int bootdev; int biosmem; vm_offset_t phys_avail[6]; int cpu_class; void dumpsys __P((void)); vm_offset_t buffer_sva, buffer_eva; vm_offset_t clean_sva, clean_eva; vm_offset_t pager_sva, pager_eva; extern int pager_map_size; #define offsetof(type, member) ((size_t)(&((type *)0)->member)) void cpu_startup() { register unsigned i; register caddr_t v; extern void (*netisrs[32])(void); - vm_offset_t minaddr, maxaddr; + vm_offset_t maxaddr; vm_size_t size = 0; int firstaddr; /* * Initialize error message buffer (at end of core). */ /* avail_end was pre-decremented in init_386() to compensate */ for (i = 0; i < btoc(sizeof (struct msgbuf)); i++) pmap_enter(pmap_kernel(), (vm_offset_t)msgbufp, avail_end + i * NBPG, VM_PROT_ALL, TRUE); msgbufmapped = 1; /* * Good {morning,afternoon,evening,night}. */ printf(version); startrtclock(); identifycpu(); printf("real memory = %d (%d pages)\n", ptoa(physmem), physmem); if (badpages) printf("bad memory = %d (%d pages)\n", ptoa(badpages), badpages); /* * Quickly wire in netisrs. */ #define DONET(isr, n) do { extern void isr(void); netisrs[n] = isr; } while(0) #ifdef INET #if NETHER > 0 DONET(arpintr, NETISR_ARP); #endif DONET(ipintr, NETISR_IP); #endif #ifdef NS DONET(nsintr, NETISR_NS); #endif #ifdef ISO DONET(clnlintr, NETISR_ISO); #endif #ifdef CCITT DONET(ccittintr, NETISR_CCITT); #endif #undef DONET /* * Allocate space for system data structures. * The first available kernel virtual address is in "v". * As pages of kernel virtual memory are allocated, "v" is incremented. * As pages of memory are allocated and cleared, * "firstaddr" is incremented. * An index into the kernel page table corresponding to the * virtual memory address maintained in "v" is kept in "mapaddr". */ /* * Make two passes. The first pass calculates how much memory is * needed and allocates it. The second pass assigns virtual * addresses to the various data structures. */ firstaddr = 0; again: v = (caddr_t)firstaddr; #define valloc(name, type, num) \ (name) = (type *)v; v = (caddr_t)((name)+(num)) #define valloclim(name, type, num, lim) \ (name) = (type *)v; v = (caddr_t)((lim) = ((name)+(num))) valloc(callout, struct callout, ncallout); #ifdef SYSVSHM valloc(shmsegs, struct shmid_ds, shminfo.shmmni); #endif #ifdef SYSVSEM valloc(sema, struct semid_ds, seminfo.semmni); valloc(sem, struct sem, seminfo.semmns); /* This is pretty disgusting! */ valloc(semu, int, (seminfo.semmnu * seminfo.semusz) / sizeof(int)); #endif #ifdef SYSVMSG valloc(msgpool, char, msginfo.msgmax); valloc(msgmaps, struct msgmap, msginfo.msgseg); valloc(msghdrs, struct msg, msginfo.msgtql); valloc(msqids, struct msqid_ds, msginfo.msgmni); #endif /* * Determine how many buffers to allocate. * Use 20% of memory of memory beyond the first 2MB * Insure a minimum of 16 fs buffers. * We allocate 1/2 as many swap buffer headers as file i/o buffers. */ if (bufpages == 0) bufpages = ((physmem << PGSHIFT) - 2048*1024) / NBPG / 5; if (bufpages < 64) bufpages = 64; /* * We must still limit the maximum number of buffers to be no * more than 2/5's of the size of the kernal malloc region, this * will only take effect for machines with lots of memory */ bufpages = min(bufpages, (VM_KMEM_SIZE / NBPG) * 2 / 5); if (nbuf == 0) { nbuf = bufpages / 2; if (nbuf < 32) nbuf = 32; } freebufspace = bufpages * NBPG; if (nswbuf == 0) { nswbuf = (nbuf / 2) &~ 1; /* force even */ if (nswbuf > 64) nswbuf = 64; /* sanity */ } valloc(swbuf, struct buf, nswbuf); valloc(buf, struct buf, nbuf); #ifdef BOUNCE_BUFFERS /* * If there is more than 16MB of memory, allocate some bounce buffers */ if (Maxmem > 4096) { if (bouncepages == 0) bouncepages = 96; /* largest physio size + extra */ v = (caddr_t)((vm_offset_t)((vm_offset_t)v + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)); valloc(bouncememory, char, bouncepages * PAGE_SIZE); } #endif /* * End of first pass, size has been calculated so allocate memory */ if (firstaddr == 0) { size = (vm_size_t)(v - firstaddr); firstaddr = (int)kmem_alloc(kernel_map, round_page(size)); if (firstaddr == 0) panic("startup: no room for tables"); goto again; } /* * End of second pass, addresses have been assigned */ if ((vm_size_t)(v - firstaddr) != size) panic("startup: table size inconsistency"); #ifdef BOUNCE_BUFFERS clean_map = kmem_suballoc(kernel_map, &clean_sva, &clean_eva, (nbuf*MAXBSIZE) + (nswbuf*MAXPHYS) + maxbkva + pager_map_size, TRUE); io_map = kmem_suballoc(clean_map, &minaddr, &maxaddr, maxbkva, FALSE); #else clean_map = kmem_suballoc(kernel_map, &clean_sva, &clean_eva, (nbuf*MAXBSIZE) + (nswbuf*MAXPHYS) + pager_map_size, TRUE); #endif buffer_map = kmem_suballoc(clean_map, &buffer_sva, &buffer_eva, (nbuf*MAXBSIZE), TRUE); pager_map = kmem_suballoc(clean_map, &pager_sva, &pager_eva, (nswbuf*MAXPHYS) + pager_map_size, TRUE); /* * Finally, allocate mbuf pool. Since mclrefcnt is an off-size * we use the more space efficient malloc in place of kmem_alloc. */ mclrefcnt = (char *)malloc(NMBCLUSTERS+CLBYTES/MCLBYTES, M_MBUF, M_NOWAIT); bzero(mclrefcnt, NMBCLUSTERS+CLBYTES/MCLBYTES); mb_map = kmem_suballoc(kmem_map, (vm_offset_t *)&mbutl, &maxaddr, VM_MBUF_SIZE, FALSE); /* * Initialize callouts */ callfree = callout; for (i = 1; i < ncallout; i++) callout[i-1].c_next = &callout[i]; printf("avail memory = %d (%d pages)\n", ptoa(cnt.v_free_count), cnt.v_free_count); printf("using %d buffers containing %d bytes of memory\n", nbuf, bufpages * CLBYTES); #ifdef BOUNCE_BUFFERS /* * init bounce buffers */ vm_bounce_init(); #endif /* * Set up CPU-specific registers, cache, etc. */ initcpu(); /* * Set up buffers, so they can be used to read disk labels. */ bufinit(); vm_pager_bufferinit(); /* * Configure the system. */ configure(); } struct cpu_nameclass i386_cpus[] = { { "Intel 80286", CPUCLASS_286 }, /* CPU_286 */ { "i386SX", CPUCLASS_386 }, /* CPU_386SX */ { "i386DX", CPUCLASS_386 }, /* CPU_386 */ { "i486SX", CPUCLASS_486 }, /* CPU_486SX */ { "i486DX", CPUCLASS_486 }, /* CPU_486 */ { "Pentium", CPUCLASS_586 }, /* CPU_586 */ { "Cy486DLC", CPUCLASS_486 }, /* CPU_486DLC */ }; static void identifycpu() { extern u_long cpu_id; extern char cpu_vendor[]; printf("CPU: "); if (cpu >= 0 && cpu < (sizeof i386_cpus/sizeof(struct cpu_nameclass))) { printf("%s", i386_cpus[cpu].cpu_name); cpu_class = i386_cpus[cpu].cpu_class; strncpy(cpu_model, i386_cpus[cpu].cpu_name, sizeof cpu_model); } else { printf("unknown cpu type %d\n", cpu); panic("startup: bad cpu id"); } printf(" ("); switch(cpu_class) { case CPUCLASS_286: printf("286"); break; case CPUCLASS_386: printf("386"); break; case CPUCLASS_486: printf("486"); break; case CPUCLASS_586: printf("Pentium"); break; default: printf("unknown"); /* will panic below... */ } printf("-class CPU)"); #ifdef I586_CPU if(cpu_class == CPUCLASS_586) { extern void calibrate_cyclecounter(); extern int pentium_mhz; calibrate_cyclecounter(); printf(" %d MHz", pentium_mhz); } #endif if(cpu_id) printf(" Id = 0x%lx",cpu_id); if(*cpu_vendor) printf(" Origin = \"%s\"",cpu_vendor); printf("\n"); /* cpu speed would be nice, but how? */ /* * Now that we have told the user what they have, * let them know if that machine type isn't configured. */ switch (cpu_class) { case CPUCLASS_286: /* a 286 should not make it this far, anyway */ #if !defined(I386_CPU) && !defined(I486_CPU) && !defined(I586_CPU) #error This kernel is not configured for one of the supported CPUs #endif #if !defined(I386_CPU) case CPUCLASS_386: #endif #if !defined(I486_CPU) case CPUCLASS_486: #endif #if !defined(I586_CPU) case CPUCLASS_586: #endif panic("CPU class not configured"); default: break; } } #ifdef PGINPROF /* * Return the difference (in microseconds) * between the current time and a previous * time as represented by the arguments. * If there is a pending clock interrupt * which has not been serviced due to high * ipl, return error code. */ /*ARGSUSED*/ vmtime(otime, olbolt, oicr) register int otime, olbolt, oicr; { return (((time.tv_sec-otime)*60 + lbolt-olbolt)*16667); } #endif extern int kstack[]; /* * Send an interrupt to process. * * Stack is set up to allow sigcode stored * in u. to call routine, followed by kcall * to sigreturn routine below. After sigreturn * resets the signal mask, the stack, and the * frame pointer, it returns to the user * specified pc, psl. */ void sendsig(catcher, sig, mask, code) sig_t catcher; int sig, mask; unsigned code; { register struct proc *p = curproc; register int *regs; register struct sigframe *fp; struct sigacts *psp = p->p_sigacts; int oonstack; regs = p->p_md.md_regs; oonstack = psp->ps_sigstk.ss_flags & SA_ONSTACK; /* * Allocate and validate space for the signal handler * context. Note that if the stack is in P0 space, the * call to grow() is a nop, and the useracc() check * will fail if the process has not already allocated * the space with a `brk'. */ if ((psp->ps_flags & SAS_ALTSTACK) && (psp->ps_sigstk.ss_flags & SA_ONSTACK) == 0 && (psp->ps_sigonstack & sigmask(sig))) { fp = (struct sigframe *)(psp->ps_sigstk.ss_base + psp->ps_sigstk.ss_size - sizeof(struct sigframe)); psp->ps_sigstk.ss_flags |= SA_ONSTACK; } else { fp = (struct sigframe *)(regs[tESP] - sizeof(struct sigframe)); } /* * grow() will return FALSE if the fp will not fit inside the stack * and the stack can not be grown. useracc will return FALSE * if access is denied. */ if ((grow(p, (int)fp) == FALSE) || (useracc((caddr_t)fp, sizeof (struct sigframe), B_WRITE) == FALSE)) { /* * Process has trashed its stack; give it an illegal * instruction to halt it in its tracks. */ SIGACTION(p, SIGILL) = SIG_DFL; sig = sigmask(SIGILL); p->p_sigignore &= ~sig; p->p_sigcatch &= ~sig; p->p_sigmask &= ~sig; psignal(p, SIGILL); return; } /* * Build the argument list for the signal handler. */ if (p->p_sysent->sv_sigtbl) { if (sig < p->p_sysent->sv_sigsize) sig = p->p_sysent->sv_sigtbl[sig]; else sig = p->p_sysent->sv_sigsize + 1; } fp->sf_signum = sig; fp->sf_code = code; fp->sf_scp = &fp->sf_sc; fp->sf_addr = (char *) regs[tERR]; fp->sf_handler = catcher; /* save scratch registers */ fp->sf_sc.sc_eax = regs[tEAX]; fp->sf_sc.sc_ebx = regs[tEBX]; fp->sf_sc.sc_ecx = regs[tECX]; fp->sf_sc.sc_edx = regs[tEDX]; fp->sf_sc.sc_esi = regs[tESI]; fp->sf_sc.sc_edi = regs[tEDI]; fp->sf_sc.sc_cs = regs[tCS]; fp->sf_sc.sc_ds = regs[tDS]; fp->sf_sc.sc_ss = regs[tSS]; fp->sf_sc.sc_es = regs[tES]; fp->sf_sc.sc_isp = regs[tISP]; /* * Build the signal context to be used by sigreturn. */ fp->sf_sc.sc_onstack = oonstack; fp->sf_sc.sc_mask = mask; fp->sf_sc.sc_sp = regs[tESP]; fp->sf_sc.sc_fp = regs[tEBP]; fp->sf_sc.sc_pc = regs[tEIP]; fp->sf_sc.sc_ps = regs[tEFLAGS]; regs[tESP] = (int)fp; regs[tEIP] = (int)((struct pcb *)kstack)->pcb_sigc; regs[tEFLAGS] &= ~PSL_VM; regs[tCS] = _ucodesel; regs[tDS] = _udatasel; regs[tES] = _udatasel; regs[tSS] = _udatasel; } /* * System call to cleanup state after a signal * has been taken. Reset signal mask and * stack state from context left by sendsig (above). * Return to previous pc and psl as specified by * context left by sendsig. Check carefully to * make sure that the user has not modified the * psl to gain improper privileges or to cause * a machine fault. */ struct sigreturn_args { struct sigcontext *sigcntxp; }; int sigreturn(p, uap, retval) struct proc *p; struct sigreturn_args *uap; int *retval; { register struct sigcontext *scp; register struct sigframe *fp; register int *regs = p->p_md.md_regs; int eflags; /* * (XXX old comment) regs[tESP] points to the return address. * The user scp pointer is above that. * The return address is faked in the signal trampoline code * for consistency. */ scp = uap->sigcntxp; fp = (struct sigframe *) ((caddr_t)scp - offsetof(struct sigframe, sf_sc)); if (useracc((caddr_t)fp, sizeof (*fp), 0) == 0) return(EINVAL); eflags = scp->sc_ps; if ((eflags & PSL_USERCLR) != 0 || (eflags & PSL_USERSET) != PSL_USERSET || (eflags & PSL_IOPL) < (regs[tEFLAGS] & PSL_IOPL)) { #ifdef DEBUG printf("sigreturn: eflags=0x%x\n", eflags); #endif return(EINVAL); } /* * Sanity check the user's selectors and error if they * are suspect. */ #define max_ldt_sel(pcb) \ ((pcb)->pcb_ldt ? (pcb)->pcb_ldt_len : (sizeof(ldt) / sizeof(ldt[0]))) #define valid_ldt_sel(sel) \ (ISLDT(sel) && ISPL(sel) == SEL_UPL && \ IDXSEL(sel) < max_ldt_sel(&p->p_addr->u_pcb)) #define null_sel(sel) \ (!ISLDT(sel) && IDXSEL(sel) == 0) if (((scp->sc_cs&0xffff) != _ucodesel && !valid_ldt_sel(scp->sc_cs)) || ((scp->sc_ss&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_ss)) || ((scp->sc_ds&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_ds) && !null_sel(scp->sc_ds)) || ((scp->sc_es&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_es) && !null_sel(scp->sc_es))) { #ifdef DEBUG printf("sigreturn: cs=0x%x ss=0x%x ds=0x%x es=0x%x\n", scp->sc_cs, scp->sc_ss, scp->sc_ds, scp->sc_es); #endif trapsignal(p, SIGBUS, T_PROTFLT); return(EINVAL); } #undef max_ldt_sel #undef valid_ldt_sel #undef null_sel /* restore scratch registers */ regs[tEAX] = scp->sc_eax; regs[tEBX] = scp->sc_ebx; regs[tECX] = scp->sc_ecx; regs[tEDX] = scp->sc_edx; regs[tESI] = scp->sc_esi; regs[tEDI] = scp->sc_edi; regs[tCS] = scp->sc_cs; regs[tDS] = scp->sc_ds; regs[tES] = scp->sc_es; regs[tSS] = scp->sc_ss; regs[tISP] = scp->sc_isp; if (useracc((caddr_t)scp, sizeof (*scp), 0) == 0) return(EINVAL); if (scp->sc_onstack & 01) p->p_sigacts->ps_sigstk.ss_flags |= SA_ONSTACK; else p->p_sigacts->ps_sigstk.ss_flags &= ~SA_ONSTACK; p->p_sigmask = scp->sc_mask &~ (sigmask(SIGKILL)|sigmask(SIGCONT)|sigmask(SIGSTOP)); regs[tEBP] = scp->sc_fp; regs[tESP] = scp->sc_sp; regs[tEIP] = scp->sc_pc; regs[tEFLAGS] = eflags; return(EJUSTRETURN); } /* * a simple function to make the system panic (and dump a vmcore) * in a predictable fashion */ void diediedie() { panic("because you said to!"); } int waittime = -1; struct pcb dumppcb; __dead void boot(arghowto) int arghowto; { register long dummy; /* r12 is reserved */ register int howto; /* r11 == how to boot */ register int devtype; /* r10 == major of root dev */ extern int cold; if (cold) { printf("hit reset please"); for(;;); } howto = arghowto; if ((howto&RB_NOSYNC) == 0 && waittime < 0) { register struct buf *bp; int iter, nbusy; waittime = 0; printf("\nsyncing disks... "); /* * Release inodes held by texts before update. */ if (panicstr == 0) vnode_pager_umount(NULL); sync(curproc, NULL, NULL); for (iter = 0; iter < 20; iter++) { nbusy = 0; for (bp = &buf[nbuf]; --bp >= buf; ) if ((bp->b_flags & (B_BUSY|B_INVAL)) == B_BUSY) nbusy++; if (nbusy == 0) break; printf("%d ", nbusy); DELAY(40000 * iter); } if (nbusy) { /* * Failed to sync all blocks. Indicate this and don't * unmount filesystems (thus forcing an fsck on reboot). */ printf("giving up\n"); } else { printf("done\n"); /* * Unmount filesystems */ if (panicstr == 0) vfs_unmountall(); } DELAY(100000); /* wait for console output to finish */ } splhigh(); devtype = major(rootdev); if (howto&RB_HALT) { printf("\n"); printf("The operating system has halted.\n"); printf("Please press any key to reboot.\n\n"); cngetc(); } else { if (howto & RB_DUMP) { savectx(&dumppcb, 0); dumppcb.pcb_ptd = rcr3(); dumpsys(); if (PANIC_REBOOT_WAIT_TIME != 0) { if (PANIC_REBOOT_WAIT_TIME != -1) { int loop; printf("Automatic reboot in %d seconds - press a key on the console to abort\n", PANIC_REBOOT_WAIT_TIME); for (loop = PANIC_REBOOT_WAIT_TIME; loop > 0; --loop) { DELAY(1000 * 1000); /* one second */ if (sgetc(1)) /* Did user type a key? */ break; } if (!loop) goto die; } } else { /* zero time specified - reboot NOW */ goto die; } printf("--> Press a key on the console to reboot <--\n"); cngetc(); } } #ifdef lint dummy = 0; dummy = dummy; printf("howto %d, devtype %d\n", arghowto, devtype); #endif die: printf("Rebooting...\n"); DELAY(1000000); /* wait 1 sec for printf's to complete and be read */ cpu_reset(); for(;;) ; /* NOTREACHED */ } unsigned long dumpmag = 0x8fca0101UL; /* magic number for savecore */ int dumpsize = 0; /* also for savecore */ /* * Doadump comes here after turning off memory management and * getting on the dump stack, either when called above, or by * the auto-restart code. */ void dumpsys() { if (dumpdev == NODEV) return; if ((minor(dumpdev)&07) != 1) return; dumpsize = Maxmem; printf("\ndumping to dev %lx, offset %ld\n", dumpdev, dumplo); printf("dump "); switch ((*bdevsw[major(dumpdev)].d_dump)(dumpdev)) { case ENXIO: printf("device bad\n"); break; case EFAULT: printf("device not ready\n"); break; case EINVAL: printf("area improper\n"); break; case EIO: printf("i/o error\n"); break; case EINTR: printf("aborted from console\n"); break; default: printf("succeeded\n"); break; } } #ifdef HZ /* * If HZ is defined we use this code, otherwise the code in * /sys/i386/i386/microtime.s is used. The othercode only works * for HZ=100. */ microtime(tvp) register struct timeval *tvp; { int s = splhigh(); *tvp = time; tvp->tv_usec += tick; while (tvp->tv_usec > 1000000) { tvp->tv_sec++; tvp->tv_usec -= 1000000; } splx(s); } #endif /* HZ */ static void initcpu() { } /* * Clear registers on exec */ void setregs(p, entry, stack) struct proc *p; u_long entry; u_long stack; { p->p_md.md_regs[tEBP] = 0; /* bottom of the fp chain */ p->p_md.md_regs[tEIP] = entry; p->p_md.md_regs[tESP] = stack; p->p_md.md_regs[tSS] = _udatasel; p->p_md.md_regs[tDS] = _udatasel; p->p_md.md_regs[tES] = _udatasel; p->p_md.md_regs[tCS] = _ucodesel; p->p_addr->u_pcb.pcb_flags = 0; /* no fp at all */ load_cr0(rcr0() | CR0_TS); /* start emulating */ #if NNPX > 0 npxinit(__INITIAL_NPXCW__); #endif /* NNPX > 0 */ } /* * machine dependent system variables. */ int cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) int *name; u_int namelen; void *oldp; size_t *oldlenp; void *newp; size_t newlen; struct proc *p; { /* all sysctl names at this level are terminal */ if (namelen != 1) return (ENOTDIR); /* overloaded */ switch (name[0]) { case CPU_CONSDEV: return (sysctl_rdstruct(oldp, oldlenp, newp, &cn_tty->t_dev, sizeof cn_tty->t_dev)); case CPU_ADJKERNTZ: return (sysctl_int(oldp, oldlenp, newp, newlen, &adjkerntz)); case CPU_DISRTCSET: return (sysctl_int(oldp, oldlenp, newp, newlen, &disable_rtc_set)); default: return (EOPNOTSUPP); } /* NOTREACHED */ } /* * Initialize 386 and configure to run kernel */ /* * Initialize segments & interrupt table */ union descriptor gdt[NGDT]; union descriptor ldt[NLDT]; /* local descriptor table */ struct gate_descriptor idt[NIDT]; /* interrupt descriptor table */ int _default_ldt, currentldt; struct i386tss tss, panic_tss; extern struct user *proc0paddr; /* software prototypes -- in more palatable form */ struct soft_segment_descriptor gdt_segs[] = { - /* Null Descriptor */ +/* GNULL_SEL 0 Null Descriptor */ { 0x0, /* segment base address */ 0x0, /* length */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* Code Descriptor for kernel */ +/* GCODE_SEL 1 Code Descriptor for kernel */ { 0x0, /* segment base address */ 0xfffff, /* length - all address space */ SDT_MEMERA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ 1 /* limit granularity (byte/page units)*/ }, - /* Data Descriptor for kernel */ +/* GDATA_SEL 2 Data Descriptor for kernel */ { 0x0, /* segment base address */ 0xfffff, /* length - all address space */ SDT_MEMRWA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ 1 /* limit granularity (byte/page units)*/ }, - /* LDT Descriptor */ -{ (int) ldt, /* segment base address */ +/* GLDT_SEL 3 LDT Descriptor */ +{ (int) ldt, /* segment base address */ sizeof(ldt)-1, /* length - all address space */ SDT_SYSLDT, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* unused - default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* Null Descriptor - Placeholder */ +/* GTGATE_SEL 4 Null Descriptor - Placeholder */ { 0x0, /* segment base address */ 0x0, /* length - all address space */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* Panic Tss Descriptor */ -{ (int) &panic_tss, /* segment base address */ +/* GPANIC_SEL 5 Panic Tss Descriptor */ +{ (int) &panic_tss, /* segment base address */ sizeof(tss)-1, /* length - all address space */ SDT_SYS386TSS, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* unused - default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* Proc 0 Tss Descriptor */ -{ (int) kstack, /* segment base address */ +/* GPROC0_SEL 6 Proc 0 Tss Descriptor */ +{ (int) kstack, /* segment base address */ sizeof(tss)-1, /* length - all address space */ SDT_SYS386TSS, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* unused - default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, - /* User LDT Descriptor per process */ +/* GUSERLDT_SEL 7 User LDT Descriptor per process */ { (int) ldt, /* segment base address */ (512 * sizeof(union descriptor)-1), /* length */ SDT_SYSLDT, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* unused - default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, -#ifdef APM - /* APM BIOS 32-bit interface (32bit Code) */ +/* GAPMCODE32_SEL 8 APM BIOS 32-bit interface (32bit Code) */ { 0, /* segment base address (overwritten by APM) */ - 0xffff, /* length */ + 0xfffff, /* length */ SDT_MEMERA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, - /* APM BIOS 32-bit interface (16bit Code) */ + 1 /* limit granularity (byte/page units)*/ }, +/* GAPMCODE16_SEL 9 APM BIOS 32-bit interface (16bit Code) */ { 0, /* segment base address (overwritten by APM) */ - 0xffff, /* length */ + 0xfffff, /* length */ SDT_MEMERA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, - /* APM BIOS 32-bit interface (Data) */ + 1 /* limit granularity (byte/page units)*/ }, +/* GAPMDATA_SEL 10 APM BIOS 32-bit interface (Data) */ { 0, /* segment base address (overwritten by APM) */ - 0xffff, /* length */ + 0xfffff, /* length */ SDT_MEMRWA, /* segment type */ 0, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, -#else /* APM */ -{ 0, /* segment base address */ - 0, /* length */ - 0, /* segment type */ - 0, /* segment descriptor priority level */ - 0, /* segment descriptor present */ - 0, 0, - 0, /* unused - default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, -{ 0, /* segment base address */ - 0, /* length */ - 0, /* segment type */ - 0, /* segment descriptor priority level */ - 0, /* segment descriptor present */ - 0, 0, - 0, /* unused - default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, -{ 0, /* segment base address */ - 0, /* length */ - 0, /* segment type */ - 0, /* segment descriptor priority level */ - 0, /* segment descriptor present */ - 0, 0, - 0, /* unused - default 32 vs 16 bit size */ - 0 /* limit granularity (byte/page units)*/ }, -#endif /* APMBIOS */ + 1 /* limit granularity (byte/page units)*/ }, }; struct soft_segment_descriptor ldt_segs[] = { /* Null Descriptor - overwritten by call gate */ { 0x0, /* segment base address */ 0x0, /* length - all address space */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, /* Null Descriptor - overwritten by call gate */ { 0x0, /* segment base address */ 0x0, /* length - all address space */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, /* Null Descriptor - overwritten by call gate */ { 0x0, /* segment base address */ 0x0, /* length - all address space */ 0, /* segment type */ 0, /* segment descriptor priority level */ 0, /* segment descriptor present */ 0, 0, 0, /* default 32 vs 16 bit size */ 0 /* limit granularity (byte/page units)*/ }, /* Code Descriptor for user */ { 0x0, /* segment base address */ 0xfffff, /* length - all address space */ SDT_MEMERA, /* segment type */ SEL_UPL, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ 1 /* limit granularity (byte/page units)*/ }, /* Data Descriptor for user */ { 0x0, /* segment base address */ 0xfffff, /* length - all address space */ SDT_MEMRWA, /* segment type */ SEL_UPL, /* segment descriptor priority level */ 1, /* segment descriptor present */ 0, 0, 1, /* default 32 vs 16 bit size */ 1 /* limit granularity (byte/page units)*/ } }; void setidt(idx, func, typ, dpl) int idx; void (*func)(); int typ; int dpl; { struct gate_descriptor *ip = idt + idx; ip->gd_looffset = (int)func; ip->gd_selector = 8; ip->gd_stkcpy = 0; ip->gd_xx = 0; ip->gd_type = typ; ip->gd_dpl = dpl; ip->gd_p = 1; ip->gd_hioffset = ((int)func)>>16 ; } #define IDTVEC(name) __CONCAT(X,name) typedef void idtvec_t(); extern idtvec_t IDTVEC(div), IDTVEC(dbg), IDTVEC(nmi), IDTVEC(bpt), IDTVEC(ofl), IDTVEC(bnd), IDTVEC(ill), IDTVEC(dna), IDTVEC(dble), IDTVEC(fpusegm), IDTVEC(tss), IDTVEC(missing), IDTVEC(stk), IDTVEC(prot), IDTVEC(page), IDTVEC(rsvd), IDTVEC(fpu), IDTVEC(rsvd0), IDTVEC(rsvd1), IDTVEC(rsvd2), IDTVEC(rsvd3), IDTVEC(rsvd4), IDTVEC(rsvd5), IDTVEC(rsvd6), IDTVEC(rsvd7), IDTVEC(rsvd8), IDTVEC(rsvd9), IDTVEC(rsvd10), IDTVEC(rsvd11), IDTVEC(rsvd12), IDTVEC(rsvd13), IDTVEC(rsvd14), IDTVEC(syscall); int _gsel_tss; /* added sdtossd() by HOSOKAWA Tatsumi */ int sdtossd(sd, ssd) struct segment_descriptor *sd; struct soft_segment_descriptor *ssd; { ssd->ssd_base = (sd->sd_hibase << 24) | sd->sd_lobase; ssd->ssd_limit = (sd->sd_hilimit << 16) | sd->sd_lolimit; ssd->ssd_type = sd->sd_type; ssd->ssd_dpl = sd->sd_dpl; ssd->ssd_p = sd->sd_p; ssd->ssd_def32 = sd->sd_def32; ssd->ssd_gran = sd->sd_gran; return 0; } void init386(first) int first; { extern lgdt(), lidt(), lldt(); int x; unsigned biosbasemem, biosextmem; struct gate_descriptor *gdp; extern int sigcode,szsigcode; /* table descriptors - used to load tables by microp */ struct region_descriptor r_gdt, r_idt; int pagesinbase, pagesinext; int target_page; extern struct pte *CMAP1; extern caddr_t CADDR1; proc0.p_addr = proc0paddr; /* * Initialize the console before we print anything out. */ cninit (); /* * make gdt memory segments, the code segment goes up to end of the * page with etext in it, the data segment goes to the end of * the address space */ gdt_segs[GCODE_SEL].ssd_limit = i386_btop(0) - 1 /* i386_btop(i386_round_page(&etext)) - 1 */; gdt_segs[GDATA_SEL].ssd_limit = i386_btop(0) - 1; for (x=0; x < NGDT; x++) ssdtosd(gdt_segs+x, gdt+x); /* make ldt memory segments */ /* * The data segment limit must not cover the user area because we * don't want the user area to be writable in copyout() etc. (page * level protection is lost in kernel mode on 386's). Also, we * don't want the user area to be writable directly (page level * protection of the user area is not available on 486's with * CR0_WP set, because there is no user-read/kernel-write mode). * * XXX - VM_MAXUSER_ADDRESS is an end address, not a max. And it * should be spelled ...MAX_USER... */ #define VM_END_USER_RW_ADDRESS VM_MAXUSER_ADDRESS /* * The code segment limit has to cover the user area until we move * the signal trampoline out of the user area. This is safe because * the code segment cannot be written to directly. */ #define VM_END_USER_R_ADDRESS (VM_END_USER_RW_ADDRESS + UPAGES * NBPG) ldt_segs[LUCODE_SEL].ssd_limit = i386_btop(VM_END_USER_R_ADDRESS) - 1; ldt_segs[LUDATA_SEL].ssd_limit = i386_btop(VM_END_USER_RW_ADDRESS) - 1; /* Note. eventually want private ldts per process */ for (x=0; x < 5; x++) ssdtosd(ldt_segs+x, ldt+x); /* exceptions */ setidt(0, &IDTVEC(div), SDT_SYS386TGT, SEL_KPL); setidt(1, &IDTVEC(dbg), SDT_SYS386TGT, SEL_KPL); setidt(2, &IDTVEC(nmi), SDT_SYS386TGT, SEL_KPL); setidt(3, &IDTVEC(bpt), SDT_SYS386TGT, SEL_UPL); setidt(4, &IDTVEC(ofl), SDT_SYS386TGT, SEL_UPL); setidt(5, &IDTVEC(bnd), SDT_SYS386TGT, SEL_KPL); setidt(6, &IDTVEC(ill), SDT_SYS386TGT, SEL_KPL); setidt(7, &IDTVEC(dna), SDT_SYS386TGT, SEL_KPL); setidt(8, &IDTVEC(dble), SDT_SYS386TGT, SEL_KPL); setidt(9, &IDTVEC(fpusegm), SDT_SYS386TGT, SEL_KPL); setidt(10, &IDTVEC(tss), SDT_SYS386TGT, SEL_KPL); setidt(11, &IDTVEC(missing), SDT_SYS386TGT, SEL_KPL); setidt(12, &IDTVEC(stk), SDT_SYS386TGT, SEL_KPL); setidt(13, &IDTVEC(prot), SDT_SYS386TGT, SEL_KPL); setidt(14, &IDTVEC(page), SDT_SYS386TGT, SEL_KPL); setidt(15, &IDTVEC(rsvd), SDT_SYS386TGT, SEL_KPL); setidt(16, &IDTVEC(fpu), SDT_SYS386TGT, SEL_KPL); setidt(17, &IDTVEC(rsvd0), SDT_SYS386TGT, SEL_KPL); setidt(18, &IDTVEC(rsvd1), SDT_SYS386TGT, SEL_KPL); setidt(19, &IDTVEC(rsvd2), SDT_SYS386TGT, SEL_KPL); setidt(20, &IDTVEC(rsvd3), SDT_SYS386TGT, SEL_KPL); setidt(21, &IDTVEC(rsvd4), SDT_SYS386TGT, SEL_KPL); setidt(22, &IDTVEC(rsvd5), SDT_SYS386TGT, SEL_KPL); setidt(23, &IDTVEC(rsvd6), SDT_SYS386TGT, SEL_KPL); setidt(24, &IDTVEC(rsvd7), SDT_SYS386TGT, SEL_KPL); setidt(25, &IDTVEC(rsvd8), SDT_SYS386TGT, SEL_KPL); setidt(26, &IDTVEC(rsvd9), SDT_SYS386TGT, SEL_KPL); setidt(27, &IDTVEC(rsvd10), SDT_SYS386TGT, SEL_KPL); setidt(28, &IDTVEC(rsvd11), SDT_SYS386TGT, SEL_KPL); setidt(29, &IDTVEC(rsvd12), SDT_SYS386TGT, SEL_KPL); setidt(30, &IDTVEC(rsvd13), SDT_SYS386TGT, SEL_KPL); setidt(31, &IDTVEC(rsvd14), SDT_SYS386TGT, SEL_KPL); #include "isa.h" #if NISA >0 isa_defaultirq(); #endif r_gdt.rd_limit = sizeof(gdt) - 1; r_gdt.rd_base = (int) gdt; lgdt(&r_gdt); r_idt.rd_limit = sizeof(idt) - 1; r_idt.rd_base = (int) idt; lidt(&r_idt); _default_ldt = GSEL(GLDT_SEL, SEL_KPL); lldt(_default_ldt); currentldt = _default_ldt; #ifdef DDB kdb_init(); if (boothowto & RB_KDB) Debugger("Boot flags requested debugger"); #endif /* Use BIOS values stored in RTC CMOS RAM, since probing * breaks certain 386 AT relics. */ biosbasemem = rtcin(RTC_BASELO)+ (rtcin(RTC_BASEHI)<<8); biosextmem = rtcin(RTC_EXTLO)+ (rtcin(RTC_EXTHI)<<8); /* * If BIOS tells us that it has more than 640k in the basemem, * don't believe it - set it to 640k. */ if (biosbasemem > 640) biosbasemem = 640; /* * Some 386 machines might give us a bogus number for extended * mem. If this happens, stop now. */ #ifndef LARGEMEM if (biosextmem > 65536) { panic("extended memory beyond limit of 64MB"); /* NOTREACHED */ } #endif pagesinbase = biosbasemem * 1024 / NBPG; pagesinext = biosextmem * 1024 / NBPG; /* * Special hack for chipsets that still remap the 384k hole when * there's 16MB of memory - this really confuses people that * are trying to use bus mastering ISA controllers with the * "16MB limit"; they only have 16MB, but the remapping puts * them beyond the limit. * XXX - this should be removed when bounce buffers are * implemented. */ /* * If extended memory is between 15-16MB (16-17MB phys address range), * chop it to 15MB. */ if ((pagesinext > 3840) && (pagesinext < 4096)) pagesinext = 3840; /* * Maxmem isn't the "maximum memory", it's the highest page of * of the physical address space. It should be "Maxphyspage". */ Maxmem = pagesinext + 0x100000/PAGE_SIZE; #ifdef MAXMEM if (MAXMEM/4 < Maxmem) Maxmem = MAXMEM/4; #endif /* * Calculate number of physical pages, but account for Maxmem * limitation above. */ physmem = pagesinbase + (min(pagesinext + 0x100000/PAGE_SIZE, Maxmem) - 0x100000/PAGE_SIZE); /* call pmap initialization to make new kernel address space */ pmap_bootstrap (first, 0); /* * Do simple memory test over range of extended memory that BIOS * indicates exists. Adjust Maxmem to the highest page of * good memory. */ printf("Testing memory (%dMB)...", ptoa(Maxmem)/1024/1024); for (target_page = Maxmem - 1; target_page >= atop(first); target_page--) { /* * map page into kernel: valid, read/write, non-cacheable */ *(int *)CMAP1 = PG_V | PG_KW | PG_N | ptoa(target_page); pmap_update(); /* * Test for alternating 1's and 0's */ filli(0xaaaaaaaa, CADDR1, PAGE_SIZE/sizeof(int)); if (test_page((int *)CADDR1, 0xaaaaaaaa)) { Maxmem = target_page; badpages++; continue; } /* * Test for alternating 0's and 1's */ filli(0x55555555, CADDR1, PAGE_SIZE/sizeof(int)); if (test_page((int *)CADDR1, 0x55555555)) { Maxmem = target_page; badpages++; continue; } /* * Test for all 1's */ filli(0xffffffff, CADDR1, PAGE_SIZE/sizeof(int)); if (test_page((int *)CADDR1, 0xffffffff)) { Maxmem = target_page; badpages++; continue; } /* * Test zeroing of page */ bzero(CADDR1, PAGE_SIZE); if (test_page((int *)CADDR1, 0)) { /* * test of page failed */ Maxmem = target_page; badpages++; continue; } } printf("done.\n"); *(int *)CMAP1 = 0; pmap_update(); avail_end = (Maxmem << PAGE_SHIFT) - i386_round_page(sizeof(struct msgbuf)); /* * Initialize pointers to the two chunks of memory; for use * later in vm_page_startup. */ /* avail_start is initialized in pmap_bootstrap */ x = 0; if (pagesinbase > 1) { phys_avail[x++] = NBPG; /* skip first page of memory */ phys_avail[x++] = pagesinbase * NBPG; /* memory up to the ISA hole */ } phys_avail[x++] = avail_start; /* memory up to the end */ phys_avail[x++] = avail_end; phys_avail[x++] = 0; /* no more chunks */ phys_avail[x++] = 0; /* now running on new page tables, configured,and u/iom is accessible */ /* make a initial tss so microp can get interrupt stack on syscall! */ proc0.p_addr->u_pcb.pcb_tss.tss_esp0 = (int) kstack + UPAGES*NBPG; proc0.p_addr->u_pcb.pcb_tss.tss_ss0 = GSEL(GDATA_SEL, SEL_KPL) ; _gsel_tss = GSEL(GPROC0_SEL, SEL_KPL); ((struct i386tss *)gdt_segs[GPROC0_SEL].ssd_base)->tss_ioopt = (sizeof(tss))<<16; ltr(_gsel_tss); /* make a call gate to reenter kernel with */ gdp = &ldt[LSYS5CALLS_SEL].gd; x = (int) &IDTVEC(syscall); gdp->gd_looffset = x++; gdp->gd_selector = GSEL(GCODE_SEL,SEL_KPL); gdp->gd_stkcpy = 1; gdp->gd_type = SDT_SYS386CGT; gdp->gd_dpl = SEL_UPL; gdp->gd_p = 1; gdp->gd_hioffset = ((int) &IDTVEC(syscall)) >>16; /* transfer to user mode */ _ucodesel = LSEL(LUCODE_SEL, SEL_UPL); _udatasel = LSEL(LUDATA_SEL, SEL_UPL); /* setup proc 0's pcb */ bcopy(&sigcode, proc0.p_addr->u_pcb.pcb_sigc, szsigcode); proc0.p_addr->u_pcb.pcb_flags = 0; proc0.p_addr->u_pcb.pcb_ptd = IdlePTD; } int test_page(address, pattern) int *address; int pattern; { int *x; for (x = address; x < (int *)((char *)address + PAGE_SIZE); x++) { if (*x != pattern) return (1); } return(0); } /* * The registers are in the frame; the frame is in the user area of * the process in question; when the process is active, the registers * are in "the kernel stack"; when it's not, they're still there, but * things get flipped around. So, since p->p_md.md_regs is the whole address * of the register set, take its offset from the kernel stack, and * index into the user block. Don't you just *love* virtual memory? * (I'm starting to think seymour is right...) */ int ptrace_set_pc (struct proc *p, unsigned int addr) { void *regs = (char*)p->p_addr + ((char*) p->p_md.md_regs - (char*) kstack); ((struct trapframe *)regs)->tf_eip = addr; return 0; } int ptrace_single_step (struct proc *p) { void *regs = (char*)p->p_addr + ((char*) p->p_md.md_regs - (char*) kstack); ((struct trapframe *)regs)->tf_eflags |= PSL_T; return 0; } /* * Copy the registers to user-space. */ int ptrace_getregs (struct proc *p, unsigned int *addr) { int error; struct reg regs = {0}; error = fill_regs (p, ®s); if (error) return error; return copyout (®s, addr, sizeof (regs)); } int ptrace_setregs (struct proc *p, unsigned int *addr) { int error; struct reg regs = {0}; error = copyin (addr, ®s, sizeof(regs)); if (error) return error; return set_regs (p, ®s); } int fill_regs(struct proc *p, struct reg *regs) { struct trapframe *tp; void *ptr = (char*)p->p_addr + ((char*) p->p_md.md_regs - (char*) kstack); tp = ptr; regs->r_es = tp->tf_es; regs->r_ds = tp->tf_ds; regs->r_edi = tp->tf_edi; regs->r_esi = tp->tf_esi; regs->r_ebp = tp->tf_ebp; regs->r_ebx = tp->tf_ebx; regs->r_edx = tp->tf_edx; regs->r_ecx = tp->tf_ecx; regs->r_eax = tp->tf_eax; regs->r_eip = tp->tf_eip; regs->r_cs = tp->tf_cs; regs->r_eflags = tp->tf_eflags; regs->r_esp = tp->tf_esp; regs->r_ss = tp->tf_ss; return 0; } int set_regs (struct proc *p, struct reg *regs) { struct trapframe *tp; void *ptr = (char*)p->p_addr + ((char*) p->p_md.md_regs - (char*) kstack); tp = ptr; tp->tf_es = regs->r_es; tp->tf_ds = regs->r_ds; tp->tf_edi = regs->r_edi; tp->tf_esi = regs->r_esi; tp->tf_ebp = regs->r_ebp; tp->tf_ebx = regs->r_ebx; tp->tf_edx = regs->r_edx; tp->tf_ecx = regs->r_ecx; tp->tf_eax = regs->r_eax; tp->tf_eip = regs->r_eip; tp->tf_cs = regs->r_cs; tp->tf_eflags = regs->r_eflags; tp->tf_esp = regs->r_esp; tp->tf_ss = regs->r_ss; return 0; } #ifndef DDB void Debugger(const char *msg) { printf("Debugger(\"%s\") called.\n", msg); } #endif /* no DDB */ #include #define b_cylin b_resid #define dkpart(dev) (minor(dev) & 7) /* * Determine the size of the transfer, and make sure it is * within the boundaries of the partition. Adjust transfer * if needed, and signal errors or early completion. */ int bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel) { struct partition *p = lp->d_partitions + dkpart(bp->b_dev); int labelsect = lp->d_partitions[0].p_offset; int maxsz = p->p_size, sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT; /* overwriting disk label ? */ /* XXX should also protect bootstrap in first 8K */ if (bp->b_blkno + p->p_offset <= LABELSECTOR + labelsect && #if LABELSECTOR != 0 bp->b_blkno + p->p_offset + sz > LABELSECTOR + labelsect && #endif (bp->b_flags & B_READ) == 0 && wlabel == 0) { bp->b_error = EROFS; goto bad; } #if defined(DOSBBSECTOR) && defined(notyet) /* overwriting master boot record? */ if (bp->b_blkno + p->p_offset <= DOSBBSECTOR && (bp->b_flags & B_READ) == 0 && wlabel == 0) { bp->b_error = EROFS; goto bad; } #endif /* beyond partition? */ if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz) { /* if exactly at end of disk, return an EOF */ if (bp->b_blkno == maxsz) { bp->b_resid = bp->b_bcount; return(0); } /* or truncate if part of it fits */ sz = maxsz - bp->b_blkno; if (sz <= 0) { bp->b_error = EINVAL; goto bad; } bp->b_bcount = sz << DEV_BSHIFT; } /* calculate cylinder for disksort to order transfers with */ bp->b_pblkno = bp->b_blkno + p->p_offset; bp->b_cylin = bp->b_pblkno / lp->d_secpercyl; return(1); bad: bp->b_flags |= B_ERROR; return(-1); }