Advanced Windows Debugging

by Hewardt, Mario; Pravat, Daniel

• ISBN13: 9780321374462
• ISBN10: 0321374460
• Edition: 1st
• Format: Paperback
• Copyright: 2007-10-29
• Publisher: Addison-Wesley Professional

Summary

&>-- Bob Wilton, Escalation Engineer, Critical Problem Resolution Team, Microsoft "An excellent reference for both intermediate and advanced debuggers: highly practical, and filled with tricks and strategies. This book stands out from all other Win32 debugging literature, thanks to its in-depth examplesincluding resolving intricate problems like stack and heap corruptions." -- Kinshuman, Development Lead, Windows Core OS Division, Microsoft The First In-Depth, Real-World, Insiderrs"s Guide to Powerful Windows Debugging For Windows developers, few tasks are more challenging than debugging-or more crucial. Reliable and realistic information about Windows debugging has always been scarce. Now, with over 15 years of experience two of Microsoftrs"s system-level developers present a thorough and practical guide to Windows debugging ever written. Mario Hewardt and Daniel Pravat cover debugging throughout the entire application lifecycle and show how to make the most of the tools currently available-including Microsoftrs"s powerful native debuggers and third-party solutions. To help you find real solutionsfast, this book is organized around real-world debugging scenarios. Hewardt and Pravat use detailed code examples to illuminate the complex debugging challenges professional developers actually face. From core Windows operating system concepts to security, Windowsreg; Vistatrade; and 64-bit debugging, they address emerging topics head-onandnothingis ever oversimplified or glossed over! This book enables you to Master todayrs"s most powerful Windows debugging tools, including NTSD, CDB, WinDbg, KD, and ADPlus Debug code that wasnrs"t designed or written for easy debugging Understand debuggers "under the hood," and manage symbols and sources efficiently Debug complex memory corruptions related to stacks and heaps Resolve complex security problems Debug across processes: identity tracking, RPC debugger extensions, and tracking IPCs with Ethereal Find and fix resource leaks, such as memory and handle leaks. Debug common thread synchronization problems Learn when and how to write custom debugger extensions Perform "postmortem debugging" using crash dumps and Windows Error Reporting Automate debugging with DebugDiag and the Analyze Debugger command Whether yours"re a system-level or application developer,Advanced Windows Debuggingdelivers the deep understanding of debugging that could save you weeks on your very next project. Part I Overview Chapter 1 Introduction to the Tools Chapter 2 Introduction to the Debuggers Chapter 3 Debugger Uncovered Chapter 4 Managing Symbol and Source Files Part II Applied Debugging Chapter 5 Memory Corruptions Part I

Author Biography

Mario Hewardt is a senior design engineer with Microsoft, and has worked extensively in the Windows system level development area for the last nine years. He is currently involved with designing and implementing the next generation management protocol for Windows Longhorn.

 

Daniel Pravat is a senior design engineer with Microsoft and has worked in the Windows division, primarily within the Windows management area. He is currently leading a development team that has the responsibility of shipping the most reliable management platform for Windows Longhorn.

Table of Contents

Overview

Introduction to the Tools

Introduction to the Debuggers

Debugger Uncovered

Managing Symbol and Source Files

Applied Debugging

Memory Corruptions

Stacks

Memory Corruptions

Heaps

Security

Inter-process Communication

Resource Leaks

Synchronization

Advanced Topics

Writing Custom Debugger Extensions

64-bit Debugging

Postmortem Debugging

Power Tools

Windows Vista Fundamentals

Application Verifier Test Settings

Index

Table of Contents provided by Publisher. All Rights Reserved.

Excerpts

Preface Not long ago we, were reminiscing about a really tough problem we faced at work. The Quality Assurance team was running stress tests on our product and every four or five days, a crash would rear its ugly head. Sure, we had debugged the crash as far as we thought possible, and we had done extensive code reviews to try to figure it out, but alas, not enough information could be gained to get to the bottom of it. After several weeks of unfruitful attempts, we started looking for alternative approaches. During a random hallway conversation, someone happened to casually mention a tool called gflags. Having never heard of this tool before, we set out to do some research to find out how it could help us get to the bottom of our crash. Unfortunately, the learning process proved to be somewhat difficult. First, finding information about the tool proved to be a real challenge. There was a ton of great information in the reference documentation that came with the tools, but it was hard to figure out how to actually get started. We quickly realized that without some basic guidance, there was little hope for us to be able to utilize the tool. Naturally, we decided to ask the person who had happened to mention the tool if they knew of any documentation or pointers. They gave us some brief descriptions of the tool and, perhaps more importantly, the names of other people who had worked with the tools extensively. What followed was a series of long and instructive conversations, and bit by bit the basic idea behind the tools started falling into place. Did we ever get to the bottom of the crash? Yes--we did. As a matter of fact, enabling the correct tool while running our stress tests pinpointed the problem to such accuracy that it only took an hour of code reviewing to locate and fix the misbehaving code. Had we known about this tool and how to use it from the start we would have saved several weeks of work. From that point on, we dedicated quite a lot of time to furthering our understanding of the tools and how they can help while trying to troubleshoot misbehaving code. Over the years, the Windows debuggers and tools have matured and grown and become increasingly powerful. The amount of timesaving features now available is truly mind-boggling. What is equally mind-boggling is that after several years, the native debuggers and tools are still relatively unknown to developers. The few developers who do find out that these tools exist have to go through a similarly painful learning process as we did years ago. We were fortunate to have the luxury of working with engineers at Microsoft (some of whom wrote the tools), but without this luxury, many hopeful developers end up at a dead end and are never able to reap the benefits of the tools. This unfortunate problem of a lack of learning material also turned out to be a great opportunity for a solution, and thus the idea for this book was born. The key to enable developers to gain the knowledge required is to provide a central repository of concise information that fully explains the ins and outs of the debugging tools and processes. The book you are holding serves as that key and is the net result of three years of writing and over 10 years of collective debugging experience. We hope that you will enjoy reading this book as much as we enjoyed authoring it and that it will open up the door to a truly amazing world of highly efficient software troubleshooting and debugging. Knowing how to use the tools and techniques described in this book is a critical part of a computer scientist's work and can teach you how to very efficiently troubleshoot some of the toughest problems in software. Who Is This Book For? The short answer to this question is anyone who is involved in any facet of software development and has a strong desire to learn what is actually happening deep inside Windows. Although the technical nature of the book might make you be