Skip to contentSkip to conversation

*** Implement the NVMe reservation feature ***

PATCH Superseded Guixin Liu 2 participants 13 messages Jan 14, 2024 – Jan 16, 2024

Subsystems (2)
lore
Share & tools
lore

Guixin Liu

author
#0 lore raw

v2 cover *** Implement the NVMe reservation feature ***

Hi guys,
I've implemented the NVMe reservation feature. Please review it, all
comments are welcome as usual.

Changes from v1 to v2:
- Implement the reservation notification report, includes registration preempted, reservation released and reservation preempted. And also handle the reservation log page avaliable event and send get
reservation log page command to clear log page at host.

- Put the reservation check access after validate opcode. And remove opcodes which nvmet not implement yet check.
Now there is no admin opcode nvmet implemented needs reservation check,
so I dont add reservation check to admin command path.
Next we need to do reservation check includes the situation of nsid is
0xffffffff at each admin command path, if it is needed.

- Add reservation commands support in nvmet_get_cmd_effects_nvm().

- From Chaitanya, change the local variable tree style to make it cleaner, and add some comments about NVMe spec.
And also change others advice from chaitanya.

- Put the nvmet_pr_check_cmd_access and nvmet_parse_pr_cmd into reservation enable check warp.

- Remove kmem_cache instead to use kmalloc and kfree.

- Change others advice from Sagi.

- Add a blktest test case, this patch will be sent before these series of pathes.

Advice I dont adopt:
- From Sagi, use rcu instead of rwlock.
I need protect registrant_list, holder, type and generation simutaneously,
the rcu can not protect multiple units.

- From Sagi, use blkdev's pr_ops if it is exist.
The backend is unable to distinguish connections from the frontend, If we
use the pr_ops of the block device, the block device's target would only recognize it as a reservation by the nvme target.
Could you plz give me more information? Sagi?

- From Keith, use nvmet_get_cmd_effects_nvm to see if a command would violate a reservation.
The information is missing in effects, for example the flush command should
be checked, but there is onely a NVME_CMD_EFFECTS_CSUPP flag in effects, no LBCC.

Guixin Liu (3):
nvmet: support reservation feature
nvmet: unify aer type enum
nvme: introduce pr_work to handle resv event

 drivers/nvme/host/core.c        |  47 +-
 drivers/nvme/host/nvme.h        |   1 +
 drivers/nvme/target/Makefile    |   2 +-
 drivers/nvme/target/admin-cmd.c |  14 +-
 drivers/nvme/target/configfs.c  |  27 +
 drivers/nvme/target/core.c      |  53 +-
 drivers/nvme/target/discovery.c |   2 +-
 drivers/nvme/target/nvmet.h     |  33 ++
 drivers/nvme/target/pr.c        | 887 ++++++++++++++++++++++++++++++++
 include/linux/nvme.h            |  54 +-
 10 files changed, 1103 insertions(+), 17 deletions(-)
 create mode 100644 drivers/nvme/target/pr.c
Signature · 1 line
2.43.0
author
#1 lore raw

PATCH v2 1/3 nvmet: support reservation feature

This patch implements the reservation feature, includes:
1. reservation register(register, unregister and replace).
2. reservation acquire(acquire, preempt, preempt and abort).
3. reservation release(release and clear).
4. reservation report.

And also make reservation configurable, one can set ns to support reservation before enable ns. The default of resv_enable is false.

---
 drivers/nvme/target/Makefile    |   2 +-
 drivers/nvme/target/admin-cmd.c |  14 +-
 drivers/nvme/target/configfs.c  |  27 +
 drivers/nvme/target/core.c      |  49 +-
 drivers/nvme/target/nvmet.h     |  33 ++
 drivers/nvme/target/pr.c        | 887 ++++++++++++++++++++++++++++++++
 include/linux/nvme.h            |  48 ++
 7 files changed, 1053 insertions(+), 7 deletions(-)
 create mode 100644 drivers/nvme/target/pr.c
drivers/nvme/target/Makefile +1 -1
index c66820102493..f9bfc904a5b3 100644
@@ -10,7 +10,7 @@ obj-$(CONFIG_NVME_TARGET_FCLOOP)	+= nvme-fcloop.o
 obj-$(CONFIG_NVME_TARGET_TCP)		+= nvmet-tcp.o
 
 nvmet-y		+= core.o configfs.o admin-cmd.o fabrics-cmd.o \
-			discovery.o io-cmd-file.o io-cmd-bdev.o
+			discovery.o io-cmd-file.o io-cmd-bdev.o pr.o
 nvmet-$(CONFIG_NVME_TARGET_PASSTHRU)	+= passthru.o
 nvmet-$(CONFIG_BLK_DEV_ZONED)		+= zns.o
 nvmet-$(CONFIG_NVME_TARGET_AUTH)	+= fabrics-cmd-auth.o auth.o
drivers/nvme/target/admin-cmd.c +13 -1
index 39cb570f833d..791bc7e740c0 100644
@@ -176,6 +176,10 @@ static void nvmet_get_cmd_effects_nvm(struct nvme_effects_log *log)
 	log->iocs[nvme_cmd_read] =
 	log->iocs[nvme_cmd_flush] =
 	log->iocs[nvme_cmd_dsm]	=
+	log->iocs[nvme_cmd_resv_acquire] =
+	log->iocs[nvme_cmd_resv_register] =
+	log->iocs[nvme_cmd_resv_release] =
+	log->iocs[nvme_cmd_resv_report] =
 		cpu_to_le32(NVME_CMD_EFFECTS_CSUPP);
 	log->iocs[nvme_cmd_write] =
 	log->iocs[nvme_cmd_write_zeroes] =
@@ -340,6 +344,8 @@ static void nvmet_execute_get_log_page(struct nvmet_req *req)
 		return nvmet_execute_get_log_cmd_effects_ns(req);
 	case NVME_LOG_ANA:
 		return nvmet_execute_get_log_page_ana(req);
+	case NVME_LOG_RESERVATION:
+		return nvmet_execute_get_log_page_resv(req);
 	}
 	pr_debug("unhandled lid %d on qid %d\n",
 	       req->cmd->get_log_page.lid, req->sq->qid);
@@ -550,7 +556,13 @@ static void nvmet_execute_identify_ns(struct nvmet_req *req)
 	 */
 	id->nmic = NVME_NS_NMIC_SHARED;
 	id->anagrpid = cpu_to_le32(req->ns->anagrpid);
-
+	id->rescap = NVME_PR_SUPPORT_WRITE_EXCLUSIVE |
+		     NVME_PR_SUPPORT_EXCLUSIVE_ACCESS |
+		     NVME_PR_SUPPORT_WRITE_EXCLUSIVE_REG_ONLY |
+		     NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_REG_ONLY |
+		     NVME_PR_SUPPORT_WRITE_EXCLUSIVE_ALL_REGS |
+		     NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_ALL_REGS |
+		     NVME_PR_SUPPORT_IEKEY_VER_1_3_DEF;
 	memcpy(&id->nguid, &req->ns->nguid, sizeof(id->nguid));
 
 	id->lbaf[0].ds = req->ns->blksize_shift;
