Troubleshooting Exceptions

Module Overview

Exceptions

Managed Exceptions

Unhandled Exceptions (UhE)

Corrupted State Exceptions (CSE)

Just In Time (JIT) Debugging

Debugging Managed Exceptions

2

Exceptions

Unexpected behavior (for example, an error)

encountered by an executing program

Managed exception inherits from System.Exception

- Contains properties that describe and provide more info about

the exception

- All managed languages use the same exception-handling

system

3

Exception Hierarchy

SystemException

- Base class for all exceptions thrown by Application's and the

Common Language Runtime

- Types

• System.Runtime.InteropServices.ComException

• System.OutOfMemoryException

• System.NullReferenceException

• Many more…

ApplicationException

- .NET 1.1 - Design pattern, not used anymore

4

COM Interop Exception

The runtime tries to map the HRESULT from COM interop to .NET exceptions.

eg:

E_ACCESSDENIED becomes

UnauthorizedAccessException

E_OUTOFMEMORY becomes OutOfMemoryException

If this does not work

Throws COMException

If HRESULT that does not map to a managed exception

(eg. a custom HRESULT)

IErrorInfo is used to gather more detailed information

5

How Runtime Manages Exceptions

The runtime creates an exception information table for each executable.

Each method of the executable has an associated array of exception handling information in this table.

Each exception information table entry describes

a protected block of code,

any exception filters associated with that code,

any exception handlers (catch statements).

no performance penalty when an exception does not occur. You use resources only when an exception occurs.

Four types of exception handlers for protected blocks:

A finally handler that executes whenever the block exits, whether that occurs by normal control flow or by an unhandled exception.

A fault handler that has to execute if an exception occurs but does not execute on completion of normal control flow.

A type-filtered handler that handles any exception of a specified class or any of its derived classes.

A user-filtered handler that runs user-specified code to determine whether the exception should be handled by the associated handler or should be passed to the next protected block (VB.NET)

6

How Runtime Manages Exceptions

When an exception occurs:

- The runtime creates an Exception object.

- If a debugger is attached, the debugger is notified of the

exception (first chance).

- If no debugger is attached - or if a debugger is attached but

ignores the exception - the runtime searches for an array for

the protected block that:

• Includes the currently executing instruction; and

• Contains an exception handler that can handle the current

exception.

7

How Runtime Manages Exceptions cont.

If the runtime finds a handler in the current method:

- The runtime populates an Exception object that describes the

exception and executes all finally statements or exception

handlers between the statement where the exception occurred

and the statement handling the exception.

If no handler is found in the current method:

- Search the “caller” of the method and continue your way up

the call stack.

If no handlers are found even in the callers:

- If a debugger is attached, the debugger gets the second

chance notification.

- If a debugger is not attached, or the debugger does not

handle, the runtime raises an UnhandledException event.

8

Build an Exception Information Table

for each executable

Search for an entry for the

current method in the table to

handle the exceptionHandler

found?

Create an

Exception Object.

Search for an entry for the

caller of the current method

in the call stack

Exception Occurs

Beginning of

call stack?

no

no

yes

yes

Exception Handling Model

Populate Exception Object

Execute Finally blocks

Populate Exception Object

Execute Finally blocks

Resume Execution

Unhandled Exception event

Terminate Process!

Notify Debugger

1st Chance

Notify Debugger

2nd Chance

9

Coding to Handle Managed Exceptions

Coding blocks

- Try

- Catch

- Finally

- Filters (VB.NET only)

Implement exception-handling code appropriate for associated code

blocks

Handle most specific types first, then the more general types

Minimum combo of statements

- Try-Catch

- Try-Finally

AVOID empty catch blocks

10

C# Using and Exceptions

Used to clean up resources that require disposal (IDisposable interface).

IL Code

using (StreamReader reader = new StreamReader(@"C:\test.txt")){

string line = reader.ReadLine();}

IL_0000: ldstr "C:\\test.txt"

IL_0005: newobj instance void

