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

Merge tag 'nvme-5.18-2022-03-03' of git://git.infradead.org/nvme into for-5.18/drivers 

Pull NVMe updates from Christoph:

"nvme updates for Linux 5.18

 - add vectored-io support for user-passthrough (Kanchan Joshi)
 - add verbose error logging (Alan Adamson)
 - support buffered I/O on block devices in nvmet (Chaitanya Kulkarni)
 - central discovery controller support (Martin Belanger)
 - fix and extended the globally unique idenfier validation (me)
 - move away from the deprecated IDA APIs (Sagi Grimberg)
 - misc code cleanup (Keith Busch, Max Gurtovoy, Qinghua Jin,
   Chaitanya Kulkarni)"

* tag 'nvme-5.18-2022-03-03' of git://git.infradead.org/nvme: (27 commits)
  nvme: check that EUI/GUID/UUID are globally unique
  nvme: check for duplicate identifiers earlier
  nvme: fix the check for duplicate unique identifiers
  nvme: cleanup __nvme_check_ids
  nvme: remove nssa from struct nvme_ctrl
  nvme: explicitly set non-error for directives
  nvme: expose cntrltype and dctype through sysfs
  nvme: send uevent on connection up
  nvme: add vectored-io support for user-passthrough
  nvme: add verbose error logging
  nvme: add a helper to initialize connect_q
  nvme-rdma: add helpers for mapping/unmapping request
  nvmet-tcp: replace ida_simple[get|remove] with the simler ida_[alloc|free]
  nvmet-rdma: replace ida_simple[get|remove] with the simler ida_[alloc|free]
  nvmet-fc: replace ida_simple[get|remove] with the simler ida_[alloc|free]
  nvmet: replace ida_simple[get|remove] with the simler ida_[alloc|free]
  nvme-fc: replace ida_simple[get|remove] with the simler ida_[alloc|free]
  nvme: replace ida_simple[get|remove] with the simler ida_[alloc|free]
  nvmet: allow bdev in buffered_io mode
  nvmet: use i_size_read() to set size for file-ns
  ...
parents df00b1d2 2079f41e

drivers/nvme/host/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -24,6 +24,14 @@ config NVME_MULTIPATH 
	   /dev/nvmeXnY device will show up for each NVMe namespace,

	   even if it is accessible through multiple controllers.



config NVME_VERBOSE_ERRORS

	bool "NVMe verbose error reporting"

	depends on NVME_CORE

	help

	   This option enables verbose reporting for NVMe errors. The

	   error translation table will grow the kernel image size by

	   about 4 KB.



config NVME_HWMON

	bool "NVMe hardware monitoring"

	depends on (NVME_CORE=y && HWMON=y) || (NVME_CORE=m && HWMON)

drivers/nvme/host/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ obj-$(CONFIG_NVME_RDMA) += nvme-rdma.o 
obj-$(CONFIG_NVME_FC)			+= nvme-fc.o

obj-$(CONFIG_NVME_TCP)			+= nvme-tcp.o



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

nvme-core-y				:= core.o ioctl.o constants.o

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

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

nvme-core-$(CONFIG_BLK_DEV_ZONED)	+= zns.o

drivers/nvme/host/constants.c

0 → 100644
+185 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * NVM Express device driver verbose errors

 * Copyright (c) 2022, Oracle and/or its affiliates

 */



#include <linux/blkdev.h>

#include "nvme.h"



#ifdef CONFIG_NVME_VERBOSE_ERRORS

static const char * const nvme_ops[] = {

	[nvme_cmd_flush] = "Flush",

	[nvme_cmd_write] = "Write",

	[nvme_cmd_read] = "Read",

	[nvme_cmd_write_uncor] = "Write Uncorrectable",

	[nvme_cmd_compare] = "Compare",

	[nvme_cmd_write_zeroes] = "Write Zeros",

	[nvme_cmd_dsm] = "Dataset Management",

	[nvme_cmd_verify] = "Verify",

	[nvme_cmd_resv_register] = "Reservation Register",

	[nvme_cmd_resv_report] = "Reservation Report",

	[nvme_cmd_resv_acquire] = "Reservation Acquire",

	[nvme_cmd_resv_release] = "Reservation Release",

	[nvme_cmd_zone_mgmt_send] = "Zone Management Send",

	[nvme_cmd_zone_mgmt_recv] = "Zone Management Receive",

	[nvme_cmd_zone_append] = "Zone Management Append",

};



