Merge tag 'nvme-5.14-2021-06-08' of git://git.infradead.org/nvme into for-5.14/drivers (600abd34) · Commits · EulixOS / Software / Kernel

drivers/nvme/host/core.c

+121 −52

Original line number	Diff line number	Diff line
		@@ -57,6 +57,26 @@ static bool force_apst;
		module_param(force_apst, bool, 0644);
		MODULE_PARM_DESC(force_apst, "allow APST for newly enumerated devices even if quirked off");

		static unsigned long apst_primary_timeout_ms = 100;
		module_param(apst_primary_timeout_ms, ulong, 0644);
		MODULE_PARM_DESC(apst_primary_timeout_ms,
		"primary APST timeout in ms");

		static unsigned long apst_secondary_timeout_ms = 2000;
		module_param(apst_secondary_timeout_ms, ulong, 0644);
		MODULE_PARM_DESC(apst_secondary_timeout_ms,
		"secondary APST timeout in ms");

		static unsigned long apst_primary_latency_tol_us = 15000;
		module_param(apst_primary_latency_tol_us, ulong, 0644);
		MODULE_PARM_DESC(apst_primary_latency_tol_us,
		"primary APST latency tolerance in us");

		static unsigned long apst_secondary_latency_tol_us = 100000;
		module_param(apst_secondary_latency_tol_us, ulong, 0644);
		MODULE_PARM_DESC(apst_secondary_latency_tol_us,
		"secondary APST latency tolerance in us");

		static bool streams;
		module_param(streams, bool, 0644);
		MODULE_PARM_DESC(streams, "turn on support for Streams write directives");
		@@ -1522,36 +1542,6 @@ static void nvme_enable_aen(struct nvme_ctrl *ctrl)
		queue_work(nvme_wq, &ctrl->async_event_work);
		}

		/*
		* Issue ioctl requests on the first available path. Note that unlike normal
		* block layer requests we will not retry failed request on another controller.
		*/
		struct nvme_ns nvme_get_ns_from_disk(struct gendisk disk,
		struct nvme_ns_head *head, int srcu_idx)
		{
		#ifdef CONFIG_NVME_MULTIPATH
		if (disk->fops == &nvme_ns_head_ops) {
		struct nvme_ns *ns;

		*head = disk->private_data;
		srcu_idx = srcu_read_lock(&(head)->srcu);
		ns = nvme_find_path(*head);
		if (!ns)
		srcu_read_unlock(&(head)->srcu, srcu_idx);
		return ns;
		}
		#endif
		*head = NULL;
		*srcu_idx = -1;
		return disk->private_data;
		}

		void nvme_put_ns_from_disk(struct nvme_ns_head *head, int idx)
		{
		if (head)
		srcu_read_unlock(&head->srcu, idx);
		}

		static int nvme_ns_open(struct nvme_ns *ns)
		{

		@@ -1948,30 +1938,46 @@ static char nvme_pr_type(enum pr_type type)
		}
		};

		static int nvme_send_ns_head_pr_command(struct block_device *bdev,
		struct nvme_command *c, u8 data[16])
		{
		struct nvme_ns_head *head = bdev->bd_disk->private_data;
		int srcu_idx = srcu_read_lock(&head->srcu);
		struct nvme_ns *ns = nvme_find_path(head);
		int ret = -EWOULDBLOCK;

		if (ns) {
		c->common.nsid = cpu_to_le32(ns->head->ns_id);
		ret = nvme_submit_sync_cmd(ns->queue, c, data, 16);
		}
		srcu_read_unlock(&head->srcu, srcu_idx);
		return ret;
		}

		static int nvme_send_ns_pr_command(struct nvme_ns ns, struct nvme_command c,
		u8 data[16])
		{
		c->common.nsid = cpu_to_le32(ns->head->ns_id);
		return nvme_submit_sync_cmd(ns->queue, c, data, 16);
		}

		static int nvme_pr_command(struct block_device *bdev, u32 cdw10,
		u64 key, u64 sa_key, u8 op)
		{
		struct nvme_ns_head *head = NULL;
		struct nvme_ns *ns;
		struct nvme_command c;
		int srcu_idx, ret;
		u8 data[16] = { 0, };

		ns = nvme_get_ns_from_disk(bdev->bd_disk, &head, &srcu_idx);
		if (unlikely(!ns))
		return -EWOULDBLOCK;

		put_unaligned_le64(key, &data[0]);
		put_unaligned_le64(sa_key, &data[8]);

		memset(&c, 0, sizeof(c));
		c.common.opcode = op;
		c.common.nsid = cpu_to_le32(ns->head->ns_id);
		c.common.cdw10 = cpu_to_le32(cdw10);

		ret = nvme_submit_sync_cmd(ns->queue, &c, data, 16);
		nvme_put_ns_from_disk(head, srcu_idx);
		return ret;
		if (IS_ENABLED(CONFIG_NVME_MULTIPATH) &&
		bdev->bd_disk->fops == &nvme_ns_head_ops)
		return nvme_send_ns_head_pr_command(bdev, &c, data);
		return nvme_send_ns_pr_command(bdev->bd_disk->private_data, &c, data);
		}

		static int nvme_pr_register(struct block_device *bdev, u64 old,
		@@ -2053,6 +2059,17 @@ int nvme_sec_submit(void data, u16 spsp, u8 secp, void buffer, size_t len,
		EXPORT_SYMBOL_GPL(nvme_sec_submit);
		#endif /* CONFIG_BLK_SED_OPAL */

		#ifdef CONFIG_BLK_DEV_ZONED
		static int nvme_report_zones(struct gendisk *disk, sector_t sector,
		unsigned int nr_zones, report_zones_cb cb, void *data)
		{
		return nvme_ns_report_zones(disk->private_data, sector, nr_zones, cb,
		data);
		}
		#else
		#define nvme_report_zones NULL
		#endif /* CONFIG_BLK_DEV_ZONED */

		static const struct block_device_operations nvme_bdev_ops = {
		.owner = THIS_MODULE,
		.ioctl = nvme_ioctl,
		@@ -2217,14 +2234,54 @@ static int nvme_configure_acre(struct nvme_ctrl *ctrl)
		return ret;
		}

		/*
		* The function checks whether the given total (exlat + enlat) latency of
		* a power state allows the latter to be used as an APST transition target.
		* It does so by comparing the latency to the primary and secondary latency
		* tolerances defined by module params. If there's a match, the corresponding
		* timeout value is returned and the matching tolerance index (1 or 2) is
		* reported.
		*/
		static bool nvme_apst_get_transition_time(u64 total_latency,
		u64 transition_time, unsigned last_index)
		{
		if (total_latency <= apst_primary_latency_tol_us) {
		if (*last_index == 1)
		return false;
		*last_index = 1;
		*transition_time = apst_primary_timeout_ms;
		return true;
		}
		if (apst_secondary_timeout_ms &&
		total_latency <= apst_secondary_latency_tol_us) {
		if (*last_index <= 2)
		return false;
		*last_index = 2;
		*transition_time = apst_secondary_timeout_ms;
		return true;
		}
		return false;
		}

		/*
		* APST (Autonomous Power State Transition) lets us program a table of power
		* state transitions that the controller will perform automatically.
		* We configure it with a simple heuristic: we are willing to spend at most 2%
		* of the time transitioning between power states. Therefore, when running in
		* any given state, we will enter the next lower-power non-operational state
		* after waiting 50 * (enlat + exlat) microseconds, as long as that state's exit
		* latency is under the requested maximum latency.
		*
		* Depending on module params, one of the two supported techniques will be used:
		*
		* - If the parameters provide explicit timeouts and tolerances, they will be
		* used to build a table with up to 2 non-operational states to transition to.
		* The default parameter values were selected based on the values used by
		* Microsoft's and Intel's NVMe drivers. Yet, since we don't implement dynamic
		* regeneration of the APST table in the event of switching between external
		* and battery power, the timeouts and tolerances reflect a compromise
		* between values used by Microsoft for AC and battery scenarios.
		* - If not, we'll configure the table with a simple heuristic: we are willing
		* to spend at most 2% of the time transitioning between power states.
		* Therefore, when running in any given state, we will enter the next
		* lower-power non-operational state after waiting 50 * (enlat + exlat)
		* microseconds, as long as that state's exit latency is under the requested
		* maximum latency.
		*
		* We will not autonomously enter any non-operational state for which the total
		* latency exceeds ps_max_latency_us.
		@@ -2240,6 +2297,7 @@ static int nvme_configure_apst(struct nvme_ctrl *ctrl)
		int max_ps = -1;
		int state;
		int ret;
		unsigned last_lt_index = UINT_MAX;

		/*
		* If APST isn't supported or if we haven't been initialized yet,
		@@ -2298,13 +2356,19 @@ static int nvme_configure_apst(struct nvme_ctrl *ctrl)
		le32_to_cpu(ctrl->psd[state].entry_lat);

		/*
		* This state is good. Use it as the APST idle target for
		* higher power states.
		* This state is good. It can be used as the APST idle target
		* for higher power states.
		*/
		if (apst_primary_timeout_ms && apst_primary_latency_tol_us) {
		if (!nvme_apst_get_transition_time(total_latency_us,
		&transition_ms, &last_lt_index))
		continue;
		} else {
		transition_ms = total_latency_us + 19;
		do_div(transition_ms, 20);
		if (transition_ms > (1 << 24) - 1)
		transition_ms = (1 << 24) - 1;
		}

		target = cpu_to_le64((state << 3) \| (transition_ms << 8));
		if (max_ps == -1)
		@@ -4067,6 +4131,11 @@ static int nvme_class_uevent(struct device dev, struct kobj_uevent_env env)

		ret = add_uevent_var(env, "NVME_HOST_TRADDR=%s",
		opts->host_traddr ?: "none");
		if (ret)
		return ret;

		ret = add_uevent_var(env, "NVME_HOST_IFACE=%s",
		opts->host_iface ?: "none");
		}
		return ret;
		}

