Statistics
| Branch: | Revision:

root / block / qcow.c @ 34b5d2c6

History | View | Annotate | Download (28.3 kB)

1
/*
2
 * Block driver for the QCOW format
3
 *
4
 * Copyright (c) 2004-2006 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24
#include "qemu-common.h"
25
#include "block/block_int.h"
26
#include "qemu/module.h"
27
#include <zlib.h>
28
#include "qemu/aes.h"
29
#include "migration/migration.h"
30

    
31
/**************************************************************/
32
/* QEMU COW block driver with compression and encryption support */
33

    
34
#define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
35
#define QCOW_VERSION 1
36

    
37
#define QCOW_CRYPT_NONE 0
38
#define QCOW_CRYPT_AES  1
39

    
40
#define QCOW_OFLAG_COMPRESSED (1LL << 63)
41

    
42
typedef struct QCowHeader {
43
    uint32_t magic;
44
    uint32_t version;
45
    uint64_t backing_file_offset;
46
    uint32_t backing_file_size;
47
    uint32_t mtime;
48
    uint64_t size; /* in bytes */
49
    uint8_t cluster_bits;
50
    uint8_t l2_bits;
51
    uint32_t crypt_method;
52
    uint64_t l1_table_offset;
53
} QCowHeader;
54

    
55
#define L2_CACHE_SIZE 16
56

    
57
typedef struct BDRVQcowState {
58
    int cluster_bits;
59
    int cluster_size;
60
    int cluster_sectors;
61
    int l2_bits;
62
    int l2_size;
63
    int l1_size;
64
    uint64_t cluster_offset_mask;
65
    uint64_t l1_table_offset;
66
    uint64_t *l1_table;
67
    uint64_t *l2_cache;
68
    uint64_t l2_cache_offsets[L2_CACHE_SIZE];
69
    uint32_t l2_cache_counts[L2_CACHE_SIZE];
70
    uint8_t *cluster_cache;
71
    uint8_t *cluster_data;
72
    uint64_t cluster_cache_offset;
73
    uint32_t crypt_method; /* current crypt method, 0 if no key yet */
74
    uint32_t crypt_method_header;
75
    AES_KEY aes_encrypt_key;
76
    AES_KEY aes_decrypt_key;
77
    CoMutex lock;
78
    Error *migration_blocker;
79
} BDRVQcowState;
80

    
81
static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset);
82

    
83
static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)
84
{
85
    const QCowHeader *cow_header = (const void *)buf;
86

    
87
    if (buf_size >= sizeof(QCowHeader) &&
88
        be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
89
        be32_to_cpu(cow_header->version) == QCOW_VERSION)
90
        return 100;
91
    else
92
        return 0;
93
}
94

    
95
static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
96
                     Error **errp)
97
{
98
    BDRVQcowState *s = bs->opaque;
99
    int len, i, shift, ret;
100
    QCowHeader header;
101

    
102
    ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
103
    if (ret < 0) {
104
        goto fail;
105
    }
106
    be32_to_cpus(&header.magic);
107
    be32_to_cpus(&header.version);
108
    be64_to_cpus(&header.backing_file_offset);
109
    be32_to_cpus(&header.backing_file_size);
110
    be32_to_cpus(&header.mtime);
111
    be64_to_cpus(&header.size);
112
    be32_to_cpus(&header.crypt_method);
113
    be64_to_cpus(&header.l1_table_offset);
114

    
115
    if (header.magic != QCOW_MAGIC) {
116
        ret = -EMEDIUMTYPE;
117
        goto fail;
118
    }
119
    if (header.version != QCOW_VERSION) {
120
        char version[64];
121
        snprintf(version, sizeof(version), "QCOW version %d", header.version);
122
        qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
123
            bs->device_name, "qcow", version);
124
        ret = -ENOTSUP;
125
        goto fail;
126
    }
127

    
128
    if (header.size <= 1 || header.cluster_bits < 9) {
129
        ret = -EINVAL;
130
        goto fail;
131
    }
132
    if (header.crypt_method > QCOW_CRYPT_AES) {
133
        ret = -EINVAL;
134
        goto fail;
135
    }
136
    s->crypt_method_header = header.crypt_method;
