The Linux Kernel Primer: A Top-down Approach For X86 And Powerpc Architectures by Claudia Salzberg Rodriguez

The Linux Kernel Primer: A Top-down Approach For X86 And Powerpc Architectures

byClaudia Salzberg Rodriguez, Gordon Fischer, Steven Smolski

Paperback | September 19, 2005

not yet rated|write a review

Pricing and Purchase Info


Earn 305 plum® points

Ships within 1-2 weeks

Ships free on orders over $25

Not available in stores


Learn Linux kernel programming,hands-on: a uniquely effective top-down approach

Linux®Kernel Primeris the definitive guide to Linux kernel programming. The authors' unique top-down approach makes kernel programming easier to understand by systematically tracing functionality from user space into the kernel, and carefully associating kernel internals with user-level programming fundamentals. Their approach helps you build on what you already know about Linux, gaining a deep understanding of how the kernel works and how its elements fit together.

One step at a time, the authors introduce all the tools and assembly language programming techniques required to understand kernel code and control its behavior. They compare x86 and PowerPC implementations side-by-side, illuminating cryptic functionality through carefully-annotated source code examples and realistic projects.Linux®Kernel Primeris thefirstbook to offer in-depth coverage of the rapidly-growing PowerPC Linux development platform, and theonlybook to thoroughly discuss kernel configuration with the Linux build system. Coverage includes

  • Data structures

  • x86 and PPC assembly language

  • Viewing kernel internals

  • Linux process model

  • User and kernel space

  • Interrupts and exceptions

  • Memory allocation and tracking

  • Tracing subsystem behavior

  • I/O interactions

  • Filesystems and file operations

  • Scheduling and synchronization

  • Kernel boot process

  • Kernel build system

  • Configuration options

  • Device drivers

  • And more...

If you know C, this book teaches you all the skills and techniques you need to succeed with Linux kernel programming. Whether you're a systems programmer, software engineer, systems analyst, test professional, open source project contributor, or simply a Linux enthusiast, you'll find it indispensable.

© Copyright Pearson Education. All rights reserved.

About The Author

Claudia Salzberg Rodriguez has been a Linux systems programmer for over 5 years and has worked with Linux on a wide variety of platforms ranging from embedded to High Performance systems on both Intel and PPC. She received a Bachelor of Science from Brown University in 1997 and a Master of Science in Computer Science from the ...

Details & Specs

Title:The Linux Kernel Primer: A Top-down Approach For X86 And Powerpc ArchitecturesFormat:PaperbackDimensions:648 pages, 8.9 × 6.9 × 1.4 inPublished:September 19, 2005Publisher:Pearson EducationLanguage:English

The following ISBNs are associated with this title:

ISBN - 10:0131181637

ISBN - 13:9780131181632

Customer Reviews of The Linux Kernel Primer: A Top-down Approach For X86 And Powerpc Architectures


Extra Content

Read from the Book