drivers/nvme/host/fabrics.c

+29 −20

Original line number	Diff line number	Diff line
		@@ -112,6 +112,9 @@ int nvmf_get_address(struct nvme_ctrl ctrl, char buf, int size)
		if (ctrl->opts->mask & NVMF_OPT_HOST_TRADDR)
		len += scnprintf(buf + len, size - len, "%shost_traddr=%s",
		(len) ? "," : "", ctrl->opts->host_traddr);
		if (ctrl->opts->mask & NVMF_OPT_HOST_IFACE)
		len += scnprintf(buf + len, size - len, "%shost_iface=%s",
		(len) ? "," : "", ctrl->opts->host_iface);
		len += scnprintf(buf + len, size - len, "\n");

		return len;
		@@ -254,28 +257,23 @@ int nvmf_reg_write32(struct nvme_ctrl *ctrl, u32 off, u32 val)
		EXPORT_SYMBOL_GPL(nvmf_reg_write32);

		/**
		* nvmf_log_connect_error() - Error-parsing-diagnostic print
		* out function for connect() errors.
		*
		* @ctrl: the specific /dev/nvmeX device that had the error.
		*
		* nvmf_log_connect_error() - Error-parsing-diagnostic print out function for
		* connect() errors.
		* @ctrl: The specific /dev/nvmeX device that had the error.
		* @errval: Error code to be decoded in a more human-friendly
		* printout.
		*
		* @offset: For use with the NVMe error code NVME_SC_CONNECT_INVALID_PARAM.
		*
		* @offset: For use with the NVMe error code
		* NVME_SC_CONNECT_INVALID_PARAM.
		* @cmd: This is the SQE portion of a submission capsule.
		*
		* @data: This is the "Data" portion of a submission capsule.
		*/
		static void nvmf_log_connect_error(struct nvme_ctrl *ctrl,
		int errval, int offset, struct nvme_command *cmd,
		struct nvmf_connect_data *data)
		{
		int err_sctype = errval & (~NVME_SC_DNR);
		int err_sctype = errval & ~NVME_SC_DNR;

		switch (err_sctype) {

		case (NVME_SC_CONNECT_INVALID_PARAM):
		if (offset >> 16) {
		char *inv_data = "Connect Invalid Data Parameter";
		@@ -318,30 +316,30 @@ static void nvmf_log_connect_error(struct nvme_ctrl *ctrl,
		}
		}
		break;

		case NVME_SC_CONNECT_INVALID_HOST:
		dev_err(ctrl->device,
		"Connect for subsystem %s is not allowed, hostnqn: %s\n",
		data->subsysnqn, data->hostnqn);
		break;

		case NVME_SC_CONNECT_CTRL_BUSY:
		dev_err(ctrl->device,
		"Connect command failed: controller is busy or not available\n");
		break;

		case NVME_SC_CONNECT_FORMAT:
		dev_err(ctrl->device,
		"Connect incompatible format: %d",
		cmd->connect.recfmt);
		break;

		case NVME_SC_HOST_PATH_ERROR:
		dev_err(ctrl->device,
		"Connect command failed: host path error\n");
		break;
		default:
		dev_err(ctrl->device,
		"Connect command failed, error wo/DNR bit: %d\n",
		err_sctype);
		break;
		} /* switch (err_sctype) */
		}
		}

		/**
		@@ -545,6 +543,7 @@ static const match_table_t opt_tokens = {
		{ NVMF_OPT_KATO, "keep_alive_tmo=%d" },
		{ NVMF_OPT_HOSTNQN, "hostnqn=%s" },
		{ NVMF_OPT_HOST_TRADDR, "host_traddr=%s" },
		{ NVMF_OPT_HOST_IFACE, "host_iface=%s" },
		{ NVMF_OPT_HOST_ID, "hostid=%s" },
		{ NVMF_OPT_DUP_CONNECT, "duplicate_connect" },
		{ NVMF_OPT_DISABLE_SQFLOW, "disable_sqflow" },
		@@ -754,6 +753,15 @@ static int nvmf_parse_options(struct nvmf_ctrl_options *opts,
		kfree(opts->host_traddr);
		opts->host_traddr = p;
		break;
		case NVMF_OPT_HOST_IFACE:
		p = match_strdup(args);
		if (!p) {
		ret = -ENOMEM;
		goto out;
		}
		kfree(opts->host_iface);
		opts->host_iface = p;
		break;
		case NVMF_OPT_HOST_ID:
		p = match_strdup(args);
		if (!p) {
		@@ -938,6 +946,7 @@ void nvmf_free_options(struct nvmf_ctrl_options *opts)
		kfree(opts->trsvcid);
		kfree(opts->subsysnqn);
		kfree(opts->host_traddr);
		kfree(opts->host_iface);
		kfree(opts);
		}
		EXPORT_SYMBOL_GPL(nvmf_free_options);

drivers/nvme/host/fabrics.h

+5 −1

Original line number	Diff line number	Diff line
		@@ -66,6 +66,7 @@ enum {
		NVMF_OPT_NR_POLL_QUEUES = 1 << 18,
		NVMF_OPT_TOS = 1 << 19,
		NVMF_OPT_FAIL_FAST_TMO = 1 << 20,
		NVMF_OPT_HOST_IFACE = 1 << 21,
		};

		/**
		@@ -84,6 +85,8 @@ enum {
		* subsystem which is adding a controller.
		* @host_traddr: A transport-specific field identifying the NVME host port
		* to use for the connection to the controller.
		* @host_iface: A transport-specific field identifying the NVME host
		* interface to use for the connection to the controller.
		* @queue_size: Number of IO queue elements.
		* @nr_io_queues: Number of controller IO queues that will be established.
		* @reconnect_delay: Time between two consecutive reconnect attempts.
		@@ -108,6 +111,7 @@ struct nvmf_ctrl_options {
		char *traddr;
		char *trsvcid;
		char *host_traddr;
		char *host_iface;
		size_t queue_size;
		unsigned int nr_io_queues;
		unsigned int reconnect_delay;

drivers/nvme/host/ioctl.c

+17 −18

Original line number	Diff line number	Diff line
		@@ -372,12 +372,13 @@ long nvme_ns_chr_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
		#ifdef CONFIG_NVME_MULTIPATH
		static int nvme_ns_head_ctrl_ioctl(struct nvme_ns *ns, unsigned int cmd,
		void __user argp, struct nvme_ns_head head, int srcu_idx)
		__releases(&head->srcu)
		{
		struct nvme_ctrl *ctrl = ns->ctrl;
		int ret;

		nvme_get_ctrl(ns->ctrl);
		nvme_put_ns_from_disk(head, srcu_idx);
		srcu_read_unlock(&head->srcu, srcu_idx);
		ret = nvme_ctrl_ioctl(ns->ctrl, cmd, argp);

		nvme_put_ctrl(ctrl);
		@@ -387,14 +388,15 @@ static int nvme_ns_head_ctrl_ioctl(struct nvme_ns *ns, unsigned int cmd,
		int nvme_ns_head_ioctl(struct block_device *bdev, fmode_t mode,
		unsigned int cmd, unsigned long arg)
		{
		struct nvme_ns_head *head = NULL;
		struct nvme_ns_head *head = bdev->bd_disk->private_data;
		void __user argp = (void __user )arg;
		struct nvme_ns *ns;
		int srcu_idx, ret;
		int srcu_idx, ret = -EWOULDBLOCK;

		ns = nvme_get_ns_from_disk(bdev->bd_disk, &head, &srcu_idx);
		if (unlikely(!ns))
		return -EWOULDBLOCK;
		srcu_idx = srcu_read_lock(&head->srcu);
		ns = nvme_find_path(head);
		if (!ns)
		goto out_unlock;

		/*
		* Handle ioctls that apply to the controller instead of the namespace
		@@ -402,12 +404,11 @@ int nvme_ns_head_ioctl(struct block_device *bdev, fmode_t mode,
		* deadlock when deleting namespaces using the passthrough interface.
		*/
		if (is_ctrl_ioctl(cmd))
		ret = nvme_ns_head_ctrl_ioctl(ns, cmd, argp, head, srcu_idx);
		else {
		ret = nvme_ns_ioctl(ns, cmd, argp);
		nvme_put_ns_from_disk(head, srcu_idx);
		}
		return nvme_ns_head_ctrl_ioctl(ns, cmd, argp, head, srcu_idx);

		ret = nvme_ns_ioctl(ns, cmd, argp);
		out_unlock:
		srcu_read_unlock(&head->srcu, srcu_idx);
		return ret;
		}

		@@ -419,21 +420,19 @@ long nvme_ns_head_chr_ioctl(struct file *file, unsigned int cmd,
		container_of(cdev, struct nvme_ns_head, cdev);
		void __user argp = (void __user )arg;
		struct nvme_ns *ns;
		int srcu_idx, ret;
		int srcu_idx, ret = -EWOULDBLOCK;

		srcu_idx = srcu_read_lock(&head->srcu);
		ns = nvme_find_path(head);
		if (!ns) {
		srcu_read_unlock(&head->srcu, srcu_idx);
		return -EWOULDBLOCK;
		}
		if (!ns)
		goto out_unlock;

		if (is_ctrl_ioctl(cmd))
		return nvme_ns_head_ctrl_ioctl(ns, cmd, argp, head, srcu_idx);

		ret = nvme_ns_ioctl(ns, cmd, argp);
		nvme_put_ns_from_disk(head, srcu_idx);

		out_unlock:
		srcu_read_unlock(&head->srcu, srcu_idx);
		return ret;
		}
		#endif /* CONFIG_NVME_MULTIPATH */

