The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 1 | /* |
| 2 | * QEMU Block driver for DMG images |
| 3 | * |
| 4 | * Copyright (c) 2004 Johannes E. Schindelin |
| 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_int.h" |
| 26 | #include "bswap.h" |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 27 | #include "module.h" |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 28 | #include <zlib.h> |
| 29 | |
| 30 | typedef struct BDRVDMGState { |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 31 | /* each chunk contains a certain number of sectors, |
| 32 | * offsets[i] is the offset in the .dmg file, |
| 33 | * lengths[i] is the length of the compressed chunk, |
| 34 | * sectors[i] is the sector beginning at offsets[i], |
| 35 | * sectorcounts[i] is the number of sectors in that chunk, |
| 36 | * the sectors array is ordered |
| 37 | * 0<=i<n_chunks */ |
| 38 | |
| 39 | uint32_t n_chunks; |
| 40 | uint32_t* types; |
| 41 | uint64_t* offsets; |
| 42 | uint64_t* lengths; |
| 43 | uint64_t* sectors; |
| 44 | uint64_t* sectorcounts; |
| 45 | uint32_t current_chunk; |
| 46 | uint8_t *compressed_chunk; |
| 47 | uint8_t *uncompressed_chunk; |
| 48 | z_stream zstream; |
| 49 | } BDRVDMGState; |
| 50 | |
| 51 | static int dmg_probe(const uint8_t *buf, int buf_size, const char *filename) |
| 52 | { |
| 53 | int len=strlen(filename); |
| 54 | if(len>4 && !strcmp(filename+len-4,".dmg")) |
| 55 | return 2; |
| 56 | return 0; |
| 57 | } |
| 58 | |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 59 | static off_t read_off(BlockDriverState *bs, int64_t offset) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 60 | { |
| 61 | uint64_t buffer; |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 62 | if (bdrv_pread(bs->file, offset, &buffer, 8) < 8) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 63 | return 0; |
| 64 | return be64_to_cpu(buffer); |
| 65 | } |
| 66 | |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 67 | static off_t read_uint32(BlockDriverState *bs, int64_t offset) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 68 | { |
| 69 | uint32_t buffer; |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 70 | if (bdrv_pread(bs->file, offset, &buffer, 4) < 4) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 71 | return 0; |
| 72 | return be32_to_cpu(buffer); |
| 73 | } |
| 74 | |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 75 | static int dmg_open(BlockDriverState *bs, int flags) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 76 | { |
| 77 | BDRVDMGState *s = bs->opaque; |
| 78 | off_t info_begin,info_end,last_in_offset,last_out_offset; |
| 79 | uint32_t count; |
| 80 | uint32_t max_compressed_size=1,max_sectors_per_chunk=1,i; |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 81 | int64_t offset; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 82 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 83 | bs->read_only = 1; |
| 84 | s->n_chunks = 0; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 85 | s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 86 | |
| 87 | /* read offset of info blocks */ |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 88 | offset = bdrv_getlength(bs->file); |
| 89 | if (offset < 0) { |
| 90 | goto fail; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 91 | } |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 92 | offset -= 0x1d8; |
| 93 | |
| 94 | info_begin = read_off(bs, offset); |
| 95 | if (info_begin == 0) { |
| 96 | goto fail; |
| 97 | } |
| 98 | |
| 99 | if (read_uint32(bs, info_begin) != 0x100) { |
| 100 | goto fail; |
| 101 | } |
| 102 | |
| 103 | count = read_uint32(bs, info_begin + 4); |
| 104 | if (count == 0) { |
| 105 | goto fail; |
| 106 | } |
| 107 | info_end = info_begin + count; |
| 108 | |
| 109 | offset = info_begin + 0x100; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 110 | |
| 111 | /* read offsets */ |
| 112 | last_in_offset = last_out_offset = 0; |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 113 | while (offset < info_end) { |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 114 | uint32_t type; |
| 115 | |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 116 | count = read_uint32(bs, offset); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 117 | if(count==0) |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 118 | goto fail; |
| 119 | offset += 4; |
| 120 | |
| 121 | type = read_uint32(bs, offset); |
| 122 | if (type == 0x6d697368 && count >= 244) { |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 123 | int new_size, chunk_count; |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 124 | |
| 125 | offset += 4; |
| 126 | offset += 200; |
| 127 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 128 | chunk_count = (count-204)/40; |
| 129 | new_size = sizeof(uint64_t) * (s->n_chunks + chunk_count); |
| 130 | s->types = qemu_realloc(s->types, new_size/2); |
| 131 | s->offsets = qemu_realloc(s->offsets, new_size); |
| 132 | s->lengths = qemu_realloc(s->lengths, new_size); |
| 133 | s->sectors = qemu_realloc(s->sectors, new_size); |
| 134 | s->sectorcounts = qemu_realloc(s->sectorcounts, new_size); |
| 135 | |
| 136 | for(i=s->n_chunks;i<s->n_chunks+chunk_count;i++) { |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 137 | s->types[i] = read_uint32(bs, offset); |
| 138 | offset += 4; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 139 | if(s->types[i]!=0x80000005 && s->types[i]!=1 && s->types[i]!=2) { |
| 140 | if(s->types[i]==0xffffffff) { |
| 141 | last_in_offset = s->offsets[i-1]+s->lengths[i-1]; |
| 142 | last_out_offset = s->sectors[i-1]+s->sectorcounts[i-1]; |
| 143 | } |
| 144 | chunk_count--; |
| 145 | i--; |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 146 | offset += 36; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 147 | continue; |
| 148 | } |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 149 | offset += 4; |
| 150 | |
| 151 | s->sectors[i] = last_out_offset+read_off(bs, offset); |
| 152 | offset += 8; |
| 153 | |
| 154 | s->sectorcounts[i] = read_off(bs, offset); |
| 155 | offset += 8; |
| 156 | |
| 157 | s->offsets[i] = last_in_offset+read_off(bs, offset); |
| 158 | offset += 8; |
| 159 | |
| 160 | s->lengths[i] = read_off(bs, offset); |
| 161 | offset += 8; |
| 162 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 163 | if(s->lengths[i]>max_compressed_size) |
| 164 | max_compressed_size = s->lengths[i]; |
| 165 | if(s->sectorcounts[i]>max_sectors_per_chunk) |
| 166 | max_sectors_per_chunk = s->sectorcounts[i]; |
| 167 | } |
| 168 | s->n_chunks+=chunk_count; |
| 169 | } |
| 170 | } |
| 171 | |
| 172 | /* initialize zlib engine */ |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 173 | s->compressed_chunk = qemu_malloc(max_compressed_size+1); |
| 174 | s->uncompressed_chunk = qemu_malloc(512*max_sectors_per_chunk); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 175 | if(inflateInit(&s->zstream) != Z_OK) |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 176 | goto fail; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 177 | |
| 178 | s->current_chunk = s->n_chunks; |
| 179 | |
| 180 | return 0; |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 181 | fail: |
| 182 | return -1; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 183 | } |
| 184 | |
| 185 | static inline int is_sector_in_chunk(BDRVDMGState* s, |
| 186 | uint32_t chunk_num,int sector_num) |
| 187 | { |
| 188 | if(chunk_num>=s->n_chunks || s->sectors[chunk_num]>sector_num || |
| 189 | s->sectors[chunk_num]+s->sectorcounts[chunk_num]<=sector_num) |
| 190 | return 0; |
| 191 | else |
| 192 | return -1; |
| 193 | } |
| 194 | |
| 195 | static inline uint32_t search_chunk(BDRVDMGState* s,int sector_num) |
| 196 | { |
| 197 | /* binary search */ |
| 198 | uint32_t chunk1=0,chunk2=s->n_chunks,chunk3; |
| 199 | while(chunk1!=chunk2) { |
| 200 | chunk3 = (chunk1+chunk2)/2; |
| 201 | if(s->sectors[chunk3]>sector_num) |
| 202 | chunk2 = chunk3; |
| 203 | else if(s->sectors[chunk3]+s->sectorcounts[chunk3]>sector_num) |
| 204 | return chunk3; |
| 205 | else |
| 206 | chunk1 = chunk3; |
| 207 | } |
| 208 | return s->n_chunks; /* error */ |
| 209 | } |
| 210 | |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 211 | static inline int dmg_read_chunk(BlockDriverState *bs, int sector_num) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 212 | { |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 213 | BDRVDMGState *s = bs->opaque; |
| 214 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 215 | if(!is_sector_in_chunk(s,s->current_chunk,sector_num)) { |
| 216 | int ret; |
| 217 | uint32_t chunk = search_chunk(s,sector_num); |
| 218 | |
| 219 | if(chunk>=s->n_chunks) |
| 220 | return -1; |
| 221 | |
| 222 | s->current_chunk = s->n_chunks; |
| 223 | switch(s->types[chunk]) { |
| 224 | case 0x80000005: { /* zlib compressed */ |
| 225 | int i; |
| 226 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 227 | /* we need to buffer, because only the chunk as whole can be |
| 228 | * inflated. */ |
| 229 | i=0; |
| 230 | do { |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 231 | ret = bdrv_pread(bs->file, s->offsets[chunk] + i, |
| 232 | s->compressed_chunk+i, s->lengths[chunk]-i); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 233 | if(ret<0 && errno==EINTR) |
| 234 | ret=0; |
| 235 | i+=ret; |
| 236 | } while(ret>=0 && ret+i<s->lengths[chunk]); |
| 237 | |
| 238 | if (ret != s->lengths[chunk]) |
| 239 | return -1; |
| 240 | |
| 241 | s->zstream.next_in = s->compressed_chunk; |
| 242 | s->zstream.avail_in = s->lengths[chunk]; |
| 243 | s->zstream.next_out = s->uncompressed_chunk; |
| 244 | s->zstream.avail_out = 512*s->sectorcounts[chunk]; |
| 245 | ret = inflateReset(&s->zstream); |
| 246 | if(ret != Z_OK) |
| 247 | return -1; |
| 248 | ret = inflate(&s->zstream, Z_FINISH); |
| 249 | if(ret != Z_STREAM_END || s->zstream.total_out != 512*s->sectorcounts[chunk]) |
| 250 | return -1; |
| 251 | break; } |
| 252 | case 1: /* copy */ |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 253 | ret = bdrv_pread(bs->file, s->offsets[chunk], |
| 254 | s->uncompressed_chunk, s->lengths[chunk]); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 255 | if (ret != s->lengths[chunk]) |
| 256 | return -1; |
| 257 | break; |
| 258 | case 2: /* zero */ |
| 259 | memset(s->uncompressed_chunk, 0, 512*s->sectorcounts[chunk]); |
| 260 | break; |
| 261 | } |
| 262 | s->current_chunk = chunk; |
| 263 | } |
| 264 | return 0; |
| 265 | } |
| 266 | |
| 267 | static int dmg_read(BlockDriverState *bs, int64_t sector_num, |
| 268 | uint8_t *buf, int nb_sectors) |
| 269 | { |
| 270 | BDRVDMGState *s = bs->opaque; |
| 271 | int i; |
| 272 | |
| 273 | for(i=0;i<nb_sectors;i++) { |
| 274 | uint32_t sector_offset_in_chunk; |
David 'Digit' Turner | cb42a1b | 2010-12-23 02:54:08 +0100 | [diff] [blame] | 275 | if(dmg_read_chunk(bs, sector_num+i) != 0) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 276 | return -1; |
| 277 | sector_offset_in_chunk = sector_num+i-s->sectors[s->current_chunk]; |
| 278 | memcpy(buf+i*512,s->uncompressed_chunk+sector_offset_in_chunk*512,512); |
| 279 | } |
| 280 | return 0; |
| 281 | } |
| 282 | |
| 283 | static void dmg_close(BlockDriverState *bs) |
| 284 | { |
| 285 | BDRVDMGState *s = bs->opaque; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 286 | if(s->n_chunks>0) { |
| 287 | free(s->types); |
| 288 | free(s->offsets); |
| 289 | free(s->lengths); |
| 290 | free(s->sectors); |
| 291 | free(s->sectorcounts); |
| 292 | } |
| 293 | free(s->compressed_chunk); |
| 294 | free(s->uncompressed_chunk); |
| 295 | inflateEnd(&s->zstream); |
| 296 | } |
| 297 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 298 | static BlockDriver bdrv_dmg = { |
| 299 | .format_name = "dmg", |
| 300 | .instance_size = sizeof(BDRVDMGState), |
| 301 | .bdrv_probe = dmg_probe, |
| 302 | .bdrv_open = dmg_open, |
| 303 | .bdrv_read = dmg_read, |
| 304 | .bdrv_close = dmg_close, |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 305 | }; |
| 306 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 307 | static void bdrv_dmg_init(void) |
| 308 | { |
| 309 | bdrv_register(&bdrv_dmg); |
| 310 | } |
| 311 | |
| 312 | block_init(bdrv_dmg_init); |