Skip to contentSkip to conversation

nvme-multipath: expose path_state via sysfs

PATCH Superseded Guixin Liu 4 participants 8 messages Jun 24 – Jul 14 NVMe

v3 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Guixin Liu

author
#0 lore raw

PATCH v3 1/1 nvme-multipath: expose path_state via sysfs

Add a read-only "path_state" sysfs attribute to each NVMe path namespace device (/sys/class/nvme/nvmeX/nvmeXcYnZ/path_state) that exposes the current path state, including whether the path is enabled or disabled with a specific reason.

Factor the path disable checks from nvme_path_is_disabled() into a new nvme_path_get_state() helper that returns an enum nvme_path_state. This keeps the path selection logic and sysfs reporting in sync, so any future updates to the path disable criteria are automatically reflected in the sysfs output.

Possible values:
- "enabled (optimized)" : ANA state is optimized
- "enabled (non-optimized)" : ANA state is not optimized
- "disabled (ctrl_down)" : controller is not live
- "disabled (ana_pending)" : ANA state change pending
- "disabled (ns_not_ready)" : namespace is not ready

This gives userspace visibility into the multipath path selection state without requiring users to piece together controller state and namespace flags manually.

---
v2->v3:
- Factor path disable checks into nvme_path_get_state() helper returning enum nvme_path_state, and rebuild nvme_path_is_disabled() on top of it to keep path selection logic and sysfs reporting in sync. (Nilay Shroff)
- Distinguish "enabled (optimized)" vs "enabled (non-optimized)" based on ANA state. (Keith Busch)

v1->v2:
- Show specific disabled reason instead of just
"disabled": "disabled (ctrl_down)",
"disabled (ana_pending)",
"disabled (ns_not_ready)". (Nilay Shroff)

---
 drivers/nvme/host/multipath.c | 47 ++++++++++++++++++++++++++++++-----
 drivers/nvme/host/nvme.h      |  1 +
 drivers/nvme/host/sysfs.c     |  4 ++-
 3 files changed, 45 insertions(+), 7 deletions(-)
drivers/nvme/host/multipath.c +41 -6
index e033ede953cc..2da5e9da1866 100644
@@ -288,7 +288,15 @@ void nvme_mpath_revalidate_paths(struct nvme_ns_head *head)
 	kblockd_schedule_work(&head->requeue_work);
 }
 
-static bool nvme_path_is_disabled(struct nvme_ns *ns)
+enum nvme_path_state {
+	NVME_PATH_ENABLED_OPTIMIZED,
+	NVME_PATH_ENABLED_NONOPTIMIZED,
+	NVME_PATH_DISABLED_CTRL_DOWN,
+	NVME_PATH_DISABLED_ANA_PENDING,
+	NVME_PATH_DISABLED_NS_NOT_READY,
+};
+
+static enum nvme_path_state nvme_path_get_state(struct nvme_ns *ns)
 {
 	enum nvme_ctrl_state state = nvme_ctrl_state(ns->ctrl);
 
@@ -298,11 +306,20 @@ static bool nvme_path_is_disabled(struct nvme_ns *ns)
 	 * Otherwise it will fail immediately and return to the requeue list.
 	 */
 	if (state != NVME_CTRL_LIVE && state != NVME_CTRL_DELETING)
-		return true;
-	if (test_bit(NVME_NS_ANA_PENDING, &ns->flags) ||
-	    !test_bit(NVME_NS_READY, &ns->flags))
-		return true;
-	return false;
+		return NVME_PATH_DISABLED_CTRL_DOWN;
+	if (test_bit(NVME_NS_ANA_PENDING, &ns->flags))
+		return NVME_PATH_DISABLED_ANA_PENDING;
+	if (!test_bit(NVME_NS_READY, &ns->flags))
+		return NVME_PATH_DISABLED_NS_NOT_READY;
+	if (nvme_ctrl_use_ana(ns->ctrl) &&
+	    ns->ana_state != NVME_ANA_OPTIMIZED)
+		return NVME_PATH_ENABLED_NONOPTIMIZED;
+	return NVME_PATH_ENABLED_OPTIMIZED;
+}
+
+static bool nvme_path_is_disabled(struct nvme_ns *ns)
+{
+	return nvme_path_get_state(ns) > NVME_PATH_ENABLED_NONOPTIMIZED;
 }
 
 static struct nvme_ns *__nvme_find_path(struct nvme_ns_head *head, int node)
