Mastering Linux Kernel Development电子书

Title Page

Copyright

Mastering Linux Kernel Development

Credits

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Errata

Piracy

Questions

Comprehending Processes, Address Space, and Threads

Processes

The illusion called address space

Kernel and user space

Process context

Process descriptors

Process attributes - key elements

state

pid

tgid

thread info

flags

exit_code and exit_signal

comm

ptrace

Process relations - key elements

real_parent and parent

children

sibling

group_leader

Scheduling attributes - key elements

prio and static_prio

se, rt, and dl

policy

cpus_allowed

rt_priority

Process limits - key elements

File descriptor table - key elements

fs

files

Signal descriptor - key elements

signal

sighand

sigset_t blocked, real_blocked

pending

sas_ss_sp

sas_ss_size

Kernel stack

The issue of stack overflow

Process creation

fork()

Copy-on-write (COW)

exec

vfork()

Linux support for threads

clone()

Kernel threads

do_fork() and copy_process()

Process status and termination

wait

exit

Namespaces and cgroups

Mount namespaces

UTS namespaces

IPC namespaces

PID namespaces

Network namespaces

User namespaces

Cgroup namespaces

Control groups (cgroups)

Summary

Deciphering the Process Scheduler

Process schedulers

Linux process scheduler design

Runqueue

The scheduler's entry point

Process priorities

Scheduler classes

Completely Fair Scheduling class (CFS)

Computing priorities and time slices under CFS

CFS's runqueue

Group scheduling

Scheduling entities under many-core systems

Scheduling policies

Real-time scheduling class

FIFO

RR

Real-time group scheduling

Deadline scheduling class (sporadic task model deadline scheduling)

Scheduler related system calls

Processor affinity calls

Process preemption

Summary

Signal Management

Signals

Signal-management APIs

Raising signals from a program

Waiting for queued signals

Signal data structures

Signal descriptors

Blocked and pending queues

Signal handler descriptor

Signal generation and delivery

Signal-generation calls

Signal delivery

Executing user-mode handlers

Setting up user-mode handler frames

Restarting interrupted system calls

Summary

Memory Management and Allocators

Initialization operations

Page descriptor

Flags

Mapping

Zones and nodes

Memory zones

Memory nodes

Node descriptor structure

Zone descriptor structure

Memory allocators

Page frame allocator

Buddy system

GFP mask

Zone modifiers

Page mobility and placement

Watermark modifiers

Page reclaim modifiers

Action modifiers

Type flags

Slab allocator

Kmalloc caches

Object caches

Cache management

Cache layout - generic

Slub data structures

Vmalloc

Contiguous Memory Allocator (CMA)

Summary

Filesystems and File I/O

Filesystem - high-level view

Metadata

Inode (index node)

Data block map

Directories

Superblock

Operations

Mount and unmount operations

File creation and deletion operations

File open and close operations

File read and write operations

Additional features

Extended file attributes

Filesystem consistency and crash recovery

Access control lists (ACLs)

Filesystems in the Linux kernel

Ext family filesystems

Ext2

Ext3

Ext4

Common filesystem interface

VFS structures and operations

struct superblock

struct inode

Struct dentry

struct file

Special filesystems

Procfs

Sysfs

Debugfs

Summary

Interprocess Communication

Pipes and FIFOs

pipefs

Message queues

System V message queues

Data structures

POSIX message queues

Shared memory

System V shared memory

Operation interfaces

Allocating shared memory

Attaching a shared memory

Detaching shared memory

Data structures

POSIX shared memory

Semaphores

System V semaphores

Data structures

POSIX semaphores

Summary

Virtual Memory Management

Process address space

Process memory descriptor

Managing virtual memory areas

Locating a VMA

Merging VMA regions

struct address_space

Page tables

Summary

Kernel Synchronization and Locking

Atomic operations

Atomic integer operations

Atomic bitwise operations

Introducing exclusion locks

Spinlocks

Alternate spinlock APIs

Reader-writer spinlocks

Mutex locks

Debug checks and validations

Wait/wound mutexes

Operation interfaces:

Semaphores

Reader-writer semaphores

Sequence locks

API

Completion locks

Initialization

Waiting for completion

Signalling completion

Summary

Interrupts and Deferred Work

Interrupt signals and vectors

Programmable interrupt controller

Interrupt controller operations

IRQ descriptor table

High-level interrupt-management interfaces

Registering an interrupt handler

Deregistering an interrupt handler

Threaded interrupt handlers

Control interfaces

IRQ stacks

Deferred work

Softirqs

Tasklets

Workqueues

Interface API

Creating dedicated workqueues

Summary

Clock and Time Management

Time representation

Timing hardware

Real-time clock (RTC)

Timestamp counter (TSC)

Programmable interrupt timer (PIT)

CPU local timer

High-precision event timer (HPET)

ACPI power management timer (ACPI PMT)

Hardware abstraction

Calculating elapsed time

Linux timekeeping data structures, macros, and helper routines

Jiffies

Timeval and timespec

Tracking and maintaining time

Tick and interrupt handling

Tick devices

Software timers and delay functions

Dynamic timers

Race conditions with dynamic timers

Dynamic timer handling

Delay functions

POSIX clocks

Summary

Module Management

Kernel modules

Elements of an LKM

Binary layout of a LKM

Load and unload operations

Module data structures

Memory layout

Summary