137
    if (s->crypt_method_header) {
138
        bs->encrypted = 1;
139
    }
140
    s->cluster_bits = header.cluster_bits;
141
    s->cluster_size = 1 << s->cluster_bits;
142
    s->cluster_sectors = 1 << (s->cluster_bits - 9);
143
    s->l2_bits = header.l2_bits;
144
    s->l2_size = 1 << s->l2_bits;
145
    bs->total_sectors = header.size / 512;
146
    s->cluster_offset_mask = (1LL << (63 - s->cluster_bits)) - 1;
147

    
148
    /* read the level 1 table */
149
    shift = s->cluster_bits + s->l2_bits;
150
    s->l1_size = (header.size + (1LL << shift) - 1) >> shift;
151

    
152
    s->l1_table_offset = header.l1_table_offset;
153
    s->l1_table = g_malloc(s->l1_size * sizeof(uint64_t));
154

    
155
    ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
156
               s->l1_size * sizeof(uint64_t));
157
    if (ret < 0) {
158
        goto fail;
159
    }
160

    
161
    for(i = 0;i < s->l1_size; i++) {
162
        be64_to_cpus(&s->l1_table[i]);
163
    }
164
    /* alloc L2 cache */
165
    s->l2_cache = g_malloc(s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
166
    s->cluster_cache = g_malloc(s->cluster_size);
167
    s->cluster_data = g_malloc(s->cluster_size);
168
    s->cluster_cache_offset = -1;
169

    
170
    /* read the backing file name */
171
    if (header.backing_file_offset != 0) {
172
        len = header.backing_file_size;
173
        if (len > 1023) {
174
            len = 1023;
175
        }
176
        ret = bdrv_pread(bs->file, header.backing_file_offset,
177
                   bs->backing_file, len);
178
        if (ret < 0) {
179
            goto fail;
180
        }
181
        bs->backing_file[len] = '\0';
182
    }
183

    
184
    /* Disable migration when qcow images are used */
185
    error_set(&s->migration_blocker,
186
              QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
187
              "qcow", bs->device_name, "live migration");
188
    migrate_add_blocker(s->migration_blocker);
189

    
190
    qemu_co_mutex_init(&s->lock);
191
    return 0;
192

    
193
 fail:
194
    g_free(s->l1_table);
195
    g_free(s->l2_cache);
196
    g_free(s->cluster_cache);
197
    g_free(s->cluster_data);
198
    return ret;
199
}
200

    
201

    
202
/* We have nothing to do for QCOW reopen, stubs just return
203
 * success */
204
static int qcow_reopen_prepare(BDRVReopenState *state,
205
                               BlockReopenQueue *queue, Error **errp)
206
{
207
    return 0;
208
}
209

    
210
static int qcow_set_key(BlockDriverState *bs, const char *key)
211
{
212
    BDRVQcowState *s = bs->opaque;
213
    uint8_t keybuf[16];
214
    int len, i;
215

    
216
    memset(keybuf, 0, 16);
217
    len = strlen(key);
218
    if (len > 16)
219
        len = 16;
220
    /* XXX: we could compress the chars to 7 bits to increase
221
       entropy */
222
    for(i = 0;i < len;i++) {
223
        keybuf[i] = key[i];
224
    }
225
    s->crypt_method = s->crypt_method_header;
226

    
227
    if (AES_set_encrypt_key(keybuf, 128, &s->aes_encrypt_key) != 0)
228
        return -1;
229
    if (AES_set_decrypt_key(keybuf, 128, &s->aes_decrypt_key) != 0)
230
        return -1;
231
    return 0;
232
}
233

    
234
/* The crypt function is compatible with the linux cryptoloop
235
   algorithm for < 4 GB images. NOTE: out_buf == in_buf is
236
   supported */
237
static void encrypt_sectors(BDRVQcowState *s, int64_t sector_num,
238
                            uint8_t *out_buf, const uint8_t *in_buf,
239
                            int nb_sectors, int enc,
240
                            const AES_KEY *key)
