Revision 5d757b56

b/block/qcow2-cluster.c
33 33
    BDRVQcowState *s = bs->opaque;
34 34
    int new_l1_size, new_l1_size2, ret, i;
35 35
    uint64_t *new_l1_table;
36
    uint64_t new_l1_table_offset;
36
    int64_t new_l1_table_offset;
37 37
    uint8_t data[12];
38 38

  
39 39
    new_l1_size = s->l1_size;
......
55 55

  
56 56
    /* write new table (align to cluster) */
57 57
    new_l1_table_offset = qcow2_alloc_clusters(bs, new_l1_size2);
58
    if (new_l1_table_offset < 0) {
59
        qemu_free(new_l1_table);
60
        return new_l1_table_offset;
61
    }
58 62

  
59 63
    for(i = 0; i < s->l1_size; i++)
60 64
        new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
......
222 226
    /* allocate a new l2 entry */
223 227

  
224 228
    l2_offset = qcow2_alloc_clusters(bs, s->l2_size * sizeof(uint64_t));
229
    if (l2_offset < 0) {
230
        return NULL;
231
    }
225 232

  
226 233
    /* update the L1 entry */
227 234

  
......
569 576
        qcow2_free_any_clusters(bs, cluster_offset, 1);
570 577

  
571 578
    cluster_offset = qcow2_alloc_bytes(bs, compressed_size);
579
    if (cluster_offset < 0) {
580
        return 0;
581
    }
582

  
572 583
    nb_csectors = ((cluster_offset + compressed_size - 1) >> 9) -
573 584
                  (cluster_offset >> 9);
574 585

  
......
700 711
{
701 712
    BDRVQcowState *s = bs->opaque;
702 713
    int l2_index, ret;
703
    uint64_t l2_offset, *l2_table, cluster_offset;
714
    uint64_t l2_offset, *l2_table;
715
    int64_t cluster_offset;
704 716
    unsigned int nb_clusters, i = 0;
705 717
    QCowL2Meta *old_alloc;
706 718

  
......
794 806
    /* allocate a new cluster */
795 807

  
796 808
    cluster_offset = qcow2_alloc_clusters(bs, nb_clusters * s->cluster_size);
809
    if (cluster_offset < 0) {
810
        return cluster_offset;
811
    }
797 812

  
798 813
    /* save info needed for meta data update */
799 814
    m->offset = offset;
b/block/qcow2-refcount.c
435 435
    assert(size > 0 && size <= s->cluster_size);
436 436
    if (s->free_byte_offset == 0) {
437 437
        s->free_byte_offset = qcow2_alloc_clusters(bs, s->cluster_size);
438
        if (s->free_byte_offset < 0) {
439
            return s->free_byte_offset;
440
        }
438 441
    }
439 442
 redo:
440 443
    free_in_cluster = s->cluster_size -
......
450 453
            update_cluster_refcount(bs, offset >> s->cluster_bits, 1);
451 454
    } else {
452 455
        offset = qcow2_alloc_clusters(bs, s->cluster_size);
456
        if (offset < 0) {
457
            return offset;
458
        }
453 459
        cluster_offset = s->free_byte_offset & ~(s->cluster_size - 1);
454 460
        if ((cluster_offset + s->cluster_size) == offset) {
455 461
            /* we are lucky: contiguous data */
b/block/qcow2-snapshot.c
139 139

  
140 140
    snapshots_offset = qcow2_alloc_clusters(bs, snapshots_size);
141 141
    offset = snapshots_offset;
142
    if (offset < 0) {
143
        return offset;
144
    }
142 145

  
143 146
    for(i = 0; i < s->nb_snapshots; i++) {
144 147
        sn = s->snapshots + i;
......
235 238
    QCowSnapshot *snapshots1, sn1, *sn = &sn1;
236 239
    int i, ret;
237 240
    uint64_t *l1_table = NULL;
241
    int64_t l1_table_offset;
238 242

  
239 243
    memset(sn, 0, sizeof(*sn));
240 244

  
......
263 267
        goto fail;
264 268

  
265 269
    /* create the L1 table of the snapshot */
266
    sn->l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));
270
    l1_table_offset = qcow2_alloc_clusters(bs, s->l1_size * sizeof(uint64_t));
271
    if (l1_table_offset < 0) {
272
        goto fail;
273
    }
274

  
275
    sn->l1_table_offset = l1_table_offset;
267 276
    sn->l1_size = s->l1_size;
268 277

  
269 278
    if (s->l1_size != 0) {

Also available in: Unified diff