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

Merge tag 'nvme-5.16-2021-10-21' of git://git.infradead.org/nvme into for-5.16/drivers 

Pull NVMe updates from Christoph:

"nvme updates for Linux 5.16

 - fix a multipath partition scanning deadlock (Hannes Reinecke)
 - generate uevent once a multipath namespace is operational again
   (Hannes Reinecke)
 - support unique discovery controller NQNs (Hannes Reinecke)
 - fix use-after-free when a port is removed (Israel Rukshin)
 - clear shadow doorbell memory on resets (Keith Busch)
 - use struct_size (Len Baker)
 - add error handling support for add_disk (Luis Chamberlain)
 - limit the maximal queue size for RDMA controllers (Max Gurtovoy)
 - use a few more symbolic names (Max Gurtovoy)
 - fix error code in nvme_rdma_setup_ctrl (Max Gurtovoy)
 - add support for ->map_queues on FC (Saurav Kashyap)"

* tag 'nvme-5.16-2021-10-21' of git://git.infradead.org/nvme: (23 commits)
  nvmet: use struct_size over open coded arithmetic
  nvme: drop scan_lock and always kick requeue list when removing namespaces
  nvme-pci: clear shadow doorbell memory on resets
  nvme-rdma: fix error code in nvme_rdma_setup_ctrl
  nvme-multipath: add error handling support for add_disk()
  nvmet: use macro definitions for setting cmic value
  nvmet: use macro definition for setting nmic value
  nvme: display correct subsystem NQN
  nvme: Add connect option 'discovery'
  nvme: expose subsystem type in sysfs attribute 'subsystype'
  nvmet: set 'CNTRLTYPE' in the identify controller data
  nvmet: add nvmet_is_disc_subsys() helper
  nvme: add CNTRLTYPE definitions for 'identify controller'
  nvmet: make discovery NQN configurable
  nvmet-rdma: implement get_max_queue_size controller op
  nvmet: add get_max_queue_size op for controllers
  nvme-rdma: limit the maximal queue size for RDMA controllers
  nvmet-tcp: fix use-after-free when a port is removed
  nvmet-rdma: fix use-after-free when a port is removed
  nvmet: fix use-after-free when a port is removed
  ...
parents 39fa7a95 117d5b6d

drivers/nvme/host/core.c

+35 −1
Original line number Diff line number Diff line
@@ -222,7 +222,7 @@ int nvme_reset_ctrl_sync(struct nvme_ctrl *ctrl) 
static void nvme_do_delete_ctrl(struct nvme_ctrl *ctrl)

{

	dev_info(ctrl->device,

		 "Removing ctrl: NQN \"%s\"\n", ctrl->opts->subsysnqn);

		 "Removing ctrl: NQN \"%s\"\n", nvmf_ctrl_subsysnqn(ctrl));



	flush_work(&ctrl->reset_work);

	nvme_stop_ctrl(ctrl);
@@ -2620,6 +2620,24 @@ static ssize_t nvme_subsys_show_nqn(struct device *dev, 
}

static SUBSYS_ATTR_RO(subsysnqn, S_IRUGO, nvme_subsys_show_nqn);



static ssize_t nvme_subsys_show_type(struct device *dev,

				    struct device_attribute *attr,

				    char *buf)

{

	struct nvme_subsystem *subsys =

		container_of(dev, struct nvme_subsystem, dev);



	switch (subsys->subtype) {

	case NVME_NQN_DISC:

		return sysfs_emit(buf, "discovery\n");

	case NVME_NQN_NVME:

		return sysfs_emit(buf, "nvm\n");

	default:

		return sysfs_emit(buf, "reserved\n");

	}

}

static SUBSYS_ATTR_RO(subsystype, S_IRUGO, nvme_subsys_show_type);



#define nvme_subsys_show_str_function(field)				\

static ssize_t subsys_##field##_show(struct device *dev,		\

			    struct device_attribute *attr, char *buf)	\
