Commit 236f2552 authored by Jens Axboe's avatar Jens Axboe
Browse files

Merge tag 'nvme-6.5-2023-06-16' of git://git.infradead.org/nvme into for-6.5/block 

Pull NVMe updates from Keith:

"nvme updates for Linux 6.5

 - Various cleanups all around (Irvin, Chaitanya, Christophe)
 - Better struct packing (Christophe JAILLET)
 - Reduce controller error logs for optional commands (Keith)
 - Support for >=64KiB block sizes (Daniel Gomez)
 - Fabrics fixes and code organization (Max, Chaitanya, Daniel Wagner)"

* tag 'nvme-6.5-2023-06-16' of git://git.infradead.org/nvme: (27 commits)
  nvme: forward port sysfs delete fix
  nvme: skip optional id ctrl csi if it failed
  nvme-core: use nvme_ns_head_multipath instead of ns->head->disk
  nvmet-fcloop: Do not wait on completion when unregister fails
  nvme-fabrics: open code __nvmf_host_find()
  nvme-fabrics: error out to unlock the mutex
  nvme: Increase block size variable size to 32-bit
  nvme-fcloop: no need to return from void function
  nvmet-auth: remove unnecessary break after goto
  nvmet-auth: remove some dead code
  nvme-core: remove redundant check from nvme_init_ns_head
  nvme: move sysfs code to a dedicated sysfs.c file
  nvme-fabrics: prevent overriding of existing host
  nvme-fabrics: check hostid using uuid_equal
  nvme-fabrics: unify common code in admin and io queue connect
  nvmet: reorder fields in 'struct nvmefc_fcp_req'
  nvmet: reorder fields in 'struct nvme_dhchap_queue_context'
  nvmet: reorder fields in 'struct nvmf_ctrl_options'
  nvme: reorder fields in 'struct nvme_ctrl'
  nvmet: reorder fields in 'struct nvmet_sq'
  ...
parents f0854489 1c606f7f

drivers/nvme/host/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -10,7 +10,7 @@ obj-$(CONFIG_NVME_FC) += nvme-fc.o 
obj-$(CONFIG_NVME_TCP)			+= nvme-tcp.o

obj-$(CONFIG_NVME_APPLE)		+= nvme-apple.o



nvme-core-y				+= core.o ioctl.o

nvme-core-y				+= core.o ioctl.o sysfs.o

nvme-core-$(CONFIG_NVME_VERBOSE_ERRORS)	+= constants.o

nvme-core-$(CONFIG_TRACING)		+= trace.o

nvme-core-$(CONFIG_NVME_MULTIPATH)	+= multipath.o

drivers/nvme/host/auth.c

+3 −3
Original line number Diff line number Diff line
@@ -30,18 +30,18 @@ struct nvme_dhchap_queue_context { 
	u32 s2;

	u16 transaction;

	u8 status;

	u8 dhgroup_id;

	u8 hash_id;

	size_t hash_len;

	u8 dhgroup_id;

	u8 c1[64];

	u8 c2[64];

	u8 response[64];

	u8 *host_response;

	u8 *ctrl_key;

	int ctrl_key_len;

	u8 *host_key;

	int host_key_len;

	u8 *sess_key;

	int ctrl_key_len;

	int host_key_len;

	int sess_key_len;

};

drivers/nvme/host/core.c

+11 −652
Original line number Diff line number Diff line
@@ -237,7 +237,7 @@ int nvme_delete_ctrl(struct nvme_ctrl *ctrl) 
}

EXPORT_SYMBOL_GPL(nvme_delete_ctrl);



static void nvme_delete_ctrl_sync(struct nvme_ctrl *ctrl)

void nvme_delete_ctrl_sync(struct nvme_ctrl *ctrl)

