Remove EVENT_NOMSG (XCC)
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 12 Aug 2015 22:12:35 +0000 (18:12 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 28 Sep 2015 19:14:00 +0000 (15:14 -0400)
EVENT_NOMSG used to give you a bit in the bitmap instead of a UCQ
message.  Now that there are the evbitmaps, we don't want EVENT_NOMSG.
mhello and the other test aren't a big deal.  The simple_evq used by
glibc and by SCPs in VC ctx was a bigger deal, and needed to be
converted to the evbitmap mbox.

When removing the #define for NOMSG, I opted to change all the flags to
not leave a hole.  You need to rebuild the world anyway, so this doesn't
hurt.

Rebuild the world.

kern/include/ros/event.h
kern/src/event.c
tests/mhello.c
tests/old/msr_nice_while.c
tools/compilers/gcc-glibc/glibc-2.19-akaros/sysdeps/akaros/syscall.c

index d5c9afb..f6e3b68 100644 (file)
 
 /* Event Delivery Flags from the process to the kernel */
 #define EVENT_IPI                              0x00001 /* IPI the vcore (usually with INDIR) */
-#define EVENT_NOMSG                            0x00002 /* just send the bit, not the msg */
-#define EVENT_SPAM_PUBLIC              0x00004 /* spam the msg to public vcpd mboxes */
-#define EVENT_INDIR                            0x00008 /* send an indirection event to vcore */
-#define EVENT_VCORE_PRIVATE            0x00010 /* Will go to the private VCPD mbox */
-#define EVENT_SPAM_INDIR               0x00020 /* spam INDIRs if the vcore's offline */
-#define EVENT_VCORE_MUST_RUN   0x00040 /* spams go to a vcore that will run */
-#define EVENT_NOTHROTTLE               0x00080 /* send all INDIRs (no throttling) */
-#define EVENT_ROUNDROBIN               0x00100 /* pick a vcore, RR style */
-#define EVENT_VCORE_APPRO              0x00200 /* send to where the kernel wants */
-#define EVENT_WAKEUP                   0x00400 /* wake up the process after sending */
+#define EVENT_SPAM_PUBLIC              0x00002 /* spam the msg to public vcpd mboxes */
+#define EVENT_INDIR                            0x00004 /* send an indirection event to vcore */
+#define EVENT_VCORE_PRIVATE            0x00008 /* Will go to the private VCPD mbox */
+#define EVENT_SPAM_INDIR               0x00010 /* spam INDIRs if the vcore's offline */
+#define EVENT_VCORE_MUST_RUN   0x00020 /* spams go to a vcore that will run */
+#define EVENT_NOTHROTTLE               0x00040 /* send all INDIRs (no throttling) */
+#define EVENT_ROUNDROBIN               0x00080 /* pick a vcore, RR style */
+#define EVENT_VCORE_APPRO              0x00100 /* send to where the kernel wants */
+#define EVENT_WAKEUP                   0x00200 /* wake up the process after sending */
 
 /* Event Message Types */
 #define EV_NONE                                         0
index 6f69e98..f304ac5 100644 (file)
@@ -70,9 +70,7 @@ static void send_evbitmap_msg(struct evbitmap *evbm, struct event_msg *msg)
        evbm->check_bits = TRUE;
 }
 