static const char * const nvme_admin_ops[] = {

	[nvme_admin_delete_sq] = "Delete SQ",

	[nvme_admin_create_sq] = "Create SQ",

	[nvme_admin_get_log_page] = "Get Log Page",

	[nvme_admin_delete_cq] = "Delete CQ",

	[nvme_admin_create_cq] = "Create CQ",

	[nvme_admin_identify] = "Identify",

	[nvme_admin_abort_cmd] = "Abort Command",

	[nvme_admin_set_features] = "Set Features",

	[nvme_admin_get_features] = "Get Features",

	[nvme_admin_async_event] = "Async Event",

	[nvme_admin_ns_mgmt] = "Namespace Management",

	[nvme_admin_activate_fw] = "Activate Firmware",

	[nvme_admin_download_fw] = "Download Firmware",

	[nvme_admin_dev_self_test] = "Device Self Test",

	[nvme_admin_ns_attach] = "Namespace Attach",

	[nvme_admin_keep_alive] = "Keep Alive",

	[nvme_admin_directive_send] = "Directive Send",

	[nvme_admin_directive_recv] = "Directive Receive",

	[nvme_admin_virtual_mgmt] = "Virtual Management",

	[nvme_admin_nvme_mi_send] = "NVMe Send MI",

	[nvme_admin_nvme_mi_recv] = "NVMe Receive MI",

	[nvme_admin_dbbuf] = "Doorbell Buffer Config",

	[nvme_admin_format_nvm] = "Format NVM",

	[nvme_admin_security_send] = "Security Send",

	[nvme_admin_security_recv] = "Security Receive",

	[nvme_admin_sanitize_nvm] = "Sanitize NVM",

	[nvme_admin_get_lba_status] = "Get LBA Status",

};



