feat: add /sys/devices/system/node/node0/hugepages

Expose the Linux per-NUMA-node huge-page attributes:

    /sys/devices/system/node/node0/hugepages/hugepages-2048kB/
        nr_hugepages, free_hugepages, surplus_hugepages

/sys/devices/system is synthetic on Linux too - it describes CPUs, memory and
NUMA nodes rather than discovered hardware - so it is built as static structure
nodes rather than as part of the IOKit mirror. The SFSdevice lookup and readdir
paths now consult static children alongside registry ones, but only at the
/sys/devices root (registry id 0), where they take precedence so a device named
"system" cannot shadow the hierarchy. Below that, ordinary static handling
applies.

macOS is not NUMA, so there is exactly one node. The huge-page size is 2MB on
both Apple Silicon and Intel (the architectural large-page size; base pages are
16KB and 4KB respectively). All three counters read 0: macOS has no hugetlb
pool - large pages are managed transparently by the VM, with nothing to size,
reserve or overcommit - which is exactly what a Linux host reports when no huge
pages are configured. Per-node directories carry these three files only;
resv_/nr_overcommit_ are global to /sys/kernel/mm/hugepages.

This is the first node in the filesystem with real content, so it also adds the
add_file() structure helper and the first read handler (kext/sysfs_system.c).

Builds clean for arm64e, x86_64 and universal.

Author: somestupidgirl

include/fs/sysfs/sysfs.h

@@ -430,6 +430,16 @@ extern uint64_t   sysfs_get_fileid(uint64_t regid, uint64_t objectid, sfsbaseid_
 extern int        sysfs_atoi(const char *p, const char **end_ptr);
 extern size_t     sysfs_get_node_size_attr(sfsnode_t *snp, kauth_cred_t creds);
 
+/*
+ * Content for /sys/devices/system (sysfs_system.c).
+ *
+ * sysfs_do_zero_count renders an always-zero counter as Linux renders a sysfs
+ * integer attribute ("0\n"); SYSFS_ZERO_COUNT_LEN is the length it produces, so
+ * a node using it can report the right size without a size function.
+ */
+#define SYSFS_ZERO_COUNT_LEN 2
+extern int sysfs_do_zero_count(sfsnode_t *snp, uio_t uio, vfs_context_t ctx);
+
 #endif /* __FSBUNDLE__ */
 
 #endif /* sysfs_h */

kext/sysfs_structure.c

@@ -38,6 +38,9 @@ STATIC sfssnode_t *add_node(sfssnode_t *parent, const char *name, sfstype type,
 STATIC sfssnode_t *add_directory(sfssnode_t *parent, const char *name, sfstype type, sfsbaseid_t node_id, uint16_t flags, boolean_t raw,
                         sysfs_node_size_fn node_size_fn, sysfs_read_data_fn node_read_data_fn);
 
+STATIC sfssnode_t *add_file(sfssnode_t *parent, const char *name, sfsbaseid_t node_id, uint16_t flags, size_t size,
+                        sysfs_node_size_fn node_size_fn, sysfs_read_data_fn node_read_data_fn);
+
 STATIC void release_node(sfssnode_t *root);
 
 /*
@@ -128,7 +131,49 @@ sysfs_structure_init(void)
          * has no static "."/".." children - the dynamic readdir emits those
          * itself (see sysfs_devices_readdir), exactly as procfs does for /proc/sys.
          */
-        (void)add_node(root_node, "devices", SFSdevice, next_node_id++, SSN_FLAG_DYNAMIC, 0, NULL, NULL);
+        sfssnode_t *devices_node =
+            add_node(root_node, "devices", SFSdevice, next_node_id++, SSN_FLAG_DYNAMIC, 0, NULL, NULL);
+
+        /*
+         * /sys/devices/system - Linux's "system" pseudo-bus. Unlike the rest of
+         * /sys/devices this is NOT part of the IOKit mirror: on Linux it is a
+         * synthetic hierarchy describing CPUs, memory and NUMA nodes, so it is
+         * built here as ordinary static structure nodes. The SFSdevice lookup and
+         * readdir paths consult these static children alongside the registry
+         * ones, but only at the /sys/devices root (registry id 0).
+         *
+         * macOS is not NUMA, so there is exactly one node, node0.
+         */
+        sfssnode_t *system_dir = add_directory(devices_node, "system",
+                        SFSdir, next_node_id++, 0, 0, NULL, NULL);
+        sfssnode_t *node_dir   = add_directory(system_dir, "node",
+                        SFSdir, next_node_id++, 0, 0, NULL, NULL);
+        sfssnode_t *node0_dir  = add_directory(node_dir, "node0",
+                        SFSdir, next_node_id++, 0, 0, NULL, NULL);
+
+        /*
+         * node0/hugepages/hugepages-<size>kB/. The huge-page size is 2MB on both
+         * Apple Silicon and Intel Macs (the architectural large-page size; the
+         * base page is 16KB on arm64 and 4KB on x86_64), so the directory is
+         * named for 2048kB on either.
+         *
+         * macOS has no hugetlb pool to size, reserve or overcommit - large pages
+         * are managed transparently by the VM - so all three counters read 0,
+         * exactly as on a Linux host where no huge pages have been allocated.
+         * Per-node hugepages directories expose these three files only; the
+         * resv_/nr_overcommit_ counters are global (/sys/kernel/mm/hugepages).
+         */
+        sfssnode_t *hugepages_dir = add_directory(node0_dir, "hugepages",
+                        SFSdir, next_node_id++, 0, 0, NULL, NULL);
+        sfssnode_t *hp_2m_dir = add_directory(hugepages_dir, "hugepages-2048kB",
+                        SFSdir, next_node_id++, 0, 0, NULL, NULL);
+
+        add_file(hp_2m_dir, "nr_hugepages", next_node_id++, 0,
+                        SYSFS_ZERO_COUNT_LEN, NULL, sysfs_do_zero_count);
+        add_file(hp_2m_dir, "free_hugepages", next_node_id++, 0,
+                        SYSFS_ZERO_COUNT_LEN, NULL, sysfs_do_zero_count);
+        add_file(hp_2m_dir, "surplus_hugepages", next_node_id++, 0,
+                        SYSFS_ZERO_COUNT_LEN, NULL, sysfs_do_zero_count);
         (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);
@@ -231,6 +276,17 @@ add_directory(sfssnode_t *parent, const char *name, sfstype type, sfsbaseid_t no
     return snode;
 }
 
+/*
+ * Adds a file to the file system structure. Files are always leaf elements
+ * (although that is not checked).
+ */
+STATIC sfssnode_t *
+add_file(sfssnode_t *parent, const char *name, sfsbaseid_t node_id, uint16_t flags, size_t size,
+            sysfs_node_size_fn node_size_fn, sysfs_read_data_fn node_read_data_fn)
+{
+    return add_node(parent, name, SFSfile, node_id, flags, size, node_size_fn, node_read_data_fn);
+}
+
 #pragma mark -
 #pragma mark Clean up of Structure Nodes
 

kext/sysfs_system.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2022-2026 Sunneva N. Mariu
+ *
+ * sysfs_system.c
+ *
+ * Content for /sys/devices/system - Linux's "system" pseudo-bus. Unlike the rest
+ * of /sys/devices (which mirrors the IOKit registry), this hierarchy is
+ * synthetic on Linux too: it describes CPUs, memory and NUMA nodes rather than
+ * discovered hardware. The tree itself is built in sysfs_structure.c; this file
+ * supplies the data its files read.
+ */
+#include <sys/uio.h>
+#include <sys/vnode.h>
+
+#include <fs/sysfs/sysfs.h>
+
+/*
+ * A counter that is always zero, rendered the way Linux renders sysfs integer
+ * attributes: the decimal value followed by a newline.
+ *
+ * This backs the per-node huge-page counters
+ * (/sys/devices/system/node/node0/hugepages/hugepages-2048kB/{nr,free,surplus}_hugepages).
+ * macOS has no hugetlb pool: large pages exist, but they are managed
+ * transparently by the VM system and there is no persistent pool to size,
+ * reserve or overcommit, so nothing can be allocated to a node. Reporting 0 is
+ * both truthful and exactly what a Linux host with no huge pages configured
+ * reports, which is what callers probing these files are prepared to handle.
+ */
+int
+sysfs_do_zero_count(sfsnode_t *snp, uio_t uio, __unused vfs_context_t ctx)
+{
+    static const char zero[] = "0\n";
+
+    (void)snp;
+    return sysfs_copy_data(zero, (int)(sizeof(zero) - 1), uio);
+}

kext/sysfs_vnops.c

@@ -347,7 +347,29 @@ sysfs_vnop_lookup(struct vnop_lookup_args *ap)
              * distinguished by the matched regid/objectid.
              */
             uint64_t regid = dir_snp->node_id.nodeid_regid;
-            for (int a = 0; a < SYSFS_DEV_NATTRS; a++) {
+
+            /*
+             * Static children of /sys/devices itself (currently "system", the
+             * non-IOKit CPU/memory/NUMA hierarchy). These exist only at the
+             * devices root - a real registry entry has no static children - and
+             * take precedence, so a device that happened to be named "system"
+             * cannot shadow them. Once matched, the child is an ordinary static
+             * node and the normal static paths handle everything below it.
+             */
+            if (regid == SYSFS_NO_REGID && sysfs_dev_is_dir(dir_snp->node_id.nodeid_objectid)) {
+                sfssnode_t *static_child;
+                TAILQ_FOREACH(static_child, &dir_snode->ssn_children, ssn_next) {
+                    if (strcmp(name, static_child->ssn_name) == 0) {
+                        match_node = static_child;
+                        match_node_id.nodeid_base_id  = static_child->ssn_base_node_id;
+                        match_node_id.nodeid_regid    = SYSFS_NO_REGID;
+                        match_node_id.nodeid_objectid = SYSFS_NO_OBJECTID;
+                        break;
+                    }
+                }
+            }
+
+            for (int a = 0; match_node == NULL && a < SYSFS_DEV_NATTRS; a++) {
                 if (strcmp(name, sysfs_dev_attrs[a].name) == 0) {
                     match_node = dir_snode;
                     match_node_id.nodeid_base_id  = dir_snode->ssn_base_node_id;
@@ -588,6 +610,33 @@ sysfs_devices_readdir(struct vnop_readdir_args *ap)
         nextpos += size;
     }
 
+    /*
+     * Static children of /sys/devices itself (the non-IOKit "system" hierarchy).
+     * Only the devices root has them; emitted before the registry entries so the
+     * ordering matches lookup's precedence.
+     */
+    if (regid == SYSFS_NO_REGID) {
+        sfssnode_t *static_child;
+        TAILQ_FOREACH(static_child, &dir_snp->node_structure_node->ssn_children, ssn_next) {
+            if (uio_resid(uio) <= 0) {
+                break;
+            }
+            int size = sysfs_calc_dirent_size(static_child->ssn_name);
+            if (nextpos >= startpos) {
+                error = sysfs_copyout_dirent(
+                            sysfs_is_directory_type(static_child->ssn_node_type) ? DT_DIR : DT_REG,
+                            sysfs_get_fileid(SYSFS_NO_REGID, SYSFS_NO_OBJECTID,
+                                             static_child->ssn_base_node_id),
+                            static_child->ssn_name, uio, &size, nextpos + size);
+                if (size == 0 || error != 0) {
+                    goto done;
+                }
+                numentries++;
+            }
+            nextpos += size;
+        }
+    }
+
     /* Child registry entries, one subdirectory each. */
     for (unsigned int i = 0; error == 0 && uio_resid(uio) > 0; i++) {
         char     childname[NAME_MAX + 1];