]>
Commit | Line | Data |
---|---|---|
ea2384d3 FB |
1 | /* |
2 | * Block driver for the VMDK format | |
3 | * | |
4 | * Copyright (c) 2004 Fabrice Bellard | |
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 "vl.h" | |
25 | #include "block_int.h" | |
26 | ||
27 | /* XXX: this code is untested */ | |
28 | /* XXX: add write support */ | |
29 | ||
30 | #define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D') | |
31 | #define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V') | |
32 | ||
33 | typedef struct { | |
34 | uint32_t version; | |
35 | uint32_t flags; | |
36 | uint32_t disk_sectors; | |
37 | uint32_t granularity; | |
38 | uint32_t l1dir_offset; | |
39 | uint32_t l1dir_size; | |
40 | uint32_t file_sectors; | |
41 | uint32_t cylinders; | |
42 | uint32_t heads; | |
43 | uint32_t sectors_per_track; | |
44 | } VMDK3Header; | |
45 | ||
46 | typedef struct { | |
47 | uint32_t version; | |
48 | uint32_t flags; | |
49 | int64_t capacity; | |
50 | int64_t granularity; | |
51 | int64_t desc_offset; | |
52 | int64_t desc_size; | |
53 | int32_t num_gtes_per_gte; | |
54 | int64_t rgd_offset; | |
55 | int64_t gd_offset; | |
56 | int64_t grain_offset; | |
57 | char filler[1]; | |
58 | char check_bytes[4]; | |
59 | } VMDK4Header; | |
60 | ||
61 | #define L2_CACHE_SIZE 16 | |
62 | ||
63 | typedef struct BDRVVmdkState { | |
64 | int fd; | |
65 | int64_t l1_table_offset; | |
66 | uint32_t *l1_table; | |
67 | unsigned int l1_size; | |
68 | uint32_t l1_entry_sectors; | |
69 | ||
70 | unsigned int l2_size; | |
71 | uint32_t *l2_cache; | |
72 | uint32_t l2_cache_offsets[L2_CACHE_SIZE]; | |
73 | uint32_t l2_cache_counts[L2_CACHE_SIZE]; | |
74 | ||
75 | unsigned int cluster_sectors; | |
76 | } BDRVVmdkState; | |
77 | ||
78 | static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename) | |
79 | { | |
80 | uint32_t magic; | |
81 | ||
82 | if (buf_size < 4) | |
83 | return 0; | |
84 | magic = be32_to_cpu(*(uint32_t *)buf); | |
85 | if (magic == VMDK3_MAGIC || | |
86 | magic == VMDK4_MAGIC) | |
87 | return 100; | |
88 | else | |
89 | return 0; | |
90 | } | |
91 | ||
92 | static int vmdk_open(BlockDriverState *bs, const char *filename) | |
93 | { | |
94 | BDRVVmdkState *s = bs->opaque; | |
95 | int fd, i; | |
96 | uint32_t magic; | |
97 | int l1_size; | |
98 | ||
99 | fd = open(filename, O_RDONLY | O_BINARY | O_LARGEFILE); | |
100 | if (fd < 0) | |
101 | return -1; | |
102 | if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) | |
103 | goto fail; | |
7143c62c | 104 | magic = be32_to_cpu(magic); |
ea2384d3 FB |
105 | if (magic == VMDK3_MAGIC) { |
106 | VMDK3Header header; | |
107 | if (read(fd, &header, sizeof(header)) != | |
108 | sizeof(header)) | |
109 | goto fail; | |
110 | s->cluster_sectors = le32_to_cpu(header.granularity); | |
111 | s->l2_size = 1 << 9; | |
112 | s->l1_size = 1 << 6; | |
113 | bs->total_sectors = le32_to_cpu(header.disk_sectors); | |
114 | s->l1_table_offset = le32_to_cpu(header.l1dir_offset) * 512; | |
115 | s->l1_entry_sectors = s->l2_size * s->cluster_sectors; | |
116 | } else if (magic == VMDK4_MAGIC) { | |
117 | VMDK4Header header; | |
118 | ||
119 | if (read(fd, &header, sizeof(header)) != sizeof(header)) | |
120 | goto fail; | |
121 | bs->total_sectors = le32_to_cpu(header.capacity); | |
122 | s->cluster_sectors = le32_to_cpu(header.granularity); | |
123 | s->l2_size = le32_to_cpu(header.num_gtes_per_gte); | |
124 | s->l1_entry_sectors = s->l2_size * s->cluster_sectors; | |
125 | if (s->l1_entry_sectors <= 0) | |
126 | goto fail; | |
127 | s->l1_size = (bs->total_sectors + s->l1_entry_sectors - 1) | |
128 | / s->l1_entry_sectors; | |
129 | s->l1_table_offset = le64_to_cpu(header.rgd_offset) * 512; | |
130 | } else { | |
131 | goto fail; | |
132 | } | |
133 | /* read the L1 table */ | |
134 | l1_size = s->l1_size * sizeof(uint32_t); | |
135 | s->l1_table = qemu_malloc(l1_size); | |
136 | if (!s->l1_table) | |
137 | goto fail; | |
7143c62c FB |
138 | if (lseek(fd, s->l1_table_offset, SEEK_SET) == -1) |
139 | goto fail; | |
140 | if (read(fd, s->l1_table, l1_size) != l1_size) | |
ea2384d3 FB |
141 | goto fail; |
142 | for(i = 0; i < s->l1_size; i++) { | |
143 | le32_to_cpus(&s->l1_table[i]); | |
144 | } | |
145 | ||
146 | s->l2_cache = qemu_malloc(s->l2_size * L2_CACHE_SIZE * sizeof(uint32_t)); | |
147 | if (!s->l2_cache) | |
148 | goto fail; | |
149 | s->fd = fd; | |
150 | /* XXX: currently only read only */ | |
151 | bs->read_only = 1; | |
152 | return 0; | |
153 | fail: | |
154 | qemu_free(s->l1_table); | |
155 | qemu_free(s->l2_cache); | |
156 | close(fd); | |
157 | return -1; | |
158 | } | |
159 | ||
160 | static uint64_t get_cluster_offset(BlockDriverState *bs, | |
161 | uint64_t offset) | |
162 | { | |
163 | BDRVVmdkState *s = bs->opaque; | |
164 | unsigned int l1_index, l2_offset, l2_index; | |
165 | int min_index, i, j; | |
166 | uint32_t min_count, *l2_table; | |
167 | uint64_t cluster_offset; | |
168 | ||
169 | l1_index = (offset >> 9) / s->l1_entry_sectors; | |
170 | if (l1_index >= s->l1_size) | |
171 | return 0; | |
172 | l2_offset = s->l1_table[l1_index]; | |
173 | if (!l2_offset) | |
174 | return 0; | |
175 | ||
176 | for(i = 0; i < L2_CACHE_SIZE; i++) { | |
177 | if (l2_offset == s->l2_cache_offsets[i]) { | |
178 | /* increment the hit count */ | |
179 | if (++s->l2_cache_counts[i] == 0xffffffff) { | |
180 | for(j = 0; j < L2_CACHE_SIZE; j++) { | |
181 | s->l2_cache_counts[j] >>= 1; | |
182 | } | |
183 | } | |
184 | l2_table = s->l2_cache + (i * s->l2_size); | |
185 | goto found; | |
186 | } | |
187 | } | |
188 | /* not found: load a new entry in the least used one */ | |
189 | min_index = 0; | |
190 | min_count = 0xffffffff; | |
191 | for(i = 0; i < L2_CACHE_SIZE; i++) { | |
192 | if (s->l2_cache_counts[i] < min_count) { | |
193 | min_count = s->l2_cache_counts[i]; | |
194 | min_index = i; | |
195 | } | |
196 | } | |
197 | l2_table = s->l2_cache + (min_index * s->l2_size); | |
198 | lseek(s->fd, (int64_t)l2_offset * 512, SEEK_SET); | |
199 | if (read(s->fd, l2_table, s->l2_size * sizeof(uint32_t)) != | |
200 | s->l2_size * sizeof(uint32_t)) | |
201 | return 0; | |
202 | s->l2_cache_offsets[min_index] = l2_offset; | |
203 | s->l2_cache_counts[min_index] = 1; | |
204 | found: | |
205 | l2_index = ((offset >> 9) / s->cluster_sectors) % s->l2_size; | |
206 | cluster_offset = le32_to_cpu(l2_table[l2_index]); | |
207 | cluster_offset <<= 9; | |
208 | return cluster_offset; | |
209 | } | |
210 | ||
211 | static int vmdk_is_allocated(BlockDriverState *bs, int64_t sector_num, | |
212 | int nb_sectors, int *pnum) | |
213 | { | |
214 | BDRVVmdkState *s = bs->opaque; | |
215 | int index_in_cluster, n; | |
216 | uint64_t cluster_offset; | |
217 | ||
218 | cluster_offset = get_cluster_offset(bs, sector_num << 9); | |
219 | index_in_cluster = sector_num % s->cluster_sectors; | |
220 | n = s->cluster_sectors - index_in_cluster; | |
221 | if (n > nb_sectors) | |
222 | n = nb_sectors; | |
223 | *pnum = n; | |
224 | return (cluster_offset != 0); | |
225 | } | |
226 | ||
227 | static int vmdk_read(BlockDriverState *bs, int64_t sector_num, | |
228 | uint8_t *buf, int nb_sectors) | |
229 | { | |
230 | BDRVVmdkState *s = bs->opaque; | |
231 | int ret, index_in_cluster, n; | |
232 | uint64_t cluster_offset; | |
233 | ||
234 | while (nb_sectors > 0) { | |
235 | cluster_offset = get_cluster_offset(bs, sector_num << 9); | |
236 | index_in_cluster = sector_num % s->cluster_sectors; | |
237 | n = s->cluster_sectors - index_in_cluster; | |
238 | if (n > nb_sectors) | |
239 | n = nb_sectors; | |
240 | if (!cluster_offset) { | |
241 | memset(buf, 0, 512 * n); | |
242 | } else { | |
d5249393 | 243 | lseek(s->fd, cluster_offset + index_in_cluster * 512, SEEK_SET); |
ea2384d3 FB |
244 | ret = read(s->fd, buf, n * 512); |
245 | if (ret != n * 512) | |
246 | return -1; | |
247 | } | |
248 | nb_sectors -= n; | |
249 | sector_num += n; | |
250 | buf += n * 512; | |
251 | } | |
252 | return 0; | |
253 | } | |
254 | ||
255 | static int vmdk_write(BlockDriverState *bs, int64_t sector_num, | |
256 | const uint8_t *buf, int nb_sectors) | |
257 | { | |
258 | return -1; | |
259 | } | |
260 | ||
e2731add | 261 | static void vmdk_close(BlockDriverState *bs) |
ea2384d3 FB |
262 | { |
263 | BDRVVmdkState *s = bs->opaque; | |
264 | qemu_free(s->l1_table); | |
265 | qemu_free(s->l2_cache); | |
266 | close(s->fd); | |
267 | } | |
268 | ||
269 | BlockDriver bdrv_vmdk = { | |
270 | "vmdk", | |
271 | sizeof(BDRVVmdkState), | |
272 | vmdk_probe, | |
273 | vmdk_open, | |
274 | vmdk_read, | |
275 | vmdk_write, | |
276 | vmdk_close, | |
277 | NULL, /* no create yet */ | |
278 | vmdk_is_allocated, | |
279 | }; |