Linux Kernel Development (2nd Edition) is a great book. It is written in as easy a style as possible for a topic as technical as the internal details of the Linux kernel. If you are someone with some programming experience who wants to learn how the Linux kernel works, this is a great place to start.

The book goes into good detail for pretty much all of the main tasks the kernel performs. It includes simple code examples, with easy to understand explanations. If you need a book that goes line by line through the kernel... this is not for you. But, if you need a book that explains the basics thoroughly, but doesn't bore you to death with detail after detail, then buy this book already.

Note: This book covers up to 2.6.10, which is starting to get a bit old. 2.6.26 is current as of this review, so some of this info is out of date, but still is helpful.

This book is just great! I've been reading linux kernel source codes for a while and this book put all things together.

Hi,
eveything is good,
the price, the shipment, and the time to delivery.
very impressed.
Thanks,
Sridhar

I heartily recommend this book to anyone doing Linux Kernel or Kernel module development. Although the Modules chapter could be expanded upon, the rest of the book gives excellent insight into the workings of the 2.6 Kernel. Also, the three appendices provide good examples and additional information. This book has provided invaluable information for completing and documenting a complex project I've been working on.

Excellent book for Linux rampups(esp with years on other OS'es).
A flowing style that explains effortlessly about scheduler, slabs, dentry.

In Chap 12, it would be nice to have filesys comparison in table format(e.g. Reiser, ext3, jfs wrt performance, journalling), although this strictly is not kernel.
Chap 18(Debugging) could also be more polluted with real life tools info, e.g Kprobes, LTT, lcrash or LKCD or the coolest toy on sourceforge)

Overall, money very well spent on this book.

Excellent book for Linux rampups(esp with years on other OS'es).
A flowing style that explains effortlessly about scheduler, slabs, dentry.

In Chap 12, it would be nice to have filesys comparison in table format(e.g. Reiser, ext3, jfs wrt performance, journalling), although this strictly is not kernel.
Chap 18(Debugging) could also be more polluted with real life tools info, e.g Kprobes, LTT, lcrash or LKCD or the coolest toy on sourceforge)

Overall, money very well spent on this book.

This book presents the kernel basics in a lucid language with the necessary details, that both newbies and experienced kernel programmers can grasp. My favorite section is the one about the new 2.6 scheduler. A chapter on the open source community is also included towards the end.

Once you have read this book and understood the kernel a bit, it would be helpful in dwelling into subsystem specifics that this book might not have gone into. I suggest reading the Linux Device Drivers by Corebet, Rubini, Kroah-Hartman for that purpose. These books, together with articles on the web, should certainly help anyone interested.

This book presents the kernel basics in a lucid language with the necessary details, that both newbies and experienced kernel programmers can grasp. My favorite section is the one about the new 2.6 scheduler. A chapter on the open source community is also included towards the end.

Once you have read this book and understood the kernel a bit, it would be helpful in dwelling into subsystem specifics that this book might not have gone into. I suggest reading the Linux Device Drivers by Corebet, Rubini, Kroah-Hartman for that purpose. These books, together with articles on the web, should certainly help anyone interested.

This book describe how kernel works and how was designed, it do not shows lines of code just shows you the way you have to write code into the kernel, I think is helpful if you try to undertand or write Linux Kernel code.

This book covers the linux 2.6 kernel, but does not apply to 2.6.15 (current kernel). Data structures for working with files have changed for example. If this book gets updated, it would be quite helpful. Its still a great starting place, but be prepaired to go through include files in the linux kernel source quite a bit. Since Linus lost the change logs for the kernel, its hard to compare notes on older kernels.

If you are a professor, don't give this book to students and expect them to have all they need for kernel development.

A perfect title for this book would be "First Steps at Understanding Linux Kernel 2.6". It's a good book -- clear, logical, well written, and well illustrated, nice layout, fonts, etc. -- but it's not indepth. To make a Windows parallel, it is kind of like "Windows Internals" by Solomon/Russinovich, only smaller; lots of text, not a lot of code.

If you plan to really work with the kernel, you may want to go directly for O'Reilly's "Understanding Linux Kernel", "Device Drivers", and "Linux Networking" books -- you'll end up there anyway. Actually, this: if you DON'T plan to read the above O'Reilly books, THEN read this one to get a "sorta-kinda" picture of what takes place in the 2.6 kernel.

Don't get me wrong: this is a nice book; if time and money are no problem, get it, even in addition to whatever else; it's good, not a must, but good.

A perfect title for this book would be "First Steps at Understanding Linux Kernel 2.6". It's a good book -- clear, logical, well written, and well illustrated, -- but it's not indepth. To make a Windows parallel, it is kind of like "Windows Internals" by Solomon/Russinovich, only smaller; lots of text, not a lot of code. (...)
Actually, this: if you DON'T plan to read the above O'Reilly books, THEN read this one to get a "sorta-kinda" picture of what takes place in the 2.6 kernel.

