profiler: Reenable built-in profiler

[qemu.git] / qemu-io-cmds.c

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index e70855254af003e594f3c628bd12ad8193fac695..1afcfc01a57ca2a877b38b4ee87f144d4682d7d7 100644 (file)
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -9,10 +9,13 @@
  */
 
 #include "qemu-io.h"
  */
 
 #include "qemu-io.h"

-#include "block/block_int.h"
+#include "sysemu/block-backend.h"
+#include "block/block.h"
+#include "block/block_int.h" /* for info_f() */

 #include "block/qapi.h"
 #include "qemu/main-loop.h"
 #include "qemu/timer.h"
 #include "block/qapi.h"
 #include "qemu/main-loop.h"
 #include "qemu/timer.h"

+#include "sysemu/block-backend.h"

 
 #define CMD_NOFILE_OK   0x01
 
 
 #define CMD_NOFILE_OK   0x01
 


@@ -40,24 +43,24 @@ int qemuio_command_usage(const cmdinfo_t *ci)
     return 0;
 }
 
     return 0;
 }
 

-static int init_check_command(BlockDriverState *bs, const cmdinfo_t *ct)
+static int init_check_command(BlockBackend *blk, const cmdinfo_t *ct)

 {
     if (ct->flags & CMD_FLAG_GLOBAL) {
         return 1;
     }
 {
     if (ct->flags & CMD_FLAG_GLOBAL) {
         return 1;
     }

-    if (!(ct->flags & CMD_NOFILE_OK) && !bs) {
+    if (!(ct->flags & CMD_NOFILE_OK) && !blk) {

         fprintf(stderr, "no file open, try 'help open'\n");
         return 0;
     }
     return 1;
 }
 
         fprintf(stderr, "no file open, try 'help open'\n");
         return 0;
     }
     return 1;
 }
 

-static int command(BlockDriverState *bs, const cmdinfo_t *ct, int argc,
+static int command(BlockBackend *blk, const cmdinfo_t *ct, int argc,

                    char **argv)
 {
     char *cmd = argv[0];
 
                    char **argv)
 {
     char *cmd = argv[0];
 

-    if (!init_check_command(bs, ct)) {
+    if (!init_check_command(blk, ct)) {

         return 0;
     }
 
         return 0;
     }
 


@@ -78,7 +81,7 @@ static int command(BlockDriverState *bs, const cmdinfo_t *ct, int argc,
         return 0;
     }
     optind = 0;
         return 0;
     }
     optind = 0;

-    return ct->cfunc(bs, argc, argv);
+    return ct->cfunc(blk, argc, argv);

 }
 
 static const cmdinfo_t *find_command(const char *cmd)
 }
 
 static const cmdinfo_t *find_command(const char *cmd)


@@ -267,14 +270,14 @@ static int parse_pattern(const char *arg)
  */
 
 #define MISALIGN_OFFSET     16
  */
 
 #define MISALIGN_OFFSET     16

