Customer Reviews

Understanding the Linux Kernel

5 star:		(5)
4 star:		(5)
3 star:		(2)
2 star:		(1)
1 star:		(0)

 

 

I've been reading kernel books for nearly 20 years -- this is not recommended.

Some of the chapters and explanations I liked, others I felt were dry and lacking. The code examples seem to run through a non-deterministic preprocessor -- the code is supposed to describe 2.4.18, but the code snippets don't quite match the actual code (while generally working the same way, the algorithms/loop structure are often rewritten and the macros are sometimes expanded). I find it very useful when books comment on actual code examples, this is "kinda massaged code" -- I found it very frustrating when I actually looked at the kernel tree when they had snippets in the book.

I often found it necessary to look at the actual code to give more context (but the code rarely matched verbatim -- very strange). And when they did rewrite algorithms, I found the kernel 2.4.18 source to be MORE lucid.

The explanations without code were adequate, and I found some to be illuminating. Perhaps since the book has two authors, different authors wrote different chapters? (I liked some chapters and didn't like others).

If you want a general understanding of how kernels work, Andy Tanenbaum's "Operating Systems: Design and Implementation" where he elaborates on Minix is very useful -- with a complete Minix system (Minix is more of a teaching tool, which it does well, Linus looked at lMinix and wanted a more useful system, hence Linux).

I found Robert Love's "Linux Kernel Development" very good (I read the 1st edition, still need to read the second edtion). And Linux Device Drivers (Corbet and Rubini) is very good and has excellent examples (but the examples may need some work to build on a current kernel -- had this problem with the 2nd edition).

Oh yes! This Second of Edition of "Understanding the Linux Kernel" featured a variety of new additions. The most significant being the inclusion of all those attributes, which distinguished the 2.4 kernel version from the 2.2 one.
This new edition also revised some of the staples of its predecessor, like: individual components of data structures, programming pathways, and interdependent algorithms. Its pattern is just as dynamic as that of the First Edition: with expanded elaborations on all those programming and performance tips.
In all, this is a good book to consider, if you are seeking Linux Kernel knowledge. But, if you already own the previous edition, and do not plan to adopt the Kernel 2.4 version, then there is no wisdom in spending on this one.

As the title suggests, the author explains concepts
in the linux operating system by using C code.

You need to be able to read C code inorder to understand
the material in the book.

It can get a bit tiring after a while considering that
the author really wants YOU to know LINUX.

The effort is worth it!

If you read and understand most of what is in this book, then you will be an expert on the internals of the Linux kernel. This book goes into great detail on all aspects of the kernel. I would recommend this book, as well as "Linux Kernel Development", to be used as supplements to a college course taught on operating systems where Linux is used as a reference OS implementation.

The book does a good job of making complicated concepts accessible, but the reader may need to noodle over some concepts a bit more than others in order to fully grasp them. This, however, doesn't take away from the pedigogical nature of the book.

If you are interested in OS design, or intend to work with the Linux
Kernel, Understanding the Linux Kernel is a very useful look into how
and why certian decisions were made in the Linux kernel. This book
doesn't seem to leave anything out. Example code is used very well to
show exactly what the authors are talking about. This would be an
excellent book for a course on OS design.
The second edition doesn't cover the 2.6 kernel,
which wasn't out at the time the book was published, but it still
provides a great resource for kernel information.

This book, by admission of authors, follows bottom-up approach. Although I do not favor that approach, I would accept it if `UP' was ever reached.

Reader is encouraged to look at the code while reading this book, however, very few references to the code is found, it's mostly talk, talk, talk, and you just lose it long before you're able to get a big picture.

I just couldn't believe how much space was wasted in the first part of the book explaining things that you ought to know before you even think about buying this book. I wish that space was used for more code/examples instead.

There is hardly any code in this book, and on the other hand it tried to chew so many subjects that are impossible to fit in this book and deserve (and have!) books on their own. I don't need a book on how CPU works, just show me a piece of code in Linux and try to explain it assuming some theoretical knowledge on the readers side that has to be assumed.

If you expect Stevens-like masterpiece from this book, you will be disappointed. If you already have Kernel knowledge, I guess it might be used as a reference. If you don't, it's close to useless.

A very decent book on Linux Kernel v2.4. Based on PC 80x86 architecture, it covers both uni- and multi-processor systems. Very detailed, explains not only how kernel works but also why it was designed this way.

This is an exciting book for anyone seeking advanced insides into Linux Kernel. I rated it 4 for lack of clear separation between Linux and hardware responsibilities. I also wish the author would have conducted a comparison study with Windows, another POSIX-compliant OS.

This book doesn't just talk about Linux; it talks about how a modern OS sitting on a modern architecture functions, in real detail. I have seen many OS texts, and this one is unique in that it does not attempt to teach theory, or academic examples. Want to understand scheduling, interrupts, file system abstractions, address spaces? Read this. Even if you don't use or care about Linux particularly. It will demystify these critical topics, which you can then apply to whatever platform or code you're working with, especially if you work with kernel or related components.

I am a professional software developer who works in drivers and OS subsystems. Although I have some exposure to various Unix flavors, I don't use any of them regularly-- I have most exposure to the NT architecture. This book has been invaluable in shoring up my fundamentals. The Windows book that most closely resembles this is Windows Internals from MS Press, which is a great book but doesn't (and cannot) delve too far into actual internal structures.

Note, though, that this book does not aim to teach you all this good generalist stuff-- it only does that by accident. It will gloss over the intro material in some cases to get into the code, which works for the explicit charter of the text (Linux kernel specifics), but might require the reader cross-referencing with an OS text.

There are two type of programmers, those who start with papers and those who start with code. If you are like me, who start with code, this is the only book you need to learn about linux kernel and to use it as a quick reference.

I didn't like the first edition of this book, and I still don't like the current edition, though I admit I'm having a hard time understanding why.

I think that part of the problem is the deliberate "bottom-up" approach: this starts out in the first chapter dealing with memory addressing at the hardware level and goes on from there. I tend not to like bottom up explanations: give me the grand picture first and then drill down. But that can't be all of it: The Magic Garden Explained effectively starts there too, and I enjoyed that. Frankly, this approach probably is the best way to handle this subject matter in spite of my preferences.

Perhaps part of this is that I'm not playing by the rules. There is a strong implication in the preface that one should be looking at the source code while reading. One of the reviews at Amazon.com says the same thing. I didn't do that, and that may contribute to my vague dissatisfaction.

I certainly can't complain that this is incomplete or badly written. It covers everything that should be covered, and it is current as of the 2.4 kernels. The writing style is lucid, and I think that in general the writers have done a better than average job of explaining the why and wherefor in addition to the how.

I think maybe I've just lost my interest in this level of detail. There was a time when I found it fascinating in the most literal sense, but that was years ago. I just don't have any burning desire to understand kernel internals anymore.

You, of course, may still have that interest. If so, this would undoubtedly be a worthwhile addition to your library.