Software Diagnostics Institute

In addition to existing pattern catalogues such as for trace analysis we introduce patterns of trace acquisition as general platform and product independent reusable solutions to commonly occurring tracing and logging problems applicable in specific contexts. Here's the current list applicable to both software and network tracing:

• Trace Placing Map
• Trace Timing Plan
• Use Case Coverage
• Supplemental System Tracing
• Supplemental Network Tracing
• Supplemental Memory Acquisition
• Full Capture Tracing
• Tuned Capture Tracing
• First Occurrence Tracing
• Differential Strategy Tracing

Software Diagnostics Services is updating its Accelerated Software Trace Analysis training with complete pattern descriptions, examples and pattern-oriented trace acquisition requirements, design and implementation labs. The initial list of trace acquisition patterns may be revised and extended if necessary.

Software: the parts of a computer that can be dumped.

In addition to existing pattern catalogues such as for memory analysis we introduce patterns of memory acquisition as general platform and product independent reusable solutions to commonly occurring memory acquisition problems applicable in specific contexts. Here's the current list with their classification:

Structural Space Patterns

General

• State Summary Dump
• Region Memory Dump

Volatile

• Process Memory Dump
• Kernel memory Dump
• Physical Memory Dump
• Hyper Memory Dump
• Fibre Bundle Dump

Persistent

• File Memory Dump
• Storage Memory Dump

Acquisition Strategy Patterns

• External Dump
• Self Dump
• Conditional Dump
• Dump Sequence
• Transactional Dump

Software Diagnostics Services is developing Accelerated Memory Acquisition training with complete pattern descriptions, examples and pattern-oriented memory acquisition requirements, design and implementation labs. The initial list of memory acquisition patterns may be revised and extended if necessary.

As The Year of Software Diagnostics is almost finished we unveil a new type of software diagnostics in addition to pattern-oriented and systemic.

It is based on:

• Critical thinking
• Systemic thinking
• Semiotic thinking

and uses:

• Inductive reasoning
• Deductive reasoning
• Abductive reasoning

This is the further development of Software Narratology (T -> M) and Generalized Software Narratives (M -> M -> M -> ...). Now it incorporates devices (things) and IoT. Whereas the general narrative space is 2M1T:

the narrative space of NT is "complex" 2M2T:

Narratology of Things also incorporates Hardware Narratology.

In addition to existing pattern catalogues we introduce patterns (and their schemas) of disassembly (decompilation), reversing and reconstruction (deconstruction). Here's the current list in the order of their appearance in Accelerated Disassembly, Reconstruction and Reversing training:

• Universal Pointer
• Symbolic Pointer S²
• Interpreted Pointer S³
• Context Pyramid
• Potential Functionality
• Function Skeleton
• Function Call
• Call Path
• Local Variable
• Static Variable
• Pointer Dereference
• Function Prologue
• Function Epilogue
• Variable Initialization
• Memory Copy
• Call Prologue
• Call Parameter
• Call Epilogue
• Call Result
• Control Path
• Function Parameter
• Structure Field
• Last Call
• Loop
• Separator Frames
• Virtual Call
• Component Dependencies
• API Trace

The following direct links can be used to order the book now:

Buy Kindle or Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

This is a transcript of Software Diagnostics Services (former Memory Dump Analysis Services) seminar about a uniform methodology and tools for analysis of crashes, hangs, and other types of abnormal software behaviour in cloud environments.

• Title: The Old New Crash: Cloud Memory Dump Analysis
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (August 2011)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 40 pages
• ISBN-13: 978-1908043283

The following direct links can be used to order the book now:

Buy Kindle version

Buy Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

This is a transcript of Software Diagnostics Services seminar about the perspectives of pattern-oriented software diagnostics in mobile world with examples for Android and Java.

• Title: Mobile Software Diagnostics: An Introduction
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (September 2013)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 28 pages
• ISBN-13: 978-1908043658

The following direct links can be used to order the book now:

Buy Kindle version

Buy Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

Software Narratology found its successful application in software diagnostics of abnormal software behaviour in software logs. This is a transcript of Software Diagnostics Services seminar on the new application of software narratology to network trace analysis with examples from Wireshark.

