remove 32 bit and uses of it.
authorRon Minnich <rminnich@gmail.com>
Fri, 13 Feb 2015 23:31:52 +0000 (15:31 -0800)
committerRon Minnich <rminnich@gmail.com>
Fri, 13 Feb 2015 23:31:52 +0000 (15:31 -0800)
This is a first stab at getting out of the 32-bit architecture business.

There's lots more to do but you have to start somewhere, and I'm tired of
tags finding the wrong symbols because of these leftover bits of code
we don't compile any more.

Signed-off-by: Ron Minnich <rminnich@gmail.com>
kern/arch/x86/Kbuild
kern/arch/x86/entry32.S [deleted file]
kern/arch/x86/pmap32.c [deleted file]
kern/arch/x86/process32.c [deleted file]
kern/arch/x86/setjmp32.S [deleted file]
kern/arch/x86/smp_entry32.S [deleted file]
kern/arch/x86/support32.S [deleted file]
kern/arch/x86/trap32.c [deleted file]
kern/arch/x86/trapentry32.S [deleted file]

index b732241..ee17438 100644 (file)
@@ -4,7 +4,7 @@ obj-y                                           += colored_caches.o
 obj-y                                          += console.o
 obj-y                                          += cpuinfo.o
 obj-y                                          += devarch.o
-obj-y                                          += entry$(BITS).o
+obj-y                                          += entry64.o
 obj-y                                          += frontend.o
 obj-y                                          += init.o
 obj-y                                          += intel.o
@@ -18,17 +18,17 @@ obj-y                                               += page_alloc.o
 obj-y                                          += pci.o
 obj-y                                          += pic.o
 obj-y                                          += perfmon.o
-obj-y                                          += pmap.o pmap$(BITS).o
-obj-y                                          += process$(BITS).o
+obj-y                                          += pmap.o pmap64.o
+obj-y                                          += process64.o
 obj-y                                          += rdtsc_test.o
-obj-y                                          += setjmp$(BITS).o
-obj-y                                          += support$(BITS).o
+obj-y                                          += setjmp64.o
+obj-y                                          += support64.o
 obj-y                                          += smp.o
 obj-y                                          += smp_boot.o
-obj-y                                          += smp_entry$(BITS).o
+obj-y                                          += smp_entry64.o
 obj-y                                          += time.o
-obj-y                                          += trap.o trap$(BITS).o
-obj-y                                          += trapentry$(BITS).o
+obj-y                                          += trap.o trap64.o
+obj-y                                          += trapentry64.o
 obj-y                                          += usb.o
 
 # Virtual machine support. Optional.
