Proc refcnting wrappers
[akaros.git] / kern / src / resource.c
index f8e710a..48a83d9 100644 (file)
@@ -12,6 +12,7 @@
 
 #include <resource.h>
 #include <process.h>
+#include <smp.h>
 #include <stdio.h>
 #include <assert.h>
 #include <schedule.h>
@@ -42,15 +43,21 @@ ssize_t core_request(struct proc *p)
        bool need_to_idle = FALSE;
        bool self_ipi_pending = FALSE;
 
+       /* There are a few things broken for now if you don't have a current_tf */
+       assert(current_tf);
        spin_lock(&p->proc_lock);
+       if (p->state == PROC_DYING) {
+               return -EFAIL;
+               spin_unlock(&p->proc_lock);
+       }
        /* check to see if this is a full deallocation.  for cores, it's a
         * transition from _M to _S.  Will be issues with handling this async. */
        if (!p->resources[RES_CORES].amt_wanted) {
                assert(p->state == PROC_RUNNING_M); // TODO: (ACR) async core req
-               // save the context, to be restarted in _S mode
+               /* save the context, to be restarted in _S mode */
                p->env_tf = *current_tf;
+               current_tf = 0;                 /* Make sure it isn't used in the future */
                env_push_ancillary_state(p); // TODO: (HSS)
-               proc_set_syscall_retval(&p->env_tf, ESUCCESS);
                /* sending death, since it's not our job to save contexts or anything in
                 * this case.  also, if this returns true, we will not return down
                 * below, and need to eat the reference to p */
@@ -143,6 +150,8 @@ ssize_t core_request(struct proc *p)
                                 * descheduled? */
                                panic("Not supporting RUNNABLE_S -> RUNNABLE_M yet.\n");
                                break;
+                       case (PROC_DYING):
+                               warn("Dying, core request coming from %d\n", core_id());
                        default:
                                break;
                }
@@ -160,8 +169,9 @@ ssize_t core_request(struct proc *p)
                 * (just like in proc_destroy).  it also needs to decref, to consume the
                 * reference that came into this function (since we don't return).  */
                if (need_to_idle) {
-                       proc_decref(p, 1);
+                       proc_decref(p);
                        abandon_core();
+                       smp_idle();
                }
        } else { // nothing granted, just return
                spin_unlock(&p->proc_lock);
@@ -192,7 +202,7 @@ error_t resource_req(struct proc *p, int type, size_t amt_wanted,
                        retval = core_request(p);
                        // i don't like this retval hackery
                        if (retval < 0) {
-                               set_errno(current_tf, -retval);
+                               set_errno(-retval);
                                return -1;
                        }
                        else