Commit 8df2a0a6 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'block-5.7-2020-04-10' of git://git.kernel.dk/linux-block 

Pull block fixes from Jens Axboe:
 "Here's a set of fixes that should go into this merge window. This
  contains:

   - NVMe pull request from Christoph with various fixes

   - Better discard support for loop (Evan)

   - Only call ->commit_rqs() if we have queued IO (Keith)

   - blkcg offlining fixes (Tejun)

   - fix (and fix the fix) for busy partitions"

* tag 'block-5.7-2020-04-10' of git://git.kernel.dk/linux-block:
  block: fix busy device checking in blk_drop_partitions again
  block: fix busy device checking in blk_drop_partitions
  nvmet-rdma: fix double free of rdma queue
  blk-mq: don't commit_rqs() if none were queued
  nvme-fc: Revert "add module to ops template to allow module references"
  nvme: fix deadlock caused by ANA update wrong locking
  nvmet-rdma: fix bonding failover possible NULL deref
  loop: Better discard support for block devices
  loop: Report EOPNOTSUPP properly
  nvmet: fix NULL dereference when removing a referral
  nvme: inherit stable pages constraint in the mpath stack device
  blkcg: don't offline parent blkcg first
  blkcg: rename blkcg->cgwb_refcnt to ->online_pin and always use it
  nvme-tcp: fix possible crash in recv error flow
  nvme-tcp: don't poll a non-live queue
  nvme-tcp: fix possible crash in write_zeroes processing
  nvmet-fc: fix typo in comment
  nvme-rdma: Replace comma with a semicolon
  nvme-fcloop: fix deallocation of working context
  nvme: fix compat address handling in several ioctls
parents 172edde9 cb6b771b

block/blk-cgroup.c

+19 −3
Original line number Diff line number Diff line
@@ -883,8 +883,8 @@ static void blkcg_css_offline(struct cgroup_subsys_state *css) 
	/* this prevents anyone from attaching or migrating to this blkcg */

	wb_blkcg_offline(blkcg);



	/* put the base cgwb reference allowing step 2 to be triggered */

	blkcg_cgwb_put(blkcg);

	/* put the base online pin allowing step 2 to be triggered */

	blkcg_unpin_online(blkcg);

}



/**
@@ -983,11 +983,11 @@ blkcg_css_alloc(struct cgroup_subsys_state *parent_css) 
	}



	spin_lock_init(&blkcg->lock);

	refcount_set(&blkcg->online_pin, 1);

	INIT_RADIX_TREE(&blkcg->blkg_tree, GFP_NOWAIT | __GFP_NOWARN);

	INIT_HLIST_HEAD(&blkcg->blkg_list);

#ifdef CONFIG_CGROUP_WRITEBACK

	INIT_LIST_HEAD(&blkcg->cgwb_list);

	refcount_set(&blkcg->cgwb_refcnt, 1);

#endif

	list_add_tail(&blkcg->all_blkcgs_node, &all_blkcgs);
@@ -1006,6 +1006,21 @@ unlock: 
	return ret;

}



static int blkcg_css_online(struct cgroup_subsys_state *css)

{

	struct blkcg *blkcg = css_to_blkcg(css);

	struct blkcg *parent = blkcg_parent(blkcg);



	/*

	 * blkcg_pin_online() is used to delay blkcg offline so that blkgs

	 * don't go offline while cgwbs are still active on them.  Pin the

	 * parent so that offline always happens towards the root.

	 */

	if (parent)

		blkcg_pin_online(parent);

	return 0;

}



/**

 * blkcg_init_queue - initialize blkcg part of request queue

 * @q: request_queue to initialize
@@ -1199,6 +1214,7 @@ static void blkcg_exit(struct task_struct *tsk) 


struct cgroup_subsys io_cgrp_subsys = {

	.css_alloc = blkcg_css_alloc,

	.css_online = blkcg_css_online,

	.css_offline = blkcg_css_offline,

	.css_free = blkcg_css_free,

	.can_attach = blkcg_can_attach,

block/blk-mq.c

+6 −3
Original line number Diff line number Diff line
@@ -1289,7 +1289,7 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list, 
		 * the driver there was more coming, but that turned out to

		 * be a lie.

		 */

		if (q->mq_ops->commit_rqs)

		if (q->mq_ops->commit_rqs && queued)

			q->mq_ops->commit_rqs(hctx);



		spin_lock(&hctx->lock);
