Done Deputizing kernel
authorZach Anderson <zra@zra-intrepid.(none)>
Wed, 19 Aug 2009 04:18:01 +0000 (21:18 -0700)
committerZach Anderson <zra@zra-intrepid.(none)>
Wed, 19 Aug 2009 04:18:01 +0000 (21:18 -0700)
20 files changed:
kern/arch/i386/cpuinfo.c
kern/arch/i386/smp_boot.c
kern/include/atomic.h
kern/include/env.h
kern/include/kfs.h
kern/include/monitor.h
kern/include/pmap.h
kern/include/smp.h
kern/include/string.h
kern/include/workqueue.h
kern/src/env.c
kern/src/init.c
kern/src/kfs.c
kern/src/monitor.c
kern/src/multiboot.c
kern/src/pmap.c
kern/src/string.c
kern/src/syscall.c
kern/src/testing.c
kern/src/workqueue.c

index b3d52c3..4322a98 100644 (file)
@@ -97,7 +97,7 @@ void print_cpuinfo(void)
 
 void show_mapping(uintptr_t start, size_t size)
 {
-       pde_t* pgdir = /*(pde_t*)*/vpd;
+       pde_t *COUNT(PTSIZE) pgdir = (pde_t *COUNT(PTSIZE))vpd;
        pte_t *pte, *pde;
        page_t* page;
        uintptr_t i;
index 84ef309..c9775bf 100644 (file)
@@ -155,10 +155,11 @@ get_my_gdt_pd(page_t *my_stack)
                                      sizeof(segdesc_t)*SEG_COUNT);
 }
 
-static inline void *COUNT(sizeof(segdesc_t)*SEG_COUNT)
+//static inline void *COUNT(sizeof(segdesc_t)*SEG_COUNT)
+static inline segdesc_t *COUNT(SEG_COUNT)
 get_my_gdt(page_t *my_stack)
 {
-       return page2kva(my_stack) + PGSIZE - sizeof(segdesc_t)*SEG_COUNT;
+       return TC(page2kva(my_stack) + PGSIZE - sizeof(segdesc_t)*SEG_COUNT);
 }
 
 static inline void *COUNT(sizeof(taskstate_t))
index f9145a8..975cd1c 100644 (file)
@@ -58,7 +58,7 @@ typedef struct barrier {
     volatile uint8_t ready;
 } barrier_t;
 
-void init_barrier(barrier_t* barrier, uint32_t count);
+void init_barrier(barrier_t*COUNT(1) barrier, uint32_t count);
 void reset_barrier(barrier_t* barrier);
 void waiton_barrier(barrier_t* barrier);
 
index 6089e0d..1bc9822 100644 (file)
@@ -100,6 +100,6 @@ void        env_pop_tf(trapframe_t *tf) __attribute__((noreturn));
 
 
 /* Helper handler for smp_call to dispatch jobs to other cores */
-void run_env_handler(trapframe_t *tf, void* data);
+void run_env_handler(trapframe_t *tf, env_t* data);
 
 #endif // !ROS_KERN_ENV_H
index 60fadc1..a4f42ff 100644 (file)
 #include <arch/types.h>
 #include <process.h>
 
-#pragma nodeputy
+// zra : putting nodeputy in header files makes life difficult.
+//#pragma nodeputy
 
 struct kfs_entry {
-       char name[256];
-       uint8_t *start;
+       char (NT name)[256];
+       uint8_t *COUNT(size) start;
        size_t size;
 };
 
 #define MAX_KFS_FILES 10
 extern struct kfs_entry kfs[MAX_KFS_FILES];
 
-ssize_t kfs_lookup_path(char* path);
+ssize_t kfs_lookup_path(char*NTS path);
 struct proc *kfs_proc_create(int kfs_inode);
 
 #endif // !ROS_KERN_KFS_H
