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()
1725 if (bs->file != NULL) { in bdrv_open_driver()
1726 bdrv_unref_child(bs, bs->file); in bdrv_open_driver()
1727 assert(!bs->file); in bdrv_open_driver()
1731 g_free(bs->opaque); in bdrv_open_driver()
1732 bs->opaque = NULL; in bdrv_open_driver()
1755 bs->open_flags = flags; in bdrv_new_open_driver_opts()
1756 bs->options = options ?: qdict_new(); in bdrv_new_open_driver_opts()
1757 bs->explicit_options = qdict_clone_shallow(bs->options); in bdrv_new_open_driver_opts()
1758 bs->opaque = NULL; in bdrv_new_open_driver_opts()
1760 update_options_from_flags(bs->options, flags); in bdrv_new_open_driver_opts()
1762 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp); in bdrv_new_open_driver_opts()
1764 qobject_unref(bs->explicit_options); in bdrv_new_open_driver_opts()
1765 bs->explicit_options = NULL; in bdrv_new_open_driver_opts()
1766 qobject_unref(bs->options); in bdrv_new_open_driver_opts()
1767 bs->options = NULL; in bdrv_new_open_driver_opts()
1788 .name = "node-name",
1815 .help = "Node is opened in read-only mode",
1820 .help = "Node can become read-only if opening read-write fails",
1823 .name = "detect-zeroes",
1842 .name = "simple-create-opts",
1880 assert(bs->file == NULL); in bdrv_open_common()
1881 assert(options != NULL && bs->options != options); in bdrv_open_common()
1886 ret = -EINVAL; in bdrv_open_common()
1890 update_flags_from_options(&bs->open_flags, opts); in bdrv_open_common()
1896 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false); in bdrv_open_common()
1898 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) { in bdrv_open_common()
1901 "=on can only be used with read-only images"); in bdrv_open_common()
1902 ret = -EINVAL; in bdrv_open_common()
1911 filename = blk_bs(file)->filename; in bdrv_open_common()
1915 * non-string types would require more care. When @options in bdrv_open_common()
1916 * come from -blockdev or blockdev_add, its members are typed in bdrv_open_common()
1918 * -drive, they're all QString. in bdrv_open_common()
1923 if (drv->bdrv_needs_filename && (!filename || !filename[0])) { in bdrv_open_common()
1925 drv->format_name); in bdrv_open_common()
1926 ret = -EINVAL; in bdrv_open_common()
1930 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags, in bdrv_open_common()
1931 drv->format_name); in bdrv_open_common()
1941 ret = -ENOTSUP; in bdrv_open_common()
1946 ? "Driver '%s' can only be used for read-only devices" in bdrv_open_common()
1948 drv->format_name); in bdrv_open_common()
1954 assert(qatomic_read(&bs->copy_on_read) == 0); in bdrv_open_common()
1956 if (bs->open_flags & BDRV_O_COPY_ON_READ) { in bdrv_open_common()
1960 error_setg(errp, "Can't use copy-on-read on read-only device"); in bdrv_open_common()
1961 ret = -EINVAL; in bdrv_open_common()
1968 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) { in bdrv_open_common()
1970 ret = -EINVAL; in bdrv_open_common()
1975 bs->detect_zeroes = in bdrv_open_common()
1976 bdrv_parse_detect_zeroes(opts, bs->open_flags, &local_err); in bdrv_open_common()
1979 ret = -EINVAL; in bdrv_open_common()
1984 pstrcpy(bs->filename, sizeof(bs->filename), filename); in bdrv_open_common()
1986 bs->filename[0] = '\0'; in bdrv_open_common()
1988 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename); in bdrv_open_common()
1991 open_flags = bdrv_open_flags(bs, bs->open_flags); in bdrv_open_common()
1992 node_name = qemu_opt_get(opts, "node-name"); in bdrv_open_common()
1994 assert(!drv->protocol_name || file == NULL); in bdrv_open_common()
2044 /* Parse json: pseudo-protocol */ in parse_json_protocol()
2081 * Caution: while qdict_get_try_str() is fine, getting non-string in bdrv_fill_options()
2083 * -blockdev or blockdev_add, its members are typed according to in bdrv_fill_options()
2084 * the QAPI schema, but when they come from -drive, they're all in bdrv_fill_options()
2092 return -ENOENT; in bdrv_fill_options()
2096 protocol = drv->protocol_name; in bdrv_fill_options()
2116 return -EINVAL; in bdrv_fill_options()
2128 return -EINVAL; in bdrv_fill_options()
2131 drvname = drv->format_name; in bdrv_fill_options()
2135 return -EINVAL; in bdrv_fill_options()
2141 /* Driver-specific filename parsing */ in bdrv_fill_options()
2142 if (drv && drv->bdrv_parse_filename && parse_filename) { in bdrv_fill_options()
2143 drv->bdrv_parse_filename(filename, *options, &local_err); in bdrv_fill_options()
2146 return -EINVAL; in bdrv_fill_options()
2149 if (!drv->bdrv_needs_filename) { in bdrv_fill_options()
2174 if (entry->state.bs == bs) { in bdrv_reopen_get_flags()
2175 return entry->state.flags; in bdrv_reopen_get_flags()
2180 return bs->open_flags; in bdrv_reopen_get_flags()
2196 * be written to but do not count as read-only images.
2207 return c->klass->get_parent_desc(c); in bdrv_child_user_desc()
2221 assert(a->bs); in bdrv_a_allow_b()
2222 assert(a->bs == b->bs); in bdrv_a_allow_b()
2225 if ((b->perm & a->shared_perm) == b->perm) { in bdrv_a_allow_b()
2229 child_bs_name = bdrv_get_node_name(b->bs); in bdrv_a_allow_b()
2232 perms = bdrv_perm_names(b->perm & ~a->shared_perm); in bdrv_a_allow_b()
2238 b_user, child_bs_name, b->name, in bdrv_a_allow_b()
2239 a_user, child_bs_name, a->name); in bdrv_a_allow_b()
2255 QLIST_FOREACH(a, &bs->parents, next_parent) { in bdrv_parent_perms_conflict()
2256 QLIST_FOREACH(b, &bs->parents, next_parent) { in bdrv_parent_perms_conflict()
2277 assert(bs->drv && bs->drv->bdrv_child_perm); in bdrv_child_perm()
2279 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue, in bdrv_child_perm()
2283 if (child_bs && child_bs->force_share) { in bdrv_child_perm()
2317 QLIST_FOREACH(child, &bs->children, next) { in bdrv_topological_dfs()
2318 list = bdrv_topological_dfs(list, found, child->bs); in bdrv_topological_dfs()
2336 s->child->perm = s->old_perm; in bdrv_child_set_perm_abort()
2337 s->child->shared_perm = s->old_shared_perm; in bdrv_child_set_perm_abort()
2353 .old_perm = c->perm, in bdrv_child_set_perm()
2354 .old_shared_perm = c->shared_perm, in bdrv_child_set_perm()
2357 c->perm = perm; in bdrv_child_set_perm()
2358 c->shared_perm = shared; in bdrv_child_set_perm()
2369 if (bs->drv->bdrv_set_perm) { in bdrv_drv_set_perm_commit()
2372 bs->drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms); in bdrv_drv_set_perm_commit()
2381 if (bs->drv->bdrv_abort_perm_update) { in bdrv_drv_set_perm_abort()
2382 bs->drv->bdrv_abort_perm_update(bs); in bdrv_drv_set_perm_abort()
2400 if (!bs->drv) { in bdrv_drv_set_perm()
2404 if (bs->drv->bdrv_check_perm) { in bdrv_drv_set_perm()
2405 int ret = bs->drv->bdrv_check_perm(bs, perm, shared_perm, errp); in bdrv_drv_set_perm()
2428 bdrv_schedule_unref(s->old_bs); in bdrv_replace_child_commit()
2434 BlockDriverState *new_bs = s->child->bs; in bdrv_replace_child_abort()
2439 /* old_bs reference is transparently moved from @s to @s->child */ in bdrv_replace_child_abort()
2440 if (!s->child->bs) { in bdrv_replace_child_abort()
2450 bdrv_parent_drained_begin_single(s->child); in bdrv_replace_child_abort()
2451 assert(!bdrv_parent_drained_poll_single(s->child)); in bdrv_replace_child_abort()
2453 assert(s->child->quiesced_parent); in bdrv_replace_child_abort()
2454 bdrv_replace_child_noperm(s->child, s->old_bs); in bdrv_replace_child_abort()
2470 * Both @child->bs and @new_bs (if non-NULL) must be drained. @new_bs must be
2484 assert(child->quiesced_parent); in bdrv_replace_child_tran()
2485 assert(!new_bs || new_bs->quiesce_counter); in bdrv_replace_child_tran()
2489 .old_bs = child->bs, in bdrv_replace_child_tran()
2512 BlockDriver *drv = bs->drv; in bdrv_node_refresh_perm()
2520 /* Write permissions never work with read-only images */ in bdrv_node_refresh_perm()
2525 error_setg(errp, "Block node is read-only"); in bdrv_node_refresh_perm()
2527 error_setg(errp, "Read-only block node '%s' cannot support " in bdrv_node_refresh_perm()
2528 "read-write users", bdrv_get_node_name(bs)); in bdrv_node_refresh_perm()
2531 return -EPERM; in bdrv_node_refresh_perm()
2542 if ((bs->total_sectors * BDRV_SECTOR_SIZE) % bs->bl.request_alignment) { in bdrv_node_refresh_perm()
2546 return -EPERM; in bdrv_node_refresh_perm()
2562 if (!drv->bdrv_child_perm) { in bdrv_node_refresh_perm()
2563 assert(QLIST_EMPTY(&bs->children)); in bdrv_node_refresh_perm()
2568 QLIST_FOREACH(c, &bs->children, next) { in bdrv_node_refresh_perm()
2571 bdrv_child_perm(bs, c->bs, c, c->role, q, in bdrv_node_refresh_perm()
2581 * @list is a product of bdrv_topological_dfs() (may be called several times) -
2595 for ( ; list; list = list->next) { in bdrv_do_refresh_perms()
2596 bs = list->data; in bdrv_do_refresh_perms()
2599 return -EINVAL; in bdrv_do_refresh_perms()
2626 for ( ; list; list = list->next) { in bdrv_list_refresh_perms()
2627 refresh_list = bdrv_topological_dfs(refresh_list, found, list->data); in bdrv_list_refresh_perms()
2642 QLIST_FOREACH(c, &bs->parents, next_parent) { in bdrv_get_cumulative_perm()
2643 cumulative_perms |= c->perm; in bdrv_get_cumulative_perm()
2644 cumulative_shared_perms &= c->shared_perm; in bdrv_get_cumulative_perm()
2667 for (p = permissions; p->name; p++) { in bdrv_perm_names()
2668 if (perm & p->perm) { in bdrv_perm_names()
2669 if (result->len > 0) { in bdrv_perm_names()
2672 g_string_append(result, p->name); in bdrv_perm_names()
2718 ret = bdrv_refresh_perms(c->bs, tran, &local_err); in bdrv_child_try_set_perm()
2723 if ((perm & ~c->perm) || (c->shared_perm & ~shared)) { in bdrv_child_try_set_perm()
2749 bdrv_child_perm(bs, c->bs, c, c->role, NULL, in bdrv_child_refresh_perms()
2799 if (bs->open_flags & BDRV_O_INACTIVE) { in bdrv_default_perms_for_cow()
2834 * bs->file always needs to be consistent because of the in bdrv_default_perms_for_storage()
2857 * is split into fixed-size data files). in bdrv_default_perms_for_storage()
2864 * write copied clusters on copy-on-read. in bdrv_default_perms_for_storage()
2879 if (bs->open_flags & BDRV_O_INACTIVE) { in bdrv_default_perms_for_storage()
2930 * If @new_bs is non-NULL, the parent of @child must already be drained through
2936 BlockDriverState *old_bs = child->bs; in bdrv_replace_child_noperm()
2939 assert(!child->frozen); in bdrv_replace_child_noperm()
2943 * child->bs, we need to make sure that its new parent is drained, too. In in bdrv_replace_child_noperm()
2944 * other words, either child->quiesce_parent must already be true or we must in bdrv_replace_child_noperm()
2950 * To keep things simple, we pick the first option (child->quiesce_parent in bdrv_replace_child_noperm()
2961 assert(!new_bs || child->quiesced_parent); in bdrv_replace_child_noperm()
2970 if (child->klass->detach) { in bdrv_replace_child_noperm()
2971 child->klass->detach(child); in bdrv_replace_child_noperm()
2976 child->bs = new_bs; in bdrv_replace_child_noperm()
2979 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent); in bdrv_replace_child_noperm()
2980 if (child->klass->attach) { in bdrv_replace_child_noperm()
2981 child->klass->attach(child); in bdrv_replace_child_noperm()
2990 new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0); in bdrv_replace_child_noperm()
2991 if (!new_bs_quiesce_counter && child->quiesced_parent) { in bdrv_replace_child_noperm()
2999 * The child must be empty (i.e. `child->bs == NULL`) and it must be
3004 assert(!child->bs); in bdrv_child_free()
3008 assert(!child->next.le_prev); /* not in children list */ in bdrv_child_free()
3010 g_free(child->name); in bdrv_child_free()
3023 BlockDriverState *bs = s->child->bs; in bdrv_attach_child_common_abort()
3028 bdrv_replace_child_noperm(s->child, NULL); in bdrv_attach_child_common_abort()
3030 if (bdrv_get_aio_context(bs) != s->old_child_ctx) { in bdrv_attach_child_common_abort()
3031 bdrv_try_change_aio_context_locked(bs, s->old_child_ctx, NULL, in bdrv_attach_child_common_abort()
3035 if (bdrv_child_get_parent_aio_context(s->child) != s->old_parent_ctx) { in bdrv_attach_child_common_abort()
3044 ret = s->child->klass->change_aio_ctx(s->child, s->old_parent_ctx, in bdrv_attach_child_common_abort()
3054 bdrv_child_free(s->child); in bdrv_attach_child_common_abort()
3091 assert(child_class->get_parent_desc); in bdrv_attach_child_common()
3123 if (ret < 0 && child_class->change_aio_ctx) { in bdrv_attach_child_common()
3129 ret_child = child_class->change_aio_ctx(new_child, child_ctx, in bdrv_attach_child_common()
3136 tran_finalize(aio_ctx_tran, ret_child == true ? 0 : -1); in bdrv_attach_child_common()
3202 assert(parent_bs->drv); in bdrv_attach_child_noperm()
3207 child_bs->node_name, child_name, parent_bs->node_name); in bdrv_attach_child_noperm()
3212 child_bs->node_name, child_name, parent_bs->node_name); in bdrv_attach_child_noperm()
3251 ret = -EINVAL; in bdrv_root_attach_child()
3291 ret = -EINVAL; in bdrv_attach_child()
3309 * Callers must ensure that child->frozen is false.
3315 BlockDriverState *child_bs = child->bs; in bdrv_root_unref_child()
3330 * When the parent requiring a non-default AioContext is removed, the in bdrv_root_unref_child()
3349 s->bs->inherits_from = s->old_inherits_from; in bdrv_set_inherits_from_abort()
3367 .old_inherits_from = bs->inherits_from, in bdrv_set_inherits_from()
3373 bs->inherits_from = new_inherits_from; in bdrv_set_inherits_from()
3387 if (child->bs->inherits_from == root) { in bdrv_unset_inherits_from()
3390 * child->bs goes away. in bdrv_unset_inherits_from()
3392 QLIST_FOREACH(c, &root->children, next) { in bdrv_unset_inherits_from()
3393 if (c != child && c->bs == child->bs) { in bdrv_unset_inherits_from()
3398 bdrv_set_inherits_from(child->bs, NULL, tran); in bdrv_unset_inherits_from()
3402 QLIST_FOREACH(c, &child->bs->children, next) { in bdrv_unset_inherits_from()
3408 * Callers must ensure that child->frozen is false.
3429 QLIST_FOREACH(c, &bs->parents, next_parent) { in bdrv_parent_cb_change_media()
3430 if (c->klass->change_media) { in bdrv_parent_cb_change_media()
3431 c->klass->change_media(c, load); in bdrv_parent_cb_change_media()
3436 /* Return true if you can reach parent going through child->inherits_from
3442 child = child->inherits_from; in bdrv_inherits_from_recursive()
3449 * Return the BdrvChildRole for @bs's backing child. bs->backing is
3455 if (bs->drv && bs->drv->is_filter) { in bdrv_backing_role()
3463 * Sets the bs->backing or bs->file link of a BDS. A new reference is created;
3488 BdrvChild *child = is_backing ? parent_bs->backing : parent_bs->file; in bdrv_set_file_or_backing_noperm()
3493 if (!parent_bs->drv) { in bdrv_set_file_or_backing_noperm()
3496 * qcow2 driver to never clear bs->drv and implement format corruption in bdrv_set_file_or_backing_noperm()
3500 return -EINVAL; in bdrv_set_file_or_backing_noperm()
3503 if (child && child->frozen) { in bdrv_set_file_or_backing_noperm()
3505 child->name, parent_bs->node_name, child->bs->node_name); in bdrv_set_file_or_backing_noperm()
3506 return -EPERM; in bdrv_set_file_or_backing_noperm()
3509 if (is_backing && !parent_bs->drv->is_filter && in bdrv_set_file_or_backing_noperm()
3510 !parent_bs->drv->supports_backing) in bdrv_set_file_or_backing_noperm()
3513 "files", parent_bs->drv->format_name, parent_bs->node_name); in bdrv_set_file_or_backing_noperm()
3514 return -EINVAL; in bdrv_set_file_or_backing_noperm()
3517 if (parent_bs->drv->is_filter) { in bdrv_set_file_or_backing_noperm()
3529 return -EINVAL; in bdrv_set_file_or_backing_noperm()
3531 role = child->role; in bdrv_set_file_or_backing_noperm()
3535 assert(child->bs->quiesce_counter); in bdrv_set_file_or_backing_noperm()
3549 return -EINVAL; in bdrv_set_file_or_backing_noperm()
3580 assert(bs->quiesce_counter > 0); in bdrv_set_backing_hd()
3581 if (bs->backing) { in bdrv_set_backing_hd()
3582 assert(bs->backing->bs->quiesce_counter > 0); in bdrv_set_backing_hd()
3624 if (bs->backing != NULL) { in bdrv_open_backing_file()
3634 bs->open_flags &= ~BDRV_O_NO_BACKING; in bdrv_open_backing_file()
3641 * Caution: while qdict_get_try_str() is fine, getting non-string in bdrv_open_backing_file()
3643 * -blockdev or blockdev_add, its members are typed according to in bdrv_open_backing_file()
3644 * the QAPI schema, but when they come from -drive, they're all in bdrv_open_backing_file()
3650 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) { in bdrv_open_backing_file()
3659 * only possible with -drive anyway (otherwise the QAPI in bdrv_open_backing_file()
3661 implicit_backing = !strcmp(bs->auto_backing_file, bs->backing_file); in bdrv_open_backing_file()
3666 ret = -EINVAL; in bdrv_open_backing_file()
3673 if (!bs->drv || !bs->drv->supports_backing) { in bdrv_open_backing_file()
3674 ret = -EINVAL; in bdrv_open_backing_file()
3681 bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) { in bdrv_open_backing_file()
3682 qdict_put_str(options, "driver", bs->backing_format); in bdrv_open_backing_file()
3689 bs->open_flags |= BDRV_O_NO_BACKING; in bdrv_open_backing_file()
3691 ret = -EINVAL; in bdrv_open_backing_file()
3697 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), in bdrv_open_backing_file()
3698 backing_hd->filename); in bdrv_open_backing_file()
3741 * Caution: while qdict_get_try_str() is fine, getting non-string in bdrv_open_child_bs()
3743 * -blockdev or blockdev_add, its members are typed according to in bdrv_open_child_bs()
3744 * the QAPI schema, but when they come from -drive, they're all in bdrv_open_child_bs()
3837 assert(!parent->drv->filtered_child_is_backing); in bdrv_open_file_child()
3838 role = parent->drv->is_filter ? in bdrv_open_file_child()
3844 return -EINVAL; in bdrv_open_file_child()
3864 if (ref->type == QTYPE_QSTRING) { in bdrv_open_blockdev_ref()
3865 reference = ref->u.reference; in bdrv_open_blockdev_ref()
3867 BlockdevOptions *options = &ref->u.definition; in bdrv_open_blockdev_ref()
3868 assert(ref->type == QTYPE_QDICT); in bdrv_open_blockdev_ref()
3916 error_setg_errno(errp, -total_size, "Could not get image size"); in bdrv_append_temp_snapshot()
4033 bs->explicit_options = qdict_clone_shallow(options); in bdrv_open_inherit()
4038 if (parent->drv) { in bdrv_open_inherit()
4039 parent_is_format = parent->drv->is_format; in bdrv_open_inherit()
4042 * parent->drv is not set yet because this node is opened for in bdrv_open_inherit()
4049 bs->inherits_from = parent; in bdrv_open_inherit()
4050 child_class->inherit_options(child_role, parent_is_format, in bdrv_open_inherit()
4052 parent->open_flags, parent->options); in bdrv_open_inherit()
4064 * When @options come from -blockdev or blockdev_add, members are in bdrv_open_inherit()
4066 * -drive, they're all QString. in bdrv_open_inherit()
4079 /* Let bdrv_backing_options() override "read-only" */ in bdrv_open_inherit()
4085 bs->open_flags = flags; in bdrv_open_inherit()
4086 bs->options = options; in bdrv_open_inherit()
4112 qdict_del(bs->explicit_options, "backing"); in bdrv_open_inherit()
4113 qdict_del(bs->options, "backing"); in bdrv_open_inherit()
4147 bs->probed = !drv; in bdrv_open_inherit()
4155 * but we first need to open bs->file for the probing to work, while in bdrv_open_inherit()
4156 * opening bs->file already requires the (mostly) final set of options in bdrv_open_inherit()
4161 * sure to update both bs->options (which has the full effective in bdrv_open_inherit()
4164 qdict_put_str(bs->options, "driver", drv->format_name); in bdrv_open_inherit()
4165 qdict_put_str(options, "driver", drv->format_name); in bdrv_open_inherit()
4172 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->protocol_name); in bdrv_open_inherit()
4197 * from bs->options and bs->explicit_options */ in bdrv_open_inherit()
4198 QLIST_FOREACH(child, &bs->children, next) { in bdrv_open_inherit()
4200 child_key_dot = g_strdup_printf("%s.", child->name); in bdrv_open_inherit()
4201 qdict_extract_subqdict(bs->explicit_options, NULL, child_key_dot); in bdrv_open_inherit()
4202 qdict_extract_subqdict(bs->options, NULL, child_key_dot); in bdrv_open_inherit()
4203 qdict_del(bs->explicit_options, child->name); in bdrv_open_inherit()
4204 qdict_del(bs->options, child->name); in bdrv_open_inherit()
4213 "'%s'", drv->format_name, entry->key); in bdrv_open_inherit()
4217 drv->format_name, entry->key); in bdrv_open_inherit()
4251 qobject_unref(bs->explicit_options); in bdrv_open_inherit()
4252 qobject_unref(bs->options); in bdrv_open_inherit()
4254 bs->options = NULL; in bdrv_open_inherit()
4255 bs->explicit_options = NULL; in bdrv_open_inherit()
4277 /* Return true if the NULL-terminated @list contains @str */
4292 * Check that every option set in @bs->options is also set in
4296 * @bs->drv->mutable_opts are skipped.
4298 * Return 0 on success, otherwise return -EINVAL and set @errp.
4307 "node-name", "discard", "cache.direct", "cache.no-flush", in bdrv_reset_options_allowed()
4308 "read-only", "auto-read-only", "detect-zeroes", NULL in bdrv_reset_options_allowed()
4311 for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) { in bdrv_reset_options_allowed()
4312 if (!qdict_haskey(new_opts, e->key) && in bdrv_reset_options_allowed()
4313 !is_str_in_list(e->key, common_options) && in bdrv_reset_options_allowed()
4314 !is_str_in_list(e->key, bs->drv->mutable_opts)) { in bdrv_reset_options_allowed()
4316 "to its default value", e->key); in bdrv_reset_options_allowed()
4317 return -EINVAL; in bdrv_reset_options_allowed()
4336 QLIST_FOREACH(c, &bs->children, next) { in bdrv_recurse_has_child()
4337 if (bdrv_recurse_has_child(c->bs, child)) { in bdrv_recurse_has_child()
4384 assert(bs->quiesce_counter > 0); in bdrv_reopen_queue_child()
4397 if (bs == bs_entry->state.bs) { in bdrv_reopen_queue_child()
4413 bs_entry->state.explicit_options : in bdrv_reopen_queue_child()
4414 bs->explicit_options); in bdrv_reopen_queue_child()
4424 klass->inherit_options(role, parent_is_format, &flags, options, in bdrv_reopen_queue_child()
4432 old_options = qdict_clone_shallow(bs->options); in bdrv_reopen_queue_child()
4455 qobject_unref(bs_entry->state.options); in bdrv_reopen_queue_child()
4456 qobject_unref(bs_entry->state.explicit_options); in bdrv_reopen_queue_child()
4459 bs_entry->state.bs = bs; in bdrv_reopen_queue_child()
4460 bs_entry->state.options = options; in bdrv_reopen_queue_child()
4461 bs_entry->state.explicit_options = explicit_options; in bdrv_reopen_queue_child()
4462 bs_entry->state.flags = flags; in bdrv_reopen_queue_child()
4471 bs_entry->state.backing_missing = in bdrv_reopen_queue_child()
4476 QLIST_FOREACH(child, &bs->children, next) { in bdrv_reopen_queue_child()
4483 if (child->bs->inherits_from != bs) { in bdrv_reopen_queue_child()
4488 if (qdict_haskey(options, child->name)) { in bdrv_reopen_queue_child()
4489 const char *childref = qdict_get_try_str(options, child->name); in bdrv_reopen_queue_child()
4494 if (g_strcmp0(childref, child->bs->node_name)) { in bdrv_reopen_queue_child()
4504 /* Extract child options ("child-name.*") */ in bdrv_reopen_queue_child()
4505 char *child_key_dot = g_strdup_printf("%s.", child->name); in bdrv_reopen_queue_child()
4511 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, in bdrv_reopen_queue_child()
4512 child->klass, child->role, bs->drv->is_format, in bdrv_reopen_queue_child()
4542 qobject_unref(bs_entry->state.explicit_options); in bdrv_reopen_queue_free()
4543 qobject_unref(bs_entry->state.options); in bdrv_reopen_queue_free()
4574 int ret = -1; in bdrv_reopen_multiple()
4584 ret = bdrv_flush(bs_entry->state.bs); in bdrv_reopen_multiple()
4586 error_setg_errno(errp, -ret, "Error flushing drive"); in bdrv_reopen_multiple()
4592 assert(bs_entry->state.bs->quiesce_counter > 0); in bdrv_reopen_multiple()
4593 ret = bdrv_reopen_prepare(&bs_entry->state, bs_queue, tran, errp); in bdrv_reopen_multiple()
4597 bs_entry->prepared = true; in bdrv_reopen_multiple()
4601 BDRVReopenState *state = &bs_entry->state; in bdrv_reopen_multiple()
4603 refresh_list = g_slist_prepend(refresh_list, state->bs); in bdrv_reopen_multiple()
4604 if (state->old_backing_bs) { in bdrv_reopen_multiple()
4605 refresh_list = g_slist_prepend(refresh_list, state->old_backing_bs); in bdrv_reopen_multiple()
4607 if (state->old_file_bs) { in bdrv_reopen_multiple()
4608 refresh_list = g_slist_prepend(refresh_list, state->old_file_bs); in bdrv_reopen_multiple()
4613 * Note that file-posix driver rely on permission update done during reopen in bdrv_reopen_multiple()
4632 * children are usually goes after parents in reopen-queue, so go from last in bdrv_reopen_multiple()
4636 bdrv_reopen_commit(&bs_entry->state); in bdrv_reopen_multiple()
4644 BlockDriverState *bs = bs_entry->state.bs; in bdrv_reopen_multiple()
4646 if (bs->drv->bdrv_reopen_commit_post) { in bdrv_reopen_multiple()
4647 bs->drv->bdrv_reopen_commit_post(&bs_entry->state); in bdrv_reopen_multiple()
4660 if (bs_entry->prepared) { in bdrv_reopen_multiple()
4661 bdrv_reopen_abort(&bs_entry->state); in bdrv_reopen_multiple()
4697 * reopen_state->options QDict is valid or not.
4702 * reopen_state->bs then return 0.
4706 * If that's the case then reopen_state->replace_backing_bs is set to
4707 * true and reopen_state->new_backing_bs contains a pointer to the new
4715 * @reopen_state->bs can move to a different AioContext in this function.
4725 BlockDriverState *bs = reopen_state->bs; in bdrv_reopen_parse_file_or_backing()
4737 value = qdict_get(reopen_state->options, child_name); in bdrv_reopen_parse_file_or_backing()
4753 ret = -EINVAL; in bdrv_reopen_parse_file_or_backing()
4760 "cycle", str, child_name, bs->node_name); in bdrv_reopen_parse_file_or_backing()
4761 ret = -EINVAL; in bdrv_reopen_parse_file_or_backing()
4773 old_child_bs = is_backing ? child_bs(bs->backing) : child_bs(bs->file); in bdrv_reopen_parse_file_or_backing()
4785 if (old_child_bs->implicit) { in bdrv_reopen_parse_file_or_backing()
4787 child_name, bs->node_name); in bdrv_reopen_parse_file_or_backing()
4788 ret = -EPERM; in bdrv_reopen_parse_file_or_backing()
4793 if (bs->drv->is_filter && !old_child_bs) { in bdrv_reopen_parse_file_or_backing()
4799 "%s child", bs->node_name, bs->drv->format_name, child_name); in bdrv_reopen_parse_file_or_backing()
4800 ret = -EINVAL; in bdrv_reopen_parse_file_or_backing()
4805 reopen_state->old_backing_bs = old_child_bs; in bdrv_reopen_parse_file_or_backing()
4807 reopen_state->old_file_bs = old_child_bs; in bdrv_reopen_parse_file_or_backing()
4812 assert(old_child_bs->quiesce_counter > 0); in bdrv_reopen_parse_file_or_backing()
4843 * Returns 0 on success, non-zero on error. On error errp will be set
4860 int ret = -1; in bdrv_reopen_prepare()
4871 assert(reopen_state->bs->drv != NULL); in bdrv_reopen_prepare()
4873 drv = reopen_state->bs->drv; in bdrv_reopen_prepare()
4876 * entries from reopen_state->options as they are processed, so in bdrv_reopen_prepare()
4878 orig_reopen_opts = qdict_clone_shallow(reopen_state->options); in bdrv_reopen_prepare()
4882 if (!qemu_opts_absorb_qdict(opts, reopen_state->options, errp)) { in bdrv_reopen_prepare()
4883 ret = -EINVAL; in bdrv_reopen_prepare()
4888 * are up-to-date. This time we simply want to remove the options from in bdrv_reopen_prepare()
4890 old_flags = reopen_state->flags; in bdrv_reopen_prepare()
4891 update_flags_from_options(&reopen_state->flags, opts); in bdrv_reopen_prepare()
4892 assert(old_flags == reopen_state->flags); in bdrv_reopen_prepare()
4896 if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) { in bdrv_reopen_prepare()
4898 ret = -EINVAL; in bdrv_reopen_prepare()
4903 reopen_state->detect_zeroes = in bdrv_reopen_prepare()
4904 bdrv_parse_detect_zeroes(opts, reopen_state->flags, &local_err); in bdrv_reopen_prepare()
4907 ret = -EINVAL; in bdrv_reopen_prepare()
4911 /* All other options (including node-name and driver) must be unchanged. in bdrv_reopen_prepare()
4914 qemu_opts_to_qdict(opts, reopen_state->options); in bdrv_reopen_prepare()
4916 /* If we are to stay read-only, do not allow permission change in bdrv_reopen_prepare()
4919 read_only = !(reopen_state->flags & BDRV_O_RDWR); in bdrv_reopen_prepare()
4922 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err); in bdrv_reopen_prepare()
4929 if (drv->bdrv_reopen_prepare) { in bdrv_reopen_prepare()
4931 * If a driver-specific option is missing, it means that we in bdrv_reopen_prepare()
4935 ret = bdrv_reset_options_allowed(reopen_state->bs, in bdrv_reopen_prepare()
4936 reopen_state->options, errp); in bdrv_reopen_prepare()
4941 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err); in bdrv_reopen_prepare()
4947 bdrv_refresh_filename(reopen_state->bs); in bdrv_reopen_prepare()
4950 reopen_state->bs->filename); in bdrv_reopen_prepare()
4959 "does not support reopening files", drv->format_name, in bdrv_reopen_prepare()
4960 bdrv_get_device_or_node_name(reopen_state->bs)); in bdrv_reopen_prepare()
4962 ret = -1; in bdrv_reopen_prepare()
4974 if (drv->supports_backing && reopen_state->backing_missing && in bdrv_reopen_prepare()
4975 (reopen_state->bs->backing || reopen_state->bs->backing_file[0])) { in bdrv_reopen_prepare()
4977 reopen_state->bs->node_name); in bdrv_reopen_prepare()
4979 ret = -EINVAL; in bdrv_reopen_prepare()
4994 qdict_del(reopen_state->options, "backing"); in bdrv_reopen_prepare()
5002 qdict_del(reopen_state->options, "file"); in bdrv_reopen_prepare()
5007 if (qdict_size(reopen_state->options)) { in bdrv_reopen_prepare()
5008 const QDictEntry *entry = qdict_first(reopen_state->options); in bdrv_reopen_prepare()
5013 QObject *new = entry->value; in bdrv_reopen_prepare()
5014 QObject *old = qdict_get(reopen_state->bs->options, entry->key); in bdrv_reopen_prepare()
5020 QLIST_FOREACH(child, &reopen_state->bs->children, next) { in bdrv_reopen_prepare()
5021 if (!strcmp(child->name, entry->key)) { in bdrv_reopen_prepare()
5027 if (!strcmp(child->bs->node_name, in bdrv_reopen_prepare()
5035 * TODO: When using -drive to specify blockdev options, all values in bdrv_reopen_prepare()
5036 * will be strings; however, when using -blockdev, blockdev-add or in bdrv_reopen_prepare()
5037 * filenames using the json:{} pseudo-protocol, they will be in bdrv_reopen_prepare()
5040 * (because you can only specify them through qemu-io; all other in bdrv_reopen_prepare()
5042 * Therefore, when using anything other than -drive to create a BDS, in bdrv_reopen_prepare()
5043 * this cannot detect non-string options as unchanged, because in bdrv_reopen_prepare()
5051 error_setg(errp, "Cannot change the option '%s'", entry->key); in bdrv_reopen_prepare()
5052 ret = -EINVAL; in bdrv_reopen_prepare()
5055 } while ((entry = qdict_next(reopen_state->options, entry))); in bdrv_reopen_prepare()
5060 /* Restore the original reopen_state->options QDict */ in bdrv_reopen_prepare()
5061 qobject_unref(reopen_state->options); in bdrv_reopen_prepare()
5062 reopen_state->options = qobject_ref(orig_reopen_opts); in bdrv_reopen_prepare()
5066 /* drv->bdrv_reopen_prepare() has succeeded, so we need to in bdrv_reopen_prepare()
5067 * call drv->bdrv_reopen_abort() before signaling an error in bdrv_reopen_prepare()
5070 if (drv->bdrv_reopen_abort) { in bdrv_reopen_prepare()
5071 drv->bdrv_reopen_abort(reopen_state); in bdrv_reopen_prepare()
5092 bs = reopen_state->bs; in bdrv_reopen_commit()
5093 drv = bs->drv; in bdrv_reopen_commit()
5098 if (drv->bdrv_reopen_commit) { in bdrv_reopen_commit()
5099 drv->bdrv_reopen_commit(reopen_state); in bdrv_reopen_commit()
5105 qobject_unref(bs->explicit_options); in bdrv_reopen_commit()
5106 qobject_unref(bs->options); in bdrv_reopen_commit()
5107 qobject_ref(reopen_state->explicit_options); in bdrv_reopen_commit()
5108 qobject_ref(reopen_state->options); in bdrv_reopen_commit()
5110 bs->explicit_options = reopen_state->explicit_options; in bdrv_reopen_commit()
5111 bs->options = reopen_state->options; in bdrv_reopen_commit()
5112 bs->open_flags = reopen_state->flags; in bdrv_reopen_commit()
5113 bs->detect_zeroes = reopen_state->detect_zeroes; in bdrv_reopen_commit()
5115 /* Remove child references from bs->options and bs->explicit_options. in bdrv_reopen_commit()
5117 QLIST_FOREACH(child, &bs->children, next) { in bdrv_reopen_commit()
5118 qdict_del(bs->explicit_options, child->name); in bdrv_reopen_commit()
5119 qdict_del(bs->options, child->name); in bdrv_reopen_commit()
5122 qdict_del(bs->explicit_options, "backing"); in bdrv_reopen_commit()
5123 qdict_del(bs->options, "backing"); in bdrv_reopen_commit()
5126 bdrv_refresh_total_sectors(bs, bs->total_sectors); in bdrv_reopen_commit()
5138 drv = reopen_state->bs->drv; in bdrv_reopen_abort()
5142 if (drv->bdrv_reopen_abort) { in bdrv_reopen_abort()
5143 drv->bdrv_reopen_abort(reopen_state); in bdrv_reopen_abort()
5154 assert(!bs->refcnt); in bdrv_close()
5160 if (bs->drv) { in bdrv_close()
5161 if (bs->drv->bdrv_close) { in bdrv_close()
5163 bs->drv->bdrv_close(bs); in bdrv_close()
5165 bs->drv = NULL; in bdrv_close()
5169 QLIST_FOREACH_SAFE(child, &bs->children, next, next) { in bdrv_close()
5173 assert(!bs->backing); in bdrv_close()
5174 assert(!bs->file); in bdrv_close()
5177 g_free(bs->opaque); in bdrv_close()
5178 bs->opaque = NULL; in bdrv_close()
5179 qatomic_set(&bs->copy_on_read, 0); in bdrv_close()
5180 bs->backing_file[0] = '\0'; in bdrv_close()
5181 bs->backing_format[0] = '\0'; in bdrv_close()
5182 bs->total_sectors = 0; in bdrv_close()
5183 bs->encrypted = false; in bdrv_close()
5184 bs->sg = false; in bdrv_close()
5185 qobject_unref(bs->options); in bdrv_close()
5186 qobject_unref(bs->explicit_options); in bdrv_close()
5187 bs->options = NULL; in bdrv_close()
5188 bs->explicit_options = NULL; in bdrv_close()
5189 qobject_unref(bs->full_open_options); in bdrv_close()
5190 bs->full_open_options = NULL; in bdrv_close()
5191 g_free(bs->block_status_cache); in bdrv_close()
5192 bs->block_status_cache = NULL; in bdrv_close()
5195 assert(QLIST_EMPTY(&bs->dirty_bitmaps)); in bdrv_close()
5197 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { in bdrv_close()
5200 QLIST_INIT(&bs->aio_notifiers); in bdrv_close()
5208 if (bs->quiesce_counter) { in bdrv_close()
5234 if (c->klass->stay_at_node) { in should_update_child()
5239 * c->bs by @to would mean to create a loop. in should_update_child()
5244 * guest device -> node A -> further backing chain... in should_update_child()
5252 * guest device -> node A -> further backing chain... in should_update_child()
5255 * replace all pointers to A by pointers to B -- except for the in should_update_child()
5259 * guest device -> node B in should_update_child()
5262 * node A -> further backing chain... in should_update_child()
5264 * In general, when replacing a node A (c->bs) by a node B (@to), in should_update_child()
5272 * if @c is found (by breadth-first search) anywhere in the whole in should_update_child()
5286 QLIST_FOREACH(c2, &v->children, next) { in should_update_child()
5292 if (g_hash_table_contains(found, c2->bs)) { in should_update_child()
5296 g_queue_push_tail(queue, c2->bs); in should_update_child()
5297 g_hash_table_add(found, c2->bs); in should_update_child()
5320 * @child->bs (if non-NULL) must be drained.
5331 if (child->bs) { in bdrv_remove_child()
5332 assert(child->quiesced_parent); in bdrv_remove_child()
5340 * Both @from and @to (if non-NULL) must be drained. @to must be kept drained
5356 assert(from->quiesce_counter); in bdrv_replace_node_noperm()
5357 assert(to->quiesce_counter); in bdrv_replace_node_noperm()
5359 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) { in bdrv_replace_node_noperm()
5360 assert(c->bs == from); in bdrv_replace_node_noperm()
5366 c->name, from->node_name); in bdrv_replace_node_noperm()
5367 return -EINVAL; in bdrv_replace_node_noperm()
5369 if (c->frozen) { in bdrv_replace_node_noperm()
5371 c->name, from->node_name); in bdrv_replace_node_noperm()
5372 return -EPERM; in bdrv_replace_node_noperm()
5385 * if it creates a parent-child relation loop or if parent is block-job.
5391 * case backing link of the cow-parent of @to is removed.
5404 assert(from->quiesce_counter); in bdrv_replace_node_common()
5405 assert(to->quiesce_counter); in bdrv_replace_node_common()
5422 * permissions based on new graph. If we fail, we'll roll-back the in bdrv_replace_node_common()
5498 assert(!bs_new->backing); in bdrv_append()
5507 ret = -EINVAL; in bdrv_append()
5533 BlockDriverState *old_bs = child->bs; in bdrv_replace_child_bs()
5562 assert(!bs->refcnt); in bdrv_delete()
5566 if (bs->node_name[0] != '\0') { in bdrv_delete()
5573 qemu_mutex_destroy(&bs->reqs_lock); in bdrv_delete()
5612 node_name = qdict_get_try_str(options, "node-name"); in bdrv_insert_node()
5657 * free of errors) or -errno when an internal error occurred. The results of the
5665 if (bs->drv == NULL) { in bdrv_co_check()
5666 return -ENOMEDIUM; in bdrv_co_check()
5668 if (bs->drv->bdrv_co_check == NULL) { in bdrv_co_check()
5669 return -ENOTSUP; in bdrv_co_check()
5673 return bs->drv->bdrv_co_check(bs, res, fix); in bdrv_co_check()
5678 * 0 - success
5679 * -EINVAL - backing format specified, but no file
5680 * -ENOSPC - can't update the backing file because no space is left in the
5682 * -ENOTSUP - format driver doesn't support changing the backing file
5688 BlockDriver *drv = bs->drv; in bdrv_co_change_backing_file()
5694 return -ENOMEDIUM; in bdrv_co_change_backing_file()
5699 return -EINVAL; in bdrv_co_change_backing_file()
5703 return -EINVAL; in bdrv_co_change_backing_file()
5706 if (drv->bdrv_co_change_backing_file != NULL) { in bdrv_co_change_backing_file()
5707 ret = drv->bdrv_co_change_backing_file(bs, backing_file, backing_fmt); in bdrv_co_change_backing_file()
5709 ret = -ENOTSUP; in bdrv_co_change_backing_file()
5713 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); in bdrv_co_change_backing_file()
5714 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); in bdrv_co_change_backing_file()
5715 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), in bdrv_co_change_backing_file()
5722 * Finds the first non-filter node above bs in the chain between
5776 if (child && child->frozen) { in bdrv_is_backing_chain_frozen()
5778 child->name, i->node_name, child->bs->node_name); in bdrv_is_backing_chain_frozen()
5802 return -EPERM; in bdrv_freeze_backing_chain()
5807 if (child && child->bs->never_freeze) { in bdrv_freeze_backing_chain()
5809 child->name, child->bs->node_name); in bdrv_freeze_backing_chain()
5810 return -EPERM; in bdrv_freeze_backing_chain()
5817 child->frozen = true; in bdrv_freeze_backing_chain()
5840 assert(child->frozen); in bdrv_unfreeze_backing_chain()
5841 child->frozen = false; in bdrv_unfreeze_backing_chain()
5854 * bottom <- base <- intermediate <- top <- active
5858 * bottom <- base <- active
5862 * base <- intermediate <- top <- active
5866 * base <- active
5868 * If backing_file_str is non-NULL, it will be used when modifying top's
5883 int ret = -EIO; in bdrv_drop_intermediate()
5893 if (!top->drv || !base->drv) { in bdrv_drop_intermediate()
5903 * base->inherits_from to top->inherits_from after 'top' and all in bdrv_drop_intermediate()
5910 /* success - we can delete the intermediate states, and link top->base */ in bdrv_drop_intermediate()
5913 backing_file_str = base->filename; in bdrv_drop_intermediate()
5916 QLIST_FOREACH(c, &top->parents, next_parent) { in bdrv_drop_intermediate()
5927 * test-bdrv-drain. test_drop_intermediate_poll() test-case will crash. in bdrv_drop_intermediate()
5938 for (p = updated_children; p; p = p->next) { in bdrv_drop_intermediate()
5939 c = p->data; in bdrv_drop_intermediate()
5941 if (c->klass->update_filename) { in bdrv_drop_intermediate()
5942 ret = c->klass->update_filename(c, base, backing_file_str, in bdrv_drop_intermediate()
5951 * Note, that c->klass->update_filename may lead to permission in bdrv_drop_intermediate()
5962 base->inherits_from = explicit_top->inherits_from; in bdrv_drop_intermediate()
5978 * sums the size of all data-bearing children. (This excludes backing
5987 QLIST_FOREACH(child, &bs->children, next) { in bdrv_sum_allocated_file_size()
5988 if (child->role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA | in bdrv_sum_allocated_file_size()
5991 child_size = bdrv_co_get_allocated_file_size(child->bs); in bdrv_sum_allocated_file_size()
6008 BlockDriver *drv = bs->drv; in bdrv_co_get_allocated_file_size()
6013 return -ENOMEDIUM; in bdrv_co_get_allocated_file_size()
6015 if (drv->bdrv_co_get_allocated_file_size) { in bdrv_co_get_allocated_file_size()
6016 return drv->bdrv_co_get_allocated_file_size(bs); in bdrv_co_get_allocated_file_size()
6019 if (drv->protocol_name) { in bdrv_co_get_allocated_file_size()
6021 * Protocol drivers default to -ENOTSUP (most of their data is in bdrv_co_get_allocated_file_size()
6025 return -ENOTSUP; in bdrv_co_get_allocated_file_size()
6026 } else if (drv->is_filter) { in bdrv_co_get_allocated_file_size()
6062 if (!drv->bdrv_measure) { in bdrv_measure()
6064 drv->format_name); in bdrv_measure()
6068 return drv->bdrv_measure(opts, in_bs, errp); in bdrv_measure()
6072 * Return number of sectors on success, -errno on error.
6076 BlockDriver *drv = bs->drv; in bdrv_co_nb_sectors()
6081 return -ENOMEDIUM; in bdrv_co_nb_sectors()
6083 if (bs->bl.has_variable_length) { in bdrv_co_nb_sectors()
6084 int ret = bdrv_co_refresh_total_sectors(bs, bs->total_sectors); in bdrv_co_nb_sectors()
6089 return bs->total_sectors; in bdrv_co_nb_sectors()
6098 BlockDriver *drv = bs->drv; in bdrv_nb_sectors()
6102 return -ENOMEDIUM; in bdrv_nb_sectors()
6104 if (bs->bl.has_variable_length) { in bdrv_nb_sectors()
6105 int ret = bdrv_refresh_total_sectors(bs, bs->total_sectors); in bdrv_nb_sectors()
6111 return bs->total_sectors; in bdrv_nb_sectors()
6115 * Return length in bytes on success, -errno on error.
6129 return -EFBIG; in bdrv_co_getlength()
6137 return bs->sg; in bdrv_is_sg()
6148 if (!bs->drv || !block_driver_can_compress(bs->drv)) { in bdrv_supports_compressed_writes()
6167 return bs->drv ? bs->drv->format_name : NULL; in bdrv_get_format_name()
6186 if (drv->format_name) { in bdrv_iterate_format()
6195 found = !strcmp(formats[--i], drv->format_name); in bdrv_iterate_format()
6200 formats[count++] = drv->format_name; in bdrv_iterate_format()
6218 found = !strcmp(formats[--j], format_name); in bdrv_iterate_format()
6246 if (!strcmp(node_name, bs->node_name)) { in bdrv_find_node()
6285 gr->graph = g_new0(XDbgBlockGraph, 1); in xdbg_graph_new()
6286 gr->graph_nodes = g_hash_table_new(NULL, NULL); in xdbg_graph_new()
6293 XDbgBlockGraph *graph = gr->graph; in xdbg_graph_finalize()
6295 g_hash_table_destroy(gr->graph_nodes); in xdbg_graph_finalize()
6303 uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node); in xdbg_graph_node_num()
6310 * Start counting from 1, not 0, because 0 interferes with not-found (NULL) in xdbg_graph_node_num()
6313 ret = g_hash_table_size(gr->graph_nodes) + 1; in xdbg_graph_node_num()
6314 g_hash_table_insert(gr->graph_nodes, node, (void *)ret); in xdbg_graph_node_num()
6326 n->id = xdbg_graph_node_num(gr, node); in xdbg_graph_add_node()
6327 n->type = type; in xdbg_graph_add_node()
6328 n->name = g_strdup(name); in xdbg_graph_add_node()
6330 QAPI_LIST_PREPEND(gr->graph->nodes, n); in xdbg_graph_add_node()
6342 edge->parent = xdbg_graph_node_num(gr, parent); in xdbg_graph_add_edge()
6343 edge->child = xdbg_graph_node_num(gr, child->bs); in xdbg_graph_add_edge()
6344 edge->name = g_strdup(child->name); in xdbg_graph_add_edge()
6349 if (flag & child->perm) { in xdbg_graph_add_edge()
6350 QAPI_LIST_PREPEND(edge->perm, qapi_perm); in xdbg_graph_add_edge()
6352 if (flag & child->shared_perm) { in xdbg_graph_add_edge()
6353 QAPI_LIST_PREPEND(edge->shared_perm, qapi_perm); in xdbg_graph_add_edge()
6357 QAPI_LIST_PREPEND(gr->graph->edges, edge); in xdbg_graph_add_edge()
6392 job->job.id); in bdrv_get_xdbg_block_graph()
6393 for (el = job->nodes; el; el = el->next) { in bdrv_get_xdbg_block_graph()
6394 xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data); in bdrv_get_xdbg_block_graph()
6401 bs->node_name); in bdrv_get_xdbg_block_graph()
6402 QLIST_FOREACH(child, &bs->children, next) { in bdrv_get_xdbg_block_graph()
6440 error_setg(errp, "Cannot find device=\'%s\' nor node-name=\'%s\'", in bdrv_lookup_bs()
6481 return bs->node_name; in bdrv_get_node_name()
6491 QLIST_FOREACH(c, &bs->parents, next_parent) { in bdrv_get_parent_name()
6492 if (c->klass->get_name) { in bdrv_get_parent_name()
6493 name = c->klass->get_name(c); in bdrv_get_parent_name()
6503 /* TODO check what callers really want: bs->node_name or blk_name() */
6513 * absent, then this returns an empty (non-null) string. */
6517 return bdrv_get_parent_name(bs) ?: bs->node_name; in bdrv_get_device_or_node_name()
6523 return bs->open_flags; in bdrv_get_flags()
6537 if (!bs->drv) { in bdrv_has_zero_init()
6546 if (bs->drv->bdrv_has_zero_init) { in bdrv_has_zero_init()
6547 return bs->drv->bdrv_has_zero_init(bs); in bdrv_has_zero_init()
6562 if (!(bs->open_flags & BDRV_O_UNMAP)) { in bdrv_can_write_zeroes_with_unmap()
6566 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP; in bdrv_can_write_zeroes_with_unmap()
6573 pstrcpy(filename, filename_size, bs->backing_file); in bdrv_get_backing_filename()
6579 BlockDriver *drv = bs->drv; in bdrv_co_get_info()
6583 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */ in bdrv_co_get_info()
6585 return -ENOMEDIUM; in bdrv_co_get_info()
6587 if (!drv->bdrv_co_get_info) { in bdrv_co_get_info()
6592 return -ENOTSUP; in bdrv_co_get_info()
6595 ret = drv->bdrv_co_get_info(bs, bdi); in bdrv_co_get_info()
6596 if (bdi->subcluster_size == 0) { in bdrv_co_get_info()
6601 bdi->subcluster_size = bdi->cluster_size; in bdrv_co_get_info()
6607 if (bdi->cluster_size > BDRV_MAX_ALIGNMENT) { in bdrv_co_get_info()
6608 return -EINVAL; in bdrv_co_get_info()
6617 BlockDriver *drv = bs->drv; in bdrv_get_specific_info()
6619 if (drv && drv->bdrv_get_specific_info) { in bdrv_get_specific_info()
6620 return drv->bdrv_get_specific_info(bs, errp); in bdrv_get_specific_info()
6627 BlockDriver *drv = bs->drv; in bdrv_get_specific_stats()
6629 if (!drv || !drv->bdrv_get_specific_stats) { in bdrv_get_specific_stats()
6632 return drv->bdrv_get_specific_stats(bs); in bdrv_get_specific_stats()
6640 if (!bs || !bs->drv || !bs->drv->bdrv_co_debug_event) { in bdrv_co_debug_event()
6644 bs->drv->bdrv_co_debug_event(bs, event); in bdrv_co_debug_event()
6651 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { in bdrv_find_debug_node()
6655 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) { in bdrv_find_debug_node()
6656 assert(bs->drv->bdrv_debug_remove_breakpoint); in bdrv_find_debug_node()
6671 return bs->drv->bdrv_debug_breakpoint(bs, event, tag); in bdrv_debug_breakpoint()
6674 return -ENOTSUP; in bdrv_debug_breakpoint()
6684 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag); in bdrv_debug_remove_breakpoint()
6687 return -ENOTSUP; in bdrv_debug_remove_breakpoint()
6695 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { in bdrv_debug_resume()
6699 if (bs && bs->drv && bs->drv->bdrv_debug_resume) { in bdrv_debug_resume()
6700 return bs->drv->bdrv_debug_resume(bs, tag); in bdrv_debug_resume()
6703 return -ENOTSUP; in bdrv_debug_resume()
6711 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { in bdrv_debug_is_suspended()
6715 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) { in bdrv_debug_is_suspended()
6716 return bs->drv->bdrv_debug_is_suspended(bs, tag); in bdrv_debug_is_suspended()
6723 * relative, it must be relative to the chain. So, passing in bs->filename
6741 if (!bs || !bs->drv || !backing_file) { in bdrv_find_backing_image()
6778 if (strcmp(backing_file, bs_below->filename) == 0) { in bdrv_find_backing_image()
6782 } else if (is_protocol || path_has_protocol(curr_bs->backing_file)) { in bdrv_find_backing_image()
6789 if (strcmp(backing_file, curr_bs->backing_file) == 0) { in bdrv_find_backing_image()
6852 return bs->open_flags & BDRV_O_INACTIVE; in bdrv_is_inactive()
6865 if (!bs->drv) { in bdrv_activate()
6866 return -ENOMEDIUM; in bdrv_activate()
6869 QLIST_FOREACH(child, &bs->children, next) { in bdrv_activate()
6870 bdrv_activate(child->bs, &local_err); in bdrv_activate()
6873 return -EINVAL; in bdrv_activate()
6890 if (bs->open_flags & BDRV_O_INACTIVE) { in bdrv_activate()
6891 bs->open_flags &= ~BDRV_O_INACTIVE; in bdrv_activate()
6894 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_activate()
6900 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_activate()
6908 ret = bdrv_refresh_total_sectors(bs, bs->total_sectors); in bdrv_activate()
6910 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_activate()
6911 error_setg_errno(errp, -ret, "Could not refresh total sector count"); in bdrv_activate()
6916 QLIST_FOREACH(parent, &bs->parents, next_parent) { in bdrv_activate()
6917 if (parent->klass->activate) { in bdrv_activate()
6918 parent->klass->activate(parent, &local_err); in bdrv_activate()
6920 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_activate()
6922 return -EINVAL; in bdrv_activate()
6935 assert(!(bs->open_flags & BDRV_O_INACTIVE)); in bdrv_co_invalidate_cache()
6938 if (bs->drv->bdrv_co_invalidate_cache) { in bdrv_co_invalidate_cache()
6939 bs->drv->bdrv_co_invalidate_cache(bs, &local_err); in bdrv_co_invalidate_cache()
6942 return -EINVAL; in bdrv_co_invalidate_cache()
6974 QLIST_FOREACH(parent, &bs->parents, next_parent) { in bdrv_has_bds_parent()
6975 if (parent->klass->parent_is_bds) { in bdrv_has_bds_parent()
6976 BlockDriverState *parent_bs = parent->opaque; in bdrv_has_bds_parent()
6977 if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) { in bdrv_has_bds_parent()
6995 assert(bs->quiesce_counter > 0); in bdrv_inactivate_recurse()
6997 if (!bs->drv) { in bdrv_inactivate_recurse()
6998 return -ENOMEDIUM; in bdrv_inactivate_recurse()
7011 if (bs->open_flags & BDRV_O_INACTIVE) { in bdrv_inactivate_recurse()
7017 if (bs->drv->bdrv_inactivate) { in bdrv_inactivate_recurse()
7018 ret = bs->drv->bdrv_inactivate(bs); in bdrv_inactivate_recurse()
7024 QLIST_FOREACH(parent, &bs->parents, next_parent) { in bdrv_inactivate_recurse()
7025 if (parent->klass->inactivate) { in bdrv_inactivate_recurse()
7026 ret = parent->klass->inactivate(parent); in bdrv_inactivate_recurse()
7037 return -EPERM; in bdrv_inactivate_recurse()
7040 bs->open_flags |= BDRV_O_INACTIVE; in bdrv_inactivate_recurse()
7050 QLIST_FOREACH(child, &bs->children, next) { in bdrv_inactivate_recurse()
7051 ret = bdrv_inactivate_recurse(child->bs, false); in bdrv_inactivate_recurse()
7069 return -EPERM; in bdrv_inactivate()
7074 error_setg_errno(errp, -ret, "Failed to inactivate node"); in bdrv_inactivate()
7120 BlockDriver *drv = bs->drv; in bdrv_co_is_inserted()
7128 if (drv->bdrv_co_is_inserted) { in bdrv_co_is_inserted()
7129 return drv->bdrv_co_is_inserted(bs); in bdrv_co_is_inserted()
7131 QLIST_FOREACH(child, &bs->children, next) { in bdrv_co_is_inserted()
7132 if (!bdrv_co_is_inserted(child->bs)) { in bdrv_co_is_inserted()
7144 BlockDriver *drv = bs->drv; in bdrv_co_eject()
7148 if (drv && drv->bdrv_co_eject) { in bdrv_co_eject()
7149 drv->bdrv_co_eject(bs, eject_flag); in bdrv_co_eject()
7159 BlockDriver *drv = bs->drv; in bdrv_co_lock_medium()
7164 if (drv && drv->bdrv_co_lock_medium) { in bdrv_co_lock_medium()
7165 drv->bdrv_co_lock_medium(bs, locked); in bdrv_co_lock_medium()
7173 bs->refcnt++; in bdrv_ref()
7185 assert(bs->refcnt > 0); in bdrv_unref()
7186 if (--bs->refcnt == 0) { in bdrv_unref()
7225 if (!QLIST_EMPTY(&bs->op_blockers[op])) { in bdrv_op_is_blocked()
7226 blocker = QLIST_FIRST(&bs->op_blockers[op]); in bdrv_op_is_blocked()
7227 error_propagate_prepend(errp, error_copy(blocker->reason), in bdrv_op_is_blocked()
7242 blocker->reason = reason; in bdrv_op_block()
7243 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); in bdrv_op_block()
7251 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { in bdrv_op_unblock()
7252 if (blocker->reason == reason) { in bdrv_op_unblock()
7282 if (!QLIST_EMPTY(&bs->op_blockers[i])) { in bdrv_op_blocker_is_empty()
7316 if (!drv->create_opts) { in bdrv_img_create()
7318 drv->format_name); in bdrv_img_create()
7322 if (!proto_drv->create_opts) { in bdrv_img_create()
7324 proto_drv->format_name); in bdrv_img_create()
7329 create_opts = qemu_opts_append(create_opts, drv->create_opts); in bdrv_img_create()
7330 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); in bdrv_img_create()
7334 /* Parse -o options */ in bdrv_img_create()
7343 } else if (img_size != UINT64_C(-1)) { in bdrv_img_create()
7422 bs->drv->format_name); in bdrv_img_create()
7425 if (size == -1) { in bdrv_img_create()
7429 error_setg_errno(errp, -size, "Could not get size of '%s'", in bdrv_img_create()
7446 if (size == -1 && in bdrv_img_create()
7448 qemu_opt_get_bool(opts, "detached-header", false))) { in bdrv_img_create()
7462 if (ret == -EFBIG) { in bdrv_img_create()
7485 return bs ? bs->aio_context : qemu_get_aio_context(); in bdrv_get_aio_context()
7496 * Increase bs->in_flight to ensure that this operation is completed before in bdrv_co_enter()
7524 assert(!bs->walking_aio_notifiers); in bdrv_detach_aio_context()
7526 bs->walking_aio_notifiers = true; in bdrv_detach_aio_context()
7527 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) { in bdrv_detach_aio_context()
7528 if (baf->deleted) { in bdrv_detach_aio_context()
7531 baf->detach_aio_context(baf->opaque); in bdrv_detach_aio_context()
7534 /* Never mind iterating again to check for ->deleted. bdrv_close() will in bdrv_detach_aio_context()
7537 bs->walking_aio_notifiers = false; in bdrv_detach_aio_context()
7539 if (bs->drv && bs->drv->bdrv_detach_aio_context) { in bdrv_detach_aio_context()
7540 bs->drv->bdrv_detach_aio_context(bs); in bdrv_detach_aio_context()
7543 bs->aio_context = NULL; in bdrv_detach_aio_context()
7552 bs->aio_context = new_context; in bdrv_attach_aio_context()
7554 if (bs->drv && bs->drv->bdrv_attach_aio_context) { in bdrv_attach_aio_context()
7555 bs->drv->bdrv_attach_aio_context(bs, new_context); in bdrv_attach_aio_context()
7558 assert(!bs->walking_aio_notifiers); in bdrv_attach_aio_context()
7559 bs->walking_aio_notifiers = true; in bdrv_attach_aio_context()
7560 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) { in bdrv_attach_aio_context()
7561 if (ban->deleted) { in bdrv_attach_aio_context()
7564 ban->attached_aio_context(new_context, ban->opaque); in bdrv_attach_aio_context()
7567 bs->walking_aio_notifiers = false; in bdrv_attach_aio_context()
7601 if (!c->klass->change_aio_ctx) { in bdrv_parent_change_aio_context()
7607 if (!c->klass->change_aio_ctx(c, ctx, visited, tran, errp)) { in bdrv_parent_change_aio_context()
7615 * Changes the AioContext of @c->bs to @ctx and recursively for all its children
7634 return bdrv_change_aio_context(c->bs, ctx, visited, tran, errp); in bdrv_child_change_aio_context()
7647 BlockDriverState *bs = (BlockDriverState *) state->bs; in bdrv_set_aio_context_commit()
7648 AioContext *new_context = state->new_ctx; in bdrv_set_aio_context_commit()
7683 QLIST_FOREACH(c, &bs->parents, next_parent) { in bdrv_change_aio_context()
7689 QLIST_FOREACH(c, &bs->children, next) { in bdrv_change_aio_context()
7701 assert(bs->quiesce_counter > 0); in bdrv_change_aio_context()
7751 return -EPERM; in bdrv_try_change_aio_context_locked()
7793 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list); in bdrv_add_aio_context_notifier()
7805 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { in bdrv_remove_aio_context_notifier()
7806 if (ban->attached_aio_context == attached_aio_context && in bdrv_remove_aio_context_notifier()
7807 ban->detach_aio_context == detach_aio_context && in bdrv_remove_aio_context_notifier()
7808 ban->opaque == opaque && in bdrv_remove_aio_context_notifier()
7809 ban->deleted == false) in bdrv_remove_aio_context_notifier()
7811 if (bs->walking_aio_notifiers) { in bdrv_remove_aio_context_notifier()
7812 ban->deleted = true; in bdrv_remove_aio_context_notifier()
7829 if (!bs->drv) { in bdrv_amend_options()
7831 return -ENOMEDIUM; in bdrv_amend_options()
7833 if (!bs->drv->bdrv_amend_options) { in bdrv_amend_options()
7835 bs->drv->format_name); in bdrv_amend_options()
7836 return -ENOTSUP; in bdrv_amend_options()
7838 return bs->drv->bdrv_amend_options(bs, opts, status_cb, in bdrv_amend_options()
7861 if (!bs || !bs->drv) { in bdrv_recurse_can_replace()
7870 if (bs->drv->bdrv_recurse_can_replace) { in bdrv_recurse_can_replace()
7871 return bs->drv->bdrv_recurse_can_replace(bs, to_replace); in bdrv_recurse_can_replace()
7903 error_setg(errp, "Failed to find node with node-name='%s'", node_name); in check_to_replace_node()
7920 node_name, parent_bs->node_name); in check_to_replace_node()
7931 * "read-zeroes" options are strong, but its "latency-ns" option is
7949 if (curopt == &global_options[ARRAY_SIZE(global_options) - 1] && bs->drv) { in strong_options()
7950 curopt = bs->drv->strong_runtime_opts; in strong_options()
7957 * Copies all strong runtime options from bs->options to the given
7961 * Returns true iff any strong option was present in bs->options (and
7972 if (!bs->drv) { in append_strong_runtime_options()
7980 if ((*option_name)[strlen(*option_name) - 1] != '.') { in append_strong_runtime_options()
7981 QObject *entry = qdict_get(bs->options, *option_name); in append_strong_runtime_options()
7990 for (entry = qdict_first(bs->options); entry; in append_strong_runtime_options()
7991 entry = qdict_next(bs->options, entry)) in append_strong_runtime_options()
8013 qdict_put_str(d, "driver", bs->drv->format_name); in append_strong_runtime_options()
8021 * would result in exactly bs->backing. */
8025 if (bs->backing) { in bdrv_backing_overridden()
8026 return strcmp(bs->auto_backing_file, in bdrv_backing_overridden()
8027 bs->backing->bs->filename); in bdrv_backing_overridden()
8031 return bs->auto_backing_file[0] != '\0'; in bdrv_backing_overridden()
8036 * - exact_filename: A filename which may be used for opening a block device
8040 * - full_open_options: Options which, when given when opening a block device
8043 * - filename: If exact_filename is set, it is copied here. Otherwise,
8049 BlockDriver *drv = bs->drv; in bdrv_refresh_filename()
8065 QLIST_FOREACH(child, &bs->children, next) { in bdrv_refresh_filename()
8066 bdrv_refresh_filename(child->bs); in bdrv_refresh_filename()
8069 if (bs->implicit) { in bdrv_refresh_filename()
8071 child = QLIST_FIRST(&bs->children); in bdrv_refresh_filename()
8074 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), in bdrv_refresh_filename()
8075 child->bs->exact_filename); in bdrv_refresh_filename()
8076 pstrcpy(bs->filename, sizeof(bs->filename), child->bs->filename); in bdrv_refresh_filename()
8078 qobject_unref(bs->full_open_options); in bdrv_refresh_filename()
8079 bs->full_open_options = qobject_ref(child->bs->full_open_options); in bdrv_refresh_filename()
8086 if (bs->open_flags & BDRV_O_NO_IO) { in bdrv_refresh_filename()
8088 * Therefore, in such a case (primarily qemu-img), we can in bdrv_refresh_filename()
8099 if (drv->bdrv_gather_child_options) { in bdrv_refresh_filename()
8102 drv->bdrv_gather_child_options(bs, opts, backing_overridden); in bdrv_refresh_filename()
8104 QLIST_FOREACH(child, &bs->children, next) { in bdrv_refresh_filename()
8105 if (child == bs->backing && !backing_overridden) { in bdrv_refresh_filename()
8110 qdict_put(opts, child->name, in bdrv_refresh_filename()
8111 qobject_ref(child->bs->full_open_options)); in bdrv_refresh_filename()
8114 if (backing_overridden && !bs->backing) { in bdrv_refresh_filename()
8120 qobject_unref(bs->full_open_options); in bdrv_refresh_filename()
8121 bs->full_open_options = opts; in bdrv_refresh_filename()
8125 if (drv->bdrv_refresh_filename) { in bdrv_refresh_filename()
8128 bs->exact_filename[0] = '\0'; in bdrv_refresh_filename()
8130 drv->bdrv_refresh_filename(bs); in bdrv_refresh_filename()
8134 * file -- this only works for format nodes (filter nodes in bdrv_refresh_filename()
8141 bs->exact_filename[0] = '\0'; in bdrv_refresh_filename()
8145 * - it has a filename, in bdrv_refresh_filename()
8146 * - the current BDS is not a filter, in bdrv_refresh_filename()
8147 * - the file is a protocol BDS, and in bdrv_refresh_filename()
8148 * - opening that file (as this BDS's format) will automatically create in bdrv_refresh_filename()
8150 * - the user did not significantly change this BDS's behavior with in bdrv_refresh_filename()
8152 * - no non-file child of this BDS has been overridden by the user in bdrv_refresh_filename()
8155 if (primary_child_bs->exact_filename[0] && in bdrv_refresh_filename()
8156 primary_child_bs->drv->protocol_name && in bdrv_refresh_filename()
8157 !drv->is_filter && !generate_json_filename) in bdrv_refresh_filename()
8159 strcpy(bs->exact_filename, primary_child_bs->exact_filename); in bdrv_refresh_filename()
8163 if (bs->exact_filename[0]) { in bdrv_refresh_filename()
8164 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename); in bdrv_refresh_filename()
8166 GString *json = qobject_to_json(QOBJECT(bs->full_open_options)); in bdrv_refresh_filename()
8167 if (snprintf(bs->filename, sizeof(bs->filename), "json:%s", in bdrv_refresh_filename()
8168 json->str) >= sizeof(bs->filename)) { in bdrv_refresh_filename()
8170 strcpy(bs->filename + sizeof(bs->filename) - 4, "..."); in bdrv_refresh_filename()
8178 BlockDriver *drv = bs->drv; in bdrv_dirname()
8184 error_setg(errp, "Node '%s' is ejected", bs->node_name); in bdrv_dirname()
8188 if (drv->bdrv_dirname) { in bdrv_dirname()
8189 return drv->bdrv_dirname(bs, errp); in bdrv_dirname()
8198 if (bs->exact_filename[0] != '\0') { in bdrv_dirname()
8199 return path_combine(bs->exact_filename, ""); in bdrv_dirname()
8203 drv->format_name); in bdrv_dirname()
8217 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) { in bdrv_add_child()
8224 * Non-zoned block drivers do not follow zoned storage constraints in bdrv_add_child()
8225 * (i.e. sequential writes to zones). Refuse mixing zoned and non-zoned in bdrv_add_child()
8228 if (!parent_bs->drv->supports_zoned_children && in bdrv_add_child()
8229 child_bs->bl.zoned == BLK_Z_HM) { in bdrv_add_child()
8231 * The host-aware model allows zoned storage constraints and random in bdrv_add_child()
8232 * write. Allow mixing host-aware and non-zoned drivers. Using in bdrv_add_child()
8233 * host-aware device as a regular device. in bdrv_add_child()
8236 child_bs->bl.zoned == BLK_Z_HM ? "zoned" : "non-zoned", in bdrv_add_child()
8237 parent_bs->drv->supports_zoned_children ? in bdrv_add_child()
8242 if (!QLIST_EMPTY(&child_bs->parents)) { in bdrv_add_child()
8244 child_bs->node_name); in bdrv_add_child()
8248 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp); in bdrv_add_child()
8262 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) { in bdrv_del_child()
8268 QLIST_FOREACH(tmp, &parent_bs->children, next) { in bdrv_del_child()
8277 bdrv_get_device_or_node_name(child->bs)); in bdrv_del_child()
8281 parent_bs->drv->bdrv_del_child(parent_bs, child, errp); in bdrv_del_child()
8286 BlockDriver *drv = c->bs->drv; in bdrv_make_empty()
8290 assert(c->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)); in bdrv_make_empty()
8292 if (!drv->bdrv_make_empty) { in bdrv_make_empty()
8294 drv->format_name); in bdrv_make_empty()
8295 return -ENOTSUP; in bdrv_make_empty()
8298 ret = drv->bdrv_make_empty(c->bs); in bdrv_make_empty()
8300 error_setg_errno(errp, -ret, "Failed to empty %s", in bdrv_make_empty()
8301 c->bs->filename); in bdrv_make_empty()
8316 if (!bs || !bs->drv) { in bdrv_cow_child()
8320 if (bs->drv->is_filter) { in bdrv_cow_child()
8324 if (!bs->backing) { in bdrv_cow_child()
8328 assert(bs->backing->role & BDRV_CHILD_COW); in bdrv_cow_child()
8329 return bs->backing; in bdrv_cow_child()
8341 if (!bs || !bs->drv) { in bdrv_filter_child()
8345 if (!bs->drv->is_filter) { in bdrv_filter_child()
8350 assert(!(bs->backing && bs->file)); in bdrv_filter_child()
8352 c = bs->backing ?: bs->file; in bdrv_filter_child()
8357 assert(c->role & BDRV_CHILD_FILTERED); in bdrv_filter_child()
8363 * whichever is non-NULL.
8394 QLIST_FOREACH(c, &bs->children, next) { in bdrv_primary_child()
8395 if (c->role & BDRV_CHILD_PRIMARY) { in bdrv_primary_child()
8413 while (!(stop_on_explicit_filter && !bs->implicit)) { in bdrv_do_skip_filters()
8422 assert(!bs->drv || !bs->drv->is_filter); in bdrv_do_skip_filters()
8425 bs = c->bs; in bdrv_do_skip_filters()
8428 * Note that this treats nodes with bs->drv == NULL as not being in bdrv_do_skip_filters()
8429 * filters (bs->drv == NULL should be replaced by something else in bdrv_do_skip_filters()
8432 * always return a non-NULL value (given a non-NULL @bs). in bdrv_do_skip_filters()
8460 * For a backing chain, return the first non-filter backing image of
8461 * the first non-filter image.
8471 * block-status data region.
8473 * If so, and @pnum is not NULL, set *pnum to `bsc.data_end - offset`,
8481 BdrvBlockStatusCache *bsc = qatomic_rcu_read(&bs->block_status_cache); in bdrv_bsc_range_overlaps_locked()
8485 qatomic_read(&bsc->valid) && in bdrv_bsc_range_overlaps_locked()
8486 ranges_overlap(offset, bytes, bsc->data_start, in bdrv_bsc_range_overlaps_locked()
8487 bsc->data_end - bsc->data_start); in bdrv_bsc_range_overlaps_locked()
8490 *pnum = bsc->data_end - offset; in bdrv_bsc_range_overlaps_locked()
8516 qatomic_set(&bs->block_status_cache->valid, false); in bdrv_bsc_invalidate_range()
8535 QEMU_LOCK_GUARD(&bs->bsc_modify_lock); in bdrv_bsc_fill()
8537 old_bsc = qatomic_rcu_read(&bs->block_status_cache); in bdrv_bsc_fill()
8538 qatomic_rcu_set(&bs->block_status_cache, new_bsc); in bdrv_bsc_fill()