241
{
242
    union {
243
        uint64_t ll[2];
244
        uint8_t b[16];
245
    } ivec;
246
    int i;
247

    
248
    for(i = 0; i < nb_sectors; i++) {
249
        ivec.ll[0] = cpu_to_le64(sector_num);
250
        ivec.ll[1] = 0;
251
        AES_cbc_encrypt(in_buf, out_buf, 512, key,
252
                        ivec.b, enc);
253
        sector_num++;
254
        in_buf += 512;
255
        out_buf += 512;
256
    }
257
}
258

    
259
/* 'allocate' is:
260
 *
261
 * 0 to not allocate.
262
 *
263
 * 1 to allocate a normal cluster (for sector indexes 'n_start' to
264
 * 'n_end')
265
 *
266
 * 2 to allocate a compressed cluster of size
267
 * 'compressed_size'. 'compressed_size' must be > 0 and <
268
 * cluster_size
269
 *
270
 * return 0 if not allocated.
271
 */
272
static uint64_t get_cluster_offset(BlockDriverState *bs,
273
                                   uint64_t offset, int allocate,
274
                                   int compressed_size,
275
                                   int n_start, int n_end)
276
{
277
    BDRVQcowState *s = bs->opaque;
278
    int min_index, i, j, l1_index, l2_index;
279
    uint64_t l2_offset, *l2_table, cluster_offset, tmp;
280
    uint32_t min_count;
281
    int new_l2_table;
282

    
283
    l1_index = offset >> (s->l2_bits + s->cluster_bits);
284
    l2_offset = s->l1_table[l1_index];
285
    new_l2_table = 0;
286
    if (!l2_offset) {
287
        if (!allocate)
288
            return 0;
289
        /* allocate a new l2 entry */
290
        l2_offset = bdrv_getlength(bs->file);
291
        /* round to cluster size */
292
        l2_offset = (l2_offset + s->cluster_size - 1) & ~(s->cluster_size - 1);
293
        /* update the L1 entry */
294
        s->l1_table[l1_index] = l2_offset;
295
        tmp = cpu_to_be64(l2_offset);
296
        if (bdrv_pwrite_sync(bs->file,
297
                s->l1_table_offset + l1_index * sizeof(tmp),
298
                &tmp, sizeof(tmp)) < 0)
299
            return 0;
300
        new_l2_table = 1;
301
    }
302
    for(i = 0; i < L2_CACHE_SIZE; i++) {
303
        if (l2_offset == s->l2_cache_offsets[i]) {
304
            /* increment the hit count */
305
            if (++s->l2_cache_counts[i] == 0xffffffff) {
306
                for(j = 0; j < L2_CACHE_SIZE; j++) {
307
                    s->l2_cache_counts[j] >>= 1;
308
                }
309
            }
310
            l2_table = s->l2_cache + (i << s->l2_bits);
311
            goto found;
312
        }
313
    }
314
    /* not found: load a new entry in the least used one */
315
    min_index = 0;
316
    min_count = 0xffffffff;
317
    for(i = 0; i < L2_CACHE_SIZE; i++) {
318
        if (s->l2_cache_counts[i] < min_count) {
319
            min_count = s->l2_cache_counts[i];
320
            min_index = i;
321
        }
322
    }
323
    l2_table = s->l2_cache + (min_index << s->l2_bits);
324
    if (new_l2_table) {
325
        memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
326
        if (bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
327
                s->l2_size * sizeof(uint64_t)) < 0)
328
            return 0;
329
    } else {
330
        if (bdrv_pread(bs->file, l2_offset, l2_table, s->l2_size * sizeof(uint64_t)) !=
331
            s->l2_size * sizeof(uint64_t))
332
            return 0;
333
    }
334
    s->l2_cache_offsets[min_index] = l2_offset;
335
    s->l2_cache_counts[min_index] = 1;
336
 found:
337
    l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
338
    cluster_offset = be64_to_cpu(l2_table[l2_index]);
339
    if (!cluster_offset ||
340
        ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
341
        if (!allocate)
342
            return 0;
343
        /* allocate a new cluster */
344
        if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
345
            (n_end - n_start) < s->cluster_sectors) {
346
            /* if the cluster is already compressed, we must
347
               decompress it in the case it is not completely
348
               overwritten */
349
            if (decompress_cluster(bs, cluster_offset) < 0)
350
                return 0;
351
            cluster_offset = bdrv_getlength(bs->file);
352
            cluster_offset = (cluster_offset + s->cluster_size - 1) &
353
                ~(s->cluster_size - 1);
354
            /* write the cluster content */
355
            if (bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache, s->cluster_size) !=
356
                s->cluster_size)
