Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging (e7a1d6c5) · Commits · SUMMER2020 / students / proj-2021291

block.c

+116 −116

Original line number	Diff line number	Diff line
		@@ -955,53 +955,27 @@ free_and_fail:
		/*
		* Opens a file using a protocol (file, host_device, nbd, ...)
		*
		* options is a QDict of options to pass to the block drivers, or NULL for an
		* empty set of options. The reference to the QDict belongs to the block layer
		* after the call (even on failure), so if the caller intends to reuse the
		* dictionary, it needs to use QINCREF() before calling bdrv_file_open.
		* options is an indirect pointer to a QDict of options to pass to the block
		* drivers, or pointer to NULL for an empty set of options. If this function
		* takes ownership of the QDict reference, it will set *options to NULL;
		* otherwise, it will contain unused/unrecognized options after this function
		* returns. Then, the caller is responsible for freeing it. If it intends to
		* reuse the QDict, QINCREF() should be called beforehand.
		*/
		int bdrv_file_open(BlockDriverState *pbs, const char filename,
		const char reference, QDict options, int flags,
		Error **errp)
		static int bdrv_file_open(BlockDriverState bs, const char filename,
		QDict options, int flags, Error errp)
		{
		BlockDriverState *bs = NULL;
		BlockDriver *drv;
		const char *drvname;
		bool allow_protocol_prefix = false;
		Error *local_err = NULL;
		int ret;

		/* NULL means an empty set of options */
		if (options == NULL) {
		options = qdict_new();
		}

		if (reference) {
		if (filename \|\| qdict_size(options)) {
		error_setg(errp, "Cannot reference an existing block device with "
		"additional options or a new filename");
		return -EINVAL;
		}
		QDECREF(options);

		bs = bdrv_lookup_bs(reference, reference, errp);
		if (!bs) {
		return -ENODEV;
		}
		bdrv_ref(bs);
		*pbs = bs;
		return 0;
		}

		bs = bdrv_new("");
		bs->options = options;
		options = qdict_clone_shallow(options);

		/* Fetch the file name from the options QDict if necessary */
		if (!filename) {
		filename = qdict_get_try_str(options, "filename");
		} else if (filename && !qdict_haskey(options, "filename")) {
		qdict_put(options, "filename", qstring_from_str(filename));
		filename = qdict_get_try_str(*options, "filename");
		} else if (filename && !qdict_haskey(*options, "filename")) {
		qdict_put(*options, "filename", qstring_from_str(filename));
		allow_protocol_prefix = true;
		} else {
		error_setg(errp, "Can't specify 'file' and 'filename' options at the "
		@@ -1011,13 +985,13 @@ int bdrv_file_open(BlockDriverState *pbs, const char filename,
		}

		/* Find the right block driver */
		drvname = qdict_get_try_str(options, "driver");
		drvname = qdict_get_try_str(*options, "driver");
		if (drvname) {
		drv = bdrv_find_format(drvname);
		if (!drv) {
		error_setg(errp, "Unknown driver '%s'", drvname);
		}
		qdict_del(options, "driver");
		qdict_del(*options, "driver");
		} else if (filename) {
		drv = bdrv_find_protocol(filename, allow_protocol_prefix);
		if (!drv) {
		@@ -1036,46 +1010,30 @@ int bdrv_file_open(BlockDriverState *pbs, const char filename,

		/* Parse the filename and open it */
		if (drv->bdrv_parse_filename && filename) {
		drv->bdrv_parse_filename(filename, options, &local_err);
		drv->bdrv_parse_filename(filename, *options, &local_err);
		if (local_err) {
		error_propagate(errp, local_err);
		ret = -EINVAL;
		goto fail;
		}
		qdict_del(options, "filename");
		qdict_del(*options, "filename");
		}

		if (!drv->bdrv_file_open) {
		ret = bdrv_open(bs, filename, options, flags, drv, &local_err);
		options = NULL;
		ret = bdrv_open(&bs, filename, NULL, *options, flags, drv, &local_err);
		*options = NULL;
		} else {
		ret = bdrv_open_common(bs, NULL, options, flags, drv, &local_err);
		ret = bdrv_open_common(bs, NULL, *options, flags, drv, &local_err);
		}
		if (ret < 0) {
		error_propagate(errp, local_err);
		goto fail;
		}

		/* Check if any unknown options were used */
		if (options && (qdict_size(options) != 0)) {
		const QDictEntry *entry = qdict_first(options);
		error_setg(errp, "Block protocol '%s' doesn't support the option '%s'",
		drv->format_name, entry->key);
		ret = -EINVAL;
		goto fail;
		}
		QDECREF(options);

		bs->growable = 1;
		*pbs = bs;
		return 0;

		fail:
		QDECREF(options);
		if (!bs->drv) {
		QDECREF(bs->options);
		}
		bdrv_unref(bs);
		return ret;
		}

		@@ -1115,8 +1073,6 @@ int bdrv_open_backing_file(BlockDriverState bs, QDict options, Error **errp)
		sizeof(backing_filename));
		}

		bs->backing_hd = bdrv_new("");

		if (bs->backing_format[0] != '\0') {
		back_drv = bdrv_find_format(bs->backing_format);
		}
		@@ -1125,11 +1081,11 @@ int bdrv_open_backing_file(BlockDriverState bs, QDict options, Error **errp)
		back_flags = bs->open_flags & ~(BDRV_O_RDWR \| BDRV_O_SNAPSHOT \|
		BDRV_O_COPY_ON_READ);

		ret = bdrv_open(bs->backing_hd,
		*backing_filename ? backing_filename : NULL, options,
		assert(bs->backing_hd == NULL);
		ret = bdrv_open(&bs->backing_hd,
		*backing_filename ? backing_filename : NULL, NULL, options,
		back_flags, back_drv, &local_err);
		if (ret < 0) {
		bdrv_unref(bs->backing_hd);
		bs->backing_hd = NULL;
		bs->open_flags \|= BDRV_O_NO_BACKING;
		error_setg(errp, "Could not open backing file: %s",
		@@ -1153,10 +1109,6 @@ int bdrv_open_backing_file(BlockDriverState bs, QDict options, Error **errp)
		* Opens a disk image whose options are given as BlockdevRef in another block
		* device's options.
		*
		* If force_raw is true, bdrv_file_open() will be used, thereby preventing any
		* image format auto-detection. If it is false and a filename is given,
		* bdrv_open() will be used for auto-detection.
		*
		* If allow_none is true, no image will be opened if filename is false and no
		* BlockdevRef is given. *pbs will remain unchanged and 0 will be returned.
		*
		@@ -1166,16 +1118,21 @@ int bdrv_open_backing_file(BlockDriverState bs, QDict options, Error **errp)
		* BlockdevRef.
		*
		* The BlockdevRef will be removed from the options QDict.
		*
		* To conform with the behavior of bdrv_open(), *pbs has to be NULL.
		*/
		int bdrv_open_image(BlockDriverState *pbs, const char filename,
		QDict options, const char bdref_key, int flags,
		bool force_raw, bool allow_none, Error **errp)
		bool allow_none, Error **errp)
		{
		QDict *image_options;
		int ret;
		char *bdref_key_dot;
		const char *reference;

		assert(pbs);
		assert(*pbs == NULL);

		bdref_key_dot = g_strdup_printf("%s.", bdref_key);
		qdict_extract_subqdict(options, &image_options, bdref_key_dot);
		g_free(bdref_key_dot);
		@@ -1192,30 +1149,7 @@ int bdrv_open_image(BlockDriverState *pbs, const char filename,
		goto done;
		}

		if (filename && !force_raw) {
		/* If a filename is given and the block driver should be detected
		automatically (instead of using none), use bdrv_open() in order to do
		that auto-detection. */
		BlockDriverState *bs;

		if (reference) {
		error_setg(errp, "Cannot reference an existing block device while "
		"giving a filename");
		ret = -EINVAL;
		goto done;
		}

		bs = bdrv_new("");
		ret = bdrv_open(bs, filename, image_options, flags, NULL, errp);
		if (ret < 0) {
		bdrv_unref(bs);
		} else {
		*pbs = bs;
		}
		} else {
		ret = bdrv_file_open(pbs, filename, reference, image_options, flags,
		errp);
		}
		ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp);

		done:
		qdict_del(options, bdref_key);
		@@ -1229,17 +1163,58 @@ done:
		* empty set of options. The reference to the QDict belongs to the block layer
		* after the call (even on failure), so if the caller intends to reuse the
		* dictionary, it needs to use QINCREF() before calling bdrv_open.
		*
		* If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
		* If it is not NULL, the referenced BDS will be reused.
		*
		* The reference parameter may be used to specify an existing block device which
		* should be opened. If specified, neither options nor a filename may be given,
		* nor can an existing BDS be reused (that is, *pbs has to be NULL).
		*/
		int bdrv_open(BlockDriverState bs, const char filename, QDict *options,
		int flags, BlockDriver drv, Error *errp)
		int bdrv_open(BlockDriverState *pbs, const char filename,
		const char reference, QDict options, int flags,
		BlockDriver drv, Error *errp)
		{
		int ret;
		/* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */
		char tmp_filename[PATH_MAX + 1];
		BlockDriverState *file = NULL;
		BlockDriverState file = NULL, bs;
		const char *drvname;
		Error *local_err = NULL;

		assert(pbs);

		if (reference) {
		bool options_non_empty = options ? qdict_size(options) : false;
		QDECREF(options);

		if (*pbs) {
		error_setg(errp, "Cannot reuse an existing BDS when referencing "
		"another block device");
		return -EINVAL;
		}

		if (filename \|\| options_non_empty) {
		error_setg(errp, "Cannot reference an existing block device with "
		"additional options or a new filename");
		return -EINVAL;
		}

		bs = bdrv_lookup_bs(reference, reference, errp);
		if (!bs) {
		return -ENODEV;
		}
		bdrv_ref(bs);
		*pbs = bs;
		return 0;
		}

		if (*pbs) {
		bs = *pbs;
		} else {
		bs = bdrv_new("");
		}

		/* NULL means an empty set of options */
		if (options == NULL) {
		options = qdict_new();
		@@ -1248,6 +1223,19 @@ int bdrv_open(BlockDriverState bs, const char filename, QDict *options,
		bs->options = options;
		options = qdict_clone_shallow(options);

		if (flags & BDRV_O_PROTOCOL) {
		assert(!drv);
		ret = bdrv_file_open(bs, filename, &options, flags & ~BDRV_O_PROTOCOL,
		&local_err);
		if (!ret) {
		goto done;
		} else if (bs->drv) {
		goto close_and_fail;
		} else {
		goto fail;
		}
		}

		/* For snapshot=on, create a temporary qcow2 overlay */
		if (flags & BDRV_O_SNAPSHOT) {
		BlockDriverState *bs1;
		@@ -1260,12 +1248,11 @@ int bdrv_open(BlockDriverState bs, const char filename, QDict *options,
		instead of opening 'filename' directly */

		/* Get the required size from the image */
		bs1 = bdrv_new("");
		QINCREF(options);
		ret = bdrv_open(bs1, filename, options, BDRV_O_NO_BACKING,
		bs1 = NULL;
		ret = bdrv_open(&bs1, filename, NULL, options, BDRV_O_NO_BACKING,
		drv, &local_err);
		if (ret < 0) {
		bdrv_unref(bs1);
		goto fail;
		}
		total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK;
		@@ -1322,9 +1309,10 @@ int bdrv_open(BlockDriverState bs, const char filename, QDict *options,
		flags \|= BDRV_O_ALLOW_RDWR;
		}

		assert(file == NULL);
		ret = bdrv_open_image(&file, filename, options, "file",
		bdrv_open_flags(bs, flags \| BDRV_O_UNMAP), true, true,
		&local_err);
		bdrv_open_flags(bs, flags \| BDRV_O_UNMAP) \|
		BDRV_O_PROTOCOL, true, &local_err);
		if (ret < 0) {
		goto fail;
		}
		@@ -1377,12 +1365,18 @@ int bdrv_open(BlockDriverState bs, const char filename, QDict *options,
		}
		}

		done:
		/* Check if any unknown options were used */
		if (qdict_size(options) != 0) {
		if (options && (qdict_size(options) != 0)) {
		const QDictEntry *entry = qdict_first(options);
		if (flags & BDRV_O_PROTOCOL) {
		error_setg(errp, "Block protocol '%s' doesn't support the option "
		"'%s'", drv->format_name, entry->key);
		} else {
		error_setg(errp, "Block format '%s' used by device '%s' doesn't "
		"support the option '%s'", drv->format_name, bs->device_name,
		entry->key);
		"support the option '%s'", drv->format_name,
		bs->device_name, entry->key);
		}

		ret = -EINVAL;
		goto close_and_fail;
		@@ -1393,6 +1387,7 @@ int bdrv_open(BlockDriverState bs, const char filename, QDict *options,
		bdrv_dev_change_media_cb(bs, true);
		}

		*pbs = bs;
		return 0;

		unlink_and_fail:
		@@ -1406,13 +1401,24 @@ fail:
		QDECREF(bs->options);
		QDECREF(options);
		bs->options = NULL;
		if (!*pbs) {
		/* If *pbs is NULL, a new BDS has been created in this function and
		needs to be freed now. Otherwise, it does not need to be closed,
		since it has not really been opened yet. */
		bdrv_unref(bs);
		}
		if (local_err) {
		error_propagate(errp, local_err);
		}
		return ret;

		close_and_fail:
		/* See fail path, but now the BDS has to be always closed */
		if (*pbs) {
		bdrv_close(bs);
		} else {
		bdrv_unref(bs);
		}
		QDECREF(options);
		if (local_err) {
		error_propagate(errp, local_err);
		@@ -5290,9 +5296,8 @@ void bdrv_img_create(const char filename, const char fmt,
		back_flags =
		flags & ~(BDRV_O_RDWR \| BDRV_O_SNAPSHOT \| BDRV_O_NO_BACKING);

		bs = bdrv_new("");

		ret = bdrv_open(bs, backing_file->value.s, NULL, back_flags,
		bs = NULL;
		ret = bdrv_open(&bs, backing_file->value.s, NULL, NULL, back_flags,
		backing_drv, &local_err);
		if (ret < 0) {
		error_setg_errno(errp, -ret, "Could not open '%s': %s",
		@@ -5300,7 +5305,6 @@ void bdrv_img_create(const char filename, const char fmt,
		error_get_pretty(local_err));
		error_free(local_err);
		local_err = NULL;
		bdrv_unref(bs);
		goto out;
		}
		bdrv_get_geometry(bs, &size);
		@@ -5416,11 +5420,7 @@ bool bdrv_is_first_non_filter(BlockDriverState *candidate)
		QTAILQ_FOREACH(bs, &bdrv_states, device_list) {
		bool perm;

		if (!bs->file) {
		continue;
		}

		perm = bdrv_recurse_is_first_non_filter(bs->file, candidate);
		perm = bdrv_recurse_is_first_non_filter(bs, candidate);

		/* candidate is the first non filter */
		if (perm) {

block/Makefile.objs

+1 −0

Original line number	Diff line number	Diff line
		@@ -3,6 +3,7 @@ block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-c
		block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o
		block-obj-y += qed-check.o
		block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o vhdx-log.o
		block-obj-$(CONFIG_QUORUM) += quorum.o
		block-obj-y += parallels.o blkdebug.o blkverify.o
		block-obj-y += snapshot.o qapi.o
		block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o

block/blkdebug.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -410,8 +410,9 @@ static int blkdebug_open(BlockDriverState bs, QDict options, int flags,
		s->state = 1;

		/* Open the backing file */
		assert(bs->file == NULL);
		ret = bdrv_open_image(&bs->file, qemu_opt_get(opts, "x-image"), options, "image",
		flags, true, false, &local_err);
		flags \| BDRV_O_PROTOCOL, false, &local_err);
		if (ret < 0) {
		error_propagate(errp, local_err);
		goto out;

block/blkverify.c

+6 −108

Original line number	Diff line number	Diff line
		@@ -135,16 +135,18 @@ static int blkverify_open(BlockDriverState bs, QDict options, int flags,
		}

		/* Open the raw file */
		assert(bs->file == NULL);
		ret = bdrv_open_image(&bs->file, qemu_opt_get(opts, "x-raw"), options,
		"raw", flags, true, false, &local_err);
		"raw", flags \| BDRV_O_PROTOCOL, false, &local_err);
		if (ret < 0) {
		error_propagate(errp, local_err);
		goto fail;
		}

		/* Open the test file */
		assert(s->test_file == NULL);
		ret = bdrv_open_image(&s->test_file, qemu_opt_get(opts, "x-image"), options,
		"test", flags, false, false, &local_err);
		"test", flags, false, &local_err);
		if (ret < 0) {
		error_propagate(errp, local_err);
		s->test_file = NULL;
		@@ -171,110 +173,6 @@ static int64_t blkverify_getlength(BlockDriverState *bs)
		return bdrv_getlength(s->test_file);
		}

		/**
		* Check that I/O vector contents are identical
		*
		* @a: I/O vector
		* @b: I/O vector
		* @ret: Offset to first mismatching byte or -1 if match
		*/
		static ssize_t blkverify_iovec_compare(QEMUIOVector a, QEMUIOVector b)
		{
		int i;
		ssize_t offset = 0;

		assert(a->niov == b->niov);
		for (i = 0; i < a->niov; i++) {
		size_t len = 0;
		uint8_t p = (uint8_t )a->iov[i].iov_base;
		uint8_t q = (uint8_t )b->iov[i].iov_base;

		assert(a->iov[i].iov_len == b->iov[i].iov_len);
		while (len < a->iov[i].iov_len && p++ == q++) {
		len++;
		}

		offset += len;

		if (len != a->iov[i].iov_len) {
		return offset;
		}
		}
		return -1;
		}

		typedef struct {
		int src_index;
		struct iovec *src_iov;
		void *dest_base;
		} IOVectorSortElem;

		static int sortelem_cmp_src_base(const void a, const void b)
		{
		const IOVectorSortElem *elem_a = a;
		const IOVectorSortElem *elem_b = b;

		/* Don't overflow */
		if (elem_a->src_iov->iov_base < elem_b->src_iov->iov_base) {
		return -1;
		} else if (elem_a->src_iov->iov_base > elem_b->src_iov->iov_base) {
		return 1;
		} else {
		return 0;
		}
		}

		static int sortelem_cmp_src_index(const void a, const void b)
		{
		const IOVectorSortElem *elem_a = a;
		const IOVectorSortElem *elem_b = b;

		return elem_a->src_index - elem_b->src_index;
		}

		/**
		* Copy contents of I/O vector
		*
		* The relative relationships of overlapping iovecs are preserved. This is
		* necessary to ensure identical semantics in the cloned I/O vector.
		*/
		static void blkverify_iovec_clone(QEMUIOVector dest, const QEMUIOVector src,
		void *buf)
		{
		IOVectorSortElem sortelems[src->niov];
		void *last_end;
		int i;

		/* Sort by source iovecs by base address */
		for (i = 0; i < src->niov; i++) {
		sortelems[i].src_index = i;
		sortelems[i].src_iov = &src->iov[i];
		}
		qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_base);

		/* Allocate buffer space taking into account overlapping iovecs */
		last_end = NULL;
		for (i = 0; i < src->niov; i++) {
		struct iovec *cur = sortelems[i].src_iov;
		ptrdiff_t rewind = 0;

		/* Detect overlap */
		if (last_end && last_end > cur->iov_base) {
		rewind = last_end - cur->iov_base;
		}

		sortelems[i].dest_base = buf - rewind;
		buf += cur->iov_len - MIN(rewind, cur->iov_len);
		last_end = MAX(cur->iov_base + cur->iov_len, last_end);
		}

		/* Sort by source iovec index and build destination iovec */
		qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_index);
		for (i = 0; i < src->niov; i++) {
		qemu_iovec_add(dest, sortelems[i].dest_base, src->iov[i].iov_len);
		}
		}

		static BlkverifyAIOCB blkverify_aio_get(BlockDriverState bs, bool is_write,
		int64_t sector_num, QEMUIOVector *qiov,
		int nb_sectors,
		@@ -338,7 +236,7 @@ static void blkverify_aio_cb(void *opaque, int ret)

		static void blkverify_verify_readv(BlkverifyAIOCB *acb)
		{
		ssize_t offset = blkverify_iovec_compare(acb->qiov, &acb->raw_qiov);
		ssize_t offset = qemu_iovec_compare(acb->qiov, &acb->raw_qiov);
		if (offset != -1) {
		blkverify_err(acb, "contents mismatch in sector %" PRId64,
		acb->sector_num + (int64_t)(offset / BDRV_SECTOR_SIZE));
		@@ -356,7 +254,7 @@ static BlockDriverAIOCB blkverify_aio_readv(BlockDriverState bs,
		acb->verify = blkverify_verify_readv;
		acb->buf = qemu_blockalign(bs->file, qiov->size);
		qemu_iovec_init(&acb->raw_qiov, acb->qiov->niov);
		blkverify_iovec_clone(&acb->raw_qiov, qiov, acb->buf);
		qemu_iovec_clone(&acb->raw_qiov, qiov, acb->buf);

		bdrv_aio_readv(s->test_file, sector_num, qiov, nb_sectors,
		blkverify_aio_cb, acb);

block/bochs.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -129,7 +129,8 @@ static int bochs_open(BlockDriverState bs, QDict options, int flags,
		strcmp(bochs.subtype, GROWING_TYPE) \|\|
		((le32_to_cpu(bochs.version) != HEADER_VERSION) &&
		(le32_to_cpu(bochs.version) != HEADER_V1))) {
		return -EMEDIUMTYPE;
		error_setg(errp, "Image not in Bochs format");
		return -EINVAL;
		}

		if (le32_to_cpu(bochs.version) == HEADER_V1) {