Commit 864a556e authored by Anthony Liguori's avatar Anthony Liguori
Browse files

Merge remote-tracking branch 'kwolf/for-anthony' into staging 

# By Paolo Bonzini (7) and others
# Via Kevin Wolf
* kwolf/for-anthony: (22 commits)
  pc: add compatibility machine types for 1.4
  blockdev: enable discard by default
  qemu-nbd: add --discard option
  blockdev: add discard suboption to -drive
  block: implement BDRV_O_UNMAP
  block: complete all IOs before .bdrv_truncate
  coroutine: trim down nesting level in perf_nesting test
  coroutine: move pooling to common code
  qemu-iotests: Test qcow2 image creation options
  qemu-iotests: Add qemu-img compare test
  qemu-img: Add compare subcommand
  qemu-img: Add "Quiet mode" option
  block: Add synchronous wrapper for bdrv_co_is_allocated_above
  block: refuse negative iops and bps values
  block: use Error in do_check_io_limits()
  qcow2: support compressed clusters in BlockFragInfo
  qemu-img: add compressed clusters to BlockFragInfo
  qemu-img: fix missing space in qemu-img check output
  qcow2: record fragmentation statistics during check
  qcow2: introduce check_refcounts_l1/l2() flags
  ...
parents 9a1d7f00 bf3caa3d

block.c

+75 −5
Original line number Diff line number Diff line
@@ -580,6 +580,26 @@ static int refresh_total_sectors(BlockDriverState *bs, int64_t hint) 
    return 0;

}



/**

 * Set open flags for a given discard mode

 *

 * Return 0 on success, -1 if the discard mode was invalid.

 */

int bdrv_parse_discard_flags(const char *mode, int *flags)

{

    *flags &= ~BDRV_O_UNMAP;



    if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) {

        /* do nothing */

    } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) {

        *flags |= BDRV_O_UNMAP;

    } else {

        return -1;

    }



    return 0;

}



/**

 * Set open flags for a given cache mode

 *
@@ -2427,6 +2447,10 @@ int bdrv_truncate(BlockDriverState *bs, int64_t offset) 
        return -EACCES;

    if (bdrv_in_use(bs))

        return -EBUSY;



    /* There better not be any in-flight IOs when we truncate the device. */

    bdrv_drain_all();



    ret = drv->bdrv_truncate(bs, offset);

    if (ret == 0) {

        ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
@@ -2681,6 +2705,7 @@ int bdrv_has_zero_init(BlockDriverState *bs) 


typedef struct BdrvCoIsAllocatedData {

    BlockDriverState *bs;

    BlockDriverState *base;

    int64_t sector_num;

    int nb_sectors;

    int *pnum;
@@ -2813,6 +2838,44 @@ int coroutine_fn bdrv_co_is_allocated_above(BlockDriverState *top, 
    return 0;

}



/* Coroutine wrapper for bdrv_is_allocated_above() */

static void coroutine_fn bdrv_is_allocated_above_co_entry(void *opaque)

{

    BdrvCoIsAllocatedData *data = opaque;

    BlockDriverState *top = data->bs;

    BlockDriverState *base = data->base;



    data->ret = bdrv_co_is_allocated_above(top, base, data->sector_num,

                                           data->nb_sectors, data->pnum);

    data->done = true;

}



/*

 * Synchronous wrapper around bdrv_co_is_allocated_above().

 *

 * See bdrv_co_is_allocated_above() for details.

 */

int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,

                            int64_t sector_num, int nb_sectors, int *pnum)

{

    Coroutine *co;

    BdrvCoIsAllocatedData data = {

        .bs = top,

        .base = base,

        .sector_num = sector_num,

        .nb_sectors = nb_sectors,

        .pnum = pnum,

        .done = false,

    };



    co = qemu_coroutine_create(bdrv_is_allocated_above_co_entry);

    qemu_coroutine_enter(co, &data);

    while (!data.done) {

        qemu_aio_wait();

    }

    return data.ret;

}



BlockInfo *bdrv_query_info(BlockDriverState *bs)

{

    BlockInfo *info = g_malloc0(sizeof(*info));
@@ -4148,6 +4211,11 @@ int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, 
        bdrv_reset_dirty(bs, sector_num, nb_sectors);

    }



    /* Do nothing if disabled.  */

    if (!(bs->open_flags & BDRV_O_UNMAP)) {

        return 0;

    }



    if (bs->drv->bdrv_co_discard) {

        return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors);

    } else if (bs->drv->bdrv_aio_discard) {
@@ -4431,7 +4499,8 @@ bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie) 


