Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bbc15282 authored by Jens Axboe's avatar Jens Axboe
Browse files

Merge branch 'nvme-4.20' of git://git.infradead.org/nvme into for-4.20/block 

Pull NVMe updates from Christoph:

"The second batch of updates for Linux 4.20:
 - lot of fixes for issues found by static type checkers from Bart
 - two small fixes from Keith
 - fabrics cleanups in preparation of the TCP transport from Sagi
 - more cleanups from Chaitanya"

* 'nvme-4.20' of git://git.infradead.org/nvme:
  nvme-fabrics: move controller options matching to fabrics
  nvme-rdma: always have a valid trsvcid
  nvme-pci: remove duplicate check
  nvme-pci: fix hot removal during error handling
  nvmet-fcloop: suppress a compiler warning
  nvme-core: make implicit seed truncation explicit
  nvmet-fc: fix kernel-doc headers
  nvme-fc: rework the request initialization code
  nvme-fc: introduce struct nvme_fcp_op_w_sgl
  nvme-fc: fix kernel-doc headers
  nvmet: avoid integer overflow in the discard code
  nvmet-rdma: declare local symbols static
  nvmet: use strlcpy() instead of strcpy()
  nvme-pci: fix nvme_suspend_queue() kernel-doc header
  nvme-core: rework a NQN copying operation
  nvme-core: declare local symbols static
  nvmet-rdma: check for timeout in nvme_rdma_wait_for_cm()
  nvmet: use strcmp() instead of strncmp() for subsystem lookup
  nvmet: remove unreachable code
  nvme: update node paths after adding new path
parents ee75fa2a b7c7be6f

drivers/nvme/host/core.c

+3 −3
Original line number Diff line number Diff line
@@ -1132,7 +1132,7 @@ static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio) 


	return nvme_submit_user_cmd(ns->queue, &c,

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

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

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

}



