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.
  • Book Overview & Buying Linux Kernel Programming
  • Table Of Contents Toc
Linux Kernel Programming

Linux Kernel Programming - Second Edition

By : Kaiwan N. Billimoria
4.8 (33)
Buy this Book
close
close
Linux Kernel Programming

Linux Kernel Programming

4.8 (33)
By: Kaiwan N. Billimoria
Buy this Book

Overview of this book

The 2nd Edition of Linux Kernel Programming is an updated, comprehensive guide for those new to Linux kernel development. Built around the latest 6.1 Long-Term Support (LTS) Linux kernel, which is maintained until December 2026, this edition explores its key features and enhancements. Additionally, with the Civil Infrastructure Project extending support for the 6.1 Super LTS (SLTS) kernel until August 2033, this book will remain relevant for years to come. You'll begin this exciting journey by learning how to build the kernel from source. Step by step, 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 (for example, 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 build a strong understanding of the fundamentals to 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
close
Preface
Icon
Preface
Icon
Who this book is for
Icon
What’s been added in the second edition?
Icon
What this book covers
Icon
Get in touch
1
Linux Kernel Programming – A Quick Introduction
Icon
Linux Kernel Programming – A Quick Introduction
Icon
Kernel workspace setup
Icon
Technical requirements
Icon
Cloning this book’s code repository
Lock Free Chapter
2
Building the 6.x Linux Kernel from Source – Part 1
Icon
Building the 6.x Linux Kernel from Source – Part 1
Icon
Technical requirements
Icon
Preliminaries for the kernel build
Icon
Steps to build the kernel from source
Icon
Step 1 – Obtaining a Linux kernel source tree
Icon
Step 2 – Extracting the kernel source tree
Icon
Step 3 – Configuring the Linux kernel
Icon
Customizing the kernel menu, Kconfig, and adding our own menu item
Icon
Summary
Icon
Exercise
Icon
Questions
Icon
Further reading
3
Building the 6.x Linux Kernel from Source – Part 2
Icon
Building the 6.x Linux Kernel from Source – Part 2
Icon
Technical requirements
Icon
Step 4 – building the kernel image and modules
Icon
Step 5 – installing the kernel modules
Icon
Step 6 – generating the initramfs image and bootloader setup
Icon
Understanding the initramfs framework
Icon
Step 7 – customizing the GRUB bootloader
Icon
Verifying our new kernel’s configuration
Icon
Kernel build for the Raspberry Pi
Icon
Miscellaneous tips on the kernel build
Icon
Summary
Icon
Questions
Icon
Further reading
4
Writing Your First Kernel Module – Part 1
Icon
Writing Your First Kernel Module – Part 1
Icon
Technical requirements
Icon
Understanding the kernel architecture – part 1
Icon
Exploring LKMs
Icon
Writing our very first kernel module
Icon
Common operations on kernel modules
Icon
Understanding kernel logging and printk
Icon
Understanding the basics of a kernel module Makefile
Icon
Summary
Icon
Questions
Icon
Further reading
5
Writing Your First Kernel Module – Part 2
chevron up
Icon
Writing Your First Kernel Module – Part 2
Icon
Technical requirements
Icon
A “better” Makefile template for your kernel modules
Icon
Cross-compiling a kernel module
Icon
Gathering minimal system information
Icon
Licensing kernel modules
Icon
Emulating “library-like” features for kernel modules
Icon
Passing parameters to a kernel module
Icon
Floating point not allowed in the kernel
Icon
Auto-loading modules on system boot
Icon
Kernel modules and security – an overview
Icon
Coding style guidelines for kernel developers
Icon
Contributing to the mainline kernel
Icon
Summary
Icon
Questions
Icon
Further reading
6
Kernel Internals Essentials – Processes and Threads
Icon
Kernel Internals Essentials – Processes and Threads
Icon
Technical requirements
Icon
Understanding process and interrupt contexts
Icon
Understanding the basics of the process Virtual Address Space (VAS)
Icon
Organizing processes, threads, and their stacks – user and kernel space
Icon
Understanding and accessing the kernel task structure
Icon
Working with the task structure via ‘current’
Icon
Iterating over the kernel’s task lists
Icon
Summary
Icon
Questions
Icon
Further reading
7
Memory Management Internals – Essentials
Icon
Memory Management Internals – Essentials
Icon
Technical requirements
Icon
Understanding the VM split
Icon
Examining the process VAS
Icon
Examining the kernel VAS
Icon
Randomizing the memory layout – KASLR
Icon
Understanding physical memory organization
Icon
Summary
Icon
Questions
Icon
Further reading
8
Kernel Memory Allocation for Module Authors – Part 1
Icon
Kernel Memory Allocation for Module Authors – Part 1
Icon
Technical requirements
Icon
Introducing kernel memory allocators
Icon
Understanding and using the kernel page allocator (or BSA)
Icon
Understanding and using the kernel slab allocator
Icon
Size limitations of the kmalloc API
Icon
Slab allocator – a few additional details
Icon
Caveats when using the slab allocator
Icon
Summary
Icon
Questions
Icon
Further reading
9
Kernel Memory Allocation for Module Authors – Part 2
Icon
Kernel Memory Allocation for Module Authors – Part 2
Icon
Technical requirements
Icon
Creating a custom slab cache
Icon
Debugging kernel memory issues – a quick mention
Icon
Understanding and using the kernel vmalloc() API
Icon
Memory allocation in the kernel – which APIs to use when
Icon
Memory reclaim – a key kernel housekeeping task
Icon
Stayin’ alive – the OOM killer
Icon
Summary
Icon
Questions
Icon
Further reading
10
The CPU Scheduler – Part 1
Icon
The CPU Scheduler – Part 1
Icon
Technical requirements
Icon
Learning about the CPU scheduling internals – part 1 – essential background
Icon
Visualizing the flow
Icon
Learning about the CPU scheduling internals – part 2
Icon
Querying a given thread’s scheduling policy and priority
Icon
Learning about the CPU scheduling internals – part 3
Icon
Summary
Icon
Questions
Icon
Further reading
11
The CPU Scheduler – Part 2
Icon
The CPU Scheduler – Part 2
Icon
Technical requirements
Icon
Understanding, querying, and setting the CPU affinity mask
Icon
Querying and setting a thread’s scheduling policy and priority
Icon
An introduction to cgroups
Icon
Running Linux as an RTOS – an introduction
Icon
Miscellaneous scheduling related topics
Icon
Summary
Icon
Questions
Icon
Further reading
12
Kernel Synchronization – Part 1
Icon
Kernel Synchronization – Part 1
Icon
Technical requirements
Icon
Critical sections, exclusive execution, and atomicity
Icon
Concurrency concerns within the Linux kernel
Icon
Mutex or spinlock? Which to use when
Icon
Using the mutex lock
Icon
Using the spinlock
Icon
Locking and interrupts
Icon
Locking – common mistakes and guidelines
Icon
Solutions
Icon
Summary
Icon
Questions
Icon
Further reading
13
Kernel Synchronization – Part 2
Icon
Kernel Synchronization – Part 2
Icon
Technical requirements
Icon
Using the atomic_t and refcount_t interfaces
Icon
Using the RMW atomic operators
Icon
Using the reader-writer spinlock
Icon
Understanding CPU caching basics, cache effects, and false sharing
Icon
Lock-free programming with per-CPU and RCU
Icon
Lock debugging within the kernel
Icon
Introducing memory barriers
Icon
Summary
Icon
Questions
Icon
Further reading
14
Other Books You May Enjoy
Icon
Other Books You May Enjoy
15
Index
Icon
Index

Passing parameters to a kernel module

A common debugging technique is to instrument your code; that is, insert prints at appropriate points such that you can follow the path the code takes. Within a kernel module, of course, we would use the versatile printk (and friends) functions for this purpose. So, let’s say we do something like the following (pseudo-code):

#define pr_fmt(fmt) "%s:%s():%d: " fmt, KBUILD_MODNAME, __func__, __LINE__
[ ... ]
func_x() { 
    pr_debug("At 1\n");
    [...]
    while (<cond>) {
        pr_debug("At 2: j=0x%x\n", j); 
        [...] 
 }
 [...]
}

Okay, great. But, hey, we don’t want the debug prints to appear in a production (or release) version. That’s precisely why we’re using pr_debug(): it emits a printk only when the DEBUG symbol is defined! Indeed, but what if, interestingly, our customer is an engineering customer and wants to dynamically turn on or turn off these debug prints...

Visually different images
CONTINUE READING
83
Tech Concepts
36
Programming languages
73
Tech Tools
Icon Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.
Icon Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.
Icon 50+ new titles added per month and exclusive early access to books as they are being written.
Linux Kernel Programming
End of Section 5
Next Section
notes
bookmark Notes and Bookmarks search Search in title playlist Add to playlist download Download options
font-size Font size

Change the font size

margin-width Margin width

Change margin width

day-mode Day/Sepia/Night Modes

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Confirmation

Modal Close icon
claim successful
Order Page Read Now

Buy this book with your credits?

Modal Close icon
Are you sure you want to buy this book with one of your credits?
Close
YES, BUY

Submit Your Feedback

Modal Close icon
Modal Close icon
Modal Close icon