Added more SharC annotations
authorZach Anderson <zra@fortitude.(none)>
Sun, 13 Sep 2009 22:30:25 +0000 (15:30 -0700)
committerZach Anderson <zra@fortitude.(none)>
Sun, 13 Sep 2009 22:30:25 +0000 (15:30 -0700)
kern/arch/i386/mmu.h
kern/arch/i386/pmap.c
kern/arch/i386/smp.c
kern/arch/i386/trap.c
kern/include/env.h
kern/include/pmap.h
kern/include/smp.h
kern/include/trap.h
kern/src/env.c
kern/src/process.c
kern/src/testing.c

index 4e2ab62..9b3a67c 100644 (file)
@@ -376,7 +376,7 @@ typedef struct Pseudodesc {
        uint32_t pd_base;               // Base address
 } __attribute__ ((packed)) pseudodesc_t;
 
-extern segdesc_t (COUNT(SEG_COUNT) gdt)[];
+extern segdesc_t (COUNT(SEG_COUNT) RO gdt)[];
 extern pseudodesc_t gdt_pd;
 
 #endif /* !__ASSEMBLER__ */
index 53da017..1539060 100644 (file)
@@ -23,7 +23,7 @@
 
 // These variables are set in i386_vm_init()
 pde_t* boot_pgdir;             // Virtual address of boot time page directory
-physaddr_t boot_cr3;           // Physical address of boot time page directory
+physaddr_t RO boot_cr3;                // Physical address of boot time page directory
 
 // Global variables
 volatile uint32_t pages_lock = 0;
index cdd44e3..aed6af9 100644 (file)
@@ -23,7 +23,7 @@
 /*************************** IPI Wrapper Stuff ********************************/
 // checklists to protect the global interrupt_handlers for 0xf0, f1, f2, f3, f4
 // need to be global, since there is no function that will always exist for them
-handler_wrapper_t             (RO handler_wrappers)[NUM_HANDLER_WRAPPERS];
+handler_wrapper_t (RO handler_wrappers)[NUM_HANDLER_WRAPPERS];
 
 static int smp_call_function(uint8_t type, uint32_t dest, poly_isr_t handler, TV(t) data,
                              handler_wrapper_t** wait_wrapper)
index d57c47a..37279ef 100644 (file)
@@ -1,5 +1,5 @@
 #ifdef __SHARC__
-#pragma nosharc
+//#pragma nosharc
 #endif
 
 #include <arch/mmu.h>
 
 #include <syscall.h>
 
-taskstate_t ts;
+taskstate_t RO ts;
 
 /* Interrupt descriptor table.  (Must be built at run time because
  * shifted function addresses can't be represented in relocation records.)
  */
 // Aligned on an 8 byte boundary (SDM V3A 5-13)
