Commit 49d82b14 authored by Jens Axboe's avatar Jens Axboe
Browse files

Merge tag 'nvme-5.15-2021-09-07' of git://git.infradead.org/nvme into block-5.15 

Pull NVMe fixes from Christoph:

"nvme fixes for Linux 5.15

 - fix nvmet command set reporting for passthrough controllers
   (Adam Manzanares)
 - updated
 - update a MAINTAINERS email address (Chaitanya Kulkarni)
 - set QUEUE_FLAG_NOWAIT for nvme-multipth (me)
 - handle errors from add_disk() (Luis Chamberlain)
 - update the keep alive interval when kato is modified (Tatsuya Sasaki)
 - fix a buffer overrun in nvmet_subsys_attr_serial (Hannes Reinecke)
 - do not reset transport on data digest errors in nvme-tcp (Daniel Wagner)
 - only call synchronize_srcu when clearing current path (Daniel Wagner)
 - revalidate paths during rescan (Hannes Reinecke)"

* tag 'nvme-5.15-2021-09-07' of git://git.infradead.org/nvme:
  nvme: update MAINTAINERS email address
  nvme: add error handling support for add_disk()
  nvme: only call synchronize_srcu when clearing current path
  nvme: update keep alive interval when kato is modified
  nvme-tcp: Do not reset transport on data digest errors
  nvmet: fixup buffer overrun in nvmet_subsys_attr_serial()
  nvmet: return bool from nvmet_passthru_ctrl and nvmet_is_passthru_req
  nvmet: looks at the passthrough controller when initializing CAP
  nvme: move nvme_multi_css into nvme.h
  nvme-multipath: revalidate paths during rescan
  nvme-multipath: set QUEUE_FLAG_NOWAIT
parents 884f0e84 aff959c2

MAINTAINERS

+1 −1
Original line number Diff line number Diff line
@@ -13367,7 +13367,7 @@ F: include/linux/nvme-fc.h 
NVM EXPRESS TARGET DRIVER

M:	Christoph Hellwig <hch@lst.de>

M:	Sagi Grimberg <sagi@grimberg.me>

M:	Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>

M:	Chaitanya Kulkarni <kch@nvidia.com>

L:	linux-nvme@lists.infradead.org

S:	Supported

W:	http://git.infradead.org/nvme.git

drivers/nvme/host/core.c

+57 −11
Original line number Diff line number Diff line
@@ -116,6 +116,8 @@ static struct class *nvme_ns_chr_class; 
static void nvme_put_subsystem(struct nvme_subsystem *subsys);

static void nvme_remove_invalid_namespaces(struct nvme_ctrl *ctrl,

					   unsigned nsid);

static void nvme_update_keep_alive(struct nvme_ctrl *ctrl,

				   struct nvme_command *cmd);



/*

 * Prepare a queue for teardown.
@@ -1152,7 +1154,8 @@ static u32 nvme_passthru_start(struct nvme_ctrl *ctrl, struct nvme_ns *ns, 
	return effects;

}



static void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects)

static void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects,

			      struct nvme_command *cmd, int status)

{

	if (effects & NVME_CMD_EFFECTS_CSE_MASK) {

		nvme_unfreeze(ctrl);
@@ -1167,6 +1170,26 @@ static void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects) 
		nvme_queue_scan(ctrl);

		flush_work(&ctrl->scan_work);

	}



	switch (cmd->common.opcode) {

	case nvme_admin_set_features:

		switch (le32_to_cpu(cmd->common.cdw10) & 0xFF) {

		case NVME_FEAT_KATO:

			/*

			 * Keep alive commands interval on the host should be

			 * updated when KATO is modified by Set Features

			 * commands.

			 */

			if (!status)

				nvme_update_keep_alive(ctrl, cmd);

			break;

		default:

			break;

		}

		break;

	default:

		break;

	}

}



