Amazon no longer offers textbook rentals. We do!

Linux Kernel Development

by: Love, Robert

Linux Kernel Development

by: Love, Robert

ISBN 13:
9780672327209
ISBN 10:
0672327201
Edition: 3rd
Format: Paperback
Copyright: 01/01/2010
Publisher: Addison-Wesley Professional
Newer Edition

Rent

Sorry, this item is currently unavailable.

Note: Supplemental materials are not guaranteed with Rental or Used book purchases.

Extend or Purchase Your Rental at Any Time

Need to keep your rental past your due date? At any time before your due date you can extend or purchase your rental through your account.

Summary

An authoritative, practical guide that helps programmers better understand the Linux kernel and to write and develop kernel code.

1 Introduction to the Linux Kernel

(10)

Along Came Linus: Introduction to Linux

(2)

Overview of Operating Systems and Kernels

(2)

Linux Versus Classic Unix Kernels

(2)

Linux Kernel Versions

(1)

The Linux Kernel Development Community

(1)

Before We Begin

(2)

2 Getting Started with the Kernel

(12)

Obtaining the Kernel Source

(1)

Installing the Kernel Source

(1)

Using Patches

(1)

The Kernel Source Tree

(1)

Building the Kernel

(3)

Minimizing Build Noise

(1)

Spawning Multiple Build Jobs

(1)

Installing the Kernel

(1)

A Beast of a Different Nature

(5)

No libc

(1)

GNU C

(2)

No Memory Protection

(1)

No (Easy) Use of Floating Point

(1)

Small, Fixed-Size Stack

(1)

Synchronization and Concurrency

(1)

Portability Is Important

(1)

So Here We Are

(2)

3 Process Management

(16)

Process Descriptor and the Task Structure

(6)

Allocating the Process Descriptor

(1)

Storing the Process Descriptor

(1)

Process State

(2)

Manipulating the Current Process State

(1)

Process Context

(1)

The Process Family Tree

(1)

Process Creation

(3)

Copy-on-Write

(1)

fork()

(1)

vfork()

(1)

The Linux Implementation of Threads

(2)

Kernel Threads

(1)

Process Termination

(3)

Removal of the Process Descriptor

(1)

The Dilemma of the Parentless Task

(1)

Process Wrap Up

(1)

4 Process Scheduling

(24)

Policy

(3)

I/O-BoundVersus Processor-Bound Processes

(1)

Process Priority

(1)

Timeslice

(1)

Process Preemption

(1)

The Scheduling Policy in Action

(1)

The Linux Scheduling Algorithm

(14)

Runqueues

(3)

The Priority Arrays

(1)

Recalculating Timeslices

(1)

schedule()

(2)

Calculating Priority and Timeslice

(2)

Sleeping and Waking Up

(2)

The Load Balancer

(3)

Preemption and Context Switching

(2)

User Preemption

(1)

Kernel Preemption

(1)

Real-Time

(1)

Scheduler-Related System Calls

(2)

Scheduling Policy and Priority-Related System Calls

(1)

Processor Affinity System Calls

(1)

Yielding Processor Time

(1)

Scheduler Finale

(1)

5 System Calls

(12)

APIs, POSIX, and the C Library

(1)

Syscalls

(1)

System Call Numbers

(1)

System Call Performance

(1)

System Call Handler

(2)

Denoting the Correct System Call

(1)

Parameter Passing

(1)

System Call Implementation

(2)

Verifying the Parameters

(2)

System Call Context

(4)

Final Steps in Binding a System Call

(1)

Accessing the System Call from User-Space

(1)

Why Not to Implement a System Call

(1)

System Calls in Conclusion

(1)

6 Interrupts and Interrupt Handlers

(18)

Interrupts

(1)

Interrupt Handlers

(1)

Top Halves Versus Bottom Halves

(1)

Registering an Interrupt Handler

(3)

Freeing an Interrupt Handler

(1)

Writing an Interrupt Handler

(4)

