]>
Commit | Line | Data |
---|---|---|
585d0ed9 FB |
1 | /* |
2 | * QEMU Block driver for DMG images | |
5fafdf24 | 3 | * |
585d0ed9 | 4 | * Copyright (c) 2004 Johannes E. Schindelin |
5fafdf24 | 5 | * |
585d0ed9 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 PB |
26 | #include "qemu/bswap.h" |
27 | #include "qemu/module.h" | |
585d0ed9 | 28 | #include <zlib.h> |
0599e56e | 29 | #include <glib.h> |
585d0ed9 | 30 | |
c165f775 SH |
31 | enum { |
32 | /* Limit chunk sizes to prevent unreasonable amounts of memory being used | |
33 | * or truncating when converting to 32-bit types | |
34 | */ | |
35 | DMG_LENGTHS_MAX = 64 * 1024 * 1024, /* 64 MB */ | |
36 | DMG_SECTORCOUNTS_MAX = DMG_LENGTHS_MAX / 512, | |
37 | }; | |
38 | ||
585d0ed9 | 39 | typedef struct BDRVDMGState { |
848c66e8 | 40 | CoMutex lock; |
585d0ed9 FB |
41 | /* each chunk contains a certain number of sectors, |
42 | * offsets[i] is the offset in the .dmg file, | |
43 | * lengths[i] is the length of the compressed chunk, | |
44 | * sectors[i] is the sector beginning at offsets[i], | |
45 | * sectorcounts[i] is the number of sectors in that chunk, | |
46 | * the sectors array is ordered | |
47 | * 0<=i<n_chunks */ | |
48 | ||
49 | uint32_t n_chunks; | |
50 | uint32_t* types; | |
51 | uint64_t* offsets; | |
52 | uint64_t* lengths; | |
53 | uint64_t* sectors; | |
54 | uint64_t* sectorcounts; | |
55 | uint32_t current_chunk; | |
28a5c9c8 FB |
56 | uint8_t *compressed_chunk; |
57 | uint8_t *uncompressed_chunk; | |
585d0ed9 FB |
58 | z_stream zstream; |
59 | } BDRVDMGState; | |
60 | ||
61 | static int dmg_probe(const uint8_t *buf, int buf_size, const char *filename) | |
62 | { | |
f5866fa4 KW |
63 | int len; |
64 | ||
65 | if (!filename) { | |
66 | return 0; | |
67 | } | |
68 | ||
69 | len = strlen(filename); | |
70 | if (len > 4 && !strcmp(filename + len - 4, ".dmg")) { | |
71 | return 2; | |
72 | } | |
585d0ed9 FB |
73 | return 0; |
74 | } | |
75 | ||
69d34a36 | 76 | static int read_uint64(BlockDriverState *bs, int64_t offset, uint64_t *result) |
585d0ed9 | 77 | { |
69d34a36 KW |
78 | uint64_t buffer; |
79 | int ret; | |
80 | ||
81 | ret = bdrv_pread(bs->file, offset, &buffer, 8); | |
82 | if (ret < 0) { | |
83 | return ret; | |
84 | } | |
85 | ||
86 | *result = be64_to_cpu(buffer); | |
87 | return 0; | |
585d0ed9 FB |
88 | } |
89 | ||
69d34a36 | 90 | static int read_uint32(BlockDriverState *bs, int64_t offset, uint32_t *result) |
585d0ed9 | 91 | { |
69d34a36 KW |
92 | uint32_t buffer; |
93 | int ret; | |
94 | ||
95 | ret = bdrv_pread(bs->file, offset, &buffer, 4); | |
96 | if (ret < 0) { | |
97 | return ret; | |
98 | } | |
99 | ||
100 | *result = be32_to_cpu(buffer); | |
101 | return 0; | |
585d0ed9 FB |
102 | } |
103 | ||
7aee37b9 PW |
104 | static inline uint64_t buff_read_uint64(const uint8_t *buffer, int64_t offset) |
105 | { | |
106 | return be64_to_cpu(*(uint64_t *)&buffer[offset]); | |
107 | } | |
108 | ||
109 | static inline uint32_t buff_read_uint32(const uint8_t *buffer, int64_t offset) | |
110 | { | |
111 | return be32_to_cpu(*(uint32_t *)&buffer[offset]); | |
112 | } | |
113 | ||
f0dce234 SH |
114 | /* Increase max chunk sizes, if necessary. This function is used to calculate |
115 | * the buffer sizes needed for compressed/uncompressed chunk I/O. | |
116 | */ | |
117 | static void update_max_chunk_size(BDRVDMGState *s, uint32_t chunk, | |
118 | uint32_t *max_compressed_size, | |
119 | uint32_t *max_sectors_per_chunk) | |
120 | { | |
121 | uint32_t compressed_size = 0; | |
122 | uint32_t uncompressed_sectors = 0; | |
123 | ||
124 | switch (s->types[chunk]) { | |
125 | case 0x80000005: /* zlib compressed */ | |
126 | compressed_size = s->lengths[chunk]; | |
127 | uncompressed_sectors = s->sectorcounts[chunk]; | |
128 | break; | |
129 | case 1: /* copy */ | |
130 | uncompressed_sectors = (s->lengths[chunk] + 511) / 512; | |
131 | break; | |
132 | case 2: /* zero */ | |
133 | uncompressed_sectors = s->sectorcounts[chunk]; | |
134 | break; | |
135 | } | |
136 | ||
137 | if (compressed_size > *max_compressed_size) { | |
138 | *max_compressed_size = compressed_size; | |
139 | } | |
140 | if (uncompressed_sectors > *max_sectors_per_chunk) { | |
141 | *max_sectors_per_chunk = uncompressed_sectors; | |
142 | } | |
143 | } | |
144 | ||
fa8354bd PW |
145 | static int64_t dmg_find_koly_offset(BlockDriverState *file_bs, Error **errp) |
146 | { | |
147 | int64_t length; | |
148 | int64_t offset = 0; | |
149 | uint8_t buffer[515]; | |
150 | int i, ret; | |
151 | ||
152 | /* bdrv_getlength returns a multiple of block size (512), rounded up. Since | |
153 | * dmg images can have odd sizes, try to look for the "koly" magic which | |
154 | * marks the begin of the UDIF trailer (512 bytes). This magic can be found | |
155 | * in the last 511 bytes of the second-last sector or the first 4 bytes of | |
156 | * the last sector (search space: 515 bytes) */ | |
157 | length = bdrv_getlength(file_bs); | |
158 | if (length < 0) { | |
159 | error_setg_errno(errp, -length, | |
160 | "Failed to get file size while reading UDIF trailer"); | |
161 | return length; | |
162 | } else if (length < 512) { | |
163 | error_setg(errp, "dmg file must be at least 512 bytes long"); | |
164 | return -EINVAL; | |
165 | } | |
166 | if (length > 511 + 512) { | |
167 | offset = length - 511 - 512; | |
168 | } | |
169 | length = length < 515 ? length : 515; | |
170 | ret = bdrv_pread(file_bs, offset, buffer, length); | |
171 | if (ret < 0) { | |
172 | error_setg_errno(errp, -ret, "Failed while reading UDIF trailer"); | |
173 | return ret; | |
174 | } | |
175 | for (i = 0; i < length - 3; i++) { | |
176 | if (buffer[i] == 'k' && buffer[i+1] == 'o' && | |
177 | buffer[i+2] == 'l' && buffer[i+3] == 'y') { | |
178 | return offset + i; | |
179 | } | |
180 | } | |
181 | error_setg(errp, "Could not locate UDIF trailer in dmg file"); | |
182 | return -EINVAL; | |
183 | } | |
184 | ||
65a1c7c9 PW |
185 | /* used when building the sector table */ |
186 | typedef struct DmgHeaderState { | |
187 | /* used internally by dmg_read_mish_block to remember offsets of blocks | |
188 | * across calls */ | |
189 | uint64_t last_in_offset; | |
190 | uint64_t last_out_offset; | |
191 | /* exported for dmg_open */ | |
192 | uint32_t max_compressed_size; | |
193 | uint32_t max_sectors_per_chunk; | |
194 | } DmgHeaderState; | |
195 | ||
7aee37b9 PW |
196 | static int dmg_read_mish_block(BDRVDMGState *s, DmgHeaderState *ds, |
197 | uint8_t *buffer, uint32_t count) | |
65a1c7c9 | 198 | { |
65a1c7c9 PW |
199 | uint32_t type, i; |
200 | int ret; | |
201 | size_t new_size; | |
202 | uint32_t chunk_count; | |
7aee37b9 | 203 | int64_t offset = 0; |
65a1c7c9 | 204 | |
7aee37b9 | 205 | type = buff_read_uint32(buffer, offset); |
65a1c7c9 PW |
206 | /* skip data that is not a valid MISH block (invalid magic or too small) */ |
207 | if (type != 0x6d697368 || count < 244) { | |
208 | /* assume success for now */ | |
209 | return 0; | |
210 | } | |
211 | ||
212 | offset += 4; | |
213 | offset += 200; | |
214 | ||
215 | chunk_count = (count - 204) / 40; | |
216 | new_size = sizeof(uint64_t) * (s->n_chunks + chunk_count); | |
217 | s->types = g_realloc(s->types, new_size / 2); | |
218 | s->offsets = g_realloc(s->offsets, new_size); | |
219 | s->lengths = g_realloc(s->lengths, new_size); | |
220 | s->sectors = g_realloc(s->sectors, new_size); | |
221 | s->sectorcounts = g_realloc(s->sectorcounts, new_size); | |
222 | ||
223 | for (i = s->n_chunks; i < s->n_chunks + chunk_count; i++) { | |
7aee37b9 | 224 | s->types[i] = buff_read_uint32(buffer, offset); |
65a1c7c9 PW |
225 | offset += 4; |
226 | if (s->types[i] != 0x80000005 && s->types[i] != 1 && | |
227 | s->types[i] != 2) { | |
228 | if (s->types[i] == 0xffffffff && i > 0) { | |
229 | ds->last_in_offset = s->offsets[i - 1] + s->lengths[i - 1]; | |
230 | ds->last_out_offset = s->sectors[i - 1] + | |
231 | s->sectorcounts[i - 1]; | |
232 | } | |
233 | chunk_count--; | |
234 | i--; | |
235 | offset += 36; | |
236 | continue; | |
237 | } | |
238 | offset += 4; | |
239 | ||
7aee37b9 | 240 | s->sectors[i] = buff_read_uint64(buffer, offset); |
65a1c7c9 PW |
241 | s->sectors[i] += ds->last_out_offset; |
242 | offset += 8; | |
243 | ||
7aee37b9 | 244 | s->sectorcounts[i] = buff_read_uint64(buffer, offset); |
65a1c7c9 PW |
245 | offset += 8; |
246 | ||
247 | if (s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) { | |
248 | error_report("sector count %" PRIu64 " for chunk %" PRIu32 | |
249 | " is larger than max (%u)", | |
250 | s->sectorcounts[i], i, DMG_SECTORCOUNTS_MAX); | |
251 | ret = -EINVAL; | |
252 | goto fail; | |
253 | } | |
254 | ||
7aee37b9 | 255 | s->offsets[i] = buff_read_uint64(buffer, offset); |
65a1c7c9 PW |
256 | s->offsets[i] += ds->last_in_offset; |
257 | offset += 8; | |
258 | ||
7aee37b9 | 259 | s->lengths[i] = buff_read_uint64(buffer, offset); |
65a1c7c9 PW |
260 | offset += 8; |
261 | ||
262 | if (s->lengths[i] > DMG_LENGTHS_MAX) { | |
263 | error_report("length %" PRIu64 " for chunk %" PRIu32 | |
264 | " is larger than max (%u)", | |
265 | s->lengths[i], i, DMG_LENGTHS_MAX); | |
266 | ret = -EINVAL; | |
267 | goto fail; | |
268 | } | |
269 | ||
270 | update_max_chunk_size(s, i, &ds->max_compressed_size, | |
271 | &ds->max_sectors_per_chunk); | |
272 | } | |
273 | s->n_chunks += chunk_count; | |
274 | return 0; | |
275 | ||
276 | fail: | |
277 | return ret; | |
278 | } | |
279 | ||
b0e8dc5d PW |
280 | static int dmg_read_resource_fork(BlockDriverState *bs, DmgHeaderState *ds, |
281 | uint64_t info_begin, uint64_t info_length) | |
585d0ed9 | 282 | { |
7aee37b9 | 283 | BDRVDMGState *s = bs->opaque; |
69d34a36 | 284 | int ret; |
b0e8dc5d | 285 | uint32_t count, rsrc_data_offset; |
7aee37b9 | 286 | uint8_t *buffer = NULL; |
b0e8dc5d PW |
287 | uint64_t info_end; |
288 | uint64_t offset; | |
585d0ed9 | 289 | |
b0e8dc5d | 290 | /* read offset from begin of resource fork (info_begin) to resource data */ |
65a1c7c9 | 291 | ret = read_uint32(bs, info_begin, &rsrc_data_offset); |
69d34a36 KW |
292 | if (ret < 0) { |
293 | goto fail; | |
b0e8dc5d | 294 | } else if (rsrc_data_offset > info_length) { |
69d34a36 | 295 | ret = -EINVAL; |
16cdf7ce CH |
296 | goto fail; |
297 | } | |
298 | ||
b0e8dc5d PW |
299 | /* read length of resource data */ |
300 | ret = read_uint32(bs, info_begin + 8, &count); | |
69d34a36 KW |
301 | if (ret < 0) { |
302 | goto fail; | |
b0e8dc5d | 303 | } else if (count == 0 || rsrc_data_offset + count > info_length) { |
69d34a36 | 304 | ret = -EINVAL; |
16cdf7ce CH |
305 | goto fail; |
306 | } | |
16cdf7ce | 307 | |
65a1c7c9 | 308 | /* begin of resource data (consisting of one or more resources) */ |
b0e8dc5d PW |
309 | offset = info_begin + rsrc_data_offset; |
310 | ||
311 | /* end of resource data (there is possibly a following resource map | |
312 | * which will be ignored). */ | |
313 | info_end = offset + count; | |
585d0ed9 | 314 | |
65a1c7c9 | 315 | /* read offsets (mish blocks) from one or more resources in resource data */ |
16cdf7ce | 316 | while (offset < info_end) { |
65a1c7c9 | 317 | /* size of following resource */ |
69d34a36 KW |
318 | ret = read_uint32(bs, offset, &count); |
319 | if (ret < 0) { | |
320 | goto fail; | |
f6e6652d | 321 | } else if (count == 0 || count > info_end - offset) { |
69d34a36 KW |
322 | ret = -EINVAL; |
323 | goto fail; | |
324 | } | |
16cdf7ce CH |
325 | offset += 4; |
326 | ||
7aee37b9 PW |
327 | buffer = g_realloc(buffer, count); |
328 | ret = bdrv_pread(bs->file, offset, buffer, count); | |
329 | if (ret < 0) { | |
330 | goto fail; | |
331 | } | |
332 | ||
333 | ret = dmg_read_mish_block(s, ds, buffer, count); | |
69d34a36 KW |
334 | if (ret < 0) { |
335 | goto fail; | |
336 | } | |
65a1c7c9 PW |
337 | /* advance offset by size of resource */ |
338 | offset += count; | |
585d0ed9 | 339 | } |
7aee37b9 | 340 | ret = 0; |
b0e8dc5d PW |
341 | |
342 | fail: | |
7aee37b9 | 343 | g_free(buffer); |
b0e8dc5d PW |
344 | return ret; |
345 | } | |
346 | ||
0599e56e PW |
347 | static int dmg_read_plist_xml(BlockDriverState *bs, DmgHeaderState *ds, |
348 | uint64_t info_begin, uint64_t info_length) | |
349 | { | |
350 | BDRVDMGState *s = bs->opaque; | |
351 | int ret; | |
352 | uint8_t *buffer = NULL; | |
353 | char *data_begin, *data_end; | |
354 | ||
355 | /* Have at least some length to avoid NULL for g_malloc. Attempt to set a | |
356 | * safe upper cap on the data length. A test sample had a XML length of | |
357 | * about 1 MiB. */ | |
358 | if (info_length == 0 || info_length > 16 * 1024 * 1024) { | |
359 | ret = -EINVAL; | |
360 | goto fail; | |
361 | } | |
362 | ||
363 | buffer = g_malloc(info_length + 1); | |
364 | buffer[info_length] = '\0'; | |
365 | ret = bdrv_pread(bs->file, info_begin, buffer, info_length); | |
366 | if (ret != info_length) { | |
367 | ret = -EINVAL; | |
368 | goto fail; | |
369 | } | |
370 | ||
371 | /* look for <data>...</data>. The data is 284 (0x11c) bytes after base64 | |
372 | * decode. The actual data element has 431 (0x1af) bytes which includes tabs | |
373 | * and line feeds. */ | |
374 | data_end = (char *)buffer; | |
375 | while ((data_begin = strstr(data_end, "<data>")) != NULL) { | |
376 | guchar *mish; | |
377 | gsize out_len = 0; | |
378 | ||
379 | data_begin += 6; | |
380 | data_end = strstr(data_begin, "</data>"); | |
381 | /* malformed XML? */ | |
382 | if (data_end == NULL) { | |
383 | ret = -EINVAL; | |
384 | goto fail; | |
385 | } | |
386 | *data_end++ = '\0'; | |
387 | mish = g_base64_decode(data_begin, &out_len); | |
388 | ret = dmg_read_mish_block(s, ds, mish, (uint32_t)out_len); | |
389 | g_free(mish); | |
390 | if (ret < 0) { | |
391 | goto fail; | |
392 | } | |
393 | } | |
394 | ret = 0; | |
395 | ||
396 | fail: | |
397 | g_free(buffer); | |
398 | return ret; | |
399 | } | |
400 | ||
b0e8dc5d PW |
401 | static int dmg_open(BlockDriverState *bs, QDict *options, int flags, |
402 | Error **errp) | |
403 | { | |
404 | BDRVDMGState *s = bs->opaque; | |
405 | DmgHeaderState ds; | |
406 | uint64_t rsrc_fork_offset, rsrc_fork_length; | |
0599e56e | 407 | uint64_t plist_xml_offset, plist_xml_length; |
b0e8dc5d PW |
408 | int64_t offset; |
409 | int ret; | |
410 | ||
411 | bs->read_only = 1; | |
412 | s->n_chunks = 0; | |
413 | s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL; | |
414 | /* used by dmg_read_mish_block to keep track of the current I/O position */ | |
415 | ds.last_in_offset = 0; | |
416 | ds.last_out_offset = 0; | |
417 | ds.max_compressed_size = 1; | |
418 | ds.max_sectors_per_chunk = 1; | |
419 | ||
420 | /* locate the UDIF trailer */ | |
421 | offset = dmg_find_koly_offset(bs->file, errp); | |
422 | if (offset < 0) { | |
423 | ret = offset; | |
424 | goto fail; | |
425 | } | |
426 | ||
427 | /* offset of resource fork (RsrcForkOffset) */ | |
428 | ret = read_uint64(bs, offset + 0x28, &rsrc_fork_offset); | |
429 | if (ret < 0) { | |
430 | goto fail; | |
431 | } | |
432 | ret = read_uint64(bs, offset + 0x30, &rsrc_fork_length); | |
433 | if (ret < 0) { | |
434 | goto fail; | |
435 | } | |
f6e6652d PW |
436 | if (rsrc_fork_offset >= offset || |
437 | rsrc_fork_length > offset - rsrc_fork_offset) { | |
438 | ret = -EINVAL; | |
439 | goto fail; | |
440 | } | |
0599e56e PW |
441 | /* offset of property list (XMLOffset) */ |
442 | ret = read_uint64(bs, offset + 0xd8, &plist_xml_offset); | |
443 | if (ret < 0) { | |
444 | goto fail; | |
445 | } | |
446 | ret = read_uint64(bs, offset + 0xe0, &plist_xml_length); | |
447 | if (ret < 0) { | |
448 | goto fail; | |
449 | } | |
450 | if (plist_xml_offset >= offset || | |
451 | plist_xml_length > offset - plist_xml_offset) { | |
452 | ret = -EINVAL; | |
453 | goto fail; | |
454 | } | |
8daf4257 PW |
455 | ret = read_uint64(bs, offset + 0x1ec, (uint64_t *)&bs->total_sectors); |
456 | if (ret < 0) { | |
457 | goto fail; | |
458 | } | |
459 | if (bs->total_sectors < 0) { | |
460 | ret = -EINVAL; | |
461 | goto fail; | |
462 | } | |
b0e8dc5d PW |
463 | if (rsrc_fork_length != 0) { |
464 | ret = dmg_read_resource_fork(bs, &ds, | |
465 | rsrc_fork_offset, rsrc_fork_length); | |
466 | if (ret < 0) { | |
467 | goto fail; | |
468 | } | |
0599e56e PW |
469 | } else if (plist_xml_length != 0) { |
470 | ret = dmg_read_plist_xml(bs, &ds, plist_xml_offset, plist_xml_length); | |
471 | if (ret < 0) { | |
472 | goto fail; | |
473 | } | |
b0e8dc5d PW |
474 | } else { |
475 | ret = -EINVAL; | |
476 | goto fail; | |
477 | } | |
585d0ed9 FB |
478 | |
479 | /* initialize zlib engine */ | |
b546a944 | 480 | s->compressed_chunk = qemu_try_blockalign(bs->file, |
65a1c7c9 | 481 | ds.max_compressed_size + 1); |
b546a944 | 482 | s->uncompressed_chunk = qemu_try_blockalign(bs->file, |
65a1c7c9 | 483 | 512 * ds.max_sectors_per_chunk); |
b546a944 KW |
484 | if (s->compressed_chunk == NULL || s->uncompressed_chunk == NULL) { |
485 | ret = -ENOMEM; | |
486 | goto fail; | |
487 | } | |
488 | ||
2c1885ad | 489 | if (inflateInit(&s->zstream) != Z_OK) { |
69d34a36 KW |
490 | ret = -EINVAL; |
491 | goto fail; | |
492 | } | |
585d0ed9 FB |
493 | |
494 | s->current_chunk = s->n_chunks; | |
3b46e624 | 495 | |
848c66e8 | 496 | qemu_co_mutex_init(&s->lock); |
585d0ed9 | 497 | return 0; |
69d34a36 | 498 | |
1559ca00 | 499 | fail: |
69d34a36 KW |
500 | g_free(s->types); |
501 | g_free(s->offsets); | |
502 | g_free(s->lengths); | |
503 | g_free(s->sectors); | |
504 | g_free(s->sectorcounts); | |
b546a944 KW |
505 | qemu_vfree(s->compressed_chunk); |
506 | qemu_vfree(s->uncompressed_chunk); | |
69d34a36 | 507 | return ret; |
585d0ed9 FB |
508 | } |
509 | ||
510 | static inline int is_sector_in_chunk(BDRVDMGState* s, | |
686d7148 | 511 | uint32_t chunk_num, uint64_t sector_num) |
585d0ed9 | 512 | { |
2c1885ad SH |
513 | if (chunk_num >= s->n_chunks || s->sectors[chunk_num] > sector_num || |
514 | s->sectors[chunk_num] + s->sectorcounts[chunk_num] <= sector_num) { | |
515 | return 0; | |
516 | } else { | |
517 | return -1; | |
518 | } | |
585d0ed9 FB |
519 | } |
520 | ||
686d7148 | 521 | static inline uint32_t search_chunk(BDRVDMGState *s, uint64_t sector_num) |
585d0ed9 FB |
522 | { |
523 | /* binary search */ | |
2c1885ad SH |
524 | uint32_t chunk1 = 0, chunk2 = s->n_chunks, chunk3; |
525 | while (chunk1 != chunk2) { | |
526 | chunk3 = (chunk1 + chunk2) / 2; | |
527 | if (s->sectors[chunk3] > sector_num) { | |
528 | chunk2 = chunk3; | |
529 | } else if (s->sectors[chunk3] + s->sectorcounts[chunk3] > sector_num) { | |
530 | return chunk3; | |
531 | } else { | |
532 | chunk1 = chunk3; | |
533 | } | |
585d0ed9 FB |
534 | } |
535 | return s->n_chunks; /* error */ | |
536 | } | |
537 | ||
686d7148 | 538 | static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num) |
585d0ed9 | 539 | { |
64a31d5c CH |
540 | BDRVDMGState *s = bs->opaque; |
541 | ||
2c1885ad SH |
542 | if (!is_sector_in_chunk(s, s->current_chunk, sector_num)) { |
543 | int ret; | |
544 | uint32_t chunk = search_chunk(s, sector_num); | |
585d0ed9 | 545 | |
2c1885ad SH |
546 | if (chunk >= s->n_chunks) { |
547 | return -1; | |
548 | } | |
585d0ed9 | 549 | |
2c1885ad SH |
550 | s->current_chunk = s->n_chunks; |
551 | switch (s->types[chunk]) { | |
552 | case 0x80000005: { /* zlib compressed */ | |
2c1885ad SH |
553 | /* we need to buffer, because only the chunk as whole can be |
554 | * inflated. */ | |
b404bf85 SH |
555 | ret = bdrv_pread(bs->file, s->offsets[chunk], |
556 | s->compressed_chunk, s->lengths[chunk]); | |
2c1885ad SH |
557 | if (ret != s->lengths[chunk]) { |
558 | return -1; | |
559 | } | |
560 | ||
561 | s->zstream.next_in = s->compressed_chunk; | |
562 | s->zstream.avail_in = s->lengths[chunk]; | |
563 | s->zstream.next_out = s->uncompressed_chunk; | |
564 | s->zstream.avail_out = 512 * s->sectorcounts[chunk]; | |
565 | ret = inflateReset(&s->zstream); | |
566 | if (ret != Z_OK) { | |
567 | return -1; | |
568 | } | |
569 | ret = inflate(&s->zstream, Z_FINISH); | |
570 | if (ret != Z_STREAM_END || | |
571 | s->zstream.total_out != 512 * s->sectorcounts[chunk]) { | |
572 | return -1; | |
573 | } | |
574 | break; } | |
575 | case 1: /* copy */ | |
576 | ret = bdrv_pread(bs->file, s->offsets[chunk], | |
64a31d5c | 577 | s->uncompressed_chunk, s->lengths[chunk]); |
2c1885ad SH |
578 | if (ret != s->lengths[chunk]) { |
579 | return -1; | |
580 | } | |
581 | break; | |
582 | case 2: /* zero */ | |
583 | memset(s->uncompressed_chunk, 0, 512 * s->sectorcounts[chunk]); | |
584 | break; | |
585 | } | |
586 | s->current_chunk = chunk; | |
585d0ed9 FB |
587 | } |
588 | return 0; | |
589 | } | |
590 | ||
5fafdf24 | 591 | static int dmg_read(BlockDriverState *bs, int64_t sector_num, |
585d0ed9 FB |
592 | uint8_t *buf, int nb_sectors) |
593 | { | |
594 | BDRVDMGState *s = bs->opaque; | |
595 | int i; | |
596 | ||
2c1885ad SH |
597 | for (i = 0; i < nb_sectors; i++) { |
598 | uint32_t sector_offset_in_chunk; | |
599 | if (dmg_read_chunk(bs, sector_num + i) != 0) { | |
600 | return -1; | |
601 | } | |
602 | sector_offset_in_chunk = sector_num + i - s->sectors[s->current_chunk]; | |
603 | memcpy(buf + i * 512, | |
604 | s->uncompressed_chunk + sector_offset_in_chunk * 512, 512); | |
585d0ed9 FB |
605 | } |
606 | return 0; | |
607 | } | |
608 | ||
2914caa0 PB |
609 | static coroutine_fn int dmg_co_read(BlockDriverState *bs, int64_t sector_num, |
610 | uint8_t *buf, int nb_sectors) | |
611 | { | |
612 | int ret; | |
613 | BDRVDMGState *s = bs->opaque; | |
614 | qemu_co_mutex_lock(&s->lock); | |
615 | ret = dmg_read(bs, sector_num, buf, nb_sectors); | |
616 | qemu_co_mutex_unlock(&s->lock); | |
617 | return ret; | |
618 | } | |
619 | ||
585d0ed9 FB |
620 | static void dmg_close(BlockDriverState *bs) |
621 | { | |
622 | BDRVDMGState *s = bs->opaque; | |
4f8aa2e1 KW |
623 | |
624 | g_free(s->types); | |
625 | g_free(s->offsets); | |
626 | g_free(s->lengths); | |
627 | g_free(s->sectors); | |
628 | g_free(s->sectorcounts); | |
b546a944 KW |
629 | qemu_vfree(s->compressed_chunk); |
630 | qemu_vfree(s->uncompressed_chunk); | |
4f8aa2e1 | 631 | |
585d0ed9 FB |
632 | inflateEnd(&s->zstream); |
633 | } | |
634 | ||
5efa9d5a | 635 | static BlockDriver bdrv_dmg = { |
2c1885ad SH |
636 | .format_name = "dmg", |
637 | .instance_size = sizeof(BDRVDMGState), | |
638 | .bdrv_probe = dmg_probe, | |
639 | .bdrv_open = dmg_open, | |
640 | .bdrv_read = dmg_co_read, | |
641 | .bdrv_close = dmg_close, | |
585d0ed9 | 642 | }; |
5efa9d5a AL |
643 | |
644 | static void bdrv_dmg_init(void) | |
645 | { | |
646 | bdrv_register(&bdrv_dmg); | |
647 | } | |
648 | ||
649 | block_init(bdrv_dmg_init); |