vpc.c 18.9 KB
Newer Older
1
/*
S
Stefan Weil 已提交
2
 * Block driver for Connectix / Microsoft Virtual PC images
3
 *
4
 * Copyright (c) 2005 Alex Beregszaszi
A
aliguori 已提交
5
 * Copyright (c) 2009 Kevin Wolf <kwolf@suse.de>
6
 *
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
P
pbrook 已提交
25
#include "qemu-common.h"
26
#include "block_int.h"
27
#include "module.h"
28 29 30 31 32 33 34

/**************************************************************/

#define HEADER_SIZE 512

//#define CACHE

35 36 37 38 39 40
enum vhd_type {
    VHD_FIXED           = 2,
    VHD_DYNAMIC         = 3,
    VHD_DIFFERENCING    = 4,
};

A
aliguori 已提交
41 42 43
// Seconds since Jan 1, 2000 0:00:00 (UTC)
#define VHD_TIMESTAMP_BASE 946684800

44
// always big-endian
45
struct vhd_footer {
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
    char        creator[8]; // "conectix"
    uint32_t    features;
    uint32_t    version;

    // Offset of next header structure, 0xFFFFFFFF if none
    uint64_t    data_offset;

    // Seconds since Jan 1, 2000 0:00:00 (UTC)
    uint32_t    timestamp;

    char        creator_app[4]; // "vpc "
    uint16_t    major;
    uint16_t    minor;
    char        creator_os[4]; // "Wi2k"

    uint64_t    orig_size;
    uint64_t    size;

    uint16_t    cyls;
    uint8_t     heads;
    uint8_t     secs_per_cyl;

    uint32_t    type;

    // Checksum of the Hard Disk Footer ("one's complement of the sum of all
    // the bytes in the footer without the checksum field")
    uint32_t    checksum;

    // UUID used to identify a parent hard disk (backing file)
    uint8_t     uuid[16];

    uint8_t     in_saved_state;
78 79 80
};

struct vhd_dyndisk_header {
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
    char        magic[8]; // "cxsparse"

    // Offset of next header structure, 0xFFFFFFFF if none
    uint64_t    data_offset;

    // Offset of the Block Allocation Table (BAT)
    uint64_t    table_offset;

    uint32_t    version;
    uint32_t    max_table_entries; // 32bit/entry

    // 2 MB by default, must be a power of two
    uint32_t    block_size;

    uint32_t    checksum;
    uint8_t     parent_uuid[16];
    uint32_t    parent_timestamp;
    uint32_t    reserved;

    // Backing file name (in UTF-16)
    uint8_t     parent_name[512];

    struct {
        uint32_t    platform;
        uint32_t    data_space;
        uint32_t    data_length;
        uint32_t    reserved;
        uint64_t    data_offset;
    } parent_locator[8];
110 111 112
};

typedef struct BDRVVPCState {
113
    CoMutex lock;
A
aliguori 已提交
114 115
    uint8_t footer_buf[HEADER_SIZE];
    uint64_t free_data_block_offset;
116
    int max_table_entries;
117
    uint32_t *pagetable;
A
aliguori 已提交
118 119
    uint64_t bat_offset;
    uint64_t last_bitmap_offset;
120

121
    uint32_t block_size;
A
aliguori 已提交
122 123
    uint32_t bitmap_size;

124 125 126 127
#ifdef CACHE
    uint8_t *pageentry_u8;
    uint32_t *pageentry_u32;
    uint16_t *pageentry_u16;
128

129 130 131 132
    uint64_t last_bitmap;
#endif
} BDRVVPCState;

A
aliguori 已提交
133 134 135 136 137 138 139 140 141 142 143 144
static uint32_t vpc_checksum(uint8_t* buf, size_t size)
{
    uint32_t res = 0;
    int i;

    for (i = 0; i < size; i++)
        res += buf[i];

    return ~res;
}


145 146
static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename)
{
T
ths 已提交
147
    if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8))
148 149 150 151
	return 100;
    return 0;
}