{

	/*

	 * Keep a reference until nvme_do_delete_ctrl() complete,
@@ -1835,7 +1835,7 @@ static void nvme_update_disk_info(struct gendisk *disk, 
		struct nvme_ns *ns, struct nvme_id_ns *id)

{

	sector_t capacity = nvme_lba_to_sect(ns, le64_to_cpu(id->nsze));

	unsigned short bs = 1 << ns->lba_shift;

	u32 bs = 1U << ns->lba_shift;

	u32 atomic_bs, phys_bs, io_opt = 0;



	/*
@@ -2256,7 +2256,7 @@ static int nvme_report_zones(struct gendisk *disk, sector_t sector, 
#define nvme_report_zones	NULL

#endif /* CONFIG_BLK_DEV_ZONED */



static const struct block_device_operations nvme_bdev_ops = {

const struct block_device_operations nvme_bdev_ops = {

	.owner		= THIS_MODULE,

	.ioctl		= nvme_ioctl,

	.compat_ioctl	= blkdev_compat_ptr_ioctl,
@@ -2791,75 +2791,6 @@ static struct nvme_subsystem *__nvme_find_get_subsystem(const char *subsysnqn) 
	return NULL;

}



#define SUBSYS_ATTR_RO(_name, _mode, _show)			\

	struct device_attribute subsys_attr_##_name = \

		__ATTR(_name, _mode, _show, NULL)



static ssize_t nvme_subsys_show_nqn(struct device *dev,

				    struct device_attribute *attr,

				    char *buf)

{

	struct nvme_subsystem *subsys =

		container_of(dev, struct nvme_subsystem, dev);



	return sysfs_emit(buf, "%s\n", subsys->subnqn);

}

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)	\

{									\

	struct nvme_subsystem *subsys =					\

		container_of(dev, struct nvme_subsystem, dev);		\

	return sysfs_emit(buf, "%.*s\n",				\

			   (int)sizeof(subsys->field), subsys->field);	\

}									\

static SUBSYS_ATTR_RO(field, S_IRUGO, subsys_##field##_show);



nvme_subsys_show_str_function(model);

nvme_subsys_show_str_function(serial);

nvme_subsys_show_str_function(firmware_rev);



static struct attribute *nvme_subsys_attrs[] = {

	&subsys_attr_model.attr,

	&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

	NULL,

};



static const struct attribute_group nvme_subsys_attrs_group = {

	.attrs = nvme_subsys_attrs,

};



static const struct attribute_group *nvme_subsys_attrs_groups[] = {

	&nvme_subsys_attrs_group,

	NULL,

};



static inline bool nvme_discovery_ctrl(struct nvme_ctrl *ctrl)

{

	return ctrl->opts && ctrl->opts->discovery_nqn;
@@ -3064,7 +2995,8 @@ static int nvme_init_non_mdts_limits(struct nvme_ctrl *ctrl) 
		ctrl->max_zeroes_sectors = 0;



	if (ctrl->subsys->subtype != NVME_NQN_NVME ||

	    nvme_ctrl_limited_cns(ctrl))

	    nvme_ctrl_limited_cns(ctrl) ||

	    test_bit(NVME_CTRL_SKIP_ID_CNS_CS, &ctrl->flags))

		return 0;



	id = kzalloc(sizeof(*id), GFP_KERNEL);
@@ -3086,6 +3018,8 @@ static int nvme_init_non_mdts_limits(struct nvme_ctrl *ctrl) 
		ctrl->max_zeroes_sectors = nvme_mps_to_sectors(ctrl, id->wzsl);



free_data:

	if (ret > 0)

		set_bit(NVME_CTRL_SKIP_ID_CNS_CS, &ctrl->flags);

	kfree(id);

	return ret;

}
@@ -3393,583 +3327,6 @@ static const struct file_operations nvme_dev_fops = { 
	.uring_cmd	= nvme_dev_uring_cmd,

};



static ssize_t nvme_sysfs_reset(struct device *dev,

				struct device_attribute *attr, const char *buf,

				size_t count)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	int ret;



	ret = nvme_reset_ctrl_sync(ctrl);

	if (ret < 0)

		return ret;

	return count;

}

static DEVICE_ATTR(reset_controller, S_IWUSR, NULL, nvme_sysfs_reset);



static ssize_t nvme_sysfs_rescan(struct device *dev,

				struct device_attribute *attr, const char *buf,

				size_t count)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	nvme_queue_scan(ctrl);

	return count;

}

