static int img_bench(int argc, char **argv)

{

    int c, ret = 0;

    const char *fmt = NULL, *filename;

    bool quiet = false;

    bool image_opts = false;

    bool is_write = false;

    int count = 75000;

    int depth = 64;

    int64_t offset = 0;

    size_t bufsize = 4096;

    int pattern = 0;

    size_t step = 0;

    int flush_interval = 0;

    bool drain_on_flush = true;

    int64_t image_size;

    BlockBackend *blk = NULL;

    BenchData data = {};

    int flags = 0;

    bool writethrough = false;

    struct timeval t1, t2;

    int i;



    for (;;) {

        static const struct option long_options[] = {

            {"help", no_argument, 0, 'h'},

            {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},

            {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},

            {"pattern", required_argument, 0, OPTION_PATTERN},

            {"no-drain", no_argument, 0, OPTION_NO_DRAIN},

            {0, 0, 0, 0}

        };

        c = getopt_long(argc, argv, "hc:d:f:no:qs:S:t:w", long_options, NULL);

        if (c == -1) {

            break;

        }



        switch (c) {

        case 'h':

        case '?':

            help();

            break;

        case 'c':

        {

            unsigned long res;



            if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

                error_report("Invalid request count specified");

                return 1;

            }

            count = res;

            break;

        }

        case 'd':

        {

            unsigned long res;



            if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

                error_report("Invalid queue depth specified");

                return 1;

            }

            depth = res;

            break;

        }

        case 'f':

            fmt = optarg;

            break;

        case 'n':

            flags |= BDRV_O_NATIVE_AIO;

            break;

        case 'o':

        {

            offset = cvtnum(optarg);

            if (offset < 0) {

                error_report("Invalid offset specified");

                return 1;

            }

            break;

        }

            break;

        case 'q':

            quiet = true;

            break;

        case 's':

        {

            int64_t sval;



            sval = cvtnum(optarg);

            if (sval < 0 || sval > INT_MAX) {

                error_report("Invalid buffer size specified");

                return 1;

            }



            bufsize = sval;

            break;

        }

        case 'S':

        {

            int64_t sval;



            sval = cvtnum(optarg);

            if (sval < 0 || sval > INT_MAX) {

                error_report("Invalid step size specified");

                return 1;

            }



            step = sval;

            break;

        }

        case 't':

            ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);

            if (ret < 0) {

                error_report("Invalid cache mode");

                ret = -1;

                goto out;

            }

            break;

        case 'w':

            flags |= BDRV_O_RDWR;

            is_write = true;

            break;

        case OPTION_PATTERN:

        {

            unsigned long res;



            if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {

                error_report("Invalid pattern byte specified");

                return 1;

            }

            pattern = res;

            break;

        }

        case OPTION_FLUSH_INTERVAL:

        {

            unsigned long res;



            if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

                error_report("Invalid flush interval specified");

                return 1;

            }

            flush_interval = res;

            break;

        }

        case OPTION_NO_DRAIN:

            drain_on_flush = false;

            break;

        case OPTION_IMAGE_OPTS:

            image_opts = true;

            break;

        }

    }



    if (optind != argc - 1) {

        error_exit("Expecting one image file name");

    }

    filename = argv[argc - 1];



    if (!is_write && flush_interval) {

        error_report("--flush-interval is only available in write tests");

        ret = -1;

        goto out;

    }

    if (flush_interval && flush_interval < depth) {

        error_report("Flush interval can't be smaller than depth");

        ret = -1;

        goto out;

    }



    blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);

    if (!blk) {

        ret = -1;

        goto out;

    }



    image_size = blk_getlength(blk);

    if (image_size < 0) {

        ret = image_size;

        goto out;

    }



    data = (BenchData) {

        .blk            = blk,

        .image_size     = image_size,

        .bufsize        = bufsize,

        .step           = step ?: bufsize,

        .nrreq          = depth,

        .n              = count,

        .offset         = offset,

        .write          = is_write,

        .flush_interval = flush_interval,

        .drain_on_flush = drain_on_flush,

    };

    printf("Sending %d %s requests, %d bytes each, %d in parallel "

           "(starting at offset %" PRId64 ", step size %d)\n",

           data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,

           data.offset, data.step);

    if (flush_interval) {

        printf("Sending flush every %d requests\n", flush_interval);

    }



    data.buf = blk_blockalign(blk, data.nrreq * data.bufsize);

    memset(data.buf, pattern, data.nrreq * data.bufsize);



    data.qiov = g_new(QEMUIOVector, data.nrreq);

    for (i = 0; i < data.nrreq; i++) {

        qemu_iovec_init(&data.qiov[i], 1);

        qemu_iovec_add(&data.qiov[i],

                       data.buf + i * data.bufsize, data.bufsize);

    }



    gettimeofday(&t1, NULL);

    bench_cb(&data, 0);



    while (data.n > 0) {

        main_loop_wait(false);

    }

    gettimeofday(&t2, NULL);



    printf("Run completed in %3.3f seconds.\n",

           (t2.tv_sec - t1.tv_sec)

           + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));



