Linux Kernel `rwlock_t`
Introduction Concurrency is one of the fundamental challenges in Linux kernel development. Multiple kernel threads, interrupt contexts, and subsystem components can access shared kernel state concurre
DevNation
Blog on System Programming Languages
Latest articles
F# as a Linux Kernel Module Development Orchestrator
Introduction Linux kernel module development normally involves a repetitive sequence: make sign rmmod insmod dmesg When experimenting with kernel modules, repeating these commands manually quickly be
Understanding atomic_t vs refcount_t in the Linux Kernel
atomic_t vs refcount_t in the Linux Kernel: Counters, References, and Object Lifetime Introduction When developing Linux kernel code, counters and object lifetime management can look deceptively simil
Understanding Linux Kernel Threads and Spinlocks
Introduction Concurrent execution is an important concept in operating systems and kernel development. Modern processors can execute multiple tasks concurrently, often across multiple CPU cores. When
Linux Kernel-Priority Inheritance
Introduction Priority inversion is a classic scheduling problem in real-time and concurrent systems. It occurs when a high-priority task is forced to wait for a lower-priority task, while a medium-pri
Linux Kernel Priority Inversion: Mutex, Scheduling and Priority Inheritance
Introduction Priority inversion is a classic concurrency and real-time scheduling problem in operating systems. The basic situation is simple: A LOW-priority thread owns a mutex. A HIGH-priority thre
Understanding `mutex_lock_killable()` in Linux Kernel Modules
Synchronization is one of the most important concepts in Linux kernel development. When multiple kernel threads access a shared resource simultaneously, improper synchronization can lead to race condi
Building an F# Control Plane with a C Data Plane on Linux
Modern software systems often separate control logic from high-performance execution logic. This design is common in networking, distributed systems, operating systems, storage engines, and embedded s
Integrating F# with Native C Using P/Invoke for Engineering Computation
Introduction Engineering software often combines multiple programming languages to leverage their individual strengths. A common approach is to implement computational algorithms in native C or C++ wh