drivers/nvme/target/configfs.c +27 -0
index d937fe05129e..1ac4802ec818 100644
@@ -714,6 +714,32 @@ static ssize_t nvmet_ns_revalidate_size_store(struct config_item *item,
 
 CONFIGFS_ATTR_WO(nvmet_ns_, revalidate_size);
 
+static ssize_t nvmet_ns_resv_enable_show(struct config_item *item, char *page)
+{
+	return sprintf(page, "%d\n", to_nvmet_ns(item)->pr.enable);
+}
+
+static ssize_t nvmet_ns_resv_enable_store(struct config_item *item,
+					const char *page, size_t count)
+{
+	struct nvmet_ns *ns = to_nvmet_ns(item);
+	bool val;
+
+	if (kstrtobool(page, &val))
+		return -EINVAL;
+
+	mutex_lock(&ns->subsys->lock);
+	if (ns->enabled) {
+		pr_err("the ns:%d is already enabled.\n", ns->nsid);
+		mutex_unlock(&ns->subsys->lock);
+		return -EINVAL;
+	}
+	ns->pr.enable = val;
+	mutex_unlock(&ns->subsys->lock);
+	return count;
+}
+CONFIGFS_ATTR(nvmet_ns_, resv_enable);
+
 static struct configfs_attribute *nvmet_ns_attrs[] = {
 	&nvmet_ns_attr_device_path,
 	&nvmet_ns_attr_device_nguid,
@@ -722,6 +748,7 @@ static struct configfs_attribute *nvmet_ns_attrs[] = {
 	&nvmet_ns_attr_enable,
 	&nvmet_ns_attr_buffered_io,
 	&nvmet_ns_attr_revalidate_size,
+	&nvmet_ns_attr_resv_enable,
 #ifdef CONFIG_PCI_P2PDMA
 	&nvmet_ns_attr_p2pmem,
 #endif
drivers/nvme/target/core.c +44 -5

92 lines not on this page · raw message

drivers/nvme/target/nvmet.h +33 -0
index 6c8acebe1a1a..4ba4958768ac 100644
@@ -56,6 +56,22 @@
 #define IPO_IATTR_CONNECT_SQE(x)	\
 	(cpu_to_le32(offsetof(struct nvmf_connect_command, x)))
 
+struct nvmet_pr_registrant {
+	bool			is_holder;
+	u64			rkey;
+	uuid_t			hostid;
+	struct list_head	entry;
+};
+
+struct nvmet_pr {
+	bool			enable;
+	enum nvme_pr_type	rtype;
+	u32			generation;
+	struct nvmet_pr_registrant *holder;
+	rwlock_t		pr_lock;
+	struct list_head	registrant_list;
+};
+
 struct nvmet_ns {
 	struct percpu_ref	ref;
 	struct bdev_handle	*bdev_handle;
@@ -85,6 +101,7 @@ struct nvmet_ns {
 	int			pi_type;
 	int			metadata_size;
 	u8			csi;
+	struct nvmet_pr		pr;
 };
 
 static inline struct nvmet_ns *to_nvmet_ns(struct config_item *item)
@@ -190,6 +207,11 @@ static inline bool nvmet_port_secure_channel_required(struct nvmet_port *port)
     return nvmet_port_disc_addr_treq_secure_channel(port) == NVMF_TREQ_REQUIRED;
 }
 
+struct nvmet_pr_log_entry {
+	struct nvme_pr_log log;
+	struct list_head entry;
+};
+
 struct nvmet_ctrl {
 	struct nvmet_subsys	*subsys;
 	struct nvmet_sq		**sqs;
@@ -243,6 +265,9 @@ struct nvmet_ctrl {
 	u8			*dh_key;
 	size_t			dh_keysize;
 #endif
+	struct mutex		resv_log_lock;
+	u64			resv_log_counter;
+	struct list_head	resv_log_list;
 };
 
 struct nvmet_subsys {
@@ -750,4 +775,12 @@ static inline bool nvmet_has_auth(struct nvmet_ctrl *ctrl)
 static inline const char *nvmet_dhchap_dhgroup_name(u8 dhgid) { return NULL; }
 #endif
 
+void nvmet_pr_init_ns(struct nvmet_ns *ns);
+u16 nvmet_parse_pr_cmd(struct nvmet_req *req);
+u16 nvmet_pr_check_cmd_access(struct nvmet_req *req);
+void nvmet_ctrl_destroy_pr(struct nvmet_ctrl *ctrl);
+void nvmet_pr_exit_ns(struct nvmet_ns *ns);
+bool nvmet_is_host_still_connected(uuid_t *hostid, struct nvmet_subsys *subsys);
+void nvmet_execute_get_log_page_resv(struct nvmet_req *req);
+
 #endif /* _NVMET_H */
drivers/nvme/target/pr.c new file +887 -0

887 lines not on this page · raw message

include/linux/nvme.h +48 -0

66 lines not on this page · raw message

Signature · 1 line
2.43.0
maintainer
#2 lore raw

Re: [PATCH V2 1/3] nvmet: support reservation feature

Quoted 346 lines · Guixin Liu

This patch implements the reservation feature, includes:
1. reservation register(register, unregister and replace).
2. reservation acquire(acquire, preempt, preempt and abort).
3. reservation release(release and clear).
4. reservation report.

And also make reservation configurable, one can set ns to support reservation before enable ns. The default of resv_enable is false.

---
  drivers/nvme/target/Makefile    |   2 +-
  drivers/nvme/target/admin-cmd.c |  14 +-
  drivers/nvme/target/configfs.c  |  27 +
  drivers/nvme/target/core.c      |  49 +-
  drivers/nvme/target/nvmet.h     |  33 ++
  drivers/nvme/target/pr.c        | 887 ++++++++++++++++++++++++++++++++
  include/linux/nvme.h            |  48 ++
  7 files changed, 1053 insertions(+), 7 deletions(-)

create mode 100644 drivers/nvme/target/pr.c

drivers/nvme/target/Makefile +1 -1
index c66820102493..f9bfc904a5b3 100644
@@ -10,7 +10,7 @@ obj-$(CONFIG_NVME_TARGET_FCLOOP)	+= nvme-fcloop.o
  obj-$(CONFIG_NVME_TARGET_TCP)		+= nvmet-tcp.o
 
  nvmet-y		+= core.o configfs.o admin-cmd.o fabrics-cmd.o \
-			discovery.o io-cmd-file.o io-cmd-bdev.o
+			discovery.o io-cmd-file.o io-cmd-bdev.o pr.o
  nvmet-$(CONFIG_NVME_TARGET_PASSTHRU)	+= passthru.o
  nvmet-$(CONFIG_BLK_DEV_ZONED)		+= zns.o
  nvmet-$(CONFIG_NVME_TARGET_AUTH)	+= fabrics-cmd-auth.o auth.o
drivers/nvme/target/admin-cmd.c +13 -1
index 39cb570f833d..791bc7e740c0 100644
@@ -176,6 +176,10 @@ static void nvmet_get_cmd_effects_nvm(struct nvme_effects_log *log)
  	log->iocs[nvme_cmd_read] =
  	log->iocs[nvme_cmd_flush] =
  	log->iocs[nvme_cmd_dsm]	=
+	log->iocs[nvme_cmd_resv_acquire] =
+	log->iocs[nvme_cmd_resv_register] =
+	log->iocs[nvme_cmd_resv_release] =
+	log->iocs[nvme_cmd_resv_report] =
  		cpu_to_le32(NVME_CMD_EFFECTS_CSUPP);
  	log->iocs[nvme_cmd_write] =
  	log->iocs[nvme_cmd_write_zeroes] =
@@ -340,6 +344,8 @@ static void nvmet_execute_get_log_page(struct nvmet_req *req)
  		return nvmet_execute_get_log_cmd_effects_ns(req);
  	case NVME_LOG_ANA:
  		return nvmet_execute_get_log_page_ana(req);
+	case NVME_LOG_RESERVATION:
+		return nvmet_execute_get_log_page_resv(req);
  	}
  	pr_debug("unhandled lid %d on qid %d\n",
  	       req->cmd->get_log_page.lid, req->sq->qid);
@@ -550,7 +556,13 @@ static void nvmet_execute_identify_ns(struct nvmet_req *req)
  	 */
  	id->nmic = NVME_NS_NMIC_SHARED;
  	id->anagrpid = cpu_to_le32(req->ns->anagrpid);
-
+	id->rescap = NVME_PR_SUPPORT_WRITE_EXCLUSIVE |
+		     NVME_PR_SUPPORT_EXCLUSIVE_ACCESS |
+		     NVME_PR_SUPPORT_WRITE_EXCLUSIVE_REG_ONLY |
+		     NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_REG_ONLY |
+		     NVME_PR_SUPPORT_WRITE_EXCLUSIVE_ALL_REGS |
+		     NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_ALL_REGS |
+		     NVME_PR_SUPPORT_IEKEY_VER_1_3_DEF;
  	memcpy(&id->nguid, &req->ns->nguid, sizeof(id->nguid));
 
  	id->lbaf[0].ds = req->ns->blksize_shift;
drivers/nvme/target/configfs.c +27 -0
index d937fe05129e..1ac4802ec818 100644
@@ -714,6 +714,32 @@ static ssize_t nvmet_ns_revalidate_size_store(struct config_item *item,
 
  CONFIGFS_ATTR_WO(nvmet_ns_, revalidate_size);
 
+static ssize_t nvmet_ns_resv_enable_show(struct config_item *item, char *page)
+{
+	return sprintf(page, "%d\n", to_nvmet_ns(item)->pr.enable);
+}
+
+static ssize_t nvmet_ns_resv_enable_store(struct config_item *item,
+					const char *page, size_t count)
+{
+	struct nvmet_ns *ns = to_nvmet_ns(item);
+	bool val;
+
+	if (kstrtobool(page, &val))
+		return -EINVAL;
+
+	mutex_lock(&ns->subsys->lock);
+	if (ns->enabled) {
+		pr_err("the ns:%d is already enabled.\n", ns->nsid);
+		mutex_unlock(&ns->subsys->lock);
+		return -EINVAL;
+	}
+	ns->pr.enable = val;
+	mutex_unlock(&ns->subsys->lock);
+	return count;
+}
+CONFIGFS_ATTR(nvmet_ns_, resv_enable);
+
  static struct configfs_attribute *nvmet_ns_attrs[] = {
  	&nvmet_ns_attr_device_path,
  	&nvmet_ns_attr_device_nguid,
@@ -722,6 +748,7 @@ static struct configfs_attribute *nvmet_ns_attrs[] = {
  	&nvmet_ns_attr_enable,
  	&nvmet_ns_attr_buffered_io,
  	&nvmet_ns_attr_revalidate_size,
+	&nvmet_ns_attr_resv_enable,
  #ifdef CONFIG_PCI_P2PDMA
  	&nvmet_ns_attr_p2pmem,
  #endif
drivers/nvme/target/core.c +44 -5
index 3935165048e7..a5019881d60b 100644
@@ -591,6 +591,8 @@ int nvmet_ns_enable(struct nvmet_ns *ns)
  	if (ns->nsid > subsys->max_nsid)
  		subsys->max_nsid = ns->nsid;
 
+	nvmet_pr_init_ns(ns);
+
  	ret = xa_insert(&subsys->namespaces, ns->nsid, ns, GFP_KERNEL);
  	if (ret)
  		goto out_restore_subsys_maxnsid;
@@ -651,6 +653,7 @@ void nvmet_ns_disable(struct nvmet_ns *ns)
 
  	subsys->nr_namespaces--;
  	nvmet_ns_changed(subsys, ns->nsid);
+	nvmet_pr_exit_ns(ns);
  	nvmet_ns_dev_disable(ns);
  out_unlock:
  	mutex_unlock(&subsys->lock);
@@ -904,18 +907,34 @@ static u16 nvmet_parse_io_cmd(struct nvmet_req *req)
  		return ret;
  	}
 
+	if (req->ns->pr.enable) {
+		ret = nvmet_parse_pr_cmd(req);
+		if (!ret)
+			return ret;
+	}
+
  	switch (req->ns->csi) {
  	case NVME_CSI_NVM:
  		if (req->ns->file)
-			return nvmet_file_parse_io_cmd(req);
-		return nvmet_bdev_parse_io_cmd(req);
+			ret = nvmet_file_parse_io_cmd(req);
+		else
+			ret = nvmet_bdev_parse_io_cmd(req);
+		break;
  	case NVME_CSI_ZNS:
  		if (IS_ENABLED(CONFIG_BLK_DEV_ZONED))
-			return nvmet_bdev_zns_parse_io_cmd(req);
-		return NVME_SC_INVALID_IO_CMD_SET;
+			ret = nvmet_bdev_zns_parse_io_cmd(req);
+		else
+			ret = NVME_SC_INVALID_IO_CMD_SET;
+		break;
  	default:
-		return NVME_SC_INVALID_IO_CMD_SET;
+		ret = NVME_SC_INVALID_IO_CMD_SET;
  	}
+	if (ret)
+		return ret;
+
+	if (req->ns->pr.enable)
+		ret = nvmet_pr_check_cmd_access(req);
+	return ret;
  }
 
  bool nvmet_req_init(struct nvmet_req *req, struct nvmet_cq *cq,
@@ -1231,6 +1250,21 @@ static void nvmet_init_cap(struct nvmet_ctrl *ctrl)
  		nvmet_passthrough_override_cap(ctrl);
  }
 
+bool nvmet_is_host_still_connected(uuid_t *hostid, struct nvmet_subsys *subsys)
+{
+	struct nvmet_ctrl *ctrl;
+
+	mutex_lock(&subsys->lock);
+	list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+		if (uuid_equal(hostid, &ctrl->hostid)) {
+			mutex_unlock(&subsys->lock);
+			return true;
+		}
+	}
+	mutex_unlock(&subsys->lock);
+	return false;
+}
+
  struct nvmet_ctrl *nvmet_ctrl_find_get(const char *subsysnqn,
  				       const char *hostnqn, u16 cntlid,
  				       struct nvmet_req *req)
@@ -1450,6 +1484,10 @@ u16 nvmet_alloc_ctrl(const char *subsysnqn, const char *hostnqn,
  	ctrl->err_counter = 0;
  	spin_lock_init(&ctrl->error_lock);
 
+	ctrl->resv_log_counter = 0;
+	mutex_init(&ctrl->resv_log_lock);
+	INIT_LIST_HEAD(&ctrl->resv_log_list);
+
  	nvmet_start_keep_alive_timer(ctrl);
 
  	mutex_lock(&subsys->lock);
@@ -1488,6 +1526,7 @@ static void nvmet_ctrl_free(struct kref *ref)
  	cancel_work_sync(&ctrl->fatal_err_work);
 
  	nvmet_destroy_auth(ctrl);
+	nvmet_ctrl_destroy_pr(ctrl);
 
  	ida_free(&cntlid_ida, ctrl->cntlid);
 
drivers/nvme/target/nvmet.h +33 -0
index 6c8acebe1a1a..4ba4958768ac 100644
@@ -56,6 +56,22 @@
  #define IPO_IATTR_CONNECT_SQE(x)	\
  	(cpu_to_le32(offsetof(struct nvmf_connect_command, x)))
 
+struct nvmet_pr_registrant {
+	bool			is_holder;
+	u64			rkey;
+	uuid_t			hostid;
+	struct list_head	entry;
+};
+
+struct nvmet_pr {
+	bool			enable;
+	enum nvme_pr_type	rtype;
+	u32			generation;
+	struct nvmet_pr_registrant *holder;
+	rwlock_t		pr_lock;
+	struct list_head	registrant_list;
+};
+
  struct nvmet_ns {
  	struct percpu_ref	ref;
  	struct bdev_handle	*bdev_handle;
@@ -85,6 +101,7 @@ struct nvmet_ns {
  	int			pi_type;
  	int			metadata_size;
  	u8			csi;
+	struct nvmet_pr		pr;
  };
 
  static inline struct nvmet_ns *to_nvmet_ns(struct config_item *item)
@@ -190,6 +207,11 @@ static inline bool nvmet_port_secure_channel_required(struct nvmet_port *port)
      return nvmet_port_disc_addr_treq_secure_channel(port) == NVMF_TREQ_REQUIRED;
  }
 
+struct nvmet_pr_log_entry {
+	struct nvme_pr_log log;
+	struct list_head entry;
+};
+
  struct nvmet_ctrl {
  	struct nvmet_subsys	*subsys;
  	struct nvmet_sq		**sqs;
@@ -243,6 +265,9 @@ struct nvmet_ctrl {
  	u8			*dh_key;
  	size_t			dh_keysize;
  #endif
+	struct mutex		resv_log_lock;
+	u64			resv_log_counter;
+	struct list_head	resv_log_list;
  };
 
  struct nvmet_subsys {
@@ -750,4 +775,12 @@ static inline bool nvmet_has_auth(struct nvmet_ctrl *ctrl)
  static inline const char *nvmet_dhchap_dhgroup_name(u8 dhgid) { return NULL; }
  #endif
 
+void nvmet_pr_init_ns(struct nvmet_ns *ns);
+u16 nvmet_parse_pr_cmd(struct nvmet_req *req);
+u16 nvmet_pr_check_cmd_access(struct nvmet_req *req);
+void nvmet_ctrl_destroy_pr(struct nvmet_ctrl *ctrl);
+void nvmet_pr_exit_ns(struct nvmet_ns *ns);
+bool nvmet_is_host_still_connected(uuid_t *hostid, struct nvmet_subsys *subsys);
+void nvmet_execute_get_log_page_resv(struct nvmet_req *req);
+
  #endif /* _NVMET_H */
drivers/nvme/target/pr.c new file +50 -0
new file mode 100644
index 000000000000..900a3f7a0808
@@ -0,0 +1,887 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * NVMe over Fabrics Persist Reservation.
+ * Copyright (c) 2024 Guixin Liu, Alibaba Group.
+ * All rights reserved.
+ */
+#include "nvmet.h"
+#include <linux/slab.h>
+#include <asm/unaligned.h>
+
+struct nvmet_pr_register_data {
+	__le64	crkey;
+	__le64	nrkey;
+};
+
+struct nvmet_pr_acquire_data {
+	__le64	crkey;
+	__le64	prkey;
+};
+
+struct nvmet_pr_release_data {
+	__le64	crkey;
+};
+
+static inline struct nvmet_ns *nvmet_pr_to_ns(struct nvmet_pr *pr)
+{
+	return container_of(pr, struct nvmet_ns, pr);
+}
+
+static inline void nvmet_pr_clean_holder(struct nvmet_pr *pr)
+{
+	pr->holder = NULL;
+	pr->rtype = 0;
+}
+
+static u16 nvmet_pr_validate_and_set_rtype(struct nvmet_pr *pr, u8 rtype)
+{
+	if (rtype < NVME_PR_WRITE_EXCLUSIVE ||
+	    rtype > NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS)
+		return NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+
+	pr->rtype = rtype;
+	return NVME_SC_SUCCESS;
+}
+
+static u16 nvmet_pr_set_rtype_and_holder(struct nvmet_pr *pr, u8 rtype,
+					 struct nvmet_pr_registrant *reg)
+{
+	u16 status;
+

drivers/nvme/target/pr.c line 60

Quoted 10 lines
drivers/nvme/target/pr.c new file +10 -0
+	status = nvmet_pr_validate_and_set_rtype(pr, rtype);
+	if (!status)
+		pr->holder = reg;
+	return status;
+}
+
+static inline void nvmet_pr_inc_generation(struct nvmet_pr *pr)
+{
+	pr->generation++;
+}

Useless wrapper. Shouldn't this be atomic_inc btw?

Quoted 22 lines
drivers/nvme/target/pr.c new file +22 -0
+
+static struct nvmet_pr_registrant *nvmet_pr_find_registrant_by_hostid(
+						struct nvmet_pr *pr,
+						uuid_t *hostid)
+{
+	struct nvmet_pr_registrant *reg;
+
+	list_for_each_entry(reg, &pr->registrant_list, entry) {
+		if (uuid_equal(&reg->hostid, hostid))
+			return reg;
+	}
+	return NULL;
+}
+
+static u16 nvmet_pr_register(struct nvmet_req *req,
+			     struct nvmet_pr_register_data *d)
+{
+	u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	struct nvmet_ctrl *ctrl = req->sq->ctrl;
+	struct nvmet_pr *pr = &req->ns->pr;
+	struct nvmet_pr_registrant *reg;
+

drivers/nvme/target/pr.c line 92

Quoted 10 lines
drivers/nvme/target/pr.c new file +10 -0
+	read_lock(&pr->pr_lock);
+	list_for_each_entry(reg, &pr->registrant_list, entry) {
+		if (uuid_equal(&reg->hostid, &ctrl->hostid)) {
+			if (reg->rkey == le64_to_cpu(d->nrkey))
+				status = NVME_SC_SUCCESS;
+			read_unlock(&pr->pr_lock);
+			goto out;
+		}
+	}
+	read_unlock(&pr->pr_lock);

Move to a wrapper?

Quoted 27 lines
drivers/nvme/target/pr.c new file +27 -0
+
+	reg = kmalloc(sizeof(*reg), GFP_KERNEL);
+	if (!reg) {
+		status = NVME_SC_INTERNAL;
+		goto out;
+	}
+
+	memset(reg, 0, sizeof(*reg));
+	INIT_LIST_HEAD(&reg->entry);
+	reg->rkey = le64_to_cpu(d->nrkey);
+	uuid_copy(&reg->hostid, &ctrl->hostid);
+	reg->is_holder = false;
+
+	write_lock(&pr->pr_lock);
+	list_add_tail(&reg->entry, &pr->registrant_list);
+	write_unlock(&pr->pr_lock);
+	status = NVME_SC_SUCCESS;
+out:
+	return status;
+}
+
+void nvmet_execute_get_log_page_resv(struct nvmet_req *req)
+{
+	struct nvmet_ctrl *ctrl = req->sq->ctrl;
+	struct nvmet_pr_log_entry *log_entry;
+	u16 status = NVME_SC_SUCCESS;
+	struct nvme_pr_log *log;

drivers/nvme/target/pr.c line 129

Quoted 10 lines
drivers/nvme/target/pr.c new file +10 -0
+
+	mutex_lock(&ctrl->resv_log_lock);
+	log_entry = list_first_entry_or_null(&ctrl->resv_log_list,
+				     struct nvmet_pr_log_entry, entry);
+	if (!log_entry)
+		goto out;
+
+	list_del(&log_entry->entry);
+	log = &log_entry->log;
+	log->nr_avl_pages = min(list_count_nodes(&ctrl->resv_log_list), 255);

nr_pages

Quoted 24 lines
drivers/nvme/target/pr.c new file +24 -0
+	status = nvmet_copy_to_sgl(req, 0, log, sizeof(*log));
+	kfree(log_entry);
+out:
+	mutex_unlock(&ctrl->resv_log_lock);
+	nvmet_req_complete(req, status);
+}
+
+static void nvmet_pr_add_resv_log(struct nvmet_ctrl *ctrl, u8 log_type, u32 nsid)
+{
+	struct nvmet_pr_log_entry *log_entry;
+	struct nvme_pr_log *log;
+
+	mutex_lock(&ctrl->resv_log_lock);
+	ctrl->resv_log_counter++;
+	if (ctrl->resv_log_counter == U64_MAX)
+		ctrl->resv_log_counter = 1;
+	log_entry = kmalloc(sizeof(*log_entry), GFP_KERNEL);
+	if (!log_entry) {
+		pr_warn("a reservation log lost, cntlid:%d, log_type:%d, nsid:%d\n",
+			ctrl->cntlid, log_type, nsid);
+		log_entry = list_last_entry(&ctrl->resv_log_list,
+					struct nvmet_pr_log_entry, entry);
+		if (log_entry)
+			log_entry->log.count =

drivers/nvme/target/pr.c line 163

Quoted 10 lines
drivers/nvme/target/pr.c new file +10 -0
+			cpu_to_le64(le64_to_cpu(log_entry->log.count) + 1);
+		goto unlock;
+	}
+
+	log = &log_entry->log;
+	log->count = cpu_to_le64(ctrl->resv_log_counter);
+	log->type = log_type;
+	log->nsid = cpu_to_le32(nsid);
+
+	list_add_tail(&log_entry->entry, &ctrl->resv_log_list);

What prevents this list from exploding?
I think you should mimic the ctrl error log slots.

Quoted 177 lines
drivers/nvme/target/pr.c new file +177 -0
+unlock:
+	mutex_unlock(&ctrl->resv_log_lock);
+}
+
+static void nvmet_pr_send_resv_released(struct nvmet_pr *pr, uuid_t *hostid)
+{
+	struct nvmet_ns *ns = nvmet_pr_to_ns(pr);
+	struct nvmet_subsys *subsys = ns->subsys;
+	struct nvmet_ctrl *ctrl;
+
+	mutex_lock(&subsys->lock);
+	list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+		if (!uuid_equal(&ctrl->hostid, hostid) &&
+		    nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid)) {
+			nvmet_pr_add_resv_log(ctrl,
+					      NVME_PR_LOG_RESERVATION_RELEASED,
+					      ns->nsid);
+			nvmet_add_async_event(ctrl, NVME_AER_CSS,
+					      NVME_AEN_RESV_LOG_PAGE_AVALIABLE,
+					      NVME_LOG_RESERVATION);
+		}
+	}
+	mutex_unlock(&subsys->lock);
+}
+
+static void nvmet_pr_send_event_by_hostid(struct nvmet_pr *pr, uuid_t *hostid,
+					  u8 log_type)
+{
+	struct nvmet_ns *ns = nvmet_pr_to_ns(pr);
+	struct nvmet_subsys *subsys = ns->subsys;
+	struct nvmet_ctrl *ctrl;
+
+	mutex_lock(&subsys->lock);
+	list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+		if (uuid_equal(hostid, &ctrl->hostid)) {
+			nvmet_pr_add_resv_log(ctrl, log_type, ns->nsid);
+			nvmet_add_async_event(ctrl, NVME_AER_CSS,
+					      NVME_AEN_RESV_LOG_PAGE_AVALIABLE,
+					      NVME_LOG_RESERVATION);
+		}
+	}
+	mutex_unlock(&subsys->lock);
+}
+
+static void nvmet_pr_send_resv_preempted(struct nvmet_pr *pr, uuid_t *hostid)
+{
+	nvmet_pr_send_event_by_hostid(pr, hostid,
+				      NVME_PR_LOG_RESERVATOPM_PREEMPTED);
+}
+
+static void nvmet_pr_send_registration_preempted(struct nvmet_pr *pr,
+						 uuid_t *hostid)
+{
+	nvmet_pr_send_event_by_hostid(pr, hostid,
+				      NVME_PR_LOG_REGISTRATION_PREEMPTED);
+}
+
+static void __nvmet_pr_unregister_one(struct nvmet_pr *pr,
+				      struct nvmet_pr_registrant *reg)
+{
+	u8 original_rtype = pr->rtype;
+
+	list_del(&reg->entry);
+
+	if (pr->holder != reg)
+		goto free_reg;
+
+	if (original_rtype == NVME_PR_WRITE_EXCLUSIVE_ALL_REGS ||
+	    original_rtype == NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS) {
+		pr->holder = list_first_entry_or_null(&pr->registrant_list,
+					struct nvmet_pr_registrant, entry);
+		if (!pr->holder)
+			pr->rtype = 0;
+		goto free_reg;
+	}
+
+	nvmet_pr_clean_holder(pr);
+
+	if (original_rtype == NVME_PR_WRITE_EXCLUSIVE_REG_ONLY ||
+	    original_rtype == NVME_PR_WRITE_EXCLUSIVE_REG_ONLY)
+		nvmet_pr_send_resv_released(pr, &reg->hostid);
+
+free_reg:
+	kfree(reg);
+}
+
+static u16 nvmet_pr_unregister(struct nvmet_req *req,
+			       struct nvmet_pr_register_data *d,
+			       bool ignore_key)
+{
+	u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	struct nvmet_ctrl *ctrl = req->sq->ctrl;
+	struct nvmet_pr *pr = &req->ns->pr;
+	struct nvmet_pr_registrant *reg;
+	struct nvmet_pr_registrant *tmp;
+
+	write_lock(&pr->pr_lock);
+	list_for_each_entry_safe(reg, tmp, &pr->registrant_list, entry) {
+		if (uuid_equal(&reg->hostid, &ctrl->hostid)) {
+			if (ignore_key || reg->rkey == le64_to_cpu(d->crkey)) {
+				status = NVME_SC_SUCCESS;
+				__nvmet_pr_unregister_one(pr, reg);
+			}
+			break;
+		}
+	}
+	write_unlock(&pr->pr_lock);
+
+	return status;
+}
+
+static u16 nvmet_pr_replace(struct nvmet_req *req,
+			    struct nvmet_pr_register_data *d,
+			    bool ignore_key)
+{
+	u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	struct nvmet_ctrl *ctrl = req->sq->ctrl;
+	struct nvmet_pr *pr = &req->ns->pr;
+	struct nvmet_pr_registrant *reg;
+
+	write_lock(&pr->pr_lock);
+	list_for_each_entry(reg, &pr->registrant_list, entry) {
+		if (uuid_equal(&reg->hostid, &ctrl->hostid)) {
+			if (ignore_key || reg->rkey == le64_to_cpu(d->crkey)) {
+				reg->rkey = le64_to_cpu(d->nrkey);
+				status = NVME_SC_SUCCESS;
+			}
+			break;
+		}
+	}
+	write_unlock(&pr->pr_lock);
+	return status;
+}
+
+static void nvmet_execute_pr_register(struct nvmet_req *req)
+{
+	u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
+	bool ignore_key = (bool)((cdw10 >> 3) & 1); /* Ignore existing key, bit 03 */
+	struct nvmet_pr_register_data *d;
+	u8 reg_act = cdw10 & 0x07; /* Reservation Register Action, bit 02:00 */
+	u16 status;
+
+	d = kmalloc(sizeof(*d), GFP_KERNEL);
+	if (!d) {
+		status = NVME_SC_INTERNAL;
+		goto out;
+	}
+
+	status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d));
+	if (status)
+		goto free_data;
+
+	switch (reg_act) {
+	case NVME_PR_REGISTER_ACT_REG:
+		status = nvmet_pr_register(req, d);
+		break;
+	case NVME_PR_REGISTER_ACT_UNREG:
+		status = nvmet_pr_unregister(req, d, ignore_key);
+		break;
+	case NVME_PR_REGISTER_ACT_REPLACE:
+		status = nvmet_pr_replace(req, d, ignore_key);
+		break;
+	default:
+		req->error_loc = offsetof(struct nvme_common_command,
+						cdw10);
+		status = NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
+		break;
+	}
+free_data:
+	kfree(d);
+out:
+	if (!status)
+		nvmet_pr_inc_generation(&req->ns->pr);
+	nvmet_req_complete(req, status);
+}
+
+static u16 nvmet_pr_acquire(struct nvmet_req *req,

drivers/nvme/target/pr.c line 350

Quoted 10 lines
drivers/nvme/target/pr.c new file +10 -0
+			    struct nvmet_pr_registrant *reg,
+			    u8 rtype)
+{
+	struct nvmet_pr *pr = &req->ns->pr;
+
+	if (pr->holder && reg != pr->holder)
+		return  NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	if (pr->holder && reg == pr->holder) {
+		if (pr->rtype == rtype)
+			return 0;

NVME_SC_SUCCESS

Quoted 462 lines
drivers/nvme/target/pr.c new file +462 -0
+		return NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	}
+
+	return nvmet_pr_set_rtype_and_holder(pr, rtype, reg);
+}
+
+static u16 nvmet_pr_unreg_by_prkey(struct nvmet_pr *pr, u64 prkey,
+				   uuid_t *send_hostid)
+{
+	u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	struct nvmet_pr_registrant *reg;
+	struct nvmet_pr_registrant *tmp;
+
+	list_for_each_entry_safe(reg, tmp,
+				 &pr->registrant_list, entry) {
+		if (reg->rkey == prkey) {
+			status = NVME_SC_SUCCESS;
+			if (!uuid_equal(&reg->hostid, send_hostid))
+				nvmet_pr_send_registration_preempted(pr,
+								&reg->hostid);
+			__nvmet_pr_unregister_one(pr, reg);
+		}
+	}
+	return status;
+}
+
+static u16 nvmet_pr_unreg_by_prkey_except_hostid(struct nvmet_pr *pr, u64 prkey,
+						 uuid_t *send_hostid)
+{
+	u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	struct nvmet_pr_registrant *reg;
+	struct nvmet_pr_registrant *tmp;
+
+	list_for_each_entry_safe(reg, tmp,
+				 &pr->registrant_list, entry) {
+		if (reg->rkey == prkey &&
+		    !uuid_equal(&reg->hostid, send_hostid)) {
+			status = NVME_SC_SUCCESS;
+			nvmet_pr_send_registration_preempted(pr, &reg->hostid);
+			__nvmet_pr_unregister_one(pr, reg);
+		}
+	}
+	return status;
+}
+
+static void nvmet_pr_unreg_except_hostid(struct nvmet_pr *pr,
+					 uuid_t *send_hostid)
+{
+	struct nvmet_pr_registrant *reg;
+	struct nvmet_pr_registrant *tmp;
+
+	list_for_each_entry_safe(reg, tmp,
+				 &pr->registrant_list, entry) {
+		if (!uuid_equal(&reg->hostid, send_hostid)) {
+			nvmet_pr_send_registration_preempted(pr, &reg->hostid);
+			__nvmet_pr_unregister_one(pr, reg);
+		}
+	}
+}
+
+static u16 nvmet_pr_create_new_resv(struct nvmet_pr *pr, u8 rtype,
+				    struct nvmet_pr_registrant *reg)
+{
+	u16 status;
+
+	status = nvmet_pr_set_rtype_and_holder(pr, rtype, reg);
+	if (!status)
+		nvmet_pr_send_resv_released(pr, &reg->hostid);
+	return status;
+}
+
+static u16 nvmet_pr_preempt(struct nvmet_req *req,
+			    struct nvmet_pr_registrant *reg,
+			    u8 rtype,
+			    struct nvmet_pr_acquire_data *d)
+{
+	struct nvmet_ctrl *ctrl = req->sq->ctrl;
+	struct nvmet_pr *pr = &req->ns->pr;
+	u16 status;
+
+	if (!pr->holder)
+		return nvmet_pr_unreg_by_prkey(pr, le64_to_cpu(d->prkey),
+					       &ctrl->hostid);
+
+	if (pr->rtype == NVME_PR_WRITE_EXCLUSIVE_ALL_REGS ||
+	    pr->rtype == NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS) {
+		if (!le64_to_cpu(d->prkey)) {
+			nvmet_pr_unreg_except_hostid(pr, &ctrl->hostid);
+			return nvmet_pr_create_new_resv(pr, rtype, reg);
+		}
+		return nvmet_pr_unreg_by_prkey(pr, le64_to_cpu(d->prkey),
+					       &ctrl->hostid);
+	}
+
+	if (pr->holder == reg)
+		return nvmet_pr_validate_and_set_rtype(pr, rtype);
+
+	if (le64_to_cpu(d->prkey) == pr->holder->rkey) {
+		status = nvmet_pr_unreg_by_prkey_except_hostid(pr,
+							le64_to_cpu(d->prkey),
+							&ctrl->hostid);
+		if (status)
+			return status;
+		return nvmet_pr_create_new_resv(pr, rtype, reg);
+	}
+
+	if (le64_to_cpu(d->prkey))
+		return nvmet_pr_unreg_by_prkey(pr, le64_to_cpu(d->prkey),
+					       &ctrl->hostid);
+	return NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+}
+
+static u16 __nvmet_execute_pr_acquire(struct nvmet_req *req,
+				      struct nvmet_pr_registrant *reg,
+				      u8 acquire_act,
+				      u8 rtype,
+				      struct nvmet_pr_acquire_data *d)
+{
+	u16 status;
+
+	switch (acquire_act) {
+	case NVME_PR_ACQUIRE_ACT_ACQUIRE:
+		status = nvmet_pr_acquire(req, reg, rtype);
+		goto out;
+	case NVME_PR_ACQUIRE_ACT_PREEMPT:
+		status = nvmet_pr_preempt(req, reg, rtype, d);
+		goto inc_gen;
+	case NVME_PR_ACQUIRE_ACT_PREEMPT_AND_ABORT:
+		status = nvmet_pr_preempt(req, reg, rtype, d);
+		goto inc_gen;
+	default:
+		req->error_loc = offsetof(struct nvme_common_command,
+						cdw10);
+		status = NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
+		goto out;
+	}
+inc_gen:
+	if (!status)
+		nvmet_pr_inc_generation(&req->ns->pr);
+out:
+	return status;
+}
+
+static void nvmet_execute_pr_acquire(struct nvmet_req *req)
+{
+	u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
+	bool ignore_key = (bool)((cdw10 >> 3) & 1); /* Ignore existing key, bit 03 */
+	u8 rtype = (u8)((cdw10 >> 8) & 0xff); /* Reservation type, bit 15:08 */
+	u8 acquire_act = cdw10 & 0x07; /* Reservation acquire action, bit 02:00 */
+	struct nvmet_ctrl *ctrl = req->sq->ctrl;
+	struct nvmet_pr_acquire_data *d = NULL;
+	struct nvmet_pr *pr = &req->ns->pr;
+	struct nvmet_pr_registrant *reg;
+	u16 status = NVME_SC_SUCCESS;
+
+	if (ignore_key) {
+		status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+		goto out;
+	}
+
+	d = kmalloc(sizeof(*d), GFP_KERNEL);
+	if (!d) {
+		status = NVME_SC_INTERNAL;
+		goto out;
+	}
+
+	status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d));
+	if (status)
+		goto free_data;
+
+	status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	write_lock(&pr->pr_lock);
+	list_for_each_entry(reg, &pr->registrant_list, entry) {
+		if (uuid_equal(&reg->hostid, &ctrl->hostid) &&
+		    reg->rkey == le64_to_cpu(d->crkey)) {
+			status = __nvmet_execute_pr_acquire(req, reg,
+							    acquire_act,
+							    rtype, d);
+			break;
+		}
+	}
+	write_unlock(&pr->pr_lock);
+
+free_data:
+	kfree(d);
+out:
+	nvmet_req_complete(req, status);
+}
+
+static u16 nvmet_pr_release(struct nvmet_req *req,
+			    struct nvmet_pr_registrant *reg,
+			    u8 rtype)
+{
+	struct nvmet_pr *pr = &req->ns->pr;
+	u8 original_rtype = pr->rtype;
+
+	if (reg != pr->holder || !pr->holder)
+		return 0;
+	if (pr->rtype != rtype)
+		return NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+
+	nvmet_pr_clean_holder(pr);
+
+	if (original_rtype != NVME_PR_WRITE_EXCLUSIVE &&
+	    original_rtype != NVME_PR_EXCLUSIVE_ACCESS)
+		nvmet_pr_send_resv_released(pr, &reg->hostid);
+
+	return 0;
+}
+
+static void nvmet_pr_clear(struct nvmet_req *req)
+{
+	struct nvmet_pr *pr = &req->ns->pr;
+	struct nvmet_pr_registrant *reg;
+	struct nvmet_pr_registrant *tmp;
+
+	list_for_each_entry_safe(reg, tmp, &pr->registrant_list, entry) {
+		list_del(&reg->entry);
+		if (!uuid_equal(&req->sq->ctrl->hostid, &reg->hostid))
+			nvmet_pr_send_resv_preempted(pr, &reg->hostid);
+		kfree(reg);
+	}
+	nvmet_pr_clean_holder(pr);
+
+	nvmet_pr_inc_generation(&req->ns->pr);
+}
+
+static u16 __nvmet_execute_pr_release(struct nvmet_req *req,
+				      struct nvmet_pr_registrant *reg,
+				      u8 release_act, u8 rtype)
+{
+	switch (release_act) {
+	case NVME_PR_RELEASE_ACT_RELEASE:
+		return nvmet_pr_release(req, reg, rtype);
+	case NVME_PR_RELEASE_ACT_CLEAR:
+		nvmet_pr_clear(req);
+		return 0;
+	default:
+		req->error_loc = offsetof(struct nvme_common_command,
+					  cdw10);
+		return NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
+	}
+}
+
+static void nvmet_execute_pr_release(struct nvmet_req *req)
+{
+	u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
+	bool ignore_key = (bool)((cdw10 >> 3) & 1); /* Ignore existing key, bit 03 */
+	u8 rtype = (u8)((cdw10 >> 8) & 0xff); /* Reservation type, bit 15:08 */
+	u8 release_act = cdw10 & 0x07; /* Reservation release action, bit 02:00 */
+	struct nvmet_ctrl *ctrl = req->sq->ctrl;
+	struct nvmet_pr *pr = &req->ns->pr;
+	struct nvmet_pr_release_data *d;
+	struct nvmet_pr_registrant *reg;
+	struct nvmet_pr_registrant *tmp;
+	u16 status;
+
+	if (ignore_key) {
+		status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+		goto out;
+	}
+
+	d = kmalloc(sizeof(*d), GFP_KERNEL);
+	if (!d) {
+		status = NVME_SC_INTERNAL;
+		goto out;
+	}
+
+	status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d));
+	if (status)
+		goto free_data;
+
+	status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+	write_lock(&pr->pr_lock);
+	list_for_each_entry_safe(reg, tmp,
+				 &pr->registrant_list, entry) {
+		if (uuid_equal(&reg->hostid, &ctrl->hostid) &&
+		    reg->rkey == le64_to_cpu(d->crkey)) {
+			status = __nvmet_execute_pr_release(req, reg,
+							    release_act, rtype);
+			break;
+		}
+	}
+	write_unlock(&pr->pr_lock);
+free_data:
+	kfree(d);
+out:
+	nvmet_req_complete(req, status);
+}
+
+static void nvmet_execute_pr_report(struct nvmet_req *req)
+{
+	u32 cdw11 = le32_to_cpu(req->cmd->common.cdw11);
+	u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
+	u32 num_bytes = 4 * (cdw10 + 1); /* cdw10 is number of dwords */
+	u8 eds = cdw11 & 1; /* Extended data structure, bit 00 */
+	struct nvmet_subsys *subsys = req->sq->ctrl->subsys;
+	struct nvme_registered_ctrl_ext *ctrl_data;
+	struct nvme_reservation_status_ext *data;
+	struct nvmet_pr *pr = &req->ns->pr;
+	struct nvmet_pr_registrant *reg;
+	struct nvmet_ctrl *ctrl;
+	u16 num_ctrls = 0;
+	u16 status;
+
+	/* nvmet hostid(uuid_t) is 128 bit. */
+	if (!eds) {
+		req->error_loc = offsetof(struct nvme_common_command,
+					  cdw11);
+		status = NVME_SC_HOST_ID_INCONSIST | NVME_SC_DNR;
+		goto out;
+	}
+
+	if (num_bytes < sizeof(struct nvme_reservation_status_ext)) {
+		req->error_loc = offsetof(struct nvme_common_command,
+					  cdw10);
+		status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+		goto out;
+	}
+
+	mutex_lock(&subsys->lock);
+	read_lock(&pr->pr_lock);
+	list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+		if (nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid))
+			num_ctrls++;
+	}
+
+	num_bytes = min(num_bytes,
+			sizeof(struct nvme_reservation_status_ext) +
+			sizeof(struct nvme_registered_ctrl_ext) * num_ctrls);
+
+	data = kmalloc(num_bytes, GFP_KERNEL);
+	if (!data) {
+		status = NVME_SC_INTERNAL;
+		goto out_unlock;
+	}
+	memset(data, 0, num_bytes);
+	data->gen = cpu_to_le32(pr->generation);
+	data->rtype = pr->rtype;
+	put_unaligned_le16(num_ctrls, data->regctl);
+	data->ptpls = 0;
+	ctrl_data = data->regctl_eds;
+
+	list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+		if ((void *)ctrl_data >= (void *)(data + num_bytes))
+			break;
+		reg = nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid);
+		if (!reg)
+			continue;
+		ctrl_data->cntlid = cpu_to_le16(ctrl->cntlid);
+		if (pr->rtype == NVME_PR_WRITE_EXCLUSIVE_ALL_REGS ||
+		    pr->rtype == NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS)
+			ctrl_data->rcsts = 1;
+		if (pr->holder &&
+		    uuid_equal(&ctrl->hostid, &pr->holder->hostid))
+			ctrl_data->rcsts = 1;
+		uuid_copy((uuid_t *)&ctrl_data->hostid, &ctrl->hostid);
+		ctrl_data->rkey = cpu_to_le64(reg->rkey);
+		ctrl_data++;
+	}
+	status = nvmet_copy_to_sgl(req, 0, data, num_bytes);
+out_unlock:
+	read_unlock(&pr->pr_lock);
+	mutex_unlock(&subsys->lock);
+out:
+	nvmet_req_complete(req, status);
+}
+
+u16 nvmet_parse_pr_cmd(struct nvmet_req *req)
+{
+	struct nvme_command *cmd = req->cmd;
+
+	switch (cmd->common.opcode) {
+	case nvme_cmd_resv_register:
+		req->execute = nvmet_execute_pr_register;
+		break;
+	case nvme_cmd_resv_acquire:
+		req->execute = nvmet_execute_pr_acquire;
+		break;
+	case nvme_cmd_resv_release:
+		req->execute = nvmet_execute_pr_release;
+		break;
+	case nvme_cmd_resv_report:
+		req->execute = nvmet_execute_pr_report;
+		break;
+	default:
+		return 1;
+	}
+	return 0;
+}
+
+static bool nvmet_is_req_write_cmd_group(struct nvmet_req *req)
+{
+	u8 opcode = req->cmd->common.opcode;
+
+	if (req->sq->qid) {
+		switch (opcode) {
+		case nvme_cmd_flush:
+		case nvme_cmd_write:
+		case nvme_cmd_write_zeroes:
+		case nvme_cmd_dsm:
+		case nvme_cmd_zone_append:
+		case nvme_cmd_zone_mgmt_send:
+			return true;
+		default:
+			return false;
+		}
+	}
+	return false;
+}
+
+static bool nvmet_is_req_read_cmd_group(struct nvmet_req *req)
+{
+	u8 opcode = req->cmd->common.opcode;
+
+	if (req->sq->qid) {
+		switch (opcode) {
+		case nvme_cmd_read:
+		case nvme_cmd_zone_mgmt_recv:
+			return true;
+		default:
+			return false;
+		}
+	}
+	return false;
+}
+
+u16 nvmet_pr_check_cmd_access(struct nvmet_req *req)
+{
+	struct nvmet_ctrl *ctrl = req->sq->ctrl;
+	struct nvmet_ns *ns = req->ns;
+	struct nvmet_pr *pr = &ns->pr;
+	u16 status = NVME_SC_SUCCESS;
+
+	read_lock(&pr->pr_lock);
+	if (!pr->holder)
+		goto unlock;
+	if (uuid_equal(&ctrl->hostid, &pr->holder->hostid))
+		goto unlock;
+
+	/*
+	 * The Reservation command group is checked in executing,
+	 * allow it here.
+	 */
+	switch ((u8)pr->rtype) {
+	case NVME_PR_WRITE_EXCLUSIVE:
+		if (nvmet_is_req_write_cmd_group(req))
+			status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+		break;
+	case NVME_PR_EXCLUSIVE_ACCESS:
+		if (nvmet_is_req_read_cmd_group(req) ||
+		    nvmet_is_req_write_cmd_group(req))
+			status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+		break;
+	case NVME_PR_WRITE_EXCLUSIVE_REG_ONLY:
+	case NVME_PR_WRITE_EXCLUSIVE_ALL_REGS:
+		if ((nvmet_is_req_write_cmd_group(req)) &&
+		    !nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid))
+			status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+		break;
+	case NVME_PR_EXCLUSIVE_ACCESS_REG_ONLY:
+	case NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS:

drivers/nvme/target/pr.c line 822

Quoted 10 lines
drivers/nvme/target/pr.c new file +10 -0
+		if ((nvmet_is_req_read_cmd_group(req) ||
+		    nvmet_is_req_write_cmd_group(req)) &&
+		    !nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid))
+			status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+		break;
+	default:
+		pr_warn("the reservation type is set wrong, type:%d\n",
+			pr->rtype);
+		break;
+	}

