feat: add per-CPU topology and the global huge-page pool

    /sys/devices/system/cpu/cpuN/online
    /sys/devices/system/cpu/cpuN/topology/{core_id,physical_package_id,
                                           thread_siblings_list,core_siblings_list}
    /sys/kernel/mm/hugepages/hugepages-2048kB/{nr_,free_,surplus_,resv_,
                                               nr_overcommit_}hugepages

The cpuN directories are created statically at mount rather than expanded
dynamically: macOS never hot-plugs a core, so the logical CPU count is fixed for
the life of the boot and there is nothing to expand. Each node carries its CPU
number in the new sfssnode ssn_instance field, so one handler serves every cpuN
instead of needing a function per CPU.

Topology is derived rather than assumed. Every Mac is single-socket, so
physical_package_id is 0 and core_siblings_list is every CPU. core_id and
thread_siblings_list come from hw.logicalcpu_max against hw.physicalcpu_max: with
no SMT (Apple Silicon) each CPU is its own core and its own sibling list, and
with Hyper-Threading the consecutive threads sharing a core are reported as a
range.

/sys/kernel/mm/hugepages carries the two counters that are global-only on Linux
(reservations and the overcommit limit) alongside the three the per-node
directories already had. All read 0: macOS has no hugetlb pool to size, reserve
or overcommit.

Builds clean for arm64e, x86_64 and universal.

Author: somestupidgirl

include/fs/sysfs/sysfs.h

@@ -218,6 +218,14 @@ struct sfssnode {
     sfsbaseid_t                       ssn_base_node_id;   /* Base node id - unique. */
     uint16_t                          ssn_flags;          /* Flags - SSN_FLAG_* */
 
+    /*
+     * Which instance of a repeated node this is - the CPU number under
+     * /sys/devices/system/cpu/cpuN, for example. Lets one read handler serve a
+     * whole family of otherwise identical static nodes without a separate
+     * function per instance. Zero for nodes that are not part of such a family.
+     */
+    uint32_t                          ssn_instance;
+
     /*
      * Structure linkage. Immutable once set.
      */
@@ -454,6 +462,23 @@ extern int sysfs_do_node_numastat(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
 extern int sysfs_do_node_list(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
 extern int sysfs_do_cpu_kernel_max(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
 
+/*
+ * Per-CPU nodes (/sys/devices/system/cpu/cpuN/...). These serve every cpuN from
+ * one handler, taking the CPU number from the structure node's ssn_instance.
+ */
+extern int sysfs_do_cpu_online(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
+extern int sysfs_do_cpu_package_id(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
+extern int sysfs_do_cpu_core_id(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
+extern int sysfs_do_cpu_thread_siblings(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
+extern int sysfs_do_cpu_core_siblings(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
+
+/*
+ * Number of logical CPUs, for building the per-CPU tree at mount time. macOS
+ * never hot-plugs a core, so the count is fixed for the life of the boot and the
+ * cpuN directories can be created statically.
+ */
+extern uint32_t sysfs_cpu_count(void);
+
 #endif /* __FSBUNDLE__ */
 
 #endif /* sysfs_h */

kext/sysfs_structure.c

@@ -23,6 +23,7 @@
 #include <string.h>
 #include <kern/assert.h>
 #include <kern/debug.h>
+#include <libkern/libkern.h>
 #include <libkern/OSMalloc.h>
 #include <mach/boolean.h>
 #include <sys/vnode.h>
@@ -50,6 +51,13 @@ STATIC void release_node(sfssnode_t *root);
  */
 #define SYSFS_RELEASE_STACK_MAX 256
 
+/*
+ * Upper bound on generated /sys/devices/system/cpu/cpuN directories. The static
+ * tree is torn down through release_node()'s fixed-size stack, so the number of
+ * nodes the CPU loop can add has to stay well inside that bound.
+ */
+#define SYSFS_MAX_CPU_NODES 64
+
 /*
  * Next node id. No need to lock this value because access is guaranteed to be
  * single-threaded. Start at 2 because the root node is always 1.
@@ -206,12 +214,77 @@ sysfs_structure_init(void)
         add_file(cpu_dir, "present",    next_node_id++, 0, 0, NULL, sysfs_do_cpulist);
         add_file(cpu_dir, "offline",    next_node_id++, 0, 0, NULL, sysfs_do_zero_count);
         add_file(cpu_dir, "kernel_max", next_node_id++, 0, 0, NULL, sysfs_do_cpu_kernel_max);
+
+        /*
+         * cpu/cpuN/ with its topology. These are created statically, one per
+         * logical CPU, because macOS never hot-plugs a core: the count is fixed
+         * for the life of the boot, so there is nothing to expand dynamically.
+         * Each node carries its CPU number in ssn_instance, which is how one
+         * handler serves every cpuN.
+         */
+        uint32_t ncpu = sysfs_cpu_count();
+        for (uint32_t c = 0; c < ncpu && c < SYSFS_MAX_CPU_NODES; c++) {
+            char cpuname[MAX_STRUCT_NODE_NAME_LEN];
+            snprintf(cpuname, sizeof(cpuname), "cpu%u", c);
+
+            sfssnode_t *cpuN = add_directory(cpu_dir, cpuname,
+                            SFSdir, next_node_id++, 0, 0, NULL, NULL);
+            cpuN->ssn_instance = c;
+
+            sfssnode_t *f = add_file(cpuN, "online", next_node_id++, 0, 0,
+                            NULL, sysfs_do_cpu_online);
+            f->ssn_instance = c;
+
+            sfssnode_t *topo = add_directory(cpuN, "topology",
+                            SFSdir, next_node_id++, 0, 0, NULL, NULL);
+            topo->ssn_instance = c;
+
+            f = add_file(topo, "core_id", next_node_id++, 0, 0,
+                            NULL, sysfs_do_cpu_core_id);
+            f->ssn_instance = c;
+            f = add_file(topo, "physical_package_id", next_node_id++, 0, 0,
+                            NULL, sysfs_do_cpu_package_id);
+            f->ssn_instance = c;
+            f = add_file(topo, "thread_siblings_list", next_node_id++, 0, 0,
+                            NULL, sysfs_do_cpu_thread_siblings);
+            f->ssn_instance = c;
+            f = add_file(topo, "core_siblings_list", next_node_id++, 0, 0,
+                            NULL, sysfs_do_cpu_core_siblings);
+            f->ssn_instance = c;
+        }
+
         (void)add_directory(root_node, "firmware",   SFSdir, next_node_id++, 0, 0, NULL, NULL);
         (void)add_directory(root_node, "fs",         SFSdir, next_node_id++, 0, 0, NULL, NULL);
         (void)add_directory(root_node, "hypervisor", SFSdir, next_node_id++, 0, 0, NULL, NULL);
-        (void)add_directory(root_node, "kernel",     SFSdir, next_node_id++, 0, 0, NULL, NULL);
+        sfssnode_t *kernel_dir =
+            add_directory(root_node, "kernel",     SFSdir, next_node_id++, 0, 0, NULL, NULL);
         (void)add_directory(root_node, "module",     SFSdir, next_node_id++, 0, 0, NULL, NULL);
         (void)add_directory(root_node, "power",      SFSdir, next_node_id++, 0, 0, NULL, NULL);
+
+        /*
+         * /sys/kernel/mm/hugepages/hugepages-2048kB/ - the system-wide huge-page
+         * pool, the counterpart to the per-node counters above. Linux exposes two
+         * extra knobs here that have no per-node equivalent (reservations and the
+         * overcommit limit); like the rest they are 0, because macOS has no
+         * hugetlb pool to reserve from or overcommit.
+         */
+        sfssnode_t *mm_dir = add_directory(kernel_dir, "mm",
+                        SFSdir, next_node_id++, 0, 0, NULL, NULL);
+        sfssnode_t *mm_hp_dir = add_directory(mm_dir, "hugepages",
+                        SFSdir, next_node_id++, 0, 0, NULL, NULL);
+        sfssnode_t *mm_hp_2m = add_directory(mm_hp_dir, "hugepages-2048kB",
+                        SFSdir, next_node_id++, 0, 0, NULL, NULL);
+
+        add_file(mm_hp_2m, "nr_hugepages", next_node_id++, 0,
+                        SYSFS_ZERO_COUNT_LEN, NULL, sysfs_do_zero_count);
+        add_file(mm_hp_2m, "free_hugepages", next_node_id++, 0,
+                        SYSFS_ZERO_COUNT_LEN, NULL, sysfs_do_zero_count);
+        add_file(mm_hp_2m, "surplus_hugepages", next_node_id++, 0,
+                        SYSFS_ZERO_COUNT_LEN, NULL, sysfs_do_zero_count);
+        add_file(mm_hp_2m, "resv_hugepages", next_node_id++, 0,
+                        SYSFS_ZERO_COUNT_LEN, NULL, sysfs_do_zero_count);
+        add_file(mm_hp_2m, "nr_overcommit_hugepages", next_node_id++, 0,
+                        SYSFS_ZERO_COUNT_LEN, NULL, sysfs_do_zero_count);
     }
 }
 

kext/sysfs_system.c

@@ -53,6 +53,15 @@ sysfs_ncpu(void)
     return (uint32_t)ncpu;
 }
 
+/*
+ * Public form of the above, for building the per-CPU tree at mount time.
+ */
+uint32_t
+sysfs_cpu_count(void)
+{
+    return sysfs_ncpu();
+}
+
 /*
  * Total physical memory in bytes.
  */
@@ -208,6 +217,106 @@ sysfs_do_node_list(__unused sfsnode_t *snp, uio_t uio, __unused vfs_context_t ct
     return sysfs_copy_data(node0, (int)(sizeof(node0) - 1), uio);
 }
 
+/*
+ * How many logical CPUs share one physical core. Apple Silicon has no SMT, so
+ * this is 1; an Intel Mac with Hyper-Threading reports 2.
+ */
+static uint32_t
+sysfs_threads_per_core(void)
+{
+    int phys = 0;
+    size_t len = sizeof(phys);
+    uint32_t ncpu = sysfs_ncpu();
+
+    if (sysctlbyname("hw.physicalcpu_max", &phys, &len, NULL, 0) != 0 || phys <= 0) {
+        return 1;
+    }
+    if ((uint32_t)phys >= ncpu) {
+        return 1;
+    }
+    return ncpu / (uint32_t)phys;
+}
+
+/*
+ * The CPU number a per-CPU node stands for, carried on the structure node so one
+ * handler can serve every cpuN.
+ */
+static uint32_t
+sysfs_node_cpu(sfsnode_t *snp)
+{
+    return snp->node_structure_node->ssn_instance;
+}
+
+/*
+ * cpuN/online. macOS never offlines a core, so every CPU that exists is online.
+ */
+int
+sysfs_do_cpu_online(__unused sfsnode_t *snp, uio_t uio, __unused vfs_context_t ctx)
+{
+    static const char one[] = "1\n";
+
+    return sysfs_copy_data(one, (int)(sizeof(one) - 1), uio);
+}
+
+/*
+ * cpuN/topology/physical_package_id. Every Mac is single-socket, so every CPU is
+ * in package 0.
+ */
+int
+sysfs_do_cpu_package_id(__unused sfsnode_t *snp, uio_t uio, __unused vfs_context_t ctx)
+{
+    static const char pkg[] = "0\n";
+
+    return sysfs_copy_data(pkg, (int)(sizeof(pkg) - 1), uio);
+}
+
+/*
+ * cpuN/topology/core_id - which physical core this logical CPU sits on. Without
+ * SMT that is the CPU number itself; with Hyper-Threading the sibling threads of
+ * a core are consecutive, so dividing by the thread count gives the core.
+ */
+int
+sysfs_do_cpu_core_id(sfsnode_t *snp, uio_t uio, __unused vfs_context_t ctx)
+{
+    char buf[SYSFS_SYSTEM_BUFMAX];
+    uint32_t cpu = sysfs_node_cpu(snp);
+    uint32_t tpc = sysfs_threads_per_core();
+    int len = snprintf(buf, sizeof(buf), "%u\n", cpu / tpc);
+
+    return sysfs_copy_data(buf, len, uio);
+}
+
+/*
+ * cpuN/topology/thread_siblings_list - the logical CPUs sharing this core. Just
+ * this CPU without SMT; the consecutive run covering the core when SMT is on.
+ */
+int
+sysfs_do_cpu_thread_siblings(sfsnode_t *snp, uio_t uio, __unused vfs_context_t ctx)
+{
+    char buf[SYSFS_SYSTEM_BUFMAX];
+    uint32_t cpu = sysfs_node_cpu(snp);
+    uint32_t tpc = sysfs_threads_per_core();
+    int len;
+
+    if (tpc <= 1) {
+        len = snprintf(buf, sizeof(buf), "%u\n", cpu);
+    } else {
+        uint32_t first = (cpu / tpc) * tpc;
+        len = snprintf(buf, sizeof(buf), "%u-%u\n", first, first + tpc - 1);
+    }
+    return sysfs_copy_data(buf, len, uio);
+}
+
+/*
+ * cpuN/topology/core_siblings_list - the logical CPUs sharing this package.
+ * Single-socket, so that is every CPU.
+ */
+int
+sysfs_do_cpu_core_siblings(__unused sfsnode_t *snp, uio_t uio, vfs_context_t ctx)
+{
+    return sysfs_do_cpulist(snp, uio, ctx);
+}
+
 /*
  * cpu/kernel_max - the largest CPU index the kernel could ever use. Linux
  * reports NR_CPUS-1; the analogous bound here is the maximum logical CPU count.