@@ -2640,6 +2658,7 @@ static struct attribute *nvme_subsys_attrs[] = { 
	&subsys_attr_serial.attr,

	&subsys_attr_firmware_rev.attr,

	&subsys_attr_subsysnqn.attr,

	&subsys_attr_subsystype.attr,

#ifdef CONFIG_NVME_MULTIPATH

	&subsys_attr_iopolicy.attr,

#endif
@@ -2710,6 +2729,21 @@ static int nvme_init_subsystem(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id) 
	memcpy(subsys->firmware_rev, id->fr, sizeof(subsys->firmware_rev));

	subsys->vendor_id = le16_to_cpu(id->vid);

	subsys->cmic = id->cmic;



	/* Versions prior to 1.4 don't necessarily report a valid type */

	if (id->cntrltype == NVME_CTRL_DISC ||

	    !strcmp(subsys->subnqn, NVME_DISC_SUBSYS_NAME))

		subsys->subtype = NVME_NQN_DISC;

	else

		subsys->subtype = NVME_NQN_NVME;



	if (nvme_discovery_ctrl(ctrl) && subsys->subtype != NVME_NQN_DISC) {

		dev_err(ctrl->device,

			"Subsystem %s is not a discovery controller",

			subsys->subnqn);

		kfree(subsys);

		return -EINVAL;

	}

	subsys->awupf = le16_to_cpu(id->awupf);

#ifdef CONFIG_NVME_MULTIPATH

	subsys->iopolicy = NVME_IOPOLICY_NUMA;

drivers/nvme/host/fabrics.c

+5 −1
Original line number Diff line number Diff line
@@ -548,6 +548,7 @@ static const match_table_t opt_tokens = { 
	{ NVMF_OPT_NR_POLL_QUEUES,	"nr_poll_queues=%d"	},

	{ NVMF_OPT_TOS,			"tos=%d"		},

	{ NVMF_OPT_FAIL_FAST_TMO,	"fast_io_fail_tmo=%d"	},

	{ NVMF_OPT_DISCOVERY,		"discovery"		},

	{ NVMF_OPT_ERR,			NULL			}

};
@@ -823,6 +824,9 @@ static int nvmf_parse_options(struct nvmf_ctrl_options *opts, 
			}

			opts->tos = token;

			break;

		case NVMF_OPT_DISCOVERY:

			opts->discovery_nqn = true;

			break;

		default:

			pr_warn("unknown parameter or missing value '%s' in ctrl creation request\n",

				p);
@@ -949,7 +953,7 @@ EXPORT_SYMBOL_GPL(nvmf_free_options); 
#define NVMF_ALLOWED_OPTS	(NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \

				 NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \

				 NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT |\

				 NVMF_OPT_DISABLE_SQFLOW |\

				 NVMF_OPT_DISABLE_SQFLOW | NVMF_OPT_DISCOVERY |\

				 NVMF_OPT_FAIL_FAST_TMO)



static struct nvme_ctrl *

drivers/nvme/host/fabrics.h

+8 −0
Original line number Diff line number Diff line
@@ -67,6 +67,7 @@ enum { 
	NVMF_OPT_TOS		= 1 << 19,

	NVMF_OPT_FAIL_FAST_TMO	= 1 << 20,

	NVMF_OPT_HOST_IFACE	= 1 << 21,

	NVMF_OPT_DISCOVERY	= 1 << 22,

};



/**
@@ -178,6 +179,13 @@ nvmf_ctlr_matches_baseopts(struct nvme_ctrl *ctrl, 
	return true;

}



static inline char *nvmf_ctrl_subsysnqn(struct nvme_ctrl *ctrl)

{

	if (!ctrl->subsys)

		return ctrl->opts->subsysnqn;

	return ctrl->subsys->subnqn;

}



int nvmf_reg_read32(struct nvme_ctrl *ctrl, u32 off, u32 *val);

int nvmf_reg_read64(struct nvme_ctrl *ctrl, u32 off, u64 *val);

int nvmf_reg_write32(struct nvme_ctrl *ctrl, u32 off, u32 val);

drivers/nvme/host/fc.c

+25 −1
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#include <linux/nvme-fc.h>

#include "fc.h"

#include <scsi/scsi_transport_fc.h>

#include <linux/blk-mq-pci.h>



/* *************************** Data Structures/Defines ****************** */
@@ -2841,6 +2842,28 @@ nvme_fc_complete_rq(struct request *rq) 
	nvme_fc_ctrl_put(ctrl);

}



