Converted curenv calls into an opaque macro
authorBarret Rhoden <brho@cs.berkeley.edu>
Sat, 18 Jul 2009 00:07:31 +0000 (17:07 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Sat, 18 Jul 2009 00:07:31 +0000 (17:07 -0700)
include/env.h
kern/src/env.c
kern/src/kfs.c
kern/src/syscall.c
kern/src/trap.c

index 469c543..6a3012e 100644 (file)
@@ -24,6 +24,12 @@ void (IN_HANDLER env_destroy)(env_t *SAFE e);        // Does not return if e == curenv
 // Temporary scheduler function
 void   schedule(void);
 
+/*
+ * 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[lapic_get_id()])
+
 int    envid2env(envid_t envid, env_t **env_store, bool checkperm);
 // The following three functions do not return
 void   (IN_HANDLER env_run)(env_t *e) __attribute__((noreturn));
index 528d6f8..4d51d38 100644 (file)
@@ -45,11 +45,10 @@ int
 envid2env(envid_t envid, env_t **env_store, bool checkperm)
 {
        env_t *e;
-       env_t* curenv = curenvs[lapic_get_id()];
 
        // If envid is zero, return the current environment.
        if (envid == 0) {
-               *env_store = curenv;
+               *env_store = current;
                return 0;
        }
 
@@ -69,7 +68,8 @@ envid2env(envid_t envid, env_t **env_store, bool checkperm)
        // If checkperm is set, the specified environment
        // must be either the current environment
        // or an immediate child of the current environment.
-       if (checkperm && e != curenv && e->env_parent_id != curenv->env_id) {
+       // TODO: should check for current being null
+       if (checkperm && e != current && e->env_parent_id != current->env_id) {
                *env_store = 0;
                return -EBADENV;
        }
@@ -279,9 +279,7 @@ env_alloc(env_t **newenv_store, envid_t parent_id)
        // show them all of env, only specific things like PID, PPID, etc
        memcpy(e->env_procinfo, e, sizeof(env_t));
 
-       env_t* curenv = curenvs[lapic_get_id()];
-
-       printk("[%08x] new env %08x\n", curenv ? curenv->env_id : 0, e->env_id);
+       printk("[%08x] new env %08x\n", current ? current->env_id : 0, e->env_id);
        } // INIT_STRUCT
        return 0;
 }
@@ -425,10 +423,9 @@ env_t* env_create(uint8_t *binary, size_t size)
 {
        env_t *e;
        int r;
-       env_t *curenv = curenvs[lapic_get_id()];
        envid_t curid;
        
-       curid = (curenv ? curenv->env_id : 0);  
+       curid = (current ? current->env_id : 0);        
        if ((r = env_alloc(&e, curid)) < 0)
                panic("env_create: %e", r);
        load_icode(e, binary, size);
@@ -446,8 +443,7 @@ env_free(env_t *e)
        physaddr_t pa;
 
        // Note the environment's demise.
-       env_t* curenv = curenvs[lapic_get_id()];
-       cprintf("[%08x] free env %08x\n", curenv ? curenv->env_id : 0, e->env_id);
+       cprintf("[%08x] free env %08x\n", current ? current->env_id : 0, e->env_id);
 
        // Flush all mapped pages in the user portion of the address space
        static_assert(UTOP % PTSIZE == 0);
@@ -545,8 +541,8 @@ env_destroy(env_t *e)
        // never get back to their old hlt/relaxed/spin state, so we need to force
        // them back to an idle function.
        uint32_t id = lapic_get_id();
-       // There is no longer a curenv for this core. (TODO: Think about this.)
-       curenvs[id] = NULL;
+       // There is no longer a current process for this core. (TODO: Think about this.)
+       current = NULL;
        if (id) {
                smp_idle();
                panic("should never see me");
@@ -622,15 +618,15 @@ void env_pop_tf_sysexit(trapframe_t *tf)
 }
 
 //
-// Context switch from curenv to env e.
-// Note: if this is the first call to env_run, curenv is NULL.
+// Context switch from current process to env e.
+// Note: if this is the first call to env_run, current is NULL.
 //  (This function does not return.)
 //
 void
 env_run(env_t *e)
 {
        // Step 1: If this is a context switch (a new environment is running),
-       //         then set 'curenv' to the new environment,
+       //         then set 'current' to the new environment,
        //         update its 'env_runs' counter, and
        //         and use lcr3() to switch to its address space.
        // Step 2: Use env_pop_tf() to restore the environment's
@@ -645,8 +641,8 @@ env_run(env_t *e)
        // TODO: race here with env destroy on the status and refcnt
        // Could up the refcnt and down it when a process is not running
        e->env_status = ENV_RUNNING;
-       if (e != curenvs[lapic_get_id()]) {
-               curenvs[lapic_get_id()] = e;
+       if (e != current) {
+               current = e;
                e->env_runs++;
                lcr3(e->env_cr3);
        }
index 9c32bd6..b335394 100644 (file)
  * userapps in kern/src/Makefrag.
  * Make sure to declare it, and add an entry.  Keep MAX_KFS_FILES big enough too
  */
-DECL_PROG(roslib_hello);
+DECL_PROG(parlib_matrix);
 DECL_PROG(roslib_null);
+DECL_PROG(roslib_hello);
+DECL_PROG(roslib_proctests);
 DECL_PROG(roslib_spawn);
+DECL_PROG(roslib_measurements);
 
 struct kfs_entry kfs[MAX_KFS_FILES] = {
-       KFS_ENTRY(roslib_hello)
+       KFS_ENTRY(parlib_matrix)
        KFS_ENTRY(roslib_null)
+       KFS_ENTRY(roslib_hello)
+       KFS_ENTRY(roslib_proctests)
        KFS_ENTRY(roslib_spawn)
+       KFS_ENTRY(roslib_measurements)
 };
 
 ssize_t kfs_lookup_path(char* path)
index 9efdd19..74ce283 100644 (file)
 /* This is called from sysenter's asm, with the tf on the kernel stack. */
 void sysenter_callwrapper(struct Trapframe *tf)
 {
-       env_t* curenv = curenvs[lapic_get_id()];
-       curenv->env_tf = *tf;
+       current->env_tf = *tf;
        
        // The trapframe on the stack should be ignored from here on.
-       tf = &curenv->env_tf;
-       tf->tf_regs.reg_eax = (intreg_t) syscall(curenv,
+       tf = &current->env_tf;
+       tf->tf_regs.reg_eax = (intreg_t) syscall(current,
                                                 tf->tf_regs.reg_eax,
                                                 tf->tf_regs.reg_edx,
                                                 tf->tf_regs.reg_ecx,
                                                 tf->tf_regs.reg_ebx,
                                                 tf->tf_regs.reg_edi,
                                                 0);
-       env_run(curenv);
+       /*
+        * careful here - we need to make sure that this current is the right
+        * process, which could be weird if the syscall blocked.  it would need to
+        * restore the proper value in current before returning to here.
+        */
+       env_run(current);
 }
 
 //Do absolutely nothing.  Used for profiling.
index 924ccd3..561fddf 100644 (file)
@@ -158,8 +158,6 @@ void
 static void
 (IN_HANDLER trap_dispatch)(trapframe_t *tf)
 {
-       env_t* curenv = curenvs[lapic_get_id()];
-
        // Handle processor exceptions.
        switch(tf->tf_trapno) {
                case T_BRKPT:
@@ -174,10 +172,10 @@ static void
                        // check for userspace, for now
                        assert(tf->tf_cs != GD_KT);
                        tf->tf_regs.reg_eax =
-                               syscall(curenv, tf->tf_regs.reg_eax, tf->tf_regs.reg_edx,
+                               syscall(current, tf->tf_regs.reg_eax, tf->tf_regs.reg_edx,
                                        tf->tf_regs.reg_ecx, tf->tf_regs.reg_ebx,
                                        tf->tf_regs.reg_edi, tf->tf_regs.reg_esi);
-                       env_run(curenv);
+                       env_run(current); // Note the comment in syscall.c
                        break;
                default:
                        // Unexpected trap: The user process or the kernel has a bug.
@@ -186,7 +184,7 @@ static void
                                panic("Damn Damn!  Unhandled trap in the kernel!");
                        else {
                                warn("Unexpected trap from userspace");
-                               env_destroy(curenv);
+                               env_destroy(current);
                                return;
                        }
        }
@@ -198,7 +196,6 @@ void
 {
        //cprintf("Incoming TRAP frame at %p\n", tf);
 
-       env_t* curenv = curenvs[lapic_get_id()];
        if ((tf->tf_cs & ~3) != GD_UT && (tf->tf_cs & ~3) != GD_KT) {
                print_trapframe(tf);
                panic("Trapframe with invalid CS!");
@@ -208,12 +205,12 @@ void
                // Trapped from user mode.
                // TODO: this will change when an env has more than one context
                // Copy trap frame (which is currently on the stack)
-               // into 'curenv->env_tf', so that running the environment
+               // into 'current->env_tf', so that running the environment
                // will restart at the trap point.
-               assert(curenv);
-               curenv->env_tf = *tf;
+               assert(current);
+               current->env_tf = *tf;
                // The trapframe on the stack should be ignored from here on.
-               tf = &curenv->env_tf;
+               tf = &current->env_tf;
        }
 
        // Dispatch based on what type of trap occurred
@@ -223,8 +220,8 @@ void
        // so far we never get here
        assert(0);
         // Return to the current environment, which should be runnable.
-        assert(curenv && curenv->env_status == ENV_RUNNABLE);
-        env_run(curenv);
+        assert(current && current->env_status == ENV_RUNNABLE);
+        env_run(current);
 }
 
 void
@@ -286,7 +283,7 @@ page_fault_handler(trapframe_t *tf)
 
        // Call the environment's page fault upcall, if one exists.  Set up a
        // page fault stack frame on the user exception stack (below
-       // UXSTACKTOP), then branch to curenv->env_pgfault_upcall.
+       // UXSTACKTOP), then branch to current->env_pgfault_upcall.
        //
        // The page fault upcall might cause another page fault, in which case
        // we branch to the page fault upcall recursively, pushing another
@@ -306,17 +303,16 @@ page_fault_handler(trapframe_t *tf)
        //
        // Hints:
        //   user_mem_assert() and env_run() are useful here.
-       //   To change what the user environment runs, modify 'curenv->env_tf'
-       //   (the 'tf' variable points at 'curenv->env_tf').
+       //   To change what the user environment runs, modify 'current->env_tf'
+       //   (the 'tf' variable points at 'current->env_tf').
 
        // LAB 4: Your code here.
 
        // Destroy the environment that caused the fault.
-       env_t* curenv = curenvs[lapic_get_id()];
        cprintf("[%08x] user fault va %08x ip %08x from core %d\n",
-               curenv->env_id, fault_va, tf->tf_eip, lapic_get_id());
+               current->env_id, fault_va, tf->tf_eip, lapic_get_id());
        print_trapframe(tf);
-       env_destroy(curenv);
+       env_destroy(current);
 }
 
 void sysenter_init(void)