357
                return -1;
358
        } else {
359
            cluster_offset = bdrv_getlength(bs->file);
360
            if (allocate == 1) {
361
                /* round to cluster size */
362
                cluster_offset = (cluster_offset + s->cluster_size - 1) &
363
                    ~(s->cluster_size - 1);
364
                bdrv_truncate(bs->file, cluster_offset + s->cluster_size);
365
                /* if encrypted, we must initialize the cluster
366
                   content which won't be written */
367
                if (s->crypt_method &&
368
                    (n_end - n_start) < s->cluster_sectors) {
369
                    uint64_t start_sect;
370
                    start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
371
                    memset(s->cluster_data + 512, 0x00, 512);
372
                    for(i = 0; i < s->cluster_sectors; i++) {
373
                        if (i < n_start || i >= n_end) {
374
                            encrypt_sectors(s, start_sect + i,
375
                                            s->cluster_data,
376
                                            s->cluster_data + 512, 1, 1,
377
                                            &s->aes_encrypt_key);
378
                            if (bdrv_pwrite(bs->file, cluster_offset + i * 512,
379
                                            s->cluster_data, 512) != 512)
380
                                return -1;
381
                        }
382
                    }
383
                }
384
            } else if (allocate == 2) {
385
                cluster_offset |= QCOW_OFLAG_COMPRESSED |
386
                    (uint64_t)compressed_size << (63 - s->cluster_bits);
387
            }
388
        }
389
        /* update L2 table */
390
        tmp = cpu_to_be64(cluster_offset);
391
        l2_table[l2_index] = tmp;
392
        if (bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
393
                &tmp, sizeof(tmp)) < 0)
394
            return 0;
395
    }
396
    return cluster_offset;
397
}
398

    
399
static int64_t coroutine_fn qcow_co_get_block_status(BlockDriverState *bs,
400
        int64_t sector_num, int nb_sectors, int *pnum)
401
{
402
    BDRVQcowState *s = bs->opaque;
403
    int index_in_cluster, n;
404
    uint64_t cluster_offset;
405

    
406
    qemu_co_mutex_lock(&s->lock);
407
    cluster_offset = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0);
408
    qemu_co_mutex_unlock(&s->lock);
409
    index_in_cluster = sector_num & (s->cluster_sectors - 1);
410
    n = s->cluster_sectors - index_in_cluster;
411
    if (n > nb_sectors)
412
        n = nb_sectors;
413
    *pnum = n;
414
    if (!cluster_offset) {
415
        return 0;
416
    }
417
    if ((cluster_offset & QCOW_OFLAG_COMPRESSED) || s->crypt_method) {
418
        return BDRV_BLOCK_DATA;
419
    }
420
    cluster_offset |= (index_in_cluster << BDRV_SECTOR_BITS);
421
    return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | cluster_offset;
422
}
423

    
424
static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
425
                             const uint8_t *buf, int buf_size)
426
{
427
    z_stream strm1, *strm = &strm1;
428
    int ret, out_len;
429

    
430
    memset(strm, 0, sizeof(*strm));
431

    
432
    strm->next_in = (uint8_t *)buf;
433
    strm->avail_in = buf_size;
434
    strm->next_out = out_buf;
435
    strm->avail_out = out_buf_size;
436

    
437
    ret = inflateInit2(strm, -12);
438
    if (ret != Z_OK)
439
        return -1;
440
    ret = inflate(strm, Z_FINISH);
441
    out_len = strm->next_out - out_buf;
442
    if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
443
        out_len != out_buf_size) {
444
        inflateEnd(strm);
445
        return -1;
446
    }
447
    inflateEnd(strm);
448
    return 0;
449
}
450

    
451
static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
452
{
453
    BDRVQcowState *s = bs->opaque;
454
    int ret, csize;
455
    uint64_t coffset;
456

    
457
    coffset = cluster_offset & s->cluster_offset_mask;
458
    if (s->cluster_cache_offset != coffset) {
459
        csize = cluster_offset >> (63 - s->cluster_bits);
460
        csize &= (s->cluster_size - 1);
461
        ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize);
462
        if (ret != csize)
463
            return -1;
464
        if (decompress_buffer(s->cluster_cache, s->cluster_size,
465
                              s->cluster_data, csize) < 0) {
466
            return -1;
467
        }
468
        s->cluster_cache_offset = coffset;
469
    }
