Enable the PFM sampling to pass an 64bit info value
[akaros.git] / kern / src / process.c
index c9d63f7..1e7f103 100644 (file)
@@ -749,7 +749,7 @@ void __proc_startcore(struct proc *p, struct user_context *ctx)
        assert(!irq_is_enabled());
        /* Should never have ktask still set.  If we do, future syscalls could try
         * to block later and lose track of our address space. */
        assert(!irq_is_enabled());
        /* Should never have ktask still set.  If we do, future syscalls could try
         * to block later and lose track of our address space. */
-       assert(!pcpui->cur_kthread->is_ktask);
+       assert(!is_ktask(pcpui->cur_kthread));
        __set_proc_current(p);
        /* Clear the current_ctx, since it is no longer used */
        current_ctx = 0;        /* TODO: might not need this... */
        __set_proc_current(p);
        /* Clear the current_ctx, since it is no longer used */
        current_ctx = 0;        /* TODO: might not need this... */
@@ -767,16 +767,8 @@ void __proc_startcore(struct proc *p, struct user_context *ctx)
 void proc_restartcore(void)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
 void proc_restartcore(void)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
+
        assert(!pcpui->cur_kthread->sysc);
        assert(!pcpui->cur_kthread->sysc);
-       /* TODO: can probably remove this enable_irq.  it was an optimization for
-        * RKMs */
-       /* Try and get any interrupts before we pop back to userspace.  If we didn't
-        * do this, we'd just get them in userspace, but this might save us some
-        * effort/overhead. */
-       enable_irq();
-       /* Need ints disabled when we return from PRKM (race on missing
-        * messages/IPIs) */
-       disable_irq();
        process_routine_kmsg();
        /* If there is no owning process, just idle, since we don't know what to do.
         * This could be because the process had been restarted a long time ago and
        process_routine_kmsg();
        /* If there is no owning process, just idle, since we don't know what to do.
         * This could be because the process had been restarted a long time ago and
@@ -949,7 +941,7 @@ int proc_change_to_m(struct proc *p)
                        struct preempt_data *vcpd = &p->procdata->vcore_preempt_data[0];
                        assert(current_ctx);
                        /* Copy uthread0's context to VC 0's uthread slot */
                        struct preempt_data *vcpd = &p->procdata->vcore_preempt_data[0];
                        assert(current_ctx);
                        /* Copy uthread0's context to VC 0's uthread slot */
-                       vcpd->uthread_ctx = *current_ctx;
+                       copy_current_ctx_to(&vcpd->uthread_ctx);
                        clear_owning_proc(core_id());   /* so we don't restart */
                        save_vc_fp_state(vcpd);
                        /* Userspace needs to not fuck with notif_disabled before
                        clear_owning_proc(core_id());   /* so we don't restart */
                        save_vc_fp_state(vcpd);
                        /* Userspace needs to not fuck with notif_disabled before
@@ -1006,7 +998,7 @@ uint32_t __proc_change_to_s(struct proc *p, uint32_t *pc_arr)
        assert(p->state == PROC_RUNNING_M); // TODO: (ACR) async core req
        /* save the context, to be restarted in _S mode */
        assert(current_ctx);
        assert(p->state == PROC_RUNNING_M); // TODO: (ACR) async core req
        /* save the context, to be restarted in _S mode */
        assert(current_ctx);
-       p->scp_ctx = *current_ctx;
+       copy_current_ctx_to(&p->scp_ctx);
        clear_owning_proc(core_id());   /* so we don't restart */
        save_vc_fp_state(vcpd);
        /* sending death, since it's not our job to save contexts or anything in
        clear_owning_proc(core_id());   /* so we don't restart */
        save_vc_fp_state(vcpd);
        /* sending death, since it's not our job to save contexts or anything in
@@ -1091,7 +1083,7 @@ void __proc_save_fpu_s(struct proc *p)
  * VCPD) as a location for pcpui->cur_ctx to point (dangerous) */
 void __proc_save_context_s(struct proc *p)
 {
  * VCPD) as a location for pcpui->cur_ctx to point (dangerous) */
 void __proc_save_context_s(struct proc *p)
 {
-       p->scp_ctx = *current_ctx;
+       copy_current_ctx_to(&p->scp_ctx);
        __seq_start_write(&p->procinfo->coremap_seqctr);
        __unmap_vcore(p, 0);
        __seq_end_write(&p->procinfo->coremap_seqctr);
        __seq_start_write(&p->procinfo->coremap_seqctr);
        __unmap_vcore(p, 0);
        __seq_end_write(&p->procinfo->coremap_seqctr);
@@ -1251,6 +1243,8 @@ void proc_yield(struct proc *p, bool being_nice)
                __proc_set_state(p, PROC_WAITING);
        }
        spin_unlock(&p->proc_lock);
                __proc_set_state(p, PROC_WAITING);
        }
        spin_unlock(&p->proc_lock);