static DEVICE_ATTR(rescan_controller, S_IWUSR, NULL, nvme_sysfs_rescan);



static inline struct nvme_ns_head *dev_to_ns_head(struct device *dev)

{

	struct gendisk *disk = dev_to_disk(dev);



	if (disk->fops == &nvme_bdev_ops)

		return nvme_get_ns_from_dev(dev)->head;

	else

		return disk->private_data;

}



static ssize_t wwid_show(struct device *dev, struct device_attribute *attr,

		char *buf)

{

	struct nvme_ns_head *head = dev_to_ns_head(dev);

	struct nvme_ns_ids *ids = &head->ids;

	struct nvme_subsystem *subsys = head->subsys;

	int serial_len = sizeof(subsys->serial);

	int model_len = sizeof(subsys->model);



	if (!uuid_is_null(&ids->uuid))

		return sysfs_emit(buf, "uuid.%pU\n", &ids->uuid);



	if (memchr_inv(ids->nguid, 0, sizeof(ids->nguid)))

		return sysfs_emit(buf, "eui.%16phN\n", ids->nguid);



	if (memchr_inv(ids->eui64, 0, sizeof(ids->eui64)))

		return sysfs_emit(buf, "eui.%8phN\n", ids->eui64);



	while (serial_len > 0 && (subsys->serial[serial_len - 1] == ' ' ||

				  subsys->serial[serial_len - 1] == '\0'))

		serial_len--;

	while (model_len > 0 && (subsys->model[model_len - 1] == ' ' ||

				 subsys->model[model_len - 1] == '\0'))

		model_len--;



	return sysfs_emit(buf, "nvme.%04x-%*phN-%*phN-%08x\n", subsys->vendor_id,

		serial_len, subsys->serial, model_len, subsys->model,

		head->ns_id);

}

static DEVICE_ATTR_RO(wwid);



static ssize_t nguid_show(struct device *dev, struct device_attribute *attr,

		char *buf)

{

	return sysfs_emit(buf, "%pU\n", dev_to_ns_head(dev)->ids.nguid);

}

static DEVICE_ATTR_RO(nguid);



static ssize_t uuid_show(struct device *dev, struct device_attribute *attr,

		char *buf)

{

	struct nvme_ns_ids *ids = &dev_to_ns_head(dev)->ids;



	/* For backward compatibility expose the NGUID to userspace if

	 * we have no UUID set

	 */

	if (uuid_is_null(&ids->uuid)) {

		dev_warn_ratelimited(dev,

			"No UUID available providing old NGUID\n");

		return sysfs_emit(buf, "%pU\n", ids->nguid);

	}

	return sysfs_emit(buf, "%pU\n", &ids->uuid);

}

static DEVICE_ATTR_RO(uuid);



static ssize_t eui_show(struct device *dev, struct device_attribute *attr,

		char *buf)

{

	return sysfs_emit(buf, "%8ph\n", dev_to_ns_head(dev)->ids.eui64);

}

static DEVICE_ATTR_RO(eui);



static ssize_t nsid_show(struct device *dev, struct device_attribute *attr,

		char *buf)

{

	return sysfs_emit(buf, "%d\n", dev_to_ns_head(dev)->ns_id);

}

static DEVICE_ATTR_RO(nsid);



static struct attribute *nvme_ns_id_attrs[] = {

	&dev_attr_wwid.attr,

	&dev_attr_uuid.attr,

	&dev_attr_nguid.attr,

	&dev_attr_eui.attr,

	&dev_attr_nsid.attr,

#ifdef CONFIG_NVME_MULTIPATH

	&dev_attr_ana_grpid.attr,

	&dev_attr_ana_state.attr,

#endif

	NULL,

};



static umode_t nvme_ns_id_attrs_are_visible(struct kobject *kobj,

		struct attribute *a, int n)

{

	struct device *dev = container_of(kobj, struct device, kobj);

	struct nvme_ns_ids *ids = &dev_to_ns_head(dev)->ids;



