1 /* 2 This file is part of drd, a thread error detector. 3 4 Copyright (C) 2006-2013 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_error.h" 26 #include "drd_segment.h" 27 #include "drd_thread.h" 28 #include "pub_tool_basics.h" // Addr, SizeT 29 #include "pub_tool_libcassert.h" // tl_assert() 30 #include "pub_tool_libcbase.h" // VG_(strlen)() 31 #include "pub_tool_libcprint.h" // VG_(printf)() 32 #include "pub_tool_machine.h" // VG_(get_SP)() 33 #include "pub_tool_mallocfree.h" // VG_(malloc)(), VG_(free)() 34 #include "pub_tool_threadstate.h" // VG_INVALID_THREADID 35 36 37 /* Global variables. */ 38 39 Segment* DRD_(g_sg_list); 40 41 42 /* Local variables. */ 43 44 static ULong s_segment_merge_count; 45 static ULong s_segments_created_count; 46 static ULong s_segments_alive_count; 47 static ULong s_max_segments_alive_count; 48 static Bool s_trace_segment; 49 50 51 /* Function definitions. */ 52 53 /** 54 * Initialize the memory 'sg' points at. 55 * 56 * @note The creator and created thread ID's may be equal. 57 * @note This function copies the vector clock of thread 'creator', a technique 58 * also known as clock snooping. This will only work reliably if the thread 59 * that called pthread_create() waits until the created thread has copied 60 * the vector clock. 61 */ 62 static void sg_init(Segment* const sg, 63 const DrdThreadId creator, 64 const DrdThreadId created) 65 { 66 Segment* creator_sg; 67 ThreadId vg_created = DRD_(DrdThreadIdToVgThreadId)(created); 68 69 tl_assert(sg); 70 tl_assert(creator == DRD_INVALID_THREADID 71 || DRD_(IsValidDrdThreadId)(creator)); 72 73 creator_sg = (creator != DRD_INVALID_THREADID 74 ? DRD_(thread_get_segment)(creator) : 0); 75 76 sg->g_next = NULL; 77 sg->g_prev = NULL; 78 sg->thr_next = NULL; 79 sg->thr_prev = NULL; 80 sg->tid = created; 81 sg->refcnt = 1; 82 83 if (vg_created != VG_INVALID_THREADID && VG_(get_SP)(vg_created) != 0) 84 sg->stacktrace = VG_(record_ExeContext)(vg_created, 0); 85 else 86 sg->stacktrace = 0; 87 88 if (creator_sg) 89 DRD_(vc_copy)(&sg->vc, &creator_sg->vc); 90 else 91 DRD_(vc_init)(&sg->vc, 0, 0); 92 DRD_(vc_increment)(&sg->vc, created); 93 DRD_(bm_init)(&sg->bm); 94 95 if (s_trace_segment) 96 { 97 HChar* vc; 98 99 vc = DRD_(vc_aprint)(&sg->vc); 100 VG_(message)(Vg_DebugMsg, "New segment for thread %d with vc %s\n", 101 created, vc); 102 VG_(free)(vc); 103 } 104 } 105 106 /** Deallocate the memory that was allocated by sg_init(). */ 107 static void DRD_(sg_cleanup)(Segment* const sg) 108 { 109 tl_assert(sg); 110 tl_assert(sg->refcnt == 0); 111 112 DRD_(vc_cleanup)(&sg->vc); 113 DRD_(bm_cleanup)(&sg->bm); 114 } 115 116 /** Allocate and initialize a new segment. */ 117 Segment* DRD_(sg_new)(const DrdThreadId creator, const DrdThreadId created) 118 { 119 Segment* sg; 120 121 s_segments_created_count++; 122 s_segments_alive_count++; 123 if (s_max_segments_alive_count < s_segments_alive_count) 124 s_max_segments_alive_count = s_segments_alive_count; 125 126 sg = VG_(malloc)("drd.segment.sn.1", sizeof(*sg)); 127 tl_assert(sg); 128 sg_init(sg, creator, created); 129 if (DRD_(g_sg_list)) { 130 DRD_(g_sg_list)->g_prev = sg; 131 sg->g_next = DRD_(g_sg_list); 132 } 133 DRD_(g_sg_list) = sg; 134 return sg; 135 } 136 137 static void DRD_(sg_delete)(Segment* const sg) 138 { 139 if (DRD_(sg_get_trace)()) 140 { 141 HChar* vc; 142 143 vc = DRD_(vc_aprint)(&sg->vc); 144 VG_(message)(Vg_DebugMsg, "Discarding the segment with vector clock %s\n", 145 vc); 146 VG_(free)(vc); 147 } 148 149 s_segments_alive_count--; 150 151 tl_assert(sg); 152 if (sg->g_next) 153 sg->g_next->g_prev = sg->g_prev; 154 if (sg->g_prev) 155 sg->g_prev->g_next = sg->g_next; 156 else 157 DRD_(g_sg_list) = sg->g_next; 158 DRD_(sg_cleanup)(sg); 159 VG_(free)(sg); 160 } 161 162 /** Increment the reference count of the specified segment. */ 163 Segment* DRD_(sg_get)(Segment* const sg) 164 { 165 tl_assert(sg); 166 167 sg->refcnt++; 168 return sg; 169 } 170 171 /** 172 * Decrement the reference count of the specified segment and deallocate the 173 * segment if the reference count became zero. 174 */ 175 void DRD_(sg_put)(Segment* const sg) 176 { 177 if (sg == 0) 178 return; 179 180 if (s_trace_segment) 181 { 182 HChar* vc; 183 184 vc = DRD_(vc_aprint)(&sg->vc); 185 VG_(message)(Vg_DebugMsg, 186 "Decrementing segment reference count %d -> %d with vc %s\n", 187 sg->refcnt, sg->refcnt - 1, vc); 188 VG_(free)(vc); 189 } 190 191 tl_assert(sg->refcnt >= 1); 192 193 if (--sg->refcnt == 0) 194 { 195 DRD_(sg_delete)(sg); 196 } 197 } 198 199 /** Merge sg1 and sg2 into sg1. */ 200 void DRD_(sg_merge)(Segment* const sg1, Segment* const sg2) 201 { 202 tl_assert(sg1); 203 tl_assert(sg1->refcnt == 1); 204 tl_assert(sg2); 205 tl_assert(sg2->refcnt == 1); 206 207 if (s_trace_segment) 208 { 209 HChar *vc1, *vc2; 210 211 vc1 = DRD_(vc_aprint)(&sg1->vc); 212 vc2 = DRD_(vc_aprint)(&sg2->vc); 213 214 VG_(message)(Vg_DebugMsg, 215 "Merging segments with vector clocks %s and %s\n", vc1, vc2); 216 VG_(free)(vc1); 217 VG_(free)(vc2); 218 } 219 220 s_segment_merge_count++; 221 222 // Keep sg1->stacktrace. 223 // Keep sg1->vc. 224 // Merge sg2->bm into sg1->bm. 225 DRD_(bm_merge2)(&sg1->bm, &sg2->bm); 226 } 227 228 /** Print the vector clock and the bitmap of the specified segment. */ 229 void DRD_(sg_print)(Segment* const sg) 230 { 231 tl_assert(sg); 232 VG_(printf)("vc: "); 233 DRD_(vc_print)(&sg->vc); 234 VG_(printf)("\n"); 235 DRD_(bm_print)(&sg->bm); 236 } 237 238 /** Query whether segment tracing has been enabled. */ 239 Bool DRD_(sg_get_trace)(void) 240 { 241 return s_trace_segment; 242 } 243 244 /** Enable or disable segment tracing. */ 245 void DRD_(sg_set_trace)(Bool const trace_segment) 246 { 247 tl_assert(trace_segment == False || trace_segment == True); 248 s_trace_segment = trace_segment; 249 } 250 251 ULong DRD_(sg_get_segments_created_count)(void) 252 { 253 return s_segments_created_count; 254 } 255 256 ULong DRD_(sg_get_segments_alive_count)(void) 257 { 258 return s_segments_alive_count; 259 } 260 261 ULong DRD_(sg_get_max_segments_alive_count)(void) 262 { 263 return s_max_segments_alive_count; 264 } 265 266 ULong DRD_(sg_get_segment_merge_count)(void) 267 { 268 return s_segment_merge_count; 269 } 270