In spite of the complicated Linux kernel architecture, this book can deliver a first glance but detailed information on each core part inside Linux kernel. Readers can easily understand it's concepts after reading even without previous kernel development experience.

The book "Linux Kernel Development",
explains clearly the inner workings of the
current 2.6 Linux kernel.
The presentation is at an academic - algorithmic
level of detail,
the authors describe the main important data structures,
and the more significant chunks of code,
but they avoid a detailed description of the code.
The book is useful to any serious
Linux kernel developer, mainly as a first book.
The clear exposition of the Linux kernel
workings can speed significantly the
reader's learning curve.
The level of the book is advanced and the reader
should have a good C programming and
Operating Systems Design background.

However, also the book fits very well at the context
of an "Operating Systems Design" academic course
and the students can learn a lot from the
technologically advanced Linux 2.6 kernel implementation.
They can modify/recompile and install their own versions
of one of the most complex and elegant systems ever built,
as the Linux 2.6 kernel!

About one year ago I was browsing the univerity book store, not really knowing what I was looking for. Being all fed up with math thesis stuff I was certain that I wanted somthing practical and funny to read. By chance I saw a book called "Linux Kernel Development". At first I did not give it much attention because normaly writing kernel code does not make me relax at all. When I was leaving the book store, curiosity took over and I decided to find out who the author was - expecting to see some no name punk I was really surprised that it was Robert Love, known of much programming fame in the kernel community. Naturaly I bought the book, read it in 2 days and I loved it. Here for the first time was a book that precendet the art of kernel programming in an easy, understandebel and about all funny way. This was 2004, last week I discovered that a second edtion was out. I quickly bought it on Amazon and while I loved the first edition I must admit that this one is even better.

Robert takes you gently but thoroughly through most of the facets of kernel programming, including system call registration, coding guidelines, synchronization and the VM layer. This is a great book which while being short and precise still manages to get you hacking on the kernel without suffering two much headache. The only thing I feel is missing is a chapter or two devoted to debugging the kernel - but in that regard one could also pickup "Linux(R) Debugging and Performance Tuning " by Steve Best which is a complete book on the fine art of bug/bottleneck hunting. Anyway this is one of the best written tech book I have ever had the joy of reading and it fully deserves to be put next to computer science classics such as "Introduction to Algorithms" and "The C Programming Language".

About one year ago I was browsing the univerity book store, not really knowing what I was looking for. Being all fed up with math thesis stuff I was certain that I wanted somthing practical and funny to read. By chance I saw a book called "Linux Kernel Development". At first I did not give it much attention because normaly writing kernel code does not make me relax at all. When I was leaving the book store, curiosity took over and I decided to find out who the author was - expecting to see some no name punk I was really surprised that it was Robert Love, known of much programming fame in the kernel community. Naturaly I bought the book, read it in 2 days and I loved it. Here for the first time was a book that precendet the art of kernel programming in an easy, understandebel and about all funny way. This was 2004, last week I discovered that a second edtion was out. I quickly bought it on Amazon and while I loved the first edition I must admit that this one is even better.

Robert takes you gently but thoroughly through most of the facets of kernel programming, including system call registration, coding guidelines, synchronization and the VM layer. This is a great book which while being short and precise still manages to get you hacking on the kernel without suffering two much headache. The only thing I feel is missing is a chapter or two devoted to debugging the kernel - but in that regard one could also pickup "Linux(R) Debugging and Performance Tuning " by Steve Best which is a complete book on the fine art of bug/bottleneck hunting. Anyway this is one of the best written tech book I have ever had the joy of reading - tackling a hard subject in a readable way is a rare thing - so it fully deserves to be put next to computer science classics such as "Introduction to Algorithms" and "The C Programming Language".

About one year ago I was browsing the univerity book store, not really knowing what I was looking for. Being all fed up with math thesis stuff I was certain that I wanted somthing practical and funny to read. By chance I saw a book called "Linux Kernel Development". At first I did not give it much attention because normaly writing kernel code does not make me relax at all. When I was leaving the book store, curiosity took over and I decided to find out who the author was - expecting to see some no name punk I was really surprised that it was Rober Love, known of much programming fame in the kernel community. Naturaly I bought the book, read it in 2 days and I loved it. Here for the first time was a book that precendet the art of kernel programming in an easy, understandebel and about all funny way. This was 2004, last week I discovered that a second edtion was out. I quickly bought it on Amazon and while I loved the first edition I must admit that this one is even better - it fully deservs to be put next to computer science classics such as "Introduction to Algorithimics" and "The C Programming Language".

This book will take you from being a 'C' application developer to being ready to modify your first Linux kernel code. It covers the major systems of the kernel and provides enough detail to point you in the right direction should you need to actually make changes. This is the book to start with in your journey to modifying the kernel.

