Composable OS Kernel Architectures for Autonomous Intelligence

Rajpreet Singh; Vidhi Kothari

REVIEW 4 major objections 4 minor 16 references

Composable OS Kernel Architectures for Autonomous Intelligence

T0 review · 4 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper argues that operating system kernels can be rebuilt as AI-native, neurosymbolic platforms that reason, learn, and adapt inside the OS substrate.

desk verdict Clear, honest vision paper; no implementation, no data, and the paper's own challenge sections concede the obstacles that sink the central claim. read the letter →

arxiv 2508.00604 v1 pith:AZVYWJA4 submitted 2025-08-01 cs.OS cs.AI

Rajpreet Singh , Vidhi Kothari This is my paper · ORCID

classification cs.OScs.AI

keywords AI-nativeoperatingsystemsLoadableKernelModuleskernel-spacedeeplearningNeurosymbolicHomotopyTypeTheoryLinearLogicML-awareschedulingautonomous

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that the operating system kernel, traditionally a static resource manager, should be rebuilt as an AI-native platform: deep learning inference, floating-point acceleration, GPU memory management, and ML-aware scheduling would live in the kernel itself, with Loadable Kernel Modules acting as high-speed sensory and cognitive units. On top of that, it argues for a "Neurosymbolic kernel" in which Category Theory, Homotopy Type Theory, and Linear Logic unify symbolic reasoning with differentiable neural logic inside the OS. The payoff would be operating systems that anticipate and adapt to autonomous applications rather than merely execute system calls, which the paper frames as groundwork for AGI-native systems. A sympathetic reader would care because this is the strongest version of the claim that the OS is the right layer to host intelligence, not just an application to be run.

What carries the argument

The carrying object is the hybrid automaton and categorical model of the RaBAB-NeuSym kernel: computational states are logical predicates combined with continuous neural embeddings, resources are Linear Logic tokens that must be consumed exactly once, transformations are morphisms in a category, and Homotopy Type Theory path equivalence identifies redundant computational derivations. This machinery lets symbolic and sub-symbolic processing share one substrate while keeping resource use composable and provably safe. The more implementation-oriented carriers are the AI-enabled LKM, with tensor operations, zero-copy data transfer, AVX-512 instructions, and DMA buffers, and the Kernel ML Subsystem's five components: floating-point engine, GPU driver, memory manager, ML-aware scheduler, and security layer.

What would settle it

Run a standard convolutional image classifier as a loadable kernel module under the paper's FPU-context switching and its 512 MB kernel memory pool on commodity x86-64 hardware, then probe the module with malformed inputs. A kernel panic, corrupted FPU state for user processes, memory exhaustion, or a privilege-escalation path would refute the claim that kernel-space inference is safe and efficient.

Watch

Extended reading notes

Core claim

The central claim is that kernel architecture can be decomposed into composable AI-oriented primitives, validated by three prototype-level designs: LKMs that execute tensor operations in kernel space, a Kernel ML Subsystem with a floating-point engine, GPU driver, memory pool, and ML-aware scheduler, and the RaBAB-NeuSym design that models kernel computation as categorical objects and morphisms, using Linear Logic for single-use resource semantics and Homotopy Type Theory for path equivalence. The paper asserts that these components jointly transform the kernel from a deterministic executor into a declarative, knowledge-aware mediator that interprets high-level intent (for example, "draw a red pixel at (100, 50)") and optimizes hardware actions through symbolic and neural reasoning. It claims that this is the foundation for autonomous, AGI-ready operating systems with emergent, context-aware intelligence.

Load-bearing premise

The architecture assumes that deep learning inference can run safely and efficiently inside the operating system kernel's privileged mode; if kernel-level floating-point handling, memory limits, or security isolation cannot be made dependable, the central vision collapses.

Editorial extensions

If this is right

If correct, latency-critical AI tasks such as computer vision, audio analysis, and sensor fusion could run without user-kernel context switches, changing the performance envelope for edge and real-time systems.
Kernels would gain first-class ML scheduling and GPU memory management, so machine learning workloads would no longer be bolted on through user-space frameworks.
The OS would become a reasoning system that maintains knowledge graphs and dynamically evolves predicates, meaning system behavior could adapt to workload semantics rather than fixed heuristics.
The neurosymbolic model implies that resource management, security, and scheduling can be treated as declarative, logically constrained computations, potentially making them more verifiable.
It reframes AGI infrastructure as an OS-level problem, shifting attention from application frameworks to kernel and hardware-software co-design.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A near-term, lower-risk test would be to implement the RaBAB-NeuSym ideas in user space as a declarative runtime or library; if categorical composition and Linear Logic resource tracking deliver no benefit there, the kernel version is unlikely to work either.
The paper's own admission that floating-point support and kernel memory constraints are unsolved suggests the realistic path is a microkernel or hypervisor-isolated AI subsystem rather than a monolithic kernel.
The claimed latency advantage is falsifiable in isolation: comparing tail latencies of the same inference workload in kernel space versus user space on identical hardware would show whether the architecture's central benefit actually materializes.
The "anticipatory" property could be tested before any reasoning layer is built by measuring whether the ML-aware scheduler's predictions beat simple heuristics on real workload traces.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: this is a position statement, not a research result. The authors describe a Linux kernel extended with AI-oriented LKMs, a kernel ML subsystem, and a 'Neurosymbolic' kernel based on Category Theory, HoTT, and Linear Logic. Almost none of it is built or measured. The reader's REJECT verdict is right, but I want to credit the parts that are genuinely decent.

What the paper does well: the writing is clear, the structure is sensible, and the authors are unusually honest about their own limitations. Sections 2.5, 3.5, and 4.5 list the real obstacles: kernel FPU isolation, kmalloc's lack of virtual memory, security exposure, debugging difficulty, and the fact that ML frameworks live in user space. The references are relevant and mostly well chosen—LAKE, ML load balancing in the Linux kernel, and LKM-based GPU resource management are all real prior work. If this were a survey or a research agenda, those parts would be acceptable.

The only genuinely new element is the RaBAB neurosymbolic kernel, and it is described only verbally. The paper claims validation and benchmarks but shows no data. 'Validation tests confirm significant improvements' appears without any numbers, methodology, or reproduction. The named files, constants, and function prototypes are not evidence. The RaBAB section is the biggest problem: Category Theory, HoTT, and Linear Logic are used as metaphors, not as formal machinery. There is no categorical semantics, no dependent-type checker, no HoTT path-equivalence algorithm, no linear-resource proof rule. The paper's own Section 2.5 concedes that FPU isolation, memory constraints, and security risks are unresolved, so the central claim that reasoning and learning can safely run inside the kernel is an assertion, not an established result. This is not a disagreement about research taste; it is an absence of support.

The citation pattern is acceptable—they cite relevant work and do not hide it. The problem is that the claimed novelty overlaps heavily with their own references, and the neurosymbolic part is not defined tightly enough to be checked.

Who is this for? Someone looking for an example of an ambitious kernel/AI vision paper might use it as a starting point, but no researcher should rely on it as a technical foundation.

Recommendation: desk reject for a research venue. If the authors want a serious hearing, they need an implementation, actual measurements, and a formal or at least precise specification of the neurosymbolic kernel. I would not send this to peer review in its current form.

Referee Report

4 major / 4 minor

Summary. The manuscript proposes three intertwined operating-system kernel designs: (1) treating Loadable Kernel Modules (LKMs) as AI-oriented computation units for kernel-space sensory and cognitive processing; (2) a 'KernelAGI' subsystem that embeds deep-learning inference, GPU support, memory pools, and ML-aware scheduling inside the Linux kernel; and (3) a 'RaBAB-NeuSym Kernel' that purports to use Category Theory, Homotopy Type Theory (HoTT), and Linear Logic to unify symbolic reasoning and differentiable logic in OS internals. The abstract and conclusion claim that these designs enable 'AGI-native' operating systems and that validation tests confirm significant performance improvements. The body contains no equations, no formal semantics, no code listings, no benchmark data, and no reproducibility artifacts; instead it describes intended file/function inventories and asserts that test modules validate the designs.

Significance. If the central claims were established, the work would address a timely and important question: whether OS kernels can be redesigned to support adaptive, learning-enabled workloads. The manuscript deserves credit for an honest enumeration of kernel-space ML obstacles in Sections 2.5 and 3.5 (FPU isolation, kmalloc's lack of virtual memory, privileged-execution security risks, and the user-space nature of mainstream ML frameworks), and for positioning its contributions against relevant prior work such as LAKE and agent-centric OS surveys. However, the paper provides no machine-checked proofs, no reproducible code, no parameter-free derivations, and no falsifiable predictions. Its central claims are asserted rather than demonstrated, and the RaBAB section offers only metaphors and named functions in place of a formal or executable design. The significance is therefore conditional: the vision is interesting, but the submitted manuscript does not establish that any of the proposed architectures can be realized.

major comments (4)

[§4.2–4.3] The central claim that Category Theory, HoTT, and Linear Logic become executable kernel semantics is unsupported. The text names functions and data structures (evolvePredicate, NeuralEmbedding, LinearResource, cosineSimilarity) and says that dependent types, path equivalence, and linear resource tokens provide correctness guarantees, but it gives no categorical semantics, no dependent type-checking rules, no HoTT-based path-equivalence algorithm, and no linear-logic proof rules. No code or runnable artifact is supplied. Since this is the load-bearing novelty of the RaBAB design, the claim that the kernel 'transforms traditional imperative programming into a declarative, mathematically rigorous system' is not established.
[§3.2–3.3] Validation is asserted rather than reported. Statements such as 'Validation tests (fp test.ko) confirm high-precision operations without system instability' (§3.2) and 'validation tests confirm significant improvements in performance metrics' (§3.3) appear without test inputs, measured values, baseline comparisons, hardware configuration, or methodology. No tables, figures, or logs are provided, and the claimed benchmarks in §4.3 ('Transformation Correctness and Simplification Efficiency') are also absent. Without this data, the performance and correctness claims cannot be checked by a reader.
[§2.5, §3.2, §3.5] The paper's own challenge sections identify obstacles that its proposed designs do not resolve. Section 2.5 states that kmalloc lacks virtual memory and risks exhaustion for large neural-network weights, yet §3.2 proposes a fixed 512 MB pool allocated with kmalloc, which does not address large-model deployment. Section 2.5 and §3.5 both list floating-point isolation and privileged-execution security risks as unresolved challenges, but §3.2 claims an implemented floating-point engine and GPU driver without explaining how these security and isolation problems are solved. The manuscript needs to explain, with concrete mechanisms, how its architecture overcomes the very obstacles it enumerates; otherwise the viability of kernel-space inference and neurosymbolic reasoning remains an unsupported assertion.
[§4.4] The correctness guarantees attributed to the RaBAB architecture are not backed by definitions. The Resource Manager is said to enforce 'deterministic single-use semantics' and 'provable resource tracking' via LinearResource tokens, and the Knowledge Graph is described as a directed graph of [String, Double] tuples, but no resource calculus, typing judgment, or graph-update invariant is specified. Claims of memory safety and leak-freedom therefore have no formal basis in the text.

minor comments (4)

[Throughout] The manuscript repeatedly uses phrases such as 'validation tests confirm' and 'tests in test_advanced_memory.c show' without identifying where the test code, data, or logs can be found; a reproducibility appendix or repository link would be needed even for a preliminary report.
[§2.2] The text assigns syscall number 548 to 'sys_simple_compute' as if it were globally available; syscall numbers are architecture-specific and must be reserved or patched, so this should be clarified or removed.
[Throughout] There are typographical and notational issues, including 'A VX512' for AVX-512, 'module init()' and 'module exit()' for module_init() and module_exit(), and inconsistent spacing in identifiers such as 'ml pool->bitmap'.
[References] Several references are incomplete or informal (e.g., [5], [7], and [12] are web pages with access dates but no URLs), and the paper would benefit from a more systematic related-work discussion beyond the single survey citation in [13].

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the paper makes no quantitative predictions and contains no self-citation chain; its core claims are unsupported assertions, not derivations that reduce to their own inputs.

full rationale

The paper is a design/vision proposal with no fitted parameters, no equations, and no quantitative derivation, so the main circularity patterns (self-definitional reduction, fitted input called prediction, self-citation load-bearing, uniqueness imported from authors, ansatz smuggled via citation, renaming known result) do not apply. Its central claim that a Neurosymbolic kernel can unify symbolic reasoning and differentiable logic is argued by analogy and asserted with named functions such as evolvePredicate, NeuralEmbedding, and LinearResource, but Section 4 supplies no formal semantics, executable specification, or proof; this is a completeness and soundness problem, not circularity. Section 2.5 candidly identifies unresolved obstacles including kmalloc memory exhaustion, lack of floating-point support, and security risks, and the paper's 'validation' statements claim success without presenting measurements; again, these are evidential gaps, not reductions of conclusions into premises. No load-bearing step is justified by a self-citation, and no cited result is used to forbid alternatives. The absence of evidence for the central claims is real and should be weighed as a correctness/verification risk, but it does not constitute circular reasoning.

Assumptions & free parameters 3 free parameters · 4 assumptions · 3 invented entities

The paper introduces no fitted parameters but uses hand-chosen constants. It relies on unproven assumptions about kernel safety, FPU implementation, and the applicability of advanced type theory. The invented software entities are proposals with no independent evidence.

free parameters (3)

ML_POOL_SIZE = 512 MB
Hand-chosen memory pool size for kernel ML subsystem, Section 3.2. No sensitivity analysis or empirical fitting.
GPU_BUFFER_SIZE = 1 MB
Hand-chosen shared buffer size for kernel GPU driver, Section 3.2.
ML_SCHED_PRIORITY = 10
Hand-chosen scheduling class priority for ML tasks, Section 3.2.

assumptions (4)

domain assumption Kernel-space ML inference is safe and beneficial
Central premise of Sections 2 and 3; the paper itself lists FPU, memory, and security obstacles in Sections 2.5 and 3.5.
ad hoc to paper Category Theory, HoTT, and Linear Logic can be implemented as kernel execution semantics
Section 4.2 asserts these frameworks 'ensure that the kernel is both mathematically sound and practically robust' without formalization or implementation.
domain assumption User-kernel context switching is a dominant bottleneck for AI workloads
Sections 1 and 2.1 motivate the design with this claim; no measurements are provided.
domain assumption Hardware abstraction layer can support zero-copy, FPU isolation, and heterogeneous accelerators in kernel space
Sections 3.1 and 4.4 assume HAL feasibility; no experimental validation.

invented entities (3)

RaBAB-NeuSym Kernel
purpose: Neurosymbolic kernel unifying symbolic and neural computation via category theory, HoTT, and linear logic
Described in Section 4 with no implementation, formal spec, or testable prediction.
NeurosymbolicPredicate and evolvePredicate
purpose: Dynamic logical predicates that adapt via probabilistic learning inside the kernel
Section 4.4; no code, semantics, or convergence analysis.
LinearResource tokens
purpose: Deterministic single-use resource semantics based on linear logic
Section 4.4; no formal system or implementation.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Composable OS Kernel Architectures for Autonomous Intelligence." pith.science (2026). https://pith.science/paper/AZVYWJA4

@misc{pith2026250800604,
  author       = {Pith},
  title        = {Pith review of: Composable OS Kernel Architectures for Autonomous Intelligence},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AZVYWJA4}},
  note         = {Machine review of arXiv:2508.00604}
}

read the original abstract

As intelligent systems permeate edge devices, cloud infrastructure, and embedded real-time environments, this research proposes a new OS kernel architecture for intelligent systems, transforming kernels from static resource managers to adaptive, AI-integrated platforms. Key contributions include: (1) treating Loadable Kernel Modules (LKMs) as AI-oriented computation units for fast sensory and cognitive processing in kernel space; (2) expanding the Linux kernel into an AI-native environment with built-in deep learning inference, floating-point acceleration, and real-time adaptive scheduling for efficient ML workloads; and (3) introducing a Neurosymbolic kernel design leveraging Category Theory and Homotopy Type Theory to unify symbolic reasoning and differentiable logic within OS internals. Together, these approaches enable operating systems to proactively anticipate and adapt to the cognitive needs of autonomous intelligent applications.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

16 extracted references · 15 canonical work pages

[1]

Can We Trust AI-Powered Real- Time Embedded Systems?

Giorgio Buttazzo. “Can We Trust AI-Powered Real- Time Embedded Systems?” In: Third Workshop on Next Generation Real-Time Embedded Systems (NG- RES 2022). Ed. by Marko Bertogna, Federico Terra- neo, and Federico Reghenzani. V ol. 98. Open Ac- cess Series in Informatics (OASIcs). Dagstuhl, Ger- many: Schloss Dagstuhl – Leibniz-Zentrum f ¨ur In- formatik, 20...

work page 2022
[2]

4230 / OASIcs

DOI: 10 . 4230 / OASIcs . NG - RES . 2022

work page 2022
[3]

dagstuhl

URL: https : / / drops . dagstuhl . de / 7 entities / document / 10 . 4230 / OASIcs . NG-RES.2022.1

work page 2022
[4]

Machine learning for load bal- ancing in the Linux kernel

Jingde Chen et al. “Machine learning for load bal- ancing in the Linux kernel”. In: Proceedings of the 11th ACM SIGOPS Asia-Pacific Workshop on Systems. APSys ’20. Tsukuba, Japan: Association for Computing Machinery, 2020, pp. 67–74. ISBN : 9781450380690. DOI: 10 . 1145 / 3409963 . 3410492. URL: https : / / doi . org / 10 . 1145/3409963.3410492

work page arXiv 2020
[5]

Supporting AI-powered real-time cyber-physical systems on heterogeneous platforms via hypervisor technology

Edoardo Cittadini et al. “Supporting AI-powered real-time cyber-physical systems on heterogeneous platforms via hypervisor technology”. In: Real-Time Syst. 59.4 (July 2023), pp. 609–635. ISSN : 0922-

work page 2023
[6]

Agent Centric Operating System -- a Comprehensive Review and Outlook for Operating System

Shian Jia et al. Agent Centric Operating System – a Comprehensive Review and Outlook for Operat- ing System. 2024. arXiv: 2411.17710 [cs.DC]. URL: https : / / arxiv . org / abs / 2411 . 17710

work page Pith review arXiv 2024
[7]

Towards a Machine Learning-Assisted Kernel with LAKE

Henrique Fingler et al. “Towards a Machine Learning-Assisted Kernel with LAKE”. In: Pro- ceedings of the 28th ACM International Conference on Architectural Support for Programming Lan- guages and Operating Systems, Volume 2 . ASP- LOS 2023. Vancouver, BC, Canada: Association for Computing Machinery, 2023, pp. 846–861. ISBN : 9781450399166. DOI: 10 . 1145 ...

work page arXiv 2023
[8]

Loadable Kernel Modules

Bryan Henderson. Loadable Kernel Modules . Ac- cessed: 2025-01-13. 2025

work page 2025

Show all 16 references

[9]

Performance Analysis of Process Using Loadable Kernel Module (LKM)

Barun Kumar Parichha. “Performance Analysis of Process Using Loadable Kernel Module (LKM)”. In: 2015 Fifth International Conference on Commu- nication Systems and Network Technologies . 2015, pp. 1338–1343. DOI: 10 . 1109 / CSNT . 2015 . 184

2015
[10]

Kernel modules, device drivers and Device Tree

Mike Krinkin. Kernel modules, device drivers and Device Tree. Accessed: 2025-01-13. 2025

2025
[11]

Network for AI and AI for Net- work: Challenges and Opportunities for Learning- Oriented Networks

Jianping Pan et al. “Network for AI and AI for Net- work: Challenges and Opportunities for Learning- Oriented Networks”. In: IEEE Network 35.6 (2021), pp. 270–277. DOI: 10 . 1109 / MNET . 101 . 2100118

2021
[12]

Dynamic Modules

CS UCLA. Dynamic Modules. Accessed: 2025-01-

2025
[13]

Real-Time GPU Resource Man- agement with Loadable Kernel Modules

Yuhei Suzuki et al. “Real-Time GPU Resource Man- agement with Loadable Kernel Modules”. In: IEEE Transactions on Parallel and Distributed Systems 28.6 (2017), pp. 1715–1727. DOI: 10 . 1109 / TPDS.2016.2630697

2017
[14]

Tri- ton: an intermediate language and compiler for tiled neural network computations

Philippe Tillet, H. T. Kung, and David Cox. “Tri- ton: an intermediate language and compiler for tiled neural network computations”. In: Proceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages . MAPL 2019. Phoenix, AZ, USA: Assoc...

2019
[16]

Integrating Artificial Intelli- gence into Operating Systems: A Comprehensive Survey on Techniques, Applications, and Future Directions

Yifan Zhang et al. “Integrating Artificial Intelli- gence into Operating Systems: A Comprehensive Survey on Techniques, Applications, and Future Directions”. In: arXiv e-prints , arXiv:2407.14567 (July 2024), arXiv:2407.14567. DOI: 10.48550/ arXiv . 2407 . 14567 . arXiv: 2407 ...

2024 doi
[6443]

URL: https://doi.org/10.1007/s11241- 023-09402-4

DOI: 10.1007/s11241-023-09402-4 . URL: https://doi.org/10.1007/s11241- 023-09402-4

doi

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

Can We Trust AI-Powered Real- Time Embedded Systems?

Giorgio Buttazzo. “Can We Trust AI-Powered Real- Time Embedded Systems?” In: Third Workshop on Next Generation Real-Time Embedded Systems (NG- RES 2022). Ed. by Marko Bertogna, Federico Terra- neo, and Federico Reghenzani. V ol. 98. Open Ac- cess Series in Informatics (OASIcs). Dagstuhl, Ger- many: Schloss Dagstuhl – Leibniz-Zentrum f ¨ur In- formatik, 20...

work page 2022

[2] [2]

4230 / OASIcs

DOI: 10 . 4230 / OASIcs . NG - RES . 2022

work page 2022

[3] [3]

dagstuhl

URL: https : / / drops . dagstuhl . de / 7 entities / document / 10 . 4230 / OASIcs . NG-RES.2022.1

work page 2022

[4] [4]

Machine learning for load bal- ancing in the Linux kernel

Jingde Chen et al. “Machine learning for load bal- ancing in the Linux kernel”. In: Proceedings of the 11th ACM SIGOPS Asia-Pacific Workshop on Systems. APSys ’20. Tsukuba, Japan: Association for Computing Machinery, 2020, pp. 67–74. ISBN : 9781450380690. DOI: 10 . 1145 / 3409963 . 3410492. URL: https : / / doi . org / 10 . 1145/3409963.3410492

work page arXiv 2020

[5] [5]

Supporting AI-powered real-time cyber-physical systems on heterogeneous platforms via hypervisor technology

Edoardo Cittadini et al. “Supporting AI-powered real-time cyber-physical systems on heterogeneous platforms via hypervisor technology”. In: Real-Time Syst. 59.4 (July 2023), pp. 609–635. ISSN : 0922-

work page 2023

[6] [6]

Agent Centric Operating System -- a Comprehensive Review and Outlook for Operating System

Shian Jia et al. Agent Centric Operating System – a Comprehensive Review and Outlook for Operat- ing System. 2024. arXiv: 2411.17710 [cs.DC]. URL: https : / / arxiv . org / abs / 2411 . 17710

work page Pith review arXiv 2024

[7] [7]

Towards a Machine Learning-Assisted Kernel with LAKE

Henrique Fingler et al. “Towards a Machine Learning-Assisted Kernel with LAKE”. In: Pro- ceedings of the 28th ACM International Conference on Architectural Support for Programming Lan- guages and Operating Systems, Volume 2 . ASP- LOS 2023. Vancouver, BC, Canada: Association for Computing Machinery, 2023, pp. 846–861. ISBN : 9781450399166. DOI: 10 . 1145 ...

work page arXiv 2023

[8] [8]

Loadable Kernel Modules

Bryan Henderson. Loadable Kernel Modules . Ac- cessed: 2025-01-13. 2025

work page 2025