]>
Commit | Line | Data |
---|---|---|
ea2384d3 FB |
1 | /* |
2 | * Block driver for the COW format | |
5fafdf24 | 3 | * |
ea2384d3 | 4 | * Copyright (c) 2004 Fabrice Bellard |
5fafdf24 | 5 | * |
ea2384d3 FB |
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 | */ | |
faf07963 | 24 | #include "qemu-common.h" |
737e150e | 25 | #include "block/block_int.h" |
1de7afc9 | 26 | #include "qemu/module.h" |
ea2384d3 FB |
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 { | |
848c66e8 | 45 | CoMutex lock; |
ea2384d3 FB |
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 | ||
712e7874 FB |
53 | if (buf_size >= sizeof(struct cow_header_v2) && |
54 | be32_to_cpu(cow_header->magic) == COW_MAGIC && | |
5fafdf24 | 55 | be32_to_cpu(cow_header->version) == COW_VERSION) |
ea2384d3 FB |
56 | return 100; |
57 | else | |
58 | return 0; | |
59 | } | |
60 | ||
1a86938f | 61 | static int cow_open(BlockDriverState *bs, QDict *options, int flags) |
ea2384d3 FB |
62 | { |
63 | BDRVCowState *s = bs->opaque; | |
ea2384d3 | 64 | struct cow_header_v2 cow_header; |
893a9cb4 | 65 | int bitmap_size; |
ea2384d3 | 66 | int64_t size; |
16d2fc00 | 67 | int ret; |
ea2384d3 | 68 | |
ea2384d3 | 69 | /* see if it is a cow image */ |
16d2fc00 LZH |
70 | ret = bdrv_pread(bs->file, 0, &cow_header, sizeof(cow_header)); |
71 | if (ret < 0) { | |
72 | goto fail; | |
73 | } | |
74 | ||
75 | if (be32_to_cpu(cow_header.magic) != COW_MAGIC) { | |
15bac0d5 | 76 | ret = -EMEDIUMTYPE; |
ea2384d3 FB |
77 | goto fail; |
78 | } | |
79 | ||
16d2fc00 LZH |
80 | if (be32_to_cpu(cow_header.version) != COW_VERSION) { |
81 | char version[64]; | |
82 | snprintf(version, sizeof(version), | |
83 | "COW version %d", cow_header.version); | |
84 | qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, | |
85 | bs->device_name, "cow", version); | |
86 | ret = -ENOTSUP; | |
ea2384d3 FB |
87 | goto fail; |
88 | } | |
3b46e624 | 89 | |
ea2384d3 FB |
90 | /* cow image found */ |
91 | size = be64_to_cpu(cow_header.size); | |
92 | bs->total_sectors = size / 512; | |
93 | ||
5fafdf24 | 94 | pstrcpy(bs->backing_file, sizeof(bs->backing_file), |
ea2384d3 | 95 | cow_header.backing_file); |
3b46e624 | 96 | |
893a9cb4 CH |
97 | bitmap_size = ((bs->total_sectors + 7) >> 3) + sizeof(cow_header); |
98 | s->cow_sectors_offset = (bitmap_size + 511) & ~511; | |
848c66e8 | 99 | qemu_co_mutex_init(&s->lock); |
ea2384d3 FB |
100 | return 0; |
101 | fail: | |
16d2fc00 | 102 | return ret; |
ea2384d3 FB |
103 | } |
104 | ||
893a9cb4 | 105 | /* |
4e35b92a | 106 | * XXX(hch): right now these functions are extremely inefficient. |
893a9cb4 CH |
107 | * We should just read the whole bitmap we'll need in one go instead. |
108 | */ | |
26ae9804 | 109 | static inline int cow_set_bit(BlockDriverState *bs, int64_t bitnum, bool *first) |
ea2384d3 | 110 | { |
893a9cb4 CH |
111 | uint64_t offset = sizeof(struct cow_header_v2) + bitnum / 8; |
112 | uint8_t bitmap; | |
b0ad5a45 | 113 | int ret; |
893a9cb4 | 114 | |
b0ad5a45 KW |
115 | ret = bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap)); |
116 | if (ret < 0) { | |
117 | return ret; | |
893a9cb4 CH |
118 | } |
119 | ||
26ae9804 PB |
120 | if (bitmap & (1 << (bitnum % 8))) { |
121 | return 0; | |
122 | } | |
123 | ||
124 | if (*first) { | |
125 | ret = bdrv_flush(bs->file); | |
126 | if (ret < 0) { | |
127 | return ret; | |
128 | } | |
129 | *first = false; | |
130 | } | |
131 | ||
893a9cb4 CH |
132 | bitmap |= (1 << (bitnum % 8)); |
133 | ||
26ae9804 | 134 | ret = bdrv_pwrite(bs->file, offset, &bitmap, sizeof(bitmap)); |
b0ad5a45 KW |
135 | if (ret < 0) { |
136 | return ret; | |
893a9cb4 CH |
137 | } |
138 | return 0; | |
ea2384d3 FB |
139 | } |
140 | ||
276cbc7f PB |
141 | #define BITS_PER_BITMAP_SECTOR (512 * 8) |
142 | ||
143 | /* Cannot use bitmap.c on big-endian machines. */ | |
144 | static int cow_test_bit(int64_t bitnum, const uint8_t *bitmap) | |
ea2384d3 | 145 | { |
276cbc7f PB |
146 | return (bitmap[bitnum / 8] & (1 << (bitnum & 7))) != 0; |
147 | } | |
ea2384d3 | 148 | |
276cbc7f PB |
149 | static int cow_find_streak(const uint8_t *bitmap, int value, int start, int nb_sectors) |
150 | { | |
151 | int streak_value = value ? 0xFF : 0; | |
152 | int last = MIN(start + nb_sectors, BITS_PER_BITMAP_SECTOR); | |
153 | int bitnum = start; | |
154 | while (bitnum < last) { | |
155 | if ((bitnum & 7) == 0 && bitmap[bitnum / 8] == streak_value) { | |
156 | bitnum += 8; | |
157 | continue; | |
158 | } | |
159 | if (cow_test_bit(bitnum, bitmap) == value) { | |
160 | bitnum++; | |
161 | continue; | |
162 | } | |
163 | break; | |
893a9cb4 | 164 | } |
276cbc7f | 165 | return MIN(bitnum, last) - start; |
893a9cb4 | 166 | } |
ea2384d3 FB |
167 | |
168 | /* Return true if first block has been changed (ie. current version is | |
169 | * in COW file). Set the number of continuous blocks for which that | |
170 | * is true. */ | |
81145834 SH |
171 | static int coroutine_fn cow_co_is_allocated(BlockDriverState *bs, |
172 | int64_t sector_num, int nb_sectors, int *num_same) | |
ea2384d3 | 173 | { |
276cbc7f PB |
174 | int64_t bitnum = sector_num + sizeof(struct cow_header_v2) * 8; |
175 | uint64_t offset = (bitnum / 8) & -BDRV_SECTOR_SIZE; | |
176 | uint8_t bitmap[BDRV_SECTOR_SIZE]; | |
177 | int ret; | |
ea2384d3 FB |
178 | int changed; |
179 | ||
276cbc7f PB |
180 | ret = bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap)); |
181 | if (ret < 0) { | |
182 | return ret; | |
ea2384d3 FB |
183 | } |
184 | ||
276cbc7f PB |
185 | bitnum &= BITS_PER_BITMAP_SECTOR - 1; |
186 | changed = cow_test_bit(bitnum, bitmap); | |
187 | *num_same = cow_find_streak(bitmap, changed, bitnum, nb_sectors); | |
ea2384d3 FB |
188 | return changed; |
189 | } | |
190 | ||
b6b8a333 PB |
191 | static int64_t coroutine_fn cow_co_get_block_status(BlockDriverState *bs, |
192 | int64_t sector_num, int nb_sectors, int *num_same) | |
193 | { | |
4bc74be9 PB |
194 | BDRVCowState *s = bs->opaque; |
195 | int ret = cow_co_is_allocated(bs, sector_num, nb_sectors, num_same); | |
196 | int64_t offset = s->cow_sectors_offset + (sector_num << BDRV_SECTOR_BITS); | |
197 | if (ret < 0) { | |
198 | return ret; | |
199 | } | |
200 | return (ret ? BDRV_BLOCK_DATA : 0) | offset | BDRV_BLOCK_OFFSET_VALID; | |
b6b8a333 PB |
201 | } |
202 | ||
893a9cb4 CH |
203 | static int cow_update_bitmap(BlockDriverState *bs, int64_t sector_num, |
204 | int nb_sectors) | |
ea2384d3 | 205 | { |
893a9cb4 CH |
206 | int error = 0; |
207 | int i; | |
26ae9804 | 208 | bool first = true; |
893a9cb4 CH |
209 | |
210 | for (i = 0; i < nb_sectors; i++) { | |
26ae9804 | 211 | error = cow_set_bit(bs, sector_num + i, &first); |
893a9cb4 CH |
212 | if (error) { |
213 | break; | |
214 | } | |
215 | } | |
216 | ||
217 | return error; | |
ea2384d3 FB |
218 | } |
219 | ||
e94d1387 SH |
220 | static int coroutine_fn cow_read(BlockDriverState *bs, int64_t sector_num, |
221 | uint8_t *buf, int nb_sectors) | |
ea2384d3 FB |
222 | { |
223 | BDRVCowState *s = bs->opaque; | |
224 | int ret, n; | |
3b46e624 | 225 | |
ea2384d3 | 226 | while (nb_sectors > 0) { |
d663640c PB |
227 | ret = cow_co_is_allocated(bs, sector_num, nb_sectors, &n); |
228 | if (ret < 0) { | |
229 | return ret; | |
230 | } | |
231 | if (ret) { | |
2063392a CH |
232 | ret = bdrv_pread(bs->file, |
233 | s->cow_sectors_offset + sector_num * 512, | |
234 | buf, n * 512); | |
16d2fc00 LZH |
235 | if (ret < 0) { |
236 | return ret; | |
237 | } | |
ea2384d3 | 238 | } else { |
83f64091 FB |
239 | if (bs->backing_hd) { |
240 | /* read from the base image */ | |
241 | ret = bdrv_read(bs->backing_hd, sector_num, buf, n); | |
16d2fc00 LZH |
242 | if (ret < 0) { |
243 | return ret; | |
244 | } | |
83f64091 | 245 | } else { |
16d2fc00 LZH |
246 | memset(buf, 0, n * 512); |
247 | } | |
83f64091 | 248 | } |
ea2384d3 FB |
249 | nb_sectors -= n; |
250 | sector_num += n; | |
251 | buf += n * 512; | |
252 | } | |
253 | return 0; | |
254 | } | |
255 | ||
2914caa0 PB |
256 | static coroutine_fn int cow_co_read(BlockDriverState *bs, int64_t sector_num, |
257 | uint8_t *buf, int nb_sectors) | |
258 | { | |
259 | int ret; | |
260 | BDRVCowState *s = bs->opaque; | |
261 | qemu_co_mutex_lock(&s->lock); | |
262 | ret = cow_read(bs, sector_num, buf, nb_sectors); | |
263 | qemu_co_mutex_unlock(&s->lock); | |
264 | return ret; | |
265 | } | |
266 | ||
5fafdf24 | 267 | static int cow_write(BlockDriverState *bs, int64_t sector_num, |
ea2384d3 FB |
268 | const uint8_t *buf, int nb_sectors) |
269 | { | |
270 | BDRVCowState *s = bs->opaque; | |
893a9cb4 | 271 | int ret; |
3b46e624 | 272 | |
2063392a CH |
273 | ret = bdrv_pwrite(bs->file, s->cow_sectors_offset + sector_num * 512, |
274 | buf, nb_sectors * 512); | |
16d2fc00 LZH |
275 | if (ret < 0) { |
276 | return ret; | |
277 | } | |
893a9cb4 CH |
278 | |
279 | return cow_update_bitmap(bs, sector_num, nb_sectors); | |
ea2384d3 FB |
280 | } |
281 | ||
e183ef75 PB |
282 | static coroutine_fn int cow_co_write(BlockDriverState *bs, int64_t sector_num, |
283 | const uint8_t *buf, int nb_sectors) | |
284 | { | |
285 | int ret; | |
286 | BDRVCowState *s = bs->opaque; | |
287 | qemu_co_mutex_lock(&s->lock); | |
288 | ret = cow_write(bs, sector_num, buf, nb_sectors); | |
289 | qemu_co_mutex_unlock(&s->lock); | |
290 | return ret; | |
291 | } | |
292 | ||
e2731add | 293 | static void cow_close(BlockDriverState *bs) |
ea2384d3 | 294 | { |
ea2384d3 FB |
295 | } |
296 | ||
0e7e1989 | 297 | static int cow_create(const char *filename, QEMUOptionParameter *options) |
ea2384d3 | 298 | { |
ea2384d3 FB |
299 | struct cow_header_v2 cow_header; |
300 | struct stat st; | |
0e7e1989 KW |
301 | int64_t image_sectors = 0; |
302 | const char *image_filename = NULL; | |
31f38120 | 303 | int ret; |
3535a9c6 | 304 | BlockDriverState *cow_bs; |
0e7e1989 KW |
305 | |
306 | /* Read out options */ | |
307 | while (options && options->name) { | |
308 | if (!strcmp(options->name, BLOCK_OPT_SIZE)) { | |
309 | image_sectors = options->value.n / 512; | |
310 | } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { | |
311 | image_filename = options->value.s; | |
312 | } | |
313 | options++; | |
314 | } | |
ea2384d3 | 315 | |
3535a9c6 LZH |
316 | ret = bdrv_create_file(filename, options); |
317 | if (ret < 0) { | |
318 | return ret; | |
319 | } | |
320 | ||
787e4a85 | 321 | ret = bdrv_file_open(&cow_bs, filename, NULL, BDRV_O_RDWR); |
3535a9c6 LZH |
322 | if (ret < 0) { |
323 | return ret; | |
324 | } | |
325 | ||
ea2384d3 FB |
326 | memset(&cow_header, 0, sizeof(cow_header)); |
327 | cow_header.magic = cpu_to_be32(COW_MAGIC); | |
328 | cow_header.version = cpu_to_be32(COW_VERSION); | |
329 | if (image_filename) { | |
83f64091 FB |
330 | /* Note: if no file, we put a dummy mtime */ |
331 | cow_header.mtime = cpu_to_be32(0); | |
332 | ||
3535a9c6 | 333 | if (stat(image_filename, &st) != 0) { |
83f64091 | 334 | goto mtime_fail; |
ea2384d3 | 335 | } |
ea2384d3 | 336 | cow_header.mtime = cpu_to_be32(st.st_mtime); |
83f64091 FB |
337 | mtime_fail: |
338 | pstrcpy(cow_header.backing_file, sizeof(cow_header.backing_file), | |
339 | image_filename); | |
ea2384d3 FB |
340 | } |
341 | cow_header.sectorsize = cpu_to_be32(512); | |
342 | cow_header.size = cpu_to_be64(image_sectors * 512); | |
3535a9c6 | 343 | ret = bdrv_pwrite(cow_bs, 0, &cow_header, sizeof(cow_header)); |
16d2fc00 | 344 | if (ret < 0) { |
31f38120 KS |
345 | goto exit; |
346 | } | |
347 | ||
ea2384d3 | 348 | /* resize to include at least all the bitmap */ |
3535a9c6 LZH |
349 | ret = bdrv_truncate(cow_bs, |
350 | sizeof(cow_header) + ((image_sectors + 7) >> 3)); | |
16d2fc00 | 351 | if (ret < 0) { |
31f38120 KS |
352 | goto exit; |
353 | } | |
354 | ||
31f38120 | 355 | exit: |
4f6fd349 | 356 | bdrv_unref(cow_bs); |
31f38120 | 357 | return ret; |
ea2384d3 FB |
358 | } |
359 | ||
0e7e1989 | 360 | static QEMUOptionParameter cow_create_options[] = { |
db08adf5 KW |
361 | { |
362 | .name = BLOCK_OPT_SIZE, | |
363 | .type = OPT_SIZE, | |
364 | .help = "Virtual disk size" | |
365 | }, | |
366 | { | |
367 | .name = BLOCK_OPT_BACKING_FILE, | |
368 | .type = OPT_STRING, | |
369 | .help = "File name of a base image" | |
370 | }, | |
0e7e1989 KW |
371 | { NULL } |
372 | }; | |
373 | ||
5efa9d5a | 374 | static BlockDriver bdrv_cow = { |
c68b89ac KW |
375 | .format_name = "cow", |
376 | .instance_size = sizeof(BDRVCowState), | |
377 | ||
378 | .bdrv_probe = cow_probe, | |
379 | .bdrv_open = cow_open, | |
380 | .bdrv_close = cow_close, | |
381 | .bdrv_create = cow_create, | |
3ac21627 | 382 | .bdrv_has_zero_init = bdrv_has_zero_init_1, |
c68b89ac KW |
383 | |
384 | .bdrv_read = cow_co_read, | |
385 | .bdrv_write = cow_co_write, | |
b6b8a333 | 386 | .bdrv_co_get_block_status = cow_co_get_block_status, |
0e7e1989 KW |
387 | |
388 | .create_options = cow_create_options, | |
ea2384d3 | 389 | }; |
5efa9d5a AL |
390 | |
391 | static void bdrv_cow_init(void) | |
392 | { | |
393 | bdrv_register(&bdrv_cow); | |
394 | } | |
395 | ||
396 | block_init(bdrv_cow_init); |