[PATCHv3 5/9] libnvme: add support for retrieving namespace gendisk I/O statistics

[Nilay Shroff <nilay@linux.ibm.com>]

Gendisk I/O statistics provide useful insight into disk activity,
including read/write/discard/flush operations, as well as information
about in-flight I/Os and I/O timing.

Parsing these statistics allows users to determine the number of I/Os
processed, time spent servicing I/O, number of sectors accessed, and
the count of in-flight requests.

Add support for retrieving namespace gendisk I/O statistics. Also add
support for computing deltas of these statistics between samples, such
as I/O ticks, number of sectors, and number of serviced I/Os.

These metrics can be used by tools such as nvme-top to display real-time
disk activity.

Signed-off-by: Nilay Shroff <nilay@linux.ibm.com>
---
 libnvme/src/libnvme.ld     |  11 +++
 libnvme/src/nvme/private.h |   5 ++
 libnvme/src/nvme/tree.c    | 142 +++++++++++++++++++++++++++++++++++++
 libnvme/src/nvme/tree.h    |  93 ++++++++++++++++++++++++
 4 files changed, 251 insertions(+)

diff --git a/libnvme/src/libnvme.ld b/libnvme/src/libnvme.ld
index 6b7a08cb5..ce85c960e 100644
--- a/libnvme/src/libnvme.ld
+++ b/libnvme/src/libnvme.ld
@@ -129,6 +129,17 @@ LIBNVME_3 {
 		libnvme_ns_get_serial;
 		libnvme_ns_get_subsystem;
 		libnvme_ns_get_uuid;
+		libnvme_ns_reset_stat;
+		libnvme_ns_update_stat;
+		libnvme_ns_get_stat_interval;
+		libnvme_ns_get_read_ios;
+		libnvme_ns_get_write_ios;
+		libnvme_ns_get_read_ticks;
+		libnvme_ns_get_write_ticks;
+		libnvme_ns_get_read_sectors;
+		libnvme_ns_get_write_sectors;
+		libnvme_ns_get_inflights;
+		libnvme_ns_get_io_ticks;
 		libnvme_ns_identify;
 		libnvme_ns_read;
 		libnvme_ns_verify;
diff --git a/libnvme/src/nvme/private.h b/libnvme/src/nvme/private.h
index 818303d85..08b35e002 100644
--- a/libnvme/src/nvme/private.h
+++ b/libnvme/src/nvme/private.h
@@ -227,6 +227,11 @@ struct libnvme_ns { // !generate-accessors
 	struct libnvme_ns_head *head;
 
 	struct libnvme_global_ctx *ctx;
+
+	struct libnvme_stat stat[2];	/* gendisk I/O stat */
+	unsigned int curr_idx;		/* current index into the stat[] */
+	bool diffstat; //!accessors:none
+
 	struct libnvme_transport_handle *hdl;
 	__u32 nsid;
 	char *name;
diff --git a/libnvme/src/nvme/tree.c b/libnvme/src/nvme/tree.c
index 6a05ae994..ca716bde7 100644
--- a/libnvme/src/nvme/tree.c
+++ b/libnvme/src/nvme/tree.c
@@ -900,6 +900,21 @@ __public void libnvme_path_reset_stat(libnvme_path_t p)
 	memset(stat, 0, 2 * sizeof(struct libnvme_stat));
 }
 
+static libnvme_stat_t libnvme_ns_get_stat(libnvme_ns_t n, unsigned int idx)
+{
+	if (idx > 1)
+		return NULL;
+
+	return &n->stat[idx];
+}
+
+__public void libnvme_ns_reset_stat(libnvme_ns_t n)
+{
+	libnvme_stat_t stat = &n->stat[0];
+
+	memset(stat, 0, 2 * sizeof(struct libnvme_stat));
+}
+
 static int libnvme_update_stat(const char *sysfs_stat_path, libnvme_stat_t stat)
 {
 	int n;
@@ -974,6 +989,24 @@ __public int libnvme_path_update_stat(libnvme_path_t p, bool diffstat)
 	return libnvme_update_stat(sysfs_stat_path, stat);
 }
 
+__public int libnvme_ns_update_stat(libnvme_ns_t n, bool diffstat)
+{
+	__cleanup_free char *sysfs_stat_path = NULL;
+	libnvme_stat_t stat;
+
+	n->diffstat = diffstat;
+	n->curr_idx ^= 1;
+	stat = libnvme_ns_get_stat(n, n->curr_idx);
+	if (!stat)
+		return -EINVAL;
+
+	sysfs_stat_path = libnvme_get_ns_attr(n, "stat");
+	if (!sysfs_stat_path)
+		return -EINVAL;
+
+	return libnvme_update_stat(sysfs_stat_path, stat);
+}
+
 static int libnvme_stat_get_inflights(libnvme_stat_t stat)
 {
 	return stat->inflights;
@@ -990,6 +1023,17 @@ __public unsigned int libnvme_path_get_inflights(libnvme_path_t p)
 	return libnvme_stat_get_inflights(curr);
 }
 
+__public unsigned int libnvme_ns_get_inflights(libnvme_ns_t n)
+{
+	libnvme_stat_t curr;
+
+	curr = libnvme_ns_get_stat(n, n->curr_idx);
+	if (!curr)
+		return 0;
+
+	return libnvme_stat_get_inflights(curr);
+}
+
 static int libnvme_stat_get_io_ticks(libnvme_stat_t curr, libnvme_stat_t prev,
 		bool diffstat)
 {
@@ -1017,6 +1061,19 @@ __public unsigned int libnvme_path_get_io_ticks(libnvme_path_t p)
 	return libnvme_stat_get_io_ticks(curr, prev, p->diffstat);
 }
 
+__public unsigned int libnvme_ns_get_io_ticks(libnvme_ns_t n)
+{
+	libnvme_stat_t curr, prev;
+
+	curr = libnvme_ns_get_stat(n, n->curr_idx);
+	prev = libnvme_ns_get_stat(n, !n->curr_idx);
+
+	if (!curr || !prev)
+		return 0;
+
+	return libnvme_stat_get_io_ticks(curr, prev, n->diffstat);
+}
+
 static unsigned int libnvme_stat_get_ticks(libnvme_stat_t curr,
 		libnvme_stat_t prev, enum libnvme_stat_group grp, bool diffstat)
 {
@@ -1055,6 +1112,30 @@ __public unsigned int libnvme_path_get_write_ticks(libnvme_path_t p)
 	return __libnvme_path_get_ticks(p, WRITE);
 }
 
+static unsigned int __libnvme_ns_get_ticks(libnvme_ns_t n,
+		enum libnvme_stat_group grp)
+{
+	libnvme_stat_t curr, prev;
+
+	curr = libnvme_ns_get_stat(n, n->curr_idx);
+	prev = libnvme_ns_get_stat(n, !n->curr_idx);
+
+	if (!curr || !prev)
+		return 0;
+
+	return libnvme_stat_get_ticks(curr, prev, grp, n->diffstat);
+}
+
+__public unsigned int libnvme_ns_get_read_ticks(libnvme_ns_t n)
+{
+	return __libnvme_ns_get_ticks(n, READ);
+}
+
+__public unsigned int libnvme_ns_get_write_ticks(libnvme_ns_t n)
+{
+	return __libnvme_ns_get_ticks(n, WRITE);
+}
+
 static double libnvme_stat_get_interval(libnvme_stat_t curr,
 		libnvme_stat_t prev)
 {
@@ -1079,6 +1160,19 @@ __public double libnvme_path_get_stat_interval(libnvme_path_t p)
 	return libnvme_stat_get_interval(curr, prev);
 }
 
+__public double libnvme_ns_get_stat_interval(libnvme_ns_t n)
+{
+	libnvme_stat_t curr, prev;
+
+	curr = libnvme_ns_get_stat(n, n->curr_idx);
+	prev = libnvme_ns_get_stat(n, !n->curr_idx);
+
+	if (!curr || !prev)
+		return 0;
+
+	return libnvme_stat_get_interval(curr, prev);
+}
+
 static unsigned long libnvme_stat_get_ios(libnvme_stat_t curr,
 		libnvme_stat_t prev, enum libnvme_stat_group grp, bool diffstat)
 {
@@ -1117,6 +1211,30 @@ __public unsigned long libnvme_path_get_write_ios(libnvme_path_t p)
 	return __libnvme_path_get_ios(p, WRITE);
 }
 
+static unsigned long __libnvme_ns_get_ios(libnvme_ns_t n,
+		enum libnvme_stat_group grp)
+{
+	libnvme_stat_t curr, prev;
+
+	curr = libnvme_ns_get_stat(n, n->curr_idx);
+	prev = libnvme_ns_get_stat(n, !n->curr_idx);
+
+	if (!curr || !prev)
+		return 0;
+
+	return libnvme_stat_get_ios(curr, prev, grp, n->diffstat);
+}
+
+__public unsigned long libnvme_ns_get_read_ios(libnvme_ns_t n)
+{
+	return __libnvme_ns_get_ios(n, READ);
+}
+
+__public unsigned long libnvme_ns_get_write_ios(libnvme_ns_t n)
+{
+	return __libnvme_ns_get_ios(n, WRITE);
+}
+
 static unsigned long long libnvme_stat_get_sectors(libnvme_stat_t curr,
 		libnvme_stat_t prev, enum libnvme_stat_group grp, bool diffstat)
 {
@@ -1155,6 +1273,30 @@ __public unsigned long long libnvme_path_get_write_sectors(libnvme_path_t p)
 	return __libnvme_path_get_sectors(p, WRITE);
 }
 
+static unsigned long long __libnvme_ns_get_sectors(libnvme_ns_t n,
+		enum libnvme_stat_group grp)
+{
+	libnvme_stat_t curr, prev;
+
+	curr = libnvme_ns_get_stat(n, n->curr_idx);
+	prev = libnvme_ns_get_stat(n, !n->curr_idx);
+
+	if (!curr || !prev)
+		return 0;
+
+	return libnvme_stat_get_sectors(curr, prev, grp, n->diffstat);
+}
+
+__public unsigned long long libnvme_ns_get_read_sectors(libnvme_ns_t n)
+{
+	return __libnvme_ns_get_sectors(n, READ);
+}
+
+__public unsigned long long libnvme_ns_get_write_sectors(libnvme_ns_t n)
+{
+	return __libnvme_ns_get_sectors(n, WRITE);
+}
+
 void nvme_free_path(struct libnvme_path *p)
 {
 	if (!p)
diff --git a/libnvme/src/nvme/tree.h b/libnvme/src/nvme/tree.h
index b46c3c4c2..a166d9df6 100644
--- a/libnvme/src/nvme/tree.h
+++ b/libnvme/src/nvme/tree.h
@@ -853,6 +853,99 @@ libnvme_subsystem_t libnvme_ctrl_get_subsystem(libnvme_ctrl_t c);
  */
 const char *libnvme_ns_head_get_sysfs_dir(libnvme_ns_head_t head);
 
+/**
+ * libnvme_ns_update_stat() - update the nvme namespace stat
+ * @n:		&libnvme_ns_t object
+ * @diffstat:	If set to true then getters return the diff stat otherwise
+ *		return the current absolute stat
+ *
+ * Returns:	0 on success, -1 on error
+ */
+int libnvme_ns_update_stat(libnvme_ns_t n, bool diffstat);
+
+/**
+ * libnvme_ns_reset_stat() - Resets nvme namespace stat
+ * @n:	&libnvme_ns_t object
+ *
+ */
+void libnvme_ns_reset_stat(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_inflights() - Inflight IOs for nvme_ns_t object
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Inflight number of IOs
+ */
+unsigned int libnvme_ns_get_inflights(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_io_ticks() - Get IO ticks
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Time consumed, in milliseconds, processing I/O requests between
+ *		two stat samples
+ */
+unsigned int libnvme_ns_get_io_ticks(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_read_ticks() - Get read I/O ticks
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Time, in milliseconds, sepnt processing read I/O requests
+ *		between two stat samples
+ */
+unsigned int libnvme_ns_get_read_ticks(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_write_ticks() - Get write I/O ticks
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Time, in milliseconds, sepnt processing write I/O requests
+ *		between two stat samples
+ */
+unsigned int libnvme_ns_get_write_ticks(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_stat_interval() - Get interval between two stat samples
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Interval, in milliseconds, between collection of two consecutive
+ *		stat samples
+ */
+double libnvme_ns_get_stat_interval(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_read_ios() - Get num of read I/Os
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Num of read IOs processed between two stat samples
+ */
+unsigned long libnvme_ns_get_read_ios(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_write_ios() - Get num of write I/Os
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Num of write IOs processed between two consecutive stat samples
+ */
+unsigned long libnvme_ns_get_write_ios(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_read_sectors() - Get num of read sectors
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Num of sectors read from the device between two stat samples
+ */
+unsigned long long libnvme_ns_get_read_sectors(libnvme_ns_t n);
+
+/**
+ * libnvme_ns_get_write_sectors() - Get num of write sectors
+ * @n:		&libnvme_ns_t object
+ *
+ * Return:	Num of sectors written to the device between two stat samples
+ */
+unsigned long long libnvme_ns_get_write_sectors(libnvme_ns_t n);
+
 /**
  * libnvme_ctrl_identify() - Issues an 'identify controller' command
  * @c:	Controller instance
-- 
2.53.0