int nvme_execute_passthru_rq(struct request *rq)
@@ -1181,7 +1204,7 @@ int nvme_execute_passthru_rq(struct request *rq) 
	effects = nvme_passthru_start(ctrl, ns, cmd->common.opcode);

	ret = nvme_execute_rq(disk, rq, false);

	if (effects) /* nothing to be done for zero cmd effects */

		nvme_passthru_end(ctrl, effects);

		nvme_passthru_end(ctrl, effects, cmd, ret);



	return ret;

}
@@ -1269,6 +1292,21 @@ void nvme_stop_keep_alive(struct nvme_ctrl *ctrl) 
}

EXPORT_SYMBOL_GPL(nvme_stop_keep_alive);



static void nvme_update_keep_alive(struct nvme_ctrl *ctrl,

				   struct nvme_command *cmd)

{

	unsigned int new_kato =

		DIV_ROUND_UP(le32_to_cpu(cmd->common.cdw11), 1000);



	dev_info(ctrl->device,

		 "keep alive interval updated from %u ms to %u ms\n",

		 ctrl->kato * 1000 / 2, new_kato * 1000 / 2);



	nvme_stop_keep_alive(ctrl);

	ctrl->kato = new_kato;

	nvme_start_keep_alive(ctrl);

}



/*

 * In NVMe 1.0 the CNS field was just a binary controller or namespace

 * flag, thus sending any new CNS opcodes has a big chance of not working.
@@ -1302,11 +1340,6 @@ static int nvme_identify_ctrl(struct nvme_ctrl *dev, struct nvme_id_ctrl **id) 
	return error;

}



static bool nvme_multi_css(struct nvme_ctrl *ctrl)

{

	return (ctrl->ctrl_config & NVME_CC_CSS_MASK) == NVME_CC_CSS_CSI;

}



static int nvme_process_ns_desc(struct nvme_ctrl *ctrl, struct nvme_ns_ids *ids,

		struct nvme_ns_id_desc *cur, bool *csi_seen)

{
@@ -1874,6 +1907,7 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_id_ns *id) 
			goto out_unfreeze;

	}



	set_bit(NVME_NS_READY, &ns->flags);

	blk_mq_unfreeze_queue(ns->disk->queue);



	if (blk_queue_is_zoned(ns->queue)) {
@@ -1885,6 +1919,7 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_id_ns *id) 
	if (nvme_ns_head_multipath(ns->head)) {

		blk_mq_freeze_queue(ns->head->disk->queue);

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

		nvme_mpath_revalidate_paths(ns);

		blk_stack_limits(&ns->head->disk->queue->limits,

				 &ns->queue->limits, 0);

		disk_update_readahead(ns->head->disk);
@@ -3763,7 +3798,9 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid, 


	nvme_get_ctrl(ctrl);



	device_add_disk(ctrl->device, ns->disk, nvme_ns_id_attr_groups);

	if (device_add_disk(ctrl->device, ns->disk, nvme_ns_id_attr_groups))

		goto out_cleanup_ns_from_list;



	if (!nvme_ns_head_multipath(ns->head))

		nvme_add_ns_cdev(ns);
@@ -3773,6 +3810,11 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid, 


	return;



 out_cleanup_ns_from_list:

	nvme_put_ctrl(ctrl);

	down_write(&ctrl->namespaces_rwsem);

	list_del_init(&ns->list);

	up_write(&ctrl->namespaces_rwsem);

 out_unlink_ns:

	mutex_lock(&ctrl->subsys->lock);

	list_del_rcu(&ns->siblings);
@@ -3795,6 +3837,7 @@ static void nvme_ns_remove(struct nvme_ns *ns) 
	if (test_and_set_bit(NVME_NS_REMOVING, &ns->flags))

		return;



	clear_bit(NVME_NS_READY, &ns->flags);

	set_capacity(ns->disk, 0);

	nvme_fault_inject_fini(&ns->fault_inject);
@@ -3802,9 +3845,12 @@ static void nvme_ns_remove(struct nvme_ns *ns) 
	list_del_rcu(&ns->siblings);

	mutex_unlock(&ns->ctrl->subsys->lock);



	synchronize_rcu(); /* guarantee not available in head->list */

	nvme_mpath_clear_current_path(ns);

	synchronize_srcu(&ns->head->srcu); /* wait for concurrent submissions */

	/* guarantee not available in head->list */

	synchronize_rcu();



	/* wait for concurrent submissions */

	if (nvme_mpath_clear_current_path(ns))

		synchronize_srcu(&ns->head->srcu);



	if (!nvme_ns_head_multipath(ns->head))

		nvme_cdev_del(&ns->cdev, &ns->cdev_device);

