1 /*
2 This file is part of drd, a thread error detector.
3
4 Copyright (C) 2006-2013 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 #ifndef __THREAD_H
26 #define __THREAD_H
27
28
29 /* Include directives. */
30
31 #include "drd_basics.h"
32 #include "drd_segment.h"
33 #include "pub_drd_bitmap.h"
34 #include "pub_tool_libcassert.h" /* tl_assert() */
35 #include "pub_tool_stacktrace.h" /* typedef StackTrace */
36 #include "pub_tool_threadstate.h" /* VG_N_THREADS */
37
38
39 /* Defines. */
40
41 /** Maximum number of threads DRD keeps information about. */
42 #define DRD_N_THREADS VG_N_THREADS
43
44 /** A number different from any valid DRD thread ID. */
45 #define DRD_INVALID_THREADID 0
46
47 /**
48 * A number different from any valid POSIX thread ID.
49 *
50 * @note The PThreadId typedef and the INVALID_POSIX_THREADID depend on the
51 * operating system and threading library in use. PThreadId must contain at
52 * least as many bits as pthread_t, and INVALID_POSIX_THREADID
53 * must be a value that will never be returned by pthread_self().
54 */
55 #define INVALID_POSIX_THREADID ((PThreadId)0)
56
57
58 /* Type definitions. */
59
60 /**
61 * POSIX thread ID. The type PThreadId must be at least as wide as
62 * pthread_t.
63 */
64 typedef UWord PThreadId;
65
66 /** Per-thread information managed by DRD. */
67 typedef struct
68 {
69 struct segment* sg_first;/**< Segment list. */
70 struct segment* sg_last;
71 ThreadId vg_threadid; /**< Valgrind thread ID. */
72 PThreadId pt_threadid; /**< POSIX thread ID. */
73 Addr stack_min_min; /**< Lowest value stack pointer ever had. */
74 Addr stack_min; /**< Current stack pointer. */
75 Addr stack_startup; /**<Stack pointer after pthread_create() finished.*/
76 Addr stack_max; /**< Top of stack. */
77 SizeT stack_size; /**< Maximum size of stack. */
78 HChar name[64]; /**< User-assigned thread name. */
79 Bool on_alt_stack;
80 /** Whether this structure contains valid information. */
81 Bool valid;
82 /** Indicates whether the Valgrind core knows about this thread. */
83 Bool vg_thread_exists;
84 /** Indicates whether there is an associated POSIX thread ID. */
85 Bool posix_thread_exists;
86 /**
87 * If true, indicates that there is a corresponding POSIX thread ID and
88 * a corresponding OS thread that is detached.
89 */
90 Bool detached_posix_thread;
91 /** Wether recording of memory load accesses is currently enabled. */
92 Bool is_recording_loads;
93 /** Wether recording of memory load accesses is currently enabled. */
94 Bool is_recording_stores;
95 /** pthread_create() nesting level. */
96 Int pthread_create_nesting_level;
97 /** Nesting level of synchronization functions called by the client. */
98 Int synchr_nesting;
99 /** Delayed thread deletion sequence number. */
100 unsigned deletion_seq;
101 } ThreadInfo;
102
103
104 /*
105 * Local variables of drd_thread.c that are declared here such that these
106 * can be accessed by inline functions.
107 */
108
109 /**
110 * DRD thread ID of the currently running thread. It is crucial for correct
111 * operation of DRD that this number is always in sync with
112 * VG_(get_running_tid)().
113 */
114 extern DrdThreadId DRD_(g_drd_running_tid);
115 /** Per-thread information managed by DRD. */
116 extern ThreadInfo* DRD_(g_threadinfo);
117 /** Conflict set for the currently running thread. */
118 extern struct bitmap* DRD_(g_conflict_set);
119 extern Bool DRD_(verify_conflict_set);
120
121
122 /* Function declarations. */
123
124 void DRD_(thread_trace_context_switches)(const Bool t);
125 void DRD_(thread_trace_conflict_set)(const Bool t);
126 void DRD_(thread_trace_conflict_set_bm)(const Bool t);
127 Bool DRD_(thread_get_trace_fork_join)(void);
128 void DRD_(thread_set_trace_fork_join)(const Bool t);
129 void DRD_(thread_set_segment_merging)(const Bool m);
130 int DRD_(thread_get_segment_merge_interval)(void);
131 void DRD_(thread_set_segment_merge_interval)(const int i);
132 void DRD_(thread_set_join_list_vol)(const int jlv);
133
134 void DRD_(thread_init)(void);
135 DrdThreadId DRD_(VgThreadIdToDrdThreadId)(const ThreadId tid);
136 DrdThreadId DRD_(NewVgThreadIdToDrdThreadId)(const ThreadId tid);
137 DrdThreadId DRD_(PtThreadIdToDrdThreadId)(const PThreadId tid);
138 ThreadId DRD_(DrdThreadIdToVgThreadId)(const DrdThreadId tid);
139 DrdThreadId DRD_(thread_pre_create)(const DrdThreadId creator,
140 const ThreadId vg_created);
141 DrdThreadId DRD_(thread_post_create)(const ThreadId vg_created);
142 void DRD_(thread_post_join)(DrdThreadId drd_joiner, DrdThreadId drd_joinee);
143 void DRD_(thread_delete)(const DrdThreadId tid, Bool detached);
144 void DRD_(thread_finished)(const DrdThreadId tid);
145 void DRD_(drd_thread_atfork_child)(const DrdThreadId tid);
146 void DRD_(thread_pre_cancel)(const DrdThreadId tid);
147 void DRD_(thread_set_stack_startup)(const DrdThreadId tid,
148 const Addr stack_startup);
149 Addr DRD_(thread_get_stack_min)(const DrdThreadId tid);
150 Addr DRD_(thread_get_stack_min_min)(const DrdThreadId tid);
151 Addr DRD_(thread_get_stack_max)(const DrdThreadId tid);
152 SizeT DRD_(thread_get_stack_size)(const DrdThreadId tid);
153 Bool DRD_(thread_get_on_alt_stack)(const DrdThreadId tid);
154 void DRD_(thread_set_on_alt_stack)(const DrdThreadId tid,
155 const Bool on_alt_stack);
156 Int DRD_(thread_get_threads_on_alt_stack)(void);
157 void DRD_(thread_set_pthreadid)(const DrdThreadId tid, const PThreadId ptid);
158 Bool DRD_(thread_get_joinable)(const DrdThreadId tid);
159 void DRD_(thread_set_joinable)(const DrdThreadId tid, const Bool joinable);
160 void DRD_(thread_entering_pthread_create)(const DrdThreadId tid);
161 void DRD_(thread_left_pthread_create)(const DrdThreadId tid);
162 const HChar* DRD_(thread_get_name)(const DrdThreadId tid);
163 void DRD_(thread_set_name)(const DrdThreadId tid, const HChar* const name);
164 void DRD_(thread_set_vg_running_tid)(const ThreadId vg_tid);
165 void DRD_(thread_set_running_tid)(const ThreadId vg_tid,
166 const DrdThreadId drd_tid);
167 int DRD_(thread_enter_synchr)(const DrdThreadId tid);
168 int DRD_(thread_leave_synchr)(const DrdThreadId tid);
169 int DRD_(thread_get_synchr_nesting_count)(const DrdThreadId tid);
170 void DRD_(thread_new_segment)(const DrdThreadId tid);
171 VectorClock* DRD_(thread_get_vc)(const DrdThreadId tid);
172 void DRD_(thread_get_latest_segment)(Segment** sg, const DrdThreadId tid);
173 void DRD_(thread_combine_vc_join)(const DrdThreadId joiner,
174 const DrdThreadId joinee);
175 void DRD_(thread_new_segment_and_combine_vc)(DrdThreadId tid,
176 const Segment* sg);
177 void DRD_(thread_update_conflict_set)(const DrdThreadId tid,
178 const VectorClock* const old_vc);
179
180 void DRD_(thread_stop_using_mem)(const Addr a1, const Addr a2);
181 void DRD_(thread_set_record_loads)(const DrdThreadId tid, const Bool enabled);
182 void DRD_(thread_set_record_stores)(const DrdThreadId tid, const Bool enabled);
183 void DRD_(thread_print_all)(void);
184 void DRD_(thread_report_races)(const DrdThreadId tid);
185 void DRD_(thread_report_races_segment)(const DrdThreadId tid,
186 const Segment* const p);
187 void DRD_(thread_report_all_races)(void);
188 void DRD_(thread_report_conflicting_segments)(const DrdThreadId tid,
189 const Addr addr,
190 const SizeT size,
191 const BmAccessTypeT access_type);
192 ULong DRD_(thread_get_context_switch_count)(void);
193 ULong DRD_(thread_get_report_races_count)(void);
194 ULong DRD_(thread_get_discard_ordered_segments_count)(void);
195 ULong DRD_(thread_get_compute_conflict_set_count)(void);
196 ULong DRD_(thread_get_update_conflict_set_count)(void);
197 ULong DRD_(thread_get_update_conflict_set_new_sg_count)(void);
198 ULong DRD_(thread_get_update_conflict_set_sync_count)(void);
199 ULong DRD_(thread_get_update_conflict_set_join_count)(void);
200 ULong DRD_(thread_get_conflict_set_bitmap_creation_count)(void);
201 ULong DRD_(thread_get_conflict_set_bitmap2_creation_count)(void);
202
203
204 /* Inline function definitions. */
205
206 /**
207 * Whether or not the specified DRD thread ID is valid.
208 *
209 * A DRD thread ID is valid if and only if the following conditions are met:
210 * - The ID is a valid index of the DRD_(g_threadinfo)[] array.
211 * - The ID is not equal to DRD_INVALID_THREADID.
212 * - The ID refers either to a thread known by the Valgrind core, a joinable
213 * thread that has not yet been joined or a detached thread.
214 */
215 static __inline__
DRD_(IsValidDrdThreadId)216 Bool DRD_(IsValidDrdThreadId)(const DrdThreadId tid)
217 {
218 return (0 <= (int)tid && tid < DRD_N_THREADS && tid != DRD_INVALID_THREADID
219 && (DRD_(g_threadinfo)[tid].valid));
220 }
221
222 /** Returns the DRD thread ID of the currently running thread. */
223 static __inline__
DRD_(thread_get_running_tid)224 DrdThreadId DRD_(thread_get_running_tid)(void)
225 {
226 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
227 tl_assert(DRD_(g_drd_running_tid) != DRD_INVALID_THREADID);
228 #endif
229 return DRD_(g_drd_running_tid);
230 }
231
232 /** Returns a pointer to the conflict set for the currently running thread. */
233 static __inline__
DRD_(thread_get_conflict_set)234 struct bitmap* DRD_(thread_get_conflict_set)(void)
235 {
236 return DRD_(g_conflict_set);
237 }
238
239 /**
240 * Reports whether or not the currently running client thread is executing code
241 * inside the pthread_create() function.
242 */
243 static __inline__
DRD_(running_thread_inside_pthread_create)244 Bool DRD_(running_thread_inside_pthread_create)(void)
245 {
246 return (DRD_(g_threadinfo)[DRD_(g_drd_running_tid)]
247 .pthread_create_nesting_level > 0);
248 }
249
250 /**
251 * Reports whether or not recording of memory loads is enabled for the
252 * currently running client thread.
253 */
254 static __inline__
DRD_(running_thread_is_recording_loads)255 Bool DRD_(running_thread_is_recording_loads)(void)
256 {
257 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
258 tl_assert(0 <= (int)DRD_(g_drd_running_tid)
259 && DRD_(g_drd_running_tid) < DRD_N_THREADS
260 && DRD_(g_drd_running_tid) != DRD_INVALID_THREADID);
261 #endif
262 return (DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].synchr_nesting == 0
263 && DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].is_recording_loads);
264 }
265
266 /**
267 * Reports whether or not recording memory stores is enabled for the
268 * currently running client thread.
269 */
270 static __inline__
DRD_(running_thread_is_recording_stores)271 Bool DRD_(running_thread_is_recording_stores)(void)
272 {
273 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
274 tl_assert(0 <= (int)DRD_(g_drd_running_tid)
275 && DRD_(g_drd_running_tid) < DRD_N_THREADS
276 && DRD_(g_drd_running_tid) != DRD_INVALID_THREADID);
277 #endif
278 return (DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].synchr_nesting == 0
279 && DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].is_recording_stores);
280 }
281
282 /**
283 * Update the information about the lowest stack address that has ever been
284 * accessed by a thread.
285 */
286 static __inline__
DRD_(thread_set_stack_min)287 void DRD_(thread_set_stack_min)(const DrdThreadId tid, const Addr stack_min)
288 {
289 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
290 tl_assert(0 <= (int)tid
291 && tid < DRD_N_THREADS
292 && tid != DRD_INVALID_THREADID);
293 #endif
294 DRD_(g_threadinfo)[tid].stack_min = stack_min;
295 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
296 /* This function can be called after the thread has been created but */
297 /* before drd_post_thread_create() has filled in stack_max. */
298 tl_assert(DRD_(g_threadinfo)[tid].stack_min
299 <= DRD_(g_threadinfo)[tid].stack_max
300 || DRD_(g_threadinfo)[tid].stack_max == 0);
301 #endif
302 if (UNLIKELY(stack_min < DRD_(g_threadinfo)[tid].stack_min_min))
303 {
304 DRD_(g_threadinfo)[tid].stack_min_min = stack_min;
305 }
306 }
307
308 /**
309 * Return true if and only if the specified address is on the stack of the
310 * currently scheduled thread.
311 */
312 static __inline__
DRD_(thread_address_on_stack)313 Bool DRD_(thread_address_on_stack)(const Addr a)
314 {
315 return (DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].stack_min <= a
316 && a < DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].stack_max);
317 }
318
319 /**
320 * Return true if and only if the specified address is on the stack of any
321 * thread.
322 */
323 static __inline__
DRD_(thread_address_on_any_stack)324 Bool DRD_(thread_address_on_any_stack)(const Addr a)
325 {
326 UInt i;
327
328 for (i = 1; i < DRD_N_THREADS; i++)
329 {
330 if (DRD_(g_threadinfo)[i].vg_thread_exists
331 && DRD_(g_threadinfo)[i].stack_min <= a
332 && a < DRD_(g_threadinfo)[i].stack_max)
333 {
334 return True;
335 }
336 }
337 return False;
338 }
339
340 /** Return a pointer to the latest segment for the specified thread. */
341 static __inline__
DRD_(thread_get_segment)342 Segment* DRD_(thread_get_segment)(const DrdThreadId tid)
343 {
344 #ifdef ENABLE_DRD_CONSISTENCY_CHECKS
345 tl_assert(0 <= (int)tid && tid < DRD_N_THREADS
346 && tid != DRD_INVALID_THREADID);
347 tl_assert(DRD_(g_threadinfo)[tid].sg_last);
348 #endif
349 return DRD_(g_threadinfo)[tid].sg_last;
350 }
351
352 /** Return a pointer to the latest segment for the running thread. */
353 static __inline__
DRD_(running_thread_get_segment)354 Segment* DRD_(running_thread_get_segment)(void)
355 {
356 return DRD_(thread_get_segment)(DRD_(g_drd_running_tid));
357 }
358
359 #endif /* __THREAD_H */
360