What about impacted admin commands? I'm assuming none of them is supported by nvmet?

What about the passthru ctrl? Chaitanya, how does this play with the passthru controller?

Quoted 138 lines
drivers/nvme/target/pr.c new file +65 -0
+
+unlock:
+	read_unlock(&pr->pr_lock);
+	if (status)
+		req->error_loc = offsetof(struct nvme_common_command, opcode);
+	return status;
+}
+
+void nvmet_ctrl_destroy_pr(struct nvmet_ctrl *ctrl)
+{
+	struct nvmet_pr_log_entry *tmp_log_entry;
+	struct nvmet_pr_log_entry *log_entry;
+	struct nvmet_pr_registrant *reg;
+	struct nvmet_pr_registrant *tmp;
+	struct nvmet_ns *ns;
+	unsigned long idx;
+
+	mutex_lock(&ctrl->resv_log_lock);
+	list_for_each_entry_safe(log_entry, tmp_log_entry,
+				 &ctrl->resv_log_list, entry) {
+		list_del(&log_entry->entry);
+		kfree(log_entry);
+	}
+	mutex_unlock(&ctrl->resv_log_lock);
+
+	mutex_destroy(&ctrl->resv_log_lock);
+
+	if (nvmet_is_host_still_connected(&ctrl->hostid, ctrl->subsys))
+		return;
+
+	xa_for_each(&ctrl->subsys->namespaces, idx, ns) {
+		write_lock(&ns->pr.pr_lock);
+		list_for_each_entry_safe(reg, tmp,
+					 &ns->pr.registrant_list, entry) {
+			if (uuid_equal(&reg->hostid, &ctrl->hostid)) {
+				__nvmet_pr_unregister_one(&ns->pr, reg);
+				break;
+			}
+		}
+		write_unlock(&ns->pr.pr_lock);
+	}
+}
+
+void nvmet_pr_exit_ns(struct nvmet_ns *ns)
+{
+	struct nvmet_pr_registrant *tmp_reg;
+	struct nvmet_pr_registrant *tmp;
+	struct nvmet_pr *pr = &ns->pr;
+
+	write_lock(&pr->pr_lock);
+	list_for_each_entry_safe(tmp_reg, tmp, &pr->registrant_list, entry) {
+		list_del(&tmp_reg->entry);
+		kfree(tmp_reg);
+	}
+	write_unlock(&pr->pr_lock);
+}
+
+void nvmet_pr_init_ns(struct nvmet_ns *ns)
+{
+	ns->pr.holder = NULL;
+	ns->pr.generation = 0;
+	ns->pr.rtype = 0;
+	rwlock_init(&ns->pr.pr_lock);
+	INIT_LIST_HEAD(&ns->pr.registrant_list);
+}
include/linux/nvme.h +48 -0
index 44325c068b6a..bb5f56ebae50 100644
@@ -746,6 +746,26 @@ enum {
  	NVME_AEN_CFG_DISC_CHANGE	= 1 << NVME_AEN_BIT_DISC_CHANGE,
  };
 