void bdrv_img_create(const char *filename, const char *fmt,

                     const char *base_filename, const char *base_fmt,

                     char *options, uint64_t img_size, int flags, Error **errp)

                     char *options, uint64_t img_size, int flags,

                     Error **errp, bool quiet)

{

    QEMUOptionParameter *param = NULL, *create_options = NULL;

    QEMUOptionParameter *backing_fmt, *backing_file, *size;
@@ -4540,10 +4609,11 @@ void bdrv_img_create(const char *filename, const char *fmt, 
        }

    }



    if (!quiet) {

        printf("Formatting '%s', fmt=%s ", filename, fmt);

        print_option_parameters(param);

        puts("");



    }

    ret = bdrv_create(drv, filename, param);

    if (ret < 0) {

        if (ret == -ENOTSUP) {

block/qcow2-refcount.c

+44 −8
Original line number Diff line number Diff line
@@ -914,6 +914,12 @@ static void inc_refcounts(BlockDriverState *bs, 
    }

}



/* Flags for check_refcounts_l1() and check_refcounts_l2() */

enum {

    CHECK_OFLAG_COPIED = 0x1,   /* check QCOW_OFLAG_COPIED matches refcount */

    CHECK_FRAG_INFO = 0x2,      /* update BlockFragInfo counters */

};



/*

 * Increases the refcount in the given refcount table for the all clusters

 * referenced in the L2 table. While doing so, performs some checks on L2
@@ -924,10 +930,11 @@ static void inc_refcounts(BlockDriverState *bs, 
 */

static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,

    uint16_t *refcount_table, int refcount_table_size, int64_t l2_offset,

    int check_copied)

    int flags)