static int nvme_fc_map_queues(struct blk_mq_tag_set *set)

{

	struct nvme_fc_ctrl *ctrl = set->driver_data;

	int i;



	for (i = 0; i < set->nr_maps; i++) {

		struct blk_mq_queue_map *map = &set->map[i];



		if (!map->nr_queues) {

			WARN_ON(i == HCTX_TYPE_DEFAULT);

			continue;

		}



		/* Call LLDD map queue functionality if defined */

		if (ctrl->lport->ops->map_queues)

			ctrl->lport->ops->map_queues(&ctrl->lport->localport,

						     map);

		else

			blk_mq_map_queues(map);

	}

	return 0;

}



static const struct blk_mq_ops nvme_fc_mq_ops = {

	.queue_rq	= nvme_fc_queue_rq,
@@ -2849,6 +2872,7 @@ static const struct blk_mq_ops nvme_fc_mq_ops = { 
	.exit_request	= nvme_fc_exit_request,

	.init_hctx	= nvme_fc_init_hctx,

	.timeout	= nvme_fc_timeout,

	.map_queues	= nvme_fc_map_queues,

};



static int
@@ -3572,7 +3596,7 @@ nvme_fc_init_ctrl(struct device *dev, struct nvmf_ctrl_options *opts, 


	dev_info(ctrl->ctrl.device,

		"NVME-FC{%d}: new ctrl: NQN \"%s\"\n",

		ctrl->cnum, ctrl->ctrl.opts->subsysnqn);

		ctrl->cnum, nvmf_ctrl_subsysnqn(&ctrl->ctrl));



	return &ctrl->ctrl;

drivers/nvme/host/multipath.c

+21 −9
Original line number Diff line number Diff line
@@ -105,8 +105,11 @@ void nvme_kick_requeue_lists(struct nvme_ctrl *ctrl) 


	down_read(&ctrl->namespaces_rwsem);

	list_for_each_entry(ns, &ctrl->namespaces, list) {

		if (ns->head->disk)

		if (!ns->head->disk)

			continue;

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

		if (ctrl->state == NVME_CTRL_LIVE)

			disk_uevent(ns->head->disk, KOBJ_CHANGE);

	}

	up_read(&ctrl->namespaces_rwsem);

}
@@ -143,13 +146,12 @@ void nvme_mpath_clear_ctrl_paths(struct nvme_ctrl *ctrl) 
{

	struct nvme_ns *ns;



	mutex_lock(&ctrl->scan_lock);

	down_read(&ctrl->namespaces_rwsem);

	list_for_each_entry(ns, &ctrl->namespaces, list)

		if (nvme_mpath_clear_current_path(ns))

	list_for_each_entry(ns, &ctrl->namespaces, list) {

		nvme_mpath_clear_current_path(ns);

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

	}

	up_read(&ctrl->namespaces_rwsem);

	mutex_unlock(&ctrl->scan_lock);

}



void nvme_mpath_revalidate_paths(struct nvme_ns *ns)
@@ -506,13 +508,23 @@ int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl, struct nvme_ns_head *head) 
static void nvme_mpath_set_live(struct nvme_ns *ns)

{

	struct nvme_ns_head *head = ns->head;

	int rc;



	if (!head->disk)

		return;



	/*

	 * test_and_set_bit() is used because it is protecting against two nvme

	 * paths simultaneously calling device_add_disk() on the same namespace

	 * head.

	 */

	if (!test_and_set_bit(NVME_NSHEAD_DISK_LIVE, &head->flags)) {

		device_add_disk(&head->subsys->dev, head->disk,

		rc = device_add_disk(&head->subsys->dev, head->disk,

				     nvme_ns_id_attr_groups);

		if (rc) {

			clear_bit(NVME_NSHEAD_DISK_LIVE, &ns->flags);

			return;

		}

		nvme_add_ns_head_cdev(head);

	}