Merge branch 'nvme-5.2' of git://git.infradead.org/nvme into for-5.2/block-post (47ca23c1) · Commits · 戴 / test

drivers/nvme/host/core.c

+40 −39

Original line number	Diff line number	Diff line
		@@ -1257,10 +1257,9 @@ static u32 nvme_passthru_start(struct nvme_ctrl ctrl, struct nvme_ns ns,
		return 0;
		}

		effects \|= nvme_known_admin_effects(opcode);
		if (ctrl->effects)
		effects = le32_to_cpu(ctrl->effects->acs[opcode]);
		else
		effects = nvme_known_admin_effects(opcode);

		/*
		* For simplicity, IO to all namespaces is quiesced even if the command
		@@ -2342,20 +2341,35 @@ static const struct attribute_group *nvme_subsys_attrs_groups[] = {
		NULL,
		};

		static int nvme_active_ctrls(struct nvme_subsystem *subsys)
		static bool nvme_validate_cntlid(struct nvme_subsystem *subsys,
		struct nvme_ctrl ctrl, struct nvme_id_ctrl id)
		{
		int count = 0;
		struct nvme_ctrl *ctrl;
		struct nvme_ctrl *tmp;

		lockdep_assert_held(&nvme_subsystems_lock);

		list_for_each_entry(tmp, &subsys->ctrls, subsys_entry) {
		if (ctrl->state == NVME_CTRL_DELETING \|\|
		ctrl->state == NVME_CTRL_DEAD)
		continue;

		mutex_lock(&subsys->lock);
		list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
		if (ctrl->state != NVME_CTRL_DELETING &&
		ctrl->state != NVME_CTRL_DEAD)
		count++;
		if (tmp->cntlid == ctrl->cntlid) {
		dev_err(ctrl->device,
		"Duplicate cntlid %u with %s, rejecting\n",
		ctrl->cntlid, dev_name(tmp->device));
		return false;
		}
		mutex_unlock(&subsys->lock);

		return count;
		if ((id->cmic & (1 << 1)) \|\|
		(ctrl->opts && ctrl->opts->discovery_nqn))
		continue;

		dev_err(ctrl->device,
		"Subsystem does not support multiple controllers\n");
		return false;
		}

		return true;
		}

		static int nvme_init_subsystem(struct nvme_ctrl ctrl, struct nvme_id_ctrl id)
		@@ -2395,22 +2409,13 @@ static int nvme_init_subsystem(struct nvme_ctrl ctrl, struct nvme_id_ctrl id)
		mutex_lock(&nvme_subsystems_lock);
		found = __nvme_find_get_subsystem(subsys->subnqn);
		if (found) {
		/*
		* Verify that the subsystem actually supports multiple
		* controllers, else bail out.
		*/
		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",
		found->subnqn);
		nvme_put_subsystem(found);
		ret = -EINVAL;
		goto out_unlock;
		}

		__nvme_release_subsystem(subsys);
		subsys = found;

		if (!nvme_validate_cntlid(subsys, ctrl, id)) {
		ret = -EINVAL;
		goto out_put_subsystem;
		}
		} else {
		ret = device_add(&subsys->dev);
		if (ret) {
		@@ -2422,23 +2427,20 @@ static int nvme_init_subsystem(struct nvme_ctrl ctrl, struct nvme_id_ctrl id)
		list_add_tail(&subsys->entry, &nvme_subsystems);
		}

		ctrl->subsys = subsys;
		mutex_unlock(&nvme_subsystems_lock);

		if (sysfs_create_link(&subsys->dev.kobj, &ctrl->device->kobj,
		dev_name(ctrl->device))) {
		dev_err(ctrl->device,
		"failed to create sysfs link from subsystem.\n");
		/* the transport driver will eventually put the subsystem */
		return -EINVAL;
		goto out_put_subsystem;
		}

		mutex_lock(&subsys->lock);
		ctrl->subsys = subsys;
		list_add_tail(&ctrl->subsys_entry, &subsys->ctrls);
		mutex_unlock(&subsys->lock);

		mutex_unlock(&nvme_subsystems_lock);
		return 0;

		out_put_subsystem:
		nvme_put_subsystem(subsys);
		out_unlock:
		mutex_unlock(&nvme_subsystems_lock);
		put_device(&subsys->dev);
		@@ -3605,19 +3607,18 @@ static void nvme_handle_aen_notice(struct nvme_ctrl *ctrl, u32 result)
		{
		u32 aer_notice_type = (result & 0xff00) >> 8;

		trace_nvme_async_event(ctrl, aer_notice_type);

		switch (aer_notice_type) {
		case NVME_AER_NOTICE_NS_CHANGED:
		trace_nvme_async_event(ctrl, aer_notice_type);
		set_bit(NVME_AER_NOTICE_NS_CHANGED, &ctrl->events);
		nvme_queue_scan(ctrl);
		break;
		case NVME_AER_NOTICE_FW_ACT_STARTING:
		trace_nvme_async_event(ctrl, aer_notice_type);
		queue_work(nvme_wq, &ctrl->fw_act_work);
		break;
		#ifdef CONFIG_NVME_MULTIPATH
		case NVME_AER_NOTICE_ANA:
		trace_nvme_async_event(ctrl, aer_notice_type);
		if (!ctrl->ana_log_buf)
		break;
		queue_work(nvme_wq, &ctrl->ana_work);
		@@ -3696,10 +3697,10 @@ static void nvme_free_ctrl(struct device *dev)
		__free_page(ctrl->discard_page);

		if (subsys) {
		mutex_lock(&subsys->lock);
		mutex_lock(&nvme_subsystems_lock);
		list_del(&ctrl->subsys_entry);
		mutex_unlock(&subsys->lock);
		sysfs_remove_link(&subsys->dev.kobj, dev_name(ctrl->device));
		mutex_unlock(&nvme_subsystems_lock);
		}

		ctrl->ops->free_ctrl(ctrl);

drivers/nvme/host/fabrics.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -978,7 +978,7 @@ EXPORT_SYMBOL_GPL(nvmf_free_options);
		NVMF_OPT_DISABLE_SQFLOW)

		static struct nvme_ctrl *
		nvmf_create_ctrl(struct device dev, const char buf, size_t count)
		nvmf_create_ctrl(struct device dev, const char buf)
		{
		struct nvmf_ctrl_options *opts;
		struct nvmf_transport_ops *ops;
		@@ -1073,7 +1073,7 @@ static ssize_t nvmf_dev_write(struct file file, const char __user ubuf,
		goto out_unlock;
		}

		ctrl = nvmf_create_ctrl(nvmf_device, buf, count);
		ctrl = nvmf_create_ctrl(nvmf_device, buf);
		if (IS_ERR(ctrl)) {
		ret = PTR_ERR(ctrl);
		goto out_unlock;

drivers/nvme/host/fc.c

+11 −3

Original line number	Diff line number	Diff line
		@@ -202,7 +202,7 @@ static LIST_HEAD(nvme_fc_lport_list);
		static DEFINE_IDA(nvme_fc_local_port_cnt);
		static DEFINE_IDA(nvme_fc_ctrl_cnt);


		static struct workqueue_struct *nvme_fc_wq;

		/*
		* These items are short-term. They will eventually be moved into
		@@ -2054,7 +2054,7 @@ nvme_fc_error_recovery(struct nvme_fc_ctrl ctrl, char errmsg)
		*/
		if (ctrl->ctrl.state == NVME_CTRL_CONNECTING) {
		active = atomic_xchg(&ctrl->err_work_active, 1);
		if (!active && !schedule_work(&ctrl->err_work)) {
		if (!active && !queue_work(nvme_fc_wq, &ctrl->err_work)) {
		atomic_set(&ctrl->err_work_active, 0);
		WARN_ON(1);
		}
		@@ -3399,6 +3399,10 @@ static int __init nvme_fc_init_module(void)
		{
		int ret;

		nvme_fc_wq = alloc_workqueue("nvme_fc_wq", WQ_MEM_RECLAIM, 0);
		if (!nvme_fc_wq)
		return -ENOMEM;

		/*
		* NOTE:
		* It is expected that in the future the kernel will combine
		@@ -3416,7 +3420,7 @@ static int __init nvme_fc_init_module(void)
		ret = class_register(&fc_class);
		if (ret) {
		pr_err("couldn't register class fc\n");
		return ret;
		goto out_destroy_wq;
		}

		/*
		@@ -3440,6 +3444,9 @@ out_destroy_device:
		device_destroy(&fc_class, MKDEV(0, 0));
		out_destroy_class:
		class_unregister(&fc_class);
		out_destroy_wq:
		destroy_workqueue(nvme_fc_wq);

		return ret;
		}

		@@ -3456,6 +3463,7 @@ static void __exit nvme_fc_exit_module(void)

		device_destroy(&fc_class, MKDEV(0, 0));
		class_unregister(&fc_class);
		destroy_workqueue(nvme_fc_wq);
		}

		module_init(nvme_fc_init_module);

drivers/nvme/host/multipath.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -31,7 +31,7 @@ void nvme_set_disk_name(char disk_name, struct nvme_ns ns,
		sprintf(disk_name, "nvme%dn%d", ctrl->instance, ns->head->instance);
		} else if (ns->head->disk) {
		sprintf(disk_name, "nvme%dc%dn%d", ctrl->subsys->instance,
		ctrl->cntlid, ns->head->instance);
		ctrl->instance, ns->head->instance);
		*flags = GENHD_FL_HIDDEN;
		} else {
		sprintf(disk_name, "nvme%dn%d", ctrl->subsys->instance,

drivers/nvme/host/pci.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -1296,6 +1296,7 @@ static enum blk_eh_timer_return nvme_timeout(struct request *req, bool reserved)
		switch (dev->ctrl.state) {
		case NVME_CTRL_DELETING:
		shutdown = true;
		/* fall through */
		case NVME_CTRL_CONNECTING:
		case NVME_CTRL_RESETTING:
		dev_warn_ratelimited(dev->ctrl.device,
		@@ -2280,8 +2281,6 @@ static int nvme_dev_add(struct nvme_dev *dev)
		return ret;
		}
		dev->ctrl.tagset = &dev->tagset;

		nvme_dbbuf_set(dev);
		} else {
		blk_mq_update_nr_hw_queues(&dev->tagset, dev->online_queues - 1);

		@@ -2289,6 +2288,7 @@ static int nvme_dev_add(struct nvme_dev *dev)
		nvme_free_queues(dev, dev->online_queues);
		}

		nvme_dbbuf_set(dev);
		return 0;
		}

Admin message