Marked lock-required proc functions with __
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 6 Nov 2009 01:00:45 +0000 (17:00 -0800)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 9 Nov 2009 22:20:49 +0000 (14:20 -0800)
In general, I'm using __ to denote a somewhat special function, usually
meant for more internal usage.  In the case of these proc functions, you
need to hold the lock before you call it.  In some other cases, the
functions are internal and not meant to be called directly in most cases
(like __spin_lock, or the active message handlers).

kern/include/process.h
kern/src/env.c
kern/src/manager.c
kern/src/monitor.c
kern/src/process.c
kern/src/resource.c
kern/src/syscall.c

index 06a434a..5b931ce 100644 (file)
@@ -61,7 +61,7 @@ extern uint32_t LCKD(&idle_lock) (RO idlecoremap)[MAX_NUM_CPUS];
 extern uint32_t LCKD(&idle_lock) num_idlecores;
 
 /* Process management: */
-int proc_set_state(struct proc *p, uint32_t state) WRITES(p->state);
+int __proc_set_state(struct proc *p, uint32_t state) WRITES(p->state);
 struct proc *get_proc(unsigned pid);
 bool proc_controls(struct proc *SAFE actor, struct proc *SAFE target);
 /* Transition from RUNNABLE_* to RUNNING_*. */
@@ -80,15 +80,17 @@ void proc_yield(struct proc *SAFE p);
  *
  * WARNING: YOU MUST HOLD THE PROC_LOCK BEFORE CALLING THESE! */
 /* Gives process p the additional num cores listed in corelist */
-error_t proc_give_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num);
+error_t __proc_give_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num);
 /* Makes process p's coremap look like corelist (add, remove, etc) */
-error_t proc_set_allcores(struct proc *SAFE p, uint32_t corelist[], size_t *num,
-                          amr_t message,TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2);
+error_t __proc_set_allcores(struct proc *SAFE p, uint32_t corelist[],
+                            size_t *num, amr_t message, TV(a0t) arg0,
+                            TV(a1t) arg1, TV(a2t) arg2);
 /* Takes from process p the num cores listed in corelist */
-error_t proc_take_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num,
-                        amr_t message, TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2);
-error_t proc_take_allcores(struct proc *SAFE p, amr_t message, TV(a0t) arg0,
-                           TV(a1t) arg1, TV(a2t) arg2);
+error_t __proc_take_cores(struct proc *SAFE p, uint32_t corelist[],
+                          size_t *num, amr_t message, TV(a0t) arg0,
+                          TV(a1t) arg1, TV(a2t) arg2);
+error_t __proc_take_allcores(struct proc *SAFE p, amr_t message, TV(a0t) arg0,
+                             TV(a1t) arg1, TV(a2t) arg2);
 
 /* The reference counts are mostly to track how many cores loaded the cr3 */
 error_t proc_incref(struct proc *SAFE p);
index e679378..3a76a8d 100644 (file)
@@ -269,7 +269,7 @@ env_alloc(env_t **newenv_store, envid_t parent_id)
        // Set the basic status variables.
     spinlock_init(&e->proc_lock);
        e->env_parent_id = parent_id;
-       proc_set_state(e, PROC_CREATED);
+       __proc_set_state(e, PROC_CREATED);
        e->env_runs = 0;
        e->env_refcnt = 1;
        e->env_flags = 0;
index e00d11e..bd091e0 100644 (file)
@@ -45,7 +45,7 @@ void manager(void)
        // of a remote binary to function correctly (schedule() call below)
        if (progress++ == 0) {
                envs[0] = kfs_proc_create(kfs_lookup_path("parlib_matrix"));
-               proc_set_state(envs[0], PROC_RUNNABLE_S);
+               __proc_set_state(envs[0], PROC_RUNNABLE_S);
                proc_run(envs[0]);
        }
        schedule();
@@ -58,15 +58,15 @@ void manager(void)
                        //p = kfs_proc_create(kfs_lookup_path("roslib_spawn"));
                        // being proper and all:
                        spin_lock_irqsave(&p->proc_lock);