It's important to realize what this book is *NOT*. It will not get you started writing kernel device drivers. It will not cover every data structure in the kernel. Rather, it hits on the major points with great technical accurace and readability.

It's also important ou meet a few prequisites before buying this book, otherwise you will not get the most from it. You should have:
* A good working knowledge of the 'C' programming language
* A good basic background of operating system concepts
* A good working knowledge of basic data structures
For example, if you aren't adept with 'C' pointers, you will struggle to read the code examples. For example, if you don't already know the difference between a physical address and a logical address, you will have a higher hill to climb to get through the chapter on process memory. For example, if you don't know what a queue, stack, and linked-list are, you will struggle through some of the algorithm descriptions.

This book is first rate and the material is described with accuracy and readability. The right audience will find the material here indispensible.

The content is one part why this book is great, but I think bigger points go to Robert Love's delivery. His style is casual yet not willy nilly. A subject like the kernel is both dense and minutia-filled and in turn is so much easier to grasp when it's not presented in a dry academic style. This book is a good contrast to McKusick's Design and Implementation of BSD, which is technically/theoretically on point but in all truths _kinda_ boring. The way I would characterize this book -- it's as if you're older brother took you aside and taught you how to hack the mainframe.

(I wish there was a chapter/section on 'signal posting/handling' though.)

The book is easily readable. It gives a higher-level overview of the architecture of the linux kernel. Most important subsystems are covered, but in-depth descriptions are sorely missing. It is easily readable and generally useful as a guide through more stable parts of the kernel.

One star less because some subsystems are not mentioned at all, like networking, SCSI, ATA, USB or FireWire. For these parts the would-be kernel hacker is doomed to having they way around just the kernel source - no help from this book.

Another star less because of technically incorrect material written in the portability chapter. The problem is that the author is talking about the "C language" and his statements are simply incorrect in that context (although they may be valid for the gcc compiler restricted to the architectures supported by linux).

One example is saying that the unsigned long type is the natural size of the machine word (i.e. 32 bits on 32-bit machines and 64 bits on 64-bit ones). This is simply not correct in the context of the C language as such where unsigned long has to be at least 32 bits, but it doesn't say that on 64-bit machines must be 64 bits.

There are many int-to-pointer and vice-versa conversions in the kernel for which the above comment is very relevant.

Another example is saying that the char type has always 8 bits in C. This is also not true - it has CHAR_BIT bits, defined by the implementation. CHAR_BIT can be arbitrary as far as the C standard is concerned.

This book will not only provide a good understanding of the Linux kernel but also Operating System design in general. Anyone who wishes to dig into the kernel source should keep a copy of this book in hand. It would be like reading an article in a foreign language and having the translation book with you too :). I highly reccommend it.

Everybody should introduce their background before reviewing, since that helps a lot when other people read your opinion. In my case I'm an EE, and never took a course in OS or have a lot of experience in OS design or the like. My work has been in low level design of embedded systems, including HW and SW. We'll be porting the Linux Kernel to our own HW architecture, and bought this book as a reference to understand what to touch.