@@ -1101,6 +1118,24 @@ static ssize_t queue_depth_show(struct device *dev,
 }
 DEVICE_ATTR_RO(queue_depth);
 
+static const char * const nvme_path_state_names[] = {
+	[NVME_PATH_ENABLED_OPTIMIZED]		= "enabled (optimized)",
+	[NVME_PATH_ENABLED_NONOPTIMIZED]	= "enabled (non-optimized)",
+	[NVME_PATH_DISABLED_CTRL_DOWN]		= "disabled (ctrl_down)",
+	[NVME_PATH_DISABLED_ANA_PENDING]	= "disabled (ana_pending)",
+	[NVME_PATH_DISABLED_NS_NOT_READY]	= "disabled (ns_not_ready)",
+};
+
+static ssize_t path_state_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
+
+	return sysfs_emit(buf, "%s\n",
+			  nvme_path_state_names[nvme_path_get_state(ns)]);
+}
+DEVICE_ATTR_RO(path_state);
+
 static ssize_t numa_nodes_show(struct device *dev, struct device_attribute *attr,
 		char *buf)
 {
drivers/nvme/host/nvme.h +1 -0
index b367c67dcb37..da59364d4774 100644
@@ -1072,6 +1072,7 @@ extern struct device_attribute dev_attr_ana_grpid;
 extern struct device_attribute dev_attr_ana_state;
 extern struct device_attribute dev_attr_queue_depth;
 extern struct device_attribute dev_attr_numa_nodes;
+extern struct device_attribute dev_attr_path_state;
 extern struct device_attribute dev_attr_delayed_removal_secs;
 extern struct device_attribute dev_attr_multipath_failover_count;
 extern struct device_attribute dev_attr_io_requeue_no_usable_path_count;
drivers/nvme/host/sysfs.c +3 -1
index 933a5adfb7af..500d773300e7 100644
@@ -261,6 +261,7 @@ static struct attribute *nvme_ns_attrs[] = {
 	&dev_attr_ana_state.attr,
 	&dev_attr_queue_depth.attr,
 	&dev_attr_numa_nodes.attr,
+	&dev_attr_path_state.attr,
 	&dev_attr_delayed_removal_secs.attr,
 #endif
 	&dev_attr_io_passthru_err_log_enabled.attr,
@@ -294,7 +295,8 @@ static umode_t nvme_ns_attrs_are_visible(struct kobject *kobj,
 		if (!nvme_ctrl_use_ana(nvme_get_ns_from_dev(dev)->ctrl))
 			return 0;
 	}
-	if (a == &dev_attr_queue_depth.attr || a == &dev_attr_numa_nodes.attr) {
+	if (a == &dev_attr_queue_depth.attr || a == &dev_attr_numa_nodes.attr ||
+	    a == &dev_attr_path_state.attr) {
 		if (nvme_disk_is_ns_head(dev_to_disk(dev)))
 			return 0;
 	}
Signature · 1 line
2.43.7
#1 lore raw
Quoted 79 lines · Guixin Liu

Add a read-only "path_state" sysfs attribute to each NVMe path namespace device (/sys/class/nvme/nvmeX/nvmeXcYnZ/path_state) that exposes the current path state, including whether the path is enabled or disabled with a specific reason.

Factor the path disable checks from nvme_path_is_disabled() into a new nvme_path_get_state() helper that returns an enum nvme_path_state. This keeps the path selection logic and sysfs reporting in sync, so any future updates to the path disable criteria are automatically reflected in the sysfs output.

Possible values:
- "enabled (optimized)" : ANA state is optimized
- "enabled (non-optimized)" : ANA state is not optimized
- "disabled (ctrl_down)" : controller is not live
- "disabled (ana_pending)" : ANA state change pending
- "disabled (ns_not_ready)" : namespace is not ready

This gives userspace visibility into the multipath path selection state without requiring users to piece together controller state and namespace flags manually.

---
v2->v3:
- Factor path disable checks into nvme_path_get_state() helper returning enum nvme_path_state, and rebuild nvme_path_is_disabled() on top of it to keep path selection logic and sysfs reporting in sync. (Nilay Shroff)
- Distinguish "enabled (optimized)" vs "enabled (non-optimized)" based on ANA state. (Keith Busch)

v1->v2:
- Show specific disabled reason instead of just
"disabled": "disabled (ctrl_down)",
"disabled (ana_pending)",
"disabled (ns_not_ready)". (Nilay Shroff)

---
  drivers/nvme/host/multipath.c | 47 ++++++++++++++++++++++++++++++-----
  drivers/nvme/host/nvme.h      |  1 +
  drivers/nvme/host/sysfs.c     |  4 ++-
  3 files changed, 45 insertions(+), 7 deletions(-)
drivers/nvme/host/multipath.c +13 -6
index e033ede953cc..2da5e9da1866 100644
@@ -288,7 +288,15 @@ void nvme_mpath_revalidate_paths(struct nvme_ns_head *head)
  	kblockd_schedule_work(&head->requeue_work);
  }
 
-static bool nvme_path_is_disabled(struct nvme_ns *ns)
+enum nvme_path_state {
+	NVME_PATH_ENABLED_OPTIMIZED,
+	NVME_PATH_ENABLED_NONOPTIMIZED,
+	NVME_PATH_DISABLED_CTRL_DOWN,
+	NVME_PATH_DISABLED_ANA_PENDING,
+	NVME_PATH_DISABLED_NS_NOT_READY,
+};
+
+static enum nvme_path_state nvme_path_get_state(struct nvme_ns *ns)
  {
  	enum nvme_ctrl_state state = nvme_ctrl_state(ns->ctrl);
 
@@ -298,11 +306,20 @@ static bool nvme_path_is_disabled(struct nvme_ns *ns)
  	 * Otherwise it will fail immediately and return to the requeue list.
  	 */
  	if (state != NVME_CTRL_LIVE && state != NVME_CTRL_DELETING)
-		return true;
-	if (test_bit(NVME_NS_ANA_PENDING, &ns->flags) ||
-	    !test_bit(NVME_NS_READY, &ns->flags))
-		return true;
-	return false;
+		return NVME_PATH_DISABLED_CTRL_DOWN;
+	if (test_bit(NVME_NS_ANA_PENDING, &ns->flags))
+		return NVME_PATH_DISABLED_ANA_PENDING;
+	if (!test_bit(NVME_NS_READY, &ns->flags))

drivers/nvme/host/multipath.c static bool nvme_path_is_disabled(struct nvme_ns *ns) · line 322

Quoted 10 lines
drivers/nvme/host/multipath.c +10 -0
+		return NVME_PATH_DISABLED_NS_NOT_READY;
+	if (nvme_ctrl_use_ana(ns->ctrl) &&
+	    ns->ana_state != NVME_ANA_OPTIMIZED)
+		return NVME_PATH_ENABLED_NONOPTIMIZED;
+	return NVME_PATH_ENABLED_OPTIMIZED;
+}
+
+static bool nvme_path_is_disabled(struct nvme_ns *ns)
+{
+	return nvme_path_get_state(ns) > NVME_PATH_ENABLED_NONOPTIMIZED;

I don't think that this is a particularly robust programming style, since nothing in enum nvme_path_state explicitly states that a very specific ordering or grouping is required

drivers/nvme/host/multipath.c static ssize_t queue_depth_show(struct device *dev, · line 1126

Quoted 13 lines
drivers/nvme/host/multipath.c +6 -0
  }
 
  static struct nvme_ns *__nvme_find_path(struct nvme_ns_head *head, int node)
@@ -1101,6 +1118,24 @@ static ssize_t queue_depth_show(struct device *dev,
  }
  DEVICE_ATTR_RO(queue_depth);
 
+static const char * const nvme_path_state_names[] = {
+	[NVME_PATH_ENABLED_OPTIMIZED]		= "enabled (optimized)",
+	[NVME_PATH_ENABLED_NONOPTIMIZED]	= "enabled (non-optimized)",
+	[NVME_PATH_DISABLED_CTRL_DOWN]		= "disabled (ctrl_down)",
+	[NVME_PATH_DISABLED_ANA_PENDING]	= "disabled (ana_pending)",
+	[NVME_PATH_DISABLED_NS_NOT_READY]	= "disabled (ns_not_ready)",

some strings are abbreviated and some aren't

drivers/nvme/host/multipath.c static ssize_t queue_depth_show(struct device *dev, · line 1135

Quoted 9 lines
drivers/nvme/host/multipath.c +9 -0
+};
+
+static ssize_t path_state_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
+
+	return sysfs_emit(buf, "%s\n",
+			  nvme_path_state_names[nvme_path_get_state(ns)]);

you should really check that nvme_path_get_state(ns) does not exceed indexing into ARRAY_SIZE(nvme_path_state_names)

Quoted 40 lines
drivers/nvme/host/multipath.c +3 -0
+}
+DEVICE_ATTR_RO(path_state);
+
  static ssize_t numa_nodes_show(struct device *dev, struct device_attribute *attr,
  		char *buf)
  {
drivers/nvme/host/nvme.h +1 -0
index b367c67dcb37..da59364d4774 100644
@@ -1072,6 +1072,7 @@ extern struct device_attribute dev_attr_ana_grpid;
  extern struct device_attribute dev_attr_ana_state;
  extern struct device_attribute dev_attr_queue_depth;
  extern struct device_attribute dev_attr_numa_nodes;
+extern struct device_attribute dev_attr_path_state;
  extern struct device_attribute dev_attr_delayed_removal_secs;
  extern struct device_attribute dev_attr_multipath_failover_count;
  extern struct device_attribute dev_attr_io_requeue_no_usable_path_count;
drivers/nvme/host/sysfs.c +3 -1
index 933a5adfb7af..500d773300e7 100644
@@ -261,6 +261,7 @@ static struct attribute *nvme_ns_attrs[] = {
  	&dev_attr_ana_state.attr,
  	&dev_attr_queue_depth.attr,
  	&dev_attr_numa_nodes.attr,
+	&dev_attr_path_state.attr,
  	&dev_attr_delayed_removal_secs.attr,
  #endif
  	&dev_attr_io_passthru_err_log_enabled.attr,
@@ -294,7 +295,8 @@ static umode_t nvme_ns_attrs_are_visible(struct kobject *kobj,
  		if (!nvme_ctrl_use_ana(nvme_get_ns_from_dev(dev)->ctrl))
  			return 0;
  	}
-	if (a == &dev_attr_queue_depth.attr || a == &dev_attr_numa_nodes.attr) {
+	if (a == &dev_attr_queue_depth.attr || a == &dev_attr_numa_nodes.attr ||
+	    a == &dev_attr_path_state.attr) {
  		if (nvme_disk_is_ns_head(dev_to_disk(dev)))
  			return 0;
  	}
#2 lore raw
Quoted 12 lines · John Garry
Quoted 11 lines · Guixin Liu

Add a read-only "path_state" sysfs attribute to each NVMe path namespace device (/sys/class/nvme/nvmeX/nvmeXcYnZ/path_state) that exposes the current path state, including whether the path is enabled or disabled with a specific reason.

Factor the path disable checks from nvme_path_is_disabled() into a new nvme_path_get_state() helper that returns an enum nvme_path_state. This keeps the path selection logic and sysfs reporting in sync, so any future updates to the path disable criteria are automatically reflected in the sysfs output.

Quoted 6 lines
Quoted 6 lines

Possible values:
- "enabled (optimized)" : ANA state is optimized
- "enabled (non-optimized)" : ANA state is not optimized
- "disabled (ctrl_down)" : controller is not live
- "disabled (ana_pending)" : ANA state change pending
- "disabled (ns_not_ready)" : namespace is not ready

I'd prefer to have a single string here instead of something we might need to parse again. The sysfs docs says

Mixing types, expressing multiple lines of data, and doing fancy formatting of data is heavily frowned upon. Doing these things may get you publicly humiliated and your code rewritten without notice.

Something like

- optimized
- non-optimized
- ctrl-down
- ana-pending
- ns-no-ready

BTW, the docs on sysfs say, these interfaces should be documented also in Documentation/ABI. So far we haven't done this for the nvme subsystem. Should we start with it?

author
#3 lore raw
Quoted 26 lines · Daniel Wagner
Quoted 12 lines · John Garry
Quoted 11 lines · Guixin Liu

Add a read-only "path_state" sysfs attribute to each NVMe path namespace device (/sys/class/nvme/nvmeX/nvmeXcYnZ/path_state) that exposes the current path state, including whether the path is enabled or disabled with a specific reason.

Factor the path disable checks from nvme_path_is_disabled() into a new nvme_path_get_state() helper that returns an enum nvme_path_state. This keeps the path selection logic and sysfs reporting in sync, so any future updates to the path disable criteria are automatically reflected in the sysfs output.

Quoted 6 lines
Quoted 6 lines

Possible values:
- "enabled (optimized)" : ANA state is optimized
- "enabled (non-optimized)" : ANA state is not optimized
- "disabled (ctrl_down)" : controller is not live
- "disabled (ana_pending)" : ANA state change pending
- "disabled (ns_not_ready)" : namespace is not ready

I'd prefer to have a single string here instead of something we might need to parse again. The sysfs docs says

Mixing types, expressing multiple lines of data, and doing fancy formatting of data is heavily frowned upon. Doing these things may get you publicly humiliated and your code rewritten without notice.

Quoted 7 lines

Something like

- optimized
- non-optimized
- ctrl-down
- ana-pending
- ns-no-ready

Would this be redundant with ana_state?

Is this OK?
    - enabled
    - ctrl-down
    - ana-pending
    - ns-not-ready

CC Keith, John, Nilay, what do you think?

Quoted 4 lines

BTW, the docs on sysfs say, these interfaces should be documented also in Documentation/ABI. So far we haven't done this for the nvme subsystem. Should we start with it?

Sure, just like the nvme-multipath.rst file I worked on earlier, I can do this later with the help of AI.

Best Regards,
Guixin Liu

#4 lore raw
Quoted 38 lines · Guixin Liu
Quoted 26 lines · Daniel Wagner
Quoted 12 lines · John Garry
Quoted 11 lines · Guixin Liu

Add a read-only "path_state" sysfs attribute to each NVMe path namespace device (/sys/class/nvme/nvmeX/nvmeXcYnZ/path_state) that exposes the current path state, including whether the path is enabled or disabled with a specific reason.

Factor the path disable checks from nvme_path_is_disabled() into a new nvme_path_get_state() helper that returns an enum nvme_path_state. This keeps the path selection logic and sysfs reporting in sync, so any future updates to the path disable criteria are automatically reflected in the sysfs output.

Quoted 6 lines
Quoted 6 lines

Possible values:
    - "enabled (optimized)"     : ANA state is optimized
    - "enabled (non-optimized)" : ANA state is not optimized
    - "disabled (ctrl_down)"    : controller is not live
    - "disabled (ana_pending)"  : ANA state change pending
    - "disabled (ns_not_ready)" : namespace is not ready

I'd prefer to have a single string here instead of something we might need to parse again. The sysfs docs says

   Mixing types, expressing multiple lines of data, and doing fancy formatting of data is heavily frowned upon. Doing these things may get you publicly humiliated and your code rewritten without notice.

Quoted 7 lines

Something like

   - optimized
   - non-optimized
   - ctrl-down
   - ana-pending
   - ns-no-ready

Would this be redundant with ana_state?

Quoted 8 lines

Is this OK?
    - enabled
    - ctrl-down
    - ana-pending
    - ns-not-ready

CC Keith, John, Nilay, what do you think?

I tend to agree with Daniel about both mixing types and reporting ana state values here as ana state is also reported separately.

The purpose of path_state is really to expose whether the path is currently eligible for path selection and, if not, why.

IMO, a simpler set of values which you suggested above should be sufficient. But lets wait if Keith has any other suggestion.

Thanks
--Nilay

author
#5 lore raw
Quoted 55 lines · Nilay Shroff
Quoted 38 lines · Guixin Liu
Quoted 26 lines · Daniel Wagner
Quoted 12 lines · John Garry
Quoted 11 lines · Guixin Liu

Add a read-only "path_state" sysfs attribute to each NVMe path namespace device (/sys/class/nvme/nvmeX/nvmeXcYnZ/path_state) that exposes the current path state, including whether the path is enabled or disabled with a specific reason.

Factor the path disable checks from nvme_path_is_disabled() into a new nvme_path_get_state() helper that returns an enum nvme_path_state. This keeps the path selection logic and sysfs reporting in sync, so any future updates to the path disable criteria are automatically reflected in the sysfs output.

Quoted 6 lines
Quoted 6 lines

Possible values:
    - "enabled (optimized)"     : ANA state is optimized
    - "enabled (non-optimized)" : ANA state is not optimized
    - "disabled (ctrl_down)"    : controller is not live
    - "disabled (ana_pending)"  : ANA state change pending
    - "disabled (ns_not_ready)" : namespace is not ready

I'd prefer to have a single string here instead of something we might need to parse again. The sysfs docs says

   Mixing types, expressing multiple lines of data, and doing fancy formatting of data is heavily frowned upon. Doing these things may get you publicly humiliated and your code rewritten without notice.

Quoted 7 lines

Something like

   - optimized
   - non-optimized
   - ctrl-down
   - ana-pending
   - ns-no-ready

Would this be redundant with ana_state?

Quoted 8 lines

Is this OK?
     - enabled
     - ctrl-down
     - ana-pending
     - ns-not-ready

CC Keith, John, Nilay, what do you think?

I tend to agree with Daniel about both mixing types and reporting ana state values here as ana state is also reported separately.

The purpose of path_state is really to expose whether the path is currently eligible for path selection and, if not, why.

Quoted 7 lines

IMO, a simpler set of values which you suggested above should be sufficient. But lets wait if Keith has any other suggestion.

Thanks
--Nilay

Hi Keith, would you have any suggestions on this?

Best Regards,
Guixin Liu

author
#6 lore raw

Hi Keith, gently ping.

Best Regards,
Guixin Liu

Quoted 70 lines · Guixin Liu
Quoted 55 lines · Nilay Shroff
Quoted 38 lines · Guixin Liu
Quoted 26 lines · Daniel Wagner
Quoted 12 lines · John Garry
Quoted 11 lines · Guixin Liu

Add a read-only "path_state" sysfs attribute to each NVMe path namespace device (/sys/class/nvme/nvmeX/nvmeXcYnZ/path_state) that exposes the current path state, including whether the path is enabled or disabled with a specific reason.

Factor the path disable checks from nvme_path_is_disabled() into a new nvme_path_get_state() helper that returns an enum nvme_path_state. This keeps the path selection logic and sysfs reporting in sync, so any future updates to the path disable criteria are automatically reflected in the sysfs output.

Quoted 6 lines
Quoted 6 lines

Possible values:
    - "enabled (optimized)"     : ANA state is optimized
    - "enabled (non-optimized)" : ANA state is not optimized
    - "disabled (ctrl_down)"    : controller is not live
    - "disabled (ana_pending)"  : ANA state change pending
    - "disabled (ns_not_ready)" : namespace is not ready

I'd prefer to have a single string here instead of something we might need to parse again. The sysfs docs says

   Mixing types, expressing multiple lines of data, and doing fancy formatting of data is heavily frowned upon. Doing these things may get you publicly humiliated and your code rewritten without notice.

Quoted 7 lines

Something like

   - optimized
   - non-optimized
   - ctrl-down
   - ana-pending
   - ns-no-ready

Would this be redundant with ana_state?

Quoted 8 lines

Is this OK?
     - enabled
     - ctrl-down
     - ana-pending
     - ns-not-ready

CC Keith, John, Nilay, what do you think?

I tend to agree with Daniel about both mixing types and reporting ana state values here as ana state is also reported separately.

The purpose of path_state is really to expose whether the path is currently eligible for path selection and, if not, why.

Quoted 7 lines

IMO, a simpler set of values which you suggested above should be sufficient. But lets wait if Keith has any other suggestion.

Thanks
--Nilay

Hi Keith, would you have any suggestions on this?

Best Regards,
Guixin Liu

author
#7 lore raw
In reply to John Garry
Quoted 83 lines · John Garry
Quoted 82 lines · Guixin Liu

Add a read-only "path_state" sysfs attribute to each NVMe path namespace device (/sys/class/nvme/nvmeX/nvmeXcYnZ/path_state) that exposes the current path state, including whether the path is enabled or disabled with a specific reason.

Factor the path disable checks from nvme_path_is_disabled() into a new nvme_path_get_state() helper that returns an enum nvme_path_state. This keeps the path selection logic and sysfs reporting in sync, so any future updates to the path disable criteria are automatically reflected in the sysfs output.

Possible values:
   - "enabled (optimized)"     : ANA state is optimized
   - "enabled (non-optimized)" : ANA state is not optimized
   - "disabled (ctrl_down)"    : controller is not live
   - "disabled (ana_pending)"  : ANA state change pending
   - "disabled (ns_not_ready)" : namespace is not ready

This gives userspace visibility into the multipath path selection state without requiring users to piece together controller state and namespace flags manually.

---
v2->v3:
- Factor path disable checks into nvme_path_get_state() helper returning enum nvme_path_state, and rebuild nvme_path_is_disabled() on top of it to keep path selection logic and sysfs reporting in sync. (Nilay Shroff)
- Distinguish "enabled (optimized)" vs "enabled (non-optimized)" based on ANA state. (Keith Busch)

v1->v2:
- Show specific disabled reason instead of just
   "disabled": "disabled (ctrl_down)",
   "disabled (ana_pending)",
   "disabled (ns_not_ready)". (Nilay Shroff)
---
  drivers/nvme/host/multipath.c | 47 ++++++++++++++++++++++++++++++----- drivers/nvme/host/nvme.h      |  1 + drivers/nvme/host/sysfs.c     |  4 ++-

  3 files changed, 45 insertions(+), 7 deletions(-)
drivers/nvme/host/multipath.c +9 -0
index e033ede953cc..2da5e9da1866 100644
@@ -288,7 +288,15 @@ void nvme_mpath_revalidate_paths(struct 
 nvme_ns_head *head)
       kblockd_schedule_work(&head->requeue_work);
   }
   -static bool nvme_path_is_disabled(struct nvme_ns *ns)
+enum nvme_path_state {
+    NVME_PATH_ENABLED_OPTIMIZED,
+    NVME_PATH_ENABLED_NONOPTIMIZED,
+    NVME_PATH_DISABLED_CTRL_DOWN,
+    NVME_PATH_DISABLED_ANA_PENDING,
+    NVME_PATH_DISABLED_NS_NOT_READY,
+};
+
+static enum nvme_path_state nvme_path_get_state(struct nvme_ns *ns)
   {
       enum nvme_ctrl_state state = nvme_ctrl_state(ns->ctrl);

  @@ -298,11 +306,20 @@ static bool nvme_path_is_disabled(struct nvme_ns *ns)
       * Otherwise it will fail immediately and return to the requeue list. */
      if (state != NVME_CTRL_LIVE && state != NVME_CTRL_DELETING) -        return true;
-    if (test_bit(NVME_NS_ANA_PENDING, &ns->flags) ||
-        !test_bit(NVME_NS_READY, &ns->flags))
-        return true;
-    return false;
+        return NVME_PATH_DISABLED_CTRL_DOWN;
+    if (test_bit(NVME_NS_ANA_PENDING, &ns->flags))
+        return NVME_PATH_DISABLED_ANA_PENDING;
+    if (!test_bit(NVME_NS_READY, &ns->flags))
+        return NVME_PATH_DISABLED_NS_NOT_READY;
+    if (nvme_ctrl_use_ana(ns->ctrl) &&
+        ns->ana_state != NVME_ANA_OPTIMIZED)
+        return NVME_PATH_ENABLED_NONOPTIMIZED;

Quoted 9 lines

drivers/nvme/host/multipath.c static bool nvme_path_is_disabled(struct nvme_ns *ns) · line 322

Quoted 6 lines

+    return NVME_PATH_ENABLED_OPTIMIZED;

drivers/nvme/host/multipath.c +5 -0
+}
+
+static bool nvme_path_is_disabled(struct nvme_ns *ns)
+{
+    return nvme_path_get_state(ns) > NVME_PATH_ENABLED_NONOPTIMIZED;

I don't think that this is a particularly robust programming style, since nothing in enum nvme_path_state explicitly states that a very specific ordering or grouping is required

I think so, should add NVME_PATH_DISABLED_FIRST to identify the start of the disabled state.

Quoted 15 lines

drivers/nvme/host/multipath.c static ssize_t queue_depth_show(struct device · line 1126

Quoted 13 lines

  }
    static struct nvme_ns *__nvme_find_path(struct nvme_ns_head *head, int node)

drivers/nvme/host/multipath.c +5 -0
@@ -1101,6 +1118,24 @@ static ssize_t queue_depth_show(struct device 
 *dev,
   }
   DEVICE_ATTR_RO(queue_depth);
   +static const char * const nvme_path_state_names[] = {
+    [NVME_PATH_ENABLED_OPTIMIZED]        = "enabled (optimized)",
+    [NVME_PATH_ENABLED_NONOPTIMIZED]    = "enabled (non-optimized)",
+    [NVME_PATH_DISABLED_CTRL_DOWN]        = "disabled (ctrl_down)",
+    [NVME_PATH_DISABLED_ANA_PENDING]    = "disabled (ana_pending)",
+    [NVME_PATH_DISABLED_NS_NOT_READY]    = "disabled (ns_not_ready)",

some strings are abbreviated and some aren't

  "enabled (optimized)"
  "enabled (non-optimized)"
  "disabled (controller down)"
  "disabled (ana pending)"
  "disabled (namespace not ready)"
is this OK?

Quoted 12 lines

drivers/nvme/host/multipath.c static ssize_t queue_depth_show(struct device *dev, · line 1135

Quoted 10 lines
drivers/nvme/host/multipath.c +9 -0
+};
+
+static ssize_t path_state_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+    struct nvme_ns *ns = nvme_get_ns_from_dev(dev);
+
+    return sysfs_emit(buf, "%s\n",
+ nvme_path_state_names[nvme_path_get_state(ns)]);

you should really check that nvme_path_get_state(ns) does not exceed indexing into ARRAY_SIZE(nvme_path_state_names)

Changed in v4, thanks.

Best Regards,
Guixin Liu