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
