Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : /* system headers */
22 : #include "system.h"
23 :
24 : #define MAX_STACK_FRAMES 256
25 :
26 : #if defined( MACOSX )
27 :
28 : #if defined( INTEL )
29 : #include "backtrace.h"
30 : #define INCLUDE_BACKTRACE
31 : #define STACKTYPE "MacOsX_X86"
32 : #endif /* INTEL */
33 :
34 : #endif /* MACOSX */
35 :
36 : #ifdef LINUX
37 : #include <execinfo.h>
38 : #include <link.h>
39 : #define INCLUDE_BACKTRACE
40 : #define STACKTYPE "Linux"
41 : #endif
42 :
43 : #ifdef SOLARIS
44 :
45 : #include "backtrace.h"
46 : #define INCLUDE_BACKTRACE
47 :
48 : #if defined( SPARC )
49 : #define STACKTYPE "Solaris_Sparc"
50 : #elif defined( INTEL )
51 : #define STACKTYPE "Solaris_X86"
52 : #else
53 : #define STACKTYPE "Solaris_Unknown"
54 : #endif
55 :
56 : #endif /* defined SOLARIS */
57 :
58 : #include <osl/diagnose.h>
59 : #include <osl/mutex.h>
60 : #include <osl/signal.h>
61 : #include <osl/process.h>
62 : #include <osl/thread.h>
63 : #include <sal/macros.h>
64 : #include <rtl/bootstrap.h>
65 : #include <rtl/digest.h>
66 :
67 : #include "file_path_helper.h"
68 :
69 : #define ACT_IGNORE 1
70 : #define ACT_EXIT 2
71 : #define ACT_SYSTEM 3
72 : #define ACT_HIDE 4
73 : #ifdef SAL_ENABLE_CRASH_REPORT
74 : # define ACT_ABORT 5
75 : #else
76 : # define ACT_ABORT ACT_SYSTEM
77 : #endif
78 :
79 : #if defined HAVE_VALGRIND_HEADERS
80 : #include <valgrind/memcheck.h>
81 : #endif
82 :
83 : typedef struct _oslSignalHandlerImpl
84 : {
85 : oslSignalHandlerFunction Handler;
86 : void* pData;
87 : struct _oslSignalHandlerImpl* pNext;
88 : } oslSignalHandlerImpl;
89 :
90 : static struct SignalAction
91 : {
92 : int Signal;
93 : int Action;
94 : void (*Handler)(int);
95 : } Signals[] =
96 : {
97 : { SIGHUP, ACT_HIDE, NULL }, /* hangup */
98 : { SIGINT, ACT_EXIT, NULL }, /* interrupt (rubout) */
99 : { SIGQUIT, ACT_EXIT, NULL }, /* quit (ASCII FS) */
100 : { SIGILL, ACT_SYSTEM, NULL }, /* illegal instruction (not reset when caught) */
101 : /* changed from ACT_ABOUT to ACT_SYSTEM to try and get collector to run*/
102 : { SIGTRAP, ACT_ABORT, NULL }, /* trace trap (not reset when caught) */
103 : #if ( SIGIOT != SIGABRT )
104 : { SIGIOT, ACT_ABORT, NULL }, /* IOT instruction */
105 : #endif
106 : { SIGABRT, ACT_ABORT, NULL }, /* used by abort, replace SIGIOT in the future */
107 : #ifdef SIGEMT
108 : { SIGEMT, ACT_SYSTEM, NULL }, /* EMT instruction */
109 : /* changed from ACT_ABORT to ACT_SYSTEM to remove handler*/
110 : /* SIGEMT may also be used by the profiler - so it is probably not a good
111 : plan to have the new handler use this signal*/
112 : #endif
113 : { SIGFPE, ACT_ABORT, NULL }, /* floating point exception */
114 : { SIGKILL, ACT_SYSTEM, NULL }, /* kill (cannot be caught or ignored) */
115 : { SIGBUS, ACT_ABORT, NULL }, /* bus error */
116 : { SIGSEGV, ACT_ABORT, NULL }, /* segmentation violation */
117 : #ifdef SIGSYS
118 : { SIGSYS, ACT_ABORT, NULL }, /* bad argument to system call */
119 : #endif
120 : { SIGPIPE, ACT_HIDE, NULL }, /* write on a pipe with no one to read it */
121 : { SIGALRM, ACT_EXIT, NULL }, /* alarm clock */
122 : { SIGTERM, ACT_EXIT, NULL }, /* software termination signal from kill */
123 : { SIGUSR1, ACT_SYSTEM, NULL }, /* user defined signal 1 */
124 : { SIGUSR2, ACT_SYSTEM, NULL }, /* user defined signal 2 */
125 : { SIGCHLD, ACT_SYSTEM, NULL }, /* child status change */
126 : #ifdef SIGPWR
127 : { SIGPWR, ACT_IGNORE, NULL }, /* power-fail restart */
128 : #endif
129 : { SIGWINCH, ACT_IGNORE, NULL }, /* window size change */
130 : { SIGURG, ACT_EXIT, NULL }, /* urgent socket condition */
131 : #ifdef SIGPOLL
132 : { SIGPOLL, ACT_EXIT, NULL }, /* pollable event occurred */
133 : #endif
134 : { SIGSTOP, ACT_SYSTEM, NULL }, /* stop (cannot be caught or ignored) */
135 : { SIGTSTP, ACT_SYSTEM, NULL }, /* user stop requested from tty */
136 : { SIGCONT, ACT_SYSTEM, NULL }, /* stopped process has been continued */
137 : { SIGTTIN, ACT_SYSTEM, NULL }, /* background tty read attempted */
138 : { SIGTTOU, ACT_SYSTEM, NULL }, /* background tty write attempted */
139 : { SIGVTALRM, ACT_EXIT, NULL }, /* virtual timer expired */
140 : { SIGPROF, ACT_SYSTEM, NULL }, /* profiling timer expired */
141 : /*Change from ACT_EXIT to ACT_SYSTEM for SIGPROF is so that profiling signals do
142 : not get taken by the new handler - the new handler does not pass on context
143 : information which causes 'collect' to crash. This is a way of avoiding
144 : what looks like a bug in the new handler*/
145 : { SIGXCPU, ACT_ABORT, NULL }, /* exceeded cpu limit */
146 : { SIGXFSZ, ACT_ABORT, NULL } /* exceeded file size limit */
147 : };
148 : const int NoSignals = sizeof(Signals) / sizeof(struct SignalAction);
149 :
150 : static sal_Bool bErrorReportingEnabled = sal_True;
151 : static sal_Bool bInitSignal = sal_False;
152 : static oslMutex SignalListMutex;
153 : static oslSignalHandlerImpl* SignalList;
154 : static sal_Bool bDoHardKill = sal_False;
155 : static sal_Bool bSetSEGVHandler = sal_False;
156 : static sal_Bool bSetWINCHHandler = sal_False;
157 : static sal_Bool bSetILLHandler = sal_False;
158 :
159 : static void SignalHandlerFunction(int);
160 :
161 98 : static void getExecutableName_Impl (rtl_String ** ppstrProgName)
162 : {
163 98 : rtl_uString * ustrProgFile = 0;
164 98 : osl_getExecutableFile (&ustrProgFile);
165 98 : if (ustrProgFile)
166 : {
167 98 : rtl_uString * ustrProgName = 0;
168 98 : osl_systemPathGetFileNameOrLastDirectoryPart (ustrProgFile, &ustrProgName);
169 98 : if (ustrProgName != 0)
170 : {
171 196 : rtl_uString2String (
172 : ppstrProgName,
173 98 : rtl_uString_getStr (ustrProgName), rtl_uString_getLength (ustrProgName),
174 98 : osl_getThreadTextEncoding(),
175 : OUSTRING_TO_OSTRING_CVTFLAGS);
176 98 : rtl_uString_release (ustrProgName);
177 : }
178 98 : rtl_uString_release (ustrProgFile);
179 : }
180 98 : }
181 :
182 98 : static sal_Bool is_soffice_Impl (void)
183 : {
184 98 : sal_Int32 idx = -1;
185 98 : rtl_String * strProgName = 0;
186 :
187 98 : getExecutableName_Impl (&strProgName);
188 98 : if (strProgName)
189 : {
190 98 : idx = rtl_str_indexOfStr (rtl_string_getStr (strProgName), "soffice");
191 98 : rtl_string_release (strProgName);
192 : }
193 98 : return (idx != -1);
194 : }
195 :
196 98 : static sal_Bool InitSignal()
197 : {
198 : int i;
199 : struct sigaction act;
200 : struct sigaction oact;
201 : sigset_t unset;
202 :
203 98 : if (is_soffice_Impl())
204 : {
205 : sal_uInt32 argi;
206 : sal_uInt32 argc;
207 8 : rtl_uString *ustrCommandArg = 0;
208 :
209 8 : argc = osl_getCommandArgCount();
210 72 : for ( argi = 0; argi < argc; argi++ )
211 : {
212 64 : if (osl_Process_E_None == osl_getCommandArg (argi, &ustrCommandArg))
213 : {
214 64 : if (0 == rtl_ustr_ascii_compare (rtl_uString_getStr (ustrCommandArg), "-bean"))
215 : {
216 0 : bDoHardKill = sal_True;
217 0 : break;
218 : }
219 : }
220 : }
221 8 : if (ustrCommandArg)
222 : {
223 8 : rtl_uString_release (ustrCommandArg);
224 8 : ustrCommandArg = 0;
225 : }
226 :
227 : // WORKAROUND FOR SEGV HANDLER CONFLICT
228 : //
229 : // the java jit needs SIGSEGV for proper work
230 : // and we need SIGSEGV for the office crashguard
231 : //
232 : // TEMPORARY SOLUTION:
233 : // the office sets the signal handler during startup
234 : // java can than overwrite it, if needed
235 8 : bSetSEGVHandler = sal_True;
236 :
237 : // WORKAROUND FOR WINCH HANDLER (SEE ABOVE)
238 8 : bSetWINCHHandler = sal_True;
239 :
240 : // WORKAROUND FOR ILLEGAL INSTRUCTION HANDLER (SEE ABOVE)
241 8 : bSetILLHandler = sal_True;
242 : }
243 :
244 : #ifdef DBG_UTIL
245 : bSetSEGVHandler = bSetWINCHHandler = bSetILLHandler = bDoHardKill = sal_False;
246 : #endif
247 :
248 98 : SignalListMutex = osl_createMutex();
249 :
250 98 : act.sa_handler = SignalHandlerFunction;
251 98 : act.sa_flags = SA_RESTART;
252 :
253 98 : sigfillset(&(act.sa_mask));
254 :
255 : /* Initialize the rest of the signals */
256 3038 : for (i = 0; i < NoSignals; ++i)
257 : {
258 : #if defined HAVE_VALGRIND_HEADERS
259 : if (Signals[i].Signal == SIGUSR2 && RUNNING_ON_VALGRIND)
260 : Signals[i].Action = ACT_IGNORE;
261 : #endif
262 :
263 : /* hack: stomcatd is attaching JavaVM wich dont work with an sigaction(SEGV) */
264 2940 : if ((bSetSEGVHandler || Signals[i].Signal != SIGSEGV)
265 2850 : && (bSetWINCHHandler || Signals[i].Signal != SIGWINCH)
266 2760 : && (bSetILLHandler || Signals[i].Signal != SIGILL))
267 : {
268 2670 : if (Signals[i].Action != ACT_SYSTEM)
269 : {
270 988 : if (Signals[i].Action == ACT_HIDE)
271 : {
272 : struct sigaction ign;
273 :
274 196 : ign.sa_handler = SIG_IGN;
275 196 : ign.sa_flags = 0;
276 196 : sigemptyset(&ign.sa_mask);
277 :
278 196 : if (sigaction(Signals[i].Signal, &ign, &oact) == 0)
279 196 : Signals[i].Handler = oact.sa_handler;
280 : else
281 0 : Signals[i].Handler = SIG_DFL;
282 : }
283 : else
284 : {
285 792 : if (sigaction(Signals[i].Signal, &act, &oact) == 0)
286 792 : Signals[i].Handler = oact.sa_handler;
287 : else
288 0 : Signals[i].Handler = SIG_DFL;
289 : }
290 : }
291 : }
292 : }
293 :
294 : /* Clear signal mask inherited from parent process (on Mac OS X, upon a
295 : crash soffice re-execs itself from within the signal handler, so the
296 : second soffice would have the guilty signal blocked and would freeze upon
297 : encountering a similar crash again): */
298 98 : if (sigemptyset(&unset) < 0 ||
299 98 : pthread_sigmask(SIG_SETMASK, &unset, NULL) < 0)
300 : {
301 : OSL_TRACE("sigemptyset or pthread_sigmask failed");
302 : }
303 :
304 98 : return sal_True;
305 : }
306 :
307 8 : static sal_Bool DeInitSignal()
308 : {
309 : int i;
310 : struct sigaction act;
311 :
312 8 : act.sa_flags = 0;
313 8 : sigemptyset(&(act.sa_mask));
314 :
315 : /* Initialize the rest of the signals */
316 248 : for (i = NoSignals - 1; i >= 0; i--)
317 240 : if (Signals[i].Action != ACT_SYSTEM)
318 : {
319 88 : act.sa_handler = Signals[i].Handler;
320 :
321 88 : sigaction(Signals[i].Signal, &act, NULL);
322 : }
323 :
324 8 : osl_destroyMutex(SignalListMutex);
325 :
326 8 : return sal_False;
327 : }
328 :
329 : #if defined (SAL_ENABLE_CRASH_REPORT) && defined(INCLUDE_BACKTRACE)
330 :
331 : /*****************************************************************************/
332 : /* Generate MD5 checksum */
333 : /*****************************************************************************/
334 :
335 : static sal_uInt32 calc_md5_checksum( const char *filename, sal_uInt8 *pChecksum, sal_uInt32 nChecksumLen )
336 : {
337 : sal_uInt32 nBytesProcessed = 0;
338 :
339 : FILE *fp = fopen( filename, "r" );
340 :
341 : if ( fp )
342 : {
343 : rtlDigest digest = rtl_digest_createMD5();
344 :
345 : if ( digest )
346 : {
347 : size_t nBytesRead;
348 : sal_uInt8 buffer[4096];
349 : rtlDigestError error = rtl_Digest_E_None;
350 :
351 : while ( rtl_Digest_E_None == error &&
352 : 0 != (nBytesRead = fread( buffer, 1, sizeof(buffer), fp )) )
353 : {
354 : error = rtl_digest_updateMD5( digest, buffer, nBytesRead );
355 : nBytesProcessed += nBytesRead;
356 : }
357 :
358 : if ( rtl_Digest_E_None == error )
359 : {
360 : error = rtl_digest_getMD5( digest, pChecksum, nChecksumLen );
361 : }
362 :
363 : if ( rtl_Digest_E_None != error )
364 : nBytesProcessed = 0;
365 :
366 : rtl_digest_destroyMD5( digest );
367 : }
368 :
369 : fclose( fp );
370 : }
371 :
372 : return nBytesProcessed;
373 : }
374 :
375 : /*****************************************************************************/
376 : /* Call crash reporter */
377 : /*****************************************************************************/
378 :
379 : /* Helper function to encode and write a string to a stream */
380 :
381 : static int fputs_xml( const char *string, FILE *stream )
382 : {
383 : int result = 0;
384 :
385 : while ( result >= 0 && *string )
386 : {
387 : switch( *string )
388 : {
389 : case '&':
390 : result = fputs( "&", stream );
391 : break;
392 : case '<':
393 : result = fputs( "<", stream );
394 : break;
395 : case '>':
396 : result = fputs( ">", stream );
397 : break;
398 : default:
399 : result = fputc( *string, stream );
400 : break;
401 : }
402 :
403 : string++;
404 : }
405 :
406 : return result;
407 : }
408 : #endif
409 :
410 : /* Create intermediate files and run crash reporter */
411 :
412 : #define REPORTENV_PARAM "-crashreportenv:"
413 :
414 : #if defined SAL_ENABLE_CRASH_REPORT && defined INCLUDE_BACKTRACE && \
415 : defined LINUX
416 :
417 : typedef struct
418 : {
419 : const char *name;
420 : ElfW(Off) offset;
421 : } dynamic_entry;
422 :
423 : static int
424 : callback(struct dl_phdr_info *info, size_t size, void *data)
425 : {
426 : const ElfW(Phdr) *pDynamic = NULL;
427 :
428 : if (size == sizeof(struct dl_phdr_info))
429 : {
430 : int i;
431 : for (i = 0; i < info->dlpi_phnum; ++i)
432 : {
433 : if (info->dlpi_phdr[i].p_type == PT_DYNAMIC)
434 : {
435 : pDynamic = &(info->dlpi_phdr[i]);
436 : break;
437 : }
438 : }
439 : }
440 :
441 : if (pDynamic)
442 : {
443 : char buffer[100];
444 : int len;
445 : char exe[PATH_MAX];
446 : const char *dsoname = info->dlpi_name;
447 :
448 : dynamic_entry* entry = (dynamic_entry*)data;
449 :
450 : if (strcmp(dsoname, "") == 0)
451 : {
452 : snprintf(buffer, sizeof(buffer), "/proc/%d/exe", getpid());
453 : if ((len = readlink(buffer, exe, PATH_MAX)) != -1)
454 : {
455 : exe[len] = '\0';
456 : dsoname = exe;
457 : }
458 : }
459 :
460 : if (strcmp(dsoname, entry->name) == 0)
461 : {
462 : entry->offset = pDynamic->p_offset;
463 : return 1;
464 : }
465 : }
466 : return 0;
467 : }
468 :
469 : /* Get the location of the .dynamic section offset for the given elf file.
470 : * i.e. same as the "Offset" value shown for DYNAMIC from readelf -l foo
471 : *
472 : * We want to know this value so that if the binaries have been modifed
473 : * by prelink then we can still process the call stack on server side
474 : * by comparing this value to that of an "un-prelinked but known to be
475 : * otherwise equivalent" version of those binaries and adjust the call
476 : * stack addresses by the differences between .dynamic addresses so as
477 : * to be able to map the prelinked addresses back to the unprelinked
478 : * addresses
479 : *
480 : * cmc@openoffice.org
481 : */
482 : static ElfW(Off)
483 : dynamic_section_offset(const char *name)
484 : {
485 : dynamic_entry entry;
486 :
487 : entry.name = name;
488 : entry.offset = 0;
489 :
490 : dl_iterate_phdr(callback, &entry);
491 :
492 : return entry.offset;
493 : }
494 : #endif
495 :
496 0 : static int ReportCrash( int Signal )
497 : {
498 : #ifdef SAL_ENABLE_CRASH_REPORT
499 : static sal_Bool bCrashReporterExecuted = sal_False;
500 : sal_Bool bAutoCrashReport = sal_False;
501 :
502 : sal_uInt32 argi;
503 : sal_uInt32 argc;
504 : rtl_uString *ustrCommandArg = NULL;
505 :
506 : if ( !bErrorReportingEnabled )
507 : return -1;
508 :
509 : argc = osl_getCommandArgCount();
510 :
511 : for ( argi = 0; argi < argc; argi++ )
512 : {
513 : if ( osl_Process_E_None == osl_getCommandArg( argi, &ustrCommandArg ) )
514 : {
515 : if ( 0 == rtl_ustr_ascii_compare( rtl_uString_getStr( ustrCommandArg ), "--nocrashreport" ) )
516 : {
517 : rtl_uString_release( ustrCommandArg );
518 : return -1;
519 : }
520 : else if ( 0 == rtl_ustr_ascii_compare( rtl_uString_getStr( ustrCommandArg ), "--autocrashreport" ) )
521 : {
522 : bAutoCrashReport = sal_True;
523 : }
524 : else if ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength(
525 : rtl_uString_getStr( ustrCommandArg ), rtl_uString_getLength( ustrCommandArg ),
526 : REPORTENV_PARAM, strlen(REPORTENV_PARAM) )
527 : )
528 : {
529 : rtl_uString *ustrEnvironment = NULL;
530 : rtl_String *strEnv = NULL;
531 :
532 : rtl_uString_newFromStr( &ustrEnvironment, rtl_uString_getStr( ustrCommandArg ) + strlen(REPORTENV_PARAM) );
533 :
534 : if ( ustrEnvironment )
535 : {
536 : rtl_uString2String(
537 : &strEnv,
538 : rtl_uString_getStr( ustrEnvironment ), rtl_uString_getLength( ustrEnvironment ),
539 : osl_getThreadTextEncoding(), OUSTRING_TO_OSTRING_CVTFLAGS
540 : );
541 :
542 : if ( strEnv )
543 : {
544 : putenv( rtl_string_getStr( strEnv ) );
545 : rtl_string_release( strEnv );
546 : }
547 :
548 : rtl_uString_release( ustrEnvironment );
549 : }
550 :
551 : }
552 :
553 : }
554 : }
555 :
556 : if ( ustrCommandArg )
557 : rtl_uString_release( ustrCommandArg );
558 :
559 : if ( !bCrashReporterExecuted )
560 : {
561 : int i;
562 : /* struct sigaction act; */
563 :
564 : for (i = 0; i < NoSignals; i++)
565 : {
566 : if (Signals[i].Signal == Signal && Signals[i].Action == ACT_ABORT )
567 : {
568 : int ret;
569 : char szShellCmd[512] = { '\0' };
570 : char *pXMLTempName = NULL;
571 : char *pStackTempName = NULL;
572 : char *pChecksumTempName = NULL;
573 :
574 : #ifdef INCLUDE_BACKTRACE
575 : char szXMLTempNameBuffer[L_tmpnam];
576 : char szChecksumTempNameBuffer[L_tmpnam];
577 : char szStackTempNameBuffer[L_tmpnam];
578 :
579 : void *stackframes[MAX_STACK_FRAMES];
580 : int iFrame;
581 : int nFrames = backtrace( stackframes, SAL_N_ELEMENTS(stackframes) );
582 :
583 : FILE *xmlout = NULL, *stackout = NULL, *checksumout = NULL;
584 : int fdxml, fdstk, fdchksum;
585 :
586 : strncpy( szXMLTempNameBuffer, P_tmpdir, sizeof(szXMLTempNameBuffer) );
587 : strncat( szXMLTempNameBuffer, "/crxmlXXXXXX", sizeof(szXMLTempNameBuffer) - strlen(szXMLTempNameBuffer) - 1 );
588 :
589 : strncpy( szStackTempNameBuffer, P_tmpdir, sizeof(szStackTempNameBuffer) );
590 : strncat( szStackTempNameBuffer, "/crstkXXXXXX", sizeof(szStackTempNameBuffer) - strlen(szStackTempNameBuffer) - 1 );
591 :
592 : strncpy( szChecksumTempNameBuffer, P_tmpdir, sizeof(szChecksumTempNameBuffer) );
593 : strncat( szChecksumTempNameBuffer, "/crchkXXXXXX", sizeof(szChecksumTempNameBuffer) - strlen(szChecksumTempNameBuffer) - 1 );
594 :
595 : fdxml = mkstemp(szXMLTempNameBuffer);
596 : fdstk = mkstemp(szStackTempNameBuffer);
597 : fdchksum = mkstemp(szChecksumTempNameBuffer);
598 :
599 : xmlout = fdopen( fdxml , "w" );
600 : stackout = fdopen( fdstk , "w" );
601 : checksumout = fdopen( fdchksum, "w" );
602 :
603 : pXMLTempName = szXMLTempNameBuffer;
604 : pStackTempName = szStackTempNameBuffer;
605 : pChecksumTempName = szChecksumTempNameBuffer;
606 :
607 :
608 : if ( xmlout && stackout && checksumout )
609 : {
610 : fprintf( xmlout, "<errormail:Stack type=\"%s\">\n", STACKTYPE );
611 :
612 : fprintf( checksumout, "<errormail:Checksums type=\"MD5\">\n" );
613 :
614 : for ( iFrame = 0; iFrame < nFrames; iFrame++ )
615 : {
616 : Dl_info dl_info;
617 :
618 : fprintf( stackout, "0x%" SAL_PRIxUINTPTR ":",
619 : SAL_INT_CAST(sal_uIntPtr, stackframes[iFrame]) );
620 :
621 : fprintf( xmlout, "<errormail:StackInfo pos=\"%d\" ip=\"0x%" SAL_PRIxUINTPTR "\"",
622 : iFrame,
623 : SAL_INT_CAST(sal_uIntPtr, stackframes[iFrame])
624 : );
625 :
626 : memset( &dl_info, 0, sizeof(dl_info) );
627 :
628 : /* dladdr may fail */
629 : if ( dladdr( stackframes[iFrame], &dl_info) )
630 : {
631 : const char *dli_fname = NULL;
632 : char *dli_fdir = NULL;
633 : char szDirectory[PATH_MAX];
634 : char szCanonicDirectory[PATH_MAX];
635 :
636 : /* Don't expect that dladdr filled all members of dl_info */
637 :
638 : dli_fname = dl_info.dli_fname ? strrchr( dl_info.dli_fname, '/' ) : NULL;
639 : if ( dli_fname )
640 : {
641 : ++dli_fname;
642 : memcpy( szDirectory, dl_info.dli_fname, dli_fname - dl_info.dli_fname );
643 : szDirectory[dli_fname - dl_info.dli_fname] = 0;
644 :
645 : dli_fdir = realpath( szDirectory, szCanonicDirectory ) ? szCanonicDirectory : szDirectory;
646 :
647 : if ( *dli_fdir && dli_fdir[ strlen(dli_fdir) - 1 ] != '/' )
648 : strcat( dli_fdir, "/" );
649 : }
650 : else
651 : dli_fname = dl_info.dli_fname;
652 :
653 : /* create checksum of library on stack */
654 : if ( dli_fname )
655 : {
656 : sal_uInt8 checksum[RTL_DIGEST_LENGTH_MD5];
657 :
658 : sal_uInt32 nBytesProcessed = calc_md5_checksum(
659 : dl_info.dli_fname, checksum, sizeof(checksum) );
660 : if ( nBytesProcessed )
661 : {
662 : int j;
663 :
664 : fprintf( checksumout, "<errormail:Checksum sum=\"0x" );
665 : for ( j = 0; j < 16; fprintf( checksumout, "%02X", checksum[j++] ) );
666 : fprintf( checksumout,
667 : "\" bytes=\"%lu\" file=\"%s\"/>\n",
668 : SAL_INT_CAST(
669 : unsigned long, nBytesProcessed),
670 : dli_fname );
671 : }
672 : }
673 :
674 : if ( dl_info.dli_fbase && dl_info.dli_fname )
675 : {
676 : #ifdef LINUX
677 : ElfW(Off) dynamic_offset = dynamic_section_offset(dl_info.dli_fname);
678 : fprintf( stackout, " 0x%" SAL_PRI_SIZET "x:", dynamic_offset);
679 : #endif
680 :
681 : fprintf( stackout, " %s + 0x%" SAL_PRI_PTRDIFFT "x",
682 : dl_info.dli_fname,
683 : (char*)stackframes[iFrame] - (char*)dl_info.dli_fbase
684 : );
685 :
686 : fprintf( xmlout, " rel=\"0x%" SAL_PRI_PTRDIFFT "x\"", (char *)stackframes[iFrame] - (char *)dl_info.dli_fbase );
687 : if ( dli_fname )
688 : fprintf( xmlout, " name=\"%s\"", dli_fname );
689 :
690 : if ( dli_fdir )
691 : fprintf( xmlout, " path=\"%s\"", dli_fdir );
692 :
693 : #ifdef LINUX
694 : fprintf( xmlout, " dynamicoffset=\"0x%" SAL_PRI_SIZET "x\"", dynamic_offset );
695 : #endif
696 : }
697 : else
698 : fprintf( stackout, " ????????" );
699 :
700 : if ( dl_info.dli_sname && dl_info.dli_saddr )
701 : {
702 : fputs( " (", stackout );
703 : fputs_xml( dl_info.dli_sname, stackout );
704 : fprintf( stackout, " + 0x%" SAL_PRI_PTRDIFFT "x)",
705 : (char*)stackframes[iFrame] - (char*)dl_info.dli_saddr );
706 :
707 : fputs( " ordinal=\"", xmlout );
708 : fputs_xml( dl_info.dli_sname, xmlout );
709 : fprintf( xmlout, "+0x%" SAL_PRI_PTRDIFFT "x\"",
710 : (char *)stackframes[iFrame] - (char *)dl_info.dli_saddr );
711 : }
712 :
713 : }
714 : else /* dladdr failed */
715 : {
716 : fprintf( stackout, " ????????" );
717 : }
718 :
719 : fprintf( stackout, "\n" );
720 : fprintf( xmlout, "/>\n" );
721 :
722 : }
723 :
724 : fprintf( xmlout, "</errormail:Stack>\n" );
725 : fprintf( checksumout, "</errormail:Checksums>\n" );
726 : }
727 : else
728 : {
729 : pXMLTempName = NULL;
730 : pStackTempName = NULL;
731 : pChecksumTempName = NULL;
732 : }
733 :
734 : if ( stackout )
735 : fclose( stackout );
736 : if ( xmlout )
737 : fclose( xmlout );
738 : if ( checksumout )
739 : fclose( checksumout );
740 :
741 : if ( pXMLTempName && pChecksumTempName && pStackTempName )
742 : #endif /* INCLUDE_BACKTRACE */
743 : {
744 : rtl_uString * crashrep_url = NULL;
745 : rtl_uString * crashrep_path = NULL;
746 : rtl_String * crashrep_path_system = NULL;
747 : rtl_string2UString(
748 : &crashrep_url,
749 : RTL_CONSTASCII_USTRINGPARAM(
750 : "$BRAND_BASE_DIR/program/crashrep"),
751 : OSTRING_TO_OUSTRING_CVTFLAGS);
752 : rtl_bootstrap_expandMacros(&crashrep_url);
753 : osl_getSystemPathFromFileURL(crashrep_url, &crashrep_path);
754 : rtl_uString2String(
755 : &crashrep_path_system,
756 : rtl_uString_getStr(crashrep_path),
757 : rtl_uString_getLength(crashrep_path),
758 : osl_getThreadTextEncoding(),
759 : (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR
760 : | RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR));
761 : rtl_uString_release(crashrep_url);
762 : rtl_uString_release(crashrep_path);
763 : #if defined INCLUDE_BACKTRACE && (defined LINUX || defined MACOSX)
764 : snprintf( szShellCmd, SAL_N_ELEMENTS(szShellCmd),
765 : "%s -p %d -s %d -xml %s -chksum %s -stack %s -noui%s",
766 : rtl_string_getStr(crashrep_path_system),
767 : getpid(),
768 : Signal,
769 : pXMLTempName,
770 : pChecksumTempName,
771 : pStackTempName,
772 : bAutoCrashReport ? " -send" : "" );
773 : #elif defined INCLUDE_BACKTRACE && defined SOLARIS
774 : snprintf( szShellCmd, SAL_N_ELEMENTS(szShellCmd),
775 : "%s -p %d -s %d -xml %s -chksum %s -noui%s",
776 : rtl_string_getStr(crashrep_path_system),
777 : getpid(),
778 : Signal,
779 : pXMLTempName,
780 : pChecksumTempName,
781 : bAutoCrashReport ? " -send" : "" );
782 : #else
783 : snprintf( szShellCmd, SAL_N_ELEMENTS(szShellCmd),
784 : "%s -p %d -s %d -noui%s",
785 : rtl_string_getStr(crashrep_path_system),
786 : getpid(), Signal, bAutoCrashReport ? " -send" : "" );
787 : #endif
788 : rtl_string_release(crashrep_path_system);
789 : }
790 :
791 : ret = szShellCmd[0] == '\0' ? -1 : system( szShellCmd );
792 :
793 : if ( pXMLTempName )
794 : unlink( pXMLTempName );
795 :
796 : if ( pStackTempName )
797 : unlink( pStackTempName );
798 :
799 : if ( pChecksumTempName )
800 : unlink( pChecksumTempName );
801 :
802 : if ( -1 != ret )
803 : {
804 : bCrashReporterExecuted = sal_True;
805 : return 1;
806 : }
807 : else
808 : return -1;
809 :
810 : }
811 : }
812 :
813 : return 0;
814 : }
815 :
816 : return 1;
817 : #else /* defined SAL_ENABLE_CRASH_REPORT */
818 : /* the utility crash_report is not build, so do the same as when
819 : the option -nocrashreport is used */
820 : (void) Signal; // avoid warnings
821 0 : return -1;
822 : #endif /* defined SAL_ENABLE_CRASH_REPORT */
823 : }
824 :
825 0 : static void PrintStack( int sig )
826 : {
827 : #ifdef INCLUDE_BACKTRACE
828 : void *buffer[MAX_STACK_FRAMES];
829 0 : int size = backtrace( buffer, SAL_N_ELEMENTS(buffer) );
830 : #endif
831 :
832 0 : fprintf( stderr, "\n\nFatal exception: Signal %d\n", sig );
833 :
834 : #if defined( MACOSX ) && !defined( INCLUDE_BACKTRACE )
835 : fprintf( stderr, "Please turn on Enable Crash Reporting and\nAutomatic Display of Crashlogs in the Console application\n" );
836 : #else
837 : #ifdef INCLUDE_BACKTRACE
838 0 : if ( size > 0 )
839 : {
840 0 : fputs( "Stack:\n", stderr );
841 0 : backtrace_symbols_fd( buffer, size, fileno(stderr) );
842 : }
843 : #endif
844 : #endif
845 0 : }
846 :
847 0 : static oslSignalAction CallSignalHandler(oslSignalInfo *pInfo)
848 : {
849 0 : oslSignalHandlerImpl* pHandler = SignalList;
850 0 : oslSignalAction Action = osl_Signal_ActCallNextHdl;
851 :
852 0 : while (pHandler != NULL)
853 : {
854 0 : if ((Action = pHandler->Handler(pHandler->pData, pInfo))
855 : != osl_Signal_ActCallNextHdl)
856 0 : break;
857 :
858 0 : pHandler = pHandler->pNext;
859 : }
860 :
861 0 : return Action;
862 : }
863 :
864 0 : void CallSystemHandler(int Signal)
865 : {
866 : int i;
867 : struct sigaction act;
868 :
869 0 : for (i = 0; i < NoSignals; i++)
870 : {
871 0 : if (Signals[i].Signal == Signal)
872 0 : break;
873 : }
874 :
875 0 : if (i < NoSignals)
876 : {
877 0 : if ((Signals[i].Handler == NULL) ||
878 0 : (Signals[i].Handler == SIG_DFL) ||
879 0 : (Signals[i].Handler == SIG_IGN) ||
880 0 : (Signals[i].Handler == SIG_ERR))
881 : {
882 0 : switch (Signals[i].Action)
883 : {
884 : case ACT_EXIT: /* terminate */
885 : /* prevent dumping core on exit() */
886 0 : _exit(255);
887 : break;
888 :
889 : case ACT_ABORT: /* terminate witch core dump */
890 0 : ReportCrash( Signal );
891 0 : act.sa_handler = SIG_DFL;
892 0 : act.sa_flags = 0;
893 0 : sigemptyset(&(act.sa_mask));
894 0 : sigaction(SIGABRT, &act, NULL);
895 0 : PrintStack( Signal );
896 0 : abort();
897 : break;
898 :
899 : case ACT_IGNORE: /* ignore */
900 0 : break;
901 :
902 : default: /* should never happen */
903 : OSL_ASSERT(0);
904 : }
905 0 : }
906 : else
907 0 : (*Signals[i].Handler)(Signal);
908 : }
909 0 : }
910 :
911 : #if defined HAVE_VALGRIND_HEADERS
912 : static void DUMPCURRENTALLOCS()
913 : {
914 : VALGRIND_PRINTF( "=== start memcheck dump of active allocations ===\n" );
915 :
916 : #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
917 : # pragma GCC diagnostic push
918 : # pragma GCC diagnostic ignored "-Wunused-but-set-variable"
919 : #endif
920 :
921 : VALGRIND_DO_LEAK_CHECK;
922 :
923 : #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
924 : # pragma GCC diagnostic pop
925 : #endif
926 :
927 : VALGRIND_PRINTF( "=== end memcheck dump of active allocations ===\n" );
928 : }
929 : #endif
930 :
931 : /*****************************************************************************/
932 : /* SignalHandlerFunction */
933 : /*****************************************************************************/
934 0 : void SignalHandlerFunction(int Signal)
935 : {
936 : oslSignalInfo Info;
937 : struct sigaction act;
938 :
939 0 : Info.UserSignal = Signal;
940 0 : Info.UserData = NULL;
941 :
942 0 : switch (Signal)
943 : {
944 : case SIGBUS:
945 : case SIGILL:
946 : case SIGSEGV:
947 : case SIGIOT:
948 : #if ( SIGIOT != SIGABRT )
949 : case SIGABRT:
950 : #endif
951 0 : Info.Signal = osl_Signal_AccessViolation;
952 0 : break;
953 :
954 : case -1:
955 0 : Info.Signal = osl_Signal_IntegerDivideByZero;
956 0 : break;
957 :
958 : case SIGFPE:
959 0 : Info.Signal = osl_Signal_FloatDivideByZero;
960 0 : break;
961 :
962 : case SIGINT:
963 : case SIGTERM:
964 : case SIGQUIT:
965 0 : Info.Signal = osl_Signal_Terminate;
966 0 : break;
967 :
968 : #if defined HAVE_VALGRIND_HEADERS
969 : case SIGUSR2:
970 : if (RUNNING_ON_VALGRIND)
971 : DUMPCURRENTALLOCS();
972 : Info.Signal = osl_Signal_System;
973 : break;
974 : #endif
975 :
976 : default:
977 0 : Info.Signal = osl_Signal_System;
978 0 : break;
979 : }
980 :
981 0 : ReportCrash( Signal );
982 :
983 : /* Portal Demo HACK !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
984 0 : if (bDoHardKill && (Info.Signal == osl_Signal_AccessViolation))
985 0 : _exit(255);
986 : /* Portal Demo HACK !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
987 :
988 :
989 0 : switch (CallSignalHandler(&Info))
990 : {
991 : case osl_Signal_ActCallNextHdl:
992 0 : CallSystemHandler(Signal);
993 0 : break;
994 :
995 : case osl_Signal_ActAbortApp:
996 0 : ReportCrash( Signal );
997 0 : act.sa_handler = SIG_DFL;
998 0 : act.sa_flags = 0;
999 0 : sigemptyset(&(act.sa_mask));
1000 0 : sigaction(SIGABRT, &act, NULL);
1001 0 : PrintStack( Signal );
1002 0 : abort();
1003 : break;
1004 :
1005 : case osl_Signal_ActKillApp:
1006 : /* prevent dumping core on exit() */
1007 0 : _exit(255);
1008 : break;
1009 : default:
1010 0 : break;
1011 : }
1012 0 : }
1013 :
1014 : /*****************************************************************************/
1015 : /* osl_addSignalHandler */
1016 : /*****************************************************************************/
1017 106 : oslSignalHandler SAL_CALL osl_addSignalHandler(oslSignalHandlerFunction Handler, void* pData)
1018 : {
1019 : oslSignalHandlerImpl* pHandler;
1020 :
1021 : OSL_ASSERT(Handler != NULL);
1022 106 : if ( Handler == 0 )
1023 : {
1024 0 : return 0;
1025 : }
1026 :
1027 106 : if (! bInitSignal)
1028 98 : bInitSignal = InitSignal();
1029 :
1030 106 : pHandler = (oslSignalHandlerImpl*) calloc(1, sizeof(oslSignalHandlerImpl));
1031 :
1032 106 : if (pHandler != NULL)
1033 : {
1034 106 : pHandler->Handler = Handler;
1035 106 : pHandler->pData = pData;
1036 :
1037 106 : osl_acquireMutex(SignalListMutex);
1038 :
1039 106 : pHandler->pNext = SignalList;
1040 106 : SignalList = pHandler;
1041 :
1042 106 : osl_releaseMutex(SignalListMutex);
1043 :
1044 106 : return (pHandler);
1045 : }
1046 :
1047 0 : return (NULL);
1048 : }
1049 :
1050 : /*****************************************************************************/
1051 : /* osl_removeSignalHandler */
1052 : /*****************************************************************************/
1053 16 : sal_Bool SAL_CALL osl_removeSignalHandler(oslSignalHandler Handler)
1054 : {
1055 16 : oslSignalHandlerImpl *pHandler, *pPrevious = NULL;
1056 :
1057 : OSL_ASSERT(Handler != NULL);
1058 :
1059 16 : if (! bInitSignal)
1060 0 : bInitSignal = InitSignal();
1061 :
1062 16 : osl_acquireMutex(SignalListMutex);
1063 :
1064 16 : pHandler = SignalList;
1065 :
1066 32 : while (pHandler != NULL)
1067 : {
1068 16 : if (pHandler == Handler)
1069 : {
1070 16 : if (pPrevious)
1071 0 : pPrevious->pNext = pHandler->pNext;
1072 : else
1073 16 : SignalList = pHandler->pNext;
1074 :
1075 16 : osl_releaseMutex(SignalListMutex);
1076 :
1077 16 : if (SignalList == NULL)
1078 8 : bInitSignal = DeInitSignal();
1079 :
1080 16 : free(pHandler);
1081 :
1082 16 : return (sal_True);
1083 : }
1084 :
1085 0 : pPrevious = pHandler;
1086 0 : pHandler = pHandler->pNext;
1087 : }
1088 :
1089 0 : osl_releaseMutex(SignalListMutex);
1090 :
1091 0 : return (sal_False);
1092 : }
1093 :
1094 : /*****************************************************************************/
1095 : /* osl_raiseSignal */
1096 : /*****************************************************************************/
1097 0 : oslSignalAction SAL_CALL osl_raiseSignal(sal_Int32 UserSignal, void* UserData)
1098 : {
1099 : oslSignalInfo Info;
1100 : oslSignalAction Action;
1101 :
1102 0 : if (! bInitSignal)
1103 0 : bInitSignal = InitSignal();
1104 :
1105 0 : osl_acquireMutex(SignalListMutex);
1106 :
1107 0 : Info.Signal = osl_Signal_User;
1108 0 : Info.UserSignal = UserSignal;
1109 0 : Info.UserData = UserData;
1110 :
1111 0 : Action = CallSignalHandler(&Info);
1112 :
1113 0 : osl_releaseMutex(SignalListMutex);
1114 :
1115 0 : return (Action);
1116 : }
1117 :
1118 : /*****************************************************************************/
1119 : /* osl_setErrorReporting */
1120 : /*****************************************************************************/
1121 8 : sal_Bool SAL_CALL osl_setErrorReporting( sal_Bool bEnable )
1122 : {
1123 8 : sal_Bool bOld = bErrorReportingEnabled;
1124 8 : bErrorReportingEnabled = bEnable;
1125 :
1126 8 : return bOld;
1127 : }
1128 :
1129 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
