Changes hardware trapframe calls to use new struct
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 12 Apr 2013 00:44:50 +0000 (17:44 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 12 Apr 2013 23:18:58 +0000 (16:18 -0700)
All places where we used a struct trapframe and that was a HW trapframe
(compared to a SW trapframe or user_context) now use the new struct
hw_trapframe.

I considered removing the TF from the monitor calls, since I don't see
much use in it.  Monitor functions that want to use it can't assume it
is there (only ever called from breakpoint).  Maybe we'll find a
debugging use for it.

25 files changed:
kern/arch/i686/e1000.c
kern/arch/i686/e1000.h
kern/arch/i686/init.c
kern/arch/i686/ne2k.c
kern/arch/i686/ne2k.h
kern/arch/i686/rl8168.c
kern/arch/i686/rl8168.h
kern/arch/i686/smp_boot.c
kern/arch/i686/trap.c
kern/arch/i686/trap.h
kern/arch/riscv/cpuinfo.c
kern/arch/riscv/fpu.c
kern/arch/riscv/trap.c
kern/arch/riscv/trap.h
kern/arch/sparc/cpuinfo.c
kern/arch/sparc/fpu.c
kern/arch/sparc/trap.c
kern/arch/sparc/trap.h
kern/include/monitor.h
kern/include/testing.h
kern/include/trap.h
kern/src/monitor.c
kern/src/testing.c
kern/src/time.c
kern/src/trap.c

index ae614cb..e96a393 100644 (file)
@@ -660,7 +660,8 @@ void e1000_setup_interrupts() {
 }
 
 // Code that is executed when an interrupt comes in on IRQ e1000_irq
-void e1000_interrupt_handler(trapframe_t *tf, void* data) {
+void e1000_interrupt_handler(struct hw_trapframe *hw_tf, void *data)
+{
        e1000_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
 
        // Read the offending interrupt(s)
index 580a98f..7e743af 100644 (file)
@@ -111,7 +111,7 @@ static void e1000_wr32(uint32_t offset, uint32_t val);
 
 void e1000_init(void);
 void e1000_reset(void);
-void e1000_interrupt_handler(trapframe_t* tf, void* data);
+void e1000_interrupt_handler(struct hw_trapframe *hw_tf, void *data);
 int  e1000_scan_pci(void);
 void e1000_setup_interrupts(void);
 void e1000_setup_descriptors(void);
index ff72649..9bcf67f 100644 (file)
@@ -18,7 +18,7 @@
 #include <console.h>
 
 /* irq handler for the console (kb, serial, etc) */
-static void irq_console(struct trapframe *tf, void *data)
+static void irq_console(struct hw_trapframe *hw_tf, void *data)
 {
        uint8_t c;
        struct cons_dev *cdev = (struct cons_dev*)data;
index 2241e5e..db4f2b9 100644 (file)
@@ -245,7 +245,8 @@ void ne2k_test_interrupts() {
 
 // We need to evaluate this routine in terms of concurrency.
 // We also need to figure out whats up with different core interrupts
-void ne2k_interrupt_handler(trapframe_t *tf, void* data) {
+void ne2k_interrupt_handler(struct hw_trapframe *hw_tf, void *data)
+{
        
        ne2k_interrupt_debug("\nNE2K interrupt on core %u!\n", lapic_get_id());
 
index c72d6db..7915428 100644 (file)
@@ -20,7 +20,7 @@ void ne2k_init();
 int ne2k_scan_pci();
 void ne2k_configure_nic();
 void ne2k_setup_interrupts();
-void ne2k_interrupt_handler(trapframe_t *tf, void* data);
+void ne2k_interrupt_handler(struct hw_trapframe *hw_tf, void *data);
 void ne2k_mem_alloc();
 void ne2k_read_mac();
 void ne2k_test_interrupts();
index 2bdfe9d..93172d9 100644 (file)
@@ -325,7 +325,8 @@ void rl8168_setup_interrupts() {
 
 // We need to evaluate this routine in terms of concurrency.
 // We also need to figure out whats up with different core interrupts
-void rl8168_interrupt_handler(trapframe_t *tf, void* data) {
+void rl8168_interrupt_handler(struct hw_trapframe *hw_tf, void *data)
+{
 
        rl8168_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
                                
index c95f9bf..6ae51aa 100644 (file)
 
 void rl8168_init(void);
 void rl8168_reset(void);
-void rl8168_interrupt_handler(trapframe_t *tf, void* data);
+void rl8168_interrupt_handler(struct hw_trapframe *hw_tf, void *data);
 int rl8168_scan_pci(void);
 void rl8168_read_mac(void);
 void rl8168_setup_interrupts(void);
index d5bf3ef..1880f79 100644 (file)
@@ -59,11 +59,7 @@ static void init_smp_call_function(void)
 
 /******************************************************************************/
 
-#ifdef __IVY__
-static void smp_final_core_init(trapframe_t *tf, barrier_t *data)
-#else
-static void smp_final_core_init(trapframe_t *tf, void *data)
-#endif
+static void smp_final_core_init(struct hw_trapframe *hw_tf, void *data)
 {
        setup_default_mtrrs(data);
        smp_percpu_init();
index 7e38795..e976941 100644 (file)
@@ -202,8 +202,7 @@ void idt_init(void)
                                   handle_kmsg_ipi, NULL);
 }
 
-void
-print_regs(push_regs_t *regs)
+static void print_regs(push_regs_t *regs)
 {
        cprintf("  edi  0x%08x\n", regs->reg_edi);
        cprintf("  esi  0x%08x\n", regs->reg_esi);
@@ -215,8 +214,7 @@ print_regs(push_regs_t *regs)
        cprintf("  eax  0x%08x\n", regs->reg_eax);
 }
 
-void
-print_trapframe(trapframe_t *tf)
+void print_trapframe(struct hw_trapframe *hw_tf)
 {
        static spinlock_t ptf_lock = SPINLOCK_INITIALIZER_IRQSAVE;
 
@@ -226,57 +224,58 @@ print_trapframe(trapframe_t *tf)
         * nuts when we print/panic */
        pcpui->__lock_depth_disabled++;
        spin_lock_irqsave(&ptf_lock);
-       printk("TRAP frame at %p on core %d\n", tf, core_id());
-       print_regs(&tf->tf_regs);
-       printk("  gs   0x----%04x\n", tf->tf_gs);
-       printk("  fs   0x----%04x\n", tf->tf_fs);
-       printk("  es   0x----%04x\n", tf->tf_es);
-       printk("  ds   0x----%04x\n", tf->tf_ds);
-       printk("  trap 0x%08x %s\n", tf->tf_trapno, trapname(tf->tf_trapno));
-       printk("  err  0x%08x\n", tf->tf_err);
-       printk("  eip  0x%08x\n", tf->tf_eip);
-       printk("  cs   0x----%04x\n", tf->tf_cs);
-       printk("  flag 0x%08x\n", tf->tf_eflags);
+       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, 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 (tf->tf_cs != GD_KT) {
-               printk("  esp  0x%08x\n", tf->tf_esp);
-               printk("  ss   0x----%04x\n", tf->tf_ss);
+       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_depth_disabled--;
 }
 
-static void fake_rdtscp(struct trapframe *tf)
+static void fake_rdtscp(struct hw_trapframe *hw_tf)
 {
        uint64_t tsc_time = read_tsc();
-       tf->tf_eip += 3;
-       tf->tf_regs.reg_eax = tsc_time & 0xffffffff;
-       tf->tf_regs.reg_edx = tsc_time >> 32;
-       tf->tf_regs.reg_ecx = core_id();
+       hw_tf->tf_eip += 3;
+       hw_tf->tf_regs.reg_eax = tsc_time & 0xffffffff;
+       hw_tf->tf_regs.reg_edx = tsc_time >> 32;
+       hw_tf->tf_regs.reg_ecx = core_id();
 }
 
 /* Certain traps want IRQs enabled, such as the syscall.  Others can't handle
  * it, like the page fault handler.  Turn them on on a case-by-case basis. */
-static void trap_dispatch(struct trapframe *tf)
+static void trap_dispatch(struct hw_trapframe *hw_tf)
 {
        struct per_cpu_info *pcpui;
        // Handle processor exceptions.
-       switch(tf->tf_trapno) {
+       switch(hw_tf->tf_trapno) {
                case T_NMI:
                        /* Temporarily disable deadlock detection when we print.  We could
                         * deadlock if we were printing when we NMIed. */
                        pcpui = &per_cpu_info[core_id()];
                        pcpui->__lock_depth_disabled++;
-                       print_trapframe(tf);
-                       char *fn_name = get_fn_name(tf->tf_eip);
-                       printk("Core %d is at %08p (%s)\n", core_id(), tf->tf_eip, fn_name);
+                       print_trapframe(hw_tf);
+                       char *fn_name = get_fn_name(hw_tf->tf_eip);
+                       printk("Core %d is at %08p (%s)\n", core_id(), hw_tf->tf_eip,
+                              fn_name);
                        kfree(fn_name);
                        print_kmsgs(core_id());
                        pcpui->__lock_depth_disabled--;
                        break;
                case T_BRKPT:
                        enable_irq();
-                       monitor(tf);
+                       monitor(hw_tf);
                        break;
                case T_ILLOP:
                        pcpui = &per_cpu_info[core_id()];
@@ -285,40 +284,40 @@ static void trap_dispatch(struct trapframe *tf)
                         * userspace, we need to make sure we edit the actual TF that will
                         * get restarted (pcpui), and not the TF on the kstack (which aren't
                         * the same).  See set_current_tf() for more info. */
-                       if (!in_kernel(tf))
-                               tf = pcpui->cur_tf;
+                       if (!in_kernel(hw_tf))
+                               hw_tf = pcpui->cur_tf;
                        printd("bad opcode, eip: %08p, next 3 bytes: %x %x %x\n",
-                              tf->tf_eip, 
-                              *(uint8_t*)(tf->tf_eip + 0), 
-                              *(uint8_t*)(tf->tf_eip + 1), 
-                              *(uint8_t*)(tf->tf_eip + 2)); 
+                              hw_tf->tf_eip, 
+                              *(uint8_t*)(hw_tf->tf_eip + 0), 
+                              *(uint8_t*)(hw_tf->tf_eip + 1), 
+                              *(uint8_t*)(hw_tf->tf_eip + 2)); 
                        /* rdtscp: 0f 01 f9 */
-                       if (*(uint8_t*)(tf->tf_eip + 0) == 0x0f, 
-                           *(uint8_t*)(tf->tf_eip + 1) == 0x01, 
-                           *(uint8_t*)(tf->tf_eip + 2) == 0xf9) {
-                               fake_rdtscp(tf);
+                       if (*(uint8_t*)(hw_tf->tf_eip + 0) == 0x0f, 
+                           *(uint8_t*)(hw_tf->tf_eip + 1) == 0x01, 
+                           *(uint8_t*)(hw_tf->tf_eip + 2) == 0xf9) {
+                               fake_rdtscp(hw_tf);
                                pcpui->__lock_depth_disabled--; /* for print debugging */
                                return;
                        }
                        enable_irq();
-                       monitor(tf);
+                       monitor(hw_tf);
                        pcpui->__lock_depth_disabled--;         /* for print debugging */
                        break;
                case T_PGFLT:
-                       page_fault_handler(tf);
+                       page_fault_handler(hw_tf);
                        break;
                case T_SYSCALL:
                        enable_irq();
                        // check for userspace, for now
-                       assert(tf->tf_cs != GD_KT);
+                       assert(hw_tf->tf_cs != GD_KT);
                        /* Set up and run the async calls */
-                       prep_syscalls(current, (struct syscall*)tf->tf_regs.reg_eax,
-                                     tf->tf_regs.reg_edx);
+                       prep_syscalls(current, (struct syscall*)hw_tf->tf_regs.reg_eax,
+                                     hw_tf->tf_regs.reg_edx);
                        break;
                default:
                        // Unexpected trap: The user process or the kernel has a bug.
-                       print_trapframe(tf);
-                       if (tf->tf_cs == GD_KT)
+                       print_trapframe(hw_tf);
+                       if (hw_tf->tf_cs == GD_KT)
                                panic("Damn Damn!  Unhandled trap in the kernel!");
                        else {
                                warn("Unexpected trap from userspace");
@@ -368,38 +367,38 @@ static void set_current_tf(struct per_cpu_info *pcpui, struct trapframe *tf)
  * get the interrupt to trip on the hlt, o/w the hlt will execute before the
  * interrupt arrives (even with a pending interrupt that should hit right after
  * an interrupt_enable (sti)).  This was on the i7. */
-static void abort_halt(struct trapframe *tf)
+static void abort_halt(struct hw_trapframe *hw_tf)
 {
        /* Don't care about user TFs.  Incidentally, dereferencing user EIPs is
         * reading userspace memory, which can be dangerous.  It can page fault,
         * like immediately after a fork (which doesn't populate the pages). */
-       if (!in_kernel(tf))
+       if (!in_kernel(hw_tf))
                return;
        /* the halt instruction in 32 bit is 0xf4, and it's size is 1 byte */
-       if (*(uint8_t*)tf->tf_eip == 0xf4)
-               tf->tf_eip += 1;
+       if (*(uint8_t*)hw_tf->tf_eip == 0xf4)
+               hw_tf->tf_eip += 1;
 }
 
-void trap(struct trapframe *tf)
+void trap(struct hw_trapframe *hw_tf)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        /* Copy out the TF for now */
-       if (!in_kernel(tf))
-               set_current_tf(pcpui, tf);
+       if (!in_kernel(hw_tf))
+               set_current_tf(pcpui, hw_tf);
        else
                inc_ktrap_depth(pcpui);
 
-       printd("Incoming TRAP %d on core %d, TF at %p\n", tf->tf_trapno, core_id(),
-              tf);
-       if ((tf->tf_cs & ~3) != GD_UT && (tf->tf_cs & ~3) != GD_KT) {
-               print_trapframe(tf);
+       printd("Incoming TRAP %d on core %d, TF at %p\n", hw_tf->tf_trapno,
+              core_id(), hw_tf);
+       if ((hw_tf->tf_cs & ~3) != GD_UT && (hw_tf->tf_cs & ~3) != GD_KT) {
+               print_trapframe(hw_tf);
                panic("Trapframe with invalid CS!");
        }
-       trap_dispatch(tf);
+       trap_dispatch(hw_tf);
        /* Return to the current process, which should be runnable.  If we're the
         * kernel, we should just return naturally.  Note that current and tf need
         * to still be okay (might not be after blocking) */
-       if (in_kernel(tf)) {
+       if (in_kernel(hw_tf)) {
                dec_ktrap_depth(pcpui);
                return;
        }
@@ -484,41 +483,44 @@ static void send_eoi(uint32_t trap_nr)
  *
  * Note that from hardware's perspective (PIC, etc), IRQs start from 0, but they
  * are all mapped up at PIC1_OFFSET for the cpu / irq_handler. */
-void irq_handler(struct trapframe *tf)
+void irq_handler(struct hw_trapframe *hw_tf)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        /* Copy out the TF for now */
-       if (!in_kernel(tf))
-               set_current_tf(pcpui, tf);
+       if (!in_kernel(hw_tf))
+               set_current_tf(pcpui, hw_tf);
        inc_irq_depth(pcpui);
        /* Coupled with cpu_halt() and smp_idle() */
-       abort_halt(tf);
+       abort_halt(hw_tf);
        //if (core_id())
-               printd("Incoming IRQ, ISR: %d on core %d\n", tf->tf_trapno, core_id());
-       if (check_spurious_irq(tf->tf_trapno))
+               printd("Incoming IRQ, ISR: %d on core %d\n", hw_tf->tf_trapno,
+                      core_id());
+       if (check_spurious_irq(hw_tf->tf_trapno))
                goto out_no_eoi;
        /* Send the EOI.  This means the PIC/LAPIC can send us the same IRQ vector,
         * and we'll handle it as soon as we reenable IRQs.  This does *not* mean
         * the hardware device that triggered the IRQ had its IRQ reset.  This does
         * mean we shouldn't enable irqs in a handler that isn't reentrant. */
-       assert(tf->tf_trapno >= 32);
-       send_eoi(tf->tf_trapno);
+       assert(hw_tf->tf_trapno >= 32);
+       send_eoi(hw_tf->tf_trapno);
 
        extern handler_wrapper_t (RO handler_wrappers)[NUM_HANDLER_WRAPPERS];
        // determine the interrupt handler table to use.  for now, pick the global
        handler_t TP(TV(t)) LCKD(&iht_lock) * handler_tbl = interrupt_handlers;
-       if (handler_tbl[tf->tf_trapno].isr != 0)
-               handler_tbl[tf->tf_trapno].isr(tf, handler_tbl[tf->tf_trapno].data);
+       if (handler_tbl[hw_tf->tf_trapno].isr != 0)
+               handler_tbl[hw_tf->tf_trapno].isr(hw_tf,
+                                                 handler_tbl[hw_tf->tf_trapno].data);
        // if we're a general purpose IPI function call, down the cpu_list
-       if ((I_SMP_CALL0 <= tf->tf_trapno) && (tf->tf_trapno <= I_SMP_CALL_LAST))
-               down_checklist(handler_wrappers[tf->tf_trapno & 0x0f].cpu_list);
+       if ((I_SMP_CALL0 <= hw_tf->tf_trapno) &&
+           (hw_tf->tf_trapno <= I_SMP_CALL_LAST))
+               down_checklist(handler_wrappers[hw_tf->tf_trapno & 0x0f].cpu_list);
        /* Fall-through */
 out_no_eoi:
        dec_irq_depth(pcpui);
        /* Return to the current process, which should be runnable.  If we're the
         * kernel, we should just return naturally.  Note that current and tf need
         * to still be okay (might not be after blocking) */
-       if (in_kernel(tf))
+       if (in_kernel(hw_tf))
                return;
        proc_restartcore();
        assert(0);
@@ -532,15 +534,15 @@ register_interrupt_handler(handler_t TP(TV(t)) table[],
        table[int_num].data = data;
 }
 
-void page_fault_handler(struct trapframe *tf)
+void page_fault_handler(struct hw_trapframe *hw_tf)
 {
        uint32_t fault_va = rcr2();
-       int prot = tf->tf_err & PF_ERROR_WRITE ? PROT_WRITE : PROT_READ;
+       int prot = hw_tf->tf_err & PF_ERROR_WRITE ? PROT_WRITE : PROT_READ;
        int err;
 
        /* TODO - handle kernel page faults */
-       if ((tf->tf_cs & 3) == 0) {
-               print_trapframe(tf);
+       if ((hw_tf->tf_cs & 3) == 0) {
+               print_trapframe(hw_tf);
                panic("Page Fault in the Kernel at 0x%08x!", fault_va);
                /* if we want to do something like kill a process or other code, be
                 * aware we are in a sort of irq-like context, meaning the main kernel
@@ -552,8 +554,8 @@ void page_fault_handler(struct trapframe *tf)
                /* Destroy the faulting process */
                printk("[%08x] user %s fault va %08x ip %08x on core %d with err %d\n",
                       current->pid, prot & PROT_READ ? "READ" : "WRITE", fault_va,
-                      tf->tf_eip, core_id(), err);
-               print_trapframe(tf);
+                      hw_tf->tf_eip, core_id(), err);
+               print_trapframe(hw_tf);
                proc_destroy(current);
        }
 }
@@ -566,19 +568,20 @@ void sysenter_init(void)
 }
 
 /* This is called from sysenter's asm, with the tf on the kernel stack. */
-void sysenter_callwrapper(struct trapframe *tf)
+/* TODO: use a sw_tf for sysenter */
+void sysenter_callwrapper(struct hw_trapframe *hw_tf)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
-       assert(!in_kernel(tf));
-       set_current_tf(pcpui, tf);
-       /* Once we've set_current_tf, we can enable interrupts.  This used to be
-        * mandatory (we had immediate KMSGs that would muck with cur_tf).  Now it
+       assert(!in_kernel(hw_tf));
+       set_current_tf(pcpui, hw_tf);
+       /* Once we've set_current_ctx, we can enable interrupts.  This used to be
+        * mandatory (we had immediate KMSGs that would muck with cur_ctx).  Now it
         * should only help for sanity/debugging. */
        enable_irq();
 
        /* Set up and run the async calls */
-       prep_syscalls(current, (struct syscall*)tf->tf_regs.reg_eax,
-                     tf->tf_regs.reg_esi);
+       prep_syscalls(current, (struct syscall*)hw_tf->tf_regs.reg_eax,
+                     hw_tf->tf_regs.reg_esi);
        /* If you use pcpui again, reread it, since you might have migrated */
        proc_restartcore();
 }
index 98c40fa..d60cde9 100644 (file)
@@ -70,9 +70,9 @@ extern gatedesc_t idt[];
 extern taskstate_t ts;
 
 /* Determines if the given TF was in the kernel or not. */
-static inline bool in_kernel(struct trapframe *tf)
+static inline bool in_kernel(struct hw_trapframe *hw_tf)
 {
-       return (tf->tf_cs & ~3) == GD_KT;
+       return (hw_tf->tf_cs & ~3) == GD_KT;
 }
 
 /* TODO: (HSS) */
index 83f3641..81ed12a 100644 (file)
@@ -9,7 +9,7 @@
 static void
 static_asserts_can_go_here()
 {
-       static_assert(SIZEOF_TRAPFRAME_T == sizeof(trapframe_t));
+       static_assert(SIZEOF_TRAPFRAME_T == sizeof(struct hw_trapframe));
 }
 
 void
index d9c9745..e66b1f9 100644 (file)
@@ -15,7 +15,8 @@ static void ss(uint64_t* addr, uint32_t val)
        asm ("mxtf.s f0, %0; fsd f0, %1" : : "r"(val), "m"(*addr));
 }
 
-static int emulate_fpu_silly(struct trapframe* state, ancillary_state_t* silly)
+static int emulate_fpu_silly(struct hw_trapframe *state,
+                             ancillary_state_t *silly)
 {
        int insn;
        if (memcpy_from_user(current, &insn, (void*)state->epc, 4))
@@ -113,7 +114,7 @@ static int emulate_fpu_silly(struct trapframe* state, ancillary_state_t* silly)
 }
 
 /* For now we can only emulate missing compute insns, not the whole FPU */
-int emulate_fpu(struct trapframe* state)
+int emulate_fpu(struct hw_trapframe *state)
 {
        if (!(state->sr & SR_EF))
        {
index 460400a..6ddaf16 100644 (file)
@@ -27,7 +27,7 @@
 uintptr_t core_stacktops[MAX_NUM_CPUS] = {0xcafebabe, 0};
 
 void
-advance_pc(trapframe_t* state)
+advance_pc(struct hw_trapframe *state)
 {
        state->epc += 4;
 }
@@ -71,16 +71,16 @@ set_current_tf(struct per_cpu_info *pcpui, struct trapframe *tf)
 }
 
 static int
-format_trapframe(trapframe_t *tf, char* buf, int bufsz)
+format_trapframe(struct hw_trapframe *hw_tf, char* buf, int bufsz)
 {
        // slightly hackish way to read out the instruction that faulted.
        // not guaranteed to be right 100% of the time
        uint32_t insn;
-       if(!(current && !memcpy_from_user(current,&insn,(void*)tf->epc,4)))
+       if(!(current && !memcpy_from_user(current,&insn,(void*)hw_tf->epc,4)))
                insn = -1;
 
        int len = snprintf(buf,bufsz,"TRAP frame at %p on core %d\n",
-                          tf, core_id());
+                          hw_tf, core_id());
        static const char* regnames[] = {
          "z ", "ra", "v0", "v1", "a0", "a1", "a2", "a3",
          "a4", "a5", "a6", "a7", "t0", "t1", "t2", "t3",
@@ -88,36 +88,37 @@ format_trapframe(trapframe_t *tf, char* buf, int bufsz)
          "s4", "s5", "s6", "s7", "s8", "fp", "sp", "tp"
        };
        
-       tf->gpr[0] = 0;
+       hw_tf->gpr[0] = 0;
        
        for(int i = 0; i < 32; i+=4)
        {
                for(int j = 0; j < 4; j++)
                        len += snprintf(buf+len, bufsz-len,
-                                       "%s %016lx%c", regnames[i+j], tf->gpr[i+j], 
+                                       "%s %016lx%c", regnames[i+j], hw_tf->gpr[i+j], 
                                        j < 3 ? ' ' : '\n');
        }
        len += snprintf(buf+len, bufsz-len,
                        "sr %016lx pc %016lx va %016lx insn       %08x\n",
-                                       tf->sr, tf->epc, tf->badvaddr, insn);
+                                       hw_tf->sr, hw_tf->epc, hw_tf->badvaddr, insn);
 
        buf[bufsz-1] = 0;
        return len;
 }
 
 void
-print_trapframe(trapframe_t* tf)
+print_trapframe(struct hw_trapframe *hw_tf)
 {
        char buf[1024];
-       int len = format_trapframe(tf,buf,sizeof(buf));
+       int len = format_trapframe(hw_tf, buf, sizeof(buf));
        cputbuf(buf,len);
 }
 
-static void exit_halt_loop(trapframe_t* tf)
+static void exit_halt_loop(struct hw_trapframe *hw_tf)
 {
        extern char after_cpu_halt;
-       if ((char*)tf->epc >= (char*)&cpu_halt && (char*)tf->epc < &after_cpu_halt)
-               tf->epc = tf->gpr[1];
+       if ((char*)hw_tf->epc >= (char*)&cpu_halt &&
+           (char*)hw_tf->epc < &after_cpu_halt)
+               hw_tf->epc = hw_tf->gpr[1];
 }
 
 static void handle_keypress(char c)
@@ -128,7 +129,7 @@ static void handle_keypress(char c)
        cons_init();
 }
 
-static void handle_host_interrupt(trapframe_t* tf)
+static void handle_host_interrupt(struct hw_trapframe *hw_tf)
 {
        uintptr_t fh = mtpcr(PCR_FROMHOST, 0);
        switch (fh >> 56)
@@ -139,20 +140,20 @@ static void handle_host_interrupt(trapframe_t* tf)
        }
 }
 
-static void handle_timer_interrupt(trapframe_t* tf)
+static void handle_timer_interrupt(struct hw_trapframe *hw_tf)
 {
-       timer_interrupt(tf, NULL);
+       timer_interrupt(hw_tf, NULL);
 }
 
 /* Assumes that any IPI you get is really a kernel message */
-static void handle_interprocessor_interrupt(trapframe_t* tf)
+static void handle_interprocessor_interrupt(struct hw_trapframe *hw_tf)
 {
        clear_ipi();
-       handle_kmsg_ipi(tf, 0);
+       handle_kmsg_ipi(hw_tf, 0);
 }
 
 static void
-unhandled_trap(trapframe_t* state, const char* name)
+unhandled_trap(struct hw_trapframe *state, const char* name)
 {
        static spinlock_t screwup_lock = SPINLOCK_INITIALIZER;
        spin_lock(&screwup_lock);
@@ -178,25 +179,25 @@ unhandled_trap(trapframe_t* state, const char* name)
 }
 
 static void
-handle_misaligned_fetch(trapframe_t* state)
+handle_misaligned_fetch(struct hw_trapframe *state)
 {
        unhandled_trap(state, "Misaligned Fetch");
 }
 
 static void
-handle_misaligned_load(trapframe_t* state)
+handle_misaligned_load(struct hw_trapframe *state)
 {
        unhandled_trap(state, "Misaligned Load");
 }
 
 static void
-handle_misaligned_store(trapframe_t* state)
+handle_misaligned_store(struct hw_trapframe *state)
 {
        unhandled_trap(state, "Misaligned Store");
 }
 
 static void
-handle_fault_fetch(trapframe_t* state)
+handle_fault_fetch(struct hw_trapframe *state)
 {
        if(in_kernel(state))
        {
@@ -211,7 +212,7 @@ handle_fault_fetch(trapframe_t* state)
 }
 
 static void
-handle_fault_load(trapframe_t* state)
+handle_fault_load(struct hw_trapframe *state)
 {
        if(in_kernel(state))
        {
@@ -226,7 +227,7 @@ handle_fault_load(trapframe_t* state)
 }
 
 static void
-handle_fault_store(trapframe_t* state)
+handle_fault_store(struct hw_trapframe *state)
 {
        if(in_kernel(state))
        {
@@ -241,7 +242,7 @@ handle_fault_store(trapframe_t* state)
 }
 
 static void
-handle_illegal_instruction(trapframe_t* state)
+handle_illegal_instruction(struct hw_trapframe *state)
 {
        assert(!in_kernel(state));
 
@@ -257,17 +258,17 @@ handle_illegal_instruction(trapframe_t* state)
 }
 
 static void
-handle_fp_disabled(trapframe_t* tf)
+handle_fp_disabled(struct hw_trapframe *hw_tf)
 {
-       if(in_kernel(tf))
+       if (in_kernel(hw_tf))
                panic("kernel executed an FP instruction!");
 
-       tf->sr |= SR_EF;
-       env_pop_tf(tf); /* We didn't save our TF, so don't use proc_restartcore */
+       hw_tf->sr |= SR_EF;
+       env_pop_tf(hw_tf); /* We didn't save our TF, so don't proc_restartcore */
 }
 
 static void
-handle_syscall(trapframe_t* state)
+handle_syscall(struct hw_trapframe *state)
 {
        uintptr_t a0 = state->gpr[4];
        uintptr_t a1 = state->gpr[5];
@@ -279,16 +280,16 @@ handle_syscall(trapframe_t* state)
 }
 
 static void
-handle_breakpoint(trapframe_t* state)
+handle_breakpoint(struct hw_trapframe *state)
 {
        advance_pc(state);
        monitor(state);
 }
 
 void
-handle_trap(trapframe_t* tf)
+handle_trap(struct hw_trapframe *hw_tf)
 {
-       static void (*const trap_handlers[])(trapframe_t*) = {
+       static void (*const trap_handlers[])(struct hw_trapframe *) = {
          [CAUSE_MISALIGNED_FETCH] = handle_misaligned_fetch,
          [CAUSE_FAULT_FETCH] = handle_fault_fetch,
          [CAUSE_ILLEGAL_INSTRUCTION] = handle_illegal_instruction,
@@ -302,46 +303,46 @@ handle_trap(trapframe_t* tf)
          [CAUSE_FAULT_STORE] = handle_fault_store,
        };
 
-       static void (*const irq_handlers[])(trapframe_t*) = {
+       static void (*const irq_handlers[])(struct hw_trapframe *) = {
          [IRQ_TIMER] = handle_timer_interrupt,
          [IRQ_HOST] = handle_host_interrupt,
          [IRQ_IPI] = handle_interprocessor_interrupt,
        };
        
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
-       if (tf->cause < 0)
+       if (hw_tf->cause < 0)
        {
-               uint8_t irq = tf->cause;
+               uint8_t irq = hw_tf->cause;
                assert(irq < sizeof(irq_handlers)/sizeof(irq_handlers[0]) &&
                       irq_handlers[irq]);
 
-               if (in_kernel(tf))
-                       exit_halt_loop(tf);
+               if (in_kernel(hw_tf))
+                       exit_halt_loop(hw_tf);
                else
-                       set_current_tf(&per_cpu_info[core_id()], tf);
+                       set_current_tf(&per_cpu_info[core_id()], hw_tf);
 
                inc_irq_depth(pcpui);
-               irq_handlers[irq](tf);
+               irq_handlers[irq](hw_tf);
                dec_irq_depth(pcpui);
        }
        else
        {
-               assert(tf->cause < sizeof(trap_handlers)/sizeof(trap_handlers[0]) &&
-                      trap_handlers[tf->cause]);
-               if (in_kernel(tf)) {
+               assert(hw_tf->cause < sizeof(trap_handlers)/sizeof(trap_handlers[0]) &&
+                      trap_handlers[hw_tf->cause]);
+               if (in_kernel(hw_tf)) {
                        inc_ktrap_depth(pcpui);
-                       trap_handlers[tf->cause](tf);
+                       trap_handlers[hw_tf->cause](hw_tf);
                        dec_ktrap_depth(pcpui);
                } else {
-                       trap_handlers[tf->cause](tf);
+                       trap_handlers[hw_tf->cause](hw_tf);
                }
        }
        
        /* Return to the current process, which should be runnable.  If we're the
         * kernel, we should just return naturally.  Note that current and tf need
         * to still be okay (might not be after blocking) */
-       if (in_kernel(tf))
-               env_pop_tf(tf);
+       if (in_kernel(hw_tf))
+               env_pop_tf(hw_tf);      /* TODO: for a kernel tf?  change names? */
        else
                proc_restartcore();
 }
index 46bf232..fe53eb5 100644 (file)
@@ -19,9 +19,9 @@
 /* Kernel message interrupt vector.  ignored, for the most part */
 #define I_KERNEL_MSG 255
 
-static inline bool in_kernel(struct trapframe *tf)
+static inline bool in_kernel(struct hw_trapframe *hw_tf)
 {
-       return tf->sr & SR_PS;
+       return hw_tf->sr & SR_PS;
 }
 
 static inline void __attribute__((always_inline))
@@ -35,12 +35,12 @@ set_stack_pointer(uintptr_t sp)
  * Implemented with extern function to cause compiler to clobber most regs. */
 static inline void save_kernel_ctx(struct kernel_ctx *ctx)
 {
-  extern void save_kernel_tf_asm(struct trapframe*);
+  extern void save_kernel_tf_asm(struct hw_trapframe*);
        save_kernel_tf_asm(&ctx->hw_tf);
 }
 
-void handle_trap(struct trapframe *tf);
-int emulate_fpu(struct trapframe *tf);
+void handle_trap(struct hw_trapframe *hw_tf);
+int emulate_fpu(struct hw_trapframe *hw_tf);
 
 #endif
 
index f5c516e..368e041 100644 (file)
@@ -18,7 +18,7 @@
 void
 static_asserts_can_go_here()
 {
-       static_assert(SIZEOF_TRAPFRAME_T == sizeof(trapframe_t));
+       static_assert(SIZEOF_TRAPFRAME_T == sizeof(struct hw_trapframe));
        static_assert(SIZEOF_TRAPFRAME_T % 8 == 0);
        static_assert(SIZEOF_KERNEL_MESSAGE_T == sizeof(kernel_message_t));
        static_assert(SIZEOF_KERNEL_MESSAGE_T % 8 == 0);
index c6f98b0..883391e 100644 (file)
@@ -5,7 +5,8 @@
 #include <pmap.h>
 #include <smp.h>
 
-static inline uint32_t* effective_address(trapframe_t* state, uint32_t insn)
+static inline uint32_t *effective_address(struct hw_trapframe *state,
+                                          uint32_t insn)
 {
        uint32_t rs1 = state->gpr[(insn>>14)&0x1F];
        uint32_t rs2 = state->gpr[insn&0x1F];
@@ -15,14 +16,14 @@ static inline uint32_t* effective_address(trapframe_t* state, uint32_t insn)
        return (uint32_t*)((insn & 0x2000) ? rs1+imm : rs1+rs2);
 }
 
-void fp_access_exception(trapframe_t* state, void* addr)
+void fp_access_exception(struct hw_trapframe *state, void *addr)
 {
        state->fault_status = 1;
        state->fault_addr = (uint32_t)addr;
        data_access_exception(state);
 }
 
-static inline uint32_t fp_load_word(trapframe_t* state, uint32_t* addr)
+static inline uint32_t fp_load_word(struct hw_trapframe *state, uint32_t *addr)
 {
        uint32_t word;
        if((long)addr % sizeof(word))
@@ -32,7 +33,7 @@ static inline uint32_t fp_load_word(trapframe_t* state, uint32_t* addr)
        return word;
 }
 
-static inline uint64_t fp_load_dword(trapframe_t* state, uint64_t* addr)
+static inline uint64_t fp_load_dword(struct hw_trapframe *state, uint64_t *addr)
 {
        uint64_t word;
        if((long)addr % sizeof(word))
@@ -42,7 +43,8 @@ static inline uint64_t fp_load_dword(trapframe_t* state, uint64_t* addr)
        return word;
 }
 
-static inline void fp_store_word(trapframe_t* state, uint32_t* addr, uint32_t word)
+static inline void fp_store_word(struct hw_trapframe *state, uint32_t *addr,
+                                 uint32_t word)
 {
        if((long)addr % sizeof(word))
                address_unaligned(state);
@@ -50,7 +52,8 @@ static inline void fp_store_word(trapframe_t* state, uint32_t* addr, uint32_t wo
                fp_access_exception(state,addr);
 }
 
-static inline void fp_store_dword(trapframe_t* state, uint64_t* addr, uint64_t word)
+static inline void fp_store_dword(struct hw_trapframe *state, uint64_t *addr,
+                                  uint64_t word)
 {
        if((long)addr % sizeof(word))
                address_unaligned(state);
@@ -58,7 +61,7 @@ static inline void fp_store_dword(trapframe_t* state, uint64_t* addr, uint64_t w
                fp_access_exception(state,addr);
 }
 
-void emulate_fpu(trapframe_t* state, ancillary_state_t* astate)
+void emulate_fpu(struct hw_trapframe *state, ancillary_state_t *astate)
 {
        sparcfpu_t thefpu;
        sparcfpu_t* fpu = &thefpu;
index 391e427..4b446eb 100644 (file)
@@ -35,8 +35,7 @@
  * per_cpu_info. */
 uintptr_t core_stacktops[MAX_NUM_CPUS] = {0xcafebabe, 0};
 
-void
-advance_pc(trapframe_t* state)
+void advance_pc(struct hw_trapframe *state)
 {
        state->pc = state->npc;
        state->npc += 4;
@@ -92,44 +91,43 @@ static void set_current_tf(struct per_cpu_info *pcpui, struct trapframe *tf)
        pcpui->cur_tf = &pcpui->actual_tf;
 }
 
-static int
-format_trapframe(trapframe_t *tf, char* buf, int bufsz)
+static int format_trapframe(struct hw_trapframe *hw_tf, char *buf, int bufsz)
 {
        // slightly hackish way to read out the instruction that faulted.
        // not guaranteed to be right 100% of the time
        uint32_t insn;
-       if(!(current && !memcpy_from_user(current,&insn,(void*)tf->pc,4)))
+       if(!(current && !memcpy_from_user(current, &insn, (void*)hw_tf->pc, 4)))
                insn = -1;
 
        int len = snprintf(buf,bufsz,"TRAP frame at %p on core %d\n",
-                          tf, core_id());
+                          hw_tf, core_id());
 
        for(int i = 0; i < 8; i++)
        {
                len += snprintf(buf+len,bufsz-len,
                                "  g%d   0x%08x  o%d   0x%08x"
                                "  l%d   0x%08x  i%d   0x%08x\n",
-                               i,tf->gpr[i],i,tf->gpr[i+8],
-                               i,tf->gpr[i+16],i,tf->gpr[i+24]);
+                               i, hw_tf->gpr[i], i, hw_tf->gpr[i+8],
+                               i, hw_tf->gpr[i+16], i, hw_tf->gpr[i+24]);
        }
 
        len += snprintf(buf+len,bufsz-len,
                        "  psr  0x%08x  pc   0x%08x  npc  0x%08x  insn 0x%08x\n",
-                       tf->psr,tf->pc,tf->npc,insn);
+                       hw_tf->psr, hw_tf->pc, hw_tf->npc,insn);
        len += snprintf(buf+len,bufsz-len,
                        "  y    0x%08x  fsr  0x%08x  far  0x%08x  tbr  0x%08x\n",
-                       tf->y,tf->fault_status,tf->fault_addr,tf->tbr);
+                       hw_tf->y, hw_tf->fault_status, hw_tf->fault_addr,
+                       hw_tf->tbr);
        len += snprintf(buf+len,bufsz-len,
-                       "  timestamp  %21lld\n",tf->timestamp);
+                       "  timestamp  %21lld\n", hw_tf->timestamp);
 
        return len;
 }
 
-void
-print_trapframe(trapframe_t* tf)
+void print_trapframe(struct hw_trapframe *hw_tf)
 {
        char buf[1024];
-       int len = format_trapframe(tf,buf,sizeof(buf));
+       int len = format_trapframe(hw_tf, buf, sizeof(buf));
        cputbuf(buf,len);
 }
 
@@ -177,21 +175,20 @@ get_trapname(uint8_t tt, char buf[TRAPNAME_MAX])
 }
 
 /* Assumes that any IPI you get is really a kernel message */
-void handle_ipi(trapframe_t* tf)
+void handle_ipi(struct hw_trapframe *hw_tf)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
-       if (!in_kernel(tf))
-               set_current_tf(pcpui, tf);
-       else if((void*)tf->pc == &__cpu_halt) // break out of the __cpu_halt loop
-               advance_pc(tf);
+       if (!in_kernel(hw_tf))
+               set_current_tf(pcpui, hw_tf);
+       else if((void*)hw_tf->pc == &__cpu_halt) // break out of the __cpu_halt loop
+               advance_pc(hw_tf);
 
        inc_irq_depth(pcpui);
-       handle_kmsg_ipi(tf, 0);
+       handle_kmsg_ipi(hw_tf, 0);
        dec_irq_depth(pcpui);
 }
 
-void
-unhandled_trap(trapframe_t* state)
+void unhandled_trap(struct hw_trapframe *state)
 {
        char buf[TRAPNAME_MAX];
        uint32_t trap_type = (state->tbr >> 4) & 0xFF;
@@ -223,60 +220,52 @@ unhandled_trap(trapframe_t* state)
        }
 }
 
-static trapframe_t*
-stack_fucked(trapframe_t* state)
+static hw_trapframe *stack_fucked(struct hw_trapframe *state)
 {
        warn("You just got stack fucked!");
        extern char tflush1, tflush2;
        if(state->pc == (uint32_t)&tflush1 || state->pc == (uint32_t)&tflush2)
-               return (trapframe_t*)(bootstacktop - core_id()*KSTKSIZE
-                                                  - sizeof(trapframe_t));
+               return (struct hw_trapframe*)(bootstacktop - core_id()*KSTKSIZE
+                                                  - sizeof(struct hw_trapframe));
        return state;
 }
 
-void
-fill_misaligned(trapframe_t* state)
+void fill_misaligned(struct hw_trapframe *state)
 {
        state = stack_fucked(state);
        state->tbr = (state->tbr & ~0xFFF) | 0x070;
        address_unaligned(state);
 }
 
-void
-fill_pagefault(trapframe_t* state)
+void fill_pagefault(struct hw_trapframe *state)
 {
        state = stack_fucked(state);
        state->tbr = (state->tbr & ~0xFFF) | 0x090;
        data_access_exception(state);
 }
 
-void
-spill_misaligned(trapframe_t* state)
+void spill_misaligned(struct hw_trapframe *state)
 {
        fill_misaligned(state);
 }
 
-void
-spill_pagefault(trapframe_t* state)
+void spill_pagefault(struct hw_trapframe *state)
 {
        fill_pagefault(state);
 }
 
-void
-address_unaligned(trapframe_t* state)
+void address_unaligned(struct hw_trapframe *state)
 {
        unhandled_trap(state);
 }
 
-void
-instruction_access_exception(trapframe_t* state)
+void instruction_access_exception(struct hw_trapframe *state)
 {
        if(in_kernel(state) || handle_page_fault(current,state->pc,PROT_EXEC))
                unhandled_trap(state);
 }
 
-void
-data_access_exception(trapframe_t* state)
+void data_access_exception(struct hw_trapframe *state)
 {
        int prot = (state->fault_status & MMU_FSR_WR) ? PROT_WRITE : PROT_READ;
 
@@ -284,20 +273,18 @@ data_access_exception(trapframe_t* state)
                unhandled_trap(state);
 }
 
-void
-illegal_instruction(trapframe_t* state)
+void illegal_instruction(struct hw_trapframe *state)
 {
        unhandled_trap(state);
 }
 
-void
-real_fp_exception(trapframe_t* state, ancillary_state_t* sillystate)
+void real_fp_exception(struct hw_trapframe *state,
+                       ancillary_state_t *sillystate)
 {
        unhandled_trap(state);
 }
 
-void
-fp_exception(trapframe_t* state)
+void fp_exception(struct hw_trapframe *state)
 {
        ancillary_state_t sillystate;
        save_fp_state(&sillystate);     
@@ -310,8 +297,7 @@ fp_exception(trapframe_t* state)
        restore_fp_state(&sillystate);
 }
 
-void
-fp_disabled(trapframe_t* state)
+void fp_disabled(struct hw_trapframe *state)
 {
        if(in_kernel(state))
                panic("kernel executed an FP instruction!");
@@ -319,26 +305,24 @@ fp_disabled(trapframe_t* state)
        state->psr |= PSR_EF;
 }
 
-void
-handle_pop_tf(trapframe_t* state)
+void handle_pop_tf(struct hw_trapframe *state)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        set_current_tf(pcpui, state);
 
-       trapframe_t tf, *tf_p = &tf;
-       if (memcpy_from_user(current,&tf,(void*)state->gpr[8],sizeof(tf))) {
+       struct hw_trapframe hw_tf, *hw_tf_p = &hw_tf;
+       if (memcpy_from_user(current, &hw_tf, (void*)state->gpr[8],sizeof(hw_tf))) {
                enable_irq();
                proc_destroy(current);
                proc_restartcore();
        }
 
-       proc_secure_trapframe(&tf);
-       set_current_tf(pcpui, tf_p);
+       proc_secure_trapframe(&hw_tf);
+       set_current_tf(pcpui, hw_tf_p);
        proc_restartcore();
 }
 
-void
-handle_set_tf(trapframe_t* state)
+void handle_set_tf(struct hw_trapframe *state)
 {
        advance_pc(state);
        if (memcpy_to_user(current,(void*)state->gpr[8],state,sizeof(*state))) {
@@ -349,8 +333,7 @@ handle_set_tf(trapframe_t* state)
        }
 }
 
-void
-handle_syscall(trapframe_t* state)
+void handle_syscall(struct hw_trapframe *state)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        uint32_t a0 = state->gpr[1];
@@ -385,16 +368,14 @@ flush_windows()
                      : "=r"(foo) : "r"(foo));
 }
    
-void
-handle_flushw(trapframe_t* state)
+void handle_flushw(struct hw_trapframe *state)
 {
        // don't actually need to do anything here.
        // trap_entry flushes user windows to the stack.
        advance_pc(state);
 }
 
-void
-handle_breakpoint(trapframe_t* state)
+void handle_breakpoint(struct hw_trapframe *state)
 {
        advance_pc(state);
        monitor(state);
index d720d3b..f8661a6 100644 (file)
@@ -24,21 +24,21 @@ uintptr_t core_stacktops[MAX_NUM_CPUS];
 
 /* the struct trapframe and friends are in ros/arch/trapframe.h */
 
-void data_access_exception(trapframe_t* state);
-void real_fp_exception(trapframe_t* state, ancillary_state_t* astate);
-void address_unaligned(trapframe_t* state);
-void illegal_instruction(trapframe_t* state);
+void data_access_exception(struct hw_trapframe *state);
+void real_fp_exception(struct hw_trapframe *state, ancillary_state_t *astate);
+void address_unaligned(struct hw_trapframe *state);
+void illegal_instruction(struct hw_trapframe *state);
 
 void save_fp_state(ancillary_state_t* silly);
 void restore_fp_state(ancillary_state_t* silly);
-void emulate_fpu(trapframe_t* state, ancillary_state_t* astate);
+void emulate_fpu(struct hw_trapframe *state, ancillary_state_t *astate);
 
-static inline bool in_kernel(struct trapframe *tf)
+static inline bool in_kernel(struct hw_trapframe *hw_tf)
 {
-       return tf->psr & PSR_PS;
+       return hw_tf->psr & PSR_PS;
 }
 
-/* Needs to leave room for a trapframe at the top of the stack. */
+/* Needs to leave room for a hw_trapframe at the top of the stack. */
 static inline void __attribute__((always_inline))
 set_stack_pointer(uintptr_t sp)
 {
index 6f285b1..2e5034c 100644 (file)
@@ -7,30 +7,30 @@
 // Activate the kernel monitor,
 // optionally providing a trap frame indicating the current state
 // (NULL if none).
-void monitor(trapframe_t *tf);
+void monitor(struct hw_trapframe *hw_tf);
 
 // Functions implementing monitor commands.
-int mon_help(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_kerninfo(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_backtrace(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_ps(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_reboot(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_showmapping(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_setmapperm(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_cpuinfo(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_nanwan(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_bin_ls(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_bin_run(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_manager(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_procinfo(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_exit(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_kfunc(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_notify(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_measure(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_trace(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_monitor(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_fs(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_bb(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_alarm(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
+int mon_help(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_kerninfo(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_backtrace(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_ps(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_reboot(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_showmapping(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_setmapperm(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_cpuinfo(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_nanwan(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_bin_ls(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_bin_run(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_manager(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_procinfo(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_exit(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_kfunc(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_notify(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_measure(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_trace(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_monitor(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_fs(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_bb(int argc, char **argv, struct hw_trapframe *hw_tf);
+int mon_alarm(int argc, char **argv, struct hw_trapframe *hw_tf);
 
 #endif // !ROS_KERN_MONITOR_H
index a7fb688..9aecae6 100644 (file)
@@ -7,6 +7,7 @@
  */
 
 #include <ros/common.h>
+#include <trap.h>
 
 void test_ipi_sending(void);
 void test_pic_reception(void);
@@ -34,10 +35,8 @@ void test_radix_tree(void);
 void test_random_fs(void);
 void test_kthreads(void);
 
-struct trapframe_t;
-
-void test_hello_world_handler(trapframe_t *tf, void* data);
-void test_print_info_handler(trapframe_t *tf, void* data);
-void test_barrier_handler(trapframe_t *tf, void* data);
+void test_hello_world_handler(struct hw_trapframe *hw_tf, void *data);
+void test_print_info_handler(struct hw_trapframe *hw_tf, void *data);
+void test_barrier_handler(struct hw_trapframe *hw_tf, void *data);
 
 #endif /* !ROS_INC_TESTING_H */
index 3ffaeac..c4fb1d1 100644 (file)
@@ -22,8 +22,8 @@ struct kernel_ctx {
 #include <arch/trap.h>
 
 // func ptr for interrupt service routines
-typedef void ( *poly_isr_t)(trapframe_t* tf, TV(t) data);
-typedef void (*isr_t)(trapframe_t* tf, void * data);
+typedef void (*poly_isr_t)(struct hw_trapframe *hw_tf, void *data);
+typedef void (*isr_t)(struct hw_trapframe *hw_tf, void *data);
 typedef struct InterruptHandler {
        poly_isr_t isr;
        TV(t) data;
@@ -40,12 +40,12 @@ void
 register_interrupt_handler(handler_t SSOMELOCK (CT(NUM_INTERRUPT_HANDLERS)table)[],
                            uint8_t int_num,
                            poly_isr_t handler, TV(t) data);
-void print_trapframe(trapframe_t *tf);
-void page_fault_handler(trapframe_t *tf);
+void print_trapframe(struct hw_trapframe *hw_tf);
+void page_fault_handler(struct hw_trapframe *hw_tf);
 /* Generic per-core timer interrupt handler.  set_percore_timer() will fire the
  * timer_interrupt(). */
 void set_core_timer(uint32_t usec, bool periodic);
-void timer_interrupt(struct trapframe *tf, void *data);
+void timer_interrupt(struct hw_trapframe *hw_tf, void *data);
 
 void sysenter_init(void);
 extern void sysenter_handler();
@@ -105,7 +105,7 @@ typedef struct kernel_message kernel_message_t;
 void kernel_msg_init(void);
 uint32_t send_kernel_message(uint32_t dst, amr_t pc, long arg0, long arg1,
                              long arg2, int type);
-void handle_kmsg_ipi(struct trapframe *tf, void *data);
+void handle_kmsg_ipi(struct hw_trapframe *hw_tf, void *data);
 void process_routine_kmsg(void);
 void print_kmsgs(uint32_t coreid);
 
index 54d0b51..afc335e 100644 (file)
@@ -38,7 +38,7 @@ typedef struct command {
        const char *NTS name;
        const char *NTS desc;
        // return -1 to force monitor to exit
-       int (*func)(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
+       int (*func)(int argc, char **argv, struct hw_trapframe *hw_tf);
 } command_t;
 
 static command_t (RO commands)[] = {
@@ -69,7 +69,7 @@ static command_t (RO commands)[] = {
 
 /***** Implementations of basic kernel monitor commands *****/
 
-int mon_help(int argc, char **argv, trapframe_t *tf)
+int mon_help(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        int i;
 
@@ -78,13 +78,13 @@ int mon_help(int argc, char **argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_ps(int argc, char** argv, trapframe_t *tf)
+int mon_ps(int argc, char** argv, struct hw_trapframe *hw_tf)
 {
        print_allpids();
        return 0;
 }
 
-int mon_kerninfo(int argc, char **argv, trapframe_t *tf)
+int mon_kerninfo(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        extern char (RO SNT _start)[], (RO SNT etext)[], (RO SNT edata)[], (RO SNT end)[];
 
@@ -125,13 +125,13 @@ static char RO* function_of(uint32_t address)
 }
 #endif
 
-int mon_backtrace(int argc, char **argv, trapframe_t *tf)
+int mon_backtrace(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        backtrace();
        return 0;
 }
 
-int mon_reboot(int argc, char **argv, trapframe_t *tf)
+int mon_reboot(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        cprintf("[Scottish Accent]: She's goin' down, Cap'n!\n");
        reboot();
@@ -141,7 +141,7 @@ int mon_reboot(int argc, char **argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_showmapping(int argc, char **argv, trapframe_t *tf)
+int mon_showmapping(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        if (argc < 2) {
                cprintf("Shows virtual -> physical mappings for a virtual address range.\n");
@@ -164,7 +164,7 @@ int mon_showmapping(int argc, char **argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_setmapperm(int argc, char **argv, trapframe_t *tf)
+int mon_setmapperm(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
 #ifndef __i386__
        cprintf("I don't support this call yet!\n");
@@ -204,7 +204,7 @@ int mon_setmapperm(int argc, char **argv, trapframe_t *tf)
 #endif
 }
 
-int mon_cpuinfo(int argc, char **argv, trapframe_t *tf)
+int mon_cpuinfo(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        cprintf("Number of CPUs detected: %d\n", num_cpus);
        cprintf("Calling CPU's ID: 0x%08x\n", core_id());
@@ -217,14 +217,14 @@ int mon_cpuinfo(int argc, char **argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_manager(int argc, char** argv, trapframe_t *tf)
+int mon_manager(int argc, char** argv, struct hw_trapframe *hw_tf)
 {
        manager();
        panic("should never get here");
        return 0;
 }
 
-int mon_nanwan(int argc, char **argv, trapframe_t *tf)
+int mon_nanwan(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        /* Borrowed with love from http://www.geocities.com/SoHo/7373/zoo.htm
         * (http://www.ascii-art.com/).  Slightly modified to make it 25 lines tall.
@@ -256,7 +256,7 @@ int mon_nanwan(int argc, char **argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_bin_ls(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_bin_ls(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        struct dirent dir = {0};
        struct file *bin_dir;
@@ -276,7 +276,7 @@ int mon_bin_ls(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_bin_run(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_bin_run(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        if (argc < 2) {
                printk("Usage: bin_run FILENAME\n");
@@ -311,7 +311,7 @@ int mon_bin_run(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_procinfo(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_procinfo(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        int8_t irq_state = 0;
        if (argc < 2) {
@@ -371,12 +371,12 @@ int mon_procinfo(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_exit(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_exit(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        return -1;
 }
 
-int mon_kfunc(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_kfunc(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        #ifndef __i386__
        printk("Only supported on x86 for now.  =(\n");
@@ -442,7 +442,7 @@ int mon_kfunc(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
 }
 
 /* Sending a vcoreid forces an event and an IPI/notification */
-int mon_notify(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_notify(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        struct proc *p;
        uint32_t vcoreid;
@@ -473,7 +473,7 @@ int mon_notify(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
 
 /* Micro-benchmarky Measurements.  This is really fragile code that probably
  * won't work perfectly, esp as the kernel evolves. */
-int mon_measure(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_measure(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        uint64_t begin = 0, diff = 0;
        uint32_t end_refcnt = 0;
@@ -642,7 +642,7 @@ int mon_measure(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_trace(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_trace(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        uint32_t core;
        if (argc < 2) {
@@ -706,7 +706,7 @@ int mon_trace(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_monitor(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_monitor(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        if (argc < 2) {
                printk("Usage: monitor COREID\n");
@@ -726,7 +726,7 @@ int mon_monitor(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
 #define WHITESPACE "\t\r\n "
 #define MAXARGS 16
 
-static int runcmd(char *NTS real_buf, trapframe_t *tf) {
+static int runcmd(char *NTS real_buf, struct hw_trapframe *hw_tf) {
        char * buf = NTEXPAND(real_buf);
        int argc;
        char *NTS argv[MAXARGS];
@@ -759,13 +759,13 @@ static int runcmd(char *NTS real_buf, trapframe_t *tf) {
                return 0;
        for (i = 0; i < NCOMMANDS; i++) {
                if (strcmp(argv[0], commands[i].name) == 0)
-                       return commands[i].func(argc, argv, tf);
+                       return commands[i].func(argc, argv, hw_tf);
        }
        cprintf("Unknown command '%s'\n", argv[0]);
        return 0;
 }
 
-void monitor(struct trapframe *tf)
+void monitor(struct hw_trapframe *hw_tf)
 {
        #define MON_CMD_LENGTH 256
        char buf[MON_CMD_LENGTH];
@@ -778,20 +778,20 @@ void monitor(struct trapframe *tf)
                printk("Entering Nanwan's Dungeon on Core %d (Ints off):\n", core_id());
        printk("Type 'help' for a list of commands.\n");
 
-       if (tf != NULL)
-               print_trapframe(tf);
+       if (hw_tf != NULL)
+               print_trapframe(hw_tf);
 
        while (1) {
                cnt = readline(buf, MON_CMD_LENGTH, "ROS(Core %d)> ", core_id());
                if (cnt > 0) {
                        buf[cnt] = 0;
-                       if (runcmd(buf, tf) < 0)
+                       if (runcmd(buf, hw_tf) < 0)
                                break;
                }
        }
 }
 
-int mon_fs(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_fs(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        /* this assumes one mounted FS at the NS root */
        struct super_block *sb;
@@ -885,13 +885,13 @@ int mon_fs(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
        return 0;
 }
 
-int mon_bb(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
+int mon_bb(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        char *l_argv[3] = {"", "busybox", "ash"};
-       return mon_bin_run(3, l_argv, tf);
+       return mon_bin_run(3, l_argv, hw_tf);
 }
 
-int mon_alarm(int argc, char **argv, struct trapframe *tf)
+int mon_alarm(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
        if (argc < 2) {
                printk("Usage: alarm OPTION\n");
index 7f15984..bc76616 100644 (file)
@@ -386,7 +386,7 @@ void test_bitmasks(void)
 
 checklist_t *RO the_global_list;
 
-void test_checklist_handler(trapframe_t *tf, void* data)
+static void test_checklist_handler(struct hw_trapframe *hw_tf, void *data)
 {
        udelay(1000000);
        cprintf("down_checklist(%x,%d)\n", the_global_list, core_id());
@@ -428,17 +428,13 @@ void test_checklists(void)
 
 atomic_t a, b, c;
 
-#ifdef __IVY__
-void test_incrementer_handler(trapframe_t *tf, atomic_t *data)
-#else
-void test_incrementer_handler(trapframe_t *tf, void *data)
-#endif
+static void test_incrementer_handler(struct hw_trapframe *tf, void *data)
 {
        assert(data);
        atomic_inc(data);
 }
 
-void test_null_handler(trapframe_t *tf, void* data)
+static void test_null_handler(struct hw_trapframe *tf, void *data)
 {
        asm volatile("nop");
 }
@@ -571,24 +567,24 @@ void test_lapic_status_bit(void)
 /************************************************************/
 /* ISR Handler Functions */
 
-void test_hello_world_handler(trapframe_t *tf, void* data)
+void test_hello_world_handler(struct hw_trapframe *hw_tf, void *data)
 {
        int trapno;
        #if defined(__i386__)
-       trapno = tf->tf_trapno;
+       trapno = hw_tf->tf_trapno;
        #elif defined(__sparc_v8__)
-       trapno = (tf->tbr >> 4) & 0xFF;
+       trapno = (hw_tf->tbr >> 4) & 0xFF;
        #else
        trapno = 0;
        #endif
 
        cprintf("Incoming IRQ, ISR: %d on core %d with tf at 0x%08x\n",
-               trapno, core_id(), tf);
+               trapno, core_id(), hw_tf);
 }
 
 spinlock_t print_info_lock = SPINLOCK_INITIALIZER_IRQSAVE;
 
-void test_print_info_handler(trapframe_t *tf, void* data)
+void test_print_info_handler(struct hw_trapframe *hw_tf, void *data)
 {
        uint64_t tsc = read_tsc();
 
@@ -620,7 +616,7 @@ void test_print_info_handler(trapframe_t *tf, void* data)
        spin_unlock_irqsave(&print_info_lock);
 }
 
-void test_barrier_handler(trapframe_t *tf, void* data)
+void test_barrier_handler(struct hw_trapframe *hw_tf, void *data)
 {
        cprintf("Round 1: Core %d\n", core_id());
        waiton_barrier(&test_cpu_array);
@@ -636,11 +632,7 @@ void test_barrier_handler(trapframe_t *tf, void* data)
        //cprintf("Round 4: Core %d\n", core_id());
 }
 
-#ifdef __IVY__
-static void test_waiting_handler(trapframe_t *tf, atomic_t *data)
-#else
-static void test_waiting_handler(trapframe_t *tf, void *data)
-#endif
+static void test_waiting_handler(struct hw_trapframe *hw_tf, void *data)
 {
        atomic_dec(data);
 }
index 9364ca0..b733d27 100644 (file)
@@ -44,7 +44,7 @@ void train_timing()
 /* Convenience wrapper called when a core's timer interrupt goes off.  Not to be
  * confused with global timers (like the PIC).  Do not put your code here.  If
  * you want something to happen in the future, set an alarm. */
-void timer_interrupt(struct trapframe *tf, void *data)
+void timer_interrupt(struct hw_trapframe *hw_tf, void *data)
 {
        struct timer_chain *pcpui_tchain = &per_cpu_info[core_id()].tchain;
        trigger_tchain(pcpui_tchain);
index 0c070a0..e88c5ab 100644 (file)
@@ -65,7 +65,7 @@ uint32_t send_kernel_message(uint32_t dst, amr_t pc, long arg0, long arg1,
  *
  * Note that all of this happens from interrupt context, and interrupts are
  * disabled. */
-void handle_kmsg_ipi(struct trapframe *tf, void *data)
+void handle_kmsg_ipi(struct hw_trapframe *hw_tf, void *data)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
        struct kernel_message *kmsg_i, *temp;