Merge branch 'nvme-4.18' of git://git.infradead.org/nvme into for-linus (95c7c09f) · Commits · 戴 / test

block/blk-mq-tag.c

+0 −29

Original line number	Diff line number	Diff line
		@@ -311,35 +311,6 @@ void blk_mq_tagset_busy_iter(struct blk_mq_tag_set *tagset,
		}
		EXPORT_SYMBOL(blk_mq_tagset_busy_iter);

		int blk_mq_tagset_iter(struct blk_mq_tag_set set, void data,
		int (fn)(void , struct request ))
		{
		int i, j, ret = 0;

		if (WARN_ON_ONCE(!fn))
		goto out;

		for (i = 0; i < set->nr_hw_queues; i++) {
		struct blk_mq_tags *tags = set->tags[i];

		if (!tags)
		continue;

		for (j = 0; j < tags->nr_tags; j++) {
		if (!tags->static_rqs[j])
		continue;

		ret = fn(data, tags->static_rqs[j]);
		if (ret)
		goto out;
		}
		}

		out:
		return ret;
		}
		EXPORT_SYMBOL_GPL(blk_mq_tagset_iter);

		void blk_mq_queue_tag_busy_iter(struct request_queue q, busy_iter_fn fn,
		void *priv)
		{

drivers/nvme/host/core.c

+12 −36

Original line number	Diff line number	Diff line
		@@ -2208,7 +2208,7 @@ static int nvme_init_subsystem(struct nvme_ctrl ctrl, struct nvme_id_ctrl id)
		* Verify that the subsystem actually supports multiple
		* controllers, else bail out.
		*/
		if (!ctrl->opts->discovery_nqn &&
		if (!(ctrl->opts && ctrl->opts->discovery_nqn) &&
		nvme_active_ctrls(found) && !(id->cmic & (1 << 1))) {
		dev_err(ctrl->device,
		"ignoring ctrl due to duplicate subnqn (%s).\n",
		@@ -3197,40 +3197,28 @@ static void nvme_scan_ns_sequential(struct nvme_ctrl *ctrl, unsigned nn)
		nvme_remove_invalid_namespaces(ctrl, nn);
		}

		static bool nvme_scan_changed_ns_log(struct nvme_ctrl *ctrl)
		static void nvme_clear_changed_ns_log(struct nvme_ctrl *ctrl)
		{
		size_t log_size = NVME_MAX_CHANGED_NAMESPACES * sizeof(__le32);
		__le32 *log;
		int error, i;
		bool ret = false;
		int error;

		log = kzalloc(log_size, GFP_KERNEL);
		if (!log)
		return false;
		return;

		/*
		* We need to read the log to clear the AEN, but we don't want to rely
		* on it for the changed namespace information as userspace could have
		* raced with us in reading the log page, which could cause us to miss
		* updates.
		*/
		error = nvme_get_log(ctrl, NVME_LOG_CHANGED_NS, log, log_size);
		if (error) {
		if (error)
		dev_warn(ctrl->device,
		"reading changed ns log failed: %d\n", error);
		goto out_free_log;
		}

		if (log[0] == cpu_to_le32(0xffffffff))
		goto out_free_log;

		for (i = 0; i < NVME_MAX_CHANGED_NAMESPACES; i++) {
		u32 nsid = le32_to_cpu(log[i]);

		if (nsid == 0)
		break;
		dev_info(ctrl->device, "rescanning namespace %d.\n", nsid);
		nvme_validate_ns(ctrl, nsid);
		}
		ret = true;

		out_free_log:
		kfree(log);
		return ret;
		}

		static void nvme_scan_work(struct work_struct *work)
		@@ -3246,9 +3234,8 @@ static void nvme_scan_work(struct work_struct *work)
		WARN_ON_ONCE(!ctrl->tagset);

		if (test_and_clear_bit(NVME_AER_NOTICE_NS_CHANGED, &ctrl->events)) {
		if (nvme_scan_changed_ns_log(ctrl))
		goto out_sort_namespaces;
		dev_info(ctrl->device, "rescanning namespaces.\n");
		nvme_clear_changed_ns_log(ctrl);
		}

		if (nvme_identify_ctrl(ctrl, &id))
		@@ -3263,7 +3250,6 @@ static void nvme_scan_work(struct work_struct *work)
		nvme_scan_ns_sequential(ctrl, nn);
		out_free_id:
		kfree(id);
		out_sort_namespaces:
		down_write(&ctrl->namespaces_rwsem);
		list_sort(NULL, &ctrl->namespaces, ns_cmp);
		up_write(&ctrl->namespaces_rwsem);
		@@ -3641,16 +3627,6 @@ void nvme_start_queues(struct nvme_ctrl *ctrl)
		}
		EXPORT_SYMBOL_GPL(nvme_start_queues);

		int nvme_reinit_tagset(struct nvme_ctrl ctrl, struct blk_mq_tag_set set)
		{
		if (!ctrl->ops->reinit_request)
		return 0;

		return blk_mq_tagset_iter(set, set->driver_data,
		ctrl->ops->reinit_request);
		}
		EXPORT_SYMBOL_GPL(nvme_reinit_tagset);

		int __init nvme_core_init(void)
		{
		int result = -ENOMEM;

drivers/nvme/host/fabrics.c

+37 −49

Original line number	Diff line number	Diff line
		@@ -536,67 +536,55 @@ static struct nvmf_transport_ops *nvmf_lookup_transport(
		return NULL;
		}

		blk_status_t nvmf_check_if_ready(struct nvme_ctrl ctrl, struct request rq,
		bool queue_live, bool is_connected)
		{
		struct nvme_command *cmd = nvme_req(rq)->cmd;

		if (likely(ctrl->state == NVME_CTRL_LIVE && is_connected))
		return BLK_STS_OK;

		switch (ctrl->state) {
		case NVME_CTRL_NEW:
		case NVME_CTRL_CONNECTING:
		case NVME_CTRL_DELETING:
		/*
		* This is the case of starting a new or deleting an association
		* but connectivity was lost before it was fully created or torn
		* down. We need to error the commands used to initialize the
		* controller so the reconnect can go into a retry attempt. The
		* commands should all be marked REQ_FAILFAST_DRIVER, which will
		* hit the reject path below. Anything else will be queued while
		* the state settles.
		* For something we're not in a state to send to the device the default action
		* is to busy it and retry it after the controller state is recovered. However,
		* anything marked for failfast or nvme multipath is immediately failed.
		*
		* Note: commands used to initialize the controller will be marked for failfast.
		* Note: nvme cli/ioctl commands are marked for failfast.
		*/
		if (!is_connected)
		break;
		blk_status_t nvmf_fail_nonready_command(struct request *rq)
		{
		if (!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))
		return BLK_STS_RESOURCE;
		nvme_req(rq)->status = NVME_SC_ABORT_REQ;
		return BLK_STS_IOERR;
		}
		EXPORT_SYMBOL_GPL(nvmf_fail_nonready_command);

		bool __nvmf_check_ready(struct nvme_ctrl ctrl, struct request rq,
		bool queue_live)
		{
		struct nvme_request *req = nvme_req(rq);

		/*
		* If queue is live, allow only commands that are internally
		* generated pass through. These are commands on the admin
		* queue to initialize the controller. This will reject any
		* ioctl admin cmds received while initializing.
		* If we are in some state of setup or teardown only allow
		* internally generated commands.
		*/
		if (queue_live && !(nvme_req(rq)->flags & NVME_REQ_USERCMD))
		return BLK_STS_OK;
		if (!blk_rq_is_passthrough(rq) \|\| (req->flags & NVME_REQ_USERCMD))
		return false;

		/*
		* If the queue is not live, allow only a connect command. This
		* will reject any ioctl admin cmd as well as initialization
		* commands if the controller reverted the queue to non-live.
		* Only allow commands on a live queue, except for the connect command,
		* which is require to set the queue live in the appropinquate states.
		*/
		if (!queue_live && blk_rq_is_passthrough(rq) &&
		cmd->common.opcode == nvme_fabrics_command &&
		cmd->fabrics.fctype == nvme_fabrics_type_connect)
		return BLK_STS_OK;
		switch (ctrl->state) {
		case NVME_CTRL_NEW:
		case NVME_CTRL_CONNECTING:
		if (req->cmd->common.opcode == nvme_fabrics_command &&
		req->cmd->fabrics.fctype == nvme_fabrics_type_connect)
		return true;
		break;
		default:
		break;
		case NVME_CTRL_DEAD:
		return false;
		}

		/*
		* Any other new io is something we're not in a state to send to the
		* device. Default action is to busy it and retry it after the
		* controller state is recovered. However, anything marked for failfast
		* or nvme multipath is immediately failed. Note: commands used to
		* initialize the controller will be marked for failfast.
		* Note: nvme cli/ioctl commands are marked for failfast.
		*/
		if (!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))
		return BLK_STS_RESOURCE;
		nvme_req(rq)->status = NVME_SC_ABORT_REQ;
		return BLK_STS_IOERR;
		return queue_live;
		}
		EXPORT_SYMBOL_GPL(nvmf_check_if_ready);
		EXPORT_SYMBOL_GPL(__nvmf_check_ready);

		static const match_table_t opt_tokens = {
		{ NVMF_OPT_TRANSPORT, "transport=%s" },

drivers/nvme/host/fabrics.h

+12 −2

Original line number	Diff line number	Diff line
		@@ -162,7 +162,17 @@ void nvmf_unregister_transport(struct nvmf_transport_ops *ops);
		void nvmf_free_options(struct nvmf_ctrl_options *opts);
		int nvmf_get_address(struct nvme_ctrl ctrl, char buf, int size);
		bool nvmf_should_reconnect(struct nvme_ctrl *ctrl);
		blk_status_t nvmf_check_if_ready(struct nvme_ctrl *ctrl,
		struct request *rq, bool queue_live, bool is_connected);
		blk_status_t nvmf_fail_nonready_command(struct request *rq);
		bool __nvmf_check_ready(struct nvme_ctrl ctrl, struct request rq,
		bool queue_live);

		static inline bool nvmf_check_ready(struct nvme_ctrl ctrl, struct request rq,
		bool queue_live)
		{
		if (likely(ctrl->state == NVME_CTRL_LIVE \|\|
		ctrl->state == NVME_CTRL_ADMIN_ONLY))
		return true;
		return __nvmf_check_ready(ctrl, rq, queue_live);
		}

		#endif /* _NVME_FABRICS_H */

drivers/nvme/host/fc.c

+56 −88

Original line number	Diff line number	Diff line
		@@ -142,6 +142,7 @@ struct nvme_fc_ctrl {
		struct nvme_fc_rport *rport;
		u32 cnum;

		bool ioq_live;
		bool assoc_active;
		u64 association_id;

		@@ -1470,21 +1471,6 @@ nvme_fc_xmt_disconnect_assoc(struct nvme_fc_ctrl *ctrl)

		static void nvme_fc_error_recovery(struct nvme_fc_ctrl ctrl, char errmsg);

		static int
		nvme_fc_reinit_request(void data, struct request rq)
		{
		struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(rq);
		struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu;

		memset(cmdiu, 0, sizeof(*cmdiu));
		cmdiu->scsi_id = NVME_CMD_SCSI_ID;
		cmdiu->fc_id = NVME_CMD_FC_ID;
		cmdiu->iu_len = cpu_to_be16(sizeof(*cmdiu) / sizeof(u32));
		memset(&op->rsp_iu, 0, sizeof(op->rsp_iu));

		return 0;
		}

		static void
		__nvme_fc_exit_request(struct nvme_fc_ctrl *ctrl,
		struct nvme_fc_fcp_op *op)
		@@ -1893,6 +1879,7 @@ nvme_fc_free_queue(struct nvme_fc_queue *queue)
		*/

		queue->connection_id = 0;
		atomic_set(&queue->csn, 1);
		}

		static void
		@@ -2279,14 +2266,13 @@ nvme_fc_queue_rq(struct blk_mq_hw_ctx *hctx,
		struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu;
		struct nvme_command *sqe = &cmdiu->sqe;
		enum nvmefc_fcp_datadir io_dir;
		bool queue_ready = test_bit(NVME_FC_Q_LIVE, &queue->flags);
		u32 data_len;
		blk_status_t ret;

		ret = nvmf_check_if_ready(&queue->ctrl->ctrl, rq,
		test_bit(NVME_FC_Q_LIVE, &queue->flags),
		ctrl->rport->remoteport.port_state == FC_OBJSTATE_ONLINE);
		if (unlikely(ret))
		return ret;
		if (ctrl->rport->remoteport.port_state != FC_OBJSTATE_ONLINE \|\|
		!nvmf_check_ready(&queue->ctrl->ctrl, rq, queue_ready))
		return nvmf_fail_nonready_command(rq);

		ret = nvme_setup_cmd(ns, rq, sqe);
		if (ret)
		@@ -2463,6 +2449,8 @@ nvme_fc_create_io_queues(struct nvme_fc_ctrl *ctrl)
		if (ret)
		goto out_delete_hw_queues;

		ctrl->ioq_live = true;

		return 0;

		out_delete_hw_queues:
		@@ -2480,7 +2468,7 @@ out_free_tag_set:
		}

		static int
		nvme_fc_reinit_io_queues(struct nvme_fc_ctrl *ctrl)
		nvme_fc_recreate_io_queues(struct nvme_fc_ctrl *ctrl)
		{
		struct nvmf_ctrl_options *opts = ctrl->ctrl.opts;
		unsigned int nr_io_queues;
		@@ -2500,12 +2488,6 @@ nvme_fc_reinit_io_queues(struct nvme_fc_ctrl *ctrl)
		if (ctrl->ctrl.queue_count == 1)
		return 0;

		nvme_fc_init_io_queues(ctrl);

		ret = nvme_reinit_tagset(&ctrl->ctrl, ctrl->ctrl.tagset);
		if (ret)
		goto out_free_io_queues;

		ret = nvme_fc_create_hw_io_queues(ctrl, ctrl->ctrl.sqsize + 1);
		if (ret)
		goto out_free_io_queues;
		@@ -2603,8 +2585,6 @@ nvme_fc_create_association(struct nvme_fc_ctrl *ctrl)
		* Create the admin queue
		*/

		nvme_fc_init_queue(ctrl, 0);

		ret = __nvme_fc_create_hw_queue(ctrl, &ctrl->queues[0], 0,
		NVME_AQ_DEPTH);
		if (ret)
		@@ -2615,7 +2595,6 @@ nvme_fc_create_association(struct nvme_fc_ctrl *ctrl)
		if (ret)
		goto out_delete_hw_queue;

		if (ctrl->ctrl.state != NVME_CTRL_NEW)
		blk_mq_unquiesce_queue(ctrl->ctrl.admin_q);

		ret = nvmf_connect_admin_queue(&ctrl->ctrl);
		@@ -2689,10 +2668,10 @@ nvme_fc_create_association(struct nvme_fc_ctrl *ctrl)
		*/

		if (ctrl->ctrl.queue_count > 1) {
		if (ctrl->ctrl.state == NVME_CTRL_NEW)
		if (!ctrl->ioq_live)
		ret = nvme_fc_create_io_queues(ctrl);
		else
		ret = nvme_fc_reinit_io_queues(ctrl);
		ret = nvme_fc_recreate_io_queues(ctrl);
		if (ret)
		goto out_term_aen_ops;
		}
		@@ -2776,7 +2755,6 @@ nvme_fc_delete_association(struct nvme_fc_ctrl *ctrl)
		* use blk_mq_tagset_busy_itr() and the transport routine to
		* terminate the exchanges.
		*/
		if (ctrl->ctrl.state != NVME_CTRL_NEW)
		blk_mq_quiesce_queue(ctrl->ctrl.admin_q);
		blk_mq_tagset_busy_iter(&ctrl->admin_tag_set,
		nvme_fc_terminate_exchange, &ctrl->ctrl);
		@@ -2917,7 +2895,6 @@ static const struct nvme_ctrl_ops nvme_fc_ctrl_ops = {
		.submit_async_event = nvme_fc_submit_async_event,
		.delete_ctrl = nvme_fc_delete_ctrl,
		.get_address = nvmf_get_address,
		.reinit_request = nvme_fc_reinit_request,
		};

		static void
		@@ -2934,7 +2911,7 @@ nvme_fc_connect_ctrl_work(struct work_struct *work)
		nvme_fc_reconnect_or_delete(ctrl, ret);
		else
		dev_info(ctrl->ctrl.device,
		"NVME-FC{%d}: controller reconnect complete\n",
		"NVME-FC{%d}: controller connect complete\n",
		ctrl->cnum);
		}

		@@ -2982,7 +2959,7 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts,
		{
		struct nvme_fc_ctrl *ctrl;
		unsigned long flags;
		int ret, idx, retry;
		int ret, idx;

		if (!(rport->remoteport.port_role &
		(FC_PORT_ROLE_NVME_DISCOVERY \| FC_PORT_ROLE_NVME_TARGET))) {
		@@ -3009,11 +2986,13 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts,
		}

		ctrl->ctrl.opts = opts;
		ctrl->ctrl.nr_reconnects = 0;
		INIT_LIST_HEAD(&ctrl->ctrl_list);
		ctrl->lport = lport;
		ctrl->rport = rport;
		ctrl->dev = lport->dev;
		ctrl->cnum = idx;
		ctrl->ioq_live = false;
		ctrl->assoc_active = false;
		init_waitqueue_head(&ctrl->ioabort_wait);

		@@ -3032,6 +3011,7 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts,

		ctrl->ctrl.sqsize = opts->queue_size - 1;
		ctrl->ctrl.kato = opts->kato;
		ctrl->ctrl.cntlid = 0xffff;

		ret = -ENOMEM;
		ctrl->queues = kcalloc(ctrl->ctrl.queue_count,
		@@ -3039,6 +3019,8 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts,
		if (!ctrl->queues)
		goto out_free_ida;

		nvme_fc_init_queue(ctrl, 0);

		memset(&ctrl->admin_tag_set, 0, sizeof(ctrl->admin_tag_set));
		ctrl->admin_tag_set.ops = &nvme_fc_admin_mq_ops;
		ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;
		@@ -3081,39 +3063,36 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts,
		list_add_tail(&ctrl->ctrl_list, &rport->ctrl_list);
		spin_unlock_irqrestore(&rport->lock, flags);

		/*
		* It's possible that transactions used to create the association
		* may fail. Examples: CreateAssociation LS or CreateIOConnection
		* LS gets dropped/corrupted/fails; or a frame gets dropped or a
		* command times out for one of the actions to init the controller
		* (Connect, Get/Set_Property, Set_Features, etc). Many of these
		* transport errors (frame drop, LS failure) inherently must kill
		* the association. The transport is coded so that any command used
		* to create the association (prior to a LIVE state transition
		* while NEW or CONNECTING) will fail if it completes in error or
		* times out.
		*
		* As such: as the connect request was mostly likely due to a
		* udev event that discovered the remote port, meaning there is
		* not an admin or script there to restart if the connect
		* request fails, retry the initial connection creation up to
		* three times before giving up and declaring failure.
		*/
		for (retry = 0; retry < 3; retry++) {
		ret = nvme_fc_create_association(ctrl);
		if (!ret)
		break;
		if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_RESETTING) \|\|
		!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING)) {
		dev_err(ctrl->ctrl.device,
		"NVME-FC{%d}: failed to init ctrl state\n", ctrl->cnum);
		goto fail_ctrl;
		}

		if (ret) {
		nvme_get_ctrl(&ctrl->ctrl);

		if (!queue_delayed_work(nvme_wq, &ctrl->connect_work, 0)) {
		nvme_put_ctrl(&ctrl->ctrl);
		dev_err(ctrl->ctrl.device,
		"NVME-FC{%d}: failed to schedule initial connect\n",
		ctrl->cnum);
		goto fail_ctrl;
		}

		flush_delayed_work(&ctrl->connect_work);

		dev_info(ctrl->ctrl.device,
		"NVME-FC{%d}: new ctrl: NQN \"%s\"\n",
		ctrl->cnum, ctrl->ctrl.opts->subsysnqn);

		return &ctrl->ctrl;

		fail_ctrl:
		nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_DELETING);
		cancel_work_sync(&ctrl->ctrl.reset_work);
		cancel_delayed_work_sync(&ctrl->connect_work);

		/* couldn't schedule retry - fail out */
		dev_err(ctrl->ctrl.device,
		"NVME-FC{%d}: Connect retry failed\n", ctrl->cnum);

		ctrl->ctrl.opts = NULL;

		/* initiate nvme ctrl ref counting teardown */
		@@ -3131,18 +3110,7 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts,
		*/
		nvme_fc_rport_get(rport);

		if (ret > 0)
		ret = -EIO;
		return ERR_PTR(ret);
		}

		nvme_get_ctrl(&ctrl->ctrl);

		dev_info(ctrl->ctrl.device,
		"NVME-FC{%d}: new ctrl: NQN \"%s\"\n",
		ctrl->cnum, ctrl->ctrl.opts->subsysnqn);

		return &ctrl->ctrl;
		return ERR_PTR(-EIO);

		out_cleanup_admin_q:
		blk_cleanup_queue(ctrl->ctrl.admin_q);

Admin message