1 /* -*- mode: C; c-basic-offset: 3; -*- */
2 /*
3 This file is part of drd, a thread error detector.
4
5 Copyright (C) 2006-2010 Bart Van Assche <bvanassche@acm.org>.
6
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
20 02111-1307, USA.
21
22 The GNU General Public License is contained in the file COPYING.
23 */
24
25
26 #include "drd_clientobj.h" /* struct mutex_info */
27 #include "drd_error.h"
28 #include "drd_malloc_wrappers.h"
29 #include "drd_mutex.h"
30 #include "drd_suppression.h" /* drd_start_suppression() */
31 #include "pub_drd_bitmap.h" /* LHS_W, ... */
32 #include "pub_tool_vki.h"
33 #include "pub_tool_basics.h"
34 #include "pub_tool_libcassert.h" /* tl_assert() */
35 #include "pub_tool_libcbase.h" /* strlen() */
36 #include "pub_tool_libcfile.h" /* VG_(get_startup_wd)() */
37 #include "pub_tool_libcprint.h" /* VG_(printf)() */
38 #include "pub_tool_machine.h"
39 #include "pub_tool_mallocfree.h" /* VG_(malloc), VG_(free) */
40 #include "pub_tool_threadstate.h" /* VG_(get_pthread_id)() */
41 #include "pub_tool_tooliface.h" /* VG_(needs_tool_errors)() */
42
43
44 /* Local variables. */
45
46 static Bool s_show_conflicting_segments = True;
47
48
DRD_(set_show_conflicting_segments)49 void DRD_(set_show_conflicting_segments)(const Bool scs)
50 {
51 s_show_conflicting_segments = scs;
52 }
53
54 /**
55 * Describe the client address a as good as possible, putting the result in ai.
56 */
57 static
describe_malloced_addr(Addr const a,AddrInfo * const ai)58 void describe_malloced_addr(Addr const a, AddrInfo* const ai)
59 {
60 Addr heap_block_start;
61
62 if (DRD_(heap_addrinfo)(a, &heap_block_start, &ai->size, &ai->lastchange))
63 {
64 ai->akind = eMallocd;
65 ai->rwoffset = a - heap_block_start;
66 }
67 else
68 {
69 ai->akind = eUnknown;
70 }
71 }
72
73 /**
74 * Report where a client synchronization object has been observed for the first
75 * time. The printed call stack will either refer to a pthread_*_init() or a
76 * pthread_*lock() call.
77 */
first_observed(const Addr obj)78 static void first_observed(const Addr obj)
79 {
80 DrdClientobj* cl;
81
82 cl = DRD_(clientobj_get_any)(obj);
83 if (cl)
84 {
85 tl_assert(cl->any.first_observed_at);
86 VG_(message)(Vg_UserMsg,
87 "%s 0x%lx was first observed at:\n",
88 DRD_(clientobj_type_name)(cl->any.type),
89 obj);
90 VG_(pp_ExeContext)(cl->any.first_observed_at);
91 }
92 }
93
94 static
drd_report_data_race(Error * const err,const DataRaceErrInfo * const dri)95 void drd_report_data_race(Error* const err, const DataRaceErrInfo* const dri)
96 {
97 AddrInfo ai;
98
99 XArray* /* of HChar */ descr1
100 = VG_(newXA)( VG_(malloc), "drd.error.drdr2.1",
101 VG_(free), sizeof(HChar) );
102 XArray* /* of HChar */ descr2
103 = VG_(newXA)( VG_(malloc), "drd.error.drdr2.2",
104 VG_(free), sizeof(HChar) );
105
106 tl_assert(dri);
107 tl_assert(dri->addr);
108 tl_assert(dri->size > 0);
109 tl_assert(descr1);
110 tl_assert(descr2);
111
112 (void) VG_(get_data_description)(descr1, descr2, dri->addr);
113 /* If there's nothing in descr1/2, free them. Why is it safe to to
114 VG_(indexXA) at zero here? Because VG_(get_data_description)
115 guarantees to zero terminate descr1/2 regardless of the outcome
116 of the call. So there's always at least one element in each XA
117 after the call.
118 */
119 if (0 == VG_(strlen)( VG_(indexXA)( descr1, 0 ))) {
120 VG_(deleteXA)( descr1 );
121 descr1 = NULL;
122 }
123 if (0 == VG_(strlen)( VG_(indexXA)( descr2, 0 ))) {
124 VG_(deleteXA)( descr2 );
125 descr2 = NULL;
126 }
127 /* Assume (assert) that VG_(get_data_description) fills in descr1
128 before it fills in descr2 */
129 if (descr1 == NULL)
130 tl_assert(descr2 == NULL);
131 /* So anyway. Do we have something useful? */
132 if (descr1 == NULL)
133 {
134 /* No. Do Plan B. */
135 describe_malloced_addr(dri->addr, &ai);
136 }
137 VG_(message)(Vg_UserMsg,
138 "Conflicting %s by thread %d at 0x%08lx size %ld\n",
139 dri->access_type == eStore ? "store" : "load",
140 dri->tid,
141 dri->addr,
142 dri->size);
143 VG_(pp_ExeContext)(VG_(get_error_where)(err));
144 if (descr1 != NULL)
145 {
146 VG_(message)(Vg_UserMsg, "%s\n", (HChar*)VG_(indexXA)(descr1, 0));
147 if (descr2 != NULL)
148 VG_(message)(Vg_UserMsg, "%s\n", (HChar*)VG_(indexXA)(descr2, 0));
149 }
150 else if (ai.akind == eMallocd && ai.lastchange)
151 {
152 VG_(message)(Vg_UserMsg,
153 "Address 0x%lx is at offset %ld from 0x%lx."
154 " Allocation context:\n",
155 dri->addr, ai.rwoffset, dri->addr - ai.rwoffset);
156 VG_(pp_ExeContext)(ai.lastchange);
157 }
158 else
159 {
160 char sect_name[64];
161 VgSectKind sect_kind;
162
163 sect_kind = VG_(DebugInfo_sect_kind)(sect_name, sizeof(sect_name),
164 dri->addr);
165 if (sect_kind != Vg_SectUnknown)
166 {
167 VG_(message)(Vg_UserMsg,
168 "Allocation context: %s section of %s\n",
169 VG_(pp_SectKind)(sect_kind),
170 sect_name);
171 }
172 else
173 {
174 VG_(message)(Vg_UserMsg, "Allocation context: unknown.\n");
175 }
176 }
177 if (s_show_conflicting_segments)
178 {
179 DRD_(thread_report_conflicting_segments)(dri->tid,
180 dri->addr, dri->size,
181 dri->access_type);
182 }
183
184 if (descr2)
185 VG_(deleteXA)(descr2);
186 if (descr1)
187 VG_(deleteXA)(descr1);
188 }
189
190 /**
191 * Compare two error contexts. The core function VG_(maybe_record_error)()
192 * calls this function to compare error contexts such that errors that occur
193 * repeatedly are only printed once. This function is only called by the core
194 * if the error kind of e1 and e2 matches and if the ExeContext's of e1 and
195 * e2 also match.
196 */
drd_compare_error_contexts(VgRes res,Error * e1,Error * e2)197 static Bool drd_compare_error_contexts(VgRes res, Error* e1, Error* e2)
198 {
199 tl_assert(VG_(get_error_kind)(e1) == VG_(get_error_kind)(e2));
200
201 switch (VG_(get_error_kind)(e1))
202 {
203 case DataRaceErr:
204 {
205 const DataRaceErrInfo* const dri1 = VG_(get_error_extra)(e1);
206 const DataRaceErrInfo* const dri2 = VG_(get_error_extra)(e2);
207 return dri1->access_type == dri2->access_type
208 && dri1->size == dri2->size;
209 }
210 case MutexErr:
211 {
212 const MutexErrInfo* const mei1 = VG_(get_error_extra)(e1);
213 const MutexErrInfo* const mei2 = VG_(get_error_extra)(e2);
214 return mei1->mutex == mei2->mutex;
215 }
216 default:
217 return True;
218 }
219 }
220
221 /**
222 * Called by the core just before an error message will be printed. Used by
223 * DRD to print the thread number as a preamble.
224 */
drd_tool_error_before_pp(Error * const e)225 static void drd_tool_error_before_pp(Error* const e)
226 {
227 static DrdThreadId s_last_tid_printed = 1;
228 DrdThreadId* err_extra;
229
230 err_extra = VG_(get_error_extra)(e);
231
232 if (err_extra && *err_extra != s_last_tid_printed)
233 {
234 VG_(umsg)("%s:\n", DRD_(thread_get_name)(*err_extra));
235 s_last_tid_printed = *err_extra;
236 }
237 }
238
239 /** Report an error to the user. */
drd_tool_error_pp(Error * const e)240 static void drd_tool_error_pp(Error* const e)
241 {
242 switch (VG_(get_error_kind)(e))
243 {
244 case DataRaceErr: {
245 drd_report_data_race(e, VG_(get_error_extra)(e));
246 break;
247 }
248 case MutexErr: {
249 MutexErrInfo* p = (MutexErrInfo*)(VG_(get_error_extra)(e));
250 tl_assert(p);
251 if (p->recursion_count >= 0)
252 {
253 VG_(message)(Vg_UserMsg,
254 "%s: mutex 0x%lx, recursion count %d, owner %d.\n",
255 VG_(get_error_string)(e),
256 p->mutex,
257 p->recursion_count,
258 p->owner);
259 }
260 else
261 {
262 VG_(message)(Vg_UserMsg,
263 "The object at address 0x%lx is not a mutex.\n",
264 p->mutex);
265 }
266 VG_(pp_ExeContext)(VG_(get_error_where)(e));
267 first_observed(p->mutex);
268 break;
269 }
270 case CondErr: {
271 CondErrInfo* cdei =(CondErrInfo*)(VG_(get_error_extra)(e));
272 VG_(message)(Vg_UserMsg,
273 "%s: cond 0x%lx\n",
274 VG_(get_error_string)(e),
275 cdei->cond);
276 VG_(pp_ExeContext)(VG_(get_error_where)(e));
277 first_observed(cdei->cond);
278 break;
279 }
280 case CondDestrErr: {
281 CondDestrErrInfo* cdi = (CondDestrErrInfo*)(VG_(get_error_extra)(e));
282 VG_(message)(Vg_UserMsg,
283 "%s: cond 0x%lx, mutex 0x%lx locked by thread %d\n",
284 VG_(get_error_string)(e),
285 cdi->cond, cdi->mutex,
286 cdi->owner);
287 VG_(pp_ExeContext)(VG_(get_error_where)(e));
288 first_observed(cdi->mutex);
289 break;
290 }
291 case CondRaceErr: {
292 CondRaceErrInfo* cei = (CondRaceErrInfo*)(VG_(get_error_extra)(e));
293 VG_(message)(Vg_UserMsg,
294 "Probably a race condition: condition variable 0x%lx has"
295 " been signaled but the associated mutex 0x%lx is not"
296 " locked by the signalling thread.\n",
297 cei->cond, cei->mutex);
298 VG_(pp_ExeContext)(VG_(get_error_where)(e));
299 first_observed(cei->cond);
300 first_observed(cei->mutex);
301 break;
302 }
303 case CondWaitErr: {
304 CondWaitErrInfo* cwei = (CondWaitErrInfo*)(VG_(get_error_extra)(e));
305 VG_(message)(Vg_UserMsg,
306 "%s: condition variable 0x%lx, mutexes 0x%lx and 0x%lx\n",
307 VG_(get_error_string)(e),
308 cwei->cond,
309 cwei->mutex1,
310 cwei->mutex2);
311 VG_(pp_ExeContext)(VG_(get_error_where)(e));
312 first_observed(cwei->cond);
313 first_observed(cwei->mutex1);
314 first_observed(cwei->mutex2);
315 break;
316 }
317 case SemaphoreErr: {
318 SemaphoreErrInfo* sei = (SemaphoreErrInfo*)(VG_(get_error_extra)(e));
319 tl_assert(sei);
320 VG_(message)(Vg_UserMsg,
321 "%s: semaphore 0x%lx\n",
322 VG_(get_error_string)(e),
323 sei->semaphore);
324 VG_(pp_ExeContext)(VG_(get_error_where)(e));
325 first_observed(sei->semaphore);
326 break;
327 }
328 case BarrierErr: {
329 BarrierErrInfo* bei = (BarrierErrInfo*)(VG_(get_error_extra)(e));
330 tl_assert(bei);
331 VG_(message)(Vg_UserMsg,
332 "%s: barrier 0x%lx\n",
333 VG_(get_error_string)(e),
334 bei->barrier);
335 VG_(pp_ExeContext)(VG_(get_error_where)(e));
336 if (bei->other_context)
337 {
338 VG_(message)(Vg_UserMsg,
339 "Conflicting wait call by thread %d:\n",
340 bei->other_tid);
341 VG_(pp_ExeContext)(bei->other_context);
342 }
343 first_observed(bei->barrier);
344 break;
345 }
346 case RwlockErr: {
347 RwlockErrInfo* p = (RwlockErrInfo*)(VG_(get_error_extra)(e));
348 tl_assert(p);
349 VG_(message)(Vg_UserMsg,
350 "%s: rwlock 0x%lx.\n",
351 VG_(get_error_string)(e),
352 p->rwlock);
353 VG_(pp_ExeContext)(VG_(get_error_where)(e));
354 first_observed(p->rwlock);
355 break;
356 }
357 case HoldtimeErr: {
358 HoldtimeErrInfo* p =(HoldtimeErrInfo*)(VG_(get_error_extra)(e));
359 tl_assert(p);
360 tl_assert(p->acquired_at);
361 VG_(message)(Vg_UserMsg, "Acquired at:\n");
362 VG_(pp_ExeContext)(p->acquired_at);
363 VG_(message)(Vg_UserMsg,
364 "Lock on %s 0x%lx was held during %d ms (threshold: %d ms).\n",
365 VG_(get_error_string)(e),
366 p->synchronization_object,
367 p->hold_time_ms,
368 p->threshold_ms);
369 VG_(pp_ExeContext)(VG_(get_error_where)(e));
370 first_observed(p->synchronization_object);
371 break;
372 }
373 case GenericErr: {
374 GenericErrInfo* gei = (GenericErrInfo*)(VG_(get_error_extra)(e));
375 VG_(message)(Vg_UserMsg, "%s\n", VG_(get_error_string)(e));
376 VG_(pp_ExeContext)(VG_(get_error_where)(e));
377 if (gei->addr)
378 first_observed(gei->addr);
379 break;
380 }
381 case InvalidThreadId: {
382 InvalidThreadIdInfo* iti =(InvalidThreadIdInfo*)(VG_(get_error_extra)(e));
383 VG_(message)(Vg_UserMsg,
384 "%s 0x%llx\n", VG_(get_error_string)(e), iti->ptid);
385 VG_(pp_ExeContext)(VG_(get_error_where)(e));
386 break;
387 }
388 case UnimpHgClReq: {
389 UnimpClReqInfo* uicr =(UnimpClReqInfo*)(VG_(get_error_extra)(e));
390 VG_(message)(Vg_UserMsg,
391 "The annotation macro %s has not yet been implemented in"
392 " <valgrind/helgrind.h>\n",
393 /*VG_(get_error_string)(e),*/ uicr->descr);
394 VG_(pp_ExeContext)(VG_(get_error_where)(e));
395 break;
396 }
397 case UnimpDrdClReq: {
398 UnimpClReqInfo* uicr =(UnimpClReqInfo*)(VG_(get_error_extra)(e));
399 VG_(message)(Vg_UserMsg,
400 "The annotation macro %s has not yet been implemented in"
401 " <valgrind/drd.h>\n",
402 uicr->descr);
403 VG_(pp_ExeContext)(VG_(get_error_where)(e));
404 break;
405 }
406 default:
407 VG_(message)(Vg_UserMsg,
408 "%s\n",
409 VG_(get_error_string)(e));
410 VG_(pp_ExeContext)(VG_(get_error_where)(e));
411 break;
412 }
413 }
414
drd_tool_error_update_extra(Error * e)415 static UInt drd_tool_error_update_extra(Error* e)
416 {
417 switch (VG_(get_error_kind)(e))
418 {
419 case DataRaceErr:
420 return sizeof(DataRaceErrInfo);
421 case MutexErr:
422 return sizeof(MutexErrInfo);
423 case CondErr:
424 return sizeof(CondErrInfo);
425 case CondDestrErr:
426 return sizeof(CondDestrErrInfo);
427 case CondRaceErr:
428 return sizeof(CondRaceErrInfo);
429 case CondWaitErr:
430 return sizeof(CondWaitErrInfo);
431 case SemaphoreErr:
432 return sizeof(SemaphoreErrInfo);
433 case BarrierErr:
434 return sizeof(BarrierErrInfo);
435 case RwlockErr:
436 return sizeof(RwlockErrInfo);
437 case HoldtimeErr:
438 return sizeof(HoldtimeErrInfo);
439 case GenericErr:
440 return sizeof(GenericErrInfo);
441 case InvalidThreadId:
442 return sizeof(InvalidThreadIdInfo);
443 case UnimpHgClReq:
444 return sizeof(UnimpClReqInfo);
445 case UnimpDrdClReq:
446 return sizeof(UnimpClReqInfo);
447 default:
448 tl_assert(False);
449 break;
450 }
451 }
452
453 /**
454 * Parse suppression name.
455 *
456 * The suppression types recognized by DRD are the same types as the error
457 * types supported by DRD. So try to match the suppression name against the
458 * names of DRD error types.
459 */
drd_is_recognized_suppression(Char * const name,Supp * const supp)460 static Bool drd_is_recognized_suppression(Char* const name, Supp* const supp)
461 {
462 DrdErrorKind skind = 0;
463
464 if (VG_(strcmp)(name, STR_DataRaceErr) == 0)
465 skind = DataRaceErr;
466 else if (VG_(strcmp)(name, STR_MutexErr) == 0)
467 skind = MutexErr;
468 else if (VG_(strcmp)(name, STR_CondErr) == 0)
469 skind = CondErr;
470 else if (VG_(strcmp)(name, STR_CondDestrErr) == 0)
471 skind = CondDestrErr;
472 else if (VG_(strcmp)(name, STR_CondRaceErr) == 0)
473 skind = CondRaceErr;
474 else if (VG_(strcmp)(name, STR_CondWaitErr) == 0)
475 skind = CondWaitErr;
476 else if (VG_(strcmp)(name, STR_SemaphoreErr) == 0)
477 skind = SemaphoreErr;
478 else if (VG_(strcmp)(name, STR_BarrierErr) == 0)
479 skind = BarrierErr;
480 else if (VG_(strcmp)(name, STR_RwlockErr) == 0)
481 skind = RwlockErr;
482 else if (VG_(strcmp)(name, STR_HoldtimeErr) == 0)
483 skind = HoldtimeErr;
484 else if (VG_(strcmp)(name, STR_GenericErr) == 0)
485 skind = GenericErr;
486 else if (VG_(strcmp)(name, STR_InvalidThreadId) == 0)
487 skind = InvalidThreadId;
488 else if (VG_(strcmp)(name, STR_UnimpHgClReq) == 0)
489 skind = UnimpHgClReq;
490 else if (VG_(strcmp)(name, STR_UnimpDrdClReq) == 0)
491 skind = UnimpDrdClReq;
492 else
493 return False;
494
495 VG_(set_supp_kind)(supp, skind);
496 return True;
497 }
498
499 /**
500 * Read additional suppression information from the suppression file.
501 *
502 * None of the suppression patterns recognized by DRD has 'extra' lines
503 * of information in the suppression file, so just return True to indicate
504 * that reading the 'extra' lines succeeded.
505 */
506 static
drd_read_extra_suppression_info(Int fd,Char ** bufpp,SizeT * nBufp,Supp * supp)507 Bool drd_read_extra_suppression_info(Int fd, Char** bufpp,
508 SizeT* nBufp, Supp* supp)
509 {
510 return True;
511 }
512
513 /**
514 * Determine whether or not the types of the given error message and the
515 * given suppression match.
516 */
drd_error_matches_suppression(Error * const e,Supp * const supp)517 static Bool drd_error_matches_suppression(Error* const e, Supp* const supp)
518 {
519 return VG_(get_supp_kind)(supp) == VG_(get_error_kind)(e);
520 }
521
drd_get_error_name(Error * e)522 static Char* drd_get_error_name(Error* e)
523 {
524 switch (VG_(get_error_kind)(e))
525 {
526 case DataRaceErr: return VGAPPEND(STR_, DataRaceErr);
527 case MutexErr: return VGAPPEND(STR_, MutexErr);
528 case CondErr: return VGAPPEND(STR_, CondErr);
529 case CondDestrErr: return VGAPPEND(STR_, CondDestrErr);
530 case CondRaceErr: return VGAPPEND(STR_, CondRaceErr);
531 case CondWaitErr: return VGAPPEND(STR_, CondWaitErr);
532 case SemaphoreErr: return VGAPPEND(STR_, SemaphoreErr);
533 case BarrierErr: return VGAPPEND(STR_, BarrierErr);
534 case RwlockErr: return VGAPPEND(STR_, RwlockErr);
535 case HoldtimeErr: return VGAPPEND(STR_, HoldtimeErr);
536 case GenericErr: return VGAPPEND(STR_, GenericErr);
537 case InvalidThreadId: return VGAPPEND(STR_, InvalidThreadId);
538 case UnimpHgClReq: return VGAPPEND(STR_, UnimpHgClReq);
539 case UnimpDrdClReq: return VGAPPEND(STR_, UnimpDrdClReq);
540 default:
541 tl_assert(0);
542 }
543 return 0;
544 }
545
546 /**
547 * Return extra suppression information.
548 *
549 * Invoked while printing a suppression pattern because the user
550 * specified --gen-suppressions=yes or all on the command line. DRD does not
551 * define any 'extra' suppression information.
552 */
553 static
drd_get_extra_suppression_info(Error * e,Char * buf,Int nBuf)554 Bool drd_get_extra_suppression_info(Error* e,
555 /*OUT*/Char* buf, Int nBuf)
556 {
557 return False;
558 }
559
560 /** Tell the Valgrind core about DRD's error handlers. */
DRD_(register_error_handlers)561 void DRD_(register_error_handlers)(void)
562 {
563 VG_(needs_tool_errors)(drd_compare_error_contexts,
564 drd_tool_error_before_pp,
565 drd_tool_error_pp,
566 False,
567 drd_tool_error_update_extra,
568 drd_is_recognized_suppression,
569 drd_read_extra_suppression_info,
570 drd_error_matches_suppression,
571 drd_get_error_name,
572 drd_get_extra_suppression_info);
573 }
574