static u32 nvme_known_admin_effects(u8 opcode)
@@ -2076,7 +2076,7 @@ static void nvme_init_subnqn(struct nvme_subsystem *subsys, struct nvme_ctrl *ct 


	nqnlen = strnlen(id->subnqn, NVMF_NQN_SIZE);

	if (nqnlen > 0 && nqnlen < NVMF_NQN_SIZE) {

		strncpy(subsys->subnqn, id->subnqn, NVMF_NQN_SIZE);

		strlcpy(subsys->subnqn, id->subnqn, NVMF_NQN_SIZE);

		return;

	}
@@ -2729,7 +2729,7 @@ static umode_t nvme_ns_id_attrs_are_visible(struct kobject *kobj, 
	return a->mode;

}



const struct attribute_group nvme_ns_id_attr_group = {

static const struct attribute_group nvme_ns_id_attr_group = {

	.attrs		= nvme_ns_id_attrs,

	.is_visible	= nvme_ns_id_attrs_are_visible,

};

drivers/nvme/host/fabrics.c

+30 −0
Original line number Diff line number Diff line
@@ -868,6 +868,36 @@ static int nvmf_check_required_opts(struct nvmf_ctrl_options *opts, 
	return 0;

}



bool nvmf_ip_options_match(struct nvme_ctrl *ctrl,

		struct nvmf_ctrl_options *opts)

{

	if (!nvmf_ctlr_matches_baseopts(ctrl, opts) ||

	    strcmp(opts->traddr, ctrl->opts->traddr) ||

	    strcmp(opts->trsvcid, ctrl->opts->trsvcid))

		return false;



	/*

	 * Checking the local address is rough. In most cases, none is specified

	 * and the host port is selected by the stack.

	 *

	 * Assume no match if:

	 * -  local address is specified and address is not the same

	 * -  local address is not specified but remote is, or vice versa

	 *    (admin using specific host_traddr when it matters).

	 */

	if ((opts->mask & NVMF_OPT_HOST_TRADDR) &&

	    (ctrl->opts->mask & NVMF_OPT_HOST_TRADDR)) {

		if (strcmp(opts->host_traddr, ctrl->opts->host_traddr))

			return false;

	} else if ((opts->mask & NVMF_OPT_HOST_TRADDR) ||

		   (ctrl->opts->mask & NVMF_OPT_HOST_TRADDR)) {

		return false;

	}



	return true;

}

EXPORT_SYMBOL_GPL(nvmf_ip_options_match);



static int nvmf_check_allowed_opts(struct nvmf_ctrl_options *opts,

		unsigned int allowed_opts)

{

drivers/nvme/host/fabrics.h

+2 −0
Original line number Diff line number Diff line
@@ -166,6 +166,8 @@ blk_status_t nvmf_fail_nonready_command(struct nvme_ctrl *ctrl, 
		struct request *rq);

bool __nvmf_check_ready(struct nvme_ctrl *ctrl, struct request *rq,

		bool queue_live);

bool nvmf_ip_options_match(struct nvme_ctrl *ctrl,

		struct nvmf_ctrl_options *opts);



static inline bool nvmf_check_ready(struct nvme_ctrl *ctrl, struct request *rq,

		bool queue_live)

drivers/nvme/host/fc.c

+27 −18
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
#include <uapi/scsi/fc/fc_fs.h>

#include <uapi/scsi/fc/fc_els.h>

#include <linux/delay.h>

#include <linux/overflow.h>



#include "nvme.h"

#include "fabrics.h"
@@ -104,6 +105,12 @@ struct nvme_fc_fcp_op { 
	struct nvme_fc_ersp_iu	rsp_iu;

};



struct nvme_fcp_op_w_sgl {

	struct nvme_fc_fcp_op	op;

	struct scatterlist	sgl[SG_CHUNK_SIZE];

	uint8_t			priv[0];

};



struct nvme_fc_lport {

	struct nvme_fc_local_port	localport;
@@ -317,7 +324,7 @@ nvme_fc_attach_to_unreg_lport(struct nvme_fc_port_info *pinfo, 
 * @template:  LLDD entrypoints and operational parameters for the port

 * @dev:       physical hardware device node port corresponds to. Will be

 *             used for DMA mappings

 * @lport_p:   pointer to a local port pointer. Upon success, the routine

 * @portptr:   pointer to a local port pointer. Upon success, the routine

 *             will allocate a nvme_fc_local_port structure and place its

 *             address in the local port pointer. Upon failure, local port

 *             pointer will be set to 0.
@@ -425,8 +432,7 @@ EXPORT_SYMBOL_GPL(nvme_fc_register_localport); 
 * nvme_fc_unregister_localport - transport entry point called by an

 *                              LLDD to deregister/remove a previously

 *                              registered a NVME host FC port.

 * @localport: pointer to the (registered) local port that is to be

 *             deregistered.

 * @portptr: pointer to the (registered) local port that is to be deregistered.

 *

 * Returns:

 * a completion status. Must be 0 upon success; a negative errno
@@ -632,7 +638,7 @@ __nvme_fc_set_dev_loss_tmo(struct nvme_fc_rport *rport, 
 * @localport: pointer to the (registered) local port that the remote

 *             subsystem port is connected to.

 * @pinfo:     pointer to information about the port to be registered

 * @rport_p:   pointer to a remote port pointer. Upon success, the routine

 * @portptr:   pointer to a remote port pointer. Upon success, the routine

 *             will allocate a nvme_fc_remote_port structure and place its

 *             address in the remote port pointer. Upon failure, remote port

 *             pointer will be set to 0.
@@ -809,7 +815,7 @@ nvme_fc_ctrl_connectivity_loss(struct nvme_fc_ctrl *ctrl) 
 * nvme_fc_unregister_remoteport - transport entry point called by an

 *                              LLDD to deregister/remove a previously

 *                              registered a NVME subsystem FC port.

 * @remoteport: pointer to the (registered) remote port that is to be

 * @portptr: pointer to the (registered) remote port that is to be

 *           deregistered.

 *

 * Returns:
@@ -1687,6 +1693,8 @@ __nvme_fc_init_request(struct nvme_fc_ctrl *ctrl, 
		struct nvme_fc_queue *queue, struct nvme_fc_fcp_op *op,

		struct request *rq, u32 rqno)

{

	struct nvme_fcp_op_w_sgl *op_w_sgl =

		container_of(op, typeof(*op_w_sgl), op);

	struct nvme_fc_cmd_iu *cmdiu = &op->cmd_iu;

	int ret = 0;
@@ -1696,7 +1704,6 @@ __nvme_fc_init_request(struct nvme_fc_ctrl *ctrl, 
	op->fcp_req.rspaddr = &op->rsp_iu;

	op->fcp_req.rsplen = sizeof(op->rsp_iu);

	op->fcp_req.done = nvme_fc_fcpio_done;

	op->fcp_req.first_sgl = (struct scatterlist *)&op[1];

	op->fcp_req.private = &op->fcp_req.first_sgl[SG_CHUNK_SIZE];

	op->ctrl = ctrl;

	op->queue = queue;
@@ -1735,12 +1742,17 @@ nvme_fc_init_request(struct blk_mq_tag_set *set, struct request *rq, 
		unsigned int hctx_idx, unsigned int numa_node)

{

	struct nvme_fc_ctrl *ctrl = set->driver_data;

	struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(rq);

	struct nvme_fcp_op_w_sgl *op = blk_mq_rq_to_pdu(rq);

	int queue_idx = (set == &ctrl->tag_set) ? hctx_idx + 1 : 0;

	struct nvme_fc_queue *queue = &ctrl->queues[queue_idx];

	int res;



	nvme_req(rq)->ctrl = &ctrl->ctrl;

	return __nvme_fc_init_request(ctrl, queue, op, rq, queue->rqcnt++);

	res = __nvme_fc_init_request(ctrl, queue, &op->op, rq, queue->rqcnt++);

	if (res)

		return res;

	op->op.fcp_req.first_sgl = &op->sgl[0];

	return res;

}



static int
@@ -1770,7 +1782,6 @@ nvme_fc_init_aen_ops(struct nvme_fc_ctrl *ctrl) 
		}



		aen_op->flags = FCOP_FLAGS_AEN;

		aen_op->fcp_req.first_sgl = NULL; /* no sg list */

		aen_op->fcp_req.private = private;



		memset(sqe, 0, sizeof(*sqe));
@@ -2424,10 +2435,9 @@ nvme_fc_create_io_queues(struct nvme_fc_ctrl *ctrl) 
	ctrl->tag_set.reserved_tags = 1; /* fabric connect */

	ctrl->tag_set.numa_node = NUMA_NO_NODE;

	ctrl->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;

	ctrl->tag_set.cmd_size = sizeof(struct nvme_fc_fcp_op) +

					(SG_CHUNK_SIZE *

						sizeof(struct scatterlist)) +

					ctrl->lport->ops->fcprqst_priv_sz;

	ctrl->tag_set.cmd_size =

		struct_size((struct nvme_fcp_op_w_sgl *)NULL, priv,

			    ctrl->lport->ops->fcprqst_priv_sz);

	ctrl->tag_set.driver_data = ctrl;

	ctrl->tag_set.nr_hw_queues = ctrl->ctrl.queue_count - 1;

	ctrl->tag_set.timeout = NVME_IO_TIMEOUT;
@@ -3029,10 +3039,9 @@ nvme_fc_init_ctrl(struct device *dev, struct nvmf_ctrl_options *opts, 
	ctrl->admin_tag_set.queue_depth = NVME_AQ_MQ_TAG_DEPTH;

	ctrl->admin_tag_set.reserved_tags = 2; /* fabric connect + Keep-Alive */

	ctrl->admin_tag_set.numa_node = NUMA_NO_NODE;

	ctrl->admin_tag_set.cmd_size = sizeof(struct nvme_fc_fcp_op) +

					(SG_CHUNK_SIZE *

						sizeof(struct scatterlist)) +

					ctrl->lport->ops->fcprqst_priv_sz;

	ctrl->admin_tag_set.cmd_size =

		struct_size((struct nvme_fcp_op_w_sgl *)NULL, priv,

			    ctrl->lport->ops->fcprqst_priv_sz);

	ctrl->admin_tag_set.driver_data = ctrl;

	ctrl->admin_tag_set.nr_hw_queues = 1;

	ctrl->admin_tag_set.timeout = ADMIN_TIMEOUT;

drivers/nvme/host/multipath.c

+9 −0
Original line number Diff line number Diff line
@@ -321,6 +321,15 @@ static void nvme_mpath_set_live(struct nvme_ns *ns) 
		device_add_disk(&head->subsys->dev, head->disk,

				nvme_ns_id_attr_groups);



	if (nvme_path_is_optimized(ns)) {

		int node, srcu_idx;



		srcu_idx = srcu_read_lock(&head->srcu);

		for_each_node(node)

			__nvme_find_path(head, node);

		srcu_read_unlock(&head->srcu, srcu_idx);

	}



	kblockd_schedule_work(&ns->head->requeue_work);

}