]>
Commit | Line | Data |
---|---|---|
6ada7453 TS |
1 | /* |
2 | * Block driver for Parallels disk image format | |
3 | * | |
4 | * Copyright (c) 2007 Alex Beregszaszi | |
5 | * | |
6 | * This code is based on comparing different disk images created by Parallels. | |
7 | * | |
8 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
9 | * of this software and associated documentation files (the "Software"), to deal | |
10 | * in the Software without restriction, including without limitation the rights | |
11 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
12 | * copies of the Software, and to permit persons to whom the Software is | |
13 | * furnished to do so, subject to the following conditions: | |
14 | * | |
15 | * The above copyright notice and this permission notice shall be included in | |
16 | * all copies or substantial portions of the Software. | |
17 | * | |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
21 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
23 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
24 | * THE SOFTWARE. | |
25 | */ | |
faf07963 | 26 | #include "qemu-common.h" |
737e150e | 27 | #include "block/block_int.h" |
1de7afc9 | 28 | #include "qemu/module.h" |
6ada7453 TS |
29 | |
30 | /**************************************************************/ | |
31 | ||
32 | #define HEADER_MAGIC "WithoutFreeSpace" | |
d25d5980 | 33 | #define HEADER_MAGIC2 "WithouFreSpacExt" |
6ada7453 TS |
34 | #define HEADER_VERSION 2 |
35 | #define HEADER_SIZE 64 | |
36 | ||
37 | // always little-endian | |
38 | struct parallels_header { | |
39 | char magic[16]; // "WithoutFreeSpace" | |
40 | uint32_t version; | |
41 | uint32_t heads; | |
42 | uint32_t cylinders; | |
43 | uint32_t tracks; | |
44 | uint32_t catalog_entries; | |
8c27d54f DL |
45 | uint64_t nb_sectors; |
46 | uint32_t inuse; | |
47 | uint32_t data_off; | |
48 | char padding[12]; | |
541dc0d4 | 49 | } QEMU_PACKED; |
6ada7453 TS |
50 | |
51 | typedef struct BDRVParallelsState { | |
848c66e8 | 52 | CoMutex lock; |
6ada7453 TS |
53 | |
54 | uint32_t *catalog_bitmap; | |
afbcc40b | 55 | unsigned int catalog_size; |
6ada7453 | 56 | |
9302e863 | 57 | unsigned int tracks; |
d25d5980 DL |
58 | |
59 | unsigned int off_multiplier; | |
6ada7453 TS |
60 | } BDRVParallelsState; |
61 | ||
62 | static int parallels_probe(const uint8_t *buf, int buf_size, const char *filename) | |
63 | { | |
64 | const struct parallels_header *ph = (const void *)buf; | |
65 | ||
66 | if (buf_size < HEADER_SIZE) | |
f08e2f84 | 67 | return 0; |
6ada7453 | 68 | |
d25d5980 DL |
69 | if ((!memcmp(ph->magic, HEADER_MAGIC, 16) || |
70 | !memcmp(ph->magic, HEADER_MAGIC2, 16)) && | |
f08e2f84 DL |
71 | (le32_to_cpu(ph->version) == HEADER_VERSION)) |
72 | return 100; | |
6ada7453 TS |
73 | |
74 | return 0; | |
75 | } | |
76 | ||
015a1036 HR |
77 | static int parallels_open(BlockDriverState *bs, QDict *options, int flags, |
78 | Error **errp) | |
6ada7453 TS |
79 | { |
80 | BDRVParallelsState *s = bs->opaque; | |
1dec5a70 | 81 | int i; |
6ada7453 | 82 | struct parallels_header ph; |
46536235 | 83 | int ret; |
6ada7453 | 84 | |
6ada7453 TS |
85 | bs->read_only = 1; // no write support yet |
86 | ||
46536235 KW |
87 | ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph)); |
88 | if (ret < 0) { | |
6ada7453 | 89 | goto fail; |
46536235 | 90 | } |
6ada7453 | 91 | |
d25d5980 DL |
92 | bs->total_sectors = le64_to_cpu(ph.nb_sectors); |
93 | ||
418a7adb DL |
94 | if (le32_to_cpu(ph.version) != HEADER_VERSION) { |
95 | goto fail_format; | |
96 | } | |
d25d5980 DL |
97 | if (!memcmp(ph.magic, HEADER_MAGIC, 16)) { |
98 | s->off_multiplier = 1; | |
99 | bs->total_sectors = 0xffffffff & bs->total_sectors; | |
100 | } else if (!memcmp(ph.magic, HEADER_MAGIC2, 16)) { | |
101 | s->off_multiplier = le32_to_cpu(ph.tracks); | |
102 | } else { | |
418a7adb | 103 | goto fail_format; |
6ada7453 TS |
104 | } |
105 | ||
6ada7453 | 106 | s->tracks = le32_to_cpu(ph.tracks); |
9302e863 KW |
107 | if (s->tracks == 0) { |
108 | error_setg(errp, "Invalid image: Zero sectors per track"); | |
109 | ret = -EINVAL; | |
110 | goto fail; | |
111 | } | |
d25d5980 DL |
112 | if (s->tracks > INT32_MAX/513) { |
113 | error_setg(errp, "Invalid image: Too big cluster"); | |
114 | ret = -EFBIG; | |
115 | goto fail; | |
116 | } | |
6ada7453 TS |
117 | |
118 | s->catalog_size = le32_to_cpu(ph.catalog_entries); | |
afbcc40b KW |
119 | if (s->catalog_size > INT_MAX / 4) { |
120 | error_setg(errp, "Catalog too large"); | |
121 | ret = -EFBIG; | |
122 | goto fail; | |
123 | } | |
02c4f26b | 124 | s->catalog_bitmap = g_try_new(uint32_t, s->catalog_size); |
f7b593d9 KW |
125 | if (s->catalog_size && s->catalog_bitmap == NULL) { |
126 | ret = -ENOMEM; | |
127 | goto fail; | |
128 | } | |
46536235 KW |
129 | |
130 | ret = bdrv_pread(bs->file, 64, s->catalog_bitmap, s->catalog_size * 4); | |
131 | if (ret < 0) { | |
132 | goto fail; | |
133 | } | |
134 | ||
6ada7453 | 135 | for (i = 0; i < s->catalog_size; i++) |
f08e2f84 | 136 | le32_to_cpus(&s->catalog_bitmap[i]); |
6ada7453 | 137 | |
848c66e8 | 138 | qemu_co_mutex_init(&s->lock); |
6ada7453 | 139 | return 0; |
46536235 | 140 | |
418a7adb DL |
141 | fail_format: |
142 | error_setg(errp, "Image not in Parallels format"); | |
143 | ret = -EINVAL; | |
6ada7453 | 144 | fail: |
46536235 KW |
145 | g_free(s->catalog_bitmap); |
146 | return ret; | |
6ada7453 TS |
147 | } |
148 | ||
9d8b88f6 | 149 | static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num) |
6ada7453 TS |
150 | { |
151 | BDRVParallelsState *s = bs->opaque; | |
c34d2451 | 152 | uint32_t index, offset; |
6ada7453 TS |
153 | |
154 | index = sector_num / s->tracks; | |
155 | offset = sector_num % s->tracks; | |
156 | ||
9d8b88f6 | 157 | /* not allocated */ |
da725d0b | 158 | if ((index >= s->catalog_size) || (s->catalog_bitmap[index] == 0)) |
f08e2f84 | 159 | return -1; |
d25d5980 DL |
160 | return |
161 | ((uint64_t)s->catalog_bitmap[index] * s->off_multiplier + offset) * 512; | |
6ada7453 TS |
162 | } |
163 | ||
164 | static int parallels_read(BlockDriverState *bs, int64_t sector_num, | |
165 | uint8_t *buf, int nb_sectors) | |
166 | { | |
6ada7453 | 167 | while (nb_sectors > 0) { |
9d8b88f6 CH |
168 | int64_t position = seek_to_sector(bs, sector_num); |
169 | if (position >= 0) { | |
1dec5a70 | 170 | if (bdrv_pread(bs->file, position, buf, 512) != 512) |
9d8b88f6 CH |
171 | return -1; |
172 | } else { | |
6ada7453 | 173 | memset(buf, 0, 512); |
9d8b88f6 | 174 | } |
6ada7453 TS |
175 | nb_sectors--; |
176 | sector_num++; | |
177 | buf += 512; | |
178 | } | |
179 | return 0; | |
180 | } | |
181 | ||
2914caa0 PB |
182 | static coroutine_fn int parallels_co_read(BlockDriverState *bs, int64_t sector_num, |
183 | uint8_t *buf, int nb_sectors) | |
184 | { | |
185 | int ret; | |
186 | BDRVParallelsState *s = bs->opaque; | |
187 | qemu_co_mutex_lock(&s->lock); | |
188 | ret = parallels_read(bs, sector_num, buf, nb_sectors); | |
189 | qemu_co_mutex_unlock(&s->lock); | |
190 | return ret; | |
191 | } | |
192 | ||
6ada7453 TS |
193 | static void parallels_close(BlockDriverState *bs) |
194 | { | |
195 | BDRVParallelsState *s = bs->opaque; | |
7267c094 | 196 | g_free(s->catalog_bitmap); |
6ada7453 TS |
197 | } |
198 | ||
5efa9d5a | 199 | static BlockDriver bdrv_parallels = { |
e60f469c AJ |
200 | .format_name = "parallels", |
201 | .instance_size = sizeof(BDRVParallelsState), | |
202 | .bdrv_probe = parallels_probe, | |
1dec5a70 | 203 | .bdrv_open = parallels_open, |
2914caa0 | 204 | .bdrv_read = parallels_co_read, |
e60f469c | 205 | .bdrv_close = parallels_close, |
6ada7453 | 206 | }; |
5efa9d5a AL |
207 | |
208 | static void bdrv_parallels_init(void) | |
209 | { | |
210 | bdrv_register(&bdrv_parallels); | |
211 | } | |
212 | ||
213 | block_init(bdrv_parallels_init); |