Customer Reviews

The Linux® Kernel Primer: A Top-Down Approach for x86 and PowerPC Architectures

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

 

 

I've been less than happy with other kernel books before, so when this landed in my mailbox, I was prepared for disappointment. I've been down this road: it's too overwhelming a subject, authors typically assume far too much prior knowledge, and I'm left feeling puzzled and confused.

Well, the subject is overwhelming, and it really can't be covered in one book. But you have to start somewhere, and this looks like the best place I've seen so far. Yes, of course you'll need and want other books, and you'll need to spend a lot of time experimenting on your own, but this is (as the title says) your primer: the book that introduces and explains all the confusing little conventions and quirks that you need to know to avoid being totally lost.

I really like the approach of trying to relate everything to user space programs and of writing example code and drivers to illustrate concepts. The authors have also made an effort to point out and elucidate the things that confused them when they first started looking at the kernel.

Every chapter has at least a few review questions at the end, and lots of annotated source code. Four projects get you started with actual kernel programming.

There are, of course, ommissions and lightly covered areas. Six hundred pages aren't enough to cover everything in depth, and there has to be at least some basic assumption of programming knowledge. But overall, this looks great and I'm looking forward to spending more time with it.

A good basic intro to the linux kernel, pretty much exactly what I was looking for. I bought this to act as a primer before delving into Understanding the Linux Kernel, which is a much deeper and difficult work, and it's proved very satisfactory.

The major problem I have is that it seems not to have been proofread AT ALL. I have found at least a typo a page on average, and not just punctuation and spelling mistakes. Using the wrong name for a function, referring the reader to the wrong figure, chapter or section, that kind of typo. The design of the book (notational conventions, typefaces, how they display varible names vs. code blocks vs. normal text, etc) is quite inconsistent at times.

All in all, a good read, and a great intro, but very inconsistent and error-ridden; prepare to read it with oversight.

Really appreciate the detailed comparison of x86 and PPC assembler, description of analysis tools, and the exercises. The exercises are extremely useful to determine whether or not you actually need to read a chapter. The book assumes you're going to do a lot of hands-on exploration and analysis while you're reading, and gears a lot of its examples and exercises towards that activity. Between this, and the referrals back to the differences between an x86 and PPC implementation (when necessary) and the detailed blow-by-blow of booting may make it a better buy for the kernel newbie than the O'Reilly book Understanding the Linux Kernel.

The views expressed in this review are based on the Filesystems chapter. The book has a very dull presentation style. Kernel structures are listed and the important lines in them are explained. The explanation lacks sufficient detail in a lot of places. It also suffers from redundant, obvious statements (conveying no information) in other places. I could also spot several mistakes; figures drawn wrong, text referring to something that is not present in the figure etc...

A book that steps through the important parts of the kernel and explains each point. Ive read other Linux kernel books before (ie: Oreillys Understanding the Linux kernel), and this book is by far the best read for the advanced user that has some programming experience and wants dive into tinkering around with the kernel.

Very easy to read, follow and understand. If you want to learn how Linux works, buy this book.

This is a pretty solid book for beginners... as to the reviewer who disapointed that this "only scratched the surface", perhaps he should look up what the definition of a primer is ...

prim·er
2. A book that covers the basic elements of a subject.

This is an excellent primer on the intricacies of the Linux kernel. It includes programming information for assembly and C, some very useful kernel exploration tools, information on memory management, filesystem details, IO operations, boot loaders, memory initialization, building the kernel, and adding your code to the kernel. The section on processes includes creating, lifespan, termination, schedulers and wait queues and is particularly good. Throughout the book you will find lots of examples and illustrations to clearly illustrate the concepts discussed. With the source code available online it is easy for the experienced programmer to follow through and understand the various functions used by the kernel. Although not advanced book on the subject, nor does it claim to be, The Linux Kernel Primer is highly recommended for anyone interested in programming the kernel or understanding how it functions.

In any operating system, kernel programming is reserved for a few experts in the field. Largely due to the very specialised nature of what they want to do. Linux is no exception. This book stands far afield from a typical linux sysadmin text.

The authors choose to explain for two chip sets. Namely for the Intel x86. Natural and obvious, given Intel's domination of the microprocessor market. As for a second choice, there are many contenders, like the Alpha or the ARM chips. But instead, the book describes the PowerPC, which is prominently backed by IBM and Motorola. I suspect this choice might have been influenced by one of the authors being at IBM. Arguably, a credible alternative is the chip set from AMD.

But the main thrust of the book is to offer a top down view of linux, drilling as close to the hardware as possible. The code excerpts are in C. (Very little kernel development seems to be done in other languages, and this book is no exception.)

At the lowest level, you are shown how to access the drivers in /dev/, which in turn access the hardware. For example, one code fragment explains the reading of the real time clock on the x86. For some developers who might be used to dealing in pure software, these hardware interaction examples may be the most valuable portions of the text.

Another merit of the book is presence of 2 architectures that are described. If you are developing for another chip set, the text may still be quite useful. You get 2 case studies here of how linux works. Contrasting these might give insight into what changes you need for your chip set.

Overall, this is definitely an advanced book. Having a strong background in C coding is a plus.

I read Chapter 4 Memory Management, Chapter 7 Scheduling and Kernel Synchronization and Chapter 8. Booting the Kernel, I think this book works best as a memory refresher, it highlights some key point with example source code.

Overall, it's disappointing. The book merely scratches the surface on a wide range of topics and therefore is only slightly useful for someone who already knows what processes are or can build a kernel. Still haven't found a replacement for O'reilly's Understanding the Linux Kernel, which has detailed coverage of such topics as processes, scheduling, and memory management.