Revision 8b3b7206
| b/block/qcow2-cluster.c | ||
|---|---|---|
| 64 | 64 |
BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE); |
| 65 | 65 |
for(i = 0; i < s->l1_size; i++) |
| 66 | 66 |
new_l1_table[i] = cpu_to_be64(new_l1_table[i]); |
| 67 |
ret = bdrv_pwrite(bs->file, new_l1_table_offset, new_l1_table, new_l1_size2); |
|
| 68 |
if (ret != new_l1_size2)
|
|
| 67 |
ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, new_l1_table, new_l1_size2);
|
|
| 68 |
if (ret < 0)
|
|
| 69 | 69 |
goto fail; |
| 70 | 70 |
for(i = 0; i < s->l1_size; i++) |
| 71 | 71 |
new_l1_table[i] = be64_to_cpu(new_l1_table[i]); |
| ... | ... | |
| 74 | 74 |
BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE); |
| 75 | 75 |
cpu_to_be32w((uint32_t*)data, new_l1_size); |
| 76 | 76 |
cpu_to_be64w((uint64_t*)(data + 4), new_l1_table_offset); |
| 77 |
ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, l1_size), data,sizeof(data)); |
|
| 78 |
if (ret != sizeof(data)) {
|
|
| 77 |
ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size), data,sizeof(data));
|
|
| 78 |
if (ret < 0) {
|
|
| 79 | 79 |
goto fail; |
| 80 | 80 |
} |
| 81 | 81 |
qemu_free(s->l1_table); |
| ... | ... | |
| 87 | 87 |
fail: |
| 88 | 88 |
qemu_free(new_l1_table); |
| 89 | 89 |
qcow2_free_clusters(bs, new_l1_table_offset, new_l1_size2); |
| 90 |
return ret < 0 ? ret : -EIO;
|
|
| 90 |
return ret; |
|
| 91 | 91 |
} |
| 92 | 92 |
|
| 93 | 93 |
void qcow2_l2_cache_reset(BlockDriverState *bs) |
| ... | ... | |
| 207 | 207 |
} |
| 208 | 208 |
|
| 209 | 209 |
BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); |
| 210 |
ret = bdrv_pwrite(bs->file, s->l1_table_offset + 8 * l1_start_index, |
|
| 210 |
ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset + 8 * l1_start_index,
|
|
| 211 | 211 |
buf, sizeof(buf)); |
| 212 | 212 |
if (ret < 0) {
|
| 213 | 213 |
return ret; |
| ... | ... | |
| 263 | 263 |
} |
| 264 | 264 |
/* write the l2 table to the file */ |
| 265 | 265 |
BLKDBG_EVENT(bs->file, BLKDBG_L2_ALLOC_WRITE); |
| 266 |
ret = bdrv_pwrite(bs->file, l2_offset, l2_table, |
|
| 266 |
ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
|
|
| 267 | 267 |
s->l2_size * sizeof(uint64_t)); |
| 268 | 268 |
if (ret < 0) {
|
| 269 | 269 |
goto fail; |
| ... | ... | |
| 413 | 413 |
&s->aes_encrypt_key); |
| 414 | 414 |
} |
| 415 | 415 |
BLKDBG_EVENT(bs->file, BLKDBG_COW_WRITE); |
| 416 |
ret = bdrv_write(bs->file, (cluster_offset >> 9) + n_start, |
|
| 417 |
s->cluster_data, n);
|
|
| 416 |
ret = bdrv_write_sync(bs->file, (cluster_offset >> 9) + n_start,
|
|
| 417 |
s->cluster_data, n); |
|
| 418 | 418 |
if (ret < 0) |
| 419 | 419 |
return ret; |
| 420 | 420 |
return 0; |
| ... | ... | |
| 631 | 631 |
|
| 632 | 632 |
BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED); |
| 633 | 633 |
l2_table[l2_index] = cpu_to_be64(cluster_offset); |
| 634 |
if (bdrv_pwrite(bs->file, |
|
| 634 |
if (bdrv_pwrite_sync(bs->file,
|
|
| 635 | 635 |
l2_offset + l2_index * sizeof(uint64_t), |
| 636 | 636 |
l2_table + l2_index, |
| 637 |
sizeof(uint64_t)) != sizeof(uint64_t))
|
|
| 637 |
sizeof(uint64_t)) < 0)
|
|
| 638 | 638 |
return 0; |
| 639 | 639 |
|
| 640 | 640 |
return cluster_offset; |
| ... | ... | |
| 655 | 655 |
int ret; |
| 656 | 656 |
|
| 657 | 657 |
BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE); |
| 658 |
ret = bdrv_pwrite(bs->file, l2_offset + start_offset, |
|
| 658 |
ret = bdrv_pwrite_sync(bs->file, l2_offset + start_offset,
|
|
| 659 | 659 |
&l2_table[l2_start_index], len); |
| 660 | 660 |
if (ret < 0) {
|
| 661 | 661 |
return ret; |
| b/block/qcow2-refcount.c | ||
|---|---|---|
| 44 | 44 |
} |
| 45 | 45 |
|
| 46 | 46 |
BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE); |
| 47 |
if (bdrv_pwrite(bs->file, s->refcount_block_cache_offset, |
|
| 48 |
s->refcount_block_cache, size) != size)
|
|
| 47 |
if (bdrv_pwrite_sync(bs->file, s->refcount_block_cache_offset,
|
|
| 48 |
s->refcount_block_cache, size) < 0)
|
|
| 49 | 49 |
{
|
| 50 | 50 |
return -EIO; |
| 51 | 51 |
} |
| ... | ... | |
| 269 | 269 |
|
| 270 | 270 |
/* Now the new refcount block needs to be written to disk */ |
| 271 | 271 |
BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE); |
| 272 |
ret = bdrv_pwrite(bs->file, new_block, s->refcount_block_cache, |
|
| 272 |
ret = bdrv_pwrite_sync(bs->file, new_block, s->refcount_block_cache,
|
|
| 273 | 273 |
s->cluster_size); |
| 274 | 274 |
if (ret < 0) {
|
| 275 | 275 |
goto fail_block; |
| ... | ... | |
| 279 | 279 |
if (refcount_table_index < s->refcount_table_size) {
|
| 280 | 280 |
uint64_t data64 = cpu_to_be64(new_block); |
| 281 | 281 |
BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP); |
| 282 |
ret = bdrv_pwrite(bs->file, |
|
| 282 |
ret = bdrv_pwrite_sync(bs->file,
|
|
| 283 | 283 |
s->refcount_table_offset + refcount_table_index * sizeof(uint64_t), |
| 284 | 284 |
&data64, sizeof(data64)); |
| 285 | 285 |
if (ret < 0) {
|
| ... | ... | |
| 359 | 359 |
|
| 360 | 360 |
/* Write refcount blocks to disk */ |
| 361 | 361 |
BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS); |
| 362 |
ret = bdrv_pwrite(bs->file, meta_offset, new_blocks, |
|
| 362 |
ret = bdrv_pwrite_sync(bs->file, meta_offset, new_blocks,
|
|
| 363 | 363 |
blocks_clusters * s->cluster_size); |
| 364 | 364 |
qemu_free(new_blocks); |
| 365 | 365 |
if (ret < 0) {
|
| ... | ... | |
| 372 | 372 |
} |
| 373 | 373 |
|
| 374 | 374 |
BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE); |
| 375 |
ret = bdrv_pwrite(bs->file, table_offset, new_table, |
|
| 375 |
ret = bdrv_pwrite_sync(bs->file, table_offset, new_table,
|
|
| 376 | 376 |
table_size * sizeof(uint64_t)); |
| 377 | 377 |
if (ret < 0) {
|
| 378 | 378 |
goto fail_table; |
| ... | ... | |
| 387 | 387 |
cpu_to_be64w((uint64_t*)data, table_offset); |
| 388 | 388 |
cpu_to_be32w((uint32_t*)(data + 8), table_clusters); |
| 389 | 389 |
BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE); |
| 390 |
ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, refcount_table_offset), |
|
| 390 |
ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, refcount_table_offset),
|
|
| 391 | 391 |
data, sizeof(data)); |
| 392 | 392 |
if (ret < 0) {
|
| 393 | 393 |
goto fail_table; |
| ... | ... | |
| 444 | 444 |
size = (last_index - first_index) << REFCOUNT_SHIFT; |
| 445 | 445 |
|
| 446 | 446 |
BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_UPDATE_PART); |
| 447 |
ret = bdrv_pwrite(bs->file, |
|
| 447 |
ret = bdrv_pwrite_sync(bs->file,
|
|
| 448 | 448 |
refcount_block_offset + (first_index << REFCOUNT_SHIFT), |
| 449 | 449 |
&s->refcount_block_cache[first_index], size); |
| 450 | 450 |
if (ret < 0) {
|
| ... | ... | |
| 826 | 826 |
} |
| 827 | 827 |
} |
| 828 | 828 |
if (l2_modified) {
|
| 829 |
if (bdrv_pwrite(bs->file, |
|
| 830 |
l2_offset, l2_table, l2_size) != l2_size)
|
|
| 829 |
if (bdrv_pwrite_sync(bs->file,
|
|
| 830 |
l2_offset, l2_table, l2_size) < 0)
|
|
| 831 | 831 |
goto fail; |
| 832 | 832 |
} |
| 833 | 833 |
|
| ... | ... | |
| 850 | 850 |
if (l1_modified) {
|
| 851 | 851 |
for(i = 0; i < l1_size; i++) |
| 852 | 852 |
cpu_to_be64s(&l1_table[i]); |
| 853 |
if (bdrv_pwrite(bs->file, l1_table_offset, l1_table, |
|
| 854 |
l1_size2) != l1_size2)
|
|
| 853 |
if (bdrv_pwrite_sync(bs->file, l1_table_offset, l1_table,
|
|
| 854 |
l1_size2) < 0)
|
|
| 855 | 855 |
goto fail; |
| 856 | 856 |
for(i = 0; i < l1_size; i++) |
| 857 | 857 |
be64_to_cpus(&l1_table[i]); |
| b/block/qcow2-snapshot.c | ||
|---|---|---|
| 158 | 158 |
h.id_str_size = cpu_to_be16(id_str_size); |
| 159 | 159 |
h.name_size = cpu_to_be16(name_size); |
| 160 | 160 |
offset = align_offset(offset, 8); |
| 161 |
if (bdrv_pwrite(bs->file, offset, &h, sizeof(h)) != sizeof(h))
|
|
| 161 |
if (bdrv_pwrite_sync(bs->file, offset, &h, sizeof(h)) < 0)
|
|
| 162 | 162 |
goto fail; |
| 163 | 163 |
offset += sizeof(h); |
| 164 |
if (bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size) != id_str_size)
|
|
| 164 |
if (bdrv_pwrite_sync(bs->file, offset, sn->id_str, id_str_size) < 0)
|
|
| 165 | 165 |
goto fail; |
| 166 | 166 |
offset += id_str_size; |
| 167 |
if (bdrv_pwrite(bs->file, offset, sn->name, name_size) != name_size)
|
|
| 167 |
if (bdrv_pwrite_sync(bs->file, offset, sn->name, name_size) < 0)
|
|
| 168 | 168 |
goto fail; |
| 169 | 169 |
offset += name_size; |
| 170 | 170 |
} |
| 171 | 171 |
|
| 172 | 172 |
/* update the various header fields */ |
| 173 | 173 |
data64 = cpu_to_be64(snapshots_offset); |
| 174 |
if (bdrv_pwrite(bs->file, offsetof(QCowHeader, snapshots_offset), |
|
| 175 |
&data64, sizeof(data64)) != sizeof(data64))
|
|
| 174 |
if (bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, snapshots_offset),
|
|
| 175 |
&data64, sizeof(data64)) < 0)
|
|
| 176 | 176 |
goto fail; |
| 177 | 177 |
data32 = cpu_to_be32(s->nb_snapshots); |
| 178 |
if (bdrv_pwrite(bs->file, offsetof(QCowHeader, nb_snapshots), |
|
| 179 |
&data32, sizeof(data32)) != sizeof(data32))
|
|
| 178 |
if (bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
|
|
| 179 |
&data32, sizeof(data32)) < 0)
|
|
| 180 | 180 |
goto fail; |
| 181 | 181 |
|
| 182 | 182 |
/* free the old snapshot table */ |
| ... | ... | |
| 284 | 284 |
for(i = 0; i < s->l1_size; i++) {
|
| 285 | 285 |
l1_table[i] = cpu_to_be64(s->l1_table[i]); |
| 286 | 286 |
} |
| 287 |
if (bdrv_pwrite(bs->file, sn->l1_table_offset, |
|
| 288 |
l1_table, s->l1_size * sizeof(uint64_t)) != |
|
| 289 |
(s->l1_size * sizeof(uint64_t))) |
|
| 287 |
if (bdrv_pwrite_sync(bs->file, sn->l1_table_offset, |
|
| 288 |
l1_table, s->l1_size * sizeof(uint64_t)) < 0) |
|
| 290 | 289 |
goto fail; |
| 291 | 290 |
qemu_free(l1_table); |
| 292 | 291 |
l1_table = NULL; |
| ... | ... | |
| 335 | 334 |
if (bdrv_pread(bs->file, sn->l1_table_offset, |
| 336 | 335 |
s->l1_table, l1_size2) != l1_size2) |
| 337 | 336 |
goto fail; |
| 338 |
if (bdrv_pwrite(bs->file, s->l1_table_offset, |
|
| 339 |
s->l1_table, l1_size2) != l1_size2)
|
|
| 337 |
if (bdrv_pwrite_sync(bs->file, s->l1_table_offset,
|
|
| 338 |
s->l1_table, l1_size2) < 0)
|
|
| 340 | 339 |
goto fail; |
| 341 | 340 |
for(i = 0;i < s->l1_size; i++) {
|
| 342 | 341 |
be64_to_cpus(&s->l1_table[i]); |
| b/block/qcow2.c | ||
|---|---|---|
| 735 | 735 |
backing_file_offset = sizeof(QCowHeader) + offset; |
| 736 | 736 |
} |
| 737 | 737 |
|
| 738 |
ret = bdrv_pwrite(bs->file, sizeof(QCowHeader), buf, ext_size); |
|
| 738 |
ret = bdrv_pwrite_sync(bs->file, sizeof(QCowHeader), buf, ext_size);
|
|
| 739 | 739 |
if (ret < 0) {
|
| 740 | 740 |
goto fail; |
| 741 | 741 |
} |
| ... | ... | |
| 744 | 744 |
uint64_t be_backing_file_offset = cpu_to_be64(backing_file_offset); |
| 745 | 745 |
uint32_t be_backing_file_size = cpu_to_be32(backing_file_len); |
| 746 | 746 |
|
| 747 |
ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, backing_file_offset), |
|
| 747 |
ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, backing_file_offset),
|
|
| 748 | 748 |
&be_backing_file_offset, sizeof(uint64_t)); |
| 749 | 749 |
if (ret < 0) {
|
| 750 | 750 |
goto fail; |
| 751 | 751 |
} |
| 752 | 752 |
|
| 753 |
ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, backing_file_size), |
|
| 753 |
ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, backing_file_size),
|
|
| 754 | 754 |
&be_backing_file_size, sizeof(uint32_t)); |
| 755 | 755 |
if (ret < 0) {
|
| 756 | 756 |
goto fail; |
| ... | ... | |
| 1131 | 1131 |
|
| 1132 | 1132 |
/* write updated header.size */ |
| 1133 | 1133 |
offset = cpu_to_be64(offset); |
| 1134 |
ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, size), |
|
| 1135 |
&offset, sizeof(uint64_t)); |
|
| 1134 |
ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
|
|
| 1135 |
&offset, sizeof(uint64_t));
|
|
| 1136 | 1136 |
if (ret < 0) {
|
| 1137 | 1137 |
return ret; |
| 1138 | 1138 |
} |
Also available in: Unified diff