Linux Kernel Primer, The: A Top-Down Approach for x86 and PowerPC Architectures
- By Claudia Salzberg Rodriguez, Gordon Fischer, Steven Smolski
- Published Sep 19, 2005 by Prentice Hall. Part of the Prentice Hall Open Source Software Development Series series.
- Copyright 2006
- Dimensions: 7x9-1/4
- Pages: 648
- Edition: 1st
- ISBN-10: 0-13-118163-7
- ISBN-13: 978-0-13-118163-2
Register your product to gain access to bonus material or receive a coupon.
Product Author Bios
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 University of Pennsylvania in 1999. She currently works in IBM's Linux Technology Center developing the kernel and associated programming tools.
Gordon Fischer has been using Linux and other Unices since 1996. He has written device drivers for RF tuners, modulators and other low-level devices. He has used both the 2.2 and 2.4 Linux kernels in enterprise settings ranging from servers to embedded devices across both i386 and PPC chipsets. He believes all code should be written in either C or LISP.
Steve Smolski has been in the semiconductor business for 26 years and has always been interested in the line between hardware and software. He has worked in manufacturing, test, and development of memory, processors, and ASICS. He has written applications and device drivers for Windows, AIX, Linux, and several embedded operating systems. His favorite jobs have been in robotics and multimedia.
© Copyright Pearson Education. All rights reserved.
Learn Linux kernel programming, hands-on: a uniquely effective top-down approach
The Linux® Kernel Primer is 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. The Linux® Kernel Primer is the first book to offer in-depth coverage of the rapidly growing PowerPC Linux development platform, and the only book to thoroughly discuss kernel configuration with the Linux build system. Coverage includes
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
Filesystems and file operations
Scheduling and synchronization
Kernel boot process
Kernel build system
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.
23 of 26 people found the following review helpful
Finally, a good Kernel book,
This review is from: The Linux Kernel Primer: A Top-Down Approach for x86 and PowerPC Architectures (Paperback)I've been less than happy with other kernel books before, so when this landed in my mailbox, I was prepared for disappointment. I've been down this road: it's too overwhelming a subject, authors typically assume far too much prior knowledge, and I'm left feeling puzzled and confused.
Well, the subject is overwhelming, and it really can't be covered in one book. But you have to start somewhere, and this looks like the best place I've seen so far. Yes, of course you'll need and want other books, and you'll need to spend a lot of time experimenting on your own, but this is (as the title says) your primer: the book that introduces and explains all the confusing little conventions and quirks that you need to know to avoid being totally lost.
I really like the approach of trying to relate everything to user space programs and of writing example code and drivers to illustrate concepts. The authors have also made an effort to point out and elucidate the things that... Read more
9 of 10 people found the following review helpful
This review is from: The Linux Kernel Primer: A Top-Down Approach for x86 and PowerPC Architectures (Paperback)A good basic intro to the linux kernel, pretty much exactly what I was looking for. I bought this to act as a primer before delving into Understanding the Linux Kernel, which is a much deeper and difficult work, and it's proved very satisfactory.
The major problem I have is that it seems not to have been proofread AT ALL. I have found at least a typo a page on average, and not just punctuation and spelling mistakes. Using the wrong name for a function, referring the reader to the wrong figure, chapter or section, that kind of typo. The design of the book (notational conventions, typefaces, how they display varible names vs. code blocks vs. normal text, etc) is quite inconsistent at times.
All in all, a good read, and a great intro, but very inconsistent and error-ridden; prepare to read it with oversight.
11 of 13 people found the following review helpful
excellent linux kernel intro,
This review is from: The Linux Kernel Primer: A Top-Down Approach for x86 and PowerPC Architectures (Paperback)Really appreciate the detailed comparison of x86 and PPC assembler, description of analysis tools, and the exercises. The exercises are extremely useful to determine whether or not you actually need to read a chapter. The book assumes you're going to do a lot of hands-on exploration and analysis while you're reading, and gears a lot of its examples and exercises towards that activity. Between this, and the referrals back to the differences between an x86 and PPC implementation (when necessary) and the detailed blow-by-blow of booting may make it a better buy for the kernel newbie than the O'Reilly book Understanding the Linux Kernel.
› See all 12 customer reviews...
Online Sample Chapter
Table of Contents
About the Authors.
2. Exploration Toolkit.
3. Processes: The Principal Model of Execution.
4. Memory Management.
7. Scheduling and Kernel Synchronization.
8. Booting the Kernel.
9. Building the Linux Kernel.
10. Adding Your Code to the Kernel.
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 AudienceThis 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 understandingit 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 MaterialThis 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 ApproachThis 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.
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.
Downloadable Sample Chapter
Download the Sample
Chapter related to this title.
Download the Index
file related to this title.
This book includes free shipping!
Get access to thousands of books and training videos about technology, professional development and digital media from more than 40 leading publishers, including Addison-Wesley, Prentice Hall, Cisco Press, IBM Press, O'Reilly Media, Wrox, Apress, and many more. If you continue your subscription after your 30-day trial, you can receive 30% off a monthly subscription to the Safari Library for up to 12 months. That's a total savings of $199.