book

Linux Kernel Programming - Second Edition

by Kaiwan N. Billimoria

February 2024

Intermediate to advanced

826 pages

24h 48m

English

Packt Publishing

Read now

Unlock full access

Who this book is forWhat’s been added in the second edition?What this book coversGet in touch
Kernel workspace setupTechnical requirementsCloning this book’s code repository
Technical requirementsPreliminaries for the kernel buildUnderstanding the Linux kernel release nomenclatureFingers-and-toes releasesKernel development workflow – understanding the basicsViewing the kernel’s Git log via the command lineViewing the kernel’s Git log via its GitHub pageThe kernel dev workflow in a nutshellExerciseExploring the types of kernel source treesLTS kernels – the new mandateWhich kernel should I run?Steps to build the kernel from sourceStep 1 – Obtaining a Linux kernel source treeDownloading a specific kernel treeCloning a Git treeStep 2 – Extracting the kernel source treeA brief tour of the kernel source treeStep 3 – Configuring the Linux kernelMinimally understanding the Kconfig/Kbuild build systemHow the Kconfig+Kbuild system works – a minimal takeArriving at a default configurationObtaining a good starting point for kernel configurationKernel config using distribution config as a starting pointTuned kernel config via the localmodconfig approachKernel config for typical embedded Linux systemsSeeing all available config optionsGetting going with the localmodconfig approachTuning our kernel configuration via the make menuconfig UISample usage of the make menuconfig UIKernel config – exploring a bit moreSearching within the menuconfig UILooking up the differences in configurationUsing the kernel’s config script to view/edit the kernel configConfiguring the kernel for securityMiscellaneous tips – kernel configCustomizing the kernel menu, Kconfig, and adding our own menu itemUnderstanding the Kconfig* filesCreating a new menu item within the General Setup menuA few details on the Kconfig languageSummaryExerciseQuestionsFurther reading
Technical requirementsStep 4 – building the kernel image and modulesGetting over a cert config issue on UbuntuStep 5 – installing the kernel modulesLocating the kernel modules within the kernel sourceGetting the kernel modules installedOverriding the default module installation locationStep 6 – generating the initramfs image and bootloader setupGenerating the initramfs image – under the hoodUnderstanding the initramfs frameworkWhy the initramfs framework?Understanding the basics of the boot process on the x86More on the initramfs frameworkPeeking into the initramfs imageStep 7 – customizing the GRUB bootloaderCustomizing GRUB – the basicsSelecting the default kernel to boot intoBooting our VM via the GNU GRUB bootloader Experimenting with the GRUB promptVerifying our new kernel’s configurationKernel build for the Raspberry PiStep 1 – cloning the Raspberry Pi kernel source treeStep 2 – installing an x86_64-to-AArch64 cross-toolchainStep 3 – configuring and building the Raspberry Pi AArch64 kernelMiscellaneous tips on the kernel buildMinimum version requirementsBuilding a kernel for another siteWatching the kernel build runA shortcut shell syntax to the build procedureDealing with missing OpenSSL development headersHow can I check which distro kernels are installed?SummaryQuestionsFurther reading
Technical requirementsUnderstanding the kernel architecture – part 1User space and kernel spaceLibrary and system call APIsKernel space componentsExploring LKMsThe LKM frameworkKernel modules within the kernel source treeWriting our very first kernel moduleIntroducing our Hello, world LKM C codeBreaking it downKernel headersModule macrosEntry and exit pointsReturn valuesCommon operations on kernel modulesBuilding the kernel moduleRunning the kernel moduleA quick first look at the kernel printk()Listing the live kernel modulesUnloading the module from kernel memoryOur lkm convenience scriptUnderstanding kernel logging and printkUsing the kernel memory ring bufferKernel logging and systemd’s journalctlUsing printk log levelsThe pr_<foo> convenience macrosWriting to the consoleWriting output to the Raspberry Pi consoleTurning on debug-level kernel messagesRate limiting the printk instancesRate-limiting macros to useGenerating kernel messages from user spaceStandardizing printk output via the pr_fmt macroPortability and the printk format specifiersUnderstanding the new printk indexing featureUnderstanding the basics of a kernel module MakefileSummary QuestionsFurther reading
Technical requirementsA “better” Makefile template for your kernel modulesConfiguring a “debug” kernelCross-compiling a kernel moduleSetting up the system for cross-compilationAttempt 1 – setting the ARCH and CROSS_COMPILE environment variablesAttempt 2 – pointing the Makefile to the correct kernel source tree for the targetAttempt 3 – cross-compiling our kernel moduleExamining Linux kernel ABI compatibility issuesAttempt 4 – cross-compiling our kernel moduleSummarizing what went wrong with the module cross-buildd/load and how it was fixedGathering minimal system informationBeing a bit more security-awareLicensing kernel modulesLicensing of inline kernel codeLicensing of out-of-tree kernel modulesEmulating “library-like” features for kernel modulesPerforming library emulation via linking multiple source filesUnderstanding function and variable scope in a kernel moduleUnderstanding module stackingTrying out module stackingEmulating ‘library-like’ features – summary and conclusionsPassing parameters to a kernel moduleDeclaring and using module parametersGetting/setting module parameters after insertionLearning module parameter data types and validationValidating kernel module parametersOverriding the module parameter’s nameHardware-related kernel parametersFloating point not allowed in the kernelForcing FP in the kernelAuto-loading modules on system bootModule auto-loading – additional detailsKernel modules and security – an overviewProc filesystem tunables affecting the system logA quick word on the dmesg_restrict sysctlA quick word on the kptr_restrict sysctlUnderstanding the cryptographic signing of kernel modulesThe two module-signing modesDisabling kernel modules altogetherThe kernel lockdown LSM – an introductionCoding style guidelines for kernel developersContributing to the mainline kernelGetting started with contributing to the kernelSummaryQuestionsFurther reading
Technical requirementsUnderstanding process and interrupt contextsUnderstanding the basics of the process Virtual Address Space (VAS)Organizing processes, threads, and their stacks – user and kernel spaceRunning a small script to see the number of processes and threads aliveUser space organizationKernel space organizationSummarizing the kernel with respect to threads, task structures, and stacksViewing the user and kernel stacksTraditional approach to viewing the stackseBPF – the modern approach to viewing both stacksThe 10,000-foot view of the process VASUnderstanding and accessing the kernel task structureLooking into the task structureAccessing the task structure with currentDetermining the contextWorking with the task structure via ‘current’Built-in kernel helper methods and optimizationsTrying out the kernel module to print process context infoSeeing that the Linux OS is monolithicCoding for security with printkIterating over the kernel’s task listsIterating over the task list I – displaying all processesIterating over the task list II – displaying all threadsDifferentiating between the process and thread – the TGID and the PIDIterating over the task list III – the codeSummaryQuestionsFurther reading
Technical requirementsUnderstanding the VM splitLooking under the hood – the Hello, world C programGoing beyond the printf() APIVirtual addressing and address translationVM split on 64-bit Linux systemsCommon VM splitsUnderstanding the process VAS – the full viewExamining the process VASExamining the user VAS in detailDirectly viewing the process memory map using procfsFrontends to view the process memory mapUnderstanding VMA basicsExamining the kernel VASHigh memory on 32-bit systemsWriting a kernel module to show information about the kernel VASMacros and variables describing the kernel VAS layoutTrying it out – viewing kernel VAS detailsThe kernel VAS via procmapTrying it out – the user segmentViewing kernel documentation on the memory layoutRandomizing the memory layout – KASLRUser memory randomization with ASLRKernel memory layout randomization with KASLRQuerying/setting KASLR status with a scriptUnderstanding physical memory organizationPhysical RAM organizationNodes and NUMAZones within a nodeDirect-mapped RAM and address translationAn introduction to physical memory models Understanding the sparsemem[-vmemmap] memory model in briefSummaryQuestionsFurther reading
Technical requirementsIntroducing kernel memory allocatorsUnderstanding and using the kernel page allocator (or BSA)The fundamental workings of the page allocatorUnderstanding the organization of the page allocator freelistThe workings of the page allocatorWorking through a few scenariosPage allocator internals – a few more detailsLearning how to use the page allocator APIsDealing with the GFP flagsFreeing pages with the page allocatorA few guidelines to observe when (de)allocating kernel memoryWriting a kernel module to demo using the page allocator APIsDeploying our lowlevel_mem_lkm kernel moduleThe page allocator and internal fragmentation (wastage)The GFP flags – digging deeperNever sleep in interrupt or atomic contextsPage allocator – pros and consUnderstanding and using the kernel slab allocatorThe object caching ideaA few FAQs regarding (slab) memory usage and their answersLearning how to use the slab allocator APIsAllocating slab memoryFreeing slab memoryData structures – a few design tipsThe actual slab caches in use for kmallocWriting a kernel module to use the basic slab APIsSize limitations of the kmalloc APITesting the limits – memory allocation with a single callChecking via the /proc/buddyinfo pseudofileSlab allocator – a few additional detailsUsing the kernel’s resource-managed memory allocation APIsAdditional slab helper APIsControl groups and memoryCaveats when using the slab allocatorBackground details and conclusionsTesting slab allocation with ksize() – case 1Testing slab allocation with ksize() – case 2Interpreting the output from case 2Graphing itFinding internal fragmentation (wastage) within the kernelThe easy way with slabinfoMore details with alloc_traces and a custom scriptSlab layer - pros and consSlab layer – a word on its implementations within the kernelSummaryQuestionsFurther reading
Technical requirementsCreating a custom slab cacheCreating and using a custom slab cache within a kernel moduleStep 1 – creating a custom slab cacheStep 2 – using our custom slab cache’s memoryStep 3 – destroying our custom cacheCustom slab – a demo kernel moduleExtracting useful information regarding slab cachesUnderstanding slab shrinkersSummarizing the slab allocator pros and consDebugging kernel memory issues – a quick mentionUnderstanding and using the kernel vmalloc() APILearning to use the vmalloc family of APIsTrying out vmalloc()A brief note on user-mode memory allocations and demand pagingFriends of vmalloc()Is this vmalloc-ed (or module region) memory?Unsure which API to use? Try kvmalloc()Miscellaneous helpers – vmalloc_exec() and vmalloc_user()Specifying memory protectionsThe kmalloc() and vmalloc() APIs – a quick comparisonMemory allocation in the kernel – which APIs to use whenVisualizing the kernel memory allocation API setSelecting an appropriate API for kernel memory allocationA word on DMA and CMAMemory reclaim – a key kernel housekeeping taskZone watermarks and kswapdThe new multi-generational LRU (MGLRU) lists featureTrying it out – seeing histogram data from MGLRUA quick introduction to DAMON – the Data Access Monitoring featureRunning a memory workload and visualizing it with DAMON’s damo front-endStayin’ alive – the OOM killerDeliberately invoking the OOM killerInvoking the OOM killer via Magic SysRqInvoking the OOM killer with a crazy allocator programUnderstanding the three VM overcommit_memory policiesVM overcommit from the viewpoint of the __vm_enough_memory() codeCase 1: vm.overcommit_memory == 0 (the default, OVERCOMMIT_GUESS)Case 2: vm.overcommit_memory == 2 (VM overcommit turned off, OVERCOMMIT_NEVER) and vm.overcommit_ratio == 50Demand paging and OOMThe optimized (unmapped) readUnderstanding the OOM scoreClosing thoughts on the OOM killer and cgroupsCgroups and memory bandwidth – a noteSummaryQuestionsFurther reading

Technical requirementsLearning about the CPU scheduling internals – part 1 – essential backgroundWhat is the KSE on Linux?The Linux process state machineThe POSIX scheduling policiesThread prioritiesVisualizing the flowUsing the gnome-system-monitor GUI to visualize the flowUsing perf to visualize the flowTrying it out – the command-line approachTrying it out – the graphical approachVisualizing the flow via alternate approachesLearning about the CPU scheduling internals – part 2Understanding modular scheduling classesA conceptual example to help understand scheduling classesAsking the scheduling classThe workings of the Completely Fair Scheduling (CFS) class in briefScheduling statisticsQuerying a given thread’s scheduling policy and priorityLearning about the CPU scheduling internals – part 3Preemptible kernelThe dynamic preemptible kernel featureWho runs the scheduler code?When does schedule() run?Minimally understanding the thread_info structureThe timer interrupt housekeeping – setting TIF_NEED_RESCHEDThe process context part – checking TIF_NEED_RESCHEDCPU scheduler entry points – a summaryThe core scheduler code in briefSummaryQuestionsFurther reading
Technical requirementsUnderstanding, querying, and setting the CPU affinity maskQuerying and setting a thread’s CPU affinity maskUsing taskset to perform CPU affinitySetting the CPU affinity mask on a kernel threadQuerying and setting a thread’s scheduling policy and prioritySetting the policy and priority within the kernel – on a kernel threadA real-world example – threaded interrupt handlersAn introduction to cgroupsCgroup controllersExploring the cgroups v2 hierarchyEnabling or disabling controllersThe cgroups within the hierarchySystemd and cgroupsOur cgroups v2 explorer scriptTrying it out – constraining the CPU resource via cgroups v2Leveraging systemd to set up CPU resource constraints on a serviceThe manual way – a cgroups v2 CPU controllerRunning Linux as an RTOS – an introductionPointers to building RTL for the mainline 6.x kernel (on x86_64)Miscellaneous scheduling related topicsA few small (kernel space) routines to check outThe ghOSt OSSummaryQuestionsFurther reading
Technical requirementsCritical sections, exclusive execution, and atomicityWhat is a critical section?A classic case – the global i ++Concepts – the lockCritical sections – a summary of key pointsData races – a more formal definitionConcurrency concerns within the Linux kernelMulticore SMP systems and data racesPreemptible kernels, blocking I/O, and data racesHardware interrupts and data racesLocking guidelines and deadlockMutex or spinlock? Which to use whenDetermining which lock to use – in theoryDetermining which lock to use – in practiceUsing the mutex lockInitializing the mutex lockCorrectly using the mutex lockMutex lock and unlock APIs and their usageMutex lock – via [un]interruptible sleep?Mutex locking – an example driverThe mutex lock – a few remaining pointsMutex lock API variantsThe semaphore and the mutexPriority inversion and the RT-mutexInternal designUsing the spinlockSpinlock – simple usageSpinlock – an example driverTest – sleep in an atomic contextTesting the buggy module on a 6.1 debug kernelLocking and interruptsScenario 1 – driver method and hardware interrupt handler run serialized, sequentiallyScenario 2 – driver method and hardware interrupt handler run interleavedScenario 2 on a single-core (UP) systemScenario 2 on a multicore (SMP) systemSolving the issue on UP and SMP with the spin_[un]lock_irq() API variantScenario 3 – some interrupts masked, driver method and hardware interrupt handler run interleavedInterrupt handling, bottom halves, and lockingInterrupt handling on Linux – a summary of key pointsBottom halves and lockingUsing spinlocks – a quick summaryLocking – common mistakes and guidelinesCommon mistakesLocking guidelinesSolutionsSummaryQuestionsFurther reading
Technical requirementsUsing the atomic_t and refcount_t interfacesThe newer refcount_t versus older atomic_t interfacesThe simpler atomic_t and refcount_t interfacesExamples of using refcount_t within the kernel codebase64-bit atomic integer operatorsA note on internal implementationUsing the RMW atomic operatorsRMW atomic operations – operating on device registersUsing the RMW bitwise operatorsUsing bitwise atomic operators – an exampleEfficiently searching a bitmaskUsing the reader-writer spinlockReader-writer spinlock interfacesTrying out the reader-writer spinlockPerformance issues with reader-writer spinlocksThe reader-writer semaphoreUnderstanding CPU caching basics, cache effects, and false sharingAn introduction to CPU cachesThe risks – cache coherency, performance issues, and false sharingWhat is the cache coherency problem?The false sharing issueLock-free programming with per-CPU and RCUPer-CPU variablesWorking with per-CPU variablesPer-CPU – an example kernel modulePer-CPU usage within the kernelUnderstanding and using the RCU (Read-Copy-Update) lock-free technology – a primerHow does RCU work?Trying out RCURCU: detailed documentationRCU usage within the kernelLock debugging within the kernelConfiguring a debug kernel for lock debuggingThe lock validator lockdep – catching locking issues earlyCatching deadlock bugs with lockdep – a few examplesExample 1 – catching a self deadlock bug with lockdepExample 2 – catching an AB-BA deadlock with lockdepBrief notes on lockdep – annotations and issuesA note on lockdep annotationsA note on lockdep – known issuesKernel lock statisticsViewing and interpreting the kernel lock statisticsIntroducing memory barriersAn example of using memory barriers in a device driverA note on marked accessesSummaryQuestionsFurther reading

Overview

Explore the intricacies of Linux kernel development with 'Linux Kernel Programming, 2nd Edition,' a hands-on guide covering the 6.1 LTS kernel. This updated book ensures lasting relevance with its focus on modern kernel features and best practices. Learn kernel module writing, memory management, and synchronization techniques to confidently engage in real-world development.

What this Book will help me do

Build and configure the 6.1 LTS Linux kernel from its source code.
Write modular and high-quality Linux kernel code using the LKM framework.
Gain advanced knowledge of Linux kernel internals, including memory management and CPU scheduling.
Address kernel concurrency issues effectively by mastering synchronization techniques.
Apply this knowledge to practical scenarios and real-world Linux-based projects.

Author(s)

Kaiwan N. Billimoria is a seasoned software engineer with extensive experience in Linux kernel programming and systems development. With a deep passion for sharing knowledge, Kaiwan aims to simplify complex concepts into approachable teachings for readers. His dedication is seen through his professional work and contributions to Linux and open source.

Who is it for?

This book is ideal for beginner and intermediate Linux programmers interested in delving into kernel programming. Suitable for readers with basic CLI and C programming knowledge, it assists those aiming to comprehensively understand Linux kernel internals. Whether you're a system developer or a curious learner, this guide will empower you to confidently work with Linux kernels.