+enum {
+	NVME_AEN_RESV_LOG_PAGE_AVALIABLE	= 0x00,
+};
+
+enum {
+	NVME_PR_LOG_EMPTY_LOG_PAGE			= 0x00,
+	NVME_PR_LOG_REGISTRATION_PREEMPTED		= 0x01,
+	NVME_PR_LOG_RESERVATION_RELEASED		= 0x02,
+	NVME_PR_LOG_RESERVATOPM_PREEMPTED		= 0x03,
+};
+
+struct nvme_pr_log {
+	__le64			count;
+	__u8			type;
+	__u8			nr_avl_pages;
+	__u8			rsvd1[2];
+	__le32			nsid;
+	__u8			rsvd2[48];
+};
+
  struct nvme_lba_range_type {
  	__u8			type;
  	__u8			attributes;
@@ -766,6 +786,17 @@ enum {
  	NVME_LBART_ATTRIB_HIDE	= 1 << 1,
  };
 
+enum nvme_pr_capabilities {
+	NVME_PR_SUPPORT_PTPL				= 1,
+	NVME_PR_SUPPORT_WRITE_EXCLUSIVE			= 1 << 1,
+	NVME_PR_SUPPORT_EXCLUSIVE_ACCESS		= 1 << 2,
+	NVME_PR_SUPPORT_WRITE_EXCLUSIVE_REG_ONLY	= 1 << 3,
+	NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_REG_ONLY	= 1 << 4,
+	NVME_PR_SUPPORT_WRITE_EXCLUSIVE_ALL_REGS	= 1 << 5,
+	NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_ALL_REGS	= 1 << 6,
+	NVME_PR_SUPPORT_IEKEY_VER_1_3_DEF		= 1 << 7,
+};
+
  enum nvme_pr_type {
  	NVME_PR_WRITE_EXCLUSIVE			= 1,
  	NVME_PR_EXCLUSIVE_ACCESS		= 2,
@@ -775,6 +806,23 @@ enum nvme_pr_type {
  	NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS	= 6,
  };
 
+enum nvme_pr_register_action {
+	NVME_PR_REGISTER_ACT_REG		= 0,
+	NVME_PR_REGISTER_ACT_UNREG		= 1,
+	NVME_PR_REGISTER_ACT_REPLACE		= 1 << 1,
+};
+
+enum nvme_pr_acquire_action {
+	NVME_PR_ACQUIRE_ACT_ACQUIRE		= 0,
+	NVME_PR_ACQUIRE_ACT_PREEMPT		= 1,
+	NVME_PR_ACQUIRE_ACT_PREEMPT_AND_ABORT	= 1 << 1,
+};
+
+enum nvme_pr_release_action {
+	NVME_PR_RELEASE_ACT_RELEASE		= 0,
+	NVME_PR_RELEASE_ACT_CLEAR		= 1,
+};
+
  enum nvme_eds {
  	NVME_EXTENDED_DATA_STRUCT	= 0x1,
  };
author
#3 lore raw

Re: [PATCH V2 1/3] nvmet: support reservation feature

Quoted 346 lines · Sagi Grimberg
Quoted 343 lines · Guixin Liu

This patch implements the reservation feature, includes:
1. reservation register(register, unregister and replace).
2. reservation acquire(acquire, preempt, preempt and abort).
3. reservation release(release and clear).
4. reservation report.

And also make reservation configurable, one can set ns to support reservation before enable ns. The default of resv_enable is false.

---
  drivers/nvme/target/Makefile    |   2 +- drivers/nvme/target/admin-cmd.c |  14 +- drivers/nvme/target/configfs.c  |  27 + drivers/nvme/target/core.c      |  49 +- drivers/nvme/target/nvmet.h     |  33 ++ drivers/nvme/target/pr.c        | 887 ++++++++++++++++++++++++++++++++ include/linux/nvme.h            |  48 ++

  7 files changed, 1053 insertions(+), 7 deletions(-)

  create mode 100644 drivers/nvme/target/pr.c

drivers/nvme/target/Makefile +0 -0
index c66820102493..f9bfc904a5b3 100644
@@ -10,7 +10,7 @@ obj-$(CONFIG_NVME_TARGET_FCLOOP)    += nvme-fcloop.o

  obj-$(CONFIG_NVME_TARGET_TCP)        += nvmet-tcp.o nvmet-y        += core.o configfs.o admin-cmd.o fabrics-cmd.o \
-            discovery.o io-cmd-file.o io-cmd-bdev.o
+            discovery.o io-cmd-file.o io-cmd-bdev.o pr.o nvmet-$(CONFIG_NVME_TARGET_PASSTHRU)    += passthru.o nvmet-$(CONFIG_BLK_DEV_ZONED)        += zns.o nvmet-$(CONFIG_NVME_TARGET_AUTH)    += fabrics-cmd-auth.o auth.o

drivers/nvme/target/admin-cmd.c +0 -0
index 39cb570f833d..791bc7e740c0 100644
@@ -176,6 +176,10 @@ static void nvmet_get_cmd_effects_nvm(struct 
 nvme_effects_log *log)

      log->iocs[nvme_cmd_read] =
      log->iocs[nvme_cmd_flush] =
      log->iocs[nvme_cmd_dsm]    =
+    log->iocs[nvme_cmd_resv_acquire] =
+    log->iocs[nvme_cmd_resv_register] =
+    log->iocs[nvme_cmd_resv_release] =
+    log->iocs[nvme_cmd_resv_report] =
          cpu_to_le32(NVME_CMD_EFFECTS_CSUPP);
      log->iocs[nvme_cmd_write] =
      log->iocs[nvme_cmd_write_zeroes] =

drivers/nvme/target/admin-cmd.c +0 -0
@@ -340,6 +344,8 @@ static void nvmet_execute_get_log_page(struct 
 nvmet_req *req)
           return nvmet_execute_get_log_cmd_effects_ns(req);

      case NVME_LOG_ANA:
          return nvmet_execute_get_log_page_ana(req); +    case NVME_LOG_RESERVATION:
+        return nvmet_execute_get_log_page_resv(req); }
      pr_debug("unhandled lid %d on qid %d\n", req->cmd->get_log_page.lid, req->sq->qid);

drivers/nvme/target/admin-cmd.c +7 -1
@@ -550,7 +556,13 @@ static void nvmet_execute_identify_ns(struct 
 nvmet_req *req)
        */
       id->nmic = NVME_NS_NMIC_SHARED;
       id->anagrpid = cpu_to_le32(req->ns->anagrpid);
-
+    id->rescap = NVME_PR_SUPPORT_WRITE_EXCLUSIVE |
+             NVME_PR_SUPPORT_EXCLUSIVE_ACCESS |
+             NVME_PR_SUPPORT_WRITE_EXCLUSIVE_REG_ONLY |
+             NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_REG_ONLY |
+             NVME_PR_SUPPORT_WRITE_EXCLUSIVE_ALL_REGS |
+             NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_ALL_REGS |
+             NVME_PR_SUPPORT_IEKEY_VER_1_3_DEF;
       memcpy(&id->nguid, &req->ns->nguid, sizeof(id->nguid));
         id->lbaf[0].ds = req->ns->blksize_shift;
drivers/nvme/target/configfs.c +26 -0
index d937fe05129e..1ac4802ec818 100644
@@ -714,6 +714,32 @@ static ssize_t 
 nvmet_ns_revalidate_size_store(struct config_item *item,
     CONFIGFS_ATTR_WO(nvmet_ns_, revalidate_size);
   +static ssize_t nvmet_ns_resv_enable_show(struct config_item *item, char *page)
+{
+    return sprintf(page, "%d\n", to_nvmet_ns(item)->pr.enable);
+}
+
+static ssize_t nvmet_ns_resv_enable_store(struct config_item *item,
+                    const char *page, size_t count)
+{
+    struct nvmet_ns *ns = to_nvmet_ns(item);
+    bool val;
+
+    if (kstrtobool(page, &val))
+        return -EINVAL;
+
+    mutex_lock(&ns->subsys->lock);
+    if (ns->enabled) {
+        pr_err("the ns:%d is already enabled.\n", ns->nsid);
+        mutex_unlock(&ns->subsys->lock);
+        return -EINVAL;
+    }
+    ns->pr.enable = val;
+    mutex_unlock(&ns->subsys->lock);
+    return count;
+}
+CONFIGFS_ATTR(nvmet_ns_, resv_enable);
+
   static struct configfs_attribute *nvmet_ns_attrs[] = {
       &nvmet_ns_attr_device_path,
       &nvmet_ns_attr_device_nguid,
@@ -722,6 +748,7 @@ static struct configfs_attribute 
 *nvmet_ns_attrs[] = {
       &nvmet_ns_attr_enable,
       &nvmet_ns_attr_buffered_io,
       &nvmet_ns_attr_revalidate_size,
+    &nvmet_ns_attr_resv_enable,
   #ifdef CONFIG_PCI_P2PDMA
       &nvmet_ns_attr_p2pmem,

  #endif

drivers/nvme/target/core.c +2 -0
index 3935165048e7..a5019881d60b 100644
@@ -591,6 +591,8 @@ int nvmet_ns_enable(struct nvmet_ns *ns)
       if (ns->nsid > subsys->max_nsid)
           subsys->max_nsid = ns->nsid;
   +    nvmet_pr_init_ns(ns);
+
       ret = xa_insert(&subsys->namespaces, ns->nsid, ns, GFP_KERNEL);
       if (ret)
           goto out_restore_subsys_maxnsid;
@@ -651,6 +653,7 @@ void nvmet_ns_disable(struct nvmet_ns *ns)
         subsys->nr_namespaces--;
       nvmet_ns_changed(subsys, ns->nsid);
+    nvmet_pr_exit_ns(ns);
       nvmet_ns_dev_disable(ns);

  out_unlock:
      mutex_unlock(&subsys->lock);

drivers/nvme/target/core.c +5 -0
@@ -904,18 +907,34 @@ static u16 nvmet_parse_io_cmd(struct nvmet_req 
 *req)
           return ret;
       }
   +    if (req->ns->pr.enable) {
+        ret = nvmet_parse_pr_cmd(req);
+        if (!ret)
+            return ret;
+    }
+
       switch (req->ns->csi) {

      case NVME_CSI_NVM:
          if (req->ns->file)
-            return nvmet_file_parse_io_cmd(req);
-        return nvmet_bdev_parse_io_cmd(req);
+            ret = nvmet_file_parse_io_cmd(req);
+        else
+            ret = nvmet_bdev_parse_io_cmd(req);
+        break;
      case NVME_CSI_ZNS:
          if (IS_ENABLED(CONFIG_BLK_DEV_ZONED))
-            return nvmet_bdev_zns_parse_io_cmd(req);
-        return NVME_SC_INVALID_IO_CMD_SET;
+            ret = nvmet_bdev_zns_parse_io_cmd(req);
+        else
+            ret = NVME_SC_INVALID_IO_CMD_SET;
+        break;
      default:
-        return NVME_SC_INVALID_IO_CMD_SET;
+        ret = NVME_SC_INVALID_IO_CMD_SET;
      }
+    if (ret)
+        return ret;
+
+    if (req->ns->pr.enable)
+        ret = nvmet_pr_check_cmd_access(req);
+    return ret;
  }
    bool nvmet_req_init(struct nvmet_req *req, struct nvmet_cq *cq,

drivers/nvme/target/core.c +14 -0
@@ -1231,6 +1250,21 @@ static void nvmet_init_cap(struct nvmet_ctrl 
 *ctrl)
           nvmet_passthrough_override_cap(ctrl);
   }
   +bool nvmet_is_host_still_connected(uuid_t *hostid, struct nvmet_subsys *subsys)
+{
+    struct nvmet_ctrl *ctrl;
+
+    mutex_lock(&subsys->lock);
+    list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+        if (uuid_equal(hostid, &ctrl->hostid)) {
+            mutex_unlock(&subsys->lock);
+            return true;
+        }
+    }
+    mutex_unlock(&subsys->lock);
+    return false;
+}
+
   struct nvmet_ctrl *nvmet_ctrl_find_get(const char *subsysnqn,
                          const char *hostnqn, u16 cntlid,

                         struct nvmet_req *req)

drivers/nvme/target/core.c +4 -0
@@ -1450,6 +1484,10 @@ u16 nvmet_alloc_ctrl(const char *subsysnqn, 
 const char *hostnqn,
       ctrl->err_counter = 0;
       spin_lock_init(&ctrl->error_lock);
   +    ctrl->resv_log_counter = 0;
+    mutex_init(&ctrl->resv_log_lock);
+    INIT_LIST_HEAD(&ctrl->resv_log_list);
+
       nvmet_start_keep_alive_timer(ctrl);
         mutex_lock(&subsys->lock);
@@ -1488,6 +1526,7 @@ static void nvmet_ctrl_free(struct kref *ref)
       cancel_work_sync(&ctrl->fatal_err_work);
         nvmet_destroy_auth(ctrl);
+    nvmet_ctrl_destroy_pr(ctrl);
         ida_free(&cntlid_ida, ctrl->cntlid);

  diff --git a/drivers/nvme/target/nvmet.h b/drivers/nvme/target/nvmet.h index 6c8acebe1a1a..4ba4958768ac 100644

drivers/nvme/target/nvmet.h +20 -0
@@ -56,6 +56,22 @@
   #define IPO_IATTR_CONNECT_SQE(x)    \
       (cpu_to_le32(offsetof(struct nvmf_connect_command, x)))
   +struct nvmet_pr_registrant {
+    bool            is_holder;
+    u64            rkey;
+    uuid_t            hostid;
+    struct list_head    entry;
+};
+
+struct nvmet_pr {
+    bool            enable;
+    enum nvme_pr_type    rtype;
+    u32            generation;
+    struct nvmet_pr_registrant *holder;
+    rwlock_t        pr_lock;
+    struct list_head    registrant_list;
+};
+
   struct nvmet_ns {
       struct percpu_ref    ref;
       struct bdev_handle    *bdev_handle;
@@ -85,6 +101,7 @@ struct nvmet_ns {
       int            pi_type;
       int            metadata_size;
       u8            csi;
+    struct nvmet_pr        pr;
   };
     static inline struct nvmet_ns *to_nvmet_ns(struct config_item *item)
@@ -190,6 +207,11 @@ static inline bool 
 nvmet_port_secure_channel_required(struct nvmet_port *port)
       return nvmet_port_disc_addr_treq_secure_channel(port) == NVMF_TREQ_REQUIRED;
   }
   +struct nvmet_pr_log_entry {
+    struct nvme_pr_log log;
+    struct list_head entry;
+};
+
   struct nvmet_ctrl {
       struct nvmet_subsys    *subsys;

      struct nvmet_sq        **sqs;

drivers/nvme/target/nvmet.h +8 -0
@@ -243,6 +265,9 @@ struct nvmet_ctrl {
       u8            *dh_key;
       size_t            dh_keysize;
   #endif
+    struct mutex        resv_log_lock;
+    u64            resv_log_counter;
+    struct list_head    resv_log_list;
   };
     struct nvmet_subsys {
@@ -750,4 +775,12 @@ static inline bool nvmet_has_auth(struct 
 nvmet_ctrl *ctrl)
   static inline const char *nvmet_dhchap_dhgroup_name(u8 dhgid) { return NULL; }
   #endif
   +void nvmet_pr_init_ns(struct nvmet_ns *ns);
+u16 nvmet_parse_pr_cmd(struct nvmet_req *req);
+u16 nvmet_pr_check_cmd_access(struct nvmet_req *req);
+void nvmet_ctrl_destroy_pr(struct nvmet_ctrl *ctrl);
+void nvmet_pr_exit_ns(struct nvmet_ns *ns);
+bool nvmet_is_host_still_connected(uuid_t *hostid, struct 

nvmet_subsys *subsys);

drivers/nvme/target/nvmet.h +2 -0
+void nvmet_execute_get_log_page_resv(struct nvmet_req *req);
+

  #endif /* _NVMET_H */

drivers/nvme/target/pr.c new file +36 -0
new file mode 100644
index 000000000000..900a3f7a0808
@@ -0,0 +1,887 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * NVMe over Fabrics Persist Reservation.
+ * Copyright (c) 2024 Guixin Liu, Alibaba Group.
+ * All rights reserved.
+ */
+#include "nvmet.h"
+#include <linux/slab.h>
+#include <asm/unaligned.h>
+
+struct nvmet_pr_register_data {
+    __le64    crkey;
+    __le64    nrkey;
+};
+
+struct nvmet_pr_acquire_data {
+    __le64    crkey;
+    __le64    prkey;
+};
+
+struct nvmet_pr_release_data {
+    __le64    crkey;
+};
+
+static inline struct nvmet_ns *nvmet_pr_to_ns(struct nvmet_pr *pr)
+{
+    return container_of(pr, struct nvmet_ns, pr);
+}
+
+static inline void nvmet_pr_clean_holder(struct nvmet_pr *pr)
+{
+    pr->holder = NULL;
+    pr->rtype = 0;
+}
+
+static u16 nvmet_pr_validate_and_set_rtype(struct nvmet_pr *pr, u8 

rtype)

drivers/nvme/target/pr.c new file +18 -0
+{
+    if (rtype < NVME_PR_WRITE_EXCLUSIVE ||
+        rtype > NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS)
+        return NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+
+    pr->rtype = rtype;
+    return NVME_SC_SUCCESS;
+}
+
+static u16 nvmet_pr_set_rtype_and_holder(struct nvmet_pr *pr, u8 rtype,
+                     struct nvmet_pr_registrant *reg)
+{
+    u16 status;
+
+    status = nvmet_pr_validate_and_set_rtype(pr, rtype);
+    if (!status)
+        pr->holder = reg;
+    return status;
Quoted 8 lines

drivers/nvme/target/pr.c line 60

Quoted 6 lines
drivers/nvme/target/pr.c new file +6 -0
+}
+
+static inline void nvmet_pr_inc_generation(struct nvmet_pr *pr)
+{
+    pr->generation++;
+}

Useless wrapper. Shouldn't this be atomic_inc btw?

Sorry, I miss that generation is not protected when execut register command.

I will delete the wrapper, and put it in to pr_lock protection.

Quoted 27 lines
Quoted 27 lines
drivers/nvme/target/pr.c new file +26 -0
+
+static struct nvmet_pr_registrant *nvmet_pr_find_registrant_by_hostid(
+                        struct nvmet_pr *pr,
+                        uuid_t *hostid)
+{
+    struct nvmet_pr_registrant *reg;
+
+    list_for_each_entry(reg, &pr->registrant_list, entry) {
+        if (uuid_equal(&reg->hostid, hostid))
+            return reg;
+    }
+    return NULL;
+}
+
+static u16 nvmet_pr_register(struct nvmet_req *req,
+                 struct nvmet_pr_register_data *d)
+{
+    u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+    struct nvmet_ctrl *ctrl = req->sq->ctrl;
+    struct nvmet_pr *pr = &req->ns->pr;
+    struct nvmet_pr_registrant *reg;
+
+    read_lock(&pr->pr_lock);
+    list_for_each_entry(reg, &pr->registrant_list, entry) {
+        if (uuid_equal(&reg->hostid, &ctrl->hostid)) {
+            if (reg->rkey == le64_to_cpu(d->nrkey))
Quoted 8 lines
Quoted 6 lines

+                status = NVME_SC_SUCCESS;
+            read_unlock(&pr->pr_lock);
+            goto out;
+        }
+    }
+    read_unlock(&pr->pr_lock);

Move to a wrapper?

OK.

Quoted 33 lines
Quoted 33 lines
drivers/nvme/target/pr.c new file +32 -0
+
+    reg = kmalloc(sizeof(*reg), GFP_KERNEL);
+    if (!reg) {
+        status = NVME_SC_INTERNAL;
+        goto out;
+    }
+
+    memset(reg, 0, sizeof(*reg));
+    INIT_LIST_HEAD(&reg->entry);
+    reg->rkey = le64_to_cpu(d->nrkey);
+    uuid_copy(&reg->hostid, &ctrl->hostid);
+    reg->is_holder = false;
+
+    write_lock(&pr->pr_lock);
+    list_add_tail(&reg->entry, &pr->registrant_list);
+    write_unlock(&pr->pr_lock);
+    status = NVME_SC_SUCCESS;
+out:
+    return status;
+}
+
+void nvmet_execute_get_log_page_resv(struct nvmet_req *req)
+{
+    struct nvmet_ctrl *ctrl = req->sq->ctrl;
+    struct nvmet_pr_log_entry *log_entry;
+    u16 status = NVME_SC_SUCCESS;
+    struct nvme_pr_log *log;
+
+    mutex_lock(&ctrl->resv_log_lock);
+    log_entry = list_first_entry_or_null(&ctrl->resv_log_list,
+                     struct nvmet_pr_log_entry, entry);
+    if (!log_entry)
Quoted 8 lines
Quoted 6 lines

+        goto out;
+
+    list_del(&log_entry->entry);
+    log = &log_entry->log;
+    log->nr_avl_pages = min(list_count_nodes(&ctrl->resv_log_list), 255);

nr_pages

OK.

Quoted 32 lines
Quoted 32 lines

+    status = nvmet_copy_to_sgl(req, 0, log, sizeof(*log)); +    kfree(log_entry);

drivers/nvme/target/pr.c new file +6 -0
+out:
+    mutex_unlock(&ctrl->resv_log_lock);
+    nvmet_req_complete(req, status);
+}
+
+static void nvmet_pr_add_resv_log(struct nvmet_ctrl *ctrl, u8 

log_type, u32 nsid)

drivers/nvme/target/pr.c new file +11 -0
+{
+    struct nvmet_pr_log_entry *log_entry;
+    struct nvme_pr_log *log;
+
+    mutex_lock(&ctrl->resv_log_lock);
+    ctrl->resv_log_counter++;
+    if (ctrl->resv_log_counter == U64_MAX)
+        ctrl->resv_log_counter = 1;
+    log_entry = kmalloc(sizeof(*log_entry), GFP_KERNEL);
+    if (!log_entry) {
+        pr_warn("a reservation log lost, cntlid:%d, log_type:%d, 

nsid:%d\n",
+            ctrl->cntlid, log_type, nsid);
+        log_entry = list_last_entry(&ctrl->resv_log_list, +                    struct nvmet_pr_log_entry, entry); +        if (log_entry)
+            log_entry->log.count =
+            cpu_to_le64(le64_to_cpu(log_entry->log.count) + 1); +        goto unlock;
+    }
+
+    log = &log_entry->log;

Quoted 8 lines
Quoted 5 lines

+    log->count = cpu_to_le64(ctrl->resv_log_counter); +    log->type = log_type;
+    log->nsid = cpu_to_le32(nsid);
+
+    list_add_tail(&log_entry->entry, &ctrl->resv_log_list);

What prevents this list from exploding?
I think you should mimic the ctrl error log slots.

Yeah, this is depends on the host pr_work which in another patch,

I will limit it in v3.

Quoted 187 lines
Quoted 187 lines
drivers/nvme/target/pr.c new file +5 -0
+unlock:
+    mutex_unlock(&ctrl->resv_log_lock);
+}
+
+static void nvmet_pr_send_resv_released(struct nvmet_pr *pr, uuid_t 

*hostid)

drivers/nvme/target/pr.c new file +21 -0
+{
+    struct nvmet_ns *ns = nvmet_pr_to_ns(pr);
+    struct nvmet_subsys *subsys = ns->subsys;
+    struct nvmet_ctrl *ctrl;
+
+    mutex_lock(&subsys->lock);
+    list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+        if (!uuid_equal(&ctrl->hostid, hostid) &&
+            nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid)) {
+            nvmet_pr_add_resv_log(ctrl,
+                          NVME_PR_LOG_RESERVATION_RELEASED,
+                          ns->nsid);
+            nvmet_add_async_event(ctrl, NVME_AER_CSS,
+                          NVME_AEN_RESV_LOG_PAGE_AVALIABLE,
+                          NVME_LOG_RESERVATION);
+        }
+    }
+    mutex_unlock(&subsys->lock);
+}
+
+static void nvmet_pr_send_event_by_hostid(struct nvmet_pr *pr, 

uuid_t *hostid,
+                      u8 log_type)

drivers/nvme/target/pr.c new file +18 -0
+{
+    struct nvmet_ns *ns = nvmet_pr_to_ns(pr);
+    struct nvmet_subsys *subsys = ns->subsys;
+    struct nvmet_ctrl *ctrl;
+
+    mutex_lock(&subsys->lock);
+    list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+        if (uuid_equal(hostid, &ctrl->hostid)) {
+            nvmet_pr_add_resv_log(ctrl, log_type, ns->nsid);
+            nvmet_add_async_event(ctrl, NVME_AER_CSS,
+                          NVME_AEN_RESV_LOG_PAGE_AVALIABLE,
+                          NVME_LOG_RESERVATION);
+        }
+    }
+    mutex_unlock(&subsys->lock);
+}
+
+static void nvmet_pr_send_resv_preempted(struct nvmet_pr *pr, uuid_t 

*hostid)

drivers/nvme/target/pr.c new file +93 -0
+{
+    nvmet_pr_send_event_by_hostid(pr, hostid,
+                      NVME_PR_LOG_RESERVATOPM_PREEMPTED);
+}
+
+static void nvmet_pr_send_registration_preempted(struct nvmet_pr *pr,
+                         uuid_t *hostid)
+{
+    nvmet_pr_send_event_by_hostid(pr, hostid,
+                      NVME_PR_LOG_REGISTRATION_PREEMPTED);
+}
+
+static void __nvmet_pr_unregister_one(struct nvmet_pr *pr,
+                      struct nvmet_pr_registrant *reg)
+{
+    u8 original_rtype = pr->rtype;
+
+    list_del(&reg->entry);
+
+    if (pr->holder != reg)
+        goto free_reg;
+
+    if (original_rtype == NVME_PR_WRITE_EXCLUSIVE_ALL_REGS ||
+        original_rtype == NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS) {
+        pr->holder = list_first_entry_or_null(&pr->registrant_list,
+                    struct nvmet_pr_registrant, entry);
+        if (!pr->holder)
+            pr->rtype = 0;
+        goto free_reg;
+    }
+
+    nvmet_pr_clean_holder(pr);
+
+    if (original_rtype == NVME_PR_WRITE_EXCLUSIVE_REG_ONLY ||
+        original_rtype == NVME_PR_WRITE_EXCLUSIVE_REG_ONLY)
+        nvmet_pr_send_resv_released(pr, &reg->hostid);
+
+free_reg:
+    kfree(reg);
+}
+
+static u16 nvmet_pr_unregister(struct nvmet_req *req,
+                   struct nvmet_pr_register_data *d,
+                   bool ignore_key)
+{
+    u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+    struct nvmet_ctrl *ctrl = req->sq->ctrl;
+    struct nvmet_pr *pr = &req->ns->pr;
+    struct nvmet_pr_registrant *reg;
+    struct nvmet_pr_registrant *tmp;
+
+    write_lock(&pr->pr_lock);
+    list_for_each_entry_safe(reg, tmp, &pr->registrant_list, entry) {
+        if (uuid_equal(&reg->hostid, &ctrl->hostid)) {
+            if (ignore_key || reg->rkey == le64_to_cpu(d->crkey)) {
+                status = NVME_SC_SUCCESS;
+                __nvmet_pr_unregister_one(pr, reg);
+            }
+            break;
+        }
+    }
+    write_unlock(&pr->pr_lock);
+
+    return status;
+}
+
+static u16 nvmet_pr_replace(struct nvmet_req *req,
+                struct nvmet_pr_register_data *d,
+                bool ignore_key)
+{
+    u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+    struct nvmet_ctrl *ctrl = req->sq->ctrl;
+    struct nvmet_pr *pr = &req->ns->pr;
+    struct nvmet_pr_registrant *reg;
+
+    write_lock(&pr->pr_lock);
+    list_for_each_entry(reg, &pr->registrant_list, entry) {
+        if (uuid_equal(&reg->hostid, &ctrl->hostid)) {
+            if (ignore_key || reg->rkey == le64_to_cpu(d->crkey)) {
+                reg->rkey = le64_to_cpu(d->nrkey);
+                status = NVME_SC_SUCCESS;
+            }
+            break;
+        }
+    }
+    write_unlock(&pr->pr_lock);
+    return status;
+}
+
+static void nvmet_execute_pr_register(struct nvmet_req *req)
+{
+    u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
+    bool ignore_key = (bool)((cdw10 >> 3) & 1); /* Ignore existing 

key, bit 03 */
+    struct nvmet_pr_register_data *d;
+    u8 reg_act = cdw10 & 0x07; /* Reservation Register Action, bit 02:00 */
+    u16 status;

drivers/nvme/target/pr.c new file +40 -0
+
+    d = kmalloc(sizeof(*d), GFP_KERNEL);
+    if (!d) {
+        status = NVME_SC_INTERNAL;
+        goto out;
+    }
+
+    status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d));
+    if (status)
+        goto free_data;
+
+    switch (reg_act) {
+    case NVME_PR_REGISTER_ACT_REG:
+        status = nvmet_pr_register(req, d);
+        break;
+    case NVME_PR_REGISTER_ACT_UNREG:
+        status = nvmet_pr_unregister(req, d, ignore_key);
+        break;
+    case NVME_PR_REGISTER_ACT_REPLACE:
+        status = nvmet_pr_replace(req, d, ignore_key);
+        break;
+    default:
+        req->error_loc = offsetof(struct nvme_common_command,
+                        cdw10);
+        status = NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
+        break;
+    }
+free_data:
+    kfree(d);
+out:
+    if (!status)
+        nvmet_pr_inc_generation(&req->ns->pr);
+    nvmet_req_complete(req, status);
+}
+
+static u16 nvmet_pr_acquire(struct nvmet_req *req,
+                struct nvmet_pr_registrant *reg,
+                u8 rtype)
+{
+    struct nvmet_pr *pr = &req->ns->pr;
Quoted 8 lines
Quoted 6 lines

+
+    if (pr->holder && reg != pr->holder)
+        return  NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR; +    if (pr->holder && reg == pr->holder) {
+        if (pr->rtype == rtype)
+            return 0;

NVME_SC_SUCCESS

Sorry I miss that, it will be changed in v3.

Quoted 475 lines
Quoted 475 lines

+        return NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR; +    }

drivers/nvme/target/pr.c new file +25 -0
+
+    return nvmet_pr_set_rtype_and_holder(pr, rtype, reg);
+}
+
+static u16 nvmet_pr_unreg_by_prkey(struct nvmet_pr *pr, u64 prkey,
+                   uuid_t *send_hostid)
+{
+    u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+    struct nvmet_pr_registrant *reg;
+    struct nvmet_pr_registrant *tmp;
+
+    list_for_each_entry_safe(reg, tmp,
+                 &pr->registrant_list, entry) {
+        if (reg->rkey == prkey) {
+            status = NVME_SC_SUCCESS;
+            if (!uuid_equal(&reg->hostid, send_hostid))
+                nvmet_pr_send_registration_preempted(pr,
+                                &reg->hostid);
+            __nvmet_pr_unregister_one(pr, reg);
+        }
+    }
+    return status;
+}
+
+static u16 nvmet_pr_unreg_by_prkey_except_hostid(struct nvmet_pr 

*pr, u64 prkey,
+                         uuid_t *send_hostid)

