block: change variable names in BlockDriverState (f5a5ca79) · Commits · SUMMER2020 / students / proj-2021291

block/blkdebug.c

+18 −18

Original line number	Diff line number	Diff line
		@@ -575,7 +575,7 @@ static int blkdebug_co_flush(BlockDriverState *bs)
		}

		static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs,
		int64_t offset, int count,
		int64_t offset, int bytes,
		BdrvRequestFlags flags)
		{
		uint32_t align = MAX(bs->bl.request_alignment,
		@@ -586,29 +586,29 @@ static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs,
		* preferred alignment (so that we test the fallback to writes on
		* unaligned portions), and check that the block layer never hands
		* us anything unaligned that crosses an alignment boundary. */
		if (count < align) {
		if (bytes < align) {
		assert(QEMU_IS_ALIGNED(offset, align) \|\|
		QEMU_IS_ALIGNED(offset + count, align) \|\|
		QEMU_IS_ALIGNED(offset + bytes, align) \|\|
		DIV_ROUND_UP(offset, align) ==
		DIV_ROUND_UP(offset + count, align));
		DIV_ROUND_UP(offset + bytes, align));
		return -ENOTSUP;
		}
		assert(QEMU_IS_ALIGNED(offset, align));
		assert(QEMU_IS_ALIGNED(count, align));
		assert(QEMU_IS_ALIGNED(bytes, align));
		if (bs->bl.max_pwrite_zeroes) {
		assert(count <= bs->bl.max_pwrite_zeroes);
		assert(bytes <= bs->bl.max_pwrite_zeroes);
		}

		err = rule_check(bs, offset, count);
		err = rule_check(bs, offset, bytes);
		if (err) {
		return err;
		}

		return bdrv_co_pwrite_zeroes(bs->file, offset, count, flags);
		return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
		}

		static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs,
		int64_t offset, int count)
		int64_t offset, int bytes)
		{
		uint32_t align = bs->bl.pdiscard_alignment;
		int err;
		@@ -616,29 +616,29 @@ static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs,
		/* Only pass through requests that are larger than requested
		* minimum alignment, and ensure that unaligned requests do not
		* cross optimum discard boundaries. */
		if (count < bs->bl.request_alignment) {
		if (bytes < bs->bl.request_alignment) {
		assert(QEMU_IS_ALIGNED(offset, align) \|\|
		QEMU_IS_ALIGNED(offset + count, align) \|\|
		QEMU_IS_ALIGNED(offset + bytes, align) \|\|
		DIV_ROUND_UP(offset, align) ==
		DIV_ROUND_UP(offset + count, align));
		DIV_ROUND_UP(offset + bytes, align));
		return -ENOTSUP;
		}
		assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
		assert(QEMU_IS_ALIGNED(count, bs->bl.request_alignment));
		if (align && count >= align) {
		assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
		if (align && bytes >= align) {
		assert(QEMU_IS_ALIGNED(offset, align));
		assert(QEMU_IS_ALIGNED(count, align));
		assert(QEMU_IS_ALIGNED(bytes, align));
		}
		if (bs->bl.max_pdiscard) {
		assert(count <= bs->bl.max_pdiscard);
		assert(bytes <= bs->bl.max_pdiscard);
		}

		err = rule_check(bs, offset, count);
		err = rule_check(bs, offset, bytes);
		if (err) {
		return err;
		}

		return bdrv_co_pdiscard(bs->file->bs, offset, count);
		return bdrv_co_pdiscard(bs->file->bs, offset, bytes);
		}

		static void blkdebug_close(BlockDriverState *bs)

block/blkreplay.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -96,10 +96,10 @@ static int coroutine_fn blkreplay_co_pwritev(BlockDriverState *bs,
		}

		static int coroutine_fn blkreplay_co_pwrite_zeroes(BlockDriverState *bs,
		int64_t offset, int count, BdrvRequestFlags flags)
		int64_t offset, int bytes, BdrvRequestFlags flags)
		{
		uint64_t reqid = blkreplay_next_id();
		int ret = bdrv_co_pwrite_zeroes(bs->file, offset, count, flags);
		int ret = bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
		block_request_create(reqid, bs, qemu_coroutine_self());
		qemu_coroutine_yield();

		@@ -107,10 +107,10 @@ static int coroutine_fn blkreplay_co_pwrite_zeroes(BlockDriverState *bs,
		}

		static int coroutine_fn blkreplay_co_pdiscard(BlockDriverState *bs,
		int64_t offset, int count)
		int64_t offset, int bytes)
		{
		uint64_t reqid = blkreplay_next_id();
		int ret = bdrv_co_pdiscard(bs->file->bs, offset, count);
		int ret = bdrv_co_pdiscard(bs->file->bs, offset, bytes);
		block_request_create(reqid, bs, qemu_coroutine_self());
		qemu_coroutine_yield();

block/block-backend.c

+11 −11

Original line number	Diff line number	Diff line
		@@ -1099,9 +1099,9 @@ int blk_pread_unthrottled(BlockBackend blk, int64_t offset, uint8_t buf,
		}

		int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
		int count, BdrvRequestFlags flags)
		int bytes, BdrvRequestFlags flags)
		{
		return blk_prw(blk, offset, NULL, count, blk_write_entry,
		return blk_prw(blk, offset, NULL, bytes, blk_write_entry,
		flags \| BDRV_REQ_ZERO_WRITE);
		}

		@@ -1311,10 +1311,10 @@ static void blk_aio_pdiscard_entry(void *opaque)
		}

		BlockAIOCB blk_aio_pdiscard(BlockBackend blk,
		int64_t offset, int count,
		int64_t offset, int bytes,
		BlockCompletionFunc cb, void opaque)
		{
		return blk_aio_prwv(blk, offset, count, NULL, blk_aio_pdiscard_entry, 0,
		return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,
		cb, opaque);
		}

		@@ -1374,14 +1374,14 @@ BlockAIOCB blk_aio_ioctl(BlockBackend blk, unsigned long int req, void *buf,
		return blk_aio_prwv(blk, req, 0, &qiov, blk_aio_ioctl_entry, 0, cb, opaque);
		}

		int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int count)
		int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
		{
		int ret = blk_check_byte_request(blk, offset, count);
		int ret = blk_check_byte_request(blk, offset, bytes);
		if (ret < 0) {
		return ret;
		}

		return bdrv_co_pdiscard(blk_bs(blk), offset, count);
		return bdrv_co_pdiscard(blk_bs(blk), offset, bytes);
		}

		int blk_co_flush(BlockBackend *blk)
		@@ -1760,9 +1760,9 @@ void blk_aio_get(const AIOCBInfo aiocb_info, BlockBackend *blk,
		}

		int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
		int count, BdrvRequestFlags flags)
		int bytes, BdrvRequestFlags flags)
		{
		return blk_co_pwritev(blk, offset, count, NULL,
		return blk_co_pwritev(blk, offset, bytes, NULL,
		flags \| BDRV_REQ_ZERO_WRITE);
		}

		@@ -1789,9 +1789,9 @@ static void blk_pdiscard_entry(void *opaque)
		rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, rwco->qiov->size);
		}

		int blk_pdiscard(BlockBackend *blk, int64_t offset, int count)
		int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
		{
		return blk_prw(blk, offset, NULL, count, blk_pdiscard_entry, 0);
		return blk_prw(blk, offset, NULL, bytes, blk_pdiscard_entry, 0);
		}

		int blk_save_vmstate(BlockBackend blk, const uint8_t buf,

block/file-posix.c

+17 −17

Original line number	Diff line number	Diff line
		@@ -1485,7 +1485,7 @@ static int aio_worker(void *arg)

		static int paio_submit_co(BlockDriverState *bs, int fd,
		int64_t offset, QEMUIOVector *qiov,
		int count, int type)
		int bytes, int type)
		{
		RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
		ThreadPool *pool;
		@@ -1494,22 +1494,22 @@ static int paio_submit_co(BlockDriverState *bs, int fd,
		acb->aio_type = type;
		acb->aio_fildes = fd;

		acb->aio_nbytes = count;
		acb->aio_nbytes = bytes;
		acb->aio_offset = offset;

		if (qiov) {
		acb->aio_iov = qiov->iov;
		acb->aio_niov = qiov->niov;
		assert(qiov->size == count);
		assert(qiov->size == bytes);
		}

		trace_paio_submit_co(offset, count, type);
		trace_paio_submit_co(offset, bytes, type);
		pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
		return thread_pool_submit_co(pool, aio_worker, acb);
		}

		static BlockAIOCB paio_submit(BlockDriverState bs, int fd,
		int64_t offset, QEMUIOVector *qiov, int count,
		int64_t offset, QEMUIOVector *qiov, int bytes,
		BlockCompletionFunc cb, void opaque, int type)
		{
		RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
		@@ -1519,7 +1519,7 @@ static BlockAIOCB paio_submit(BlockDriverState bs, int fd,
		acb->aio_type = type;
		acb->aio_fildes = fd;

		acb->aio_nbytes = count;
		acb->aio_nbytes = bytes;
		acb->aio_offset = offset;

		if (qiov) {
		@@ -1528,7 +1528,7 @@ static BlockAIOCB paio_submit(BlockDriverState bs, int fd,
		assert(qiov->size == acb->aio_nbytes);
		}

		trace_paio_submit(acb, opaque, offset, count, type);
		trace_paio_submit(acb, opaque, offset, bytes, type);
		pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
		return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
		}
		@@ -2109,26 +2109,26 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
		}

		static coroutine_fn BlockAIOCB raw_aio_pdiscard(BlockDriverState bs,
		int64_t offset, int count,
		int64_t offset, int bytes,
		BlockCompletionFunc cb, void opaque)
		{
		BDRVRawState *s = bs->opaque;

		return paio_submit(bs, s->fd, offset, NULL, count,
		return paio_submit(bs, s->fd, offset, NULL, bytes,
		cb, opaque, QEMU_AIO_DISCARD);
		}

		static int coroutine_fn raw_co_pwrite_zeroes(
		BlockDriverState *bs, int64_t offset,
		int count, BdrvRequestFlags flags)
		int bytes, BdrvRequestFlags flags)
		{
		BDRVRawState *s = bs->opaque;

		if (!(flags & BDRV_REQ_MAY_UNMAP)) {
		return paio_submit_co(bs, s->fd, offset, NULL, count,
		return paio_submit_co(bs, s->fd, offset, NULL, bytes,
		QEMU_AIO_WRITE_ZEROES);
		} else if (s->discard_zeroes) {
		return paio_submit_co(bs, s->fd, offset, NULL, count,
		return paio_submit_co(bs, s->fd, offset, NULL, bytes,
		QEMU_AIO_DISCARD);
		}
		return -ENOTSUP;
		@@ -2560,7 +2560,7 @@ static int fd_open(BlockDriverState *bs)
		}

		static coroutine_fn BlockAIOCB hdev_aio_pdiscard(BlockDriverState bs,
		int64_t offset, int count,
		int64_t offset, int bytes,
		BlockCompletionFunc cb, void opaque)
		{
		BDRVRawState *s = bs->opaque;
		@@ -2568,12 +2568,12 @@ static coroutine_fn BlockAIOCB hdev_aio_pdiscard(BlockDriverState bs,
		if (fd_open(bs) < 0) {
		return NULL;
		}
		return paio_submit(bs, s->fd, offset, NULL, count,
		return paio_submit(bs, s->fd, offset, NULL, bytes,
		cb, opaque, QEMU_AIO_DISCARD\|QEMU_AIO_BLKDEV);
		}

		static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
		int64_t offset, int count, BdrvRequestFlags flags)
		int64_t offset, int bytes, BdrvRequestFlags flags)
		{
		BDRVRawState *s = bs->opaque;
		int rc;
		@@ -2583,10 +2583,10 @@ static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
		return rc;
		}
		if (!(flags & BDRV_REQ_MAY_UNMAP)) {
		return paio_submit_co(bs, s->fd, offset, NULL, count,
		return paio_submit_co(bs, s->fd, offset, NULL, bytes,
		QEMU_AIO_WRITE_ZEROES\|QEMU_AIO_BLKDEV);
		} else if (s->discard_zeroes) {
		return paio_submit_co(bs, s->fd, offset, NULL, count,
		return paio_submit_co(bs, s->fd, offset, NULL, bytes,
		QEMU_AIO_DISCARD\|QEMU_AIO_BLKDEV);
		}
		return -ENOTSUP;

block/io.c

+24 −24

Original line number	Diff line number	Diff line
		@@ -35,7 +35,7 @@
		#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */

		static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
		int64_t offset, int count, BdrvRequestFlags flags);
		int64_t offset, int bytes, BdrvRequestFlags flags);

		void bdrv_parent_drained_begin(BlockDriverState *bs)
		{
		@@ -666,12 +666,12 @@ int bdrv_write(BdrvChild *child, int64_t sector_num,
		}

		int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
		int count, BdrvRequestFlags flags)
		int bytes, BdrvRequestFlags flags)
		{
		QEMUIOVector qiov;
		struct iovec iov = {
		.iov_base = NULL,
		.iov_len = count,
		.iov_len = bytes,
		};

		qemu_iovec_init_external(&qiov, &iov, 1);
		@@ -1212,7 +1212,7 @@ int coroutine_fn bdrv_co_readv(BdrvChild *child, int64_t sector_num,
		#define MAX_WRITE_ZEROES_BOUNCE_BUFFER (32768 << BDRV_SECTOR_BITS)

		static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
		int64_t offset, int count, BdrvRequestFlags flags)
		int64_t offset, int bytes, BdrvRequestFlags flags)
		{
		BlockDriver *drv = bs->drv;
		QEMUIOVector qiov;
		@@ -1230,12 +1230,12 @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,

		assert(alignment % bs->bl.request_alignment == 0);
		head = offset % alignment;
		tail = (offset + count) % alignment;
		tail = (offset + bytes) % alignment;
		max_write_zeroes = QEMU_ALIGN_DOWN(max_write_zeroes, alignment);
		assert(max_write_zeroes >= bs->bl.request_alignment);

		while (count > 0 && !ret) {
		int num = count;
		while (bytes > 0 && !ret) {
		int num = bytes;

		/* Align request. Block drivers can expect the "bulk" of the request
		* to be aligned, and that unaligned requests do not cross cluster
		@@ -1245,7 +1245,7 @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
		/* Make a small request up to the first aligned sector. For
		* convenience, limit this request to max_transfer even if
		* we don't need to fall back to writes. */
		num = MIN(MIN(count, max_transfer), alignment - head);
		num = MIN(MIN(bytes, max_transfer), alignment - head);
		head = (head + num) % alignment;
		assert(num < max_write_zeroes);
		} else if (tail && num > alignment) {
		@@ -1306,7 +1306,7 @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
		}

		offset += num;
		count -= num;
		bytes -= num;
		}

		fail:
		@@ -1658,15 +1658,15 @@ int coroutine_fn bdrv_co_writev(BdrvChild *child, int64_t sector_num,
		}

		int coroutine_fn bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset,
		int count, BdrvRequestFlags flags)
		int bytes, BdrvRequestFlags flags)
		{
		trace_bdrv_co_pwrite_zeroes(child->bs, offset, count, flags);
		trace_bdrv_co_pwrite_zeroes(child->bs, offset, bytes, flags);

		if (!(child->bs->open_flags & BDRV_O_UNMAP)) {
		flags &= ~BDRV_REQ_MAY_UNMAP;
		}

		return bdrv_co_pwritev(child, offset, count, NULL,
		return bdrv_co_pwritev(child, offset, bytes, NULL,
		BDRV_REQ_ZERO_WRITE \| flags);
		}

		@@ -2248,18 +2248,18 @@ int bdrv_flush(BlockDriverState *bs)
		typedef struct DiscardCo {
		BlockDriverState *bs;
		int64_t offset;
		int count;
		int bytes;
		int ret;
		} DiscardCo;
		static void coroutine_fn bdrv_pdiscard_co_entry(void *opaque)
		{
		DiscardCo *rwco = opaque;

		rwco->ret = bdrv_co_pdiscard(rwco->bs, rwco->offset, rwco->count);
		rwco->ret = bdrv_co_pdiscard(rwco->bs, rwco->offset, rwco->bytes);
		}

		int coroutine_fn bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset,
		int count)
		int bytes)
		{
		BdrvTrackedRequest req;
		int max_pdiscard, ret;
		@@ -2269,7 +2269,7 @@ int coroutine_fn bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset,
		return -ENOMEDIUM;
		}

		ret = bdrv_check_byte_request(bs, offset, count);
		ret = bdrv_check_byte_request(bs, offset, bytes);
		if (ret < 0) {
		return ret;
		} else if (bs->read_only) {
		@@ -2294,10 +2294,10 @@ int coroutine_fn bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset,
		align = MAX(bs->bl.pdiscard_alignment, bs->bl.request_alignment);
		assert(align % bs->bl.request_alignment == 0);
		head = offset % align;
		tail = (offset + count) % align;
		tail = (offset + bytes) % align;

		bdrv_inc_in_flight(bs);
		tracked_request_begin(&req, bs, offset, count, BDRV_TRACKED_DISCARD);
		tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_DISCARD);

		ret = notifier_with_return_list_notify(&bs->before_write_notifiers, &req);
		if (ret < 0) {
		@@ -2308,13 +2308,13 @@ int coroutine_fn bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset,
		align);
		assert(max_pdiscard >= bs->bl.request_alignment);

		while (count > 0) {
		while (bytes > 0) {
		int ret;
		int num = count;
		int num = bytes;

		if (head) {
		/* Make small requests to get to alignment boundaries. */
		num = MIN(count, align - head);
		num = MIN(bytes, align - head);
		if (!QEMU_IS_ALIGNED(num, bs->bl.request_alignment)) {
		num %= bs->bl.request_alignment;
		}
		@@ -2358,7 +2358,7 @@ int coroutine_fn bdrv_co_pdiscard(BlockDriverState *bs, int64_t offset,
		}

		offset += num;
		count -= num;
		bytes -= num;
		}
		ret = 0;
		out:
		@@ -2370,13 +2370,13 @@ out:
		return ret;
		}

		int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int count)
		int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
		{
		Coroutine *co;
		DiscardCo rwco = {
		.bs = bs,
		.offset = offset,
		.count = count,
		.bytes = bytes,
		.ret = NOT_DONE,
		};