Book Image

Linux Kernel Programming - Second Edition

By : Kaiwan N. Billimoria

Book Image

Linux Kernel Programming - Second Edition

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.

Preface

Who this book is for

What’s been added in the second edition?

What this book covers

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

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

Further reading

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

Further reading

Writing Your First Kernel Module – Part 1

Writing Your First Kernel Module – Part 1

Technical requirements

Understanding the kernel architecture – part 1

Writing our very first kernel module

Common operations on kernel modules

Understanding kernel logging and printk

Understanding the basics of a kernel module Makefile

Further reading

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

Further reading

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

Further reading

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

Further reading

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

Further reading

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

Further reading

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

Further reading

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

Further reading

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

Further reading

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

Further reading

Other Books You May Enjoy

Other Books You May Enjoy

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Miscellaneous scheduling related topics

We close this chapter with a couple of miscellaneous yet useful topic mentions.

A few small (kernel space) routines to check out

Here are a few kernel routines you may find useful (we leave it to you to look up the details and sample usage within the kernel):

rt_prio(): Given the priority as a parameter, returns a Boolean to indicate whether it’s a real-time task or not.
rt_task(): Based on the priority value of the task, given the task structure pointer as a parameter, returns a Boolean to indicate whether it’s a real-time task or not (a wrapper over rt_prio()).
task_is_realtime(): Similar, but based on the scheduling policy of the task. Given the task structure pointer as a parameter, returns a Boolean to indicate whether it’s a real-time task or not.

As the above routines all fall within a header (include/linux/sched/rt.h), simply include it and directly use them within your module...