sdk/lib/rtl/exception.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Runtime Library
   4  * PURPOSE:         User-Mode Exception Support
   5  * FILE:            lib/rtl/exception.c
   6  * PROGRAMERS:      Alex Ionescu (alex@relsoft.net)
   7  *                  David Welch <welch@cwcom.net>
   8  *                  Skywing <skywing@valhallalegends.com>
   9  *                  KJK::Hyperion <noog@libero.it>
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <rtl.h>
  15
  16 #define NDEBUG
  17 #include <debug.h>
  18
  19 /* GLOBALS *****************************************************************/
  20
  21 PRTLP_UNHANDLED_EXCEPTION_FILTER RtlpUnhandledExceptionFilter;
  22
  23 /* FUNCTIONS ***************************************************************/
  24
  25 #if !defined(_M_IX86) && !defined(_M_AMD64)
  26
  27 /*
  28  * @implemented
  29  */
  30 VOID
  31 NTAPI
  32 RtlRaiseException(IN PEXCEPTION_RECORD ExceptionRecord)
  33 {
  34     CONTEXT Context;
  35     NTSTATUS Status;
  36
  37     /* Capture the context */
  38     RtlCaptureContext(&Context);
  39
  40     /* Save the exception address */
  41     ExceptionRecord->ExceptionAddress = _ReturnAddress();
  42
  43     /* Write the context flag */
  44     Context.ContextFlags = CONTEXT_FULL;
  45
  46     /* Check if user mode debugger is active */
  47     if (RtlpCheckForActiveDebugger())
  48     {
  49         /* Raise an exception immediately */
  50         Status = ZwRaiseException(ExceptionRecord, &Context, TRUE);
  51     }
  52     else
  53     {
  54         /* Dispatch the exception and check if we should continue */
  55         if (!RtlDispatchException(ExceptionRecord, &Context))
  56         {
  57             /* Raise the exception */
  58             Status = ZwRaiseException(ExceptionRecord, &Context, FALSE);
  59         }
  60         else
  61         {
  62             /* Continue, go back to previous context */
  63             Status = ZwContinue(&Context, FALSE);
  64         }
  65     }
  66
  67     /* If we returned, raise a status */
  68     RtlRaiseStatus(Status);
  69 }
  70
  71 #endif
  72
  73 #if !defined(_M_IX86)
  74
  75 #ifdef _MSC_VER
  76 #pragma warning(push)
  77 #pragma warning(disable:4717) // RtlRaiseStatus is recursive by design
  78 #endif
  79
  80 /*
  81  * @implemented
  82  */
  83 VOID
  84 NTAPI
  85 RtlRaiseStatus(IN NTSTATUS Status)
  86 {
  87     EXCEPTION_RECORD ExceptionRecord;
  88     CONTEXT Context;
  89
  90      /* Capture the context */
  91     RtlCaptureContext(&Context);
  92
  93     /* Create an exception record */
  94     ExceptionRecord.ExceptionAddress = _ReturnAddress();
  95     ExceptionRecord.ExceptionCode  = Status;
  96     ExceptionRecord.ExceptionRecord = NULL;
  97     ExceptionRecord.NumberParameters = 0;
  98     ExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
  99
 100     /* Write the context flag */
 101     Context.ContextFlags = CONTEXT_FULL;
 102
 103     /* Check if user mode debugger is active */
 104     if (RtlpCheckForActiveDebugger())
 105     {
 106         /* Raise an exception immediately */
 107         ZwRaiseException(&ExceptionRecord, &Context, TRUE);
 108     }
 109     else
 110     {
 111         /* Dispatch the exception */
 112         RtlDispatchException(&ExceptionRecord, &Context);
 113
 114         /* Raise exception if we got here */
 115         Status = ZwRaiseException(&ExceptionRecord, &Context, FALSE);
 116     }
 117
 118     /* If we returned, raise a status */
 119     RtlRaiseStatus(Status);
 120 }
 121
 122 #ifdef _MSC_VER
 123 #pragma warning(pop)
 124 #endif
 125
 126 #endif
 127
 128 /*
 129  * @implemented
 130  */
 131 USHORT
 132 NTAPI
 133 RtlCaptureStackBackTrace(IN ULONG FramesToSkip,
 134                          IN ULONG FramesToCapture,
 135                          OUT PVOID *BackTrace,
 136                          OUT PULONG BackTraceHash OPTIONAL)
 137 {
 138     PVOID Frames[2 * 64];
 139     ULONG FrameCount;
 140     ULONG Hash = 0, i;
 141
 142     /* Skip a frame for the caller */
 143     FramesToSkip++;
 144
 145     /* Don't go past the limit */
 146     if ((FramesToCapture + FramesToSkip) >= 128) return 0;
 147
 148     /* Do the back trace */
 149     FrameCount = RtlWalkFrameChain(Frames, FramesToCapture + FramesToSkip, 0);
 150
 151     /* Make sure we're not skipping all of them */
 152     if (FrameCount <= FramesToSkip) return 0;
 153
 154     /* Loop all the frames */
 155     for (i = 0; i < FramesToCapture; i++)
 156     {
 157         /* Don't go past the limit */
 158         if ((FramesToSkip + i) >= FrameCount) break;
 159
 160         /* Save this entry and hash it */
 161         BackTrace[i] = Frames[FramesToSkip + i];
 162         Hash += PtrToUlong(BackTrace[i]);
 163     }
 164
 165     /* Write the hash */
 166     if (BackTraceHash) *BackTraceHash = Hash;
 167
 168     /* Clear the other entries and return count */
 169     RtlFillMemoryUlong(Frames, 128, 0);
 170     return (USHORT)i;
 171 }
 172
 173 /*
 174 * Private helper function to lookup the module name from a given address.
 175 * The address can point to anywhere within the module.
 176 */
 177 static const char*
 178     _module_name_from_addr(const void* addr, void **module_start_addr,
 179     char* psz, size_t nChars)
 180 {
 181 #if 0
 182     MEMORY_BASIC_INFORMATION mbi;
 183     if (VirtualQuery(addr, &mbi, sizeof(mbi)) != sizeof(mbi) ||
 184         !GetModuleFileNameA((HMODULE) mbi.AllocationBase, psz, nChars))
 185     {
 186         psz[0] = '\0';
 187         *module_start_addr = 0;
 188     }
 189     else
 190     {
 191         *module_start_addr = (void *) mbi.AllocationBase;
 192     }
 193     return psz;
 194 #else
 195     psz[0] = '\0';
 196     *module_start_addr = 0;
 197     return psz;
 198 #endif
 199 }
 200
 201
 202 static VOID
 203     _dump_context(PCONTEXT pc)
 204 {
 205 #ifdef _M_IX86
 206     /*
 207     * Print out the CPU registers
 208     */
 209     DbgPrint("CS:EIP %x:%x\n", pc->SegCs & 0xffff, pc->Eip);
 210     DbgPrint("DS %x ES %x FS %x GS %x\n", pc->SegDs & 0xffff, pc->SegEs & 0xffff,
 211         pc->SegFs & 0xffff, pc->SegGs & 0xfff);
 212     DbgPrint("EAX: %.8x   EBX: %.8x   ECX: %.8x\n", pc->Eax, pc->Ebx, pc->Ecx);
 213     DbgPrint("EDX: %.8x   EBP: %.8x   ESI: %.8x   ESP: %.8x\n", pc->Edx,
 214         pc->Ebp, pc->Esi, pc->Esp);
 215     DbgPrint("EDI: %.8x   EFLAGS: %.8x\n", pc->Edi, pc->EFlags);
 216 #elif defined(_M_AMD64)
 217     DbgPrint("CS:RIP %x:%I64x\n", pc->SegCs & 0xffff, pc->Rip);
 218     DbgPrint("DS %x ES %x FS %x GS %x\n", pc->SegDs & 0xffff, pc->SegEs & 0xffff,
 219         pc->SegFs & 0xffff, pc->SegGs & 0xfff);
 220     DbgPrint("RAX: %I64x   RBX: %I64x   RCX: %I64x RDI: %I64x\n", pc->Rax, pc->Rbx, pc->Rcx, pc->Rdi);
 221     DbgPrint("RDX: %I64x   RBP: %I64x   RSI: %I64x   RSP: %I64x\n", pc->Rdx, pc->Rbp, pc->Rsi, pc->Rsp);
 222     DbgPrint("R8: %I64x   R9: %I64x   R10: %I64x   R11: %I64x\n", pc->R8, pc->R9, pc->R10, pc->R11);
 223     DbgPrint("R12: %I64x   R13: %I64x   R14: %I64x   R15: %I64x\n", pc->R12, pc->R13, pc->R14, pc->R15);
 224     DbgPrint("EFLAGS: %.8x\n", pc->EFlags);
 225 #elif defined(_M_ARM)
 226     DbgPrint("Pc: %lx   Lr: %lx   Sp: %lx    Cpsr: %lx\n", pc->Pc, pc->Lr, pc->Sp, pc->Cpsr);
 227     DbgPrint("R0: %lx   R1: %lx   R2: %lx    R3: %lx\n", pc->R0, pc->R1, pc->R2, pc->R3);
 228     DbgPrint("R4: %lx   R5: %lx   R6: %lx    R7: %lx\n", pc->R4, pc->R5, pc->R6, pc->R7);
 229     DbgPrint("R8: %lx   R9: %lx  R10: %lx   R11: %lx\n", pc->R8, pc->R9, pc->R10, pc->R11);
 230     DbgPrint("R12: %lx   \n", pc->R12);
 231 #else
 232 #pragma message ("Unknown architecture")
 233 #endif
 234 }
 235
 236 static VOID
 237     PrintStackTrace(struct _EXCEPTION_POINTERS *ExceptionInfo)
 238 {
 239     PVOID StartAddr;
 240     CHAR szMod[128] = "";
 241     PEXCEPTION_RECORD ExceptionRecord = ExceptionInfo->ExceptionRecord;
 242     PCONTEXT ContextRecord = ExceptionInfo->ContextRecord;
 243
 244     /* Print a stack trace. */
 245     DbgPrint("Unhandled exception\n");
 246     DbgPrint("ExceptionCode:    %8x\n", ExceptionRecord->ExceptionCode);
 247
 248     if ((NTSTATUS) ExceptionRecord->ExceptionCode == STATUS_ACCESS_VIOLATION &&
 249         ExceptionRecord->NumberParameters == 2)
 250     {
 251         DbgPrint("Faulting Address: %8x\n", ExceptionRecord->ExceptionInformation[1]);
 252     }
 253
 254     _dump_context(ContextRecord);
 255     _module_name_from_addr(ExceptionRecord->ExceptionAddress, &StartAddr, szMod, sizeof(szMod));
 256     DbgPrint("Address:\n   %8x+%-8x   %s\n",
 257         (PVOID) StartAddr,
 258         (ULONG_PTR) ExceptionRecord->ExceptionAddress - (ULONG_PTR) StartAddr,
 259         szMod);
 260 #ifdef _M_IX86
 261     DbgPrint("Frames:\n");
 262
 263     _SEH2_TRY
 264     {
 265         UINT i;
 266         PULONG Frame = (PULONG) ContextRecord->Ebp;
 267
 268         for (i = 0; Frame[1] != 0 && Frame[1] != 0xdeadbeef && i < 128; i++)
 269         {
 270             //if (IsBadReadPtr((PVOID) Frame[1], 4))
 271             if (Frame[1] == 0)
 272             {
 273                 DbgPrint("   %8x%9s   %s\n", Frame[1], "<invalid address>", " ");
 274             }
 275             else
 276             {
 277                 _module_name_from_addr((const void*) Frame[1], &StartAddr,
 278                     szMod, sizeof(szMod));
 279                 DbgPrint("   %8x+%-8x   %s\n",
 280                     (PVOID) StartAddr,
 281                     (ULONG_PTR) Frame[1] - (ULONG_PTR) StartAddr,
 282                     szMod);
 283             }
 284
 285             if (Frame[0] == 0) break;
 286             //if (IsBadReadPtr((PVOID) Frame[0], sizeof(*Frame) * 2))
 287                 //break;
 288
 289             Frame = (PULONG) Frame[0];
 290         }
 291     }
 292     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 293     {
 294         DbgPrint("<error dumping stack trace: 0x%x>\n", _SEH2_GetExceptionCode());
 295     }
 296     _SEH2_END;
 297 #endif
 298 }
 299
 300
 301 /*
 302  * @unimplemented
 303  */
 304 LONG
 305 NTAPI
 306 RtlUnhandledExceptionFilter(IN struct _EXCEPTION_POINTERS* ExceptionInfo)
 307 {
 308     /* This is used by the security cookie checks, and also called externally */
 309     UNIMPLEMENTED;
 310     PrintStackTrace(ExceptionInfo);
 311     return ERROR_CALL_NOT_IMPLEMENTED;
 312 }
 313
 314 /*
 315  * @implemented
 316  */
 317 VOID
 318 NTAPI
 319 RtlSetUnhandledExceptionFilter(IN PRTLP_UNHANDLED_EXCEPTION_FILTER TopLevelExceptionFilter)
 320 {
 321     /* Set the filter which is used by the CriticalSection package */
 322     RtlpUnhandledExceptionFilter = RtlEncodePointer(TopLevelExceptionFilter);
 323 }