Technology in general and computers in specific have a magical allure that seems to consume those who would approach them. Developments in technology push established boundaries and force the re-evaluation of troublesome concepts previously laid to rest. The Linux operating system has been a large contributor to a torrent of notable shifts in industry and the way business is done. By its adoption of the GNU Public License and its interactions with GNU software, it has served as a cornerstone to the various debates that surround open source, free software, and the concept of the development community. Linux is an extremely successful example of how powerful an open source operating system can be, and how the magic of its underpinnings can hold programmers from all corners of the world spellbound. The use of Linux is something that is increasingly accessible to most computer users. With multiple distributions, community support, and industry backing, the use of Linux has also found safe harbor in universities, industrial applications, and the homes of millions of users. Increased need in support and for new functionality follow at the heels of this upsurge in use. In turn, more and more programmers are finding themselves interested in the internals of the Linux kernel as the number of architectures and devices that demand support are added to the already vast (and rapidly growing) arsenal. The porting of the Linux kernel to the Power architecture has contributed to the operating system's blossoming among high-end servers and embedded systems. The need for understanding how Linux runs on the Power architecture has grown, with companies now purchasing PowerPC-based systems intended to run Linux. Intended Audience This book is intended for the budding and veteran systems programmer, the Linux enthusiast, and the application programmer eager to have a better understanding of what makes his programs work the way they do. Anyone who has knowledge of C, familiarity with basic Linux user fundamentals, and wants to know how Linux works should find this book provides him with the basic concepts necessary to build this understanding—it is intended to be a primer for understanding how the Linux kernel works. Whether your experience with Linux has been logging in and writing small programs to run on Linux, or you are an established systems programmer seeking to understand particularities of one of the subsystems, this book provides you with the information you are looking for. Organization of Material This book is divided into three parts, each of which provides the reader with knowledge necessary to succeed in the study of Linux internals. Part I provides the necessary tools and understanding to tackle the exploration of the kernel internals: Chapter 1, "Overview," provides a history of Linux and UNIX, a listing of the many distributions, and a short overview of the various kernel subsystems from a user space perspective. Chapter 2, "Exploration Toolkit," provides a description of the data structures and language usage commonly found throughout the Linux kernel, an introduction to assembly for x86 and PowerPC architectures, and a summary of tools and utilities used to get the information needed to understand kernel internals. Part II introduces the reader to the basic concepts in each kernel subsystem and to trace the code that executes the subsystem functionality: Chapter 3, "Processes: The Principal Model of Execution," covers the implementation of the process model. We explain how processes come to be and discuss the flow of control of a user space process into kernel space and back. We also discuss how processes are implemented in the kernel and discuss all data structures associated with process execution. This chapter also covers interrupts and exceptions, how these hardware mechanisms occur in each of the architectures, and how they interact with the Linux kernel. Chapter 4, "Memory Management," describes how the Linux kernel tracks and manages available memory among various user space processes and the kernel. This chapter describes the way in which the kernel categorizes memory and how it decides to allocate and deallocate memory. It also describes in detail the mechanism of the page fault and how it is executed in the hardware. Chapter 5, "Input/Output," describes how the processor interacts with other devices, and how the kernel interfaces and controls these interactions. This chapter also covers various kinds of devices and their implementation in the kernel. Chapter 6, "Filesystems," provides an overview of how files and directories are implemented in the kernel. This chapter introduces the virtual filesystem, the layer of abstraction used to support multiple filesystems. This chapter also traces the execution of file-related operations such as open and close. Chapter 7, "Scheduling and Kernel Synchronization," describes the operation of the scheduler, which allows multiple processes to run as though they are the only process in the system. This chapter covers in detail how the kernel selects which task to execute and how it interfaces with the hardware to switch from one process to another. This chapter also describes what kernel preemption is and how it is executed. Finally, it describes how the system clock works and its use by the kernel to keep time. Chapter 8, "Booting the Kernel," describes what happens from Power On to Power Off. It traces how the various processors handle the loading of the kernel, including a description of BIOS, Open Firmware, and bootloaders. This chapter then goes through the linear order in kernel bringup and initialization, covering all the subsystems discussed in previous chapters. Part III deals with a more hands-on approach to building and interacting with the Linux kernel: Chapter 9, "Building the Linux Kernel," covers the toolchain necessary to build the kernel and the format of the object files executed. It also describes in detail how the Kernel Source Build system operates and how to add configuration options into the kernel build system. Chapter 10, "Adding Your Code to the Kernel," describes the operation of /dev/random, which is seen in all Linux systems. As it traces the device, the chapter touches on previously described concepts from a more practical perspective. It then covers how to implement your own device in the kernel. Our Approach This book introduces the reader to the concepts necessary to understand the kernel. We follow a top-down approach in the following two ways: First, we associate the kernel workings with the execution of user space operations the reader may be more familiar with and strive to explain the kernel workings in association with this. When possible, we begin with a user space example and trace the execution of the code down into the kernel. It is not always possible to follow this tracing straight down since the subsystem data types and substructures need to be introduced before the explanation of how it works can take place. In these cases, we tie in explanations of the kernel subsystem with specific examples of how it relates to a user space program. The intent is twofold: to highlight the layering seen in the kernel as it interfaces with user space on one side and the hardware on the other, and to explain workings of the subsystem by tracing the code and following the order of events as they occur. We believe this will help the reader get a sense of how the kernel workings fit in with what he knows, and will provide him with a framed reference for how a particular functionality associates to the rest of the operating system. Second, we use the top-down perspective to view the data structures central to the operation of the subsystem and see how they relate to the execution of the system's management. We strive to delineate structures central to the subsystem operation and to keep focus on them as we follow the operation of the subsystem. Conventions Throughout this book, you will see listings of the source code. The top-right corner will hold the location of the source file with respect to the root of the source code tree. The listings are shown in this font. Line numbers are provided for the code commentary that usually follows. As we explain the kernel subsystem and how it works, we will continually refer to the source code and explain it. Command-line options, function names, function output, and variable names are distinguished by this font. Bold type is used whenever a new concept is introduced. © Copyright Pearson Education. All rights reserved.

Table of Contents


About the Authors.



 1. Overview.

 2. Exploration Toolkit.

 3. Processes: The Principal Model of Execution.

 4. Memory Management.

 5. Input/Output.

 6. Filesystems.

 7. Scheduling and Kernel Synchronization.

 8. Booting the Kernel.

 9. Building the Linux Kernel.

10. Adding Your Code to the Kernel.



Editorial Reviews

Link:   Full Text: I've been less than happy with other kernel books I've read. Admittedly,it's a difficult subject: there's a lot to cover, and you really need quite a bit of programming and general Unix knowledge before you could even consider jumping into this area. But I have the background,have even written simple Unix drivers, and yet every other kernel programming book has disappointed me. It's all so overwhelming: there are conventions and quirks that have developed over time and surely are second nature to the people who have been doing Linux kernels for years, but these things are baffling to the newcomer. This book tries to get you past that. The authors specifically say that they have tried to cover the things that confused them when they first started looking at the kernel. I'm sure their efforts aren't perfect, but the effort does definitely show. The authors present several programming projects to help explore the kernel concepts, and every chapter has review questions to help firm up your understanding. The approach is from user space when possible: the assumption is that you are comfortable with application programming and that is used as the base to lead you down into the work done by the kernel for your programs. There's plenty of annotated source code here, both for x86 and PowerPC architectures. The inclusion of PowerPC information was an unexpected bonus; other books I've read have usually ignored that entirely or glossed it over quickly. Of course you need a background in C, and while this does try to cover general kernel subjects, it wouldn't hurt to have at least some prior reading there. A little familiarity with hardware and light assembly language will help also, although the authors do give some coverage there. I'm looking forward to spending more time exploring this book.