@@ -1911,6 +1911,8 @@ blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last) 
void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,

		struct list_head *list)

{

	int queued = 0;



	while (!list_empty(list)) {

		blk_status_t ret;

		struct request *rq = list_first_entry(list, struct request,
@@ -1926,7 +1928,8 @@ void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, 
				break;

			}

			blk_mq_end_request(rq, ret);

		}

		} else

			queued++;

	}



	/*
@@ -1934,7 +1937,7 @@ void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, 
	 * the driver there was more coming, but that turned out to

	 * be a lie.

	 */

	if (!list_empty(list) && hctx->queue->mq_ops->commit_rqs)

	if (!list_empty(list) && hctx->queue->mq_ops->commit_rqs && queued)

		hctx->queue->mq_ops->commit_rqs(hctx);

}

block/partitions/core.c

+1 −1
Original line number Diff line number Diff line
@@ -496,7 +496,7 @@ int blk_drop_partitions(struct gendisk *disk, struct block_device *bdev) 


	if (!disk_part_scan_enabled(disk))

		return 0;

	if (bdev->bd_part_count || bdev->bd_super)

	if (bdev->bd_part_count || bdev->bd_openers > 1)

		return -EBUSY;

	res = invalidate_partition(disk, 0);

	if (res)

drivers/block/loop.c

+36 −13
Original line number Diff line number Diff line
@@ -429,11 +429,12 @@ static int lo_fallocate(struct loop_device *lo, struct request *rq, loff_t pos, 
	 * information.

	 */

	struct file *file = lo->lo_backing_file;

	struct request_queue *q = lo->lo_queue;

	int ret;



	mode |= FALLOC_FL_KEEP_SIZE;



	if ((!file->f_op->fallocate) || lo->lo_encrypt_key_size) {

	if (!blk_queue_discard(q)) {

		ret = -EOPNOTSUPP;

		goto out;

	}
@@ -463,7 +464,7 @@ static void lo_complete_rq(struct request *rq) 
	if (!cmd->use_aio || cmd->ret < 0 || cmd->ret == blk_rq_bytes(rq) ||

	    req_op(rq) != REQ_OP_READ) {

		if (cmd->ret < 0)

			ret = BLK_STS_IOERR;

			ret = errno_to_blk_status(cmd->ret);

		goto end_io;

	}
@@ -867,28 +868,47 @@ static void loop_config_discard(struct loop_device *lo) 
	struct inode *inode = file->f_mapping->host;

	struct request_queue *q = lo->lo_queue;



	/*

	 * If the backing device is a block device, mirror its zeroing

	 * capability. Set the discard sectors to the block device's zeroing

	 * capabilities because loop discards result in blkdev_issue_zeroout(),

	 * not blkdev_issue_discard(). This maintains consistent behavior with

	 * file-backed loop devices: discarded regions read back as zero.

	 */

	if (S_ISBLK(inode->i_mode) && !lo->lo_encrypt_key_size) {

		struct request_queue *backingq;



		backingq = bdev_get_queue(inode->i_bdev);

		blk_queue_max_discard_sectors(q,

			backingq->limits.max_write_zeroes_sectors);



		blk_queue_max_write_zeroes_sectors(q,

			backingq->limits.max_write_zeroes_sectors);



	/*

	 * We use punch hole to reclaim the free space used by the

	 * image a.k.a. discard. However we do not support discard if

	 * encryption is enabled, because it may give an attacker

	 * useful information.

	 */

	if ((!file->f_op->fallocate) ||

	    lo->lo_encrypt_key_size) {

	} else if (!file->f_op->fallocate || lo->lo_encrypt_key_size) {

		q->limits.discard_granularity = 0;

		q->limits.discard_alignment = 0;

		blk_queue_max_discard_sectors(q, 0);

		blk_queue_max_write_zeroes_sectors(q, 0);

		blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q);

		return;

	}



	} else {

		q->limits.discard_granularity = inode->i_sb->s_blocksize;

		q->limits.discard_alignment = 0;



		blk_queue_max_discard_sectors(q, UINT_MAX >> 9);

		blk_queue_max_write_zeroes_sectors(q, UINT_MAX >> 9);

	}



	if (q->limits.max_write_zeroes_sectors)

		blk_queue_flag_set(QUEUE_FLAG_DISCARD, q);

	else

		blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q);

}