-                       proc_set_state(p, PROC_RUNNABLE_S);
+                       __proc_set_state(p, PROC_RUNNABLE_S);
                        // normal single-cored way
                        spin_unlock_irqsave(&p->proc_lock);
                        proc_run(p);
                        #if 0
                        // this is how you can transition to a parallel process manually
                        // make sure you don't proc run first
-                       proc_set_state(p, PROC_RUNNING_S);
-                       proc_set_state(p, PROC_RUNNABLE_M);
+                       __proc_set_state(p, PROC_RUNNING_S);
+                       __proc_set_state(p, PROC_RUNNABLE_M);
                        p->resources[RES_CORES].amt_wanted = 5;
                        spin_unlock_irqsave(&p->proc_lock);
                        core_request(p);
@@ -80,7 +80,7 @@ void manager(void)
                                printk("\nattempting to ghetto preempt...\n");
                                spin_lock_irqsave(&p->proc_lock);
                                proc_take_allcores(p, __death);
-                               proc_set_state(p, PROC_RUNNABLE_M);
+                               __proc_set_state(p, PROC_RUNNABLE_M);
                                spin_unlock_irqsave(&p->proc_lock);
                                udelay(5000000);
                                printk("\nattempting to restart...\n");
@@ -100,7 +100,7 @@ void manager(void)
                        panic("This is okay");
 
                        envs[0] = kfs_proc_create(kfs_lookup_path("roslib_hello"));
-                       proc_set_state(envs[0], PROC_RUNNABLE_S);
+                       __proc_set_state(envs[0], PROC_RUNNABLE_S);
                        proc_run(envs[0]);
                        break;
                        #endif
@@ -133,7 +133,7 @@ void manager(void)
                        // reminder of how to spawn remotely
                        for (int i = 0; i < 8; i++) {
                                envs[i] = kfs_proc_create(kfs_lookup_path("roslib_hello"));
-                               proc_set_state(envs[i], PROC_RUNNABLE_S);
+                               __proc_set_state(envs[i], PROC_RUNNABLE_S);
                                smp_call_function_single(i, run_env_handler, envs[i], 0);
                        }
                        process_workqueue();
index a0f61a3..418fd97 100644 (file)
@@ -258,7 +258,7 @@ int mon_kfs_run(int argc, char *NTS *NT COUNT(argc) argv, trapframe_t *tf)
        struct proc *p = kfs_proc_create(kfs_inode);
        // go from PROC_CREATED->PROC_RUNNABLE_S
        spin_lock_irqsave(&p->proc_lock); // might not be necessary for a mon function
-       proc_set_state(p, PROC_RUNNABLE_S);
+       __proc_set_state(p, PROC_RUNNABLE_S);
        schedule_proc(p);
        spin_unlock_irqsave(&p->proc_lock);
        // Should never return from schedule (env_pop in there)
index b9e5b19..ca0ab8a 100644 (file)
@@ -48,7 +48,7 @@ static void put_idle_core(uint32_t coreid)
  * opportunity to check for bad transitions.  Might compile these out later, so
  * we shouldn't rely on them for sanity checking from userspace.
  */
