Remove bootp
[akaros.git] / kern / src / process.c
index b8a6f75..dd561ca 100644 (file)
@@ -211,7 +211,7 @@ struct proc *pid_nth(unsigned int n)
                 * so continue
                 */
 
-               if (kref_get_not_zero(&p->p_kref, 1)){
+               if (kref_get_not_zero(&p->p_kref, 1)) {
                        /* this one counts */
                        if (! n){
                                printd("pid_nth: at end, p %p\n", p);
@@ -220,7 +220,7 @@ struct proc *pid_nth(unsigned int n)
                        kref_put(&p->p_kref);
                        n--;
                }
-               if (!hashtable_iterator_advance(iter)){
+               if (!hashtable_iterator_advance(iter)) {
                        p = NULL;
                        break;
                }
@@ -330,6 +330,8 @@ error_t proc_alloc(struct proc **pp, struct proc *parent, int flags)
                kmem_cache_free(proc_cache, p);
                return -ENOFREEPID;
        }
+       if (parent && parent->binary_path)
+               kstrdup(&p->binary_path, parent->binary_path);
        /* Set the basic status variables. */
        spinlock_init(&p->proc_lock);
        p->exitcode = 1337;     /* so we can see processes killed by the kernel */
@@ -408,6 +410,7 @@ error_t proc_alloc(struct proc **pp, struct proc *parent, int flags)
        TAILQ_INIT(&p->abortable_sleepers);
        spinlock_init_irqsave(&p->abort_list_lock);
        memset(&p->vmm, 0, sizeof(struct vmm));
+       spinlock_init(&p->vmm.lock);
        qlock_init(&p->vmm.qlock);
        printd("[%08x] new process %08x\n", current ? current->pid : 0, p->pid);
        *pp = p;
@@ -465,6 +468,10 @@ static void __proc_free(struct kref *kref)
        assert(kref_refcnt(&p->p_kref) == 0);
        assert(TAILQ_EMPTY(&p->alarmset.list));
 
+       if (p->strace) {
+               kref_put(&p->strace->procs);
+               kref_put(&p->strace->users);
+       }
        __vmm_struct_cleanup(p);
        p->progname[0] = 0;
        free_path(p, p->binary_path);
@@ -747,10 +754,8 @@ 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(!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_cpu_state(pcpui, CPU_STATE_USER);
        proc_pop_ctx(ctx);
 }
@@ -765,16 +770,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()];
+
        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
@@ -813,10 +810,7 @@ void proc_destroy(struct proc *p)
        uint32_t nr_cores_revoked = 0;
        struct kthread *sleeper;
        struct proc *child_i, *temp;
-       /* Can't spin on the proc lock with irq disabled.  This is a problem for all
-        * places where we grab the lock, but it is particularly bad for destroy,
-        * since we tend to call this from trap and irq handlers */
-       assert(irq_is_enabled());
+
        spin_lock(&p->proc_lock);
        /* storage for pc_arr is alloced at decl, which is after grabbing the lock*/
        uint32_t pc_arr[p->procinfo->num_vcores];
@@ -947,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 */
-                       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
@@ -1004,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);
-       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
@@ -1087,9 +1081,9 @@ void __proc_save_fpu_s(struct proc *p)
  * In the future, we'll probably use vc0's space for scp_ctx and the silly
  * state.  If we ever do that, we'll need to stop using scp_ctx (soon to be in
  * VCPD) as a location for pcpui->cur_ctx to point (dangerous) */
-void __proc_save_context_s(struct proc *p, struct user_context *ctx)
+void __proc_save_context_s(struct proc *p)
 {
-       p->scp_ctx = *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);
@@ -1152,13 +1146,13 @@ void proc_yield(struct proc *p, bool being_nice)
                                /* if we're here, we want to sleep.  a concurrent event that
                                 * hasn't already written notif_pending will have seen WAITING,
                                 * and will be spinning while we do this. */
-                               __proc_save_context_s(p, current_ctx);
+                               __proc_save_context_s(p);
                                spin_unlock(&p->proc_lock);
                        } else {
                                /* yielding to allow other processes to run.  we're briefly
                                 * WAITING, til we are woken up */
                                __proc_set_state(p, PROC_WAITING);
-                               __proc_save_context_s(p, current_ctx);
+                               __proc_save_context_s(p);
                                spin_unlock(&p->proc_lock);
                                /* immediately wake up the proc (makes it runnable) */
                                proc_wakeup(p);
@@ -1249,6 +1243,8 @@ void proc_yield(struct proc *p, bool being_nice)
                __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;
@@ -1787,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
- * 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 kthread *kth = pcpui->cur_kthread;
        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) {
@@ -1804,14 +1802,33 @@ struct proc *switch_to(struct proc *new_p)
                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 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)
@@ -1999,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
-                * 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. */
-               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
@@ -2134,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->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);
@@ -2165,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)
-               vcpd->vcore_ctx = *pcpui->cur_ctx;
+               copy_current_ctx_to(&vcpd->vcore_ctx);
        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
@@ -2209,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
-                * (smp_idle, restartcore, etc) */
+                * (smp_idle, restartcore, etc). */
+               arch_finalize_ctx(pcpui->cur_ctx);
                clear_owning_proc(coreid);
        }
 }
@@ -2245,6 +2267,48 @@ void print_allpids(void)
        spin_unlock(&pid_hash_lock);
 }
 
+void proc_get_set(struct process_set *pset)
+{
+       void enum_proc(void *item, void *opaque)
+       {
+               struct proc *p = (struct proc*) item;
+               struct process_set *pset = (struct process_set *) opaque;
+
+               if (pset->num_processes < pset->size) {
+                       proc_incref(p, 1);
+
+                       pset->procs[pset->num_processes] = p;
+                       pset->num_processes++;
+               }
+       }
+
+       static const size_t num_extra_alloc = 16;
+
+       pset->procs = NULL;
+       do {
+               if (pset->procs)
+                       proc_free_set(pset);
+               pset->size = atomic_read(&num_envs) + num_extra_alloc;
+               pset->num_processes = 0;
+               pset->procs = (struct proc **)
+                       kzmalloc(pset->size * sizeof(struct proc *), KMALLOC_WAIT);
+               if (!pset->procs)
+                       error(-ENOMEM, ERROR_FIXME);
+
+               spin_lock(&pid_hash_lock);
+               hash_for_each(pid_hash, enum_proc, pset);
+               spin_unlock(&pid_hash_lock);
+
+       } while (pset->num_processes == pset->size);
+}
+
+void proc_free_set(struct process_set *pset)
+{
+       for (size_t i = 0; i < pset->num_processes; i++)
+               proc_decref(pset->procs[i]);
+       kfree(pset->procs);
+}
+
 void print_proc_info(pid_t pid)
 {
        int j = 0;