	if (a == &dev_attr_uuid.attr) {

		if (uuid_is_null(&ids->uuid) &&

		    !memchr_inv(ids->nguid, 0, sizeof(ids->nguid)))

			return 0;

	}

	if (a == &dev_attr_nguid.attr) {

		if (!memchr_inv(ids->nguid, 0, sizeof(ids->nguid)))

			return 0;

	}

	if (a == &dev_attr_eui.attr) {

		if (!memchr_inv(ids->eui64, 0, sizeof(ids->eui64)))

			return 0;

	}

#ifdef CONFIG_NVME_MULTIPATH

	if (a == &dev_attr_ana_grpid.attr || a == &dev_attr_ana_state.attr) {

		if (dev_to_disk(dev)->fops != &nvme_bdev_ops) /* per-path attr */

			return 0;

		if (!nvme_ctrl_use_ana(nvme_get_ns_from_dev(dev)->ctrl))

			return 0;

	}

#endif

	return a->mode;

}



static const struct attribute_group nvme_ns_id_attr_group = {

	.attrs		= nvme_ns_id_attrs,

	.is_visible	= nvme_ns_id_attrs_are_visible,

};



const struct attribute_group *nvme_ns_id_attr_groups[] = {

	&nvme_ns_id_attr_group,

	NULL,

};



#define nvme_show_str_function(field)						\

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

			    struct device_attribute *attr, char *buf)		\

{										\

        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);				\

        return sysfs_emit(buf, "%.*s\n",					\

		(int)sizeof(ctrl->subsys->field), ctrl->subsys->field);		\

}										\

static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL);



nvme_show_str_function(model);

nvme_show_str_function(serial);

nvme_show_str_function(firmware_rev);



#define nvme_show_int_function(field)						\

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

			    struct device_attribute *attr, char *buf)		\

{										\

        struct nvme_ctrl *ctrl = dev_get_drvdata(dev);				\

        return sysfs_emit(buf, "%d\n", ctrl->field);				\

}										\

static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL);



nvme_show_int_function(cntlid);

nvme_show_int_function(numa_node);

nvme_show_int_function(queue_count);

nvme_show_int_function(sqsize);

nvme_show_int_function(kato);



static ssize_t nvme_sysfs_delete(struct device *dev,

				struct device_attribute *attr, const char *buf,

				size_t count)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	if (device_remove_file_self(dev, attr))

		nvme_delete_ctrl_sync(ctrl);

	return count;

}

static DEVICE_ATTR(delete_controller, S_IWUSR, NULL, nvme_sysfs_delete);



static ssize_t nvme_sysfs_show_transport(struct device *dev,

					 struct device_attribute *attr,

					 char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	return sysfs_emit(buf, "%s\n", ctrl->ops->name);

}

static DEVICE_ATTR(transport, S_IRUGO, nvme_sysfs_show_transport, NULL);



static ssize_t nvme_sysfs_show_state(struct device *dev,

				     struct device_attribute *attr,

				     char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	static const char *const state_name[] = {

		[NVME_CTRL_NEW]		= "new",

		[NVME_CTRL_LIVE]	= "live",

		[NVME_CTRL_RESETTING]	= "resetting",

		[NVME_CTRL_CONNECTING]	= "connecting",

		[NVME_CTRL_DELETING]	= "deleting",

		[NVME_CTRL_DELETING_NOIO]= "deleting (no IO)",

		[NVME_CTRL_DEAD]	= "dead",

	};



	if ((unsigned)ctrl->state < ARRAY_SIZE(state_name) &&

	    state_name[ctrl->state])

		return sysfs_emit(buf, "%s\n", state_name[ctrl->state]);



	return sysfs_emit(buf, "unknown state\n");

}



static DEVICE_ATTR(state, S_IRUGO, nvme_sysfs_show_state, NULL);



static ssize_t nvme_sysfs_show_subsysnqn(struct device *dev,

					 struct device_attribute *attr,

					 char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	return sysfs_emit(buf, "%s\n", ctrl->subsys->subnqn);

}

static DEVICE_ATTR(subsysnqn, S_IRUGO, nvme_sysfs_show_subsysnqn, NULL);



