Lines Matching refs:bs
47 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
50 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
53 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
55 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
57 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
59 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
159 BlockDriverState *bs;
161 bs = g_malloc0(sizeof(BlockDriverState));
162 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
164 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
166 return bs;
340 BlockDriverState *bs;
342 ret = bdrv_file_open(&bs, filename, 0);
349 if (bs->sg || !bdrv_is_inserted(bs)) {
350 bdrv_delete(bs);
359 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
360 bdrv_delete(bs);
387 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
389 BlockDriver *drv = bs->drv;
392 if (bs->sg)
397 int64_t length = drv->bdrv_getlength(bs);
404 bs->total_sectors = hint;
411 static int bdrv_open_common(BlockDriverState *bs, const char *filename,
418 bs->file = NULL;
419 bs->total_sectors = 0;
420 bs->encrypted = 0;
421 bs->valid_key = 0;
422 bs->open_flags = flags;
424 bs->buffer_alignment = 512;
426 pstrcpy(bs->filename, sizeof(bs->filename), filename);
432 bs->drv = drv;
433 bs->opaque = g_malloc0(drv->instance_size);
442 bs->enable_write_cache = 1;
453 if (bs->is_temporary) {
459 ret = drv->bdrv_file_open(bs, filename, open_flags);
461 ret = bdrv_file_open(&bs->file, filename, open_flags);
463 ret = drv->bdrv_open(bs, open_flags);
471 bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
473 ret = refresh_total_sectors(bs, bs->total_sectors);
479 if (bs->is_temporary) {
486 if (bs->file) {
487 bdrv_delete(bs->file);
488 bs->file = NULL;
490 g_free(bs->opaque);
491 bs->opaque = NULL;
492 bs->drv = NULL;
501 BlockDriverState *bs;
510 bs = bdrv_new("");
511 ret = bdrv_open_common(bs, filename, flags, drv);
513 bdrv_delete(bs);
516 bs->growable = 1;
517 *pbs = bs;
524 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
583 bs->is_temporary = 1;
597 ret = bdrv_open_common(bs, filename, flags, drv);
602 bs->probed = probed;
605 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
610 bs->backing_hd = bdrv_new("");
612 filename, bs->backing_file);
613 if (bs->backing_format[0] != '\0')
614 back_drv = bdrv_find_format(bs->backing_format);
620 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv);
622 bdrv_close(bs);
625 if (bs->is_temporary) {
626 bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
629 bs->backing_hd->keep_read_only = bs->keep_read_only;
633 if (!bdrv_key_required(bs)) {
635 bs->media_changed = 1;
636 if (bs->change_cb)
637 bs->change_cb(bs->change_opaque);
643 if (bs->is_temporary) {
649 void bdrv_close(BlockDriverState *bs)
651 if (bs->drv) {
652 if (bs == bs_snapshots) {
655 if (bs->backing_hd) {
656 bdrv_delete(bs->backing_hd);
657 bs->backing_hd = NULL;
659 bs->drv->bdrv_close(bs);
660 g_free(bs->opaque);
662 if (bs->is_temporary) {
663 unlink(bs->filename);
666 bs->opaque = NULL;
667 bs->drv = NULL;
669 if (bs->file != NULL) {
670 bdrv_close(bs->file);
674 bs->media_changed = 1;
675 if (bs->change_cb)
676 bs->change_cb(bs->change_opaque);
682 BlockDriverState *bs;
684 QTAILQ_FOREACH(bs, &bdrv_states, list) {
685 bdrv_close(bs);
689 void bdrv_delete(BlockDriverState *bs)
691 assert(!bs->peer);
694 if (bs->device_name[0] != '\0') {
695 QTAILQ_REMOVE(&bdrv_states, bs, list);
698 bdrv_close(bs);
699 if (bs->file != NULL) {
700 bdrv_delete(bs->file);
703 assert(bs != bs_snapshots);
704 g_free(bs);
707 int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)
709 if (bs->peer) {
712 bs->peer = qdev;
716 void bdrv_detach(BlockDriverState *bs, DeviceState *qdev)
718 assert(bs->peer == qdev);
719 bs->peer = NULL;
722 DeviceState *bdrv_get_attached(BlockDriverState *bs)
724 return bs->peer;
734 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
736 if (bs->drv->bdrv_check == NULL) {
741 return bs->drv->bdrv_check(bs, res);
747 int bdrv_commit(BlockDriverState *bs)
749 BlockDriver *drv = bs->drv;
760 if (!bs->backing_hd) {
764 if (bs->backing_hd->keep_read_only) {
768 ro = bs->backing_hd->read_only;
769 strncpy(filename, bs->backing_hd->filename, sizeof(filename));
770 open_flags = bs->backing_hd->open_flags;
774 bdrv_delete(bs->backing_hd);
775 bs->backing_hd = NULL;
786 bs->drv = NULL;
789 bs->backing_hd = bs_ro;
792 bs->backing_hd = bs_rw;
795 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
799 if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
801 if (bdrv_read(bs, sector, buf, n) != 0) {
806 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
814 ret = drv->bdrv_make_empty(bs);
815 bdrv_flush(bs);
822 if (bs->backing_hd)
823 bdrv_flush(bs->backing_hd);
830 bdrv_delete(bs->backing_hd);
831 bs->backing_hd = NULL;
837 bs->drv = NULL;
840 bs->backing_hd = bs_ro;
841 bs->backing_hd->keep_read_only = 0;
849 BlockDriverState *bs;
851 QTAILQ_FOREACH(bs, &bdrv_states, list) {
852 bdrv_commit(bs);
864 int bdrv_change_backing_file(BlockDriverState *bs,
867 BlockDriver *drv = bs->drv;
870 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
876 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
881 if (!bdrv_is_inserted(bs))
884 if (bs->growable)
887 len = bdrv_getlength(bs);
898 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
901 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
906 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
909 BlockDriver *drv = bs->drv;
913 if (bdrv_check_request(bs, sector_num, nb_sectors))
916 return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
919 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
931 val = bs->dirty_bitmap[idx];
934 bs->dirty_count++;
939 bs->dirty_count--;
943 bs->dirty_bitmap[idx] = val;
953 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
956 BlockDriver *drv = bs->drv;
957 if (!bs->drv)
959 if (bs->read_only)
961 if (bdrv_check_request(bs, sector_num, nb_sectors))
964 if (bs->dirty_bitmap) {
965 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
968 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
969 bs->wr_highest_sector = sector_num + nb_sectors - 1;
972 return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
975 int bdrv_pread(BlockDriverState *bs, int64_t offset,
990 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1003 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1013 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1020 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1035 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1038 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1050 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1060 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1063 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1075 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1080 ret = bdrv_pwrite(bs, offset, buf, count);
1086 if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) {
1087 bdrv_flush(bs);
1099 int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num,
1102 return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num,
1109 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1111 BlockDriver *drv = bs->drv;
1117 if (bs->read_only)
1119 ret = drv->bdrv_truncate(bs, offset);
1121 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1129 int64_t bdrv_getlength(BlockDriverState *bs)
1131 BlockDriver *drv = bs->drv;
1139 if (!bs->growable || !drv->bdrv_getlength) {
1140 return bs->total_sectors * BDRV_SECTOR_SIZE;
1142 return drv->bdrv_getlength(bs);
1146 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1149 length = bdrv_getlength(bs);
1171 static int guess_disk_lchs(BlockDriverState *bs,
1180 bdrv_get_geometry(bs, &nb_sectors);
1182 ret = bdrv_read(bs, 0, buf, 1);
1214 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1221 bdrv_get_geometry(bs, &nb_sectors);
1222 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1223 translation = bdrv_get_translation_hint(bs);
1229 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1243 bdrv_set_translation_hint(bs,
1261 bdrv_set_translation_hint(bs,
1264 bdrv_set_translation_hint(bs,
1269 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1273 void bdrv_set_geometry_hint(BlockDriverState *bs,
1276 bs->cyls = cyls;
1277 bs->heads = heads;
1278 bs->secs = secs;
1281 void bdrv_set_type_hint(BlockDriverState *bs, int type)
1283 bs->type = type;
1284 bs->removable = ((type == BDRV_TYPE_CDROM ||
1288 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1290 bs->translation = translation;
1293 void bdrv_get_geometry_hint(BlockDriverState *bs,
1296 *pcyls = bs->cyls;
1297 *pheads = bs->heads;
1298 *psecs = bs->secs;
1301 int bdrv_get_type_hint(BlockDriverState *bs)
1303 return bs->type;
1306 int bdrv_get_translation_hint(BlockDriverState *bs)
1308 return bs->translation;
1311 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1314 bs->on_read_error = on_read_error;
1315 bs->on_write_error = on_write_error;
1318 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
1320 return is_read ? bs->on_read_error : bs->on_write_error;
1323 void bdrv_set_removable(BlockDriverState *bs, int removable)
1325 bs->removable = removable;
1326 if (removable && bs == bs_snapshots) {
1331 int bdrv_is_removable(BlockDriverState *bs)
1333 return bs->removable;
1336 int bdrv_is_read_only(BlockDriverState *bs)
1338 return bs->read_only;
1341 int bdrv_is_sg(BlockDriverState *bs)
1343 return bs->sg;
1346 int bdrv_enable_write_cache(BlockDriverState *bs)
1348 return bs->enable_write_cache;
1352 void bdrv_set_change_cb(BlockDriverState *bs,
1355 bs->change_cb = change_cb;
1356 bs->change_opaque = opaque;
1359 int bdrv_is_encrypted(BlockDriverState *bs)
1361 if (bs->backing_hd && bs->backing_hd->encrypted)
1363 return bs->encrypted;
1366 int bdrv_key_required(BlockDriverState *bs)
1368 BlockDriverState *backing_hd = bs->backing_hd;
1372 return (bs->encrypted && !bs->valid_key);
1375 int bdrv_set_key(BlockDriverState *bs, const char *key)
1378 if (bs->backing_hd && bs->backing_hd->encrypted) {
1379 ret = bdrv_set_key(bs->backing_hd, key);
1382 if (!bs->encrypted)
1385 if (!bs->encrypted) {
1387 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1390 ret = bs->drv->bdrv_set_key(bs, key);
1392 bs->valid_key = 0;
1393 } else if (!bs->valid_key) {
1394 bs->valid_key = 1;
1396 bs->media_changed = 1;
1397 if (bs->change_cb)
1398 bs->change_cb(bs->change_opaque);
1403 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1405 if (!bs->drv) {
1408 pstrcpy(buf, buf_size, bs->drv->format_name);
1424 BlockDriverState *bs;
1426 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1427 if (!strcmp(name, bs->device_name)) {
1428 return bs;
1434 BlockDriverState *bdrv_next(BlockDriverState *bs)
1436 if (!bs) {
1439 return QTAILQ_NEXT(bs, list);
1442 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1444 BlockDriverState *bs;
1446 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1447 it(opaque, bs);
1451 const char *bdrv_get_device_name(BlockDriverState *bs)
1453 return bs->device_name;
1456 void bdrv_flush(BlockDriverState *bs)
1458 if (bs->open_flags & BDRV_O_NO_FLUSH) {
1462 if (bs->drv && bs->drv->bdrv_flush)
1463 bs->drv->bdrv_flush(bs);
1468 BlockDriverState *bs;
1470 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1471 if (bs->drv && !bdrv_is_read_only(bs) &&
1472 (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) {
1473 bdrv_flush(bs);
1478 int bdrv_has_zero_init(BlockDriverState *bs)
1480 assert(bs->drv);
1482 if (bs->drv->bdrv_has_zero_init) {
1483 return bs->drv->bdrv_has_zero_init(bs);
1500 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1504 if (!bs->drv->bdrv_is_allocated) {
1505 if (sector_num >= bs->total_sectors) {
1509 n = bs->total_sectors - sector_num;
1513 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1589 BlockDriverState *bs;
1593 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1597 switch(bs->type) {
1611 bs->device_name, type, bs->removable,
1612 bs->locked);
1614 if (bs->drv) {
1620 bs->filename, bs->read_only,
1621 bs->drv->format_name,
1622 bdrv_is_encrypted(bs));
1623 if (bs->backing_file[0] != '\0') {
1626 qstring_from_str(bs->backing_file));
1662 static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
1674 bs->rd_bytes, bs->wr_bytes,
1675 bs->rd_ops, bs->wr_ops,
1676 bs->wr_highest_sector *
1680 if (*bs->device_name) {
1681 qdict_put(dict, "device", qstring_from_str(bs->device_name));
1684 if (bs->file) {
1685 QObject *parent = bdrv_info_stats_bs(bs->file);
1696 BlockDriverState *bs;
1700 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1701 obj = bdrv_info_stats_bs(bs);
1708 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1710 if (bs->backing_hd && bs->backing_hd->encrypted)
1711 return bs->backing_file;
1712 else if (bs->encrypted)
1713 return bs->filename;
1718 void bdrv_get_backing_filename(BlockDriverState *bs,
1721 if (!bs->backing_file) {
1724 pstrcpy(filename, filename_size, bs->backing_file);
1728 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1731 BlockDriver *drv = bs->drv;
1736 if (bdrv_check_request(bs, sector_num, nb_sectors))
1739 if (bs->dirty_bitmap) {
1740 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1743 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1746 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1748 BlockDriver *drv = bs->drv;
1754 return drv->bdrv_get_info(bs, bdi);
1757 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1760 BlockDriver *drv = bs->drv;
1764 return drv->bdrv_save_vmstate(bs, buf, pos, size);
1765 if (bs->file)
1766 return bdrv_save_vmstate(bs->file, buf, pos, size);
1770 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
1773 BlockDriver *drv = bs->drv;
1777 return drv->bdrv_load_vmstate(bs, buf, pos, size);
1778 if (bs->file)
1779 return bdrv_load_vmstate(bs->file, buf, pos, size);
1783 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
1785 BlockDriver *drv = bs->drv;
1791 return drv->bdrv_debug_event(bs, event);
1798 int bdrv_can_snapshot(BlockDriverState *bs)
1800 BlockDriver *drv = bs->drv;
1801 if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
1806 if (bs->file != NULL) {
1807 return bdrv_can_snapshot(bs->file);
1815 int bdrv_is_snapshot(BlockDriverState *bs)
1817 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
1822 BlockDriverState *bs;
1828 bs = NULL;
1829 while ((bs = bdrv_next(bs))) {
1830 if (bdrv_can_snapshot(bs)) {
1831 bs_snapshots = bs;
1832 return bs;
1838 int bdrv_snapshot_create(BlockDriverState *bs,
1841 BlockDriver *drv = bs->drv;
1845 return drv->bdrv_snapshot_create(bs, sn_info);
1846 if (bs->file)
1847 return bdrv_snapshot_create(bs->file, sn_info);
1851 int bdrv_snapshot_goto(BlockDriverState *bs,
1854 BlockDriver *drv = bs->drv;
1860 return drv->bdrv_snapshot_goto(bs, snapshot_id);
1862 if (bs->file) {
1863 drv->bdrv_close(bs);
1864 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
1865 open_ret = drv->bdrv_open(bs, bs->open_flags);
1867 bdrv_delete(bs->file);
1868 bs->drv = NULL;
1877 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1879 BlockDriver *drv = bs->drv;
1883 return drv->bdrv_snapshot_delete(bs, snapshot_id);
1884 if (bs->file)
1885 return bdrv_snapshot_delete(bs->file, snapshot_id);
1889 int bdrv_snapshot_list(BlockDriverState *bs,
1892 BlockDriver *drv = bs->drv;
1896 return drv->bdrv_snapshot_list(bs, psn_info);
1897 if (bs->file)
1898 return bdrv_snapshot_list(bs->file, psn_info);
1979 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1983 BlockDriver *drv = bs->drv;
1988 if (bdrv_check_request(bs, sector_num, nb_sectors))
1991 ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
1996 bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1997 bs->rd_ops ++;
2003 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2007 BlockDriver *drv = bs->drv;
2012 if (bs->read_only)
2014 if (bdrv_check_request(bs, sector_num, nb_sectors))
2017 if (bs->dirty_bitmap) {
2018 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2021 ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
2026 bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2027 bs->wr_ops ++;
2028 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2029 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2099 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2124 if (!merge && bs->drv->bdrv_merge_requests) {
2125 merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2146 uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2184 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2205 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2230 acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2259 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2262 BlockDriver *drv = bs->drv;
2264 if (bs->open_flags & BDRV_O_NO_FLUSH) {
2265 return bdrv_aio_noop_em(bs, cb, opaque);
2270 return drv->bdrv_aio_flush(bs, cb, opaque);
2319 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2330 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2333 acb->bounce = qemu_blockalign(bs, qiov->size);
2340 acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2342 acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2350 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2354 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2357 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2361 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
2364 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2369 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2378 bdrv_flush(bs);
2383 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2388 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2412 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
2426 acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2443 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2457 acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2483 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2495 acb->bs = bs;
2515 int bdrv_is_inserted(BlockDriverState *bs)
2517 BlockDriver *drv = bs->drv;
2522 return !bs->tray_open;
2523 ret = drv->bdrv_is_inserted(bs);
2531 int bdrv_media_changed(BlockDriverState *bs)
2533 BlockDriver *drv = bs->drv;
2539 ret = drv->bdrv_media_changed(bs);
2541 ret = bs->media_changed;
2542 bs->media_changed = 0;
2549 int bdrv_eject(BlockDriverState *bs, int eject_flag)
2551 BlockDriver *drv = bs->drv;
2554 if (bs->locked) {
2561 ret = drv->bdrv_eject(bs, eject_flag);
2567 bs->tray_open = eject_flag;
2573 int bdrv_is_locked(BlockDriverState *bs)
2575 return bs->locked;
2582 void bdrv_set_locked(BlockDriverState *bs, int locked)
2584 BlockDriver *drv = bs->drv;
2586 bs->locked = locked;
2588 drv->bdrv_set_locked(bs, locked);
2594 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2596 BlockDriver *drv = bs->drv;
2599 return drv->bdrv_ioctl(bs, req, buf);
2603 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
2607 BlockDriver *drv = bs->drv;
2610 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
2616 void *qemu_blockalign(BlockDriverState *bs, size_t size)
2618 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
2621 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
2625 bs->dirty_count = 0;
2627 if (!bs->dirty_bitmap) {
2628 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
2632 bs->dirty_bitmap = g_malloc0(bitmap_size);
2635 if (bs->dirty_bitmap) {
2636 g_free(bs->dirty_bitmap);
2637 bs->dirty_bitmap = NULL;
2642 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
2646 if (bs->dirty_bitmap &&
2647 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
2648 return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
2655 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
2658 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
2661 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
2663 return bs->dirty_count;