BNX2X: spatch signed typedefs
[akaros.git] / kern / src / event.c
index c89bc2d..04f16ba 100644 (file)
@@ -52,7 +52,7 @@ static struct event_mbox *get_vcpd_mbox(uint32_t vcoreid, int ev_flags)
 static bool can_msg_vcore(uint32_t vcoreid)
 {
        struct preempt_data *vcpd = &__procdata.vcore_preempt_data[vcoreid];
-       return vcpd->can_rcv_msg;
+       return atomic_read(&vcpd->flags) & VC_CAN_RCV_MSG;
 }
 
 /* Says a vcore can be messaged.  Only call this once you are sure this is true
@@ -60,7 +60,7 @@ static bool can_msg_vcore(uint32_t vcoreid)
 static void set_vcore_msgable(uint32_t vcoreid)
 {
        struct preempt_data *vcpd = &__procdata.vcore_preempt_data[vcoreid];
-       vcpd->can_rcv_msg = TRUE;
+       atomic_or(&vcpd->flags, VC_CAN_RCV_MSG);
 }
 
 /* Posts a message to the mbox, subject to flags.  Feel free to send 0 for the
@@ -71,7 +71,7 @@ static void set_vcore_msgable(uint32_t vcoreid)
 static void post_ev_msg(struct proc *p, struct event_mbox *mbox,
                         struct event_msg *msg, int ev_flags)
 {
-       printd("[kernel] Sending event type %d to mbox %08p\n", msg->ev_type, mbox);
+       printd("[kernel] Sending event type %d to mbox %p\n", msg->ev_type, mbox);
        /* Sanity check */
        assert(p);
        /* If they just want a bit (NOMSG), just set the bit */
@@ -118,7 +118,7 @@ static void spam_vcore(struct proc *p, uint32_t vcoreid,
        try_notify(p, vcoreid, ev_flags);
 }
 