152
static int vpc_open(BlockDriverState *bs, int flags)
153 154
{
    BDRVVPCState *s = bs->opaque;
155
    int i;
156 157 158
    struct vhd_footer* footer;
    struct vhd_dyndisk_header* dyndisk_header;
    uint8_t buf[HEADER_SIZE];
A
aliguori 已提交
159
    uint32_t checksum;
160
    int err = -1;
161

162
    if (bdrv_pread(bs->file, 0, s->footer_buf, HEADER_SIZE) != HEADER_SIZE)
163 164
        goto fail;

A
aliguori 已提交
165
    footer = (struct vhd_footer*) s->footer_buf;
166
    if (strncmp(footer->creator, "conectix", 8))
167 168
        goto fail;

A
aliguori 已提交
169 170 171 172
    checksum = be32_to_cpu(footer->checksum);
    footer->checksum = 0;
    if (vpc_checksum(s->footer_buf, HEADER_SIZE) != checksum)
        fprintf(stderr, "block-vpc: The header checksum of '%s' is "
173
            "incorrect.\n", bs->filename);
A
aliguori 已提交
174

A
aliguori 已提交
175 176 177 178 179 180
    // The visible size of a image in Virtual PC depends on the geometry
    // rather than on the size stored in the footer (the size in the footer
    // is too large usually)
    bs->total_sectors = (int64_t)
        be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;

181 182 183 184 185
    if (bs->total_sectors >= 65535 * 16 * 255) {
        err = -EFBIG;
        goto fail;
    }

186
    if (bdrv_pread(bs->file, be64_to_cpu(footer->data_offset), buf, HEADER_SIZE)
187
            != HEADER_SIZE)
188 189
        goto fail;

190 191 192 193
    dyndisk_header = (struct vhd_dyndisk_header*) buf;

    if (strncmp(dyndisk_header->magic, "cxsparse", 8))
        goto fail;
194 195


A
aliguori 已提交
196 197 198
    s->block_size = be32_to_cpu(dyndisk_header->block_size);
    s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511;

199
    s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries);
200
    s->pagetable = g_malloc(s->max_table_entries * 4);
201

A
aliguori 已提交
202
    s->bat_offset = be64_to_cpu(dyndisk_header->table_offset);
203
    if (bdrv_pread(bs->file, s->bat_offset, s->pagetable,
A
aliguori 已提交
204
            s->max_table_entries * 4) != s->max_table_entries * 4)
205 206
	    goto fail;

A
aliguori 已提交
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
    s->free_data_block_offset =
        (s->bat_offset + (s->max_table_entries * 4) + 511) & ~511;

    for (i = 0; i < s->max_table_entries; i++) {
        be32_to_cpus(&s->pagetable[i]);
        if (s->pagetable[i] != 0xFFFFFFFF) {
            int64_t next = (512 * (int64_t) s->pagetable[i]) +
                s->bitmap_size + s->block_size;

            if (next> s->free_data_block_offset)
                s->free_data_block_offset = next;
        }
    }

    s->last_bitmap_offset = (int64_t) -1;
222 223

#ifdef CACHE
224
    s->pageentry_u8 = g_malloc(512);
225 226 227 228 229
    s->pageentry_u32 = s->pageentry_u8;
    s->pageentry_u16 = s->pageentry_u8;
    s->last_pagetable = -1;
#endif

230
    qemu_co_mutex_init(&s->lock);
231 232
    return 0;
 fail:
233
    return err;
234 235
}

236 237 238
/*
 * Returns the absolute byte offset of the given sector in the image file.
 * If the sector is not allocated, -1 is returned instead.
A
aliguori 已提交
239 240 241
 *
 * The parameter write must be 1 if the offset will be used for a write
 * operation (the block bitmaps is updated then), 0 otherwise.
242
 */
A
aliguori 已提交
243 244
static inline int64_t get_sector_offset(BlockDriverState *bs,
    int64_t sector_num, int write)
