drd/drd_clientobj.c

   1 /*
   2   This file is part of drd, a thread error detector.
   3
   4   Copyright (C) 2006-2017 Bart Van Assche <bvanassche@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 }