-/* Attempts to message a vcore that may or may not have 'can_rcv_msg' set.  If
+/* Attempts to message a vcore that may or may not have VC_CAN_RCV_MSG set.  If
  * so, we'll post the message and the message will eventually get dealt with
  * (when the vcore runs or when it is preempte-recovered). */
 static bool try_spam_vcore(struct proc *p, uint32_t vcoreid,
@@ -156,21 +156,17 @@ static bool spam_list_member(struct vcore_tailq *list, struct proc *p,
                 * something more customized for the lists. */
                spam_vcore(p, vcoreid, ev_msg, ev_flags);
                wrmb(); /* prev write (notif_pending) must come before following reads*/
-               /* if they are still alertable after we sent the msg, then they'll get
-                * it before yielding (racing with userspace yield here).  This check is
-                * not as critical as the next one, but will allow us to alert vcores
-                * that happen to concurrently be moved from the active to the
-                * bulk_preempt list. */
-               if (can_msg_vcore(vcoreid))
-                       return TRUE;
-               /* As a backup, if they are still the first on the list, then they are
+               /* I used to check can_msg_vcore(vcoreid) here, but that would make
+                * spamming list members unusable for MUST_RUN scenarios.
+                *
+                * Regardless, if they are still the first on the list, then they are
                 * still going to get the message.  For the online list, proc_yield()
                 * will return them to userspace (where they will get the message)
                 * because __alert_vcore() set notif_pending.  For the BP list, they
                 * will either be turned on later, or have a preempt message sent about
                 * their demise.
                 *
-                * We race on list membership (and not exclusively 'can_rcv_msg', so
+                * We race on list membership (and not exclusively VC_CAN_RCV_MSG, so
                 * that when it fails we can get a new vcore to try (or know WHP there
                 * are none). */
                vc_first = TAILQ_FIRST(list);
@@ -197,7 +193,7 @@ static bool spam_list_member(struct vcore_tailq *list, struct proc *p,
  * this must be able to handle spurious reads, since more than one vcore is
  * likely to get the message and handle it.
  *
- * We try the desired vcore, using 'can_rcv_msg'.  Failing that, we'll search
+ * We try the desired vcore, using VC_CAN_RCV_MSG.  Failing that, we'll search
  * the online and then the bulk_preempted lists.  These lists serve as a way to
  * find likely messageable vcores.  spam_list_member() helps us with them,
  * failing if anything seems to go wrong.  At which point we just lock and try
@@ -213,10 +209,21 @@ static void spam_public_msg(struct proc *p, struct event_msg *ev_msg,
                                                        uint32_t vcoreid, int ev_flags)
 {
        struct vcore *vc;
-       /* First, try posting to the desired vcore (so long as we don't have to send
-        * it to a vcore that will run, like we do for preempt messages). */
-       if (!(ev_flags & EVENT_VCORE_MUST_RUN) &&
-          (try_spam_vcore(p, vcoreid, ev_msg, ev_flags)))
+       if (ev_flags & EVENT_VCORE_MUST_RUN) {
+               /* Could check for waiting and skip these spams, which will fail.  Could
+                * also skip trying for vcoreid, and just spam any old online VC. */
+               if (vcore_is_mapped(p, vcoreid)) {      /* check, signal, check again */
+                       spam_vcore(p, vcoreid, ev_msg, ev_flags);
+                       wrmb(); /* notif_pending write must come before following read */
+                       if (vcore_is_mapped(p, vcoreid))
+                               return;
+               }
+               if (spam_list_member(&p->online_vcs, p, ev_msg, ev_flags))
+                       return;
+               goto ultimate_fallback;
+       }
+       /* First, try posting to the desired vcore */
+       if (try_spam_vcore(p, vcoreid, ev_msg, ev_flags))
                return;
        /* If the process is WAITING, let's just jump to the fallback */
        if (p->state == PROC_WAITING)
@@ -251,7 +258,7 @@ ultimate_fallback:
         * empty and the process is simply WAITING (yielded all of its vcores and is
         * waiting on an event).  Time for the ultimate fallback: locking.  Note
         * that when we __alert_vcore(), there is a chance we need to mmap, which
-        * grabs the mm_lock. */
+        * grabs the vmr_lock and pte_lock. */
        spin_lock(&p->proc_lock);
        if (p->state != PROC_WAITING) {
                /* We need to check the online and bulk_preempt lists again, now that we are
@@ -342,8 +349,11 @@ void send_event(struct proc *p, struct event_queue *ev_q, struct event_msg *msg,
 {
        struct proc *old_proc;
        struct event_mbox *ev_mbox = 0;
+       assert(!in_irq_ctx(&per_cpu_info[core_id()]));
        assert(p);
-       printd("[kernel] sending msg to proc %08p, ev_q %08p\n", p, ev_q);
+       if (p->state == PROC_DYING)
+               return;
+       printd("[kernel] sending msg to proc %p, ev_q %p\n", p, ev_q);
        if (!ev_q) {
                warn("[kernel] Null ev_q - kernel code should check before sending!");
                return;
@@ -353,6 +363,13 @@ void send_event(struct proc *p, struct event_queue *ev_q, struct event_msg *msg,
                printk("[kernel] Illegal addr for ev_q\n");
                return;
        }
+       /* This should be caught by "future technology" that can tell when the
+        * kernel PFs on the user's behalf.  For now, we catch common userspace bugs
+        * (had this happen a few times). */
+       if (!PTE_ADDR(ev_q)) {
+               printk("[kernel] Bad addr %p for ev_q\n", ev_q);
+               return;
+       }
        /* ev_q is a user pointer, so we need to make sure we're in the right
         * address space */
        old_proc = switch_to(p);
@@ -466,3 +483,13 @@ void post_vcore_event(struct proc *p, struct event_msg *msg, uint32_t vcoreid,
        post_vc_msg(p, vcoreid, get_vcpd_mbox(vcoreid, ev_flags), msg, ev_flags);
        switch_back(p, old_proc);
 }
+
+/* Attempts to send a posix signal to the process.  If they do not have an ev_q
+ * registered for EV_POSIX_SIGNAL, then nothing will happen. */
+void send_posix_signal(struct proc *p, int sig_nr)
+{
+       struct event_msg local_msg = {0};
+       local_msg.ev_type = EV_POSIX_SIGNAL;
+       local_msg.ev_arg1 = sig_nr;
+       send_kernel_event(p, &local_msg, 0);
+}