245 246 247 248 249 250
{
    BDRVVPCState *s = bs->opaque;
    uint64_t offset = sector_num * 512;
    uint64_t bitmap_offset, block_offset;
    uint32_t pagetable_index, pageentry_index;

251 252
    pagetable_index = offset / s->block_size;
    pageentry_index = (offset % s->block_size) / 512;
253

A
aliguori 已提交
254 255
    if (pagetable_index >= s->max_table_entries || s->pagetable[pagetable_index] == 0xffffffff)
        return -1; // not allocated
256

257
    bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
A
aliguori 已提交
258 259 260 261 262 263 264 265 266 267 268 269
    block_offset = bitmap_offset + s->bitmap_size + (512 * pageentry_index);

    // We must ensure that we don't write to any sectors which are marked as
    // unused in the bitmap. We get away with setting all bits in the block
    // bitmap each time we write to a new block. This might cause Virtual PC to
    // miss sparse read optimization, but it's not a problem in terms of
    // correctness.
    if (write && (s->last_bitmap_offset != bitmap_offset)) {
        uint8_t bitmap[s->bitmap_size];

        s->last_bitmap_offset = bitmap_offset;
        memset(bitmap, 0xff, s->bitmap_size);
270
        bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);
A
aliguori 已提交
271
    }
272

B
bellard 已提交
273
//    printf("sector: %" PRIx64 ", index: %x, offset: %x, bioff: %" PRIx64 ", bloff: %" PRIx64 "\n",
274 275 276 277 278 279 280 281 282 283 284
//	sector_num, pagetable_index, pageentry_index,
//	bitmap_offset, block_offset);

// disabled by reason
#if 0
#ifdef CACHE
    if (bitmap_offset != s->last_bitmap)
    {
	lseek(s->fd, bitmap_offset, SEEK_SET);

	s->last_bitmap = bitmap_offset;
285

286 287 288 289 290 291 292 293 294 295 296
	// Scary! Bitmap is stored as big endian 32bit entries,
	// while we used to look it up byte by byte
	read(s->fd, s->pageentry_u8, 512);
	for (i = 0; i < 128; i++)
	    be32_to_cpus(&s->pageentry_u32[i]);
    }

    if ((s->pageentry_u8[pageentry_index / 8] >> (pageentry_index % 8)) & 1)
	return -1;
#else
    lseek(s->fd, bitmap_offset + (pageentry_index / 8), SEEK_SET);
297

298 299 300 301 302 303 304
    read(s->fd, &bitmap_entry, 1);

    if ((bitmap_entry >> (pageentry_index % 8)) & 1)
	return -1; // not allocated
#endif
#endif

305
    return block_offset;
306 307
}

A
aliguori 已提交
308 309 310 311 312 313 314 315 316 317 318 319
/*
 * Writes the footer to the end of the image file. This is needed when the
 * file grows as it overwrites the old footer
 *
 * Returns 0 on success and < 0 on error
 */
static int rewrite_footer(BlockDriverState* bs)
{
    int ret;
    BDRVVPCState *s = bs->opaque;
    int64_t offset = s->free_data_block_offset;

320
    ret = bdrv_pwrite_sync(bs->file, offset, s->footer_buf, HEADER_SIZE);
A
aliguori 已提交
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
    if (ret < 0)
        return ret;

    return 0;
}

/*
 * Allocates a new block. This involves writing a new footer and updating
 * the Block Allocation Table to use the space at the old end of the image
 * file (overwriting the old footer)
 *
 * Returns the sectors' offset in the image file on success and < 0 on error
 */
static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
{
    BDRVVPCState *s = bs->opaque;
    int64_t bat_offset;
    uint32_t index, bat_value;
    int ret;
    uint8_t bitmap[s->bitmap_size];

    // Check if sector_num is valid
    if ((sector_num < 0) || (sector_num > bs->total_sectors))
        return -1;

    // Write entry into in-memory BAT
    index = (sector_num * 512) / s->block_size;
    if (s->pagetable[index] != 0xFFFFFFFF)
        return -1;

    s->pagetable[index] = s->free_data_block_offset / 512;

    // Initialize the block's bitmap
    memset(bitmap, 0xff, s->bitmap_size);
355 356
    bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
        s->bitmap_size);
A
aliguori 已提交
357 358 359 360 361 362 363 364 365 366

    // Write new footer (the old one will be overwritten)
    s->free_data_block_offset += s->block_size + s->bitmap_size;
    ret = rewrite_footer(bs);
    if (ret < 0)
        goto fail;

    // Write BAT entry to disk
    bat_offset = s->bat_offset + (4 * index);
    bat_value = be32_to_cpu(s->pagetable[index]);