static const char * const nvme_statuses[] = {

	[NVME_SC_SUCCESS] = "Success",

	[NVME_SC_INVALID_OPCODE] = "Invalid Command Opcode",

	[NVME_SC_INVALID_FIELD] = "Invalid Field in Command",

	[NVME_SC_CMDID_CONFLICT] = "Command ID Conflict",

	[NVME_SC_DATA_XFER_ERROR] = "Data Transfer Error",

	[NVME_SC_POWER_LOSS] = "Commands Aborted due to Power Loss Notification",

	[NVME_SC_INTERNAL] = "Internal Error",

	[NVME_SC_ABORT_REQ] = "Command Abort Requested",

	[NVME_SC_ABORT_QUEUE] = "Command Aborted due to SQ Deletion",

	[NVME_SC_FUSED_FAIL] = "Command Aborted due to Failed Fused Command",

	[NVME_SC_FUSED_MISSING] = "Command Aborted due to Missing Fused Command",

	[NVME_SC_INVALID_NS] = "Invalid Namespace or Format",

	[NVME_SC_CMD_SEQ_ERROR] = "Command Sequence Error",

	[NVME_SC_SGL_INVALID_LAST] = "Invalid SGL Segment Descriptor",

	[NVME_SC_SGL_INVALID_COUNT] = "Invalid Number of SGL Descriptors",

	[NVME_SC_SGL_INVALID_DATA] = "Data SGL Length Invalid",

	[NVME_SC_SGL_INVALID_METADATA] = "Metadata SGL Length Invalid",

	[NVME_SC_SGL_INVALID_TYPE] = "SGL Descriptor Type Invalid",

	[NVME_SC_CMB_INVALID_USE] = "Invalid Use of Controller Memory Buffer",

	[NVME_SC_PRP_INVALID_OFFSET] = "PRP Offset Invalid",

	[NVME_SC_ATOMIC_WU_EXCEEDED] = "Atomic Write Unit Exceeded",

	[NVME_SC_OP_DENIED] = "Operation Denied",

	[NVME_SC_SGL_INVALID_OFFSET] = "SGL Offset Invalid",

	[NVME_SC_RESERVED] = "Reserved",

	[NVME_SC_HOST_ID_INCONSIST] = "Host Identifier Inconsistent Format",

	[NVME_SC_KA_TIMEOUT_EXPIRED] = "Keep Alive Timeout Expired",

	[NVME_SC_KA_TIMEOUT_INVALID] = "Keep Alive Timeout Invalid",

	[NVME_SC_ABORTED_PREEMPT_ABORT] = "Command Aborted due to Preempt and Abort",

	[NVME_SC_SANITIZE_FAILED] = "Sanitize Failed",

	[NVME_SC_SANITIZE_IN_PROGRESS] = "Sanitize In Progress",

	[NVME_SC_SGL_INVALID_GRANULARITY] = "SGL Data Block Granularity Invalid",

	[NVME_SC_CMD_NOT_SUP_CMB_QUEUE] = "Command Not Supported for Queue in CMB",

	[NVME_SC_NS_WRITE_PROTECTED] = "Namespace is Write Protected",

	[NVME_SC_CMD_INTERRUPTED] = "Command Interrupted",

	[NVME_SC_TRANSIENT_TR_ERR] = "Transient Transport Error",

	[NVME_SC_INVALID_IO_CMD_SET] = "Invalid IO Command Set",

	[NVME_SC_LBA_RANGE] = "LBA Out of Range",

	[NVME_SC_CAP_EXCEEDED] = "Capacity Exceeded",

	[NVME_SC_NS_NOT_READY] = "Namespace Not Ready",

	[NVME_SC_RESERVATION_CONFLICT] = "Reservation Conflict",

	[NVME_SC_FORMAT_IN_PROGRESS] = "Format In Progress",

	[NVME_SC_CQ_INVALID] = "Completion Queue Invalid",

	[NVME_SC_QID_INVALID] = "Invalid Queue Identifier",

	[NVME_SC_QUEUE_SIZE] = "Invalid Queue Size",

	[NVME_SC_ABORT_LIMIT] = "Abort Command Limit Exceeded",

	[NVME_SC_ABORT_MISSING] = "Reserved", /* XXX */

	[NVME_SC_ASYNC_LIMIT] = "Asynchronous Event Request Limit Exceeded",

	[NVME_SC_FIRMWARE_SLOT] = "Invalid Firmware Slot",

	[NVME_SC_FIRMWARE_IMAGE] = "Invalid Firmware Image",

	[NVME_SC_INVALID_VECTOR] = "Invalid Interrupt Vector",

	[NVME_SC_INVALID_LOG_PAGE] = "Invalid Log Page",

	[NVME_SC_INVALID_FORMAT] = "Invalid Format",

	[NVME_SC_FW_NEEDS_CONV_RESET] = "Firmware Activation Requires Conventional Reset",

	[NVME_SC_INVALID_QUEUE] = "Invalid Queue Deletion",

	[NVME_SC_FEATURE_NOT_SAVEABLE] = "Feature Identifier Not Saveable",

	[NVME_SC_FEATURE_NOT_CHANGEABLE] = "Feature Not Changeable",

	[NVME_SC_FEATURE_NOT_PER_NS] = "Feature Not Namespace Specific",

	[NVME_SC_FW_NEEDS_SUBSYS_RESET] = "Firmware Activation Requires NVM Subsystem Reset",

	[NVME_SC_FW_NEEDS_RESET] = "Firmware Activation Requires Reset",

	[NVME_SC_FW_NEEDS_MAX_TIME] = "Firmware Activation Requires Maximum Time Violation",

	[NVME_SC_FW_ACTIVATE_PROHIBITED] = "Firmware Activation Prohibited",

	[NVME_SC_OVERLAPPING_RANGE] = "Overlapping Range",

	[NVME_SC_NS_INSUFFICIENT_CAP] = "Namespace Insufficient Capacity",

	[NVME_SC_NS_ID_UNAVAILABLE] = "Namespace Identifier Unavailable",

	[NVME_SC_NS_ALREADY_ATTACHED] = "Namespace Already Attached",

	[NVME_SC_NS_IS_PRIVATE] = "Namespace Is Private",

	[NVME_SC_NS_NOT_ATTACHED] = "Namespace Not Attached",

	[NVME_SC_THIN_PROV_NOT_SUPP] = "Thin Provisioning Not Supported",

	[NVME_SC_CTRL_LIST_INVALID] = "Controller List Invalid",

	[NVME_SC_SELT_TEST_IN_PROGRESS] = "Device Self-test In Progress",

	[NVME_SC_BP_WRITE_PROHIBITED] = "Boot Partition Write Prohibited",

	[NVME_SC_CTRL_ID_INVALID] = "Invalid Controller Identifier",

	[NVME_SC_SEC_CTRL_STATE_INVALID] = "Invalid Secondary Controller State",

	[NVME_SC_CTRL_RES_NUM_INVALID] = "Invalid Number of Controller Resources",

	[NVME_SC_RES_ID_INVALID] = "Invalid Resource Identifier",

	[NVME_SC_PMR_SAN_PROHIBITED] = "Sanitize Prohibited",

	[NVME_SC_ANA_GROUP_ID_INVALID] = "ANA Group Identifier Invalid",

	[NVME_SC_ANA_ATTACH_FAILED] = "ANA Attach Failed",

	[NVME_SC_BAD_ATTRIBUTES] = "Conflicting Attributes",

	[NVME_SC_INVALID_PI] = "Invalid Protection Information",

	[NVME_SC_READ_ONLY] = "Attempted Write to Read Only Range",

	[NVME_SC_ONCS_NOT_SUPPORTED] = "ONCS Not Supported",

	[NVME_SC_ZONE_BOUNDARY_ERROR] = "Zoned Boundary Error",

	[NVME_SC_ZONE_FULL] = "Zone Is Full",

	[NVME_SC_ZONE_READ_ONLY] = "Zone Is Read Only",

	[NVME_SC_ZONE_OFFLINE] = "Zone Is Offline",

	[NVME_SC_ZONE_INVALID_WRITE] = "Zone Invalid Write",

	[NVME_SC_ZONE_TOO_MANY_ACTIVE] = "Too Many Active Zones",

	[NVME_SC_ZONE_TOO_MANY_OPEN] = "Too Many Open Zones",

	[NVME_SC_ZONE_INVALID_TRANSITION] = "Invalid Zone State Transition",

	[NVME_SC_WRITE_FAULT] = "Write Fault",

	[NVME_SC_READ_ERROR] = "Unrecovered Read Error",

	[NVME_SC_GUARD_CHECK] = "End-to-end Guard Check Error",

	[NVME_SC_APPTAG_CHECK] = "End-to-end Application Tag Check Error",

	[NVME_SC_REFTAG_CHECK] = "End-to-end Reference Tag Check Error",

	[NVME_SC_COMPARE_FAILED] = "Compare Failure",

	[NVME_SC_ACCESS_DENIED] = "Access Denied",

	[NVME_SC_UNWRITTEN_BLOCK] = "Deallocated or Unwritten Logical Block",

	[NVME_SC_ANA_PERSISTENT_LOSS] = "Asymmetric Access Persistent Loss",

	[NVME_SC_ANA_INACCESSIBLE] = "Asymmetric Access Inaccessible",

	[NVME_SC_ANA_TRANSITION] = "Asymmetric Access Transition",

	[NVME_SC_HOST_PATH_ERROR] = "Host Pathing Error",

};



