notif_enabled -> notif_disabled (XCC)
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 9 Nov 2011 00:55:06 +0000 (16:55 -0800)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 15 Dec 2011 22:48:40 +0000 (14:48 -0800)
The default state is now notifs enabled.  Vcores will still come up with
notifs disabled: the kernel will sort that out.  Its just that fresh
vcore preempt data won't need to have notifs manually enabled or
anything for the _S -> _M transition.

Reinstall your kernel header(s).

15 files changed:
kern/include/ros/event.h
kern/src/process.c
kern/src/resource.c
tests/eth_audio.c
tests/msr_cycling_vcores.c
tests/msr_dumb_while.c
tests/msr_get_cores.c
tests/msr_get_singlecore.c
tests/syscall.c
user/c3po/threads/vcore.c
user/parlib/include/i686/vcore.h
user/parlib/include/sparc/vcore.h
user/parlib/include/vcore.h
user/parlib/uthread.c
user/parlib/vcore.c

index 2351dd8..37eed70 100644 (file)
@@ -92,7 +92,7 @@ struct preempt_data {
        struct ancillary_state          preempt_anc;
        struct user_trapframe           notif_tf;
        uintptr_t                                       transition_stack;       /* advertised by the user */
-       bool                                            notif_enabled;          /* vcore willing to recv */
+       bool                                            notif_disabled;         /* vcore unwilling to recv*/
        bool                                            notif_pending;          /* notif k_msg on the way */
        bool                                            can_rcv_msg;            /* can receive FALLBACK */
        seq_ctr_t                                       preempt_tf_valid;
index 19ce670..171f4cb 100644 (file)
@@ -904,8 +904,8 @@ void proc_notify(struct proc *p, uint32_t vcoreid)
 {
        struct preempt_data *vcpd = &p->procdata->vcore_preempt_data[vcoreid];
        vcpd->notif_pending = TRUE;
-       wrmb(); /* must write notif_pending before reading notif_enabled */
-       if (vcpd->notif_enabled) {
+       wrmb(); /* must write notif_pending before reading notif_disabled */
+       if (!vcpd->notif_disabled) {
                /* GIANT WARNING: we aren't using the proc-lock to protect the
                 * vcoremap.  We want to be able to use this from interrupt context,
                 * and don't want the proc_lock to be an irqsave.  Spurious
@@ -1470,13 +1470,13 @@ static void __set_curtf_to_vcoreid(struct proc *p, uint32_t vcoreid)
                /* notif_pending and enabled means the proc wants to receive the IPI,
                 * but might have missed it.  copy over the tf so they can restart it
                 * later, and give them a fresh vcore. */
-               if (vcpd->notif_pending && vcpd->notif_enabled) {
+               if (vcpd->notif_pending && !vcpd->notif_disabled) {
                        vcpd->notif_tf = vcpd->preempt_tf; // could memset
                        proc_init_trapframe(&pcpui->actual_tf, vcoreid, p->env_entry,
                                            vcpd->transition_stack);
                        if (!vcpd->transition_stack)
                                warn("No transition stack!");
-                       vcpd->notif_enabled = FALSE;
+                       vcpd->notif_disabled = TRUE;
                        vcpd->notif_pending = FALSE;
                } else {
                        /* copy-in the tf we'll pop, then set all security-related fields */
@@ -1489,7 +1489,7 @@ static void __set_curtf_to_vcoreid(struct proc *p, uint32_t vcoreid)
                proc_init_trapframe(&pcpui->actual_tf, vcoreid, p->env_entry,
                                    vcpd->transition_stack);
                /* Disable/mask active notifications for fresh vcores */
-               vcpd->notif_enabled = FALSE;
+               vcpd->notif_disabled = TRUE;
        }
        /* cur_tf was built above (in actual_tf), now use it */
        pcpui->cur_tf = &pcpui->actual_tf;
@@ -1546,7 +1546,7 @@ void proc_change_to_vcore(struct proc *p, uint32_t new_vcoreid,
        if (enable_my_notif) {
                /* if they set this flag, then the vcore can just restart from scratch,
                 * and we don't care about either the notif_tf or the preempt_tf. */
-               caller_vcpd->notif_enabled = TRUE;
+               caller_vcpd->notif_disabled = FALSE;
        } else {
                /* need to set up the calling vcore's tf so that it'll get restarted by
                 * __startcore, to make the caller look like it was preempted. */
@@ -1640,9 +1640,9 @@ void __notify(struct trapframe *tf, uint32_t srcid, long a0, long a1, long a2)
        printd("received active notification for proc %d's vcore %d on pcore %d\n",
               p->procinfo->pid, vcoreid, coreid);
        /* sort signals.  notifs are now masked, like an interrupt gate */
-       if (!vcpd->notif_enabled)
+       if (vcpd->notif_disabled)
                return;
-       vcpd->notif_enabled = FALSE;
+       vcpd->notif_disabled = TRUE;
        vcpd->notif_pending = FALSE; // no longer pending - it made it here
        /* save the old tf in the notify slot, build and pop a new one.  Note that
         * silly state isn't our business for a notification. */
index 2b91927..a7f2ad7 100644 (file)
@@ -134,7 +134,7 @@ ssize_t core_request(struct proc *p)
                                __seq_start_write(&vcpd->preempt_tf_valid);
                                /* If we remove this, vcore0 will start where the _S left off */
                                vcpd->notif_pending = TRUE;
-                               assert(vcpd->notif_enabled);
+                               assert(!vcpd->notif_disabled);
                                /* in the async case, we'll need to remotely stop and bundle
                                 * vcore0's TF.  this is already done for the sync case (local
                                 * syscall). */
index b290d9e..8eec163 100644 (file)
@@ -63,11 +63,6 @@ int main()
        /* Need to save our floating point state somewhere (like in the
         * user_thread_tcb so it can be restarted too */
 
-       /* don't forget to enable notifs on vcore0 at some point */
-       struct preempt_data *vcpd;
-       vcpd = &__procdata.vcore_preempt_data[0];
-       vcpd->notif_enabled = TRUE;
-       
 /* end: stuff userspace needs to do before switching to multi-mode */
        /* ETHAUD */
        /* Switch into _M mode */
@@ -133,7 +128,7 @@ void vcore_entry(void)
         * to clobber the transition stack.
         * Check Documentation/processes.txt: 4.2.4.  In real code, you should be
         * popping the tf of whatever user process you want (get off the x-stack) */
-       vcpd->notif_enabled = TRUE;
+       vcpd->notif_disabled = FALSE;
        
 /* end: stuff userspace needs to do to handle notifications */
        /* The other vcores will hit here. */
index 9ea144f..ae59e35 100644 (file)
@@ -21,12 +21,6 @@ uint64_t begin = 0, end = 0;
 
 int main(int argc, char** argv)
 {
-
-       /* don't forget to enable notifs on vcore0.  if you don't, the kernel will
-        * restart your _S with notifs disabled, which is a path to confusion. */
-       struct preempt_data *vcpd = &__procdata.vcore_preempt_data[0];
-       vcpd->notif_enabled = TRUE;
-
        mcs_barrier_init(&b, max_vcores());
 
        vcore_request(max_vcores());
index dc0e3c7..16a58cd 100644 (file)
 
 int main(int argc, char** argv)
 {
-
-       /* don't forget to enable notifs on vcore0.  if you don't, the kernel will
-        * restart your _S with notifs disabled, which is a path to confusion. */
-       struct preempt_data *vcpd = &__procdata.vcore_preempt_data[0];
-       vcpd->notif_enabled = TRUE;
-
        /* Get EV_ALARM on vcore 1, with IPI. */
        enable_kevent(EV_ALARM, 1, EVENT_IPI);
 
@@ -29,7 +23,7 @@ int main(int argc, char** argv)
 void vcore_entry(void)
 {
        struct preempt_data *vcpd = &__procdata.vcore_preempt_data[0];
-       vcpd->notif_enabled = TRUE;
+       vcpd->notif_disabled = FALSE;
 
        unsigned int ev_type = get_event_type(&vcpd->ev_mbox);
        if (ev_type == EV_ALARM)
index aaab7e1..0a92563 100644 (file)
@@ -57,10 +57,6 @@ int main(int argc, char** argv)
        core0_tls = get_tls_desc(0);
        /* Need to save our floating point state somewhere (like in the
         * user_thread_tcb so it can be restarted too */
-       /* don't forget to enable notifs on vcore0 at some point */
-       struct preempt_data *vcpd;
-       vcpd = &__procdata.vcore_preempt_data[0];
-       vcpd->notif_enabled = TRUE;
 /* end: stuff userspace needs to do before switching to multi-mode */
 
        begin = read_tsc();
index bddc59b..176c8cb 100644 (file)
@@ -50,10 +50,6 @@ int main(int argc, char** argv)
        core0_tls = get_tls_desc(0);
        /* Need to save our floating point state somewhere (like in the
         * user_thread_tcb so it can be restarted too */
-       /* don't forget to enable notifs on vcore0 at some point */
-       struct preempt_data *vcpd;
-       vcpd = &__procdata.vcore_preempt_data[0];
-       vcpd->notif_enabled = TRUE;
 /* end: stuff userspace needs to do before switching to multi-mode */
 
        /* get into multi mode */
index d13344b..6a2184e 100644 (file)
@@ -124,7 +124,7 @@ void ghetto_vcore_entry(void)
         * popping the tf of whatever user process you want (get off the x-stack) */
        struct preempt_data *vcpd;
        vcpd = &__procdata.vcore_preempt_data[vcoreid];
-       vcpd->notif_enabled = TRUE;
+       vcpd->notif_disabled = FALSE;
        
 /* end: stuff userspace needs to do to handle notifications */
        /* if you have other vcores, they'll just chill here */
index 8f58cfe..4f751e7 100644 (file)
@@ -80,11 +80,6 @@ void vcore_startup()
         * to use parts of event.c to do what you want. */
        enable_kevent(EV_USER_IPI, 0, EVENT_IPI);
 
-       /* Don't forget to enable notifs on vcore0.  if you don't, the kernel will
-        * restart your _S with notifs disabled, which is a path to confusion. */
-       struct preempt_data *vcpd = &__procdata.vcore_preempt_data[0];
-       vcpd->notif_enabled = TRUE;
-
        /* Grab a reference to the main_thread on the current stack (i.e.
         * current_thread, since we know this has been set up for us properly by
         * the fact that the constructor calls main_thread_init() before this
@@ -118,7 +113,7 @@ void switch_to_vcore() {
         * so we need to enter vcore entry later.  Need to disable notifs so we
         * don't get in weird loops */
        struct preempt_data *vcpd = &__procdata.vcore_preempt_data[vcoreid];
-       vcpd->notif_enabled = FALSE;
+       vcpd->notif_disabled = TRUE;
 
        /* Grab a reference to the currently running thread on this vcore */
        thread_t *t = current_thread; 
@@ -165,7 +160,7 @@ void __attribute__((noreturn)) vcore_entry()
 
        /* Assert that notifications are disabled. Should always have notifications
         * disabled when coming in here. */
-       assert(vcpd->notif_enabled == FALSE);
+       assert(vcpd->notif_disabled == TRUE);
 
        /* Put this in the loop that deals with notifications.  It will return if
         * there is no preempt pending. */ 
index bc32fdf..f52dac6 100644 (file)
@@ -21,7 +21,7 @@ extern __thread int __vcoreid;
  * Basically, it sets up the future stack pointer to have extra stuff after it,
  * and then it pops the registers, then pops the new context's stack
  * pointer.  Then it uses the extra stuff (the new PC is on the stack, the
- * location of notif_enabled, and a clobbered work register) to enable notifs,
+ * location of notif_disabled, and a clobbered work register) to enable notifs,
  * make sure notif IPIs weren't pending, restore the work reg, and then "ret".
  *
  * This is what the target notif_tf's stack will look like (growing down):
@@ -33,7 +33,7 @@ extern __thread int __vcoreid;
  *               |   actual syscall         | 0x10 below (0x30 space)
  *               |   *sysc ptr to syscall   | 0x40 below (0x10 + 0x30)
  *               |   notif_pending_loc      | 0x44 below (0x10 + 0x30)
- *               |   notif_enabled_loc      | 0x48 below (0x10 + 0x30)
+ *               |   notif_disabled_loc     | 0x48 below (0x10 + 0x30)
  *
  * The important thing is that it can handle a notification after it enables
  * notifications, and when it gets resumed it can ultimately run the new
@@ -56,7 +56,7 @@ extern __thread int __vcoreid;
  * could get fucked if the struct syscall isn't a multiple of 4-bytes.  Also,
  * note this goes backwards, since memory reads up the stack. */
 struct restart_helper {
-       uint32_t                                        notif_enab_loc;
+       uint32_t                                        notif_disab_loc;
        uint32_t                                        notif_pend_loc;
        struct syscall                          *sysc;
        struct syscall                          local_sysc;
@@ -77,7 +77,7 @@ static inline void pop_ros_tf(struct user_trapframe *tf, uint32_t vcoreid)
        rst = (struct restart_helper*)((void*)tf->tf_esp -
                                       sizeof(struct restart_helper));
        /* Fill in the info we'll need later */
-       rst->notif_enab_loc = (uint32_t)&vcpd->notif_enabled;
+       rst->notif_disab_loc = (uint32_t)&vcpd->notif_disabled;
        rst->notif_pend_loc = (uint32_t)&vcpd->notif_pending;
        rst->sysc = &rst->local_sysc;   /* point to the local one */
        memset(rst->sysc, 0, sizeof(struct syscall));
@@ -97,8 +97,8 @@ static inline void pop_ros_tf(struct user_trapframe *tf, uint32_t vcoreid)
                                  "movl %2,%%eax;        " /* sizeof struct syscall */
                                  "addl $0x0c,%%eax;     " /* more offset btw eax/notif_en_loc*/
                      "subl %%eax,%%esp;     " /* move to notif_en_loc slot */
-                     "popl %%eax;           " /* load notif_enabaled addr */
-                     "movb $0x01,(%%eax);   " /* enable notifications */
+                     "popl %%eax;           " /* load notif_disabled addr */
+                     "movb $0x00,(%%eax);   " /* enable notifications */
                                  /* Need a wrmb() here so the write of enable_notif can't pass
                                   * the read of notif_pending (racing with a potential
                                   * cross-core call with proc_notify()). */
@@ -139,7 +139,7 @@ static inline void pop_ros_tf_raw(struct user_trapframe *tf, uint32_t vcoreid)
        rst = (struct restart_helper*)((void*)tf->tf_esp -
                                       sizeof(struct restart_helper));
        /* Fill in the info we'll need later */
-       rst->notif_enab_loc = (uint32_t)&vcpd->notif_enabled;
+       rst->notif_disab_loc = (uint32_t)&vcpd->notif_disabled;
        rst->eax_save = 0;                      /* avoid bugs */
        rst->eflags = tf->tf_eflags;
        rst->eip = tf->tf_eip;
@@ -153,8 +153,8 @@ static inline void pop_ros_tf_raw(struct user_trapframe *tf, uint32_t vcoreid)
                                  "movl %2,%%eax;        " /* sizeof struct syscall */
                                  "addl $0x0c,%%eax;     " /* more offset btw eax/notif_en_loc*/
                      "subl %%eax,%%esp;     " /* move to notif_en_loc slot */
-                     "popl %%eax;           " /* load notif_enabaled addr */
-                     "movb $0x01,(%%eax);   " /* enable notifications */
+                     "popl %%eax;           " /* load notif_disabled addr */
+                     "movb $0x00,(%%eax);   " /* enable notifications */
                                  /* Here's where we differ from the regular pop_ros_tf().  We
                                   * do the same pops/esp moves, just to keep things similar
                                   * and simple, but don't do test, clear notif_pending, or
index a88d84d..6adb14e 100644 (file)
@@ -56,7 +56,7 @@ static inline void pop_ros_tf(struct user_trapframe *tf, uint32_t vcoreid)
        else
                assert(tf->gpr[7] == (uint32_t)get_tls_desc(vcoreid));
 
-       vcpd->notif_enabled = true;
+       vcpd->notif_disabled = FALSE;
        if(vcpd->notif_pending)
                ros_syscall(SYS_self_notify, vcoreid, 0, 0, 0, 0, 0);
 
@@ -84,7 +84,7 @@ static inline void pop_ros_tf_raw(struct user_trapframe *tf, uint32_t vcoreid)
        else
                assert(tf->gpr[7] == (uint32_t)get_tls_desc(vcoreid));
 
-       vcpd->notif_enabled = true;
+       vcpd->notif_disabled = FALSE;
        /* This is just like the regular one, but we don't bother with
         * notif_pending.  This comment is where it was dealt with. */
 
index 338588e..dcc688d 100644 (file)
@@ -85,17 +85,17 @@ static inline bool in_multi_mode(void)
 /* Only call this if you know what you are doing. */
 static inline void __enable_notifs(uint32_t vcoreid)
 {
-       __procdata.vcore_preempt_data[vcoreid].notif_enabled = TRUE;
+       __procdata.vcore_preempt_data[vcoreid].notif_disabled = FALSE;
 }
 
 static inline void __disable_notifs(uint32_t vcoreid)
 {
-       __procdata.vcore_preempt_data[vcoreid].notif_enabled = FALSE;
+       __procdata.vcore_preempt_data[vcoreid].notif_disabled = TRUE;
 }
 
 static inline bool notif_is_enabled(uint32_t vcoreid)
 {
-       return __procdata.vcore_preempt_data[vcoreid].notif_enabled;
+       return !__procdata.vcore_preempt_data[vcoreid].notif_disabled;
 }
 
 static inline bool vcore_is_mapped(uint32_t vcoreid)
index fca8abd..40a97c5 100644 (file)
@@ -50,9 +50,6 @@ int uthread_lib_init(struct uthread *uthread)
        current_uthread = uthread;
        set_tls_desc(uthread->tls_desc, 0);
        assert(!in_vcore_context());
-       /* don't forget to enable notifs on vcore0.  if you don't, the kernel will
-        * restart your _S with notifs disabled, which is a path to confusion. */
-       __enable_notifs(0);
        /* Receive preemption events */
        ev_handlers[EV_VCORE_PREEMPT] = handle_vc_preempt;
        preempt_ev_q = get_big_event_q();
index 3b1fbb1..405f6e1 100644 (file)
@@ -149,8 +149,9 @@ int vcore_init()
        atomic_init(&vc_req_being_handled, 0);
        assert(!in_vcore_context());
        initialized = 1;
-       /* Ugly hack, but we need to be able to transition to _M mode later. */
-       __enable_notifs(vcore_id());
+       /* no longer need to enable notifs on vcore 0, it is set like that by
+        * default (so you drop into vcore context immediately on transtioning to
+        * _M) */
        return 0;
 vcore_init_tls_fail:
        free(vcore_thread_control_blocks);