• Title: Pattern-Oriented Network Trace Analysis
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (September 2013)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 52 pages
• ISBN-13: 978-1908043580

The following direct links can be used to order the book now:

Buy Kindle version

Buy Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

This is a transcript of Software Diagnostics Services seminar about phenomenological, hermeneutical and analytical approaches to software diagnostics.

• Title: Philosophy of Software Diagnostics: An Introduction, Part 1
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (September 2013)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 36 pages
• ISBN-13: 978-1908043571

The following direct links can be used to order the book now:

Buy Kindle or Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

Some software components are innocent victims of other component coding mistakes or deliberate subversion and some start as a part of crimeware and malware but eventually become victims themselves (they crash, hang, spike, leak, are dumped, subverted, etc.) This is a transcript of Software Diagnostics Services seminar about unified malware and victimware analysis by using behavioural and structural patterns including a live memory dump analysis example.

• Title: Victimware: The Missing Part of the Equation
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (August 2013)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 28 pages
• ISBN-13: 978-1908043634

The following direct links can be used to order the book now:

Buy Kindle version

Buy Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

This is a transcript of Software Diagnostics Services seminar about how pattern-based software diagnostics, troubleshooting and debugging address software post-construction problem solving pattern life cycle: from the discovery of a new pattern through its integration into an existing pattern catalogue and pattern language, testing, packaging and delivering to pattern consumers with subsequent usage, refactoring and writing case studies.

• Title: Pattern-Based Software Diagnostics: An Introduction
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (August 2013)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 28 pages
• ISBN-13: 978-1908043498

We introduce this method based on iterative and incremental pattern-oriented diagnostics we founded and developed during the last few years. It is currently based on 5 principles:

1. Patterns are the principal measure of quality
2. Attention to detail through checklists
3. Analysis is done by motivated expertise-driven trusted individuals
4. Customer satisfaction by useful analysis delivered in the shortest possible time
5. Analysis audit as a pair diagnostics

Welcome to Debugging TV and Frames series where each episode features some facet of debugging, memory dump, and software trace analysis on Windows, Mac OS X, and Android platforms in 8 slides in 8 minutes including live WinDbg (Windows) or GDB demonstration (Mac OS X, Linux) plus extra 8 minutes for you to ask questions.

All episodes are available on YouTube with descriptions: http://www.youtube.com/DebuggingTV

Debugging TV Frame 0x01
Slides: DebuggingTV_Frame_0x01.pdf
WinDbg log: DebuggingTV_Frame_0x01.txt

Debugging TV Frame 0x02
Slides: DebuggingTV_Frame_0x02.pdf
From Q&A session: DIA SDK to access PDB symbol files

Debugging TV Frame 0x03
Slides: DebuggingTV_Frame_0x03.pdf
WinDbg log: DebuggingTV_Frame_0x03.txt

Debugging TV Frame 0x04
Slides: DebuggingTV_Frame_0x04.pdf
WinDbg log: DebuggingTV_Frame_0x04.txt
Note on Q&A: There was a question about the difference between .symopt-4 and .reload /f and indeed for the exercise purpose there was no difference. However I understood the question incorrectly and when I mentioned about forcing mismatched symbols load I meant .reload /f /i that we covered in the previous Frame Episode 0x02.

Debugging TV Frame 0x05
Slides: DebuggingTV_Frame_0x05.pdf
WinDbg log: DebuggingTV_Frame_0x05.txt

Debugging TV Frame 0x06
Slides: DebuggingTV_Frame_0x06.pdf
WinDbg log: DebuggingTV_Frame_0x06.txt

Debugging TV Frame 0x07
Slides: DebuggingTV_Frame_0x07.pdf
WinDbg log: DebuggingTV_Frame_0x07.txt

Debugging TV Frame 0x08
Slides: DebuggingTV_Frame_0x08.pdf
WinDbg log: DebuggingTV_Frame_0x08.txt
API description: contexts.h

Debugging TV Frame 0x09
Slides: DebuggingTV_Frame_0x09.pdf
WinDbg log 1: DebuggingTV_Frame_0x09-1.txt
WinDbg log 2: DebuggingTV_Frame_0x09-2.txt