Shared Handlers

(1)

A Real-Life Interrupt Handler

(2)

Interrupt Context

(1)

Implementation of Interrupt Handling

(3)

/proc/interrupts

(1)

Interrupt Control

(4)

Disabling and Enabling Interrupts

(1)

Disabling a Specific Interrupt Line

(1)

Status of the Interrupt System

(1)

Don't Interrupt Me; We're Almost Done!

(1)

7 Bottom Halves and Deferring Work

(26)

Bottom Halves

(3)

Why Bottom Halves?

(1)

A World of Bottom Halves

(2)

Softirqs

(4)

Implementation of Softirqs

(3)

Using Softirqs

100

(1)

Tasklets

101

(7)

Implementation of Tasklets

101

(3)

Using Tasklets

104

(1)

ksoftirqd

105

(2)

The Old BH Mechanism

107

(1)

Work Queues

108

(7)

Implementation of Work Queues

108

(3)

Using Work Queues

111

(3)

The Old Task Queue Mechanism

114

(1)

Which Bottom Half Should I Use?

115

(1)

Locking Between the Bottom Halves

116

(2)

Disabling Bottom Halves

116

(2)

The Bottom of Bottom-Half Processing

118

(1)

8 Kernel Synchronization Introduction

119

(12)

Critical Regions and Race Conditions

120

(2)

Why Do We Need Protection?

120

(2)

Locking

122

(4)

What Causes Concurrency, Anyway?

124

(1)

So, How Do I Know What Needs Protecting?

125

(1)

Deadlocks

126

(2)

Contention and Scalability

128

(2)

Locking and Your Code

130

(1)

9 Kernel Synchronization Methods

131

(26)

Atomic Operations

131

(6)

Atomic Integer Operations

132

(2)

Atomic Bitwise Operations

134

(3)

Spin Locks

137

(4)

Other Spin Lock Methods

140

(1)

Spin Locks and Bottom Halves

140

(1)

Reader-Writer Spin Locks

141

(2)

Semaphores

143

(3)

Creating and Initializing Semaphores

145

(1)

Using Semaphores

145

(1)

Reader-Writer Semaphores

146

(2)

Spin Locks Versus Semaphores

148

(1)

Completion Variables

148

(1)

BKL: The Big Kernel Lock

149

(2)

Seq Locks

150

(1)

Preemption Disabling

151

(2)

Ordering and Barriers

153

(3)

Synchronization Summarization

156

(1)

10 Timers and Time Management

157

(24)

Kernel Notion of Time

158

(1)

The Tick Rate: HZ

158

(4)

The Ideal HZ Value

160

(2)

Jiffies

162

(4)

Internal Representation of Jiffies

163

(1)

Jiffies Wraparound

164

(1)

User-Space and HZ

165

(1)

Hardware Clocks and Timers

166

(1)

Real-Time Clock

166

(1)

System Timer

167

(1)

The Timer Interrupt Handler

167

(2)

The Time of Day

169

(2)

Timers

171

(3)

Using Timers

172

(1)

Timer Race Conditions

173

(1)

The Timer Implementation

174

(1)

Delaying Execution

174

(5)

Busy Looping

175

(1)

Small Delays

176

(1)

schedule_timeout()

177

(2)

Out of Time

179

(2)

11 Memory Management

181

(28)

Pages

181

(2)

Zones

183

(2)

Getting Pages

185

(2)

Getting Zeroed Pages

186

(1)

Freeing pages

186

(1)

kmalloc()

187

(6)

gfp_mask Flags

188

(4)

kfree ()

192

(1)

vmalloc ()

193

(1)

Slab Layer

194

(4)

Design of the Slab Layer

195

(3)

Slab Allocator Interface

198

(3)

Statically Allocating on the Stack

201

(1)

Playing Fair on the Stack

202

(1)

High Memory Mappings

202

(2)

Permanent Mappings

203

(1)

Temporary Mappings

203

(1)

Per-CPU Allocations

204

(1)

