Revision 205ef796
b/block.c | ||
---|---|---|
1453 | 1453 |
return bs->device_name; |
1454 | 1454 |
} |
1455 | 1455 |
|
1456 |
void bdrv_flush(BlockDriverState *bs)
|
|
1456 |
int bdrv_flush(BlockDriverState *bs)
|
|
1457 | 1457 |
{ |
1458 | 1458 |
if (bs->open_flags & BDRV_O_NO_FLUSH) { |
1459 |
return; |
|
1459 |
return 0; |
|
1460 |
} |
|
1461 |
|
|
1462 |
if (bs->drv && bs->drv->bdrv_flush) { |
|
1463 |
return bs->drv->bdrv_flush(bs); |
|
1460 | 1464 |
} |
1461 | 1465 |
|
1462 |
if (bs->drv && bs->drv->bdrv_flush) |
|
1463 |
bs->drv->bdrv_flush(bs); |
|
1466 |
/* |
|
1467 |
* Some block drivers always operate in either writethrough or unsafe mode |
|
1468 |
* and don't support bdrv_flush therefore. Usually qemu doesn't know how |
|
1469 |
* the server works (because the behaviour is hardcoded or depends on |
|
1470 |
* server-side configuration), so we can't ensure that everything is safe |
|
1471 |
* on disk. Returning an error doesn't work because that would break guests |
|
1472 |
* even if the server operates in writethrough mode. |
|
1473 |
* |
|
1474 |
* Let's hope the user knows what he's doing. |
|
1475 |
*/ |
|
1476 |
return 0; |
|
1464 | 1477 |
} |
1465 | 1478 |
|
1466 | 1479 |
void bdrv_flush_all(void) |
b/block.h | ||
---|---|---|
142 | 142 |
BlockDriverCompletionFunc *cb, void *opaque); |
143 | 143 |
|
144 | 144 |
/* Ensure contents are flushed to disk. */ |
145 |
void bdrv_flush(BlockDriverState *bs);
|
|
145 |
int bdrv_flush(BlockDriverState *bs);
|
|
146 | 146 |
void bdrv_flush_all(void); |
147 | 147 |
void bdrv_close_all(void); |
148 | 148 |
|
b/block/blkdebug.c | ||
---|---|---|
397 | 397 |
} |
398 | 398 |
} |
399 | 399 |
|
400 |
static void blkdebug_flush(BlockDriverState *bs)
|
|
400 |
static int blkdebug_flush(BlockDriverState *bs)
|
|
401 | 401 |
{ |
402 |
bdrv_flush(bs->file); |
|
402 |
return bdrv_flush(bs->file);
|
|
403 | 403 |
} |
404 | 404 |
|
405 | 405 |
static BlockDriverAIOCB *blkdebug_aio_flush(BlockDriverState *bs, |
b/block/blkverify.c | ||
---|---|---|
116 | 116 |
s->test_file = NULL; |
117 | 117 |
} |
118 | 118 |
|
119 |
static void blkverify_flush(BlockDriverState *bs)
|
|
119 |
static int blkverify_flush(BlockDriverState *bs)
|
|
120 | 120 |
{ |
121 | 121 |
BDRVBlkverifyState *s = bs->opaque; |
122 | 122 |
|
123 | 123 |
/* Only flush test file, the raw file is not important */ |
124 |
bdrv_flush(s->test_file); |
|
124 |
return bdrv_flush(s->test_file);
|
|
125 | 125 |
} |
126 | 126 |
|
127 | 127 |
static int64_t blkverify_getlength(BlockDriverState *bs) |
b/block/cow.c | ||
---|---|---|
282 | 282 |
return ret; |
283 | 283 |
} |
284 | 284 |
|
285 |
static void cow_flush(BlockDriverState *bs)
|
|
285 |
static int cow_flush(BlockDriverState *bs)
|
|
286 | 286 |
{ |
287 |
bdrv_flush(bs->file); |
|
287 |
return bdrv_flush(bs->file);
|
|
288 | 288 |
} |
289 | 289 |
|
290 | 290 |
static QEMUOptionParameter cow_create_options[] = { |
b/block/qcow.c | ||
---|---|---|
910 | 910 |
return 0; |
911 | 911 |
} |
912 | 912 |
|
913 |
static void qcow_flush(BlockDriverState *bs)
|
|
913 |
static int qcow_flush(BlockDriverState *bs)
|
|
914 | 914 |
{ |
915 |
bdrv_flush(bs->file); |
|
915 |
return bdrv_flush(bs->file);
|
|
916 | 916 |
} |
917 | 917 |
|
918 | 918 |
static BlockDriverAIOCB *qcow_aio_flush(BlockDriverState *bs, |
b/block/qcow2.c | ||
---|---|---|
1148 | 1148 |
return 0; |
1149 | 1149 |
} |
1150 | 1150 |
|
1151 |
static void qcow_flush(BlockDriverState *bs)
|
|
1151 |
static int qcow_flush(BlockDriverState *bs)
|
|
1152 | 1152 |
{ |
1153 |
bdrv_flush(bs->file); |
|
1153 |
return bdrv_flush(bs->file);
|
|
1154 | 1154 |
} |
1155 | 1155 |
|
1156 | 1156 |
static BlockDriverAIOCB *qcow_aio_flush(BlockDriverState *bs, |
b/block/raw-posix.c | ||
---|---|---|
734 | 734 |
return result; |
735 | 735 |
} |
736 | 736 |
|
737 |
static void raw_flush(BlockDriverState *bs)
|
|
737 |
static int raw_flush(BlockDriverState *bs)
|
|
738 | 738 |
{ |
739 | 739 |
BDRVRawState *s = bs->opaque; |
740 |
qemu_fdatasync(s->fd); |
|
740 |
return qemu_fdatasync(s->fd);
|
|
741 | 741 |
} |
742 | 742 |
|
743 | 743 |
|
b/block/raw-win32.c | ||
---|---|---|
150 | 150 |
static void raw_flush(BlockDriverState *bs) |
151 | 151 |
{ |
152 | 152 |
BDRVRawState *s = bs->opaque; |
153 |
FlushFileBuffers(s->hfile); |
|
153 |
int ret; |
|
154 |
|
|
155 |
ret = FlushFileBuffers(s->hfile); |
|
156 |
if (ret != 0) { |
|
157 |
return -EIO; |
|
158 |
} |
|
159 |
|
|
160 |
return 0; |
|
154 | 161 |
} |
155 | 162 |
|
156 | 163 |
static void raw_close(BlockDriverState *bs) |
b/block/raw.c | ||
---|---|---|
39 | 39 |
{ |
40 | 40 |
} |
41 | 41 |
|
42 |
static void raw_flush(BlockDriverState *bs)
|
|
42 |
static int raw_flush(BlockDriverState *bs)
|
|
43 | 43 |
{ |
44 |
bdrv_flush(bs->file); |
|
44 |
return bdrv_flush(bs->file);
|
|
45 | 45 |
} |
46 | 46 |
|
47 | 47 |
static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs, |
b/block/vdi.c | ||
---|---|---|
900 | 900 |
{ |
901 | 901 |
} |
902 | 902 |
|
903 |
static void vdi_flush(BlockDriverState *bs)
|
|
903 |
static int vdi_flush(BlockDriverState *bs)
|
|
904 | 904 |
{ |
905 | 905 |
logout("\n"); |
906 |
bdrv_flush(bs->file); |
|
906 |
return bdrv_flush(bs->file);
|
|
907 | 907 |
} |
908 | 908 |
|
909 | 909 |
|
b/block/vmdk.c | ||
---|---|---|
823 | 823 |
qemu_free(s->l2_cache); |
824 | 824 |
} |
825 | 825 |
|
826 |
static void vmdk_flush(BlockDriverState *bs)
|
|
826 |
static int vmdk_flush(BlockDriverState *bs)
|
|
827 | 827 |
{ |
828 |
bdrv_flush(bs->file); |
|
828 |
return bdrv_flush(bs->file);
|
|
829 | 829 |
} |
830 | 830 |
|
831 | 831 |
|
b/block_int.h | ||
---|---|---|
59 | 59 |
const uint8_t *buf, int nb_sectors); |
60 | 60 |
void (*bdrv_close)(BlockDriverState *bs); |
61 | 61 |
int (*bdrv_create)(const char *filename, QEMUOptionParameter *options); |
62 |
void (*bdrv_flush)(BlockDriverState *bs);
|
|
62 |
int (*bdrv_flush)(BlockDriverState *bs);
|
|
63 | 63 |
int (*bdrv_is_allocated)(BlockDriverState *bs, int64_t sector_num, |
64 | 64 |
int nb_sectors, int *pnum); |
65 | 65 |
int (*bdrv_set_key)(BlockDriverState *bs, const char *key); |
Also available in: Unified diff