[mscorlib]System.IO.StreamReader::.ctor(string)

…

.try

{

… IL_000c: callvirt instance string

[mscorlib]System.IO.TextReader::ReadLine()

} // end .try

finally

{

…

IL_0018: callvirt instance void

[mscorlib]System.IDisposable::Dispose()

….

} // end handler11

Demo:Exception Objects

Sxe clr

!dumpheap –type Exception

!ehinfo

Corrupted State Exceptions (CSE)

Introduced in .Net 4.0

Corrupted State Exceptions are a symptom of the corrupted

process, not the cause

- Raised after the process has been corrupted

By the time the OS gives you notification you don’t know what’s

gone wrong & for how long

People write managed code that swallows these exceptions all

the time!

try{

CreateNamedPipe(MyBadPointer, 0, ..0, 0, new System.IntPtr(0));}catch (Exception ex){ //Exception handling code… }

13

Corrupted State Exceptions (CSE)

Corrupted State Exceptions

- STATUS_ACCESS_VIOLATION

• presented as System.AccessViolationException

- STATUS_STACK_OVERFLOW

- EXCEPTION_ILLEGAL_INSTRUCTION

- EXCEPTION_IN_PAGE_ERROR

- EXCEPTION_INVALID_DISPOSITION

- EXCEPTION_NONCONTINUABLE_EXCEPTION

- EXCEPTION_PRIV_INSTRUCTION

- STATUS_UNWIND_CONSOLIDATE

Exception will be marked as “corrupted”

COM will no longer convert a CSE to an HRESULT

14

Corrupted State Exceptions (Cont.)

.NET 4.0 marks CSE exceptions internally and will not allow them to be caught

.NET 4.0 will not catch CSEs inside of runtime or swallow them

- TargetInvocation and TypeInitialization will inherit corrupted exception state:

• Eg: When CSE happens during TypeInitialization, a TypeInitializationException will be created with CSE as the inner exception and instance will be marked as corrupted(we can’t trust the state of the object).

- COM will no longer convert CSEs to HRESULTS

• Non-CSEs will still be converted into HRESULTS

To handle CSE, you have to use:

- [HandleProcessCorruptedStateExceptions] attribute

• code must be SecurityCritical & not sandboxed

- <legacyCorruptedStateExceptionsPolicy enabled="true|false"/>

• Process-wide switch to mimic .NET 3.5 or older behavior

15

Exception Policies

Behavior of runtime in case of Exceptions can be controlled with

CLR Policy:

- Requires to host runtime

- Eg: in case of stack overflow unload AppDomain instead of

terminating Application

- Eg: Change to Rude Thread Abort (no finally) in case of a Thread

Abort

hr = pPolicyManager->SetActionOnFailure(EClrFailure::FAIL_StackOverflow,EPolicyAction::eRudeUnloadAppDomain);

hr = pPolicyManager->SetDefaultAction(EClrOperation::OPR_ThreadAbort,EPolicyAction::eRudeAbortThread);

16

Unhandled Exceptions (UhE)

Occurs when an exception is thrown and no catch filter accepts

the exception object

Set up UnhandledExceptionEventHandler

- Delegate which is triggered by an unhandled exception

In .NET 4.0, the following will terminate a process

- StackOverflowException

- Corrupted State Exceptions

17

Unhandled Exceptions (UhE)

What happens if unhandled Exception occurs on what

kind of thread?

.NET Version

Unmanaged Main Finalizer Worker Threadpool

1.1 Process

Term.

Process

Term.

Thread

Term.

Thread

Term.

Thread Term.

2.0 / 4.0 Process

Term.

Process

Term.

Process

Term.

Process

Term.

Process

Term.

2.0 / 4.0 +

<legacyUnhandledExce

ptionPolicy =“true”/>

Process

Term.

Process

Term.

Thread

Term.

Thread

Term.

Thread Term.

18

Just In Time (JIT) Debugging .NET 4.X

19

JIT debugging for native and managed code configured in registry

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\Current Version\AeDebug

During 2nd chance exceptions

Auto (REG_SZ) 0 – The system displays a message box notifying

the user when an application error occurs.

Auto (REG_SZ) 1 – Starts automatically debugging

Debugger

(REG_SZ)

Name of debugger and switch settings

-p Stores the Process ID specified by %ld

-e Stores the Events ID specified by %ld

eg:cdb -pv -p %ld -c ".dump /u /ma

c:\crashdump.dmp;.kill;qd"

UserDebuggerHot

Key (DWORD)

Specifies the key that, when pressed, establishes

a breakpoint in code being debugged.

Exceptions and WinRT up from .NET 4.5.1

20

Better exception support for Windows Runtime components

- Up from Windows 8.1 and .NET 4.5.1

- preserve information about the error that caused the exception, even across

language boundaries

Perfmon Counters

.NET CLR Exceptions

# of Exceps Thrown

# Exceps Thrown/sec

Memory

Available MBytes

ASP.NET version

Application Restarts

Worker Process

Restarts

21

Debugging Managed Exceptions

Managed debuggers

- Visual Studio 2008..2013• Break if CLR exceptions are thrown

• Supports Full and Mini Dumps up from .NET 4.0

22

Managed debuggers - IntelliTrace

“Historical” Debugging facility

Included with Ultimate Edition

Cmd line tool “IntelliTrace.exe”

Options

- Exceptions and other Events only

- Events and call information (can build custom)

Limitations

- Managed code only

- 64-bit support launched from Visual Studio 2010 up from sp1

- Edit and continue is disabled

23

Gather Dumps on unhandled Exceptions

ProcDump

Debug Diag

Intellitrace

Windows Error Reporting

24

Demo:WER, Procdump

Native Debuggers

Windbg / cdb

Pros

- Debuggers of choice in production

• Automated

• Can be noninvasive

Cons

- Cannot see the true managed exception

- During live debug, must suspend entire process – not just

managed threads

26

Debugging Exceptions .NET

Common debugger cmd(s)

Tell the debugger to break on CLR exception

- sxe clr

Get the native call stack - k

Review the Exception Type

- !PrintException <exception address>

Get the managed callstack

- !clrstack

Get All exceptions in the heap use:

- !dumpheap –type Exception, !PrintException <obj>

- !psscor4.dae,!psscor2.dae

New in 4.0! CLR exception code changed

e0434f4d .NET 1.0 – 3.5. Look for 1st param of

mscorwks!RaiseTheException

e0434352 New in 4.0. Look for 1st param of

clr!RaiseTheExceptionInternalOnly27

Debugging Exceptions native

Controls debugger actions when an exception occurs

Enable Exceptions

sxe AV

Disable Exceptions

sxd AV

Ignore Exceptions

sxi AV

Notify Exceptions

sxn AV

Types of events to handle

sxe ld – break when a module loads

sxn av – notify (don’t break) on Access Violations

Debugging Exceptions in ASP.NET

Symptoms

ASP.NET will report errors in application log

Event code: 3005

Event message: An unhandled exception has occurred.

Event time: 2/27/2011 7:48:47 AM

Event time (UTC): 2/27/2011 6:48:47 AM

Event ID: d436a409de9b4f51a3554db02b178fff

Event sequence: 14

Event occurrence: 1

Event detail code: 0

Application information:

Application domain: /LM/W3SVC/1/ROOT/WebApplication1-1-129432629145240513

Trust level: Full

Application Virtual Path: /WebApplication1

Application Path: c:\inetput\wwwroot\WebApplication1\

Machine name: NTXXXSRV

29

Debugging Exceptions in ASP.NET

Remediation Strategies

Crash

- Use Debug Diagnostics or Adplus to set breakpoint on

- Locate the crashing thread and determine cause

Session State Loss and Application Restarts

- Determine causes of Application restarts

• Add logging in global.asax Application_End event

• Since ASP.NET 2.0, you can use Health Monitoring to log application

restarts

XP kernel32!ExitProcess /

kernel32!TerminateProces

Win7 ntdll!RtlExitUserProcess /

ntdll!RtlpTerminateCurrentProcess

30

Debugging Exceptions in ASP.NET

Sample Health Monitoring Web.Config

<healthMonitoringenabled="true"><providers>

<add name="EventLogProvider"type="System.Web.Management.EventLogWebEventProvider"

/></providers><eventMappings>

<add name="Application Lifetime Events"type="System.Web.Management.WebApplicationLifetimeEvent"

/></eventMappings><rules>

<addname="Web Application Lifetime Events"eventName="Application Lifetime Events"provider="EventLogProvider"

/></rules>

</healthMonitoring>

31

Debugging Exceptions in ASP.NET

Sample Health Monitoring Log

Event code: 1002

Event message: Application is shutting down. Reason: Hosting environment is

shutting down.

Event time: 3/25/2011 5:34:10 PM

Event time (UTC): 3/25/2011 9:34:10 PM

Event ID: 8d7a69ed388a4b60ad09758d7c2f63b7

Event sequence: 4

Event occurrence: 1

Event detail code: 50002

Application information:

Application domain: /LM/W3SVC/1/ROOT/Debugging2-1-129455624285402371

Trust level: Full

Application Virtual Path: /WebApp

Application Path: C:\inetpub\wwwroot\WebApp\

Machine name: WebServerName

Process information:

Process ID: 3816

Process name: w3wp.exe

Account name: IIS APPPOOL\DefaultAppPool

32

Debugging Exceptions in WinForm

Attach debugger to take memory dump for post-mortem analysis

.NET 2.0 - .NET 3.5 sp1

Enable jitDebugging in App.config

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework]"InstallRoot"="C:\\WINDOWS\\Microsoft.NET\\Framework\\""DbgManagedDebugger"="cdb -pv -p %ld -c ".dump /u /ma c:\crashdump.dmp;.kill;qd""DbgJitDebugLaunchSetting"=dword:00000002