470
    return 0;
471
}
472

    
473
static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
474
                         int nb_sectors, QEMUIOVector *qiov)
475
{
476
    BDRVQcowState *s = bs->opaque;
477
    int index_in_cluster;
478
    int ret = 0, n;
479
    uint64_t cluster_offset;
480
    struct iovec hd_iov;
481
    QEMUIOVector hd_qiov;
482
    uint8_t *buf;
483
    void *orig_buf;
484

    
485
    if (qiov->niov > 1) {
486
        buf = orig_buf = qemu_blockalign(bs, qiov->size);
487
    } else {
488
        orig_buf = NULL;
489
        buf = (uint8_t *)qiov->iov->iov_base;
490
    }
491

    
492
    qemu_co_mutex_lock(&s->lock);
493

    
494
    while (nb_sectors != 0) {
495
        /* prepare next request */
496
        cluster_offset = get_cluster_offset(bs, sector_num << 9,
497
                                                 0, 0, 0, 0);
498
        index_in_cluster = sector_num & (s->cluster_sectors - 1);
499
        n = s->cluster_sectors - index_in_cluster;
500
        if (n > nb_sectors) {
501
            n = nb_sectors;
502
        }
503

    
504
        if (!cluster_offset) {
505
            if (bs->backing_hd) {
506
                /* read from the base image */
507
                hd_iov.iov_base = (void *)buf;
508
                hd_iov.iov_len = n * 512;
509
                qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
510
                qemu_co_mutex_unlock(&s->lock);
511
                ret = bdrv_co_readv(bs->backing_hd, sector_num,
512
                                    n, &hd_qiov);
513
                qemu_co_mutex_lock(&s->lock);
514
                if (ret < 0) {
515
                    goto fail;
516
                }
517
            } else {
518
                /* Note: in this case, no need to wait */
519
                memset(buf, 0, 512 * n);
520
            }
521
        } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
522
            /* add AIO support for compressed blocks ? */
523
            if (decompress_cluster(bs, cluster_offset) < 0) {
524
                goto fail;
525
            }
526
            memcpy(buf,
527
                   s->cluster_cache + index_in_cluster * 512, 512 * n);
528
        } else {
529
            if ((cluster_offset & 511) != 0) {
530
                goto fail;
531
            }
532
            hd_iov.iov_base = (void *)buf;
533
            hd_iov.iov_len = n * 512;
534
            qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
535
            qemu_co_mutex_unlock(&s->lock);
536
            ret = bdrv_co_readv(bs->file,
537
                                (cluster_offset >> 9) + index_in_cluster,
538
                                n, &hd_qiov);
539
            qemu_co_mutex_lock(&s->lock);
540
            if (ret < 0) {
541
                break;
542
            }
543
            if (s->crypt_method) {
544
                encrypt_sectors(s, sector_num, buf, buf,
545
                                n, 0,
546
                                &s->aes_decrypt_key);
547
            }
548
        }
549
        ret = 0;
550

    
551
        nb_sectors -= n;
552
        sector_num += n;
553
        buf += n * 512;
554
    }
555

    
556
done:
557
    qemu_co_mutex_unlock(&s->lock);
558

    
559
    if (qiov->niov > 1) {
560
        qemu_iovec_from_buf(qiov, 0, orig_buf, qiov->size);
561
        qemu_vfree(orig_buf);
562
    }
563

    
564
    return ret;
565

    
566
fail:
567
    ret = -EIO;
568
    goto done;
569
}
570

    
571
static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
572
                          int nb_sectors, QEMUIOVector *qiov)
