Customer Reviews

LINUX Kernel Internals

5 star:		(11)
4 star:		(6)
3 star:		(2)
2 star:		(6)
1 star:		(3)

 

 

Since I had already taken a course in university on Unix Kernel Architecture, I found this book a good introduction to the Linux implementation. If you can pick up concepts quickly you may find the book adequate on its own, otherwise get another general Operating Systems textbook to help you with things like understanding virtual memory, interrupt service routines, drivers and networking concepts.

The author's goal seems to be to introduce you to a good portion of the kernel source code. Understanding the kernel source tree, the build process and the code itself is much easier once you have read the first few chapters of the book.

The book avoids teaching you or even using examples in assembly language. This may annoy you if you know assembly language, or thrill you if you don't. For example, the extremely time-critical interupt service routines, which are written in hand-optimized assembler, are explained with some C-like pseudo code.

Although the book is quite short, it is well written, and it explains the Linux kernel implementation in sufficient detail. Although it was intentional, some readers may wish that the book included more explanation of the concepts before the implementation is introduced.

A suggested companion text would be Andrew Tannenbaum's "Operating Systems: Design and Implementation".

Basically there are two approaches to help you really understand how unix kernel works. The static approach is to look at the code and illustrate how various parts cooperate. The dynamic approach is by showing you how to play with the kernel with various tools the kernel hacker used to debug kernel. This book takes the static approach mostly. I just browsed through the first several chapters and disappointedly found this one did not really help if you don't already know another unix kernel. This book does not cover x86's multitasking support mechnism at all. The kernel memory management chapter is also too vague. It even makes people thinking whether the authors really understand the content at a kernel hacker's level. Though I would rather believe the authors did not have enough time(or due to some other limitations) to illustrate what they know in detail. Unfortunately, to be terse does not work for static approach.

The most sucessful static approach I have seen is Dr. Tanebaum's 1997 book about minx. And the best dynamic approach to me is Pate's Unix Kernel internels: a practical approach. I really hope there will be a linux kernel book that can be comparable to the above two.

The book is well done. There's no way you could please everyone when attempting to explain the kernel of an OS, but I thought they did an outstanding job. It makes "grepping" through the source much more pleasant and understandable. Chapters 1 through 3 present the flow of processes in Linux and introduce the operation of system calls, wait queues,etc. The chapter on the file system was very well done, however, the chapter on memory management left me with more questions than answers...it needs a little more work. The book requires a pretty good knowledge of C and some prior knowledge of OS's in general.

The book is largely a comment of the source code, most which is branded as "too complicated". System administrators can not find the stuff that interests them (how to determine time slice, how to control paging/and swapping, what kernel variables are available for tweaking) The presentation style is unclear, superficial and assumes that the readers are the people who wrote kernel itself. I didn't learn anything and so far I consider my money wasted on this book. A note to Amazon.com: if you expect us to pay $41 for the book, be so kind and publish the table of contents!

I found the explanations in this book to be very clear, giving enough detail for a good head start into Linux internals. The book briefly explains the OS concepts, such as semaphores, virtual memory, etc., followed by an overview of how each is implemented in Linux, and code snippets.

Most of the code snippets are simplified for readability, which I found useful because the hacks can be distracting (scary, too) for a beginner. Detailed and up-to-date information can best be obtained from source code itself.

The book assumes some familiarity with Unix concepts, as it mentions such buzzwords as POSIX, BSD, and SVR4 in the context of the discussions, but one could safely ignore them, and just concentrate on the Linux part.

The book briefly covers adding new system calls, compilinag and debugging the kernel, and even shows how to write a simple device driver - these are hard to find in one place.

Overall, I found this book to be very useful for my self-paced study (the best so far), and I only wish they had a newer edition.

This book was quite disappointing. I don't feel that I learned anything that I couldn't have learned in a similar amount of time spent by reading through source code. What's worse, the book wasn't any better at presenting that information.

