← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to block/qcow2-cluster.c

  • Committer: Blue Swirl
  • Date: 2009-08-31 15:14:40 UTC
  • Revision ID: git-v1:528e93a9787ccfc59582a44035f5f342caf5b84f
Fix breakage due to __thread

Thread-local storage is not supported on all hosts.

Signed-off-by: Blue Swirl <blauwirbel@gmail.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
block/qcow2-cluster.c
 
1
/*
 
2
 * Block driver for the QCOW version 2 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
 
 
25
#include <zlib.h>
 
26
 
 
27
#include "qemu-common.h"
 
28
#include "block_int.h"
 
29
#include "block/qcow2.h"
 
30
 
 
31
int qcow2_grow_l1_table(BlockDriverState *bs, int min_size)
 
32
{
 
33
    BDRVQcowState *s = bs->opaque;
 
34
    int new_l1_size, new_l1_size2, ret, i;
 
35
    uint64_t *new_l1_table;
 
36
    uint64_t new_l1_table_offset;
 
37
    uint8_t data[12];
 
38
 
 
39
    new_l1_size = s->l1_size;
 
40
    if (min_size <= new_l1_size)
 
41
        return 0;
 
42
    while (min_size > new_l1_size) {
 
43
        new_l1_size = (new_l1_size * 3 + 1) / 2;
 
44
    }
 
45
#ifdef DEBUG_ALLOC2
 
46
    printf("grow l1_table from %d to %d\n", s->l1_size, new_l1_size);
 
47
#endif
 
48
 
 
49
    new_l1_size2 = sizeof(uint64_t) * new_l1_size;
 
50
    new_l1_table = qemu_mallocz(align_offset(new_l1_size2, 512));
 
51
    memcpy(new_l1_table, s->l1_table, s->l1_size * sizeof(uint64_t));
 
52
 
 
53
    /* write new table (align to cluster) */
 
54
    new_l1_table_offset = qcow2_alloc_clusters(bs, new_l1_size2);
 
55
 
 
56
    for(i = 0; i < s->l1_size; i++)
 
57
        new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
 
58
    ret = bdrv_pwrite(s->hd, new_l1_table_offset, new_l1_table, new_l1_size2);
 
59
    if (ret != new_l1_size2)
 
60
        goto fail;
 
61
    for(i = 0; i < s->l1_size; i++)
 
62
        new_l1_table[i] = be64_to_cpu(new_l1_table[i]);
 
63
 
 
64
    /* set new table */
 
65
    cpu_to_be32w((uint32_t*)data, new_l1_size);
 
66
    cpu_to_be64w((uint64_t*)(data + 4), new_l1_table_offset);
 
67
    if (bdrv_pwrite(s->hd, offsetof(QCowHeader, l1_size), data,
 
68
                sizeof(data)) != sizeof(data))
 
69
        goto fail;
 
70
    qemu_free(s->l1_table);
 
71
    qcow2_free_clusters(bs, s->l1_table_offset, s->l1_size * sizeof(uint64_t));
 
72
    s->l1_table_offset = new_l1_table_offset;
 
73
    s->l1_table = new_l1_table;
 
74
    s->l1_size = new_l1_size;
 
75
    return 0;
 
76
 fail:
 
77
    qemu_free(s->l1_table);
 
78
    return -EIO;
 
79
}
 
80
 
 
81
void qcow2_l2_cache_reset(BlockDriverState *bs)
 
82
{
 
83
    BDRVQcowState *s = bs->opaque;
 
84
 
 
85
    memset(s->l2_cache, 0, s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t));
 
86
    memset(s->l2_cache_offsets, 0, L2_CACHE_SIZE * sizeof(uint64_t));
 
87
    memset(s->l2_cache_counts, 0, L2_CACHE_SIZE * sizeof(uint32_t));
 
88
}
 
89
 
 
90
static inline int l2_cache_new_entry(BlockDriverState *bs)
 
91
{
 
92
    BDRVQcowState *s = bs->opaque;
 
93
    uint32_t min_count;
 
94
    int min_index, i;
 
95
 
 
96
    /* find a new entry in the least used one */
 
97
    min_index = 0;
 
98
    min_count = 0xffffffff;
 
99
    for(i = 0; i < L2_CACHE_SIZE; i++) {
 
100
        if (s->l2_cache_counts[i] < min_count) {
 
101
            min_count = s->l2_cache_counts[i];
 
102
            min_index = i;
 
103
        }
 
104
    }
 
105
    return min_index;
 
106
}
 
