← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to block-qcow.c

  • Committer: blueswir1
  • Date: 2007-11-25 08:48:16 UTC
  • Revision ID: git-v1:b76482e76560345c00e7d6c89199ced204a926d2
 Fix buffer mux handling for unconnected serial ports


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3737 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
block-qcow.c
339
339
                return -1;
340
340
        } else {
341
341
            cluster_offset = bdrv_getlength(s->hd);
342
 
            /* round to cluster size */
343
 
            cluster_offset = (cluster_offset + s->cluster_size - 1) &
344
 
                ~(s->cluster_size - 1);
345
 
            bdrv_truncate(s->hd, cluster_offset + s->cluster_size);
346
 
            /* if encrypted, we must initialize the cluster
347
 
               content which won't be written */
348
 
            if (s->crypt_method &&
349
 
                (n_end - n_start) < s->cluster_sectors) {
350
 
                uint64_t start_sect;
351
 
                start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
352
 
                memset(s->cluster_data + 512, 0x00, 512);
353
 
                for(i = 0; i < s->cluster_sectors; i++) {
354
 
                    if (i < n_start || i >= n_end) {
355
 
                        encrypt_sectors(s, start_sect + i,
356
 
                                        s->cluster_data,
357
 
                                        s->cluster_data + 512, 1, 1,
358
 
                                        &s->aes_encrypt_key);
359
 
                        if (bdrv_pwrite(s->hd, cluster_offset + i * 512,
360
 
                                        s->cluster_data, 512) != 512)
361
 
                            return -1;
 
342
            if (allocate == 1) {
 
343
                /* round to cluster size */
 
344
                cluster_offset = (cluster_offset + s->cluster_size - 1) &
 
345
                    ~(s->cluster_size - 1);
 
346
                bdrv_truncate(s->hd, cluster_offset + s->cluster_size);
 
347
                /* if encrypted, we must initialize the cluster
 
348
                   content which won't be written */
 
349
                if (s->crypt_method &&
 
350
                    (n_end - n_start) < s->cluster_sectors) {
 
351
                    uint64_t start_sect;
 
352
                    start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
 
353
                    memset(s->cluster_data + 512, 0x00, 512);
 
354
                    for(i = 0; i < s->cluster_sectors; i++) {
 
355
                        if (i < n_start || i >= n_end) {
 
356
                            encrypt_sectors(s, start_sect + i,
 
357
                                            s->cluster_data,
 
358
                                            s->cluster_data + 512, 1, 1,
 
359
                                            &s->aes_encrypt_key);
 
360
                            if (bdrv_pwrite(s->hd, cluster_offset + i * 512,
 
361
                                            s->cluster_data, 512) != 512)
 
362
                                return -1;
 
363
                        }
362
364
                    }
363
365
                }
 
366
            } else {
 
367
                cluster_offset |= QCOW_OFLAG_COMPRESSED |
 
368
                    (uint64_t)compressed_size << (63 - s->cluster_bits);
364
369
            }
365
370
        }
366
371
        /* update L2 table */
747
752
    header_size = sizeof(header);
748
753
    backing_filename_len = 0;
749
754
    if (backing_file) {
750
 
        if (strcmp(backing_file, "fat:")) {
751
 
            header.backing_file_offset = cpu_to_be64(header_size);
752
 
            backing_filename_len = strlen(backing_file);
753
 
            header.backing_file_size = cpu_to_be32(backing_filename_len);
754
 
            header_size += backing_filename_len;
755
 
        } else {
756
 
            /* special backing file for vvfat */
757
 
            backing_file = NULL;
758
 
        }
 
755
        header.backing_file_offset = cpu_to_be64(header_size);
 
756
        backing_filename_len = strlen(backing_file);
 
757
        header.backing_file_size = cpu_to_be32(backing_filename_len);
 
758
        header_size += backing_filename_len;
 
759
        header.mtime = cpu_to_be32(0);
759
760
        header.cluster_bits = 9; /* 512 byte cluster to avoid copying
760
761
                                    unmodifyed sectors */
761
762
        header.l2_bits = 12; /* 32 KB L2 tables */