static void loop_unprepare_queue(struct loop_device *lo)
@@ -1955,6 +1975,9 @@ static void loop_handle_cmd(struct loop_cmd *cmd) 
 failed:

	/* complete non-aio request */

	if (!cmd->use_aio || ret) {

		if (ret == -EOPNOTSUPP)

			cmd->ret = ret;

		else

			cmd->ret = ret ? -EIO : 0;

		blk_mq_complete_request(rq);

	}

drivers/nvme/host/core.c

+27 −7
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 


#include <linux/blkdev.h>

#include <linux/blk-mq.h>

#include <linux/compat.h>

#include <linux/delay.h>

#include <linux/errno.h>

#include <linux/hdreg.h>
@@ -1252,6 +1253,18 @@ static void nvme_enable_aen(struct nvme_ctrl *ctrl) 
	queue_work(nvme_wq, &ctrl->async_event_work);

}



/*

 * Convert integer values from ioctl structures to user pointers, silently

 * ignoring the upper bits in the compat case to match behaviour of 32-bit

 * kernels.

 */

static void __user *nvme_to_user_ptr(uintptr_t ptrval)

{

	if (in_compat_syscall())

		ptrval = (compat_uptr_t)ptrval;

	return (void __user *)ptrval;

}



static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)

{

	struct nvme_user_io io;
@@ -1275,7 +1288,7 @@ static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio) 


	length = (io.nblocks + 1) << ns->lba_shift;

	meta_len = (io.nblocks + 1) * ns->ms;

	metadata = (void __user *)(uintptr_t)io.metadata;

	metadata = nvme_to_user_ptr(io.metadata);



	if (ns->ext) {

		length += meta_len;
@@ -1298,7 +1311,7 @@ static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio) 
	c.rw.appmask = cpu_to_le16(io.appmask);



	return nvme_submit_user_cmd(ns->queue, &c,

			(void __user *)(uintptr_t)io.addr, length,

			nvme_to_user_ptr(io.addr), length,

			metadata, meta_len, lower_32_bits(io.slba), NULL, 0);

}
@@ -1418,9 +1431,9 @@ static int nvme_user_cmd(struct nvme_ctrl *ctrl, struct nvme_ns *ns, 


	effects = nvme_passthru_start(ctrl, ns, cmd.opcode);

	status = nvme_submit_user_cmd(ns ? ns->queue : ctrl->admin_q, &c,

			(void __user *)(uintptr_t)cmd.addr, cmd.data_len,

			(void __user *)(uintptr_t)cmd.metadata,

			cmd.metadata_len, 0, &result, timeout);

			nvme_to_user_ptr(cmd.addr), cmd.data_len,

			nvme_to_user_ptr(cmd.metadata), cmd.metadata_len,

			0, &result, timeout);

	nvme_passthru_end(ctrl, effects);



	if (status >= 0) {
@@ -1465,8 +1478,8 @@ static int nvme_user_cmd64(struct nvme_ctrl *ctrl, struct nvme_ns *ns, 


	effects = nvme_passthru_start(ctrl, ns, cmd.opcode);

	status = nvme_submit_user_cmd(ns ? ns->queue : ctrl->admin_q, &c,

			(void __user *)(uintptr_t)cmd.addr, cmd.data_len,

			(void __user *)(uintptr_t)cmd.metadata, cmd.metadata_len,

			nvme_to_user_ptr(cmd.addr), cmd.data_len,

			nvme_to_user_ptr(cmd.metadata), cmd.metadata_len,

			0, &cmd.result, timeout);

	nvme_passthru_end(ctrl, effects);
@@ -1884,6 +1897,13 @@ static void __nvme_revalidate_disk(struct gendisk *disk, struct nvme_id_ns *id) 
	if (ns->head->disk) {

		nvme_update_disk_info(ns->head->disk, ns, id);

		blk_queue_stack_limits(ns->head->disk->queue, ns->queue);

		if (bdi_cap_stable_pages_required(ns->queue->backing_dev_info)) {

			struct backing_dev_info *info =

				ns->head->disk->queue->backing_dev_info;



                        info->capabilities |= BDI_CAP_STABLE_WRITES;

		}



		revalidate_disk(ns->head->disk);

	}

#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE