Support printing the runlist and channels on Ampere+ GPUs

**Modifes the user API from `cat /proc/gpuX/runlist0` to
`cat /proc/gpuX/runlist0/runlist` to support runlist-scoped
registers**

- Count number of runlists via Ampere-style PTOP parsing.
- Create a ProcFS directory for each runlist, and create the runlist
  printing file in this directory.
- Document the newly-added/-formatted Runlist RAM and Channel RAM
  registers.
- Add a helper function `get_runlist_ram()` to obtain the location
  of each runlist's registers.
- Support printing Ampere-style Channel RAM entries.

Tested on Jetson Orin (ga10b), A100, H100, and AD102 (RTX 6000 Ada)

1 files changed, 55 insertions, 22 deletions

diff --git a/nvdebug_entry.c b/nvdebug_entry.c
index eee7351..1f9e1c9 100644
--- a/nvdebug_entry.c
+++ b/nvdebug_entry.c
@@ -159,35 +159,53 @@ int probe_and_cache_devices(void) {
         return -ENODEV;
 }
 
-// Create files `/proc/gpu#/runlist#`, world readable
 // Support: Fermi, Maxwell, Pascal, Volta, Turing
-int create_runlist_files(int device_id, struct proc_dir_entry *dir) {
+int get_last_runlist_id_gk104(struct nvdebug_state *g) {
         ptop_device_info_gk104_t info;
-        struct proc_dir_entry *rl_entry;
-        int i, rl_id;
-        char runlist_name[12];
-        int max_rl_id = 0; // Always at least one runlist
+        int i, max_rl_id = 0; // Always at least one runlist
         // Figure out how many runlists there are by checking the device info
         // registers. Runlists are always numbered sequentially, so we just have
         // to find the highest-valued one and add 1 to get the number of runlists.
         for (i = 0; i < NV_PTOP_DEVICE_INFO__SIZE_1_GK104; i++) {
-                info.raw = nvdebug_readl(&g_nvdebug_state[device_id], NV_PTOP_DEVICE_INFO_GK104(i));
+                if ((info.raw = nvdebug_readl(g, NV_PTOP_DEVICE_INFO_GK104(i))) == -1)
+                        return -EIO;
                 if (info.info_type != INFO_TYPE_ENUM || !info.runlist_is_valid)
                         continue;
                 if (info.runlist_enum > max_rl_id)
                         max_rl_id = info.runlist_enum;
         }
-        // Create files to read each runlist. The read handling code looks at the
-        // `pde_data` associated with the file to determine what the runlist ID is.
-        for (rl_id = 0; rl_id <= max_rl_id; rl_id++) {
-                snprintf(runlist_name, 12, "runlist%d", rl_id);
-                rl_entry = proc_create_data(
-                        runlist_name, 0444, dir, compat_ops(&runlist_file_ops),
-                        (void*)(uintptr_t)rl_id);
-                if (!rl_entry)
-                        return -ENOMEM;
+        return max_rl_id;
+}
+
+// Support: Ampere, Hopper, Ada (and newer likely)
+// Identical structure to get_runlist_ram() in runlist.c. See comments there.
+int get_last_runlist_id_ga100(struct nvdebug_state *g) {
+        ptop_device_info_ga100_t ptop_entry;
+        int i, runlist_count = 0;
+        int ptop_size = NV_PTOP_DEVICE_INFO__SIZE_1_GA100(g);
+        int ptop_entry_subrow = 0;
+        for (i = 0; i < ptop_size; i++) {
+                if ((ptop_entry.raw = nvdebug_readl(g, NV_PTOP_DEVICE_INFO_GA100(i))) == -1)
+                        return -EIO;
+                if (!ptop_entry.raw)
+                        continue;
+                if (ptop_entry_subrow == 2 && ptop_entry.rleng_id == 0)
+                        runlist_count++;
+                if (ptop_entry.has_next_entry)
+                        ptop_entry_subrow += 1;
+                else
+                        ptop_entry_subrow = 0;
         }
-        return 0;
+        return runlist_count - 1;
+}
+
+// Return the maximum runlist ID. For a two-runlist GPU, this would return 1.
+int get_last_runlist_id(int device_id) {
+        struct nvdebug_state* g = &g_nvdebug_state[device_id];
+        if (g->chip_id >= NV_CHIP_ID_AMPERE)
+                return get_last_runlist_id_ga100(g);
+        else
+                return get_last_runlist_id_gk104(g);
 }
 
 // Create files `/proc/gpu#/gpc#_tpc_mask`, world readable
@@ -238,6 +256,7 @@ int __init nvdebug_init(void) {
         g_nvdebug_devices = res;
         // Create seperate ProcFS directories for each gpu
         while (res--) {
+                uintptr_t last_runlist = 0;
                 char device_id_str[7];
                 // Create a wider copy of the GPU ID to allow us to abuse the *data
                 // field of proc_dir_entry to store the GPU ID.
@@ -248,10 +267,24 @@ int __init nvdebug_init(void) {
                 snprintf(device_id_str, 7, "gpu%ld", device_id);
                 if (!(dir = proc_mkdir_data(device_id_str, 0555, NULL, (void*)device_id)))
                         goto out_nomem;
-                // Create files `/proc/gpu#/runlist#`, world readable
-                if (g_nvdebug_state[device_id].chip_id < NV_CHIP_ID_AMPERE)
-                        if ((err = create_runlist_files(device_id, dir)))
-                                goto out_err;
+                // Create files in the `/proc/gpu#/runlist#/` directory
+                // The read handling code looks at the `pde_data` associated with the parent
+                // directory to determine what the runlist ID is.
+                if ((last_runlist = get_last_runlist_id(device_id)) < 0)
+                        return last_runlist;
+                do {
+                        char runlist_name[12];
+                        struct proc_dir_entry *rl_dir;
+                        // Create `/proc/gpu#/runlist#` directory
+                        snprintf(runlist_name, 12, "runlist%lu", last_runlist);
+                        if (!(rl_dir = proc_mkdir_data(runlist_name, 0555, dir, (void*)device_id)))
+                                goto out_nomem;
+                        // Create file `/proc/gpu#/runlist#/runlist`, world readable
+                        if (!proc_create_data(
+                                        "runlist", 0444, rl_dir, compat_ops(&runlist_file_ops),
+                                        (void*)last_runlist))
+                                goto out_nomem;
+                } while (last_runlist-- > 0);
                 // Create file `/proc/gpu#/preempt_tsg`, world writable
                 if (!proc_create_data(
                                 "preempt_tsg", 0222, dir, compat_ops(&preempt_tsg_file_ops),
@@ -325,7 +358,7 @@ int __init nvdebug_init(void) {
                                         "local_memory", 0444, dir, compat_ops(&local_memory_file_ops),
                                         (void*)0x00100ce0))
                                 goto out_nomem;
-                        }
+                }
                 // Create files exposing LCE and PCE configuration (Pascal+)
                 if (g_nvdebug_state[res].chip_id >= NV_CHIP_ID_PASCAL) {
                         // Create file `/proc/gpu#/copy_topology`, world readable