diff --git a/kern/arch/x86/entry32.S b/kern/arch/x86/entry32.S
deleted file mode 100644 (file)
index 260289b..0000000
+++ /dev/null
@@ -1,114 +0,0 @@
-/* Copyright (c) 2009-13 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details. */
-
-#include <arch/mmu.h>
-#include <arch/trap.h>
-#include <kstack.h>
-
-.set CODE_SEL,0x8              # index of code seg within mygdt
-.set DATA_SEL,0x10             # index of data seg within mygdt
-
-#define MULTIBOOT_PAGE_ALIGN  (1<<0)
-#define MULTIBOOT_MEMORY_INFO (1<<1)
-#define MULTIBOOT_HEADER_MAGIC (0x1BADB002)
-#define MULTIBOOT_HEADER_FLAGS (MULTIBOOT_MEMORY_INFO | MULTIBOOT_PAGE_ALIGN)
-#define CHECKSUM (-(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS))
-
-# The kernel bootstrap (this code) is linked and loaded at physical address
-# 0x00100000 (1MB), which is the start of extended memory.  (See kernel.ld)
-
-# Flagging boottext to be text.  Check out:
-# http://sourceware.org/binutils/docs/as/Section.html
-.section .boottext, "awx"
-
-.code32
-.align 4
-multiboot_header:
-.long MULTIBOOT_HEADER_MAGIC
-.long MULTIBOOT_HEADER_FLAGS
-.long CHECKSUM
-
-.globl         _start
-_start:
-       movw    $0x1234,0x472                   # warm boot
-       # Reload all segment registers (including CS!) with flag segment selectors
-       # from our boot GDT.
-       lgdt    mygdtdesc
-       movl    $DATA_SEL, %eax
-       movw    %ax,%ds
-       movw    %ax,%es
-       movw    %ax,%ss
-       ljmp    $CODE_SEL,$newcs                # reload CS by jumping
-newcs:
-       # build page table.  need a mapping for current code at 0x00100000 and a
-       # basic kernbase mapping.  we're using the 32 bit second PT (aka, pg_dir),
-       # which covers 4MB per entry
-       movl    $boot_pdt, %edx
-       # identity map the first jumbo PTE from 0x0 -> 0x0
-       movl    $(PTE_P | PTE_W | PTE_PS), (%edx)
-       # map KERNBASE -> 0 for 1GB (1/4 of the 1024 entries)
-       movl    $256, %ecx
-       # init loop, eax at paddr 0, and edx is advanced by KERNBASE mapping slots
-       # (with 4 bytes per PTE).
-       addl    $((KERNBASE >> PTSHIFT) << 2), %edx
-       movl    $(PTE_P | PTE_W | PTE_PS), %eax
-loop:
-       movl    %eax, (%edx)
-       addl    $PTSIZE, %eax
-       addl    $4, %edx
-       decl    %ecx
-       jnz             loop
-       # load cr3 and turn on paging.  note we assume PSE support.  if we didn't
-       # have it, then our jumbo page mappings are going to fail.
-       movl    $boot_pdt, %eax
-       movl    %eax, %cr3
-       movl    %cr4, %eax
-       orl             $(CR4_PSE | CR4_PGE), %eax
-       movl    %eax, %cr4
-       movl    %cr0, %eax
-       orl             $(CR0_PE | CR0_PG | CR0_AM | CR0_WP | CR0_NE | CR0_MP), %eax  
-       andl    $(~(CR0_TS | CR0_EM | CR0_CD | CR0_NW)), %eax  
-       movl    %eax, %cr0
-       # paging is on, and our code is still running at 0x00100000 do some
-       # miscellaneous OS setup.  the coreid stuff is so we can call core_id()
-       # before smp_boot.  this is the only arch-dependent code called before then.
-       movl    $0x0, os_coreid_lookup
-       movl    $0x0, hw_coreid_lookup
-       # Clear the frame pointer register (EBP)
-       # so that once we get into debugging C code,
-       # stack backtraces will be terminated properly.
-       movl    $0x0,%ebp
-       movl    $(bootstacktop),%esp
-       # Save multiboot info
-       push    %ebx
-       movl    $0x1,num_cpus           # init global var, for now
-       call    kernel_init
-       # Should never get here, but in case we do, just spin.
-spin:  jmp     spin
-
-.section .bootdata, "aw"
-       .p2align        2               # force 4 byte alignment
-mygdt:
-       SEG_NULL                        # null seg
-       SEG(STA_X|STA_R, 0, 0xffffffff) # code seg
-       SEG(STA_W, 0, 0xffffffff)       # data seg
-mygdtdesc:
-       .word   0x17            # sizeof(mygdt) - 1
-       .long   mygdt           # address mygdt
-# boot page directory.  going to use jumbo page entries
-       .align PGSIZE
-boot_pdt:
-       .space  PGSIZE
-
-
-# From here down is linked for KERNBASE
-
-.data
-       .p2align        PGSHIFT         # force page alignment
-       .globl          bootstack
-bootstack:
-       .space          KSTKSIZE
-       .globl          bootstacktop   
-bootstacktop:
-
diff --git a/kern/arch/x86/pmap32.c b/kern/arch/x86/pmap32.c
deleted file mode 100644 (file)
index 263ecd5..0000000
+++ /dev/null
@@ -1,700 +0,0 @@
-#ifdef __SHARC__
-#pragma nosharc
-#define SINIT(x) x
-#endif
-
-/* See COPYRIGHT for copyright information. */
-#include <arch/x86.h>
-#include <arch/arch.h>
-#include <arch/mmu.h>
-#include <arch/apic.h>
-
-#include <error.h>
-#include <sys/queue.h>
-
-#include <atomic.h>
-#include <string.h>
-#include <assert.h>
-#include <pmap.h>
-#include <kclock.h>
-#include <env.h>
-#include <stdio.h>
-#include <kmalloc.h>
-#include <page_alloc.h>
-
-// These variables are set in i386_vm_init()
-pde_t* boot_pgdir;             // Virtual address of boot time page directory
-physaddr_t RO boot_cr3;                // Physical address of boot time page directory
-
-// Global descriptor table.
-//
-// The kernel and user segments are identical (except for the DPL).
-// To load the SS register, the CPL must equal the DPL.  Thus,
-// we must duplicate the segments for the user and the kernel.
-//
-segdesc_t gdt_in_c[] =
-{
-       // 0x0 - unused (always faults -- for trapping NULL far pointers)
-       SEG_NULL,
-
-       // 0x8 - kernel code segment
-       [GD_KT >> 3] = SEG(STA_X | STA_R, 0x0, 0xffffffff, 0),
-
-       // 0x10 - kernel data segment
-       [GD_KD >> 3] = SEG(STA_W, 0x0, 0xffffffff, 0),
-
-       // 0x18 - user code segment
-       [GD_UT >> 3] = SEG(STA_X | STA_R, 0x0, 0xffffffff, 3),
-
-       // 0x20 - user data segment
-       [GD_UD >> 3] = SEG(STA_W, 0x0, 0xffffffff, 3),
-
-       // 0x28 - tss, initialized in idt_init()
-       [GD_TSS >> 3] = SEG_NULL,
-
-       // 0x30 - LDT, set per-process
-       [GD_LDT >> 3] = SEG_NULL
-};
-
-/* Want gdt to be a pointer, not an array type (can replace it more easily) */
-segdesc_t *gdt = gdt_in_c;
-
-pseudodesc_t gdt_pd = {
-       sizeof(gdt_in_c) - 1, (unsigned long) gdt_in_c
-};
-
-// --------------------------------------------------------------
-// Set up initial memory mappings and turn on MMU.
-// --------------------------------------------------------------
-
-static void check_boot_pgdir(bool pse);
-
-//
-// Map [la, la+size) of linear address space to physical [pa, pa+size)
-// in the page table rooted at pgdir.  Size is a multiple of PGSIZE.
-// Use permission bits perm|PTE_P for the entries.
-//
-// To map with Jumbos, set PTE_PS in perm
-static void
-boot_map_segment(pde_t *COUNT(NPDENTRIES) pgdir, uintptr_t la, size_t size, physaddr_t pa, int perm)
-{
-       uintptr_t i;
-       pte_t *pte;
-       // la can be page unaligned, but weird things will happen
-       // unless pa has the same offset.  pa always truncates any
-       // possible offset.  will warn.  size can be weird too. 
-       if (PGOFF(la)) {
-               warn("la not page aligned in boot_map_segment!");
-               size += PGOFF(la);
-       }
-       if (perm & PTE_PS) {
-               if (JPGOFF(la) || JPGOFF(pa))
-                       panic("Tried to map a Jumbo page at an unaligned address!");
-               // need to index with i instead of la + size, in case of wrap-around
-               for (i = 0; i < size; i += JPGSIZE, la += JPGSIZE, pa += JPGSIZE) {
-                       pte = pgdir_walk(pgdir, (void*)la, 2);
-                       assert(pte);
-                       *pte = PTE_ADDR(pa) | PTE_P | perm;
-               }
-       } else {
-               for (i = 0; i < size; i += PGSIZE, la += PGSIZE, pa += PGSIZE) {
-                       pte = pgdir_walk(pgdir, (void*)la, 1);
-                       assert(pte);
-                       if (*pte & PTE_PS)
-                               // if we start using the extra flag for PAT, which we aren't,
-                               // this will warn, since PTE_PS and PTE_PAT are the same....
-                               warn("Possibly attempting to map a regular page into a Jumbo PDE");
-                       *pte = PTE_ADDR(pa) | PTE_P | perm;
-               }
-       }
-}
-
-// Set up a two-level page table:
-//    boot_pgdir is its linear (virtual) address of the root
-//    boot_cr3 is the physical adresss of the root
-// Then turn on paging.  Then effectively turn off segmentation.
-// (i.e., the segment base addrs are set to zero).
-// 
-// This function only sets up the kernel part of the address space
-// (ie. addresses >= ULIM).  The user part of the address space
-// will be setup later.
-//
-// From UWLIM to ULIM, the user is allowed to read but not write.
-// Above ULIM the user cannot read (or write). 
-void
-vm_init(void)
-{
-       pde_t* pgdir;
-       uint32_t cr0, edx;
-       size_t n;
-       bool pse;
-
-       pse = enable_pse();
-       if (pse)
-               cprintf("PSE capability detected.\n");
-
-       // we paniced earlier if we don't support PGE.  turn it on now.
-       // it's used in boot_map_segment, which covers all of the mappings that are
-       // the same for all address spaces.  and also for the VPT mapping below.
-       lcr4(rcr4() | CR4_PGE);
-
-       // set up mtrr's for core0.  other cores will do the same later
-       setup_default_mtrrs(0);
-
-       /*
-        * PSE status: 
-        * - can walk and set up boot_map_segments with jumbos but can't
-        *   insert yet.  need to look at the page_dir and friends.
-        * - anything related to a single struct page still can't handle 
-        *   jumbos.  will need to think about and adjust Page functions
-        * - do we want to store info like this in the struct page?  or just check
-        *   by walking the PTE
-        * - when we alloc a page, and we want it to be 4MB, we'll need
-        *   to have contiguous memory, etc
-        * - there's a difference between having 4MB page table entries
-        *   and having 4MB Page tracking structs.  changing the latter will
-        *   break a lot of things
-        * - showmapping and friends work on a 4KB granularity, but map to the
-        *   correct entries
-        * - need to not insert / boot_map a single page into an area that is 
-        *   already holding a jumbo page.  will need to break the jumbo up so that
-        *   we can then insert the lone page.  currently warns.
-        * - some inherent issues with the pgdir_walks returning a PTE, and we
-        *   don't know whether it is a jumbo (PDE) or a regular PTE.
-        */
-
-       //////////////////////////////////////////////////////////////////////
-       // create initial page directory.
-       pgdir = kpage_zalloc_addr();
-       assert(pgdir);
-       boot_pgdir = pgdir;
-       boot_cr3 = PADDR(pgdir);
-       // helpful if you want to manually walk with kvm / bochs
-       //printk("pgdir va = %p, pgdir pa = %p\n\n", pgdir, PADDR(pgdir));
-
-       //////////////////////////////////////////////////////////////////////
-       // Recursively insert PD in itself as a page table, to form
-       // a virtual page table at virtual address VPT.
-       // (For now, you don't have understand the greater purpose of the
-       // following two lines.  Unless you are eagle-eyed, in which case you
-       // should already know.)
-
-       // Permissions: kernel RW, user NONE, Global Page
-       pgdir[PDX(VPT)] = PADDR(pgdir) | PTE_W | PTE_P | PTE_G;
-
-       // same for UVPT
-       // Permissions: kernel R, user R, Global Page
-       pgdir[PDX(UVPT)] = PADDR(pgdir) | PTE_U | PTE_P | PTE_G;
-
-       //////////////////////////////////////////////////////////////////////
-       // Map all of physical memory at KERNBASE. 
-       // Ie.  the VA range [KERNBASE, 2^32) should map to
-       //      the PA range [0, 2^32 - KERNBASE)
-       // We might not have 2^32 - KERNBASE bytes of physical memory, but
-       // we just set up the mapping anyway.
-       // Permissions: kernel RW, user NONE
-       // Your code goes here: 
-       
-       // this maps all of the possible phys memory
-       // note the use of unsigned underflow to get size = 0x40000000
-       //boot_map_segment(pgdir, KERNBASE, -KERNBASE, 0, PTE_W);
-       // but this only maps what is available, and saves memory.  every 4MB of
-       // mapped memory requires a 2nd level page: 2^10 entries, each covering 2^12
-       // need to modify tests below to account for this
-       if (pse) {
-               // map the first 4MB as regular entries, to support different MTRRs
-               boot_map_segment(pgdir, KERNBASE, JPGSIZE, 0, PTE_W | PTE_G);
-               boot_map_segment(pgdir, KERNBASE + JPGSIZE, max_paddr - JPGSIZE, JPGSIZE,
-                                PTE_W | PTE_G | PTE_PS);
-       } else
-               boot_map_segment(pgdir, KERNBASE, max_paddr, 0, PTE_W | PTE_G);
-
-       // APIC mapping: using PAT (but not *the* PAT flag) to make these type UC
-       // IOAPIC
-       boot_map_segment(pgdir, IOAPIC_BASE, APIC_SIZE, IOAPIC_PBASE,
-                        PTE_PCD | PTE_PWT | PTE_W | PTE_G);
-       // Local APIC
-       boot_map_segment(pgdir, LAPIC_BASE, APIC_SIZE, LAPIC_PBASE,
-                        PTE_PCD | PTE_PWT | PTE_W | PTE_G);
-
-       // Check that the initial page directory has been set up correctly.
-       check_boot_pgdir(pse);
-
-       //////////////////////////////////////////////////////////////////////
-       // On x86, segmentation maps a VA to a LA (linear addr) and
-       // paging maps the LA to a PA.  I.e. VA => LA => PA.  If paging is
-       // turned off the LA is used as the PA.  Note: there is no way to
-       // turn off segmentation.  The closest thing is to set the base
-       // address to 0, so the VA => LA mapping is the identity.
-
-       // Current mapping: VA KERNBASE+x => PA x.
-       //     (segmentation base=-KERNBASE and paging is off)
-
-       // From here on down we must maintain this VA KERNBASE + x => PA x
-       // mapping, even though we are turning on paging and reconfiguring
-       // segmentation.
-
-       // Map VA 0:4MB same as VA KERNBASE, i.e. to PA 0:4MB.
-       // (Limits our kernel to <4MB)
-       /* They mean linear address 0:4MB, and the kernel < 4MB is only until 
-        * segmentation is turned off.
-        * once we turn on paging, segmentation is still on, so references to
-        * KERNBASE+x will get mapped to linear address x, which we need to make 
-        * sure can map to phys addr x, until we can turn off segmentation and
-        * KERNBASE+x maps to LA KERNBASE+x, which maps to PA x, via paging
-        */
-       pgdir[0] = pgdir[PDX(KERNBASE)];
-
-       // Install page table.
-       lcr3(boot_cr3);
-
-       // Turn on paging.
-       cr0 = rcr0();
-       // CD and NW should already be on, but just in case these turn on caching
-       cr0 |= CR0_PE|CR0_PG|CR0_AM|CR0_WP|CR0_NE|CR0_MP;
-       cr0 &= ~(CR0_TS|CR0_EM|CR0_CD|CR0_NW);
-       lcr0(cr0);
-
-       // Current mapping: KERNBASE+x => x => x.
-       // (x < 4MB so uses paging pgdir[0])
-
-       // Reload all segment registers.
-       asm volatile("lgdt gdt_pd");
-       asm volatile("movw %%ax,%%gs" :: "a" (GD_UD|3));
-       asm volatile("movw %%ax,%%fs" :: "a" (GD_UD|3));
-       asm volatile("movw %%ax,%%es" :: "a" (GD_KD));
-       asm volatile("movw %%ax,%%ds" :: "a" (GD_KD));
-       asm volatile("movw %%ax,%%ss" :: "a" (GD_KD));
-       asm volatile("ljmp %0,$1f\n 1:\n" :: "i" (GD_KT));  // reload cs
-       asm volatile("lldt %%ax" :: "a" (0));
-
-       // Final mapping: KERNBASE+x => KERNBASE+x => x.
-
-       // This mapping was only used after paging was turned on but
-       // before the segment registers were reloaded.
-       pgdir[0] = 0;
-
-       // Flush the TLB for good measure, to kill the pgdir[0] mapping.
-       tlb_flush_global();
-}
-
-void x86_cleanup_bootmem(void)
-{
-       #define trampoline_pg 0x00001000UL
-       // Remove the mapping of the page used by the trampoline
-       page_remove(boot_pgdir, (void*)trampoline_pg);
-       // Remove the page table used for that mapping
-       pagetable_remove(boot_pgdir, (void*)trampoline_pg);
-}
-
-//
-// Checks that the kernel part of virtual address space
-// has been setup roughly correctly(by i386_vm_init()).
-//
-// This function doesn't test every corner case,
-// in fact it doesn't test the permission bits at all,
-// but it is a pretty good sanity check. 
-//
-static physaddr_t check_va2pa(pde_t *COUNT(NPDENTRIES) pgdir, uintptr_t va);
-
-static void
-check_boot_pgdir(bool pse)
-{
-       uint32_t i, n;
-       pde_t *pgdir, pte;
-
-       pgdir = boot_pgdir;
-
-       // check phys mem
-       //for (i = 0; KERNBASE + i != 0; i += PGSIZE)
-       // adjusted check to account for only mapping avail mem
-       if (pse)
-               for (i = 0; i < max_paddr; i += JPGSIZE)
-                       assert(check_va2pa(pgdir, KERNBASE + i) == i);
-       else
-               for (i = 0; i < max_paddr; i += PGSIZE)
-                       assert(check_va2pa(pgdir, KERNBASE + i) == i);
-
-       // check for zero/non-zero in PDEs
-       for (i = 0; i < NPDENTRIES; i++) {
-               switch (i) {
-               case PDX(VPT):
-               case PDX(UVPT):
-               case PDX(LAPIC_BASE): // LAPIC mapping.  TODO: remove when MTRRs are up
-                       assert(pgdir[i]);
-                       break;
-               default:
-                       //if (i >= PDX(KERNBASE))
-                       // adjusted check to account for only mapping avail mem
-                       // and you can't KADDR maxpa (just above legal range)
-                       // max_paddr can be up to maxpa, so assume the worst
-                       if (i >= PDX(KERNBASE) && i <= PDX(KADDR(max_paddr-1)))
-                               assert(pgdir[i]);
-                       else
-                               assert(pgdir[i] == 0);
-                       break;
-               }
-       }
-
-       /* check permissions
-        * user read-only.  check for user and write, should be only user
-        * eagle-eyed viewers should be able to explain the extra cases.
-        * for the mongoose-eyed, remember that weird shit happens when you loop
-        * through UVPT.  Specifically, you can't loop once, then look at a jumbo
-        * page that is kernel only.  That's the end of the page table for you, so
-        * having a U on the entry doesn't make sense.  Thus we check for a jumbo
-        * page, and special case it.  This will happen at 0xbf701000.  Why is this
-        * magical?  Get your eagle glasses and figure it out. */
-       for (i = UWLIM; i < ULIM; i+=PGSIZE) {
-               pte = get_va_perms(pgdir, (void*SAFE)TC(i));
-               if (pte & PTE_P) {
-                       if (i == UVPT+(VPT >> 10))
-                               continue;
-                       if (*pgdir_walk(pgdir, (void*SAFE)TC(i), 0) & PTE_PS) {
-                               assert((pte & PTE_U) != PTE_U);
-                               assert((pte & PTE_W) != PTE_W);
-                       } else {
-                               assert((pte & PTE_U) == PTE_U);
-                               assert((pte & PTE_W) != PTE_W);
-                       }
-               }
-       }
-       // kernel read-write.
-       for (i = ULIM; i <= KERNBASE + max_paddr - PGSIZE; i+=PGSIZE) {
-               pte = get_va_perms(pgdir, (void*SAFE)TC(i));
-               if ((pte & PTE_P) && (i != VPT+(UVPT>>10))) {
-                       assert((pte & PTE_U) != PTE_U);
-                       assert((pte & PTE_W) == PTE_W);
-               }
-       }
-       // special mappings
-       pte = get_va_perms(pgdir, (void*SAFE)TC(UVPT+(VPT>>10)));
-       assert((pte & PTE_U) != PTE_U);
-       assert((pte & PTE_W) != PTE_W);
-
-       // note this means the kernel cannot directly manipulate this virtual address
-       // convince yourself this isn't a big deal, eagle-eyes!
-       pte = get_va_perms(pgdir, (void*SAFE)TC(VPT+(UVPT>>10)));
-       assert((pte & PTE_U) != PTE_U);
-       assert((pte & PTE_W) != PTE_W);
-
-       cprintf("check_boot_pgdir() succeeded!\n");
-}
-
-// This function returns the physical address of the page containing 'va',
-// defined by the page directory 'pgdir'.  The hardware normally performs
-// this functionality for us!  We define our own version to help check
-// the check_boot_pgdir() function; it shouldn't be used elsewhere.
-
-static physaddr_t
-check_va2pa(pde_t *COUNT(NPDENTRIES) _pgdir, uintptr_t va)
-{
-       pte_t *COUNT(NPTENTRIES) p;
-       pde_t *COUNT(1) pgdir;
-
-       pgdir = &_pgdir[PDX(va)];
-       if (!(*pgdir & PTE_P))
-               return ~0;
-       if (*pgdir & PTE_PS)
-               return PTE_ADDR(*pgdir);
-       p = (pte_t*COUNT(NPTENTRIES)) KADDR(PTE_ADDR(*pgdir));
-       if (!(p[PTX(va)] & PTE_P))
-               return ~0;
-       return PTE_ADDR(p[PTX(va)]);
-}
-
-/* 
- * Remove the second level page table associated with virtual address va.
- * Will 0 out the PDE for that page table.
- * Panics if the page table has any present entries.
- * This should be called rarely and with good cause.
- * Currently errors if the PDE is jumbo or not present.
- */
-error_t        pagetable_remove(pde_t *pgdir, void *va)
-{
-       pde_t* the_pde = &pgdir[PDX(va)];
-
-       if (!(*the_pde & PTE_P) || (*the_pde & PTE_PS))
-               return -EFAULT;
-       pte_t* page_table = (pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(*the_pde));
-       for (int i = 0; i < NPTENTRIES; i++) 
-               if (page_table[i] & PTE_P)
-                       panic("Page table not empty during attempted removal!");
-       *the_pde = 0;
-       page_decref(pa2page(PADDR(page_table)));
-       return 0;
-}
-
-// Given 'pgdir', a pointer to a page directory, pgdir_walk returns
-// a pointer to the page table entry (PTE) for linear address 'va'.
-// This requires walking the two-level page table structure.
-//
-// If the relevant page table doesn't exist in the page directory, then:
-//    - If create == 0, pgdir_walk returns NULL.
-//    - Otherwise, pgdir_walk tries to allocate a new page table
-//     with page_alloc.  If this fails, pgdir_walk returns NULL.
-//    - Otherwise, pgdir_walk returns a pointer into the new page table.
-//
-// Hint: you can turn a Page * into the physical address of the
-// page it refers to with page2pa() from kern/pmap.h.
-//
-// Supports returning jumbo (4MB PSE) PTEs.  To create with a jumbo, pass in 2.
-pte_t*
-pgdir_walk(pde_t *pgdir, const void *SNT va, int create)
-{
-       pde_t* the_pde = &pgdir[PDX(va)];
-       page_t *new_table;
-
-       if (*the_pde & PTE_P) {
-               if (*the_pde & PTE_PS)
-                       return (pte_t*)the_pde;
-               return &((pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(*the_pde)))[PTX(va)];
-       }
-       if (!create)
-               return NULL;
-       if (create == 2) {
-               if (JPGOFF(va))
-                       panic("Attempting to find a Jumbo PTE at an unaligned VA!");
-               *the_pde = PTE_PS | PTE_P;
-               return (pte_t*)the_pde;
-       }
-       if (kpage_alloc(&new_table))
-               return NULL;
-       memset(page2kva(new_table), 0, PGSIZE);
-       /* storing our ref to new_table in the PTE */
-       *the_pde = (pde_t)page2pa(new_table) | PTE_P | PTE_W | PTE_U;
-       return &((pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(*the_pde)))[PTX(va)];
-}
-
-/* Returns the effective permissions for PTE_U, PTE_W, and PTE_P on a given
- * virtual address.  Note we need to consider the composition of every PTE in
- * the page table walk. */
-int get_va_perms(pde_t *pgdir, const void *SNT va)
-{
-       pde_t the_pde = pgdir[PDX(va)];
-       pte_t the_pte;
-
-       if (!(the_pde & PTE_P))
-               return 0;
-       if (the_pde & PTE_PS)
-               return the_pde & (PTE_U | PTE_W | PTE_P);
-       the_pte = ((pde_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(the_pde)))[PTX(va)];
-       if (!(the_pte & PTE_P))
-               return 0;
-       return the_pte & the_pde & (PTE_U | PTE_W | PTE_P);
-}
-
-void
-page_check(void)
-{
-       page_t *pp, *pp0, *pp1, *pp2;
-       page_list_t fl[1024];
-       pte_t *ptep;
-
-       // should be able to allocate three pages
-       pp0 = pp1 = pp2 = 0;
-       assert(kpage_alloc(&pp0) == 0);
-       assert(kpage_alloc(&pp1) == 0);
-       assert(kpage_alloc(&pp2) == 0);
-
-       assert(pp0);
-       assert(pp1 && pp1 != pp0);
-       assert(pp2 && pp2 != pp1 && pp2 != pp0);
-
-       // temporarily steal the rest of the free pages
-       for(int i=0; i<llc_cache->num_colors; i++) {
-               fl[i] = colored_page_free_list[i];
-               LIST_INIT(&colored_page_free_list[i]);
-       }
-
-       // should be no free memory
-       assert(kpage_alloc(&pp) == -ENOMEM);
-
-       // Fill pp1 with bogus data and check for invalid tlb entries
-       memset(page2kva(pp1), 0xFFFFFFFF, PGSIZE);
-
-       // there is no page allocated at address 0
-       assert(page_lookup(boot_pgdir, (void *) 0x0, &ptep) == NULL);
-
-       // there is no free memory, so we can't allocate a page table 
-       assert(page_insert(boot_pgdir, pp1, 0x0, 0) < 0);
-
-       // free pp0 and try again: pp0 should be used for page table
-       page_decref(pp0);
-       assert(page_insert(boot_pgdir, pp1, 0x0, 0) == 0);
-       tlb_invalidate(boot_pgdir, 0x0);
-       // DEP Should have shot down invalid TLB entry - let's check
-       { TRUSTEDBLOCK
-         int *x = 0x0;
-         assert(*x == 0xFFFFFFFF);
-       }
-       assert(PTE_ADDR(boot_pgdir[0]) == page2pa(pp0));
-       assert(check_va2pa(boot_pgdir, 0x0) == page2pa(pp1));
-       assert(kref_refcnt(&pp1->pg_kref) == 2);
-       assert(kref_refcnt(&pp0->pg_kref) == 1);
-
-       // should be able to map pp2 at PGSIZE because pp0 is already allocated for page table
-       assert(page_insert(boot_pgdir, pp2, (void*SNT) PGSIZE, 0) == 0);
-       assert(check_va2pa(boot_pgdir, PGSIZE) == page2pa(pp2));
-       assert(kref_refcnt(&pp2->pg_kref) == 2);
-
-       // Make sure that pgdir_walk returns a pointer to the pte and
-       // not the table or some other garbage
-       {
-         pte_t *p = (pte_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(boot_pgdir[PDX(PGSIZE)]));
-         assert(pgdir_walk(boot_pgdir, (void *SNT)PGSIZE, 0) == &p[PTX(PGSIZE)]);
-       }
-
-       // should be no free memory
-       assert(kpage_alloc(&pp) == -ENOMEM);
-
-       // should be able to map pp2 at PGSIZE because it's already there
-       assert(page_insert(boot_pgdir, pp2, (void*SNT) PGSIZE, PTE_U) == 0);
-       assert(check_va2pa(boot_pgdir, PGSIZE) == page2pa(pp2));
-       assert(kref_refcnt(&pp2->pg_kref) == 2);
-
-       // Make sure that we actually changed the permission on pp2 when we re-mapped it
-       {
-         pte_t *p = pgdir_walk(boot_pgdir, (void*SNT)PGSIZE, 0);
-         assert(((*p) & PTE_U) == PTE_U);
-       }
-
-       // pp2 should NOT be on the free list
-       // could happen if ref counts are handled sloppily in page_insert
-       assert(kpage_alloc(&pp) == -ENOMEM);
-
-       // should not be able to map at PTSIZE because need free page for page table
-       assert(page_insert(boot_pgdir, pp0, (void*SNT) PTSIZE, 0) < 0);
-
-       // insert pp1 at PGSIZE (replacing pp2)
-       assert(page_insert(boot_pgdir, pp1, (void*SNT) PGSIZE, 0) == 0);
-
-       // should have pp1 at both 0 and PGSIZE, pp2 nowhere, ...
-       assert(check_va2pa(boot_pgdir, 0) == page2pa(pp1));
-       assert(check_va2pa(boot_pgdir, PGSIZE) == page2pa(pp1));
-       // ... and ref counts should reflect this
-       assert(kref_refcnt(&pp1->pg_kref) == 3);
-       assert(kref_refcnt(&pp2->pg_kref) == 1);
-
-       // pp2 should be returned by page_alloc
-       page_decref(pp2);       /* should free it */
-       assert(kpage_alloc(&pp) == 0 && pp == pp2);
-
-       // unmapping pp1 at 0 should keep pp1 at PGSIZE
-       page_remove(boot_pgdir, 0x0);
-       assert(check_va2pa(boot_pgdir, 0x0) == ~0);
-       assert(check_va2pa(boot_pgdir, PGSIZE) == page2pa(pp1));
-       assert(kref_refcnt(&pp1->pg_kref) == 2);
-       assert(kref_refcnt(&pp2->pg_kref) == 1);
-
-       // unmapping pp1 at PGSIZE should free it
-       page_remove(boot_pgdir, (void*SNT) PGSIZE);
-       assert(check_va2pa(boot_pgdir, 0x0) == ~0);
-       assert(check_va2pa(boot_pgdir, PGSIZE) == ~0);
-       assert(kref_refcnt(&pp1->pg_kref) == 1);
-       assert(kref_refcnt(&pp2->pg_kref) == 1);
-       page_decref(pp1);
-
-       // so it should be returned by page_alloc
-       assert(kpage_alloc(&pp) == 0 && pp == pp1);
-
-       // should be no free memory
-       assert(kpage_alloc(&pp) == -ENOMEM);
-
-       // forcibly take pp0 back
-       assert(PTE_ADDR(boot_pgdir[0]) == page2pa(pp0));
-       boot_pgdir[0] = 0;
-       assert(kref_refcnt(&pp0->pg_kref) == 1);
-
-       // Catch invalid pointer addition in pgdir_walk - i.e. pgdir + PDX(va)
-       {
-         // Give back pp0 for a bit
-         page_decref(pp0);
-
-         void *SNT va = (void *SNT)((PGSIZE * NPDENTRIES) + PGSIZE);
-         pte_t *p2 = pgdir_walk(boot_pgdir, va, 1);
-         pte_t *p = (pte_t*COUNT(NPTENTRIES))KADDR(PTE_ADDR(boot_pgdir[PDX(va)]));
-         assert(p2 == &p[PTX(va)]);
-
-         // Clean up again
-         boot_pgdir[PDX(va)] = 0;
-       }
-
-       // give free list back
-       for(int i=0; i<llc_cache->num_colors; i++)
-               colored_page_free_list[i] = fl[i];
-
-       // free the pages we took
-       page_decref(pp0);
-       page_decref(pp1);
-       page_decref(pp2);
-       assert(!kref_refcnt(&pp0->pg_kref));
-       assert(!kref_refcnt(&pp1->pg_kref));
-       assert(!kref_refcnt(&pp2->pg_kref));
-
-       cprintf("page_check() succeeded!\n");
-}
-
-/* Walks len bytes from start, executing 'callback' on every PTE, passing it a
- * specific VA and whatever arg is passed in.  Note, this cannot handle jumbo
- * pages. */
-int env_user_mem_walk(env_t* e, void* start, size_t len,
-                      mem_walk_callback_t callback, void* arg)
-{
-       pte_t *pt;
-       uint32_t pdeno, pteno;
-       physaddr_t pa;
-
-       assert((uintptr_t)start % PGSIZE == 0 && len % PGSIZE == 0);
-       uintptr_t end = (uintptr_t)start+len;
-       uint32_t pdeno_start = PDX(start);
-       uint32_t pdeno_end = PDX(ROUNDUP(end,PTSIZE));
-       /* concerned about overflow.  this should catch it for now, given the above
-        * assert. */
-       assert((len == 0) || (pdeno_start < pdeno_end));
-
-       for (pdeno = pdeno_start; pdeno < pdeno_end; pdeno++) {
-               if (!(e->env_pgdir[pdeno] & PTE_P))
-                       continue;
-               /* find the pa and a pointer to the page table */
-               pa = PTE_ADDR(e->env_pgdir[pdeno]);
-               pt = (pte_t*COUNT(NPTENTRIES)) KADDR(pa);
-               /* figure out where we start and end within the page table */
-               uint32_t pteno_start = (pdeno == pdeno_start ? PTX(start) : 0);
-               uint32_t pteno_end = (pdeno == pdeno_end - 1 && PTX(end) != 0 ?
-                                     PTX(end) : NPTENTRIES );
-               int ret;
-               for (pteno = pteno_start; pteno < pteno_end; pteno++) {
-                       if((ret = callback(e, &pt[pteno], PGADDR(pdeno, pteno, 0), arg)))
-                               return ret;
-               }
-       }
-       return 0;
-}
-
-/* Frees (decrefs) all pages of the process's page table, including the page
- * directory.  Does not free the memory that is actually mapped. */
-void env_pagetable_free(env_t* e)
-{
-       static_assert(UVPT % PTSIZE == 0);
-       assert(e->env_cr3 != rcr3());
-       for(uint32_t pdeno = 0; pdeno < PDX(UVPT); pdeno++)
-       {
-               // only look at mapped page tables
-               if (!(e->env_pgdir[pdeno] & PTE_P))
-                       continue;
-
-               // find the pa and va of the page table
-               physaddr_t pa = PTE_ADDR(e->env_pgdir[pdeno]);
-
-               // free the page table itself
-               e->env_pgdir[pdeno] = 0;
-               page_decref(pa2page(pa));
-       }
-
-       // free the page directory
-       physaddr_t pa = e->env_cr3;
-       e->env_cr3 = 0;
-       page_decref(pa2page(pa));
-       tlbflush();
-}
diff --git a/kern/arch/x86/process32.c b/kern/arch/x86/process32.c
deleted file mode 100644 (file)
index de969c4..0000000
+++ /dev/null
@@ -1,150 +0,0 @@
-#include <arch/arch.h>
-#include <trap.h>
-#include <process.h>
-#include <pmap.h>
-#include <smp.h>
-
-#include <string.h>
-#include <assert.h>
-#include <stdio.h>
-
-/* TODO: handle user and kernel contexts */
-void proc_pop_ctx(struct user_context *ctx)
-{
-       struct hw_trapframe *tf = &ctx->tf.hw_tf;
-       assert(ctx->type == ROS_HW_CTX);
-
-       /* Bug with this whole idea (TODO: (TLSV))*/
-       /* Load the LDT for this process.  Slightly ghetto doing it here. */
-       /* copy-in and check the LDT location.  the segmentation hardware writes the
-        * accessed bit, so we want the memory to be in the user-writeable area. */
-       segdesc_t *ldt = current->procdata->ldt;
-       ldt = (segdesc_t*)MIN((uintptr_t)ldt, UWLIM - LDT_SIZE);
-       /* Only set up the ldt if a pointer to the ldt actually exists */
-       if(ldt != NULL) {
-               segdesc_t *my_gdt = per_cpu_info[core_id()].gdt;
-               segdesc_t ldt_temp = SEG_SYS(STS_LDT, (uint32_t)ldt, LDT_SIZE, 3);
-               my_gdt[GD_LDT >> 3] = ldt_temp;
-               asm volatile("lldt %%ax" :: "a"(GD_LDT));
-       }
-
-       /* In case they are enabled elsewhere.  We can't take an interrupt in these
-        * routines, due to how they play with the kernel stack pointer. */
-       disable_irq();
-       /*
-        * If the process entered the kernel via sysenter, we need to leave via
-        * sysexit.  sysenter trapframes have 0 for a CS, which is pushed in
-        * sysenter_handler.
-        */
-       if(tf->tf_cs) {
-               /*
-                * Restores the register values in the Trapframe with the 'iret'
-                * instruction.  This exits the kernel and starts executing some
-                * environment's code.  This function does not return.
-                */
-               asm volatile ("movl %0,%%esp;           "
-                             "popal;                   "
-                             "popl %%gs;               "
-                             "popl %%fs;               "
-                             "popl %%es;               "
-                             "popl %%ds;               "
-                             "addl $0x8,%%esp;         "
-                             "iret                     "
-                             : : "g" (tf) : "memory");
-               panic("iret failed");  /* mostly to placate the compiler */
-       } else {
-               /* Return path of sysexit.  See sysenter_handler's asm for details.
-                * One difference is that this tf could be somewhere other than a stack
-                * (like in a struct proc).  We need to make sure esp is valid once
-                * interrupts are turned on (which would happen on popfl normally), so
-                * we need to save and restore a decent esp (the current one).  We need
-                * a place to save it that is accessible after we change the stack
-                * pointer to the tf *and* that is specific to this core/instance of
-                * sysexit.  The simplest and nicest is to use the tf_esp, which we
-                * can just pop.  Incidentally, the value in oesp would work too.
-                * To prevent popfl from turning interrupts on, we hack the tf's eflags
-                * so that we have a chance to change esp to a good value before
-                * interrupts are enabled.  The other option would be to throw away the
-                * eflags, but that's less desirable. */
-               tf->tf_eflags &= !FL_IF;
-               tf->tf_esp = read_sp();
-               asm volatile ("movl %0,%%esp;           "
-                             "popal;                   "
-                             "popl %%gs;               "
-                             "popl %%fs;               "
-                             "popl %%es;               "
-                             "popl %%ds;               "
-                             "addl $0x10,%%esp;        "
-                             "popfl;                   "
-                             "movl %%ebp,%%ecx;        "
-                             "popl %%esp;              "
-                             "sti;                     "
-                             "sysexit                  "
-                             : : "g" (tf) : "memory");
-               panic("sysexit failed");  /* mostly to placate your mom */
-       }
-}
-
-/* TODO: consider using a SW context */
-void proc_init_ctx(struct user_context *ctx, uint32_t vcoreid, uintptr_t entryp,
-                   uintptr_t stack_top, uintptr_t tls_desc)
-{
-       struct hw_trapframe *tf = &ctx->tf.hw_tf;
-       ctx->type = ROS_HW_CTX;
-
-       memset(tf,0,sizeof(*tf));
-
-       /* Set up appropriate initial values for the segment registers.
-        * GD_UD is the user data segment selector in the GDT, and
-        * GD_UT is the user text segment selector (see inc/memlayout.h).
-        * The low 2 bits of each segment register contains the
-        * Requestor Privilege Level (RPL); 3 means user mode. */
-       tf->tf_ds = GD_UD | 3;
-       tf->tf_es = GD_UD | 3;
-       tf->tf_ss = GD_UD | 3;
-       tf->tf_esp = stack_top-64;
-       tf->tf_cs = GD_UT | 3;
-       /* set the env's EFLAGSs to have interrupts enabled */
-       tf->tf_eflags |= 0x00000200; // bit 9 is the interrupts-enabled
-
-       tf->tf_eip = entryp;
-
-       /* Coupled closely with user's entry.S.  id is the vcoreid, which entry.S
-        * uses to determine what to do.  vcoreid == 0 is the main core/context. */
-       tf->tf_regs.reg_eax = vcoreid;
-       /* Note we don't pass the tlsdesc.  32 bit TLS is pretty jacked up, so we
-        * let userspace deal with it. TODO: (TLSV) */
-}
-
-/* TODO: handle both HW and SW contexts */
-void proc_secure_ctx(struct user_context *ctx)
-{
-       struct hw_trapframe *tf = &ctx->tf.hw_tf;
-       ctx->type = ROS_HW_CTX;
-       /* we normally don't need to set the non-CS regs, but they could be
-        * gibberish and cause a GPF.  gs can still be gibberish, but we don't
-        * necessarily know what it ought to be (we could check, but that's a pain).
-        * the code protecting the kernel from TLS related things ought to be able
-        * to handle GPFs on popping gs. TODO: (TLSV) */
-       tf->tf_ds = GD_UD | 3;
-       tf->tf_es = GD_UD | 3;
-       tf->tf_fs = 0;
-       //tf->tf_gs = whatevs.  ignoring this.
-       tf->tf_ss = GD_UD | 3;
-       tf->tf_cs ? GD_UT | 3 : 0; // can be 0 for sysenter TFs.
-       tf->tf_eflags |= 0x00000200; // bit 9 is the interrupts-enabled
-}
-
-/* Called when we are currently running an address space on our core and want to
- * abandon it.  We need a known good pgdir before releasing the old one.  We
- * decref, since current no longer tracks the proc (and current no longer
- * protects the cr3).  We also need to clear out the TLS registers (before
- * unmapping the address space!) */
-void __abandon_core(void)
-{
-       struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
-       asm volatile ("movw %%ax,%%gs; lldt %%ax" :: "a"(0));
-       lcr3(boot_cr3);
-       proc_decref(pcpui->cur_proc);
-       pcpui->cur_proc = 0;
-}
diff --git a/kern/arch/x86/setjmp32.S b/kern/arch/x86/setjmp32.S
deleted file mode 100644 (file)
index a9b4e87..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-# Kernel implementations for slim setjmp/longjmp.
-#
-# int setjmp(struct jmpbuf *env);
-# void longjmp(struct jmpbuf *env, int val);
-
-# The jmpbuf struct is defined as below:
-# struct jmpbuf {
-#      uintptr_t retaddr; // return address
-#      uintreg_t esp;     // post-return esp
-#      uintreg_t ebp;
-# };
-
-.text
-.align 4
-.globl slim_setjmp
-.type slim_setjmp, @function
-slim_setjmp:
-       movl 4(%esp),%edx  # Grab a reference to the jmpbuf passed in
-       xorl %eax,%eax     # Zero out the return value for our first return
-       popl %ecx          # Temporarily grab the return address and adjust %rsp
-       movl %ecx,(%edx)   # Save the return address
-       movl %esp,4(%edx)  # The adjusted %esp is the post-return %esp (see longjmp)
-       movl %ebp,8(%edx)
-       pushl %ecx         # Restore stuff to make the call/return stack happy
-       ret
-.size slim_setjmp,.-slim_setjmp
-.text
-.align 4
-.globl longjmp
-.type longjmp, @function
-longjmp:
-       movl 4(%esp),%edx  # Grab a reference to the jmpbuf passed in
-       movl 8(%esp),%eax  # Set the return value to val (32-bit int)
-       movl 8(%edx),%ebp
-       movl 4(%edx),%esp  # Set the post-return %rsp
-       jmp *(%edx)        # Jump back to setjmp callsite (no ret necessary)
-.size longjmp,.-longjmp
diff --git a/kern/arch/x86/smp_entry32.S b/kern/arch/x86/smp_entry32.S
deleted file mode 100644 (file)
index bdf5168..0000000
+++ /dev/null
@@ -1,113 +0,0 @@
-#include <arch/mmu.h>
-#include <ros/memlayout.h>
-#include <arch/trap.h>
-
-#define        RELOC(x) ((x) - KERNBASE)
-#define        CPUID_PSE_SUPPORT       0x00000008
-
-.globl                 smp_entry
-smp_entry:             .code16
-       cli
-       cld
-       lock incw       smp_semaphore - smp_entry + 0x1000  # announce our presence
-spin_start:                                            # grab lock in real mode
-       movw    $1, %ax
-       xchgw   %ax, smp_boot_lock - smp_entry + 0x1000
-       test    %ax, %ax
-       jne             spin_start
-
-       # Set up rudimentary segmentation
-       xorw    %ax, %ax                        # Segment number zero
-       movw    %ax, %ds                        # -> Data Segment
-       movw    %ax, %es                        # -> Extra Segment
-       movw    %ax, %ss                        # -> Stack Segment
-       # Would like to patch all of these 0x1000's at trampoline relocation time
-       # There's three of them, so we could patch the trampoline code when we load,
-       # once we're sure the entry code will not change anymore
-       # Note that this GDT is straight through, with no KERNBASE translation
-       lgdt    gdtdesc - smp_entry + 0x1000
-
-       # Turn on protected mode
-       movl    %cr0, %eax
-       orl             $CR0_PE, %eax
-       movl    %eax, %cr0
-       ljmp    $GD_KT, $(protcseg - smp_entry + 0x1000)
-       
-protcseg:      .code32
-       # Set up the protected-mode data segment registers
-       movw    $GD_KD, %ax             # Kernel segment selector
-       movw    %ax, %ds                # -> DS: Data Segment
-       movw    %ax, %es                # -> ES: Extra Segment
-       movw    %ax, %ss                # -> SS: Stack Segment
-       movw    %ax, %fs                # -> FS
-       movw    %ax, %gs                # -> GS
-
-       # Turn on Paging
-       movl    RELOC(boot_cr3), %eax
-       movl    %eax, %cr3
-       # Enable PSE, if available
-       movl    $1, %eax
-       cpuid
-       test    $CPUID_PSE_SUPPORT, %edx
-       jz              past_pse
-       movl    %cr4, %eax
-       orl             $CR4_PSE, %eax
-       movl    %eax, %cr4
-past_pse:
-       # Turn on PGE, no matter what.  Ghetto, but we panic if it's not supported.
-       movl    %cr4, %eax
-       orl             $CR4_PGE, %eax
-       movl    %eax, %cr4
-       movl    %cr0, %eax      
-       # These cr0 flags are the same as in pmap.c.  Keep them in sync
-       orl             $(CR0_PE|CR0_PG|CR0_AM|CR0_WP|CR0_NE|CR0_MP), %eax  
-       andl    $(~(CR0_TS|CR0_EM|CR0_CD|CR0_NW)), %eax  
-       movl    %eax, %cr0
-
-       # Reload Segments, using the same gdt_pd as Core 0
-       lgdt    gdt_pd
-       movw    $GD_KD, %ax             # Kernel segment selector
-       movw    %ax, %ds                # -> DS: Data Segment
-       movw    %ax, %es                # -> ES: Extra Segment
-       movw    %ax, %ss                # -> SS: Stack Segment
-       movw    $GD_UD|3, %ax   # User segment selector, with RPL=3
-       movw    %ax, %fs                # -> FS
-       movw    %ax, %gs                # -> GS
-       ljmp    $GD_KT, $here   # jumping to original location of trampoline!
-here:
-       xorl    %eax, %eax
-       lldt    %ax
-       incl    num_cpus
-       movl    (smp_stack_top), %esp
-       movl    $0, %ebp                # so backtrace works
-       call    smp_main
-       movl    %eax, %esp              # use our new stack, value returned from smp_main
-       # note the next two lines are using the direct mapping from smp_boot()
-       movw    $0, smp_boot_lock - smp_entry + 0x1000  # release lock
-       lock decw       smp_semaphore - smp_entry + 0x1000  # show we are done
-       sti                     # so we can get the IPI
-       hlt                     # wait for the IPI to run smp_pcu_init()
-       call    smp_final_core_init
-       call    smp_idle                # idle loop, will have interrupts turned on
-       # smp_idle should never return
-spin:
-       jmp spin
-
-       # Below here is just data, stored with the code text
-       .p2align        2                                               # force 4 byte alignment
-gdt:
-       SEG_NULL                                                        # null seg
-       SEG(STA_X|STA_R, 0, 0xffffffff)         # code seg
-       SEG(STA_W, 0, 0xffffffff)                       # data seg
-gdtdesc:
-       .word   gdtdesc - gdt - 1                       # sizeof(gdt) - 1
-       .long   gdt - smp_entry + 0x1000        # address gdt
-       .p2align        2                                               # force 4 byte alignment
-.globl                 smp_boot_lock
-smp_boot_lock:                                                 # this lock word will be only used from
-       .word   0                                                       # its spot in the trampoline (0x1000)
-.globl                 smp_semaphore
-smp_semaphore:                                                 # poor man's polling semaphore
-       .word   0                                                       
-.globl                 smp_entry_end
-smp_entry_end:
diff --git a/kern/arch/x86/support32.S b/kern/arch/x86/support32.S
deleted file mode 100644 (file)
index c8981a5..0000000
+++ /dev/null
@@ -1,90 +0,0 @@
-/*-
- * Copyright (c) 1993 The Regents of the University of California.
- * All rights reserved.
- *
- * 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.
- * 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.
- *
- * $FreeBSD$
- */
-
-/*
- * bcopy(src, dst, cnt)
- *  ws@tools.de     (Wolfgang Solfrank, TooLs GmbH) +49-228-985800
- */
-
-.text
-.align 4
-.globl bcopy
-.type bcopy, @function
-bcopy:
-       pushl   %ebp
-       movl    %esp,%ebp
-       pushl   %esi
-       pushl   %edi
-       movl    8(%ebp),%esi
-       movl    12(%ebp),%edi
-       movl    16(%ebp),%ecx
-
-       movl    %edi,%eax
-       subl    %esi,%eax
-       cmpl    %ecx,%eax                       /* overlapping && src < dst? */
-       jb      1f
-
-       shrl    $2,%ecx                         /* copy by 32-bit words */
-       cld                                     /* nope, copy forwards */
-       rep
-       movsl
-       movl    16(%ebp),%ecx
-       andl    $3,%ecx                         /* any bytes left? */
-       rep
-       movsb
-       popl    %edi
-       popl    %esi
-       popl    %ebp
-       ret
-
-       .p2align 2,0x90
-1:
-       addl    %ecx,%edi                       /* copy backwards */
-       addl    %ecx,%esi
-       decl    %edi
-       decl    %esi
-       andl    $3,%ecx                         /* any fractional bytes? */
-       std
-       rep
-       movsb
-       movl    16(%ebp),%ecx                   /* copy remainder by 32-bit words */
-       shrl    $2,%ecx
-       subl    $3,%esi
-       subl    $3,%edi
-       rep
-       movsl
-       popl    %edi
-       popl    %esi
-       cld
-       popl    %ebp
-       ret
-
-.size bcopy,.-bcopy
diff --git a/kern/arch/x86/trap32.c b/kern/arch/x86/trap32.c
deleted file mode 100644 (file)
index d1a8714..0000000
+++ /dev/null
@@ -1,78 +0,0 @@
-/* Copyright (c) 2009-13 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * x86 trap.c bit-specific functions. */
-
-#include <arch/mmu.h>
-#include <arch/x86.h>
-#include <arch/arch.h>
-#include <arch/console.h>
-#include <arch/apic.h>
-#include <ros/common.h>
-#include <smp.h>
-#include <assert.h>
-#include <pmap.h>
-#include <trap.h>
-#include <monitor.h>
-#include <process.h>
-#include <mm.h>
-#include <stdio.h>
-#include <slab.h>
-#include <syscall.h>
-#include <kdebug.h>
-#include <kmalloc.h>
-
-static void print_regs(push_regs_t *regs)
-{
-       printk("  edi  0x%08x\n", regs->reg_edi);
-       printk("  esi  0x%08x\n", regs->reg_esi);
-       printk("  ebp  0x%08x\n", regs->reg_ebp);
-       printk("  oesp 0x%08x\n", regs->reg_oesp);
-       printk("  ebx  0x%08x\n", regs->reg_ebx);
-       printk("  edx  0x%08x\n", regs->reg_edx);
-       printk("  ecx  0x%08x\n", regs->reg_ecx);
-       printk("  eax  0x%08x\n", regs->reg_eax);
-}
-
-void print_trapframe(struct hw_trapframe *hw_tf)
-{
-       static spinlock_t ptf_lock = SPINLOCK_INITIALIZER_IRQSAVE;
-
-       struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
-       /* This is only called in debug scenarios, and often when the kernel trapped
-        * and needs to tell us about it.  Disable the lock checker so it doesn't go
-        * nuts when we print/panic */
-       pcpui->__lock_checking_enabled--;
-       spin_lock_irqsave(&ptf_lock);
-       printk("TRAP frame at %p on core %d\n", hw_tf, core_id());
-       print_regs(&hw_tf->tf_regs);
-       printk("  gs   0x----%04x\n", hw_tf->tf_gs);
-       printk("  fs   0x----%04x\n", hw_tf->tf_fs);
-       printk("  es   0x----%04x\n", hw_tf->tf_es);
-       printk("  ds   0x----%04x\n", hw_tf->tf_ds);
-       printk("  trap 0x%08x %s\n",  hw_tf->tf_trapno,
-                                     x86_trapname(hw_tf->tf_trapno));
-       printk("  err  0x%08x\n",     hw_tf->tf_err);
-       printk("  eip  0x%08x\n",     hw_tf->tf_eip);
-       printk("  cs   0x----%04x\n", hw_tf->tf_cs);
-       printk("  flag 0x%08x\n",     hw_tf->tf_eflags);
-       /* Prevents us from thinking these mean something for nested interrupts. */
-       if (hw_tf->tf_cs != GD_KT) {
-               printk("  esp  0x%08x\n",     hw_tf->tf_esp);
-               printk("  ss   0x----%04x\n", hw_tf->tf_ss);
-       }
-       spin_unlock_irqsave(&ptf_lock);
-       pcpui->__lock_checking_enabled++;
-}
-
-void __arch_reflect_trap_hwtf(struct hw_trapframe *hw_tf, unsigned int trap_nr,
-                              unsigned int err, unsigned long aux)
-{
-       hw_tf->tf_trapno = trap_nr;
-       /* this can be necessary, since hw_tf is the pcpui one, and the err that
-        * came in probably came from the kernel stack's hw_tf. */
-       hw_tf->tf_err = err;
-       hw_tf->tf_regs.reg_oesp = aux;
-       hw_tf->tf_padding3 = ROS_ARCH_REFL_ID;
-}
diff --git a/kern/arch/x86/trapentry32.S b/kern/arch/x86/trapentry32.S
deleted file mode 100644 (file)
index 7c6d4c0..0000000
+++ /dev/null
@@ -1,482 +0,0 @@
-/* See COPYRIGHT for copyright information.
- * The two TRAP* macros (minus the .data parts) are from the JOS project.
- * Everything else:
- * Copyright (c) 2009 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- */
-#include <arch/mmu.h>
-#include <arch/trap.h>
-#include <ros/memlayout.h>
-
-###################################################################
-# exceptions/interrupts
-###################################################################
-
-/* The TRAPHANDLER macro defines a globally-visible function for handling
- * a trap.  It pushes a trap number onto the stack, then jumps to _alltraps.
- * It also builds this traps portion of the trap_tbl.
- * Use TRAPHANDLER for traps where the CPU automatically pushes an error code.
- */
-#define TRAPHANDLER(name, num)                                                                 \
-       .text;                                                                                                          \
-       .globl name;            /* define global symbol for 'name' */   \
-       .type name, @function;  /* symbol type is function */           \
-       .align 2;               /* align function definition */                         \
-       name:                   /* function starts here */                                      \
-       pushl $(num);                                                                                           \
-       jmp _alltraps;                                                                                          \
-       .data;                                                                                                          \
-       .long name;                                                                                                     \
-       .long num
-
-/* Use TRAPHANDLER_NOEC for traps where the CPU doesn't push an error code.
- * It pushes a 0 in place of the error code, so the trap frame has the same
- * format in either case.
- */
-#define TRAPHANDLER_NOEC(name, num)            \
-       .text;                                                          \
-       .globl name;                                            \
-       .type name, @function;                          \
-       .align 2;                                                       \
-       name:                                                           \
-       pushl $0;                                                       \
-       pushl $(num);                                           \
-       jmp _alltraps;                                          \
-       .data;                                                          \
-       .long name;                                                     \
-       .long num
-
-/* Same as NOEC, but for IRQs instead.  num is the ISR number it is mapped to */
-#define IRQ_HANDLER(name, num)                 \
-       .text;                                                          \
-       .globl name;                                            \
-       .type name, @function;                          \
-       .align 2;                                                       \
-       name:                                                           \
-       pushl $0;                                                       \
-       pushl $(num);                                           \
-       jmp _allirqs;                                           \
-       .data;                                                          \
-       .long name;                                                     \
-       .long num
-
-/* Only used in the kernel during SMP boot.  Send a LAPIC_EOI and iret. */
-#define POKE_HANDLER(name, num)                        \
-       .text;                                                          \
-       .globl name;                                            \
-       .type name, @function;                          \
-       .align 2;                                                       \
-       name:;                                                          \
-       movl $0, (LAPIC_BASE + 0x0b0);      \
-       iret;                                                           \
-       .data;                                                          \
-       .long name;                                                     \
-       .long num
-
-/* Same as above, but takes a specific function to jump to.  See comments
- * below from _allirqs for details.
- */
-#define IRQ_HANDLER_SPEC(name, num, func)                                      \
-       .text;                                                                                                 \
-       .globl name;                                                                                   \
-       .type name, @function;                                                                 \
-       .align 2;                                                                                              \
-       name:                                                                                                  \
-       pushl $0;                                                                  \
-       pushl $(num);                                                              \
-       cld;                                                                       \
-       pushl %ds;                                                                 \
-       pushl %es;                                                                 \
-       pushl %fs;                                                                 \
-       pushl %gs;                                                                 \
-       pushal;                                                                    \
-       movw $0, %ax;                                                              \
-       movw %ax, %gs;                                                             \
-       movw %ax, %fs;                                                             \
-       movw $GD_KD, %ax;                                                          \
-       movw %ax, %ds;                                                             \
-       movw %ax, %es;                                                             \
-       pushl %esp;                                                                \
-       movl $0, %ebp;                                                             \
-       call (func);                                                               \
-       popl %esp;                                                                 \
-       popal;                                                                     \
-       popl %gs;                                                                  \
-       popl %fs;                                                                  \
-       popl %es;                                                                  \
-       popl %ds;                                                                  \
-       addl $0x8, %esp;                                                           \
-       iret;                                                                      \
-       .data;                                                                     \
-       .long name;                                                                \
-       .long num
-
-.data
-.globl trap_tbl
-trap_tbl:
-
-/* Generate entry points for the different traps.  Note that all of these bounce
- * off the corresponding trap.c function, such as handle_irqs, and that the name
- * e.g. ISR_NMI is soley for the little stup that jumps to something like
- * _alltraps.
- *
- * Technically, these HANDLER entries do not need to be in numeric order.
- * trap.c will do a 'foreach (up to last-1), set the IDT for the number to point
- * to the func' in the order in which they appear in the trap tbl, so the 'last
- * one wins'. */
-TRAPHANDLER_NOEC(ISR_divide_error, T_DIVIDE)
-TRAPHANDLER_NOEC(ISR_debug_exceptions, T_DEBUG)
-TRAPHANDLER_NOEC(ISR_NMI, T_NMI)
-TRAPHANDLER_NOEC(ISR_breakpoint, T_BRKPT)
-TRAPHANDLER_NOEC(ISR_overflow, T_OFLOW)
-TRAPHANDLER_NOEC(ISR_bounds_check, T_BOUND)
-TRAPHANDLER_NOEC(ISR_invalid_opcode, T_ILLOP)
-TRAPHANDLER_NOEC(ISR_device_not_available, T_DEVICE)
-/* supposedly, DF generates an error code, but the one time we've had a DF so
- * far, it didn't.  eventually, this should probably be handled with a task gate
- * it might have pushed a 0, but just the rest of the stack was corrupt
- */
-TRAPHANDLER_NOEC(ISR_double_fault, T_DBLFLT)
-/* 9 reserved */
-TRAPHANDLER(ISR_invalid_TSS, T_TSS)
-TRAPHANDLER(ISR_segment_not_present, T_SEGNP)
-TRAPHANDLER(ISR_stack_exception, T_STACK)
-TRAPHANDLER(ISR_general_protection_fault, T_GPFLT)
-TRAPHANDLER(ISR_page_fault, T_PGFLT)
-/* 15 reserved */
-TRAPHANDLER_NOEC(ISR_floating_point_error, T_FPERR)
-TRAPHANDLER(ISR_alignment_check, T_ALIGN)
-TRAPHANDLER_NOEC(ISR_machine_check, T_MCHK)
-TRAPHANDLER_NOEC(ISR_simd_error, T_SIMDERR)
-/* 20 - 31 reserved */
-/* 32-47 are PIC/8259 IRQ vectors */
-IRQ_HANDLER(IRQ0, 32)
-IRQ_HANDLER(IRQ1, 33)
-IRQ_HANDLER(IRQ2, 34)
-IRQ_HANDLER(IRQ3, 35)
-IRQ_HANDLER(IRQ4, 36)
-IRQ_HANDLER(IRQ5, 37)
-IRQ_HANDLER(IRQ6, 38)
-IRQ_HANDLER(IRQ7, 39)
-IRQ_HANDLER(IRQ8, 40)
-IRQ_HANDLER(IRQ9, 41)
-IRQ_HANDLER(IRQ10, 42)
-IRQ_HANDLER(IRQ11, 43)
-IRQ_HANDLER(IRQ12, 44)
-IRQ_HANDLER(IRQ13, 45)
-IRQ_HANDLER(IRQ14, 46)
-IRQ_HANDLER(IRQ15, 47)
-TRAPHANDLER_NOEC(ISR_syscall, T_SYSCALL)
-/* 49-223 are IOAPIC routing vectors (from IOAPIC to LAPIC) */
-IRQ_HANDLER(IRQ17, 49)
-IRQ_HANDLER(IRQ18, 50)
-IRQ_HANDLER(IRQ19, 51)
-IRQ_HANDLER(IRQ20, 52)
-IRQ_HANDLER(IRQ21, 53)
-IRQ_HANDLER(IRQ22, 54)
-IRQ_HANDLER(IRQ23, 55)
-IRQ_HANDLER(IRQ24, 56)
-IRQ_HANDLER(IRQ25, 57)
-IRQ_HANDLER(IRQ26, 58)
-IRQ_HANDLER(IRQ27, 59)
-IRQ_HANDLER(IRQ28, 60)
-IRQ_HANDLER(IRQ29, 61)
-IRQ_HANDLER(IRQ30, 62)
-IRQ_HANDLER(IRQ31, 63)
-IRQ_HANDLER(IRQ32, 64)
-IRQ_HANDLER(IRQ33, 65)
-IRQ_HANDLER(IRQ34, 66)
-IRQ_HANDLER(IRQ35, 67)
-IRQ_HANDLER(IRQ36, 68)
-IRQ_HANDLER(IRQ37, 69)
-IRQ_HANDLER(IRQ38, 70)
-IRQ_HANDLER(IRQ39, 71)
-IRQ_HANDLER(IRQ40, 72)
-IRQ_HANDLER(IRQ41, 73)
-IRQ_HANDLER(IRQ42, 74)
-IRQ_HANDLER(IRQ43, 75)
-IRQ_HANDLER(IRQ44, 76)
-IRQ_HANDLER(IRQ45, 77)
-IRQ_HANDLER(IRQ46, 78)
-IRQ_HANDLER(IRQ47, 79)
-IRQ_HANDLER(IRQ48, 80)
-IRQ_HANDLER(IRQ49, 81)
-IRQ_HANDLER(IRQ50, 82)
-IRQ_HANDLER(IRQ51, 83)
-IRQ_HANDLER(IRQ52, 84)
-IRQ_HANDLER(IRQ53, 85)
-IRQ_HANDLER(IRQ54, 86)
-IRQ_HANDLER(IRQ55, 87)
-IRQ_HANDLER(IRQ56, 88)
-IRQ_HANDLER(IRQ57, 89)
-IRQ_HANDLER(IRQ58, 90)
-IRQ_HANDLER(IRQ59, 91)
-IRQ_HANDLER(IRQ60, 92)
-IRQ_HANDLER(IRQ61, 93)
-IRQ_HANDLER(IRQ62, 94)
-IRQ_HANDLER(IRQ63, 95)
-IRQ_HANDLER(IRQ64, 96)
-IRQ_HANDLER(IRQ65, 97)
-IRQ_HANDLER(IRQ66, 98)
-IRQ_HANDLER(IRQ67, 99)
-IRQ_HANDLER(IRQ68, 100)
-IRQ_HANDLER(IRQ69, 101)
-IRQ_HANDLER(IRQ70, 102)
-IRQ_HANDLER(IRQ71, 103)
-IRQ_HANDLER(IRQ72, 104)
-IRQ_HANDLER(IRQ73, 105)
-IRQ_HANDLER(IRQ74, 106)
-IRQ_HANDLER(IRQ75, 107)
-IRQ_HANDLER(IRQ76, 108)
-IRQ_HANDLER(IRQ77, 109)
-IRQ_HANDLER(IRQ78, 110)
-IRQ_HANDLER(IRQ79, 111)
-IRQ_HANDLER(IRQ80, 112)
-IRQ_HANDLER(IRQ81, 113)
-IRQ_HANDLER(IRQ82, 114)
-IRQ_HANDLER(IRQ83, 115)
-IRQ_HANDLER(IRQ84, 116)
-IRQ_HANDLER(IRQ85, 117)
-IRQ_HANDLER(IRQ86, 118)
-IRQ_HANDLER(IRQ87, 119)
-IRQ_HANDLER(IRQ88, 120)
-IRQ_HANDLER(IRQ89, 121)
-IRQ_HANDLER(IRQ90, 122)
-IRQ_HANDLER(IRQ91, 123)
-IRQ_HANDLER(IRQ92, 124)
-IRQ_HANDLER(IRQ93, 125)
-IRQ_HANDLER(IRQ94, 126)
-IRQ_HANDLER(IRQ95, 127)
-IRQ_HANDLER(IRQ96, 128)
-IRQ_HANDLER(IRQ97, 129)
-IRQ_HANDLER(IRQ98, 130)
-IRQ_HANDLER(IRQ99, 131)
-IRQ_HANDLER(IRQ100, 132)
-IRQ_HANDLER(IRQ101, 133)
-IRQ_HANDLER(IRQ102, 134)
-IRQ_HANDLER(IRQ103, 135)
-IRQ_HANDLER(IRQ104, 136)
-IRQ_HANDLER(IRQ105, 137)
-IRQ_HANDLER(IRQ106, 138)
-IRQ_HANDLER(IRQ107, 139)
-IRQ_HANDLER(IRQ108, 140)
-IRQ_HANDLER(IRQ109, 141)
-IRQ_HANDLER(IRQ110, 142)
-IRQ_HANDLER(IRQ111, 143)
-IRQ_HANDLER(IRQ112, 144)
-IRQ_HANDLER(IRQ113, 145)
-IRQ_HANDLER(IRQ114, 146)
-IRQ_HANDLER(IRQ115, 147)
-IRQ_HANDLER(IRQ116, 148)
-IRQ_HANDLER(IRQ117, 149)
-IRQ_HANDLER(IRQ118, 150)
-IRQ_HANDLER(IRQ119, 151)
-IRQ_HANDLER(IRQ120, 152)
-IRQ_HANDLER(IRQ121, 153)
-IRQ_HANDLER(IRQ122, 154)
-IRQ_HANDLER(IRQ123, 155)
-IRQ_HANDLER(IRQ124, 156)
-IRQ_HANDLER(IRQ125, 157)
-IRQ_HANDLER(IRQ126, 158)
-IRQ_HANDLER(IRQ127, 159)
-IRQ_HANDLER(IRQ128, 160)
-IRQ_HANDLER(IRQ129, 161)
-IRQ_HANDLER(IRQ130, 162)
-IRQ_HANDLER(IRQ131, 163)
-IRQ_HANDLER(IRQ132, 164)
-IRQ_HANDLER(IRQ133, 165)
-IRQ_HANDLER(IRQ134, 166)
-IRQ_HANDLER(IRQ135, 167)
-IRQ_HANDLER(IRQ136, 168)
-IRQ_HANDLER(IRQ137, 169)
-IRQ_HANDLER(IRQ138, 170)
-IRQ_HANDLER(IRQ139, 171)
-IRQ_HANDLER(IRQ140, 172)
-IRQ_HANDLER(IRQ141, 173)
-IRQ_HANDLER(IRQ142, 174)
-IRQ_HANDLER(IRQ143, 175)
-IRQ_HANDLER(IRQ144, 176)
-IRQ_HANDLER(IRQ145, 177)
-IRQ_HANDLER(IRQ146, 178)
-IRQ_HANDLER(IRQ147, 179)
-IRQ_HANDLER(IRQ148, 180)
-IRQ_HANDLER(IRQ149, 181)
-IRQ_HANDLER(IRQ150, 182)
-IRQ_HANDLER(IRQ151, 183)
-IRQ_HANDLER(IRQ152, 184)
-IRQ_HANDLER(IRQ153, 185)
-IRQ_HANDLER(IRQ154, 186)
-IRQ_HANDLER(IRQ155, 187)
-IRQ_HANDLER(IRQ156, 188)
-IRQ_HANDLER(IRQ157, 189)
-IRQ_HANDLER(IRQ158, 190)
-IRQ_HANDLER(IRQ159, 191)
-IRQ_HANDLER(IRQ160, 192)
-IRQ_HANDLER(IRQ161, 193)
-IRQ_HANDLER(IRQ162, 194)
-IRQ_HANDLER(IRQ163, 195)
-IRQ_HANDLER(IRQ164, 196)
-IRQ_HANDLER(IRQ165, 197)
-IRQ_HANDLER(IRQ166, 198)
-IRQ_HANDLER(IRQ167, 199)
-IRQ_HANDLER(IRQ168, 200)
-IRQ_HANDLER(IRQ169, 201)
-IRQ_HANDLER(IRQ170, 202)
-IRQ_HANDLER(IRQ171, 203)
-IRQ_HANDLER(IRQ172, 204)
-IRQ_HANDLER(IRQ173, 205)
-IRQ_HANDLER(IRQ174, 206)
-IRQ_HANDLER(IRQ175, 207)
-IRQ_HANDLER(IRQ176, 208)
-IRQ_HANDLER(IRQ177, 209)
-IRQ_HANDLER(IRQ178, 210)
-IRQ_HANDLER(IRQ179, 211)
-IRQ_HANDLER(IRQ180, 212)
-IRQ_HANDLER(IRQ181, 213)
-IRQ_HANDLER(IRQ182, 214)
-IRQ_HANDLER(IRQ183, 215)
-IRQ_HANDLER(IRQ184, 216)
-IRQ_HANDLER(IRQ185, 217)
-IRQ_HANDLER(IRQ186, 218)
-IRQ_HANDLER(IRQ187, 219)
-IRQ_HANDLER(IRQ188, 220)
-IRQ_HANDLER(IRQ189, 221)
-IRQ_HANDLER(IRQ190, 222)
-IRQ_HANDLER(IRQ191, 223)
-/* 224-239 are OS IPI vectors (0xe0-0xef) */
-IRQ_HANDLER(IRQ192, I_SMP_CALL0)
-IRQ_HANDLER(IRQ193, I_SMP_CALL1)
-IRQ_HANDLER(IRQ194, I_SMP_CALL2)
-IRQ_HANDLER(IRQ195, I_SMP_CALL3)
-IRQ_HANDLER(IRQ196, I_SMP_CALL4)
-IRQ_HANDLER(IRQ197, 229)
-IRQ_HANDLER(IRQ198, 230)
-IRQ_HANDLER(IRQ199, 231)
-IRQ_HANDLER(IRQ200, 232)
-IRQ_HANDLER(IRQ201, 233)
-IRQ_HANDLER(IRQ202, 234)
-IRQ_HANDLER(IRQ203, 235)
-IRQ_HANDLER(IRQ204, 236)
-IRQ_HANDLER(IRQ205, I_TESTING)
-POKE_HANDLER(IRQ206, I_POKE_CORE)
-IRQ_HANDLER(IRQ207, I_KERNEL_MSG)
-/* 240-255 are LAPIC vectors (0xf0-0xff), hightest priority class */
-IRQ_HANDLER(IRQ208, 240)
-IRQ_HANDLER(IRQ209, 241)
-IRQ_HANDLER(IRQ210, 242)
-IRQ_HANDLER(IRQ211, 243)
-IRQ_HANDLER(IRQ212, 244)
-IRQ_HANDLER(IRQ213, 245)
-IRQ_HANDLER(IRQ214, 246)
-IRQ_HANDLER(IRQ215, 247)
-IRQ_HANDLER(IRQ216, 248)
-IRQ_HANDLER(IRQ217, 249)
-IRQ_HANDLER(IRQ218, 250)
-IRQ_HANDLER(IRQ219, 251)
-IRQ_HANDLER(IRQ220, 252)
-IRQ_HANDLER(IRQ221, 253)
-IRQ_HANDLER(IRQ222, 254)
-IRQ_HANDLER(IRQ223, 255)
-/* But make sure default is last!! */
-TRAPHANDLER_NOEC(ISR_default, T_DEFAULT)
-
-.data
-.globl trap_tbl_end
-trap_tbl_end:
-
-/* Keep the exit paths of _alltraps, _allirqs, and sysenter_handler in sync
- * with the corresponding pop_tf's.
- */
-.text
-_alltraps:
-       cld
-       pushl %ds
-       pushl %es
-       pushl %fs
-       pushl %gs
-       pushal
-       movw $0, %ax;
-       movw %ax, %gs;
-       movw %ax, %fs;
-       movw $GD_KD, %ax                # data segments aren't accessible by default
-       movw %ax, %ds
-       movw %ax, %es
-       pushl %esp
-       movl $0, %ebp                   # so we can backtrace to this point
-       call trap
-       popl %esp
-       popal
-       popl %gs
-       popl %fs
-       popl %es
-       popl %ds
-       addl $0x8, %esp                 # skip trapno and err
-       iret
-
-/* will need to think about when we reenable interrupts.  right now, iret does it,
- * if the previous EFLAGS had interrupts enabled
- */
-_allirqs:
-       cld
-       pushl %ds
-       pushl %es
-       pushl %fs
-       pushl %gs
-       pushal
-       movw $0, %ax;
-       movw %ax, %gs;
-       movw %ax, %fs;
-       movw $GD_KD, %ax                # data segments aren't accessible by default
-       movw %ax, %ds
-       movw %ax, %es
-       pushl %esp
-       movl $0, %ebp                   # so we can backtrace to this point
-       call handle_irq
-       popl %esp
-       popal
-       popl %gs
-       popl %fs
-       popl %es
-       popl %ds
-       addl $0x8, %esp                 # skip IRQ number and err (which is 0)
-       iret
-
-.globl sysenter_handler;
-.type sysenter_handler, @function;
-# All of the pushl zeros are to keep the trap frame looking the same as when we
-# receive a trap or an interrupt
-sysenter_handler:
-       cld
-       pushl $0                                # ss
-       pushl $0                                # esp
-       pushfl                                  # eflags
-       pushl $0                                # CS == 0 lets the kernel know it was a sysenter        
-       pushl $0                                # eip
-       pushl $0                                # err 
-       pushl $T_SYSCALL                # helps with print_trapframe
-       pushl %ds
-       pushl %es
-       pushl %fs
-       pushl %gs
-       pushal
-       movw $0, %ax;
-       movw %ax, %gs;
-       movw %ax, %fs;
-       movw $GD_KD, %ax
-       movw %ax, %ds
-       movw %ax, %es
-       pushl %esp
-       movl $0, %ebp                   # so we can backtrace to this point
-       call sysenter_callwrapper
-       popl %esp
-       popal
-       popl %gs
-       popl %fs
-       popl %es
-       popl %ds
-       addl $0x10, %esp                # pop T_SYSCALL and the three zeros
-       popfl                                   # restore EFLAGS (and usually enables interrupts!)
-       movl %ebp, %ecx
-       sti                                             # interrupts are turned off when starting a core
-       sysexit