drivers/nvme/target/pr.c new file +119 -0
+{
+    u16 status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+    struct nvmet_pr_registrant *reg;
+    struct nvmet_pr_registrant *tmp;
+
+    list_for_each_entry_safe(reg, tmp,
+                 &pr->registrant_list, entry) {
+        if (reg->rkey == prkey &&
+            !uuid_equal(&reg->hostid, send_hostid)) {
+            status = NVME_SC_SUCCESS;
+            nvmet_pr_send_registration_preempted(pr, &reg->hostid);
+            __nvmet_pr_unregister_one(pr, reg);
+        }
+    }
+    return status;
+}
+
+static void nvmet_pr_unreg_except_hostid(struct nvmet_pr *pr,
+                     uuid_t *send_hostid)
+{
+    struct nvmet_pr_registrant *reg;
+    struct nvmet_pr_registrant *tmp;
+
+    list_for_each_entry_safe(reg, tmp,
+                 &pr->registrant_list, entry) {
+        if (!uuid_equal(&reg->hostid, send_hostid)) {
+            nvmet_pr_send_registration_preempted(pr, &reg->hostid);
+            __nvmet_pr_unregister_one(pr, reg);
+        }
+    }
+}
+
+static u16 nvmet_pr_create_new_resv(struct nvmet_pr *pr, u8 rtype,
+                    struct nvmet_pr_registrant *reg)
+{
+    u16 status;
+
+    status = nvmet_pr_set_rtype_and_holder(pr, rtype, reg);
+    if (!status)
+        nvmet_pr_send_resv_released(pr, &reg->hostid);
+    return status;
+}
+
+static u16 nvmet_pr_preempt(struct nvmet_req *req,
+                struct nvmet_pr_registrant *reg,
+                u8 rtype,
+                struct nvmet_pr_acquire_data *d)
+{
+    struct nvmet_ctrl *ctrl = req->sq->ctrl;
+    struct nvmet_pr *pr = &req->ns->pr;
+    u16 status;
+
+    if (!pr->holder)
+        return nvmet_pr_unreg_by_prkey(pr, le64_to_cpu(d->prkey),
+                           &ctrl->hostid);
+
+    if (pr->rtype == NVME_PR_WRITE_EXCLUSIVE_ALL_REGS ||
+        pr->rtype == NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS) {
+        if (!le64_to_cpu(d->prkey)) {
+            nvmet_pr_unreg_except_hostid(pr, &ctrl->hostid);
+            return nvmet_pr_create_new_resv(pr, rtype, reg);
+        }
+        return nvmet_pr_unreg_by_prkey(pr, le64_to_cpu(d->prkey),
+                           &ctrl->hostid);
+    }
+
+    if (pr->holder == reg)
+        return nvmet_pr_validate_and_set_rtype(pr, rtype);
+
+    if (le64_to_cpu(d->prkey) == pr->holder->rkey) {
+        status = nvmet_pr_unreg_by_prkey_except_hostid(pr,
+                            le64_to_cpu(d->prkey),
+                            &ctrl->hostid);
+        if (status)
+            return status;
+        return nvmet_pr_create_new_resv(pr, rtype, reg);
+    }
+
+    if (le64_to_cpu(d->prkey))
+        return nvmet_pr_unreg_by_prkey(pr, le64_to_cpu(d->prkey),
+                           &ctrl->hostid);
+    return NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+}
+
+static u16 __nvmet_execute_pr_acquire(struct nvmet_req *req,
+                      struct nvmet_pr_registrant *reg,
+                      u8 acquire_act,
+                      u8 rtype,
+                      struct nvmet_pr_acquire_data *d)
+{
+    u16 status;
+
+    switch (acquire_act) {
+    case NVME_PR_ACQUIRE_ACT_ACQUIRE:
+        status = nvmet_pr_acquire(req, reg, rtype);
+        goto out;
+    case NVME_PR_ACQUIRE_ACT_PREEMPT:
+        status = nvmet_pr_preempt(req, reg, rtype, d);
+        goto inc_gen;
+    case NVME_PR_ACQUIRE_ACT_PREEMPT_AND_ABORT:
+        status = nvmet_pr_preempt(req, reg, rtype, d);
+        goto inc_gen;
+    default:
+        req->error_loc = offsetof(struct nvme_common_command,
+                        cdw10);
+        status = NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
+        goto out;
+    }
+inc_gen:
+    if (!status)
+        nvmet_pr_inc_generation(&req->ns->pr);
+out:
+    return status;
+}
+
+static void nvmet_execute_pr_acquire(struct nvmet_req *req)
+{
+    u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
+    bool ignore_key = (bool)((cdw10 >> 3) & 1); /* Ignore existing 

key, bit 03 */
+    u8 rtype = (u8)((cdw10 >> 8) & 0xff); /* Reservation type, bit 15:08 */
+    u8 acquire_act = cdw10 & 0x07; /* Reservation acquire action, bit 02:00 */
+    struct nvmet_ctrl *ctrl = req->sq->ctrl;
+    struct nvmet_pr_acquire_data *d = NULL;
+    struct nvmet_pr *pr = &req->ns->pr;
+    struct nvmet_pr_registrant *reg;
+    u16 status = NVME_SC_SUCCESS;

drivers/nvme/target/pr.c new file +94 -0
+
+    if (ignore_key) {
+        status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+        goto out;
+    }
+
+    d = kmalloc(sizeof(*d), GFP_KERNEL);
+    if (!d) {
+        status = NVME_SC_INTERNAL;
+        goto out;
+    }
+
+    status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d));
+    if (status)
+        goto free_data;
+
+    status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+    write_lock(&pr->pr_lock);
+    list_for_each_entry(reg, &pr->registrant_list, entry) {
+        if (uuid_equal(&reg->hostid, &ctrl->hostid) &&
+            reg->rkey == le64_to_cpu(d->crkey)) {
+            status = __nvmet_execute_pr_acquire(req, reg,
+                                acquire_act,
+                                rtype, d);
+            break;
+        }
+    }
+    write_unlock(&pr->pr_lock);
+
+free_data:
+    kfree(d);
+out:
+    nvmet_req_complete(req, status);
+}
+
+static u16 nvmet_pr_release(struct nvmet_req *req,
+                struct nvmet_pr_registrant *reg,
+                u8 rtype)
+{
+    struct nvmet_pr *pr = &req->ns->pr;
+    u8 original_rtype = pr->rtype;
+
+    if (reg != pr->holder || !pr->holder)
+        return 0;
+    if (pr->rtype != rtype)
+        return NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+
+    nvmet_pr_clean_holder(pr);
+
+    if (original_rtype != NVME_PR_WRITE_EXCLUSIVE &&
+        original_rtype != NVME_PR_EXCLUSIVE_ACCESS)
+        nvmet_pr_send_resv_released(pr, &reg->hostid);
+
+    return 0;
+}
+
+static void nvmet_pr_clear(struct nvmet_req *req)
+{
+    struct nvmet_pr *pr = &req->ns->pr;
+    struct nvmet_pr_registrant *reg;
+    struct nvmet_pr_registrant *tmp;
+
+    list_for_each_entry_safe(reg, tmp, &pr->registrant_list, entry) {
+        list_del(&reg->entry);
+        if (!uuid_equal(&req->sq->ctrl->hostid, &reg->hostid))
+            nvmet_pr_send_resv_preempted(pr, &reg->hostid);
+        kfree(reg);
+    }
+    nvmet_pr_clean_holder(pr);
+
+    nvmet_pr_inc_generation(&req->ns->pr);
+}
+
+static u16 __nvmet_execute_pr_release(struct nvmet_req *req,
+                      struct nvmet_pr_registrant *reg,
+                      u8 release_act, u8 rtype)
+{
+    switch (release_act) {
+    case NVME_PR_RELEASE_ACT_RELEASE:
+        return nvmet_pr_release(req, reg, rtype);
+    case NVME_PR_RELEASE_ACT_CLEAR:
+        nvmet_pr_clear(req);
+        return 0;
+    default:
+        req->error_loc = offsetof(struct nvme_common_command,
+                      cdw10);
+        return NVME_SC_INVALID_OPCODE | NVME_SC_DNR;
+    }
+}
+
+static void nvmet_execute_pr_release(struct nvmet_req *req)
+{
+    u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
+    bool ignore_key = (bool)((cdw10 >> 3) & 1); /* Ignore existing 

key, bit 03 */
+    u8 rtype = (u8)((cdw10 >> 8) & 0xff); /* Reservation type, bit 15:08 */
+    u8 release_act = cdw10 & 0x07; /* Reservation release action, bit 02:00 */
+    struct nvmet_ctrl *ctrl = req->sq->ctrl;
+    struct nvmet_pr *pr = &req->ns->pr;
+    struct nvmet_pr_release_data *d;
+    struct nvmet_pr_registrant *reg;
+    struct nvmet_pr_registrant *tmp;
+    u16 status;

drivers/nvme/target/pr.c new file +211 -0
+
+    if (ignore_key) {
+        status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+        goto out;
+    }
+
+    d = kmalloc(sizeof(*d), GFP_KERNEL);
+    if (!d) {
+        status = NVME_SC_INTERNAL;
+        goto out;
+    }
+
+    status = nvmet_copy_from_sgl(req, 0, d, sizeof(*d));
+    if (status)
+        goto free_data;
+
+    status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+    write_lock(&pr->pr_lock);
+    list_for_each_entry_safe(reg, tmp,
+                 &pr->registrant_list, entry) {
+        if (uuid_equal(&reg->hostid, &ctrl->hostid) &&
+            reg->rkey == le64_to_cpu(d->crkey)) {
+            status = __nvmet_execute_pr_release(req, reg,
+                                release_act, rtype);
+            break;
+        }
+    }
+    write_unlock(&pr->pr_lock);
+free_data:
+    kfree(d);
+out:
+    nvmet_req_complete(req, status);
+}
+
+static void nvmet_execute_pr_report(struct nvmet_req *req)
+{
+    u32 cdw11 = le32_to_cpu(req->cmd->common.cdw11);
+    u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10);
+    u32 num_bytes = 4 * (cdw10 + 1); /* cdw10 is number of dwords */
+    u8 eds = cdw11 & 1; /* Extended data structure, bit 00 */
+    struct nvmet_subsys *subsys = req->sq->ctrl->subsys;
+    struct nvme_registered_ctrl_ext *ctrl_data;
+    struct nvme_reservation_status_ext *data;
+    struct nvmet_pr *pr = &req->ns->pr;
+    struct nvmet_pr_registrant *reg;
+    struct nvmet_ctrl *ctrl;
+    u16 num_ctrls = 0;
+    u16 status;
+
+    /* nvmet hostid(uuid_t) is 128 bit. */
+    if (!eds) {
+        req->error_loc = offsetof(struct nvme_common_command,
+                      cdw11);
+        status = NVME_SC_HOST_ID_INCONSIST | NVME_SC_DNR;
+        goto out;
+    }
+
+    if (num_bytes < sizeof(struct nvme_reservation_status_ext)) {
+        req->error_loc = offsetof(struct nvme_common_command,
+                      cdw10);
+        status = NVME_SC_INVALID_FIELD | NVME_SC_DNR;
+        goto out;
+    }
+
+    mutex_lock(&subsys->lock);
+    read_lock(&pr->pr_lock);
+    list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+        if (nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid))
+            num_ctrls++;
+    }
+
+    num_bytes = min(num_bytes,
+            sizeof(struct nvme_reservation_status_ext) +
+            sizeof(struct nvme_registered_ctrl_ext) * num_ctrls);
+
+    data = kmalloc(num_bytes, GFP_KERNEL);
+    if (!data) {
+        status = NVME_SC_INTERNAL;
+        goto out_unlock;
+    }
+    memset(data, 0, num_bytes);
+    data->gen = cpu_to_le32(pr->generation);
+    data->rtype = pr->rtype;
+    put_unaligned_le16(num_ctrls, data->regctl);
+    data->ptpls = 0;
+    ctrl_data = data->regctl_eds;
+
+    list_for_each_entry(ctrl, &subsys->ctrls, subsys_entry) {
+        if ((void *)ctrl_data >= (void *)(data + num_bytes))
+            break;
+        reg = nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid);
+        if (!reg)
+            continue;
+        ctrl_data->cntlid = cpu_to_le16(ctrl->cntlid);
+        if (pr->rtype == NVME_PR_WRITE_EXCLUSIVE_ALL_REGS ||
+            pr->rtype == NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS)
+            ctrl_data->rcsts = 1;
+        if (pr->holder &&
+            uuid_equal(&ctrl->hostid, &pr->holder->hostid))
+            ctrl_data->rcsts = 1;
+        uuid_copy((uuid_t *)&ctrl_data->hostid, &ctrl->hostid);
+        ctrl_data->rkey = cpu_to_le64(reg->rkey);
+        ctrl_data++;
+    }
+    status = nvmet_copy_to_sgl(req, 0, data, num_bytes);
+out_unlock:
+    read_unlock(&pr->pr_lock);
+    mutex_unlock(&subsys->lock);
+out:
+    nvmet_req_complete(req, status);
+}
+
+u16 nvmet_parse_pr_cmd(struct nvmet_req *req)
+{
+    struct nvme_command *cmd = req->cmd;
+
+    switch (cmd->common.opcode) {
+    case nvme_cmd_resv_register:
+        req->execute = nvmet_execute_pr_register;
+        break;
+    case nvme_cmd_resv_acquire:
+        req->execute = nvmet_execute_pr_acquire;
+        break;
+    case nvme_cmd_resv_release:
+        req->execute = nvmet_execute_pr_release;
+        break;
+    case nvme_cmd_resv_report:
+        req->execute = nvmet_execute_pr_report;
+        break;
+    default:
+        return 1;
+    }
+    return 0;
+}
+
+static bool nvmet_is_req_write_cmd_group(struct nvmet_req *req)
+{
+    u8 opcode = req->cmd->common.opcode;
+
+    if (req->sq->qid) {
+        switch (opcode) {
+        case nvme_cmd_flush:
+        case nvme_cmd_write:
+        case nvme_cmd_write_zeroes:
+        case nvme_cmd_dsm:
+        case nvme_cmd_zone_append:
+        case nvme_cmd_zone_mgmt_send:
+            return true;
+        default:
+            return false;
+        }
+    }
+    return false;
+}
+
+static bool nvmet_is_req_read_cmd_group(struct nvmet_req *req)
+{
+    u8 opcode = req->cmd->common.opcode;
+
+    if (req->sq->qid) {
+        switch (opcode) {
+        case nvme_cmd_read:
+        case nvme_cmd_zone_mgmt_recv:
+            return true;
+        default:
+            return false;
+        }
+    }
+    return false;
+}
+
+u16 nvmet_pr_check_cmd_access(struct nvmet_req *req)
+{
+    struct nvmet_ctrl *ctrl = req->sq->ctrl;
+    struct nvmet_ns *ns = req->ns;
+    struct nvmet_pr *pr = &ns->pr;
+    u16 status = NVME_SC_SUCCESS;
+
+    read_lock(&pr->pr_lock);
+    if (!pr->holder)
+        goto unlock;
+    if (uuid_equal(&ctrl->hostid, &pr->holder->hostid))
+        goto unlock;
+
+    /*
+     * The Reservation command group is checked in executing,
+     * allow it here.
+     */
+    switch ((u8)pr->rtype) {
+    case NVME_PR_WRITE_EXCLUSIVE:
+        if (nvmet_is_req_write_cmd_group(req))
+            status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+        break;
+    case NVME_PR_EXCLUSIVE_ACCESS:
+        if (nvmet_is_req_read_cmd_group(req) ||
+            nvmet_is_req_write_cmd_group(req))
+            status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+        break;
+    case NVME_PR_WRITE_EXCLUSIVE_REG_ONLY:
+    case NVME_PR_WRITE_EXCLUSIVE_ALL_REGS:
+        if ((nvmet_is_req_write_cmd_group(req)) &&
+            !nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid))
+            status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+        break;
+    case NVME_PR_EXCLUSIVE_ACCESS_REG_ONLY:
+    case NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS:
+        if ((nvmet_is_req_read_cmd_group(req) ||
+            nvmet_is_req_write_cmd_group(req)) &&
+            !nvmet_pr_find_registrant_by_hostid(pr, &ctrl->hostid))
+            status = NVME_SC_RESERVATION_CONFLICT | NVME_SC_DNR;
+        break;
Quoted 8 lines
Quoted 5 lines

+    default:
+        pr_warn("the reservation type is set wrong, type:%d\n", +            pr->rtype);
+        break;
+    }