index 114e56f..8d7af4c 100644 (file)
@@ -17,9 +17,9 @@ 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 **argv, trapframe_t *tf);
+int mon_nanwan(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
 int mon_kfs_ls(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
 int mon_kfs_run(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
-int mon_manager(int argc, char **argv, trapframe_t *tf);
+int mon_manager(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf);
 
 #endif // !ROS_KERN_MONITOR_H
index e832918..3d9e34d 100644 (file)
@@ -104,11 +104,14 @@ void setup_default_mtrrs(barrier_t* smp_barrier);
 void   tlb_invalidate(pde_t *COUNT(NPDENTRIES) pgdir, void *SNT va);
 void tlb_flush_global(void);
 
-void *COUNT(len)
-user_mem_check(env_t *env, const void *DANGEROUS va, size_t len, int perm);
+void * (DALLOC(len) user_mem_check) (env_t *env, const void *DANGEROUS va,
+                                     size_t len, int perm);
 
-void *COUNT(len)
-user_mem_assert(env_t *env, const void *DANGEROUS va, size_t len, int perm);
+void * (DALLOC(len) user_mem_assert)(env_t *env, const void *DANGEROUS va,
+                                     size_t len, int perm);
+
+size_t user_mem_strlcpy(env_t *env, char *NT COUNT(len - 1),
+                        const char *DANGEROUS va, size_t len, int perm);
 
 error_t
 memcpy_from_user(env_t* env, void* COUNT(len) dest,
index b6a674d..e911da9 100644 (file)
@@ -14,6 +14,7 @@
 #include <trap.h>
 #include <atomic.h>
 #include <workqueue.h>
+#include <env.h>
 
 // will want this padded out to cacheline alignment
 struct per_cpu_info {
index c8eb281..fc15ae9 100644 (file)
@@ -19,10 +19,11 @@ int strncmp(const STRING s1, const STRING s2, size_t size);
 STRING strchr(const STRING s, char c);
 STRING strfind(const STRING s, char c);
 
-void *COUNT(len) memset(void *COUNT(len) dst, int c, size_t len);
-void *COUNT(len) memcpy(void *COUNT(len) dst, const void *COUNT(len) src, size_t len);
-void *COUNT(len) memmove(void *COUNT(len) dst, const void *COUNT(len) src, size_t len);
-int    memcmp(const void *COUNT(len) s1, const void *COUNT(len) s2, size_t len);
+void * (DMEMSET(1, 2, 3) memset)(void* p, int what, size_t sz);
+int    (DMEMCMP(1, 2, 3) memcmp)(const void* s1, const void* s2, size_t sz);
+void * (DMEMCPY(1, 2, 3) memcpy)(void* dst, const void* src, size_t sz);
+void * (DMEMCPY(1, 2, 3) memmove)(void *dst, const void* src, size_t sz);
+
 void *BND(s,s+len)     memfind(const void *COUNT(len) s, int c, size_t len);
 
 long   strtol(const char *NTS s, char **endptr, int base);
index ba7dc15..27ce98e 100644 (file)
 
 #include <sys/queue.h>
 #include <arch/types.h>
+#include <env.h>
 
-typedef void (*func_t)(void *data);
+typedef void (*func_t)(TV(t) data);
 struct work {
        LIST_ENTRY(work) work_link;
        func_t func;
-       void *data;
+       TV(t) data;
 };
 
 // TODO make these dynamic and hold more than 1.  might want better list macros.
 #define WORKQUEUE_ELEMENTS 1
 struct workqueue {
-       struct work statics[WORKQUEUE_ELEMENTS];
+       struct work TP(env_t *) statics[WORKQUEUE_ELEMENTS];
 };
 
 void process_workqueue(void);
 // For now, the caller should free their struct work after this call
-int enqueue_work(struct workqueue *queue, struct work *job);
+int enqueue_work(struct workqueue *queue, struct work TP(env_t *) *job);
 
 #endif /* ROS_KERN_WORKQUEUE_H */
index 39c972e..0122e99 100644 (file)
@@ -1,7 +1,4 @@
 /* See COPYRIGHT for copyright information. */
-#ifdef __DEPUTY__
-#pragma noasync
-#endif
 
 #include <arch/arch.h>
 #include <arch/mmu.h>
@@ -464,13 +461,13 @@ env_free(env_t *e)
  *
  * Note this is rather old, and meant to run a RUNNABLE_S on a worker core.
  */
-void run_env_handler(trapframe_t *tf, void *data)
+void run_env_handler(trapframe_t *tf, env_t *data)
 {
        assert(data);
-       struct work job;
+       struct work TP(env_t *) job;
        struct workqueue *workqueue = &per_cpu_info[core_id()].workqueue;
-       { TRUSTEDBLOCK // TODO: how do we make this func_t cast work?
-       job.func = (func_t)proc_run;
+       { //TRUSTEDBLOCK TODO: how do we make this func_t cast work?
+       job.func = proc_run;
        job.data = data;
        }
        if (enqueue_work(workqueue, &job))
index 44b4c78..41a85c8 100644 (file)
@@ -41,8 +41,8 @@ void kernel_init(multiboot_info_t *mboot_info)
     //      clear what's going on this way?
        //multiboot_detect_memory((multiboot_info_t*)((uint32_t)mboot_info + KERNBASE));
        //multiboot_print_memory_map((multiboot_info_t*)((uint32_t)mboot_info + KERNBASE));
-       multiboot_detect_memory((multiboot_info_t*COUNT(1))KADDR(mboot_info));
-       multiboot_print_memory_map((multiboot_info_t*COUNT(1))KADDR(mboot_info));
+       multiboot_detect_memory((multiboot_info_t*COUNT(1))KADDR((physaddr_t)mboot_info));
+       multiboot_print_memory_map((multiboot_info_t*COUNT(1))KADDR((physaddr_t)mboot_info));
 
        vm_init();
 
index 58997ad..72a3f3b 100644 (file)
@@ -9,7 +9,9 @@
 #include <assert.h>
 #include <ros/error.h>
 
-#define DECL_PROG(x) extern uint8_t _binary_obj_user_apps_##x##_start[], _binary_obj_user_apps_##x##_size[];      
+#define DECL_PROG(x) \
+    extern uint8_t (COUNT(sizeof(size_t)) _binary_obj_user_apps_##x##_size)[],\
+        (COUNT(_binary_obj_user_apps_##x##_size)_binary_obj_user_apps_##x##_start)[];
 
 #define KFS_ENTRY(x) {#x, _binary_obj_user_apps_##x##_start, (size_t) _binary_obj_user_apps_##x##_size},
 
index aece729..9b87344 100644 (file)
@@ -145,12 +145,12 @@ int mon_setmapperm(int argc, char **argv, trapframe_t *tf)
                cprintf("Usage: setmapperm VIRT_ADDR PERMS\n");
                return 1;
        }
-       pde_t* pgdir = (pde_t*)vpd;
+       pde_t*COUNT(PTSIZE) pgdir = (pde_t*COUNT(PTSIZE))vpd;
        pte_t *pte, *pde;
        page_t* page;
        uintptr_t va;
        va = ROUNDDOWN(strtol(argv[1], 0, 16), PGSIZE);
-       page = page_lookup(pgdir, (void*)va, &pte);
+       page = page_lookup(pgdir, (void*SNT)va, &pte);
        if (!page) {
                cprintf("No such mapping\n");
                return 1;
@@ -181,10 +181,10 @@ int mon_cpuinfo(int argc, char **argv, trapframe_t *tf)
 
 #ifdef __i386__
        if (argc < 2)
-               smp_call_function_self(test_print_info_handler, 0, 0);
+               smp_call_function_self(test_print_info_handler, NULL, 0);
        else
                smp_call_function_single(strtol(argv[1], 0, 16),
-                                        test_print_info_handler, 0, 0);
+                                        test_print_info_handler, NULL, 0);
 #endif
        return 0;
 }
@@ -266,8 +266,8 @@ int mon_kfs_run(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
 #define WHITESPACE "\t\r\n "
 #define MAXARGS 16
 
-static int runcmd(char *COUNT(CMDBUF_SIZE) real_buf, trapframe_t *tf) {
-       char *BND(real_buf, real_buf+CMDBUF_SIZE) buf = real_buf;
+static int runcmd(char *NTS real_buf, trapframe_t *tf) {
+       char * buf = NTEXPAND(real_buf);
        int argc;
        char *NTS argv[MAXARGS];
        int i;
@@ -288,7 +288,7 @@ static int runcmd(char *COUNT(CMDBUF_SIZE) real_buf, trapframe_t *tf) {
                        return 0;
                }
                //This will get fucked at runtime..... in the ASS
-               argv[argc++] = (char *NTS) TC(buf);
+               argv[argc++] = buf;
                while (*buf && !strchr(WHITESPACE, *buf))
                        buf++;
        }
index dc6b6e4..b66207a 100644 (file)
@@ -37,7 +37,7 @@ multiboot_detect_memory(multiboot_info_t *mbi)
        // IOAPIC - KERNBASE is the max amount of virtual addresses we can use
        // for the physical memory mapping (aka - the KERNBASE mapping)
        maxaddrpa = MIN(maxpa, IOAPIC_BASE - KERNBASE);
-       maxaddrpa_ptr = maxaddrpa;
+       maxaddrpa_ptr = (void *SNT)maxaddrpa;
 
        naddrpage = maxaddrpa / PGSIZE;
 
@@ -68,7 +68,7 @@ multiboot_print_memory_map(multiboot_info_t *mbi) {
                                (unsigned) mmap->length_high,
                                (unsigned) mmap->length_low,
                                (unsigned) memory_type[mmap->type]);
-                       mmap = (char *)mmap + mmap->size + sizeof(mmap->size);
+                       mmap = (memory_map_t *BND(mmap_b,mmap_e))((char *BND(mmap_b,mmap_e))mmap + mmap->size + sizeof(mmap->size));
                }
        }
 }
index 62b5866..a1cb625 100644 (file)
@@ -337,7 +337,7 @@ static void *DANGEROUS user_mem_check_addr;
 // COUNT(len) pointer. user_mem_check now returns NULL on error instead of
 // -EFAULT.
 
-void *COUNT(len)
+void *
 user_mem_check(env_t *env, const void *DANGEROUS va, size_t len, int perm)
 {
        // TODO - will need to sort this out wrt page faulting / PTE_P
@@ -360,7 +360,7 @@ user_mem_check(env_t *env, const void *DANGEROUS va, size_t len, int perm)
                pte = pgdir_walk(env->env_pgdir, start, 0);
                // ensures the bits we want on are turned on.  if not, error out
                if ( !pte || ((*pte & perm) != perm) ) {
-                       if (i = 0)
+                       if (i == 0)
                                user_mem_check_addr = (void*DANGEROUS)va;
                        else
                                user_mem_check_addr = start;
@@ -375,13 +375,36 @@ user_mem_check(env_t *env, const void *DANGEROUS va, size_t len, int perm)
        return (void *COUNT(len))TC(va);
 }
 
+size_t
+user_mem_strlcpy(env_t *env, char *dst, const char *DANGEROUS va,
+                 size_t len, int perm)
+{
+       const char *DANGEROUS src = va;
+       char *NT COUNT(len-1) dst_in = dst;
+
+       if (len > 0) {
+               while (1) {
+                       char *c;
+                       if (--len <= 0) break;
+                       c = user_mem_check(env, src, 1, perm);
+                       if (!c) break;
+                       if (*c == '\0') break;
+                       *dst++ = *c;
+                       src++;
+               }
+               *dst = '\0';
+       }
+
+       return dst - dst_in;
+}
+
 //
 // Checks that environment 'env' is allowed to access the range
 // of memory [va, va+len) with permissions 'perm | PTE_U'.
 // If it can, then the function simply returns.
 // If it cannot, 'env' is destroyed.
 //
-void *COUNT(len)
+void *
 user_mem_assert(env_t *env, const void *DANGEROUS va, size_t len, int perm)
 {
     void *COUNT(len) res = user_mem_check(env,va,len,perm | PTE_USER_RO);
index 3ee27ca..005568f 100644 (file)
@@ -139,13 +139,13 @@ static inline void *
 memcpy16(uint32_t *COUNT(n/sizeof(uint32_t)) _dst,
          const uint32_t *COUNT(n/sizeof(uint32_t)) _src, size_t n)
 {
-       uint32_t *dststart, *dstend, *srcend;
+       uint32_t *dststart, *SNT dstend, *SNT srcend;
        uint32_t *BND(_dst,dstend) dst;
-       uint32_t *BND(_src,srcend) src;
+       const uint32_t *BND(_src,srcend) src;
 
        dststart = _dst;
-       dstend = _dst + n/sizeof(uint32_t);
-       srcend = _src + n/sizeof(uint32_t);
+       dstend = (uint32_t *SNT)(_dst + n/sizeof(uint32_t));
+       srcend = (uint32_t *SNT)(_src + n/sizeof(uint32_t));
        dst = _dst;
        src = _src;
 
@@ -164,7 +164,7 @@ memcpy16(uint32_t *COUNT(n/sizeof(uint32_t)) _dst,
 }
 
 void *
-memset(void *v, int c, size_t _n)
+memset(void *COUNT(_n) v, int c, size_t _n)
 {
        char *BND(v,v+_n) p;
        size_t n0;
@@ -177,7 +177,7 @@ memset(void *v, int c, size_t _n)
        if(n >= 16 && ((uintptr_t)v & 3) == 0)
        {
                n0 = (n/16)*16;
-               memset16((uint32_t*)v,c,n0);
+               memset16((uint32_t*COUNT(n0/sizeof(uint32_t)))v,c,n0);
                n -= n0;
                p += n0;
        }
@@ -192,7 +192,7 @@ memset(void *v, int c, size_t _n)
 }
 
 void *
-memcpy(void *dst, const void *src, size_t _n)
+(DMEMCPY(1,2,3) memcpy)(void *COUNT(_n) dst, const void *COUNT(_n) src, size_t _n)
 {
        const char *BND(src,src+_n) s;
        char *BND(dst,dst+_n) d;
@@ -205,7 +205,8 @@ memcpy(void *dst, const void *src, size_t _n)
        if(n >= 16 && ((uintptr_t)src  & 3) == 0 && ((uintptr_t)dst & 3) == 0)
        {
                n0 = (n/16)*16;
-               memcpy16((uint32_t*)dst,(const uint32_t*)src,n0);
+               memcpy16((uint32_t*COUNT(n0/sizeof(uint32_t)))dst,
+                 (const uint32_t*COUNT(n0/sizeof(uint32_t)))src,n0);
                n -= n0;
                s += n0;
                d += n0;
@@ -218,7 +219,7 @@ memcpy(void *dst, const void *src, size_t _n)
 }
 
 void *
-memmove(void *dst, const void *src, size_t _n)
+memmove(void *COUNT(_n) dst, const void *COUNT(_n) src, size_t _n)
 {
        const char *BND(src,src+_n) s;
        char *BND(dst,dst+_n) d;
@@ -239,7 +240,7 @@ memmove(void *dst, const void *src, size_t _n)
 }
 
 int
-memcmp(const void *v1, const void *v2, size_t n)
+memcmp(const void *COUNT(n) v1, const void *COUNT(n) v2, size_t n)
 {
        const uint8_t *BND(v1,v1+n) s1 = (const uint8_t *) v1;
        const uint8_t *BND(v2,v2+n) s2 = (const uint8_t *) v2;
@@ -261,7 +262,7 @@ memfind(const void *_s, int c, size_t n)
        for (; s < ends; s++)
                if (*(const unsigned char *) s == (unsigned char) c)
                        break;
-       return (void *) s;
+       return (void *BND(_s,_s+n)) s;
 }
 
 long
index e4bda71..ec9b0fd 100644 (file)
@@ -1,7 +1,4 @@
 /* See COPYRIGHT for copyright information. */
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
 
 #include <arch/types.h>
 #include <arch/arch.h>
@@ -40,10 +37,10 @@ static ssize_t sys_serial_write(env_t* e, const char *DANGEROUS buf, size_t len)
 }
 
 //Read a buffer over the serial port
-static ssize_t sys_serial_read(env_t* e, char *DANGEROUS buf, size_t len)
+static ssize_t sys_serial_read(env_t* e, char *DANGEROUS _buf, size_t len)
 {
        #ifdef SERIAL_IO
-           char *COUNT(len) _buf = user_mem_assert(e, buf, len, PTE_USER_RO);
+           char *COUNT(len) buf = user_mem_assert(e, _buf, len, PTE_USER_RO);
                size_t bytes_read = 0;
                int c;
                while((c = serial_read_byte()) != -1) {
@@ -57,25 +54,28 @@ static ssize_t sys_serial_read(env_t* e, char *DANGEROUS buf, size_t len)
 }
 
 static ssize_t sys_shared_page_alloc(env_t* p1,
-                                     void**DANGEROUS addr, envid_t p2_id,
+                                     void**DANGEROUS _addr, envid_t p2_id,
                                      int p1_flags, int p2_flags
                                     )
 {
        //if (!VALID_USER_PERMS(p1_flags)) return -EPERM;
        //if (!VALID_USER_PERMS(p2_flags)) return -EPERM;
 
+       void * COUNT(1) * COUNT(1) addr = user_mem_assert(p1, _addr, sizeof(void *), 
+                                                      PTE_USER_RW);
        page_t* page;
        env_t* p2 = &(envs[ENVX(p2_id)]);
        error_t e = page_alloc(&page);
+
        if(e < 0) return e;
 
        void* p2_addr = page_insert_in_range(p2->env_pgdir, page,
-                                            (void*)UTEXT, (void*)UTOP, p2_flags);
+                                            (void*SNT)UTEXT, (void*SNT)UTOP, p2_flags);
        if(p2_addr == NULL)
                return -EFAIL;
 
        void* p1_addr = page_insert_in_range(p1->env_pgdir, page,
-                                           (void*)UTEXT, (void*)UTOP, p1_flags);
+                                           (void*SNT)UTEXT, (void*SNT)UTOP, p1_flags);
        if(p1_addr == NULL) {
                page_remove(p2->env_pgdir, p2_addr);
                return -EFAIL;
@@ -104,7 +104,7 @@ static void sys_cache_invalidate(void)
 // lines, to simulate doing something useful.
 static void sys_cache_buster(env_t* e, uint32_t num_writes, uint32_t num_pages,
                              uint32_t flags)
-{
+{ TRUSTEDBLOCK /* zra: this is not really part of the kernel */
        #define BUSTER_ADDR             0xd0000000  // around 512 MB deep
        #define MAX_WRITES              1048576*8
        #define MAX_PAGES               32
@@ -277,8 +277,13 @@ static int sys_proc_create(struct proc *p, const char *DANGEROUS path)
         * space, and resolving both of these without knowing the length of the
         * string. (TODO)
         * Change this so that all syscalls with a pointer take a length.
+        *
+        * zra: I've added this user_mem_strlcpy, which I think eliminates the
+     * the TOCTOU issue. Adding a length arg to this call would allow a more
+        * efficient implementation, though, since only one call to user_mem_check
+        * would be required.
         */
-       strncpy(tpath, path, MAX_PATH_LEN);
+       int ret = user_mem_strlcpy(p,tpath, path, MAX_PATH_LEN, PTE_USER_RO);
        int kfs_inode = kfs_lookup_path(tpath);
        if (kfs_inode < 0)
                return -EINVAL;
index 15cde23..1f01de7 100644 (file)
@@ -1,5 +1,5 @@
 #ifdef __DEPUTY__
-#pragma nodeputy
+//#pragma nodeputy
 #endif
 
 #include <arch/mmu.h>
 
 void test_ipi_sending(void)
 {
-       extern handler_t interrupt_handlers[];
+       extern handler_t (COUNT(NUM_INTERRUPT_HANDLERS) interrupt_handlers)[];
        int8_t state = 0;
 
        register_interrupt_handler(interrupt_handlers, test_vector,
-                                  test_hello_world_handler, 0);
+                                  test_hello_world_handler, NULL);
        enable_irqsave(&state);
        cprintf("\nCORE 0 sending broadcast\n");
        send_broadcast_ipi(test_vector);
@@ -65,7 +65,7 @@ void test_ipi_sending(void)
 // Note this never returns and will muck with any other timer work
 void test_pic_reception(void)
 {
-       register_interrupt_handler(interrupt_handlers, 0x20, test_hello_world_handler, 0);
+       register_interrupt_handler(interrupt_handlers, 0x20, test_hello_world_handler, NULL);
        pit_set_timer(100,TIMER_RATEGEN); // totally arbitrary time
        pic_unmask_irq(0);
        cprintf("PIC1 Mask = 0x%04x\n", inb(PIC1_DATA));
@@ -81,7 +81,7 @@ void test_pic_reception(void)
 void test_print_info(void)
 {
        cprintf("\nCORE 0 asking all cores to print info:\n");
-       smp_call_function_all(test_print_info_handler, 0, 0);
+       smp_call_function_all(test_print_info_handler, NULL, 0);
        cprintf("\nDone!\n");
 }
 
@@ -94,7 +94,7 @@ void test_barrier(void)
        cprintf("Core 0 initializing barrier\n");
        init_barrier(&test_cpu_array, num_cpus);
        cprintf("Core 0 asking all cores to print ids, barrier, rinse, repeat\n");
-       smp_call_function_all(test_barrier_handler, 0, 0);
+       smp_call_function_all(test_barrier_handler, NULL, 0);
 }
 
 void test_interrupts_irqsave(void)
@@ -262,7 +262,7 @@ void test_checklists(void)
        PRINT_BITMASK(a_list.mask.bits, a_list.mask.size);
        //smp_call_function_single(1, test_checklist_handler, 0, 0);
 
-       smp_call_function_all(test_checklist_handler, 0, 0);
+       smp_call_function_all(test_checklist_handler, NULL, 0);
 
        printk("Waiting on checklist\n");
        waiton_checklist(&a_list);
@@ -272,10 +272,10 @@ void test_checklists(void)
 
 atomic_t a, b, c;
 
-void test_incrementer_handler(trapframe_t *tf, void* data)
+void test_incrementer_handler(trapframe_t *tf, atomic_t* data)
 {
        assert(data);
-       atomic_inc((atomic_t*)data);
+       atomic_inc(data);
 }
 
 void test_null_handler(trapframe_t *tf, void* data)
@@ -294,31 +294,31 @@ void test_smp_call_functions(void)
        uint8_t me = core_id();
        printk("\nCore %d: SMP Call Self (nowait):\n", me);
        printk("---------------------\n");
-       smp_call_function_self(test_hello_world_handler, 0, 0);
+       smp_call_function_self(test_hello_world_handler, NULL, 0);
        printk("\nCore %d: SMP Call Self (wait):\n", me);
        printk("---------------------\n");
-       smp_call_function_self(test_hello_world_handler, 0, &waiter0);
+       smp_call_function_self(test_hello_world_handler, NULL, &waiter0);
        smp_call_wait(waiter0);
        printk("\nCore %d: SMP Call All (nowait):\n", me);
        printk("---------------------\n");
-       smp_call_function_all(test_hello_world_handler, 0, 0);
+       smp_call_function_all(test_hello_world_handler, NULL, 0);
        printk("\nCore %d: SMP Call All (wait):\n", me);
        printk("---------------------\n");
-       smp_call_function_all(test_hello_world_handler, 0, &waiter0);
+       smp_call_function_all(test_hello_world_handler, NULL, &waiter0);
        smp_call_wait(waiter0);
        printk("\nCore %d: SMP Call All-Else Individually, in order (nowait):\n", me);
        printk("---------------------\n");
        for(i = 1; i < num_cpus; i++)
-               smp_call_function_single(i, test_hello_world_handler, 0, 0);
+               smp_call_function_single(i, test_hello_world_handler, NULL, 0);
        printk("\nCore %d: SMP Call Self (wait):\n", me);
        printk("---------------------\n");
-       smp_call_function_self(test_hello_world_handler, 0, &waiter0);
+       smp_call_function_self(test_hello_world_handler, NULL, &waiter0);
        smp_call_wait(waiter0);
        printk("\nCore %d: SMP Call All-Else Individually, in order (wait):\n", me);
        printk("---------------------\n");
        for(i = 1; i < num_cpus; i++)
        {
-               smp_call_function_single(i, test_hello_world_handler, 0, &waiter0);
+               smp_call_function_single(i, test_hello_world_handler, NULL, &waiter0);
                smp_call_wait(waiter0);
        }
        printk("\nTesting to see if any IPI-functions are dropped when not waiting:\n");
@@ -342,12 +342,12 @@ void test_smp_call_functions(void)
        // wait, so we're sure the others finish before printing.
        // without this, we could (and did) get 19,18,19, since the B_inc
        // handler didn't finish yet
-       smp_call_function_self(test_null_handler, 0, &waiter0);
+       smp_call_function_self(test_null_handler, NULL, &waiter0);
        // need to grab all 5 handlers (max), since the code moves to the next free.
-       smp_call_function_self(test_null_handler, 0, &waiter1);
-       smp_call_function_self(test_null_handler, 0, &waiter2);
-       smp_call_function_self(test_null_handler, 0, &waiter3);
-       smp_call_function_self(test_null_handler, 0, &waiter4);
+       smp_call_function_self(test_null_handler, NULL, &waiter1);
+       smp_call_function_self(test_null_handler, NULL, &waiter2);
+       smp_call_function_self(test_null_handler, NULL, &waiter3);
+       smp_call_function_self(test_null_handler, NULL, &waiter4);
        smp_call_wait(waiter0);
        smp_call_wait(waiter1);
        smp_call_wait(waiter2);
@@ -355,9 +355,9 @@ void test_smp_call_functions(void)
        smp_call_wait(waiter4);
        printk("A: %d, B: %d, C: %d (should be 19,19,19)\n", atomic_read(&a), atomic_read(&b), atomic_read(&c));
        printk("Attempting to deadlock by smp_calling with an outstanding wait:\n");
-       smp_call_function_self(test_null_handler, 0, &waiter0);
+       smp_call_function_self(test_null_handler, NULL, &waiter0);
        printk("Sent one\n");
-       smp_call_function_self(test_null_handler, 0, &waiter1);
+       smp_call_function_self(test_null_handler, NULL, &waiter1);
        printk("Sent two\n");
        smp_call_wait(waiter0);
        printk("Wait one\n");
@@ -366,17 +366,17 @@ void test_smp_call_functions(void)
        printk("\tMade it through!\n");
        printk("Attempting to deadlock by smp_calling more than are available:\n");
        printk("\tShould see an Insufficient message and a kernel warning.\n");
-       if (smp_call_function_self(test_null_handler, 0, &waiter0))
+       if (smp_call_function_self(test_null_handler, NULL, &waiter0))
                printk("\tInsufficient handlers to call function (0)\n");
-       if (smp_call_function_self(test_null_handler, 0, &waiter1))
+       if (smp_call_function_self(test_null_handler, NULL, &waiter1))
                printk("\tInsufficient handlers to call function (1)\n");
-       if (smp_call_function_self(test_null_handler, 0, &waiter2))
+       if (smp_call_function_self(test_null_handler, NULL, &waiter2))
                printk("\tInsufficient handlers to call function (2)\n");
-       if (smp_call_function_self(test_null_handler, 0, &waiter3))
+       if (smp_call_function_self(test_null_handler, NULL, &waiter3))
                printk("\tInsufficient handlers to call function (3)\n");
-       if (smp_call_function_self(test_null_handler, 0, &waiter4))
+       if (smp_call_function_self(test_null_handler, NULL, &waiter4))
                printk("\tInsufficient handlers to call function (4)\n");
-       if (smp_call_function_self(test_null_handler, 0, &waiter5))
+       if (smp_call_function_self(test_null_handler, NULL, &waiter5))
                printk("\tInsufficient handlers to call function (5)\n");
        smp_call_wait(waiter0);
        smp_call_wait(waiter1);
@@ -411,8 +411,8 @@ void test_lapic_status_bit(void)
 /******************************************************************************/
 /*            Test Measurements: Couples with measurement.c                   */
 // All user processes can R/W the UGDATA page
-barrier_t* bar = (barrier_t*)UGDATA;
-uint32_t* job_to_run = (uint32_t*)(UGDATA + sizeof(barrier_t));
+barrier_t*COUNT(1) bar = (barrier_t*COUNT(1))TC(UGDATA);
+uint32_t*COUNT(1) job_to_run = (uint32_t*COUNT(1))TC(UGDATA + sizeof(barrier_t));
 env_t* env_batch[64]; // Fairly arbitrary, just the max I plan to use.
 
 /* Helpers for test_run_measurements */
@@ -606,9 +606,9 @@ void test_barrier_handler(trapframe_t *tf, void* data)
        //cprintf("Round 4: Core %d\n", core_id());
 }
 
-static void test_waiting_handler(trapframe_t *tf, void* data)
+static void test_waiting_handler(trapframe_t *tf, atomic_t * data)
 {
-       {HANDLER_ATOMIC atomic_dec((atomic_t*)data);}
+       {HANDLER_ATOMIC atomic_dec(data);}
 }
 
 #ifdef __i386__
index fa07e9f..5e2de2f 100644 (file)
@@ -18,7 +18,7 @@
  */
 void process_workqueue()
 {
-       struct work work;
+       struct work TP(env_t *) work;
        struct per_cpu_info *cpuinfo = &per_cpu_info[core_id()];
 
        // copy the work in, since we may never return to this stack frame