-static void *qemu_io_alloc(BlockDriverState *bs, size_t len, int pattern)
+static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern)

 {
     void *buf;
 
     if (qemuio_misalign) {
         len += MISALIGN_OFFSET;
     }
 {
     void *buf;
 
     if (qemuio_misalign) {
         len += MISALIGN_OFFSET;
     }

-    buf = qemu_blockalign(bs, len);
+    buf = blk_blockalign(blk, len);

     memset(buf, pattern, len);
     if (qemuio_misalign) {
         buf += MISALIGN_OFFSET;
     memset(buf, pattern, len);
     if (qemuio_misalign) {
         buf += MISALIGN_OFFSET;


@@ -340,7 +343,7 @@ static void print_report(const char *op, struct timeval *t, int64_t offset,
  * vector matching it.
  */
 static void *
  * vector matching it.
  */
 static void *

-create_iovec(BlockDriverState *bs, QEMUIOVector *qiov, char **argv, int nr_iov,
+create_iovec(BlockBackend *blk, QEMUIOVector *qiov, char **argv, int nr_iov,

              int pattern)
 {
     size_t *sizes = g_new0(size_t, nr_iov);
              int pattern)
 {
     size_t *sizes = g_new0(size_t, nr_iov);


@@ -377,7 +380,7 @@ create_iovec(BlockDriverState *bs, QEMUIOVector *qiov, char **argv, int nr_iov,
 
     qemu_iovec_init(qiov, nr_iov);
 
 
     qemu_iovec_init(qiov, nr_iov);
 

-    buf = p = qemu_io_alloc(bs, count, pattern);
+    buf = p = qemu_io_alloc(blk, count, pattern);

 
     for (i = 0; i < nr_iov; i++) {
         qemu_iovec_add(qiov, p, sizes[i]);
 
     for (i = 0; i < nr_iov; i++) {
         qemu_iovec_add(qiov, p, sizes[i]);


@@ -389,12 +392,12 @@ fail:
     return buf;
 }
 
     return buf;
 }
 

-static int do_read(BlockDriverState *bs, char *buf, int64_t offset, int count,
+static int do_read(BlockBackend *blk, char *buf, int64_t offset, int count,

                    int *total)
 {
     int ret;
 
                    int *total)
 {
     int ret;
 

-    ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, count >> 9);
+    ret = blk_read(blk, offset >> 9, (uint8_t *)buf, count >> 9);

     if (ret < 0) {
         return ret;
     }
     if (ret < 0) {
         return ret;
     }


@@ -402,12 +405,12 @@ static int do_read(BlockDriverState *bs, char *buf, int64_t offset, int count,
     return 1;
 }
 
     return 1;
 }
 

-static int do_write(BlockDriverState *bs, char *buf, int64_t offset, int count,
+static int do_write(BlockBackend *blk, char *buf, int64_t offset, int count,

                     int *total)
 {
     int ret;
 
                     int *total)
 {
     int ret;
 

-    ret = bdrv_write(bs, offset >> 9, (uint8_t *)buf, count >> 9);
+    ret = blk_write(blk, offset >> 9, (uint8_t *)buf, count >> 9);

     if (ret < 0) {
         return ret;
     }
     if (ret < 0) {
         return ret;
     }


@@ -415,20 +418,20 @@ static int do_write(BlockDriverState *bs, char *buf, int64_t offset, int count,
     return 1;
 }
 
     return 1;
 }
 

-static int do_pread(BlockDriverState *bs, char *buf, int64_t offset, int count,
+static int do_pread(BlockBackend *blk, char *buf, int64_t offset, int count,

                     int *total)
 {
                     int *total)
 {

-    *total = bdrv_pread(bs, offset, (uint8_t *)buf, count);
+    *total = blk_pread(blk, offset, (uint8_t *)buf, count);

     if (*total < 0) {
         return *total;
     }
     return 1;
 }
 
     if (*total < 0) {
         return *total;
     }
     return 1;
 }
 

-static int do_pwrite(BlockDriverState *bs, char *buf, int64_t offset, int count,
+static int do_pwrite(BlockBackend *blk, char *buf, int64_t offset, int count,

                      int *total)
 {
                      int *total)
 {

-    *total = bdrv_pwrite(bs, offset, (uint8_t *)buf, count);
+    *total = blk_pwrite(blk, offset, (uint8_t *)buf, count);

     if (*total < 0) {
         return *total;
     }
     if (*total < 0) {
         return *total;
     }


@@ -436,7 +439,7 @@ static int do_pwrite(BlockDriverState *bs, char *buf, int64_t offset, int count,
 }
 
 typedef struct {
 }
 
 typedef struct {

-    BlockDriverState *bs;
+    BlockBackend *blk;

     int64_t offset;
     int count;
     int *total;
     int64_t offset;
     int count;
     int *total;


@@ -448,8 +451,8 @@ static void coroutine_fn co_write_zeroes_entry(void *opaque)
 {
     CoWriteZeroes *data = opaque;
 
 {
     CoWriteZeroes *data = opaque;
 

-    data->ret = bdrv_co_write_zeroes(data->bs, data->offset / BDRV_SECTOR_SIZE,
-                                     data->count / BDRV_SECTOR_SIZE, 0);
+    data->ret = blk_co_write_zeroes(data->blk, data->offset / BDRV_SECTOR_SIZE,
+                                    data->count / BDRV_SECTOR_SIZE, 0);

     data->done = true;
     if (data->ret < 0) {
         *data->total = data->ret;
     data->done = true;
     if (data->ret < 0) {
         *data->total = data->ret;


@@ -459,12 +462,12 @@ static void coroutine_fn co_write_zeroes_entry(void *opaque)
     *data->total = data->count;
 }
 
     *data->total = data->count;
 }
 

-static int do_co_write_zeroes(BlockDriverState *bs, int64_t offset, int count,
+static int do_co_write_zeroes(BlockBackend *blk, int64_t offset, int count,

                               int *total)
 {
     Coroutine *co;
     CoWriteZeroes data = {
                               int *total)
 {
     Coroutine *co;
     CoWriteZeroes data = {

-        .bs     = bs,
+        .blk    = blk,

         .offset = offset,
         .count  = count,
         .total  = total,
         .offset = offset,
         .count  = count,
         .total  = total,


@@ -474,7 +477,7 @@ static int do_co_write_zeroes(BlockDriverState *bs, int64_t offset, int count,
     co = qemu_coroutine_create(co_write_zeroes_entry);
     qemu_coroutine_enter(co, &data);
     while (!data.done) {
     co = qemu_coroutine_create(co_write_zeroes_entry);
     qemu_coroutine_enter(co, &data);
     while (!data.done) {

-        aio_poll(bdrv_get_aio_context(bs), true);
+        aio_poll(blk_get_aio_context(blk), true);

     }
     if (data.ret < 0) {
         return data.ret;
     }
     if (data.ret < 0) {
         return data.ret;


@@ -483,12 +486,12 @@ static int do_co_write_zeroes(BlockDriverState *bs, int64_t offset, int count,
     }
 }
 
     }
 }
 

-static int do_write_compressed(BlockDriverState *bs, char *buf, int64_t offset,
+static int do_write_compressed(BlockBackend *blk, char *buf, int64_t offset,

                                int count, int *total)
 {
     int ret;
 
                                int count, int *total)
 {
     int ret;
 

-    ret = bdrv_write_compressed(bs, offset >> 9, (uint8_t *)buf, count >> 9);
+    ret = blk_write_compressed(blk, offset >> 9, (uint8_t *)buf, count >> 9);

     if (ret < 0) {
         return ret;
     }
     if (ret < 0) {
         return ret;
     }


@@ -496,20 +499,20 @@ static int do_write_compressed(BlockDriverState *bs, char *buf, int64_t offset,
     return 1;
 }
 
     return 1;
 }
 

-static int do_load_vmstate(BlockDriverState *bs, char *buf, int64_t offset,
+static int do_load_vmstate(BlockBackend *blk, char *buf, int64_t offset,

                            int count, int *total)
 {
                            int count, int *total)
 {

-    *total = bdrv_load_vmstate(bs, (uint8_t *)buf, offset, count);
+    *total = blk_load_vmstate(blk, (uint8_t *)buf, offset, count);

     if (*total < 0) {
         return *total;
     }
     return 1;
 }
 
     if (*total < 0) {
         return *total;
     }
     return 1;
 }
 

-static int do_save_vmstate(BlockDriverState *bs, char *buf, int64_t offset,
+static int do_save_vmstate(BlockBackend *blk, char *buf, int64_t offset,

                            int count, int *total)
 {
                            int count, int *total)
 {

-    *total = bdrv_save_vmstate(bs, (uint8_t *)buf, offset, count);
+    *total = blk_save_vmstate(blk, (uint8_t *)buf, offset, count);

     if (*total < 0) {
         return *total;
     }
     if (*total < 0) {
         return *total;
     }


@@ -522,13 +525,13 @@ static void aio_rw_done(void *opaque, int ret)
     *(int *)opaque = ret;
 }
 
     *(int *)opaque = ret;
 }
 

-static int do_aio_readv(BlockDriverState *bs, QEMUIOVector *qiov,
+static int do_aio_readv(BlockBackend *blk, QEMUIOVector *qiov,

                         int64_t offset, int *total)
 {
     int async_ret = NOT_DONE;
 
                         int64_t offset, int *total)
 {
     int async_ret = NOT_DONE;
 

-    bdrv_aio_readv(bs, offset >> 9, qiov, qiov->size >> 9,
-                   aio_rw_done, &async_ret);
+    blk_aio_readv(blk, offset >> 9, qiov, qiov->size >> 9,
+                  aio_rw_done, &async_ret);

     while (async_ret == NOT_DONE) {
         main_loop_wait(false);
     }
     while (async_ret == NOT_DONE) {
         main_loop_wait(false);
     }


@@ -537,13 +540,13 @@ static int do_aio_readv(BlockDriverState *bs, QEMUIOVector *qiov,
     return async_ret < 0 ? async_ret : 1;
 }
 
     return async_ret < 0 ? async_ret : 1;
 }
 

-static int do_aio_writev(BlockDriverState *bs, QEMUIOVector *qiov,
+static int do_aio_writev(BlockBackend *blk, QEMUIOVector *qiov,

                          int64_t offset, int *total)
 {
     int async_ret = NOT_DONE;
 
                          int64_t offset, int *total)
 {
     int async_ret = NOT_DONE;
 

-    bdrv_aio_writev(bs, offset >> 9, qiov, qiov->size >> 9,
-                    aio_rw_done, &async_ret);
+    blk_aio_writev(blk, offset >> 9, qiov, qiov->size >> 9,
+                   aio_rw_done, &async_ret);

     while (async_ret == NOT_DONE) {
         main_loop_wait(false);
     }
     while (async_ret == NOT_DONE) {
         main_loop_wait(false);
     }


@@ -567,7 +570,7 @@ static void multiwrite_cb(void *opaque, int ret)
     }
 }
 
     }
 }
 

-static int do_aio_multiwrite(BlockDriverState *bs, BlockRequest* reqs,
+static int do_aio_multiwrite(BlockBackend *blk, BlockRequest* reqs,

                              int num_reqs, int *total)
 {
     int i, ret;
                              int num_reqs, int *total)
 {
     int i, ret;


@@ -583,7 +586,7 @@ static int do_aio_multiwrite(BlockDriverState *bs, BlockRequest* reqs,
         *total += reqs[i].qiov->size;
     }
 
         *total += reqs[i].qiov->size;
     }
 

-    ret = bdrv_aio_multiwrite(bs, reqs, num_reqs);
+    ret = blk_aio_multiwrite(blk, reqs, num_reqs);

     if (ret < 0) {
         return ret;
     }
     if (ret < 0) {
         return ret;
     }


@@ -609,7 +612,7 @@ static void read_help(void)
 " -b, -- read from the VM state rather than the virtual disk\n"
 " -C, -- report statistics in a machine parsable format\n"
 " -l, -- length for pattern verification (only with -P)\n"
 " -b, -- read from the VM state rather than the virtual disk\n"
 " -C, -- report statistics in a machine parsable format\n"
 " -l, -- length for pattern verification (only with -P)\n"

-" -p, -- use bdrv_pread to read the file\n"
+" -p, -- use blk_pread to read the file\n"

 " -P, -- use a pattern to verify read data\n"
 " -q, -- quiet mode, do not show I/O statistics\n"
 " -s, -- start offset for pattern verification (only with -P)\n"
 " -P, -- use a pattern to verify read data\n"
 " -q, -- quiet mode, do not show I/O statistics\n"
 " -s, -- start offset for pattern verification (only with -P)\n"


@@ -617,7 +620,7 @@ static void read_help(void)
 "\n");
 }
 
 "\n");
 }
 

-static int read_f(BlockDriverState *bs, int argc, char **argv);
+static int read_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t read_cmd = {
     .name       = "read",
 
 static const cmdinfo_t read_cmd = {
     .name       = "read",


@@ -630,7 +633,7 @@ static const cmdinfo_t read_cmd = {
     .help       = read_help,
 };
 
     .help       = read_help,
 };
 

-static int read_f(BlockDriverState *bs, int argc, char **argv)
+static int read_f(BlockBackend *blk, int argc, char **argv)

 {
     struct timeval t1, t2;
     int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;
 {
     struct timeval t1, t2;
     int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;


@@ -736,15 +739,15 @@ static int read_f(BlockDriverState *bs, int argc, char **argv)
         }
     }
 
         }
     }
 

-    buf = qemu_io_alloc(bs, count, 0xab);
+    buf = qemu_io_alloc(blk, count, 0xab);

 
     gettimeofday(&t1, NULL);
     if (pflag) {
 
     gettimeofday(&t1, NULL);
     if (pflag) {

-        cnt = do_pread(bs, buf, offset, count, &total);
+        cnt = do_pread(blk, buf, offset, count, &total);

     } else if (bflag) {
     } else if (bflag) {

-        cnt = do_load_vmstate(bs, buf, offset, count, &total);
+        cnt = do_load_vmstate(blk, buf, offset, count, &total);

     } else {
     } else {

-        cnt = do_read(bs, buf, offset, count, &total);
+        cnt = do_read(blk, buf, offset, count, &total);

     }
     gettimeofday(&t2, NULL);
 
     }
     gettimeofday(&t2, NULL);
 


@@ -801,7 +804,7 @@ static void readv_help(void)
 "\n");
 }
 
 "\n");
 }
 

-static int readv_f(BlockDriverState *bs, int argc, char **argv);
+static int readv_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t readv_cmd = {
     .name       = "readv",
 
 static const cmdinfo_t readv_cmd = {
     .name       = "readv",


@@ -813,7 +816,7 @@ static const cmdinfo_t readv_cmd = {
     .help       = readv_help,
 };
 
     .help       = readv_help,
 };
 

-static int readv_f(BlockDriverState *bs, int argc, char **argv)
+static int readv_f(BlockBackend *blk, int argc, char **argv)

 {
     struct timeval t1, t2;
     int Cflag = 0, qflag = 0, vflag = 0;
 {
     struct timeval t1, t2;
     int Cflag = 0, qflag = 0, vflag = 0;


@@ -869,13 +872,13 @@ static int readv_f(BlockDriverState *bs, int argc, char **argv)
     }
 
     nr_iov = argc - optind;
     }
 
     nr_iov = argc - optind;

-    buf = create_iovec(bs, &qiov, &argv[optind], nr_iov, 0xab);
+    buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, 0xab);

     if (buf == NULL) {
         return 0;
     }
 
     gettimeofday(&t1, NULL);
     if (buf == NULL) {
         return 0;
     }
 
     gettimeofday(&t1, NULL);

-    cnt = do_aio_readv(bs, &qiov, offset, &total);
+    cnt = do_aio_readv(blk, &qiov, offset, &total);

     gettimeofday(&t2, NULL);
 
     if (cnt < 0) {
     gettimeofday(&t2, NULL);
 
     if (cnt < 0) {


@@ -923,16 +926,16 @@ static void write_help(void)
 " Writes into a segment of the currently open file, using a buffer\n"
 " filled with a set pattern (0xcdcdcdcd).\n"
 " -b, -- write to the VM state rather than the virtual disk\n"
 " Writes into a segment of the currently open file, using a buffer\n"
 " filled with a set pattern (0xcdcdcdcd).\n"
 " -b, -- write to the VM state rather than the virtual disk\n"

-" -c, -- write compressed data with bdrv_write_compressed\n"
-" -p, -- use bdrv_pwrite to write the file\n"
+" -c, -- write compressed data with blk_write_compressed\n"
+" -p, -- use blk_pwrite to write the file\n"

 " -P, -- use different pattern to fill file\n"
 " -C, -- report statistics in a machine parsable format\n"
 " -q, -- quiet mode, do not show I/O statistics\n"
 " -P, -- use different pattern to fill file\n"
 " -C, -- report statistics in a machine parsable format\n"
 " -q, -- quiet mode, do not show I/O statistics\n"

-" -z, -- write zeroes using bdrv_co_write_zeroes\n"
+" -z, -- write zeroes using blk_co_write_zeroes\n"

 "\n");
 }
 
 "\n");
 }
 

-static int write_f(BlockDriverState *bs, int argc, char **argv);
+static int write_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t write_cmd = {
     .name       = "write",
 
 static const cmdinfo_t write_cmd = {
     .name       = "write",


@@ -945,7 +948,7 @@ static const cmdinfo_t write_cmd = {
     .help       = write_help,
 };
 
     .help       = write_help,
 };
 

-static int write_f(BlockDriverState *bs, int argc, char **argv)
+static int write_f(BlockBackend *blk, int argc, char **argv)

 {
     struct timeval t1, t2;
     int Cflag = 0, pflag = 0, qflag = 0, bflag = 0, Pflag = 0, zflag = 0;
 {
     struct timeval t1, t2;
     int Cflag = 0, pflag = 0, qflag = 0, bflag = 0, Pflag = 0, zflag = 0;


@@ -1032,20 +1035,20 @@ static int write_f(BlockDriverState *bs, int argc, char **argv)
     }
 
     if (!zflag) {
     }
 
     if (!zflag) {

-        buf = qemu_io_alloc(bs, count, pattern);
+        buf = qemu_io_alloc(blk, count, pattern);

     }
 
     gettimeofday(&t1, NULL);
     if (pflag) {
     }
 
     gettimeofday(&t1, NULL);
     if (pflag) {

-        cnt = do_pwrite(bs, buf, offset, count, &total);
+        cnt = do_pwrite(blk, buf, offset, count, &total);

     } else if (bflag) {
     } else if (bflag) {

-        cnt = do_save_vmstate(bs, buf, offset, count, &total);
+        cnt = do_save_vmstate(blk, buf, offset, count, &total);

     } else if (zflag) {
     } else if (zflag) {

-        cnt = do_co_write_zeroes(bs, offset, count, &total);
+        cnt = do_co_write_zeroes(blk, offset, count, &total);

     } else if (cflag) {
     } else if (cflag) {

-        cnt = do_write_compressed(bs, buf, offset, count, &total);
+        cnt = do_write_compressed(blk, buf, offset, count, &total);

     } else {
     } else {

-        cnt = do_write(bs, buf, offset, count, &total);
+        cnt = do_write(blk, buf, offset, count, &total);

     }
     gettimeofday(&t2, NULL);
 
     }
     gettimeofday(&t2, NULL);
 


@@ -1088,7 +1091,7 @@ writev_help(void)
 "\n");
 }
 
 "\n");
 }
 

-static int writev_f(BlockDriverState *bs, int argc, char **argv);
+static int writev_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t writev_cmd = {
     .name       = "writev",
 
 static const cmdinfo_t writev_cmd = {
     .name       = "writev",


@@ -1100,7 +1103,7 @@ static const cmdinfo_t writev_cmd = {
     .help       = writev_help,
 };
 
     .help       = writev_help,
 };
 

-static int writev_f(BlockDriverState *bs, int argc, char **argv)
+static int writev_f(BlockBackend *blk, int argc, char **argv)

 {
     struct timeval t1, t2;
     int Cflag = 0, qflag = 0;
 {
     struct timeval t1, t2;
     int Cflag = 0, qflag = 0;


@@ -1150,13 +1153,13 @@ static int writev_f(BlockDriverState *bs, int argc, char **argv)
     }
 
     nr_iov = argc - optind;
     }
 
     nr_iov = argc - optind;

-    buf = create_iovec(bs, &qiov, &argv[optind], nr_iov, pattern);
+    buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, pattern);

     if (buf == NULL) {
         return 0;
     }
 
     gettimeofday(&t1, NULL);
     if (buf == NULL) {
         return 0;
     }
 
     gettimeofday(&t1, NULL);

-    cnt = do_aio_writev(bs, &qiov, offset, &total);
+    cnt = do_aio_writev(blk, &qiov, offset, &total);

     gettimeofday(&t2, NULL);
 
     if (cnt < 0) {
     gettimeofday(&t2, NULL);
 
     if (cnt < 0) {


@@ -1197,7 +1200,7 @@ static void multiwrite_help(void)
 "\n");
 }
 
 "\n");
 }
 

-static int multiwrite_f(BlockDriverState *bs, int argc, char **argv);
+static int multiwrite_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t multiwrite_cmd = {
     .name       = "multiwrite",
 
 static const cmdinfo_t multiwrite_cmd = {
     .name       = "multiwrite",


@@ -1209,7 +1212,7 @@ static const cmdinfo_t multiwrite_cmd = {
     .help       = multiwrite_help,
 };
 
     .help       = multiwrite_help,
 };
 

-static int multiwrite_f(BlockDriverState *bs, int argc, char **argv)
+static int multiwrite_f(BlockBackend *blk, int argc, char **argv)

 {
     struct timeval t1, t2;
     int Cflag = 0, qflag = 0;
 {
     struct timeval t1, t2;
     int Cflag = 0, qflag = 0;


@@ -1290,7 +1293,7 @@ static int multiwrite_f(BlockDriverState *bs, int argc, char **argv)
         nr_iov = j - optind;
 
         /* Build request */
         nr_iov = j - optind;
 
         /* Build request */

-        buf[i] = create_iovec(bs, &qiovs[i], &argv[optind], nr_iov, pattern);
+        buf[i] = create_iovec(blk, &qiovs[i], &argv[optind], nr_iov, pattern);

         if (buf[i] == NULL) {
             goto out;
         }
         if (buf[i] == NULL) {
             goto out;
         }


@@ -1308,7 +1311,7 @@ static int multiwrite_f(BlockDriverState *bs, int argc, char **argv)
     nr_reqs = i;
 
     gettimeofday(&t1, NULL);
     nr_reqs = i;
 
     gettimeofday(&t1, NULL);

-    cnt = do_aio_multiwrite(bs, reqs, nr_reqs, &total);
+    cnt = do_aio_multiwrite(blk, reqs, nr_reqs, &total);

     gettimeofday(&t2, NULL);
 
     if (cnt < 0) {
     gettimeofday(&t2, NULL);
 
     if (cnt < 0) {


@@ -1337,6 +1340,7 @@ out:
 }
 
 struct aio_ctx {
 }
 
 struct aio_ctx {

+    BlockBackend *blk;

     QEMUIOVector qiov;
     int64_t offset;
     char *buf;
     QEMUIOVector qiov;
     int64_t offset;
     char *buf;


@@ -1344,6 +1348,7 @@ struct aio_ctx {
     int vflag;
     int Cflag;
     int Pflag;
     int vflag;
     int Cflag;
     int Pflag;

+    BlockAcctCookie acct;

     int pattern;
     struct timeval t1;
 };
     int pattern;
     struct timeval t1;
 };


@@ -1361,6 +1366,8 @@ static void aio_write_done(void *opaque, int ret)
         goto out;
     }
 
         goto out;
     }
 

+    block_acct_done(blk_get_stats(ctx->blk), &ctx->acct);
+

     if (ctx->qflag) {
         goto out;
     }
     if (ctx->qflag) {
         goto out;
     }


@@ -1398,6 +1405,8 @@ static void aio_read_done(void *opaque, int ret)
         g_free(cmp_buf);
     }
 
         g_free(cmp_buf);
     }
 

+    block_acct_done(blk_get_stats(ctx->blk), &ctx->acct);
+

     if (ctx->qflag) {
         goto out;
     }
     if (ctx->qflag) {
         goto out;
     }


@@ -1436,7 +1445,7 @@ static void aio_read_help(void)
 "\n");
 }
 
 "\n");
 }
 