out:

    qemu_vfree(data.buf);

    blk_unref(blk);



    if (ret) {

        return 1;

    }

    return 0;

}

static int img_bench(int argc, char **argv)

{

    int c, ret = 0;

    const char *fmt = NULL, *filename;

    bool quiet = false;

    bool image_opts = false;

    bool is_write = false;

    int count = 75000;

    int depth = 64;

    int64_t offset = 0;

    size_t bufsize = 4096;

    int pattern = 0;

    size_t step = 0;

    int flush_interval = 0;

    bool drain_on_flush = true;

    int64_t image_size;

    BlockBackend *blk = NULL;

    BenchData data = {};

    int flags = 0;

    bool writethrough = false;

    struct timeval t1, t2;

    int i;



    for (;;) {

        static const struct option long_options[] = {

            {"help", no_argument, 0, 'h'},

            {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},

            {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},

            {"pattern", required_argument, 0, OPTION_PATTERN},

            {"no-drain", no_argument, 0, OPTION_NO_DRAIN},

            {0, 0, 0, 0}

        };

        c = getopt_long(argc, argv, "hc:d:f:no:qs:S:t:w", long_options, NULL);

        if (c == -1) {

            break;

        }



        switch (c) {

        case 'h':

        case '?':

            help();

            break;

        case 'c':

        {

            unsigned long res;



            if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

                error_report("Invalid request count specified");

                return 1;

            }

            count = res;

            break;

        }

        case 'd':

        {

            unsigned long res;



            if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

                error_report("Invalid queue depth specified");

                return 1;

            }

            depth = res;

            break;

        }

        case 'f':

            fmt = optarg;

            break;

        case 'n':

            flags |= BDRV_O_NATIVE_AIO;

            break;

        case 'o':

        {

            offset = cvtnum(optarg);

            if (offset < 0) {

                error_report("Invalid offset specified");

                return 1;

            }

            break;

        }

            break;

        case 'q':

            quiet = true;

            break;

        case 's':

        {

            int64_t sval;



            sval = cvtnum(optarg);

            if (sval < 0 || sval > INT_MAX) {

                error_report("Invalid buffer size specified");

                return 1;

            }



            bufsize = sval;

            break;

        }

        case 'S':

        {

            int64_t sval;



            sval = cvtnum(optarg);

            if (sval < 0 || sval > INT_MAX) {

                error_report("Invalid step size specified");

                return 1;

            }



            step = sval;

            break;

        }

        case 't':

            ret = bdrv_parse_cache_mode(optarg, &flags, &writethrough);

            if (ret < 0) {

                error_report("Invalid cache mode");

                ret = -1;

                goto out;

            }

            break;

        case 'w':

            flags |= BDRV_O_RDWR;

            is_write = true;

            break;

        case OPTION_PATTERN:

        {

            unsigned long res;



            if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {

                error_report("Invalid pattern byte specified");

                return 1;

            }

            pattern = res;

            break;

        }

        case OPTION_FLUSH_INTERVAL:

        {

            unsigned long res;



            if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {

                error_report("Invalid flush interval specified");

                return 1;

            }

            flush_interval = res;

            break;

        }

        case OPTION_NO_DRAIN:

            drain_on_flush = false;

            break;

        case OPTION_IMAGE_OPTS:

            image_opts = true;

            break;

        }

    }



    if (optind != argc - 1) {

        error_exit("Expecting one image file name");

    }

    filename = argv[argc - 1];



    if (!is_write && flush_interval) {

        error_report("--flush-interval is only available in write tests");

        ret = -1;

        goto out;

    }

    if (flush_interval && flush_interval < depth) {

        error_report("Flush interval can't be smaller than depth");

        ret = -1;

        goto out;

    }



    blk = img_open(image_opts, filename, fmt, flags, writethrough, quiet);

    if (!blk) {

        ret = -1;

        goto out;

    }



    image_size = blk_getlength(blk);

    if (image_size < 0) {

        ret = image_size;

        goto out;

    }



    data = (BenchData) {

        .blk            = blk,

        .image_size     = image_size,

        .bufsize        = bufsize,

        .step           = step ?: bufsize,

        .nrreq          = depth,

        .n              = count,

        .offset         = offset,

        .write          = is_write,

        .flush_interval = flush_interval,

        .drain_on_flush = drain_on_flush,

    };

    printf("Sending %d %s requests, %d bytes each, %d in parallel "

           "(starting at offset %" PRId64 ", step size %d)\n",

           data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,

           data.offset, data.step);

    if (flush_interval) {

        printf("Sending flush every %d requests\n", flush_interval);

    }



    data.buf = blk_blockalign(blk, data.nrreq * data.bufsize);

    memset(data.buf, pattern, data.nrreq * data.bufsize);



    data.qiov = g_new(QEMUIOVector, data.nrreq);

    for (i = 0; i < data.nrreq; i++) {

        qemu_iovec_init(&data.qiov[i], 1);

        qemu_iovec_add(&data.qiov[i],

                       data.buf + i * data.bufsize, data.bufsize);

    }



    gettimeofday(&t1, NULL);

    bench_cb(&data, 0);



    while (data.n > 0) {

        main_loop_wait(false);

    }

    gettimeofday(&t2, NULL);



    printf("Run completed in %3.3f seconds.\n",

           (t2.tv_sec - t1.tv_sec)

           + ((double)(t2.tv_usec - t1.tv_usec) / 1000000));