const unsigned char *nvme_get_error_status_str(u16 status)

{

	status &= 0x7ff;

	if (status < ARRAY_SIZE(nvme_statuses) && nvme_statuses[status])

		return nvme_statuses[status & 0x7ff];

	return "Unknown";

}



const unsigned char *nvme_get_opcode_str(u8 opcode)

{

	if (opcode < ARRAY_SIZE(nvme_ops) && nvme_ops[opcode])

		return nvme_ops[opcode];

	return "Unknown";

}



const unsigned char *nvme_get_admin_opcode_str(u8 opcode)

{

	if (opcode < ARRAY_SIZE(nvme_admin_ops) && nvme_admin_ops[opcode])

		return nvme_admin_ops[opcode];

	return "Unknown";

}

#endif /* CONFIG_NVME_VERBOSE_ERRORS */

drivers/nvme/host/core.c

+154 −38
Original line number Diff line number Diff line
@@ -299,6 +299,37 @@ static void nvme_retry_req(struct request *req) 
	blk_mq_delay_kick_requeue_list(req->q, delay);

}



static void nvme_log_error(struct request *req)

{

	struct nvme_ns *ns = req->q->queuedata;

	struct nvme_request *nr = nvme_req(req);



	if (ns) {

		pr_err_ratelimited("%s: %s(0x%x) @ LBA %llu, %llu blocks, %s (sct 0x%x / sc 0x%x) %s%s\n",

		       ns->disk ? ns->disk->disk_name : "?",

		       nvme_get_opcode_str(nr->cmd->common.opcode),

		       nr->cmd->common.opcode,

		       (unsigned long long)nvme_sect_to_lba(ns, blk_rq_pos(req)),

		       (unsigned long long)blk_rq_bytes(req) >> ns->lba_shift,

		       nvme_get_error_status_str(nr->status),

		       nr->status >> 8 & 7,	/* Status Code Type */

		       nr->status & 0xff,	/* Status Code */

		       nr->status & NVME_SC_MORE ? "MORE " : "",

		       nr->status & NVME_SC_DNR  ? "DNR "  : "");

		return;

	}



	pr_err_ratelimited("%s: %s(0x%x), %s (sct 0x%x / sc 0x%x) %s%s\n",

			   dev_name(nr->ctrl->device),

			   nvme_get_admin_opcode_str(nr->cmd->common.opcode),

			   nr->cmd->common.opcode,

			   nvme_get_error_status_str(nr->status),

			   nr->status >> 8 & 7,	/* Status Code Type */

			   nr->status & 0xff,	/* Status Code */

			   nr->status & NVME_SC_MORE ? "MORE " : "",

			   nr->status & NVME_SC_DNR  ? "DNR "  : "");

}



