Merge vk-gl-cts/vulkan-cts-1.0.1 into vk-gl-cts/vulkan-cts-1.0.2
[platform/upstream/VK-GL-CTS.git] / framework / qphelper / qpCrashHandler.c
1 /*-------------------------------------------------------------------------
2  * drawElements Quality Program Helper Library
3  * -------------------------------------------
4  *
5  * Copyright 2014 The Android Open Source Project
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  *//*!
20  * \file
21  * \brief System handler handler override
22  *//*--------------------------------------------------------------------*/
23
24 #include "qpCrashHandler.h"
25 #include "qpDebugOut.h"
26
27 #include "deThread.h"
28 #include "deMemory.h"
29 #include "deString.h"
30 #include "deMutex.h"
31
32 #include <stdio.h>
33 #include <stdarg.h>
34 #include <stdlib.h>
35
36 #if (DE_OS == DE_OS_UNIX)
37 #       include <unistd.h>
38 #       include <execinfo.h>
39 #       include <errno.h>
40 #       include <inttypes.h>
41 #endif
42
43 #if 0
44 #       define DBGPRINT(X) qpPrintf X
45 #else
46 #       define DBGPRINT(X)
47 #endif
48
49 /* Crash info write helper. */
50 static void writeInfoFormat (qpWriteCrashInfoFunc writeFunc, void* userPtr, const char* format, ...)
51 {
52         char            buf[256];
53         va_list         ap;
54
55         va_start(ap, format);
56         vsnprintf(buf, sizeof(buf), format, ap);
57         va_end(ap);
58
59         writeFunc(userPtr, buf);
60 }
61
62 /* Shared crash info. */
63 typedef enum qpCrashType_e
64 {
65         QP_CRASHTYPE_SEGMENTATION_FAULT = 0,
66         QP_CRASHTYPE_ASSERT,
67         QP_CRASHTYPE_UNHANDLED_EXCEPTION,
68         QP_CRASHTYPE_OTHER,
69
70         QP_CRASHTYPE_LAST
71 } qpCrashType;
72
73 typedef struct qpCrashInfo_s
74 {
75         qpCrashType                                             type;
76         const char*                                             message;
77         const char*                                             file;
78         int                                                             line;
79 } qpCrashInfo;
80
81 static void qpCrashInfo_init (qpCrashInfo* info)
82 {
83         info->type              = QP_CRASHTYPE_LAST;
84         info->message   = DE_NULL;
85         info->file              = DE_NULL;
86         info->line              = 0;
87 }
88
89 static void qpCrashInfo_set (qpCrashInfo* info, qpCrashType type, const char* message, const char* file, int line)
90 {
91         info->type              = type;
92         info->message   = message;
93         info->file              = file;
94         info->line              = line;
95 }
96
97 static void qpCrashInfo_write (qpCrashInfo* info, qpWriteCrashInfoFunc writeInfo, void* userPtr)
98 {
99         switch (info->type)
100         {
101                 case QP_CRASHTYPE_SEGMENTATION_FAULT:
102                         writeInfoFormat(writeInfo, userPtr, "Segmentation fault: '%s'\n", info->message);
103                         break;
104
105                 case QP_CRASHTYPE_UNHANDLED_EXCEPTION:
106                         writeInfoFormat(writeInfo, userPtr, "Unhandled exception: '%s'\n", info->message);
107                         break;
108
109                 case QP_CRASHTYPE_ASSERT:
110                         writeInfoFormat(writeInfo, userPtr, "Assertion '%s' failed at %s:%d\n",
111                                                         info->message,
112                                                         info->file,
113                                                         info->line);
114                         break;
115
116                 case QP_CRASHTYPE_OTHER:
117                 default:
118                         writeInfoFormat(writeInfo, userPtr, "Crash: '%s'\n", info->message);
119                         break;
120         }
121 }
122
123 static void defaultWriteInfo (void* userPtr, const char* infoString)
124 {
125         DE_UNREF(userPtr);
126         qpPrintf("%s", infoString);
127 }
128
129 static void defaultCrashHandler (qpCrashHandler* crashHandler, void* userPtr)
130 {
131         DE_UNREF(userPtr);
132         qpCrashHandler_writeCrashInfo(crashHandler, defaultWriteInfo, DE_NULL);
133         qpDief("Test process crashed");
134 }
135
136 #if (DE_OS == DE_OS_WIN32) && (DE_COMPILER == DE_COMPILER_MSC)
137
138 #define WIN32_LEAN_AND_MEAN
139 #include <windows.h>
140
141 /* DbgHelp.h generates C4091 */
142 #pragma warning (push)
143 #pragma warning (disable: 4091)
144 #include <DbgHelp.h>
145 #pragma warning (pop)
146
147 struct qpCrashHandler_s
148 {
149         qpCrashHandlerFunc                              crashHandlerFunc;
150         void*                                                   handlerUserPointer;
151
152         deMutex                                                 crashHandlerLock;
153         qpCrashInfo                                             crashInfo;
154         deUintptr                                               crashAddress;
155
156         LPTOP_LEVEL_EXCEPTION_FILTER    oldExceptionFilter;
157 };
158
159 qpCrashHandler*         g_crashHandler = DE_NULL;
160
161 static LONG WINAPI unhandledExceptionFilter (struct _EXCEPTION_POINTERS* info)
162 {
163         qpCrashType crashType   = QP_CRASHTYPE_LAST;
164         const char*     reason          = DE_NULL;
165
166         /* Skip breakpoints. */
167         if (info->ExceptionRecord->ExceptionCode == EXCEPTION_BREAKPOINT)
168         {
169                 DBGPRINT(("qpCrashHandler::unhandledExceptionFilter(): breakpoint\n"));
170                 return EXCEPTION_CONTINUE_SEARCH;
171         }
172
173         /* If no handler present (how could that be?), don't handle. */
174         if (g_crashHandler == DE_NULL)
175         {
176                 DBGPRINT(("qpCrashHandler::unhandledExceptionFilter(): no crash handler registered\n"));
177                 return EXCEPTION_CONTINUE_SEARCH;
178         }
179
180         /* If we have a debugger, let it handle the exception. */
181         if (IsDebuggerPresent())
182         {
183                 DBGPRINT(("qpCrashHandler::unhandledExceptionFilter(): debugger present\n"));
184                 return EXCEPTION_CONTINUE_SEARCH;
185         }
186
187         /* Acquire crash handler lock. Otherwise we might get strange behavior when multiple threads enter crash handler simultaneously. */
188         deMutex_lock(g_crashHandler->crashHandlerLock);
189
190         /* Map crash type. */
191         switch (info->ExceptionRecord->ExceptionCode)
192         {
193                 case EXCEPTION_ACCESS_VIOLATION:
194                         crashType       = QP_CRASHTYPE_SEGMENTATION_FAULT;
195                         reason          = "Access violation";
196                         break;
197
198                 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
199                         crashType       = QP_CRASHTYPE_SEGMENTATION_FAULT;
200                         reason          = "Array bounds exceeded";
201                         break;
202
203                 case EXCEPTION_ILLEGAL_INSTRUCTION:
204                         crashType       = QP_CRASHTYPE_OTHER;
205                         reason          = "Illegal instruction";
206                         break;
207
208                 case EXCEPTION_STACK_OVERFLOW:
209                         crashType       = QP_CRASHTYPE_OTHER;
210                         reason          = "Stack overflow";
211                         break;
212
213                 default:
214                         /* \todo [pyry] Others. */
215                         crashType       = QP_CRASHTYPE_OTHER;
216                         reason          = "";
217                         break;
218         }
219
220         /* Store reason. */
221         qpCrashInfo_set(&g_crashHandler->crashInfo, crashType, reason, __FILE__, __LINE__);
222
223         /* Store win32-specific crash info. */
224         g_crashHandler->crashAddress = (deUintptr)info->ExceptionRecord->ExceptionAddress;
225
226         /* Handle the crash. */
227         DBGPRINT(("qpCrashHandler::unhandledExceptionFilter(): handled quietly\n"));
228         if (g_crashHandler->crashHandlerFunc != DE_NULL)
229                 g_crashHandler->crashHandlerFunc(g_crashHandler, g_crashHandler->handlerUserPointer);
230
231         /* Release lock. */
232         deMutex_unlock(g_crashHandler->crashHandlerLock);
233
234         return EXCEPTION_EXECUTE_HANDLER;
235 }
236
237 static void assertFailureCallback (const char* expr, const char* file, int line)
238 {
239         /* Don't execute crash handler function if debugger is present. */
240         if (IsDebuggerPresent())
241         {
242                 DBGPRINT(("qpCrashHandler::assertFailureCallback(): debugger present\n"));
243                 return;
244         }
245
246         /* Acquire crash handler lock. */
247         deMutex_lock(g_crashHandler->crashHandlerLock);
248
249         /* Store info. */
250         qpCrashInfo_set(&g_crashHandler->crashInfo, QP_CRASHTYPE_ASSERT, expr, file, line);
251         g_crashHandler->crashAddress = 0;
252
253         /* Handle the crash. */
254         if (g_crashHandler->crashHandlerFunc != DE_NULL)
255                 g_crashHandler->crashHandlerFunc(g_crashHandler, g_crashHandler->handlerUserPointer);
256
257         /* Release lock. */
258         deMutex_unlock(g_crashHandler->crashHandlerLock);
259 }
260
261 qpCrashHandler* qpCrashHandler_create (qpCrashHandlerFunc handlerFunc, void* userPointer)
262 {
263         /* Allocate & initialize. */
264         qpCrashHandler* handler = (qpCrashHandler*)deCalloc(sizeof(qpCrashHandler));
265         DBGPRINT(("qpCrashHandler::create() -- Win32\n"));
266         if (!handler)
267                 return handler;
268
269         DE_ASSERT(g_crashHandler == DE_NULL);
270
271         handler->crashHandlerFunc       = handlerFunc ? handlerFunc : defaultCrashHandler;
272         handler->handlerUserPointer     = userPointer;
273
274         /* Create lock for crash handler. \note Has to be recursive or otherwise crash in assert failure causes deadlock. */
275         {
276                 deMutexAttributes attr;
277                 attr.flags = DE_MUTEX_RECURSIVE;
278                 handler->crashHandlerLock = deMutex_create(&attr);
279
280                 if (!handler->crashHandlerLock)
281                 {
282                         deFree(handler);
283                         return DE_NULL;
284                 }
285         }
286
287         qpCrashInfo_init(&handler->crashInfo);
288         handler->crashAddress           = 0;
289
290         /* Unhandled exception filter. */
291         handler->oldExceptionFilter = SetUnhandledExceptionFilter(unhandledExceptionFilter);
292
293         /* Prevent nasty error dialog. */
294         SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOGPFAULTERRORBOX);
295
296         /* DE_ASSERT callback. */
297         deSetAssertFailureCallback(assertFailureCallback);
298
299         g_crashHandler = handler;
300         return handler;
301 }
302
303 void qpCrashHandler_destroy (qpCrashHandler* handler)
304 {
305         DBGPRINT(("qpCrashHandler::destroy()\n"));
306
307         DE_ASSERT(g_crashHandler == handler);
308
309         deSetAssertFailureCallback(DE_NULL);
310         SetUnhandledExceptionFilter(handler->oldExceptionFilter);
311
312         g_crashHandler = DE_NULL;
313         deFree(handler);
314 }
315
316 enum
317 {
318         MAX_NAME_LENGTH = 64
319 };
320
321 void qpCrashHandler_writeCrashInfo (qpCrashHandler* handler, qpWriteCrashInfoFunc writeInfo, void* userPtr)
322 {
323         void*                   addresses[32];
324         HANDLE                  process;
325
326         /* Symbol info struct. */
327         deUint8                 symInfoStorage[sizeof(SYMBOL_INFO)+MAX_NAME_LENGTH];
328         SYMBOL_INFO*    symInfo                 = (SYMBOL_INFO*)symInfoStorage;
329
330         DE_STATIC_ASSERT(sizeof(TCHAR) == sizeof(deUint8));
331
332         /* Write basic info. */
333         qpCrashInfo_write(&handler->crashInfo, writeInfo, userPtr);
334
335         /* Acquire process handle and initialize symbols. */
336         process = GetCurrentProcess();
337
338         /* Write backtrace. */
339         if (SymInitialize(process, NULL, TRUE))
340         {
341                 int batchStart          = 0;
342                 int globalFrameNdx      = 0;
343
344                 /* Initialize symInfo. */
345                 deMemset(symInfo, 0, sizeof(symInfoStorage));
346                 symInfo->SizeOfStruct   = sizeof(SYMBOL_INFO);
347                 symInfo->MaxNameLen             = MAX_NAME_LENGTH;
348
349                 /* Print address and symbol where crash happened. */
350                 if (handler->crashAddress != 0)
351                 {
352                         BOOL symInfoOk = SymFromAddr(process, (DWORD64)handler->crashAddress, 0, symInfo);
353
354                         writeInfoFormat(writeInfo, userPtr, "  at %p %s%s\n", handler->crashAddress,
355                                                         symInfoOk ? symInfo->Name : "(unknown)",
356                                                         symInfoOk ? "()" : "");
357                 }
358
359                 writeInfo(userPtr, "Backtrace:\n");
360
361                 for (;;)
362                 {
363                         int curFrame;
364                         int numInBatch;
365
366                         /* Get one batch. */
367                         numInBatch = CaptureStackBackTrace(batchStart, DE_LENGTH_OF_ARRAY(addresses), addresses, NULL);
368
369                         for (curFrame = 0; curFrame < numInBatch; curFrame++)
370                         {
371                                 BOOL symInfoOk = SymFromAddr(process, (DWORD64)addresses[curFrame], 0, symInfo);
372
373                                 writeInfoFormat(writeInfo, userPtr, "  %2d: %p %s%s\n", globalFrameNdx++, addresses[curFrame],
374                                                                 symInfoOk ? symInfo->Name : "(unknown)",
375                                                                 symInfoOk ? "()" : "");
376                         }
377
378                         batchStart += numInBatch;
379
380                         /* Check if we hit end of stack trace. */
381                         if (numInBatch == 0 || numInBatch < DE_LENGTH_OF_ARRAY(addresses))
382                                 break;
383                 }
384         }
385 }
386
387 #else /* posix / generic implementation */
388
389 #if defined(QP_USE_SIGNAL_HANDLER)
390 #       include <signal.h>
391 #endif
392
393 #if defined(QP_USE_SIGNAL_HANDLER)
394
395 typedef struct SignalInfo_s
396 {
397         int                             signalNum;
398         qpCrashType             type;
399         const char*             name;
400 } SignalInfo;
401
402 static const SignalInfo s_signals[] =
403 {
404         { SIGABRT,              QP_CRASHTYPE_UNHANDLED_EXCEPTION,       "SIGABRT"       },
405         { SIGILL,               QP_CRASHTYPE_OTHER,                                     "SIGILL"        },
406         { SIGSEGV,              QP_CRASHTYPE_SEGMENTATION_FAULT,        "SIGSEGV"       },
407         { SIGFPE,               QP_CRASHTYPE_OTHER,                                     "SIGFPE"        },
408         { SIGBUS,               QP_CRASHTYPE_SEGMENTATION_FAULT,        "SIGBUS"        },
409         { SIGPIPE,              QP_CRASHTYPE_OTHER,                                     "SIGPIPE"       }
410 };
411
412 #endif /* QP_USE_SIGNAL_HANDLER */
413
414 struct qpCrashHandler_s
415 {
416         qpCrashHandlerFunc              crashHandlerFunc;
417         void*                                   handlerUserPointer;
418
419         qpCrashInfo                             crashInfo;
420         int                                             crashSignal;
421
422 #if defined(QP_USE_SIGNAL_HANDLER)
423         struct sigaction                oldHandlers[DE_LENGTH_OF_ARRAY(s_signals)];
424 #endif
425 };
426
427 qpCrashHandler* g_crashHandler = DE_NULL;
428
429 static void assertFailureCallback (const char* expr, const char* file, int line)
430 {
431         /* Store info. */
432         qpCrashInfo_set(&g_crashHandler->crashInfo, QP_CRASHTYPE_ASSERT, expr, file, line);
433
434         /* Handle the crash. */
435         if (g_crashHandler->crashHandlerFunc != DE_NULL)
436                 g_crashHandler->crashHandlerFunc(g_crashHandler, g_crashHandler->handlerUserPointer);
437 }
438
439 #if defined(QP_USE_SIGNAL_HANDLER)
440
441 static const SignalInfo* getSignalInfo (int sigNum)
442 {
443         int ndx;
444         for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_signals); ndx++)
445         {
446                 if (s_signals[ndx].signalNum == sigNum)
447                         return &s_signals[ndx];
448         }
449         return DE_NULL;
450 }
451
452 static void signalHandler (int sigNum)
453 {
454         const SignalInfo*       info    = getSignalInfo(sigNum);
455         qpCrashType                     type    = info ? info->type : QP_CRASHTYPE_OTHER;
456         const char*                     name    = info ? info->name : "Unknown signal";
457
458         qpCrashInfo_set(&g_crashHandler->crashInfo, type, name, DE_NULL, 0);
459
460         if (g_crashHandler->crashHandlerFunc != DE_NULL)
461                 g_crashHandler->crashHandlerFunc(g_crashHandler, g_crashHandler->handlerUserPointer);
462 }
463
464 #endif /* QP_USE_SIGNAL_HANDLER */
465
466 qpCrashHandler* qpCrashHandler_create (qpCrashHandlerFunc handlerFunc, void* userPointer)
467 {
468         /* Allocate & initialize. */
469         qpCrashHandler* handler = (qpCrashHandler*)deCalloc(sizeof(qpCrashHandler));
470         DBGPRINT(("qpCrashHandler::create()\n"));
471         if (!handler)
472                 return handler;
473
474         DE_ASSERT(g_crashHandler == DE_NULL);
475
476         handler->crashHandlerFunc       = handlerFunc ? handlerFunc : defaultCrashHandler;
477         handler->handlerUserPointer     = userPointer;
478
479         qpCrashInfo_init(&handler->crashInfo);
480
481         g_crashHandler = handler;
482
483         /* DE_ASSERT callback. */
484         deSetAssertFailureCallback(assertFailureCallback);
485
486 #if defined(QP_USE_SIGNAL_HANDLER)
487         /* Register signal handlers. */
488         {
489                 struct sigaction        action;
490                 int                                     sigNdx;
491
492                 sigemptyset(&action.sa_mask);
493                 action.sa_handler       = signalHandler;
494                 action.sa_flags         = 0;
495
496                 for (sigNdx = 0; sigNdx < DE_LENGTH_OF_ARRAY(s_signals); sigNdx++)
497                         sigaction(s_signals[sigNdx].signalNum, &action, &handler->oldHandlers[sigNdx]);
498         }
499 #endif
500
501         return handler;
502 }
503
504 void qpCrashHandler_destroy (qpCrashHandler* handler)
505 {
506         DBGPRINT(("qpCrashHandler::destroy()\n"));
507
508         DE_ASSERT(g_crashHandler == handler);
509
510         deSetAssertFailureCallback(DE_NULL);
511
512 #if defined(QP_USE_SIGNAL_HANDLER)
513         /* Restore old handlers. */
514         {
515                 int sigNdx;
516                 for (sigNdx = 0; sigNdx < DE_LENGTH_OF_ARRAY(s_signals); sigNdx++)
517                         sigaction(s_signals[sigNdx].signalNum, &handler->oldHandlers[sigNdx], DE_NULL);
518         }
519 #endif
520
521         g_crashHandler = DE_NULL;
522
523         deFree(handler);
524 }
525
526 #if (DE_PTR_SIZE  == 8)
527 #       define PTR_FMT "0x%016"
528 #elif (DE_PTR_SIZE  == 4)
529 #       define PTR_FMT "0x%08"
530 #else
531 #       error Unknwon DE_PTR_SIZE
532 #endif
533
534 void qpCrashHandler_writeCrashInfo (qpCrashHandler* crashHandler, qpWriteCrashInfoFunc writeInfo, void* userPtr)
535 {
536         qpCrashInfo_write(&crashHandler->crashInfo, writeInfo, userPtr);
537
538 #if (DE_OS == DE_OS_UNIX)
539         {
540                 char    tmpFileName[]   = "backtrace-XXXXXX";
541                 int             tmpFile                 = mkstemp(tmpFileName);
542
543                 if (tmpFile == -1)
544                 {
545                         writeInfoFormat(writeInfo, userPtr, "Failed to create tmpfile '%s' for the backtrace %s.", tmpFileName, strerror(errno));
546                         return;
547                 }
548                 else
549                 {
550                         void*   symbols[32];
551                         int             symbolCount;
552                         int             symbolNdx;
553
554                         /* Remove file from filesystem. */
555                         remove(tmpFileName);
556
557                         symbolCount = backtrace(symbols, DE_LENGTH_OF_ARRAY(symbols));
558                         backtrace_symbols_fd(symbols, symbolCount, tmpFile);
559
560                         if (lseek(tmpFile, 0, SEEK_SET) < 0)
561                         {
562                                 writeInfoFormat(writeInfo, userPtr, "Failed to seek to the beginning of the trace file %s.", strerror(errno));
563                                 close(tmpFile);
564                                 return;
565                         }
566
567                         for (symbolNdx = 0; symbolNdx < symbolCount; symbolNdx++)
568                         {
569                                 char    nameBuffer[256];
570                                 size_t  symbolNameLength = 0;
571                                 char    c;
572
573                                 {
574                                         const int ret = snprintf(nameBuffer, DE_LENGTH_OF_ARRAY(nameBuffer), PTR_FMT  PRIXPTR " : ", (uintptr_t)symbols[symbolNdx]);
575
576                                         if (ret < 0)
577                                         {
578                                                 writeInfoFormat(writeInfo, userPtr, "Failed to print symbol pointer.");
579                                                 symbolNameLength = 0;
580                                         }
581                                         else if (ret >= DE_LENGTH_OF_ARRAY(nameBuffer))
582                                         {
583                                                 symbolNameLength = DE_LENGTH_OF_ARRAY(nameBuffer) - 1;
584                                                 nameBuffer[DE_LENGTH_OF_ARRAY(nameBuffer) - 1] = '\0';
585                                         }
586                                         else
587                                                 symbolNameLength = ret;
588                                 }
589
590                                 for (;;)
591                                 {
592                                         if (read(tmpFile, &c, 1) == 1)
593                                         {
594                                                 if (c == '\n')
595                                                 {
596                                                         /* Flush nameBuffer and move to next symbol. */
597                                                         nameBuffer[symbolNameLength] = '\0';
598                                                         writeInfo(userPtr, nameBuffer);
599                                                         break;
600                                                 }
601                                                 else
602                                                 {
603                                                         /* Add character to buffer if there is still space left. */
604                                                         if (symbolNameLength+1 < DE_LENGTH_OF_ARRAY(nameBuffer))
605                                                         {
606                                                                 nameBuffer[symbolNameLength] = c;
607                                                                 symbolNameLength++;
608                                                         }
609                                                 }
610                                         }
611                                         else
612                                         {
613                                                 /* Flush nameBuffer. */
614                                                 nameBuffer[symbolNameLength] = '\0';
615                                                 writeInfo(userPtr, nameBuffer);
616
617                                                 /* Temp file ended unexpectedly? */
618                                                 writeInfoFormat(writeInfo, userPtr, "Unexpected EOF reading backtrace file '%s'", tmpFileName);
619                                                 close(tmpFile);
620                                                 tmpFile = -1;
621
622                                                 break;
623                                         }
624                                 }
625
626                                 if (tmpFile == -1)
627                                         break;
628                         }
629
630                         if (tmpFile != -1)
631                                 close(tmpFile);
632                 }
633         }
634 #endif
635 }
636
637 #endif /* generic */