Fix potential compile warning.
[akaros.git] / kern / include / trap.h
index 16811ef..60e25d5 100644 (file)
@@ -7,67 +7,39 @@
 #include <arch/arch.h>
 #include <arch/mmu.h>
 #include <sys/queue.h>
-/* #include <arch/trap.h> included below */
-
-/* For kernel contexts, when we save/restore/move them around.  For now, we'll
- * just use the old trapframe/hw_trap, but in the future we can slim this down a
- * bit.  Additionally, we might have different types of these in the future, if
- * we ever do non-cooperative kthread scheduling. */
-struct kernel_ctx {
-       /* RISCV's current pop_kernel_ctx assumes the hw_tf is the first member */
-       struct hw_trapframe             hw_tf;
-};
-
-/* Arch needs to hear about 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 struct InterruptHandler {
-       poly_isr_t isr;
-       TV(t) data;
-} handler_t;
-
-#ifdef __IVY__
-#pragma cilnoremove("iht_lock")
-extern spinlock_t iht_lock;
-#endif
-extern handler_t LCKD(&iht_lock) (CT(NUM_INTERRUPT_HANDLERS) RO interrupt_handlers)[];
+typedef void (*isr_t)(struct hw_trapframe *hw_tf, void *data);
 
 void idt_init(void);
-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);
+int register_irq(int irq, isr_t handler, void *irq_arg, uint32_t tbdf);
+int route_irqs(int cpu_vec, int coreid);
+void print_trapframe(struct hw_trapframe *hw_tf);
+void print_user_ctx(struct user_context *ctx);
 /* 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 sysenter_init(void);
-extern void sysenter_handler();
+void timer_interrupt(struct hw_trapframe *hw_tf, void *data);
 
 extern inline void save_fp_state(struct ancillary_state *silly);
 extern inline void restore_fp_state(struct ancillary_state *silly);
+extern inline void init_fp_state(void);
 /* Set stacktop for the current core to be the stack the kernel will start on
  * when trapping/interrupting from userspace */
 void set_stack_top(uintptr_t stacktop);
 uintptr_t get_stack_top(void);
 
-/* It's important that this is inline and that ctx is not a stack variable */
-static inline void save_kernel_ctx(struct kernel_ctx *ctx)
-                   __attribute__((always_inline));
-void pop_kernel_ctx(struct kernel_ctx *ctx) __attribute__((noreturn));
-
-/* Sends a non-maskable interrupt, which we have print a trapframe. */
 void send_nmi(uint32_t os_coreid);
-
-/* Kernel messages.  Each arch implements them in their own way.  Both should be
- * guaranteeing in-order delivery.  Kept here in trap.h, since sparc is using
- * trap.h for KMs.  Eventually, both arches will use the same implementation.
+void reflect_unhandled_trap(unsigned int trap_nr, unsigned int err,
+                            unsigned long aux);
+void __arch_reflect_trap_hwtf(struct hw_trapframe *hw_tf, unsigned int trap_nr,
+                              unsigned int err, unsigned long aux);
+
+/* Kernel messages.  This is an in-order 'active message' style messaging
+ * subsystem, where you can instruct other cores (including your own) to execute
+ * a function (with arguments), either immediately or whenever the kernel is
+ * able to abandon its context/stack (permanent swap).
  *
  * These are different (for now) than the smp_calls in smp.h, since
  * they will be executed immediately (for urgent messages), and in the order in
@@ -85,10 +57,8 @@ void send_nmi(uint32_t os_coreid);
 #define KMSG_IMMEDIATE                         1
 #define KMSG_ROUTINE                   2
 
-typedef void (*amr_t)(struct trapframe *tf, uint32_t srcid, long a0, long a1,
-                      long a2);
+typedef void (*amr_t)(uint32_t srcid, long a0, long a1, long a2);
 
-/* Must stay 8-byte aligned for sparc */
 struct kernel_message
 {
        STAILQ_ENTRY(kernel_message) link;
@@ -106,7 +76,8 @@ 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);
+bool has_routine_kmsg(void);
 void process_routine_kmsg(void);
 void print_kmsgs(uint32_t coreid);