static ssize_t nvme_sysfs_show_hostnqn(struct device *dev,

					struct device_attribute *attr,

					char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	return sysfs_emit(buf, "%s\n", ctrl->opts->host->nqn);

}

static DEVICE_ATTR(hostnqn, S_IRUGO, nvme_sysfs_show_hostnqn, NULL);



static ssize_t nvme_sysfs_show_hostid(struct device *dev,

					struct device_attribute *attr,

					char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	return sysfs_emit(buf, "%pU\n", &ctrl->opts->host->id);

}

static DEVICE_ATTR(hostid, S_IRUGO, nvme_sysfs_show_hostid, NULL);



static ssize_t nvme_sysfs_show_address(struct device *dev,

					 struct device_attribute *attr,

					 char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	return ctrl->ops->get_address(ctrl, buf, PAGE_SIZE);

}

static DEVICE_ATTR(address, S_IRUGO, nvme_sysfs_show_address, NULL);



static ssize_t nvme_ctrl_loss_tmo_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	struct nvmf_ctrl_options *opts = ctrl->opts;



	if (ctrl->opts->max_reconnects == -1)

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

	return sysfs_emit(buf, "%d\n",

			  opts->max_reconnects * opts->reconnect_delay);

}



static ssize_t nvme_ctrl_loss_tmo_store(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	struct nvmf_ctrl_options *opts = ctrl->opts;

	int ctrl_loss_tmo, err;



	err = kstrtoint(buf, 10, &ctrl_loss_tmo);

	if (err)

		return -EINVAL;



	if (ctrl_loss_tmo < 0)

		opts->max_reconnects = -1;

	else

		opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo,

						opts->reconnect_delay);

	return count;

}

static DEVICE_ATTR(ctrl_loss_tmo, S_IRUGO | S_IWUSR,

	nvme_ctrl_loss_tmo_show, nvme_ctrl_loss_tmo_store);



static ssize_t nvme_ctrl_reconnect_delay_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	if (ctrl->opts->reconnect_delay == -1)

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

	return sysfs_emit(buf, "%d\n", ctrl->opts->reconnect_delay);

}



static ssize_t nvme_ctrl_reconnect_delay_store(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	unsigned int v;

	int err;



	err = kstrtou32(buf, 10, &v);

	if (err)

		return err;



	ctrl->opts->reconnect_delay = v;

	return count;

}

static DEVICE_ATTR(reconnect_delay, S_IRUGO | S_IWUSR,

	nvme_ctrl_reconnect_delay_show, nvme_ctrl_reconnect_delay_store);



static ssize_t nvme_ctrl_fast_io_fail_tmo_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	if (ctrl->opts->fast_io_fail_tmo == -1)

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

	return sysfs_emit(buf, "%d\n", ctrl->opts->fast_io_fail_tmo);

}



static ssize_t nvme_ctrl_fast_io_fail_tmo_store(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	struct nvmf_ctrl_options *opts = ctrl->opts;

	int fast_io_fail_tmo, err;



	err = kstrtoint(buf, 10, &fast_io_fail_tmo);

	if (err)

		return -EINVAL;



	if (fast_io_fail_tmo < 0)

		opts->fast_io_fail_tmo = -1;

	else

		opts->fast_io_fail_tmo = fast_io_fail_tmo;

	return count;

}

static DEVICE_ATTR(fast_io_fail_tmo, S_IRUGO | S_IWUSR,

	nvme_ctrl_fast_io_fail_tmo_show, nvme_ctrl_fast_io_fail_tmo_store);



static ssize_t cntrltype_show(struct device *dev,

			      struct device_attribute *attr, char *buf)

{

	static const char * const type[] = {

		[NVME_CTRL_IO] = "io\n",

		[NVME_CTRL_DISC] = "discovery\n",

		[NVME_CTRL_ADMIN] = "admin\n",

	};

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	if (ctrl->cntrltype > NVME_CTRL_ADMIN || !type[ctrl->cntrltype])

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



	return sysfs_emit(buf, type[ctrl->cntrltype]);

}