-gatedesc_t __attribute__ ((aligned (8))) idt[256] = { { 0 } };
-pseudodesc_t idt_pd = {
+gatedesc_t __attribute__ ((aligned (8))) (RO idt)[256] = { { 0 } };
+pseudodesc_t RO idt_pd = {
        sizeof(idt) - 1, (uint32_t) idt
 };
 
@@ -37,12 +37,12 @@ pseudodesc_t idt_pd = {
 #pragma cilnoremove("iht_lock")
 #endif
 spinlock_t iht_lock;
-handler_t TP(void *) LCKD(&iht_lock) (RO interrupt_handlers)[NUM_INTERRUPT_HANDLERS];
+handler_t TP(TV(t)) LCKD(&iht_lock) (RO interrupt_handlers)[NUM_INTERRUPT_HANDLERS];
 
 static const char *NTS trapname(int trapno)
 {
     // zra: excnames is SREADONLY because Ivy doesn't trust const
-       static const char *NT const ( excnames)[] = {
+       static const char *NT const (RO excnames)[] = {
                "Divide error",
                "Debug",
                "Non-Maskable Interrupt",
@@ -76,20 +76,20 @@ static const char *NTS trapname(int trapno)
 void
 idt_init(void)
 {
-       extern segdesc_t gdt[];
+       extern segdesc_t (RO gdt)[];
 
        // This table is made in trapentry.S by each macro in that file.
        // It is layed out such that the ith entry is the ith's traphandler's
        // (uint32_t) trap addr, then (uint32_t) trap number
        struct trapinfo { uint32_t trapaddr; uint32_t trapnumber; };
-       extern struct trapinfo (BND(__this,trap_tbl_end) trap_tbl)[];
-       extern struct trapinfo (SNT trap_tbl_end)[];
+       extern struct trapinfo (BND(__this,trap_tbl_end) RO trap_tbl)[];
+       extern struct trapinfo (SNT RO trap_tbl_end)[];
        int i, trap_tbl_size = trap_tbl_end - trap_tbl;
        extern void ISR_default(void);
 
        // set all to default, to catch everything
        for(i = 0; i < 256; i++)
-               SETGATE(idt[i], 0, GD_KT, &ISR_default, 0);
+               ROSETGATE(idt[i], 0, GD_KT, &ISR_default, 0);
 
        // set all entries that have real trap handlers
        // we need to stop short of the last one, since the last is the default
@@ -98,24 +98,25 @@ idt_init(void)
        // if we set these to trap gates, be sure to handle the IRQs separately
        // and we might need to break our pretty tables
        for(i = 0; i < trap_tbl_size - 1; i++)
-               SETGATE(idt[trap_tbl[i].trapnumber], 0, GD_KT, trap_tbl[i].trapaddr, 0);
+               ROSETGATE(idt[trap_tbl[i].trapnumber], 0, GD_KT, trap_tbl[i].trapaddr, 0);
 
        // turn on syscall handling and other user-accessible ints
        // DPL 3 means this can be triggered by the int instruction
        // STS_TG32 sets the IDT type to a Trap Gate (interrupts enabled)
-       idt[T_SYSCALL].gd_dpl = 3;
-       idt[T_SYSCALL].gd_type = STS_TG32;
-       idt[T_BRKPT].gd_dpl = 3;
+       idt[T_SYSCALL].gd_dpl = SINIT(3);
+       idt[T_SYSCALL].gd_type = SINIT(STS_TG32);
+       idt[T_BRKPT].gd_dpl = SINIT(3);
 
        // Setup a TSS so that we get the right stack
        // when we trap to the kernel.
-       ts.ts_esp0 = KSTACKTOP;
-       ts.ts_ss0 = GD_KD;
+       ts.ts_esp0 = SINIT(KSTACKTOP);
+       ts.ts_ss0 = SINIT(GD_KD);
 
        // Initialize the TSS field of the gdt.
-       gdt[GD_TSS >> 3] = (segdesc_t)SEG16(STS_T32A, (uint32_t) (&ts),
-                                          sizeof(taskstate_t), 0);
-       gdt[GD_TSS >> 3].sd_s = 0;
+       SEG16ROINIT(gdt[GD_TSS >> 3],STS_T32A, (uint32_t)(&ts),sizeof(taskstate_t),0);
+       //gdt[GD_TSS >> 3] = (segdesc_t)SEG16(STS_T32A, (uint32_t) (&ts),
+       //                                 sizeof(taskstate_t), 0);
+       gdt[GD_TSS >> 3].sd_s = SINIT(0);
 
        // Load the TSS
        ltr(GD_TSS);
@@ -257,10 +258,10 @@ irq_handler(trapframe_t *tf)
        // context.  doing it now is safe. (HSS)
        env_push_ancillary_state(current);
 
-       extern handler_wrapper_t handler_wrappers[NUM_HANDLER_WRAPPERS];
+       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(void *) * handler_tbl = interrupt_handlers;
+       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);
@@ -282,7 +283,7 @@ irq_handler(trapframe_t *tf)
 
 void
 register_interrupt_handler(handler_t TP(TV(t)) table[],
-                           uint8_t int_num, poly_isr_t handler, void* data)
+                           uint8_t int_num, poly_isr_t handler, TV(t) data)
 {
        table[int_num].isr = handler;
        table[int_num].data = data;
@@ -406,7 +407,7 @@ uint32_t send_active_message(uint32_t dst, amr_t pc,
  * currently disabled for this gate. */
 void __active_message(trapframe_t *tf)
 {
-       per_cpu_info_t *myinfo = &per_cpu_info[core_id()];
+       per_cpu_info_t RO*myinfo = &per_cpu_info[core_id()];
        active_message_t amsg;
 
        lapic_send_eoi();
index bba2269..969f203 100644 (file)
@@ -92,7 +92,19 @@ struct Env {
 extern env_t *COUNT(NENV) envs;                // All environments
 extern atomic_t num_envs;              // Number of envs
 // TODO: consider moving this to struct per_cpu_info
-extern env_t* curenvs[MAX_NUM_CPUS];
+extern env_t * (RO curenvs)[MAX_NUM_CPUS];
+
+static inline env_t *
+get_cpu_curenv() TRUSTED
+{
+       return curenvs[core_id()];
+}
+
+static inline void
+set_cpu_curenv(env_t *p) TRUSTED
+{
+       curenvs[core_id()] = p;
+}
 
 void   env_init(void);
 int            env_alloc(env_t *SAFE*SAFE e, envid_t parent_id);
@@ -106,7 +118,8 @@ env_t*      env_create(uint8_t *COUNT(size) binary, size_t size);
  * Allows the kernel to figure out what process is running on its core.
  * Can be used just like a pointer to a struct process.
  */
-#define current (curenvs[core_id()])
+#define current (get_cpu_curenv())
+//#define current (curenvs[core_id()])
 
 int    envid2env(envid_t envid, env_t **env_store, bool checkperm);
 // The following three functions do not return
index 3a57d39..3eed160 100644 (file)
@@ -43,7 +43,7 @@ extern char (SNT bootstacktop)[], (SNT bootstack)[];
 extern volatile uint32_t pages_lock;
 extern page_t SLOCKED(&pages_lock) * SREADONLY COUNT(npages) pages;
 
-extern physaddr_t boot_cr3;
+extern physaddr_t RO boot_cr3;
 extern pde_t *COUNT(NPDENTRIES) boot_pgdir;
 
 extern char*BND(end, maxaddrpa_ptr + IVY_KERNBASE) boot_freemem;
index ee6c8c2..5d46162 100644 (file)
@@ -24,14 +24,14 @@ struct per_cpu_info {
        struct workqueue NTPTV(t) workqueue;
 #ifdef __i386__
        spinlock_t amsg_lock;
-       unsigned amsg_current;
-       active_message_t active_msgs[NUM_ACTIVE_MESSAGES];
+       unsigned LCKD(&amsg_lock) amsg_current;
+       active_message_t LCKD(&amsg_lock) (RO active_msgs)[NUM_ACTIVE_MESSAGES];
 #endif
 };
 
 typedef struct per_cpu_info NTPTV(t) NTPTV(a0t) NTPTV(a1t) NTPTV(a2t) per_cpu_info_t;
 
-extern per_cpu_info_t ( per_cpu_info)[MAX_NUM_CPUS];
+extern per_cpu_info_t (RO per_cpu_info)[MAX_NUM_CPUS];
 extern volatile uint8_t RO num_cpus;
 
 /* SMP bootup functions */
index 59aa133..fc76c49 100644 (file)
@@ -25,9 +25,10 @@ extern spinlock_t iht_lock;
 extern handler_t LCKD(&iht_lock) (CT(NUM_INTERRUPT_HANDLERS) RO interrupt_handlers)[];
 
 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
+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);
 
index 092f162..d37d1a1 100644 (file)
@@ -29,7 +29,7 @@ atomic_t num_envs;
 // This lets the kernel know what process is running on the core it traps into.
 // A lot of the Env business, including this and its usage, will change when we
 // redesign the env as a multi-process.
-env_t* curenvs[MAX_NUM_CPUS] = {[0 ... (MAX_NUM_CPUS-1)] NULL};
+env_t* (RO curenvs)[MAX_NUM_CPUS] = {[0 ... (MAX_NUM_CPUS-1)] NULL};
 
 #define ENVGENSHIFT    12              // >= LOGNENV
 
index ed9cd4c..b7071f8 100644 (file)
@@ -29,8 +29,8 @@ spinlock_t runnablelist_lock = 0;
 /* Tracks which cores are idle, similar to the vcoremap.  Each value is the
  * physical coreid of an unallocated core. */
 spinlock_t idle_lock = 0;
-uint32_t idlecoremap[MAX_NUM_CPUS];
-uint32_t num_idlecores = 0;
+uint32_t LCKD(&idle_lock) (RO idlecoremap)[MAX_NUM_CPUS];
+uint32_t LCKD(&idle_lock) num_idlecores = 0;
 
 /*
  * While this could be done with just an assignment, this gives us the
@@ -248,7 +248,7 @@ void proc_startcore(struct proc *p, trapframe_t *tf) {
                // process's context".
                if (current)
                        proc_decref(current);
-               current = p;
+               set_cpu_curenv(p);
        }
        /* need to load our silly state, preferably somewhere other than here so we
         * can avoid the case where the context was just running here.  it's not
@@ -465,7 +465,7 @@ void __death(trapframe_t *tf, uint32_t srcid, void *SNT a0, void *SNT a1,
        if (current) {
                lcr3(boot_cr3);
                proc_decref(current);
-               current = NULL;
+               set_cpu_curenv(NULL);
        }
        smp_idle();
 }
index 621e38e..75d98d7 100644 (file)
@@ -29,7 +29,7 @@
 
 void test_ipi_sending(void)
 {
-       extern handler_t (COUNT(NUM_INTERRUPT_HANDLERS) interrupt_handlers)[];
+       extern handler_t (CT(NUM_INTERRUPT_HANDLERS) RO interrupt_handlers)[];
        int8_t state = 0;
 
        register_interrupt_handler(interrupt_handlers, I_TESTING,