diff mbox

[v4,01/15] coroutine: add co_sleep_ns() coroutine sleep function

Message ID 1325858501-25741-2-git-send-email-stefanha@linux.vnet.ibm.com
State New
Headers show

Commit Message

Stefan Hajnoczi Jan. 6, 2012, 2:01 p.m. UTC 
Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
---
 Makefile.objs          |    1 +
 qemu-coroutine-sleep.c |   38 ++++++++++++++++++++++++++++++++++++++
 qemu-coroutine.h       |    6 ++++++
 3 files changed, 45 insertions(+), 0 deletions(-)
 create mode 100644 qemu-coroutine-sleep.c

Comments

Kevin Wolf Jan. 12, 2012, 10:13 a.m. UTC | #1 
Am 06.01.2012 15:01, schrieb Stefan Hajnoczi:
> Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
> ---
>  Makefile.objs          |    1 +
>  qemu-coroutine-sleep.c |   38 ++++++++++++++++++++++++++++++++++++++
>  qemu-coroutine.h       |    6 ++++++
>  3 files changed, 45 insertions(+), 0 deletions(-)
>  create mode 100644 qemu-coroutine-sleep.c

> diff --git a/qemu-coroutine.h b/qemu-coroutine.h
> index 8a55fe1..bae1ffe 100644
> --- a/qemu-coroutine.h
> +++ b/qemu-coroutine.h
> @@ -17,6 +17,7 @@
>  
>  #include <stdbool.h>
>  #include "qemu-queue.h"
> +#include "qemu-timer.h"
>  
>  /**
>   * Coroutines are a mechanism for stack switching and can be used for
> @@ -199,4 +200,9 @@ void qemu_co_rwlock_wrlock(CoRwlock *lock);
>   */
>  void qemu_co_rwlock_unlock(CoRwlock *lock);
>  
> +/**
> + * Yield the coroutine for a given duration
> + */
> +void coroutine_fn co_sleep_ns(QEMUClock *clock, int64_t ns);
> +
>  #endif /* QEMU_COROUTINE_H */

As you mentioned on IRC yesterday, timers don't work in the tools. There
should probably be a warning in the comment (or a fix before this is merged)

Kevin
Stefan Hajnoczi Jan. 12, 2012, 10:58 a.m. UTC | #2 
On Thu, Jan 12, 2012 at 10:13 AM, Kevin Wolf <kwolf@redhat.com> wrote:
> Am 06.01.2012 15:01, schrieb Stefan Hajnoczi:
>> Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
>> ---
>>  Makefile.objs          |    1 +
>>  qemu-coroutine-sleep.c |   38 ++++++++++++++++++++++++++++++++++++++
>>  qemu-coroutine.h       |    6 ++++++
>>  3 files changed, 45 insertions(+), 0 deletions(-)
>>  create mode 100644 qemu-coroutine-sleep.c
>
>> diff --git a/qemu-coroutine.h b/qemu-coroutine.h
>> index 8a55fe1..bae1ffe 100644
>> --- a/qemu-coroutine.h
>> +++ b/qemu-coroutine.h
>> @@ -17,6 +17,7 @@
>>
>>  #include <stdbool.h>
>>  #include "qemu-queue.h"
>> +#include "qemu-timer.h"
>>
>>  /**
>>   * Coroutines are a mechanism for stack switching and can be used for
>> @@ -199,4 +200,9 @@ void qemu_co_rwlock_wrlock(CoRwlock *lock);
>>   */
>>  void qemu_co_rwlock_unlock(CoRwlock *lock);
>>
>> +/**
>> + * Yield the coroutine for a given duration
>> + */
>> +void coroutine_fn co_sleep_ns(QEMUClock *clock, int64_t ns);
>> +
>>  #endif /* QEMU_COROUTINE_H */
>
> As you mentioned on IRC yesterday, timers don't work in the tools. There
> should probably be a warning in the comment (or a fix before this is merged)

This is something I'm looking at right now and will probably want to
discuss with Paolo.

In a coroutine we're probably using a main loop and timers should be
available there.  In general, the problem we're starting to see is
that some block layer features are using timers (I/O throttling, QED
deferred dirty bit clearing, image streaming).  The question is do we
isolate this functionality so it is unavailable from a qemu-tool world
when there's no main loop, or do we move everything into a main loop?

