Enhanced descriptions from Syndetics:

Linux Kernel Development details the design and implementation of the Linux kernel, presenting the content in a manner that is beneficial to those writing and developing kernel code, as well as to programmers seeking to better understand the operating system and become more efficient and productive in their coding.

The book details the major subsystems and features of the Linux kernel, including its design, implementation, and interfaces. It covers the Linux kernel with both a practical and theoretical eye, which should appeal to readers with a variety of interests and needs.

The author, a core kernel developer, shares valuable knowledge and experience on the 2.6 Linux kernel. Specific topics covered include process management, scheduling, time management and timers, the system call interface, memory addressing, memory management, the page cache, the VFS, kernel synchronization, portability concerns, and debugging techniques. This book covers the most interesting features of the Linux 2.6 kernel, including the CFS scheduler, preemptive kernel, block I/O layer, and I/O schedulers.

The third edition of Linux Kernel Development includes new and updated material throughout the book:

An all-new chapter on kernel data structures Details on interrupt handlers and bottom halves Extended coverage of virtual memory and memory allocation Tips on debugging the Linux kernel In-depth coverage of kernel synchronization and locking Useful insight into submitting kernel patches and working with the Linux kernel community

Table of contents provided by Syndetics

• Preface
• 1 Introduction to the Linux Kernel
• 2 Getting Started with the Kernel
• 3 Process Management
• 4 Process Scheduling
• 5 System Calls
• 6 Kernel Data Structures
• 7 Interrupts and Interrupt Handlers
• 8 Bottom Halves and Deferring Work
• 9 An Introduction to Kernel Synchronization
• 10 Kernel Synchronization Methods
• 11 Timers and Time Management
• 12 Memory Management
• 13 The Virtual Filesystem
• 14 The Block I/O Layer
• 15 The Process Address Space
• 16 The Page Cache and Page Writeback
• 17 Modules
• 18 Device Drivers
• 19 Debugging
• 20 Portability
• 21 Patches, Hacking, and the Community
• Appendix A
• Algorithmic Complexity

Excerpt provided by Syndetics

