Commit 5839e53b authored by Markus Armbruster's avatar Markus Armbruster Committed by Kevin Wolf
Browse files

block: Use g_new() & friends where that makes obvious sense 



g_new(T, n) is neater than g_malloc(sizeof(T) * n).  It's also safer,
for two reasons.  One, it catches multiplication overflowing size_t.
Two, it returns T * rather than void *, which lets the compiler catch
more type errors.

Patch created with Coccinelle, with two manual changes on top:

* Add const to bdrv_iterate_format() to keep the types straight

* Convert the allocation in bdrv_drop_intermediate(), which Coccinelle
  inexplicably misses

Coccinelle semantic patch:

    @@
    type T;
    @@
    -g_malloc(sizeof(T))
    +g_new(T, 1)
    @@
    type T;
    @@
    -g_try_malloc(sizeof(T))
    +g_try_new(T, 1)
    @@
    type T;
    @@
    -g_malloc0(sizeof(T))
    +g_new0(T, 1)
    @@
    type T;
    @@
    -g_try_malloc0(sizeof(T))
    +g_try_new0(T, 1)
    @@
    type T;
    expression n;
    @@
    -g_malloc(sizeof(T) * (n))
    +g_new(T, n)
    @@
    type T;
    expression n;
    @@
    -g_try_malloc(sizeof(T) * (n))
    +g_try_new(T, n)
    @@
    type T;
    expression n;
    @@
    -g_malloc0(sizeof(T) * (n))
    +g_new0(T, n)
    @@
    type T;
    expression n;
    @@
    -g_try_malloc0(sizeof(T) * (n))
    +g_try_new0(T, n)
    @@
    type T;
    expression p, n;
    @@
    -g_realloc(p, sizeof(T) * (n))
    +g_renew(T, p, n)
    @@
    type T;
    expression p, n;
    @@
    -g_try_realloc(p, sizeof(T) * (n))
    +g_try_renew(T, p, n)

Signed-off-by: default avatarMarkus Armbruster <armbru@redhat.com>
Reviewed-by: default avatarMax Reitz <mreitz@redhat.com>
Reviewed-by: default avatarJeff Cody <jcody@redhat.com>
Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parent 302fa283

block-migration.c

+3 −3
Original line number Diff line number Diff line
@@ -283,7 +283,7 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds) 
        nr_sectors = total_sectors - cur_sector;

    }



    blk = g_malloc(sizeof(BlkMigBlock));

    blk = g_new(BlkMigBlock, 1);

    blk->buf = g_malloc(BLOCK_SIZE);

    blk->bmds = bmds;

    blk->sector = cur_sector;
@@ -354,7 +354,7 @@ static void init_blk_migration_it(void *opaque, BlockDriverState *bs) 
            return;

        }



        bmds = g_malloc0(sizeof(BlkMigDevState));

        bmds = g_new0(BlkMigDevState, 1);

        bmds->bs = bs;

        bmds->bulk_completed = 0;

        bmds->total_sectors = sectors;
@@ -465,7 +465,7 @@ static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds, 
            } else {

                nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;

            }

            blk = g_malloc(sizeof(BlkMigBlock));

            blk = g_new(BlkMigBlock, 1);

            blk->buf = g_malloc(BLOCK_SIZE);

            blk->bmds = bmds;

            blk->sector = sector;

block.c

+7 −7
Original line number Diff line number Diff line
@@ -351,7 +351,7 @@ BlockDriverState *bdrv_new(const char *device_name, Error **errp) 
        return NULL;

    }



    bs = g_malloc0(sizeof(BlockDriverState));

    bs = g_new0(BlockDriverState, 1);

    QLIST_INIT(&bs->dirty_bitmaps);

    pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);

    if (device_name[0] != '\0') {
@@ -2628,7 +2628,7 @@ int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top, 
     * into our deletion queue, until we hit the 'base'

     */

    while (intermediate) {

        intermediate_state = g_malloc0(sizeof(BlkIntermediateStates));

        intermediate_state = g_new0(BlkIntermediateStates, 1);

        intermediate_state->bs = intermediate;

        QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry);
@@ -3755,7 +3755,7 @@ void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 
            }



            if (!found) {

                formats = g_realloc(formats, (count + 1) * sizeof(char *));

                formats = g_renew(const char *, formats, count + 1);

                formats[count++] = drv->format_name;

                it(opaque, drv->format_name);

            }