Stefan
Stefan Hajnoczi Jan. 12, 2012, 1:11 p.m. UTC | #3 
On Thu, Jan 12, 2012 at 10:13 AM, Kevin Wolf <kwolf@redhat.com> wrote:
> Am 06.01.2012 15:01, schrieb Stefan Hajnoczi:
>> Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
>> ---
>>  Makefile.objs          |    1 +
>>  qemu-coroutine-sleep.c |   38 ++++++++++++++++++++++++++++++++++++++
>>  qemu-coroutine.h       |    6 ++++++
>>  3 files changed, 45 insertions(+), 0 deletions(-)
>>  create mode 100644 qemu-coroutine-sleep.c
>
>> diff --git a/qemu-coroutine.h b/qemu-coroutine.h
>> index 8a55fe1..bae1ffe 100644
>> --- a/qemu-coroutine.h
>> +++ b/qemu-coroutine.h
>> @@ -17,6 +17,7 @@
>>
>>  #include <stdbool.h>
>>  #include "qemu-queue.h"
>> +#include "qemu-timer.h"
>>
>>  /**
>>   * Coroutines are a mechanism for stack switching and can be used for
>> @@ -199,4 +200,9 @@ void qemu_co_rwlock_wrlock(CoRwlock *lock);
>>   */
>>  void qemu_co_rwlock_unlock(CoRwlock *lock);
>>
>> +/**
>> + * Yield the coroutine for a given duration
>> + */
>> +void coroutine_fn co_sleep_ns(QEMUClock *clock, int64_t ns);
>> +
>>  #endif /* QEMU_COROUTINE_H */
>
> As you mentioned on IRC yesterday, timers don't work in the tools. There
> should probably be a warning in the comment (or a fix before this is merged)

I will add a comment to prevent new callers using this
inappropriately.  qemu-img/qemu-io do not use image streaming so we
never hit an abort(3).

But I still have an interest in solving the larger problem because QED
broken in qemu-tools!  So I'll look into using the main loop in
qemu-io/qemu-img based on Paolo's patches independently of this image
streaming series.

Stefan
diff mbox

Patch

diff --git a/Makefile.objs b/Makefile.objs
index 47fdc82..64d84de 100644
--- a/Makefile.objs
+++ b/Makefile.objs
@@ -13,6 +13,7 @@  oslib-obj-$(CONFIG_POSIX) += oslib-posix.o qemu-thread-posix.o
 #######################################################################
 # coroutines
 coroutine-obj-y = qemu-coroutine.o qemu-coroutine-lock.o qemu-coroutine-io.o
+coroutine-obj-y += qemu-coroutine-sleep.o
 ifeq ($(CONFIG_UCONTEXT_COROUTINE),y)
 coroutine-obj-$(CONFIG_POSIX) += coroutine-ucontext.o
 else
diff --git a/qemu-coroutine-sleep.c b/qemu-coroutine-sleep.c
new file mode 100644
index 0000000..fd65274
--- /dev/null
+++ b/qemu-coroutine-sleep.c
@@ -0,0 +1,38 @@ 
+/*
+ * QEMU coroutine sleep
+ *
+ * Copyright IBM, Corp. 2011
+ *
+ * Authors:
+ *  Stefan Hajnoczi    <stefanha@linux.vnet.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU LGPL, version 2 or later.
+ * See the COPYING.LIB file in the top-level directory.
+ *
+ */
+
+#include "qemu-coroutine.h"
+#include "qemu-timer.h"
+
+typedef struct CoSleepCB {
+    QEMUTimer *ts;
+    Coroutine *co;
+} CoSleepCB;
+
+static void co_sleep_cb(void *opaque)
+{
+    CoSleepCB *sleep_cb = opaque;
+
+    qemu_free_timer(sleep_cb->ts);
+    qemu_coroutine_enter(sleep_cb->co, NULL);
+}
+
+void coroutine_fn co_sleep_ns(QEMUClock *clock, int64_t ns)
+{
+    CoSleepCB sleep_cb = {
+        .co = qemu_coroutine_self(),
+    };
+    sleep_cb.ts = qemu_new_timer(clock, SCALE_NS, co_sleep_cb, &sleep_cb);
+    qemu_mod_timer(sleep_cb.ts, qemu_get_clock_ns(clock) + ns);
+    qemu_coroutine_yield();
+}
diff --git a/qemu-coroutine.h b/qemu-coroutine.h
index 8a55fe1..bae1ffe 100644
--- a/qemu-coroutine.h
+++ b/qemu-coroutine.h
@@ -17,6 +17,7 @@ 
 
 #include <stdbool.h>
 #include "qemu-queue.h"
+#include "qemu-timer.h"
 
 /**
  * Coroutines are a mechanism for stack switching and can be used for
@@ -199,4 +200,9 @@  void qemu_co_rwlock_wrlock(CoRwlock *lock);
  */
 void qemu_co_rwlock_unlock(CoRwlock *lock);
 
+/**
+ * Yield the coroutine for a given duration
+ */
+void coroutine_fn co_sleep_ns(QEMUClock *clock, int64_t ns);
+
 #endif /* QEMU_COROUTINE_H */