367
    ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4);
A
aliguori 已提交
368 369 370 371 372 373 374 375 376 377
    if (ret < 0)
        goto fail;

    return get_sector_offset(bs, sector_num, 0);

fail:
    s->free_data_block_offset -= (s->block_size + s->bitmap_size);
    return -1;
}

378
static int vpc_read(BlockDriverState *bs, int64_t sector_num,
379 380
                    uint8_t *buf, int nb_sectors)
{
381
    BDRVVPCState *s = bs->opaque;
382
    int ret;
383
    int64_t offset;
384
    int64_t sectors, sectors_per_block;
385 386

    while (nb_sectors > 0) {
A
aliguori 已提交
387
        offset = get_sector_offset(bs, sector_num, 0);
388

389 390 391 392 393 394
        sectors_per_block = s->block_size >> BDRV_SECTOR_BITS;
        sectors = sectors_per_block - (sector_num % sectors_per_block);
        if (sectors > nb_sectors) {
            sectors = nb_sectors;
        }

395
        if (offset == -1) {
396
            memset(buf, 0, sectors * BDRV_SECTOR_SIZE);
397
        } else {
398 399 400
            ret = bdrv_pread(bs->file, offset, buf,
                sectors * BDRV_SECTOR_SIZE);
            if (ret != sectors * BDRV_SECTOR_SIZE) {
401
                return -1;
402
            }
403 404
        }

405 406 407
        nb_sectors -= sectors;
        sector_num += sectors;
        buf += sectors * BDRV_SECTOR_SIZE;
408 409 410 411
    }
    return 0;
}

412 413 414 415 416 417 418 419 420 421 422
static coroutine_fn int vpc_co_read(BlockDriverState *bs, int64_t sector_num,
                                    uint8_t *buf, int nb_sectors)
{
    int ret;
    BDRVVPCState *s = bs->opaque;
    qemu_co_mutex_lock(&s->lock);
    ret = vpc_read(bs, sector_num, buf, nb_sectors);
    qemu_co_mutex_unlock(&s->lock);
    return ret;
}

A
aliguori 已提交
423 424 425
static int vpc_write(BlockDriverState *bs, int64_t sector_num,
    const uint8_t *buf, int nb_sectors)
{
426
    BDRVVPCState *s = bs->opaque;
A
aliguori 已提交
427
    int64_t offset;
428
    int64_t sectors, sectors_per_block;
A
aliguori 已提交
429 430 431 432 433
    int ret;

    while (nb_sectors > 0) {
        offset = get_sector_offset(bs, sector_num, 1);

434 435 436 437 438 439
        sectors_per_block = s->block_size >> BDRV_SECTOR_BITS;
        sectors = sectors_per_block - (sector_num % sectors_per_block);
        if (sectors > nb_sectors) {
            sectors = nb_sectors;
        }

A
aliguori 已提交
440 441 442 443 444 445
        if (offset == -1) {
            offset = alloc_block(bs, sector_num);
            if (offset < 0)
                return -1;
        }

446 447
        ret = bdrv_pwrite(bs->file, offset, buf, sectors * BDRV_SECTOR_SIZE);
        if (ret != sectors * BDRV_SECTOR_SIZE) {
A
aliguori 已提交
448
            return -1;
449
        }
A
aliguori 已提交
450

451 452 453
        nb_sectors -= sectors;
        sector_num += sectors;
        buf += sectors * BDRV_SECTOR_SIZE;
A
aliguori 已提交
454 455 456 457 458
    }

    return 0;
}

459 460 461 462 463 464 465 466 467 468 469
static coroutine_fn int vpc_co_write(BlockDriverState *bs, int64_t sector_num,
                                     const uint8_t *buf, int nb_sectors)
{
    int ret;
    BDRVVPCState *s = bs->opaque;
    qemu_co_mutex_lock(&s->lock);
    ret = vpc_write(bs, sector_num, buf, nb_sectors);
    qemu_co_mutex_unlock(&s->lock);
    return ret;
}

K
Kevin Wolf 已提交
470 471 472 473
static int vpc_flush(BlockDriverState *bs)
{
    return bdrv_flush(bs->file);
}
A
aliguori 已提交
474 475 476 477 478 479 480 481

