]>
Commit | Line | Data |
---|---|---|
a8753c34 FB |
1 | /* |
2 | * Block driver for the various disk image formats used by Bochs | |
3 | * Currently only for "growing" type in read-only mode | |
5fafdf24 | 4 | * |
a8753c34 | 5 | * Copyright (c) 2005 Alex Beregszaszi |
5fafdf24 | 6 | * |
a8753c34 FB |
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
8 | * of this software and associated documentation files (the "Software"), to deal | |
9 | * in the Software without restriction, including without limitation the rights | |
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
11 | * copies of the Software, and to permit persons to whom the Software is | |
12 | * furnished to do so, subject to the following conditions: | |
13 | * | |
14 | * The above copyright notice and this permission notice shall be included in | |
15 | * all copies or substantial portions of the Software. | |
16 | * | |
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
20 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
23 | * THE SOFTWARE. | |
24 | */ | |
80c71a24 | 25 | #include "qemu/osdep.h" |
da34e65c | 26 | #include "qapi/error.h" |
e2c1c34f | 27 | #include "block/block-io.h" |
737e150e | 28 | #include "block/block_int.h" |
1de7afc9 | 29 | #include "qemu/module.h" |
58369e22 | 30 | #include "qemu/bswap.h" |
398e6ad0 | 31 | #include "qemu/error-report.h" |
a8753c34 FB |
32 | |
33 | /**************************************************************/ | |
34 | ||
35 | #define HEADER_MAGIC "Bochs Virtual HD Image" | |
6850dd94 TS |
36 | #define HEADER_VERSION 0x00020000 |
37 | #define HEADER_V1 0x00010000 | |
a8753c34 FB |
38 | #define HEADER_SIZE 512 |
39 | ||
40 | #define REDOLOG_TYPE "Redolog" | |
41 | #define GROWING_TYPE "Growing" | |
42 | ||
43 | // not allocated: 0xffffffff | |
44 | ||
6850dd94 TS |
45 | // always little-endian |
46 | struct bochs_header { | |
3dd8a676 KW |
47 | char magic[32]; /* "Bochs Virtual HD Image" */ |
48 | char type[16]; /* "Redolog" */ | |
49 | char subtype[16]; /* "Undoable" / "Volatile" / "Growing" */ | |
6850dd94 | 50 | uint32_t version; |
3dd8a676 KW |
51 | uint32_t header; /* size of header */ |
52 | ||
53 | uint32_t catalog; /* num of entries */ | |
54 | uint32_t bitmap; /* bitmap size */ | |
55 | uint32_t extent; /* extent size */ | |
3b46e624 | 56 | |
6850dd94 | 57 | union { |
3dd8a676 KW |
58 | struct { |
59 | uint32_t reserved; /* for ??? */ | |
60 | uint64_t disk; /* disk size */ | |
61 | char padding[HEADER_SIZE - 64 - 20 - 12]; | |
62 | } QEMU_PACKED redolog; | |
63 | struct { | |
64 | uint64_t disk; /* disk size */ | |
65 | char padding[HEADER_SIZE - 64 - 20 - 8]; | |
66 | } QEMU_PACKED redolog_v1; | |
67 | char padding[HEADER_SIZE - 64 - 20]; | |
6850dd94 | 68 | } extra; |
3dd8a676 | 69 | } QEMU_PACKED; |
6850dd94 | 70 | |
a8753c34 | 71 | typedef struct BDRVBochsState { |
848c66e8 | 72 | CoMutex lock; |
a8753c34 | 73 | uint32_t *catalog_bitmap; |
246f6583 | 74 | uint32_t catalog_size; |
3b46e624 | 75 | |
246f6583 | 76 | uint32_t data_offset; |
3b46e624 | 77 | |
246f6583 KW |
78 | uint32_t bitmap_blocks; |
79 | uint32_t extent_blocks; | |
80 | uint32_t extent_size; | |
a8753c34 FB |
81 | } BDRVBochsState; |
82 | ||
83 | static int bochs_probe(const uint8_t *buf, int buf_size, const char *filename) | |
84 | { | |
85 | const struct bochs_header *bochs = (const void *)buf; | |
3b46e624 | 86 | |
a8753c34 | 87 | if (buf_size < HEADER_SIZE) |
7d37435b | 88 | return 0; |
a8753c34 FB |
89 | |
90 | if (!strcmp(bochs->magic, HEADER_MAGIC) && | |
7d37435b PB |
91 | !strcmp(bochs->type, REDOLOG_TYPE) && |
92 | !strcmp(bochs->subtype, GROWING_TYPE) && | |
93 | ((le32_to_cpu(bochs->version) == HEADER_VERSION) || | |
94 | (le32_to_cpu(bochs->version) == HEADER_V1))) | |
95 | return 100; | |
a8753c34 FB |
96 | |
97 | return 0; | |
98 | } | |
99 | ||
015a1036 HR |
100 | static int bochs_open(BlockDriverState *bs, QDict *options, int flags, |
101 | Error **errp) | |
a8753c34 FB |
102 | { |
103 | BDRVBochsState *s = bs->opaque; | |
246f6583 | 104 | uint32_t i; |
a8753c34 | 105 | struct bochs_header bochs; |
5b7d7dfd | 106 | int ret; |
a8753c34 | 107 | |
eaa2410f | 108 | /* No write support yet */ |
018f9dea | 109 | bdrv_graph_rdlock_main_loop(); |
eaa2410f | 110 | ret = bdrv_apply_auto_read_only(bs, NULL, errp); |
018f9dea | 111 | bdrv_graph_rdunlock_main_loop(); |
eaa2410f KW |
112 | if (ret < 0) { |
113 | return ret; | |
114 | } | |
115 | ||
83930780 VSO |
116 | ret = bdrv_open_file_child(NULL, options, "file", bs, errp); |
117 | if (ret < 0) { | |
118 | return ret; | |
4e4bf5c4 KW |
119 | } |
120 | ||
32cc71de | 121 | ret = bdrv_pread(bs->file, 0, sizeof(bochs), &bochs, 0); |
5b7d7dfd KW |
122 | if (ret < 0) { |
123 | return ret; | |
a8753c34 FB |
124 | } |
125 | ||
126 | if (strcmp(bochs.magic, HEADER_MAGIC) || | |
127 | strcmp(bochs.type, REDOLOG_TYPE) || | |
128 | strcmp(bochs.subtype, GROWING_TYPE) || | |
7d37435b PB |
129 | ((le32_to_cpu(bochs.version) != HEADER_VERSION) && |
130 | (le32_to_cpu(bochs.version) != HEADER_V1))) { | |
76abe407 PB |
131 | error_setg(errp, "Image not in Bochs format"); |
132 | return -EINVAL; | |
a8753c34 FB |
133 | } |
134 | ||
6850dd94 | 135 | if (le32_to_cpu(bochs.version) == HEADER_V1) { |
3dd8a676 | 136 | bs->total_sectors = le64_to_cpu(bochs.extra.redolog_v1.disk) / 512; |
6850dd94 | 137 | } else { |
3dd8a676 | 138 | bs->total_sectors = le64_to_cpu(bochs.extra.redolog.disk) / 512; |
6850dd94 | 139 | } |
a8753c34 | 140 | |
e3737b82 KW |
141 | /* Limit to 1M entries to avoid unbounded allocation. This is what is |
142 | * needed for the largest image that bximage can create (~8 TB). */ | |
3dd8a676 | 143 | s->catalog_size = le32_to_cpu(bochs.catalog); |
e3737b82 KW |
144 | if (s->catalog_size > 0x100000) { |
145 | error_setg(errp, "Catalog size is too large"); | |
146 | return -EFBIG; | |
147 | } | |
148 | ||
02c4f26b | 149 | s->catalog_bitmap = g_try_new(uint32_t, s->catalog_size); |
7bf665ee KW |
150 | if (s->catalog_size && s->catalog_bitmap == NULL) { |
151 | error_setg(errp, "Could not allocate memory for catalog"); | |
152 | return -ENOMEM; | |
153 | } | |
5b7d7dfd | 154 | |
32cc71de AF |
155 | ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_size * 4, |
156 | s->catalog_bitmap, 0); | |
5b7d7dfd KW |
157 | if (ret < 0) { |
158 | goto fail; | |
159 | } | |
160 | ||
a8753c34 | 161 | for (i = 0; i < s->catalog_size; i++) |
7d37435b | 162 | le32_to_cpus(&s->catalog_bitmap[i]); |
a8753c34 FB |
163 | |
164 | s->data_offset = le32_to_cpu(bochs.header) + (s->catalog_size * 4); | |
165 | ||
3dd8a676 KW |
166 | s->bitmap_blocks = 1 + (le32_to_cpu(bochs.bitmap) - 1) / 512; |
167 | s->extent_blocks = 1 + (le32_to_cpu(bochs.extent) - 1) / 512; | |
3b46e624 | 168 | |
3dd8a676 | 169 | s->extent_size = le32_to_cpu(bochs.extent); |
715c3f60 KW |
170 | if (s->extent_size < BDRV_SECTOR_SIZE) { |
171 | /* bximage actually never creates extents smaller than 4k */ | |
172 | error_setg(errp, "Extent size must be at least 512"); | |
173 | ret = -EINVAL; | |
174 | goto fail; | |
175 | } else if (!is_power_of_2(s->extent_size)) { | |
176 | error_setg(errp, "Extent size %" PRIu32 " is not a power of two", | |
177 | s->extent_size); | |
28ec11bc KW |
178 | ret = -EINVAL; |
179 | goto fail; | |
8e53abbc KW |
180 | } else if (s->extent_size > 0x800000) { |
181 | error_setg(errp, "Extent size %" PRIu32 " is too large", | |
182 | s->extent_size); | |
28ec11bc KW |
183 | ret = -EINVAL; |
184 | goto fail; | |
8e53abbc | 185 | } |
a8753c34 | 186 | |
715c3f60 KW |
187 | if (s->catalog_size < DIV_ROUND_UP(bs->total_sectors, |
188 | s->extent_size / BDRV_SECTOR_SIZE)) | |
189 | { | |
e3737b82 KW |
190 | error_setg(errp, "Catalog size is too small for this disk size"); |
191 | ret = -EINVAL; | |
192 | goto fail; | |
193 | } | |
194 | ||
848c66e8 | 195 | qemu_co_mutex_init(&s->lock); |
a8753c34 | 196 | return 0; |
5b7d7dfd KW |
197 | |
198 | fail: | |
199 | g_free(s->catalog_bitmap); | |
200 | return ret; | |
a8753c34 FB |
201 | } |
202 | ||
a6506481 EB |
203 | static void bochs_refresh_limits(BlockDriverState *bs, Error **errp) |
204 | { | |
a5b8dd2c | 205 | bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */ |
a6506481 EB |
206 | } |
207 | ||
e7918e96 PB |
208 | static int64_t coroutine_fn GRAPH_RDLOCK |
209 | seek_to_sector(BlockDriverState *bs, int64_t sector_num) | |
a8753c34 FB |
210 | { |
211 | BDRVBochsState *s = bs->opaque; | |
246f6583 KW |
212 | uint64_t offset = sector_num * 512; |
213 | uint64_t extent_index, extent_offset, bitmap_offset; | |
a8753c34 | 214 | char bitmap_entry; |
e1b42f45 | 215 | int ret; |
a8753c34 FB |
216 | |
217 | // seek to sector | |
218 | extent_index = offset / s->extent_size; | |
219 | extent_offset = (offset % s->extent_size) / 512; | |
3b46e624 | 220 | |
efbca10f | 221 | if (s->catalog_bitmap[extent_index] == 0xffffffff) { |
7d37435b | 222 | return 0; /* not allocated */ |
a8753c34 FB |
223 | } |
224 | ||
a9ba36a4 KW |
225 | bitmap_offset = s->data_offset + |
226 | (512 * (uint64_t) s->catalog_bitmap[extent_index] * | |
227 | (s->extent_blocks + s->bitmap_blocks)); | |
3b46e624 | 228 | |
efbca10f | 229 | /* read in bitmap for current extent */ |
e7918e96 PB |
230 | ret = bdrv_co_pread(bs->file, bitmap_offset + (extent_offset / 8), 1, |
231 | &bitmap_entry, 0); | |
e1b42f45 HR |
232 | if (ret < 0) { |
233 | return ret; | |
a8753c34 FB |
234 | } |
235 | ||
efbca10f | 236 | if (!((bitmap_entry >> (extent_offset % 8)) & 1)) { |
7d37435b | 237 | return 0; /* not allocated */ |
ecbe1576 | 238 | } |
3b46e624 | 239 | |
efbca10f | 240 | return bitmap_offset + (512 * (s->bitmap_blocks + extent_offset)); |
a8753c34 FB |
241 | } |
242 | ||
b9b10c35 | 243 | static int coroutine_fn GRAPH_RDLOCK |
f7ef38dd VSO |
244 | bochs_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes, |
245 | QEMUIOVector *qiov, BdrvRequestFlags flags) | |
a8753c34 | 246 | { |
3b8fd330 KW |
247 | BDRVBochsState *s = bs->opaque; |
248 | uint64_t sector_num = offset >> BDRV_SECTOR_BITS; | |
249 | int nb_sectors = bytes >> BDRV_SECTOR_BITS; | |
250 | uint64_t bytes_done = 0; | |
251 | QEMUIOVector local_qiov; | |
a8753c34 FB |
252 | int ret; |
253 | ||
1bbbf32d NS |
254 | assert(QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)); |
255 | assert(QEMU_IS_ALIGNED(bytes, BDRV_SECTOR_SIZE)); | |
3b8fd330 KW |
256 | |
257 | qemu_iovec_init(&local_qiov, qiov->niov); | |
258 | qemu_co_mutex_lock(&s->lock); | |
259 | ||
a8753c34 | 260 | while (nb_sectors > 0) { |
efbca10f | 261 | int64_t block_offset = seek_to_sector(bs, sector_num); |
e1b42f45 | 262 | if (block_offset < 0) { |
3b8fd330 KW |
263 | ret = block_offset; |
264 | goto fail; | |
265 | } | |
266 | ||
267 | qemu_iovec_reset(&local_qiov); | |
268 | qemu_iovec_concat(&local_qiov, qiov, bytes_done, 512); | |
269 | ||
270 | if (block_offset > 0) { | |
a03ef88f | 271 | ret = bdrv_co_preadv(bs->file, block_offset, 512, |
3b8fd330 | 272 | &local_qiov, 0); |
e1b42f45 | 273 | if (ret < 0) { |
3b8fd330 | 274 | goto fail; |
efbca10f | 275 | } |
e1b42f45 | 276 | } else { |
3b8fd330 | 277 | qemu_iovec_memset(&local_qiov, 0, 0, 512); |
e1b42f45 | 278 | } |
a8753c34 FB |
279 | nb_sectors--; |
280 | sector_num++; | |
3b8fd330 | 281 | bytes_done += 512; |
a8753c34 | 282 | } |
a8753c34 | 283 | |
3b8fd330 KW |
284 | ret = 0; |
285 | fail: | |
2914caa0 | 286 | qemu_co_mutex_unlock(&s->lock); |
3b8fd330 KW |
287 | qemu_iovec_destroy(&local_qiov); |
288 | ||
2914caa0 PB |
289 | return ret; |
290 | } | |
291 | ||
a8753c34 FB |
292 | static void bochs_close(BlockDriverState *bs) |
293 | { | |
294 | BDRVBochsState *s = bs->opaque; | |
7267c094 | 295 | g_free(s->catalog_bitmap); |
a8753c34 FB |
296 | } |
297 | ||
5efa9d5a | 298 | static BlockDriver bdrv_bochs = { |
e60f469c AJ |
299 | .format_name = "bochs", |
300 | .instance_size = sizeof(BDRVBochsState), | |
301 | .bdrv_probe = bochs_probe, | |
7a6f3913 | 302 | .bdrv_open = bochs_open, |
69dca43d | 303 | .bdrv_child_perm = bdrv_default_perms, |
a6506481 | 304 | .bdrv_refresh_limits = bochs_refresh_limits, |
3b8fd330 | 305 | .bdrv_co_preadv = bochs_co_preadv, |
e60f469c | 306 | .bdrv_close = bochs_close, |
d67066d8 | 307 | .is_format = true, |
a8753c34 | 308 | }; |
5efa9d5a AL |
309 | |
310 | static void bdrv_bochs_init(void) | |
311 | { | |
312 | bdrv_register(&bdrv_bochs); | |
313 | } | |
314 | ||
315 | block_init(bdrv_bochs_init); |