drivers/nvme/host/multipath.c

+18 −1
Original line number Diff line number Diff line
@@ -147,6 +147,21 @@ void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl) 
	mutex_unlock(&ctrl->scan_lock);

}



void nvme_mpath_revalidate_paths(struct nvme_ns *ns)

{

	struct nvme_ns_head *head = ns->head;

	sector_t capacity = get_capacity(head->disk);

	int node;



	list_for_each_entry_rcu(ns, &head->list, siblings) {

		if (capacity != get_capacity(ns->disk))

			clear_bit(NVME_NS_READY, &ns->flags);

	}



	for_each_node(node)

		rcu_assign_pointer(head->current_path[node], NULL);

}



static bool nvme_path_is_disabled(struct nvme_ns *ns)

{

	/*
@@ -158,7 +173,7 @@ static bool nvme_path_is_disabled(struct nvme_ns *ns) 
	    ns->ctrl->state != NVME_CTRL_DELETING)

		return true;

	if (test_bit(NVME_NS_ANA_PENDING, &ns->flags) ||

	    test_bit(NVME_NS_REMOVING, &ns->flags))

	    !test_bit(NVME_NS_READY, &ns->flags))

		return true;

	return false;

}
@@ -465,6 +480,8 @@ int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl, struct nvme_ns_head *head) 
			ctrl->subsys->instance, head->instance);



	blk_queue_flag_set(QUEUE_FLAG_NONROT, head->disk->queue);

	blk_queue_flag_set(QUEUE_FLAG_NOWAIT, head->disk->queue);



	/* set to a default value of 512 until the disk is validated */

	blk_queue_logical_block_size(head->disk->queue, 512);

	blk_set_stacking_limits(&head->disk->queue->limits);

drivers/nvme/host/nvme.h

+10 −0
Original line number Diff line number Diff line
@@ -456,6 +456,7 @@ struct nvme_ns { 
#define NVME_NS_DEAD     	1

#define NVME_NS_ANA_PENDING	2

#define NVME_NS_FORCE_RO	3

#define NVME_NS_READY		4



	struct cdev		cdev;

	struct device		cdev_device;
@@ -748,6 +749,7 @@ void nvme_mpath_init_ctrl(struct nvme_ctrl *ctrl); 
void nvme_mpath_uninit(struct nvme_ctrl *ctrl);

void nvme_mpath_stop(struct nvme_ctrl *ctrl);

bool nvme_mpath_clear_current_path(struct nvme_ns *ns);

void nvme_mpath_revalidate_paths(struct nvme_ns *ns);

void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl);

void nvme_mpath_shutdown_disk(struct nvme_ns_head *head);
@@ -795,6 +797,9 @@ static inline bool nvme_mpath_clear_current_path(struct nvme_ns *ns) 
{

	return false;

}

static inline void nvme_mpath_revalidate_paths(struct nvme_ns *ns)

{

}

static inline void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl)

{

}
@@ -887,4 +892,9 @@ struct nvme_ctrl *nvme_ctrl_from_file(struct file *file); 
struct nvme_ns *nvme_find_get_ns(struct nvme_ctrl *ctrl, unsigned nsid);