107
 
 
108
/*
 
109
 * seek_l2_table
 
110
 *
 
111
 * seek l2_offset in the l2_cache table
 
112
 * if not found, return NULL,
 
113
 * if found,
 
114
 *   increments the l2 cache hit count of the entry,
 
115
 *   if counter overflow, divide by two all counters
 
116
 *   return the pointer to the l2 cache entry
 
117
 *
 
118
 */
 
119
 
 
120
static uint64_t *seek_l2_table(BDRVQcowState *s, uint64_t l2_offset)
 
121
{
 
122
    int i, j;
 
123
 
 
124
    for(i = 0; i < L2_CACHE_SIZE; i++) {
 
125
        if (l2_offset == s->l2_cache_offsets[i]) {
 
126
            /* increment the hit count */
 
127
            if (++s->l2_cache_counts[i] == 0xffffffff) {
 
128
                for(j = 0; j < L2_CACHE_SIZE; j++) {
 
129
                    s->l2_cache_counts[j] >>= 1;
 
130
                }
 
131
            }
 
132
            return s->l2_cache + (i << s->l2_bits);
 
133
        }
 
134
    }
 
135
    return NULL;
 
136
}
 
137
 
 
138
/*
 
139
 * l2_load
 
140
 *
 
141
 * Loads a L2 table into memory. If the table is in the cache, the cache
 
142
 * is used; otherwise the L2 table is loaded from the image file.
 
143
 *
 
144
 * Returns a pointer to the L2 table on success, or NULL if the read from
 
145
 * the image file failed.
 
146
 */
 
147
 
 
148
static uint64_t *l2_load(BlockDriverState *bs, uint64_t l2_offset)
 
149
{
 
150
    BDRVQcowState *s = bs->opaque;
 
151
    int min_index;
 
152
    uint64_t *l2_table;
 
153
 
 
154
    /* seek if the table for the given offset is in the cache */
 
155
 
 
156
    l2_table = seek_l2_table(s, l2_offset);
 
157
    if (l2_table != NULL)
 
158
        return l2_table;
 
159
 
 
160
    /* not found: load a new entry in the least used one */
 
161
 
 
162
    min_index = l2_cache_new_entry(bs);
 
163
    l2_table = s->l2_cache + (min_index << s->l2_bits);
 
164
    if (bdrv_pread(s->hd, l2_offset, l2_table, s->l2_size * sizeof(uint64_t)) !=
 
165
        s->l2_size * sizeof(uint64_t))
 
166
        return NULL;
 
167
    s->l2_cache_offsets[min_index] = l2_offset;
 
168
    s->l2_cache_counts[min_index] = 1;
 
169
 
 
170
    return l2_table;
 
171
}
 
172
 
 
173
/*
 
174
 * Writes one sector of the L1 table to the disk (can't update single entries
 
175
 * and we really don't want bdrv_pread to perform a read-modify-write)
 
176
 */
 
177
#define L1_ENTRIES_PER_SECTOR (512 / 8)
 
178
static int write_l1_entry(BDRVQcowState *s, int l1_index)
 
179
{
 
180
    uint64_t buf[L1_ENTRIES_PER_SECTOR];
 
181
    int l1_start_index;
 
182
    int i;
 
183
 
 
184
    l1_start_index = l1_index & ~(L1_ENTRIES_PER_SECTOR - 1);
 
185
    for (i = 0; i < L1_ENTRIES_PER_SECTOR; i++) {
 
186
        buf[i] = cpu_to_be64(s->l1_table[l1_start_index + i]);
 
187
    }
 
188
 
 
189
    if (bdrv_pwrite(s->hd, s->l1_table_offset + 8 * l1_start_index,
 
190
        buf, sizeof(buf)) != sizeof(buf))
 
191
    {
 
192
        return -1;
 
193
    }
 
194
 
 
195
    return 0;
 
196
}
 
197
 
 
198
/*
 
199
 * l2_allocate
 
200
 *
 
201
 * Allocate a new l2 entry in the file. If l1_index points to an already
 
202
 * used entry in the L2 table (i.e. we are doing a copy on write for the L2
 
203
 * table) copy the contents of the old L2 table into the newly allocated one.
 
204
 * Otherwise the new table is initialized with zeros.
 
205
 *
 
206
 */
 
207
 
 
208
static uint64_t *l2_allocate(BlockDriverState *bs, int l1_index)
 
209
{
 
210
    BDRVQcowState *s = bs->opaque;
 
211
    int min_index;
 
212
    uint64_t old_l2_offset;
 
213
    uint64_t *l2_table, l2_offset;
 
214
 
 
215
    old_l2_offset = s->l1_table[l1_index];
 
216
 
 
217
    /* allocate a new l2 entry */
 
218
 
 
219
    l2_offset = qcow2_alloc_clusters(bs, s->l2_size * sizeof(uint64_t));
 
220
 
 
221
    /* update the L1 entry */
 
222
 
 
223
    s->l1_table[l1_index] = l2_offset | QCOW_OFLAG_COPIED;
 
224
    if (write_l1_entry(s, l1_index) < 0) {
 
225
        return NULL;
 
226
    }
 
227
 
 
228
    /* allocate a new entry in the l2 cache */
 
229
 
 
230
    min_index = l2_cache_new_entry(bs);
 
231
    l2_table = s->l2_cache + (min_index << s->l2_bits);
 
232
 
 
233
    if (old_l2_offset == 0) {
 
234
        /* if there was no old l2 table, clear the new table */
 
235
        memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
 
236
    } else {
 
237
        /* if there was an old l2 table, read it from the disk */
 
238
        if (bdrv_pread(s->hd, old_l2_offset,
 
239
                       l2_table, s->l2_size * sizeof(uint64_t)) !=
 
240
            s->l2_size * sizeof(uint64_t))
 
241
            return NULL;
 
242
    }
 
243
    /* write the l2 table to the file */
 
244
    if (bdrv_pwrite(s->hd, l2_offset,
 
245
                    l2_table, s->l2_size * sizeof(uint64_t)) !=
 
246
        s->l2_size * sizeof(uint64_t))
 
247
        return NULL;
 
248
 
 
249
    /* update the l2 cache entry */
 
250
 
 
251
    s->l2_cache_offsets[min_index] = l2_offset;
 
252
    s->l2_cache_counts[min_index] = 1;
 
253
 
 
254
    return l2_table;
 
255
}
 
256
 
 
257
static int count_contiguous_clusters(uint64_t nb_clusters, int cluster_size,
 
258
        uint64_t *l2_table, uint64_t start, uint64_t mask)
 
259
{
 
260
    int i;
 
261
    uint64_t offset = be64_to_cpu(l2_table[0]) & ~mask;
 
262
 
 
263
    if (!offset)
 
264
        return 0;
 
265
 
 
266
    for (i = start; i < start + nb_clusters; i++)
 
267
        if (offset + i * cluster_size != (be64_to_cpu(l2_table[i]) & ~mask))
 
268
            break;
 
269
 
 
270
        return (i - start);
 
271
}
 
272
 
 
273
static int count_contiguous_free_clusters(uint64_t nb_clusters, uint64_t *l2_table)
 
274
{
 
275
    int i = 0;
 
276
 
 
277
    while(nb_clusters-- && l2_table[i] == 0)
 
278
        i++;
 
279
 
 
280
    return i;
 
281
}
 
282
 
 
283
/* The crypt function is compatible with the linux cryptoloop
 
284
   algorithm for < 4 GB images. NOTE: out_buf == in_buf is
 
285
   supported */
 
286
void qcow2_encrypt_sectors(BDRVQcowState *s, int64_t sector_num,
 
287
                           uint8_t *out_buf, const uint8_t *in_buf,
 
288
                           int nb_sectors, int enc,
 
289
                           const AES_KEY *key)
 
290
{
 
291
    union {
 
292
        uint64_t ll[2];
 
293
        uint8_t b[16];
 
294
    } ivec;
 
295
    int i;
 
296
 
 
297
    for(i = 0; i < nb_sectors; i++) {
 
298
        ivec.ll[0] = cpu_to_le64(sector_num);
 
299
        ivec.ll[1] = 0;
 
300
        AES_cbc_encrypt(in_buf, out_buf, 512, key,
 
301
                        ivec.b, enc);
 
302
        sector_num++;
 
303
        in_buf += 512;
 
304
        out_buf += 512;
 
305
    }
 
306
}
 
307
 
 
308
 
 
309
static int qcow_read(BlockDriverState *bs, int64_t sector_num,
 
310
                     uint8_t *buf, int nb_sectors)
 
311
{
 
312
    BDRVQcowState *s = bs->opaque;
 
313
    int ret, index_in_cluster, n, n1;
 
314
    uint64_t cluster_offset;
 
315
 
 
316
    while (nb_sectors > 0) {
 
317
        n = nb_sectors;
 
318
        cluster_offset = qcow2_get_cluster_offset(bs, sector_num << 9, &n);
 
319
        index_in_cluster = sector_num & (s->cluster_sectors - 1);
 
320
        if (!cluster_offset) {
 
321
            if (bs->backing_hd) {
 
322
                /* read from the base image */
 
323
                n1 = qcow2_backing_read1(bs->backing_hd, sector_num, buf, n);
 
324
                if (n1 > 0) {
 
325
                    ret = bdrv_read(bs->backing_hd, sector_num, buf, n1);
 
326
                    if (ret < 0)
 
327
                        return -1;
 
328
                }
 
329
            } else {
 
330
                memset(buf, 0, 512 * n);
 
331
            }
 
332
        } else if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
 
333
            if (qcow2_decompress_cluster(s, cluster_offset) < 0)
 
334
                return -1;
 
335
            memcpy(buf, s->cluster_cache + index_in_cluster * 512, 512 * n);
 
336
        } else {
 
337
            ret = bdrv_pread(s->hd, cluster_offset + index_in_cluster * 512, buf, n * 512);
 
338
            if (ret != n * 512)
 
339
                return -1;
 
340
            if (s->crypt_method) {
 
341
                qcow2_encrypt_sectors(s, sector_num, buf, buf, n, 0,
 
342
                                &s->aes_decrypt_key);
 
343
            }
 
344
        }
 
345
        nb_sectors -= n;
 
346
        sector_num += n;
 
347
        buf += n * 512;
 
348
    }
 
349
    return 0;
 
350
}
 
351
 
 
352
static int copy_sectors(BlockDriverState *bs, uint64_t start_sect,
 
353
                        uint64_t cluster_offset, int n_start, int n_end)
 
354
{
 
355
    BDRVQcowState *s = bs->opaque;
 
356
    int n, ret;
 
357
 
 
358
    n = n_end - n_start;
 
359
    if (n <= 0)
 
360
        return 0;
 
361
    ret = qcow_read(bs, start_sect + n_start, s->cluster_data, n);
 
362
    if (ret < 0)
 
363
        return ret;
 
364
    if (s->crypt_method) {
 
365
        qcow2_encrypt_sectors(s, start_sect + n_start,
 
366
                        s->cluster_data,
 
367
                        s->cluster_data, n, 1,
 
368
                        &s->aes_encrypt_key);
 
369
    }
 
370
    ret = bdrv_write(s->hd, (cluster_offset >> 9) + n_start,
 
371
                     s->cluster_data, n);
 
372
    if (ret < 0)
 
373
        return ret;
 
374
    return 0;
 
375
}
 
376
 
 
377
 
 
378
/*
 
379
 * get_cluster_offset
 
380
 *
 
381
 * For a given offset of the disk image, return cluster offset in
 
382
 * qcow2 file.
 
383
 *
 
384
 * on entry, *num is the number of contiguous clusters we'd like to
 
385
 * access following offset.
 
386
 *
 
387
 * on exit, *num is the number of contiguous clusters we can read.
 
388
 *
 
389
 * Return 1, if the offset is found
 
390
 * Return 0, otherwise.
 
391
 *
 
392
 */
 
393
 
 
394
uint64_t qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
 
395
    int *num)
 
