Linux kernel programming a comprehensive guide to kernel internals, writing kernel modules, and kernel synchronization
Learn how to write high-quality kernel module code, solve common Linux kernel programming issues, and understand the fundamentals of Linux kernel internalsKey FeaturesDiscover how to write kernel code using the Loadable Kernel Module frameworkExplore industry-grade techniques to perform efficient me...
| Otros Autores: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham ; Mumbai :
Packt Publishing
2021.
|
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009631748706719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright and Credits
- Dedication
- Contributors
- Table of Contents
- Preface
- Section 1: The Basics
- Chapter 1: Kernel Workspace Setup
- Technical requirements
- Running Linux as a guest VM
- Installing a 64-bit Linux guest
- Turn on your x86 system's virtualization extension support
- Allocate sufficient space to the disk
- Install the Oracle VirtualBox Guest Additions
- Experimenting with the Raspberry Pi
- Setting up the software - distribution and packages
- Installing software packages
- Installing the Oracle VirtualBox guest additions
- Installing required software packages
- Installing a cross toolchain and QEMU
- Installing a cross compiler
- Important installation notes
- Additional useful projects
- Using the Linux man pages
- The tldr variant
- Locating and using the Linux kernel documentation
- Generating the kernel documentation from source
- Static analysis tools for the Linux kernel
- Linux Trace Toolkit next generation
- The procmap utility
- Simple Embedded ARM Linux System FOSS project
- Modern tracing and performance analysis with [e]BPF
- The LDV - Linux Driver Verification - project
- Summary
- Questions
- Further reading
- Chapter 2: Building the 5.x Linux Kernel from Source - Part 1
- Technical requirements
- Preliminaries for the kernel build
- Kernel release nomenclature
- Kernel development workflow - the basics
- Types of kernel source trees
- Steps to build the kernel from source
- Step 1 - obtaining a Linux kernel source tree
- Downloading a specific kernel tree
- Cloning a Git tree
- Step 2 - extracting the kernel source tree
- A brief tour of the kernel source tree
- Step 3 - configuring the Linux kernel
- Understanding the kbuild build system
- Arriving at a default configuration
- Obtaining a good starting point for kernel configuration.
- Kernel config for typical embedded Linux systems
- Kernel config using distribution config as a starting point
- Tuned kernel config via the localmodconfig approach
- Getting started with the localmodconfig approach
- Tuning our kernel configuration via the make menuconfig UI
- Sample usage of the make menuconfig UI
- More on kbuild
- Looking up the differences in configuration
- Customizing the kernel menu - adding our own menu item
- The Kconfig* files
- Creating a new menu item in the Kconfig file
- A few details on the Kconfig language
- Summary
- Questions
- Further reading
- Chapter 3: Building the 5.x Linux Kernel from Source - Part 2
- Technical requirements
- Step 4 - building the kernel image and modules
- Step 5 - installing the kernel modules
- Locating the kernel modules within the kernel source
- Getting the kernel modules installed
- Step 6 - generating the initramfs image and bootloader setup
- Generating the initramfs image on Fedora 30 and above
- Generating the initramfs image - under the hood
- Understanding the initramfs framework
- Why the initramfs framework?
- Understanding the basics of the boot process on the x86
- More on the initramfs framework
- Step 7 - customizing the GRUB bootloader
- Customizing GRUB - the basics
- Selecting the default kernel to boot into
- Booting our VM via the GNU GRUB bootloader
- Experimenting with the GRUB prompt
- Verifying our new kernel's configuration
- Kernel build for the Raspberry Pi
- Step 1 - cloning the kernel source tree
- Step 2 - installing a cross-toolchain
- First method - package install via apt
- Second method - installation via the source repo
- Step 3 - configuring and building the kernel
- Miscellaneous tips on the kernel build
- Minimum version requirements
- Building a kernel for another site
- Watching the kernel build run.
- A shortcut shell syntax to the build procedure
- Dealing with compiler switch issues
- Dealing with missing OpenSSL development headers
- Summary
- Questions
- Further reading
- Chapter 4: Writing Your First Kernel Module - LKMs Part 1
- Technical requirements
- Understanding kernel architecture - part 1
- User space and kernel space
- Library and system call APIs
- Kernel space components
- Exploring LKMs
- The LKM framework
- Kernel modules within the kernel source tree
- Writing our very first kernel module
- Introducing our Hello, world LKM C code
- Breaking it down
- Kernel headers
- Module macros
- Entry and exit points
- Return values
- The 0/-E return convention
- The ERR_PTR and PTR_ERR macros
- The __init and __exit keywords
- Common operations on kernel modules
- Building the kernel module
- Running the kernel module
- A quick first look at the kernel printk()
- Listing the live kernel modules
- Unloading the module from kernel memory
- Our lkm convenience script
- Understanding kernel logging and printk
- Using the kernel memory ring buffer
- Kernel logging and systemd's journalctl
- Using printk log levels
- The pr_<
- foo>
- convenience macros
- Wiring to the console
- Writing output to the Raspberry Pi console
- Enabling the pr_debug() kernel messages
- Rate limiting the printk instances
- Generating kernel messages from the user space
- Standardizing printk output via the pr_fmt macro
- Portability and the printk format specifiers
- Understanding the basics of a kernel module Makefile
- Summary
- Questions
- Further reading
- Chapter 5: Writing Your First Kernel Module - LKMs Part 2
- Technical requirements
- A "better" Makefile template for your kernel modules
- Configuring a "debug" kernel
- Cross-compiling a kernel module
- Setting up the system for cross-compilation.
- Attempt 1 - setting the "special" environment variables
- Attempt 2 - pointing the Makefile to the correct kernel source tree for the target
- Attempt 3 - cross-compiling our kernel module
- Attempt 4 - cross-compiling our kernel module
- Gathering minimal system information
- Being a bit more security-aware
- Licensing kernel modules
- Emulating "library-like" features for kernel modules
- Performing library emulation via multiple source files
- Understanding function and variable scope in a kernel module
- Understanding module stacking
- Trying out module stacking
- Passing parameters to a kernel module
- Declaring and using module parameters
- Getting/setting module parameters after insertion
- Module parameter data types and validation
- Validating kernel module parameters
- Overriding the module parameter's name
- Hardware-related kernel parameters
- Floating point not allowed in the kernel
- Auto-loading modules on system boot
- Module auto-loading - additional details
- Kernel modules and security - an overview
- Proc filesystem tunables affecting the system log
- The cryptographic signing of kernel modules
- Disabling kernel modules altogether
- Coding style guidelines for kernel developers
- Contributing to the mainline kernel
- Getting started with contributing to the kernel
- Summary
- Questions
- Further reading
- Section 2: Understanding and Working with the Kernel
- Chapter 6: Kernel Internals Essentials - Processes and Threads
- Technical requirements
- Understanding process and interrupt contexts
- Understanding the basics of the process VAS
- Organizing processes, threads, and their stacks - user and kernel space
- User space organization
- Kernel space organization
- Summarizing the current situation
- Viewing the user and kernel stacks
- Traditional approach to viewing the stacks.
- Viewing the kernel space stack of a given thread or process
- Viewing the user space stack of a given thread or process
- [e]BPF - the modern approach to viewing both stacks
- The 10,000-foot view of the process VAS
- Understanding and accessing the kernel task structure
- Looking into the task structure
- Accessing the task structure with current
- Determining the context
- Working with the task structure via current
- Built-in kernel helper methods and optimizations
- Trying out the kernel module to print process context info
- Seeing that the Linux OS is monolithic
- Coding for security with printk
- Iterating over the kernel's task lists
- Iterating over the task list I - displaying all processes
- Iterating over the task list II - displaying all threads
- Differentiating between the process and thread - the TGID and the PID
- Iterating over the task list III - the code
- Summary
- Questions
- Further reading
- Chapter 7: Memory Management Internals - Essentials
- Technical requirements
- Understanding the VM split
- Looking under the hood - the Hello, world C program
- Going beyond the printf() API
- VM split on 64-bit Linux systems
- Virtual addressing and address translation
- The process VAS - the full view
- Examining the process VAS
- Examining the user VAS in detail
- Directly viewing the process memory map using procfs
- Interpreting the /proc/PID/maps output
- The vsyscall page
- Frontends to view the process memory map
- The procmap process VAS visualization utility
- Understanding VMA basics
- Examining the kernel segment
- High memory on 32-bit systems
- Writing a kernel module to show information about the kernel segment
- Viewing the kernel segment on a Raspberry Pi via dmesg
- Macros and variables describing the kernel segment layout
- Trying it out - viewing kernel segment details.
- The kernel VAS via procmap.