573
{
574
    BDRVQcowState *s = bs->opaque;
575
    int index_in_cluster;
576
    uint64_t cluster_offset;
577
    const uint8_t *src_buf;
578
    int ret = 0, n;
579
    uint8_t *cluster_data = NULL;
580
    struct iovec hd_iov;
581
    QEMUIOVector hd_qiov;
582
    uint8_t *buf;
583
    void *orig_buf;
584

    
585
    s->cluster_cache_offset = -1; /* disable compressed cache */
586

    
587
    if (qiov->niov > 1) {
588
        buf = orig_buf = qemu_blockalign(bs, qiov->size);
589
        qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
590
    } else {
591
        orig_buf = NULL;
592
        buf = (uint8_t *)qiov->iov->iov_base;
593
    }
594

    
595
    qemu_co_mutex_lock(&s->lock);
596

    
597
    while (nb_sectors != 0) {
598

    
599
        index_in_cluster = sector_num & (s->cluster_sectors - 1);
600
        n = s->cluster_sectors - index_in_cluster;
601
        if (n > nb_sectors) {
602
            n = nb_sectors;
603
        }
604
        cluster_offset = get_cluster_offset(bs, sector_num << 9, 1, 0,
605
                                            index_in_cluster,
606
                                            index_in_cluster + n);
607
        if (!cluster_offset || (cluster_offset & 511) != 0) {
608
            ret = -EIO;
609
            break;
610
        }
611
        if (s->crypt_method) {
612
            if (!cluster_data) {
613
                cluster_data = g_malloc0(s->cluster_size);
614
            }
615
            encrypt_sectors(s, sector_num, cluster_data, buf,
616
                            n, 1, &s->aes_encrypt_key);
617
            src_buf = cluster_data;
618
        } else {
619
            src_buf = buf;
620
        }
621

    
622
        hd_iov.iov_base = (void *)src_buf;
623
        hd_iov.iov_len = n * 512;
624
        qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
625
        qemu_co_mutex_unlock(&s->lock);
626
        ret = bdrv_co_writev(bs->file,
627
                             (cluster_offset >> 9) + index_in_cluster,
628
                             n, &hd_qiov);
629
        qemu_co_mutex_lock(&s->lock);
630
        if (ret < 0) {
631
            break;
632
        }
633
        ret = 0;
634

    
635
        nb_sectors -= n;
636
        sector_num += n;
637
        buf += n * 512;
638
    }
639
    qemu_co_mutex_unlock(&s->lock);
640

    
641
    if (qiov->niov > 1) {
642
        qemu_vfree(orig_buf);
643
    }
644
    g_free(cluster_data);
645

    
646
    return ret;
647
}
648

    
649
static void qcow_close(BlockDriverState *bs)
650
{
651
    BDRVQcowState *s = bs->opaque;
652

    
653
    g_free(s->l1_table);
654
    g_free(s->l2_cache);
655
    g_free(s->cluster_cache);
656
    g_free(s->cluster_data);
657

    
658
    migrate_del_blocker(s->migration_blocker);
659
    error_free(s->migration_blocker);
660
}
661

    
662
static int qcow_create(const char *filename, QEMUOptionParameter *options,
663
                       Error **errp)
664
{
665
    int header_size, backing_filename_len, l1_size, shift, i;
666
    QCowHeader header;
667
    uint8_t *tmp;
668
    int64_t total_size = 0;
669
    const char *backing_file = NULL;
670
    int flags = 0;
671
    Error *local_err = NULL;
672
    int ret;
673
    BlockDriverState *qcow_bs;
674

    
675
    /* Read out options */
676
    while (options && options->name) {
677
        if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
678
            total_size = options->value.n / 512;
679
        } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
680
            backing_file = options->value.s;
681
        } else if (!strcmp(options->name, BLOCK_OPT_ENCRYPT)) {
682
            flags |= options->value.n ? BLOCK_FLAG_ENCRYPT : 0;
683
        }
684
        options++;
685
    }
686

    
687
    ret = bdrv_create_file(filename, options);
688
    if (ret < 0) {
689
        return ret;
690
    }
691

    
692
    ret = bdrv_file_open(&qcow_bs, filename, NULL, BDRV_O_RDWR, &local_err);
693
    if (ret < 0) {
694
        qerror_report_err(local_err);
695
        error_free(local_err);
696
        return ret;
697
    }
698

    
699
    ret = bdrv_truncate(qcow_bs, 0);
700
    if (ret < 0) {
701
        goto exit;
702
    }
703

    
704
    memset(&header, 0, sizeof(header));