static DEVICE_ATTR_RO(cntrltype);



static ssize_t dctype_show(struct device *dev,

			   struct device_attribute *attr, char *buf)

{

	static const char * const type[] = {

		[NVME_DCTYPE_NOT_REPORTED] = "none\n",

		[NVME_DCTYPE_DDC] = "ddc\n",

		[NVME_DCTYPE_CDC] = "cdc\n",

	};

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	if (ctrl->dctype > NVME_DCTYPE_CDC || !type[ctrl->dctype])

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



	return sysfs_emit(buf, type[ctrl->dctype]);

}

static DEVICE_ATTR_RO(dctype);



#ifdef CONFIG_NVME_AUTH

static ssize_t nvme_ctrl_dhchap_secret_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	struct nvmf_ctrl_options *opts = ctrl->opts;



	if (!opts->dhchap_secret)

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

	return sysfs_emit(buf, "%s\n", opts->dhchap_secret);

}



static ssize_t nvme_ctrl_dhchap_secret_store(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	struct nvmf_ctrl_options *opts = ctrl->opts;

	char *dhchap_secret;



	if (!ctrl->opts->dhchap_secret)

		return -EINVAL;

	if (count < 7)

		return -EINVAL;

	if (memcmp(buf, "DHHC-1:", 7))

		return -EINVAL;



	dhchap_secret = kzalloc(count + 1, GFP_KERNEL);

	if (!dhchap_secret)

		return -ENOMEM;

	memcpy(dhchap_secret, buf, count);

	nvme_auth_stop(ctrl);

	if (strcmp(dhchap_secret, opts->dhchap_secret)) {

		struct nvme_dhchap_key *key, *host_key;

		int ret;



		ret = nvme_auth_generate_key(dhchap_secret, &key);

		if (ret)

			return ret;

		kfree(opts->dhchap_secret);

		opts->dhchap_secret = dhchap_secret;

		host_key = ctrl->host_key;

		mutex_lock(&ctrl->dhchap_auth_mutex);

		ctrl->host_key = key;

		mutex_unlock(&ctrl->dhchap_auth_mutex);

		nvme_auth_free_key(host_key);

	}

	/* Start re-authentication */

	dev_info(ctrl->device, "re-authenticating controller\n");

	queue_work(nvme_wq, &ctrl->dhchap_auth_work);



	return count;

}

static DEVICE_ATTR(dhchap_secret, S_IRUGO | S_IWUSR,

	nvme_ctrl_dhchap_secret_show, nvme_ctrl_dhchap_secret_store);



static ssize_t nvme_ctrl_dhchap_ctrl_secret_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	struct nvmf_ctrl_options *opts = ctrl->opts;



	if (!opts->dhchap_ctrl_secret)

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

	return sysfs_emit(buf, "%s\n", opts->dhchap_ctrl_secret);

}



static ssize_t nvme_ctrl_dhchap_ctrl_secret_store(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);

	struct nvmf_ctrl_options *opts = ctrl->opts;

	char *dhchap_secret;



	if (!ctrl->opts->dhchap_ctrl_secret)

		return -EINVAL;

	if (count < 7)

		return -EINVAL;

	if (memcmp(buf, "DHHC-1:", 7))

		return -EINVAL;



	dhchap_secret = kzalloc(count + 1, GFP_KERNEL);

	if (!dhchap_secret)

		return -ENOMEM;

	memcpy(dhchap_secret, buf, count);

	nvme_auth_stop(ctrl);

	if (strcmp(dhchap_secret, opts->dhchap_ctrl_secret)) {

		struct nvme_dhchap_key *key, *ctrl_key;

		int ret;



		ret = nvme_auth_generate_key(dhchap_secret, &key);

		if (ret)

			return ret;

		kfree(opts->dhchap_ctrl_secret);

		opts->dhchap_ctrl_secret = dhchap_secret;

		ctrl_key = ctrl->ctrl_key;

		mutex_lock(&ctrl->dhchap_auth_mutex);

		ctrl->ctrl_key = key;

		mutex_unlock(&ctrl->dhchap_auth_mutex);

		nvme_auth_free_key(ctrl_key);

	}

	/* Start re-authentication */

	dev_info(ctrl->device, "re-authenticating controller\n");

	queue_work(nvme_wq, &ctrl->dhchap_auth_work);



	return count;

}

