2 This file is part of drd, a thread error detector.
4 Copyright (C) 2006-2012 Bart Van Assche <bvanassche@acm.org>.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
21 The GNU General Public License is contained in the file COPYING.
25 #include "drd_clientobj.h" /* struct mutex_info */
26 #include "drd_error.h"
27 #include "drd_malloc_wrappers.h"
28 #include "drd_mutex.h"
29 #include "drd_suppression.h" /* drd_start_suppression() */
30 #include "pub_drd_bitmap.h" /* LHS_W, ... */
31 #include "pub_tool_vki.h"
32 #include "pub_tool_basics.h"
33 #include "pub_tool_libcassert.h" /* tl_assert() */
34 #include "pub_tool_libcbase.h" /* strlen() */
35 #include "pub_tool_libcfile.h" /* VG_(get_startup_wd)() */
36 #include "pub_tool_libcprint.h" /* VG_(printf)() */
37 #include "pub_tool_machine.h"
38 #include "pub_tool_mallocfree.h" /* VG_(malloc), VG_(free) */
39 #include "pub_tool_options.h" /* VG_(clo_xml) */
40 #include "pub_tool_threadstate.h" /* VG_(get_pthread_id)() */
41 #include "pub_tool_tooliface.h" /* VG_(needs_tool_errors)() */
44 /* Local function declarations. */
46 static const HChar* drd_get_error_name(Error* e);
49 /* Local variables. */
51 static Bool s_show_conflicting_segments = True;
54 void DRD_(set_show_conflicting_segments)(const Bool scs)
56 s_show_conflicting_segments = scs;
59 void DRD_(trace_msg)(const char* format, ...)
62 va_start(vargs, format);
64 VG_(printf_xml)(" <trace><text>");
65 VG_(vprintf_xml)(format, vargs);
66 VG_(printf_xml)("</text></trace>\n");
68 VG_(vmessage)(Vg_UserMsg, format, vargs);
69 VG_(message)(Vg_UserMsg, "\n");
74 void DRD_(trace_msg_w_bt)(const char* format, ...)
77 va_start(vargs, format);
79 VG_(printf_xml)(" <trace><text>");
80 VG_(vprintf_xml)(format, vargs);
81 VG_(printf_xml)("</text>\n");
83 VG_(vmessage)(Vg_UserMsg, format, vargs);
84 VG_(message)(Vg_UserMsg, "\n");
86 VG_(get_and_pp_StackTrace)(VG_(get_running_tid)(), VG_(clo_backtrace_size));
89 VG_(printf_xml)(" </trace>\n");
93 * Emit error message detail in the format requested by the user.
95 static void print_err_detail(const char* format, ...) PRINTF_CHECK(1, 2);
96 static void print_err_detail(const char* format, ...)
99 va_start(vargs, format);
101 VG_(vprintf_xml)(format, vargs);
103 VG_(vmessage)(Vg_UserMsg, format, vargs);
108 * Describe the client address a as good as possible, putting the result in ai.
111 void describe_malloced_addr(Addr const a, AddrInfo* const ai)
113 Addr heap_block_start;
115 if (DRD_(heap_addrinfo)(a, &heap_block_start, &ai->size, &ai->lastchange))
117 ai->akind = eMallocd;
118 ai->rwoffset = a - heap_block_start;
122 ai->akind = eUnknown;
127 * Report where a client synchronization object has been observed for the first
128 * time. The printed call stack will either refer to a pthread_*_init() or a
129 * pthread_*lock() call.
131 static void first_observed(const Addr obj)
135 cl = DRD_(clientobj_get_any)(obj);
137 tl_assert(cl->any.first_observed_at);
139 print_err_detail(" <first_observed_at>\n"
140 " <what>%pS</what>\n"
141 " <address>0x%lx</address>\n",
142 DRD_(clientobj_type_name)(cl->any.type), obj);
143 VG_(pp_ExeContext)(cl->any.first_observed_at);
144 print_err_detail(" </first_observed_at>\n");
146 print_err_detail("%s 0x%lx was first observed at:\n",
147 DRD_(clientobj_type_name)(cl->any.type), obj);
148 VG_(pp_ExeContext)(cl->any.first_observed_at);
154 void drd_report_data_race(Error* const err, const DataRaceErrInfo* const dri)
156 const Bool xml = VG_(clo_xml);
157 const char* const what_prefix = xml ? " <what>" : "";
158 const char* const what_suffix = xml ? "</what>" : "";
159 const char* const auxwhat_prefix = xml ? " <auxwhat>" : "";
160 const char* const auxwhat_suffix = xml ? "</auxwhat>" : "";
161 const char* const indent = xml ? " " : "";
164 XArray* /* of HChar */ descr1
165 = VG_(newXA)( VG_(malloc), "drd.error.drdr2.1",
166 VG_(free), sizeof(HChar) );
167 XArray* /* of HChar */ descr2
168 = VG_(newXA)( VG_(malloc), "drd.error.drdr2.2",
169 VG_(free), sizeof(HChar) );
172 tl_assert(dri->addr);
173 tl_assert(dri->size > 0);
177 (void) VG_(get_data_description)(descr1, descr2, dri->addr);
178 /* If there's nothing in descr1/2, free them. Why is it safe to to
179 VG_(indexXA) at zero here? Because VG_(get_data_description)
180 guarantees to zero terminate descr1/2 regardless of the outcome
181 of the call. So there's always at least one element in each XA
184 if (0 == VG_(strlen)( VG_(indexXA)( descr1, 0 ))) {
185 VG_(deleteXA)( descr1 );
188 if (0 == VG_(strlen)( VG_(indexXA)( descr2, 0 ))) {
189 VG_(deleteXA)( descr2 );
192 /* Assume (assert) that VG_(get_data_description) fills in descr1
193 before it fills in descr2 */
195 tl_assert(descr2 == NULL);
196 /* So anyway. Do we have something useful? */
200 describe_malloced_addr(dri->addr, &ai);
203 print_err_detail("%sConflicting %s by thread %d at 0x%08lx size %ld%s\n",
204 what_prefix, dri->access_type == eStore ? "store" : "load",
205 dri->tid, dri->addr, dri->size, what_suffix);
207 VG_(pp_ExeContext)(VG_(get_error_where)(err));
208 if (descr1 != NULL) {
209 print_err_detail("%s%s\n", indent, (HChar*)VG_(indexXA)(descr1, 0));
211 print_err_detail("%s%s\n", indent, (HChar*)VG_(indexXA)(descr2, 0));
212 } else if (ai.akind == eMallocd && ai.lastchange) {
213 print_err_detail("%sAddress 0x%lx is at offset %ld from 0x%lx.%s%s",
214 auxwhat_prefix, dri->addr, ai.rwoffset,
215 dri->addr - ai.rwoffset, auxwhat_suffix,
218 print_err_detail(" <allocation_context>\n");
220 print_err_detail(" Allocation context:\n");
221 VG_(pp_ExeContext)(ai.lastchange);
223 print_err_detail(" </allocation_context>\n");
226 VgSectKind sect_kind;
228 sect_kind = VG_(DebugInfo_sect_kind)(sect_name, sizeof(sect_name),
230 if (sect_kind != Vg_SectUnknown) {
231 print_err_detail("%sAllocation context: %ps section of %ps%s\n",
232 auxwhat_prefix, VG_(pp_SectKind)(sect_kind),
233 sect_name, auxwhat_suffix);
235 print_err_detail("%sAllocation context: unknown.%s\n",
236 auxwhat_prefix, auxwhat_suffix);
239 if (s_show_conflicting_segments)
241 DRD_(thread_report_conflicting_segments)(dri->tid,
242 dri->addr, dri->size,
247 VG_(deleteXA)(descr2);
249 VG_(deleteXA)(descr1);
253 * Compare two error contexts. The core function VG_(maybe_record_error)()
254 * calls this function to compare error contexts such that errors that occur
255 * repeatedly are only printed once. This function is only called by the core
256 * if the error kind of e1 and e2 matches and if the ExeContext's of e1 and
259 static Bool drd_compare_error_contexts(VgRes res, Error* e1, Error* e2)
261 tl_assert(VG_(get_error_kind)(e1) == VG_(get_error_kind)(e2));
263 switch (VG_(get_error_kind)(e1))
267 const DataRaceErrInfo* const dri1 = VG_(get_error_extra)(e1);
268 const DataRaceErrInfo* const dri2 = VG_(get_error_extra)(e2);
269 return dri1->access_type == dri2->access_type
270 && dri1->size == dri2->size;
274 const MutexErrInfo* const mei1 = VG_(get_error_extra)(e1);
275 const MutexErrInfo* const mei2 = VG_(get_error_extra)(e2);
276 return mei1->mutex == mei2->mutex;
284 * Called by the core just before an error message will be printed. Used by
285 * DRD to print the thread number as a preamble.
287 static void drd_tool_error_before_pp(Error* const e)
289 static DrdThreadId s_last_tid_printed = 1;
290 DrdThreadId* err_extra;
292 err_extra = VG_(get_error_extra)(e);
294 if (err_extra && *err_extra != s_last_tid_printed && !VG_(clo_xml)) {
295 VG_(umsg)("%s:\n", DRD_(thread_get_name)(*err_extra));
296 s_last_tid_printed = *err_extra;
300 /** Report an error to the user. */
301 static void drd_tool_error_pp(Error* const e)
303 const Bool xml = VG_(clo_xml);
304 const char* const what_prefix = xml ? " <what>" : "";
305 const char* const what_suffix = xml ? "</what>" : "";
308 VG_(printf_xml)( " <kind>%pS</kind>\n", drd_get_error_name(e));
310 switch (VG_(get_error_kind)(e))
313 drd_report_data_race(e, VG_(get_error_extra)(e));
317 MutexErrInfo* p = (MutexErrInfo*)(VG_(get_error_extra)(e));
319 if (p->recursion_count >= 0) {
320 print_err_detail("%s%s: mutex 0x%lx, recursion count %d, owner %d."
321 "%s\n", what_prefix, VG_(get_error_string)(e),
322 p->mutex, p->recursion_count, p->owner, what_suffix);
324 print_err_detail("%sThe object at address 0x%lx is not a mutex.%s\n",
325 what_prefix, p->mutex, what_suffix);
327 VG_(pp_ExeContext)(VG_(get_error_where)(e));
328 first_observed(p->mutex);
332 CondErrInfo* cdei =(CondErrInfo*)(VG_(get_error_extra)(e));
333 print_err_detail("%s%s: cond 0x%lx%s\n", what_prefix,
334 VG_(get_error_string)(e), cdei->cond, what_suffix);
335 VG_(pp_ExeContext)(VG_(get_error_where)(e));
336 first_observed(cdei->cond);
340 CondDestrErrInfo* cdi = (CondDestrErrInfo*)(VG_(get_error_extra)(e));
341 print_err_detail("%s%s: cond 0x%lx, mutex 0x%lx locked by thread %d%s\n",
342 what_prefix, VG_(get_error_string)(e), cdi->cond,
343 cdi->mutex, cdi->owner, what_suffix);
344 VG_(pp_ExeContext)(VG_(get_error_where)(e));
345 first_observed(cdi->mutex);
349 CondRaceErrInfo* cei = (CondRaceErrInfo*)(VG_(get_error_extra)(e));
350 print_err_detail("%sProbably a race condition: condition variable 0x%lx"
351 " has been signaled but the associated mutex 0x%lx is"
352 " not locked by the signalling thread.%s\n",
353 what_prefix, cei->cond, cei->mutex, what_suffix);
354 VG_(pp_ExeContext)(VG_(get_error_where)(e));
355 first_observed(cei->cond);
356 first_observed(cei->mutex);
360 CondWaitErrInfo* cwei = (CondWaitErrInfo*)(VG_(get_error_extra)(e));
361 print_err_detail("%s%s: condition variable 0x%lx, mutexes 0x%lx and"
362 " 0x%lx%s\n", what_prefix, VG_(get_error_string)(e),
363 cwei->cond, cwei->mutex1, cwei->mutex2, what_suffix);
364 VG_(pp_ExeContext)(VG_(get_error_where)(e));
365 first_observed(cwei->cond);
366 first_observed(cwei->mutex1);
367 first_observed(cwei->mutex2);
371 SemaphoreErrInfo* sei = (SemaphoreErrInfo*)(VG_(get_error_extra)(e));
373 print_err_detail("%s%s: semaphore 0x%lx%s\n", what_prefix,
374 VG_(get_error_string)(e), sei->semaphore, what_suffix);
375 VG_(pp_ExeContext)(VG_(get_error_where)(e));
376 first_observed(sei->semaphore);
380 BarrierErrInfo* bei = (BarrierErrInfo*)(VG_(get_error_extra)(e));
382 print_err_detail("%s%s: barrier 0x%lx%s\n", what_prefix,
383 VG_(get_error_string)(e), bei->barrier, what_suffix);
384 VG_(pp_ExeContext)(VG_(get_error_where)(e));
385 if (bei->other_context) {
387 print_err_detail(" <confl_wait_call>\n");
388 print_err_detail("%sConflicting wait call by thread %d:%s\n",
389 what_prefix, bei->other_tid, what_suffix);
390 VG_(pp_ExeContext)(bei->other_context);
392 print_err_detail(" </confl_wait_call>\n");
394 first_observed(bei->barrier);
398 RwlockErrInfo* p = (RwlockErrInfo*)(VG_(get_error_extra)(e));
400 print_err_detail("%s%s: rwlock 0x%lx.%s\n", what_prefix,
401 VG_(get_error_string)(e), p->rwlock, what_suffix);
402 VG_(pp_ExeContext)(VG_(get_error_where)(e));
403 first_observed(p->rwlock);
407 HoldtimeErrInfo* p =(HoldtimeErrInfo*)(VG_(get_error_extra)(e));
409 tl_assert(p->acquired_at);
411 print_err_detail(" <acquired_at>\n");
413 print_err_detail("Acquired at:\n");
414 VG_(pp_ExeContext)(p->acquired_at);
416 print_err_detail(" </acquired_at>\n");
417 print_err_detail("%sLock on %s 0x%lx was held during %d ms"
418 " (threshold: %d ms).%s\n", what_prefix,
419 VG_(get_error_string)(e), p->synchronization_object,
420 p->hold_time_ms, p->threshold_ms, what_suffix);
421 VG_(pp_ExeContext)(VG_(get_error_where)(e));
422 first_observed(p->synchronization_object);
426 GenericErrInfo* gei = (GenericErrInfo*)(VG_(get_error_extra)(e));
427 print_err_detail("%s%s%s\n", what_prefix, VG_(get_error_string)(e),
429 VG_(pp_ExeContext)(VG_(get_error_where)(e));
431 first_observed(gei->addr);
434 case InvalidThreadId: {
435 InvalidThreadIdInfo* iti =(InvalidThreadIdInfo*)(VG_(get_error_extra)(e));
436 print_err_detail("%s%s 0x%llx%s\n", what_prefix, VG_(get_error_string)(e),
437 iti->ptid, what_suffix);
438 VG_(pp_ExeContext)(VG_(get_error_where)(e));
442 UnimpClReqInfo* uicr =(UnimpClReqInfo*)(VG_(get_error_extra)(e));
443 print_err_detail("%sThe annotation macro %s has not yet been implemented"
444 " in %ps%s\n", what_prefix, uicr->descr,
445 "<valgrind/helgrind.h>", what_suffix);
446 VG_(pp_ExeContext)(VG_(get_error_where)(e));
449 case UnimpDrdClReq: {
450 UnimpClReqInfo* uicr =(UnimpClReqInfo*)(VG_(get_error_extra)(e));
451 print_err_detail("%sThe annotation macro %s has not yet been implemented"
452 " in %ps%s\n", what_prefix, uicr->descr,
453 "<valgrind/drd.h>", what_suffix);
454 VG_(pp_ExeContext)(VG_(get_error_where)(e));
458 print_err_detail("%s%s%s\n", what_prefix, VG_(get_error_string)(e),
460 VG_(pp_ExeContext)(VG_(get_error_where)(e));
465 static UInt drd_tool_error_update_extra(Error* e)
467 switch (VG_(get_error_kind)(e))
470 return sizeof(DataRaceErrInfo);
472 return sizeof(MutexErrInfo);
474 return sizeof(CondErrInfo);
476 return sizeof(CondDestrErrInfo);
478 return sizeof(CondRaceErrInfo);
480 return sizeof(CondWaitErrInfo);
482 return sizeof(SemaphoreErrInfo);
484 return sizeof(BarrierErrInfo);
486 return sizeof(RwlockErrInfo);
488 return sizeof(HoldtimeErrInfo);
490 return sizeof(GenericErrInfo);
491 case InvalidThreadId:
492 return sizeof(InvalidThreadIdInfo);
494 return sizeof(UnimpClReqInfo);
496 return sizeof(UnimpClReqInfo);
504 * Parse suppression name.
506 * The suppression types recognized by DRD are the same types as the error
507 * types supported by DRD. So try to match the suppression name against the
508 * names of DRD error types.
510 static Bool drd_is_recognized_suppression(Char* const name, Supp* const supp)
512 DrdErrorKind skind = 0;
514 if (VG_(strcmp)(name, STR_DataRaceErr) == 0)
516 else if (VG_(strcmp)(name, STR_MutexErr) == 0)
518 else if (VG_(strcmp)(name, STR_CondErr) == 0)
520 else if (VG_(strcmp)(name, STR_CondDestrErr) == 0)
521 skind = CondDestrErr;
522 else if (VG_(strcmp)(name, STR_CondRaceErr) == 0)
524 else if (VG_(strcmp)(name, STR_CondWaitErr) == 0)
526 else if (VG_(strcmp)(name, STR_SemaphoreErr) == 0)
527 skind = SemaphoreErr;
528 else if (VG_(strcmp)(name, STR_BarrierErr) == 0)
530 else if (VG_(strcmp)(name, STR_RwlockErr) == 0)
532 else if (VG_(strcmp)(name, STR_HoldtimeErr) == 0)
534 else if (VG_(strcmp)(name, STR_GenericErr) == 0)
536 else if (VG_(strcmp)(name, STR_InvalidThreadId) == 0)
537 skind = InvalidThreadId;
538 else if (VG_(strcmp)(name, STR_UnimpHgClReq) == 0)
539 skind = UnimpHgClReq;
540 else if (VG_(strcmp)(name, STR_UnimpDrdClReq) == 0)
541 skind = UnimpDrdClReq;
545 VG_(set_supp_kind)(supp, skind);
550 * Read additional suppression information from the suppression file.
552 * None of the suppression patterns recognized by DRD has 'extra' lines
553 * of information in the suppression file, so just return True to indicate
554 * that reading the 'extra' lines succeeded.
557 Bool drd_read_extra_suppression_info(Int fd, Char** bufpp,
558 SizeT* nBufp, Supp* supp)
564 * Determine whether or not the types of the given error message and the
565 * given suppression match.
567 static Bool drd_error_matches_suppression(Error* const e, Supp* const supp)
569 return VG_(get_supp_kind)(supp) == VG_(get_error_kind)(e);
572 static const HChar* drd_get_error_name(Error* e)
574 switch (VG_(get_error_kind)(e))
576 case DataRaceErr: return VGAPPEND(STR_, DataRaceErr);
577 case MutexErr: return VGAPPEND(STR_, MutexErr);
578 case CondErr: return VGAPPEND(STR_, CondErr);
579 case CondDestrErr: return VGAPPEND(STR_, CondDestrErr);
580 case CondRaceErr: return VGAPPEND(STR_, CondRaceErr);
581 case CondWaitErr: return VGAPPEND(STR_, CondWaitErr);
582 case SemaphoreErr: return VGAPPEND(STR_, SemaphoreErr);
583 case BarrierErr: return VGAPPEND(STR_, BarrierErr);
584 case RwlockErr: return VGAPPEND(STR_, RwlockErr);
585 case HoldtimeErr: return VGAPPEND(STR_, HoldtimeErr);
586 case GenericErr: return VGAPPEND(STR_, GenericErr);
587 case InvalidThreadId: return VGAPPEND(STR_, InvalidThreadId);
588 case UnimpHgClReq: return VGAPPEND(STR_, UnimpHgClReq);
589 case UnimpDrdClReq: return VGAPPEND(STR_, UnimpDrdClReq);
597 * Return extra suppression information.
599 * Invoked while printing a suppression pattern because the user
600 * specified --gen-suppressions=yes or all on the command line. DRD does not
601 * define any 'extra' suppression information.
604 Bool drd_get_extra_suppression_info(Error* e,
605 /*OUT*/HChar* buf, Int nBuf)
610 /** Tell the Valgrind core about DRD's error handlers. */
611 void DRD_(register_error_handlers)(void)
613 VG_(needs_tool_errors)(drd_compare_error_contexts,
614 drd_tool_error_before_pp,
617 drd_tool_error_update_extra,
618 drd_is_recognized_suppression,
619 drd_read_extra_suppression_info,
620 drd_error_matches_suppression,
622 drd_get_extra_suppression_info);