705
    header.magic = cpu_to_be32(QCOW_MAGIC);
706
    header.version = cpu_to_be32(QCOW_VERSION);
707
    header.size = cpu_to_be64(total_size * 512);
708
    header_size = sizeof(header);
709
    backing_filename_len = 0;
710
    if (backing_file) {
711
        if (strcmp(backing_file, "fat:")) {
712
            header.backing_file_offset = cpu_to_be64(header_size);
713
            backing_filename_len = strlen(backing_file);
714
            header.backing_file_size = cpu_to_be32(backing_filename_len);
715
            header_size += backing_filename_len;
716
        } else {
717
            /* special backing file for vvfat */
718
            backing_file = NULL;
719
        }
720
        header.cluster_bits = 9; /* 512 byte cluster to avoid copying
721
                                    unmodifyed sectors */
722
        header.l2_bits = 12; /* 32 KB L2 tables */
723
    } else {
724
        header.cluster_bits = 12; /* 4 KB clusters */
725
        header.l2_bits = 9; /* 4 KB L2 tables */
726
    }
727
    header_size = (header_size + 7) & ~7;
728
    shift = header.cluster_bits + header.l2_bits;
729
    l1_size = ((total_size * 512) + (1LL << shift) - 1) >> shift;
730

    
731
    header.l1_table_offset = cpu_to_be64(header_size);
732
    if (flags & BLOCK_FLAG_ENCRYPT) {
733
        header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
734
    } else {
735
        header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
736
    }
737

    
738
    /* write all the data */
739
    ret = bdrv_pwrite(qcow_bs, 0, &header, sizeof(header));
740
    if (ret != sizeof(header)) {
741
        goto exit;
742
    }
743

    
744
    if (backing_file) {
745
        ret = bdrv_pwrite(qcow_bs, sizeof(header),
746
            backing_file, backing_filename_len);
747
        if (ret != backing_filename_len) {
748
            goto exit;
749
        }
750
    }
751

    
752
    tmp = g_malloc0(BDRV_SECTOR_SIZE);
753
    for (i = 0; i < ((sizeof(uint64_t)*l1_size + BDRV_SECTOR_SIZE - 1)/
754
        BDRV_SECTOR_SIZE); i++) {
755
        ret = bdrv_pwrite(qcow_bs, header_size +
756
            BDRV_SECTOR_SIZE*i, tmp, BDRV_SECTOR_SIZE);
757
        if (ret != BDRV_SECTOR_SIZE) {
758
            g_free(tmp);
759
            goto exit;
760
        }
761
    }
762

    
763
    g_free(tmp);
764
    ret = 0;
765
exit:
766
    bdrv_unref(qcow_bs);
767
    return ret;
768
}
769

    
770
static int qcow_make_empty(BlockDriverState *bs)
771
{
772
    BDRVQcowState *s = bs->opaque;
773
    uint32_t l1_length = s->l1_size * sizeof(uint64_t);
774
    int ret;
775

    
776
    memset(s->l1_table, 0, l1_length);
777
    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table,
778
            l1_length) < 0)
779
        return -1;
780
    ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length);
781
    if (ret < 0)
782
        return ret;
783

    
784
    memset(s->l2_cache, 0, s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
785
    memset(s->l2_cache_offsets, 0, L2_CACHE_SIZE * sizeof(uint64_t));
786
    memset(s->l2_cache_counts, 0, L2_CACHE_SIZE * sizeof(uint32_t));
787

    
788
    return 0;
789
}
790

    
791
/* XXX: put compressed sectors first, then all the cluster aligned
792
   tables to avoid losing bytes in alignment */
793
static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,
794
                                 const uint8_t *buf, int nb_sectors)