enum nvme_disposition {

	COMPLETE,

	RETRY,
@@ -339,6 +370,8 @@ static inline void nvme_end_req(struct request *req) 
{

	blk_status_t status = nvme_error_status(nvme_req(req)->status);



	if (unlikely(nvme_req(req)->status != NVME_SC_SUCCESS))

		nvme_log_error(req);

	nvme_end_req_zoned(req);

	nvme_trace_bio_complete(req);

	blk_mq_end_request(req, status);
@@ -561,7 +594,7 @@ static void nvme_free_ns_head(struct kref *ref) 
		container_of(ref, struct nvme_ns_head, ref);



	nvme_mpath_remove_disk(head);

	ida_simple_remove(&head->subsys->ns_ida, head->instance);

	ida_free(&head->subsys->ns_ida, head->instance);

	cleanup_srcu_struct(&head->srcu);

	nvme_put_subsystem(head->subsys);

	kfree(head);
@@ -757,6 +790,7 @@ static int nvme_get_stream_params(struct nvme_ctrl *ctrl, 
static int nvme_configure_directives(struct nvme_ctrl *ctrl)

{

	struct streams_directive_params s;

	u16 nssa;

	int ret;



	if (!(ctrl->oacs & NVME_CTRL_OACS_DIRECTIVES))
@@ -772,14 +806,16 @@ static int nvme_configure_directives(struct nvme_ctrl *ctrl) 
	if (ret)

		goto out_disable_stream;



	ctrl->nssa = le16_to_cpu(s.nssa);

	if (ctrl->nssa < BLK_MAX_WRITE_HINTS - 1) {

	nssa = le16_to_cpu(s.nssa);

	if (nssa < BLK_MAX_WRITE_HINTS - 1) {

		dev_info(ctrl->device, "too few streams (%u) available\n",

					ctrl->nssa);

					nssa);

		/* this condition is not an error: streams are optional */

		ret = 0;

		goto out_disable_stream;

	}



	ctrl->nr_streams = min_t(u16, ctrl->nssa, BLK_MAX_WRITE_HINTS - 1);

	ctrl->nr_streams = min_t(u16, nssa, BLK_MAX_WRITE_HINTS - 1);

	dev_info(ctrl->device, "Using %u streams\n", ctrl->nr_streams);

	return 0;
@@ -1049,8 +1085,7 @@ EXPORT_SYMBOL_GPL(nvme_setup_cmd); 
 * >0: nvme controller's cqe status response

 * <0: kernel error in lieu of controller response

 */

static int nvme_execute_rq(struct gendisk *disk, struct request *rq,

		bool at_head)

static int nvme_execute_rq(struct request *rq, bool at_head)

{

	blk_status_t status;
@@ -1090,7 +1125,7 @@ int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd, 
			goto out;

	}



	ret = nvme_execute_rq(NULL, req, at_head);

	ret = nvme_execute_rq(req, at_head);

	if (result && ret >= 0)

		*result = nvme_req(req)->result;

 out:
@@ -1206,12 +1241,11 @@ int nvme_execute_passthru_rq(struct request *rq) 
	struct nvme_command *cmd = nvme_req(rq)->cmd;

	struct nvme_ctrl *ctrl = nvme_req(rq)->ctrl;

	struct nvme_ns *ns = rq->q->queuedata;

	struct gendisk *disk = ns ? ns->disk : NULL;

	u32 effects;

	int  ret;



	effects = nvme_passthru_start(ctrl, ns, cmd->common.opcode);

	ret = nvme_execute_rq(disk, rq, false);

	ret = nvme_execute_rq(rq, false);

	if (effects) /* nothing to be done for zero cmd effects */

		nvme_passthru_end(ctrl, effects, cmd, ret);
@@ -1682,13 +1716,6 @@ static void nvme_config_discard(struct gendisk *disk, struct nvme_ns *ns) 
		blk_queue_max_write_zeroes_sectors(queue, UINT_MAX);

}



static bool nvme_ns_ids_valid(struct nvme_ns_ids *ids)

{

	return !uuid_is_null(&ids->uuid) ||

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

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

}



static bool nvme_ns_ids_equal(struct nvme_ns_ids *a, struct nvme_ns_ids *b)

{

	return uuid_equal(&a->uuid, &b->uuid) &&
@@ -1979,7 +2006,7 @@ static char nvme_pr_type(enum pr_type type) 
	default:

		return 0;

	}

};

}



static int nvme_send_ns_head_pr_command(struct block_device *bdev,

		struct nvme_command *c, u8 data[16])
@@ -2567,7 +2594,7 @@ static void nvme_release_subsystem(struct device *dev) 
		container_of(dev, struct nvme_subsystem, dev);