{

    BDRVQcowState *s = bs->opaque;

    uint64_t *l2_table, l2_entry;

    uint64_t next_contiguous_offset = 0;

    int i, l2_size, nb_csectors, refcount;



    /* Read L2 table from disk */
@@ -958,6 +965,18 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res, 
            l2_entry &= s->cluster_offset_mask;

            inc_refcounts(bs, res, refcount_table, refcount_table_size,

                l2_entry & ~511, nb_csectors * 512);



            if (flags & CHECK_FRAG_INFO) {

                res->bfi.allocated_clusters++;

                res->bfi.compressed_clusters++;



                /* Compressed clusters are fragmented by nature.  Since they

                 * take up sub-sector space but we only have sector granularity

                 * I/O we need to re-read the same sectors even for adjacent

                 * compressed clusters.

                 */

                res->bfi.fragmented_clusters++;

            }

            break;



        case QCOW2_CLUSTER_ZERO:
@@ -971,7 +990,7 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res, 
            /* QCOW_OFLAG_COPIED must be set iff refcount == 1 */

            uint64_t offset = l2_entry & L2E_OFFSET_MASK;



            if (check_copied) {

            if (flags & CHECK_OFLAG_COPIED) {

                refcount = get_refcount(bs, offset >> s->cluster_bits);

                if (refcount < 0) {

                    fprintf(stderr, "Can't get refcount for offset %"
@@ -985,6 +1004,15 @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res, 
                }

            }



            if (flags & CHECK_FRAG_INFO) {

                res->bfi.allocated_clusters++;

                if (next_contiguous_offset &&

                    offset != next_contiguous_offset) {

                    res->bfi.fragmented_clusters++;

                }

                next_contiguous_offset = offset + s->cluster_size;

            }



            /* Mark cluster as used */

            inc_refcounts(bs, res, refcount_table,refcount_table_size,

                offset, s->cluster_size);
@@ -1028,7 +1056,7 @@ static int check_refcounts_l1(BlockDriverState *bs, 
                              uint16_t *refcount_table,

                              int refcount_table_size,

                              int64_t l1_table_offset, int l1_size,

                              int check_copied)

                              int flags)

{

    BDRVQcowState *s = bs->opaque;

    uint64_t *l1_table, l2_offset, l1_size2;
@@ -1057,7 +1085,7 @@ static int check_refcounts_l1(BlockDriverState *bs, 
        l2_offset = l1_table[i];

        if (l2_offset) {

            /* QCOW_OFLAG_COPIED must be set iff refcount == 1 */

            if (check_copied) {

            if (flags & CHECK_OFLAG_COPIED) {

                refcount = get_refcount(bs, (l2_offset & ~QCOW_OFLAG_COPIED)

                    >> s->cluster_bits);

                if (refcount < 0) {
@@ -1086,7 +1114,7 @@ static int check_refcounts_l1(BlockDriverState *bs, 


            /* Process and check L2 entries */

            ret = check_refcounts_l2(bs, res, refcount_table,

                refcount_table_size, l2_offset, check_copied);

                                     refcount_table_size, l2_offset, flags);

            if (ret < 0) {

                goto fail;

            }
@@ -1112,7 +1140,7 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, 
                          BdrvCheckMode fix)

{

    BDRVQcowState *s = bs->opaque;

    int64_t size, i;

    int64_t size, i, highest_cluster;

    int nb_clusters, refcount1, refcount2;

    QCowSnapshot *sn;

    uint16_t *refcount_table;
@@ -1120,6 +1148,7 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, 


    size = bdrv_getlength(bs->file);

    nb_clusters = size_to_clusters(s, size);

    res->bfi.total_clusters = nb_clusters;

    refcount_table = g_malloc0(nb_clusters * sizeof(uint16_t));



    /* header */
@@ -1128,7 +1157,8 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, 


    /* current L1 table */

    ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,

                       s->l1_table_offset, s->l1_size, 1);

                             s->l1_table_offset, s->l1_size,

                             CHECK_OFLAG_COPIED | CHECK_FRAG_INFO);

    if (ret < 0) {

        goto fail;

    }
@@ -1183,7 +1213,7 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, 
    }



    /* compare ref counts */

    for(i = 0; i < nb_clusters; i++) {

    for (i = 0, highest_cluster = 0; i < nb_clusters; i++) {

        refcount1 = get_refcount(bs, i);

        if (refcount1 < 0) {

            fprintf(stderr, "Can't get refcount for cluster %" PRId64 ": %s\n",
@@ -1193,6 +1223,11 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, 
        }



        refcount2 = refcount_table[i];



        if (refcount1 > 0 || refcount2 > 0) {

            highest_cluster = i;

        }



        if (refcount1 != refcount2) {



            /* Check if we're allowed to fix the mismatch */
@@ -1227,6 +1262,7 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, 
        }

    }



    res->image_end_offset = (highest_cluster + 1) * s->cluster_size;

    ret = 0;



fail:

blockdev.c

+32 −9
Original line number Diff line number Diff line
@@ -255,7 +255,7 @@ static int parse_block_error_action(const char *buf, bool is_read) 
    }

}



static bool do_check_io_limits(BlockIOLimit *io_limits)

static bool do_check_io_limits(BlockIOLimit *io_limits, Error **errp)

{

    bool bps_flag;

    bool iops_flag;
@@ -269,6 +269,18 @@ static bool do_check_io_limits(BlockIOLimit *io_limits) 
                 && ((io_limits->iops[BLOCK_IO_LIMIT_READ] != 0)

                 || (io_limits->iops[BLOCK_IO_LIMIT_WRITE] != 0));

    if (bps_flag || iops_flag) {

        error_setg(errp, "bps(iops) and bps_rd/bps_wr(iops_rd/iops_wr) "

                         "cannot be used at the same time");

        return false;

    }



    if (io_limits->bps[BLOCK_IO_LIMIT_TOTAL] < 0 ||

        io_limits->bps[BLOCK_IO_LIMIT_WRITE] < 0 ||

        io_limits->bps[BLOCK_IO_LIMIT_READ] < 0 ||

        io_limits->iops[BLOCK_IO_LIMIT_TOTAL] < 0 ||

        io_limits->iops[BLOCK_IO_LIMIT_WRITE] < 0 ||

        io_limits->iops[BLOCK_IO_LIMIT_READ] < 0) {

        error_setg(errp, "bps and iops values must be 0 or greater");

        return false;

    }
@@ -297,6 +309,7 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type) 
    int snapshot = 0;

    bool copy_on_read;

    int ret;

    Error *error = NULL;



    translation = BIOS_ATA_TRANSLATION_AUTO;

    media = MEDIA_DISK;
@@ -378,6 +391,13 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type) 
	}

    }



    if ((buf = qemu_opt_get(opts, "discard")) != NULL) {

        if (bdrv_parse_discard_flags(buf, &bdrv_flags) != 0) {

            error_report("invalid discard option");

            return NULL;

        }

    }



    bdrv_flags |= BDRV_O_CACHE_WB;

    if ((buf = qemu_opt_get(opts, "cache")) != NULL) {

        if (bdrv_parse_cache_flags(buf, &bdrv_flags) != 0) {
@@ -427,9 +447,9 @@ DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type) 
    io_limits.iops[BLOCK_IO_LIMIT_WRITE] =

                           qemu_opt_get_number(opts, "iops_wr", 0);



    if (!do_check_io_limits(&io_limits)) {

        error_report("bps(iops) and bps_rd/bps_wr(iops_rd/iops_wr) "

                     "cannot be used at the same time");

    if (!do_check_io_limits(&io_limits, &error)) {

        error_report("%s", error_get_pretty(error));

        error_free(error);

        return NULL;

    }
@@ -791,7 +811,7 @@ void qmp_transaction(BlockdevActionList *dev_list, Error **errp) 
            bdrv_img_create(new_image_file, format,

                            states->old_bs->filename,

                            states->old_bs->drv->format_name,

                            NULL, -1, flags, &local_err);

                            NULL, -1, flags, &local_err, false);

            if (error_is_set(&local_err)) {

                error_propagate(errp, local_err);

                goto delete_and_fail;
@@ -975,8 +995,7 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, 
    io_limits.iops[BLOCK_IO_LIMIT_READ] = iops_rd;

    io_limits.iops[BLOCK_IO_LIMIT_WRITE]= iops_wr;



    if (!do_check_io_limits(&io_limits)) {

        error_set(errp, QERR_INVALID_PARAMETER_COMBINATION);

    if (!do_check_io_limits(&io_limits, errp)) {

        return;

    }
@@ -1284,7 +1303,7 @@ void qmp_drive_mirror(const char *device, const char *target, 
        /* create new image w/o backing file */

        assert(format && drv);

        bdrv_img_create(target, format,

                        NULL, NULL, NULL, size, flags, &local_err);

                        NULL, NULL, NULL, size, flags, &local_err, false);

    } else {

        switch (mode) {

        case NEW_IMAGE_MODE_EXISTING:
@@ -1295,7 +1314,7 @@ void qmp_drive_mirror(const char *device, const char *target, 
            bdrv_img_create(target, format,

                            source->filename,

                            source->drv->format_name,

                            NULL, size, flags, &local_err);

                            NULL, size, flags, &local_err, false);

            break;

        default:

            abort();
@@ -1488,6 +1507,10 @@ QemuOptsList qemu_drive_opts = { 
            .name = "file",

            .type = QEMU_OPT_STRING,

            .help = "disk image",

        },{

            .name = "discard",

            .type = QEMU_OPT_STRING,

            .help = "discard operation (ignore/off, unmap/on)",

        },{

            .name = "cache",

            .type = QEMU_OPT_STRING,

coroutine-sigaltstack.c

+1 −42
Original line number Diff line number Diff line
@@ -33,15 +33,6 @@ 
#include "qemu-common.h"

#include "block/coroutine_int.h"



enum {

    /* Maximum free pool size prevents holding too many freed coroutines */

    POOL_MAX_SIZE = 64,

};



/** Free list to speed up creation */

static QSLIST_HEAD(, Coroutine) pool = QSLIST_HEAD_INITIALIZER(pool);

static unsigned int pool_size;



typedef struct {

    Coroutine base;

    void *stack;
@@ -85,17 +76,6 @@ static void qemu_coroutine_thread_cleanup(void *opaque) 
    g_free(s);

}



static void __attribute__((destructor)) coroutine_cleanup(void)

{

    Coroutine *co;

    Coroutine *tmp;



    QSLIST_FOREACH_SAFE(co, &pool, pool_next, tmp) {

        g_free(DO_UPCAST(CoroutineUContext, base, co)->stack);

        g_free(co);

    }

}



static void __attribute__((constructor)) coroutine_init(void)

{

    int ret;
@@ -164,7 +144,7 @@ static void coroutine_trampoline(int signal) 
    coroutine_bootstrap(self, co);

}



static Coroutine *coroutine_new(void)

Coroutine *qemu_coroutine_new(void)

{

    const size_t stack_size = 1 << 20;

    CoroutineUContext *co;
@@ -272,31 +252,10 @@ static Coroutine *coroutine_new(void) 
    return &co->base;

}



Coroutine *qemu_coroutine_new(void)

{

    Coroutine *co;



    co = QSLIST_FIRST(&pool);

    if (co) {

        QSLIST_REMOVE_HEAD(&pool, pool_next);

        pool_size--;

    } else {

        co = coroutine_new();

    }

    return co;

}



void qemu_coroutine_delete(Coroutine *co_)

{

    CoroutineUContext *co = DO_UPCAST(CoroutineUContext, base, co_);



    if (pool_size < POOL_MAX_SIZE) {

        QSLIST_INSERT_HEAD(&pool, &co->base, pool_next);

        co->base.caller = NULL;

        pool_size++;

        return;

    }



    g_free(co->stack);

    g_free(co);

}

coroutine-ucontext.c

+1 −42
Original line number Diff line number Diff line
@@ -34,15 +34,6 @@ 
#include <valgrind/valgrind.h>

#endif



enum {

    /* Maximum free pool size prevents holding too many freed coroutines */

    POOL_MAX_SIZE = 64,

};



/** Free list to speed up creation */

static QSLIST_HEAD(, Coroutine) pool = QSLIST_HEAD_INITIALIZER(pool);

static unsigned int pool_size;



typedef struct {

    Coroutine base;

    void *stack;
@@ -96,17 +87,6 @@ static void qemu_coroutine_thread_cleanup(void *opaque) 
    g_free(s);

}



static void __attribute__((destructor)) coroutine_cleanup(void)

{

    Coroutine *co;

    Coroutine *tmp;



    QSLIST_FOREACH_SAFE(co, &pool, pool_next, tmp) {

        g_free(DO_UPCAST(CoroutineUContext, base, co)->stack);

        g_free(co);

    }

}



static void __attribute__((constructor)) coroutine_init(void)

{

    int ret;
@@ -140,7 +120,7 @@ static void coroutine_trampoline(int i0, int i1) 
    }

}



static Coroutine *coroutine_new(void)

Coroutine *qemu_coroutine_new(void)

{

    const size_t stack_size = 1 << 20;

    CoroutineUContext *co;
@@ -186,20 +166,6 @@ static Coroutine *coroutine_new(void) 
    return &co->base;

}



Coroutine *qemu_coroutine_new(void)

{

    Coroutine *co;



    co = QSLIST_FIRST(&pool);

    if (co) {

        QSLIST_REMOVE_HEAD(&pool, pool_next);

        pool_size--;

    } else {

        co = coroutine_new();

    }

    return co;

}



#ifdef CONFIG_VALGRIND_H

#ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE

/* Work around an unused variable in the valgrind.h macro... */
@@ -218,13 +184,6 @@ void qemu_coroutine_delete(Coroutine *co_) 
{

    CoroutineUContext *co = DO_UPCAST(CoroutineUContext, base, co_);



    if (pool_size < POOL_MAX_SIZE) {

        QSLIST_INSERT_HEAD(&pool, &co->base, pool_next);

        co->base.caller = NULL;

        pool_size++;

        return;

    }



#ifdef CONFIG_VALGRIND_H

    valgrind_stack_deregister(co);

#endif