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 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.

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".

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.

It is a compact book and easy to read. Although it does not go deep into many parts of the kernel, it kind of makes you feel good that you can grasp the fundamentals in a short time. The chapters are kept rather short, such that you can go through a few in several hours. Contrasting it with The Design and Impl. of FreeBSD, the FreeBSD book provides more depth into how the general Unix concepts (e.g. explaining how sessions work in FreeBSD etc.) are implemented in the kernel. In summary, I would definitely finish reading this book, get the big picture, and then try to specialise on a particular kernel subsystem.

Robert love clearly describes many of the important Linux Kernel internal APIs. I have been working on kernels of different OS's for over a decade. This book clarified some areas of the Linux Kernel for me.

This book mostly talks about the 2.6 Kernel, but it occasionally references earlier kernels - mostly to indicate what 2.6 does differently.

When I wanted to just refer few things in this book, I couldn't stop with that and continued to read and ended up reading several chapters in one sitting. You will enjoy reading this book, most of all finally understand the big picture and the details. I personally would thank the authors for their work.

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).

This book dives into the structure of the kernel and how it works in great details. It doesn't lose you in technicalities like some books, instead Robert Love keeps it as close to simple english as possible and tries to make it very easy to read.

I've never read a book that taught me so much about the kernel's inner workings in just the first 3 chapters. I've now read about half of them and will probably finish it today. This book is truly amazing.

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 is only 1 reason that I didn't give this book a 5 star rating. I found the memory management a bit below par. But that's probably because the initial chapters up the bar so high that the last few fail to live up to those high standards.

The chapter on Scheduling is phenomenal - easily the best! Maybe even that is an understatement. An added "advantage" is that this book is on kernel 2.6.

If you're entering the realm of kernel hacking, my recommendation is, read this first, Linux device Drivers by Rubini next, and then Understanding the Linux Kernel by Bovet and Cesati.

What next? The source - that's where you'll get all the answers. :)

The author is really a good teacher. He gradually takes the reader into the dark woods of kernel and still assures the ease of understanding the programming concepts well.You really feel the joy of evolving into a professional as you read this book.Kudos.
I own it.

I was a Linux kernel newbie writing a device driver and started reading "Linux Device Drivers" by Rubini. On hindsight, this was a bad idea. Rubini's book goes deep into driver code quickly with good details but it only sparingly touches the higher level kernel overview or essential concepts. These missing pieces are covered very well in Love's book and I should have understood them before reading Rubini's book; important basic concepts covered in good detail include:

- user thread vs kernel thread.
- kernel-space process context vs kernel-space interrupt context.
- tasklet as a non-concurrent form of softirq and is not related in any way to tasks.
- bottom-half methods comprising softirq, tasklet and work queue; and that BH and task queue are obsolete and deprecated.
- semaphore sleeping vs spinlock spinning (busy-wait).
- spinlock adversely affecting scheduling latency while semaphore does not.

Love's book shows ambly that he is an expert in Linux kernel matters and speaks with authority. At the same time he has the ability of a good teacher to explain obscure and critical kernel concepts clearly. I heartily recommend this as the first book one should read about the Linux kernel, well before books such as Bovet's "Understanding the Linux Kernel" or Rubini's device driver book.

This 2nd edition introduces more materials and explanation to cover the updated 2.6 kernel. As far as I can see, it is a worthy new edition to own.

This is a good book to know kernel internals, good explanations with irqsoft(syscall) versus workqeues ant tasklets, context proces versus fork and thread ....

Good joob

This is a very easy introduction to hacking on the linux kernel,
there is not much discussion about design choices, but it explains
how the kernel work, how to program on it and what things one need to look out for.

The book is readable for both newbies and uber kernel hackers and
through out the book Robert has a great sense of humor that most
other technical books does not have. Highly recomended read.

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.

Just bought it from amazon. After two days reading many of my doubts on the Linux Kernel were solved and I must say this book has a great structure and good editorial work on it! A very good Book.

There are more technical books than Linux Kernel Development, with more code samples and technical jargon, but when it comes to up to date knowledge, and a clear, concise writing style, this volume is one of the best.

Robert Love has written a book that is readable for both kernel newbies and those wishing to get a better grasp for what is at the heart of 2.6. However, what I find most appealing about this book is it has a sense of humor that most other technical books seem to have left at home. This is a book you will read cover to cover, instead of using it as a meer reference.

I recommend this book to anyone who wants to learn, or brush up on, the linux kernel.

I like the book because it is well organized, clear, no nonsense, explains the subject top-down, up-to-date including kernel 2.6, contains very little code and despite the subject still readable as a regular book. It is like a book about operating systems in general but about Linux only. I'd recommend reading this book before "Understanding the Linux Kernel".
However, I find the word "Development" in the title a little misleading because the book contains very little about the actual howto and could have been backed up by for example an appendix with an example from real life with a step-by-step walk-thru by the hand.

This book is a kernel bible. Robert Love is an amazing hacker and an amazing writer too. If you are even remotely interested in kernel devlopment this book will change your life forever. Great read.