1 /*
2 This file is part of drd, a thread error detector.
3
4 Copyright (C) 2006-2012 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_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 */
sg_init(Segment * const sg,const DrdThreadId creator,const DrdThreadId created)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 char* 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(). */
DRD_(sg_cleanup)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. */
DRD_(sg_new)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
DRD_(sg_delete)137 static void DRD_(sg_delete)(Segment* const sg)
138 {
139 if (DRD_(sg_get_trace)())
140 {
141 char* 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. */
DRD_(sg_get)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 */
DRD_(sg_put)175 void DRD_(sg_put)(Segment* const sg)
176 {
177 if (sg == 0)
178 return;
179
180 if (s_trace_segment)
181 {
182 char* 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. */
DRD_(sg_merge)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 char *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. */
DRD_(sg_print)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. */
DRD_(sg_get_trace)239 Bool DRD_(sg_get_trace)(void)
240 {
241 return s_trace_segment;
242 }
243
244 /** Enable or disable segment tracing. */
DRD_(sg_set_trace)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
DRD_(sg_get_segments_created_count)251 ULong DRD_(sg_get_segments_created_count)(void)
252 {
253 return s_segments_created_count;
254 }
255
DRD_(sg_get_segments_alive_count)256 ULong DRD_(sg_get_segments_alive_count)(void)
257 {
258 return s_segments_alive_count;
259 }
260
DRD_(sg_get_max_segments_alive_count)261 ULong DRD_(sg_get_max_segments_alive_count)(void)
262 {
263 return s_max_segments_alive_count;
264 }
265
DRD_(sg_get_segment_merge_count)266 ULong DRD_(sg_get_segment_merge_count)(void)
267 {
268 return s_segment_merge_count;
269 }
270