ia64/xen-unstable

view tools/ioemu/block-vmdk.c @ 7238:971e7c7411b3

Raise an exception if an error appears on the pipes to our children, and make
sure that the child's pipes are closed even under that exception. Move the
handling of POLLHUP to the end of the loop, so that we guarantee to read any
remaining data from the child if POLLHUP and POLLIN appear at the same time.

Signed-off-by: Ewan Mellor <ewan@xensource.com>
author emellor@ewan
date Thu Oct 06 10:13:11 2005 +0100 (2005-10-06)
parents 8e5fc5fe636c
children f7b43e5c42b9
line source
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"
27 /* XXX: this code is untested */
28 /* XXX: add write support */
30 #define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D')
31 #define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V')
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;
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;
61 #define L2_CACHE_SIZE 16
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;
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];
75 unsigned int cluster_sectors;
76 } BDRVVmdkState;
78 static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename)
79 {
80 uint32_t magic;
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 }
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;
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;
104 magic = be32_to_cpu(magic);
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;
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;
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)
141 goto fail;
142 for(i = 0; i < s->l1_size; i++) {
143 le32_to_cpus(&s->l1_table[i]);
144 }
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 }
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;
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;
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 }
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;
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 }
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;
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 {
243 lseek(s->fd, cluster_offset + index_in_cluster * 512, SEEK_SET);
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 }
255 static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
256 const uint8_t *buf, int nb_sectors)
257 {
258 return -1;
259 }
261 static void vmdk_close(BlockDriverState *bs)
262 {
263 BDRVVmdkState *s = bs->opaque;
264 qemu_free(s->l1_table);
265 qemu_free(s->l2_cache);
266 close(s->fd);
267 }
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 };