@@ -5330,7 +5330,7 @@ BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity, 
        errno = -bitmap_size;

        return NULL;

    }

    bitmap = g_malloc0(sizeof(BdrvDirtyBitmap));

    bitmap = g_new0(BdrvDirtyBitmap, 1);

    bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1);

    QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list);

    return bitmap;
@@ -5356,8 +5356,8 @@ BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs) 
    BlockDirtyInfoList **plist = &list;



    QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) {

        BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo));

        BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList));

        BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1);

        BlockDirtyInfoList *entry = g_new0(BlockDirtyInfoList, 1);

        info->count = bdrv_get_dirty_count(bs, bm);

        info->granularity =

            ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap));
@@ -5451,7 +5451,7 @@ void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason) 
    BdrvOpBlocker *blocker;

    assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);



    blocker = g_malloc0(sizeof(BdrvOpBlocker));

    blocker = g_new0(BdrvOpBlocker, 1);

    blocker->reason = reason;

    QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list);

}

block/archipelago.c

+3 −3
Original line number Diff line number Diff line
@@ -750,7 +750,7 @@ static int archipelago_submit_request(BDRVArchipelagoState *s, 
    char *target;

    void *data = NULL;

    struct xseg_request *req;

    AIORequestData *reqdata = g_malloc(sizeof(AIORequestData));

    AIORequestData *reqdata = g_new(AIORequestData, 1);



    targetlen = strlen(s->volname);

    req = xseg_get_request(s->xseg, s->srcport, s->vportno, X_ALLOC);
@@ -827,7 +827,7 @@ static int archipelago_aio_segmented_rw(BDRVArchipelagoState *s, 
    int i, ret, segments_nr, last_segment_size;

    ArchipelagoSegmentedRequest *segreq;



    segreq = g_malloc(sizeof(ArchipelagoSegmentedRequest));

    segreq = g_new(ArchipelagoSegmentedRequest, 1);



    if (op == ARCHIP_OP_FLUSH) {

        segments_nr = 1;
@@ -960,7 +960,7 @@ static int64_t archipelago_volume_info(BDRVArchipelagoState *s) 
    int ret, targetlen;

    struct xseg_request *req;

    struct xseg_reply_info *xinfo;

    AIORequestData *reqdata = g_malloc(sizeof(AIORequestData));

    AIORequestData *reqdata = g_new(AIORequestData, 1);



    const char *volname = s->volname;

    targetlen = strlen(volname);

block/gluster.c

+4 −4
Original line number Diff line number Diff line
@@ -291,7 +291,7 @@ static int qemu_gluster_open(BlockDriverState *bs, QDict *options, 
    BDRVGlusterState *s = bs->opaque;

    int open_flags = 0;

    int ret = 0;

    GlusterConf *gconf = g_malloc0(sizeof(GlusterConf));

    GlusterConf *gconf = g_new0(GlusterConf, 1);

    QemuOpts *opts;

    Error *local_err = NULL;

    const char *filename;
@@ -351,12 +351,12 @@ static int qemu_gluster_reopen_prepare(BDRVReopenState *state, 
    assert(state != NULL);

    assert(state->bs != NULL);



    state->opaque = g_malloc0(sizeof(BDRVGlusterReopenState));

    state->opaque = g_new0(BDRVGlusterReopenState, 1);

    reop_s = state->opaque;



    qemu_gluster_parse_flags(state->flags, &open_flags);



    gconf = g_malloc0(sizeof(GlusterConf));

    gconf = g_new0(GlusterConf, 1);



    reop_s->glfs = qemu_gluster_init(gconf, state->bs->filename, errp);

    if (reop_s->glfs == NULL) {
@@ -486,7 +486,7 @@ static int qemu_gluster_create(const char *filename, 
    int prealloc = 0;

    int64_t total_size = 0;

    char *tmp = NULL;

    GlusterConf *gconf = g_malloc0(sizeof(GlusterConf));

    GlusterConf *gconf = g_new0(GlusterConf, 1);



    glfs = qemu_gluster_init(gconf, filename, errp);

    if (!glfs) {

block/iscsi.c

+1 −1
Original line number Diff line number Diff line
@@ -1532,7 +1532,7 @@ static int iscsi_create(const char *filename, QemuOpts *opts, Error **errp) 
    /* Read out options */

    total_size =

        qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0) / BDRV_SECTOR_SIZE;

    bs->opaque = g_malloc0(sizeof(struct IscsiLun));

    bs->opaque = g_new0(struct IscsiLun, 1);

    iscsilun = bs->opaque;



    bs_options = qdict_new();