Linux Kernel Development, Second Edition Preface When I was first approached about converting my experiences with the Linux kernel into a book, I proceeded with trepidation. I did not want to write simply yet another kernel book. Sure, there are not that many books on the subject, but I still wanted my approach to be somehow unique. What would place my book at the top of its subject? I was not motivated unless I could do something special, a best-in-class work. I then realized that I could offer quite a unique approach to the topic. My job is hacking the kernel. My hobby is hacking the kernel. Mylove is hacking the kernel.Over the years, I have surely accumulated interesting anecdotes and important tips. With my experiences, I could write a book on how to hack the kernel and--more importantly--how not to hack the kernel. Primarily, this is a book about the design and implementation of the Linux kernel. The book's approach differs from would-be competition, however, in that the information is given with a slant to learning enough to actually get work done--and getting it done right. I am a pragmatic guy and this is a practical book. It should be fun, easy to read, and useful. I hope that readers can walk away from this book with a better understanding of the rules (written and unwritten) of the kernel. I hope readers, fresh from reading this book and the kernel source code, can jump in and start writing useful, correct, clean kernel code. Of course, you can read this book just for fun, too. That was the first edition. Time has passed, and now we return once more to the fray. This edition offers quite a bit over the first: intense polish and revision, updates, and many fresh sections and all new chapters. Changes in the kernel since the first edition have been recognized. More importantly, however, is the decision made by the Linux kernel community 1 to not proceed with a 2.7 development kernel in the near feature. Instead, kernel developers plan to continue developing and stabilizing 2.6. This implies many things, but one big item of relevance to this book is that there is quite a bit of staying power in a recent book on the 2.6 Linux kernel. If things do not move too quickly, there is a greater chance of a captured snapshot of the kernel remaining relevant long into the future. A book can finally rise up and become the canonical documentation for the kernel. I hope that you are holding that book. Anyhow, here it is. I hope you enjoy it. So Here We Are Developing code in the kernel does not require genius, magic, or a bushy Unix-hacker beard. The kernel, although having some interesting rules of its own, is not much different from any other large software endeavor. There is much to learn--as with any big project--but there is not too much about the kernel that is more sacred or confusing than anything else. It is imperative that you utilize the source. The open availability of the source code for the Linux system is a rarity that we must not take for granted. It is not sufficient only to read the source, however. You need to dig in and change some code. Find a bug and fix it. Improve the drivers for your hardware. Find an itch and scratch it! Only when you write code will it all come together. Kernel Version This book is based on the 2.6 Linux kernel series. Specifically, it is up to date as of Linux kernel version 2.6.10. The kernel is a moving target and no book can hope to capture a dynamic beast in a timeless manner. Nonetheless, the basics and core internals of the kernel are mature and I work hard to present the material with an eye to the future and with as wide applicability as possible. Audience This book targets software developers who are interested in understanding the Linux kernel. It is not a line-by-line commentary of the kernel source. Nor is it a guide to developing drivers or a reference on the kernel API (as if there even were a formal kernel API--hah!). Instead, the goal of this book is to provide enough information on the design and implementation of the Linux kernel that a sufficiently accomplished programmer can begin developing code in the kernel. Kernel development can be fun and rewarding, and I want to introduce the reader to that world as readily as possible. This book, however, in discussing both theory and application, should appeal to readers of either interest. I have always been of the mind that one needs to understand the theory to understand the application, but I do not feel that this book leans too far in either direction. I hope that whatever your motivations for understanding the Linux kernel, this book will explain the design and implementation sufficiently for your needs. Thus, this book covers both the usage of core kernel systems and their design and implementation. I think this is important, and deserves a moment's discussion. A good example is Chapter 7, "Bottom Halves and Deferring Work," which covers bottom halves. In that chapter, I discuss both the design and implementation of the kernel's bottom-half mechanisms (which a core kernel developer might find interesting) and how to actually use the exported interfaces to implement your own bottom half (which a device driver developer might find interesting). In fact, I believe both parties should find both discussions relevant. The core kernel developer, who certainly needs to understand the inner workings of the kernel, should have a good understanding of how the interfaces are actually used. At the same time, a device driver writer will benefit from a good understanding of the implementation behind the interface. This is akin to learning some library's API versus studying the actual implementation of the library. At first glance, an application programmer needs only to understand the API--it is often taught to treat interfaces as a black box, in fact. Likewise, a library developer is concerned only with the library's design and implementation. I believe, however, both parties should invest time in learning the other half. An application programmer who better understands the underlying operating system can make much greater use of it. Similarly, the library developer should not grow out of touch with the reality and practicality of the applications that use the library. Consequently, I discuss both the design and usage of kernel subsystems, not only in hopes that this book will be useful to either party, but also in hopes that the whole book is useful to both parties. I assume that the reader knows the C programming language and is familiar with Linux. Some experience with operating system design and related computer science concepts is beneficial, but I try to explain concepts as much as possible--if not, there are some excellent books on operating system design referenced in the bibliography. This book is appropriate for an undergraduate course introducing operating system design as the applied text if an introductory book on theory accompanies it. It should fare well either in an advanced undergraduate course or in a graduate-level course without ancillary material. I encourage potential instructors to contact me; I am eager to help. Book Website I maintain a website at http://tech9.net/rml/kernel_book/ that contains information pertaining to the book, including errata, expanded and revised topics, and information on future printings and editions. I encourage readers to check it out. I also apologize profusely for the previous end-of-sentence preposition, it was uncalled for, but the revamped sentence was hard to read, it was confusing, and you deserve better . Second Edition Acknowledgments Like most authors, I did not write this book in a cave (which is a good thing, because there are bears in caves) and consequently many hearts and minds contributed to the completion of this manuscript. Although no list would be complete, it is my sincere pleasure to acknowledge the assistance of many friends and colleagues who provided encouragement, knowledge, and constructive criticism. First off, I would like to thank all of the editors who worked long and hard to make this book better. I would particularly like to thank Scott Meyers, my acquisition editor, for spearheading this second edition from conception to final product. I had the wonderful pleasure of again working with George Nedeff, production editor, who kept everything in order. Extra special thanks to my copy editor, Margo Catts. We can all only hope that our command of the kernel is as good as her command of the written word. A special thanks to my technical editors on this edition: Adam Belay, Martin Pool, and Chris Rivera. Their insight and corrections improved this book immeasurably. Despite their sterling efforts, however, any remaining mistakes are my own fault. The same big thanks to Zack Brown, whose awesome technical editing efforts on the first edition still resonate loudly. Many fellow kernel developers answered questions, provided support, or simply wrote code interesting enough on which to write a book. They are Andrea Arcangeli, Alan Cox, Greg Kroah-Hartman, Daniel Phillips, Dave Miller, Patrick Mochel, Andrew Morton, Zwane Mwaikambo, Nick Piggin, and Linus Torvalds. Special thanks to the kernel cabal (there is no cabal). Respect and love to Paul Amici, Scott Anderson, Mike Babbitt, Keith Barbag, Dave Camp, Dave Eggers, Richard Erickson, Nat Friedman, Dustin Hall, Joyce Hawkins, Miguel de Icaza, Jimmy Krehl, Patrick LeClair, Doris Love, Jonathan Love, Linda Love, Randy O'Dowd, Sal Ribaudo and mother, Chris Rivera, Joey Shaw, Jon Stewart, Jeremy VanDoren and family, Luis Villa, Steve Weisberg and family, and Helen Whisnant. Finally, thank you to my parents, for so much. Happy Hacking! -Robert Love Cambridge, Massachusetts This decision was made in the summer of 2004 at the annual Linux Kernel Developers Summit in Ottawa, Canada. © Copyright Pearson Education. All rights reserved. Excerpted from Linux Kernel Development by Robert Love All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Reviews provided by Syndetics

Library Journal Review

These Linux titles target intermediate to advanced users (for introductory guides, see Computer Media, LJ 1/05). For intermediate users with a Linux background but little security experience, Linux Server Security covers general topics such as intrusion detection, hardening the OS, threat modeling, and risk management and provides specific steps toward securing key services like DNS, Apache server, and mail. It takes a clear, step-by-step, topical approach to securing the most widely used Linux server applications and services. The inclusion of general guidelines, background, and explanation, as well as specific configuration details, makes this a recommended guide for all medium and larger collections. With a nice combination of context and how-to, Linux Network Administrator's Guide addresses beginning to intermediate Linux users needing to set up and administer Linux networks. It walks readers through networking fundamentals, configuring a Linux TCP/IP network, and using and configuring common and important features (including NAT, email, Apache, and Samba), before ending with a discussion of wireless networking. A thorough and clear guide; highly recommended for all libraries. GNU/Linux Application Programming shows how to program applications in this environment, beginning with an introduction to GNU/Linux and open-source licensing, then on to programming tools and useful services, the use of shells and scripting languages, and, finally, debugging, testing, and security. Overall, the most common commands, tools, and uses are stressed; appendixes include acronyms and the text of the GNU GPL. Its CD includes example code and figures from the title. Especially useful for developers wanting to move into the Linux environment; appropriate for large libraries. Linux Kernel Development is a straightforward guide for C programmers and Linux users looking to understand enough about the design and implementation of the kernel to be able to write and modify kernel code themselves. Beginning with a nice overview of the kernel and ending with information on participating in the kernel community, it provides just enough background to be useful, while never losing sight of its practical foundations. Recommended for large libraries. (c) Copyright 2010. Library Journals LLC, a wholly owned subsidiary of Media Source, Inc. No redistribution permitted. All rights reserved.

Author notes provided by Syndetics

Robert Love is an open source programmer, speaker, and author who has been using and contributing to Linux for more than 15 years. He is currently senior software engineer at Google, where he was a member of the team that developed the Android mobile platform's kernel. Prior to Google, he was Chief Architect, Linux Desktop, at Novell. Before Novell, he was a kernel engineer at MontaVista Software and Ximian.

¿

Love's kernel projects include the preemptive kernel, the process scheduler, the kernel events layer, inotify,VM enhancements, and several device drivers.

¿

He has given numerous talks on and has written multiple articles about the Linux kernel and is a contributing editor for Linux Journal. His other books include Linux System Programming and Linux in a Nutshell.