2 * Block driver for the COW format
4 * Copyright (c) 2004 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
24 #include "qemu-common.h"
25 #include "block/block_int.h"
26 #include "qemu/module.h"
28 /**************************************************************/
29 /* COW block driver using file system holes */
31 /* user mode linux compatible COW file */
32 #define COW_MAGIC 0x4f4f4f4d /* MOOO */
35 struct cow_header_v2
{
38 char backing_file
[1024];
44 typedef struct BDRVCowState
{
46 int64_t cow_sectors_offset
;
49 static int cow_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
51 const struct cow_header_v2
*cow_header
= (const void *)buf
;
53 if (buf_size
>= sizeof(struct cow_header_v2
) &&
54 be32_to_cpu(cow_header
->magic
) == COW_MAGIC
&&
55 be32_to_cpu(cow_header
->version
) == COW_VERSION
)
61 static int cow_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
64 BDRVCowState
*s
= bs
->opaque
;
65 struct cow_header_v2 cow_header
;
70 /* see if it is a cow image */
71 ret
= bdrv_pread(bs
->file
, 0, &cow_header
, sizeof(cow_header
));
76 if (be32_to_cpu(cow_header
.magic
) != COW_MAGIC
) {
81 if (be32_to_cpu(cow_header
.version
) != COW_VERSION
) {
83 snprintf(version
, sizeof(version
),
84 "COW version %d", cow_header
.version
);
85 qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE
,
86 bs
->device_name
, "cow", version
);
92 size
= be64_to_cpu(cow_header
.size
);
93 bs
->total_sectors
= size
/ 512;
95 pstrcpy(bs
->backing_file
, sizeof(bs
->backing_file
),
96 cow_header
.backing_file
);
98 bitmap_size
= ((bs
->total_sectors
+ 7) >> 3) + sizeof(cow_header
);
99 s
->cow_sectors_offset
= (bitmap_size
+ 511) & ~511;
100 qemu_co_mutex_init(&s
->lock
);
107 * XXX(hch): right now these functions are extremely inefficient.
108 * We should just read the whole bitmap we'll need in one go instead.
110 static inline int cow_set_bit(BlockDriverState
*bs
, int64_t bitnum
, bool *first
)
112 uint64_t offset
= sizeof(struct cow_header_v2
) + bitnum
/ 8;
116 ret
= bdrv_pread(bs
->file
, offset
, &bitmap
, sizeof(bitmap
));
121 if (bitmap
& (1 << (bitnum
% 8))) {
126 ret
= bdrv_flush(bs
->file
);
133 bitmap
|= (1 << (bitnum
% 8));
135 ret
= bdrv_pwrite(bs
->file
, offset
, &bitmap
, sizeof(bitmap
));
142 #define BITS_PER_BITMAP_SECTOR (512 * 8)
144 /* Cannot use bitmap.c on big-endian machines. */
145 static int cow_test_bit(int64_t bitnum
, const uint8_t *bitmap
)
147 return (bitmap
[bitnum
/ 8] & (1 << (bitnum
& 7))) != 0;
150 static int cow_find_streak(const uint8_t *bitmap
, int value
, int start
, int nb_sectors
)
152 int streak_value
= value
? 0xFF : 0;
153 int last
= MIN(start
+ nb_sectors
, BITS_PER_BITMAP_SECTOR
);
155 while (bitnum
< last
) {
156 if ((bitnum
& 7) == 0 && bitmap
[bitnum
/ 8] == streak_value
) {
160 if (cow_test_bit(bitnum
, bitmap
) == value
) {
166 return MIN(bitnum
, last
) - start
;
169 /* Return true if first block has been changed (ie. current version is
170 * in COW file). Set the number of continuous blocks for which that
172 static int coroutine_fn
cow_co_is_allocated(BlockDriverState
*bs
,
173 int64_t sector_num
, int nb_sectors
, int *num_same
)
175 int64_t bitnum
= sector_num
+ sizeof(struct cow_header_v2
) * 8;
176 uint64_t offset
= (bitnum
/ 8) & -BDRV_SECTOR_SIZE
;
177 uint8_t bitmap
[BDRV_SECTOR_SIZE
];
181 ret
= bdrv_pread(bs
->file
, offset
, &bitmap
, sizeof(bitmap
));
186 bitnum
&= BITS_PER_BITMAP_SECTOR
- 1;
187 changed
= cow_test_bit(bitnum
, bitmap
);
188 *num_same
= cow_find_streak(bitmap
, changed
, bitnum
, nb_sectors
);
192 static int64_t coroutine_fn
cow_co_get_block_status(BlockDriverState
*bs
,
193 int64_t sector_num
, int nb_sectors
, int *num_same
)
195 BDRVCowState
*s
= bs
->opaque
;
196 int ret
= cow_co_is_allocated(bs
, sector_num
, nb_sectors
, num_same
);
197 int64_t offset
= s
->cow_sectors_offset
+ (sector_num
<< BDRV_SECTOR_BITS
);
201 return (ret
? BDRV_BLOCK_DATA
: 0) | offset
| BDRV_BLOCK_OFFSET_VALID
;
204 static int cow_update_bitmap(BlockDriverState
*bs
, int64_t sector_num
,
211 for (i
= 0; i
< nb_sectors
; i
++) {
212 error
= cow_set_bit(bs
, sector_num
+ i
, &first
);
221 static int coroutine_fn
cow_read(BlockDriverState
*bs
, int64_t sector_num
,
222 uint8_t *buf
, int nb_sectors
)
224 BDRVCowState
*s
= bs
->opaque
;
227 while (nb_sectors
> 0) {
228 ret
= cow_co_is_allocated(bs
, sector_num
, nb_sectors
, &n
);
233 ret
= bdrv_pread(bs
->file
,
234 s
->cow_sectors_offset
+ sector_num
* 512,
240 if (bs
->backing_hd
) {
241 /* read from the base image */
242 ret
= bdrv_read(bs
->backing_hd
, sector_num
, buf
, n
);
247 memset(buf
, 0, n
* 512);
257 static coroutine_fn
int cow_co_read(BlockDriverState
*bs
, int64_t sector_num
,
258 uint8_t *buf
, int nb_sectors
)
261 BDRVCowState
*s
= bs
->opaque
;
262 qemu_co_mutex_lock(&s
->lock
);
263 ret
= cow_read(bs
, sector_num
, buf
, nb_sectors
);
264 qemu_co_mutex_unlock(&s
->lock
);
268 static int cow_write(BlockDriverState
*bs
, int64_t sector_num
,
269 const uint8_t *buf
, int nb_sectors
)
271 BDRVCowState
*s
= bs
->opaque
;
274 ret
= bdrv_pwrite(bs
->file
, s
->cow_sectors_offset
+ sector_num
* 512,
275 buf
, nb_sectors
* 512);
280 return cow_update_bitmap(bs
, sector_num
, nb_sectors
);
283 static coroutine_fn
int cow_co_write(BlockDriverState
*bs
, int64_t sector_num
,
284 const uint8_t *buf
, int nb_sectors
)
287 BDRVCowState
*s
= bs
->opaque
;
288 qemu_co_mutex_lock(&s
->lock
);
289 ret
= cow_write(bs
, sector_num
, buf
, nb_sectors
);
290 qemu_co_mutex_unlock(&s
->lock
);
294 static void cow_close(BlockDriverState
*bs
)
298 static int cow_create(const char *filename
, QEMUOptionParameter
*options
,
301 struct cow_header_v2 cow_header
;
303 int64_t image_sectors
= 0;
304 const char *image_filename
= NULL
;
305 Error
*local_err
= NULL
;
307 BlockDriverState
*cow_bs
;
309 /* Read out options */
310 while (options
&& options
->name
) {
311 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
312 image_sectors
= options
->value
.n
/ 512;
313 } else if (!strcmp(options
->name
, BLOCK_OPT_BACKING_FILE
)) {
314 image_filename
= options
->value
.s
;
319 ret
= bdrv_create_file(filename
, options
, &local_err
);
321 qerror_report_err(local_err
);
322 error_free(local_err
);
326 ret
= bdrv_file_open(&cow_bs
, filename
, NULL
, BDRV_O_RDWR
, &local_err
);
328 qerror_report_err(local_err
);
329 error_free(local_err
);
333 memset(&cow_header
, 0, sizeof(cow_header
));
334 cow_header
.magic
= cpu_to_be32(COW_MAGIC
);
335 cow_header
.version
= cpu_to_be32(COW_VERSION
);
336 if (image_filename
) {
337 /* Note: if no file, we put a dummy mtime */
338 cow_header
.mtime
= cpu_to_be32(0);
340 if (stat(image_filename
, &st
) != 0) {
343 cow_header
.mtime
= cpu_to_be32(st
.st_mtime
);
345 pstrcpy(cow_header
.backing_file
, sizeof(cow_header
.backing_file
),
348 cow_header
.sectorsize
= cpu_to_be32(512);
349 cow_header
.size
= cpu_to_be64(image_sectors
* 512);
350 ret
= bdrv_pwrite(cow_bs
, 0, &cow_header
, sizeof(cow_header
));
355 /* resize to include at least all the bitmap */
356 ret
= bdrv_truncate(cow_bs
,
357 sizeof(cow_header
) + ((image_sectors
+ 7) >> 3));
367 static QEMUOptionParameter cow_create_options
[] = {
369 .name
= BLOCK_OPT_SIZE
,
371 .help
= "Virtual disk size"
374 .name
= BLOCK_OPT_BACKING_FILE
,
376 .help
= "File name of a base image"
381 static BlockDriver bdrv_cow
= {
382 .format_name
= "cow",
383 .instance_size
= sizeof(BDRVCowState
),
385 .bdrv_probe
= cow_probe
,
386 .bdrv_open
= cow_open
,
387 .bdrv_close
= cow_close
,
388 .bdrv_create
= cow_create
,
389 .bdrv_has_zero_init
= bdrv_has_zero_init_1
,
391 .bdrv_read
= cow_co_read
,
392 .bdrv_write
= cow_co_write
,
393 .bdrv_co_get_block_status
= cow_co_get_block_status
,
395 .create_options
= cow_create_options
,
398 static void bdrv_cow_init(void)
400 bdrv_register(&bdrv_cow
);
403 block_init(bdrv_cow_init
);