What about impacted admin commands? I'm assuming none of them is supported by nvmet?

Currently there is no admin command which nvmet implemented should

 check reservation.

Quoted 3 lines

What about the passthru ctrl? Chaitanya, how does this play with the passthru controller?

I will take a look at passthry ctrl.

Quoted 137 lines
Quoted 137 lines
drivers/nvme/target/pr.c new file +51 -0
+
+unlock:
+    read_unlock(&pr->pr_lock);
+    if (status)
+        req->error_loc = offsetof(struct nvme_common_command, opcode);
+    return status;
+}
+
+void nvmet_ctrl_destroy_pr(struct nvmet_ctrl *ctrl)
+{
+    struct nvmet_pr_log_entry *tmp_log_entry;
+    struct nvmet_pr_log_entry *log_entry;
+    struct nvmet_pr_registrant *reg;
+    struct nvmet_pr_registrant *tmp;
+    struct nvmet_ns *ns;
+    unsigned long idx;
+
+    mutex_lock(&ctrl->resv_log_lock);
+    list_for_each_entry_safe(log_entry, tmp_log_entry,
+                 &ctrl->resv_log_list, entry) {
+        list_del(&log_entry->entry);
+        kfree(log_entry);
+    }
+    mutex_unlock(&ctrl->resv_log_lock);
+
+    mutex_destroy(&ctrl->resv_log_lock);
+
+    if (nvmet_is_host_still_connected(&ctrl->hostid, ctrl->subsys))
+        return;
+
+    xa_for_each(&ctrl->subsys->namespaces, idx, ns) {
+        write_lock(&ns->pr.pr_lock);
+        list_for_each_entry_safe(reg, tmp,
+                     &ns->pr.registrant_list, entry) {
+            if (uuid_equal(&reg->hostid, &ctrl->hostid)) {
+                __nvmet_pr_unregister_one(&ns->pr, reg);
+                break;
+            }
+        }
+        write_unlock(&ns->pr.pr_lock);
+    }
+}
+
+void nvmet_pr_exit_ns(struct nvmet_ns *ns)
+{
+    struct nvmet_pr_registrant *tmp_reg;
+    struct nvmet_pr_registrant *tmp;
+    struct nvmet_pr *pr = &ns->pr;
+
+    write_lock(&pr->pr_lock);
+    list_for_each_entry_safe(tmp_reg, tmp, &pr->registrant_list, 

entry) {
+        list_del(&tmp_reg->entry);
+        kfree(tmp_reg);
+    }
+    write_unlock(&pr->pr_lock);

drivers/nvme/target/pr.c new file +10 -0
+}
+
+void nvmet_pr_init_ns(struct nvmet_ns *ns)
+{
+    ns->pr.holder = NULL;
+    ns->pr.generation = 0;
+    ns->pr.rtype = 0;
+    rwlock_init(&ns->pr.pr_lock);
+    INIT_LIST_HEAD(&ns->pr.registrant_list);
+}
include/linux/nvme.h +45 -0
index 44325c068b6a..bb5f56ebae50 100644
@@ -746,6 +746,26 @@ enum {
       NVME_AEN_CFG_DISC_CHANGE    = 1 << NVME_AEN_BIT_DISC_CHANGE,
   };
   +enum {
+    NVME_AEN_RESV_LOG_PAGE_AVALIABLE    = 0x00,
+};
+
+enum {
+    NVME_PR_LOG_EMPTY_LOG_PAGE            = 0x00,
+    NVME_PR_LOG_REGISTRATION_PREEMPTED        = 0x01,
+    NVME_PR_LOG_RESERVATION_RELEASED        = 0x02,
+    NVME_PR_LOG_RESERVATOPM_PREEMPTED        = 0x03,
+};
+
+struct nvme_pr_log {
+    __le64            count;
+    __u8            type;
+    __u8            nr_avl_pages;
+    __u8            rsvd1[2];
+    __le32            nsid;
+    __u8            rsvd2[48];
+};
+
   struct nvme_lba_range_type {
       __u8            type;
       __u8            attributes;
@@ -766,6 +786,17 @@ enum {
       NVME_LBART_ATTRIB_HIDE    = 1 << 1,
   };
   +enum nvme_pr_capabilities {
+    NVME_PR_SUPPORT_PTPL                = 1,
+    NVME_PR_SUPPORT_WRITE_EXCLUSIVE            = 1 << 1,
+    NVME_PR_SUPPORT_EXCLUSIVE_ACCESS        = 1 << 2,
+    NVME_PR_SUPPORT_WRITE_EXCLUSIVE_REG_ONLY    = 1 << 3,
+    NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_REG_ONLY    = 1 << 4,
+    NVME_PR_SUPPORT_WRITE_EXCLUSIVE_ALL_REGS    = 1 << 5,
+    NVME_PR_SUPPORT_EXCLUSIVE_ACCESS_ALL_REGS    = 1 << 6,
+    NVME_PR_SUPPORT_IEKEY_VER_1_3_DEF        = 1 << 7,
+};
+
   enum nvme_pr_type {
       NVME_PR_WRITE_EXCLUSIVE            = 1,
       NVME_PR_EXCLUSIVE_ACCESS        = 2,
@@ -775,6 +806,23 @@ enum nvme_pr_type {
       NVME_PR_EXCLUSIVE_ACCESS_ALL_REGS    = 6,
   };
   +enum nvme_pr_register_action {
+    NVME_PR_REGISTER_ACT_REG        = 0,
+    NVME_PR_REGISTER_ACT_UNREG        = 1,
+    NVME_PR_REGISTER_ACT_REPLACE        = 1 << 1,
+};
+
+enum nvme_pr_acquire_action {
+    NVME_PR_ACQUIRE_ACT_ACQUIRE        = 0,
+    NVME_PR_ACQUIRE_ACT_PREEMPT        = 1,
+    NVME_PR_ACQUIRE_ACT_PREEMPT_AND_ABORT    = 1 << 1,
+};
+
+enum nvme_pr_release_action {
+    NVME_PR_RELEASE_ACT_RELEASE        = 0,
+    NVME_PR_RELEASE_ACT_CLEAR        = 1,
+};
+
   enum nvme_eds {
       NVME_EXTENDED_DATA_STRUCT    = 0x1,
   };
author
#4 lore raw

PATCH v2 2/3 nvmet: unify aer type enum

In reply to Guixin Liu

The host and target use two definition of aer type, unify them into a single one.

---
 drivers/nvme/target/core.c      | 4 ++--
 drivers/nvme/target/discovery.c | 2 +-
 include/linux/nvme.h            | 6 ------
 3 files changed, 3 insertions(+), 9 deletions(-)
drivers/nvme/target/core.c +2 -2
index a5019881d60b..12088160ce23 100644
@@ -248,7 +248,7 @@ void nvmet_ns_changed(struct nvmet_subsys *subsys, u32 nsid)
 		nvmet_add_to_changed_ns_log(ctrl, cpu_to_le32(nsid));
 		if (nvmet_aen_bit_disabled(ctrl, NVME_AEN_BIT_NS_ATTR))
 			continue;
-		nvmet_add_async_event(ctrl, NVME_AER_TYPE_NOTICE,
+		nvmet_add_async_event(ctrl, NVME_AER_NOTICE,
 				NVME_AER_NOTICE_NS_CHANGED,
 				NVME_LOG_CHANGED_NS);
 	}
@@ -265,7 +265,7 @@ void nvmet_send_ana_event(struct nvmet_subsys *subsys,
 			continue;
 		if (nvmet_aen_bit_disabled(ctrl, NVME_AEN_BIT_ANA_CHANGE))
 			continue;
-		nvmet_add_async_event(ctrl, NVME_AER_TYPE_NOTICE,
+		nvmet_add_async_event(ctrl, NVME_AER_NOTICE,
 				NVME_AER_NOTICE_ANA, NVME_LOG_ANA);
 	}
 	mutex_unlock(&subsys->lock);
drivers/nvme/target/discovery.c +1 -1
index 668d257fa986..68e82ccc0e4e 100644
@@ -21,7 +21,7 @@ static void __nvmet_disc_changed(struct nvmet_port *port,
 	if (nvmet_aen_bit_disabled(ctrl, NVME_AEN_BIT_DISC_CHANGE))
 		return;
 
-	nvmet_add_async_event(ctrl, NVME_AER_TYPE_NOTICE,
+	nvmet_add_async_event(ctrl, NVME_AER_NOTICE,
 			      NVME_AER_NOTICE_DISC_CHANGED, NVME_LOG_DISC);
 }
 
include/linux/nvme.h +0 -6
index bb5f56ebae50..226f5d48d135 100644
@@ -865,12 +865,6 @@ struct nvme_reservation_status_ext {
 	struct nvme_registered_ctrl_ext regctl_eds[];
 };
 
-enum nvme_async_event_type {
-	NVME_AER_TYPE_ERROR	= 0,
-	NVME_AER_TYPE_SMART	= 1,
-	NVME_AER_TYPE_NOTICE	= 2,
-};
-
 /* I/O commands */
 
 enum nvme_opcode {
Signature · 1 line
2.43.0
author
#6 lore raw

PATCH v2 3/3 nvme: introduce pr_work to handle resv event

In reply to Guixin Liu

When a reservation event is reported, the corresponding log page is already on the target side, and the host side needs to send a get log command to clear these log pages.

---
 drivers/nvme/host/core.c | 47 +++++++++++++++++++++++++++++++++++++++-
 drivers/nvme/host/nvme.h |  1 +
 2 files changed, 47 insertions(+), 1 deletion(-)
drivers/nvme/host/core.c +46 -1
index 60f14019f981..a906aea2f4a8 100644
@@ -4220,6 +4220,47 @@ static void nvme_handle_aer_persistent_error(struct nvme_ctrl *ctrl)
 	nvme_reset_ctrl(ctrl);
 }
 
+static void nvme_queue_pr(struct nvme_ctrl *ctrl)
+{
+	if (nvme_ctrl_state(ctrl) == NVME_CTRL_LIVE)
+		queue_work(nvme_wq, &ctrl->pr_work);
+}
+
+static void nvme_pr_work(struct work_struct *work)
+{
+	struct nvme_ctrl *ctrl = container_of(work, struct nvme_ctrl, pr_work);
+	struct nvme_pr_log log = { 0 };
+	int error;
+
+	if (nvme_ctrl_state(ctrl) != NVME_CTRL_LIVE)
+		return;
+
+	error = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_RESERVATION, 0,
+			NVME_CSI_NVM, &log, sizeof(log), 0);
+	if (error) {
+		dev_warn(ctrl->device,
+			 "reading reservation log failed: %d\n", error);
+		return;
+	}
+
+	if (log.nr_avl_pages)
+		nvme_queue_pr(ctrl);
+}
+
+static void nvme_handle_aen_css(struct nvme_ctrl *ctrl, u32 result)
+{
+	u32 aer_css_type = nvme_aer_subtype(result);
+
+	switch (aer_css_type) {
+	case NVME_AEN_RESV_LOG_PAGE_AVALIABLE:
+		nvme_queue_pr(ctrl);
+		break;
+	default:
+		ctrl->aen_result = result;
+		dev_warn(ctrl->device, "async event result %08x\n", result);
+	}
+}
+
 void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,
 		volatile union nvme_result *res)
 {
@@ -4236,6 +4277,9 @@ void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,
 	case NVME_AER_NOTICE:
 		requeue = nvme_handle_aen_notice(ctrl, result);
 		break;
+	case NVME_AER_CSS:
+		nvme_handle_aen_css(ctrl, result);
+		break;
 	case NVME_AER_ERROR:
 		/*
 		 * For a persistent internal error, don't run async_event_work
@@ -4247,7 +4291,6 @@ void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,
 		}
 		fallthrough;
 	case NVME_AER_SMART:
-	case NVME_AER_CSS:
 	case NVME_AER_VS:
 		ctrl->aen_result = result;
 		break;
@@ -4389,6 +4432,7 @@ void nvme_stop_ctrl(struct nvme_ctrl *ctrl)
 	nvme_stop_keep_alive(ctrl);
 	nvme_stop_failfast_work(ctrl);
 	flush_work(&ctrl->async_event_work);
+	flush_work(&ctrl->pr_work);
 	cancel_work_sync(&ctrl->fw_act_work);
 	if (ctrl->ops->stop_ctrl)
 		ctrl->ops->stop_ctrl(ctrl);
@@ -4494,6 +4538,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev,
 	ctrl->quirks = quirks;
 	ctrl->numa_node = NUMA_NO_NODE;
 	INIT_WORK(&ctrl->scan_work, nvme_scan_work);
+	INIT_WORK(&ctrl->pr_work, nvme_pr_work);
 	INIT_WORK(&ctrl->async_event_work, nvme_async_event_work);
 	INIT_WORK(&ctrl->fw_act_work, nvme_fw_act_work);
 	INIT_WORK(&ctrl->delete_work, nvme_delete_ctrl_work);
drivers/nvme/host/nvme.h +1 -0
index e7411dac00f7..6ea4552c4de3 100644
@@ -334,6 +334,7 @@ struct nvme_ctrl {
 	struct nvme_effects_log *effects;
 	struct xarray cels;
 	struct work_struct scan_work;
+	struct work_struct pr_work;
 	struct work_struct async_event_work;
 	struct delayed_work ka_work;
 	struct delayed_work failfast_work;
Signature · 1 line
2.43.0
maintainer
#7 lore raw

Re: [PATCH V2 3/3] nvme: introduce pr_work to handle resv event

Quoted 4 lines

When a reservation event is reported, the corresponding log page is already on the target side, and the host side needs to send a get log command to clear these log pages.

AENs are already sent to userspace, I don't see why the kernel should read the log page unless it has something meaningful to do with it.

Quoted 105 lines
---
  drivers/nvme/host/core.c | 47 +++++++++++++++++++++++++++++++++++++++-
  drivers/nvme/host/nvme.h |  1 +
  2 files changed, 47 insertions(+), 1 deletion(-)
drivers/nvme/host/core.c +46 -1
index 60f14019f981..a906aea2f4a8 100644
@@ -4220,6 +4220,47 @@ static void nvme_handle_aer_persistent_error(struct nvme_ctrl *ctrl)
  	nvme_reset_ctrl(ctrl);
  }
 
+static void nvme_queue_pr(struct nvme_ctrl *ctrl)
+{
+	if (nvme_ctrl_state(ctrl) == NVME_CTRL_LIVE)
+		queue_work(nvme_wq, &ctrl->pr_work);
+}
+
+static void nvme_pr_work(struct work_struct *work)
+{
+	struct nvme_ctrl *ctrl = container_of(work, struct nvme_ctrl, pr_work);
+	struct nvme_pr_log log = { 0 };
+	int error;
+
+	if (nvme_ctrl_state(ctrl) != NVME_CTRL_LIVE)
+		return;
+
+	error = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_RESERVATION, 0,
+			NVME_CSI_NVM, &log, sizeof(log), 0);
+	if (error) {
+		dev_warn(ctrl->device,
+			 "reading reservation log failed: %d\n", error);
+		return;
+	}
+
+	if (log.nr_avl_pages)
+		nvme_queue_pr(ctrl);
+}
+
+static void nvme_handle_aen_css(struct nvme_ctrl *ctrl, u32 result)
+{
+	u32 aer_css_type = nvme_aer_subtype(result);
+
+	switch (aer_css_type) {
+	case NVME_AEN_RESV_LOG_PAGE_AVALIABLE:
+		nvme_queue_pr(ctrl);
+		break;
+	default:
+		ctrl->aen_result = result;
+		dev_warn(ctrl->device, "async event result %08x\n", result);
+	}
+}
+
  void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,
  		volatile union nvme_result *res)
  {
@@ -4236,6 +4277,9 @@ void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,
  	case NVME_AER_NOTICE:
  		requeue = nvme_handle_aen_notice(ctrl, result);
  		break;
+	case NVME_AER_CSS:
+		nvme_handle_aen_css(ctrl, result);
+		break;
  	case NVME_AER_ERROR:
  		/*
  		 * For a persistent internal error, don't run async_event_work
@@ -4247,7 +4291,6 @@ void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,
  		}
  		fallthrough;
  	case NVME_AER_SMART:
-	case NVME_AER_CSS:
  	case NVME_AER_VS:
  		ctrl->aen_result = result;
  		break;
@@ -4389,6 +4432,7 @@ void nvme_stop_ctrl(struct nvme_ctrl *ctrl)
  	nvme_stop_keep_alive(ctrl);
  	nvme_stop_failfast_work(ctrl);
  	flush_work(&ctrl->async_event_work);
+	flush_work(&ctrl->pr_work);
  	cancel_work_sync(&ctrl->fw_act_work);
  	if (ctrl->ops->stop_ctrl)
  		ctrl->ops->stop_ctrl(ctrl);
@@ -4494,6 +4538,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev,
  	ctrl->quirks = quirks;
  	ctrl->numa_node = NUMA_NO_NODE;
  	INIT_WORK(&ctrl->scan_work, nvme_scan_work);
+	INIT_WORK(&ctrl->pr_work, nvme_pr_work);
  	INIT_WORK(&ctrl->async_event_work, nvme_async_event_work);
  	INIT_WORK(&ctrl->fw_act_work, nvme_fw_act_work);
  	INIT_WORK(&ctrl->delete_work, nvme_delete_ctrl_work);
drivers/nvme/host/nvme.h +1 -0
index e7411dac00f7..6ea4552c4de3 100644
@@ -334,6 +334,7 @@ struct nvme_ctrl {
  	struct nvme_effects_log *effects;
  	struct xarray cels;
  	struct work_struct scan_work;
+	struct work_struct pr_work;
  	struct work_struct async_event_work;
  	struct delayed_work ka_work;
  	struct delayed_work failfast_work;
author
#8 lore raw

Re: [PATCH V2 3/3] nvme: introduce pr_work to handle resv event

Quoted 9 lines · Sagi Grimberg
Quoted 4 lines

When a reservation event is reported, the corresponding log page is already on the target side, and the host side needs to send a get log command to clear these log pages.

AENs are already sent to userspace, I don't see why the kernel should read the log page unless it has something meaningful to do with it.

Is it tolerable if we dont clear the log page?

Maybe I should check the max count of resv_log_list in nvmet.

Quoted 109 lines
Quoted 109 lines

---
  drivers/nvme/host/core.c | 47 +++++++++++++++++++++++++++++++++++++++- drivers/nvme/host/nvme.h |  1 +

  2 files changed, 47 insertions(+), 1 deletion(-)
drivers/nvme/host/core.c +40 -0
index 60f14019f981..a906aea2f4a8 100644
@@ -4220,6 +4220,47 @@ static void 
 nvme_handle_aer_persistent_error(struct nvme_ctrl *ctrl)
       nvme_reset_ctrl(ctrl);
   }
   +static void nvme_queue_pr(struct nvme_ctrl *ctrl)
+{
+    if (nvme_ctrl_state(ctrl) == NVME_CTRL_LIVE)
+        queue_work(nvme_wq, &ctrl->pr_work);
+}
+
+static void nvme_pr_work(struct work_struct *work)
+{
+    struct nvme_ctrl *ctrl = container_of(work, struct nvme_ctrl, 
 pr_work);
+    struct nvme_pr_log log = { 0 };
+    int error;
+
+    if (nvme_ctrl_state(ctrl) != NVME_CTRL_LIVE)
+        return;
+
+    error = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_RESERVATION, 0,
+            NVME_CSI_NVM, &log, sizeof(log), 0);
+    if (error) {
+        dev_warn(ctrl->device,
+             "reading reservation log failed: %d\n", error);
+        return;
+    }
+
+    if (log.nr_avl_pages)
+        nvme_queue_pr(ctrl);
+}
+
+static void nvme_handle_aen_css(struct nvme_ctrl *ctrl, u32 result)
+{
+    u32 aer_css_type = nvme_aer_subtype(result);
+
+    switch (aer_css_type) {
+    case NVME_AEN_RESV_LOG_PAGE_AVALIABLE:
+        nvme_queue_pr(ctrl);
+        break;
+    default:
+        ctrl->aen_result = result;
+        dev_warn(ctrl->device, "async event result %08x\n", result);
+    }
+}
+
   void nvme_complete_async_event(struct nvme_ctrl *ctrl, __le16 status,

          volatile union nvme_result *res)
  {

drivers/nvme/host/core.c +0 -0
@@ -4236,6 +4277,9 @@ void nvme_complete_async_event(struct nvme_ctrl 
 *ctrl, __le16 status,

      case NVME_AER_NOTICE:
          requeue = nvme_handle_aen_notice(ctrl, result); break;
+    case NVME_AER_CSS:
+        nvme_handle_aen_css(ctrl, result);
+        break;
      case NVME_AER_ERROR:
          /*
           * For a persistent internal error, don't run async_event_work

drivers/nvme/host/core.c +0 -0
@@ -4247,7 +4291,6 @@ void nvme_complete_async_event(struct nvme_ctrl 
 *ctrl, __le16 status,
           }
           fallthrough;

      case NVME_AER_SMART:
-    case NVME_AER_CSS:
      case NVME_AER_VS:
          ctrl->aen_result = result;
          break;

drivers/nvme/host/core.c +2 -0
@@ -4389,6 +4432,7 @@ void nvme_stop_ctrl(struct nvme_ctrl *ctrl)
       nvme_stop_keep_alive(ctrl);
       nvme_stop_failfast_work(ctrl);
       flush_work(&ctrl->async_event_work);
+    flush_work(&ctrl->pr_work);
       cancel_work_sync(&ctrl->fw_act_work);
       if (ctrl->ops->stop_ctrl)
           ctrl->ops->stop_ctrl(ctrl);
@@ -4494,6 +4538,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, 
 struct device *dev,
       ctrl->quirks = quirks;
       ctrl->numa_node = NUMA_NO_NODE;
       INIT_WORK(&ctrl->scan_work, nvme_scan_work);
+    INIT_WORK(&ctrl->pr_work, nvme_pr_work);
       INIT_WORK(&ctrl->async_event_work, nvme_async_event_work);
       INIT_WORK(&ctrl->fw_act_work, nvme_fw_act_work);

      INIT_WORK(&ctrl->delete_work, nvme_delete_ctrl_work);

drivers/nvme/host/nvme.h +1 -0
index e7411dac00f7..6ea4552c4de3 100644
@@ -334,6 +334,7 @@ struct nvme_ctrl {
       struct nvme_effects_log *effects;
       struct xarray cels;
       struct work_struct scan_work;
+    struct work_struct pr_work;
       struct work_struct async_event_work;
       struct delayed_work ka_work;
       struct delayed_work failfast_work;
maintainer
#9 lore raw

Re: [PATCH V2 3/3] nvme: introduce pr_work to handle resv event

Quoted 7 lines · Guixin Liu
Quoted 5 lines · Sagi Grimberg
Quoted 4 lines

When a reservation event is reported, the corresponding log page is already on the target side, and the host side needs to send a get log command to clear these log pages.

Quoted 5 lines
Quoted 4 lines

AENs are already sent to userspace, I don't see why the kernel should read the log page unless it has something meaningful to do with it.

Is it tolerable if we dont clear the log page?

Its up to the host. If the host has nothing to do with it then it doesn't have to do anything with it. I'm assuming that the user exercising reservations would listen to udev.

Perhaps libnvme would be the place we want to allow users to consume an api to deal with reservation events.

author
#10 lore raw

Re: [PATCH V2 3/3] nvme: introduce pr_work to handle resv event

Quoted 14 lines · Sagi Grimberg
Quoted 11 lines · Guixin Liu
Quoted 9 lines · Sagi Grimberg
Quoted 4 lines

When a reservation event is reported, the corresponding log page is already on the target side, and the host side needs to send a get log command to clear these log pages.

AENs are already sent to userspace, I don't see why the kernel should read the log page unless it has something meaningful to do with it.

Quoted 8 lines
Quoted 1 line

Is it tolerable if we dont clear the log page?

Its up to the host. If the host has nothing to do with it then it doesn't have to do anything with it. I'm assuming that the user exercising reservations would listen to udev.

Perhaps libnvme would be the place we want to allow users to consume an api to deal with reservation events.

Agree, the userspace may use the reservation log page's information,

I will do a research on libnvme to see if we can add a consuming api after

this is done.

maintainer
#11 lore raw
In reply to Guixin Liu
Quoted 30 lines · Guixin Liu

Hi guys,
I've implemented the NVMe reservation feature. Please review it, all
comments are welcome as usual.

Changes from v1 to v2:
- Implement the reservation notification report, includes registration preempted, reservation released and reservation preempted. And also handle the reservation log page avaliable event and send get
reservation log page command to clear log page at host.

- Put the reservation check access after validate opcode. And remove opcodes which nvmet not implement yet check.
Now there is no admin opcode nvmet implemented needs reservation check,
so I dont add reservation check to admin command path.
Next we need to do reservation check includes the situation of nsid is
0xffffffff at each admin command path, if it is needed.

- Add reservation commands support in nvmet_get_cmd_effects_nvm().

- From Chaitanya, change the local variable tree style to make it cleaner, and add some comments about NVMe spec.
And also change others advice from chaitanya.

- Put the nvmet_pr_check_cmd_access and nvmet_parse_pr_cmd into reservation enable check warp.

- Remove kmem_cache instead to use kmalloc and kfree.

- Change others advice from Sagi.

Quoted 7 lines

- Add a blktest test case, this patch will be sent before these series of pathes.

Advice I dont adopt:
- From Sagi, use rcu instead of rwlock.
I need protect registrant_list, holder, type and generation simutaneously,
the rcu can not protect multiple units.

I don't see how the generation needs the same protection. As for the type and holder, perhaps we can find ordering that allows us to relax the dereference? Or make it a member of the holder?

All I'm saying is that nvmet_pr_check_cmd_access() is dereferencing ns->pr->holder and ns->pr->holder->uuid, so the proposal is to update ns->pr->hostder with rcu synchronization such that the IO path will simply do:

	rcu_read_lock();
	if (!rcu_dereference(pr->holder))
		goto unlock;
	if (uuid_equal(&ctrl->hostid, &pr->holder->hostid)
		goto unlock;
	rtype = pr->rtype; // or pr->holder->rtype ?
	rcu_read_unlock();

Nothing prevents you from protecting anything else on top of that.

Quoted 6 lines

- From Sagi, use blkdev's pr_ops if it is exist.
The backend is unable to distinguish connections from the frontend, If we
use the pr_ops of the block device, the block device's target would only recognize it as a reservation by the nvme target.
Could you plz give me more information? Sagi?

Umm, won't nvmet register the same key as transferred by the host? Not sure either how it should work.

In any event fwiw, if we can make the data path access cheap enough with rcu I don't think its a necessary optimization...

Quoted 25 lines

- From Keith, use nvmet_get_cmd_effects_nvm to see if a command would violate a reservation.
The information is missing in effects, for example the flush command should
be checked, but there is onely a NVME_CMD_EFFECTS_CSUPP flag in effects, no LBCC.

Guixin Liu (3):
nvmet: support reservation feature
nvmet: unify aer type enum
nvme: introduce pr_work to handle resv event

  drivers/nvme/host/core.c        |  47 +-
  drivers/nvme/host/nvme.h        |   1 +
  drivers/nvme/target/Makefile    |   2 +-
  drivers/nvme/target/admin-cmd.c |  14 +-
  drivers/nvme/target/configfs.c  |  27 +
  drivers/nvme/target/core.c      |  53 +-
  drivers/nvme/target/discovery.c |   2 +-
  drivers/nvme/target/nvmet.h     |  33 ++
  drivers/nvme/target/pr.c        | 887 ++++++++++++++++++++++++++++++++
  include/linux/nvme.h            |  54 +-
  10 files changed, 1103 insertions(+), 17 deletions(-)

create mode 100644 drivers/nvme/target/pr.c

author
#12 lore raw
Quoted 64 lines · Sagi Grimberg
Quoted 32 lines · Guixin Liu

Hi guys,
     I've implemented the NVMe reservation feature. Please review it, all comments are welcome as usual.

Changes from v1 to v2:
- Implement the reservation notification report, includes registration preempted, reservation released and reservation preempted. And also handle the reservation log page avaliable event and send get reservation log page command to clear log page at host.

- Put the reservation check access after validate opcode. And remove opcodes which nvmet not implement yet check.
   Now there is no admin opcode nvmet implemented needs reservation check, so I dont add reservation check to admin command path.
   Next we need to do reservation check includes the situation of nsid is 0xffffffff at each admin command path, if it is needed.

- Add reservation commands support in nvmet_get_cmd_effects_nvm().

- From Chaitanya, change the local variable tree style to make it cleaner,
and add some comments about NVMe spec.
   And also change others advice from chaitanya.

- Put the nvmet_pr_check_cmd_access and nvmet_parse_pr_cmd into reservation
enable check warp.

- Remove kmem_cache instead to use kmalloc and kfree.

- Change others advice from Sagi.

Quoted 8 lines

- Add a blktest test case, this patch will be sent before these series of
pathes.

Advice I dont adopt:
- From Sagi, use rcu instead of rwlock.
   I need protect registrant_list, holder, type and generation simutaneously, the rcu can not protect multiple units.

I don't see how the generation needs the same protection. As for the type and holder, perhaps we can find ordering that allows us to relax the dereference? Or make it a member of the holder?

All I'm saying is that nvmet_pr_check_cmd_access() is dereferencing ns->pr->holder and ns->pr->holder->uuid, so the proposal is to update ns->pr->hostder with rcu synchronization such that the IO path will simply do:

    rcu_read_lock();
    if (!rcu_dereference(pr->holder))
        goto unlock;
    if (uuid_equal(&ctrl->hostid, &pr->holder->hostid) goto unlock;
    rtype = pr->rtype; // or pr->holder->rtype ? rcu_read_unlock();

Nothing prevents you from protecting anything else on top of that.

Quoted 1 line
Quoted 8 lines
Quoted 5 lines

- From Sagi, use blkdev's pr_ops if it is exist.
   The backend is unable to distinguish connections from the frontend, If we use the pr_ops of the block device, the block device's target would only recognize it as a reservation by the nvme target.
   Could you plz give me more information? Sagi?

Umm, won't nvmet register the same key as transferred by the host? Not sure either how it should work.

I think the person who manages the nvmet configuration should make sure

that nvmet has exclusive access to the backend disk.

Quoted 3 lines

In any event fwiw, if we can make the data path access cheap enough with rcu I don't think its a necessary optimization...

OK, I will do a deep thinking about rcu.

Thanks.

Guixin Liu

Quoted 27 lines
Quoted 27 lines

- From Keith, use nvmet_get_cmd_effects_nvm to see if a command would violate
a reservation.
   The information is missing in effects, for example the flush command should be checked, but there is onely a  NVME_CMD_EFFECTS_CSUPP flag in effects, no LBCC.

Guixin Liu (3):
   nvmet: support reservation feature
   nvmet: unify aer type enum
   nvme: introduce pr_work to handle resv event

  drivers/nvme/host/core.c        |  47 +- drivers/nvme/host/nvme.h        |   1 + drivers/nvme/target/Makefile    |   2 +- drivers/nvme/target/admin-cmd.c |  14 +- drivers/nvme/target/configfs.c  |  27 + drivers/nvme/target/core.c      |  53 +- drivers/nvme/target/discovery.c |   2 +- drivers/nvme/target/nvmet.h     |  33 ++ drivers/nvme/target/pr.c        | 887 ++++++++++++++++++++++++++++++++ include/linux/nvme.h            |  54 +-

  10 files changed, 1103 insertions(+), 17 deletions(-)

  create mode 100644 drivers/nvme/target/pr.c