Reviews for Linux System Programming: Talking Directly to the Kernel and C Library

1. T Taktakci

   Rated 5 out of 5 stars, November 12th, 2008

   When you talk about programming in Linux environment, you have to think user level and kernel level seperately. This book is a quite nice one explaining the topics in user level programming. I bought this book and read it in about two weeks, in parallel to my other tasks. I must say that it really helped me understand what system programming is. Even if your task is developing kernel level software/driver/module you have to be well versed in user level. I would suggest you read a user level programming book, strongly recommend this one, then study another kernel book which would make things much better for you. When you read the book you feel the writer's overall knowledge and experience on linux environment.

2. The Linux system call and C API explored in depth.

   Rated 5 out of 5 stars, January 12th, 2008

   As a perl programmer recently thrown in to the world of C development on
   Linux, I have been looking for something that would take my K&R level of
   experience and bring it up to date with modern methods, hopefully
   letting me write more efficient and reliable programs.
   
   Robert Love, former "Chief Architect, Linux Desktop" at Novell, kernel
   hacker of many years, and Gnome developer of well known features such as Beagle
   and NetworkManager, attempts in this book to document the Linux system call
   and C API to common systems programming tasks. Given that he developed
   the pre-emptive kernel and inotify he has the knowledge.
   
   Getting this book out of the box, I had wrongly been expecting a cookbook
   style that I would get instant gratification from. Although structured
   around common programming tasks, it doesn't lend itself to just dipping in.
   The section on time lists a handful of ways that "time" is available to the
   programmer; jump into the middle of the section and you might miss
   the most suitable one for the job in hand. The book rewards reading it
   in larger chunks.
   
   This doesn't mean it is necessary to read it from cover to cover. Logically
   organised into chapters around "things you want to do", such as file access,
   memory management and process management it will lead you in with a survey of
   techniques you might be familiar with, before drilling down with advanced
   methods.
   
   Knowing advanced methods for performance is great, but not at all costs. One
   of the most useful and practical lessons this book gives is to encourage you
   to think about error conditions that may occur during a system call. Early
   on, in the section on reading files, a detailed example is given on reading
   from a file. Every possible case of return code from the read call is described
   together with what it means and how you should handle it - it can be surprising
   that 7 possible outcomes are listed, with good descriptions of what to
   do with each of them.
   
   This good practice by example continues throughout the book. Every system call
   described also lists the errors that may occur. This does show up a slight
   weakness: many system calls share a common set of errors which are repeated
   many times in the text. If you are not paying attention it may feel like you
   are just flipping through man pages. However you are soon halted by the easy
   introduction of an advanced concept to get your teeth into.
   
   These are done in a nicely graded level for each topic. In "file access" to give
   an example, you are lead from simple read/write calls, through to what
   the C library can provide in buffering, to improved performance using
   mmap. The techniques continue with descriptions of I/O schedulers and
   how the kernel will order hardware disk access, scatter/gather, and ends up
   with how it is possible to order block reads/writes yourself bypassing any
   scheduler.
   
   You are hardly aware of the progression, as the pacing is very well done.
   New concepts clearly fit into what you have seen so far - current sections
   signpost the practical use of what is being explained and at what cost,
   allowing clear consideration of the use of advanced features against any
   consequences.
   
   For process management discussion starts with fork and exec, before moving
   onto user ids and groups, covers daemonification and goes onto process
   scheduling, including real time scheduling. Throughout the book each new
   call is illustrated with a short code snippet showing the call being used in a
   practical situation.
   
   Not everything is present and correct. The author immediately states that
   networking is not covered at all. This is a shame as this subject would
   benefit from the depth of coverage given to the topics in this book - although
   no doubt would increase the number of pages considerably. Perhaps scope for
   a second volume. The length of some sections seems odd - Asynchronous file I/O
   is whizzed through in a page with no code example, whereas I/O schedulers gets
   a luxurious 12.
   
   On the other hand there are some unexpected and useful extras, such as a
   discussion in the appendix of gcc C language extensions and how they
   might be used to fine tune your code.
   
   The books stated target is for modern Linux development, a 2.6.22 kernel,
   gcc 4.2 and glibc 2.5. Many calls have been standardised by POSIX, and where
   this is so it are noted in the text, so a large portion of the content is
   useful on other systems. There is even the occasional mention of non-Linux
   system calls, the use of which is not encouraged, but shown so you know how
   they function if you come across them in older code.
   
   I recommend this book to anyone who has a need to developing Linux
   applications. The book is not a primer in C on Unix, so you are expected
   to be familar at least to the level of K&R. From this level though the
   journey into getting the best from the kernel and C library into your
   programs is easy going and enjoyable.