]>
git.proxmox.com Git - qemu.git/blob - block-vpc.c
88ad575bf8062c821a9668c1f9e0b4d4452c301b
2 * Block driver for Conectix/Microsoft Virtual PC images
4 * Copyright (c) 2005 Alex Beregszaszi
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "block_int.h"
27 /**************************************************************/
29 #define HEADER_SIZE 512
34 struct vpc_subheader
{
35 char magic
[8]; // "conectix" / "cxsparse"
39 uint32_t unk2
; // always zero?
40 uint32_t subheader_offset
;
41 uint32_t unk3
; // some size?
42 char creator
[4]; // "vpc "
45 char guest
[4]; // "Wi2k"
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];
53 uint32_t unk1
[2]; // all bits set
54 uint32_t unk2
; // always zero?
55 uint32_t pagetable_offset
;
57 uint32_t pagetable_entries
; // 32bit/entry
58 uint32_t pageentry_size
; // 512*8*512
60 char padding
[HEADER_SIZE
- 40];
62 char padding
[HEADER_SIZE
- 8];
66 typedef struct BDRVVPCState
{
69 int pagetable_entries
;
72 uint32_t pageentry_size
;
74 uint8_t *pageentry_u8
;
75 uint32_t *pageentry_u32
;
76 uint16_t *pageentry_u16
;
82 static int vpc_probe(const uint8_t *buf
, int buf_size
, const char *filename
)
84 if (!strncmp(buf
, "conectix", 8))
90 static int vpc_open(BlockDriverState
*bs
, const char *filename
)
92 BDRVVPCState
*s
= bs
->opaque
;
94 struct vpc_subheader header
;
96 fd
= open(filename
, O_RDWR
| O_BINARY
| O_LARGEFILE
);
98 fd
= open(filename
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
103 bs
->read_only
= 1; // no write support yet
107 if (read(fd
, &header
, HEADER_SIZE
) != HEADER_SIZE
)
110 if (strncmp(header
.magic
, "conectix", 8))
112 lseek(s
->fd
, be32_to_cpu(header
.type
.main
.subheader_offset
), SEEK_SET
);
114 if (read(fd
, &header
, HEADER_SIZE
) != HEADER_SIZE
)
117 if (strncmp(header
.magic
, "cxsparse", 8))
120 bs
->total_sectors
= ((uint64_t)be32_to_cpu(header
.type
.sparse
.pagetable_entries
) *
121 be32_to_cpu(header
.type
.sparse
.pageentry_size
)) / 512;
123 lseek(s
->fd
, be32_to_cpu(header
.type
.sparse
.pagetable_offset
), SEEK_SET
);
125 s
->pagetable_entries
= be32_to_cpu(header
.type
.sparse
.pagetable_entries
);
126 s
->pagetable
= qemu_malloc(s
->pagetable_entries
* 4);
129 if (read(s
->fd
, s
->pagetable
, s
->pagetable_entries
* 4) !=
130 s
->pagetable_entries
* 4)
132 for (i
= 0; i
< s
->pagetable_entries
; i
++)
133 be32_to_cpus(&s
->pagetable
[i
]);
135 s
->pageentry_size
= be32_to_cpu(header
.type
.sparse
.pageentry_size
);
137 s
->pageentry_u8
= qemu_malloc(512);
138 if (!s
->pageentry_u8
)
140 s
->pageentry_u32
= s
->pageentry_u8
;
141 s
->pageentry_u16
= s
->pageentry_u8
;
142 s
->last_pagetable
= -1;
151 static inline int seek_to_sector(BlockDriverState
*bs
, int64_t sector_num
)
153 BDRVVPCState
*s
= bs
->opaque
;
154 uint64_t offset
= sector_num
* 512;
155 uint64_t bitmap_offset
, block_offset
;
156 uint32_t pagetable_index
, pageentry_index
;
158 pagetable_index
= offset
/ s
->pageentry_size
;
159 pageentry_index
= (offset
% s
->pageentry_size
) / 512;
161 if (pagetable_index
> s
->pagetable_entries
|| s
->pagetable
[pagetable_index
] == 0xffffffff)
162 return -1; // not allocated
164 bitmap_offset
= 512 * s
->pagetable
[pagetable_index
];
165 block_offset
= bitmap_offset
+ 512 + (512 * pageentry_index
);
167 // printf("sector: %llx, index: %x, offset: %x, bioff: %llx, bloff: %llx\n",
168 // sector_num, pagetable_index, pageentry_index,
169 // bitmap_offset, block_offset);
171 // disabled by reason
174 if (bitmap_offset
!= s
->last_bitmap
)
176 lseek(s
->fd
, bitmap_offset
, SEEK_SET
);
178 s
->last_bitmap
= bitmap_offset
;
180 // Scary! Bitmap is stored as big endian 32bit entries,
181 // while we used to look it up byte by byte
182 read(s
->fd
, s
->pageentry_u8
, 512);
183 for (i
= 0; i
< 128; i
++)
184 be32_to_cpus(&s
->pageentry_u32
[i
]);
187 if ((s
->pageentry_u8
[pageentry_index
/ 8] >> (pageentry_index
% 8)) & 1)
190 lseek(s
->fd
, bitmap_offset
+ (pageentry_index
/ 8), SEEK_SET
);
192 read(s
->fd
, &bitmap_entry
, 1);
194 if ((bitmap_entry
>> (pageentry_index
% 8)) & 1)
195 return -1; // not allocated
198 lseek(s
->fd
, block_offset
, SEEK_SET
);
203 static int vpc_read(BlockDriverState
*bs
, int64_t sector_num
,
204 uint8_t *buf
, int nb_sectors
)
206 BDRVVPCState
*s
= bs
->opaque
;
209 while (nb_sectors
> 0) {
210 if (!seek_to_sector(bs
, sector_num
))
212 ret
= read(s
->fd
, buf
, 512);
225 static void vpc_close(BlockDriverState
*bs
)
227 BDRVVPCState
*s
= bs
->opaque
;
228 qemu_free(s
->pagetable
);
230 qemu_free(s
->pageentry_u8
);
235 BlockDriver bdrv_vpc
= {
237 sizeof(BDRVVPCState
),