Debugging TV Frame 0x0A (Mac OS X)
Slides: DebuggingTV_Frame_0x0A.pdf

Debugging TV Frame 0x0B (Mac OS X)
Slides: DebuggingTV_Frame_0x0B.pdf

Debugging TV Frame 0x0C (Mac OS X)
Crash report: MultipleThreads_2012-04-06-092234_DumpAnalysis-MacBook-Air.crash
Slides: DebuggingTV_Frame_0x0C.pdf

Debugging TV Frame 0x0D (Mac OS X)
Crash report: SpikingThread_2012-05-04-174941_DumpAnalysis-MacBook-Air.crash
Slides: DebuggingTV_Frame_0x0D.pdf

Debugging TV Frame 0x0E (Mac OS X)
Crash report: HeapCorruption2_2012-05-24-111258_DumpAnalysis-MacBook-Air.crash
Crash report: DoubleFree_2012-05-24-130929_DumpAnalysis-MacBook-Air.crash
Slides: DebuggingTV_Frame_0x0E.pdf

Debugging TV Frame 0x0F (Mac OS X)
Slides: DebuggingTV_Frame_0x0F.pdf

Debugging TV Frame 0x10 (General Software Diagnostics)
Slides: DebuggingTV_Frame_0x10.pdf

Debugging TV Frame 0x11 (Windows, Mac OS X)
Slides: DebuggingTV_Frame_0x11.pdf

Debugging TV Frame 0x12 (Mac OS X)
Slides: DebuggingTV_Frame_0x12.pdf

Debugging TV Frame 0x13 (Mac OS X)
Slides: DebuggingTV_Frame_0x13.pdf

Debugging TV Frame 0x14 (Windows)
Slides: DebuggingTV_Frame_0x14.pdf

Debugging TV Frame 0x15 (Windows)
Slides: DebuggingTV_Frame_0x15.pdf
MessageHistory x86 log: messages32.txt
MessageHistory x64 log: messages64.txt

Debugging TV Frame 0x16 (Windows)
Slides: DebuggingTV_Frame_0x16.pdf
WinDbg log (process dump): windbg-old-hangs-on-windows8-dump.txt
WinDbg log (complete dump): memory-windows8.txt

Debugging TV Frame 0x17 (Windows)
Slides: DebuggingTV_Frame_0x17.pdf

Debugging TV Frame 0x18 (Windows)
Slides: DebuggingTV_Frame_0x18.pdf
WinDbg log: logfile.txt
Source code: FrameNavigation.txt

Debugging TV Frame 0x19 (Windows)
Slides: DebuggingTV_Frame_0x19.pdf

Debugging TV Frame 0x1A (Software Diagnostics Architecture)
Slides: DebuggingTV_Frame_0x1A.pdf

Debugging TV Frame 0x1B (Windows)
Slides: DebuggingTV_Frame_0x1B.pdf
WinDbg log (iexplore memory dump analysis): iexplore-dump-analysis.txt
WinDbg log (iexplore live analysis): iexplore-live-analysis.txt

Debugging TV Frame 0x1C (Windows)
Slides: DebuggingTV_Frame_0x1C.pdf
WinDbg log: Episode-0x1C-1-no-lsass.txt
WinDbg log: Episode-0x1C-2-fibre-bundle-user-space.txt
WinDbg log: Episode-0x1C-3-fibre-bundle-kernel-space.txt
WinDbg log: Episode-0x1C-4-file-copy-spike-wrl-symbols.txt

Debugging TV Frame 0x20 (Windows)
Slides: DebuggingTV_Frame_0x20.pdf
WinDbg log: InjectionResidue.txt

Debugging TV Frame 0x21 (Windows)
Slides: DebuggingTV_Frame_0x21.pdf

Debugging TV Frame 0x22 (Windows)
Slides: DebuggingTV_Frame_0x22.pdf

Debugging TV Frame 0x23 (Windows)
Slides: DebuggingTV_Frame_0x23.pdf

Debugging TV Frame 0x24 (Windows)
Slides: DebuggingTV_Frame_0x24.pdf
Source code: PastStackTrace.txt
WinDbg log (x86): PastStackTrace32.txt
WinDbg log (x64): PastStackTrace64.txt

