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_clientobj.h"
     26 #include "drd_error.h"
     27 #include "drd_suppression.h"
     28 #include "pub_tool_basics.h"
     29 #include "pub_tool_libcassert.h"
     30 #include "pub_tool_libcbase.h"
     31 #include "pub_tool_libcprint.h"   // VG_(message)()
     32 #include "pub_tool_mallocfree.h"
     33 #include "pub_tool_options.h"     // VG_(clo_backtrace_size)
     34 #include "pub_tool_oset.h"
     35 #include "pub_tool_stacktrace.h"
     36 #include "pub_tool_threadstate.h" // VG_(get_running_tid)()
     37 
     38 
     39 /* Local variables. */
     40 
     41 static OSet* s_clientobj_set;
     42 static Bool s_trace_clientobj;
     43 
     44 
     45 /* Local functions. */
     46 
     47 static Bool clientobj_remove_obj(DrdClientobj* const p);
     48 
     49 
     50 /* Function definitions. */
     51 
     52 void DRD_(clientobj_set_trace)(const Bool trace)
     53 {
     54    s_trace_clientobj = trace;
     55 }
     56 
     57 /** Initialize the client object set. */
     58 void DRD_(clientobj_init)(void)
     59 {
     60    tl_assert(s_clientobj_set == 0);
     61    s_clientobj_set = VG_(OSetGen_Create)(0, 0, VG_(malloc),
     62                                          "drd.clientobj.ci.1", VG_(free));
     63 }
     64 
     65 /**
     66  * Free the memory allocated for the client object set.
     67  *
     68  * @pre Client object set is empty.
     69  */
     70 void DRD_(clientobj_cleanup)(void)
     71 {
     72    tl_assert(s_clientobj_set);
     73    tl_assert(VG_(OSetGen_Size)(s_clientobj_set) == 0);
     74    VG_(OSetGen_Destroy)(s_clientobj_set);
     75    s_clientobj_set = 0;
     76 }
     77 
     78 /**
     79  * Return the data associated with the client object at client address addr.
     80  * Return 0 if there is no client object in the set with the specified start
     81  * address.
     82  */
     83 DrdClientobj* DRD_(clientobj_get_any)(const Addr addr)
     84 {
     85    return VG_(OSetGen_Lookup)(s_clientobj_set, &addr);
     86 }
     87 
     88 /**
     89  * Return the data associated with the client object at client address addr
     90  * and that has object type t. Return 0 if there is no client object in the
     91  * set with the specified start address.
     92  */
     93 DrdClientobj* DRD_(clientobj_get)(const Addr addr, const ObjType t)
     94 {
     95    DrdClientobj* p;
     96    p = VG_(OSetGen_Lookup)(s_clientobj_set, &addr);
     97    if (p && p->any.type == t)
     98       return p;
     99    return 0;
    100 }
    101 
    102 /** Return true if and only if the address range of any client object overlaps
    103  *  with the specified address range.
    104  */
    105 Bool DRD_(clientobj_present)(const Addr a1, const Addr a2)
    106 {
    107    DrdClientobj *p;
    108 
    109    tl_assert(a1 <= a2);
    110    VG_(OSetGen_ResetIter)(s_clientobj_set);
    111    for ( ; (p = VG_(OSetGen_Next)(s_clientobj_set)) != 0; )
    112    {
    113       if (a1 <= p->any.a1 && p->any.a1 < a2)
    114       {
    115          return True;
    116       }
    117    }
    118    return False;
    119 }
    120 
    121 /**
    122  * Add state information for the client object at client address addr and
    123  * of type t. Suppress data race reports on the address range [addr,addr+size[.
    124  *
    125  * @pre No other client object is present in the address range [addr,addr+size[.
    126  */
    127 DrdClientobj* DRD_(clientobj_add)(const Addr a1, const ObjType t)
    128 {
    129    DrdClientobj* p;
    130 
    131    tl_assert(! DRD_(clientobj_present)(a1, a1 + 1));
    132    tl_assert(VG_(OSetGen_Lookup)(s_clientobj_set, &a1) == 0);
    133 
    134    if (s_trace_clientobj)
    135      DRD_(trace_msg)("Adding client object 0x%lx of type %d", a1, (Int)t);
    136 
    137    p = VG_(OSetGen_AllocNode)(s_clientobj_set, sizeof(*p));
    138    VG_(memset)(p, 0, sizeof(*p));
    139    p->any.a1   = a1;
    140    p->any.type = t;
    141    p->any.first_observed_at = VG_(record_ExeContext)(VG_(get_running_tid)(), 0);
    142    VG_(OSetGen_Insert)(s_clientobj_set, p);
    143    tl_assert(VG_(OSetGen_Lookup)(s_clientobj_set, &a1) == p);
    144    if (t == ClientHbvar)
    145       DRD_(mark_hbvar)(a1);
    146    else
    147       DRD_(start_suppression)(a1, a1 + 1, "clientobj");
    148    return p;
    149 }
    150 
    151 /**
    152  * Remove the information that was stored about the client object.
    153  *
    154  * @param[in] addr Address of the client object in the client address space.
    155  * @param[in] t    Type of the client object.
    156  */
    157 Bool DRD_(clientobj_remove)(const Addr addr, const ObjType t)
    158 {
    159    DrdClientobj* p;
    160 
    161    p = VG_(OSetGen_Lookup)(s_clientobj_set, &addr);
    162    tl_assert(p);
    163    tl_assert(p->any.type == t);
    164    return clientobj_remove_obj(p);
    165 }
    166 
    167 /**
    168  * Remove the information that was stored about the client object p.
    169  *
    170  * @note The order of operations below is important. The client object is
    171  *   removed from the client object set after the cleanup function has been
    172  *   called such that if the cleanup function can still use the function
    173  *   DRD_(clientobj_get_any)(). This happens e.g. in the function
    174  *   first_observed() in drd_error.c.
    175  */
    176 static Bool clientobj_remove_obj(DrdClientobj* const p)
    177 {
    178    tl_assert(p);
    179 
    180    if (s_trace_clientobj) {
    181       DRD_(trace_msg)("Removing client object 0x%lx of type %d", p->any.a1,
    182                       (Int)p->any.type);
    183 #if 0
    184       VG_(get_and_pp_StackTrace)(VG_(get_running_tid)(),
    185                                  VG_(clo_backtrace_size));
    186 #endif
    187    }
    188 
    189    tl_assert(p->any.cleanup);
    190    (*p->any.cleanup)(p);
    191    VG_(OSetGen_Remove)(s_clientobj_set, &p->any.a1);
    192    VG_(OSetGen_FreeNode)(s_clientobj_set, p);
    193    return True;
    194 }
    195 
    196 /**
    197  * Clean up all client objects p for which their start address p->any.a1 fits
    198  * inside the address range [ a1, a2 [.
    199  *
    200  * @note The implementation of this function relies on the fact that the
    201  *   data in s_clientobj_set is sorted on the start address of client objects.
    202  */
    203 void DRD_(clientobj_stop_using_mem)(const Addr a1, const Addr a2)
    204 {
    205    Addr removed_at;
    206    DrdClientobj* p;
    207 
    208    tl_assert(s_clientobj_set);
    209 
    210    if (! DRD_(range_contains_suppression_or_hbvar)(a1, a2))
    211       return;
    212 
    213    VG_(OSetGen_ResetIterAt)(s_clientobj_set, &a1);
    214    for ( ; (p = VG_(OSetGen_Next)(s_clientobj_set)) != 0 && p->any.a1 < a2; )
    215    {
    216       tl_assert(a1 <= p->any.a1);
    217       removed_at = p->any.a1;
    218       clientobj_remove_obj(p);
    219       /*
    220        * The above call removes an element from the oset and hence
    221        * invalidates the iterator. Restore the iterator.
    222        */
    223       VG_(OSetGen_ResetIterAt)(s_clientobj_set, &removed_at);
    224    }
    225 }
    226 
    227 /**
    228  * Delete the per-thread information stored in client objects for the
    229  * specified thread.
    230  */
    231 void DRD_(clientobj_delete_thread)(const DrdThreadId tid)
    232 {
    233    DrdClientobj *p;
    234 
    235    VG_(OSetGen_ResetIter)(s_clientobj_set);
    236    for ( ; (p = VG_(OSetGen_Next)(s_clientobj_set)) != 0; )
    237    {
    238       if (p->any.delete_thread)
    239       {
    240          (*p->any.delete_thread)(p, tid);
    241       }
    242    }
    243 }
    244 
    245 const HChar* DRD_(clientobj_type_name)(const ObjType t)
    246 {
    247    switch (t)
    248    {
    249    case ClientMutex:     return "mutex";
    250    case ClientCondvar:   return "cond";
    251    case ClientHbvar:     return "order annotation";
    252    case ClientSemaphore: return "semaphore";
    253    case ClientBarrier:   return "barrier";
    254    case ClientRwlock:    return "rwlock";
    255    }
    256    return "(unknown)";
    257 }
    258