Now on to the book: I think it's great. I haven't got to the point where we touched actual code though. I've read the book and got a great idea of how Linux handles all the tasks an OS should. It also helped me understand a lot about OS design in general, without being a beginner's book (you know, those that have just the basic stuff that you can't do anything with).

I believe the idea behind the book is to teach you the philosophy behind the OS, with samples of the algorithms and C cde, and then point you in the right direction (where in the source to go for each thing). After that, you need to dig into the source code yourself.

I'd really recommend this book for someone with my background or even for experienced SW types or students who need to get started with the Linux Kernel and want to understand how it is designed. The great thing is that it covers the latest release (2.6) and also talks about how things were done in previous releases.

If you'll be implementing a Linux System this book should be complemented with some driver design reference for Linux, since this book only covers the Kernel (and entry points for the drivers, but not driver design).

I just got my order (the 2nd edition) yesterday. This is my second book about Linux Kernel, the other one is "Understanding The Linux Kernel" by Daniel P. Bovet, Marco Cesati. I was having hard time to understand reading the Bovet's book, but when I read this book it was really fun. I even couldn't stop reading it when the time past midnight (wow, it is like reading a thrilling novel book :-).

I love the way the author tries to explain in a "human plaintext" language (w/ some humors), and gradually he introduces some jargons w/ clear explanations. The book is intended for intermediate to advanced programmers who now C and have some experience in building their kernel from source code. Although, it still guides readers how to compile, to patch and so on (chapter 2).

Another good thing is that, unlike many other Linux Kernel books, the author emphasizes concepts of the Linux Internals. So he tries to minimize a copy-paste of the source code on the book (you can just open the source code and see it, no need to have a book for that). This is what I have been looking for. Besides, when there is a new patch/version, the book will be still relevant long into the future.

Here is the list of the chapters:

1. Intro to the Linux Kernel
2. Getting Started w/ the Kernel
3. Process Management
4. Process Scheduling
5. System Calls
6. Interrupts and Interrupt Handlers
7. Bottom Halves and Deferring Work
8. Kernel Synchronization Intro
9. Kernel Synchronization Methods
10. Timers and Time Management
11. Memory Management
12. The Virtual Filesystem
13. The Block I/O Layer
14. The Process Address Space
15. The Page Cache and Page Writeback
16. Modules
17. kobjects and sysfs
18. Debugging
19. Portability
20. Patches, Hacking and the Community
Appendix (Linked Lists, Kernel Random Number Generator, Algorithmic Complexity)

My suggestion is first read this book thoroughly, then may continue with "UNderstanding The Kernel" and also "Linux Device Drivers", 3rd Edition by Jonathan Corbet. If you want to know more about TCP/IP stack in the kernel, "The Linux TCP/IP stack" by Herbert may be good too (I bought this book too, but I have not read it yet, but from what I saw on the table of content seems it is interesting). The last but not the least, another book about wi-fi "Linux unwired" may also compliment your personal library of Linux.

[A review of the 2ND EDITION 2005.]

You should find this to be a graceful description of what it means to change the linux kernel. Love goes into enough detail to give practical guidance with code mods. But he also writes clearly of the reasons behind the various kernel operations. The choice of using the current 2.6 kernel means this book may be more relevant than earlier linux kernel texts.

A point of some amusement is the table of supported linux architectures. Surely some of these will be exiting the stage soon. Who is going to keep developing linux for the DEC Alpha or the 32 bit MIPS?

Don't be put off by the Novell logo on the cover. Love works for them and they approved the book. But in going through it, there seems to be no pro-Novell slant. It may also be that Novell is trying to burnish its open source credibility with books like this.

This is a great book. I liked the fact that it covers the latest 2.6.x kernel and explains in detail both the theoretical concepts as well as the technical aspects of the kernel architecture and its implementation.
It concentrates more on the core kernel subsystems like: Process Scheduling, Memory Management , Interrupts Handlers, Synchronization, Timers, Virtual File Systems and Modules. But nothing much about the Network Subsystem. There are other books which explain in details the Linux Networking Architecture and the Linux TCP/IP implementation.

Simply put this book is well written. The author makes difficult concepts accessible to even newbies. I own both editions, and the second one is even better than the first. This book would also be good as a supplement to the required text for a college-level course on operating systems where Linux is one of the OSes discussed (as is the case these days).

I buy a lot of technical books - more than I could possibly ever read. This title is, for me, very readable. The Author presents information the way I want to see it. I really like the historical background information on Linux and comparisons to Unix. If you are looking for one single reference on Linux programming, I recommend this title. Not just for kernel hacking.

I have been doing Linux kernel/system level development on and off since 1999. This is the book that I think should be owned by any Linux newbie who wants starting their kernel hacking. Even if people do not directly do Linux kernel development, it is a good book complementary to any serious operating systems course in college - it helps gain a better idea of how and why.

The book is quite easy to follow and read and does not try to overwhelm readers with tons of information (consequently it does not address many details in Linux kernel). I consider this is a major strength of the book which parts away from other books (comparing to "Understanding the Linux Kernel", which has quite some details on each subsystem, but if you take the book as your guide to kernel programming, you feel you are overwhelmed by the information and often clueless on where to start to write some simple stuffs. This does not mean I think the latter is a bad one - it is a very good one indeed). Considering the fact that Linux kernel evolves so fast, it may make sense to focus on the core parts and once you understand them, it may become easy for you to track and understand changes later. Even as a professional programmer doing kernel development, occasionally referencing a well-written book like this is very helpful.

I am a bit reluctant to rate it 5 stars though due to many typos observed, which I guess is the result of rush to publishing (and the poor job of proofreading). Fortuanately, most can be understood by reading the contexts around them. But a few are really misleading or totally wrong. For example, on page 169, there is a sample code to show how page allocation/free is done in kernel. It uses __get_free_pages() to allocate pages, but uses free_pages() to free these pages. As the author has just said a page ago, __free_pages() should be used to free (struct page*) pages, otherwise corruption will ensure (free_pages is used to free pages with logic address as parameter).

There are not many good books on Linux kernel programming. This is the most recent good book. The text is informative, but there are quite a few typos. "Linux Device Drivers" is another good book on Linux kernel programmaing, but it focuses on the older Linux 2.4.

I just got the book today. I feel deceived in that the details about this book stated around 500 pages. Given the price, I figured this was a reasonable price/page ratio. Now that I have the book in hand, I realize it's only 330 pages, including index and stuff.

I guess this is more of a beef with Amazon than the book.