-/* Posts a message to the mbox, subject to flags.  Feel free to send 0 for the
- * flags if you don't want to give them the option of EVENT_NOMSG (which is what
- * we do when sending an indirection event).  Make sure that if mbox is a user
+/* Posts a message to the mbox.  Make sure that if mbox is a user
  * pointer, that you've checked it *and* have that processes address space
  * loaded.  This can get called with a KVA for mbox. */
 static void post_ev_msg(struct proc *p, struct event_mbox *mbox,
@@ -347,9 +345,8 @@ static void send_indir(struct proc *p, struct event_queue *ev_q,
                return;
        }
        /* At this point, we actually want to send and spam an INDIR.
-        * This will guarantee the message makes it to some vcore.  For flags, we
-        * can't send NOMSG - that applied to the original ev_msg. */
-       spam_public_msg(p, &local_msg, vcoreid, ev_q->ev_flags & ~EVENT_NOMSG);
+        * This will guarantee the message makes it to some vcore. */
+       spam_public_msg(p, &local_msg, vcoreid, ev_q->ev_flags);
 }
 
 /* Send an event to ev_q, based on the parameters in ev_q's flag.  We don't
@@ -435,10 +432,6 @@ void send_event(struct proc *p, struct event_queue *ev_q, struct event_msg *msg,
                printk("[kernel] Illegal addr for ev_mbox\n");
                goto out;
        }
-       /* We used to support no msgs, but quit being lazy and send a 'msg'.  If the
-        * ev_q is a NOMSG, we won't actually memcpy or anything, it'll just be a
-        * vehicle for sending the ev_type. */
-       assert(msg);
        post_ev_msg(p, ev_mbox, msg, ev_q->ev_flags);
        wmb();  /* ensure ev_msg write is before alerting the vcore */
        /* Prod/alert a vcore with an IPI or INDIR, if desired.  INDIR will also
index 5a7352e..ee1566c 100644 (file)
@@ -68,9 +68,9 @@ int main(int argc, char** argv)
         * Note you don't have to register for USER_IPIs to receive ones you send
         * yourself with sys_self_notify(). */
        enable_kevent(EV_USER_IPI, 0, EVENT_IPI | EVENT_VCORE_PRIVATE);
-       /* Receive pending preemption events.  Can also get a MSG if you want. */
-       struct event_queue *ev_q = get_event_q();
-       ev_q->ev_flags = EVENT_IPI | EVENT_NOMSG | EVENT_VCORE_APPRO;
+       /* Receive pending preemption events.  (though there's no PP handler) */
+       struct event_queue *ev_q = get_event_q_vcpd(0, EVENT_VCORE_PRIVATE);
+       ev_q->ev_flags = EVENT_IPI | EVENT_VCORE_APPRO;
        register_kevent_q(ev_q, EV_PREEMPT_PENDING);
        /* We also receive preemption events, it is set up in uthread.c */
 
index fe54263..dbefb70 100644 (file)
@@ -23,8 +23,8 @@ int main(int argc, char** argv)
        /* set up to receive the PREEMPT_PENDING event.  EVENT_VCORE_APPRO tells the
         * kernel to send the msg to whichever vcore is appropriate.  Pthread code
         * will see the preemption and yield. */
-       struct event_queue *ev_q = get_event_q();
-       ev_q->ev_flags = EVENT_IPI | EVENT_NOMSG | EVENT_VCORE_APPRO;
+       struct event_queue *ev_q = get_event_q_vcpd(0, EVENT_VCORE_PRIVATE);
+       ev_q->ev_flags = EVENT_IPI | EVENT_VCORE_APPRO;
        register_kevent_q(ev_q, EV_PREEMPT_PENDING);
 
        /* actually only need one less, since the _S will be pthread 0 */
index a60f2c2..2f61fc5 100644 (file)
  * should work for any bit messages, even if the process hasn't done any set up
  * yet, since the memory for the mbox is allocted by the kernel (procdata).
  * Don't send full messages to it, since the UCQ won't be initialized. */
+struct event_mbox __simple_evbitmap = { .type = EV_MBOX_BITMAP, };
 struct event_queue __ros_scp_simple_evq =
-                  { .ev_mbox = &__procdata.vcore_preempt_data[0].ev_mbox_public,
-                    .ev_flags = EVENT_NOMSG | EVENT_WAKEUP,
+                  { .ev_mbox = &__simple_evbitmap,
+                    .ev_flags = EVENT_WAKEUP,
                     .ev_alert_pending = FALSE,
                     .ev_vcore = 0,
                     .ev_handler = 0 };