• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 /*--------------------------------------------------------------------*/
3 /*--- Assertions and panics.                        m_libcassert.c ---*/
4 /*--------------------------------------------------------------------*/
5 
6 /*
7    This file is part of Valgrind, a dynamic binary instrumentation
8    framework.
9 
10    Copyright (C) 2000-2017 Julian Seward
11       jseward@acm.org
12 
13    This program is free software; you can redistribute it and/or
14    modify it under the terms of the GNU General Public License as
15    published by the Free Software Foundation; either version 2 of the
16    License, or (at your option) any later version.
17 
18    This program is distributed in the hope that it will be useful, but
19    WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21    General Public License for more details.
22 
23    You should have received a copy of the GNU General Public License
24    along with this program; if not, write to the Free Software
25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26    02111-1307, USA.
27 
28    The GNU General Public License is contained in the file COPYING.
29 */
30 
31 #include "pub_core_basics.h"
32 #include "pub_core_vki.h"
33 #include "pub_core_vkiscnums.h"
34 #include "pub_core_threadstate.h"
35 #include "pub_core_gdbserver.h"
36 #include "pub_core_aspacemgr.h"
37 #include "pub_core_libcbase.h"
38 #include "pub_core_libcassert.h"
39 #include "pub_core_libcprint.h"
40 #include "pub_core_libcproc.h"      // For VG_(gettid)()
41 #include "pub_core_machine.h"
42 #include "pub_core_stacks.h"
43 #include "pub_core_stacktrace.h"
44 #include "pub_core_syscall.h"
45 #include "pub_core_tooliface.h"     // For VG_(details).{name,bug_reports_to}
46 #include "pub_core_options.h"       // For VG_(clo_xml)
47 
48 /* ---------------------------------------------------------------------
49    Assertery.
50    ------------------------------------------------------------------ */
51 
52 #if defined(VGP_x86_linux) || defined(VGP_x86_darwin) \
53     || defined(VGP_x86_solaris)
54 #  define GET_STARTREGS(srP)                              \
55       { UInt eip, esp, ebp;                               \
56         __asm__ __volatile__(                             \
57            "call 0f;"                                     \
58            "0: popl %0;"                                  \
59            "movl %%esp, %1;"                              \
60            "movl %%ebp, %2;"                              \
61            : "=r" (eip), "=r" (esp), "=r" (ebp)           \
62            : /* reads none */                             \
63            : "memory"                                     \
64         );                                                \
65         (srP)->r_pc = (ULong)eip;                         \
66         (srP)->r_sp = (ULong)esp;                         \
67         (srP)->misc.X86.r_ebp = ebp;                      \
68       }
69 #elif defined(VGP_amd64_linux) || defined(VGP_amd64_darwin) \
70       || defined(VGP_amd64_solaris)
71 #  define GET_STARTREGS(srP)                              \
72       { ULong rip, rsp, rbp;                              \
73         __asm__ __volatile__(                             \
74            "leaq 0(%%rip), %0;"                           \
75            "movq %%rsp, %1;"                              \
76            "movq %%rbp, %2;"                              \
77            : "=r" (rip), "=r" (rsp), "=r" (rbp)           \
78            : /* reads none */                             \
79            : "memory"                                     \
80         );                                                \
81         (srP)->r_pc = rip;                                \
82         (srP)->r_sp = rsp;                                \
83         (srP)->misc.AMD64.r_rbp = rbp;                    \
84       }
85 #elif defined(VGP_ppc32_linux)
86 #  define GET_STARTREGS(srP)                              \
87       { UInt cia, r1, lr;                                 \
88         __asm__ __volatile__(                             \
89            "mflr 0;"                   /* r0 = lr */      \
90            "bl 0f;"                    /* lr = pc */      \
91            "0:\n"                                         \
92            "mflr %0;"                  /* %0 = pc */      \
93            "mtlr 0;"                   /* restore lr */   \
94            "mr %1,1;"                  /* %1 = r1 */      \
95            "mr %2,0;"                  /* %2 = lr */      \
96            : "=r" (cia), "=r" (r1), "=r" (lr)             \
97            : /* reads none */                             \
98            : "r0" /* trashed */                           \
99         );                                                \
100         (srP)->r_pc = (ULong)cia;                         \
101         (srP)->r_sp = (ULong)r1;                          \
102         (srP)->misc.PPC32.r_lr = lr;                      \
103       }
104 #elif defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
105 #  define GET_STARTREGS(srP)                              \
106       { ULong cia, r1, lr;                                \
107         __asm__ __volatile__(                             \
108            "mflr 0;"                   /* r0 = lr */      \
109            "bl 0f;"                    /* lr = pc */      \
110            "0:\n"                                         \
111            "mflr %0;"                  /* %0 = pc */      \
112            "mtlr 0;"                   /* restore lr */   \
113            "mr %1,1;"                  /* %1 = r1 */      \
114            "mr %2,0;"                  /* %2 = lr */      \
115            : "=r" (cia), "=r" (r1), "=r" (lr)             \
116            : /* reads none */                             \
117            : "r0" /* trashed */                           \
118         );                                                \
119         (srP)->r_pc = cia;                                \
120         (srP)->r_sp = r1;                                 \
121         (srP)->misc.PPC64.r_lr = lr;                      \
122       }
123 #elif defined(VGP_arm_linux)
124 #  define GET_STARTREGS(srP)                              \
125       { UInt block[6];                                    \
126         __asm__ __volatile__(                             \
127            "str r15, [%0, #+0];"                          \
128            "str r14, [%0, #+4];"                          \
129            "str r13, [%0, #+8];"                          \
130            "str r12, [%0, #+12];"                         \
131            "str r11, [%0, #+16];"                         \
132            "str r7,  [%0, #+20];"                         \
133            : /* out */                                    \
134            : /* in */ "r"(&block[0])                      \
135            : /* trash */ "memory"                         \
136         );                                                \
137         (srP)->r_pc = block[0] - 8;                       \
138         (srP)->misc.ARM.r14 = block[1];                   \
139         (srP)->r_sp = block[2];                           \
140         (srP)->misc.ARM.r12 = block[3];                   \
141         (srP)->misc.ARM.r11 = block[4];                   \
142         (srP)->misc.ARM.r7  = block[5];                   \
143       }
144 #elif defined(VGP_arm64_linux)
145 #  define GET_STARTREGS(srP)                              \
146       { ULong block[4];                                   \
147         __asm__ __volatile__(                             \
148            "adr x19, 0;"                                  \
149            "str x19, [%0, #+0];"   /* pc */               \
150            "mov x19, sp;"                                 \
151            "str x19, [%0, #+8];"   /* sp */               \
152            "str x29, [%0, #+16];"  /* fp */               \
153            "str x30, [%0, #+24];"  /* lr */               \
154            : /* out */                                    \
155            : /* in */ "r"(&block[0])                      \
156            : /* trash */ "memory","x19"                   \
157         );                                                \
158         (srP)->r_pc = block[0];                           \
159         (srP)->r_sp = block[1];                           \
160         (srP)->misc.ARM64.x29 = block[2];                 \
161         (srP)->misc.ARM64.x30 = block[3];                 \
162       }
163 #elif defined(VGP_s390x_linux)
164 #  define GET_STARTREGS(srP)                              \
165       { ULong ia, sp, fp, lr;                             \
166         __asm__ __volatile__(                             \
167            "bras %0,0f;"                                  \
168            "0: lgr %1,15;"                                \
169            "lgr %2,11;"                                   \
170            "lgr %3,14;"                                   \
171            : "=r" (ia), "=r" (sp),"=r" (fp),"=r" (lr)     \
172            /* no read & clobber */                        \
173         );                                                \
174         (srP)->r_pc = ia;                                 \
175         (srP)->r_sp = sp;                                 \
176         (srP)->misc.S390X.r_fp = fp;                      \
177         (srP)->misc.S390X.r_lr = lr;                      \
178       }
179 #elif defined(VGP_mips32_linux)
180 #  define GET_STARTREGS(srP)                              \
181       { UInt pc, sp, fp, ra, gp;                          \
182       asm("move $8, $31;"             /* t0 = ra */       \
183           "bal 0f;"                   /* ra = pc */       \
184           "0:\n"                                          \
185           "move %0, $31;"                                 \
186           "move $31, $8;"             /* restore lr */    \
187           "move %1, $29;"                                 \
188           "move %2, $30;"                                 \
189           "move %3, $31;"                                 \
190           "move %4, $28;"                                 \
191           : "=r" (pc),                                    \
192             "=r" (sp),                                    \
193             "=r" (fp),                                    \
194             "=r" (ra),                                    \
195             "=r" (gp)                                     \
196           : /* reads none */                              \
197           : "$8" /* trashed */ );                         \
198         (srP)->r_pc = (ULong)pc - 8;                      \
199         (srP)->r_sp = (ULong)sp;                          \
200         (srP)->misc.MIPS32.r30 = (ULong)fp;               \
201         (srP)->misc.MIPS32.r31 = (ULong)ra;               \
202         (srP)->misc.MIPS32.r28 = (ULong)gp;               \
203       }
204 #elif defined(VGP_mips64_linux)
205 #  define GET_STARTREGS(srP)                              \
206       { ULong pc, sp, fp, ra, gp;                         \
207       asm("move $8, $31;"             /* t0 = ra */       \
208           "bal 0f;"                   /* ra = pc */       \
209           "0:\n"                                          \
210           "move %0, $31;"                                 \
211           "move $31, $8;"             /* restore lr */    \
212           "move %1, $29;"                                 \
213           "move %2, $30;"                                 \
214           "move %3, $31;"                                 \
215           "move %4, $28;"                                 \
216           : "=r" (pc),                                    \
217             "=r" (sp),                                    \
218             "=r" (fp),                                    \
219             "=r" (ra),                                    \
220             "=r" (gp)                                     \
221           : /* reads none */                              \
222           : "$8" /* trashed */ );                         \
223         (srP)->r_pc = (ULong)pc - 8;                      \
224         (srP)->r_sp = (ULong)sp;                          \
225         (srP)->misc.MIPS64.r30 = (ULong)fp;               \
226         (srP)->misc.MIPS64.r31 = (ULong)ra;               \
227         (srP)->misc.MIPS64.r28 = (ULong)gp;               \
228       }
229 #else
230 #  error Unknown platform
231 #endif
232 
233 #define BACKTRACE_DEPTH    100         // nice and deep!
234 
235 __attribute__ ((__noreturn__))
exit_wrk(Int status,Bool gdbserver_call_allowed)236 static void exit_wrk( Int status, Bool gdbserver_call_allowed)
237 {
238    static Bool exit_called = False;
239    // avoid recursive exit during gdbserver call.
240 
241    if (gdbserver_call_allowed && !exit_called) {
242       const ThreadId atid = 1; // Arbitrary tid used to call/terminate gdbsrv.
243       exit_called = True;
244       if (status != 0
245           && VgdbStopAtiS(VgdbStopAt_ValgrindAbExit, VG_(clo_vgdb_stop_at))) {
246          if (VG_(gdbserver_init_done)()) {
247             VG_(umsg)("(action at valgrind abnormal exit) vgdb me ... \n");
248             VG_(gdbserver) (atid);
249          } else {
250             VG_(umsg)("(action at valgrind abnormal exit)\n"
251                       "valgrind exit is too early => vgdb not yet usable\n");
252          }
253       }
254       if (VG_(gdbserver_init_done)()) {
255          // Always terminate the gdbserver when Valgrind exits, so as
256          // to e.g. cleanup the FIFOs.
257          VG_(gdbserver_exit) (atid,
258                               status == 0 ? VgSrc_ExitProcess : VgSrc_FatalSig);
259       }
260    }
261    exit_called = True;
262 
263    VG_(exit_now) (status);
264 }
265 
266 /* Call the appropriate system call and nothing else. This function should
267    be called in places where the dependencies of VG_(exit) need to be
268    avoided. */
269 __attribute__ ((__noreturn__))
VG_(exit_now)270 void VG_(exit_now)( Int status )
271 {
272 #if defined(VGO_linux)
273    (void)VG_(do_syscall1)(__NR_exit_group, status );
274 #elif defined(VGO_darwin) || defined(VGO_solaris)
275    (void)VG_(do_syscall1)(__NR_exit, status );
276 #else
277 #  error Unknown OS
278 #endif
279    /*NOTREACHED*/
280    // We really shouldn't reach here.  Just in case we do, use some very crude
281    // methods to force abort
282    __builtin_trap();
283    *(volatile Int*)0 = 'x';
284 }
285 
286 /* Pull down the entire world */
VG_(exit)287 void VG_(exit)( Int status )
288 {
289    exit_wrk (status, True);
290 }
291 
292 /* Pull down the entire world */
VG_(client_exit)293 void VG_(client_exit)( Int status )
294 {
295    exit_wrk (status, False);
296 }
297 
print_thread_state(Bool stack_usage,const HChar * prefix,ThreadId i)298 static void print_thread_state (Bool stack_usage,
299                                 const HChar* prefix, ThreadId i)
300 {
301    VgStack *stack
302       = (VgStack*)VG_(threads)[i].os_state.valgrind_stack_base;
303 
304    VG_(printf)("\n%sThread %d: status = %s (lwpid %d)\n", prefix, i,
305                VG_(name_of_ThreadStatus)(VG_(threads)[i].status),
306                VG_(threads)[i].os_state.lwpid);
307    if (VG_(threads)[i].status != VgTs_Empty)
308       VG_(get_and_pp_StackTrace)( i, BACKTRACE_DEPTH );
309    if (stack_usage && VG_(threads)[i].client_stack_highest_byte != 0 ) {
310       Addr start, end;
311 
312       start = end = 0;
313       VG_(stack_limits)(VG_(get_SP)(i), &start, &end);
314       if (start != end)
315          VG_(printf)("%sclient stack range: [%p %p] client SP: %p\n",
316                      prefix,
317                      (void*)start, (void*)end, (void*)VG_(get_SP)(i));
318       else
319          VG_(printf)("%sclient stack range: ??????? client SP: %p\n",
320                      prefix,
321                      (void*)VG_(get_SP)(i));
322    }
323    if (stack_usage && stack != 0)
324       VG_(printf)
325          ("%svalgrind stack top usage: %lu of %lu\n",
326           prefix,
327           VG_(clo_valgrind_stacksize)
328           - VG_(am_get_VgStack_unused_szB) (stack,
329                                             VG_(clo_valgrind_stacksize)),
330           (SizeT) VG_(clo_valgrind_stacksize));
331 }
332 
333 // Print the scheduler status.
show_sched_status_wrk(Bool host_stacktrace,Bool stack_usage,Bool exited_threads,const UnwindStartRegs * startRegsIN)334 static void show_sched_status_wrk ( Bool host_stacktrace,
335                                     Bool stack_usage,
336                                     Bool exited_threads,
337                                     const UnwindStartRegs* startRegsIN)
338 {
339    Int i;
340    if (host_stacktrace) {
341       const Bool save_clo_xml = VG_(clo_xml);
342       Addr stacktop;
343       Addr ips[BACKTRACE_DEPTH];
344       Int  n_ips;
345       ThreadState *tst
346          = VG_(get_ThreadState)( VG_(lwpid_to_vgtid)( VG_(gettid)() ) );
347 
348       // If necessary, fake up an ExeContext which is of our actual real CPU
349       // state.  Could cause problems if we got the panic/exception within the
350       // execontext/stack dump/symtab code.  But it's better than nothing.
351       UnwindStartRegs startRegs;
352       VG_(memset)(&startRegs, 0, sizeof(startRegs));
353 
354       if (startRegsIN == NULL) {
355          GET_STARTREGS(&startRegs);
356       } else {
357          startRegs = *startRegsIN;
358       }
359 
360       stacktop = tst->os_state.valgrind_stack_init_SP;
361 
362       n_ips =
363          VG_(get_StackTrace_wrk)(
364             0/*tid is unknown*/,
365             ips, BACKTRACE_DEPTH,
366             NULL/*array to dump SP values in*/,
367             NULL/*array to dump FP values in*/,
368             &startRegs, stacktop
369          );
370       VG_(printf)("\nhost stacktrace:\n");
371       VG_(clo_xml) = False;
372       VG_(pp_StackTrace) (ips, n_ips);
373       VG_(clo_xml) = save_clo_xml;
374    }
375 
376    VG_(printf)("\nsched status:\n");
377    if (VG_(threads) == NULL) {
378       VG_(printf)("  scheduler not yet initialised\n");
379    } else {
380       VG_(printf)("  running_tid=%u\n", VG_(get_running_tid)());
381       for (i = 1; i < VG_N_THREADS; i++) {
382          VgStack *stack
383             = (VgStack*)VG_(threads)[i].os_state.valgrind_stack_base;
384          /* If a thread slot was never used (yet), valgrind_stack_base is 0.
385             If a thread slot is used by a thread or was used by a thread which
386             has exited, then valgrind_stack_base points to the stack base. */
387          if (VG_(threads)[i].status == VgTs_Empty
388              && (!exited_threads || stack == 0)) continue;
389          print_thread_state(stack_usage, "", i);
390          if (VG_(inner_threads) != NULL) {
391             /* An inner V has informed us (the outer) of its thread array.
392                Report the inner guest stack trace. */
393             UInt inner_tid;
394 
395             for (inner_tid = 1; inner_tid < VG_N_THREADS; inner_tid++) {
396                if (VG_(threads)[i].os_state.lwpid
397                    == VG_(inner_threads)[inner_tid].os_state.lwpid) {
398                   ThreadState* save_outer_vg_threads = VG_(threads);
399 
400                   VG_(threads) = VG_(inner_threads);
401                   print_thread_state(stack_usage, "INNER ", inner_tid);
402                   VG_(threads) = save_outer_vg_threads;
403                   break;
404                }
405             }
406          }
407       }
408    }
409    VG_(printf)("\n");
410 }
411 
VG_(show_sched_status)412 void VG_(show_sched_status) ( Bool host_stacktrace,
413                               Bool stack_usage,
414                               Bool exited_threads)
415 {
416    show_sched_status_wrk (host_stacktrace,
417                           stack_usage,
418                           exited_threads,
419                           NULL);
420 }
421 
422 __attribute__ ((noreturn))
report_and_quit(const HChar * report,const UnwindStartRegs * startRegsIN)423 static void report_and_quit ( const HChar* report,
424                               const UnwindStartRegs* startRegsIN )
425 {
426    show_sched_status_wrk (True,  // host_stacktrace
427                           False, // stack_usage
428                           False, // exited_threads
429                           startRegsIN);
430    VG_(printf)(
431       "\n"
432       "Note: see also the FAQ in the source distribution.\n"
433       "It contains workarounds to several common problems.\n"
434       "In particular, if Valgrind aborted or crashed after\n"
435       "identifying problems in your program, there's a good chance\n"
436       "that fixing those problems will prevent Valgrind aborting or\n"
437       "crashing, especially if it happened in m_mallocfree.c.\n"
438       "\n"
439       "If that doesn't help, please report this bug to: %s\n\n"
440       "In the bug report, send all the above text, the valgrind\n"
441       "version, and what OS and version you are using.  Thanks.\n\n",
442       report);
443    VG_(exit)(1);
444 }
445 
VG_(assert_fail)446 void VG_(assert_fail) ( Bool isCore, const HChar* expr, const HChar* file,
447                         Int line, const HChar* fn, const HChar* format, ... )
448 {
449    va_list vargs, vargs_copy;
450    const HChar* component;
451    const HChar* bugs_to;
452    UInt written;
453 
454    static Bool entered = False;
455    if (entered)
456       VG_(exit)(2);
457    entered = True;
458 
459    if (isCore) {
460       component = "valgrind";
461       bugs_to   = VG_BUGS_TO;
462    } else {
463       component = VG_(details).name;
464       bugs_to   = VG_(details).bug_reports_to;
465    }
466 
467    if (VG_(clo_xml))
468       VG_(printf_xml)("</valgrindoutput>\n");
469 
470    // Treat vg_assert2(0, "foo") specially, as a panicky abort
471    if (VG_STREQ(expr, "0")) {
472       VG_(printf)("\n%s: %s:%d (%s): the 'impossible' happened.\n",
473                   component, file, line, fn );
474    } else {
475       VG_(printf)("\n%s: %s:%d (%s): Assertion '%s' failed.\n",
476                   component, file, line, fn, expr );
477    }
478 
479    /* Check whether anything will be written */
480    HChar buf[5];
481    va_start(vargs, format);
482    va_copy(vargs_copy, vargs);
483    written = VG_(vsnprintf) ( buf, sizeof(buf), format, vargs );
484    va_end(vargs);
485 
486    if (written > 0) {
487       VG_(printf)("%s: ", component);
488       VG_(vprintf)(format, vargs_copy);
489       VG_(printf)("\n");
490    }
491 
492    report_and_quit(bugs_to, NULL);
493 }
494 
495 __attribute__ ((noreturn))
panic(const HChar * name,const HChar * report,const HChar * str,const UnwindStartRegs * startRegs)496 static void panic ( const HChar* name, const HChar* report, const HChar* str,
497                     const UnwindStartRegs* startRegs )
498 {
499    if (VG_(clo_xml))
500       VG_(printf_xml)("</valgrindoutput>\n");
501    VG_(printf)("\n%s: the 'impossible' happened:\n   %s\n", name, str);
502    report_and_quit(report, startRegs);
503 }
504 
VG_(core_panic_at)505 void VG_(core_panic_at) ( const HChar* str, const UnwindStartRegs* startRegs )
506 {
507    panic("valgrind", VG_BUGS_TO, str, startRegs);
508 }
509 
VG_(core_panic)510 void VG_(core_panic) ( const HChar* str )
511 {
512    VG_(core_panic_at)(str, NULL);
513 }
514 
VG_(tool_panic)515 void VG_(tool_panic) ( const HChar* str )
516 {
517    panic(VG_(details).name, VG_(details).bug_reports_to, str, NULL);
518 }
519 
520 /* Print some helpful-ish text about unimplemented things, and give up. */
VG_(unimplemented)521 void VG_(unimplemented) ( const HChar* format, ... )
522 {
523    va_list vargs;
524    HChar msg[256];
525 
526    va_start(vargs, format);
527    VG_(vsnprintf)(msg, sizeof(msg), format, vargs);
528    va_end(vargs);
529 
530    if (VG_(clo_xml))
531       VG_(printf_xml)("</valgrindoutput>\n");
532    VG_(umsg)("\n");
533    VG_(umsg)("Valgrind detected that your program requires\n");
534    VG_(umsg)("the following unimplemented functionality:\n");
535    VG_(umsg)("   %s\n", msg);
536    VG_(umsg)("This may be because the functionality is hard to implement,\n");
537    VG_(umsg)("or because no reasonable program would behave this way,\n");
538    VG_(umsg)("or because nobody has yet needed it.  "
539              "In any case, let us know at\n");
540    VG_(umsg)("%s and/or try to work around the problem, if you can.\n",
541              VG_BUGS_TO);
542    VG_(umsg)("\n");
543    VG_(umsg)("Valgrind has to exit now.  Sorry.  Bye!\n");
544    VG_(umsg)("\n");
545    VG_(show_sched_status)(False,  // host_stacktrace
546                           False,  // stack_usage
547                           False); // exited_threads
548    VG_(exit)(1);
549 }
550 
551 /*--------------------------------------------------------------------*/
552 /*--- end                                                          ---*/
553 /*--------------------------------------------------------------------*/
554