<?xml version="1.0" encoding="utf-8" ?><configuration><system.windows.forms jitDebugging="true" /> </configuration>

33

Managed Debugging Assistants

MDA

Debugging aids that provide additional info about runtime events

Assist in troubleshooting specific issues when moving between managed & unmanaged code

Common MDA’s

- bindingFailure

• Including probed path and/or display name

• Helps troubleshoot FileNotFoundException / FileLoadException

- pInvokeStackImbalance

• Detects memory/stack corruptions during Pinvoke calls

• Example calling convention not matching native API

- reportAvOnComRelease

• Detects invalid COM Release calls

- callbackOnCollectedDelegate

• Access violations attempting to call into managed code through function pointers that were obtained from managed delegates.

34

Enabling MDA(s)

Depending on Environment

Development: Use Visual Studio - Debug | Exceptions

Production:

- Regkey

- AppName.mda.config

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework]"MDA"="1“[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\.NETFramework]"MDA"="1“

<mdaConfig><assistants>

<reportAvOnComRelease allowAv="false"/></assistants>

</mdaConfig> 35

Demo:MDA

<reportAvOnComRelease>

Review

1. When debugging managed exceptions, what is one advantage a managed debugger has over native debugger?

2. How do you control JIT debugging of managed application when an unhandled exception is thrown?

3. What happens when a Finalizer thread throws an unhandled exception?

4. Is there a way to get .NET 2.0 Exception Handling behavior?

37

Reference

Handling Corrupted State Exceptions

- http://msdn.microsoft.com/en-us/magazine/dd419661.aspx

Sandboxing in .NET 4.0

- http://blogs.msdn.com/b/shawnfa/archive/2009/05/22/sandboxing-in-net-4-

0.aspx

Logging ASP.NET Application Shutdown Events

- http://weblogs.asp.net/scottgu/archive/2005/12/14/433194.aspx

Diagnosing Errors with Managed Debugging Assistants

- http://msdn.microsoft.com/en-us/library/d21c150d.aspx

38