static DEVICE_ATTR(dhchap_ctrl_secret, S_IRUGO | S_IWUSR,

	nvme_ctrl_dhchap_ctrl_secret_show, nvme_ctrl_dhchap_ctrl_secret_store);

#endif



static struct attribute *nvme_dev_attrs[] = {

	&dev_attr_reset_controller.attr,

	&dev_attr_rescan_controller.attr,

	&dev_attr_model.attr,

	&dev_attr_serial.attr,

	&dev_attr_firmware_rev.attr,

	&dev_attr_cntlid.attr,

	&dev_attr_delete_controller.attr,

	&dev_attr_transport.attr,

	&dev_attr_subsysnqn.attr,

	&dev_attr_address.attr,

	&dev_attr_state.attr,

	&dev_attr_numa_node.attr,

	&dev_attr_queue_count.attr,

	&dev_attr_sqsize.attr,

	&dev_attr_hostnqn.attr,

	&dev_attr_hostid.attr,

	&dev_attr_ctrl_loss_tmo.attr,

	&dev_attr_reconnect_delay.attr,

	&dev_attr_fast_io_fail_tmo.attr,

	&dev_attr_kato.attr,

	&dev_attr_cntrltype.attr,

	&dev_attr_dctype.attr,

#ifdef CONFIG_NVME_AUTH

	&dev_attr_dhchap_secret.attr,

	&dev_attr_dhchap_ctrl_secret.attr,

#endif

	NULL

};



static umode_t nvme_dev_attrs_are_visible(struct kobject *kobj,

		struct attribute *a, int n)

{

	struct device *dev = container_of(kobj, struct device, kobj);

	struct nvme_ctrl *ctrl = dev_get_drvdata(dev);



	if (a == &dev_attr_delete_controller.attr && !ctrl->ops->delete_ctrl)

		return 0;

	if (a == &dev_attr_address.attr && !ctrl->ops->get_address)

		return 0;

	if (a == &dev_attr_hostnqn.attr && !ctrl->opts)

		return 0;

	if (a == &dev_attr_hostid.attr && !ctrl->opts)

		return 0;

	if (a == &dev_attr_ctrl_loss_tmo.attr && !ctrl->opts)

		return 0;

	if (a == &dev_attr_reconnect_delay.attr && !ctrl->opts)

		return 0;

	if (a == &dev_attr_fast_io_fail_tmo.attr && !ctrl->opts)

		return 0;

#ifdef CONFIG_NVME_AUTH

	if (a == &dev_attr_dhchap_secret.attr && !ctrl->opts)

		return 0;

	if (a == &dev_attr_dhchap_ctrl_secret.attr && !ctrl->opts)

		return 0;

#endif



	return a->mode;

}



const struct attribute_group nvme_dev_attrs_group = {

	.attrs		= nvme_dev_attrs,

	.is_visible	= nvme_dev_attrs_are_visible,

};

EXPORT_SYMBOL_GPL(nvme_dev_attrs_group);



static const struct attribute_group *nvme_dev_attr_groups[] = {

	&nvme_dev_attrs_group,

	NULL,

};



static struct nvme_ns_head *nvme_find_ns_head(struct nvme_ctrl *ctrl,

		unsigned nsid)

