Self-Service Linux(R): Mastering the Art of Problem Determination (Paperback)

~ (Author), Dan Behman (Author)

Editorial Reviews

Product Description

The biggest factor in a company's decision to go with Linux is overcoming thesupport issues. Adopting Linux successfully means taking on a differentapproach to support. Since Linux is open source, there are different methodsto get the support that companies need. This includes deeper skills on how toinvestigate problems, how to get help from the open source community (i.e.how to ask for help on usenet) and how to resolve problems in-house withoutthe extra cost of a consultant. This book should be an essential part of everycompany's Linux adoption plan to keep the total cost of ownership (TCO)down and improve the ROI of their Linux strategy. It is also a book thatadvanced Linux professionals running their own Linux systems will be able touse to troubleshoot. This book gives the staff the basics they need to diagnose most problems that they will face and will go into the nitty-gritty on the toughest problems. It also points users to the appropriate resources so that they may get help quickly.

From the Back Cover

"This welcome addition to the Linux bookshelf provides real insight into the black-art of debugging. All too often debugging books concentrate solely on the tools but this book avoids that pitfall by concentrating on examples. The authors dissect and discuss each example in detail; in so doing they give invaluable insight into the Linux environment."

—Richard J Moore, IBM Advanced Linux Response Team-Linux Technology Centre

"A plethora of Linux books exist but this guide offers a definitive overview of practical hints and tips for Linux users. Written by experts in the field, it will be extremely useful for system administrators and Linux enthusiasts."

—Markus Rex, VP and General Manager, SUSE LINUX

• The indispensable troubleshooting resource for every Linux administrator, developer, support professional, and power user!

• Systematically resolve errors, crashes, hangs, performance slowdowns, unexpected behavior, and unexpected outputs

• Master essential Linux troubleshooting tools, including strace, gdb, kdb, SysRq, /proc, and more

The indispensable start-to-finish troubleshooting guide for every Linux professional

Now, there's a systematic, practical guide to Linux troubleshooting for every power user, administrator, and developer. In Self-Service Linux®, two of IBM's leading Linux experts introduce a four-step methodology for identifying and resolving every type of Linux-related system or application problem: errors, crashes, hangs, performance slowdowns, unexpected behavior, and unexpected outputs. You'll learn exactly how to use Linux's key troubleshooting tools to solve problems on your own—and how to make effective use of the Linux community's knowledge.

If you use Linux professionally, this book can dramatically increase your efficiency, productivity, and marketability. If you're involved with deploying or managing Linux in the enterprise, it can help you significantly reduce operation costs, enhance availability, and improve ROI.

• Discover proven best practices for diagnosing problems in Linux environments

• Leverage troubleshooting skills you've developed with other platforms

• Learn to identify problems with strace—the most frequently used Linux troubleshooting tool

• Use /proc to uncover crucial information about hardware, kernels, and processes

• Recompile open source applications with debug information

• Debug applications with gdb, including C++ and threaded applications

• Debug kernel crashes and hangs, one step at a time

• Understand the Executable and Linking Format (ELF), and use that knowledge for more effective debugging

• Includes a production-ready data collection script that can save you hours or days in debugging mission-critical Linux systems!

Series Editor Bruce Perens' is an open source evangelist, developer, and consultant whose software is a major component of most commercial embedded Linux offerings. He founded or cofounded Linux Standard Base, Open Source Initiative, and Software in the Public Interest. As Debian GNU/Linux Project Leader, he was instrumental in getting the system on two U.S. space shuttle flights.

© Copyright Pearson Education. All rights reserved.

See all Editorial Reviews

Product Details

• Paperback: 456 pages
• Publisher: Prentice Hall PTR; 1 edition (September 29, 2005)
• Language: English
• ISBN-10: 013147751X
• ISBN-13: 978-0131477513
• Product Dimensions: 9.1 x 7 x 1.3 inches
• Shipping Weight: 1.9 pounds (View shipping rates and policies)
• Average Customer Review: 4.7 out of 5 stars  See all reviews (6 customer reviews)
• Amazon.com Sales Rank: #220,662 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

12 of 13 people found the following review helpful:

5.0 out of 5 stars I don't give 5 stars lightly, October 13, 2005

By	Anthony Lawrence "Unix, Linux and Mac OS X" (Middleboro, MA USA) - See all my reviews (REAL NAME)

I'm not sure I've ever given a book 5 stars, but this hits me where I live. The only complaint I have is that the title is misleading: it should have been "Learn how to troubleshoot any Linux problem you ever see" or something like that.

I once thought I'd like to write a book on trouble shooting and problem diagnosis. I'm glad I didn't, because this would make me feel like I had wasted my time.

This is truly excellent. I have already learned more here than I have anywhere in the past year, and look forward to spending a lot more time with this.

6 of 6 people found the following review helpful:

5.0 out of 5 stars The high art of problem investigation and software debugging, June 14, 2006

By	Nils Valentin (Tokyo, Japan) - See all my reviews

(long review)

I have just finished reading through the book Self service Linux from Wilding & Behman.
Let me point out, that when I read the description first I thought that it would be a troubleshooting & performance tweak guide.
However when I read through the first chapters I believed hat the title should say "Troubleshooting (GNU) Linux using Compiler and Debugger".
Finally after I read the whole book I decided the book deserves a different title something like

"The high art of problem investigation and software debugging". - I explain why below.

O.k the title issue out of the way lets focus on the contents of the book.