-static int aio_read_f(BlockDriverState *bs, int argc, char **argv);
+static int aio_read_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t aio_read_cmd = {
     .name       = "aio_read",
 
 static const cmdinfo_t aio_read_cmd = {
     .name       = "aio_read",


@@ -1448,11 +1457,12 @@ static const cmdinfo_t aio_read_cmd = {
     .help       = aio_read_help,
 };
 
     .help       = aio_read_help,
 };
 

-static int aio_read_f(BlockDriverState *bs, int argc, char **argv)
+static int aio_read_f(BlockBackend *blk, int argc, char **argv)

 {
     int nr_iov, c;
     struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
 
 {
     int nr_iov, c;
     struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
 

+    ctx->blk = blk;

     while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
         switch (c) {
         case 'C':
     while ((c = getopt(argc, argv, "CP:qv")) != EOF) {
         switch (c) {
         case 'C':


@@ -1499,15 +1509,17 @@ static int aio_read_f(BlockDriverState *bs, int argc, char **argv)
     }
 
     nr_iov = argc - optind;
     }
 
     nr_iov = argc - optind;

-    ctx->buf = create_iovec(bs, &ctx->qiov, &argv[optind], nr_iov, 0xab);
+    ctx->buf = create_iovec(blk, &ctx->qiov, &argv[optind], nr_iov, 0xab);

     if (ctx->buf == NULL) {
         g_free(ctx);
         return 0;
     }
 
     gettimeofday(&ctx->t1, NULL);
     if (ctx->buf == NULL) {
         g_free(ctx);
         return 0;
     }
 
     gettimeofday(&ctx->t1, NULL);

-    bdrv_aio_readv(bs, ctx->offset >> 9, &ctx->qiov,
-                   ctx->qiov.size >> 9, aio_read_done, ctx);
+    block_acct_start(blk_get_stats(blk), &ctx->acct, ctx->qiov.size,
+                     BLOCK_ACCT_READ);
+    blk_aio_readv(blk, ctx->offset >> 9, &ctx->qiov,
+                  ctx->qiov.size >> 9, aio_read_done, ctx);

     return 0;
 }
 
     return 0;
 }
 


@@ -1531,7 +1543,7 @@ static void aio_write_help(void)
 "\n");
 }
 
 "\n");
 }
 

