Looking for:
Advanced windows debugging ebook free download |
- Advanced windows debugging ebook free download
Advanced windows debugging ebook free download. Follow the Authors
This volume contains the kind of stuff we all wish we had known back at the beginning of those projects—the kind of stuff that the debugging guru tells you over a coffee-spilled keyboard on February 29 only because an extra day showed up and he has the afternoon free; the kind of stuff that only comes from actually building and then debugging complex systems projects instead of just read-ing about somebody else doread-ing it.
Get two copies. You will always be lending the other one out. In-depth examples showing how to debug intri-cate problems, such as stack and heap corruptions, make this book stand out among cur-rent available literature on debugging Win32 software on Windows. It does not only tell how to deal with tough diagnosis problems, but it also explains the mechanisms behind the techniques used. The pragmatic approach taken in. Advanced Windows Debugging makes it a good resource to understand several key Windows areas.
It includes representative examples of typical defects, the tools used to investigate these defects, and step-by-step instructions for using these tools.
I am buying a copy of this book, so she can learn it. The chapters on postmortem debugging and memory corruption are essential reading that provide real insight into the internals of the runtime and OS in the context of a program fault.
This is what industrial strength debugging is all about. The authors and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume no responsibility for errors or omis-sions.
No liability is assumed for incidental or consequential damages in connection with or arising out of the use of the information or programs contained herein. For more information, please contact:. Visit us on the Web: www. ISBN pbk.
Operating systems Computers — Management. Debugging in computer science. Pravat, Daniel. All rights reserved. Printed in the United States of America. This publication is protected by copyright, and permission must be obtained from the publisher prior to any prohibited reproduction, storage in a retrieval system, or transmission in any form or by any means, electronic, mechanical, photocopying, recording, or likewise. For information regarding permis-sions, write to:.
Pearson Education, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1. Software has one goal: simplify. While simplifying, software must not introduce undo complexity, and there-fore should install with minimal user interaction, seamlessly integrate services and data from other applications and multiple sources, and be resilient to changes in its soft-ware and hardsoft-ware environment. For the most part, softsoft-ware magically just works.
However, while software strives to simplify the experiences of end users and administrators, it has become more and more complex. Just deter-mining which component is at fault—much less why, for a problem that surfaces as a crash in a library, a meaningless error message, or a hang—is often daunting. We all earn our pay and reputations not by how we debug, but by how quickly and accurately we do it. Happy hunting! Not long ago, we were reminiscing about a really tough problem we faced at work.
After sev-eral weeks of unfruitful attempts, we started looking for alternative approaches. 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 per-son who had happened to mention the tool if he knew of any documentation or point-ers. He gave us some brief descriptions of the tool and, perhaps more importantly, the names of other people who had worked with the tool extensively.
What followed was a series of long and instructive conversations, and bit by bit the basic idea behind the tool started falling into place. Did we ever get to the bottom of the crash? Yes—we did. 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. 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 15 years of collective debugging experience.
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 believe that its content is only intended for advanced system engineers, this is absolutely not true. One of the key points of this book is the removing of the magic.
For various reasons, a lot of software engineers believe that there is a magical relationship between the software they are working on and the operating system. Windows to gain more information that can potentially help them solve the problem.
To make effective use of this book, you will have to learn how to remove this precon-ceived notion and truly be of the mind-set that there is no magic behind-the-scenes. The core Windows components should be viewed as an extension of your product and not as a separate and magical layer. After all, the beauty of writing code at a higher level is that all of the low-level intricacies are abstracted and hidden away from the developer.
However, our claim is that although abstractive programming allows the developer not to have to focus on low-level details, it does not negate the need to know how the abstraction really works. The substance behind this claim is simple. What you are working with is really just that—an abstraction.
Usage of this abstraction in a design that it was not suited for can cause serious problems in your software; and, in such a case, without a solid understanding of how the abstraction works, it can mean the difference between shipping your product on time and slipping the release date by several months. Another key factor when considering mastering the Windows debuggers and tools is related to the debugging of live production servers.
When these bugs do surface post release, it can be a real headache tracking them down. In short, it enables customers to keep a pris-tine server during the troubleshooting process. Product support faces many of the same problems that quality assurance and software developers face on a day by day basis. The key difference, however, is the environ-mental constraints that they work under. The constraints can include not having full access to the server exhibiting the problems, having a limited amount of time avail-able for troubleshooting the server, having limited access to customer source code, and other issues.
The information presented in this book will give product support engineers a great deal of ammunition when tackling these tough problems. It should come as no surprise that the material presented in this book is highly tech-nical in nature. As with any technically oriented book, a certain amount of knowledge is assumed. While writing this book, we came to the realization that some of the areas of Windows we were writing about had been taken for granted.
Sure, most of the time we knew that those areas worked a certain way, but we did not know exactly what made them work that way. We could have simply accepted the fact that they just work, but curios-ity got the best of us as it usually does. We spent quite a lot of time researching the topics and trying to connect the dots. The basic principle behind learning anything is that there must be a will to learn. Depending on your background, some of the high-level material in the book might feel intimidating.
Embrace this intimidation, and you will be in a stronger position to fully grasp and understand the contents of this book. This book is about advanced Windows debugging, and as such parts of the book are dedicated to describing the internals of several integral Windows components for example, heap manager, RPC, security subsystem. Our intentions are not to fully explain all aspects of these components but rather to give a brief but in-depth sum-mary of how the component functions in relationship to the debugging scenarios being illustrated.
If you want to take your knowledge of the internals of Windows even further, we strongly recommend reading. Russinovich and David A. Redmond, WA: Microsoft Press, The book consists of three major parts.
In this section, we provide a short description of the contents of each chapter. Topics such as download locations, installation instructions, and usage scenarios are detailed. A minimalist implementation of a debugger is provided, as well as looking at more advanced topics such as how the exception dispatch mechanism works.
It gives a brief description of what symbol and source servers are, how to use them in association with the debuggers, and how to effectively manage them by set-ting up symbol servers and maintaining source servers for your organization. The focus of Part II is to provide the reader with the opportunity to analyze common programming mistakes using the Windows debuggers.
Each chapter begins with an overview of the Windows component s involved followed by one or more scenarios that illustrate common programming mistakes in that area. With the exception of Chapters 5 and 6, the chapters in Part II are standalone and can be read in any order. Chapter 5 focuses on stack corruptions, and Chapter 6 on heap corruptions. Each chapter begins by explaining the overall con-cept behind the type of memory being examined stack and heap and is followed by a number of common scenarios under which the corruption can occur.
Each scenario has associated sample code and a walk-through of the process that is used during debugging and root cause analysis. Knowing how to trou-bleshoot this important component is paramount when working with most applica-tions. Using the debuggers, this chapter will show how you can track identity, analyze RPC failures, and much more.
The most common form of resource leaks is related to memo-ry but not limited to it. A number of different synchronization scenarios are examined with associated debug sessions that give an in-depth view of the analysis process.
Part III is an advanced section that consists of chapters that discuss topics such as postmortem debugging bit debugging, Windows Vista fundamentals, and much more. The goal of these chapters is not to provide an exhaustive examination of each area, but rather provide just enough fundamentals for the reader to get started in the topic explained. Even though the Windows debugdebug-gers pack an extremely powerful set of commands and tools, there are times when you want to automate certain aspects of your own application debugging sessions.
This chapter details how the extensibili-ty model of the debuggers works and describes an example of a sample custom debugger extension. Basic concepts such as stack traces, function calls, and parameter passing are discussed to enable the reader to get started on debugging these power-ful architectures.
The other tool is a command called analyze, which automates the initial fault analysis process.
Comments
Post a Comment