Merge remote-tracking branch 'mreitz/block' into queue-block (47aced50) · Commits · SUMMER2020 / students / proj-2021291

block.c

+0 −9

Original line number	Diff line number	Diff line
		@@ -3821,15 +3821,6 @@ void bdrv_iterate_format(void (it)(void opaque, const char *name),
		g_free(formats);
		}

		/* This function is to find block backend bs */
		/* TODO convert callers to blk_by_name(), then remove */
		BlockDriverState bdrv_find(const char name)
		{
		BlockBackend *blk = blk_by_name(name);

		return blk ? blk_bs(blk) : NULL;
		}

		/* This function is to find a node in the bs graph */
		BlockDriverState bdrv_find_node(const char node_name)
		{

block/qcow2-refcount.c

+14 −2

Original line number	Diff line number	Diff line
		@@ -466,8 +466,20 @@ static int alloc_refcount_block(BlockDriverState *bs,
		*/
		BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_GROW);

		/* Calculate the number of refcount blocks needed so far */
		uint64_t blocks_used = DIV_ROUND_UP(cluster_index, s->refcount_block_size);
		/* Calculate the number of refcount blocks needed so far; this will be the
		* basis for calculating the index of the first cluster used for the
		* self-describing refcount structures which we are about to create.
		*
		* Because we reached this point, there cannot be any refcount entries for
		* cluster_index or higher indices yet. However, because new_block has been
		* allocated to describe that cluster (and it will assume this role later
		* on), we cannot use that index; also, new_block may actually have a higher
		* cluster index than cluster_index, so it needs to be taken into account
		* here (and 1 needs to be added to its value because that cluster is used).
		*/
		uint64_t blocks_used = DIV_ROUND_UP(MAX(cluster_index + 1,
		(new_block >> s->cluster_bits) + 1),
		s->refcount_block_size);

		if (blocks_used > QCOW_MAX_REFTABLE_SIZE / sizeof(uint64_t)) {
		return -EFBIG;

block/vpc.c

+37 −69

Original line number	Diff line number	Diff line
		@@ -46,6 +46,7 @@ enum vhd_type {
		#define VHD_TIMESTAMP_BASE 946684800

		#define VHD_MAX_SECTORS (65535LL * 255 * 255)
		#define VHD_MAX_GEOMETRY (65535LL * 16 * 255)

		// always big-endian
		typedef struct vhd_footer {
		@@ -65,7 +66,7 @@ typedef struct vhd_footer {
		char creator_os[4]; // "Wi2k"

		uint64_t orig_size;
		uint64_t size;
		uint64_t current_size;

		uint16_t cyls;
		uint8_t heads;
		@@ -215,13 +216,12 @@ static int vpc_open(BlockDriverState bs, QDict options, int flags,
		bs->total_sectors = (int64_t)
		be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;

		/* images created with disk2vhd report a far higher virtual size
		* than expected with the cyls * heads * sectors_per_cyl formula.
		* use the footer->size instead if the image was created with
		* disk2vhd.
		*/
		if (!strncmp(footer->creator_app, "d2v", 4)) {
		bs->total_sectors = be64_to_cpu(footer->size) / BDRV_SECTOR_SIZE;
		/* Images that have exactly the maximum geometry are probably bigger and
		* would be truncated if we adhered to the geometry for them. Rely on
		* footer->current_size for them. */
		if (bs->total_sectors == VHD_MAX_GEOMETRY) {
		bs->total_sectors = be64_to_cpu(footer->current_size) /
		BDRV_SECTOR_SIZE;
		}

		/* Allow a maximum disk size of approximately 2 TB */
		@@ -376,38 +376,6 @@ static inline int64_t get_sector_offset(BlockDriverState *bs,
		bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);
		}

		// printf("sector: %" PRIx64 ", index: %x, offset: %x, bioff: %" PRIx64 ", bloff: %" PRIx64 "\n",
		// sector_num, pagetable_index, pageentry_index,
		// bitmap_offset, block_offset);

		// disabled by reason
		#if 0
		#ifdef CACHE
		if (bitmap_offset != s->last_bitmap)
		{
		lseek(s->fd, bitmap_offset, SEEK_SET);

		s->last_bitmap = bitmap_offset;

		// Scary! Bitmap is stored as big endian 32bit entries,
		// while we used to look it up byte by byte
		read(s->fd, s->pageentry_u8, 512);
		for (i = 0; i < 128; i++)
		be32_to_cpus(&s->pageentry_u32[i]);
		}

		if ((s->pageentry_u8[pageentry_index / 8] >> (pageentry_index % 8)) & 1)
		return -1;
		#else
		lseek(s->fd, bitmap_offset + (pageentry_index / 8), SEEK_SET);

		read(s->fd, &bitmap_entry, 1);

		if ((bitmap_entry >> (pageentry_index % 8)) & 1)
		return -1; // not allocated
		#endif
		#endif

		return block_offset;
		}

		@@ -602,7 +570,7 @@ static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
		{
		BDRVVPCState *s = bs->opaque;
		VHDFooter footer = (VHDFooter) s->footer_buf;
		int64_t start, offset, next;
		int64_t start, offset;
		bool allocated;
		int n;

		@@ -626,21 +594,19 @@ static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs,
		*pnum += n;
		sector_num += n;
		nb_sectors -= n;
		next = start + (pnum BDRV_SECTOR_SIZE);

		/* *pnum can't be greater than one block for allocated
		* sectors since there is always a bitmap in between. */
		if (allocated) {
		return BDRV_BLOCK_DATA \| BDRV_BLOCK_OFFSET_VALID \| start;
		}
		if (nb_sectors == 0) {
		break;
		}

		offset = get_sector_offset(bs, sector_num, 0);
		} while ((allocated && offset == next) \|\| (!allocated && offset == -1));
		} while (offset == -1);

		if (allocated) {
		return BDRV_BLOCK_DATA \| BDRV_BLOCK_OFFSET_VALID \| start;
		} else {
		return 0;
		}
		}

		/*
		* Calculates the number of cylinders, heads and sectors per cylinder
		@@ -659,26 +625,20 @@ static int calculate_geometry(int64_t total_sectors, uint16_t* cyls,
		{
		uint32_t cyls_times_heads;

		/* Allow a maximum disk size of approximately 2 TB */
		if (total_sectors > 65535LL * 255 * 255) {
		return -EFBIG;
		}
		total_sectors = MIN(total_sectors, VHD_MAX_GEOMETRY);

		if (total_sectors > 65535 * 16 * 63) {
		if (total_sectors >= 65535LL * 16 * 63) {
		*secs_per_cyl = 255;
		if (total_sectors > 65535 * 16 * 255) {
		*heads = 255;
		} else {
		*heads = 16;
		}
		cyls_times_heads = total_sectors / *secs_per_cyl;
		} else {
		*secs_per_cyl = 17;
		cyls_times_heads = total_sectors / *secs_per_cyl;
		*heads = (cyls_times_heads + 1023) / 1024;

		if (*heads < 4)
		if (*heads < 4) {
		*heads = 4;
		}

		if (cyls_times_heads >= (heads 1024) \|\| *heads > 16) {
		*secs_per_cyl = 31;
		@@ -834,19 +794,27 @@ static int vpc_create(const char filename, QemuOpts opts, Error **errp)
		* Calculate matching total_size and geometry. Increase the number of
		* sectors requested until we get enough (or fail). This ensures that
		* qemu-img convert doesn't truncate images, but rather rounds up.
		*
		* If the image size can't be represented by a spec conform CHS geometry,
		* we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use
		* the image size from the VHD footer to calculate total_sectors.
		*/
		total_sectors = total_size / BDRV_SECTOR_SIZE;
		total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE);
		for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) {
		if (calculate_geometry(total_sectors + i, &cyls, &heads,
		&secs_per_cyl))
		{
		calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl);
		}

		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 */
		if (total_sectors > VHD_MAX_SECTORS) {
		ret = -EFBIG;
		goto out;
		}
		}

		} else {
		total_sectors = (int64_t)cyls * heads * secs_per_cyl;
		total_size = total_sectors * BDRV_SECTOR_SIZE;
		}

		/* Prepare the Hard Disk Footer */
		memset(buf, 0, 1024);
		@@ -869,7 +837,7 @@ static int vpc_create(const char filename, QemuOpts opts, Error **errp)
		footer->major = cpu_to_be16(0x0005);
		footer->minor = cpu_to_be16(0x0003);
		footer->orig_size = cpu_to_be64(total_size);
		footer->size = cpu_to_be64(total_size);
		footer->current_size = cpu_to_be64(total_size);
		footer->cyls = cpu_to_be16(cyls);
		footer->heads = heads;
		footer->secs_per_cyl = secs_per_cyl;

blockdev.c

+59 −33

Original line number	Diff line number	Diff line
		@@ -1016,18 +1016,18 @@ fail:
		void hmp_commit(Monitor mon, const QDict qdict)
		{
		const char *device = qdict_get_str(qdict, "device");
		BlockDriverState *bs;
		BlockBackend *blk;
		int ret;

		if (!strcmp(device, "all")) {
		ret = bdrv_commit_all();
		} else {
		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		monitor_printf(mon, "Device '%s' not found\n", device);
		return;
		}
		ret = bdrv_commit(bs);
		ret = bdrv_commit(blk_bs(blk));
		}
		if (ret < 0) {
		monitor_printf(mon, "'commit' error for '%s': %s\n", device,
		@@ -1092,17 +1092,20 @@ SnapshotInfo qmp_blockdev_snapshot_delete_internal_sync(const char device,
		const char *name,
		Error **errp)
		{
		BlockDriverState *bs = bdrv_find(device);
		BlockDriverState *bs;
		BlockBackend *blk;
		AioContext *aio_context;
		QEMUSnapshotInfo sn;
		Error *local_err = NULL;
		SnapshotInfo *info = NULL;
		int ret;

		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return NULL;
		}
		bs = blk_bs(blk);

		if (!has_id) {
		id = NULL;
		@@ -1205,6 +1208,7 @@ static void internal_snapshot_prepare(BlkTransactionState *common,
		Error *local_err = NULL;
		const char *device;
		const char *name;
		BlockBackend *blk;
		BlockDriverState *bs;
		QEMUSnapshotInfo old_sn, *sn;
		bool ret;
		@@ -1223,11 +1227,12 @@ static void internal_snapshot_prepare(BlkTransactionState *common,
		name = internal->name;

		/* 2. check for validation */
		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return;
		}
		bs = blk_bs(blk);

		/* AioContext is released in .clean() */
		state->aio_context = bdrv_get_aio_context(bs);
		@@ -1494,17 +1499,19 @@ static void drive_backup_prepare(BlkTransactionState common, Error *errp)
		{
		DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
		BlockDriverState *bs;
		BlockBackend *blk;
		DriveBackup *backup;
		Error *local_err = NULL;

		assert(common->action->kind == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
		backup = common->action->drive_backup;

		bs = bdrv_find(backup->device);
		if (!bs) {
		blk = blk_by_name(backup->device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, backup->device);
		return;
		}
		bs = blk_bs(blk);

		/* AioContext is released in .clean() */
		state->aio_context = bdrv_get_aio_context(bs);
		@@ -1559,22 +1566,25 @@ static void blockdev_backup_prepare(BlkTransactionState common, Error *errp)
		BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
		BlockdevBackup *backup;
		BlockDriverState bs, target;
		BlockBackend *blk;
		Error *local_err = NULL;

		assert(common->action->kind == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
		backup = common->action->blockdev_backup;

		bs = bdrv_find(backup->device);
		if (!bs) {
		blk = blk_by_name(backup->device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, backup->device);
		return;
		}
		bs = blk_bs(blk);

		target = bdrv_find(backup->target);
		if (!target) {
		blk = blk_by_name(backup->target);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, backup->target);
		return;
		}
		target = blk_bs(blk);

		/* AioContext is released in .clean() */
		state->aio_context = bdrv_get_aio_context(bs);
		@@ -1881,13 +1891,15 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd,
		{
		ThrottleConfig cfg;
		BlockDriverState *bs;
		BlockBackend *blk;
		AioContext *aio_context;

		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return;
		}
		bs = blk_bs(blk);

		memset(&cfg, 0, sizeof(cfg));
		cfg.buckets[THROTTLE_BPS_TOTAL].avg = bps;
		@@ -2091,6 +2103,7 @@ void qmp_block_stream(const char *device,
		bool has_on_error, BlockdevOnError on_error,
		Error **errp)
		{
		BlockBackend *blk;
		BlockDriverState *bs;
		BlockDriverState *base_bs = NULL;
		AioContext *aio_context;
		@@ -2101,11 +2114,12 @@ void qmp_block_stream(const char *device,
		on_error = BLOCKDEV_ON_ERROR_REPORT;
		}

		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return;
		}
		bs = blk_bs(blk);

		aio_context = bdrv_get_aio_context(bs);
		aio_context_acquire(aio_context);
		@@ -2155,6 +2169,7 @@ void qmp_block_commit(const char *device,
		bool has_speed, int64_t speed,
		Error **errp)
		{
		BlockBackend *blk;
		BlockDriverState *bs;
		BlockDriverState base_bs, top_bs;
		AioContext *aio_context;
		@@ -2173,11 +2188,12 @@ void qmp_block_commit(const char *device,
		* live commit feature versions; for this to work, we must make sure to
		* perform the device lookup before any generic errors that may occur in a
		* scenario in which all optional arguments are omitted. */
		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return;
		}
		bs = blk_bs(blk);

		aio_context = bdrv_get_aio_context(bs);
		aio_context_acquire(aio_context);
		@@ -2258,6 +2274,7 @@ void qmp_drive_backup(const char device, const char target,
		bool has_on_target_error, BlockdevOnError on_target_error,
		Error **errp)
		{
		BlockBackend *blk;
		BlockDriverState *bs;
		BlockDriverState *target_bs;
		BlockDriverState *source = NULL;
		@@ -2281,11 +2298,12 @@ void qmp_drive_backup(const char device, const char target,
		mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
		}

		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return;
		}
		bs = blk_bs(blk);

		aio_context = bdrv_get_aio_context(bs);
		aio_context_acquire(aio_context);
		@@ -2385,6 +2403,7 @@ void qmp_blockdev_backup(const char device, const char target,
		BlockdevOnError on_target_error,
		Error **errp)
		{
		BlockBackend *blk;
		BlockDriverState *bs;
		BlockDriverState *target_bs;
		Error *local_err = NULL;
		@@ -2400,20 +2419,22 @@ void qmp_blockdev_backup(const char device, const char target,
		on_target_error = BLOCKDEV_ON_ERROR_REPORT;
		}

		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return;
		}
		bs = blk_bs(blk);

		aio_context = bdrv_get_aio_context(bs);
		aio_context_acquire(aio_context);

		target_bs = bdrv_find(target);
		if (!target_bs) {
		blk = blk_by_name(target);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, target);
		goto out;
		}
		target_bs = blk_bs(blk);

		bdrv_ref(target_bs);
		bdrv_set_aio_context(target_bs, aio_context);
		@@ -2442,6 +2463,7 @@ void qmp_drive_mirror(const char device, const char target,
		bool has_on_target_error, BlockdevOnError on_target_error,
		Error **errp)
		{
		BlockBackend *blk;
		BlockDriverState *bs;
		BlockDriverState source, target_bs;
		AioContext *aio_context;
		@@ -2481,11 +2503,12 @@ void qmp_drive_mirror(const char device, const char target,
		return;
		}

		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return;
		}
		bs = blk_bs(blk);

		aio_context = bdrv_get_aio_context(bs);
		aio_context_acquire(aio_context);
		@@ -2623,12 +2646,14 @@ out:
		static BlockJob find_block_job(const char device, AioContext **aio_context,
		Error **errp)
		{
		BlockBackend *blk;
		BlockDriverState *bs;

		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		goto notfound;
		}
		bs = blk_bs(blk);

		*aio_context = bdrv_get_aio_context(bs);
		aio_context_acquire(*aio_context);
		@@ -2733,6 +2758,7 @@ void qmp_change_backing_file(const char *device,
		const char *backing_file,
		Error **errp)
		{
		BlockBackend *blk;
		BlockDriverState *bs = NULL;
		AioContext *aio_context;
		BlockDriverState *image_bs = NULL;
		@@ -2741,12 +2767,12 @@ void qmp_change_backing_file(const char *device,
		int open_flags;
		int ret;

		/* find the top layer BDS of the chain */
		bs = bdrv_find(device);
		if (!bs) {
		blk = blk_by_name(device);
		if (!blk) {
		error_set(errp, QERR_DEVICE_NOT_FOUND, device);
		return;
		}
		bs = blk_bs(blk);

		aio_context = bdrv_get_aio_context(bs);
		aio_context_acquire(aio_context);

include/block/block.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -381,7 +381,6 @@ int bdrv_media_changed(BlockDriverState *bs);
		void bdrv_lock_medium(BlockDriverState *bs, bool locked);
		void bdrv_eject(BlockDriverState *bs, bool eject_flag);
		const char bdrv_get_format_name(BlockDriverState bs);
		BlockDriverState bdrv_find(const char name);
		BlockDriverState bdrv_find_node(const char node_name);
		BlockDeviceInfoList *bdrv_named_nodes_list(void);
		BlockDriverState bdrv_lookup_bs(const char device,