Debugging TV Frame 0x25 (Windows)
Slides: DebuggingTV_Frame_0x25.pdf
WinDbg log: Episode-0x25-windbg-log.txt

Debugging TV Frame 0x26 (Windows)
Slides: DebuggingTV_Frame_0x26.pdf
Source code: BufferUnderwrite.cpp
WinDbg log 1: NormalHeap.txt
WinDbg log 2: FullPageHeap.txt
WinDbg log 3: FullPageHeapBackwards.txt

Debugging TV Frame 0x27 (Windows)
Slides: DebuggingTV_Frame_0x27.pdf
WinDbg log: Episode-0x27-windbg-log.txt

Debugging TV Frame 0x28 (Windows)
Slides: DebuggingTV_Frame_0x28.pdf
WinDbg log: Episode-0x28-windbg-log.txt

Debugging TV Frame 0x29 (Windows)
Slides: DebuggingTV_Frame_0x29.pdf
WinDbg log: Episode-0x29-windbg-log.txt

Debugging TV Frame 0x30 (Windows)
Slides: DebuggingTV_Frame_0x30.pdf

Debugging TV Frame 0x31 (Windows)
Slides: DebuggingTV_Frame_0x31.pdf
WinDbg log: Episode-0x31-WinDbg-log.txt

Debugging TV Frame 0x32 (Android)
Slides: DebuggingTV_Frame_0x32.pdf
Java code: FullscreenActivityJava.txt
Android log (fragments): StackTraceCollectionLog.txt

Debugging TV Frame 0x33 (Android)
Slides: DebuggingTV_Frame_0x33.pdf
Java code for SpikingThread app: FullscreenActivitySpikingThreadJava.txt
Java code for Deadlock app: FullscreenActivityDeadlockJava.txt
Android log (fragments) for SpikingThread app: SpikingThreadLog.txt
Android log (fragments) for Deadlock app: DeadlockLog.txt
The output of top command (ADB): top.txt
The output of ps -t command (ADB): ps-t.txt

Debugging TV Frame 0x34 (Android)
Slides: DebuggingTV_Frame_0x34.pdf

More frames are coming and www.debugging.tv hosts TV programme and recordings of past episodes.

The following direct links can be used to order the book now:

Buy Kindle version

Buy Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

This is a transcript of Software Diagnostics Services seminar about how to apply systems theory and systems thinking for effective and efficient abnormal software behaviour diagnostics: the foundation of software troubleshooting and debugging.

• Title: Systemic Software Diagnostics: An Introduction
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (July 2013)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 32 pages
• ISBN-13: 978-1908043399

Based on the separation of problem solving powers we propose the following software problem solving triangle with a separate software diagnostics department:

In the forthcoming Webinar we outline the benefits of this approach.

In Pattern-Based Software Diagnostics seminar we proposed to use pattern catalogues to bridge the separation of software construction and memory dump software diagnostics. With an introduction of Motifs to trace and log analysis pattern catalogue it is now possible (at least conceptually) to bridge construction and trace analysis too:

These are patterns of abnormal software behaviour that affect software users and trigger the application of pattern-oriented software diagnostics and debugging if necessary. The initial list of relevant elementary patterns include:

1. Functional
   • Use-case Deviation
2. Non-functional
   • Crash
   • Hang (includes delays^*)
   • Counter Value (includes resource leaks, CPU spikes)
   • Error Message

^* In choosing the pattern vocabulary we decided to use ordinary names, for example, Hang was chosen instead of Response Delay.

General:

• Symbol servers (.symfix)
• Internal database(s) search
• Google or Microsoft search for suspected components as this could be a known issue. Sometimes a simple search immediately points to the fix on a vendor’s site
• The tool used to save a dump (to flag false positive, incomplete or inconsistent dumps)
• OS/SP version (version)
• Language
• Debug time
• System uptime
• Computer name (dS srv!srvcomputername or !envvar COMPUTERNAME)
• List of loaded and unloaded modules (lmv or !dlls)
• Hardware configuration (!sysinfo)
• .kframes 1000

Application or service:

