[Xen-devel] [PATCH] Add SCHEDOP_block_on

[John Levon <levon@xxxxxxxxxxxxxxxxx>]

This patch adds a facility to block on a particular event channel, for
when a domain needs to block, but cannot enable interrupts. A domain
uses the call something like this:

        while (1) {
                clear_evtchn_pending(evtchn);
                if (check_for_data(evtchn))
                        break;
                HYPERVISOR_block_on(evtchn);
        }

The clear of the pending is needed to ensure that any subsequent calls
to block_on() don't return immediately.

regards,
john


# HG changeset patch
# User john.levon@xxxxxxx
# Node ID 15aea7d020cd13b1f13692518f10051e401962df
# Parent  fbeb0a5b7219630839986cf4cdb1b813618cbdce
Add SCHEDOP_block_on.

Signed-off-by: John Levon <john.levon@xxxxxxx>

diff -r fbeb0a5b7219 -r 15aea7d020cd docs/src/interface.tex
--- a/docs/src/interface.tex    Thu Mar  9 16:24:57 2006 +0000
+++ b/docs/src/interface.tex    Thu Mar  9 21:55:15 2006 -0800
@@ -1721,13 +1721,17 @@
 \hypercall{sched\_op(unsigned long op)} 
 
 Request scheduling operation from hypervisor. The options are: {\it
-SCHEDOP\_yield}, {\it SCHEDOP\_block}, and {\it SCHEDOP\_shutdown}.
-{\it yield} keeps the calling domain runnable but may cause a
-reschedule if other domains are runnable.  {\it block} removes the
-calling domain from the run queue and cause is to sleeps until an
-event is delivered to it.  {\it shutdown} is used to end the domain's
-execution; the caller can additionally specify whether the domain
-should reboot, halt or suspend.
+SCHEDOP\_yield}, {\it SCHEDOP\_block}, {\it SCHEDOP\_block\_on} and
+{\it SCHEDOP\_shutdown}.  {\it yield} keeps the calling vcpu runnable
+but may cause a reschedule if other vcpus are runnable. {\it block}
+enables event delivery, removes the calling vcpu from the run queue,
+and causes it to sleep until an event is delivered to it.
+{\it block\_on} causes the calling vcpu to sleep until any event is
+delivered. It takes an event channel argument, which is checked to 
+see if it's pending; if it is, then the vcpu does not sleep.
+{\it shutdown} is used to end the domain's execution; the caller
+can additionally specify whether the domain should reboot, halt or
+suspend.
 \end{quote} 
 
 To aid the implementation of a process scheduler within a guest OS,
diff -r fbeb0a5b7219 -r 15aea7d020cd xen/common/schedule.c
--- a/xen/common/schedule.c     Thu Mar  9 16:24:57 2006 +0000
+++ b/xen/common/schedule.c     Thu Mar  9 21:55:15 2006 -0800
@@ -249,7 +249,7 @@
 }
 
 /* Block the currently-executing domain until a pertinent event occurs. */
-static long do_block(void)
+static void do_block(void)
 {
     struct vcpu *v = current;
 
@@ -258,6 +258,32 @@
 
     /* Check for events /after/ blocking: avoids wakeup waiting race. */
     if ( event_pending(v) )
+    {
+        clear_bit(_VCPUF_blocked, &v->vcpu_flags);
+    }
+    else
+    {
+        TRACE_2D(TRC_SCHED_BLOCK, v->domain->domain_id, v->vcpu_id);
+        __enter_scheduler();
+    }
+}
+
+/*
+ * Block the currently-executing domain without enabling interrupts, for a
+ * particular evtchn. Whilst we check for a particular evtchn, /any/ event
+ * will wake us up again.
+ */
+static long do_block_on(unsigned long evtchn)
+{
+    struct vcpu *v = current;
+
+    if ( evtchn >= MAX_EVTCHNS )
+        return -EINVAL;
+   
+    set_bit(_VCPUF_blocked, &v->vcpu_flags);
+
+    /* Check for event /after/ blocking: avoids wakeup waiting race. */
+    if ( evtchn_pending(v->domain->shared_info, evtchn) )
     {
         clear_bit(_VCPUF_blocked, &v->vcpu_flags);
     }
@@ -292,7 +318,13 @@
 
     case SCHEDOP_block:
     {
-        ret = do_block();
+        do_block();
+        break;
+    }
+
+    case SCHEDOP_block_on:
+    {
+        ret = do_block_on(arg);
         break;
     }
 
diff -r fbeb0a5b7219 -r 15aea7d020cd xen/include/public/sched.h
--- a/xen/include/public/sched.h        Thu Mar  9 16:24:57 2006 +0000
+++ b/xen/include/public/sched.h        Thu Mar  9 21:55:15 2006 -0800
@@ -38,6 +38,16 @@
 #define SCHEDOP_shutdown    2
 
 /*
+ * Block execution of this VCPU until an event is received for processing,
+ * without clearing the upcall mask; a subsequent pending event will not be
+ * delivered, but will still wake up the domain. This is intended for use in
+ * polling loops when "interrupts" are disabled. It takes one argument; that of
+ * a channel to check for pending events before sleeping.
+ * @arg == evtchn.
+ */
+#define SCHEDOP_block_on    3
+
+/*
  * Reason codes for SCHEDOP_shutdown. These may be interpreted by controller
  * software to determine the appropriate action. For the most part, Xen does
  * not care about the shutdown code.
diff -r fbeb0a5b7219 -r 15aea7d020cd xen/include/xen/event.h
--- a/xen/include/xen/event.h   Thu Mar  9 16:24:57 2006 +0000
+++ b/xen/include/xen/event.h   Thu Mar  9 21:55:15 2006 -0800
@@ -14,6 +14,16 @@
 #include <xen/smp.h>
 #include <asm/bitops.h>
 #include <asm/event.h>
+
+/*
+ * If the vcpu has events masked, we should unblock it even if the event
+ * channel is already pending.
+ */
+static inline void evtchn_check_unblock(struct vcpu *v)
+{
+    if ( v->vcpu_info->evtchn_upcall_mask && (v->vcpu_flags & VCPUF_blocked) )
+        vcpu_unblock(v);
+}
 
 /*
  * EVENT-CHANNEL NOTIFICATIONS
@@ -35,6 +45,10 @@
          !test_and_set_bit(0, &v->vcpu_info->evtchn_upcall_pending) )
     {
         evtchn_notify(v);
+    }
+    else
+    {
+        evtchn_check_unblock(v);
     }
 }
 
@@ -69,4 +83,7 @@
 /* Bind a local event-channel port to the specified VCPU. */
 extern long evtchn_bind_vcpu(unsigned int port, unsigned int vcpu_id);
 
+#define evtchn_pending(s, e)                \
+   (test_bit((e), &(s)->evtchn_pending[0]))
+
 #endif /* __XEN_EVENT_H__ */

_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel