Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Linux Kernel Programming
  • Toc
  • feedback
Linux Kernel Programming

Linux Kernel Programming

By : Kaiwan N. Billimoria
4.9 (35)
close
Linux Kernel Programming

Linux Kernel Programming

4.9 (35)
By: Kaiwan N. Billimoria

Overview of this book

The 2nd Edition of Linux Kernel Programming is an updated, comprehensive guide for new programmers to the Linux kernel. This book uses the recent 6.1 Long-Term Support (LTS) Linux kernel series, which will be maintained until Dec 2026, and also delves into its many new features. Further, the Civil Infrastructure Project has pledged to maintain and support this 6.1 Super LTS (SLTS) kernel right until August 2033, keeping this book valid for years to come! You’ll begin this exciting journey by learning how to build the kernel from source. In a step by step manner, you will then learn how to write your first kernel module by leveraging the kernel’s powerful Loadable Kernel Module (LKM) framework. With this foundation, you will delve into key kernel internals topics including Linux kernel architecture, memory management, and CPU (task) scheduling. You’ll finish with understanding the deep issues of concurrency, and gain insight into how they can be addressed with various synchronization/locking technologies (e.g., mutexes, spinlocks, atomic/refcount operators, rw-spinlocks and even lock-free technologies such as per-CPU and RCU). By the end of this book, you’ll have a much better understanding of the fundamentals of writing the Linux kernel and kernel module code that can straight away be used in real-world projects and products.
Table of Contents (16 chapters)
close
close
Preface
chevron up
Preface
Who this book is for
What’s been added in the second edition?
What this book covers
Get in touch
1
Linux Kernel Programming – A Quick Introduction
Linux Kernel Programming – A Quick Introduction
Kernel workspace setup
Technical requirements
Cloning this book’s code repository
Free Chapter
2
Building the 6.x Linux Kernel from Source – Part 1
Building the 6.x Linux Kernel from Source – Part 1
Technical requirements
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
Summary
Exercise
Questions
Further reading
3
Building the 6.x Linux Kernel from Source – Part 2
Building the 6.x Linux Kernel from Source – Part 2
Technical requirements
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
Summary
Questions
Further reading
4
Writing Your First Kernel Module – Part 1
Writing Your First Kernel Module – Part 1
Technical requirements
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
Summary
Questions
Further reading
5
Writing Your First Kernel Module – Part 2
Writing Your First Kernel Module – Part 2
Technical requirements
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
Summary
Questions
Further reading
6
Kernel Internals Essentials – Processes and Threads
Kernel Internals Essentials – Processes and Threads
Technical requirements
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
Summary
Questions
Further reading
7
Memory Management Internals – Essentials
Memory Management Internals – Essentials
Technical requirements
Understanding the VM split
Examining the process VAS
Examining the kernel VAS
Randomizing the memory layout – KASLR
Understanding physical memory organization
Summary
Questions
Further reading
8
Kernel Memory Allocation for Module Authors – Part 1
Kernel Memory Allocation for Module Authors – Part 1
Technical requirements
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
Summary
Questions
Further reading
9
Kernel Memory Allocation for Module Authors – Part 2
Kernel Memory Allocation for Module Authors – Part 2
Technical requirements
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
Summary
Questions
Further reading
10
The CPU Scheduler – Part 1
The CPU Scheduler – Part 1
Technical requirements
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
Summary
Questions
Further reading
11
The CPU Scheduler – Part 2
The CPU Scheduler – Part 2
Technical requirements
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
Summary
Questions
Further reading
12
Kernel Synchronization – Part 1
Kernel Synchronization – Part 1
Technical requirements
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
Summary
Questions
Further reading
13
Kernel Synchronization – Part 2
Kernel Synchronization – Part 2
Technical requirements
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
Summary
Questions
Further reading
14
Other Books You May Enjoy
Other Books You May Enjoy
15
Index
Index

What’s been added in the second edition?

A pretty huge amount of new material has been added into this, the Second Edition of the Linux Kernel Programming book. As well, being based on the very recent (as of this writing) 6.1 LTS release, its information and even code will remain industry-relevant for many, many years to come.

Here’s a quick chapter-wise summarization of what’s new in this second edition:

  • Materials updated for the 6.1 LTS kernel, maintained until December 2026, and until August 2033 via the CLP (6.1 SLTS)!
  • Updated, new, and working code for the 6.1 LTS kernel
  • Several new info-rich sections added to most chapters, many new diagrams, and new code examples to help explain concepts better
  • Chapter 1, Linux Kernel Programming – A Quick Introduction
    • Introduction to the book
  • Chapter 2, Building the 6.x Linux Kernel from Source – Part 1
    • The new LTS kernel lifetime mandate
    • More details on the kernel’s Kconfig+Kbuild system
    • Updated approaches on configuring the kernel
  • Chapter 3, Building the 6.x Linux Kernel from Source – Part 2
    • More details on the initramfs (initrd) image
    • Cross-compiling the kernel on an x86_64 host to an AArch64 target
  • Chapter 4, Writing Your First Kernel Module – Part 1
    • new-ish printk indexing feature covered
    • Powerful kernel dynamic debug feature introduced
    • Rate-limiting macros updated (deprecated ones not used)
  • Chapter 5, Writing Your First Kernel Module – Part 2
    • A better, ‘better’ Makefile (v0.2)
  • Chapter 6, Kernel Internals Essentials – Processes and Threads
    • New linked list demo module
  • Chapter 7, Memory Management Internals – Essentials
    • New coverage on how address translation works (including diagrams)
  • Chapter 8, Kernel Memory Allocation for Module Authors – Part 1
    • Coverage on using the “exact” page allocator API pair
    • FAQs regarding (slab) memory usage and their answers
    • The graphing demo (via gnuplot) is now automated and even saved to an image file, via a helper script
    • Finding internal fragmentation (wastage) within the kernel
  • Chapter 9, Kernel Memory Allocation for Module Authors – Part 2
    • Extracting useful information regarding slab caches
    • A word on slab shrinkers
    • Better coverage on the OOM killer (and systemd-oomd) and how it’s triggered; includes a flowchart depicting demand-paging and possible OOM killer invocation
    • Better coverage on kernel page reclaim, as well as the new MGLRU and DAMON technologies
  • Chapter 10, The CPU Scheduler – Part 1
    • New coverage on CFS scheduling period and timeslice. Coverage on the thread_info structure as well
    • New: the preempt dynamic feature
    • Enhanced coverage on exactly how and when schedule() is invoked
  • Chapter 11, The CPU Scheduler – Part 2
    • Much more depth in the powerful cgroups (v2) coverage plus an interesting script to let you explore its content
    • Leveraging the cgroups v2 CPU controller via both systemd and manually to perform CPU bandwidth allocation
    • A note on Google’s ghOSt OS
  • Chapter 12, Kernel Synchronization – Part 1
    • A new intro to the LKMM (Linux Kernel Memory Model)
    • More on locking plus deadlock avoidance guidelines
  • Chapter 13, Kernel Synchronization – Part 2
    • Expanded coverage on CPU caching and cache effects
    • New coverage on the powerful lock-free RCU synchronization technology
  • Online Chapter, Kernel Workspace Setup
    • Fixed errors in package names and versions
    • Ubuntu-based helper script that auto-installs all required packages

Most (if not all) earlier code errors, typos, and URLs are now fixed, based on prompt feedback, raising Issues/PRs on the book’s GitHub repo, from you, our wonderful readers!

Next Section
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete