ia64/xen-unstable

view tools/ioemu/block-vpc.c @ 15841:c5f735271e22

[IA64] Foreign p2m: Fix vti domain builder.

It should set arch_domain::convmem_end.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Alex Williamson <alex.williamson@hp.com>
date Thu Sep 06 13:48:43 2007 -0600 (2007-09-06)
parents 00618037d37d
children
line source
1 /*
2 * Block driver for Conectix/Microsoft Virtual PC images
3 *
4 * Copyright (c) 2005 Alex Beregszaszi
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 /**************************************************************/
29 #define HEADER_SIZE 512
31 //#define CACHE
33 // always big-endian
34 struct vpc_subheader {
35 char magic[8]; // "conectix" / "cxsparse"
36 union {
37 struct {
38 uint32_t unk1[2];
39 uint32_t unk2; // always zero?
40 uint32_t subheader_offset;
41 uint32_t unk3; // some size?
42 char creator[4]; // "vpc "
43 uint16_t major;
44 uint16_t minor;
45 char guest[4]; // "Wi2k"
46 uint32_t unk4[7];
47 uint8_t vnet_id[16]; // virtual network id, purpose unknown
48 // next 16 longs are used, but dunno the purpose
49 // next 6 longs unknown, following 7 long maybe a serial
50 char padding[HEADER_SIZE - 84];
51 } main;
52 struct {
53 uint32_t unk1[2]; // all bits set
54 uint32_t unk2; // always zero?
55 uint32_t pagetable_offset;
56 uint32_t unk3;
57 uint32_t pagetable_entries; // 32bit/entry
58 uint32_t pageentry_size; // 512*8*512
59 uint32_t nb_sectors;
60 char padding[HEADER_SIZE - 40];
61 } sparse;
62 char padding[HEADER_SIZE - 8];
63 } type;
64 };
66 typedef struct BDRVVPCState {
67 int fd;
69 int pagetable_entries;
70 uint32_t *pagetable;
72 uint32_t pageentry_size;
73 #ifdef CACHE
74 uint8_t *pageentry_u8;
75 uint32_t *pageentry_u32;
76 uint16_t *pageentry_u16;
78 uint64_t last_bitmap;
79 #endif
80 } BDRVVPCState;
82 static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)
83 {
84 if (buf_size >= 8 && !strncmp(buf, "conectix", 8))
85 return 100;
86 return 0;
87 }
89 static int vpc_open(BlockDriverState *bs, const char *filename, int flags)
90 {
91 BDRVVPCState *s = bs->opaque;
92 int fd, i;
93 struct vpc_subheader header;
95 fd = open(filename, O_RDONLY | O_BINARY);
96 if (fd < 0)
97 return -1;
99 bs->read_only = 1; // no write support yet
101 s->fd = fd;
103 if (read(fd, &header, HEADER_SIZE) != HEADER_SIZE)
104 goto fail;
106 if (strncmp(header.magic, "conectix", 8))
107 goto fail;
108 lseek(s->fd, be32_to_cpu(header.type.main.subheader_offset), SEEK_SET);
110 if (read(fd, &header, HEADER_SIZE) != HEADER_SIZE)
111 goto fail;
113 if (strncmp(header.magic, "cxsparse", 8))
114 goto fail;
116 bs->total_sectors = ((uint64_t)be32_to_cpu(header.type.sparse.pagetable_entries) *
117 be32_to_cpu(header.type.sparse.pageentry_size)) / 512;
119 lseek(s->fd, be32_to_cpu(header.type.sparse.pagetable_offset), SEEK_SET);
121 s->pagetable_entries = be32_to_cpu(header.type.sparse.pagetable_entries);
122 s->pagetable = qemu_malloc(s->pagetable_entries * 4);
123 if (!s->pagetable)
124 goto fail;
125 if (read(s->fd, s->pagetable, s->pagetable_entries * 4) !=
126 s->pagetable_entries * 4)
127 goto fail;
128 for (i = 0; i < s->pagetable_entries; i++)
129 be32_to_cpus(&s->pagetable[i]);
131 s->pageentry_size = be32_to_cpu(header.type.sparse.pageentry_size);
132 #ifdef CACHE
133 s->pageentry_u8 = qemu_malloc(512);
134 if (!s->pageentry_u8)
135 goto fail;
136 s->pageentry_u32 = s->pageentry_u8;
137 s->pageentry_u16 = s->pageentry_u8;
138 s->last_pagetable = -1;
139 #endif
141 return 0;
142 fail:
143 close(fd);
144 return -1;
145 }
147 static inline int seek_to_sector(BlockDriverState *bs, int64_t sector_num)
148 {
149 BDRVVPCState *s = bs->opaque;
150 uint64_t offset = sector_num * 512;
151 uint64_t bitmap_offset, block_offset;
152 uint32_t pagetable_index, pageentry_index;
154 pagetable_index = offset / s->pageentry_size;
155 pageentry_index = (offset % s->pageentry_size) / 512;
157 if (pagetable_index > s->pagetable_entries || s->pagetable[pagetable_index] == 0xffffffff)
158 return -1; // not allocated
160 bitmap_offset = 512 * s->pagetable[pagetable_index];
161 block_offset = bitmap_offset + 512 + (512 * pageentry_index);
163 // printf("sector: %" PRIx64 ", index: %x, offset: %x, bioff: %" PRIx64 ", bloff: %" PRIx64 "\n",
164 // sector_num, pagetable_index, pageentry_index,
165 // bitmap_offset, block_offset);
167 // disabled by reason
168 #if 0
169 #ifdef CACHE
170 if (bitmap_offset != s->last_bitmap)
171 {
172 lseek(s->fd, bitmap_offset, SEEK_SET);
174 s->last_bitmap = bitmap_offset;
176 // Scary! Bitmap is stored as big endian 32bit entries,
177 // while we used to look it up byte by byte
178 read(s->fd, s->pageentry_u8, 512);
179 for (i = 0; i < 128; i++)
180 be32_to_cpus(&s->pageentry_u32[i]);
181 }
183 if ((s->pageentry_u8[pageentry_index / 8] >> (pageentry_index % 8)) & 1)
184 return -1;
185 #else
186 lseek(s->fd, bitmap_offset + (pageentry_index / 8), SEEK_SET);
188 read(s->fd, &bitmap_entry, 1);
190 if ((bitmap_entry >> (pageentry_index % 8)) & 1)
191 return -1; // not allocated
192 #endif
193 #endif
194 lseek(s->fd, block_offset, SEEK_SET);
196 return 0;
197 }
199 static int vpc_read(BlockDriverState *bs, int64_t sector_num,
200 uint8_t *buf, int nb_sectors)
201 {
202 BDRVVPCState *s = bs->opaque;
203 int ret;
205 while (nb_sectors > 0) {
206 if (!seek_to_sector(bs, sector_num))
207 {
208 ret = read(s->fd, buf, 512);
209 if (ret != 512)
210 return -1;
211 }
212 else
213 memset(buf, 0, 512);
214 nb_sectors--;
215 sector_num++;
216 buf += 512;
217 }
218 return 0;
219 }
221 static void vpc_close(BlockDriverState *bs)
222 {
223 BDRVVPCState *s = bs->opaque;
224 qemu_free(s->pagetable);
225 #ifdef CACHE
226 qemu_free(s->pageentry_u8);
227 #endif
228 close(s->fd);
229 }
231 BlockDriver bdrv_vpc = {
232 "vpc",
233 sizeof(BDRVVPCState),
234 vpc_probe,
235 vpc_open,
236 vpc_read,
237 NULL,
238 vpc_close,
239 };