-static int aio_write_f(BlockDriverState *bs, int argc, char **argv);
+static int aio_write_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t aio_write_cmd = {
     .name       = "aio_write",
 
 static const cmdinfo_t aio_write_cmd = {
     .name       = "aio_write",


@@ -1543,12 +1555,13 @@ static const cmdinfo_t aio_write_cmd = {
     .help       = aio_write_help,
 };
 
     .help       = aio_write_help,
 };
 

-static int aio_write_f(BlockDriverState *bs, int argc, char **argv)
+static int aio_write_f(BlockBackend *blk, int argc, char **argv)

 {
     int nr_iov, c;
     int pattern = 0xcd;
     struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
 
 {
     int nr_iov, c;
     int pattern = 0xcd;
     struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);
 

+    ctx->blk = blk;

     while ((c = getopt(argc, argv, "CqP:")) != EOF) {
         switch (c) {
         case 'C':
     while ((c = getopt(argc, argv, "CqP:")) != EOF) {
         switch (c) {
         case 'C':


@@ -1591,21 +1604,23 @@ static int aio_write_f(BlockDriverState *bs, int argc, char **argv)
     }
 
     nr_iov = argc - optind;
     }
 
     nr_iov = argc - optind;

-    ctx->buf = create_iovec(bs, &ctx->qiov, &argv[optind], nr_iov, pattern);
+    ctx->buf = create_iovec(blk, &ctx->qiov, &argv[optind], nr_iov, pattern);

     if (ctx->buf == NULL) {
         g_free(ctx);
         return 0;
     }
 
     gettimeofday(&ctx->t1, NULL);
     if (ctx->buf == NULL) {
         g_free(ctx);
         return 0;
     }
 
     gettimeofday(&ctx->t1, NULL);

-    bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov,
-                    ctx->qiov.size >> 9, aio_write_done, ctx);
+    block_acct_start(blk_get_stats(blk), &ctx->acct, ctx->qiov.size,
+                     BLOCK_ACCT_WRITE);
+    blk_aio_writev(blk, ctx->offset >> 9, &ctx->qiov,
+                   ctx->qiov.size >> 9, aio_write_done, ctx);

     return 0;
 }
 
     return 0;
 }
 

-static int aio_flush_f(BlockDriverState *bs, int argc, char **argv)
+static int aio_flush_f(BlockBackend *blk, int argc, char **argv)

 {
 {

-    bdrv_drain_all();
+    blk_drain_all();

     return 0;
 }
 
     return 0;
 }
 


@@ -1615,9 +1630,9 @@ static const cmdinfo_t aio_flush_cmd = {
     .oneline    = "completes all outstanding aio requests"
 };
 
     .oneline    = "completes all outstanding aio requests"
 };
 