Table of Contents
Preface.
1. Best Practices and Initial Investigation. - (40p)
2. strace and System Call Tracing Explained. - (50p)
3. The /proc Filesystem. - (30p)
4. Compiling. - (30p)
5. The Stack. - (40p)
6. The GNU Debugger (GDB). - (80p)
7. Linux System Crashes and Hangs. - (20p)
8.: Kernel Debugging with KDB. - (10p)
9.: ELF: Executable and Linking Format. - (85p)
Appendix A: The Toolbox. - (13p)
Appendix B: Data Collection Script. - (12p)
Index. - (10p)


You can already conclude just by looking at the TOC that most is compiling and debugging related stuff.
So to make it clear, this book is NOT for the faint hearted neither is it for beginners. It is for the professionals class room, Power users,
Sysadmins, engineers etc. which either have 3-5 years Linux experience, are in need of a thorough understanding or are looking into developing software.

This is also backed up by the fact that Wilding has 15 years experience writing software and Behman 10 years
experience with (GNU) Linux alone.

Now, if you think 10 years back (1996) you will probably remember that GNU Linux was not that major yet.
So you can assume that Wilding and Behman carry "some" pioneer spirit which is reflected in their book all the way by
the rich details in every single chapter.

The book doesnt loose a lot of time and explains in Chapter 1 (The Intro) an overview of the investigation methods
and also spends an extra 10 pages for the symptoms versus cause explanations with its possible solutions.
That described experience alone can be an invaluable and a BIG timesaver.
If I may make a recommmendation: Make sure you read Chapter 1 thoroughly and DONT SKIM OVER IT !!
I made the mistake and skimmed over it. Almost at the end of the book I realised that many of the questions that
came up for me where caused by not having read the first Chapter thoroughly enough.

Having never done an strace before I found the strace chapter to be very detailed *almost a bit overwhelming for a second chapter.
Developers and senior IT professionals might feel here right at home. I found that the book is overall very detailed and contains so much information that I have
to admit I did not crasp all on the first read ;-). Especially the chapters about Compiling, the GDB and ELF are incredible detailed
and very thoroughly describe many steps which are absolutely necessary investigating software issues.
It is this thoroughly prepared "learned lessons" which the authors describe which makes the book so valuable.

Many people out there may have some experience with debugging and compiling and the typical three commands
"configure or make config, make and install", may have read the one or the other howto.
It is this book which takes those bits and puzzle peaces and allows you to put it together to see the whole picture
of how the software stuff works on the inside of your box.

Instructors and Teachers might use the book for prepareing tutorials and howto*s for classrooms or study courses.
There is enough info inside to make lots of them. It is also a very nice self study book.
The book is very readable, which is especially surprising considering the complex topics Wilding and Behman
are takling.

I personally enjoyed most the chapters about the /proc filesystem and the ELF. However I have to admit that ELF
(the default format for shared libraries and executables) is by no way a simple topic and I had to take a break several times in
order to be able to stay focused and remind me where I am. f.e. In the ELF chapter Wilding and Behman describe 17 of 29
Section names and types * which is a lot *.
They do not only describe their functions, but also their correlations and their importance in the debugging process. A this isnt enough,
Wilding and Behman step you through several debugging process and documented almost each single step I could think of - a gesture
which is very helpful, not only for beginners. They also explain the symbol resolution thats going on internal of the ELF files.
Finally they even explain 2 interception methods, including one showing you how to attach to a running process and debugging it !!

I could feel that this book is written with a lot of passion for a great topic. This is not only a compliment for the authors but also for the team behind the book.
The book is a VERY VALUABLE CONTRIBUTION - not only but - especially for junior members in the open source community.
I also believe that it is a very nice text for the classroom or selve study courses.

If you read until here, chances are high that you will like the book.


Summary:

Its nice to see such a thoroughly prepared text about compiling and debugging which is so readable.
The book allows anybody who has read a few howto's and was wondering how this all relates to each other, to finally get the big picture.
On top of it, Wildman and Behman put a lot of "best practices" tips and advices in the book.

Soo, to sum it up in one sentence:

FINALLY an easy understandable and very readable book about debugging and compiling. If you want to get only one book about compiling and debugging, this is it !


Note: This review was edited to remove some mispellings, however you may still find some typos in the text.

6 of 8 people found the following review helpful:

4.0 out of 5 stars nice chapter on explaining GDB , October 15, 2005

By	W Boudville (Terra, Sol 3) - See all my reviews (TOP 10 REVIEWER)    (REAL NAME)

Wilding and Behman take us deep into diagnosing problems that can arise under linux. It seems best suited for an experienced developer or sysadmin. The issues it deals with tend to require this. For example, in many instances, the text gives example assembler code, for the x86 architecture. Most programmers, even when debugging, simply do not need to know the assembler version of their code. Or how the stack works.

However, for those of you who do, the text can be very useful in explaining what really happens under the bonnet, when you compile and run a program.

The book's cover suggests that it can also be useful to power users. I'm somewhat dubious of this. The most that a latter user might do or can do is to hand over a core dump or a screen capture of some diagnostics, to a programmer. Where the latter is the one who avails herself of this book.

The book devotes an entire chapter to the GNU debugger, gdb. More readable than the official GNU documentation on gdb. Given gdb's widespread use across of linux, and indeed over most versions of unix, this chapter may be the most helpful in the book, to some readers. It's a usage exposition that is distinct from a reference manual. Also, given the wealth of user interfaces these days, the text shows how to use a UI front end to gdb, called the Data Display Debugger. While some gdb purists might scorn this, and revert to their trusty command lines, others will welcome the DDD.

If you have been looking for help on gdb, the book is a good answer.