396
{
 
397
    BDRVQcowState *s = bs->opaque;
 
398
    int l1_index, l2_index;
 
399
    uint64_t l2_offset, *l2_table, cluster_offset;
 
400
    int l1_bits, c;
 
401
    int index_in_cluster, nb_available, nb_needed, nb_clusters;
 
402
 
 
403
    index_in_cluster = (offset >> 9) & (s->cluster_sectors - 1);
 
404
    nb_needed = *num + index_in_cluster;
 
405
 
 
406
    l1_bits = s->l2_bits + s->cluster_bits;
 
407
 
 
408
    /* compute how many bytes there are between the offset and
 
409
     * the end of the l1 entry
 
410
     */
 
411
 
 
412
    nb_available = (1 << l1_bits) - (offset & ((1 << l1_bits) - 1));
 
413
 
 
414
    /* compute the number of available sectors */
 
415
 
 
416
    nb_available = (nb_available >> 9) + index_in_cluster;
 
417
 
 
418
    if (nb_needed > nb_available) {
 
419
        nb_needed = nb_available;
 
420
    }
 
421
 
 
422
    cluster_offset = 0;
 
423
 
 
424
    /* seek the the l2 offset in the l1 table */
 
425
 
 
426
    l1_index = offset >> l1_bits;
 
427
    if (l1_index >= s->l1_size)
 
428
        goto out;
 
429
 
 
430
    l2_offset = s->l1_table[l1_index];
 
431
 
 
432
    /* seek the l2 table of the given l2 offset */
 
433
 
 
434
    if (!l2_offset)
 
435
        goto out;
 
436
 
 
437
    /* load the l2 table in memory */
 
438
 
 
439
    l2_offset &= ~QCOW_OFLAG_COPIED;
 
440
    l2_table = l2_load(bs, l2_offset);
 
441
    if (l2_table == NULL)
 
442
        return 0;
 
443
 
 
444
    /* find the cluster offset for the given disk offset */
 
445
 
 
446
    l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
 
447
    cluster_offset = be64_to_cpu(l2_table[l2_index]);
 
448
    nb_clusters = size_to_clusters(s, nb_needed << 9);
 
449
 
 
450
    if (!cluster_offset) {
 
451
        /* how many empty clusters ? */
 
452
        c = count_contiguous_free_clusters(nb_clusters, &l2_table[l2_index]);
 
453
    } else {
 
454
        /* how many allocated clusters ? */
 
455
        c = count_contiguous_clusters(nb_clusters, s->cluster_size,
 
456
                &l2_table[l2_index], 0, QCOW_OFLAG_COPIED);
 
457
    }
 
458
 
 
459
   nb_available = (c * s->cluster_sectors);
 
460
out:
 
461
    if (nb_available > nb_needed)
 
462
        nb_available = nb_needed;
 
463
 
 
464
    *num = nb_available - index_in_cluster;
 
465
 
 
466
    return cluster_offset & ~QCOW_OFLAG_COPIED;
 
467
}
 
468
 
 
469
/*
 
470
 * get_cluster_table
 
471
 *
 
472
 * for a given disk offset, load (and allocate if needed)
 
473
 * the l2 table.
 
474
 *
 
475
 * the l2 table offset in the qcow2 file and the cluster index
 
476
 * in the l2 table are given to the caller.
 
477
 *
 
478
 */
 
479
 
 
480
static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
 
481
                             uint64_t **new_l2_table,
 
482
                             uint64_t *new_l2_offset,
 
483
                             int *new_l2_index)
 
484
{
 
485
    BDRVQcowState *s = bs->opaque;
 
486
    int l1_index, l2_index, ret;
 
487
    uint64_t l2_offset, *l2_table;
 
488
 
 
489
    /* seek the the l2 offset in the l1 table */
 
490
 
 
491
    l1_index = offset >> (s->l2_bits + s->cluster_bits);
 
492
    if (l1_index >= s->l1_size) {
 
493
        ret = qcow2_grow_l1_table(bs, l1_index + 1);
 
494
        if (ret < 0)
 
495
            return 0;
 
496
    }
 
497
    l2_offset = s->l1_table[l1_index];
 
498
 
 
499
    /* seek the l2 table of the given l2 offset */
 
500
 
 
501
    if (l2_offset & QCOW_OFLAG_COPIED) {
 
502
        /* load the l2 table in memory */
 
503
        l2_offset &= ~QCOW_OFLAG_COPIED;
 
504
        l2_table = l2_load(bs, l2_offset);
 
505
        if (l2_table == NULL)
 
506
            return 0;
 
507
    } else {
 
508
        if (l2_offset)
 
509
            qcow2_free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t));
 