	if (subsys->instance >= 0)

		ida_simple_remove(&nvme_instance_ida, subsys->instance);

		ida_free(&nvme_instance_ida, subsys->instance);

	kfree(subsys);

}
@@ -2992,6 +3019,9 @@ static int nvme_init_identify(struct nvme_ctrl *ctrl) 
	ctrl->max_namespaces = le32_to_cpu(id->mnan);

	ctrl->ctratt = le32_to_cpu(id->ctratt);



	ctrl->cntrltype = id->cntrltype;

	ctrl->dctype = id->dctype;



	if (id->rtd3e) {

		/* us -> s */

		u32 transition_time = le32_to_cpu(id->rtd3e) / USEC_PER_SEC;
@@ -3525,6 +3555,40 @@ static ssize_t nvme_ctrl_fast_io_fail_tmo_store(struct device *dev, 
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);



static struct attribute *nvme_dev_attrs[] = {

	&dev_attr_reset_controller.attr,

	&dev_attr_rescan_controller.attr,
@@ -3546,6 +3610,8 @@ static struct attribute *nvme_dev_attrs[] = { 
	&dev_attr_reconnect_delay.attr,

	&dev_attr_fast_io_fail_tmo.attr,

	&dev_attr_kato.attr,

	&dev_attr_cntrltype.attr,

	&dev_attr_dctype.attr,

	NULL

};
@@ -3600,16 +3666,24 @@ static struct nvme_ns_head *nvme_find_ns_head(struct nvme_subsystem *subsys, 
	return NULL;

}



static int __nvme_check_ids(struct nvme_subsystem *subsys,

		struct nvme_ns_head *new)

static int nvme_subsys_check_duplicate_ids(struct nvme_subsystem *subsys,

		struct nvme_ns_ids *ids)

{

	bool has_uuid = !uuid_is_null(&ids->uuid);

	bool has_nguid = memchr_inv(ids->nguid, 0, sizeof(ids->nguid));

	bool has_eui64 = memchr_inv(ids->eui64, 0, sizeof(ids->eui64));

	struct nvme_ns_head *h;



	lockdep_assert_held(&subsys->lock);



	list_for_each_entry(h, &subsys->nsheads, entry) {

		if (nvme_ns_ids_valid(&new->ids) &&

		    nvme_ns_ids_equal(&new->ids, &h->ids))

		if (has_uuid && uuid_equal(&ids->uuid, &h->ids.uuid))

			return -EINVAL;

		if (has_nguid &&

		    memcmp(&ids->nguid, &h->ids.nguid, sizeof(ids->nguid)) == 0)

			return -EINVAL;

		if (has_eui64 &&

		    memcmp(&ids->eui64, &h->ids.eui64, sizeof(ids->eui64)) == 0)

			return -EINVAL;

	}
@@ -3618,7 +3692,7 @@ static int __nvme_check_ids(struct nvme_subsystem *subsys, 


static void nvme_cdev_rel(struct device *dev)

{

	ida_simple_remove(&nvme_ns_chr_minor_ida, MINOR(dev->devt));

	ida_free(&nvme_ns_chr_minor_ida, MINOR(dev->devt));

}



void nvme_cdev_del(struct cdev *cdev, struct device *cdev_device)
@@ -3632,7 +3706,7 @@ int nvme_cdev_add(struct cdev *cdev, struct device *cdev_device, 
{

	int minor, ret;



	minor = ida_simple_get(&nvme_ns_chr_minor_ida, 0, 0, GFP_KERNEL);

	minor = ida_alloc(&nvme_ns_chr_minor_ida, GFP_KERNEL);

	if (minor < 0)

		return minor;

	cdev_device->devt = MKDEV(MAJOR(nvme_ns_chr_devt), minor);
@@ -3695,7 +3769,7 @@ static struct nvme_ns_head *nvme_alloc_ns_head(struct nvme_ctrl *ctrl, 
	head = kzalloc(size, GFP_KERNEL);

	if (!head)

		goto out;

	ret = ida_simple_get(&ctrl->subsys->ns_ida, 1, 0, GFP_KERNEL);

	ret = ida_alloc_min(&ctrl->subsys->ns_ida, 1, GFP_KERNEL);

	if (ret < 0)

		goto out_free_head;

	head->instance = ret;
@@ -3708,13 +3782,6 @@ static struct nvme_ns_head *nvme_alloc_ns_head(struct nvme_ctrl *ctrl, 
	head->ids = *ids;

	kref_init(&head->ref);



	ret = __nvme_check_ids(ctrl->subsys, head);

	if (ret) {

		dev_err(ctrl->device,

			"duplicate IDs for nsid %d\n", nsid);

		goto out_cleanup_srcu;

	}



	if (head->ids.csi) {

		ret = nvme_get_effects_log(ctrl, head->ids.csi, &head->effects);

		if (ret)
@@ -3734,7 +3801,7 @@ static struct nvme_ns_head *nvme_alloc_ns_head(struct nvme_ctrl *ctrl, 
out_cleanup_srcu:

	cleanup_srcu_struct(&head->srcu);

out_ida_remove:

	ida_simple_remove(&ctrl->subsys->ns_ida, head->instance);

	ida_free(&ctrl->subsys->ns_ida, head->instance);

out_free_head:

	kfree(head);

out:
@@ -3743,16 +3810,56 @@ static struct nvme_ns_head *nvme_alloc_ns_head(struct nvme_ctrl *ctrl, 
	return ERR_PTR(ret);

}



static int nvme_global_check_duplicate_ids(struct nvme_subsystem *this,

		struct nvme_ns_ids *ids)

{

	struct nvme_subsystem *s;

	int ret = 0;



	/*

	 * Note that this check is racy as we try to avoid holding the global

	 * lock over the whole ns_head creation.  But it is only intended as

	 * a sanity check anyway.

	 */

	mutex_lock(&nvme_subsystems_lock);

	list_for_each_entry(s, &nvme_subsystems, entry) {

		if (s == this)

			continue;

		mutex_lock(&s->lock);

		ret = nvme_subsys_check_duplicate_ids(s, ids);

		mutex_unlock(&s->lock);

		if (ret)

			break;

	}

	mutex_unlock(&nvme_subsystems_lock);



	return ret;

}



static int nvme_init_ns_head(struct nvme_ns *ns, unsigned nsid,

		struct nvme_ns_ids *ids, bool is_shared)

{

	struct nvme_ctrl *ctrl = ns->ctrl;

	struct nvme_ns_head *head = NULL;

	int ret = 0;

	int ret;



	ret = nvme_global_check_duplicate_ids(ctrl->subsys, ids);

	if (ret) {

		dev_err(ctrl->device,

			"globally duplicate IDs for nsid %d\n", nsid);

		return ret;

	}



	mutex_lock(&ctrl->subsys->lock);

	head = nvme_find_ns_head(ctrl->subsys, nsid);

	if (!head) {

		ret = nvme_subsys_check_duplicate_ids(ctrl->subsys, ids);

		if (ret) {

			dev_err(ctrl->device,

				"duplicate IDs in subsystem for nsid %d\n",

				nsid);

			goto out_unlock;

		}

		head = nvme_alloc_ns_head(ctrl, nsid, ids);

		if (IS_ERR(head)) {

			ret = PTR_ERR(head);
@@ -4231,6 +4338,13 @@ static int nvme_class_uevent(struct device *dev, struct kobj_uevent_env *env) 
	return ret;

}



static void nvme_change_uevent(struct nvme_ctrl *ctrl, char *envdata)

{

	char *envp[2] = { envdata, NULL };



	kobject_uevent_env(&ctrl->device->kobj, KOBJ_CHANGE, envp);

}



static void nvme_aen_uevent(struct nvme_ctrl *ctrl)

{

	char *envp[2] = { NULL, NULL };
@@ -4398,6 +4512,8 @@ void nvme_start_ctrl(struct nvme_ctrl *ctrl) 
		nvme_queue_scan(ctrl);

		nvme_start_queues(ctrl);

	}



	nvme_change_uevent(ctrl, "NVME_EVENT=connected");

}

EXPORT_SYMBOL_GPL(nvme_start_ctrl);
@@ -4431,7 +4547,7 @@ static void nvme_free_ctrl(struct device *dev) 
	struct nvme_subsystem *subsys = ctrl->subsys;



	if (!subsys || ctrl->instance != subsys->instance)

		ida_simple_remove(&nvme_instance_ida, ctrl->instance);

		ida_free(&nvme_instance_ida, ctrl->instance);



	nvme_free_cels(ctrl);

	nvme_mpath_uninit(ctrl);
@@ -4490,7 +4606,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev, 
		goto out;

	}



	ret = ida_simple_get(&nvme_instance_ida, 0, 0, GFP_KERNEL);

	ret = ida_alloc(&nvme_instance_ida, GFP_KERNEL);

	if (ret < 0)

		goto out;

	ctrl->instance = ret;
@@ -4531,7 +4647,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev, 
	nvme_put_ctrl(ctrl);

	kfree_const(ctrl->device->kobj.name);

out_release_instance:

	ida_simple_remove(&nvme_instance_ida, ctrl->instance);

	ida_free(&nvme_instance_ida, ctrl->instance);

out:

	if (ctrl->discard_page)

		__free_page(ctrl->discard_page);

drivers/nvme/host/fabrics.c

+4 −5
Original line number Diff line number Diff line
@@ -144,11 +144,10 @@ EXPORT_SYMBOL_GPL(nvmf_get_address); 
 */

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

{

	struct nvme_command cmd;

	struct nvme_command cmd = { };

	union nvme_result res;

	int ret;



	memset(&cmd, 0, sizeof(cmd));

	cmd.prop_get.opcode = nvme_fabrics_command;

	cmd.prop_get.fctype = nvme_fabrics_type_property_get;

	cmd.prop_get.offset = cpu_to_le32(off);
@@ -272,7 +271,7 @@ static void nvmf_log_connect_error(struct nvme_ctrl *ctrl, 
	int err_sctype = errval & ~NVME_SC_DNR;



	switch (err_sctype) {

	case (NVME_SC_CONNECT_INVALID_PARAM):

	case NVME_SC_CONNECT_INVALID_PARAM:

		if (offset >> 16) {

			char *inv_data = "Connect Invalid Data Parameter";
@@ -873,7 +872,7 @@ static int nvmf_check_required_opts(struct nvmf_ctrl_options *opts, 
		unsigned int required_opts)

{

	if ((opts->mask & required_opts) != required_opts) {

		int i;

		unsigned int i;



		for (i = 0; i < ARRAY_SIZE(opt_tokens); i++) {

			if ((opt_tokens[i].token & required_opts) &&
@@ -923,7 +922,7 @@ static int nvmf_check_allowed_opts(struct nvmf_ctrl_options *opts, 
		unsigned int allowed_opts)

{

	if (opts->mask & ~allowed_opts) {

		int i;

		unsigned int i;



		for (i = 0; i < ARRAY_SIZE(opt_tokens); i++) {

			if ((opt_tokens[i].token & opts->mask) &&