Lines Matching refs:bs
45 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
48 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
51 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
53 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
55 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
57 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
157 BlockDriverState *bs;
159 bs = qemu_mallocz(sizeof(BlockDriverState));
160 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name);
162 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list);
164 return bs;
338 BlockDriverState *bs;
340 ret = bdrv_file_open(&bs, filename, 0);
347 if (bs->sg || !bdrv_is_inserted(bs)) {
348 bdrv_delete(bs);
357 ret = bdrv_pread(bs, 0, buf, sizeof(buf));
358 bdrv_delete(bs);
385 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint)
387 BlockDriver *drv = bs->drv;
390 if (bs->sg)
395 int64_t length = drv->bdrv_getlength(bs);
402 bs->total_sectors = hint;
409 static int bdrv_open_common(BlockDriverState *bs, const char *filename,
416 bs->file = NULL;
417 bs->total_sectors = 0;
418 bs->encrypted = 0;
419 bs->valid_key = 0;
420 bs->open_flags = flags;
422 bs->buffer_alignment = 512;
424 pstrcpy(bs->filename, sizeof(bs->filename), filename);
430 bs->drv = drv;
431 bs->opaque = qemu_mallocz(drv->instance_size);
440 bs->enable_write_cache = 1;
451 if (bs->is_temporary) {
457 ret = drv->bdrv_file_open(bs, filename, open_flags);
459 ret = bdrv_file_open(&bs->file, filename, open_flags);
461 ret = drv->bdrv_open(bs, open_flags);
469 bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR);
471 ret = refresh_total_sectors(bs, bs->total_sectors);
477 if (bs->is_temporary) {
484 if (bs->file) {
485 bdrv_delete(bs->file);
486 bs->file = NULL;
488 qemu_free(bs->opaque);
489 bs->opaque = NULL;
490 bs->drv = NULL;
499 BlockDriverState *bs;
508 bs = bdrv_new("");
509 ret = bdrv_open_common(bs, filename, flags, drv);
511 bdrv_delete(bs);
514 bs->growable = 1;
515 *pbs = bs;
522 int bdrv_open(BlockDriverState *bs, const char *filename, int flags,
581 bs->is_temporary = 1;
595 ret = bdrv_open_common(bs, filename, flags, drv);
600 bs->probed = probed;
603 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') {
608 bs->backing_hd = bdrv_new("");
610 filename, bs->backing_file);
611 if (bs->backing_format[0] != '\0')
612 back_drv = bdrv_find_format(bs->backing_format);
618 ret = bdrv_open(bs
620 bdrv_close(bs);
623 if (bs->is_temporary) {
624 bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR);
627 bs->backing_hd->keep_read_only = bs->keep_read_only;
631 if (!bdrv_key_required(bs)) {
633 bs->media_changed = 1;
634 if (bs->change_cb)
635 bs->change_cb(bs->change_opaque);
641 if (bs->is_temporary) {
647 void bdrv_close(BlockDriverState *bs)
649 if (bs->drv) {
650 if (bs == bs_snapshots) {
653 if (bs->backing_hd) {
654 bdrv_delete(bs->backing_hd);
655 bs->backing_hd = NULL;
657 bs->drv->bdrv_close(bs);
658 qemu_free(bs->opaque);
660 if (bs->is_temporary) {
661 unlink(bs->filename);
664 bs->opaque = NULL;
665 bs->drv = NULL;
667 if (bs->file != NULL) {
668 bdrv_close(bs->file);
672 bs->media_changed = 1;
673 if (bs->change_cb)
674 bs->change_cb(bs->change_opaque);
680 BlockDriverState *bs;
682 QTAILQ_FOREACH(bs, &bdrv_states, list) {
683 bdrv_close(bs);
687 void bdrv_delete(BlockDriverState *bs)
689 assert(!bs->peer);
692 if (bs->device_name[0] != '\0') {
693 QTAILQ_REMOVE(&bdrv_states, bs, list);
696 bdrv_close(bs);
697 if (bs->file != NULL) {
698 bdrv_delete(bs->file);
701 assert(bs != bs_snapshots);
702 qemu_free(bs);
705 int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)
707 if (bs->peer) {
710 bs->peer = qdev;
714 void bdrv_detach(BlockDriverState *bs, DeviceState *qdev)
716 assert(bs->peer == qdev);
717 bs->peer = NULL;
720 DeviceState *bdrv_get_attached(BlockDriverState *bs)
722 return bs->peer;
732 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res)
734 if (bs->drv->bdrv_check == NULL) {
739 return bs->drv->bdrv_check(bs, res);
745 int bdrv_commit(BlockDriverState *bs)
747 BlockDriver *drv = bs->drv;
758 if (!bs->backing_hd) {
762 if (bs->backing_hd->keep_read_only) {
766 ro = bs->backing_hd->read_only;
767 strncpy(filename, bs->backing_hd->filename, sizeof(filename));
768 open_flags = bs->backing_hd->open_flags;
772 bdrv_delete(bs->backing_hd);
773 bs->backing_hd = NULL;
784 bs->drv = NULL;
787 bs->backing_hd = bs_ro;
790 bs->backing_hd = bs_rw;
793 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
797 if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) {
799 if (bdrv_read(bs, sector, buf, n) != 0) {
804 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) {
812 ret = drv->bdrv_make_empty(bs);
813 bdrv_flush(bs);
820 if (bs->backing_hd)
821 bdrv_flush(bs->backing_hd);
828 bdrv_delete(bs->backing_hd);
829 bs->backing_hd = NULL;
835 bs->drv = NULL;
838 bs->backing_hd = bs_ro;
839 bs->backing_hd->keep_read_only = 0;
847 BlockDriverState *bs;
849 QTAILQ_FOREACH(bs, &bdrv_states, list) {
850 bdrv_commit(bs);
862 int bdrv_change_backing_file(BlockDriverState *bs,
865 BlockDriver *drv = bs->drv;
868 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);
874 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset,
879 if (!bdrv_is_inserted(bs))
882 if (bs->growable)
885 len = bdrv_getlength(bs);
896 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
899 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
904 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
907 BlockDriver *drv = bs->drv;
911 if (bdrv_check_request(bs, sector_num, nb_sectors))
914 return drv->bdrv_read(bs, sector_num, buf, nb_sectors);
917 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num,
929 val = bs->dirty_bitmap[idx];
932 bs->dirty_count++;
937 bs->dirty_count--;
941 bs->dirty_bitmap[idx] = val;
951 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
954 BlockDriver *drv = bs->drv;
955 if (!bs->drv)
957 if (bs->read_only)
959 if (bdrv_check_request(bs, sector_num, nb_sectors))
962 if (bs->dirty_bitmap) {
963 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
966 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
967 bs->wr_highest_sector = sector_num + nb_sectors - 1;
970 return drv->bdrv_write(bs, sector_num, buf, nb_sectors);
973 int bdrv_pread(BlockDriverState *bs, int64_t offset,
988 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1001 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0)
1011 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1018 int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
1033 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1036 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1048 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
1058 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
1061 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
1073 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
1078 ret = bdrv_pwrite(bs, offset, buf, count);
1084 if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) {
1085 bdrv_flush(bs);
1097 int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num,
1100 return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num,
1107 int bdrv_truncate(BlockDriverState *bs, int64_t offset)
1109 BlockDriver *drv = bs->drv;
1115 if (bs->read_only)
1117 ret = drv->bdrv_truncate(bs, offset);
1119 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
1127 int64_t bdrv_getlength(BlockDriverState *bs)
1129 BlockDriver *drv = bs->drv;
1137 if (!bs->growable || !drv->bdrv_getlength) {
1138 return bs->total_sectors * BDRV_SECTOR_SIZE;
1140 return drv->bdrv_getlength(bs);
1144 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
1147 length = bdrv_getlength(bs);
1169 static int guess_disk_lchs(BlockDriverState *bs,
1178 bdrv_get_geometry(bs, &nb_sectors);
1180 ret = bdrv_read(bs, 0, buf, 1);
1212 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs)
1219 bdrv_get_geometry(bs, &nb_sectors);
1220 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs);
1221 translation = bdrv_get_translation_hint(bs);
1227 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) {
1241 bdrv_set_translation_hint(bs,
1259 bdrv_set_translation_hint(bs,
1262 bdrv_set_translation_hint(bs,
1267 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs);
1271 void bdrv_set_geometry_hint(BlockDriverState *bs,
1274 bs->cyls = cyls;
1275 bs->heads = heads;
1276 bs->secs = secs;
1279 void bdrv_set_type_hint(BlockDriverState *bs, int type)
1281 bs->type = type;
1282 bs->removable = ((type == BDRV_TYPE_CDROM ||
1286 void bdrv_set_translation_hint(BlockDriverState *bs, int translation)
1288 bs->translation = translation;
1291 void bdrv_get_geometry_hint(BlockDriverState *bs,
1294 *pcyls = bs->cyls;
1295 *pheads = bs->heads;
1296 *psecs = bs->secs;
1299 int bdrv_get_type_hint(BlockDriverState *bs)
1301 return bs->type;
1304 int bdrv_get_translation_hint(BlockDriverState *bs)
1306 return bs->translation;
1309 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error,
1312 bs->on_read_error = on_read_error;
1313 bs->on_write_error = on_write_error;
1316 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read)
1318 return is_read ? bs->on_read_error : bs->on_write_error;
1321 void bdrv_set_removable(BlockDriverState *bs, int removable)
1323 bs->removable = removable;
1324 if (removable && bs == bs_snapshots) {
1329 int bdrv_is_removable(BlockDriverState *bs)
1331 return bs->removable;
1334 int bdrv_is_read_only(BlockDriverState *bs)
1336 return bs->read_only;
1339 int bdrv_is_sg(BlockDriverState *bs)
1341 return bs->sg;
1344 int bdrv_enable_write_cache(BlockDriverState *bs)
1346 return bs->enable_write_cache;
1350 void bdrv_set_change_cb(BlockDriverState *bs,
1353 bs->change_cb = change_cb;
1354 bs->change_opaque = opaque;
1357 int bdrv_is_encrypted(BlockDriverState *bs)
1359 if (bs->backing_hd && bs->backing_hd->encrypted)
1361 return bs->encrypted;
1364 int bdrv_key_required(BlockDriverState *bs)
1366 BlockDriverState *backing_hd = bs->backing_hd;
1370 return (bs->encrypted && !bs->valid_key);
1373 int bdrv_set_key(BlockDriverState *bs, const char *key)
1376 if (bs->backing_hd && bs->backing_hd->encrypted) {
1377 ret = bdrv_set_key(bs->backing_hd, key);
1380 if (!bs->encrypted)
1383 if (!bs->encrypted) {
1385 } else if (!bs->drv || !bs->drv->bdrv_set_key) {
1388 ret = bs->drv->bdrv_set_key(bs, key);
1390 bs->valid_key = 0;
1391 } else if (!bs->valid_key) {
1392 bs->valid_key = 1;
1394 bs->media_changed = 1;
1395 if (bs->change_cb)
1396 bs->change_cb(bs->change_opaque);
1401 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size)
1403 if (!bs->drv) {
1406 pstrcpy(buf, buf_size, bs->drv->format_name);
1422 BlockDriverState *bs;
1424 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1425 if (!strcmp(name, bs->device_name)) {
1426 return bs;
1432 BlockDriverState *bdrv_next(BlockDriverState *bs)
1434 if (!bs) {
1437 return QTAILQ_NEXT(bs, list);
1440 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque)
1442 BlockDriverState *bs;
1444 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1445 it(opaque, bs);
1449 const char *bdrv_get_device_name(BlockDriverState *bs)
1451 return bs->device_name;
1454 void bdrv_flush(BlockDriverState *bs)
1456 if (bs->open_flags & BDRV_O_NO_FLUSH) {
1460 if (bs->drv && bs->drv->bdrv_flush)
1461 bs->drv->bdrv_flush(bs);
1466 BlockDriverState *bs;
1468 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1469 if (bs->drv && !bdrv_is_read_only(bs) &&
1470 (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) {
1471 bdrv_flush(bs);
1476 int bdrv_has_zero_init(BlockDriverState *bs)
1478 assert(bs->drv);
1480 if (bs->drv->bdrv_has_zero_init) {
1481 return bs->drv->bdrv_has_zero_init(bs);
1498 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
1502 if (!bs->drv->bdrv_is_allocated) {
1503 if (sector_num >= bs->total_sectors) {
1507 n = bs->total_sectors - sector_num;
1511 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum);
1587 BlockDriverState *bs;
1591 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1595 switch(bs->type) {
1609 bs->device_name, type, bs->removable,
1610 bs->locked);
1612 if (bs->drv) {
1618 bs->filename, bs->read_only,
1619 bs->drv->format_name,
1620 bdrv_is_encrypted(bs));
1621 if (bs->backing_file[0] != '\0') {
1624 qstring_from_str(bs->backing_file));
1660 static QObject* bdrv_info_stats_bs(BlockDriverState *bs)
1672 bs->rd_bytes, bs->wr_bytes,
1673 bs->rd_ops, bs->wr_ops,
1674 bs->wr_highest_sector *
1678 if (*bs->device_name) {
1679 qdict_put(dict, "device", qstring_from_str(bs->device_name));
1682 if (bs->file) {
1683 QObject *parent = bdrv_info_stats_bs(bs->file);
1694 BlockDriverState *bs;
1698 QTAILQ_FOREACH(bs, &bdrv_states, list) {
1699 obj = bdrv_info_stats_bs(bs);
1706 const char *bdrv_get_encrypted_filename(BlockDriverState *bs)
1708 if (bs->backing_hd && bs->backing_hd->encrypted)
1709 return bs->backing_file;
1710 else if (bs->encrypted)
1711 return bs->filename;
1716 void bdrv_get_backing_filename(BlockDriverState *bs,
1719 if (!bs->backing_file) {
1722 pstrcpy(filename, filename_size, bs->backing_file);
1726 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
1729 BlockDriver *drv = bs->drv;
1734 if (bdrv_check_request(bs, sector_num, nb_sectors))
1737 if (bs->dirty_bitmap) {
1738 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
1741 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);
1744 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1746 BlockDriver *drv = bs->drv;
1752 return drv->bdrv_get_info(bs, bdi);
1755 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
1758 BlockDriver *drv = bs->drv;
1762 return drv->bdrv_save_vmstate(bs, buf, pos, size);
1763 if (bs->file)
1764 return bdrv_save_vmstate(bs->file, buf, pos, size);
1768 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
1771 BlockDriver *drv = bs->drv;
1775 return drv->bdrv_load_vmstate(bs, buf, pos, size);
1776 if (bs->file)
1777 return bdrv_load_vmstate(bs->file, buf, pos, size);
1781 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
1783 BlockDriver *drv = bs->drv;
1789 return drv->bdrv_debug_event(bs, event);
1796 int bdrv_can_snapshot(BlockDriverState *bs)
1798 BlockDriver *drv = bs->drv;
1799 if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) {
1804 if (bs->file != NULL) {
1805 return bdrv_can_snapshot(bs->file);
1813 int bdrv_is_snapshot(BlockDriverState *bs)
1815 return !!(bs->open_flags & BDRV_O_SNAPSHOT);
1820 BlockDriverState *bs;
1826 bs = NULL;
1827 while ((bs = bdrv_next(bs))) {
1828 if (bdrv_can_snapshot(bs)) {
1829 bs_snapshots = bs;
1830 return bs;
1836 int bdrv_snapshot_create(BlockDriverState *bs,
1839 BlockDriver *drv = bs->drv;
1843 bs, sn_info);
1844 if (bs->file)
1845 return bdrv_snapshot_create(bs->file, sn_info);
1849 int bdrv_snapshot_goto(BlockDriverState *bs,
1852 BlockDriver *drv = bs->drv;
1858 return drv->bdrv_snapshot_goto(bs, snapshot_id);
1860 if (bs->file) {
1861 drv->bdrv_close(bs);
1862 ret = bdrv_snapshot_goto(bs->file, snapshot_id);
1863 open_ret = drv->bdrv_open(bs, bs->open_flags);
1865 bdrv_delete(bs->file);
1866 bs->drv = NULL;
1875 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
1877 BlockDriver *drv = bs->drv;
1881 return drv->bdrv_snapshot_delete(bs, snapshot_id);
1882 if (bs->file)
1883 return bdrv_snapshot_delete(bs->file, snapshot_id);
1887 int bdrv_snapshot_list(BlockDriverState *bs,
1890 BlockDriver *drv = bs->drv;
1894 return drv->bdrv_snapshot_list(bs, psn_info);
1895 if (bs->file)
1896 return bdrv_snapshot_list(bs->file, psn_info);
1977 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
1981 BlockDriver *drv = bs->drv;
1986 if (bdrv_check_request(bs, sector_num, nb_sectors))
1989 ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors,
1994 bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
1995 bs->rd_ops ++;
2001 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
2005 BlockDriver *drv = bs->drv;
2010 if (bs->read_only)
2012 if (bdrv_check_request(bs, sector_num, nb_sectors))
2015 if (bs->dirty_bitmap) {
2016 set_dirty_bitmap(bs, sector_num, nb_sectors, 1);
2019 ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors,
2024 bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE;
2025 bs->wr_ops ++;
2026 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) {
2027 bs->wr_highest_sector = sector_num + nb_sectors - 1;
2097 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
2122 if (!merge && bs->drv->bdrv_merge_requests) {
2123 merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]);
2144 uint8_t *buf = qemu_blockalign(bs, zero_bytes);
2182 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
2203 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);
2228 acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,
2257 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs,
2260 BlockDriver *drv = bs->drv;
2262 if (bs->open_flags & BDRV_O_NO_FLUSH) {
2263 return bdrv_aio_noop_em(bs, cb, opaque);
2268 return drv->bdrv_aio_flush(bs, cb, opaque);
2317 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs,
2328 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2331 acb->bounce = qemu_blockalign(bs, qiov->size);
2338 acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors);
2340 acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors);
2348 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs,
2352 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0);
2355 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs,
2359 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1);
2362 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs,
2367 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque);
2376 bdrv_flush(bs);
2381 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs,
2386 bs, cb, opaque);
2410 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num,
2424 acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors,
2441 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
2455 acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors,
2481 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
2493 acb->bs = bs;
2513 int bdrv_is_inserted(BlockDriverState *bs)
2515 BlockDriver *drv = bs->drv;
2520 return !bs->tray_open;
2521 ret = drv->bdrv_is_inserted(bs);
2529 int bdrv_media_changed(BlockDriverState *bs)
2531 BlockDriver *drv = bs->drv;
2537 ret = drv->bdrv_media_changed(bs);
2539 ret = bs->media_changed;
2540 bs->media_changed = 0;
2547 int bdrv_eject(BlockDriverState *bs, int eject_flag)
2549 BlockDriver *drv = bs->drv;
2552 if (bs->locked) {
2559 ret = drv->bdrv_eject(bs, eject_flag);
2565 bs->tray_open = eject_flag;
2571 int bdrv_is_locked(BlockDriverState *bs)
2573 return bs->locked;
2580 void bdrv_set_locked(BlockDriverState *bs, int locked)
2582 BlockDriver *drv = bs->drv;
2584 bs->locked = locked;
2586 drv->bdrv_set_locked(bs, locked);
2592 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2594 BlockDriver *drv = bs->drv;
2597 return drv->bdrv_ioctl(bs, req, buf);
2601 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
2605 BlockDriver *drv = bs->drv;
2608 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
2614 void *qemu_blockalign(BlockDriverState *bs, size_t size)
2616 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size);
2619 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable)
2623 bs->dirty_count = 0;
2625 if (!bs->dirty_bitmap) {
2626 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
2630 bs->dirty_bitmap = qemu_mallocz(bitmap_size);
2633 if (bs->dirty_bitmap) {
2634 qemu_free(bs->dirty_bitmap);
2635 bs->dirty_bitmap = NULL;
2640 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector)
2644 if (bs->dirty_bitmap &&
2645 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) {
2646 return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] &
2653 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector,
2656 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0);
2659 int64_t bdrv_get_dirty_count(BlockDriverState *bs)
2661 return bs->dirty_count;