+       /* We discard the current context, but we still need to restore the core */
+       arch_finalize_ctx(pcpui->cur_ctx);
        /* Hand the now-idle core to the ksched */
        __sched_put_idle_core(p, pcoreid);
        goto out_yield_core;
        /* Hand the now-idle core to the ksched */
        __sched_put_idle_core(p, pcoreid);
        goto out_yield_core;
@@ -1789,14 +1783,16 @@ void clear_owning_proc(uint32_t coreid)
 
 /* Switches to the address space/context of new_p, doing nothing if we are
  * already in new_p.  This won't add extra refcnts or anything, and needs to be
 
 /* Switches to the address space/context of new_p, doing nothing if we are
  * already in new_p.  This won't add extra refcnts or anything, and needs to be
- * paired with switch_back() at the end of whatever function you are in.  Don't
- * migrate cores in the middle of a pair.  Specifically, the uncounted refs are
- * one for the old_proc, which is passed back to the caller, and new_p is
- * getting placed in cur_proc. */
-struct proc *switch_to(struct proc *new_p)
+ * paired with switch_back() at the end of whatever function you are in.
+ * Specifically, the uncounted refs are one for the old_proc, which is passed
+ * back to the caller, and new_p is getting placed in cur_proc. */
+uintptr_t switch_to(struct proc *new_p)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
+       struct kthread *kth = pcpui->cur_kthread;
        struct proc *old_proc;
        struct proc *old_proc;
+       uintptr_t ret;
+
        old_proc = pcpui->cur_proc;                                     /* uncounted ref */
        /* If we aren't the proc already, then switch to it */
        if (old_proc != new_p) {
        old_proc = pcpui->cur_proc;                                     /* uncounted ref */
        /* If we aren't the proc already, then switch to it */
        if (old_proc != new_p) {
@@ -1806,14 +1802,33 @@ struct proc *switch_to(struct proc *new_p)
                else
                        lcr3(boot_cr3);
        }
                else
                        lcr3(boot_cr3);
        }
-       return old_proc;
+       ret = (uintptr_t)old_proc;
+       if (is_ktask(kth)) {
+               if (!(kth->flags & KTH_SAVE_ADDR_SPACE)) {
+                       kth->flags |= KTH_SAVE_ADDR_SPACE;
+                       /* proc pointers are aligned; we can use the lower bit as a signal
+                        * to turn off SAVE_ADDR_SPACE. */
+                       ret |= 0x1;
+               }
+       }
+       return ret;
 }
 
 }
 
