Linux Kernel Programming, Second Edition: A practical guide to kernel internals, writing kernel modules, and synchronization

Cloning this book’s code repository

Free Chapter

Building the 6.x Linux Kernel from Source – Part 1

Preliminaries for the kernel build

Steps to build the kernel from source

Step 1 – Obtaining a Linux kernel source tree

Step 2 – Extracting the kernel source tree

Step 3 – Configuring the Linux kernel

Customizing the kernel menu, Kconfig, and adding our own menu item

Exercise

Building the 6.x Linux Kernel from Source – Part 2

Step 4 – building the kernel image and modules

Step 5 – installing the kernel modules

Step 6 – generating the initramfs image and bootloader setup

Understanding the initramfs framework

Step 7 – customizing the GRUB bootloader

Verifying our new kernel’s configuration

Kernel build for the Raspberry Pi

Miscellaneous tips on the kernel build

Writing Your First Kernel Module – Part 1

Understanding the kernel architecture – part 1

Exploring LKMs

Writing our very first kernel module

Common operations on kernel modules

Understanding kernel logging and printk

Understanding the basics of a kernel module Makefile

Writing Your First Kernel Module – Part 2

A “better” Makefile template for your kernel modules

Cross-compiling a kernel module

Gathering minimal system information

Licensing kernel modules

Emulating “library-like” features for kernel modules

Passing parameters to a kernel module

Floating point not allowed in the kernel

Auto-loading modules on system boot

Kernel modules and security – an overview

Coding style guidelines for kernel developers

Contributing to the mainline kernel

Kernel Internals Essentials – Processes and Threads

Understanding process and interrupt contexts

Understanding the basics of the process Virtual Address Space (VAS)

Organizing processes, threads, and their stacks – user and kernel space

Understanding and accessing the kernel task structure

Working with the task structure via ‘current’

Iterating over the kernel’s task lists

Memory Management Internals – Essentials

Understanding the VM split

Examining the process VAS

Examining the kernel VAS

Randomizing the memory layout – KASLR

Understanding physical memory organization

Kernel Memory Allocation for Module Authors – Part 1

Introducing kernel memory allocators

Understanding and using the kernel page allocator (or BSA)

Understanding and using the kernel slab allocator

Size limitations of the kmalloc API

Slab allocator – a few additional details

Caveats when using the slab allocator

Kernel Memory Allocation for Module Authors – Part 2

Creating a custom slab cache

Debugging kernel memory issues – a quick mention

Understanding and using the kernel vmalloc() API

Memory allocation in the kernel – which APIs to use when

Memory reclaim – a key kernel housekeeping task

Stayin’ alive – the OOM killer

The CPU Scheduler – Part 1

Learning about the CPU scheduling internals – part 1 – essential background

Visualizing the flow

Learning about the CPU scheduling internals – part 2

Querying a given thread’s scheduling policy and priority

Learning about the CPU scheduling internals – part 3

The CPU Scheduler – Part 2

Understanding, querying, and setting the CPU affinity mask

Querying and setting a thread’s scheduling policy and priority

An introduction to cgroups

Running Linux as an RTOS – an introduction

Miscellaneous scheduling related topics

Kernel Synchronization – Part 1

Critical sections, exclusive execution, and atomicity

Concurrency concerns within the Linux kernel

Mutex or spinlock? Which to use when

Using the mutex lock

Using the spinlock

Locking and interrupts

Locking – common mistakes and guidelines

Solutions

Kernel Synchronization – Part 2

Using the atomic_t and refcount_t interfaces

Using the RMW atomic operators

Using the reader-writer spinlock

Understanding CPU caching basics, cache effects, and false sharing

Lock-free programming with per-CPU and RCU

Lock debugging within the kernel

Introducing memory barriers