510
        l2_table = l2_allocate(bs, l1_index);
 
511
        if (l2_table == NULL)
 
512
            return 0;
 
513
        l2_offset = s->l1_table[l1_index] & ~QCOW_OFLAG_COPIED;
 
514
    }
 
515
 
 
516
    /* find the cluster offset for the given disk offset */
 
517
 
 
518
    l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
 
519
 
 
520
    *new_l2_table = l2_table;
 
521
    *new_l2_offset = l2_offset;
 
522
    *new_l2_index = l2_index;
 
523
 
 
524
    return 1;
 
525
}
 
526
 
 
527
/*
 
528
 * alloc_compressed_cluster_offset
 
529
 *
 
530
 * For a given offset of the disk image, return cluster offset in
 
531
 * qcow2 file.
 
532
 *
 
533
 * If the offset is not found, allocate a new compressed cluster.
 
534
 *
 
535
 * Return the cluster offset if successful,
 
536
 * Return 0, otherwise.
 
537
 *
 
538
 */
 
539
 
 
540
uint64_t qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
 
541
                                               uint64_t offset,
 
542
                                               int compressed_size)
 
543
{
 
544
    BDRVQcowState *s = bs->opaque;
 
545
    int l2_index, ret;
 
546
    uint64_t l2_offset, *l2_table, cluster_offset;
 
547
    int nb_csectors;
 
548
 
 
549
    ret = get_cluster_table(bs, offset, &l2_table, &l2_offset, &l2_index);
 
550
    if (ret == 0)
 
551
        return 0;
 
552
 
 
553
    cluster_offset = be64_to_cpu(l2_table[l2_index]);
 
554
    if (cluster_offset & QCOW_OFLAG_COPIED)
 
555
        return cluster_offset & ~QCOW_OFLAG_COPIED;
 
556
 
 
557
    if (cluster_offset)
 
558
        qcow2_free_any_clusters(bs, cluster_offset, 1);
 
559
 
 
560
    cluster_offset = qcow2_alloc_bytes(bs, compressed_size);
 
561
    nb_csectors = ((cluster_offset + compressed_size - 1) >> 9) -
 
562
                  (cluster_offset >> 9);
 
563
 
 
564
    cluster_offset |= QCOW_OFLAG_COMPRESSED |
 
565
                      ((uint64_t)nb_csectors << s->csize_shift);
 
566
 
 
567
    /* update L2 table */
 
568
 
 
569
    /* compressed clusters never have the copied flag */
 
570
 
 
571
    l2_table[l2_index] = cpu_to_be64(cluster_offset);
 
572
    if (bdrv_pwrite(s->hd,
 
573
                    l2_offset + l2_index * sizeof(uint64_t),
 
574
                    l2_table + l2_index,
 
575
                    sizeof(uint64_t)) != sizeof(uint64_t))
 
576
        return 0;
 
577
 
 
578
    return cluster_offset;
 
579
}
 
580
 
 
581
/*
 
582
 * Write L2 table updates to disk, writing whole sectors to avoid a
 
583
 * read-modify-write in bdrv_pwrite
 
584
 */
 
585
#define L2_ENTRIES_PER_SECTOR (512 / 8)
 
586
static int write_l2_entries(BDRVQcowState *s, uint64_t *l2_table,
 
587
    uint64_t l2_offset, int l2_index, int num)
 
588
{
 
589
    int l2_start_index = l2_index & ~(L1_ENTRIES_PER_SECTOR - 1);
 
590
    int start_offset = (8 * l2_index) & ~511;
 
591
    int end_offset = (8 * (l2_index + num) + 511) & ~511;
 
592
    size_t len = end_offset - start_offset;
 
593
 
 
594
    if (bdrv_pwrite(s->hd, l2_offset + start_offset, &l2_table[l2_start_index],
 
595
        len) != len)
 
596
    {
 
597
        return -1;
 
598
    }
 
599
 
 
600
    return 0;
 
601
}
 
602
 
 
603
int qcow2_alloc_cluster_link_l2(BlockDriverState *bs, uint64_t cluster_offset,
 
604
    QCowL2Meta *m)
 