void nvme_put_ns(struct nvme_ns *ns);



static inline bool nvme_multi_css(struct nvme_ctrl *ctrl)

{

	return (ctrl->ctrl_config & NVME_CC_CSS_MASK) == NVME_CC_CSS_CSI;

}



#endif /* _NVME_H */

drivers/nvme/host/tcp.c

+18 −4
Original line number Diff line number Diff line
@@ -45,6 +45,7 @@ struct nvme_tcp_request { 
	u32			pdu_len;

	u32			pdu_sent;

	u16			ttag;

	__le16			status;

	struct list_head	entry;

	struct llist_node	lentry;

	__le32			ddgst;
@@ -485,6 +486,7 @@ static void nvme_tcp_error_recovery(struct nvme_ctrl *ctrl) 
static int nvme_tcp_process_nvme_cqe(struct nvme_tcp_queue *queue,

		struct nvme_completion *cqe)

{

	struct nvme_tcp_request *req;

	struct request *rq;



	rq = nvme_find_rq(nvme_tcp_tagset(queue), cqe->command_id);
@@ -496,7 +498,11 @@ static int nvme_tcp_process_nvme_cqe(struct nvme_tcp_queue *queue, 
		return -EINVAL;

	}



	if (!nvme_try_complete_req(rq, cqe->status, cqe->result))

	req = blk_mq_rq_to_pdu(rq);

	if (req->status == cpu_to_le16(NVME_SC_SUCCESS))

		req->status = cqe->status;



	if (!nvme_try_complete_req(rq, req->status, cqe->result))

		nvme_complete_rq(rq);

	queue->nr_cqe++;
@@ -758,7 +764,8 @@ static int nvme_tcp_recv_data(struct nvme_tcp_queue *queue, struct sk_buff *skb, 
			queue->ddgst_remaining = NVME_TCP_DIGEST_LENGTH;

		} else {

			if (pdu->hdr.flags & NVME_TCP_F_DATA_SUCCESS) {

				nvme_tcp_end_request(rq, NVME_SC_SUCCESS);

				nvme_tcp_end_request(rq,

						le16_to_cpu(req->status));

				queue->nr_cqe++;

			}

			nvme_tcp_init_recv_ctx(queue);
@@ -788,18 +795,24 @@ static int nvme_tcp_recv_ddgst(struct nvme_tcp_queue *queue, 
		return 0;



	if (queue->recv_ddgst != queue->exp_ddgst) {

		struct request *rq = nvme_cid_to_rq(nvme_tcp_tagset(queue),

					pdu->command_id);

		struct nvme_tcp_request *req = blk_mq_rq_to_pdu(rq);



		req->status = cpu_to_le16(NVME_SC_DATA_XFER_ERROR);



		dev_err(queue->ctrl->ctrl.device,

			"data digest error: recv %#x expected %#x\n",

			le32_to_cpu(queue->recv_ddgst),

			le32_to_cpu(queue->exp_ddgst));

		return -EIO;

	}



	if (pdu->hdr.flags & NVME_TCP_F_DATA_SUCCESS) {

		struct request *rq = nvme_cid_to_rq(nvme_tcp_tagset(queue),

					pdu->command_id);

		struct nvme_tcp_request *req = blk_mq_rq_to_pdu(rq);



		nvme_tcp_end_request(rq, NVME_SC_SUCCESS);

		nvme_tcp_end_request(rq, le16_to_cpu(req->status));

		queue->nr_cqe++;

	}
@@ -2293,6 +2306,7 @@ static blk_status_t nvme_tcp_setup_cmd_pdu(struct nvme_ns *ns, 
		return ret;



	req->state = NVME_TCP_SEND_CMD_PDU;

	req->status = cpu_to_le16(NVME_SC_SUCCESS);

	req->offset = 0;

	req->data_sent = 0;

	req->pdu_len = 0;