The New percpu Interface

205

(2)

Per-CPU Data at Compile-Time

205

(1)

Per-CPU Data at Runtime

206

(1)

Reasons for Using Per-CPU Data

207

(1)

Which Allocation Method Should I Use?

208

(1)

12 The Virtual Filesystem

209

(26)

Common Filesystem Interface

209

(1)

Filesystem Abstraction Layer

210

(1)

Unix Filesystems

211

(1)

VFS Objects and Their Data Structures

212

(1)

Other VFS Objects

213

(1)

The Superblock Object

213

(4)

Superblock Operations

214

(3)

The Inode Object

217

(5)

Inode Operations

219

(3)

The Dentry Object

222

(4)

Dentry State

223

(1)

The Dentry Cache

223

(1)

Dentry Operations

224

(2)

The File Object

226

(5)

File Operations

227

(4)

Data Structures Associated with Filesystems

231

(1)

Data Structures Associated with a Process

232

(2)

Filesystems in Linux

234

(1)

13 The Block I/O Layer

235

(16)

Anatomy of a Block Device

236

(1)

Buffers and Buffer Heads

237

(2)

The bio structure

239

(3)

The Old Versus the New

242

(1)

Request Queues

242

(1)

Requests

243

(1)

I/O Schedulers

243

(7)

The Job of an I/O Scheduler

244

(1)

The Linus Elevator

244

(1)

The Deadline I/O Scheduler

245

(2)

The Anticipatory I/O Scheduler

247

(1)

The Complete Fair Queuing I/O Scheduler

248

(1)

The Noop I/O Scheduler

249

(1)

I/O Scheduler Selection

249

(1)

Summary

250

(1)

14 The Process Address Space

251

(18)

The Memory Descriptor

252

(3)

Allocating a Memory Descriptor

254

(1)

Destroying a Memory Descriptor

255

(1)

The mm_struct and Kernel Threads

255

(1)

Memory Areas

255

(6)

VMA Flags

257

(1)

VMA Operations

258

(1)

Lists and Trees of Memory Areas

259

(1)

Memory Areas in Real Life

260

(1)

Manipulating Memory Areas

261

(3)

find_vma()

262

(1)

find_vma_prev()

263

(1)

find_vma_intersection()

263

(1)

mmap() and do_mmap(): Creating an Address Interval

264

(2)

The mmap() System Call

265

(1)

munmap() and do_munmap(): Removing an Address Interval

266

(1)

The munmap() System Call

266

(1)

Page Tables

266

(2)

Conclusion

268

(1)

15 The Page Cache and Page Writeback

269

(10)

Page Cache

270

(3)

The address_space Object

270

(3)

Radix Tree

273

(1)

The Old Page Hash Table

273

(1)

The Buffer Cache

273

(1)

The pdflush Daemon

274

(3)

Laptop Mode

275

(1)

bdflush and kupdated

276

(1)

Congestion Avoidance: Why We Have Multiple Threads

276

(1)

To Make a Long Story Short

277

(2)

16 Modules

279

(12)

Hello, World!

279

(2)

Building Modules

281

(2)

At Home in the Source Tree

281

(1)

Living Externally

282

(1)

Installing Modules

283

(1)

Generating Module Dependencies

283

(1)

Loading Modules

283

(1)

Managing Configuration Options

284

(2)

Module Parameters

286

(2)

Exported Symbols

288

(1)

Wrapping Up Modules

289

(2)

17 kobjects and sysfs

291

(16)

kobjects

292

(1)

ktypes

293

(1)

ksets

293

(1)

Subsystems

294

(1)

Structure Confusion

294

(1)

Managing and Manipulating kobjects

295

(1)

Reference Counts

296

(2)

krefs

297

(1)

sysfs

298

(5)

Adding and Removing kobjects from sysfs

300

(1)

Adding Files to sysfs

300

(3)

The Kernel Events Layer

303

(2)

kobjects and sysfs in a Nutshell

305

(2)

