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