block: Catch backing files assigned to non-COW drivers
[qemu.git] / block / cow.c
1 /*
2 * Block driver for the COW format
3 *
4 * Copyright (c) 2004 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
28 /**************************************************************/
29 /* COW block driver using file system holes */
30
31 /* user mode linux compatible COW file */
32 #define COW_MAGIC 0x4f4f4f4d /* MOOO */
33 #define COW_VERSION 2
34
35 struct cow_header_v2 {
36 uint32_t magic;
37 uint32_t version;
38 char backing_file[1024];
39 int32_t mtime;
40 uint64_t size;
41 uint32_t sectorsize;
42 };
43
44 typedef struct BDRVCowState {
45 CoMutex lock;
46 int64_t cow_sectors_offset;
47 } BDRVCowState;
48
49 static int cow_probe(const uint8_t *buf, int buf_size, const char *filename)
50 {
51 const struct cow_header_v2 *cow_header = (const void *)buf;
52
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)
56 return 100;
57 else
58 return 0;
59 }
60
61 static int cow_open(BlockDriverState *bs, QDict *options, int flags,
62 Error **errp)
63 {
64 BDRVCowState *s = bs->opaque;
65 struct cow_header_v2 cow_header;
66 int bitmap_size;
67 int64_t size;
68 int ret;
69
70 /* see if it is a cow image */
71 ret = bdrv_pread(bs->file, 0, &cow_header, sizeof(cow_header));
72 if (ret < 0) {
73 goto fail;
74 }
75
76 if (be32_to_cpu(cow_header.magic) != COW_MAGIC) {
77 error_setg(errp, "Image not in COW format");
78 ret = -EINVAL;
79 goto fail;
80 }
81
82 if (be32_to_cpu(cow_header.version) != COW_VERSION) {
83 char version[64];
84 snprintf(version, sizeof(version),
85 "COW version %" PRIu32, cow_header.version);
86 error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
87 bs->device_name, "cow", version);
88 ret = -ENOTSUP;
89 goto fail;
90 }
91
92 /* cow image found */
93 size = be64_to_cpu(cow_header.size);
94 bs->total_sectors = size / 512;
95
96 pstrcpy(bs->backing_file, sizeof(bs->backing_file),
97 cow_header.backing_file);
98
99 bitmap_size = ((bs->total_sectors + 7) >> 3) + sizeof(cow_header);
100 s->cow_sectors_offset = (bitmap_size + 511) & ~511;
101 qemu_co_mutex_init(&s->lock);
102 return 0;
103 fail:
104 return ret;
105 }
106
107 static inline void cow_set_bits(uint8_t *bitmap, int start, int64_t nb_sectors)
108 {
109 int64_t bitnum = start, last = start + nb_sectors;
110 while (bitnum < last) {
111 if ((bitnum & 7) == 0 && bitnum + 8 <= last) {
112 bitmap[bitnum / 8] = 0xFF;
113 bitnum += 8;
114 continue;
115 }
116 bitmap[bitnum/8] |= (1 << (bitnum % 8));
117 bitnum++;
118 }
119 }
120
121 #define BITS_PER_BITMAP_SECTOR (512 * 8)
122
123 /* Cannot use bitmap.c on big-endian machines. */
124 static int cow_test_bit(int64_t bitnum, const uint8_t *bitmap)
125 {
126 return (bitmap[bitnum / 8] & (1 << (bitnum & 7))) != 0;
127 }
128
129 static int cow_find_streak(const uint8_t *bitmap, int value, int start, int nb_sectors)
130 {
131 int streak_value = value ? 0xFF : 0;
132 int last = MIN(start + nb_sectors, BITS_PER_BITMAP_SECTOR);
133 int bitnum = start;
134 while (bitnum < last) {
135 if ((bitnum & 7) == 0 && bitmap[bitnum / 8] == streak_value) {
136 bitnum += 8;
137 continue;
138 }
139 if (cow_test_bit(bitnum, bitmap) == value) {
140 bitnum++;
141 continue;
142 }
143 break;
144 }
145 return MIN(bitnum, last) - start;
146 }
147
148 /* Return true if first block has been changed (ie. current version is
149 * in COW file). Set the number of continuous blocks for which that
150 * is true. */
151 static int coroutine_fn cow_co_is_allocated(BlockDriverState *bs,
152 int64_t sector_num, int nb_sectors, int *num_same)
153 {
154 int64_t bitnum = sector_num + sizeof(struct cow_header_v2) * 8;
155 uint64_t offset = (bitnum / 8) & -BDRV_SECTOR_SIZE;
156 bool first = true;
157 int changed = 0, same = 0;
158
159 do {
160 int ret;
161 uint8_t bitmap[BDRV_SECTOR_SIZE];
162
163 bitnum &= BITS_PER_BITMAP_SECTOR - 1;
164 int sector_bits = MIN(nb_sectors, BITS_PER_BITMAP_SECTOR - bitnum);
165
166 ret = bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap));
167 if (ret < 0) {
168 return ret;
169 }
170
171 if (first) {
172 changed = cow_test_bit(bitnum, bitmap);
173 first = false;
174 }
175
176 same += cow_find_streak(bitmap, changed, bitnum, nb_sectors);
177
178 bitnum += sector_bits;
179 nb_sectors -= sector_bits;
180 offset += BDRV_SECTOR_SIZE;
181 } while (nb_sectors);
182
183 *num_same = same;
184 return changed;
185 }
186
187 static int64_t coroutine_fn cow_co_get_block_status(BlockDriverState *bs,
188 int64_t sector_num, int nb_sectors, int *num_same)
189 {
190 BDRVCowState *s = bs->opaque;
191 int ret = cow_co_is_allocated(bs, sector_num, nb_sectors, num_same);
192 int64_t offset = s->cow_sectors_offset + (sector_num << BDRV_SECTOR_BITS);
193 if (ret < 0) {
194 return ret;
195 }
196 return (ret ? BDRV_BLOCK_DATA : 0) | offset | BDRV_BLOCK_OFFSET_VALID;
197 }
198
199 static int cow_update_bitmap(BlockDriverState *bs, int64_t sector_num,
200 int nb_sectors)
201 {
202 int64_t bitnum = sector_num + sizeof(struct cow_header_v2) * 8;
203 uint64_t offset = (bitnum / 8) & -BDRV_SECTOR_SIZE;
204 bool first = true;
205 int sector_bits;
206
207 for ( ; nb_sectors;
208 bitnum += sector_bits,
209 nb_sectors -= sector_bits,
210 offset += BDRV_SECTOR_SIZE) {
211 int ret, set;
212 uint8_t bitmap[BDRV_SECTOR_SIZE];
213
214 bitnum &= BITS_PER_BITMAP_SECTOR - 1;
215 sector_bits = MIN(nb_sectors, BITS_PER_BITMAP_SECTOR - bitnum);
216
217 ret = bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap));
218 if (ret < 0) {
219 return ret;
220 }
221
222 /* Skip over any already set bits */
223 set = cow_find_streak(bitmap, 1, bitnum, sector_bits);
224 bitnum += set;
225 sector_bits -= set;
226 nb_sectors -= set;
227 if (!sector_bits) {
228 continue;
229 }
230
231 if (first) {
232 ret = bdrv_flush(bs->file);
233 if (ret < 0) {
234 return ret;
235 }
236 first = false;
237 }
238
239 cow_set_bits(bitmap, bitnum, sector_bits);
240
241 ret = bdrv_pwrite(bs->file, offset, &bitmap, sizeof(bitmap));
242 if (ret < 0) {
243 return ret;
244 }
245 }
246
247 return 0;
248 }
249
250 static int coroutine_fn cow_read(BlockDriverState *bs, int64_t sector_num,
251 uint8_t *buf, int nb_sectors)
252 {
253 BDRVCowState *s = bs->opaque;
254 int ret, n;
255
256 while (nb_sectors > 0) {
257 ret = cow_co_is_allocated(bs, sector_num, nb_sectors, &n);
258 if (ret < 0) {
259 return ret;
260 }
261 if (ret) {
262 ret = bdrv_pread(bs->file,
263 s->cow_sectors_offset + sector_num * 512,
264 buf, n * 512);
265 if (ret < 0) {
266 return ret;
267 }
268 } else {
269 if (bs->backing_hd) {
270 /* read from the base image */
271 ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
272 if (ret < 0) {
273 return ret;
274 }
275 } else {
276 memset(buf, 0, n * 512);
277 }
278 }
279 nb_sectors -= n;
280 sector_num += n;
281 buf += n * 512;
282 }
283 return 0;
284 }
285
286 static coroutine_fn int cow_co_read(BlockDriverState *bs, int64_t sector_num,
287 uint8_t *buf, int nb_sectors)
288 {
289 int ret;
290 BDRVCowState *s = bs->opaque;
291 qemu_co_mutex_lock(&s->lock);
292 ret = cow_read(bs, sector_num, buf, nb_sectors);
293 qemu_co_mutex_unlock(&s->lock);
294 return ret;
295 }
296
297 static int cow_write(BlockDriverState *bs, int64_t sector_num,
298 const uint8_t *buf, int nb_sectors)
299 {
300 BDRVCowState *s = bs->opaque;
301 int ret;
302
303 ret = bdrv_pwrite(bs->file, s->cow_sectors_offset + sector_num * 512,
304 buf, nb_sectors * 512);
305 if (ret < 0) {
306 return ret;
307 }
308
309 return cow_update_bitmap(bs, sector_num, nb_sectors);
310 }
311
312 static coroutine_fn int cow_co_write(BlockDriverState *bs, int64_t sector_num,
313 const uint8_t *buf, int nb_sectors)
314 {
315 int ret;
316 BDRVCowState *s = bs->opaque;
317 qemu_co_mutex_lock(&s->lock);
318 ret = cow_write(bs, sector_num, buf, nb_sectors);
319 qemu_co_mutex_unlock(&s->lock);
320 return ret;
321 }
322
323 static void cow_close(BlockDriverState *bs)
324 {
325 }
326
327 static int cow_create(const char *filename, QemuOpts *opts, Error **errp)
328 {
329 struct cow_header_v2 cow_header;
330 struct stat st;
331 int64_t image_sectors = 0;
332 char *image_filename = NULL;
333 Error *local_err = NULL;
334 int ret;
335 BlockDriverState *cow_bs;
336
337 /* Read out options */
338 image_sectors = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0) / 512;
339 image_filename = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
340
341 ret = bdrv_create_file(filename, opts, &local_err);
342 if (ret < 0) {
343 error_propagate(errp, local_err);
344 goto exit;
345 }
346
347 cow_bs = NULL;
348 ret = bdrv_open(&cow_bs, filename, NULL, NULL,
349 BDRV_O_RDWR | BDRV_O_PROTOCOL, NULL, &local_err);
350 if (ret < 0) {
351 error_propagate(errp, local_err);
352 goto exit;
353 }
354
355 memset(&cow_header, 0, sizeof(cow_header));
356 cow_header.magic = cpu_to_be32(COW_MAGIC);
357 cow_header.version = cpu_to_be32(COW_VERSION);
358 if (image_filename) {
359 /* Note: if no file, we put a dummy mtime */
360 cow_header.mtime = cpu_to_be32(0);
361
362 if (stat(image_filename, &st) != 0) {
363 goto mtime_fail;
364 }
365 cow_header.mtime = cpu_to_be32(st.st_mtime);
366 mtime_fail:
367 pstrcpy(cow_header.backing_file, sizeof(cow_header.backing_file),
368 image_filename);
369 }
370 cow_header.sectorsize = cpu_to_be32(512);
371 cow_header.size = cpu_to_be64(image_sectors * 512);
372 ret = bdrv_pwrite(cow_bs, 0, &cow_header, sizeof(cow_header));
373 if (ret < 0) {
374 goto exit;
375 }
376
377 /* resize to include at least all the bitmap */
378 ret = bdrv_truncate(cow_bs,
379 sizeof(cow_header) + ((image_sectors + 7) >> 3));
380 if (ret < 0) {
381 goto exit;
382 }
383
384 exit:
385 g_free(image_filename);
386 bdrv_unref(cow_bs);
387 return ret;
388 }
389
390 static QemuOptsList cow_create_opts = {
391 .name = "cow-create-opts",
392 .head = QTAILQ_HEAD_INITIALIZER(cow_create_opts.head),
393 .desc = {
394 {
395 .name = BLOCK_OPT_SIZE,
396 .type = QEMU_OPT_SIZE,
397 .help = "Virtual disk size"
398 },
399 {
400 .name = BLOCK_OPT_BACKING_FILE,
401 .type = QEMU_OPT_STRING,
402 .help = "File name of a base image"
403 },
404 { /* end of list */ }
405 }
406 };
407
408 static BlockDriver bdrv_cow = {
409 .format_name = "cow",
410 .instance_size = sizeof(BDRVCowState),
411
412 .bdrv_probe = cow_probe,
413 .bdrv_open = cow_open,
414 .bdrv_close = cow_close,
415 .bdrv_create = cow_create,
416 .bdrv_has_zero_init = bdrv_has_zero_init_1,
417 .supports_backing = true,
418
419 .bdrv_read = cow_co_read,
420 .bdrv_write = cow_co_write,
421 .bdrv_co_get_block_status = cow_co_get_block_status,
422
423 .create_opts = &cow_create_opts,
424 };
425
426 static void bdrv_cow_init(void)
427 {
428 bdrv_register(&bdrv_cow);
429 }
430
431 block_init(bdrv_cow_init);