out:

    qemu_vfree(data.buf);

    blk_unref(blk);



    if (ret) {

        return 1;

    }

    return 0;

}

        case 'h':         c = getopt_long(argc, argv, "hc:d:f:no:qs:S:t:w", long_options, NULL);         case 'h':         case 'h':
static int FUNC_0(int VAR_0, char **VAR_1)

{

    int VAR_2, VAR_3 = 0;

    const char *VAR_4 = NULL, *VAR_5;

    bool quiet = false;

    bool image_opts = false;

    bool is_write = false;

    int VAR_6 = 75000;

    int VAR_7 = 64;

    int64_t offset = 0;

    size_t bufsize = 4096;

    int VAR_8 = 0;

    size_t step = 0;

    int VAR_9 = 0;

    bool drain_on_flush = true;

    int64_t image_size;

    BlockBackend *blk = NULL;

    BenchData data = {};

    int VAR_10 = 0;

    bool writethrough = false;

    struct timeval VAR_11, VAR_12;

    int VAR_13;



    for (;;) {

        static const struct option VAR_14[] = {

            {"help", no_argument, 0, 'h'},

            {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL},

            {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS},

            {"VAR_8", required_argument, 0, OPTION_PATTERN},

            {"no-drain", no_argument, 0, OPTION_NO_DRAIN},

            {0, 0, 0, 0}

        };

        VAR_2 = getopt_long(VAR_0, VAR_1, "hc:d:f:no:qs:S:t:w", VAR_14, NULL);

        if (VAR_2 == -1) {

            break;

        }



        switch (VAR_2) {

        case 'h':

        case '?':

            help();

            break;

        case 'VAR_2':

        {

            unsigned long VAR_16;



            if (qemu_strtoul(optarg, NULL, 0, &VAR_16) < 0 || VAR_16 > INT_MAX) {

                error_report("Invalid request VAR_6 specified");

                return 1;

            }

            VAR_6 = VAR_16;

            break;

        }

        case 'd':

        {

            unsigned long VAR_16;



            if (qemu_strtoul(optarg, NULL, 0, &VAR_16) < 0 || VAR_16 > INT_MAX) {

                error_report("Invalid queue VAR_7 specified");

                return 1;

            }

            VAR_7 = VAR_16;

            break;

        }

        case 'f':

            VAR_4 = optarg;

            break;

        case 'n':

            VAR_10 |= BDRV_O_NATIVE_AIO;

            break;

        case 'o':

        {

            offset = cvtnum(optarg);

            if (offset < 0) {

                error_report("Invalid offset specified");

                return 1;

            }

            break;

        }

            break;

        case 'q':

            quiet = true;

            break;

        case 's':

        {

            int64_t sval;



            sval = cvtnum(optarg);

            if (sval < 0 || sval > INT_MAX) {

                error_report("Invalid buffer size specified");

                return 1;

            }



            bufsize = sval;

            break;

        }

        case 'S':

        {

            int64_t sval;



            sval = cvtnum(optarg);

            if (sval < 0 || sval > INT_MAX) {

                error_report("Invalid step size specified");

                return 1;

            }



            step = sval;

            break;

        }

        case 't':

            VAR_3 = bdrv_parse_cache_mode(optarg, &VAR_10, &writethrough);

            if (VAR_3 < 0) {

                error_report("Invalid cache mode");

                VAR_3 = -1;

                goto out;

            }

            break;

        case 'w':

            VAR_10 |= BDRV_O_RDWR;

            is_write = true;

            break;

        case OPTION_PATTERN:

        {

            unsigned long VAR_16;



            if (qemu_strtoul(optarg, NULL, 0, &VAR_16) < 0 || VAR_16 > 0xff) {

                error_report("Invalid VAR_8 byte specified");

                return 1;

            }

            VAR_8 = VAR_16;

            break;

        }

        case OPTION_FLUSH_INTERVAL:

        {

            unsigned long VAR_16;



            if (qemu_strtoul(optarg, NULL, 0, &VAR_16) < 0 || VAR_16 > INT_MAX) {

                error_report("Invalid flush interval specified");

                return 1;

            }

            VAR_9 = VAR_16;

            break;

        }

        case OPTION_NO_DRAIN:

            drain_on_flush = false;

            break;

        case OPTION_IMAGE_OPTS:

            image_opts = true;

            break;

        }

    }



    if (optind != VAR_0 - 1) {

        error_exit("Expecting one image file name");

    }

    VAR_5 = VAR_1[VAR_0 - 1];



    if (!is_write && VAR_9) {

        error_report("--flush-interval is only available in write tests");

        VAR_3 = -1;

        goto out;

    }

    if (VAR_9 && VAR_9 < VAR_7) {

        error_report("Flush interval can't be smaller than VAR_7");

        VAR_3 = -1;

        goto out;

    }



    blk = img_open(image_opts, VAR_5, VAR_4, VAR_10, writethrough, quiet);

    if (!blk) {

        VAR_3 = -1;

        goto out;

    }



    image_size = blk_getlength(blk);

    if (image_size < 0) {

        VAR_3 = image_size;

        goto out;

    }



    data = (BenchData) {

        .blk            = blk,

        .image_size     = image_size,

        .bufsize        = bufsize,

        .step           = step ?: bufsize,

        .nrreq          = VAR_7,

        .n              = VAR_6,

        .offset         = offset,

        .write          = is_write,

        .VAR_9 = VAR_9,

        .drain_on_flush = drain_on_flush,

    };

    printf("Sending %d %s requests, %d bytes each, %d in parallel "

           "(starting at offset %" PRId64 ", step size %d)\n",

           data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,

           data.offset, data.step);

    if (VAR_9) {

        printf("Sending flush every %d requests\n", VAR_9);

    }



    data.buf = blk_blockalign(blk, data.nrreq * data.bufsize);

    memset(data.buf, VAR_8, data.nrreq * data.bufsize);



    data.qiov = g_new(QEMUIOVector, data.nrreq);

    for (VAR_13 = 0; VAR_13 < data.nrreq; VAR_13++) {

        qemu_iovec_init(&data.qiov[VAR_13], 1);

        qemu_iovec_add(&data.qiov[VAR_13],

                       data.buf + VAR_13 * data.bufsize, data.bufsize);

    }



    gettimeofday(&VAR_11, NULL);

    bench_cb(&data, 0);



    while (data.n > 0) {

        main_loop_wait(false);

    }

    gettimeofday(&VAR_12, NULL);



    printf("Run completed in %3.3f seconds.\n",

           (VAR_12.tv_sec - VAR_11.tv_sec)

           + ((double)(VAR_12.tv_usec - VAR_11.tv_usec) / 1000000));



out:

    qemu_vfree(data.buf);

    blk_unref(blk);



    if (VAR_3) {

        return 1;

    }

    return 0;

}

