Lines Matching refs:blk
99 BlockBackend *blk; member
122 blk_set_perm_locked(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
145 BlockBackend *blk = child->opaque; in blk_root_get_parent_desc() local
148 if (blk->name) { in blk_root_get_parent_desc()
149 return g_strdup_printf("block device '%s'", blk->name); in blk_root_get_parent_desc()
152 dev_id = blk_get_attached_dev_id(blk); in blk_root_get_parent_desc()
169 BlockBackend *blk = opaque; in blk_vm_state_changed() local
175 qemu_del_vm_change_state_handler(blk->vmsh); in blk_vm_state_changed()
176 blk->vmsh = NULL; in blk_vm_state_changed()
177 blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err); in blk_vm_state_changed()
192 BlockBackend *blk = child->opaque; in blk_root_activate() local
196 if (!blk->disable_perm) { in blk_root_activate()
200 blk->disable_perm = false; in blk_root_activate()
209 saved_shared_perm = blk->shared_perm; in blk_root_activate()
211 blk_set_perm_locked(blk, blk->perm, BLK_PERM_ALL, &local_err); in blk_root_activate()
214 blk->disable_perm = true; in blk_root_activate()
217 blk->shared_perm = saved_shared_perm; in blk_root_activate()
223 if (!blk->vmsh) { in blk_root_activate()
224 blk->vmsh = qemu_add_vm_change_state_handler(blk_vm_state_changed, in blk_root_activate()
225 blk); in blk_root_activate()
230 blk_set_perm_locked(blk, blk->perm, blk->shared_perm, &local_err); in blk_root_activate()
233 blk->disable_perm = true; in blk_root_activate()
238 void blk_set_force_allow_inactivate(BlockBackend *blk) in blk_set_force_allow_inactivate() argument
241 blk->force_allow_inactivate = true; in blk_set_force_allow_inactivate()
244 static bool blk_can_inactivate(BlockBackend *blk) in blk_can_inactivate() argument
247 if (blk->dev || blk_name(blk)[0]) { in blk_can_inactivate()
256 if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) { in blk_can_inactivate()
260 return blk->force_allow_inactivate; in blk_can_inactivate()
265 BlockBackend *blk = child->opaque; in blk_root_inactivate() local
267 if (blk->disable_perm) { in blk_root_inactivate()
271 if (!blk_can_inactivate(blk)) { in blk_root_inactivate()
275 blk->disable_perm = true; in blk_root_inactivate()
276 if (blk->root) { in blk_root_inactivate()
277 bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort); in blk_root_inactivate()
285 BlockBackend *blk = child->opaque; in blk_root_attach() local
288 trace_blk_root_attach(child, blk, child->bs); in blk_root_attach()
290 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) { in blk_root_attach()
300 BlockBackend *blk = child->opaque; in blk_root_detach() local
303 trace_blk_root_detach(child, blk, child->bs); in blk_root_detach()
305 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) { in blk_root_detach()
315 BlockBackend *blk = c->opaque; in blk_root_get_parent_aio_context() local
318 return blk_get_aio_context(blk); in blk_root_get_parent_aio_context()
357 BlockBackend *blk; in blk_new() local
361 blk = g_new0(BlockBackend, 1); in blk_new()
362 blk->refcnt = 1; in blk_new()
363 blk->ctx = ctx; in blk_new()
364 blk->perm = perm; in blk_new()
365 blk->shared_perm = shared_perm; in blk_new()
366 blk_set_enable_write_cache(blk, true); in blk_new()
368 blk->on_read_error = BLOCKDEV_ON_ERROR_REPORT; in blk_new()
369 blk->on_write_error = BLOCKDEV_ON_ERROR_ENOSPC; in blk_new()
371 block_acct_init(&blk->stats); in blk_new()
373 qemu_mutex_init(&blk->queued_requests_lock); in blk_new()
374 qemu_co_queue_init(&blk->queued_requests); in blk_new()
375 notifier_list_init(&blk->remove_bs_notifiers); in blk_new()
376 notifier_list_init(&blk->insert_bs_notifiers); in blk_new()
377 QLIST_INIT(&blk->aio_notifiers); in blk_new()
379 QTAILQ_INSERT_TAIL(&block_backends, blk, link); in blk_new()
380 return blk; in blk_new()
397 BlockBackend *blk = blk_new(bdrv_get_aio_context(bs), perm, shared_perm); in blk_new_with_bs() local
401 if (blk_insert_bs(blk, bs, errp) < 0) { in blk_new_with_bs()
402 blk_unref(blk); in blk_new_with_bs()
405 return blk; in blk_new_with_bs()
426 BlockBackend *blk; in blk_new_open() local
463 blk = blk_new(bdrv_get_aio_context(bs), perm, shared); in blk_new_open()
464 blk->perm = perm; in blk_new_open()
465 blk->shared_perm = shared; in blk_new_open()
467 blk_insert_bs(blk, bs, errp); in blk_new_open()
470 if (!blk->root) { in blk_new_open()
471 blk_unref(blk); in blk_new_open()
475 return blk; in blk_new_open()
478 static void blk_delete(BlockBackend *blk) in blk_delete() argument
480 assert(!blk->refcnt); in blk_delete()
481 assert(!blk->name); in blk_delete()
482 assert(!blk->dev); in blk_delete()
483 if (blk->public.throttle_group_member.throttle_state) { in blk_delete()
484 blk_io_limits_disable(blk); in blk_delete()
486 if (blk->root) { in blk_delete()
487 blk_remove_bs(blk); in blk_delete()
489 if (blk->vmsh) { in blk_delete()
490 qemu_del_vm_change_state_handler(blk->vmsh); in blk_delete()
491 blk->vmsh = NULL; in blk_delete()
493 assert(QLIST_EMPTY(&blk->remove_bs_notifiers.notifiers)); in blk_delete()
494 assert(QLIST_EMPTY(&blk->insert_bs_notifiers.notifiers)); in blk_delete()
495 assert(QLIST_EMPTY(&blk->aio_notifiers)); in blk_delete()
496 assert(qemu_co_queue_empty(&blk->queued_requests)); in blk_delete()
497 qemu_mutex_destroy(&blk->queued_requests_lock); in blk_delete()
498 QTAILQ_REMOVE(&block_backends, blk, link); in blk_delete()
499 drive_info_del(blk->legacy_dinfo); in blk_delete()
500 block_acct_cleanup(&blk->stats); in blk_delete()
501 g_free(blk); in blk_delete()
513 int blk_get_refcnt(BlockBackend *blk) in blk_get_refcnt() argument
516 return blk ? blk->refcnt : 0; in blk_get_refcnt()
523 void blk_ref(BlockBackend *blk) in blk_ref() argument
525 assert(blk->refcnt > 0); in blk_ref()
527 blk->refcnt++; in blk_ref()
535 void blk_unref(BlockBackend *blk) in blk_unref() argument
538 if (blk) { in blk_unref()
539 assert(blk->refcnt > 0); in blk_unref()
540 if (blk->refcnt > 1) { in blk_unref()
541 blk->refcnt--; in blk_unref()
543 blk_drain(blk); in blk_unref()
545 assert(blk->refcnt == 1); in blk_unref()
546 blk->refcnt = 0; in blk_unref()
547 blk_delete(blk); in blk_unref()
556 BlockBackend *blk_all_next(BlockBackend *blk) in blk_all_next() argument
559 return blk ? QTAILQ_NEXT(blk, link) in blk_all_next()
565 BlockBackend *blk = NULL; in blk_remove_all_bs() local
569 while ((blk = blk_all_next(blk)) != NULL) { in blk_remove_all_bs()
570 if (blk->root) { in blk_remove_all_bs()
571 blk_remove_bs(blk); in blk_remove_all_bs()
586 BlockBackend *blk_next(BlockBackend *blk) in blk_next() argument
589 return blk ? QTAILQ_NEXT(blk, monitor_link) in blk_next()
608 BlockBackend *old_blk = it->blk; in bdrv_next()
611 it->blk = blk_all_next(it->blk); in bdrv_next()
612 bs = it->blk ? blk_bs(it->blk) : NULL; in bdrv_next()
613 } while (it->blk && (bs == NULL || bdrv_first_blk(bs) != it->blk)); in bdrv_next()
615 if (it->blk) { in bdrv_next()
616 blk_ref(it->blk); in bdrv_next()
668 if (it->phase == BDRV_NEXT_BACKEND_ROOTS && it->blk) { in bdrv_next_cleanup()
669 blk_unref(it->blk); in bdrv_next_cleanup()
685 bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp) in monitor_add_blk() argument
687 assert(!blk->name); in monitor_add_blk()
706 blk->name = g_strdup(name); in monitor_add_blk()
707 QTAILQ_INSERT_TAIL(&monitor_block_backends, blk, monitor_link); in monitor_add_blk()
715 void monitor_remove_blk(BlockBackend *blk) in monitor_remove_blk() argument
719 if (!blk->name) { in monitor_remove_blk()
723 QTAILQ_REMOVE(&monitor_block_backends, blk, monitor_link); in monitor_remove_blk()
724 g_free(blk->name); in monitor_remove_blk()
725 blk->name = NULL; in monitor_remove_blk()
732 const char *blk_name(const BlockBackend *blk) in blk_name() argument
735 return blk->name ?: ""; in blk_name()
744 BlockBackend *blk = NULL; in blk_by_name() local
748 while ((blk = blk_next(blk)) != NULL) { in blk_by_name()
749 if (!strcmp(name, blk->name)) { in blk_by_name()
750 return blk; in blk_by_name()
759 BlockDriverState *blk_bs(BlockBackend *blk) in blk_bs() argument
762 return blk->root ? blk->root->bs : NULL; in blk_bs()
812 DriveInfo *blk_legacy_dinfo(BlockBackend *blk) in blk_legacy_dinfo() argument
815 return blk->legacy_dinfo; in blk_legacy_dinfo()
823 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo) in blk_set_legacy_dinfo() argument
825 assert(!blk->legacy_dinfo); in blk_set_legacy_dinfo()
827 return blk->legacy_dinfo = dinfo; in blk_set_legacy_dinfo()
836 BlockBackend *blk = NULL; in blk_by_legacy_dinfo() local
839 while ((blk = blk_next(blk)) != NULL) { in blk_by_legacy_dinfo()
840 if (blk->legacy_dinfo == dinfo) { in blk_by_legacy_dinfo()
841 return blk; in blk_by_legacy_dinfo()
850 BlockBackendPublic *blk_get_public(BlockBackend *blk) in blk_get_public() argument
853 return &blk->public; in blk_get_public()
868 void blk_remove_bs(BlockBackend *blk) in blk_remove_bs() argument
870 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; in blk_remove_bs()
875 notifier_list_notify(&blk->remove_bs_notifiers, blk); in blk_remove_bs()
877 BlockDriverState *bs = blk_bs(blk); in blk_remove_bs()
891 blk_update_root_state(blk); in blk_remove_bs()
897 blk_drain(blk); in blk_remove_bs()
898 root = blk->root; in blk_remove_bs()
899 blk->root = NULL; in blk_remove_bs()
909 int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp) in blk_insert_bs() argument
911 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; in blk_insert_bs()
916 blk->root = bdrv_root_attach_child(bs, "root", &child_root, in blk_insert_bs()
918 blk->perm, blk->shared_perm, in blk_insert_bs()
919 blk, errp); in blk_insert_bs()
921 if (blk->root == NULL) { in blk_insert_bs()
925 notifier_list_notify(&blk->insert_bs_notifiers, blk); in blk_insert_bs()
937 int blk_replace_bs(BlockBackend *blk, BlockDriverState *new_bs, Error **errp) in blk_replace_bs() argument
940 return bdrv_replace_child_bs(blk->root, new_bs, errp); in blk_replace_bs()
947 blk_set_perm_locked(BlockBackend *blk, uint64_t perm, uint64_t shared_perm, in blk_set_perm_locked() argument
953 if (blk->root && !blk->disable_perm) { in blk_set_perm_locked()
954 ret = bdrv_child_try_set_perm(blk->root, perm, shared_perm, errp); in blk_set_perm_locked()
960 blk->perm = perm; in blk_set_perm_locked()
961 blk->shared_perm = shared_perm; in blk_set_perm_locked()
966 int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm, in blk_set_perm() argument
972 return blk_set_perm_locked(blk, perm, shared_perm, errp); in blk_set_perm()
975 void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm) in blk_get_perm() argument
978 *perm = blk->perm; in blk_get_perm()
979 *shared_perm = blk->shared_perm; in blk_get_perm()
986 int blk_attach_dev(BlockBackend *blk, DeviceState *dev) in blk_attach_dev() argument
989 if (blk->dev) { in blk_attach_dev()
997 blk->disable_perm = true; in blk_attach_dev()
1000 blk_ref(blk); in blk_attach_dev()
1001 blk->dev = dev; in blk_attach_dev()
1002 blk_iostatus_reset(blk); in blk_attach_dev()
1011 void blk_detach_dev(BlockBackend *blk, DeviceState *dev) in blk_detach_dev() argument
1013 assert(blk->dev == dev); in blk_detach_dev()
1015 blk->dev = NULL; in blk_detach_dev()
1016 blk->dev_ops = NULL; in blk_detach_dev()
1017 blk->dev_opaque = NULL; in blk_detach_dev()
1018 blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort); in blk_detach_dev()
1019 blk_unref(blk); in blk_detach_dev()
1025 DeviceState *blk_get_attached_dev(BlockBackend *blk) in blk_get_attached_dev() argument
1028 return blk->dev; in blk_get_attached_dev()
1033 char *blk_get_attached_dev_id(BlockBackend *blk) in blk_get_attached_dev_id() argument
1035 DeviceState *dev = blk->dev; in blk_get_attached_dev_id()
1055 BlockBackend *blk = NULL; in blk_by_dev() local
1060 while ((blk = blk_all_next(blk)) != NULL) { in blk_by_dev()
1061 if (blk->dev == dev) { in blk_by_dev()
1062 return blk; in blk_by_dev()
1073 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, in blk_set_dev_ops() argument
1077 blk->dev_ops = ops; in blk_set_dev_ops()
1078 blk->dev_opaque = opaque; in blk_set_dev_ops()
1081 if (qatomic_read(&blk->quiesce_counter) && ops && ops->drained_begin) { in blk_set_dev_ops()
1096 void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp) in blk_dev_change_media_cb() argument
1099 if (blk->dev_ops && blk->dev_ops->change_media_cb) { in blk_dev_change_media_cb()
1103 tray_was_open = blk_dev_is_tray_open(blk); in blk_dev_change_media_cb()
1104 blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err); in blk_dev_change_media_cb()
1110 tray_is_open = blk_dev_is_tray_open(blk); in blk_dev_change_media_cb()
1113 char *id = blk_get_attached_dev_id(blk); in blk_dev_change_media_cb()
1114 qapi_event_send_device_tray_moved(blk_name(blk), id, tray_is_open); in blk_dev_change_media_cb()
1129 bool blk_dev_has_removable_media(BlockBackend *blk) in blk_dev_has_removable_media() argument
1132 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb); in blk_dev_has_removable_media()
1138 bool blk_dev_has_tray(BlockBackend *blk) in blk_dev_has_tray() argument
1141 return blk->dev_ops && blk->dev_ops->is_tray_open; in blk_dev_has_tray()
1148 void blk_dev_eject_request(BlockBackend *blk, bool force) in blk_dev_eject_request() argument
1151 if (blk->dev_ops && blk->dev_ops->eject_request_cb) { in blk_dev_eject_request()
1152 blk->dev_ops->eject_request_cb(blk->dev_opaque, force); in blk_dev_eject_request()
1159 bool blk_dev_is_tray_open(BlockBackend *blk) in blk_dev_is_tray_open() argument
1162 if (blk_dev_has_tray(blk)) { in blk_dev_is_tray_open()
1163 return blk->dev_ops->is_tray_open(blk->dev_opaque); in blk_dev_is_tray_open()
1172 bool blk_dev_is_medium_locked(BlockBackend *blk) in blk_dev_is_medium_locked() argument
1175 if (blk->dev_ops && blk->dev_ops->is_medium_locked) { in blk_dev_is_medium_locked()
1176 return blk->dev_ops->is_medium_locked(blk->dev_opaque); in blk_dev_is_medium_locked()
1186 BlockBackend *blk = child->opaque; in blk_root_resize() local
1188 if (blk->dev_ops && blk->dev_ops->resize_cb) { in blk_root_resize()
1189 blk->dev_ops->resize_cb(blk->dev_opaque); in blk_root_resize()
1193 void blk_iostatus_enable(BlockBackend *blk) in blk_iostatus_enable() argument
1196 blk->iostatus_enabled = true; in blk_iostatus_enable()
1197 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK; in blk_iostatus_enable()
1202 bool blk_iostatus_is_enabled(const BlockBackend *blk) in blk_iostatus_is_enabled() argument
1205 return (blk->iostatus_enabled && in blk_iostatus_is_enabled()
1206 (blk->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC || in blk_iostatus_is_enabled()
1207 blk->on_write_error == BLOCKDEV_ON_ERROR_STOP || in blk_iostatus_is_enabled()
1208 blk->on_read_error == BLOCKDEV_ON_ERROR_STOP)); in blk_iostatus_is_enabled()
1211 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk) in blk_iostatus() argument
1214 return blk->iostatus; in blk_iostatus()
1217 void blk_iostatus_disable(BlockBackend *blk) in blk_iostatus_disable() argument
1220 blk->iostatus_enabled = false; in blk_iostatus_disable()
1223 void blk_iostatus_reset(BlockBackend *blk) in blk_iostatus_reset() argument
1226 if (blk_iostatus_is_enabled(blk)) { in blk_iostatus_reset()
1227 blk->iostatus = BLOCK_DEVICE_IO_STATUS_OK; in blk_iostatus_reset()
1231 void blk_iostatus_set_err(BlockBackend *blk, int error) in blk_iostatus_set_err() argument
1234 assert(blk_iostatus_is_enabled(blk)); in blk_iostatus_set_err()
1235 if (blk->iostatus == BLOCK_DEVICE_IO_STATUS_OK) { in blk_iostatus_set_err()
1236 blk->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE : in blk_iostatus_set_err()
1241 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow) in blk_set_allow_write_beyond_eof() argument
1244 blk->allow_write_beyond_eof = allow; in blk_set_allow_write_beyond_eof()
1247 void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow) in blk_set_allow_aio_context_change() argument
1250 blk->allow_aio_context_change = allow; in blk_set_allow_aio_context_change()
1253 void blk_set_disable_request_queuing(BlockBackend *blk, bool disable) in blk_set_disable_request_queuing() argument
1256 qatomic_set(&blk->disable_request_queuing, disable); in blk_set_disable_request_queuing()
1260 blk_check_byte_request(BlockBackend *blk, int64_t offset, int64_t bytes) in blk_check_byte_request() argument
1268 if (!blk_co_is_available(blk)) { in blk_check_byte_request()
1276 if (!blk->allow_write_beyond_eof) { in blk_check_byte_request()
1277 len = bdrv_co_getlength(blk_bs(blk)); in blk_check_byte_request()
1291 bool blk_in_drain(BlockBackend *blk) in blk_in_drain() argument
1294 return qatomic_read(&blk->quiesce_counter); in blk_in_drain()
1298 static void coroutine_fn blk_wait_while_drained(BlockBackend *blk) in blk_wait_while_drained() argument
1300 assert(blk->in_flight > 0); in blk_wait_while_drained()
1302 if (qatomic_read(&blk->quiesce_counter) && in blk_wait_while_drained()
1303 !qatomic_read(&blk->disable_request_queuing)) { in blk_wait_while_drained()
1309 qemu_mutex_lock(&blk->queued_requests_lock); in blk_wait_while_drained()
1310 blk_dec_in_flight(blk); in blk_wait_while_drained()
1311 qemu_co_queue_wait(&blk->queued_requests, &blk->queued_requests_lock); in blk_wait_while_drained()
1312 blk_inc_in_flight(blk); in blk_wait_while_drained()
1313 qemu_mutex_unlock(&blk->queued_requests_lock); in blk_wait_while_drained()
1319 blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes, in blk_co_do_preadv_part() argument
1327 blk_wait_while_drained(blk); in blk_co_do_preadv_part()
1331 bs = blk_bs(blk); in blk_co_do_preadv_part()
1332 trace_blk_co_preadv(blk, bs, offset, bytes, flags); in blk_co_do_preadv_part()
1334 ret = blk_check_byte_request(blk, offset, bytes); in blk_co_do_preadv_part()
1342 if (blk->public.throttle_group_member.throttle_state) { in blk_co_do_preadv_part()
1343 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member, in blk_co_do_preadv_part()
1347 ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset, in blk_co_do_preadv_part()
1353 int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes, in blk_co_pread() argument
1361 return blk_co_preadv(blk, offset, bytes, &qiov, flags); in blk_co_pread()
1364 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset, in blk_co_preadv() argument
1371 blk_inc_in_flight(blk); in blk_co_preadv()
1372 ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, 0, flags); in blk_co_preadv()
1373 blk_dec_in_flight(blk); in blk_co_preadv()
1378 int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset, in blk_co_preadv_part() argument
1385 blk_inc_in_flight(blk); in blk_co_preadv_part()
1386 ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, qiov_offset, flags); in blk_co_preadv_part()
1387 blk_dec_in_flight(blk); in blk_co_preadv_part()
1394 blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes, in blk_co_do_pwritev_part() argument
1402 blk_wait_while_drained(blk); in blk_co_do_pwritev_part()
1406 bs = blk_bs(blk); in blk_co_do_pwritev_part()
1407 trace_blk_co_pwritev(blk, bs, offset, bytes, flags); in blk_co_do_pwritev_part()
1409 ret = blk_check_byte_request(blk, offset, bytes); in blk_co_do_pwritev_part()
1416 if (blk->public.throttle_group_member.throttle_state) { in blk_co_do_pwritev_part()
1417 throttle_group_co_io_limits_intercept(&blk->public.throttle_group_member, in blk_co_do_pwritev_part()
1421 if (!blk->enable_write_cache) { in blk_co_do_pwritev_part()
1425 ret = bdrv_co_pwritev_part(blk->root, offset, bytes, qiov, qiov_offset, in blk_co_do_pwritev_part()
1431 int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset, in blk_co_pwritev_part() argument
1439 blk_inc_in_flight(blk); in blk_co_pwritev_part()
1440 ret = blk_co_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags); in blk_co_pwritev_part()
1441 blk_dec_in_flight(blk); in blk_co_pwritev_part()
1446 int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes, in blk_co_pwrite() argument
1454 return blk_co_pwritev(blk, offset, bytes, &qiov, flags); in blk_co_pwrite()
1457 int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset, in blk_co_pwritev() argument
1462 return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags); in blk_co_pwritev()
1465 int coroutine_fn blk_co_block_status_above(BlockBackend *blk, in blk_co_block_status_above() argument
1473 return bdrv_co_block_status_above(blk_bs(blk), base, offset, bytes, pnum, in blk_co_block_status_above()
1477 int coroutine_fn blk_co_is_allocated_above(BlockBackend *blk, in blk_co_is_allocated_above() argument
1484 return bdrv_co_is_allocated_above(blk_bs(blk), base, include_base, offset, in blk_co_is_allocated_above()
1489 BlockBackend *blk; member
1496 int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags) in blk_make_zero() argument
1499 return bdrv_make_zero(blk->root, flags); in blk_make_zero()
1502 void blk_inc_in_flight(BlockBackend *blk) in blk_inc_in_flight() argument
1505 qatomic_inc(&blk->in_flight); in blk_inc_in_flight()
1508 void blk_dec_in_flight(BlockBackend *blk) in blk_dec_in_flight() argument
1511 qatomic_dec(&blk->in_flight); in blk_dec_in_flight()
1519 blk_dec_in_flight(acb->blk); in error_callback_bh()
1524 BlockAIOCB *blk_abort_aio_request(BlockBackend *blk, in blk_abort_aio_request() argument
1531 blk_inc_in_flight(blk); in blk_abort_aio_request()
1532 acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque); in blk_abort_aio_request()
1533 acb->blk = blk; in blk_abort_aio_request()
1556 blk_dec_in_flight(acb->rwco.blk); in blk_aio_complete()
1568 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, in blk_aio_prwv() argument
1577 blk_inc_in_flight(blk); in blk_aio_prwv()
1578 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque); in blk_aio_prwv()
1580 .blk = blk, in blk_aio_prwv()
1608 rwco->ret = blk_co_do_preadv_part(rwco->blk, rwco->offset, acb->bytes, qiov, in blk_aio_read_entry()
1620 rwco->ret = blk_co_do_pwritev_part(rwco->blk, rwco->offset, acb->bytes, in blk_aio_write_entry()
1625 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset, in blk_aio_pwrite_zeroes() argument
1630 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_write_entry, in blk_aio_pwrite_zeroes()
1634 int64_t coroutine_fn blk_co_getlength(BlockBackend *blk) in blk_co_getlength() argument
1639 if (!blk_co_is_available(blk)) { in blk_co_getlength()
1643 return bdrv_co_getlength(blk_bs(blk)); in blk_co_getlength()
1646 int64_t coroutine_fn blk_co_nb_sectors(BlockBackend *blk) in blk_co_nb_sectors() argument
1648 BlockDriverState *bs = blk_bs(blk); in blk_co_nb_sectors()
1664 int64_t coroutine_mixed_fn blk_nb_sectors(BlockBackend *blk) in blk_nb_sectors() argument
1666 BlockDriverState *bs = blk_bs(blk); in blk_nb_sectors()
1678 void coroutine_fn blk_co_get_geometry(BlockBackend *blk, in blk_co_get_geometry() argument
1681 int64_t ret = blk_co_nb_sectors(blk); in blk_co_get_geometry()
1688 void coroutine_mixed_fn blk_get_geometry(BlockBackend *blk, in blk_get_geometry() argument
1691 int64_t ret = blk_nb_sectors(blk); in blk_get_geometry()
1695 BlockAIOCB *blk_aio_preadv(BlockBackend *blk, int64_t offset, in blk_aio_preadv() argument
1701 return blk_aio_prwv(blk, offset, qiov->size, qiov, in blk_aio_preadv()
1705 BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset, in blk_aio_pwritev() argument
1711 return blk_aio_prwv(blk, offset, qiov->size, qiov, in blk_aio_pwritev()
1729 blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf) in blk_co_do_ioctl() argument
1733 blk_wait_while_drained(blk); in blk_co_do_ioctl()
1736 if (!blk_co_is_available(blk)) { in blk_co_do_ioctl()
1740 return bdrv_co_ioctl(blk_bs(blk), req, buf); in blk_co_do_ioctl()
1743 int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req, in blk_co_ioctl() argument
1749 blk_inc_in_flight(blk); in blk_co_ioctl()
1750 ret = blk_co_do_ioctl(blk, req, buf); in blk_co_ioctl()
1751 blk_dec_in_flight(blk); in blk_co_ioctl()
1761 rwco->ret = blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf); in blk_aio_ioctl_entry()
1766 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf, in blk_aio_ioctl() argument
1770 return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque); in blk_aio_ioctl()
1775 blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes) in blk_co_do_pdiscard() argument
1780 blk_wait_while_drained(blk); in blk_co_do_pdiscard()
1783 ret = blk_check_byte_request(blk, offset, bytes); in blk_co_do_pdiscard()
1788 return bdrv_co_pdiscard(blk->root, offset, bytes); in blk_co_do_pdiscard()
1796 rwco->ret = blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes); in blk_aio_pdiscard_entry()
1800 BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk, in blk_aio_pdiscard() argument
1805 return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0, in blk_aio_pdiscard()
1809 int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset, in blk_co_pdiscard() argument
1815 blk_inc_in_flight(blk); in blk_co_pdiscard()
1816 ret = blk_co_do_pdiscard(blk, offset, bytes); in blk_co_pdiscard()
1817 blk_dec_in_flight(blk); in blk_co_pdiscard()
1823 static int coroutine_fn blk_co_do_flush(BlockBackend *blk) in blk_co_do_flush() argument
1826 blk_wait_while_drained(blk); in blk_co_do_flush()
1829 if (!blk_co_is_available(blk)) { in blk_co_do_flush()
1833 return bdrv_co_flush(blk_bs(blk)); in blk_co_do_flush()
1841 rwco->ret = blk_co_do_flush(rwco->blk); in blk_aio_flush_entry()
1845 BlockAIOCB *blk_aio_flush(BlockBackend *blk, in blk_aio_flush() argument
1849 return blk_aio_prwv(blk, 0, 0, NULL, blk_aio_flush_entry, 0, cb, opaque); in blk_aio_flush()
1852 int coroutine_fn blk_co_flush(BlockBackend *blk) in blk_co_flush() argument
1857 blk_inc_in_flight(blk); in blk_co_flush()
1858 ret = blk_co_do_flush(blk); in blk_co_flush()
1859 blk_dec_in_flight(blk); in blk_co_flush()
1869 rwco->ret = blk_co_zone_report(rwco->blk, rwco->offset, in blk_aio_zone_report_entry()
1875 BlockAIOCB *blk_aio_zone_report(BlockBackend *blk, int64_t offset, in blk_aio_zone_report() argument
1884 blk_inc_in_flight(blk); in blk_aio_zone_report()
1885 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque); in blk_aio_zone_report()
1887 .blk = blk, in blk_aio_zone_report()
1912 rwco->ret = blk_co_zone_mgmt(rwco->blk, in blk_aio_zone_mgmt_entry()
1918 BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op, in blk_aio_zone_mgmt() argument
1925 blk_inc_in_flight(blk); in blk_aio_zone_mgmt()
1926 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque); in blk_aio_zone_mgmt()
1928 .blk = blk, in blk_aio_zone_mgmt()
1953 rwco->ret = blk_co_zone_append(rwco->blk, (int64_t *)(uintptr_t)acb->bytes, in blk_aio_zone_append_entry()
1958 BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset, in blk_aio_zone_append() argument
1965 blk_inc_in_flight(blk); in blk_aio_zone_append()
1966 acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque); in blk_aio_zone_append()
1968 .blk = blk, in blk_aio_zone_append()
1993 int coroutine_fn blk_co_zone_report(BlockBackend *blk, int64_t offset, in blk_co_zone_report() argument
2000 blk_inc_in_flight(blk); /* increase before waiting */ in blk_co_zone_report()
2001 blk_wait_while_drained(blk); in blk_co_zone_report()
2003 if (!blk_is_available(blk)) { in blk_co_zone_report()
2004 blk_dec_in_flight(blk); in blk_co_zone_report()
2007 ret = bdrv_co_zone_report(blk_bs(blk), offset, nr_zones, zones); in blk_co_zone_report()
2008 blk_dec_in_flight(blk); in blk_co_zone_report()
2019 int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, BlockZoneOp op, in blk_co_zone_mgmt() argument
2025 blk_inc_in_flight(blk); in blk_co_zone_mgmt()
2026 blk_wait_while_drained(blk); in blk_co_zone_mgmt()
2029 ret = blk_check_byte_request(blk, offset, len); in blk_co_zone_mgmt()
2031 blk_dec_in_flight(blk); in blk_co_zone_mgmt()
2035 ret = bdrv_co_zone_mgmt(blk_bs(blk), op, offset, len); in blk_co_zone_mgmt()
2036 blk_dec_in_flight(blk); in blk_co_zone_mgmt()
2043 int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset, in blk_co_zone_append() argument
2049 blk_inc_in_flight(blk); in blk_co_zone_append()
2050 blk_wait_while_drained(blk); in blk_co_zone_append()
2052 if (!blk_is_available(blk)) { in blk_co_zone_append()
2053 blk_dec_in_flight(blk); in blk_co_zone_append()
2057 ret = bdrv_co_zone_append(blk_bs(blk), offset, qiov, flags); in blk_co_zone_append()
2058 blk_dec_in_flight(blk); in blk_co_zone_append()
2062 void blk_drain(BlockBackend *blk) in blk_drain() argument
2064 BlockDriverState *bs = blk_bs(blk); in blk_drain()
2073 AIO_WAIT_WHILE(blk_get_aio_context(blk), in blk_drain()
2074 qatomic_read(&blk->in_flight) > 0); in blk_drain()
2084 BlockBackend *blk = NULL; in blk_drain_all() local
2090 while ((blk = blk_all_next(blk)) != NULL) { in blk_drain_all()
2092 AIO_WAIT_WHILE_UNLOCKED(NULL, qatomic_read(&blk->in_flight) > 0); in blk_drain_all()
2098 void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error, in blk_set_on_error() argument
2102 blk->on_read_error = on_read_error; in blk_set_on_error()
2103 blk->on_write_error = on_write_error; in blk_set_on_error()
2106 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read) in blk_get_on_error() argument
2109 return is_read ? blk->on_read_error : blk->on_write_error; in blk_get_on_error()
2112 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read, in blk_get_error_action() argument
2115 BlockdevOnError on_err = blk_get_on_error(blk, is_read); in blk_get_error_action()
2134 static void send_qmp_error_event(BlockBackend *blk, in send_qmp_error_event() argument
2139 BlockDriverState *bs = blk_bs(blk); in send_qmp_error_event()
2142 qapi_event_send_block_io_error(blk_name(blk), in send_qmp_error_event()
2144 action, blk_iostatus_is_enabled(blk), in send_qmp_error_event()
2152 void blk_error_action(BlockBackend *blk, BlockErrorAction action, in blk_error_action() argument
2163 blk_iostatus_set_err(blk, error); in blk_error_action()
2174 send_qmp_error_event(blk, action, is_read, error); in blk_error_action()
2177 send_qmp_error_event(blk, action, is_read, error); in blk_error_action()
2185 bool blk_supports_write_perm(BlockBackend *blk) in blk_supports_write_perm() argument
2187 BlockDriverState *bs = blk_bs(blk); in blk_supports_write_perm()
2193 return blk->root_state.open_flags & BDRV_O_RDWR; in blk_supports_write_perm()
2201 bool blk_is_writable(BlockBackend *blk) in blk_is_writable() argument
2204 return blk->perm & BLK_PERM_WRITE; in blk_is_writable()
2207 bool blk_is_sg(BlockBackend *blk) in blk_is_sg() argument
2209 BlockDriverState *bs = blk_bs(blk); in blk_is_sg()
2219 bool blk_enable_write_cache(BlockBackend *blk) in blk_enable_write_cache() argument
2222 return blk->enable_write_cache; in blk_enable_write_cache()
2225 void blk_set_enable_write_cache(BlockBackend *blk, bool wce) in blk_set_enable_write_cache() argument
2228 blk->enable_write_cache = wce; in blk_set_enable_write_cache()
2231 void blk_activate(BlockBackend *blk, Error **errp) in blk_activate() argument
2233 BlockDriverState *bs = blk_bs(blk); in blk_activate()
2237 error_setg(errp, "Device '%s' has no medium", blk->name); in blk_activate()
2253 bool coroutine_fn blk_co_is_inserted(BlockBackend *blk) in blk_co_is_inserted() argument
2255 BlockDriverState *bs = blk_bs(blk); in blk_co_is_inserted()
2262 bool coroutine_fn blk_co_is_available(BlockBackend *blk) in blk_co_is_available() argument
2265 return blk_co_is_inserted(blk) && !blk_dev_is_tray_open(blk); in blk_co_is_available()
2268 void coroutine_fn blk_co_lock_medium(BlockBackend *blk, bool locked) in blk_co_lock_medium() argument
2270 BlockDriverState *bs = blk_bs(blk); in blk_co_lock_medium()
2279 void coroutine_fn blk_co_eject(BlockBackend *blk, bool eject_flag) in blk_co_eject() argument
2281 BlockDriverState *bs = blk_bs(blk); in blk_co_eject()
2292 id = blk_get_attached_dev_id(blk); in blk_co_eject()
2293 qapi_event_send_device_tray_moved(blk_name(blk), id, in blk_co_eject()
2298 int blk_get_flags(BlockBackend *blk) in blk_get_flags() argument
2300 BlockDriverState *bs = blk_bs(blk); in blk_get_flags()
2306 return blk->root_state.open_flags; in blk_get_flags()
2311 uint32_t blk_get_request_alignment(BlockBackend *blk) in blk_get_request_alignment() argument
2313 BlockDriverState *bs = blk_bs(blk); in blk_get_request_alignment()
2319 uint64_t blk_get_max_hw_transfer(BlockBackend *blk) in blk_get_max_hw_transfer() argument
2321 BlockDriverState *bs = blk_bs(blk); in blk_get_max_hw_transfer()
2329 return ROUND_DOWN(max, blk_get_request_alignment(blk)); in blk_get_max_hw_transfer()
2333 uint32_t blk_get_max_transfer(BlockBackend *blk) in blk_get_max_transfer() argument
2335 BlockDriverState *bs = blk_bs(blk); in blk_get_max_transfer()
2342 return ROUND_DOWN(max, blk_get_request_alignment(blk)); in blk_get_max_transfer()
2345 int blk_get_max_hw_iov(BlockBackend *blk) in blk_get_max_hw_iov() argument
2348 return MIN_NON_ZERO(blk->root->bs->bl.max_hw_iov, in blk_get_max_hw_iov()
2349 blk->root->bs->bl.max_iov); in blk_get_max_hw_iov()
2352 int blk_get_max_iov(BlockBackend *blk) in blk_get_max_iov() argument
2355 return blk->root->bs->bl.max_iov; in blk_get_max_iov()
2358 void *blk_try_blockalign(BlockBackend *blk, size_t size) in blk_try_blockalign() argument
2361 return qemu_try_blockalign(blk ? blk_bs(blk) : NULL, size); in blk_try_blockalign()
2364 void *blk_blockalign(BlockBackend *blk, size_t size) in blk_blockalign() argument
2367 return qemu_blockalign(blk ? blk_bs(blk) : NULL, size); in blk_blockalign()
2370 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp) in blk_op_is_blocked() argument
2372 BlockDriverState *bs = blk_bs(blk); in blk_op_is_blocked()
2383 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason) in blk_op_unblock() argument
2385 BlockDriverState *bs = blk_bs(blk); in blk_op_unblock()
2393 void blk_op_block_all(BlockBackend *blk, Error *reason) in blk_op_block_all() argument
2395 BlockDriverState *bs = blk_bs(blk); in blk_op_block_all()
2403 void blk_op_unblock_all(BlockBackend *blk, Error *reason) in blk_op_unblock_all() argument
2405 BlockDriverState *bs = blk_bs(blk); in blk_op_unblock_all()
2420 AioContext *blk_get_aio_context(BlockBackend *blk) in blk_get_aio_context() argument
2424 if (!blk) { in blk_get_aio_context()
2428 return qatomic_read(&blk->ctx); in blk_get_aio_context()
2431 int blk_set_aio_context(BlockBackend *blk, AioContext *new_context, in blk_set_aio_context() argument
2435 BlockDriverState *bs = blk_bs(blk); in blk_set_aio_context()
2441 qatomic_set(&blk->ctx, new_context); in blk_set_aio_context()
2447 old_allow_change = blk->allow_aio_context_change; in blk_set_aio_context()
2448 blk->allow_aio_context_change = true; in blk_set_aio_context()
2452 blk->allow_aio_context_change = old_allow_change; in blk_set_aio_context()
2460 BlockBackend *blk; member
2466 BlockBackend *blk = s->blk; in blk_root_set_aio_ctx_commit() local
2468 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; in blk_root_set_aio_ctx_commit()
2470 qatomic_set(&blk->ctx, new_context); in blk_root_set_aio_ctx_commit()
2486 BlockBackend *blk = child->opaque; in blk_root_change_aio_ctx() local
2489 if (!blk->allow_aio_context_change) { in blk_root_change_aio_ctx()
2495 if (!blk->name || blk->dev) { in blk_root_change_aio_ctx()
2505 .blk = blk, in blk_root_change_aio_ctx()
2512 void blk_add_aio_context_notifier(BlockBackend *blk, in blk_add_aio_context_notifier() argument
2517 BlockDriverState *bs = blk_bs(blk); in blk_add_aio_context_notifier()
2524 QLIST_INSERT_HEAD(&blk->aio_notifiers, notifier, list); in blk_add_aio_context_notifier()
2532 void blk_remove_aio_context_notifier(BlockBackend *blk, in blk_remove_aio_context_notifier() argument
2539 BlockDriverState *bs = blk_bs(blk); in blk_remove_aio_context_notifier()
2548 QLIST_FOREACH(notifier, &blk->aio_notifiers, list) { in blk_remove_aio_context_notifier()
2561 void blk_add_remove_bs_notifier(BlockBackend *blk, Notifier *notify) in blk_add_remove_bs_notifier() argument
2564 notifier_list_add(&blk->remove_bs_notifiers, notify); in blk_add_remove_bs_notifier()
2567 void blk_add_insert_bs_notifier(BlockBackend *blk, Notifier *notify) in blk_add_insert_bs_notifier() argument
2570 notifier_list_add(&blk->insert_bs_notifiers, notify); in blk_add_insert_bs_notifier()
2573 BlockAcctStats *blk_get_stats(BlockBackend *blk) in blk_get_stats() argument
2576 return &blk->stats; in blk_get_stats()
2579 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk, in blk_aio_get() argument
2583 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque); in blk_aio_get()
2586 int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset, in blk_co_pwrite_zeroes() argument
2590 return blk_co_pwritev(blk, offset, bytes, NULL, in blk_co_pwrite_zeroes()
2594 int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset, in blk_co_pwrite_compressed() argument
2599 return blk_co_pwritev_part(blk, offset, bytes, &qiov, 0, in blk_co_pwrite_compressed()
2603 int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact, in blk_co_truncate() argument
2609 if (!blk_co_is_available(blk)) { in blk_co_truncate()
2614 return bdrv_co_truncate(blk->root, offset, exact, prealloc, flags, errp); in blk_co_truncate()
2617 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf, in blk_save_vmstate() argument
2623 if (!blk_is_available(blk)) { in blk_save_vmstate()
2627 ret = bdrv_save_vmstate(blk_bs(blk), buf, pos, size); in blk_save_vmstate()
2632 if (ret == size && !blk->enable_write_cache) { in blk_save_vmstate()
2633 ret = bdrv_flush(blk_bs(blk)); in blk_save_vmstate()
2639 int blk_load_vmstate(BlockBackend *blk, uint8_t *buf, int64_t pos, int size) in blk_load_vmstate() argument
2642 if (!blk_is_available(blk)) { in blk_load_vmstate()
2646 return bdrv_load_vmstate(blk_bs(blk), buf, pos, size); in blk_load_vmstate()
2649 int blk_probe_blocksizes(BlockBackend *blk, BlockSizes *bsz) in blk_probe_blocksizes() argument
2654 if (!blk_is_available(blk)) { in blk_probe_blocksizes()
2658 return bdrv_probe_blocksizes(blk_bs(blk), bsz); in blk_probe_blocksizes()
2661 int blk_probe_geometry(BlockBackend *blk, HDGeometry *geo) in blk_probe_geometry() argument
2664 if (!blk_is_available(blk)) { in blk_probe_geometry()
2668 return bdrv_probe_geometry(blk_bs(blk), geo); in blk_probe_geometry()
2675 void blk_update_root_state(BlockBackend *blk) in blk_update_root_state() argument
2678 assert(blk->root); in blk_update_root_state()
2680 blk->root_state.open_flags = blk->root->bs->open_flags; in blk_update_root_state()
2681 blk->root_state.detect_zeroes = blk->root->bs->detect_zeroes; in blk_update_root_state()
2688 bool blk_get_detect_zeroes_from_root_state(BlockBackend *blk) in blk_get_detect_zeroes_from_root_state() argument
2691 return blk->root_state.detect_zeroes; in blk_get_detect_zeroes_from_root_state()
2698 int blk_get_open_flags_from_root_state(BlockBackend *blk) in blk_get_open_flags_from_root_state() argument
2701 return blk->root_state.open_flags; in blk_get_open_flags_from_root_state()
2704 BlockBackendRootState *blk_get_root_state(BlockBackend *blk) in blk_get_root_state() argument
2707 return &blk->root_state; in blk_get_root_state()
2712 BlockBackend *blk = NULL; in blk_commit_all() local
2716 while ((blk = blk_all_next(blk)) != NULL) { in blk_commit_all()
2717 BlockDriverState *unfiltered_bs = bdrv_skip_filters(blk_bs(blk)); in blk_commit_all()
2719 if (blk_is_inserted(blk) && bdrv_cow_child(unfiltered_bs)) { in blk_commit_all()
2733 void blk_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg) in blk_set_io_limits() argument
2736 throttle_group_config(&blk->public.throttle_group_member, cfg); in blk_set_io_limits()
2739 void blk_io_limits_disable(BlockBackend *blk) in blk_io_limits_disable() argument
2741 BlockDriverState *bs = blk_bs(blk); in blk_io_limits_disable()
2742 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; in blk_io_limits_disable()
2757 void blk_io_limits_enable(BlockBackend *blk, const char *group) in blk_io_limits_enable() argument
2759 assert(!blk->public.throttle_group_member.throttle_state); in blk_io_limits_enable()
2761 throttle_group_register_tgm(&blk->public.throttle_group_member, in blk_io_limits_enable()
2762 group, blk_get_aio_context(blk)); in blk_io_limits_enable()
2765 void blk_io_limits_update_group(BlockBackend *blk, const char *group) in blk_io_limits_update_group() argument
2769 if (!blk->public.throttle_group_member.throttle_state) { in blk_io_limits_update_group()
2774 if (!g_strcmp0(throttle_group_get_name(&blk->public.throttle_group_member), in blk_io_limits_update_group()
2780 blk_io_limits_disable(blk); in blk_io_limits_update_group()
2781 blk_io_limits_enable(blk, group); in blk_io_limits_update_group()
2786 BlockBackend *blk = child->opaque; in blk_root_drained_begin() local
2787 ThrottleGroupMember *tgm = &blk->public.throttle_group_member; in blk_root_drained_begin()
2789 if (qatomic_fetch_inc(&blk->quiesce_counter) == 0) { in blk_root_drained_begin()
2790 if (blk->dev_ops && blk->dev_ops->drained_begin) { in blk_root_drained_begin()
2791 blk->dev_ops->drained_begin(blk->dev_opaque); in blk_root_drained_begin()
2805 BlockBackend *blk = child->opaque; in blk_root_drained_poll() local
2807 assert(qatomic_read(&blk->quiesce_counter)); in blk_root_drained_poll()
2809 if (blk->dev_ops && blk->dev_ops->drained_poll) { in blk_root_drained_poll()
2810 busy = blk->dev_ops->drained_poll(blk->dev_opaque); in blk_root_drained_poll()
2812 return busy || !!blk->in_flight; in blk_root_drained_poll()
2817 BlockBackend *blk = child->opaque; in blk_root_drained_end() local
2818 assert(qatomic_read(&blk->quiesce_counter)); in blk_root_drained_end()
2820 assert(blk->public.throttle_group_member.io_limits_disabled); in blk_root_drained_end()
2821 qatomic_dec(&blk->public.throttle_group_member.io_limits_disabled); in blk_root_drained_end()
2823 if (qatomic_fetch_dec(&blk->quiesce_counter) == 1) { in blk_root_drained_end()
2824 if (blk->dev_ops && blk->dev_ops->drained_end) { in blk_root_drained_end()
2825 blk->dev_ops->drained_end(blk->dev_opaque); in blk_root_drained_end()
2827 qemu_mutex_lock(&blk->queued_requests_lock); in blk_root_drained_end()
2828 while (qemu_co_enter_next(&blk->queued_requests, in blk_root_drained_end()
2829 &blk->queued_requests_lock)) { in blk_root_drained_end()
2832 qemu_mutex_unlock(&blk->queued_requests_lock); in blk_root_drained_end()
2836 bool blk_register_buf(BlockBackend *blk, void *host, size_t size, Error **errp) in blk_register_buf() argument
2838 BlockDriverState *bs = blk_bs(blk); in blk_register_buf()
2848 void blk_unregister_buf(BlockBackend *blk, void *host, size_t size) in blk_unregister_buf() argument
2850 BlockDriverState *bs = blk_bs(blk); in blk_unregister_buf()
2882 const BdrvChild *blk_root(BlockBackend *blk) in blk_root() argument
2885 return blk->root; in blk_root()
2888 int blk_make_empty(BlockBackend *blk, Error **errp) in blk_make_empty() argument
2893 if (!blk_is_available(blk)) { in blk_make_empty()
2898 return bdrv_make_empty(blk->root, errp); in blk_make_empty()