Lines Matching +full:- +full:- +full:disable +full:- +full:rbd
30 #include "block/dirty-bitmap.h"
34 #include "qemu/error-report.h"
36 #include "qemu/main-loop.h"
43 #include "qapi/qobject-output-visitor.h"
44 #include "qapi/qapi-visit-block-core.h"
45 #include "system/block-backend.h"
113 /* If non-zero, use only whitelisted block drivers */
138 if (!bs || !bs->drv) { in bdrv_opt_mem_align()
144 return bs->bl.opt_mem_alignment; in bdrv_opt_mem_align()
149 if (!bs || !bs->drv) { in bdrv_min_mem_align()
155 return bs->bl.min_mem_alignment; in bdrv_min_mem_align()
229 len = p - base_path; in path_combine()
261 assert(!path_has_protocol(fat_filename->str)); in bdrv_parse_filename_strip_prefix()
267 * filename as-is */ in bdrv_parse_filename_strip_prefix()
274 /* Returns whether the image file is opened as read-only. Note that this can
280 return !(bs->open_flags & BDRV_O_RDWR); in bdrv_is_read_only()
290 if (bs->copy_on_read && read_only) { in bdrv_can_set_read_only()
291 error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled", in bdrv_can_set_read_only()
293 return -EINVAL; in bdrv_can_set_read_only()
297 if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) && in bdrv_can_set_read_only()
302 return -EPERM; in bdrv_can_set_read_only()
309 * Called by a driver that can only provide a read-only image.
311 * Returns 0 if the node is already read-only or it could switch the node to
312 * read-only because BDRV_O_AUTO_RDONLY is set.
314 * Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set
315 * or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg
324 if (!(bs->open_flags & BDRV_O_RDWR)) { in bdrv_apply_auto_read_only()
327 if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) { in bdrv_apply_auto_read_only()
336 bs->open_flags &= ~BDRV_O_RDWR; in bdrv_apply_auto_read_only()
341 error_setg(errp, "%s", errmsg ?: "Image is read-only"); in bdrv_apply_auto_read_only()
342 return -EACCES; in bdrv_apply_auto_read_only()
401 return bdrv_make_absolute_filename(bs, bs->backing_file, errp); in bdrv_get_full_backing_filename()
406 assert(bdrv->format_name); in bdrv_register()
419 QLIST_INIT(&bs->dirty_bitmaps); in bdrv_new()
421 QLIST_INIT(&bs->op_blockers[i]); in bdrv_new()
423 qemu_mutex_init(&bs->reqs_lock); in bdrv_new()
424 qemu_mutex_init(&bs->dirty_bitmap_mutex); in bdrv_new()
425 bs->refcnt = 1; in bdrv_new()
426 bs->aio_context = qemu_get_aio_context(); in bdrv_new()
428 qemu_co_queue_init(&bs->flush_queue); in bdrv_new()
430 qemu_co_mutex_init(&bs->bsc_modify_lock); in bdrv_new()
431 bs->block_status_cache = g_new0(BdrvBlockStatusCache, 1); in bdrv_new()
448 if (!strcmp(drv1->format_name, format_name)) { in bdrv_do_find_format()
519 return bdrv_format_is_whitelisted(drv->format_name, read_only); in bdrv_is_whitelisted()
542 if (!drv->bdrv_co_create_opts) { in bdrv_co_create()
544 drv->format_name); in bdrv_co_create()
545 return -ENOTSUP; in bdrv_co_create()
548 ret = drv->bdrv_co_create_opts(drv, filename, opts, errp); in bdrv_co_create()
550 error_setg_errno(errp, -ret, "Could not create image"); in bdrv_co_create()
561 * Otherwise, return -errno.
575 if (ret < 0 && ret != -ENOTSUP) { in create_file_fallback_truncate()
583 error_setg_errno(errp, -size, in create_file_fallback_truncate()
591 return -ENOTSUP; in create_file_fallback_truncate()
602 * sector to remove any potentially pre-existing image header.
618 error_setg_errno(errp, -ret, in create_file_fallback_zero_first_sector()
655 return -EINVAL; in bdrv_co_create_opts_simple()
661 return -ENOTSUP; in bdrv_co_create_opts_simple()
665 qdict_put_str(options, "driver", drv->format_name); in bdrv_co_create_opts_simple()
674 drv->format_name); in bdrv_co_create_opts_simple()
675 return -EINVAL; in bdrv_co_create_opts_simple()
707 return -ENOENT; in bdrv_co_create_file()
710 if (!drv->create_opts) { in bdrv_co_create_file()
712 drv->format_name); in bdrv_co_create_file()
713 return -ENOTSUP; in bdrv_co_create_file()
721 * in 'opts->list'. So if the protocol has options with the same name in bdrv_co_create_file()
722 * (e.g. rbd has 'cluster_size' as qcow2), it will see the default values in bdrv_co_create_file()
731 protocol_opts = qemu_opts_from_qdict(drv->create_opts, qdict, errp); in bdrv_co_create_file()
733 ret = -EINVAL; in bdrv_co_create_file()
753 if (!bs->drv) { in bdrv_co_delete_file()
754 error_setg(errp, "Block node '%s' is not opened", bs->filename); in bdrv_co_delete_file()
755 return -ENOMEDIUM; in bdrv_co_delete_file()
758 if (!bs->drv->bdrv_co_delete_file) { in bdrv_co_delete_file()
760 bs->drv->format_name); in bdrv_co_delete_file()
761 return -ENOTSUP; in bdrv_co_delete_file()
764 ret = bs->drv->bdrv_co_delete_file(bs, &local_err); in bdrv_co_delete_file()
788 if (ret == -ENOTSUP) { in bdrv_co_delete_file_noerr()
798 * On failure return -errno.
803 BlockDriver *drv = bs->drv; in bdrv_probe_blocksizes()
807 if (drv && drv->bdrv_probe_blocksizes) { in bdrv_probe_blocksizes()
808 return drv->bdrv_probe_blocksizes(bs, bsz); in bdrv_probe_blocksizes()
813 return -ENOTSUP; in bdrv_probe_blocksizes()
819 * On failure return -errno.
824 BlockDriver *drv = bs->drv; in bdrv_probe_geometry()
830 if (drv && drv->bdrv_probe_geometry) { in bdrv_probe_geometry()
831 return drv->bdrv_probe_geometry(bs, geo); in bdrv_probe_geometry()
839 return -ENOTSUP; in bdrv_probe_geometry()
843 * Create a uniquely-named empty temporary file.
859 * See commit 69bef79 ("block: use /var/tmp instead of /tmp for -snapshot") in create_tmp_file()
861 * This function is used to create temporary disk images (like -snapshot), in create_tmp_file()
893 if (d->bdrv_probe_device) { in find_hdev_driver()
894 score = d->bdrv_probe_device(filename); in find_hdev_driver()
911 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) { in bdrv_do_find_protocol()
935 * Thanks to the brain-dead persistent naming schemes on udev- in bdrv_find_protocol()
949 len = p - filename; in bdrv_find_protocol()
950 if (len > sizeof(protocol) - 1) in bdrv_find_protocol()
951 len = sizeof(protocol) - 1; in bdrv_find_protocol()
981 * This is not a good idea when your image is raw (CVE-2008-2004), but
1001 if (d->bdrv_probe) { in bdrv_probe_all()
1002 score = d->bdrv_probe(buf, buf_size, filename); in bdrv_probe_all()
1022 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */ in find_image_format()
1030 error_setg_errno(errp, -ret, "Could not read image for determining its " in find_image_format()
1041 return -ENOENT; in find_image_format()
1050 * Return 0 on success, -errno on error.
1055 BlockDriver *drv = bs->drv; in bdrv_co_refresh_total_sectors()
1060 return -ENOMEDIUM; in bdrv_co_refresh_total_sectors()
1063 /* Do not attempt drv->bdrv_co_getlength() on scsi-generic devices */ in bdrv_co_refresh_total_sectors()
1068 if (drv->bdrv_co_getlength) { in bdrv_co_refresh_total_sectors()
1069 int64_t length = drv->bdrv_co_getlength(bs); in bdrv_co_refresh_total_sectors()
1076 bs->total_sectors = hint; in bdrv_co_refresh_total_sectors()
1078 if (bs->total_sectors * BDRV_SECTOR_SIZE > BDRV_MAX_LENGTH) { in bdrv_co_refresh_total_sectors()
1079 return -EFBIG; in bdrv_co_refresh_total_sectors()
1093 if (bs->drv && bs->drv->bdrv_join_options) { in bdrv_join_options()
1094 bs->drv->bdrv_join_options(options, old_options); in bdrv_join_options()
1105 char *value = qemu_opt_get_del(opts, "detect-zeroes"); in bdrv_parse_detect_zeroes()
1119 error_setg(errp, "setting detect-zeroes to unmap is not allowed " in bdrv_parse_detect_zeroes()
1129 * Return 0 on success, -1 if the engine specified is invalid
1142 return -1; in bdrv_parse_aio()
1151 * Return 0 on success, -1 if the discard mode was invalid.
1162 return -1; in bdrv_parse_discard_flags()
1171 * Return 0 on success, -1 if the cache mode was invalid.
1191 return -1; in bdrv_parse_cache_mode()
1199 BlockDriverState *parent = c->opaque; in bdrv_child_get_parent_desc()
1205 BlockDriverState *bs = child->opaque; in bdrv_child_cb_drained_begin()
1211 BlockDriverState *bs = child->opaque; in bdrv_child_cb_drained_poll()
1217 BlockDriverState *bs = child->opaque; in bdrv_child_cb_drained_end()
1223 BlockDriverState *bs = child->opaque; in bdrv_child_cb_inactivate()
1225 assert(bs->open_flags & BDRV_O_INACTIVE); in bdrv_child_cb_inactivate()
1234 BlockDriverState *bs = child->opaque; in bdrv_child_cb_change_aio_ctx()
1253 /* Copy the read-only and discard options from the parent */ in bdrv_temp_snapshot_options()
1257 /* aio=native doesn't work for cache.direct=off, so disable it for the in bdrv_temp_snapshot_options()
1264 BlockDriverState *parent = c->opaque; in bdrv_backing_attach()
1265 BlockDriverState *backing_hd = c->bs; in bdrv_backing_attach()
1268 assert(!parent->backing_blocker); in bdrv_backing_attach()
1269 error_setg(&parent->backing_blocker, in bdrv_backing_attach()
1275 parent->open_flags &= ~BDRV_O_NO_BACKING; in bdrv_backing_attach()
1277 bdrv_op_block_all(backing_hd, parent->backing_blocker); in bdrv_backing_attach()
1280 parent->backing_blocker); in bdrv_backing_attach()
1282 parent->backing_blocker); in bdrv_backing_attach()
1297 parent->backing_blocker); in bdrv_backing_attach()
1299 parent->backing_blocker); in bdrv_backing_attach()
1304 BlockDriverState *parent = c->opaque; in bdrv_backing_detach()
1307 assert(parent->backing_blocker); in bdrv_backing_detach()
1308 bdrv_op_unblock_all(c->bs, parent->backing_blocker); in bdrv_backing_detach()
1309 error_free(parent->backing_blocker); in bdrv_backing_detach()
1310 parent->backing_blocker = NULL; in bdrv_backing_detach()
1318 BlockDriverState *parent = c->opaque; in bdrv_backing_update_filename()
1331 if (base->drv) { in bdrv_backing_update_filename()
1338 if (backing_mask_protocol && base->drv->protocol_name) { in bdrv_backing_update_filename()
1341 format_name = base->drv->format_name; in bdrv_backing_update_filename()
1349 error_setg_errno(errp, -ret, "Could not update backing file link"); in bdrv_backing_update_filename()
1373 * format-probed by default? in bdrv_inherited_options()
1377 * Pure and non-filtered data children of non-format nodes should in bdrv_inherited_options()
1381 * Force-clear BDRV_O_PROTOCOL then. in bdrv_inherited_options()
1392 * metadata children in general should never be format-probed. in bdrv_inherited_options()
1393 * Force-set BDRV_O_PROTOCOL then. in bdrv_inherited_options()
1402 * If the cache mode isn't explicitly set, inherit direct and no-flush from in bdrv_inherited_options()
1410 /* backing files are opened read-only by default */ in bdrv_inherited_options()
1414 /* Inherit the read-only option from the parent if it's not set */ in bdrv_inherited_options()
1442 BlockDriverState *bs = child->opaque; in bdrv_child_cb_attach()
1445 QLIST_INSERT_HEAD(&bs->children, child, next); in bdrv_child_cb_attach()
1446 if (bs->drv->is_filter || (child->role & BDRV_CHILD_FILTERED)) { in bdrv_child_cb_attach()
1448 * Here we handle filters and block/raw-format.c when it behave like in bdrv_child_cb_attach()
1452 * So bs->file will be the PRIMARY child, unless the PRIMARY child goes in bdrv_child_cb_attach()
1453 * into bs->backing on exceptional cases; and bs->backing will be in bdrv_child_cb_attach()
1456 assert(!(child->role & BDRV_CHILD_COW)); in bdrv_child_cb_attach()
1457 if (child->role & BDRV_CHILD_PRIMARY) { in bdrv_child_cb_attach()
1458 assert(child->role & BDRV_CHILD_FILTERED); in bdrv_child_cb_attach()
1459 assert(!bs->backing); in bdrv_child_cb_attach()
1460 assert(!bs->file); in bdrv_child_cb_attach()
1462 if (bs->drv->filtered_child_is_backing) { in bdrv_child_cb_attach()
1463 bs->backing = child; in bdrv_child_cb_attach()
1465 bs->file = child; in bdrv_child_cb_attach()
1468 assert(!(child->role & BDRV_CHILD_FILTERED)); in bdrv_child_cb_attach()
1470 } else if (child->role & BDRV_CHILD_COW) { in bdrv_child_cb_attach()
1471 assert(bs->drv->supports_backing); in bdrv_child_cb_attach()
1472 assert(!(child->role & BDRV_CHILD_PRIMARY)); in bdrv_child_cb_attach()
1473 assert(!bs->backing); in bdrv_child_cb_attach()
1474 bs->backing = child; in bdrv_child_cb_attach()
1476 } else if (child->role & BDRV_CHILD_PRIMARY) { in bdrv_child_cb_attach()
1477 assert(!bs->file); in bdrv_child_cb_attach()
1478 bs->file = child; in bdrv_child_cb_attach()
1484 BlockDriverState *bs = child->opaque; in bdrv_child_cb_detach()
1486 if (child->role & BDRV_CHILD_COW) { in bdrv_child_cb_detach()
1492 if (child == bs->backing) { in bdrv_child_cb_detach()
1493 assert(child != bs->file); in bdrv_child_cb_detach()
1494 bs->backing = NULL; in bdrv_child_cb_detach()
1495 } else if (child == bs->file) { in bdrv_child_cb_detach()
1496 bs->file = NULL; in bdrv_child_cb_detach()
1505 if (c->role & BDRV_CHILD_COW) { in bdrv_child_cb_update_filename()
1515 BlockDriverState *bs = c->opaque; in child_of_bds_get_parent_aio_context()
1539 return c->klass->get_parent_aio_context(c); in bdrv_child_get_parent_aio_context()
1616 error_setg(errp, "Invalid node-name: '%s'", node_name); in bdrv_assign_node_name()
1622 error_setg(errp, "node-name=%s is conflicting with a device id", in bdrv_assign_node_name()
1629 error_setg(errp, "Duplicate nodes with node-name='%s'", node_name); in bdrv_assign_node_name()
1634 if (strlen(node_name) >= sizeof(bs->node_name)) { in bdrv_assign_node_name()
1640 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name); in bdrv_assign_node_name()
1657 return -EINVAL; in bdrv_open_driver()
1660 bs->drv = drv; in bdrv_open_driver()
1661 bs->opaque = g_malloc0(drv->instance_size); in bdrv_open_driver()
1663 assert(!drv->bdrv_needs_filename || bs->filename[0]); in bdrv_open_driver()
1664 if (drv->bdrv_open) { in bdrv_open_driver()
1665 ret = drv->bdrv_open(bs, options, open_flags, &local_err); in bdrv_open_driver()
1673 } else if (bs->filename[0]) { in bdrv_open_driver()
1674 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename); in bdrv_open_driver()
1676 error_setg_errno(errp, -ret, "Could not open image"); in bdrv_open_driver()
1681 assert(!(bs->supported_read_flags & ~BDRV_REQ_MASK)); in bdrv_open_driver()
1682 assert(!(bs->supported_write_flags & ~BDRV_REQ_MASK)); in bdrv_open_driver()
1692 bs->supported_read_flags |= BDRV_REQ_REGISTERED_BUF; in bdrv_open_driver()
1693 bs->supported_write_flags |= BDRV_REQ_REGISTERED_BUF; in bdrv_open_driver()
1695 ret = bdrv_refresh_total_sectors(bs, bs->total_sectors); in bdrv_open_driver()
1697 error_setg_errno(errp, -ret, "Could not refresh total sector count"); in bdrv_open_driver()
1707 return -EINVAL; in bdrv_open_driver()
1712 assert(is_power_of_2(bs->bl.request_alignment)); in bdrv_open_driver()
1714 for (i = 0; i < bs->quiesce_counter; i++) { in bdrv_open_driver()
1715 if (drv->bdrv_drain_begin) { in bdrv_open_driver()
1716 drv->bdrv_drain_begin(bs); in bdrv_open_driver()
1722 bs->drv = NULL; in bdrv_open_driver()
1726 if (bs->file != NULL) { in bdrv_open_driver()
1727 bdrv_unref_child(bs, bs->file); in bdrv_open_driver()
1728 assert(!bs->file); in bdrv_open_driver()
1733 g_free(bs->opaque); in bdrv_open_driver()
1734 bs->opaque = NULL; in bdrv_open_driver()
1757 bs->open_flags = flags; in bdrv_new_open_driver_opts()
1758 bs->options = options ?: qdict_new(); in bdrv_new_open_driver_opts()
1759 bs->explicit_options = qdict_clone_shallow(bs->options); in bdrv_new_open_driver_opts()
1760 bs->opaque = NULL; in bdrv_new_open_driver_opts()
1762 update_options_from_flags(bs->options, flags); in bdrv_new_open_driver_opts()
1764 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp); in bdrv_new_open_driver_opts()
1766 qobject_unref(bs->explicit_options); in bdrv_new_open_driver_opts()
1767 bs->explicit_options = NULL; in bdrv_new_open_driver_opts()
1768 qobject_unref(bs->options); in bdrv_new_open_driver_opts()
1769 bs->options = NULL; in bdrv_new_open_driver_opts()
1790 .name = "node-name",
1817 .help = "Node is opened in read-only mode",
1822 .help = "Node can become read-only if opening read-write fails",
1825 .name = "detect-zeroes",
1844 .name = "simple-create-opts",
1882 assert(bs->file == NULL); in bdrv_open_common()
1883 assert(options != NULL && bs->options != options); in bdrv_open_common()
1888 ret = -EINVAL; in bdrv_open_common()
1892 update_flags_from_options(&bs->open_flags, opts); in bdrv_open_common()
1898 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false); in bdrv_open_common()
1900 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) { in bdrv_open_common()
1903 "=on can only be used with read-only images"); in bdrv_open_common()
1904 ret = -EINVAL; in bdrv_open_common()
1913 filename = blk_bs(file)->filename; in bdrv_open_common()
1917 * non-string types would require more care. When @options in bdrv_open_common()
1918 * come from -blockdev or blockdev_add, its members are typed in bdrv_open_common()
1920 * -drive, they're all QString. in bdrv_open_common()
1925 if (drv->bdrv_needs_filename && (!filename || !filename[0])) { in bdrv_open_common()
1927 drv->format_name); in bdrv_open_common()
1928 ret = -EINVAL; in bdrv_open_common()
1932 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags, in bdrv_open_common()
1933 drv->format_name); in bdrv_open_common()
1943 ret = -ENOTSUP; in bdrv_open_common()
1948 ? "Driver '%s' can only be used for read-only devices" in bdrv_open_common()
1950 drv->format_name); in bdrv_open_common()
1956 assert(qatomic_read(&bs->copy_on_read) == 0); in bdrv_open_common()
1958 if (bs->open_flags & BDRV_O_COPY_ON_READ) { in bdrv_open_common()
1962 error_setg(errp, "Can't use copy-on-read on read-only device"); in bdrv_open_common()
1963 ret = -EINVAL; in bdrv_open_common()
1970 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) { in bdrv_open_common()
1972 ret = -EINVAL; in bdrv_open_common()
1977 bs->detect_zeroes = in bdrv_open_common()
1978 bdrv_parse_detect_zeroes(opts, bs->open_flags, &local_err); in bdrv_open_common()
1981 ret = -EINVAL; in bdrv_open_common()
1986 pstrcpy(bs->filename, sizeof(bs->filename), filename); in bdrv_open_common()
1988 bs->filename[0] = '\0'; in bdrv_open_common()
1990 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename); in bdrv_open_common()
1993 open_flags = bdrv_open_flags(bs, bs->open_flags); in bdrv_open_common()
1994 node_name = qemu_opt_get(opts, "node-name"); in bdrv_open_common()
1996 assert(!drv->protocol_name || file == NULL); in bdrv_open_common()
2046 /* Parse json: pseudo-protocol */ in parse_json_protocol()
2083 * Caution: while qdict_get_try_str() is fine, getting non-string in bdrv_fill_options()
2085 * -blockdev or blockdev_add, its members are typed according to in bdrv_fill_options()
2086 * the QAPI schema, but when they come from -drive, they're all in bdrv_fill_options()
2094 return -ENOENT; in bdrv_fill_options()
2098 protocol = drv->protocol_name; in bdrv_fill_options()
2118 return -EINVAL; in bdrv_fill_options()
2130 return -EINVAL; in bdrv_fill_options()
2133 drvname = drv->format_name; in bdrv_fill_options()
2137 return -EINVAL; in bdrv_fill_options()
2143 /* Driver-specific filename parsing */ in bdrv_fill_options()
2144 if (drv && drv->bdrv_parse_filename && parse_filename) { in bdrv_fill_options()
2145 drv->bdrv_parse_filename(filename, *options, &local_err); in bdrv_fill_options()
2148 return -EINVAL; in bdrv_fill_options()
2151 if (!drv->bdrv_needs_filename) { in bdrv_fill_options()
2176 if (entry->state.bs == bs) { in bdrv_reopen_get_flags()
2177 return entry->state.flags; in bdrv_reopen_get_flags()
2182 return bs->open_flags; in bdrv_reopen_get_flags()
2198 * be written to but do not count as read-only images.
2209 return c->klass->get_parent_desc(c); in bdrv_child_user_desc()
2223 assert(a->bs); in bdrv_a_allow_b()
2224 assert(a->bs == b->bs); in bdrv_a_allow_b()
2227 if ((b->perm & a->shared_perm) == b->perm) { in bdrv_a_allow_b()
2231 child_bs_name = bdrv_get_node_name(b->bs); in bdrv_a_allow_b()
2234 perms = bdrv_perm_names(b->perm & ~a->shared_perm); in bdrv_a_allow_b()
2240 b_user, child_bs_name, b->name, in bdrv_a_allow_b()
2241 a_user, child_bs_name, a->name); in bdrv_a_allow_b()
2257 QLIST_FOREACH(a, &bs->parents, next_parent) { in bdrv_parent_perms_conflict()
2258 QLIST_FOREACH(b, &bs->parents, next_parent) { in bdrv_parent_perms_conflict()
2279 assert(bs->drv && bs->drv->bdrv_child_perm); in bdrv_child_perm()
2281 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue, in bdrv_child_perm()
2285 if (child_bs && child_bs->force_share) { in bdrv_child_perm()
2319 QLIST_FOREACH(child, &bs->children, next) { in bdrv_topological_dfs()
2320 list = bdrv_topological_dfs(list, found, child->bs); in bdrv_topological_dfs()
2338 s->child->perm = s->old_perm; in bdrv_child_set_perm_abort()
2339 s->child->shared_perm = s->old_shared_perm; in bdrv_child_set_perm_abort()
2355 .old_perm = c->perm, in bdrv_child_set_perm()
2356 .old_shared_perm = c->shared_perm, in bdrv_child_set_perm()
2359 c->perm = perm; in bdrv_child_set_perm()
2360 c->shared_perm = shared; in bdrv_child_set_perm()
2371 if (bs->drv->bdrv_set_perm) { in bdrv_drv_set_perm_commit()
2374 bs->drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms); in bdrv_drv_set_perm_commit()
2383 if (bs->drv->bdrv_abort_perm_update) { in bdrv_drv_set_perm_abort()
2384 bs->drv->bdrv_abort_perm_update(bs); in bdrv_drv_set_perm_abort()
2402 if (!bs->drv) { in bdrv_drv_set_perm()
2406 if (bs->drv->bdrv_check_perm) { in bdrv_drv_set_perm()
2407 int ret = bs->drv->bdrv_check_perm(bs, perm, shared_perm, errp); in bdrv_drv_set_perm()
2430 bdrv_schedule_unref(s->old_bs); in bdrv_replace_child_commit()
2436 BlockDriverState *new_bs = s->child->bs; in bdrv_replace_child_abort()
2441 /* old_bs reference is transparently moved from @s to @s->child */ in bdrv_replace_child_abort()
2442 if (!s->child->bs) { in bdrv_replace_child_abort()
2452 bdrv_parent_drained_begin_single(s->child); in bdrv_replace_child_abort()
2453 assert(!bdrv_parent_drained_poll_single(s->child)); in bdrv_replace_child_abort()
2455 assert(s->child->quiesced_parent); in bdrv_replace_child_abort()
2456 bdrv_replace_child_noperm(s->child, s->old_bs); in bdrv_replace_child_abort()
2472 * Both @child->bs and @new_bs (if non-NULL) must be drained. @new_bs must be
2486 assert(child->quiesced_parent); in bdrv_replace_child_tran()
2487 assert(!new_bs || new_bs->quiesce_counter); in bdrv_replace_child_tran()
2491 .old_bs = child->bs, in bdrv_replace_child_tran()
2514 BlockDriver *drv = bs->drv; in bdrv_node_refresh_perm()
2522 /* Write permissions never work with read-only images */ in bdrv_node_refresh_perm()
2527 error_setg(errp, "Block node is read-only"); in bdrv_node_refresh_perm()
2529 error_setg(errp, "Read-only block node '%s' cannot support " in bdrv_node_refresh_perm()
2530 "read-write users", bdrv_get_node_name(bs)); in bdrv_node_refresh_perm()
2533 return -EPERM; in bdrv_node_refresh_perm()
2544 if ((bs->total_sectors * BDRV_SECTOR_SIZE) % bs->bl.request_alignment) { in bdrv_node_refresh_perm()
2548 return -EPERM; in bdrv_node_refresh_perm()
2564 if (!drv->bdrv_child_perm) { in bdrv_node_refresh_perm()
2565 assert(QLIST_EMPTY(&bs->children)); in bdrv_node_refresh_perm()
2570 QLIST_FOREACH(c, &bs->children, next) { in bdrv_node_refresh_perm()
2573 bdrv_child_perm(bs, c->bs, c, c->role, q, in bdrv_node_refresh_perm()
2583 * @list is a product of bdrv_topological_dfs() (may be called several times) -
2597 for ( ; list; list = list->next) { in bdrv_do_refresh_perms()
2598 bs = list->data; in bdrv_do_refresh_perms()
2601 return -EINVAL; in bdrv_do_refresh_perms()
2628 for ( ; list; list = list->next) { in bdrv_list_refresh_perms()
2629 refresh_list = bdrv_topological_dfs(refresh_list, found, list->data); in bdrv_list_refresh_perms()
2644 QLIST_FOREACH(c, &bs->parents, next_parent) { in bdrv_get_cumulative_perm()
2645 cumulative_perms |= c->perm; in bdrv_get_cumulative_perm()
2646 cumulative_shared_perms &= c->shared_perm; in bdrv_get_cumulative_perm()
2669 for (p = permissions; p->name; p++) { in bdrv_perm_names()
2670 if (perm & p->perm) { in bdrv_perm_names()
2671 if (result->len > 0) { in bdrv_perm_names()
2674 g_string_append(result, p->name); in bdrv_perm_names()
2720 ret = bdrv_refresh_perms(c->bs, tran, &local_err); in bdrv_child_try_set_perm()
2725 if ((perm & ~c->perm) || (c->shared_perm & ~shared)) { in bdrv_child_try_set_perm()
2751 bdrv_child_perm(bs, c->bs, c, c->role, NULL, in bdrv_child_refresh_perms()
2801 if (bs->open_flags & BDRV_O_INACTIVE) { in bdrv_default_perms_for_cow()
2836 * bs->file always needs to be consistent because of the in bdrv_default_perms_for_storage()
2859 * is split into fixed-size data files). in bdrv_default_perms_for_storage()
2866 * write copied clusters on copy-on-read. in bdrv_default_perms_for_storage()
2881 if (bs->open_flags & BDRV_O_INACTIVE) { in bdrv_default_perms_for_storage()
2932 * If @new_bs is non-NULL, the parent of @child must already be drained through
2938 BlockDriverState *old_bs = child->bs; in bdrv_replace_child_noperm()
2941 assert(!child->frozen); in bdrv_replace_child_noperm()
2945 * child->bs, we need to make sure that its new parent is drained, too. In in bdrv_replace_child_noperm()
2946 * other words, either child->quiesce_parent must already be true or we must in bdrv_replace_child_noperm()
2952 * To keep things simple, we pick the first option (child->quiesce_parent in bdrv_replace_child_noperm()
2963 assert(!new_bs || child->quiesced_parent); in bdrv_replace_child_noperm()
2972 if (child->klass->detach) { in bdrv_replace_child_noperm()
2973 child->klass->detach(child); in bdrv_replace_child_noperm()
2978 child->bs = new_bs; in bdrv_replace_child_noperm()
2981 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent); in bdrv_replace_child_noperm()
2982 if (child->klass->attach) { in bdrv_replace_child_noperm()
2983 child->klass->attach(child); in bdrv_replace_child_noperm()
2992 new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0); in bdrv_replace_child_noperm()
2993 if (!new_bs_quiesce_counter && child->quiesced_parent) { in bdrv_replace_child_noperm()
3001 * The child must be empty (i.e. `child->bs == NULL`) and it must be
3006 assert(!child->bs); in bdrv_child_free()
3010 assert(!child->next.le_prev); /* not in children list */ in bdrv_child_free()
3012 g_free(child->name); in bdrv_child_free()
3025 BlockDriverState *bs = s->child->bs; in bdrv_attach_child_common_abort()
3030 bdrv_replace_child_noperm(s->child, NULL); in bdrv_attach_child_common_abort()
3032 if (bdrv_get_aio_context(bs) != s->old_child_ctx) { in bdrv_attach_child_common_abort()
3033 bdrv_try_change_aio_context_locked(bs, s->old_child_ctx, NULL, in bdrv_attach_child_common_abort()
3037 if (bdrv_child_get_parent_aio_context(s->child) != s->old_parent_ctx) { in bdrv_attach_child_common_abort()
3046 ret = s->child->klass->change_aio_ctx(s->child, s->old_parent_ctx, in bdrv_attach_child_common_abort()
3056 bdrv_child_free(s->child); in bdrv_attach_child_common_abort()
3093 assert(child_class->get_parent_desc); in bdrv_attach_child_common()
3125 if (ret < 0 && child_class->change_aio_ctx) { in bdrv_attach_child_common()
3131 ret_child = child_class->change_aio_ctx(new_child, child_ctx, in bdrv_attach_child_common()
3138 tran_finalize(aio_ctx_tran, ret_child == true ? 0 : -1); in bdrv_attach_child_common()
3204 assert(parent_bs->drv); in bdrv_attach_child_noperm()
3209 child_bs->node_name, child_name, parent_bs->node_name); in bdrv_attach_child_noperm()
3214 child_bs->node_name, child_name, parent_bs->node_name); in bdrv_attach_child_noperm()
3253 ret = -EINVAL; in bdrv_root_attach_child()
3293 ret = -EINVAL; in bdrv_attach_child()
3311 * Callers must ensure that child->frozen is false.
3317 BlockDriverState *child_bs = child->bs; in bdrv_root_unref_child()
3332 * When the parent requiring a non-default AioContext is removed, the in bdrv_root_unref_child()
3351 s->bs->inherits_from = s->old_inherits_from; in bdrv_set_inherits_from_abort()
3369 .old_inherits_from = bs->inherits_from, in bdrv_set_inherits_from()
3375 bs->inherits_from = new_inherits_from; in bdrv_set_inherits_from()
3389 if (child->bs->inherits_from == root) { in bdrv_unset_inherits_from()
3392 * child->bs goes away. in bdrv_unset_inherits_from()
3394 QLIST_FOREACH(c, &root->children, next) { in bdrv_unset_inherits_from()
3395 if (c != child && c->bs == child->bs) { in bdrv_unset_inherits_from()
3400 bdrv_set_inherits_from(child->bs, NULL, tran); in bdrv_unset_inherits_from()
3404 QLIST_FOREACH(c, &child->bs->children, next) { in bdrv_unset_inherits_from()
3410 * Callers must ensure that child->frozen is false.
3431 QLIST_FOREACH(c, &bs->parents, next_parent) { in bdrv_parent_cb_change_media()
3432 if (c->klass->change_media) { in bdrv_parent_cb_change_media()
3433 c->klass->change_media(c, load); in bdrv_parent_cb_change_media()
3438 /* Return true if you can reach parent going through child->inherits_from
3444 child = child->inherits_from; in bdrv_inherits_from_recursive()
3451 * Return the BdrvChildRole for @bs's backing child. bs->backing is
3457 if (bs->drv && bs->drv->is_filter) { in bdrv_backing_role()
3465 * Sets the bs->backing or bs->file link of a BDS. A new reference is created;
3490 BdrvChild *child = is_backing ? parent_bs->backing : parent_bs->file; in bdrv_set_file_or_backing_noperm()
3495 if (!parent_bs->drv) { in bdrv_set_file_or_backing_noperm()
3498 * qcow2 driver to never clear bs->drv and implement format corruption in bdrv_set_file_or_backing_noperm()
3502 return -EINVAL; in bdrv_set_file_or_backing_noperm()
3505 if (child && child->frozen) { in bdrv_set_file_or_backing_noperm()
3507 child->name, parent_bs->node_name, child->bs->node_name); in bdrv_set_file_or_backing_noperm()
3508 return -EPERM; in bdrv_set_file_or_backing_noperm()
3511 if (is_backing && !parent_bs->drv->is_filter && in bdrv_set_file_or_backing_noperm()
3512 !parent_bs->drv->supports_backing) in bdrv_set_file_or_backing_noperm()
3515 "files", parent_bs->drv->format_name, parent_bs->node_name); in bdrv_set_file_or_backing_noperm()
3516 return -EINVAL; in bdrv_set_file_or_backing_noperm()
3519 if (parent_bs->drv->is_filter) { in bdrv_set_file_or_backing_noperm()
3531 return -EINVAL; in bdrv_set_file_or_backing_noperm()
3533 role = child->role; in bdrv_set_file_or_backing_noperm()
3537 assert(child->bs->quiesce_counter); in bdrv_set_file_or_backing_noperm()
3551 return -EINVAL; in bdrv_set_file_or_backing_noperm()
3583 assert(bs->quiesce_counter > 0); in bdrv_set_backing_hd_drained()
3584 if (bs->backing) { in bdrv_set_backing_hd_drained()
3585 assert(bs->backing->bs->quiesce_counter > 0); in bdrv_set_backing_hd_drained()
3641 if (bs->backing != NULL) { in bdrv_open_backing_file()
3651 bs->open_flags &= ~BDRV_O_NO_BACKING; in bdrv_open_backing_file()
3658 * Caution: while qdict_get_try_str() is fine, getting non-string in bdrv_open_backing_file()
3660 * -blockdev or blockdev_add, its members are typed according to in bdrv_open_backing_file()
3661 * the QAPI schema, but when they come from -drive, they're all in bdrv_open_backing_file()
3667 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) { in bdrv_open_backing_file()
3676 * only possible with -drive anyway (otherwise the QAPI in bdrv_open_backing_file()
3678 implicit_backing = !strcmp(bs->auto_backing_file, bs->backing_file); in bdrv_open_backing_file()
3683 ret = -EINVAL; in bdrv_open_backing_file()
3690 if (!bs->drv || !bs->drv->supports_backing) { in bdrv_open_backing_file()
3691 ret = -EINVAL; in bdrv_open_backing_file()
3698 bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) { in bdrv_open_backing_file()
3699 qdict_put_str(options, "driver", bs->backing_format); in bdrv_open_backing_file()
3706 bs->open_flags |= BDRV_O_NO_BACKING; in bdrv_open_backing_file()
3708 ret = -EINVAL; in bdrv_open_backing_file()
3714 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), in bdrv_open_backing_file()
3715 backing_hd->filename); in bdrv_open_backing_file()
3753 * Caution: while qdict_get_try_str() is fine, getting non-string in bdrv_open_child_bs()
3755 * -blockdev or blockdev_add, its members are typed according to in bdrv_open_child_bs()
3756 * the QAPI schema, but when they come from -drive, they're all in bdrv_open_child_bs()
3852 assert(!parent->drv->filtered_child_is_backing); in bdrv_open_file_child()
3853 role = parent->drv->is_filter ? in bdrv_open_file_child()
3859 return -EINVAL; in bdrv_open_file_child()
3879 if (ref->type == QTYPE_QSTRING) { in bdrv_open_blockdev_ref()
3880 reference = ref->u.reference; in bdrv_open_blockdev_ref()
3882 BlockdevOptions *options = &ref->u.definition; in bdrv_open_blockdev_ref()
3883 assert(ref->type == QTYPE_QDICT); in bdrv_open_blockdev_ref()
3931 error_setg_errno(errp, -total_size, "Could not get image size"); in bdrv_append_temp_snapshot()
4048 bs->explicit_options = qdict_clone_shallow(options); in bdrv_open_inherit()
4053 if (parent->drv) { in bdrv_open_inherit()
4054 parent_is_format = parent->drv->is_format; in bdrv_open_inherit()
4057 * parent->drv is not set yet because this node is opened for in bdrv_open_inherit()
4064 bs->inherits_from = parent; in bdrv_open_inherit()
4065 child_class->inherit_options(child_role, parent_is_format, in bdrv_open_inherit()
4067 parent->open_flags, parent->options); in bdrv_open_inherit()
4079 * When @options come from -blockdev or blockdev_add, members are in bdrv_open_inherit()
4081 * -drive, they're all QString. in bdrv_open_inherit()
4094 /* Let bdrv_backing_options() override "read-only" */ in bdrv_open_inherit()
4100 bs->open_flags = flags; in bdrv_open_inherit()
4101 bs->options = options; in bdrv_open_inherit()
4127 qdict_del(bs->explicit_options, "backing"); in bdrv_open_inherit()
4128 qdict_del(bs->options, "backing"); in bdrv_open_inherit()
4162 bs->probed = !drv; in bdrv_open_inherit()
4170 * but we first need to open bs->file for the probing to work, while in bdrv_open_inherit()
4171 * opening bs->file already requires the (mostly) final set of options in bdrv_open_inherit()
4176 * sure to update both bs->options (which has the full effective in bdrv_open_inherit()
4179 qdict_put_str(bs->options, "driver", drv->format_name); in bdrv_open_inherit()
4180 qdict_put_str(options, "driver", drv->format_name); in bdrv_open_inherit()
4187 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->protocol_name); in bdrv_open_inherit()
4212 * from bs->options and bs->explicit_options */ in bdrv_open_inherit()
4213 QLIST_FOREACH(child, &bs->children, next) { in bdrv_open_inherit()
4215 child_key_dot = g_strdup_printf("%s.", child->name); in bdrv_open_inherit()
4216 qdict_extract_subqdict(bs->explicit_options, NULL, child_key_dot); in bdrv_open_inherit()
4217 qdict_extract_subqdict(bs->options, NULL, child_key_dot); in bdrv_open_inherit()
4218 qdict_del(bs->explicit_options, child->name); in bdrv_open_inherit()
4219 qdict_del(bs->options, child->name); in bdrv_open_inherit()
4228 "'%s'", drv->format_name, entry->key); in bdrv_open_inherit()
4232 drv->format_name, entry->key); in bdrv_open_inherit()
4266 qobject_unref(bs->explicit_options); in bdrv_open_inherit()
4267 qobject_unref(bs->options); in bdrv_open_inherit()
4269 bs->options = NULL; in bdrv_open_inherit()
4270 bs->explicit_options = NULL; in bdrv_open_inherit()
4292 /* Return true if the NULL-terminated @list contains @str */
4307 * Check that every option set in @bs->options is also set in
4311 * @bs->drv->mutable_opts are skipped.
4313 * Return 0 on success, otherwise return -EINVAL and set @errp.
4322 "node-name", "discard", "cache.direct", "cache.no-flush", in bdrv_reset_options_allowed()
4323 "read-only", "auto-read-only", "detect-zeroes", NULL in bdrv_reset_options_allowed()
4326 for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) { in bdrv_reset_options_allowed()
4327 if (!qdict_haskey(new_opts, e->key) && in bdrv_reset_options_allowed()
4328 !is_str_in_list(e->key, common_options) && in bdrv_reset_options_allowed()
4329 !is_str_in_list(e->key, bs->drv->mutable_opts)) { in bdrv_reset_options_allowed()
4331 "to its default value", e->key); in bdrv_reset_options_allowed()
4332 return -EINVAL; in bdrv_reset_options_allowed()
4351 QLIST_FOREACH(c, &bs->children, next) { in bdrv_recurse_has_child()
4352 if (bdrv_recurse_has_child(c->bs, child)) { in bdrv_recurse_has_child()
4399 assert(bs->quiesce_counter > 0); in bdrv_reopen_queue_child()
4412 if (bs == bs_entry->state.bs) { in bdrv_reopen_queue_child()
4428 bs_entry->state.explicit_options : in bdrv_reopen_queue_child()
4429 bs->explicit_options); in bdrv_reopen_queue_child()
4439 klass->inherit_options(role, parent_is_format, &flags, options, in bdrv_reopen_queue_child()
4447 old_options = qdict_clone_shallow(bs->options); in bdrv_reopen_queue_child()
4470 qobject_unref(bs_entry->state.options); in bdrv_reopen_queue_child()
4471 qobject_unref(bs_entry->state.explicit_options); in bdrv_reopen_queue_child()
4474 bs_entry->state.bs = bs; in bdrv_reopen_queue_child()
4475 bs_entry->state.options = options; in bdrv_reopen_queue_child()
4476 bs_entry->state.explicit_options = explicit_options; in bdrv_reopen_queue_child()
4477 bs_entry->state.flags = flags; in bdrv_reopen_queue_child()
4486 bs_entry->state.backing_missing = in bdrv_reopen_queue_child()
4491 QLIST_FOREACH(child, &bs->children, next) { in bdrv_reopen_queue_child()
4498 if (child->bs->inherits_from != bs) { in bdrv_reopen_queue_child()
4503 if (qdict_haskey(options, child->name)) { in bdrv_reopen_queue_child()
4504 const char *childref = qdict_get_try_str(options, child->name); in bdrv_reopen_queue_child()
4509 if (g_strcmp0(childref, child->bs->node_name)) { in bdrv_reopen_queue_child()
4519 /* Extract child options ("child-name.*") */ in bdrv_reopen_queue_child()
4520 char *child_key_dot = g_strdup_printf("%s.", child->name); in bdrv_reopen_queue_child()
4526 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, in bdrv_reopen_queue_child()
4527 child->klass, child->role, bs->drv->is_format, in bdrv_reopen_queue_child()
4557 qobject_unref(bs_entry->state.explicit_options); in bdrv_reopen_queue_free()
4558 qobject_unref(bs_entry->state.options); in bdrv_reopen_queue_free()
4589 int ret = -1; in bdrv_reopen_multiple()
4599 ret = bdrv_flush(bs_entry->state.bs); in bdrv_reopen_multiple()
4601 error_setg_errno(errp, -ret, "Error flushing drive"); in bdrv_reopen_multiple()
4607 assert(bs_entry->state.bs->quiesce_counter > 0); in bdrv_reopen_multiple()
4608 ret = bdrv_reopen_prepare(&bs_entry->state, bs_queue, tran, errp); in bdrv_reopen_multiple()
4612 bs_entry->prepared = true; in bdrv_reopen_multiple()
4616 BDRVReopenState *state = &bs_entry->state; in bdrv_reopen_multiple()
4618 refresh_list = g_slist_prepend(refresh_list, state->bs); in bdrv_reopen_multiple()
4619 if (state->old_backing_bs) { in bdrv_reopen_multiple()
4620 refresh_list = g_slist_prepend(refresh_list, state->old_backing_bs); in bdrv_reopen_multiple()
4622 if (state->old_file_bs) { in bdrv_reopen_multiple()
4623 refresh_list = g_slist_prepend(refresh_list, state->old_file_bs); in bdrv_reopen_multiple()
4628 * Note that file-posix driver rely on permission update done during reopen in bdrv_reopen_multiple()
4647 * children are usually goes after parents in reopen-queue, so go from last in bdrv_reopen_multiple()
4651 bdrv_reopen_commit(&bs_entry->state); in bdrv_reopen_multiple()
4659 BlockDriverState *bs = bs_entry->state.bs; in bdrv_reopen_multiple()
4661 if (bs->drv->bdrv_reopen_commit_post) { in bdrv_reopen_multiple()
4662 bs->drv->bdrv_reopen_commit_post(&bs_entry->state); in bdrv_reopen_multiple()
4675 if (bs_entry->prepared) { in bdrv_reopen_multiple()
4676 bdrv_reopen_abort(&bs_entry->state); in bdrv_reopen_multiple()
4712 * reopen_state->options QDict is valid or not.
4717 * reopen_state->bs then return 0.
4721 * If that's the case then reopen_state->replace_backing_bs is set to
4722 * true and reopen_state->new_backing_bs contains a pointer to the new
4730 * @reopen_state->bs can move to a different AioContext in this function.
4740 BlockDriverState *bs = reopen_state->bs; in bdrv_reopen_parse_file_or_backing()
4752 value = qdict_get(reopen_state->options, child_name); in bdrv_reopen_parse_file_or_backing()
4768 ret = -EINVAL; in bdrv_reopen_parse_file_or_backing()
4775 "cycle", str, child_name, bs->node_name); in bdrv_reopen_parse_file_or_backing()
4776 ret = -EINVAL; in bdrv_reopen_parse_file_or_backing()
4788 old_child_bs = is_backing ? child_bs(bs->backing) : child_bs(bs->file); in bdrv_reopen_parse_file_or_backing()
4800 if (old_child_bs->implicit) { in bdrv_reopen_parse_file_or_backing()
4802 child_name, bs->node_name); in bdrv_reopen_parse_file_or_backing()
4803 ret = -EPERM; in bdrv_reopen_parse_file_or_backing()
4808 if (bs->drv->is_filter && !old_child_bs) { in bdrv_reopen_parse_file_or_backing()
4814 "%s child", bs->node_name, bs->drv->format_name, child_name); in bdrv_reopen_parse_file_or_backing()
4815 ret = -EINVAL; in bdrv_reopen_parse_file_or_backing()
4820 reopen_state->old_backing_bs = old_child_bs; in bdrv_reopen_parse_file_or_backing()
4822 reopen_state->old_file_bs = old_child_bs; in bdrv_reopen_parse_file_or_backing()
4827 assert(old_child_bs->quiesce_counter > 0); in bdrv_reopen_parse_file_or_backing()
4858 * Returns 0 on success, non-zero on error. On error errp will be set
4875 int ret = -1; in bdrv_reopen_prepare()
4886 assert(reopen_state->bs->drv != NULL); in bdrv_reopen_prepare()
4888 drv = reopen_state->bs->drv; in bdrv_reopen_prepare()
4891 * entries from reopen_state->options as they are processed, so in bdrv_reopen_prepare()
4893 orig_reopen_opts = qdict_clone_shallow(reopen_state->options); in bdrv_reopen_prepare()
4897 if (!qemu_opts_absorb_qdict(opts, reopen_state->options, errp)) { in bdrv_reopen_prepare()
4898 ret = -EINVAL; in bdrv_reopen_prepare()
4903 * are up-to-date. This time we simply want to remove the options from in bdrv_reopen_prepare()
4905 old_flags = reopen_state->flags; in bdrv_reopen_prepare()
4906 update_flags_from_options(&reopen_state->flags, opts); in bdrv_reopen_prepare()
4907 assert(old_flags == reopen_state->flags); in bdrv_reopen_prepare()
4911 if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) { in bdrv_reopen_prepare()
4913 ret = -EINVAL; in bdrv_reopen_prepare()
4918 reopen_state->detect_zeroes = in bdrv_reopen_prepare()
4919 bdrv_parse_detect_zeroes(opts, reopen_state->flags, &local_err); in bdrv_reopen_prepare()
4922 ret = -EINVAL; in bdrv_reopen_prepare()
4926 /* All other options (including node-name and driver) must be unchanged. in bdrv_reopen_prepare()
4929 qemu_opts_to_qdict(opts, reopen_state->options); in bdrv_reopen_prepare()
4931 /* If we are to stay read-only, do not allow permission change in bdrv_reopen_prepare()
4934 read_only = !(reopen_state->flags & BDRV_O_RDWR); in bdrv_reopen_prepare()
4937 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err); in bdrv_reopen_prepare()
4944 if (drv->bdrv_reopen_prepare) { in bdrv_reopen_prepare()
4946 * If a driver-specific option is missing, it means that we in bdrv_reopen_prepare()
4950 ret = bdrv_reset_options_allowed(reopen_state->bs, in bdrv_reopen_prepare()
4951 reopen_state->options, errp); in bdrv_reopen_prepare()
4956 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err); in bdrv_reopen_prepare()
4962 bdrv_refresh_filename(reopen_state->bs); in bdrv_reopen_prepare()
4965 reopen_state->bs->filename); in bdrv_reopen_prepare()
4974 "does not support reopening files", drv->format_name, in bdrv_reopen_prepare()
4975 bdrv_get_device_or_node_name(reopen_state->bs)); in bdrv_reopen_prepare()
4977 ret = -1; in bdrv_reopen_prepare()
4989 if (drv->supports_backing && reopen_state->backing_missing && in bdrv_reopen_prepare()
4990 (reopen_state->bs->backing || reopen_state->bs->backing_file[0])) { in bdrv_reopen_prepare()
4992 reopen_state->bs->node_name); in bdrv_reopen_prepare()
4994 ret = -EINVAL; in bdrv_reopen_prepare()
5009 qdict_del(reopen_state->options, "backing"); in bdrv_reopen_prepare()
5017 qdict_del(reopen_state->options, "file"); in bdrv_reopen_prepare()
5022 if (qdict_size(reopen_state->options)) { in bdrv_reopen_prepare()
5023 const QDictEntry *entry = qdict_first(reopen_state->options); in bdrv_reopen_prepare()
5028 QObject *new = entry->value; in bdrv_reopen_prepare()
5029 QObject *old = qdict_get(reopen_state->bs->options, entry->key); in bdrv_reopen_prepare()
5035 QLIST_FOREACH(child, &reopen_state->bs->children, next) { in bdrv_reopen_prepare()
5036 if (!strcmp(child->name, entry->key)) { in bdrv_reopen_prepare()
5042 if (!strcmp(child->bs->node_name, in bdrv_reopen_prepare()
5050 * TODO: When using -drive to specify blockdev options, all values in bdrv_reopen_prepare()
5051 * will be strings; however, when using -blockdev, blockdev-add or in bdrv_reopen_prepare()
5052 * filenames using the json:{} pseudo-protocol, they will be in bdrv_reopen_prepare()
5055 * (because you can only specify them through qemu-io; all other in bdrv_reopen_prepare()
5057 * Therefore, when using anything other than -drive to create a BDS, in bdrv_reopen_prepare()
5058 * this cannot detect non-string options as unchanged, because in bdrv_reopen_prepare()
5066 error_setg(errp, "Cannot change the option '%s'", entry->key); in bdrv_reopen_prepare()
5067 ret = -EINVAL; in bdrv_reopen_prepare()
5070 } while ((entry = qdict_next(reopen_state->options, entry))); in bdrv_reopen_prepare()
5075 /* Restore the original reopen_state->options QDict */ in bdrv_reopen_prepare()
5076 qobject_unref(reopen_state->options); in bdrv_reopen_prepare()
5077 reopen_state->options = qobject_ref(orig_reopen_opts); in bdrv_reopen_prepare()
5081 /* drv->bdrv_reopen_prepare() has succeeded, so we need to in bdrv_reopen_prepare()
5082 * call drv->bdrv_reopen_abort() before signaling an error in bdrv_reopen_prepare()
5085 if (drv->bdrv_reopen_abort) { in bdrv_reopen_prepare()
5086 drv->bdrv_reopen_abort(reopen_state); in bdrv_reopen_prepare()
5107 bs = reopen_state->bs; in bdrv_reopen_commit()
5108 drv = bs->drv; in bdrv_reopen_commit()
5113 if (drv->bdrv_reopen_commit) { in bdrv_reopen_commit()
5114 drv->bdrv_reopen_commit(reopen_state); in bdrv_reopen_commit()
5120 qobject_unref(bs->explicit_options); in bdrv_reopen_commit()
5121 qobject_unref(bs->options); in bdrv_reopen_commit()
5122 qobject_ref(reopen_state->explicit_options); in bdrv_reopen_commit()
5123 qobject_ref(reopen_state->options); in bdrv_reopen_commit()
5125 bs->explicit_options = reopen_state->explicit_options; in bdrv_reopen_commit()
5126 bs->options = reopen_state->options; in bdrv_reopen_commit()
5127 bs->open_flags = reopen_state->flags; in bdrv_reopen_commit()
5128 bs->detect_zeroes = reopen_state->detect_zeroes; in bdrv_reopen_commit()
5130 /* Remove child references from bs->options and bs->explicit_options. in bdrv_reopen_commit()
5132 QLIST_FOREACH(child, &bs->children, next) { in bdrv_reopen_commit()
5133 qdict_del(bs->explicit_options, child->name); in bdrv_reopen_commit()
5134 qdict_del(bs->options, child->name); in bdrv_reopen_commit()
5137 qdict_del(bs->explicit_options, "backing"); in bdrv_reopen_commit()
5138 qdict_del(bs->options, "backing"); in bdrv_reopen_commit()
5141 bdrv_refresh_total_sectors(bs, bs->total_sectors); in bdrv_reopen_commit()
5153 drv = reopen_state->bs->drv; in bdrv_reopen_abort()
5157 if (drv->bdrv_reopen_abort) { in bdrv_reopen_abort()
5158 drv->bdrv_reopen_abort(reopen_state); in bdrv_reopen_abort()
5169 assert(!bs->refcnt); in bdrv_close()
5175 if (bs->drv) { in bdrv_close()
5176 if (bs->drv->bdrv_close) { in bdrv_close()
5178 bs->drv->bdrv_close(bs); in bdrv_close()
5180 bs->drv = NULL; in bdrv_close()
5185 QLIST_FOREACH_SAFE(child, &bs->children, next, next) { in bdrv_close()
5189 assert(!bs->backing); in bdrv_close()
5190 assert(!bs->file); in bdrv_close()
5194 g_free(bs->opaque); in bdrv_close()
5195 bs->opaque = NULL; in bdrv_close()
5196 qatomic_set(&bs->copy_on_read, 0); in bdrv_close()
5197 bs->backing_file[0] = '\0'; in bdrv_close()
5198 bs->backing_format[0] = '\0'; in bdrv_close()
5199 bs->total_sectors = 0; in bdrv_close()
5200 bs->encrypted = false; in bdrv_close()
5201 bs->sg = false; in bdrv_close()
5202 qobject_unref(bs->options); in bdrv_close()
5203 qobject_unref(bs->explicit_options); in bdrv_close()
5204 bs->options = NULL; in bdrv_close()
5205 bs->explicit_options = NULL; in bdrv_close()
5206 qobject_unref(bs->full_open_options); in bdrv_close()
5207 bs->full_open_options = NULL; in bdrv_close()
5208 g_free(bs->block_status_cache); in bdrv_close()
5209 bs->block_status_cache = NULL; in bdrv_close()
5212 assert(QLIST_EMPTY(&bs->dirty_bitmaps)); in bdrv_close()
5214 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { in bdrv_close()
5217 QLIST_INIT(&bs->aio_notifiers); in bdrv_close()
5225 if (bs->quiesce_counter) { in bdrv_close()
5251 if (c->klass->stay_at_node) { in should_update_child()
5256 * c->bs by @to would mean to create a loop. in should_update_child()
5261 * guest device -> node A -> further backing chain... in should_update_child()
5269 * guest device -> node A -> further backing chain... in should_update_child()
5272 * replace all pointers to A by pointers to B -- except for the in should_update_child()
5276 * guest device -> node B in should_update_child()
5279 * node A -> further backing chain... in should_update_child()
5281 * In general, when replacing a node A (c->bs) by a node B (@to), in should_update_child()
5289 * if @c is found (by breadth-first search) anywhere in the whole in should_update_child()
5303 QLIST_FOREACH(c2, &v->children, next) { in should_update_child()
5309 if (g_hash_table_contains(found, c2->bs)) { in should_update_child()
5313 g_queue_push_tail(queue, c2->bs); in should_update_child()
5314 g_hash_table_add(found, c2->bs); in should_update_child()
5337 * @child->bs (if non-NULL) must be drained.
5348 if (child->bs) { in bdrv_remove_child()
5349 assert(child->quiesced_parent); in bdrv_remove_child()
5357 * Both @from and @to (if non-NULL) must be drained. @to must be kept drained
5373 assert(from->quiesce_counter); in bdrv_replace_node_noperm()
5374 assert(to->quiesce_counter); in bdrv_replace_node_noperm()
5376 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) { in bdrv_replace_node_noperm()
5377 assert(c->bs == from); in bdrv_replace_node_noperm()
5383 c->name, from->node_name); in bdrv_replace_node_noperm()
5384 return -EINVAL; in bdrv_replace_node_noperm()
5386 if (c->frozen) { in bdrv_replace_node_noperm()
5388 c->name, from->node_name); in bdrv_replace_node_noperm()
5389 return -EPERM; in bdrv_replace_node_noperm()
5402 * if it creates a parent-child relation loop or if parent is block-job.
5408 * case backing link of the cow-parent of @to is removed.
5421 assert(from->quiesce_counter); in bdrv_replace_node_common()
5422 assert(to->quiesce_counter); in bdrv_replace_node_common()
5439 * permissions based on new graph. If we fail, we'll roll-back the in bdrv_replace_node_common()
5515 assert(!bs_new->backing); in bdrv_append()
5525 ret = -EINVAL; in bdrv_append()
5552 BlockDriverState *old_bs = child->bs; in bdrv_replace_child_bs()
5581 assert(!bs->refcnt); in bdrv_delete()
5585 if (bs->node_name[0] != '\0') { in bdrv_delete()
5592 qemu_mutex_destroy(&bs->reqs_lock); in bdrv_delete()
5631 node_name = qdict_get_try_str(options, "node-name"); in bdrv_insert_node()
5676 * free of errors) or -errno when an internal error occurred. The results of the
5684 if (bs->drv == NULL) { in bdrv_co_check()
5685 return -ENOMEDIUM; in bdrv_co_check()
5687 if (bs->drv->bdrv_co_check == NULL) { in bdrv_co_check()
5688 return -ENOTSUP; in bdrv_co_check()
5692 return bs->drv->bdrv_co_check(bs, res, fix); in bdrv_co_check()
5697 * 0 - success
5698 * -EINVAL - backing format specified, but no file
5699 * -ENOSPC - can't update the backing file because no space is left in the
5701 * -ENOTSUP - format driver doesn't support changing the backing file
5707 BlockDriver *drv = bs->drv; in bdrv_co_change_backing_file()
5713 return -ENOMEDIUM; in bdrv_co_change_backing_file()
5718 return -EINVAL; in bdrv_co_change_backing_file()
5722 return -EINVAL; in bdrv_co_change_backing_file()
5725 if (drv->bdrv_co_change_backing_file != NULL) { in bdrv_co_change_backing_file()
5726 ret = drv->bdrv_co_change_backing_file(bs, backing_file, backing_fmt); in bdrv_co_change_backing_file()
5728 ret = -ENOTSUP; in bdrv_co_change_backing_file()
5732 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); in bdrv_co_change_backing_file()
5733 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); in bdrv_co_change_backing_file()
5734 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), in bdrv_co_change_backing_file()
5741 * Finds the first non-filter node above bs in the chain between
5795 if (child && child->frozen) { in bdrv_is_backing_chain_frozen()
5797 child->name, i->node_name, child->bs->node_name); in bdrv_is_backing_chain_frozen()
5821 return -EPERM; in bdrv_freeze_backing_chain()
5826 if (child && child->bs->never_freeze) { in bdrv_freeze_backing_chain()
5828 child->name, child->bs->node_name); in bdrv_freeze_backing_chain()
5829 return -EPERM; in bdrv_freeze_backing_chain()
5836 child->frozen = true; in bdrv_freeze_backing_chain()
5859 assert(child->frozen); in bdrv_unfreeze_backing_chain()
5860 child->frozen = false; in bdrv_unfreeze_backing_chain()
5873 * bottom <- base <- intermediate <- top <- active
5877 * bottom <- base <- active
5881 * base <- intermediate <- top <- active
5885 * base <- active
5887 * If backing_file_str is non-NULL, it will be used when modifying top's
5902 int ret = -EIO; in bdrv_drop_intermediate()
5912 if (!top->drv || !base->drv) { in bdrv_drop_intermediate()
5922 * base->inherits_from to top->inherits_from after 'top' and all in bdrv_drop_intermediate()
5929 /* success - we can delete the intermediate states, and link top->base */ in bdrv_drop_intermediate()
5932 backing_file_str = base->filename; in bdrv_drop_intermediate()
5935 QLIST_FOREACH(c, &top->parents, next_parent) { in bdrv_drop_intermediate()
5946 * test-bdrv-drain. test_drop_intermediate_poll() test-case will crash. in bdrv_drop_intermediate()
5957 for (p = updated_children; p; p = p->next) { in bdrv_drop_intermediate()
5958 c = p->data; in bdrv_drop_intermediate()
5960 if (c->klass->update_filename) { in bdrv_drop_intermediate()
5961 ret = c->klass->update_filename(c, base, backing_file_str, in bdrv_drop_intermediate()
5970 * Note, that c->klass->update_filename may lead to permission in bdrv_drop_intermediate()
5981 base->inherits_from = explicit_top->inherits_from; in bdrv_drop_intermediate()
5997 * sums the size of all data-bearing children. (This excludes backing
6006 QLIST_FOREACH(child, &bs->children, next) { in bdrv_sum_allocated_file_size()
6007 if (child->role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA | in bdrv_sum_allocated_file_size()
6010 child_size = bdrv_co_get_allocated_file_size(child->bs); in bdrv_sum_allocated_file_size()
6027 BlockDriver *drv = bs->drv; in bdrv_co_get_allocated_file_size()
6032 return -ENOMEDIUM; in bdrv_co_get_allocated_file_size()
6034 if (drv->bdrv_co_get_allocated_file_size) { in bdrv_co_get_allocated_file_size()
6035 return drv->bdrv_co_get_allocated_file_size(bs); in bdrv_co_get_allocated_file_size()
6038 if (drv->protocol_name) { in bdrv_co_get_allocated_file_size()
6040 * Protocol drivers default to -ENOTSUP (most of their data is in bdrv_co_get_allocated_file_size()
6044 return -ENOTSUP; in bdrv_co_get_allocated_file_size()
6045 } else if (drv->is_filter) { in bdrv_co_get_allocated_file_size()
6081 if (!drv->bdrv_measure) { in bdrv_measure()
6083 drv->format_name); in bdrv_measure()
6087 return drv->bdrv_measure(opts, in_bs, errp); in bdrv_measure()
6091 * Return number of sectors on success, -errno on error.
6095 BlockDriver *drv = bs->drv; in bdrv_co_nb_sectors()
6100 return -ENOMEDIUM; in bdrv_co_nb_sectors()
6102 if (bs->bl.has_variable_length) { in bdrv_co_nb_sectors()
6103 int ret = bdrv_co_refresh_total_sectors(bs, bs->total_sectors); in bdrv_co_nb_sectors()
6108 return bs->total_sectors; in bdrv_co_nb_sectors()
6117 BlockDriver *drv = bs->drv; in bdrv_nb_sectors()
6121 return -ENOMEDIUM; in bdrv_nb_sectors()
6123 if (bs->bl.has_variable_length) { in bdrv_nb_sectors()
6124 int ret = bdrv_refresh_total_sectors(bs, bs->total_sectors); in bdrv_nb_sectors()
6130 return bs->total_sectors; in bdrv_nb_sectors()
6134 * Return length in bytes on success, -errno on error.
6148 return -EFBIG; in bdrv_co_getlength()
6156 return bs->sg; in bdrv_is_sg()
6167 if (!bs->drv || !block_driver_can_compress(bs->drv)) { in bdrv_supports_compressed_writes()
6186 return bs->drv ? bs->drv->format_name : NULL; in bdrv_get_format_name()
6205 if (drv->format_name) { in bdrv_iterate_format()
6214 found = !strcmp(formats[--i], drv->format_name); in bdrv_iterate_format()
6219 formats[count++] = drv->format_name; in bdrv_iterate_format()
6237 found = !strcmp(formats[--j], format_name); in bdrv_iterate_format()
6265 if (!strcmp(node_name, bs->node_name)) { in bdrv_find_node()
6304 gr->graph = g_new0(XDbgBlockGraph, 1); in xdbg_graph_new()
6305 gr->graph_nodes = g_hash_table_new(NULL, NULL); in xdbg_graph_new()
6312 XDbgBlockGraph *graph = gr->graph; in xdbg_graph_finalize()
6314 g_hash_table_destroy(gr->graph_nodes); in xdbg_graph_finalize()
6322 uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node); in xdbg_graph_node_num()
6329 * Start counting from 1, not 0, because 0 interferes with not-found (NULL) in xdbg_graph_node_num()
6332 ret = g_hash_table_size(gr->graph_nodes) + 1; in xdbg_graph_node_num()
6333 g_hash_table_insert(gr->graph_nodes, node, (void *)ret); in xdbg_graph_node_num()
6345 n->id = xdbg_graph_node_num(gr, node); in xdbg_graph_add_node()
6346 n->type = type; in xdbg_graph_add_node()
6347 n->name = g_strdup(name); in xdbg_graph_add_node()
6349 QAPI_LIST_PREPEND(gr->graph->nodes, n); in xdbg_graph_add_node()
6361 edge->parent = xdbg_graph_node_num(gr, parent); in xdbg_graph_add_edge()
6362 edge->child = xdbg_graph_node_num(gr, child->bs); in xdbg_graph_add_edge()
6363 edge->name = g_strdup(child->name); in xdbg_graph_add_edge()
6368 if (flag & child->perm) { in xdbg_graph_add_edge()
6369 QAPI_LIST_PREPEND(edge->perm, qapi_perm); in xdbg_graph_add_edge()
6371 if (flag & child->shared_perm) { in xdbg_graph_add_edge()
6372 QAPI_LIST_PREPEND(edge->shared_perm, qapi_perm); in xdbg_graph_add_edge()
6376 QAPI_LIST_PREPEND(gr->graph->edges, edge); in xdbg_graph_add_edge()
6411 job->job.id); in bdrv_get_xdbg_block_graph()
6412 for (el = job->nodes; el; el = el->next) { in bdrv_get_xdbg_block_graph()
6413 xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data); in bdrv_get_xdbg_block_graph()
6420 bs->node_name); in bdrv_get_xdbg_block_graph()
6421 QLIST_FOREACH(child, &bs->children, next) { in bdrv_get_xdbg_block_graph()
6459 error_setg(errp, "Cannot find device=\'%s\' nor node-name=\'%s\'", in bdrv_lookup_bs()
6500 return bs->node_name; in bdrv_get_node_name()
6510 QLIST_FOREACH(c, &bs->parents, next_parent) { in bdrv_get_parent_name()
6511 if (c->klass->get_name) { in bdrv_get_parent_name()
6512 name = c->klass->get_name(c); in bdrv_get_parent_name()
6522 /* TODO check what callers really want: bs->node_name or blk_name() */
6532 * absent, then this returns an empty (non-null) string. */
6536 return bdrv_get_parent_name(bs) ?: bs->node_name; in bdrv_get_device_or_node_name()
6542 return bs->open_flags; in bdrv_get_flags()
6556 if (!bs->drv) { in bdrv_has_zero_init()
6565 if (bs->drv->bdrv_has_zero_init) { in bdrv_has_zero_init()
6566 return bs->drv->bdrv_has_zero_init(bs); in bdrv_has_zero_init()
6581 if (!(bs->open_flags & BDRV_O_UNMAP)) { in bdrv_can_write_zeroes_with_unmap()
6585 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP; in bdrv_can_write_zeroes_with_unmap()
6592 pstrcpy(filename, filename_size, bs->backing_file); in bdrv_get_backing_filename()
6598 BlockDriver *drv = bs->drv; in bdrv_co_get_info()
6602 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */ in bdrv_co_get_info()
6604 return -ENOMEDIUM; in bdrv_co_get_info()
6606 if (!drv->bdrv_co_get_info) { in bdrv_co_get_info()
6611 return -ENOTSUP; in bdrv_co_get_info()
6614 ret = drv->bdrv_co_get_info(bs, bdi); in bdrv_co_get_info()
6615 if (bdi->subcluster_size == 0) { in bdrv_co_get_info()
6620 bdi->subcluster_size = bdi->cluster_size; in bdrv_co_get_info()
6626 if (bdi->cluster_size > BDRV_MAX_ALIGNMENT) { in bdrv_co_get_info()
6627 return -EINVAL; in bdrv_co_get_info()
6636 BlockDriver *drv = bs->drv; in bdrv_get_specific_info()
6638 if (drv && drv->bdrv_get_specific_info) { in bdrv_get_specific_info()
6639 return drv->bdrv_get_specific_info(bs, errp); in bdrv_get_specific_info()
6646 BlockDriver *drv = bs->drv; in bdrv_get_specific_stats()
6648 if (!drv || !drv->bdrv_get_specific_stats) { in bdrv_get_specific_stats()
6651 return drv->bdrv_get_specific_stats(bs); in bdrv_get_specific_stats()
6659 if (!bs || !bs->drv || !bs->drv->bdrv_co_debug_event) { in bdrv_co_debug_event()
6663 bs->drv->bdrv_co_debug_event(bs, event); in bdrv_co_debug_event()
6670 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { in bdrv_find_debug_node()
6674 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) { in bdrv_find_debug_node()
6675 assert(bs->drv->bdrv_debug_remove_breakpoint); in bdrv_find_debug_node()
6690 return bs->drv->bdrv_debug_breakpoint(bs, event, tag); in bdrv_debug_breakpoint()
6693 return -ENOTSUP; in bdrv_debug_breakpoint()
6703 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag); in bdrv_debug_remove_breakpoint()
6706 return -ENOTSUP; in bdrv_debug_remove_breakpoint()
6714 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { in bdrv_debug_resume()
6718 if (bs && bs->drv && bs->drv->bdrv_debug_resume) { in bdrv_debug_resume()
6719 return bs->drv->bdrv_debug_resume(bs, tag); in bdrv_debug_resume()
6722 return -ENOTSUP; in bdrv_debug_resume()
6730 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { in bdrv_debug_is_suspended()
6734 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) { in bdrv_debug_is_suspended()
6735 return bs->drv->bdrv_debug_is_suspended(bs, tag); in bdrv_debug_is_suspended()
6742 * relative, it must be relative to the chain. So, passing in bs->filename
6760 if (!bs || !bs->drv || !backing_file) { in bdrv_find_backing_image()
6797 if (strcmp(backing_file, bs_below->filename) == 0) { in bdrv_find_backing_image()
6801 } else if (is_protocol || path_has_protocol(curr_bs->backing_file)) { in bdrv_find_backing_image()
6808 if (strcmp(backing_file, curr_bs->backing_file) == 0) { in bdrv_find_backing_image()
6871 return bs->open_flags & BDRV_O_INACTIVE; in bdrv_is_inactive()
6884 if (!bs->drv) { in bdrv_activate()
6885 return -ENOMEDIUM; in bdrv_activate()
6888 QLIST_FOREACH(child, &bs->children, next) { in bdrv_activate()
6889 bdrv_activate(child->bs, &local_err); in bdrv_activate()
6892 return -EINVAL; in bdrv_activate()
6909 if (bs->open_flags & BDRV_O_INACTIVE) { in bdrv_activate()
6910 bs->open_flags &= ~BDRV_O_INACTIVE; in bdrv_activate()
6913 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_activate()
6919 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_activate()
6927 ret = bdrv_refresh_total_sectors(bs, bs->total_sectors); in bdrv_activate()
6929 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_activate()
6930 error_setg_errno(errp, -ret, "Could not refresh total sector count"); in bdrv_activate()
6935 QLIST_FOREACH(parent, &bs->parents, next_parent) { in bdrv_activate()
6936 if (parent->klass->activate) { in bdrv_activate()
6937 parent->klass->activate(parent, &local_err); in bdrv_activate()
6939 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_activate()
6941 return -EINVAL; in bdrv_activate()
6954 assert(!(bs->open_flags & BDRV_O_INACTIVE)); in bdrv_co_invalidate_cache()
6957 if (bs->drv->bdrv_co_invalidate_cache) { in bdrv_co_invalidate_cache()
6958 bs->drv->bdrv_co_invalidate_cache(bs, &local_err); in bdrv_co_invalidate_cache()
6961 return -EINVAL; in bdrv_co_invalidate_cache()
6993 QLIST_FOREACH(parent, &bs->parents, next_parent) { in bdrv_has_bds_parent()
6994 if (parent->klass->parent_is_bds) { in bdrv_has_bds_parent()
6995 BlockDriverState *parent_bs = parent->opaque; in bdrv_has_bds_parent()
6996 if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) { in bdrv_has_bds_parent()
7014 assert(bs->quiesce_counter > 0); in bdrv_inactivate_recurse()
7016 if (!bs->drv) { in bdrv_inactivate_recurse()
7017 return -ENOMEDIUM; in bdrv_inactivate_recurse()
7030 if (bs->open_flags & BDRV_O_INACTIVE) { in bdrv_inactivate_recurse()
7036 if (bs->drv->bdrv_inactivate) { in bdrv_inactivate_recurse()
7037 ret = bs->drv->bdrv_inactivate(bs); in bdrv_inactivate_recurse()
7043 QLIST_FOREACH(parent, &bs->parents, next_parent) { in bdrv_inactivate_recurse()
7044 if (parent->klass->inactivate) { in bdrv_inactivate_recurse()
7045 ret = parent->klass->inactivate(parent); in bdrv_inactivate_recurse()
7056 return -EPERM; in bdrv_inactivate_recurse()
7059 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_inactivate_recurse()
7069 QLIST_FOREACH(child, &bs->children, next) { in bdrv_inactivate_recurse()
7070 ret = bdrv_inactivate_recurse(child->bs, false); in bdrv_inactivate_recurse()
7090 ret = -EPERM; in bdrv_inactivate()
7096 error_setg_errno(errp, -ret, "Failed to inactivate node"); in bdrv_inactivate()
7145 BlockDriver *drv = bs->drv; in bdrv_co_is_inserted()
7153 if (drv->bdrv_co_is_inserted) { in bdrv_co_is_inserted()
7154 return drv->bdrv_co_is_inserted(bs); in bdrv_co_is_inserted()
7156 QLIST_FOREACH(child, &bs->children, next) { in bdrv_co_is_inserted()
7157 if (!bdrv_co_is_inserted(child->bs)) { in bdrv_co_is_inserted()
7169 BlockDriver *drv = bs->drv; in bdrv_co_eject()
7173 if (drv && drv->bdrv_co_eject) { in bdrv_co_eject()
7174 drv->bdrv_co_eject(bs, eject_flag); in bdrv_co_eject()
7184 BlockDriver *drv = bs->drv; in bdrv_co_lock_medium()
7189 if (drv && drv->bdrv_co_lock_medium) { in bdrv_co_lock_medium()
7190 drv->bdrv_co_lock_medium(bs, locked); in bdrv_co_lock_medium()
7198 bs->refcnt++; in bdrv_ref()
7210 assert(bs->refcnt > 0); in bdrv_unref()
7211 if (--bs->refcnt == 0) { in bdrv_unref()
7250 if (!QLIST_EMPTY(&bs->op_blockers[op])) { in bdrv_op_is_blocked()
7251 blocker = QLIST_FIRST(&bs->op_blockers[op]); in bdrv_op_is_blocked()
7252 error_propagate_prepend(errp, error_copy(blocker->reason), in bdrv_op_is_blocked()
7267 blocker->reason = reason; in bdrv_op_block()
7268 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); in bdrv_op_block()
7276 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { in bdrv_op_unblock()
7277 if (blocker->reason == reason) { in bdrv_op_unblock()
7307 if (!QLIST_EMPTY(&bs->op_blockers[i])) { in bdrv_op_blocker_is_empty()
7341 if (!drv->create_opts) { in bdrv_img_create()
7343 drv->format_name); in bdrv_img_create()
7347 if (!proto_drv->create_opts) { in bdrv_img_create()
7349 proto_drv->format_name); in bdrv_img_create()
7354 create_opts = qemu_opts_append(create_opts, drv->create_opts); in bdrv_img_create()
7355 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); in bdrv_img_create()
7359 /* Parse -o options */ in bdrv_img_create()
7368 } else if (img_size != UINT64_C(-1)) { in bdrv_img_create()
7447 bs->drv->format_name); in bdrv_img_create()
7450 if (size == -1) { in bdrv_img_create()
7454 error_setg_errno(errp, -size, "Could not get size of '%s'", in bdrv_img_create()
7471 if (size == -1 && in bdrv_img_create()
7473 qemu_opt_get_bool(opts, "detached-header", false))) { in bdrv_img_create()
7487 if (ret == -EFBIG) { in bdrv_img_create()
7510 return bs ? bs->aio_context : qemu_get_aio_context(); in bdrv_get_aio_context()
7521 * Increase bs->in_flight to ensure that this operation is completed before in bdrv_co_enter()
7549 assert(!bs->walking_aio_notifiers); in bdrv_detach_aio_context()
7551 bs->walking_aio_notifiers = true; in bdrv_detach_aio_context()
7552 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) { in bdrv_detach_aio_context()
7553 if (baf->deleted) { in bdrv_detach_aio_context()
7556 baf->detach_aio_context(baf->opaque); in bdrv_detach_aio_context()
7559 /* Never mind iterating again to check for ->deleted. bdrv_close() will in bdrv_detach_aio_context()
7562 bs->walking_aio_notifiers = false; in bdrv_detach_aio_context()
7564 if (bs->drv && bs->drv->bdrv_detach_aio_context) { in bdrv_detach_aio_context()
7565 bs->drv->bdrv_detach_aio_context(bs); in bdrv_detach_aio_context()
7568 bs->aio_context = NULL; in bdrv_detach_aio_context()
7577 bs->aio_context = new_context; in bdrv_attach_aio_context()
7579 if (bs->drv && bs->drv->bdrv_attach_aio_context) { in bdrv_attach_aio_context()
7580 bs->drv->bdrv_attach_aio_context(bs, new_context); in bdrv_attach_aio_context()
7583 assert(!bs->walking_aio_notifiers); in bdrv_attach_aio_context()
7584 bs->walking_aio_notifiers = true; in bdrv_attach_aio_context()
7585 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) { in bdrv_attach_aio_context()
7586 if (ban->deleted) { in bdrv_attach_aio_context()
7589 ban->attached_aio_context(new_context, ban->opaque); in bdrv_attach_aio_context()
7592 bs->walking_aio_notifiers = false; in bdrv_attach_aio_context()
7626 if (!c->klass->change_aio_ctx) { in bdrv_parent_change_aio_context()
7632 if (!c->klass->change_aio_ctx(c, ctx, visited, tran, errp)) { in bdrv_parent_change_aio_context()
7640 * Changes the AioContext of @c->bs to @ctx and recursively for all its children
7659 return bdrv_change_aio_context(c->bs, ctx, visited, tran, errp); in bdrv_child_change_aio_context()
7672 BlockDriverState *bs = (BlockDriverState *) state->bs; in bdrv_set_aio_context_commit()
7673 AioContext *new_context = state->new_ctx; in bdrv_set_aio_context_commit()
7708 QLIST_FOREACH(c, &bs->parents, next_parent) { in bdrv_change_aio_context()
7714 QLIST_FOREACH(c, &bs->children, next) { in bdrv_change_aio_context()
7726 assert(bs->quiesce_counter > 0); in bdrv_change_aio_context()
7776 return -EPERM; in bdrv_try_change_aio_context_locked()
7818 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list); in bdrv_add_aio_context_notifier()
7830 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { in bdrv_remove_aio_context_notifier()
7831 if (ban->attached_aio_context == attached_aio_context && in bdrv_remove_aio_context_notifier()
7832 ban->detach_aio_context == detach_aio_context && in bdrv_remove_aio_context_notifier()
7833 ban->opaque == opaque && in bdrv_remove_aio_context_notifier()
7834 ban->deleted == false) in bdrv_remove_aio_context_notifier()
7836 if (bs->walking_aio_notifiers) { in bdrv_remove_aio_context_notifier()
7837 ban->deleted = true; in bdrv_remove_aio_context_notifier()
7854 if (!bs->drv) { in bdrv_amend_options()
7856 return -ENOMEDIUM; in bdrv_amend_options()
7858 if (!bs->drv->bdrv_amend_options) { in bdrv_amend_options()
7860 bs->drv->format_name); in bdrv_amend_options()
7861 return -ENOTSUP; in bdrv_amend_options()
7863 return bs->drv->bdrv_amend_options(bs, opts, status_cb, in bdrv_amend_options()
7886 if (!bs || !bs->drv) { in bdrv_recurse_can_replace()
7895 if (bs->drv->bdrv_recurse_can_replace) { in bdrv_recurse_can_replace()
7896 return bs->drv->bdrv_recurse_can_replace(bs, to_replace); in bdrv_recurse_can_replace()
7928 error_setg(errp, "Failed to find node with node-name='%s'", node_name); in check_to_replace_node()
7945 node_name, parent_bs->node_name); in check_to_replace_node()
7956 * "read-zeroes" options are strong, but its "latency-ns" option is
7974 if (curopt == &global_options[ARRAY_SIZE(global_options) - 1] && bs->drv) { in strong_options()
7975 curopt = bs->drv->strong_runtime_opts; in strong_options()
7982 * Copies all strong runtime options from bs->options to the given
7986 * Returns true iff any strong option was present in bs->options (and
7997 if (!bs->drv) { in append_strong_runtime_options()
8005 if ((*option_name)[strlen(*option_name) - 1] != '.') { in append_strong_runtime_options()
8006 QObject *entry = qdict_get(bs->options, *option_name); in append_strong_runtime_options()
8015 for (entry = qdict_first(bs->options); entry; in append_strong_runtime_options()
8016 entry = qdict_next(bs->options, entry)) in append_strong_runtime_options()
8038 qdict_put_str(d, "driver", bs->drv->format_name); in append_strong_runtime_options()
8046 * would result in exactly bs->backing. */
8050 if (bs->backing) { in bdrv_backing_overridden()
8051 return strcmp(bs->auto_backing_file, in bdrv_backing_overridden()
8052 bs->backing->bs->filename); in bdrv_backing_overridden()
8056 return bs->auto_backing_file[0] != '\0'; in bdrv_backing_overridden()
8061 * - exact_filename: A filename which may be used for opening a block device
8065 * - full_open_options: Options which, when given when opening a block device
8068 * - filename: If exact_filename is set, it is copied here. Otherwise,
8074 BlockDriver *drv = bs->drv; in bdrv_refresh_filename()
8090 QLIST_FOREACH(child, &bs->children, next) { in bdrv_refresh_filename()
8091 bdrv_refresh_filename(child->bs); in bdrv_refresh_filename()
8094 if (bs->implicit) { in bdrv_refresh_filename()
8096 child = QLIST_FIRST(&bs->children); in bdrv_refresh_filename()
8099 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), in bdrv_refresh_filename()
8100 child->bs->exact_filename); in bdrv_refresh_filename()
8101 pstrcpy(bs->filename, sizeof(bs->filename), child->bs->filename); in bdrv_refresh_filename()
8103 qobject_unref(bs->full_open_options); in bdrv_refresh_filename()
8104 bs->full_open_options = qobject_ref(child->bs->full_open_options); in bdrv_refresh_filename()
8111 if (bs->open_flags & BDRV_O_NO_IO) { in bdrv_refresh_filename()
8113 * Therefore, in such a case (primarily qemu-img), we can in bdrv_refresh_filename()
8124 if (drv->bdrv_gather_child_options) { in bdrv_refresh_filename()
8127 drv->bdrv_gather_child_options(bs, opts, backing_overridden); in bdrv_refresh_filename()
8129 QLIST_FOREACH(child, &bs->children, next) { in bdrv_refresh_filename()
8130 if (child == bs->backing && !backing_overridden) { in bdrv_refresh_filename()
8135 qdict_put(opts, child->name, in bdrv_refresh_filename()
8136 qobject_ref(child->bs->full_open_options)); in bdrv_refresh_filename()
8139 if (backing_overridden && !bs->backing) { in bdrv_refresh_filename()
8145 qobject_unref(bs->full_open_options); in bdrv_refresh_filename()
8146 bs->full_open_options = opts; in bdrv_refresh_filename()
8150 if (drv->bdrv_refresh_filename) { in bdrv_refresh_filename()
8153 bs->exact_filename[0] = '\0'; in bdrv_refresh_filename()
8155 drv->bdrv_refresh_filename(bs); in bdrv_refresh_filename()
8159 * file -- this only works for format nodes (filter nodes in bdrv_refresh_filename()
8166 bs->exact_filename[0] = '\0'; in bdrv_refresh_filename()
8170 * - it has a filename, in bdrv_refresh_filename()
8171 * - the current BDS is not a filter, in bdrv_refresh_filename()
8172 * - the file is a protocol BDS, and in bdrv_refresh_filename()
8173 * - opening that file (as this BDS's format) will automatically create in bdrv_refresh_filename()
8175 * - the user did not significantly change this BDS's behavior with in bdrv_refresh_filename()
8177 * - no non-file child of this BDS has been overridden by the user in bdrv_refresh_filename()
8180 if (primary_child_bs->exact_filename[0] && in bdrv_refresh_filename()
8181 primary_child_bs->drv->protocol_name && in bdrv_refresh_filename()
8182 !drv->is_filter && !generate_json_filename) in bdrv_refresh_filename()
8184 strcpy(bs->exact_filename, primary_child_bs->exact_filename); in bdrv_refresh_filename()
8188 if (bs->exact_filename[0]) { in bdrv_refresh_filename()
8189 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename); in bdrv_refresh_filename()
8191 GString *json = qobject_to_json(QOBJECT(bs->full_open_options)); in bdrv_refresh_filename()
8192 if (snprintf(bs->filename, sizeof(bs->filename), "json:%s", in bdrv_refresh_filename()
8193 json->str) >= sizeof(bs->filename)) { in bdrv_refresh_filename()
8195 strcpy(bs->filename + sizeof(bs->filename) - 4, "..."); in bdrv_refresh_filename()
8203 BlockDriver *drv = bs->drv; in bdrv_dirname()
8209 error_setg(errp, "Node '%s' is ejected", bs->node_name); in bdrv_dirname()
8213 if (drv->bdrv_dirname) { in bdrv_dirname()
8214 return drv->bdrv_dirname(bs, errp); in bdrv_dirname()
8223 if (bs->exact_filename[0] != '\0') { in bdrv_dirname()
8224 return path_combine(bs->exact_filename, ""); in bdrv_dirname()
8228 drv->format_name); in bdrv_dirname()
8242 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) { in bdrv_add_child()
8249 * Non-zoned block drivers do not follow zoned storage constraints in bdrv_add_child()
8250 * (i.e. sequential writes to zones). Refuse mixing zoned and non-zoned in bdrv_add_child()
8253 if (!parent_bs->drv->supports_zoned_children && in bdrv_add_child()
8254 child_bs->bl.zoned == BLK_Z_HM) { in bdrv_add_child()
8256 * The host-aware model allows zoned storage constraints and random in bdrv_add_child()
8257 * write. Allow mixing host-aware and non-zoned drivers. Using in bdrv_add_child()
8258 * host-aware device as a regular device. in bdrv_add_child()
8261 child_bs->bl.zoned == BLK_Z_HM ? "zoned" : "non-zoned", in bdrv_add_child()
8262 parent_bs->drv->supports_zoned_children ? in bdrv_add_child()
8267 if (!QLIST_EMPTY(&child_bs->parents)) { in bdrv_add_child()
8269 child_bs->node_name); in bdrv_add_child()
8273 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp); in bdrv_add_child()
8287 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) { in bdrv_del_child()
8293 QLIST_FOREACH(tmp, &parent_bs->children, next) { in bdrv_del_child()
8302 bdrv_get_device_or_node_name(child->bs)); in bdrv_del_child()
8306 parent_bs->drv->bdrv_del_child(parent_bs, child, errp); in bdrv_del_child()
8311 BlockDriver *drv = c->bs->drv; in bdrv_make_empty()
8315 assert(c->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)); in bdrv_make_empty()
8317 if (!drv->bdrv_make_empty) { in bdrv_make_empty()
8319 drv->format_name); in bdrv_make_empty()
8320 return -ENOTSUP; in bdrv_make_empty()
8323 ret = drv->bdrv_make_empty(c->bs); in bdrv_make_empty()
8325 error_setg_errno(errp, -ret, "Failed to empty %s", in bdrv_make_empty()
8326 c->bs->filename); in bdrv_make_empty()
8341 if (!bs || !bs->drv) { in bdrv_cow_child()
8345 if (bs->drv->is_filter) { in bdrv_cow_child()
8349 if (!bs->backing) { in bdrv_cow_child()
8353 assert(bs->backing->role & BDRV_CHILD_COW); in bdrv_cow_child()
8354 return bs->backing; in bdrv_cow_child()
8366 if (!bs || !bs->drv) { in bdrv_filter_child()
8370 if (!bs->drv->is_filter) { in bdrv_filter_child()
8375 assert(!(bs->backing && bs->file)); in bdrv_filter_child()
8377 c = bs->backing ?: bs->file; in bdrv_filter_child()
8382 assert(c->role & BDRV_CHILD_FILTERED); in bdrv_filter_child()
8388 * whichever is non-NULL.
8419 QLIST_FOREACH(c, &bs->children, next) { in bdrv_primary_child()
8420 if (c->role & BDRV_CHILD_PRIMARY) { in bdrv_primary_child()
8438 while (!(stop_on_explicit_filter && !bs->implicit)) { in bdrv_do_skip_filters()
8447 assert(!bs->drv || !bs->drv->is_filter); in bdrv_do_skip_filters()
8450 bs = c->bs; in bdrv_do_skip_filters()
8453 * Note that this treats nodes with bs->drv == NULL as not being in bdrv_do_skip_filters()
8454 * filters (bs->drv == NULL should be replaced by something else in bdrv_do_skip_filters()
8457 * always return a non-NULL value (given a non-NULL @bs). in bdrv_do_skip_filters()
8485 * For a backing chain, return the first non-filter backing image of
8486 * the first non-filter image.
8496 * block-status data region.
8498 * If so, and @pnum is not NULL, set *pnum to `bsc.data_end - offset`,
8506 BdrvBlockStatusCache *bsc = qatomic_rcu_read(&bs->block_status_cache); in bdrv_bsc_range_overlaps_locked()
8510 qatomic_read(&bsc->valid) && in bdrv_bsc_range_overlaps_locked()
8511 ranges_overlap(offset, bytes, bsc->data_start, in bdrv_bsc_range_overlaps_locked()
8512 bsc->data_end - bsc->data_start); in bdrv_bsc_range_overlaps_locked()
8515 *pnum = bsc->data_end - offset; in bdrv_bsc_range_overlaps_locked()
8541 qatomic_set(&bs->block_status_cache->valid, false); in bdrv_bsc_invalidate_range()
8560 QEMU_LOCK_GUARD(&bs->bsc_modify_lock); in bdrv_bsc_fill()
8562 old_bsc = qatomic_rcu_read(&bs->block_status_cache); in bdrv_bsc_fill()
8563 qatomic_rcu_set(&bs->block_status_cache, new_bsc); in bdrv_bsc_fill()