-/* This switches back to old_proc from new_p.  Pair it with switch_to(), and
- * pass in its return value for old_proc. */
-void switch_back(struct proc *new_p, struct proc *old_proc)
+/* This switches back from new_p to the original process.  Pair it with
+ * switch_to(), and pass in its return value for old_ret. */
+void switch_back(struct proc *new_p, uintptr_t old_ret)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
+       struct kthread *kth = pcpui->cur_kthread;
+       struct proc *old_proc;
+
+       if (is_ktask(kth)) {
+               if (old_ret & 0x1) {
+                       kth->flags &= ~KTH_SAVE_ADDR_SPACE;
+                       old_ret &= ~0x1;
+               }
+       }
+       old_proc = (struct proc*)old_ret;
        if (old_proc != new_p) {
                pcpui->cur_proc = old_proc;
                if (old_proc)
        if (old_proc != new_p) {
                pcpui->cur_proc = old_proc;
                if (old_proc)
@@ -2001,11 +2016,15 @@ int proc_change_to_vcore(struct proc *p, uint32_t new_vcoreid,
                 * and we don't care about either the uthread_ctx or the vcore_ctx. */
                caller_vcpd->notif_disabled = FALSE;
                /* Don't need to save the FPU.  There should be no uthread or other
                 * and we don't care about either the uthread_ctx or the vcore_ctx. */
                caller_vcpd->notif_disabled = FALSE;
                /* Don't need to save the FPU.  There should be no uthread or other
-                * reason to return to the FPU state. */
+                * reason to return to the FPU state.  But we do need to finalize the
+                * context, even though we are throwing it away.  We need to return the
+                * pcore to a state where it can run any context and not be bound to
+                * the old context. */
+               arch_finalize_ctx(pcpui->cur_ctx);
        } else {
                /* need to set up the calling vcore's ctx so that it'll get restarted by
                 * __startcore, to make the caller look like it was preempted. */
        } else {
                /* need to set up the calling vcore's ctx so that it'll get restarted by
                 * __startcore, to make the caller look like it was preempted. */
-               caller_vcpd->vcore_ctx = *current_ctx;
+               copy_current_ctx_to(&caller_vcpd->vcore_ctx);
                save_vc_fp_state(caller_vcpd);
        }
        /* Mark our core as preempted (for userspace recovery).  Userspace checks
                save_vc_fp_state(caller_vcpd);
        }
        /* Mark our core as preempted (for userspace recovery).  Userspace checks
@@ -2136,7 +2155,7 @@ void __notify(uint32_t srcid, long a0, long a1, long a2)
        vcpd->notif_disabled = TRUE;
        /* save the old ctx in the uthread slot, build and pop a new one.  Note that
         * silly state isn't our business for a notification. */
        vcpd->notif_disabled = TRUE;
        /* save the old ctx in the uthread slot, build and pop a new one.  Note that
         * silly state isn't our business for a notification. */
-       vcpd->uthread_ctx = *pcpui->cur_ctx;
+       copy_current_ctx_to(&vcpd->uthread_ctx);
        memset(pcpui->cur_ctx, 0, sizeof(struct user_context));
        proc_init_ctx(pcpui->cur_ctx, vcoreid, vcpd->vcore_entry,
                      vcpd->vcore_stack, vcpd->vcore_tls_desc);
        memset(pcpui->cur_ctx, 0, sizeof(struct user_context));
        proc_init_ctx(pcpui->cur_ctx, vcoreid, vcpd->vcore_entry,
                      vcpd->vcore_stack, vcpd->vcore_tls_desc);
@@ -2167,9 +2186,9 @@ void __preempt(uint32_t srcid, long a0, long a1, long a2)
         * cur_ctx in the uthread slot, and it'll appear to the vcore when it comes
         * back up the uthread just took a notification. */
        if (vcpd->notif_disabled)
         * cur_ctx in the uthread slot, and it'll appear to the vcore when it comes
         * back up the uthread just took a notification. */
        if (vcpd->notif_disabled)
-               vcpd->vcore_ctx = *pcpui->cur_ctx;
+               copy_current_ctx_to(&vcpd->vcore_ctx);
        else
        else
-               vcpd->uthread_ctx = *pcpui->cur_ctx;
+               copy_current_ctx_to(&vcpd->uthread_ctx);
        /* Userspace in a preemption handler on another core might be copying FP
         * state from memory (VCPD) at the moment, and if so we don't want to
         * clobber it.  In this rare case, our current core's FPU state should be
        /* Userspace in a preemption handler on another core might be copying FP
         * state from memory (VCPD) at the moment, and if so we don't want to
         * clobber it.  In this rare case, our current core's FPU state should be
@@ -2211,7 +2230,8 @@ void __death(uint32_t srcid, long a0, long a1, long a2)
                vcore_account_offline(p, vcoreid);      /* in case anyone is counting */
                /* We won't restart the process later.  current gets cleared later when
                 * we notice there is no owning_proc and we have nothing to do
                vcore_account_offline(p, vcoreid);      /* in case anyone is counting */
                /* We won't restart the process later.  current gets cleared later when
                 * we notice there is no owning_proc and we have nothing to do
-                * (smp_idle, restartcore, etc) */
+                * (smp_idle, restartcore, etc). */
+               arch_finalize_ctx(pcpui->cur_ctx);
                clear_owning_proc(coreid);
        }
 }
                clear_owning_proc(coreid);
        }
 }