/*
 * Calculates the number of cylinders, heads and sectors per cylinder
 * based on a given number of sectors. This is the algorithm described
 * in the VHD specification.
 *
 * Note that the geometry doesn't always exactly match total_sectors but
 * may round it down.
482 483
 *
 * Returns 0 on success, -EFBIG if the size is larger than 127 GB
A
aliguori 已提交
484
 */
485
static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
A
aliguori 已提交
486 487 488 489 490
    uint8_t* heads, uint8_t* secs_per_cyl)
{
    uint32_t cyls_times_heads;

    if (total_sectors > 65535 * 16 * 255)
491
        return -EFBIG;
A
aliguori 已提交
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517

    if (total_sectors > 65535 * 16 * 63) {
        *secs_per_cyl = 255;
        *heads = 16;
        cyls_times_heads = total_sectors / *secs_per_cyl;
    } else {
        *secs_per_cyl = 17;
        cyls_times_heads = total_sectors / *secs_per_cyl;
        *heads = (cyls_times_heads + 1023) / 1024;

        if (*heads < 4)
            *heads = 4;

        if (cyls_times_heads >= (*heads * 1024) || *heads > 16) {
            *secs_per_cyl = 31;
            *heads = 16;
            cyls_times_heads = total_sectors / *secs_per_cyl;
        }

        if (cyls_times_heads >= (*heads * 1024)) {
            *secs_per_cyl = 63;
            *heads = 16;
            cyls_times_heads = total_sectors / *secs_per_cyl;
        }
    }

518
    *cyls = cyls_times_heads / *heads;
519 520

    return 0;
A
aliguori 已提交
521 522
}

523
static int vpc_create(const char *filename, QEMUOptionParameter *options)
A
aliguori 已提交
524 525 526 527 528 529
{
    uint8_t buf[1024];
    struct vhd_footer* footer = (struct vhd_footer*) buf;
    struct vhd_dyndisk_header* dyndisk_header =
        (struct vhd_dyndisk_header*) buf;
    int fd, i;
530 531 532
    uint16_t cyls = 0;
    uint8_t heads = 0;
    uint8_t secs_per_cyl = 0;
A
aliguori 已提交
533
    size_t block_size, num_bat_entries;
534
    int64_t total_sectors = 0;
B
Blue Swirl 已提交
535
    int ret = -EIO;
A
aliguori 已提交
536

537
    // Read out options
538 539
    total_sectors = get_option_parameter(options, BLOCK_OPT_SIZE)->value.n /
                    BDRV_SECTOR_SIZE;
A
aliguori 已提交
540

541
    // Create the file
A
aliguori 已提交
542 543 544 545
    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
    if (fd < 0)
        return -EIO;

546 547 548 549 550
    /* Calculate matching total_size and geometry. Increase the number of
       sectors requested until we get enough (or fail). */
    for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
        if (calculate_geometry(total_sectors + i,
                               &cyls, &heads, &secs_per_cyl)) {
B
Blue Swirl 已提交
551 552
            ret = -EFBIG;
            goto fail;
553 554
        }
    }
A
aliguori 已提交
555 556 557 558 559
    total_sectors = (int64_t) cyls * heads * secs_per_cyl;

    // Prepare the Hard Disk Footer
    memset(buf, 0, 1024);

560
    memcpy(footer->creator, "conectix", 8);
A
aliguori 已提交
561
    // TODO Check if "qemu" creator_app is ok for VPC
562 563
    memcpy(footer->creator_app, "qemu", 4);
    memcpy(footer->creator_os, "Wi2k", 4);
A
aliguori 已提交
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590

    footer->features = be32_to_cpu(0x02);
    footer->version = be32_to_cpu(0x00010000);
    footer->data_offset = be64_to_cpu(HEADER_SIZE);
    footer->timestamp = be32_to_cpu(time(NULL) - VHD_TIMESTAMP_BASE);

    // Version of Virtual PC 2007
    footer->major = be16_to_cpu(0x0005);
    footer->minor =be16_to_cpu(0x0003);

    footer->orig_size = be64_to_cpu(total_sectors * 512);
    footer->size = be64_to_cpu(total_sectors * 512);

    footer->cyls = be16_to_cpu(cyls);
    footer->heads = heads;
    footer->secs_per_cyl = secs_per_cyl;

    footer->type = be32_to_cpu(VHD_DYNAMIC);

    // TODO uuid is missing

    footer->checksum = be32_to_cpu(vpc_checksum(buf, HEADER_SIZE));

    // Write the footer (twice: at the beginning and at the end)
    block_size = 0x200000;
    num_bat_entries = (total_sectors + block_size / 512) / (block_size / 512);