605
{
 
606
    BDRVQcowState *s = bs->opaque;
 
607
    int i, j = 0, l2_index, ret;
 
608
    uint64_t *old_cluster, start_sect, l2_offset, *l2_table;
 
609
 
 
610
    if (m->nb_clusters == 0)
 
611
        return 0;
 
612
 
 
613
    old_cluster = qemu_malloc(m->nb_clusters * sizeof(uint64_t));
 
614
 
 
615
    /* copy content of unmodified sectors */
 
616
    start_sect = (m->offset & ~(s->cluster_size - 1)) >> 9;
 
617
    if (m->n_start) {
 
618
        ret = copy_sectors(bs, start_sect, cluster_offset, 0, m->n_start);
 
619
        if (ret < 0)
 
620
            goto err;
 
621
    }
 
622
 
 
623
    if (m->nb_available & (s->cluster_sectors - 1)) {
 
624
        uint64_t end = m->nb_available & ~(uint64_t)(s->cluster_sectors - 1);
 
625
        ret = copy_sectors(bs, start_sect + end, cluster_offset + (end << 9),
 
626
                m->nb_available - end, s->cluster_sectors);
 
627
        if (ret < 0)
 
628
            goto err;
 
629
    }
 
630
 
 
631
    ret = -EIO;
 
632
    /* update L2 table */
 
633
    if (!get_cluster_table(bs, m->offset, &l2_table, &l2_offset, &l2_index))
 
634
        goto err;
 
635
 
 
636
    for (i = 0; i < m->nb_clusters; i++) {
 
637
        /* if two concurrent writes happen to the same unallocated cluster
 
638
         * each write allocates separate cluster and writes data concurrently.
 
639
         * The first one to complete updates l2 table with pointer to its
 
640
         * cluster the second one has to do RMW (which is done above by
 
641
         * copy_sectors()), update l2 table with its cluster pointer and free
 
642
         * old cluster. This is what this loop does */
 
643
        if(l2_table[l2_index + i] != 0)
 
644
            old_cluster[j++] = l2_table[l2_index + i];
 
645
 
 
646
        l2_table[l2_index + i] = cpu_to_be64((cluster_offset +
 
647
                    (i << s->cluster_bits)) | QCOW_OFLAG_COPIED);
 
648
     }
 
649
 
 
650
    if (write_l2_entries(s, l2_table, l2_offset, l2_index, m->nb_clusters) < 0) {
 
651
        ret = -1;
 
652
        goto err;
 
653
    }
 
654
 
 
655
    for (i = 0; i < j; i++)
 
656
        qcow2_free_any_clusters(bs,
 
657
            be64_to_cpu(old_cluster[i]) & ~QCOW_OFLAG_COPIED, 1);
 
658
 
 
659
    ret = 0;
 
660
err:
 
661
    qemu_free(old_cluster);
 
662
    return ret;
 
663
 }
 
664
 
 
665
/*
 
666
 * alloc_cluster_offset
 
667
 *
 
668
 * For a given offset of the disk image, return cluster offset in
 
669
 * qcow2 file.
 
670
 *
 
671
 * If the offset is not found, allocate a new cluster.
 
672
 *
 
673
 * Return the cluster offset if successful,
 
674
 * Return 0, otherwise.
 
675
 *
 
676
 */
 
677
 
 
678
uint64_t qcow2_alloc_cluster_offset(BlockDriverState *bs,
 
679
                                    uint64_t offset,
 
680
                                    int n_start, int n_end,
 
681
                                    int *num, QCowL2Meta *m)
 