static int FUNC_0(int VAR_0, char **VAR_1)
{ int VAR_2, VAR_3 = 0; const char *VAR_4 = NULL, *VAR_5; bool quiet = false; bool image_opts = false; bool is_write = false; int VAR_6 = 75000; int VAR_7 = 64; int64_t offset = 0; size_t bufsize = 4096; int VAR_8 = 0; size_t step = 0; int VAR_9 = 0; bool drain_on_flush = true; int64_t image_size; BlockBackend *blk = NULL; BenchData data = {}; int VAR_10 = 0; bool writethrough = false; struct timeval VAR_11, VAR_12; int VAR_13; for (;;) { static const struct option VAR_14[] = { {"help", no_argument, 0, 'h'}, {"flush-interval", required_argument, 0, OPTION_FLUSH_INTERVAL}, {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, {"VAR_8", required_argument, 0, OPTION_PATTERN}, {"no-drain", no_argument, 0, OPTION_NO_DRAIN}, {0, 0, 0, 0} }; VAR_2 = getopt_long(VAR_0, VAR_1, "hc:d:f:no:qs:S:t:w", VAR_14, NULL); if (VAR_2 == -1) { break; } switch (VAR_2) { case 'h':
case '?':
help(); break; case 'VAR_2':
{ unsigned long VAR_16; if (qemu_strtoul(optarg, NULL, 0, &VAR_16) < 0 || VAR_16 > INT_MAX) { error_report("Invalid request VAR_6 specified"); return 1; } VAR_6 = VAR_16; break; } case 'd':
{ unsigned long VAR_16; if (qemu_strtoul(optarg, NULL, 0, &VAR_16) < 0 || VAR_16 > INT_MAX) { error_report("Invalid queue VAR_7 specified"); return 1; } VAR_7 = VAR_16; break; } case 'f':
VAR_4 = optarg; break; case 'n':
VAR_10 |= BDRV_O_NATIVE_AIO; break; case 'o':
{ offset = cvtnum(optarg); if (offset < 0) { error_report("Invalid offset specified"); return 1; } break; } break; case 'q':
quiet = true; break; case 's':
{ int64_t sval; sval = cvtnum(optarg); if (sval < 0 || sval > INT_MAX) { error_report("Invalid buffer size specified"); return 1; } bufsize = sval; break; } case 'S':
{ int64_t sval; sval = cvtnum(optarg); if (sval < 0 || sval > INT_MAX) { error_report("Invalid step size specified"); return 1; } step = sval; break; } case 't':
VAR_3 = bdrv_parse_cache_mode(optarg, &VAR_10, &writethrough); if (VAR_3 < 0) { error_report("Invalid cache mode"); VAR_3 = -1; goto out; } break; case 'w':
VAR_10 |= BDRV_O_RDWR; is_write = true; break; case OPTION_PATTERN:
{ unsigned long VAR_16; if (qemu_strtoul(optarg, NULL, 0, &VAR_16) < 0 || VAR_16 > 0xff) { error_report("Invalid VAR_8 byte specified"); return 1; } VAR_8 = VAR_16; break; } case OPTION_FLUSH_INTERVAL:
{ unsigned long VAR_16; if (qemu_strtoul(optarg, NULL, 0, &VAR_16) < 0 || VAR_16 > INT_MAX) { error_report("Invalid flush interval specified"); return 1; } VAR_9 = VAR_16; break; } case OPTION_NO_DRAIN:
drain_on_flush = false; break; case OPTION_IMAGE_OPTS:
image_opts = true; break; } } if (optind != VAR_0 - 1) { error_exit("Expecting one image file name"); } VAR_5 = VAR_1[VAR_0 - 1]; if (!is_write && VAR_9) { error_report("--flush-interval is only available in write tests"); VAR_3 = -1; goto out; } if (VAR_9 && VAR_9 < VAR_7) { error_report("Flush interval can't be smaller than VAR_7"); VAR_3 = -1; goto out; } blk = img_open(image_opts, VAR_5, VAR_4, VAR_10, writethrough, quiet); if (!blk) { VAR_3 = -1; goto out; } image_size = blk_getlength(blk); if (image_size < 0) { VAR_3 = image_size; goto out; } data = (BenchData) { .blk            = blk,
.image_size     = image_size,
.bufsize        = bufsize,
.step           = step ?: bufsize,
.nrreq          = VAR_7,
.n              = VAR_6,
.offset         = offset,
.write          = is_write,
.VAR_9 = VAR_9,
.drain_on_flush = drain_on_flush,
}; printf("Sending %d %s requests, %d bytes each, %d in parallel "
"(starting at offset %" PRId64 ", step size %d)\n",
data.n, data.write ? "write" : "read", data.bufsize, data.nrreq,
data.offset, data.step); if (VAR_9) { printf("Sending flush every %d requests\n", VAR_9); } data.buf = blk_blockalign(blk, data.nrreq * data.bufsize); memset(data.buf, VAR_8, data.nrreq * data.bufsize); data.qiov = g_new(QEMUIOVector, data.nrreq); for (VAR_13 = 0; VAR_13 < data.nrreq; VAR_13++) { qemu_iovec_init(&data.qiov[VAR_13], 1); qemu_iovec_add(&data.qiov[VAR_13],
data.buf + VAR_13 * data.bufsize, data.bufsize); } gettimeofday(&VAR_11, NULL); bench_cb(&data, 0); while (data.n > 0) { main_loop_wait(false); } gettimeofday(&VAR_12, NULL); printf("Run completed in %3.3f seconds.\n",
(VAR_12.tv_sec - VAR_11.tv_sec)
+ ((double)(VAR_12.tv_usec - VAR_11.tv_usec) / 1000000)); out:
qemu_vfree(data.buf); blk_unref(blk); if (VAR_3) { return 1; } return 0; }