B
Blue Swirl 已提交
591 592 593
    if (write(fd, buf, HEADER_SIZE) != HEADER_SIZE) {
        goto fail;
    }
A
aliguori 已提交
594

B
Blue Swirl 已提交
595 596 597 598 599 600
    if (lseek(fd, 1536 + ((num_bat_entries * 4 + 511) & ~511), SEEK_SET) < 0) {
        goto fail;
    }
    if (write(fd, buf, HEADER_SIZE) != HEADER_SIZE) {
        goto fail;
    }
A
aliguori 已提交
601 602

    // Write the initial BAT
B
Blue Swirl 已提交
603 604 605
    if (lseek(fd, 3 * 512, SEEK_SET) < 0) {
        goto fail;
    }
A
aliguori 已提交
606 607

    memset(buf, 0xFF, 512);
B
Blue Swirl 已提交
608 609 610 611 612
    for (i = 0; i < (num_bat_entries * 4 + 511) / 512; i++) {
        if (write(fd, buf, 512) != 512) {
            goto fail;
        }
    }
A
aliguori 已提交
613 614 615 616 617


    // Prepare the Dynamic Disk Header
    memset(buf, 0, 1024);

618
    memcpy(dyndisk_header->magic, "cxsparse", 8);
A
aliguori 已提交
619 620 621 622 623 624 625 626 627 628

    dyndisk_header->data_offset = be64_to_cpu(0xFFFFFFFF);
    dyndisk_header->table_offset = be64_to_cpu(3 * 512);
    dyndisk_header->version = be32_to_cpu(0x00010000);
    dyndisk_header->block_size = be32_to_cpu(block_size);
    dyndisk_header->max_table_entries = be32_to_cpu(num_bat_entries);

    dyndisk_header->checksum = be32_to_cpu(vpc_checksum(buf, 1024));

    // Write the header
B
Blue Swirl 已提交
629 630 631
    if (lseek(fd, 512, SEEK_SET) < 0) {
        goto fail;
    }
A
aliguori 已提交
632

B
Blue Swirl 已提交
633 634 635 636 637 638
    if (write(fd, buf, 1024) != 1024) {
        goto fail;
    }
    ret = 0;

 fail:
A
aliguori 已提交
639
    close(fd);
B
Blue Swirl 已提交
640
    return ret;
A
aliguori 已提交
641 642
}

643 644 645
static void vpc_close(BlockDriverState *bs)
{
    BDRVVPCState *s = bs->opaque;
646
    g_free(s->pagetable);
647
#ifdef CACHE
648
    g_free(s->pageentry_u8);
649 650 651
#endif
}

652
static QEMUOptionParameter vpc_create_options[] = {
653 654 655 656 657
    {
        .name = BLOCK_OPT_SIZE,
        .type = OPT_SIZE,
        .help = "Virtual disk size"
    },
658 659 660
    { NULL }
};

661
static BlockDriver bdrv_vpc = {
K
Kevin Wolf 已提交
662 663 664 665
    .format_name    = "vpc",
    .instance_size  = sizeof(BDRVVPCState),
    .bdrv_probe     = vpc_probe,
    .bdrv_open      = vpc_open,
666
    .bdrv_read      = vpc_co_read,
667
    .bdrv_write     = vpc_co_write,
K
Kevin Wolf 已提交
668 669 670
    .bdrv_flush     = vpc_flush,
    .bdrv_close     = vpc_close,
    .bdrv_create    = vpc_create,
671 672

    .create_options = vpc_create_options,
673
};
674 675 676 677 678 679 680

static void bdrv_vpc_init(void)
{
    bdrv_register(&bdrv_vpc);
}

block_init(bdrv_vpc_init);