Home | History | Annotate | Download | only in drd
      1 /*
      2   This file is part of drd, a thread error detector.
      3 
      4   Copyright (C) 2006-2015 Bart Van Assche <bvanassche (at) acm.org>.
      5 
      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.
     10 
     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.
     15 
     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
     19   02111-1307, USA.
     20 
     21   The GNU General Public License is contained in the file COPYING.
     22 */
     23 
     24 
     25 #include "drd_barrier.h"
     26 #include "drd_clientobj.h"
     27 #include "drd_clientreq.h"
     28 #include "drd_cond.h"
     29 #include "drd_error.h"
     30 #include "drd_hb.h"
     31 #include "drd_load_store.h"
     32 #include "drd_malloc_wrappers.h"
     33 #include "drd_mutex.h"
     34 #include "drd_rwlock.h"
     35 #include "drd_segment.h"
     36 #include "drd_semaphore.h"
     37 #include "drd_suppression.h"
     38 #include "drd_thread.h"
     39 #include "libvex_guest_offsets.h"
     40 #include "pub_drd_bitmap.h"
     41 #include "pub_tool_vki.h"         // Must be included before pub_tool_libcproc
     42 #include "pub_tool_basics.h"
     43 #include "pub_tool_libcassert.h"  // tl_assert()
     44 #include "pub_tool_libcbase.h"    // VG_(strcmp)
     45 #include "pub_tool_libcprint.h"   // VG_(printf)
     46 #include "pub_tool_libcproc.h"    // VG_(getenv)()
     47 #include "pub_tool_machine.h"
     48 #include "pub_tool_mallocfree.h"  // VG_(malloc)(), VG_(free)()
     49 #include "pub_tool_options.h"     // command line options
     50 #include "pub_tool_replacemalloc.h"
     51 #include "pub_tool_threadstate.h" // VG_(get_running_tid)()
     52 #include "pub_tool_tooliface.h"
     53 #include "pub_tool_aspacemgr.h"   // VG_(am_is_valid_for_client)
     54 
     55 
     56 /* Local variables. */
     57 
     58 static Bool s_print_stats;
     59 static Bool s_var_info;
     60 static Bool s_show_stack_usage;
     61 static Bool s_trace_alloc;
     62 static Bool trace_sectsuppr;
     63 
     64 
     65 /**
     66  * Implement the needs_command_line_options for drd.
     67  */
     68 static Bool DRD_(process_cmd_line_option)(const HChar* arg)
     69 {
     70    int check_stack_accesses   = -1;
     71    int join_list_vol          = -1;
     72    int exclusive_threshold_ms = -1;
     73    int first_race_only        = -1;
     74    int report_signal_unlocked = -1;
     75    int segment_merging        = -1;
     76    int segment_merge_interval = -1;
     77    int shared_threshold_ms    = -1;
     78    int show_confl_seg         = -1;
     79    int trace_barrier          = -1;
     80    int trace_clientobj        = -1;
     81    int trace_cond             = -1;
     82    int trace_csw              = -1;
     83    int trace_fork_join        = -1;
     84    int trace_hb               = -1;
     85    int trace_conflict_set     = -1;
     86    int trace_conflict_set_bm  = -1;
     87    int trace_mutex            = -1;
     88    int trace_rwlock           = -1;
     89    int trace_segment          = -1;
     90    int trace_semaphore        = -1;
     91    int trace_suppression      = -1;
     92    const HChar* trace_address = 0;
     93    const HChar* ptrace_address= 0;
     94 
     95    if      VG_BOOL_CLO(arg, "--check-stack-var",     check_stack_accesses) {}
     96    else if VG_INT_CLO (arg, "--join-list-vol",       join_list_vol) {}
     97    else if VG_BOOL_CLO(arg, "--drd-stats",           s_print_stats) {}
     98    else if VG_BOOL_CLO(arg, "--first-race-only",     first_race_only) {}
     99    else if VG_BOOL_CLO(arg, "--free-is-write",       DRD_(g_free_is_write)) {}
    100    else if VG_BOOL_CLO(arg,"--report-signal-unlocked",report_signal_unlocked)
    101    {}
    102    else if VG_BOOL_CLO(arg, "--segment-merging",     segment_merging) {}
    103    else if VG_INT_CLO (arg, "--segment-merging-interval", segment_merge_interval)
    104    {}
    105    else if VG_BOOL_CLO(arg, "--show-confl-seg",      show_confl_seg) {}
    106    else if VG_BOOL_CLO(arg, "--show-stack-usage",    s_show_stack_usage) {}
    107    else if VG_BOOL_CLO(arg, "--ignore-thread-creation",
    108    DRD_(ignore_thread_creation)) {}
    109    else if VG_BOOL_CLO(arg, "--trace-alloc",         s_trace_alloc) {}
    110    else if VG_BOOL_CLO(arg, "--trace-barrier",       trace_barrier) {}
    111    else if VG_BOOL_CLO(arg, "--trace-clientobj",     trace_clientobj) {}
    112    else if VG_BOOL_CLO(arg, "--trace-cond",          trace_cond) {}
    113    else if VG_BOOL_CLO(arg, "--trace-conflict-set",  trace_conflict_set) {}
    114    else if VG_BOOL_CLO(arg, "--trace-conflict-set-bm", trace_conflict_set_bm){}
    115    else if VG_BOOL_CLO(arg, "--trace-csw",           trace_csw) {}
    116    else if VG_BOOL_CLO(arg, "--trace-fork-join",     trace_fork_join) {}
    117    else if VG_BOOL_CLO(arg, "--trace-hb",            trace_hb) {}
    118    else if VG_BOOL_CLO(arg, "--trace-mutex",         trace_mutex) {}
    119    else if VG_BOOL_CLO(arg, "--trace-rwlock",        trace_rwlock) {}
    120    else if VG_BOOL_CLO(arg, "--trace-sectsuppr",     trace_sectsuppr) {}
    121    else if VG_BOOL_CLO(arg, "--trace-segment",       trace_segment) {}
    122    else if VG_BOOL_CLO(arg, "--trace-semaphore",     trace_semaphore) {}
    123    else if VG_BOOL_CLO(arg, "--trace-suppr",         trace_suppression) {}
    124    else if VG_BOOL_CLO(arg, "--var-info",            s_var_info) {}
    125    else if VG_BOOL_CLO(arg, "--verify-conflict-set", DRD_(verify_conflict_set))
    126    {}
    127    else if VG_INT_CLO (arg, "--exclusive-threshold", exclusive_threshold_ms) {}
    128    else if VG_STR_CLO (arg, "--ptrace-addr",         ptrace_address) {}
    129    else if VG_INT_CLO (arg, "--shared-threshold",    shared_threshold_ms)    {}
    130    else if VG_STR_CLO (arg, "--trace-addr",          trace_address) {}
    131    else
    132       return VG_(replacement_malloc_process_cmd_line_option)(arg);
    133 
    134    if (check_stack_accesses != -1)
    135       DRD_(set_check_stack_accesses)(check_stack_accesses);
    136    if (exclusive_threshold_ms != -1)
    137    {
    138       DRD_(mutex_set_lock_threshold)(exclusive_threshold_ms);
    139       DRD_(rwlock_set_exclusive_threshold)(exclusive_threshold_ms);
    140    }
    141    if (first_race_only != -1)
    142    {
    143       DRD_(set_first_race_only)(first_race_only);
    144    }
    145    if (join_list_vol != -1)
    146       DRD_(thread_set_join_list_vol)(join_list_vol);
    147    if (report_signal_unlocked != -1)
    148    {
    149       DRD_(cond_set_report_signal_unlocked)(report_signal_unlocked);
    150    }
    151    if (shared_threshold_ms != -1)
    152    {
    153       DRD_(rwlock_set_shared_threshold)(shared_threshold_ms);
    154    }
    155    if (segment_merging != -1)
    156       DRD_(thread_set_segment_merging)(segment_merging);
    157    if (segment_merge_interval != -1)
    158       DRD_(thread_set_segment_merge_interval)(segment_merge_interval);
    159    if (show_confl_seg != -1)
    160       DRD_(set_show_conflicting_segments)(show_confl_seg);
    161    if (trace_address) {
    162       const Addr addr = VG_(strtoll16)(trace_address, 0);
    163       DRD_(start_tracing_address_range)(addr, addr + 1, False);
    164    }
    165    if (ptrace_address) {
    166       HChar *plus = VG_(strchr)(ptrace_address, '+');
    167       Addr addr, length;
    168       if (plus)
    169          *plus = '\0';
    170       addr = VG_(strtoll16)(ptrace_address, 0);
    171       length = plus ? VG_(strtoll16)(plus + 1, 0) : 1;
    172       DRD_(start_tracing_address_range)(addr, addr + length, True);
    173    }
    174    if (trace_barrier != -1)
    175       DRD_(barrier_set_trace)(trace_barrier);
    176    if (trace_clientobj != -1)
    177       DRD_(clientobj_set_trace)(trace_clientobj);
    178    if (trace_cond != -1)
    179       DRD_(cond_set_trace)(trace_cond);
    180    if (trace_csw != -1)
    181       DRD_(thread_trace_context_switches)(trace_csw);
    182    if (trace_fork_join != -1)
    183       DRD_(thread_set_trace_fork_join)(trace_fork_join);
    184    if (trace_hb != -1)
    185       DRD_(hb_set_trace)(trace_hb);
    186    if (trace_conflict_set != -1)
    187       DRD_(thread_trace_conflict_set)(trace_conflict_set);
    188    if (trace_conflict_set_bm != -1)
    189       DRD_(thread_trace_conflict_set_bm)(trace_conflict_set_bm);
    190    if (trace_mutex != -1)
    191       DRD_(mutex_set_trace)(trace_mutex);
    192    if (trace_rwlock != -1)
    193       DRD_(rwlock_set_trace)(trace_rwlock);
    194    if (trace_segment != -1)
    195       DRD_(sg_set_trace)(trace_segment);
    196    if (trace_semaphore != -1)
    197       DRD_(semaphore_set_trace)(trace_semaphore);
    198    if (trace_suppression != -1)
    199       DRD_(suppression_set_trace)(trace_suppression);
    200 
    201    return True;
    202 }
    203 
    204 static void DRD_(print_usage)(void)
    205 {
    206    VG_(printf)(
    207 "    --check-stack-var=yes|no  Whether or not to report data races on\n"
    208 "                              stack variables [no].\n"
    209 "    --exclusive-threshold=<n> Print an error message if any mutex or\n"
    210 "                              writer lock is held longer than the specified\n"
    211 "                              time (in milliseconds) [off].\n"
    212 "    --first-race-only=yes|no  Only report the first data race that occurs on\n"
    213 "                              a memory location instead of all races [no].\n"
    214 "    --free-is-write=yes|no    Whether to report races between freeing memory\n"
    215 "                              and subsequent accesses of that memory[no].\n"
    216 "    --join-list-vol=<n>       Number of threads to delay cleanup for [10].\n"
    217 "    --report-signal-unlocked=yes|no Whether to report calls to\n"
    218 "                              pthread_cond_signal() where the mutex associated\n"
    219 "                              with the signal via pthread_cond_wait() is not\n"
    220 "                              locked at the time the signal is sent [yes].\n"
    221 "    --segment-merging=yes|no  Controls segment merging [yes].\n"
    222 "        Segment merging is an algorithm to limit memory usage of the\n"
    223 "        data race detection algorithm. Disabling segment merging may\n"
    224 "        improve the accuracy of the so-called 'other segments' displayed\n"
    225 "        in race reports but can also trigger an out of memory error.\n"
    226 "    --segment-merging-interval=<n> Perform segment merging every time n new\n"
    227 "        segments have been created. Default: %d.\n"
    228 "    --shared-threshold=<n>    Print an error message if a reader lock\n"
    229 "                              is held longer than the specified time (in\n"
    230 "                              milliseconds) [off]\n"
    231 "    --show-confl-seg=yes|no   Show conflicting segments in race reports [yes].\n"
    232 "    --show-stack-usage=yes|no Print stack usage at thread exit time [no].\n"
    233 "    --ignore-thread-creation=yes|no Ignore activities during thread \n"
    234 "                              creation [%s].\n"
    235 "\n"
    236 "  drd options for monitoring process behavior:\n"
    237 "    --ptrace-addr=<address>[+<length>] Trace all load and store activity for\n"
    238 "                              the specified address range and keep doing that\n"
    239 "                              even after the memory at that address has been\n"
    240 "                              freed and reallocated [off].\n"
    241 "    --trace-addr=<address>    Trace all load and store activity for the\n"
    242 "                              specified address [off].\n"
    243 "    --trace-alloc=yes|no      Trace all memory allocations and deallocations\n"
    244 "                              [no].\n"
    245 "    --trace-barrier=yes|no    Trace all barrier activity [no].\n"
    246 "    --trace-cond=yes|no       Trace all condition variable activity [no].\n"
    247 "    --trace-fork-join=yes|no  Trace all thread fork/join activity [no].\n"
    248 "    --trace-hb=yes|no         Trace ANNOTATE_HAPPENS_BEFORE() etc. [no].\n"
    249 "    --trace-mutex=yes|no      Trace all mutex activity [no].\n"
    250 "    --trace-rwlock=yes|no     Trace all reader-writer lock activity[no].\n"
    251 "    --trace-semaphore=yes|no  Trace all semaphore activity [no].\n",
    252 DRD_(thread_get_segment_merge_interval)(),
    253 DRD_(ignore_thread_creation) ? "yes" : "no"
    254 );
    255 }
    256 
    257 static void DRD_(print_debug_usage)(void)
    258 {
    259    VG_(printf)(
    260 "    --drd-stats=yes|no        Print statistics about DRD activity [no].\n"
    261 "    --trace-clientobj=yes|no  Trace all client object activity [no].\n"
    262 "    --trace-csw=yes|no        Trace all scheduler context switches [no].\n"
    263 "    --trace-conflict-set=yes|no Trace all conflict set updates [no].\n"
    264 "    --trace-conflict-set-bm=yes|no Trace all conflict set bitmap\n"
    265 "                              updates [no]. Note: enabling this option\n"
    266 "                              will generate a lot of output !\n"
    267 "    --trace-sectsuppr=yes|no  Trace which the dynamic library sections on\n"
    268 "                              which data race detection is suppressed.\n"
    269 "    --trace-segment=yes|no    Trace segment actions [no].\n"
    270 "    --trace-suppr=yes|no      Trace all address suppression actions [no].\n"
    271 "    --verify-conflict-set=yes|no Verify conflict set consistency [no].\n"
    272 );
    273 }
    274 
    275 
    276 //
    277 // Implements the thread-related core callbacks.
    278 //
    279 
    280 static void drd_pre_mem_read(const CorePart part,
    281                              const ThreadId tid,
    282                              const HChar* const s,
    283                              const Addr a,
    284                              const SizeT size)
    285 {
    286    DRD_(thread_set_vg_running_tid)(VG_(get_running_tid)());
    287    if (size > 0)
    288    {
    289       DRD_(trace_load)(a, size);
    290    }
    291 }
    292 
    293 static void drd_pre_mem_read_asciiz(const CorePart part,
    294                                     const ThreadId tid,
    295                                     const HChar* const s,
    296                                     const Addr a)
    297 {
    298    const HChar* p = (void*)a;
    299    SizeT size = 0;
    300 
    301    // Don't segfault if the string starts in an obviously stupid
    302    // place.  Actually we should check the whole string, not just
    303    // the start address, but that's too much trouble.  At least
    304    // checking the first byte is better than nothing.  See #255009.
    305    if (!VG_(am_is_valid_for_client) (a, 1, VKI_PROT_READ))
    306       return;
    307 
    308    /* Note: the expression '*p' reads client memory and may crash if the */
    309    /* client provided an invalid pointer !                               */
    310    while (*p)
    311    {
    312       p++;
    313       size++;
    314    }
    315    if (size > 0)
    316    {
    317       DRD_(trace_load)(a, size);
    318    }
    319 }
    320 
    321 static void drd_post_mem_write(const CorePart part,
    322                                const ThreadId tid,
    323                                const Addr a,
    324                                const SizeT size)
    325 {
    326    DRD_(thread_set_vg_running_tid)(VG_(get_running_tid)());
    327    if (size > 0)
    328    {
    329       DRD_(trace_store)(a, size);
    330    }
    331 }
    332 
    333 static __inline__
    334 void drd_start_using_mem(const Addr a1, const SizeT len,
    335                          const Bool is_stack_mem)
    336 {
    337    const Addr a2 = a1 + len;
    338 
    339    tl_assert(a1 <= a2);
    340 
    341    if (!is_stack_mem && s_trace_alloc)
    342       DRD_(trace_msg)("Started using memory range 0x%lx + %lu%s",
    343                       a1, len, DRD_(running_thread_inside_pthread_create)()
    344                       ? " (inside pthread_create())" : "");
    345 
    346    if (!is_stack_mem && DRD_(g_free_is_write))
    347       DRD_(thread_stop_using_mem)(a1, a2);
    348 
    349    if (UNLIKELY(DRD_(any_address_is_traced)()))
    350    {
    351       DRD_(trace_mem_access)(a1, len, eStart, 0, 0);
    352    }
    353 
    354    if (UNLIKELY(DRD_(running_thread_inside_pthread_create)()))
    355    {
    356       DRD_(start_suppression)(a1, a2, "pthread_create()");
    357    }
    358 }
    359 
    360 static void drd_start_using_mem_w_ecu(const Addr a1,
    361                                       const SizeT len,
    362                                       UInt ec_uniq)
    363 {
    364    drd_start_using_mem(a1, len, False);
    365 }
    366 
    367 static void drd_start_using_mem_w_tid(const Addr a1,
    368                                       const SizeT len,
    369                                       ThreadId tid)
    370 {
    371    drd_start_using_mem(a1, len, False);
    372 }
    373 
    374 static __inline__
    375 void drd_stop_using_mem(const Addr a1, const SizeT len,
    376                         const Bool is_stack_mem)
    377 {
    378    const Addr a2 = a1 + len;
    379 
    380    tl_assert(a1 <= a2);
    381 
    382    if (UNLIKELY(DRD_(any_address_is_traced)()))
    383       DRD_(trace_mem_access)(a1, len, eEnd, 0, 0);
    384 
    385    if (!is_stack_mem && s_trace_alloc)
    386       DRD_(trace_msg)("Stopped using memory range 0x%lx + %lu",
    387                       a1, len);
    388 
    389    if (!is_stack_mem || DRD_(get_check_stack_accesses)())
    390    {
    391       if (is_stack_mem || !DRD_(g_free_is_write))
    392 	 DRD_(thread_stop_using_mem)(a1, a2);
    393       else if (DRD_(g_free_is_write))
    394 	 DRD_(trace_store)(a1, len);
    395       DRD_(clientobj_stop_using_mem)(a1, a2);
    396       DRD_(suppression_stop_using_mem)(a1, a2);
    397    }
    398 }
    399 
    400 static __inline__
    401 void drd_stop_using_nonstack_mem(const Addr a1, const SizeT len)
    402 {
    403    drd_stop_using_mem(a1, len, False);
    404 }
    405 
    406 /**
    407  * Discard all information DRD has about memory accesses and client objects
    408  * in the specified address range.
    409  */
    410 void DRD_(clean_memory)(const Addr a1, const SizeT len)
    411 {
    412    const Bool is_stack_memory = DRD_(thread_address_on_any_stack)(a1);
    413    drd_stop_using_mem(a1, len, is_stack_memory);
    414    drd_start_using_mem(a1, len, is_stack_memory);
    415 }
    416 
    417 /**
    418  * Suppress data race reports on all addresses contained in .plt, .got and
    419  * .got.plt sections inside the address range [ a, a + len [. The data in
    420  * these sections is modified by _dl_relocate_object() every time a function
    421  * in a shared library is called for the first time. Since the first call
    422  * to a function in a shared library can happen from a multithreaded context,
    423  * such calls can cause conflicting accesses. See also Ulrich Drepper's
    424  * paper "How to Write Shared Libraries" for more information about relocation
    425  * (http://people.redhat.com/drepper/dsohowto.pdf).
    426  * Note: the contents of the .got section is only modified by the MIPS resolver.
    427  */
    428 static void DRD_(suppress_relocation_conflicts)(const Addr a, const SizeT len)
    429 {
    430    const DebugInfo* di;
    431 
    432    if (trace_sectsuppr)
    433       VG_(dmsg)("Evaluating range @ 0x%lx size %lu\n", a, len);
    434 
    435    for (di = VG_(next_DebugInfo)(0); di; di = VG_(next_DebugInfo)(di)) {
    436       Addr  avma;
    437       SizeT size;
    438 
    439       if (trace_sectsuppr)
    440 	 VG_(dmsg)("Examining %s / %s\n", VG_(DebugInfo_get_filename)(di),
    441 		   VG_(DebugInfo_get_soname)(di));
    442 
    443       /*
    444        * Suppress the race report on the libpthread global variable
    445        * __pthread_multiple_threads. See also
    446        * http://bugs.kde.org/show_bug.cgi?id=323905.
    447        */
    448       avma = VG_(DebugInfo_get_bss_avma)(di);
    449       size = VG_(DebugInfo_get_bss_size)(di);
    450       tl_assert((avma && size) || (avma == 0 && size == 0));
    451       if (size > 0 &&
    452           VG_(strcmp)(VG_(DebugInfo_get_soname)(di), "libpthread.so.0") == 0) {
    453 	 if (trace_sectsuppr)
    454 	    VG_(dmsg)("Suppressing .bss @ 0x%lx size %lu\n", avma, size);
    455          tl_assert(VG_(DebugInfo_sect_kind)(NULL, avma) == Vg_SectBSS);
    456          DRD_(start_suppression)(avma, avma + size, ".bss");
    457       }
    458 
    459       avma = VG_(DebugInfo_get_plt_avma)(di);
    460       size = VG_(DebugInfo_get_plt_size)(di);
    461       tl_assert((avma && size) || (avma == 0 && size == 0));
    462       if (size > 0) {
    463 	 if (trace_sectsuppr)
    464 	    VG_(dmsg)("Suppressing .plt @ 0x%lx size %lu\n", avma, size);
    465          tl_assert(VG_(DebugInfo_sect_kind)(NULL, avma) == Vg_SectPLT);
    466          DRD_(start_suppression)(avma, avma + size, ".plt");
    467       }
    468 
    469       avma = VG_(DebugInfo_get_gotplt_avma)(di);
    470       size = VG_(DebugInfo_get_gotplt_size)(di);
    471       tl_assert((avma && size) || (avma == 0 && size == 0));
    472       if (size > 0) {
    473 	 if (trace_sectsuppr)
    474 	    VG_(dmsg)("Suppressing .got.plt @ 0x%lx size %lu\n", avma, size);
    475          tl_assert(VG_(DebugInfo_sect_kind)(NULL, avma) == Vg_SectGOTPLT);
    476          DRD_(start_suppression)(avma, avma + size, ".gotplt");
    477       }
    478 
    479       avma = VG_(DebugInfo_get_got_avma)(di);
    480       size = VG_(DebugInfo_get_got_size)(di);
    481       tl_assert((avma && size) || (avma == 0 && size == 0));
    482       if (size > 0) {
    483 	 if (trace_sectsuppr)
    484 	    VG_(dmsg)("Suppressing .got @ 0x%lx size %lu\n", avma, size);
    485          tl_assert(VG_(DebugInfo_sect_kind)(NULL, avma) == Vg_SectGOT);
    486          DRD_(start_suppression)(avma, avma + size, ".got");
    487       }
    488    }
    489 }
    490 
    491 static
    492 void drd_start_using_mem_w_perms(const Addr a, const SizeT len,
    493                                  const Bool rr, const Bool ww, const Bool xx,
    494                                  ULong di_handle)
    495 {
    496    DRD_(thread_set_vg_running_tid)(VG_(get_running_tid)());
    497 
    498    drd_start_using_mem(a, len, False);
    499 
    500    DRD_(suppress_relocation_conflicts)(a, len);
    501 }
    502 
    503 /**
    504  * Called by the core when the stack of a thread grows, to indicate that
    505  * the addresses in range [ a, a + len [ may now be used by the client.
    506  * Assumption: stacks grow downward.
    507  */
    508 static __inline__
    509 void drd_start_using_mem_stack2(const DrdThreadId tid, const Addr a,
    510                                 const SizeT len)
    511 {
    512    DRD_(thread_set_stack_min)(tid, a - VG_STACK_REDZONE_SZB);
    513    drd_start_using_mem(a - VG_STACK_REDZONE_SZB, len + VG_STACK_REDZONE_SZB,
    514                        True);
    515 }
    516 
    517 static __inline__
    518 void drd_start_using_mem_stack(const Addr a, const SizeT len)
    519 {
    520    drd_start_using_mem_stack2(DRD_(thread_get_running_tid)(), a, len);
    521 }
    522 
    523 /**
    524  * Called by the core when the stack of a thread shrinks, to indicate that
    525  * the addresses [ a, a + len [ are no longer accessible for the client.
    526  * Assumption: stacks grow downward.
    527  */
    528 static __inline__
    529 void drd_stop_using_mem_stack2(const DrdThreadId tid, const Addr a,
    530                                const SizeT len)
    531 {
    532    DRD_(thread_set_stack_min)(tid, a + len - VG_STACK_REDZONE_SZB);
    533    drd_stop_using_mem(a - VG_STACK_REDZONE_SZB, len + VG_STACK_REDZONE_SZB,
    534                       True);
    535 }
    536 
    537 static __inline__
    538 void drd_stop_using_mem_stack(const Addr a, const SizeT len)
    539 {
    540    drd_stop_using_mem_stack2(DRD_(thread_get_running_tid)(), a, len);
    541 }
    542 
    543 static
    544 Bool on_alt_stack(const Addr a)
    545 {
    546    ThreadId vg_tid;
    547    Addr alt_min;
    548    SizeT alt_size;
    549 
    550    vg_tid = VG_(get_running_tid)();
    551    alt_min = VG_(thread_get_altstack_min)(vg_tid);
    552    alt_size = VG_(thread_get_altstack_size)(vg_tid);
    553    return (SizeT)(a - alt_min) < alt_size;
    554 }
    555 
    556 static
    557 void drd_start_using_mem_alt_stack(const Addr a, const SizeT len)
    558 {
    559    if (!on_alt_stack(a))
    560       drd_start_using_mem_stack(a, len);
    561 }
    562 
    563 static
    564 void drd_stop_using_mem_alt_stack(const Addr a, const SizeT len)
    565 {
    566    if (!on_alt_stack(a))
    567       drd_stop_using_mem_stack(a, len);
    568 }
    569 
    570 /**
    571  * Callback function invoked by the Valgrind core before a signal is delivered.
    572  */
    573 static
    574 void drd_pre_deliver_signal(const ThreadId vg_tid, const Int sigNo,
    575                             const Bool alt_stack)
    576 {
    577    DrdThreadId drd_tid;
    578 
    579    drd_tid = DRD_(VgThreadIdToDrdThreadId)(vg_tid);
    580    DRD_(thread_set_on_alt_stack)(drd_tid, alt_stack);
    581    if (alt_stack)
    582    {
    583       /*
    584        * As soon a signal handler has been invoked on the alternate stack,
    585        * switch to stack memory handling functions that can handle the
    586        * alternate stack.
    587        */
    588       VG_(track_new_mem_stack)(drd_start_using_mem_alt_stack);
    589       VG_(track_die_mem_stack)(drd_stop_using_mem_alt_stack);
    590    }
    591 }
    592 
    593 /**
    594  * Callback function invoked by the Valgrind core after a signal is delivered,
    595  * at least if the signal handler did not longjmp().
    596  */
    597 static
    598 void drd_post_deliver_signal(const ThreadId vg_tid, const Int sigNo)
    599 {
    600    DrdThreadId drd_tid;
    601 
    602    drd_tid = DRD_(VgThreadIdToDrdThreadId)(vg_tid);
    603    DRD_(thread_set_on_alt_stack)(drd_tid, False);
    604    if (DRD_(thread_get_threads_on_alt_stack)() == 0)
    605    {
    606       VG_(track_new_mem_stack)(drd_start_using_mem_stack);
    607       VG_(track_die_mem_stack)(drd_stop_using_mem_stack);
    608    }
    609 }
    610 
    611 /**
    612  * Callback function called by the Valgrind core before a stack area is
    613  * being used by a signal handler.
    614  *
    615  * @param[in] a   Start of address range - VG_STACK_REDZONE_SZB.
    616  * @param[in] len Address range length + VG_STACK_REDZONE_SZB.
    617  * @param[in] tid Valgrind thread ID for whom the signal frame is being
    618  *                constructed.
    619  */
    620 static void drd_start_using_mem_stack_signal(const Addr a, const SizeT len,
    621                                              ThreadId tid)
    622 {
    623    DRD_(thread_set_vg_running_tid)(VG_(get_running_tid)());
    624    drd_start_using_mem(a + VG_STACK_REDZONE_SZB, len - VG_STACK_REDZONE_SZB,
    625                        True);
    626 }
    627 
    628 static void drd_stop_using_mem_stack_signal(Addr a, SizeT len)
    629 {
    630    drd_stop_using_mem(a + VG_STACK_REDZONE_SZB, len - VG_STACK_REDZONE_SZB,
    631                       True);
    632 }
    633 
    634 static
    635 void drd_pre_thread_create(const ThreadId creator, const ThreadId created)
    636 {
    637    const DrdThreadId drd_creator = DRD_(VgThreadIdToDrdThreadId)(creator);
    638    tl_assert(created != VG_INVALID_THREADID);
    639    DRD_(thread_pre_create)(drd_creator, created);
    640    if (DRD_(IsValidDrdThreadId)(drd_creator))
    641    {
    642       DRD_(thread_new_segment)(drd_creator);
    643    }
    644    if (DRD_(thread_get_trace_fork_join)())
    645    {
    646       DRD_(trace_msg)("drd_pre_thread_create creator = %u, created = %u",
    647                       drd_creator, created);
    648    }
    649 }
    650 
    651 /**
    652  * Called by Valgrind's core before any loads or stores are performed on
    653  * the context of thread "created".
    654  */
    655 static
    656 void drd_post_thread_create(const ThreadId vg_created)
    657 {
    658    DrdThreadId drd_created;
    659    Addr stack_max;
    660 
    661    tl_assert(vg_created != VG_INVALID_THREADID);
    662 
    663    drd_created = DRD_(thread_post_create)(vg_created);
    664 
    665    /* Set up red zone before the code in glibc's clone.S is run. */
    666    stack_max = DRD_(thread_get_stack_max)(drd_created);
    667    drd_start_using_mem_stack2(drd_created, stack_max, 0);
    668 
    669    if (DRD_(thread_get_trace_fork_join)())
    670    {
    671       DRD_(trace_msg)("drd_post_thread_create created = %u", drd_created);
    672    }
    673    if (! DRD_(get_check_stack_accesses)())
    674    {
    675       DRD_(start_suppression)(DRD_(thread_get_stack_max)(drd_created)
    676                               - DRD_(thread_get_stack_size)(drd_created),
    677                               DRD_(thread_get_stack_max)(drd_created),
    678                               "stack");
    679    }
    680 }
    681 
    682 /* Called after a thread has performed its last memory access. */
    683 static void drd_thread_finished(ThreadId vg_tid)
    684 {
    685    DrdThreadId drd_tid;
    686 
    687    /*
    688     * Ignore if invoked because thread creation failed. See e.g.
    689     * coregrind/m_syswrap/syswrap-amd64-linux.c
    690     */
    691    if (VG_(get_running_tid)() != vg_tid)
    692       return;
    693 
    694    drd_tid = DRD_(VgThreadIdToDrdThreadId)(vg_tid);
    695    tl_assert(drd_tid != DRD_INVALID_THREADID);
    696    if (DRD_(thread_get_trace_fork_join)())
    697    {
    698       DRD_(trace_msg)("drd_thread_finished tid = %u%s", drd_tid,
    699                       DRD_(thread_get_joinable)(drd_tid)
    700                       ? "" : " (which is a detached thread)");
    701    }
    702    if (s_show_stack_usage && !VG_(clo_xml)) {
    703       const SizeT stack_size = DRD_(thread_get_stack_size)(drd_tid);
    704       const SizeT used_stack
    705          = (DRD_(thread_get_stack_max)(drd_tid)
    706             - DRD_(thread_get_stack_min_min)(drd_tid));
    707       VG_(message)(Vg_UserMsg,
    708                    "thread %u%s finished and used %lu bytes out of %lu"
    709                    " on its stack. Margin: %lu bytes.\n",
    710                    drd_tid,
    711                    DRD_(thread_get_joinable)(drd_tid)
    712                    ? "" : " (which is a detached thread)",
    713                    used_stack, stack_size, stack_size - used_stack);
    714 
    715    }
    716    drd_stop_using_mem(DRD_(thread_get_stack_min)(drd_tid),
    717                       DRD_(thread_get_stack_max)(drd_tid)
    718                       - DRD_(thread_get_stack_min)(drd_tid),
    719                       True);
    720    DRD_(thread_set_record_loads)(drd_tid, False);
    721    DRD_(thread_set_record_stores)(drd_tid, False);
    722    DRD_(thread_finished)(drd_tid);
    723 }
    724 
    725 /*
    726  * Called immediately after fork for the child process only. 'tid' is the
    727  * only surviving thread in the child process. Cleans up thread state.
    728  * See also http://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_atfork.html for a detailed discussion of using fork() in combination with mutexes.
    729  */
    730 static
    731 void drd__atfork_child(ThreadId tid)
    732 {
    733    DRD_(drd_thread_atfork_child)(tid);
    734 }
    735 
    736 
    737 //
    738 // Implementation of the tool interface.
    739 //
    740 
    741 static void DRD_(post_clo_init)(void)
    742 {
    743 #if defined(VGO_linux) || defined(VGO_darwin) || defined(VGO_solaris)
    744    /* fine */
    745 #else
    746    VG_(printf)("\nWARNING: DRD has not yet been tested on this operating system.\n\n");
    747 #  endif
    748 
    749    if (s_var_info)
    750    {
    751       VG_(needs_var_info)();
    752    }
    753 }
    754 
    755 static void drd_start_client_code(const ThreadId tid, const ULong bbs_done)
    756 {
    757    tl_assert(tid == VG_(get_running_tid)());
    758    DRD_(thread_set_vg_running_tid)(tid);
    759 }
    760 
    761 static void DRD_(fini)(Int exitcode)
    762 {
    763    // thread_print_all();
    764    if (VG_(clo_verbosity) == 1 && !VG_(clo_xml)) {
    765       VG_(message)(Vg_UserMsg, "For counts of detected and suppressed errors, "
    766                    "rerun with: -v\n");
    767    }
    768 
    769    if ((VG_(clo_stats) || s_print_stats) && !VG_(clo_xml))
    770    {
    771       ULong pu = DRD_(thread_get_update_conflict_set_count)();
    772       ULong pu_seg_cr = DRD_(thread_get_update_conflict_set_new_sg_count)();
    773       ULong pu_mtx_cv = DRD_(thread_get_update_conflict_set_sync_count)();
    774       ULong pu_join   = DRD_(thread_get_update_conflict_set_join_count)();
    775 
    776       VG_(message)(Vg_UserMsg,
    777                    "   thread: %llu context switches.\n",
    778                    DRD_(thread_get_context_switch_count)());
    779       VG_(message)(Vg_UserMsg,
    780                    "confl set: %llu full updates and %llu partial updates;\n",
    781                    DRD_(thread_get_compute_conflict_set_count)(),
    782                    pu);
    783       VG_(message)(Vg_UserMsg,
    784                    "           %llu partial updates during segment creation,\n",
    785                    pu_seg_cr);
    786       VG_(message)(Vg_UserMsg,
    787                    "           %llu because of mutex/sema/cond.var. operations,\n",
    788                    pu_mtx_cv);
    789       VG_(message)(Vg_UserMsg,
    790                    "           %llu because of barrier/rwlock operations and\n",
    791 		   pu - pu_seg_cr - pu_mtx_cv - pu_join);
    792       VG_(message)(Vg_UserMsg,
    793                    "           %llu partial updates because of thread join"
    794                    " operations.\n",
    795                    pu_join);
    796       VG_(message)(Vg_UserMsg,
    797                    " segments: created %llu segments, max %llu alive,\n",
    798                    DRD_(sg_get_segments_created_count)(),
    799                    DRD_(sg_get_max_segments_alive_count)());
    800       VG_(message)(Vg_UserMsg,
    801                    "           %llu discard points and %llu merges.\n",
    802                    DRD_(thread_get_discard_ordered_segments_count)(),
    803                    DRD_(sg_get_segment_merge_count)());
    804       VG_(message)(Vg_UserMsg,
    805                    "segmnt cr: %llu mutex, %llu rwlock, %llu semaphore and"
    806                    " %llu barrier.\n",
    807                    DRD_(get_mutex_segment_creation_count)(),
    808                    DRD_(get_rwlock_segment_creation_count)(),
    809                    DRD_(get_semaphore_segment_creation_count)(),
    810                    DRD_(get_barrier_segment_creation_count)());
    811       VG_(message)(Vg_UserMsg,
    812                    "  bitmaps: %llu level one"
    813                    " and %llu level two bitmaps were allocated.\n",
    814                    DRD_(bm_get_bitmap_creation_count)(),
    815                    DRD_(bm_get_bitmap2_creation_count)());
    816       VG_(message)(Vg_UserMsg,
    817                    "    mutex: %llu non-recursive lock/unlock events.\n",
    818                    DRD_(get_mutex_lock_count)());
    819       DRD_(print_malloc_stats)();
    820    }
    821 
    822    DRD_(bm_module_cleanup)();
    823 }
    824 
    825 static
    826 void drd_pre_clo_init(void)
    827 {
    828    // Basic tool stuff.
    829    VG_(details_name)            ("drd");
    830    VG_(details_version)         (NULL);
    831    VG_(details_description)     ("a thread error detector");
    832    VG_(details_copyright_author)("Copyright (C) 2006-2015, and GNU GPL'd,"
    833                                  " by Bart Van Assche.");
    834    VG_(details_bug_reports_to)  (VG_BUGS_TO);
    835 
    836    VG_(basic_tool_funcs)        (DRD_(post_clo_init),
    837                                  DRD_(instrument),
    838                                  DRD_(fini));
    839 
    840    // Command line stuff.
    841    VG_(needs_command_line_options)(DRD_(process_cmd_line_option),
    842                                    DRD_(print_usage),
    843                                    DRD_(print_debug_usage));
    844    VG_(needs_xml_output)          ();
    845 
    846    // Error handling.
    847    DRD_(register_error_handlers)();
    848 
    849    // Core event tracking.
    850    VG_(track_pre_mem_read)         (drd_pre_mem_read);
    851    VG_(track_pre_mem_read_asciiz)  (drd_pre_mem_read_asciiz);
    852    VG_(track_post_mem_write)       (drd_post_mem_write);
    853    VG_(track_new_mem_brk)          (drd_start_using_mem_w_tid);
    854    VG_(track_new_mem_mmap)         (drd_start_using_mem_w_perms);
    855    VG_(track_new_mem_stack)        (drd_start_using_mem_stack);
    856    VG_(track_new_mem_stack_signal) (drd_start_using_mem_stack_signal);
    857    VG_(track_new_mem_startup)      (drd_start_using_mem_w_perms);
    858    VG_(track_die_mem_brk)          (drd_stop_using_nonstack_mem);
    859    VG_(track_die_mem_munmap)       (drd_stop_using_nonstack_mem);
    860    VG_(track_die_mem_stack)        (drd_stop_using_mem_stack);
    861    VG_(track_die_mem_stack_signal) (drd_stop_using_mem_stack_signal);
    862    VG_(track_pre_deliver_signal)   (drd_pre_deliver_signal);
    863    VG_(track_post_deliver_signal)  (drd_post_deliver_signal);
    864    VG_(track_start_client_code)    (drd_start_client_code);
    865    VG_(track_pre_thread_ll_create) (drd_pre_thread_create);
    866    VG_(track_pre_thread_first_insn)(drd_post_thread_create);
    867    VG_(track_pre_thread_ll_exit)   (drd_thread_finished);
    868    VG_(atfork)                     (NULL/*pre*/, NULL/*parent*/,
    869 				    drd__atfork_child/*child*/);
    870 
    871    // Other stuff.
    872    DRD_(register_malloc_wrappers)(drd_start_using_mem_w_ecu,
    873                                   drd_stop_using_nonstack_mem);
    874 
    875    DRD_(bm_module_init)();
    876 
    877    DRD_(clientreq_init)();
    878 
    879    DRD_(suppression_init)();
    880 
    881    DRD_(clientobj_init)();
    882 
    883    DRD_(thread_init)();
    884 
    885    {
    886       HChar* const smi = VG_(getenv)("DRD_SEGMENT_MERGING_INTERVAL");
    887       if (smi)
    888          DRD_(thread_set_segment_merge_interval)(VG_(strtoll10)(smi, NULL));
    889    }
    890 
    891    if (VG_(getenv)("DRD_VERIFY_CONFLICT_SET"))
    892       DRD_(verify_conflict_set) = True;
    893 
    894 }
    895 
    896 
    897 VG_DETERMINE_INTERFACE_VERSION(drd_pre_clo_init)
    898