• Default analysis (!analyze -v or !analyze -v -hang for hangs)
• Critical sections (!cs -s -l -o, !locks) for both crashes and hangs
• Component timestamps, duplication and paths. DLL Hell? (lmv and !dlls)
• Do any newer components exist?
• Process threads (~*kv or !uniqstack) for multiple exceptions and blocking functions
• Process uptime
• Your components on the full raw stack of the problem thread
• Your components on the full raw stack of the main application thread
• Process size
• Number of threads
• Gflags value (!gflag)
• Time consumed by threads (!runaway)
• Environment (!peb)
• Import table (!dh)
• Hooked functions (!chkimg)
• Exception handlers (!exchain)
• Computer name (!envvar COMPUTERNAME)
• Process heap stats and validation (!heap -s, !heap -s -v)
• CLR threads? (mscorwks or clr modules on stack traces) Yes: use .NET checklist below
• Hidden (unhandled and handled) exceptions on thread raw stacks

System hang:

• Default analysis (!analyze -v -hang)
• ERESOURCE contention (!locks)
• Processes and virtual memory including session space (!vm 4)
• Important services are present and not hanging
• Pools (!poolused)
• Waiting threads (!stacks)
• Critical system queues (!exqueue f)
• I/O (!irpfind)
• The list of all thread stack traces (!process 0 3f)
• LPC/ALPC chain for suspected threads (!lpc message or !alpc /m after search for "Waiting for reply to LPC" or "Waiting for reply to ALPC" in !process 0 3f output)
• RPC threads (search for "RPCRT4!OSF" in !process 0 3f output)
• Mutants (search for "Mutant - owning thread" in !process 0 3f output)
• Critical sections for suspected processes (!cs -l -o -s)
• Sessions, session processes (!session, !sprocess)
• Processes (size, handle table size) (!process 0 0)
• Running threads (!running)
• Ready threads (!ready)
• DPC queues (!dpcs)
• The list of APCs (!apc)
• Internal queued spinlocks (!qlocks)
• Computer name (dS srv!srvcomputername)
• File cache, VACB (!filecache)
• File objects for blocked thread IRPs (!irp -> !fileobj)
• Network (!ndiskd.miniports and !ndiskd.pktpools)
• Disk (!scsikd.classext -> !scsikd.classext class_device 2)
• Modules rdbss, mrxdav, mup, mrxsmb in stack traces
• Functions Ntfs!Ntfs*, nt!Fs* and fltmgr!Flt* in stack traces

BSOD:

• Default analysis (!analyze -v)
• Pool address (!pool)
• Component timestamps (lmv)
• Processes and virtual memory (!vm 4)
• Current threads on other processors
• Raw stack
• Bugcheck description (including ln exception address for corrupt or truncated dumps)
• Bugcheck callback data (!bugdump for systems prior to Windows XP SP1)
• Bugcheck secondary callback data (.enumtag)
• Computer name (dS srv!srvcomputername)
• Hardware configuration (!sysinfo)

.NET application or service:

• CLR module and SOS extension versions (lmv and .chain)
• Managed exceptions (~*e !pe)
• Nested managed exceptions (!pe -nested)
• Managed threads (!Threads -special)
• Managed stack traces (~*e !CLRStack)
• Managed execution residue (~*e !DumpStackObjects and !DumpRuntimeTypes)
• Managed heap (!VerifyHeap, !DumpHeap -stat and !eeheap -gc)
• GC handles (!GCHandles, !GCHandleLeaks)
• Finalizer queue (!FinalizeQueue)
• Sync blocks (!syncblk)

The following direct links can be used to order the book now:

Buy Kindle or Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

This is a transcript of Software Diagnostics Services seminar about different pattern categories for effective and efficient abnormal software behaviour diagnostics: the foundation of scalable and cost-effective pattern-driven software support.

• Title: Pattern-Driven Software Diagnostics: An Introduction
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (April 2013)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 32 pages
• ISBN-13: 978-1908043382

Interpreting hardware signals as messages and messages as signals allows us to apply Software Narratology and software trace analysis patterns to the domain of hardware diagnostics:

Generalized trace analysis patterns and narrative extends the view of hardware-software traces and logs as temporarily ordered event sequences. The time domain is generalized to any arbitrary set such as a list of indexes or pointers or even memory itself. This gives a unification of memory and log analysis and application of Computer Narratology ^(*) to memory dump analysis as well.