-int proc_set_state(struct proc *p, uint32_t state)
+int __proc_set_state(struct proc *p, uint32_t state)
 {
        uint32_t curstate = p->state;
        /* Valid transitions:
@@ -115,7 +115,8 @@ struct proc *get_proc(unsigned pid)
        return &envs[ENVX(pid)];
 }
 
-/* Whether or not actor can control target */
+/* Whether or not actor can control target.  Note we currently don't need
+ * locking for this. */
 bool proc_controls(struct proc *actor, struct proc *target)
 {
        return target->env_parent_id == actor->env_id;
@@ -145,7 +146,7 @@ void proc_run(struct proc *p)
                                smp_idle(); // this never returns
                        return;
                case (PROC_RUNNABLE_S):
-                       proc_set_state(p, PROC_RUNNING_S);
+                       __proc_set_state(p, PROC_RUNNING_S);
                        /* We will want to know where this process is running, even if it is
                         * only in RUNNING_S.  can use the vcoremap, which makes death easy.
                         * Also, this is the signal used in trap.c to know to save the tf in
@@ -159,7 +160,7 @@ void proc_run(struct proc *p)
                        proc_startcore(p, &p->env_tf);
                        break;
                case (PROC_RUNNABLE_M):
-                       proc_set_state(p, PROC_RUNNING_M);
+                       __proc_set_state(p, PROC_RUNNING_M);
                        /* vcoremap[i] holds the coreid of the physical core allocated to
                         * this process.  It is set outside proc_run.  For the active
                         * message, a0 = struct proc*, a1 = struct trapframe*.   */
@@ -337,7 +338,7 @@ void proc_destroy(struct proc *p)
                case PROC_RUNNABLE_M:
                        /* Need to reclaim any cores this proc might have, even though it's
                         * not running yet. */
-                       proc_take_allcores(p, NULL, NULL, NULL, NULL);
+                       __proc_take_allcores(p, NULL, NULL, NULL, NULL);
                        // fallthrough
                case PROC_RUNNABLE_S:
                        // Think about other lists, like WAITING, or better ways to do this
@@ -365,8 +366,8 @@ void proc_destroy(struct proc *p)
                         * deallocate the cores.
                         * The rule is that the vcoremap is set before proc_run, and reset
                         * within proc_destroy */
-                       proc_take_allcores(p, __death, (void *SNT)0, (void *SNT)0,
-                                          (void *SNT)0);
+                       __proc_take_allcores(p, __death, (void *SNT)0, (void *SNT)0,
+                                            (void *SNT)0);
                        break;
                default:
                        // TODO: getting here if it's already dead and free (ENV_FREE).
@@ -374,7 +375,7 @@ void proc_destroy(struct proc *p)
                        // them floating around the system.
                        panic("Weird state(0x%08x) in proc_destroy", p->state);
        }
-       proc_set_state(p, PROC_DYING);
+       __proc_set_state(p, PROC_DYING);
 
        atomic_dec(&num_envs);
        /* TODO: (REF) dirty hack.  decref currently uses a lock, but needs to use
@@ -458,7 +459,7 @@ void proc_yield(struct proc *SAFE p)
                case (PROC_RUNNING_S):
                        p->env_tf= *current_tf;
                        env_push_ancillary_state(p);
-                       proc_set_state(p, PROC_RUNNABLE_S);
+                       __proc_set_state(p, PROC_RUNNABLE_S);
                        schedule_proc(p);
                        break;
                case (PROC_RUNNING_M):
@@ -472,7 +473,7 @@ void proc_yield(struct proc *SAFE p)
                        if (p->num_vcores == 0) {
                                // might replace this with m_yield, if we have it directly
                                p->resources[RES_CORES].amt_wanted = 1;
-                               proc_set_state(p, PROC_RUNNABLE_M);
+                               __proc_set_state(p, PROC_RUNNABLE_M);
                                schedule_proc(p);
                        }
                        break;
@@ -512,7 +513,7 @@ void proc_yield(struct proc *SAFE p)
 // passed instead of a pointer to it. If in the future some way will be needed
 // to return the number of cores, then it might be best to use a separate
 // parameter for that.
-error_t proc_give_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num)
+error_t __proc_give_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num)
 { TRUSTEDBLOCK
        uint32_t free_vcoreid = 0;
        switch (p->state) {
@@ -556,8 +557,6 @@ error_t proc_give_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num)
                                send_active_message(corelist[i], __startcore, p,
                                                     (struct Trapframe *)0,
                                                     (void*SNT)free_vcoreid);
-                               //send_active_message(corelist[i], __startcore, p,
-                               //                    (void*)0, (void*)free_vcoreid);
                        }
                        break;
                default:
@@ -575,8 +574,9 @@ error_t proc_give_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num)
  * used.  Implies preempting for the message.
  *
  * WARNING: You must hold the proc_lock before calling this!*/
-error_t proc_set_allcores(struct proc *SAFE p, uint32_t corelist[], size_t *num,
-                          amr_t message,TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2)
+error_t __proc_set_allcores(struct proc *SAFE p, uint32_t corelist[],
+                            size_t *num, amr_t message,TV(a0t) arg0,
+                            TV(a1t) arg1, TV(a2t) arg2)
 {
        panic("Set all cores not implemented.\n");
 }
@@ -587,8 +587,9 @@ error_t proc_set_allcores(struct proc *SAFE p, uint32_t corelist[], size_t *num,
  * might be necessary later.  Or not, and we'll never do it.
  *
  * WARNING: You must hold the proc_lock before calling this!*/
-error_t proc_take_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num,
-                        amr_t message, TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2)
+error_t __proc_take_cores(struct proc *SAFE p, uint32_t corelist[],
+                          size_t *num, amr_t message, TV(a0t) arg0,
+                          TV(a1t) arg1, TV(a2t) arg2)
 { TRUSTEDBLOCK
        uint32_t vcoreid;
        switch (p->state) {
@@ -623,8 +624,8 @@ error_t proc_take_cores(struct proc *SAFE p, uint32_t corelist[], size_t *num,
  * __preempt, it will be sent to the cores.
  *
  * WARNING: You must hold the proc_lock before calling this! */
-error_t proc_take_allcores(struct proc *SAFE p, amr_t message,
-                           TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2)
+error_t __proc_take_allcores(struct proc *SAFE p, amr_t message,
+                             TV(a0t) arg0, TV(a1t) arg1, TV(a2t) arg2)
 {
        uint32_t active_vcoreid = 0;
        switch (p->state) {
index d090ecc..de53a4f 100644 (file)
@@ -45,8 +45,8 @@ ssize_t core_request(struct proc *p)
                env_push_ancillary_state(p);
                proc_set_syscall_retval(&p->env_tf, ESUCCESS);
                // in this case, it's not our job to save contexts or anything
-               proc_take_allcores(p, __death, 0, 0, 0);
-               proc_set_state(p, PROC_RUNNABLE_S);
+               __proc_take_allcores(p, __death, 0, 0, 0);
+               __proc_set_state(p, PROC_RUNNABLE_S);
                schedule_proc(p);
        }
        /* otherwise, see how many new cores are wanted */
@@ -104,7 +104,7 @@ ssize_t core_request(struct proc *p)
                                // will need to give up this core / idle later (sync)
                                need_to_idle = TRUE;
                                // change to runnable_m (it's TF is already saved)
-                               proc_set_state(p, PROC_RUNNABLE_M);
+                               __proc_set_state(p, PROC_RUNNABLE_M);
                                // signals to proc_run that this is a _S to _M transition
                                p->env_flags |= PROC_TRANSITION_TO_M;
                                break;
@@ -119,7 +119,7 @@ ssize_t core_request(struct proc *p)
                                break;
                }
                /* give them the cores.  this will start up the extras if RUNNING_M */
-               proc_give_cores(p, corelist, &num_granted);
+               __proc_give_cores(p, corelist, &num_granted);
                spin_unlock_irqsave(&p->proc_lock);
                /* if there's a race on state (like DEATH), it'll get handled by
                 * proc_run or proc_destroy */
index 10c3c0f..789f385 100644 (file)
@@ -92,7 +92,7 @@ static ssize_t sys_run_binary(env_t* e, void *DANGEROUS binary_buf,
 
        env_t* env = env_create(new_binary, len);
        kfree(new_binary);
-       proc_set_state(env, PROC_RUNNABLE_S);
+       __proc_set_state(env, PROC_RUNNABLE_S);
        schedule_proc(env);
        return 0;
 }
@@ -401,7 +401,7 @@ static error_t sys_proc_run(struct proc *p, unsigned pid)
        } else if (target->state != PROC_CREATED) {
                retval = -EINVAL;
        } else {
-               proc_set_state(target, PROC_RUNNABLE_S);
+               __proc_set_state(target, PROC_RUNNABLE_S);
                schedule_proc(target);
        }
        spin_unlock_irqsave(&p->proc_lock);