795
{
796
    BDRVQcowState *s = bs->opaque;
797
    z_stream strm;
798
    int ret, out_len;
799
    uint8_t *out_buf;
800
    uint64_t cluster_offset;
801

    
802
    if (nb_sectors != s->cluster_sectors) {
803
        ret = -EINVAL;
804

    
805
        /* Zero-pad last write if image size is not cluster aligned */
806
        if (sector_num + nb_sectors == bs->total_sectors &&
807
            nb_sectors < s->cluster_sectors) {
808
            uint8_t *pad_buf = qemu_blockalign(bs, s->cluster_size);
809
            memset(pad_buf, 0, s->cluster_size);
810
            memcpy(pad_buf, buf, nb_sectors * BDRV_SECTOR_SIZE);
811
            ret = qcow_write_compressed(bs, sector_num,
812
                                        pad_buf, s->cluster_sectors);
813
            qemu_vfree(pad_buf);
814
        }
815
        return ret;
816
    }
817

    
818
    out_buf = g_malloc(s->cluster_size + (s->cluster_size / 1000) + 128);
819

    
820
    /* best compression, small window, no zlib header */
821
    memset(&strm, 0, sizeof(strm));
822
    ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
823
                       Z_DEFLATED, -12,
824
                       9, Z_DEFAULT_STRATEGY);
825
    if (ret != 0) {
826
        ret = -EINVAL;
827
        goto fail;
828
    }
829

    
830
    strm.avail_in = s->cluster_size;
831
    strm.next_in = (uint8_t *)buf;
832
    strm.avail_out = s->cluster_size;
833
    strm.next_out = out_buf;
834

    
835
    ret = deflate(&strm, Z_FINISH);
836
    if (ret != Z_STREAM_END && ret != Z_OK) {
837
        deflateEnd(&strm);
838
        ret = -EINVAL;
839
        goto fail;
840
    }
841
    out_len = strm.next_out - out_buf;
842

    
843
    deflateEnd(&strm);
844

    
845
    if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
846
        /* could not compress: write normal cluster */
847
        ret = bdrv_write(bs, sector_num, buf, s->cluster_sectors);
848
        if (ret < 0) {
849
            goto fail;
850
        }
851
    } else {
852
        cluster_offset = get_cluster_offset(bs, sector_num << 9, 2,
853
                                            out_len, 0, 0);
854
        if (cluster_offset == 0) {
855
            ret = -EIO;
856
            goto fail;
857
        }
858

    
859
        cluster_offset &= s->cluster_offset_mask;
860
        ret = bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len);
861
        if (ret < 0) {
862
            goto fail;
863
        }
864
    }
865

    
866
    ret = 0;
867
fail:
868
    g_free(out_buf);
869
    return ret;
870
}
871

    
872
static int qcow_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
873
{
874
    BDRVQcowState *s = bs->opaque;
875
    bdi->cluster_size = s->cluster_size;
876
    return 0;
877
}
878

    
879

    
880
static QEMUOptionParameter qcow_create_options[] = {
881
    {
882
        .name = BLOCK_OPT_SIZE,
883
        .type = OPT_SIZE,
884
        .help = "Virtual disk size"
885
    },
886
    {
887
        .name = BLOCK_OPT_BACKING_FILE,
888
        .type = OPT_STRING,
889
        .help = "File name of a base image"
890
    },
891
    {
892
        .name = BLOCK_OPT_ENCRYPT,
893
        .type = OPT_FLAG,
894
        .help = "Encrypt the image"
895
    },
896
    { NULL }
897
};
898

    
899
static BlockDriver bdrv_qcow = {
900
    .format_name        = "qcow",
901
    .instance_size        = sizeof(BDRVQcowState),
902
    .bdrv_probe                = qcow_probe,
903
    .bdrv_open                = qcow_open,
904
    .bdrv_close                = qcow_close,
905
    .bdrv_reopen_prepare = qcow_reopen_prepare,
906
    .bdrv_create        = qcow_create,
907
    .bdrv_has_zero_init     = bdrv_has_zero_init_1,
908

    
909
    .bdrv_co_readv          = qcow_co_readv,
910
    .bdrv_co_writev         = qcow_co_writev,
911
    .bdrv_co_get_block_status   = qcow_co_get_block_status,
912

    
913
    .bdrv_set_key           = qcow_set_key,
914
    .bdrv_make_empty        = qcow_make_empty,
915
    .bdrv_write_compressed  = qcow_write_compressed,
916
    .bdrv_get_info          = qcow_get_info,
917

    
918
    .create_options = qcow_create_options,
919
};
920

    
921
static void bdrv_qcow_init(void)
922
{
923
    bdrv_register(&bdrv_qcow);
924
}
925

    
926
block_init(bdrv_qcow_init);