Customer Reviews
T Taktakci - By: T. Taktakci, 12 Nov 2008 
When you talk about programmingin Linux environment, you have to think user level & kernel level seperately. This book is a quite nice one explaining the topicsin user level programming. I bought this book & read itin 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 versedin 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 & experience on linux environment.
The Linux system call and C API explored in depth. - By: J. Mitchell, 15 Jan 2008 As a perl programmer recently thrownin to the world of C development on
Linux, I have been looking for something that would take my K&R level of
experience & bring it up to date with modern methods, hopefully
letting me write more efficient & reliable programs.
Robert Love, former "Chief Architect, Linux Desktop" at Novell, kernel
hacker of many years, & Gnome developer of well known features such as Beagle
and NetworkManager, attemptsin this book to document the Linux system call
and C API to common systems programming tasks. Given that he developed
the pre-emptive kernel & 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 & you might miss
the most suitable one for the jobin 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 & process management it will lead youin 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 & 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 & 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 timesin 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 donein 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 providein buffering, to improved performance using
mmap. The techniques continue with descriptions of I/O schedulers &
how the kernel will order hardware disk access, scatter/gather, & 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 & at what cost,
allowing clear consideration of the use of advanced features against any
consequences.
For process management discussion starts with fork & exec, before moving
onto user ids & groups, covers daemonification & 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 usedin a
practical situation.
Not everything is present & 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 topicsin 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 throughin a page with no code example, whereas I/O schedulers gets
a luxurious 12.
On the other hand there are some unexpected & useful extras, such as a
discussionin the appendix of gcc C language extensions & 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 & glibc 2.5. Many calls have been standardised by POSIX, & where
this is so it are notedin 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 themin older code.
I recommend this book to anyone who has a need to developing Linux
applications. The book is not a primerin 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 & C library into your
programs is easy going & enjoyable.