682
{
 
683
    BDRVQcowState *s = bs->opaque;
 
684
    int l2_index, ret;
 
685
    uint64_t l2_offset, *l2_table, cluster_offset;
 
686
    int nb_clusters, i = 0;
 
687
 
 
688
    ret = get_cluster_table(bs, offset, &l2_table, &l2_offset, &l2_index);
 
689
    if (ret == 0)
 
690
        return 0;
 
691
 
 
692
    nb_clusters = size_to_clusters(s, n_end << 9);
 
693
 
 
694
    nb_clusters = MIN(nb_clusters, s->l2_size - l2_index);
 
695
 
 
696
    cluster_offset = be64_to_cpu(l2_table[l2_index]);
 
697
 
 
698
    /* We keep all QCOW_OFLAG_COPIED clusters */
 
699
 
 
700
    if (cluster_offset & QCOW_OFLAG_COPIED) {
 
701
        nb_clusters = count_contiguous_clusters(nb_clusters, s->cluster_size,
 
702
                &l2_table[l2_index], 0, 0);
 
703
 
 
704
        cluster_offset &= ~QCOW_OFLAG_COPIED;
 
705
        m->nb_clusters = 0;
 
706
 
 
707
        goto out;
 
708
    }
 
709
 
 
710
    /* for the moment, multiple compressed clusters are not managed */
 
711
 
 
712
    if (cluster_offset & QCOW_OFLAG_COMPRESSED)
 
713
        nb_clusters = 1;
 
714
 
 
715
    /* how many available clusters ? */
 
716
 
 
717
    while (i < nb_clusters) {
 
718
        i += count_contiguous_clusters(nb_clusters - i, s->cluster_size,
 
719
                &l2_table[l2_index], i, 0);
 
720
 
 
721
        if(be64_to_cpu(l2_table[l2_index + i]))
 
722
            break;
 
723
 
 
724
        i += count_contiguous_free_clusters(nb_clusters - i,
 
725
                &l2_table[l2_index + i]);
 
726
 
 
727
        cluster_offset = be64_to_cpu(l2_table[l2_index + i]);
 
728
 
 
729
        if ((cluster_offset & QCOW_OFLAG_COPIED) ||
 
730
                (cluster_offset & QCOW_OFLAG_COMPRESSED))
 
731
            break;
 
732
    }
 
733
    nb_clusters = i;
 
734
 
 
735
    /* allocate a new cluster */
 
736
 
 
737
    cluster_offset = qcow2_alloc_clusters(bs, nb_clusters * s->cluster_size);
 
738
 
 
739
    /* save info needed for meta data update */
 
740
    m->offset = offset;
 
741
    m->n_start = n_start;
 
742
    m->nb_clusters = nb_clusters;
 
743
 
 
744
out:
 
745
    m->nb_available = MIN(nb_clusters << (s->cluster_bits - 9), n_end);
 
746
 
 
747
    *num = m->nb_available - n_start;
 
748
 
 
749
    return cluster_offset;
 
750
}
 
751
 
 
752
static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
 
753
                             const uint8_t *buf, int buf_size)
 
754
{
 
755
    z_stream strm1, *strm = &strm1;
 
756
    int ret, out_len;
 
757
 
 
758
    memset(strm, 0, sizeof(*strm));
 
759
 
 
760
    strm->next_in = (uint8_t *)buf;
 
761
    strm->avail_in = buf_size;
 
762
    strm->next_out = out_buf;
 
763
    strm->avail_out = out_buf_size;
 
764
 
 
765
    ret = inflateInit2(strm, -12);
 
766
    if (ret != Z_OK)
 
767
        return -1;
 
768
    ret = inflate(strm, Z_FINISH);
 
769
    out_len = strm->next_out - out_buf;
 
770
    if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
 
771
        out_len != out_buf_size) {
 
772
        inflateEnd(strm);
 
773
        return -1;
 
774
    }
 
775
    inflateEnd(strm);
 
776
    return 0;
 
777
}
 
778
 
 
779
int qcow2_decompress_cluster(BDRVQcowState *s, uint64_t cluster_offset)
 
780
{
 
781
    int ret, csize, nb_csectors, sector_offset;
 
782
    uint64_t coffset;
 
783
 
 
784
    coffset = cluster_offset & s->cluster_offset_mask;
 
785
    if (s->cluster_cache_offset != coffset) {
 
786
        nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
 
787
        sector_offset = coffset & 511;
 
788
        csize = nb_csectors * 512 - sector_offset;
 
789
        ret = bdrv_read(s->hd, coffset >> 9, s->cluster_data, nb_csectors);
 
790
        if (ret < 0) {
 
791
            return -1;
 
792
        }
 
793
        if (decompress_buffer(s->cluster_cache, s->cluster_size,
 
794
                              s->cluster_data + sector_offset, csize) < 0) {
 
795
            return -1;
 
796
        }
 
797
        s->cluster_cache_offset = coffset;
 
798
    }
 
799
    return 0;
 
800
}