(*) We call the application of methods of literary narratology to computer trace and log analysis and computer-related stories in general as Hardware-Software Narratology or simply Computer Narratology as it was originally done in Memory Dump Analysis Anthology, Volume 3 when we first introduced Software Narratology.

Software diagnostics is used whenever there is a fault that triggers some kind of an artefact such as a memory dump or a software trace. It is also used proactively in software and network monitoring. We combine all these uses with our pattern-oriented approach to anticipate faults before their occurrence:

Such preventive software diagnostics consists from 4 interrelated parts:

• General software structure and behaviour pattern catalogues
• Domain, vendor and product specific problem catalogues
• Live monitoring
• Pre-mortem analysis

Pre-mortem here means preventive memory dump analysis. It is similar to post-mortem analysis but artefacts are collected and analysed proactively before any actual problem. In some sense pre-mortem analysis is a part of live monitoring but we confine the latter to software trace and log analysis.

The following direct links can be used to order the book now:

Buy Kindle version

Buy Paperback or Hardcover from Amazon

Buy Paperback or Hardcover from Barnes & Noble

Buy Paperback or Hardcover from Book Depository

Also available in PDF format from Software Diagnostics Services

Contains revised, edited, cross-referenced, and thematically organized selected DumpAnalysis.org blog posts about memory dump and software trace analysis, software troubleshooting and debugging written in November 2010 - October 2011 for software engineers developing and maintaining products on Windows platforms, quality assurance engineers testing software on Windows platforms, technical support and escalation engineers dealing with complex software issues, and security researchers, malware analysts and reverse engineers. The sixth volume features:

- 56 new crash dump analysis patterns including 14 new .NET memory dump analysis patterns
- 4 new pattern interaction case studies
- 11 new trace analysis patterns
- New Debugware pattern
- Introduction to UI problem analysis patterns
- Introduction to intelligence analysis patterns
- Introduction to unified debugging pattern language
- Introduction to generative debugging, metadefect template library and DNA of software behavior
- The new school of debugging
- .NET memory dump analysis checklist
- Software trace analysis checklist
- Introduction to close and deconstructive readings of a software trace
- Memory dump analysis compass
- Computical and Stack Trace Art
- The abductive reasoning of Philip Marlowe
- Orbifold memory space and cloud computing
- Memory worldview
- Interpretation of cyberspace
- Relationship of memory dumps to religion
- Fully cross-referenced with Volume 1, Volume 2, Volume 3, Volume 4, and Volume 5

Product information:

• Title: Memory Dump Analysis Anthology, Volume 6
• Author: Dmitry Vostokov
• Language: English
• Product Dimensions: 22.86 x 15.24

• Paperback: 306 pages
• Publisher: Opentask (January 2013)
• ISBN-13: 978-1-908043-19-1

• Hardcover: 306 pages
• Publisher: Opentask (January 2013)
• ISBN-13: 978-1-908043-20-7

Table of Contents
Errata

Back cover features 3d memory space visualization image created with ParaView.

consists of two main parts:

• Pattern-Driven process of finding patterns from existing pattern catalogs
• Pattern-Based evolution of pattern catalogs and pattern relationships

The following direct links can be used to order the book now:

Buy Kindle version

Buy Paperback from Amazon

Buy Paperback from Barnes & Noble

Buy Paperback from Book Depository

Available for SkillSoft Books24x7 subscribers

Also available in PDF format + recording from Software Diagnostics Services.

The full transcript of Software Diagnostics Services training. Feel frustrated when opening a software trace with millions of messages from hundreds of software components, threads and processes? Go beyond simple CPU and disk hog monitoring or searching for errors in a text and learn how to efficiently and effectively analyze software traces and logs from complex software environments. Covered popular software logs and trace formats from Microsoft and Citrix products and tools including Event Tracing for Windows (ETW) and Citrix Common Diagnostics Format (CDF). This course teaches using pioneering and innovative pattern-driven and pattern-based analysis of abnormal software behavior incidents developed by Software Diagnostics Institute.

• Title: Accelerated Windows Software Trace Analysis: Training Course Transcript
• Authors: Dmitry Vostokov, Software Diagnostics Services
• Publisher: OpenTask (January 2013)
• Language: English
• Product Dimensions: 28.0 x 21.6
• Paperback: 130 pages
• ISBN-13: 978-1908043429

Table of Contents

Software log analysis patterns from Software Diagnostics Institute are independent from any OS, platform or product because they are based on viewing software logs as stories of computation and were discovered by application of narratological analysis (software narratology). In addition to these patterns there exist domain specific problem patterns such as wrong hotfix level or specific product error code during software installation or execution. Typical examples of support for such platform and product specific type of patterns include Microsoft Windows Problem Reporting and Citrix Auto Support.

Let’s define software diagnostics as a discipline studying abnormal software structure and behavior in software execution artifacts (such as memory dumps, software and network traces and logs) using pattern-driven, systemic and pattern-based analysis methodologies.

Pattern-driven software post-construction problem solving involves using preexisting pattern languages and pattern catalogs for software diagnostics, troubleshooting and debugging. Pattern-based software post-construction problem solving addresses PLS (Pattern Life Cycle) - from the discovery of a new pattern through its integration into an existing catalog and language, testing, packaging and delivering to pattern consumers with subsequent usage, refactoring and writing case studies:

The first software diagnostics certification in memory dump analysis starts this September and will be administered by Software Diagnostics Services:

http://www.patterndiagnostics.com/memory-dump-analysis-certification-out...

We also plan a beta software trace analysis certification.

For companies there is also available Software Diagnostics Maturity enterprise certification:

http://www.patterndiagnostics.com/software-diagnostics-maturity

Welcome to the project CARE!

We now also accept GDB logs and crash reports from Mac OS X and iOS.

CARE means Crash Analysis Report Environment. It includes a pattern-driven debugger log analyzer and standards for structured audience-driven reports. The system architecture is described here.

Please help to populate the database of stack traces by submitting your WinDbg and GDB output logs including Mac OS X and iOS crash reports. For Windows you can use VBScript / WinDbg script to process all .DMP files on your hard drives: DebuggerLogs.zip. The archive contains VBScript file for x64 WinDbg (DebuggerLogs64.vbs) and for x86 WinDbg (DebuggerLogs.vbs) plus the very simple mode-independent WinDbg script (DebuggerLogs.wds). The WinDbg output is stored in dbgeng.log file.

Note: Please do not submit your crash or core dumps because the file size is limited to 2 MB and CARE system is currently being designed to analyze debugger logs and crash reports only. If your log is bigger you can submit a zip file. If you have any problems please contact the administrator. Please do not expect any crash analysis response for your logs or reports. The submittal is currently for internal CARE database population only and not for the pattern analysis of your computer memory.

Under inscription...

The name for this table was suggested by Joshua J. Drake and first propagated to me by @jcran

Action                      | GDB                 | WinDbg
----------------------------------------------------------------
Start the process           | run                 | g
Exit                        | (q)uit              | q
Disassemble (forward)       | (disas)semble       | uf, u
Disassemble N instructions  | x/<N>i              | -
Disassemble (backward)      | disas <a-o> <a>     | ub
Stack trace                 | backtrace (bt)      | k
Full stack trace            | bt full             | kv
Stack trace with parameters | bt full             | kP
Partial trace (innermost)   | bt <N>              | k <N>
Partial trace (outermost)   | bt -<N>             | -
Stack trace for all threads | thread apply all bt | ~*k
Breakpoint                  | break               | bp
Frame numbers               | any bt command      | kn
Select frame                | frame               | .frame
Display parameters          | info args           | dv /t /i /V
Display locals              | info locals         | dv /t /i /V
Dump byte char array        | x/<N>bc             | db
Switch to thread            | thread <N>          | ~<N>s
Sections/regions            | maint info sections | !address
Load symbol file            | add-symbol-file     | .reload
CPU registers               | i(nfo) r            | r

The current version is from April 30th, 2012:
http://www.dumpanalysis.org/blog/index.php/2012/04/30/gdb-for-windbg-users-part-8/

To Do:

- Split rows by categories
- Add links to command descriptions, examples, relevant patterns