18 Debugging

307

(14)

What You Need to Start

307

(1)

Bugs in the Kernel

308

(1)

printk()

308

(3)

The Robustness of printk()

309

(1)

Loglevels

309

(1)

The Log Buffer

310

(1)

syslogd and klogd

311

(1)

A Note About printk() and Kernel Hacking

311

(1)

Oops

311

(2)

ksymoops

313

(1)

kallsyms

313

(1)

Kernel Debugging Options

313

(1)

Atomicity Debugging

314

(1)

Asserting Bugs and Dumping Information

314

(1)

Magic SysRq Key

315

(1)

The Saga of a Kernel Debugger

316

(2)

gdb

316

(1)

kgdb

317

(1)

kdb

317

(1)

Poking and Probing the System

318

(2)

Using UID as a Conditional

318

(1)

Using Condition Variables

318

(1)

Using Statistics

318

(1)

Rate Limiting Your Debugging

319

(1)

Binary Searching to Find the Culprit Change

320

(1)

When All Else Fails: The Community

320

(1)

19 Portability

321

(14)

History of Portability in Linux

322

(1)

Word Size and Data Types

323

(5)

Opaque Types

325

(1)

Special Types

326

(1)

Explicitly Sized Types

326

(1)

Signedness of Chars

327

(1)

Data Alignment

328

(2)

Avoiding Alignment Issues

328

(1)

Alignment of Nonstandard Types

329

(1)

Structure Padding

329

(1)

Byte Order

330

(2)

History of Big- and Little-Endian

332

(1)

Byte Ordering in the Kernel

332

(1)

Time

332

(1)

Page Size

333

(1)

Processor Ordering

334

(1)

SMP, Kernel Preemption, and High Memory

334

(1)

Portability Is Fun

334

(1)

20 Patches, Hacking, and the Community

335

(10)

The Community

335

(1)

Linux Coding Style

336

(5)

Indention

336

(1)

Braces

336

(1)

Line Size

337

(1)

Naming

338

(1)

Functions

338

(1)

Comments

338

(1)

Typedefs

339

(1)

Using What Is Already Provided

339

(1)

No ifdefs in the Source

340

(1)

Structure Initializers

340

(1)

Fixing Code Up Ex Post Facto

340

(1)

Chain of Command

341

(1)

Submitting Bug Reports

341

(1)

Generating Patches

342

(1)

Submitting Patches

343

(1)

Conclusion

343

(2)

A Linked Lists

345

(8)

Circular Linked Lists

346

(1)

Moving Through a Linked List

347

(1)

The Linux Kernel's Implementation

347

(2)

The Linked-List Structure

348

(1)

Manipulating Linked Lists

349

(2)

Traversing Linked Lists

351

(2)

B Kernel Random Number Generator

353

(6)

Design and Implementation

354

(2)

The Dilemma of System Startup

356

(1)

Interfaces to Input Entropy

356

(1)

Interfaces to Output Entropy

357

(2)

C Algorithmic Complexity

359

(4)

Algorithms

359

(1)

Big-O Notation

359

(1)

Big Theta Notation

360

(1)

Putting It All Together

360

(1)

Perils of Time Complexity

361

(2)

Bibliography and Reading List

363

(4)

Books on Operating System Design

363

(1)

Books on Unix Kernels

364

(1)

Books on Linux Kernels

364

(1)

Books on Other Kernels

364

(1)

Books on the Unix API

365

(1)

Books on the C Programming Language

365

(1)

Other Works

365

(1)

Websites

366

(1)

Index

367

Amazon no longer offers textbook rentals. We do!

Linux Kernel Development

Linux Kernel Development

9780672327209

0672327201

Summary

Table of Contents

Supplemental Materials

Excerpts

Write a Review

Amazon no longer offers textbook rentals. We do!

Linux Kernel Development

Linux Kernel Development

9780672327209

0672327201

Summary

Table of Contents

Supplemental Materials

Excerpts

Write a Review

Related Products