I give some credit for not resorting to simply printing the kernel sources in bound format as other books have done, but apart from that, there's not much good to say here.

First off, the authors' command of the English language, as presented in final form by the book's editorial staff, leaves much to be desired. The prose is very conversational and awkward, and although generally understandable (words are strung together in grammatical correctness), the text doesn't clearly present ideas.

Second, the book suffers from a lack of clear focus on a specific reader. At times, very detailed descriptions of things like slow/fast IRQ handling are discussed, but then at other times the authors spend a great deal of time talking about the specific quirks of the 8253 timer chip in the ISA PC architecture. I would have preferred if the majority of this book were discussing the ideas involved in the Linux kernel design, but it wanders in and out of describing things that most readers who would buy the book based on its title already know.

Finally, in general the book is vague just when you'd want it to be specific, in describing the way things really fit together in the Linux kernel. They've attempted to simplify the explanations of complicated, optimized subroutines, and that's great, bt in dissecting everything into little pieces, I'm left with a very small picture of how the whole system actually fits together.

As if all this weren't enough, the book is really only 300pp of useful information. About 100 of the other 180 are spent on Appendix A, a useless (but book-filling) reference to the specifics of all the system calls implemented in Linux. It's bound to be out of date and the information is of a very cookie-cutter nature anyway, and it's better left out. The remaining 80pp go to equally worthless Apendices and the Index.

By way of comparison, I recently finished reading "Inside Windows 2000, 3rd ed.", a book with a very similar goal and subject domain. The difference is night and day. The authors of that book obviously went to great pains to make extrememly complicated subsystems (which, incidentally are much better than Linux, in most all cases) comprehensible. I shudder to think about how bad the FIRST edition of Linux Kernel Internals must have been.

If you're absolutely desperate for something --anything-- that describes the Linux Kernel, I suppose this is a reasonable place to start, but otherwise, I wouldn't waste your money here.

I consider myself an system apps programmer. That means above the OS, but below the apps programmer. In other words I would write databases, web servers, etc.

I found this book excellent. It explains the workings of Linux without bogging down in details. It took me about 3 days to read the book and as such I have a firm understanding of how Linux works. Be forewarned though that you do need to understand what an OS wants to achieve in general. For example the issues of virtual memory, file systems, user and kernel mode.

Will it help me write extensions to the OS or device drivers? Maybe, but only after doing some kernel digging. But that does not matter since I really wanted an insiders knowledge of how Linux worked and what the limitations and great features of Linux are.

This book is a little outdated today as it covers the older 2.0 kernels. If you are reading this book and following it up on a 2.4 kernel you will find many changes.The book does contain the source code of the reference kernel it is written on.

I suppose its time a new updated edition is published.

However the commentry on a older kernel does not reduce the value of this book. It is a good book to understand the OS concepts as applied to Linux kernel.This book can be a good companion to Silberschatz/Galvin's "Operating Systems Concept" in a college course.

Another value of this book is purely historical, in case someone desires to compare older and newer kernels with a high-level view.

For me this book was quite a disappointment. The English is too breezy, awkward, and quite often extremely difficult to understand. While I understand that authors are not all native English speakers it appears that if it was edited the editor didn't write English either. While the blurb says that it was updated for the 2.0 kernel it is really about the 1.0.x series. I found little I could trust about the 2.0.x kernel.

I don't think this book teaches the Linux kernel at all. The writing is hard to understand and there is a total lack of examples. Some times they would pull out pieces of Linux source code and call that an example. At other times they would give you a theoretical three paragraph discussion and call that an example. I guess technically they did give an example, but those examples don't teach because they are too hard. Books are suppose to give easy examples that get progressively harder instead of dumping the real thing at you right-a-way.

The book is really for people who already knows Linux or Unix and need to look up what a particular function do (because Kernel function are not in the "man" pages) The only good part about this book is that the index is very complete so you can look up an unknown function quickly - that's basically why I kept the book. But as a teaching device - which was what I was looking for - the book fails completely.