diff mbox

block/null: Latency simulation by adding new option "latency_ns"

Message ID 1425459851-16819-1-git-send-email-famz@redhat.com
State New
Headers show

Commit Message

Fam Zheng March 4, 2015, 9:04 a.m. UTC 
Aio context switch should just work because the requests will be
drained, so the scheduled timer(s) on the old context will be freed.

Signed-off-by: Fam Zheng <famz@redhat.com>
---
 block/null.c | 34 ++++++++++++++++++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

Comments

Kevin Wolf March 4, 2015, 1:01 p.m. UTC | #1 
Am 04.03.2015 um 10:04 hat Fam Zheng geschrieben:
> Aio context switch should just work because the requests will be
> drained, so the scheduled timer(s) on the old context will be freed.
> 
> Signed-off-by: Fam Zheng <famz@redhat.com>

You should probably also add co_aio_sleep_ns() calls to
null_co_readv/write/flush().

>  block/null.c | 34 ++++++++++++++++++++++++++++++++--
>  1 file changed, 32 insertions(+), 2 deletions(-)
> 
> diff --git a/block/null.c b/block/null.c
> index ec2bd27..af49525 100644
> --- a/block/null.c
> +++ b/block/null.c
> @@ -12,8 +12,11 @@
>  
>  #include "block/block_int.h"
>  
> +#define NULL_OPT_LATENCY "latency_ns"
> +
>  typedef struct {
>      int64_t length;
> +    int64_t latency_ns;
>  } BDRVNullState;
>  
>  static QemuOptsList runtime_opts = {
> @@ -30,6 +33,12 @@ static QemuOptsList runtime_opts = {
>              .type = QEMU_OPT_SIZE,
>              .help = "size of the null block",
>          },
> +        {
> +            .name = NULL_OPT_LATENCY,
> +            .type = QEMU_OPT_NUMBER,
> +            .help = "nanoseconds (approximated) to wait "
> +                    "before completing request",
> +        },
>          { /* end of list */ }
>      },
>  };
> @@ -44,6 +53,8 @@ static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
>      qemu_opts_absorb_qdict(opts, options, &error_abort);
>      s->length =
>          qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30);
> +    s->latency_ns =
> +        qemu_opt_get_number(opts, NULL_OPT_LATENCY, 0);

s->latency_ns is signed, so I'd check for negative values.

The rest looks good to me.

Kevin
diff mbox

Patch

diff --git a/block/null.c b/block/null.c
index ec2bd27..af49525 100644
--- a/block/null.c
+++ b/block/null.c
@@ -12,8 +12,11 @@ 
 
 #include "block/block_int.h"
 
+#define NULL_OPT_LATENCY "latency_ns"
+
 typedef struct {
     int64_t length;
+    int64_t latency_ns;
 } BDRVNullState;
 
 static QemuOptsList runtime_opts = {
@@ -30,6 +33,12 @@  static QemuOptsList runtime_opts = {
             .type = QEMU_OPT_SIZE,
             .help = "size of the null block",
         },
+        {
+            .name = NULL_OPT_LATENCY,
+            .type = QEMU_OPT_NUMBER,
+            .help = "nanoseconds (approximated) to wait "
+                    "before completing request",
+        },
         { /* end of list */ }
     },
 };
@@ -44,6 +53,8 @@  static int null_file_open(BlockDriverState *bs, QDict *options, int flags,
     qemu_opts_absorb_qdict(opts, options, &error_abort);
     s->length =
         qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 1 << 30);
+    s->latency_ns =
+        qemu_opt_get_number(opts, NULL_OPT_LATENCY, 0);
     qemu_opts_del(opts);
     return 0;
 }
@@ -80,6 +91,7 @@  static coroutine_fn int null_co_flush(BlockDriverState *bs)
 typedef struct {
     BlockAIOCB common;
     QEMUBH *bh;
+    QEMUTimer timer;
 } NullAIOCB;
 
 static const AIOCBInfo null_aiocb_info = {
@@ -94,15 +106,33 @@  static void null_bh_cb(void *opaque)
     qemu_aio_unref(acb);
 }
 
+static void null_timer_cb(void *opaque)
+{
+    NullAIOCB *acb = opaque;
+    acb->common.cb(acb->common.opaque, 0);
+    timer_deinit(&acb->timer);
+    qemu_aio_unref(acb);
+}
+
 static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,
                                           BlockCompletionFunc *cb,
                                           void *opaque)
 {
     NullAIOCB *acb;
+    BDRVNullState *s = bs->opaque;
 
     acb = qemu_aio_get(&null_aiocb_info, bs, cb, opaque);
-    acb->bh = aio_bh_new(bdrv_get_aio_context(bs), null_bh_cb, acb);
-    qemu_bh_schedule(acb->bh);
+    /* Only emulate latency after vcpu is running. */
+    if (s->latency_ns && qemu_clock_get_us(QEMU_CLOCK_VIRTUAL) > 0) {
+        aio_timer_init(bdrv_get_aio_context(bs), &acb->timer,
+                       QEMU_CLOCK_VIRTUAL, SCALE_NS,
+                       null_timer_cb, acb);
+        timer_mod_ns(&acb->timer,
+                     qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->latency_ns);
+    } else {
+        acb->bh = aio_bh_new(bdrv_get_aio_context(bs), null_bh_cb, acb);
+        qemu_bh_schedule(acb->bh);
+    }
     return &acb->common;
 }