{
@@ -4209,7 +3566,7 @@ static int nvme_init_ns_head(struct nvme_ns *ns, struct nvme_ns_info *info) 
			goto out_put_ns_head;

		}



		if (!multipath && !list_empty(&head->list)) {

		if (!multipath) {

			dev_warn(ctrl->device,

				"Found shared namespace %d, but multipathing not supported.\n",

				info->nsid);
@@ -4310,7 +3667,7 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, struct nvme_ns_info *info) 
	 * instance as shared namespaces will show up as multiple block

	 * devices.

	 */

	if (ns->head->disk) {

	if (nvme_ns_head_multipath(ns->head)) {

		sprintf(disk->disk_name, "nvme%dc%dn%d", ctrl->subsys->instance,

			ctrl->instance, ns->head->instance);

		disk->flags |= GENHD_FL_HIDDEN;
@@ -5195,6 +4552,8 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev, 


	return 0;

out_free_cdev:

	nvme_fault_inject_fini(&ctrl->fault_inject);

	dev_pm_qos_hide_latency_tolerance(ctrl->device);

	cdev_device_del(&ctrl->cdev, ctrl->device);

out_free_name:

	nvme_put_ctrl(ctrl);

drivers/nvme/host/fabrics.c

+177 −64

File changed.

Preview size limit exceeded, changes collapsed.

drivers/nvme/host/fabrics.h

+16 −5
Original line number Diff line number Diff line
@@ -77,6 +77,9 @@ enum { 
 *			      with the parsing opts enum.

 * @mask:	Used by the fabrics library to parse through sysfs options

 *		on adding a NVMe controller.

 * @max_reconnects: maximum number of allowed reconnect attempts before removing

 *		the controller, (-1) means reconnect forever, zero means remove

 *		immediately;

 * @transport:	Holds the fabric transport "technology name" (for a lack of

 *		better description) that will be used by an NVMe controller

 *		being added.
@@ -96,9 +99,6 @@ enum { 
 * @discovery_nqn: indicates if the subsysnqn is the well-known discovery NQN.

 * @kato:	Keep-alive timeout.

 * @host:	Virtual NVMe host, contains the NQN and Host ID.

 * @max_reconnects: maximum number of allowed reconnect attempts before removing

 *              the controller, (-1) means reconnect forever, zero means remove

 *              immediately;

 * @dhchap_secret: DH-HMAC-CHAP secret

 * @dhchap_ctrl_secret: DH-HMAC-CHAP controller secret for bi-directional

 *              authentication
@@ -112,6 +112,7 @@ enum { 
 */

struct nvmf_ctrl_options {

	unsigned		mask;

	int			max_reconnects;

	char			*transport;

	char			*subsysnqn;

	char			*traddr;
@@ -125,7 +126,6 @@ struct nvmf_ctrl_options { 
	bool			duplicate_connect;

	unsigned int		kato;

	struct nvmf_host	*host;

	int			max_reconnects;

	char			*dhchap_secret;

	char			*dhchap_ctrl_secret;

	bool			disable_sqflow;
@@ -181,7 +181,7 @@ nvmf_ctlr_matches_baseopts(struct nvme_ctrl *ctrl, 
	    ctrl->state == NVME_CTRL_DEAD ||

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

	    strcmp(opts->host->nqn, ctrl->opts->host->nqn) ||

	    memcmp(&opts->host->id, &ctrl->opts->host->id, sizeof(uuid_t)))

	    !uuid_equal(&opts->host->id, &ctrl->opts->host->id))

		return false;



	return true;
@@ -203,6 +203,13 @@ static inline void nvmf_complete_timed_out_request(struct request *rq) 
	}

}



static inline unsigned int nvmf_nr_io_queues(struct nvmf_ctrl_options *opts)

{

	return min(opts->nr_io_queues, num_online_cpus()) +

		min(opts->nr_write_queues, num_online_cpus()) +

		min(opts->nr_poll_queues, num_online_cpus());

}



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);
@@ -215,5 +222,9 @@ int nvmf_get_address(struct nvme_ctrl *ctrl, char *buf, int size); 
bool nvmf_should_reconnect(struct nvme_ctrl *ctrl);

bool nvmf_ip_options_match(struct nvme_ctrl *ctrl,

		struct nvmf_ctrl_options *opts);

void nvmf_set_io_queues(struct nvmf_ctrl_options *opts, u32 nr_io_queues,

			u32 io_queues[HCTX_MAX_TYPES]);

void nvmf_map_queues(struct blk_mq_tag_set *set, struct nvme_ctrl *ctrl,

		     u32 io_queues[HCTX_MAX_TYPES]);



#endif /* _NVME_FABRICS_H */