]>
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 | |
07898904 | 38 | typedef struct ParallelsHeader { |
6ada7453 TS |
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]; | |
07898904 | 49 | } QEMU_PACKED ParallelsHeader; |
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 | { | |
07898904 | 64 | const ParallelsHeader *ph = (const void *)buf; |
6ada7453 TS |
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; |
07898904 | 82 | ParallelsHeader 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 | ||
29442569 | 149 | static int64_t seek_to_sector(BDRVParallelsState *s, int64_t sector_num) |
6ada7453 | 150 | { |
c34d2451 | 151 | uint32_t index, offset; |
6ada7453 TS |
152 | |
153 | index = sector_num / s->tracks; | |
154 | offset = sector_num % s->tracks; | |
155 | ||
9d8b88f6 | 156 | /* not allocated */ |
da725d0b | 157 | if ((index >= s->catalog_size) || (s->catalog_bitmap[index] == 0)) |
f08e2f84 | 158 | return -1; |
29442569 | 159 | return (uint64_t)s->catalog_bitmap[index] * s->off_multiplier + offset; |
6ada7453 TS |
160 | } |
161 | ||
9de9da17 RK |
162 | static int cluster_remainder(BDRVParallelsState *s, int64_t sector_num, |
163 | int nb_sectors) | |
164 | { | |
165 | int ret = s->tracks - sector_num % s->tracks; | |
166 | return MIN(nb_sectors, ret); | |
167 | } | |
168 | ||
6ada7453 TS |
169 | static int parallels_read(BlockDriverState *bs, int64_t sector_num, |
170 | uint8_t *buf, int nb_sectors) | |
171 | { | |
29442569 RK |
172 | BDRVParallelsState *s = bs->opaque; |
173 | ||
6ada7453 | 174 | while (nb_sectors > 0) { |
29442569 | 175 | int64_t position = seek_to_sector(s, sector_num); |
9de9da17 | 176 | int n = cluster_remainder(s, sector_num, nb_sectors); |
9d8b88f6 | 177 | if (position >= 0) { |
9de9da17 | 178 | int ret = bdrv_read(bs->file, position, buf, n); |
29442569 RK |
179 | if (ret < 0) { |
180 | return ret; | |
181 | } | |
9d8b88f6 | 182 | } else { |
9de9da17 | 183 | memset(buf, 0, n << BDRV_SECTOR_BITS); |
9d8b88f6 | 184 | } |
9de9da17 RK |
185 | nb_sectors -= n; |
186 | sector_num += n; | |
187 | buf += n << BDRV_SECTOR_BITS; | |
6ada7453 TS |
188 | } |
189 | return 0; | |
190 | } | |
191 | ||
2914caa0 PB |
192 | static coroutine_fn int parallels_co_read(BlockDriverState *bs, int64_t sector_num, |
193 | uint8_t *buf, int nb_sectors) | |
194 | { | |
195 | int ret; | |
196 | BDRVParallelsState *s = bs->opaque; | |
197 | qemu_co_mutex_lock(&s->lock); | |
198 | ret = parallels_read(bs, sector_num, buf, nb_sectors); | |
199 | qemu_co_mutex_unlock(&s->lock); | |
200 | return ret; | |
201 | } | |
202 | ||
6ada7453 TS |
203 | static void parallels_close(BlockDriverState *bs) |
204 | { | |
205 | BDRVParallelsState *s = bs->opaque; | |
7267c094 | 206 | g_free(s->catalog_bitmap); |
6ada7453 TS |
207 | } |
208 | ||
5efa9d5a | 209 | static BlockDriver bdrv_parallels = { |
e60f469c AJ |
210 | .format_name = "parallels", |
211 | .instance_size = sizeof(BDRVParallelsState), | |
212 | .bdrv_probe = parallels_probe, | |
1dec5a70 | 213 | .bdrv_open = parallels_open, |
2914caa0 | 214 | .bdrv_read = parallels_co_read, |
e60f469c | 215 | .bdrv_close = parallels_close, |
6ada7453 | 216 | }; |
5efa9d5a AL |
217 | |
218 | static void bdrv_parallels_init(void) | |
219 | { | |
220 | bdrv_register(&bdrv_parallels); | |
221 | } | |
222 | ||
223 | block_init(bdrv_parallels_init); |