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

block/block-backend.c

+17 −10

Original line number	Diff line number	Diff line
		@@ -820,7 +820,7 @@ int blk_write_zeroes(BlockBackend *blk, int64_t sector_num,
		int nb_sectors, BdrvRequestFlags flags)
		{
		return blk_rw(blk, sector_num, NULL, nb_sectors, blk_write_entry,
		BDRV_REQ_ZERO_WRITE);
		flags \| BDRV_REQ_ZERO_WRITE);
		}

		static void error_callback_bh(void *opaque)
		@@ -852,6 +852,7 @@ BlockAIOCB blk_abort_aio_request(BlockBackend blk,
		typedef struct BlkAioEmAIOCB {
		BlockAIOCB common;
		BlkRwCo rwco;
		int bytes;
		bool has_returned;
		QEMUBH* bh;
		} BlkAioEmAIOCB;
		@@ -877,7 +878,7 @@ static void blk_aio_complete_bh(void *opaque)
		blk_aio_complete(opaque);
		}

		static BlockAIOCB blk_aio_prwv(BlockBackend blk, int64_t offset,
		static BlockAIOCB blk_aio_prwv(BlockBackend blk, int64_t offset, int bytes,
		QEMUIOVector *qiov, CoroutineEntry co_entry,
		BdrvRequestFlags flags,
		BlockCompletionFunc cb, void opaque)
		@@ -893,6 +894,7 @@ static BlockAIOCB blk_aio_prwv(BlockBackend blk, int64_t offset,
		.flags = flags,
		.ret = NOT_DONE,
		};
		acb->bytes = bytes;
		acb->bh = NULL;
		acb->has_returned = false;

		@@ -913,7 +915,8 @@ static void blk_aio_read_entry(void *opaque)
		BlkAioEmAIOCB *acb = opaque;
		BlkRwCo *rwco = &acb->rwco;

		rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, rwco->qiov->size,
		assert(rwco->qiov->size == acb->bytes);
		rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, acb->bytes,
		rwco->qiov, rwco->flags);
		blk_aio_complete(acb);
		}
		@@ -923,8 +926,8 @@ static void blk_aio_write_entry(void *opaque)
		BlkAioEmAIOCB *acb = opaque;
		BlkRwCo *rwco = &acb->rwco;

		rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset,
		rwco->qiov ? rwco->qiov->size : 0,
		assert(!rwco->qiov \|\| rwco->qiov->size == acb->bytes);
		rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, acb->bytes,
		rwco->qiov, rwco->flags);
		blk_aio_complete(acb);
		}
		@@ -937,8 +940,10 @@ BlockAIOCB blk_aio_write_zeroes(BlockBackend blk, int64_t sector_num,
		return blk_abort_aio_request(blk, cb, opaque, -EINVAL);
		}

		return blk_aio_prwv(blk, sector_num << BDRV_SECTOR_BITS, NULL,
		blk_aio_write_entry, BDRV_REQ_ZERO_WRITE, cb, opaque);
		return blk_aio_prwv(blk, sector_num << BDRV_SECTOR_BITS,
		nb_sectors << BDRV_SECTOR_BITS, NULL,
		blk_aio_write_entry, flags \| BDRV_REQ_ZERO_WRITE,
		cb, opaque);
		}

		int blk_pread(BlockBackend blk, int64_t offset, void buf, int count)
		@@ -994,7 +999,8 @@ BlockAIOCB blk_aio_readv(BlockBackend blk, int64_t sector_num,
		return blk_abort_aio_request(blk, cb, opaque, -EINVAL);
		}

		return blk_aio_prwv(blk, sector_num << BDRV_SECTOR_BITS, iov,
		assert(nb_sectors << BDRV_SECTOR_BITS == iov->size);
		return blk_aio_prwv(blk, sector_num << BDRV_SECTOR_BITS, iov->size, iov,
		blk_aio_read_entry, 0, cb, opaque);
		}

		@@ -1006,7 +1012,8 @@ BlockAIOCB blk_aio_writev(BlockBackend blk, int64_t sector_num,
		return blk_abort_aio_request(blk, cb, opaque, -EINVAL);
		}

		return blk_aio_prwv(blk, sector_num << BDRV_SECTOR_BITS, iov,
		assert(nb_sectors << BDRV_SECTOR_BITS == iov->size);
		return blk_aio_prwv(blk, sector_num << BDRV_SECTOR_BITS, iov->size, iov,
		blk_aio_write_entry, 0, cb, opaque);
		}

		@@ -1446,7 +1453,7 @@ int coroutine_fn blk_co_write_zeroes(BlockBackend *blk, int64_t sector_num,

		return blk_co_pwritev(blk, sector_num << BDRV_SECTOR_BITS,
		nb_sectors << BDRV_SECTOR_BITS, NULL,
		BDRV_REQ_ZERO_WRITE);
		flags \| BDRV_REQ_ZERO_WRITE);
		}

		int blk_write_compressed(BlockBackend *blk, int64_t sector_num,

block/vpc.c

+58 −44

Original line number	Diff line number	Diff line
		@@ -45,34 +45,34 @@ enum vhd_type {
		VHD_DIFFERENCING = 4,
		};

		// Seconds since Jan 1, 2000 0:00:00 (UTC)
		/* Seconds since Jan 1, 2000 0:00:00 (UTC) */
		#define VHD_TIMESTAMP_BASE 946684800

		#define VHD_CHS_MAX_C 65535LL
		#define VHD_CHS_MAX_H 16
		#define VHD_CHS_MAX_S 255

		#define VHD_MAX_SECTORS (65535LL * 255 * 255)
		#define VHD_MAX_SECTORS 0xff000000 /* 2040 GiB max image size */
		#define VHD_MAX_GEOMETRY (VHD_CHS_MAX_C * VHD_CHS_MAX_H * VHD_CHS_MAX_S)

		#define VPC_OPT_FORCE_SIZE "force_size"

		// always big-endian
		/* always big-endian */
		typedef struct vhd_footer {
		char creator[8]; // "conectix"
		char creator[8]; /* "conectix" */
		uint32_t features;
		uint32_t version;

		// Offset of next header structure, 0xFFFFFFFF if none
		/* Offset of next header structure, 0xFFFFFFFF if none */
		uint64_t data_offset;

		// Seconds since Jan 1, 2000 0:00:00 (UTC)
		/* Seconds since Jan 1, 2000 0:00:00 (UTC) */
		uint32_t timestamp;

		char creator_app[4]; // "vpc "
		char creator_app[4]; /* e.g., "vpc " */
		uint16_t major;
		uint16_t minor;
		char creator_os[4]; // "Wi2k"
		char creator_os[4]; /* "Wi2k" */

		uint64_t orig_size;
		uint64_t current_size;
		@@ -83,29 +83,29 @@ typedef struct vhd_footer {

		uint32_t type;

		// Checksum of the Hard Disk Footer ("one's complement of the sum of all
		// the bytes in the footer without the checksum field")
		/* Checksum of the Hard Disk Footer ("one's complement of the sum of all
		the bytes in the footer without the checksum field") */
		uint32_t checksum;

		// UUID used to identify a parent hard disk (backing file)
		/* UUID used to identify a parent hard disk (backing file) */
		uint8_t uuid[16];

		uint8_t in_saved_state;
		} QEMU_PACKED VHDFooter;

		typedef struct vhd_dyndisk_header {
		char magic[8]; // "cxsparse"
		char magic[8]; /* "cxsparse" */

		// Offset of next header structure, 0xFFFFFFFF if none
		/* Offset of next header structure, 0xFFFFFFFF if none */
		uint64_t data_offset;

		// Offset of the Block Allocation Table (BAT)
		/* Offset of the Block Allocation Table (BAT) */
		uint64_t table_offset;

		uint32_t version;
		uint32_t max_table_entries; // 32bit/entry
		uint32_t max_table_entries; /* 32bit/entry */

		// 2 MB by default, must be a power of two
		/* 2 MB by default, must be a power of two */
		uint32_t block_size;

		uint32_t checksum;
		@@ -113,7 +113,7 @@ typedef struct vhd_dyndisk_header {
		uint32_t parent_timestamp;
		uint32_t reserved;

		// Backing file name (in UTF-16)
		/* Backing file name (in UTF-16) */
		uint8_t parent_name[512];

		struct {
		@@ -238,6 +238,7 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,

		ret = bdrv_pread(bs->file->bs, 0, s->footer_buf, HEADER_SIZE);
		if (ret < 0) {
		error_setg(errp, "Unable to read VHD header");
		goto fail;
		}

		@@ -246,9 +247,11 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,
		int64_t offset = bdrv_getlength(bs->file->bs);
		if (offset < 0) {
		ret = offset;
		error_setg(errp, "Invalid file size");
		goto fail;
		} else if (offset < HEADER_SIZE) {
		ret = -EINVAL;
		error_setg(errp, "File too small for a VHD header");
		goto fail;
		}

		@@ -275,9 +278,9 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,
		/* Write 'checksum' back to footer, or else will leave it with zero. */
		footer->checksum = cpu_to_be32(checksum);

		// The visible size of a image in Virtual PC depends on the geometry
		// rather than on the size stored in the footer (the size in the footer
		// is too large usually)
		/* The visible size of a image in Virtual PC depends on the geometry
		rather than on the size stored in the footer (the size in the footer
		is too large usually) */
		bs->total_sectors = (int64_t)
		be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;

		@@ -299,6 +302,8 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,
		* 'qem2' : current_size QEMU (uses current_size)
		* 'win ' : current_size Hyper-V
		* 'd2v ' : current_size Disk2vhd
		* 'tap\0' : current_size XenServer
		* 'CTXS' : current_size XenConverter
		*
		* The user can override the table values via drive options, however
		* even with an override we will still use current_size for images
		@@ -306,15 +311,17 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,
		*/
		use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
		!!strncmp(footer->creator_app, "qem2", 4) &&
		!!strncmp(footer->creator_app, "d2v ", 4)) \|\| s->force_use_chs;
		!!strncmp(footer->creator_app, "d2v ", 4) &&
		!!strncmp(footer->creator_app, "CTXS", 4) &&
		!!memcmp(footer->creator_app, "tap", 4)) \|\| s->force_use_chs;

		if (!use_chs \|\| bs->total_sectors == VHD_MAX_GEOMETRY \|\| s->force_use_sz) {
		bs->total_sectors = be64_to_cpu(footer->current_size) /
		BDRV_SECTOR_SIZE;
		}

		/* Allow a maximum disk size of approximately 2 TB */
		if (bs->total_sectors >= VHD_MAX_SECTORS) {
		/* Allow a maximum disk size of 2040 GiB */
		if (bs->total_sectors > VHD_MAX_SECTORS) {
		ret = -EFBIG;
		goto fail;
		}
		@@ -323,12 +330,14 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,
		ret = bdrv_pread(bs->file->bs, be64_to_cpu(footer->data_offset), buf,
		HEADER_SIZE);
		if (ret < 0) {
		error_setg(errp, "Error reading dynamic VHD header");
		goto fail;
		}

		dyndisk_header = (VHDDynDiskHeader *) buf;

		if (strncmp(dyndisk_header->magic, "cxsparse", 8)) {
		error_setg(errp, "Invalid header magic");
		ret = -EINVAL;
		goto fail;
		}
		@@ -344,16 +353,14 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,
		s->max_table_entries = be32_to_cpu(dyndisk_header->max_table_entries);

		if ((bs->total_sectors * 512) / s->block_size > 0xffffffffU) {
		ret = -EINVAL;
		goto fail;
		}
		if (s->max_table_entries > (VHD_MAX_SECTORS * 512) / s->block_size) {
		error_setg(errp, "Too many blocks");
		ret = -EINVAL;
		goto fail;
		}

		computed_size = (uint64_t) s->max_table_entries * s->block_size;
		if (computed_size < bs->total_sectors * 512) {
		error_setg(errp, "Page table too small");
		ret = -EINVAL;
		goto fail;
		}
		@@ -370,6 +377,7 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,

		s->pagetable = qemu_try_blockalign(bs->file->bs, pagetable_size);
		if (s->pagetable == NULL) {
		error_setg(errp, "Unable to allocate memory for page table");
		ret = -ENOMEM;
		goto fail;
		}
		@@ -379,6 +387,7 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,
		ret = bdrv_pread(bs->file->bs, s->bat_offset, s->pagetable,
		pagetable_size);
		if (ret < 0) {
		error_setg(errp, "Error reading pagetable");
		goto fail;
		}

		@@ -457,16 +466,16 @@ static inline int64_t get_sector_offset(BlockDriverState *bs,
		pageentry_index = (offset % s->block_size) / 512;

		if (pagetable_index >= s->max_table_entries \|\| s->pagetable[pagetable_index] == 0xffffffff)
		return -1; // not allocated
		return -1; /* not allocated */

		bitmap_offset = 512 * (uint64_t) s->pagetable[pagetable_index];
		block_offset = bitmap_offset + s->bitmap_size + (512 * pageentry_index);

		// We must ensure that we don't write to any sectors which are marked as
		// unused in the bitmap. We get away with setting all bits in the block
		// bitmap each time we write to a new block. This might cause Virtual PC to
		// miss sparse read optimization, but it's not a problem in terms of
		// correctness.
		/* We must ensure that we don't write to any sectors which are marked as
		unused in the bitmap. We get away with setting all bits in the block
		bitmap each time we write to a new block. This might cause Virtual PC to
		miss sparse read optimization, but it's not a problem in terms of
		correctness. */
		if (write && (s->last_bitmap_offset != bitmap_offset)) {
		uint8_t bitmap[s->bitmap_size];

		@@ -512,18 +521,18 @@ static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
		int ret;
		uint8_t bitmap[s->bitmap_size];

		// Check if sector_num is valid
		/* Check if sector_num is valid */
		if ((sector_num < 0) \|\| (sector_num > bs->total_sectors))
		return -1;

		// Write entry into in-memory BAT
		/* Write entry into in-memory BAT */
		index = (sector_num * 512) / s->block_size;
		if (s->pagetable[index] != 0xFFFFFFFF)
		return -1;

		s->pagetable[index] = s->free_data_block_offset / 512;

		// Initialize the block's bitmap
		/* Initialize the block's bitmap */
		memset(bitmap, 0xff, s->bitmap_size);
		ret = bdrv_pwrite_sync(bs->file->bs, s->free_data_block_offset, bitmap,
		s->bitmap_size);
		@@ -531,13 +540,13 @@ static int64_t alloc_block(BlockDriverState* bs, int64_t sector_num)
		return ret;
		}

		// Write new footer (the old one will be overwritten)
		/* Write new footer (the old one will be overwritten) */
		s->free_data_block_offset += s->block_size + s->bitmap_size;
		ret = rewrite_footer(bs);
		if (ret < 0)
		goto fail;

		// Write BAT entry to disk
		/* Write BAT entry to disk */
		bat_offset = s->bat_offset + (4 * index);
		bat_value = cpu_to_be32(s->pagetable[index]);
		ret = bdrv_pwrite_sync(bs->file->bs, bat_offset, &bat_value, 4);
		@@ -718,7 +727,7 @@ static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
		* Note that the geometry doesn't always exactly match total_sectors but
		* may round it down.
		*
		* Returns 0 on success, -EFBIG if the size is larger than ~2 TB. Override
		* Returns 0 on success, -EFBIG if the size is larger than 2040 GiB. Override
		* the hardware EIDE and ATA-2 limit of 16 heads (max disk size of 127 GB)
		* and instead allow up to 255 heads.
		*/
		@@ -770,7 +779,7 @@ static int create_dynamic_disk(BlockBackend blk, uint8_t buf,
		int ret;
		int64_t offset = 0;

		// Write the footer (twice: at the beginning and at the end)
		/* Write the footer (twice: at the beginning and at the end) */
		block_size = 0x200000;
		num_bat_entries = (total_sectors + block_size / 512) / (block_size / 512);

		@@ -785,7 +794,7 @@ static int create_dynamic_disk(BlockBackend blk, uint8_t buf,
		goto fail;
		}

		// Write the initial BAT
		/* Write the initial BAT */
		offset = 3 * 512;

		memset(buf, 0xFF, 512);
		@@ -797,7 +806,7 @@ static int create_dynamic_disk(BlockBackend blk, uint8_t buf,
		offset += 512;
		}

		// Prepare the Dynamic Disk Header
		/* Prepare the Dynamic Disk Header */
		memset(buf, 0, 1024);

		memcpy(dyndisk_header->magic, "cxsparse", 8);
		@@ -814,7 +823,7 @@ static int create_dynamic_disk(BlockBackend blk, uint8_t buf,

		dyndisk_header->checksum = cpu_to_be32(vpc_checksum(buf, 1024));

		// Write the header
		/* Write the header */
		offset = 512;

		ret = blk_pwrite(blk, offset, buf, 1024);
		@@ -874,6 +883,7 @@ static int vpc_create(const char filename, QemuOpts opts, Error **errp)
		} else if (!strcmp(disk_type_param, "fixed")) {
		disk_type = VHD_FIXED;
		} else {
		error_setg(errp, "Invalid disk type, %s", disk_type_param);
		ret = -EINVAL;
		goto out;
		}
		@@ -922,8 +932,9 @@ static int vpc_create(const char filename, QemuOpts opts, Error **errp)

		if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) {
		total_sectors = total_size / BDRV_SECTOR_SIZE;
		/* Allow a maximum disk size of approximately 2 TB */
		/* Allow a maximum disk size of 2040 GiB */
		if (total_sectors > VHD_MAX_SECTORS) {
		error_setg(errp, "Disk size is too large, max size is 2040 GiB");
		ret = -EFBIG;
		goto out;
		}
		@@ -974,6 +985,9 @@ static int vpc_create(const char filename, QemuOpts opts, Error **errp)
		} else {
		ret = create_fixed_disk(blk, buf, total_size);
		}
		if (ret < 0) {
		error_setg(errp, "Unable to create or write VHD header");
		}

		out:
		blk_unref(blk);

hw/block/pflash_cfi01.c

+16 −2

Original line number	Diff line number	Diff line
		@@ -46,6 +46,7 @@
		#include "exec/address-spaces.h"
		#include "qemu/host-utils.h"
		#include "hw/sysbus.h"
		#include "sysemu/sysemu.h"

		#define PFLASH_BUG(fmt, ...) \
		do { \
		@@ -97,6 +98,7 @@ struct pflash_t {
		MemoryRegion mem;
		char *name;
		void *storage;
		VMChangeStateEntry *vmstate;
		};

		static int pflash_post_load(void *opaque, int version_id);
		@@ -944,13 +946,25 @@ MemoryRegion pflash_cfi01_get_memory(pflash_t fl)
		return &fl->mem;
		}

		static int pflash_post_load(void *opaque, int version_id)
		static void postload_update_cb(void *opaque, int running, RunState state)
		{
		pflash_t *pfl = opaque;

		if (!pfl->ro) {
		/* This is called after bdrv_invalidate_cache_all. */
		qemu_del_vm_change_state_handler(pfl->vmstate);
		pfl->vmstate = NULL;

		DPRINTF("%s: updating bdrv for %s\n", __func__, pfl->name);
		pflash_update(pfl, 0, pfl->sector_len * pfl->nb_blocs);
		}

		static int pflash_post_load(void *opaque, int version_id)
		{
		pflash_t *pfl = opaque;

		if (!pfl->ro) {
		pfl->vmstate = qemu_add_vm_change_state_handler(postload_update_cb,
		pfl);
		}
		return 0;
		}

nbd/client.c

+21 −2

Original line number	Diff line number	Diff line
		@@ -192,13 +192,18 @@ static int nbd_receive_list(QIOChannel ioc, char name, Error *errp)
		return -1;
		}
		} else if (type == NBD_REP_SERVER) {
		if (len < sizeof(namelen) \|\| len > NBD_MAX_BUFFER_SIZE) {
		error_setg(errp, "incorrect option length");
		return -1;
		}
		if (read_sync(ioc, &namelen, sizeof(namelen)) != sizeof(namelen)) {
		error_setg(errp, "failed to read option name length");
		return -1;
		}
		namelen = be32_to_cpu(namelen);
		if (len != (namelen + sizeof(namelen))) {
		error_setg(errp, "incorrect option mame length");
		len -= sizeof(namelen);
		if (len < namelen) {
		error_setg(errp, "incorrect option name length");
		return -1;
		}
		if (namelen > 255) {
		@@ -214,6 +219,20 @@ static int nbd_receive_list(QIOChannel ioc, char name, Error *errp)
		return -1;
		}
		(*name)[namelen] = '\0';
		len -= namelen;
		if (len) {
		char *buf = g_malloc(len + 1);
		if (read_sync(ioc, buf, len) != len) {
		error_setg(errp, "failed to read export description");
		g_free(*name);
		g_free(buf);
		*name = NULL;
		return -1;
		}
		buf[len] = '\0';
		TRACE("Ignoring export description: %s", buf);
		g_free(buf);
		}
		} else {
		error_setg(errp, "Unexpected reply type %x expected %x",
		type, NBD_REP_SERVER);

nbd/server.c

+13 −2

Original line number	Diff line number	Diff line
		@@ -449,11 +449,19 @@ static int nbd_negotiate_options(NBDClient *client)
		client->ioc = QIO_CHANNEL(tioc);
		break;

		case NBD_OPT_EXPORT_NAME:
		/* No way to return an error to client, so drop connection */
		TRACE("Option 0x%x not permitted before TLS", clientflags);
		return -EINVAL;

		default:
		TRACE("Option 0x%x not permitted before TLS", clientflags);
		if (nbd_negotiate_drop_sync(client->ioc, length) != length) {
		return -EIO;
		}
		nbd_negotiate_send_rep(client->ioc, NBD_REP_ERR_TLS_REQD,
		clientflags);
		return -EINVAL;
		break;
		}
		} else if (fixedNewstyle) {
		switch (clientflags) {
		@@ -471,6 +479,9 @@ static int nbd_negotiate_options(NBDClient *client)
		return nbd_negotiate_handle_export_name(client, length);

		case NBD_OPT_STARTTLS:
		if (nbd_negotiate_drop_sync(client->ioc, length) != length) {
		return -EIO;
		}
		if (client->tlscreds) {
		TRACE("TLS already enabled");
		nbd_negotiate_send_rep(client->ioc, NBD_REP_ERR_INVALID,
		@@ -480,7 +491,7 @@ static int nbd_negotiate_options(NBDClient *client)
		nbd_negotiate_send_rep(client->ioc, NBD_REP_ERR_POLICY,
		clientflags);
		}
		return -EINVAL;
		break;
		default:
		TRACE("Unsupported option 0x%x", clientflags);
		if (nbd_negotiate_drop_sync(client->ioc, length) != length) {