-static int flush_f(BlockDriverState *bs, int argc, char **argv)
+static int flush_f(BlockBackend *blk, int argc, char **argv)

 {
 {

-    bdrv_flush(bs);
+    blk_flush(blk);

     return 0;
 }
 
     return 0;
 }
 


@@ -1628,7 +1643,7 @@ static const cmdinfo_t flush_cmd = {
     .oneline    = "flush all in-core file state to disk",
 };
 
     .oneline    = "flush all in-core file state to disk",
 };
 

-static int truncate_f(BlockDriverState *bs, int argc, char **argv)
+static int truncate_f(BlockBackend *blk, int argc, char **argv)

 {
     int64_t offset;
     int ret;
 {
     int64_t offset;
     int ret;


@@ -1639,7 +1654,7 @@ static int truncate_f(BlockDriverState *bs, int argc, char **argv)
         return 0;
     }
 
         return 0;
     }
 

-    ret = bdrv_truncate(bs, offset);
+    ret = blk_truncate(blk, offset);

     if (ret < 0) {
         printf("truncate: %s\n", strerror(-ret));
         return 0;
     if (ret < 0) {
         printf("truncate: %s\n", strerror(-ret));
         return 0;


@@ -1658,12 +1673,12 @@ static const cmdinfo_t truncate_cmd = {
     .oneline    = "truncates the current file at the given offset",
 };
 
     .oneline    = "truncates the current file at the given offset",
 };
 

-static int length_f(BlockDriverState *bs, int argc, char **argv)
+static int length_f(BlockBackend *blk, int argc, char **argv)

 {
     int64_t size;
     char s1[64];
 
 {
     int64_t size;
     char s1[64];
 

-    size = bdrv_getlength(bs);
+    size = blk_getlength(blk);

     if (size < 0) {
         printf("getlength: %s\n", strerror(-size));
         return 0;
     if (size < 0) {
         printf("getlength: %s\n", strerror(-size));
         return 0;


@@ -1683,8 +1698,9 @@ static const cmdinfo_t length_cmd = {
 };
 
 
 };
 
 

-static int info_f(BlockDriverState *bs, int argc, char **argv)
+static int info_f(BlockBackend *blk, int argc, char **argv)

 {
 {

+    BlockDriverState *bs = blk_bs(blk);

     BlockDriverInfo bdi;
     ImageInfoSpecific *spec_info;
     char s1[64], s2[64];
     BlockDriverInfo bdi;
     ImageInfoSpecific *spec_info;
     char s1[64], s2[64];


@@ -1742,7 +1758,7 @@ static void discard_help(void)
 "\n");
 }
 
 "\n");
 }
 

-static int discard_f(BlockDriverState *bs, int argc, char **argv);
+static int discard_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t discard_cmd = {
     .name       = "discard",
 
 static const cmdinfo_t discard_cmd = {
     .name       = "discard",


@@ -1755,7 +1771,7 @@ static const cmdinfo_t discard_cmd = {
     .help       = discard_help,
 };
 
     .help       = discard_help,
 };
 

-static int discard_f(BlockDriverState *bs, int argc, char **argv)
+static int discard_f(BlockBackend *blk, int argc, char **argv)

 {
     struct timeval t1, t2;
     int Cflag = 0, qflag = 0;
 {
     struct timeval t1, t2;
     int Cflag = 0, qflag = 0;


@@ -1794,8 +1810,8 @@ static int discard_f(BlockDriverState *bs, int argc, char **argv)
     }
 
     gettimeofday(&t1, NULL);
     }
 
     gettimeofday(&t1, NULL);

-    ret = bdrv_discard(bs, offset >> BDRV_SECTOR_BITS,
-                       count >> BDRV_SECTOR_BITS);
+    ret = blk_discard(blk, offset >> BDRV_SECTOR_BITS,
+                      count >> BDRV_SECTOR_BITS);

     gettimeofday(&t2, NULL);
 
     if (ret < 0) {
     gettimeofday(&t2, NULL);
 
     if (ret < 0) {


@@ -1813,8 +1829,9 @@ out:
     return 0;
 }
 
     return 0;
 }
 

-static int alloc_f(BlockDriverState *bs, int argc, char **argv)
+static int alloc_f(BlockBackend *blk, int argc, char **argv)

 {
 {

+    BlockDriverState *bs = blk_bs(blk);

     int64_t offset, sector_num;
     int nb_sectors, remaining;
     char s1[64];
     int64_t offset, sector_num;
     int nb_sectors, remaining;
     char s1[64];


@@ -1910,20 +1927,27 @@ static int map_is_allocated(BlockDriverState *bs, int64_t sector_num,
     return firstret;
 }
 
     return firstret;
 }
 

-static int map_f(BlockDriverState *bs, int argc, char **argv)
+static int map_f(BlockBackend *blk, int argc, char **argv)

 {
     int64_t offset;
 {
     int64_t offset;

-    int64_t nb_sectors;
+    int64_t nb_sectors, total_sectors;

     char s1[64];
     int64_t num;
     int ret;
     const char *retstr;
 
     offset = 0;
     char s1[64];
     int64_t num;
     int ret;
     const char *retstr;
 
     offset = 0;

-    nb_sectors = bs->total_sectors;
+    total_sectors = blk_nb_sectors(blk);
+    if (total_sectors < 0) {
+        error_report("Failed to query image length: %s",
+                     strerror(-total_sectors));
+        return 0;
+    }
+
+    nb_sectors = total_sectors;

 
     do {
 
     do {

-        ret = map_is_allocated(bs, offset, nb_sectors, &num);
+        ret = map_is_allocated(blk_bs(blk), offset, nb_sectors, &num);

         if (ret < 0) {
             error_report("Failed to get allocation status: %s", strerror(-ret));
             return 0;
         if (ret < 0) {
             error_report("Failed to get allocation status: %s", strerror(-ret));
             return 0;


@@ -1940,7 +1964,7 @@ static int map_f(BlockDriverState *bs, int argc, char **argv)
 
         offset += num;
         nb_sectors -= num;
 
         offset += num;
         nb_sectors -= num;

-    } while (offset < bs->total_sectors);
+    } while (offset < total_sectors);

 
     return 0;
 }
 
     return 0;
 }


@@ -1954,11 +1978,11 @@ static const cmdinfo_t map_cmd = {
        .oneline        = "prints the allocated areas of a file",
 };
 
        .oneline        = "prints the allocated areas of a file",
 };
 

-static int break_f(BlockDriverState *bs, int argc, char **argv)
+static int break_f(BlockBackend *blk, int argc, char **argv)

 {
     int ret;
 
 {
     int ret;
 

-    ret = bdrv_debug_breakpoint(bs, argv[1], argv[2]);
+    ret = bdrv_debug_breakpoint(blk_bs(blk), argv[1], argv[2]);

     if (ret < 0) {
         printf("Could not set breakpoint: %s\n", strerror(-ret));
     }
     if (ret < 0) {
         printf("Could not set breakpoint: %s\n", strerror(-ret));
     }


@@ -1966,11 +1990,11 @@ static int break_f(BlockDriverState *bs, int argc, char **argv)
     return 0;
 }
 
     return 0;
 }
 

-static int remove_break_f(BlockDriverState *bs, int argc, char **argv)
+static int remove_break_f(BlockBackend *blk, int argc, char **argv)

 {
     int ret;
 
 {
     int ret;
 

-    ret = bdrv_debug_remove_breakpoint(bs, argv[1]);
+    ret = bdrv_debug_remove_breakpoint(blk_bs(blk), argv[1]);

     if (ret < 0) {
         printf("Could not remove breakpoint %s: %s\n", argv[1], strerror(-ret));
     }
     if (ret < 0) {
         printf("Could not remove breakpoint %s: %s\n", argv[1], strerror(-ret));
     }


@@ -1997,11 +2021,11 @@ static const cmdinfo_t remove_break_cmd = {
        .oneline        = "remove a breakpoint by tag",
 };
 
        .oneline        = "remove a breakpoint by tag",
 };
 

-static int resume_f(BlockDriverState *bs, int argc, char **argv)
+static int resume_f(BlockBackend *blk, int argc, char **argv)

 {
     int ret;
 
 {
     int ret;
 

-    ret = bdrv_debug_resume(bs, argv[1]);
+    ret = bdrv_debug_resume(blk_bs(blk), argv[1]);

     if (ret < 0) {
         printf("Could not resume request: %s\n", strerror(-ret));
     }
     if (ret < 0) {
         printf("Could not resume request: %s\n", strerror(-ret));
     }


@@ -2018,10 +2042,10 @@ static const cmdinfo_t resume_cmd = {
        .oneline        = "resumes the request tagged as tag",
 };
 
        .oneline        = "resumes the request tagged as tag",
 };
 

-static int wait_break_f(BlockDriverState *bs, int argc, char **argv)
+static int wait_break_f(BlockBackend *blk, int argc, char **argv)

 {
 {

-    while (!bdrv_debug_is_suspended(bs, argv[1])) {
-        aio_poll(bdrv_get_aio_context(bs), true);
+    while (!bdrv_debug_is_suspended(blk_bs(blk), argv[1])) {
+        aio_poll(blk_get_aio_context(blk), true);

     }
 
     return 0;
     }
 
     return 0;


@@ -2036,7 +2060,7 @@ static const cmdinfo_t wait_break_cmd = {
        .oneline        = "waits for the suspension of a request",
 };
 
        .oneline        = "waits for the suspension of a request",
 };
 

-static int abort_f(BlockDriverState *bs, int argc, char **argv)
+static int abort_f(BlockBackend *blk, int argc, char **argv)

 {
     abort();
 }
 {
     abort();
 }


@@ -2062,7 +2086,7 @@ static void sigraise_help(void)
 "\n", SIGTERM);
 }
 
 "\n", SIGTERM);
 }
 

-static int sigraise_f(BlockDriverState *bs, int argc, char **argv);
+static int sigraise_f(BlockBackend *blk, int argc, char **argv);

 
 static const cmdinfo_t sigraise_cmd = {
     .name       = "sigraise",
 
 static const cmdinfo_t sigraise_cmd = {
     .name       = "sigraise",


@@ -2075,7 +2099,7 @@ static const cmdinfo_t sigraise_cmd = {
     .help       = sigraise_help,
 };
 
     .help       = sigraise_help,
 };
 

-static int sigraise_f(BlockDriverState *bs, int argc, char **argv)
+static int sigraise_f(BlockBackend *blk, int argc, char **argv)

 {
     int sig = cvtnum(argv[1]);
     if (sig < 0) {
 {
     int sig = cvtnum(argv[1]);
     if (sig < 0) {


@@ -2099,7 +2123,7 @@ static void sleep_cb(void *opaque)
     *expired = true;
 }
 
     *expired = true;
 }
 

-static int sleep_f(BlockDriverState *bs, int argc, char **argv)
+static int sleep_f(BlockBackend *blk, int argc, char **argv)

 {
     char *endptr;
     long ms;
 {
     char *endptr;
     long ms;


@@ -2168,7 +2192,7 @@ static void help_all(void)
     printf("\nUse 'help commandname' for extended help.\n");
 }
 
     printf("\nUse 'help commandname' for extended help.\n");
 }
 

-static int help_f(BlockDriverState *bs, int argc, char **argv)
+static int help_f(BlockBackend *blk, int argc, char **argv)

 {
     const cmdinfo_t *ct;
 
 {
     const cmdinfo_t *ct;
 


@@ -2198,7 +2222,7 @@ static const cmdinfo_t help_cmd = {
     .oneline    = "help for one or all commands",
 };
 
     .oneline    = "help for one or all commands",
 };
 

-bool qemuio_command(BlockDriverState *bs, const char *cmd)
+bool qemuio_command(BlockBackend *blk, const char *cmd)

 {
     char *input;
     const cmdinfo_t *ct;
 {
     char *input;
     const cmdinfo_t *ct;


@@ -2211,7 +2235,7 @@ bool qemuio_command(BlockDriverState *bs, const char *cmd)
     if (c) {
         ct = find_command(v[0]);
         if (ct) {
     if (c) {
         ct = find_command(v[0]);
         if (ct) {

-            done = command(bs, ct, c, v);
+            done = command(blk, ct, c, v);

         } else {
             fprintf(stderr, "command \"%s\" not found\n", v[0]);
         }
         } else {
             fprintf(stderr, "command \"%s\" not found\n", v[0]);
         }