Revision 6511ef77
| b/block/vmdk.c | ||
|---|---|---|
| 108 | 108 |
|
| 109 | 109 |
static uint32_t vmdk_read_cid(BlockDriverState *bs, int parent) |
| 110 | 110 |
{
|
| 111 |
BDRVVmdkState *s = bs->opaque; |
|
| 112 | 111 |
char desc[DESC_SIZE]; |
| 113 | 112 |
uint32_t cid; |
| 114 | 113 |
const char *p_name, *cid_str; |
| 115 | 114 |
size_t cid_str_size; |
| 116 | 115 |
|
| 117 | 116 |
/* the descriptor offset = 0x200 */ |
| 118 |
if (bdrv_pread(s->hd, 0x200, desc, DESC_SIZE) != DESC_SIZE)
|
|
| 117 |
if (bdrv_pread(bs->file, 0x200, desc, DESC_SIZE) != DESC_SIZE)
|
|
| 119 | 118 |
return 0; |
| 120 | 119 |
|
| 121 | 120 |
if (parent) {
|
| ... | ... | |
| 136 | 135 |
|
| 137 | 136 |
static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid) |
| 138 | 137 |
{
|
| 139 |
BDRVVmdkState *s = bs->opaque; |
|
| 140 | 138 |
char desc[DESC_SIZE], tmp_desc[DESC_SIZE]; |
| 141 | 139 |
char *p_name, *tmp_str; |
| 142 | 140 |
|
| 143 | 141 |
/* the descriptor offset = 0x200 */ |
| 144 |
if (bdrv_pread(s->hd, 0x200, desc, DESC_SIZE) != DESC_SIZE)
|
|
| 142 |
if (bdrv_pread(bs->file, 0x200, desc, DESC_SIZE) != DESC_SIZE)
|
|
| 145 | 143 |
return -1; |
| 146 | 144 |
|
| 147 | 145 |
tmp_str = strstr(desc,"parentCID"); |
| ... | ... | |
| 152 | 150 |
pstrcat(desc, sizeof(desc), tmp_desc); |
| 153 | 151 |
} |
| 154 | 152 |
|
| 155 |
if (bdrv_pwrite(s->hd, 0x200, desc, DESC_SIZE) != DESC_SIZE)
|
|
| 153 |
if (bdrv_pwrite(bs->file, 0x200, desc, DESC_SIZE) != DESC_SIZE)
|
|
| 156 | 154 |
return -1; |
| 157 | 155 |
return 0; |
| 158 | 156 |
} |
| ... | ... | |
| 339 | 337 |
|
| 340 | 338 |
static int vmdk_parent_open(BlockDriverState *bs) |
| 341 | 339 |
{
|
| 342 |
BDRVVmdkState *s = bs->opaque; |
|
| 343 | 340 |
char *p_name; |
| 344 | 341 |
char desc[DESC_SIZE]; |
| 345 | 342 |
|
| 346 | 343 |
/* the descriptor offset = 0x200 */ |
| 347 |
if (bdrv_pread(s->hd, 0x200, desc, DESC_SIZE) != DESC_SIZE)
|
|
| 344 |
if (bdrv_pread(bs->file, 0x200, desc, DESC_SIZE) != DESC_SIZE)
|
|
| 348 | 345 |
return -1; |
| 349 | 346 |
|
| 350 | 347 |
if ((p_name = strstr(desc,"parentFileNameHint")) != NULL) {
|
| ... | ... | |
| 362 | 359 |
return 0; |
| 363 | 360 |
} |
| 364 | 361 |
|
| 365 |
static int vmdk_open(BlockDriverState *bs, const char *filename, int flags)
|
|
| 362 |
static int vmdk_open(BlockDriverState *bs, int flags) |
|
| 366 | 363 |
{
|
| 367 | 364 |
BDRVVmdkState *s = bs->opaque; |
| 368 | 365 |
uint32_t magic; |
| 369 |
int l1_size, i, ret;
|
|
| 366 |
int l1_size, i; |
|
| 370 | 367 |
|
| 371 |
ret = bdrv_file_open(&s->hd, filename, flags); |
|
| 372 |
if (ret < 0) |
|
| 373 |
return ret; |
|
| 374 |
if (bdrv_pread(s->hd, 0, &magic, sizeof(magic)) != sizeof(magic)) |
|
| 368 |
if (bdrv_pread(bs->file, 0, &magic, sizeof(magic)) != sizeof(magic)) |
|
| 375 | 369 |
goto fail; |
| 376 | 370 |
|
| 377 | 371 |
magic = be32_to_cpu(magic); |
| 378 | 372 |
if (magic == VMDK3_MAGIC) {
|
| 379 | 373 |
VMDK3Header header; |
| 380 | 374 |
|
| 381 |
if (bdrv_pread(s->hd, sizeof(magic), &header, sizeof(header)) != sizeof(header))
|
|
| 375 |
if (bdrv_pread(bs->file, sizeof(magic), &header, sizeof(header)) != sizeof(header))
|
|
| 382 | 376 |
goto fail; |
| 383 | 377 |
s->cluster_sectors = le32_to_cpu(header.granularity); |
| 384 | 378 |
s->l2_size = 1 << 9; |
| ... | ... | |
| 390 | 384 |
} else if (magic == VMDK4_MAGIC) {
|
| 391 | 385 |
VMDK4Header header; |
| 392 | 386 |
|
| 393 |
if (bdrv_pread(s->hd, sizeof(magic), &header, sizeof(header)) != sizeof(header))
|
|
| 387 |
if (bdrv_pread(bs->file, sizeof(magic), &header, sizeof(header)) != sizeof(header))
|
|
| 394 | 388 |
goto fail; |
| 395 | 389 |
bs->total_sectors = le64_to_cpu(header.capacity); |
| 396 | 390 |
s->cluster_sectors = le64_to_cpu(header.granularity); |
| ... | ... | |
| 415 | 409 |
/* read the L1 table */ |
| 416 | 410 |
l1_size = s->l1_size * sizeof(uint32_t); |
| 417 | 411 |
s->l1_table = qemu_malloc(l1_size); |
| 418 |
if (bdrv_pread(s->hd, s->l1_table_offset, s->l1_table, l1_size) != l1_size)
|
|
| 412 |
if (bdrv_pread(bs->file, s->l1_table_offset, s->l1_table, l1_size) != l1_size)
|
|
| 419 | 413 |
goto fail; |
| 420 | 414 |
for(i = 0; i < s->l1_size; i++) {
|
| 421 | 415 |
le32_to_cpus(&s->l1_table[i]); |
| ... | ... | |
| 423 | 417 |
|
| 424 | 418 |
if (s->l1_backup_table_offset) {
|
| 425 | 419 |
s->l1_backup_table = qemu_malloc(l1_size); |
| 426 |
if (bdrv_pread(s->hd, s->l1_backup_table_offset, s->l1_backup_table, l1_size) != l1_size)
|
|
| 420 |
if (bdrv_pread(bs->file, s->l1_backup_table_offset, s->l1_backup_table, l1_size) != l1_size)
|
|
| 427 | 421 |
goto fail; |
| 428 | 422 |
for(i = 0; i < s->l1_size; i++) {
|
| 429 | 423 |
le32_to_cpus(&s->l1_backup_table[i]); |
| ... | ... | |
| 436 | 430 |
qemu_free(s->l1_backup_table); |
| 437 | 431 |
qemu_free(s->l1_table); |
| 438 | 432 |
qemu_free(s->l2_cache); |
| 439 |
bdrv_delete(s->hd); |
|
| 440 | 433 |
return -1; |
| 441 | 434 |
} |
| 442 | 435 |
|
| ... | ... | |
| 464 | 457 |
} |
| 465 | 458 |
|
| 466 | 459 |
//Write grain only into the active image |
| 467 |
ret = bdrv_write(s->hd, cluster_offset, whole_grain,
|
|
| 460 |
ret = bdrv_write(bs->file, cluster_offset, whole_grain,
|
|
| 468 | 461 |
s->cluster_sectors); |
| 469 | 462 |
if (ret < 0) {
|
| 470 | 463 |
return -1; |
| ... | ... | |
| 478 | 471 |
BDRVVmdkState *s = bs->opaque; |
| 479 | 472 |
|
| 480 | 473 |
/* update L2 table */ |
| 481 |
if (bdrv_pwrite(s->hd, ((int64_t)m_data->l2_offset * 512) + (m_data->l2_index * sizeof(m_data->offset)),
|
|
| 474 |
if (bdrv_pwrite(bs->file, ((int64_t)m_data->l2_offset * 512) + (m_data->l2_index * sizeof(m_data->offset)),
|
|
| 482 | 475 |
&(m_data->offset), sizeof(m_data->offset)) != sizeof(m_data->offset)) |
| 483 | 476 |
return -1; |
| 484 | 477 |
/* update backup L2 table */ |
| 485 | 478 |
if (s->l1_backup_table_offset != 0) {
|
| 486 | 479 |
m_data->l2_offset = s->l1_backup_table[m_data->l1_index]; |
| 487 |
if (bdrv_pwrite(s->hd, ((int64_t)m_data->l2_offset * 512) + (m_data->l2_index * sizeof(m_data->offset)),
|
|
| 480 |
if (bdrv_pwrite(bs->file, ((int64_t)m_data->l2_offset * 512) + (m_data->l2_index * sizeof(m_data->offset)),
|
|
| 488 | 481 |
&(m_data->offset), sizeof(m_data->offset)) != sizeof(m_data->offset)) |
| 489 | 482 |
return -1; |
| 490 | 483 |
} |
| ... | ... | |
| 532 | 525 |
} |
| 533 | 526 |
} |
| 534 | 527 |
l2_table = s->l2_cache + (min_index * s->l2_size); |
| 535 |
if (bdrv_pread(s->hd, (int64_t)l2_offset * 512, l2_table, s->l2_size * sizeof(uint32_t)) !=
|
|
| 528 |
if (bdrv_pread(bs->file, (int64_t)l2_offset * 512, l2_table, s->l2_size * sizeof(uint32_t)) !=
|
|
| 536 | 529 |
s->l2_size * sizeof(uint32_t)) |
| 537 | 530 |
return 0; |
| 538 | 531 |
|
| ... | ... | |
| 547 | 540 |
return 0; |
| 548 | 541 |
|
| 549 | 542 |
// Avoid the L2 tables update for the images that have snapshots. |
| 550 |
cluster_offset = bdrv_getlength(s->hd);
|
|
| 551 |
bdrv_truncate(s->hd, cluster_offset + (s->cluster_sectors << 9));
|
|
| 543 |
cluster_offset = bdrv_getlength(bs->file);
|
|
| 544 |
bdrv_truncate(bs->file, cluster_offset + (s->cluster_sectors << 9));
|
|
| 552 | 545 |
|
| 553 | 546 |
cluster_offset >>= 9; |
| 554 | 547 |
tmp = cpu_to_le32(cluster_offset); |
| ... | ... | |
| 615 | 608 |
memset(buf, 0, 512 * n); |
| 616 | 609 |
} |
| 617 | 610 |
} else {
|
| 618 |
if(bdrv_pread(s->hd, cluster_offset + index_in_cluster * 512, buf, n * 512) != n * 512)
|
|
| 611 |
if(bdrv_pread(bs->file, cluster_offset + index_in_cluster * 512, buf, n * 512) != n * 512)
|
|
| 619 | 612 |
return -1; |
| 620 | 613 |
} |
| 621 | 614 |
nb_sectors -= n; |
| ... | ... | |
| 651 | 644 |
if (!cluster_offset) |
| 652 | 645 |
return -1; |
| 653 | 646 |
|
| 654 |
if (bdrv_pwrite(s->hd, cluster_offset + index_in_cluster * 512, buf, n * 512) != n * 512)
|
|
| 647 |
if (bdrv_pwrite(bs->file, cluster_offset + index_in_cluster * 512, buf, n * 512) != n * 512)
|
|
| 655 | 648 |
return -1; |
| 656 | 649 |
if (m_data.valid) {
|
| 657 | 650 |
/* update L2 tables */ |
| ... | ... | |
| 828 | 821 |
|
| 829 | 822 |
qemu_free(s->l1_table); |
| 830 | 823 |
qemu_free(s->l2_cache); |
| 831 |
bdrv_delete(s->hd); |
|
| 832 | 824 |
} |
| 833 | 825 |
|
| 834 | 826 |
static void vmdk_flush(BlockDriverState *bs) |
| 835 | 827 |
{
|
| 836 |
BDRVVmdkState *s = bs->opaque; |
|
| 837 |
bdrv_flush(s->hd); |
|
| 828 |
bdrv_flush(bs->file); |
|
| 838 | 829 |
} |
| 839 | 830 |
|
| 840 | 831 |
|
| ... | ... | |
| 861 | 852 |
.format_name = "vmdk", |
| 862 | 853 |
.instance_size = sizeof(BDRVVmdkState), |
| 863 | 854 |
.bdrv_probe = vmdk_probe, |
| 864 |
.bdrv_file_open = vmdk_open,
|
|
| 855 |
.bdrv_open = vmdk_open,
|
|
| 865 | 856 |
.bdrv_read = vmdk_read, |
| 866 | 857 |
.bdrv_write = vmdk_write, |
| 867 | 858 |
.bdrv_close = vmdk_close, |
Also available in: Unified diff