drivers/nvme/host/multipath.c

+20 −1

Original line number	Diff line number	Diff line
		@@ -349,6 +349,25 @@ static void nvme_ns_head_release(struct gendisk *disk, fmode_t mode)
		nvme_put_ns_head(disk->private_data);
		}

		#ifdef CONFIG_BLK_DEV_ZONED
		static int nvme_ns_head_report_zones(struct gendisk *disk, sector_t sector,
		unsigned int nr_zones, report_zones_cb cb, void *data)
		{
		struct nvme_ns_head *head = disk->private_data;
		struct nvme_ns *ns;
		int srcu_idx, ret = -EWOULDBLOCK;

		srcu_idx = srcu_read_lock(&head->srcu);
		ns = nvme_find_path(head);
		if (ns)
		ret = nvme_ns_report_zones(ns, sector, nr_zones, cb, data);
		srcu_read_unlock(&head->srcu, srcu_idx);
		return ret;
		}
		#else
		#define nvme_ns_head_report_zones NULL
		#endif /* CONFIG_BLK_DEV_ZONED */

		const struct block_device_operations nvme_ns_head_ops = {
		.owner = THIS_MODULE,
		.submit_bio = nvme_ns_head_submit_bio,
		@@ -356,7 +375,7 @@ const struct block_device_operations nvme_ns_head_ops = {
		.release = nvme_ns_head_release,
		.ioctl = nvme_ns_head_ioctl,
		.getgeo = nvme_getgeo,
		.report_zones = nvme_report_zones,
		.report_zones = nvme_ns_head_report_zones,
		.pr_ops = &nvme_pr_ops,
		};