1 /*--------------------------------------------------------------------*/
2 /*--- Callgrind ---*/
3 /*--- ct_threads.c ---*/
4 /*--------------------------------------------------------------------*/
5
6 /*
7 This file is part of Callgrind, a Valgrind tool for call tracing.
8
9 Copyright (C) 2002-2011, Josef Weidendorfer (Josef.Weidendorfer@gmx.de)
10
11 This program is free software; you can redistribute it and/or
12 modify it under the terms of the GNU General Public License as
13 published by the Free Software Foundation; either version 2 of the
14 License, or (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful, but
17 WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
24 02111-1307, USA.
25
26 The GNU General Public License is contained in the file COPYING.
27 */
28
29 #include "global.h"
30
31 #include "pub_tool_threadstate.h"
32
33 /* forward decls */
34 static exec_state* exec_state_save(void);
35 static exec_state* exec_state_restore(void);
36 static exec_state* push_exec_state(int);
37 static exec_state* top_exec_state(void);
38
39 static exec_stack current_states;
40
41
42 /*------------------------------------------------------------*/
43 /*--- Support for multi-threading ---*/
44 /*------------------------------------------------------------*/
45
46
47 /*
48 * For Valgrind, MT is cooperative (no preemting in our code),
49 * so we don't need locks...
50 *
51 * Per-thread data:
52 * - BBCCs
53 * - call stack
54 * - call hash
55 * - event counters: last, current
56 *
57 * Even when ignoring MT, we need this functions to set up some
58 * datastructures for the process (= Thread 1).
59 */
60
61 /* current running thread */
62 ThreadId CLG_(current_tid);
63
64 static thread_info* thread[VG_N_THREADS];
65
CLG_(get_threads)66 thread_info** CLG_(get_threads)()
67 {
68 return thread;
69 }
70
CLG_(get_current_thread)71 thread_info* CLG_(get_current_thread)()
72 {
73 return thread[CLG_(current_tid)];
74 }
75
CLG_(init_threads)76 void CLG_(init_threads)()
77 {
78 Int i;
79 for(i=0;i<VG_N_THREADS;i++)
80 thread[i] = 0;
81 CLG_(current_tid) = VG_INVALID_THREADID;
82 }
83
84 /* switches through all threads and calls func */
CLG_(forall_threads)85 void CLG_(forall_threads)(void (*func)(thread_info*))
86 {
87 Int t, orig_tid = CLG_(current_tid);
88
89 for(t=1;t<VG_N_THREADS;t++) {
90 if (!thread[t]) continue;
91 CLG_(switch_thread)(t);
92 (*func)(thread[t]);
93 }
94 CLG_(switch_thread)(orig_tid);
95 }
96
97
98 static
new_thread(void)99 thread_info* new_thread(void)
100 {
101 thread_info* t;
102
103 t = (thread_info*) CLG_MALLOC("cl.threads.nt.1",
104 sizeof(thread_info));
105
106 /* init state */
107 CLG_(init_exec_stack)( &(t->states) );
108 CLG_(init_call_stack)( &(t->calls) );
109 CLG_(init_fn_stack) ( &(t->fns) );
110 /* t->states.entry[0]->cxt = CLG_(get_cxt)(t->fns.bottom); */
111
112 /* event counters */
113 t->lastdump_cost = CLG_(get_eventset_cost)( CLG_(sets).full );
114 t->sighandler_cost = CLG_(get_eventset_cost)( CLG_(sets).full );
115 CLG_(init_cost)( CLG_(sets).full, t->lastdump_cost );
116 CLG_(init_cost)( CLG_(sets).full, t->sighandler_cost );
117
118 /* init data containers */
119 CLG_(init_fn_array)( &(t->fn_active) );
120 CLG_(init_bbcc_hash)( &(t->bbccs) );
121 CLG_(init_jcc_hash)( &(t->jccs) );
122
123 return t;
124 }
125
126
CLG_(switch_thread)127 void CLG_(switch_thread)(ThreadId tid)
128 {
129 if (tid == CLG_(current_tid)) return;
130
131 CLG_DEBUG(0, ">> thread %d (was %d)\n", tid, CLG_(current_tid));
132
133 if (CLG_(current_tid) != VG_INVALID_THREADID) {
134 /* save thread state */
135 thread_info* t = thread[CLG_(current_tid)];
136
137 CLG_ASSERT(t != 0);
138
139 /* current context (including signal handler contexts) */
140 exec_state_save();
141 CLG_(copy_current_exec_stack)( &(t->states) );
142 CLG_(copy_current_call_stack)( &(t->calls) );
143 CLG_(copy_current_fn_stack) ( &(t->fns) );
144
145 CLG_(copy_current_fn_array) ( &(t->fn_active) );
146 /* If we cumulate costs of threads, use TID 1 for all jccs/bccs */
147 if (!CLG_(clo).separate_threads) t = thread[1];
148 CLG_(copy_current_bbcc_hash)( &(t->bbccs) );
149 CLG_(copy_current_jcc_hash) ( &(t->jccs) );
150 }
151
152 CLG_(current_tid) = tid;
153 CLG_ASSERT(tid < VG_N_THREADS);
154
155 if (tid != VG_INVALID_THREADID) {
156 thread_info* t;
157
158 /* load thread state */
159
160 if (thread[tid] == 0) thread[tid] = new_thread();
161 t = thread[tid];
162
163 /* current context (including signal handler contexts) */
164 CLG_(set_current_exec_stack)( &(t->states) );
165 exec_state_restore();
166 CLG_(set_current_call_stack)( &(t->calls) );
167 CLG_(set_current_fn_stack) ( &(t->fns) );
168
169 CLG_(set_current_fn_array) ( &(t->fn_active) );
170 /* If we cumulate costs of threads, use TID 1 for all jccs/bccs */
171 if (!CLG_(clo).separate_threads) t = thread[1];
172 CLG_(set_current_bbcc_hash) ( &(t->bbccs) );
173 CLG_(set_current_jcc_hash) ( &(t->jccs) );
174 }
175 }
176
177
CLG_(run_thread)178 void CLG_(run_thread)(ThreadId tid)
179 {
180 /* check for dumps needed */
181 static ULong bbs_done = 0;
182 static Char buf[512];
183
184 if (CLG_(clo).dump_every_bb >0) {
185 if (CLG_(stat).bb_executions - bbs_done > CLG_(clo).dump_every_bb) {
186 VG_(sprintf)(buf, "--dump-every-bb=%llu", CLG_(clo).dump_every_bb);
187 CLG_(dump_profile)(buf, False);
188 bbs_done = CLG_(stat).bb_executions;
189 }
190 }
191
192 CLG_(check_command)();
193
194 /* now check for thread switch */
195 CLG_(switch_thread)(tid);
196 }
197
CLG_(pre_signal)198 void CLG_(pre_signal)(ThreadId tid, Int sigNum, Bool alt_stack)
199 {
200 exec_state *es;
201
202 CLG_DEBUG(0, ">> pre_signal(TID %d, sig %d, alt_st %s)\n",
203 tid, sigNum, alt_stack ? "yes":"no");
204
205 /* switch to the thread the handler runs in */
206 CLG_(switch_thread)(tid);
207
208 /* save current execution state */
209 exec_state_save();
210
211 /* setup new cxtinfo struct for this signal handler */
212 es = push_exec_state(sigNum);
213 CLG_(zero_cost)( CLG_(sets).full, es->cost );
214 CLG_(current_state).cost = es->cost;
215 es->call_stack_bottom = CLG_(current_call_stack).sp;
216
217 /* setup current state for a spontaneous call */
218 CLG_(init_exec_state)( &CLG_(current_state) );
219 CLG_(current_state).sig = sigNum;
220 CLG_(push_cxt)(0);
221 }
222
223 /* Run post-signal if the stackpointer for call stack is at
224 * the bottom in current exec state (e.g. a signal handler)
225 *
226 * Called from CLG_(pop_call_stack)
227 */
CLG_(run_post_signal_on_call_stack_bottom)228 void CLG_(run_post_signal_on_call_stack_bottom)()
229 {
230 exec_state* es = top_exec_state();
231 CLG_ASSERT(es != 0);
232 CLG_ASSERT(CLG_(current_state).sig >0);
233
234 if (CLG_(current_call_stack).sp == es->call_stack_bottom)
235 CLG_(post_signal)( CLG_(current_tid), CLG_(current_state).sig );
236 }
237
CLG_(post_signal)238 void CLG_(post_signal)(ThreadId tid, Int sigNum)
239 {
240 exec_state* es;
241 UInt fn_number, *pactive;
242
243 CLG_DEBUG(0, ">> post_signal(TID %d, sig %d)\n",
244 tid, sigNum);
245
246 /* thread switching potentially needed, eg. with instrumentation off */
247 CLG_(switch_thread)(tid);
248 CLG_ASSERT(sigNum == CLG_(current_state).sig);
249
250 /* Unwind call stack of this signal handler.
251 * This should only be needed at finalisation time
252 */
253 es = top_exec_state();
254 CLG_ASSERT(es != 0);
255 while(CLG_(current_call_stack).sp > es->call_stack_bottom)
256 CLG_(pop_call_stack)();
257
258 if (CLG_(current_state).cxt) {
259 /* correct active counts */
260 fn_number = CLG_(current_state).cxt->fn[0]->number;
261 pactive = CLG_(get_fn_entry)(fn_number);
262 (*pactive)--;
263 CLG_DEBUG(0, " set active count of %s back to %d\n",
264 CLG_(current_state).cxt->fn[0]->name, *pactive);
265 }
266
267 if (CLG_(current_fn_stack).top > CLG_(current_fn_stack).bottom) {
268 /* set fn_stack_top back.
269 * top can point to 0 if nothing was executed in the signal handler;
270 * this is possible at end on unwinding handlers.
271 */
272 if (*(CLG_(current_fn_stack).top) != 0) {
273 CLG_(current_fn_stack).top--;
274 CLG_ASSERT(*(CLG_(current_fn_stack).top) == 0);
275 }
276 if (CLG_(current_fn_stack).top > CLG_(current_fn_stack).bottom)
277 CLG_(current_fn_stack).top--;
278 }
279
280 /* sum up costs */
281 CLG_ASSERT(CLG_(current_state).cost == es->cost);
282 CLG_(add_and_zero_cost)( CLG_(sets).full,
283 thread[CLG_(current_tid)]->sighandler_cost,
284 CLG_(current_state).cost );
285
286 /* restore previous context */
287 es->sig = -1;
288 current_states.sp--;
289 es = top_exec_state();
290 CLG_(current_state).sig = es->sig;
291 exec_state_restore();
292
293 /* There is no way to reliable get the thread ID we are switching to
294 * after this handler returns. So we sync with actual TID at start of
295 * CLG_(setup_bb)(), which should be the next for callgrind.
296 */
297 }
298
299
300
301 /*------------------------------------------------------------*/
302 /*--- Execution states in a thread & signal handlers ---*/
303 /*------------------------------------------------------------*/
304
305 /* Each thread can be interrupted by a signal handler, and they
306 * themselves again. But as there's no scheduling among handlers
307 * of the same thread, we don't need additional stacks.
308 * So storing execution contexts and
309 * adding separators in the callstack(needed to not intermix normal/handler
310 * functions in contexts) should be enough.
311 */
312
313 /* not initialized: call_stack_bottom, sig */
CLG_(init_exec_state)314 void CLG_(init_exec_state)(exec_state* es)
315 {
316 es->collect = CLG_(clo).collect_atstart;
317 es->cxt = 0;
318 es->jmps_passed = 0;
319 es->bbcc = 0;
320 es->nonskipped = 0;
321 }
322
323
new_exec_state(Int sigNum)324 static exec_state* new_exec_state(Int sigNum)
325 {
326 exec_state* es;
327 es = (exec_state*) CLG_MALLOC("cl.threads.nes.1",
328 sizeof(exec_state));
329
330 /* allocate real cost space: needed as incremented by
331 * simulation functions */
332 es->cost = CLG_(get_eventset_cost)(CLG_(sets).full);
333 CLG_(zero_cost)( CLG_(sets).full, es->cost );
334 CLG_(init_exec_state)(es);
335 es->sig = sigNum;
336 es->call_stack_bottom = 0;
337
338 return es;
339 }
340
CLG_(init_exec_stack)341 void CLG_(init_exec_stack)(exec_stack* es)
342 {
343 Int i;
344
345 /* The first element is for the main thread */
346 es->entry[0] = new_exec_state(0);
347 for(i=1;i<MAX_SIGHANDLERS;i++)
348 es->entry[i] = 0;
349 es->sp = 0;
350 }
351
CLG_(copy_current_exec_stack)352 void CLG_(copy_current_exec_stack)(exec_stack* dst)
353 {
354 Int i;
355
356 dst->sp = current_states.sp;
357 for(i=0;i<MAX_SIGHANDLERS;i++)
358 dst->entry[i] = current_states.entry[i];
359 }
360
CLG_(set_current_exec_stack)361 void CLG_(set_current_exec_stack)(exec_stack* dst)
362 {
363 Int i;
364
365 current_states.sp = dst->sp;
366 for(i=0;i<MAX_SIGHANDLERS;i++)
367 current_states.entry[i] = dst->entry[i];
368 }
369
370
371 /* Get top context info struct of current thread */
372 static
top_exec_state(void)373 exec_state* top_exec_state(void)
374 {
375 Int sp = current_states.sp;
376 exec_state* es;
377
378 CLG_ASSERT((sp >= 0) && (sp < MAX_SIGHANDLERS));
379 es = current_states.entry[sp];
380 CLG_ASSERT(es != 0);
381 return es;
382 }
383
384 /* Allocates a free context info structure for a new entered
385 * signal handler, putting it on the context stack.
386 * Returns a pointer to the structure.
387 */
push_exec_state(int sigNum)388 static exec_state* push_exec_state(int sigNum)
389 {
390 Int sp;
391 exec_state* es;
392
393 current_states.sp++;
394 sp = current_states.sp;
395
396 CLG_ASSERT((sigNum > 0) && (sigNum <= _VKI_NSIG));
397 CLG_ASSERT((sp > 0) && (sp < MAX_SIGHANDLERS));
398 es = current_states.entry[sp];
399 if (!es) {
400 es = new_exec_state(sigNum);
401 current_states.entry[sp] = es;
402 }
403 else
404 es->sig = sigNum;
405
406 return es;
407 }
408
409 /* Save current context to top cxtinfo struct */
410 static
exec_state_save(void)411 exec_state* exec_state_save(void)
412 {
413 exec_state* es = top_exec_state();
414
415 es->cxt = CLG_(current_state).cxt;
416 es->collect = CLG_(current_state).collect;
417 es->jmps_passed = CLG_(current_state).jmps_passed;
418 es->bbcc = CLG_(current_state).bbcc;
419 es->nonskipped = CLG_(current_state).nonskipped;
420 CLG_ASSERT(es->cost == CLG_(current_state).cost);
421
422 CLG_DEBUGIF(1) {
423 CLG_DEBUG(1, " cxtinfo_save(sig %d): collect %s, jmps_passed %d\n",
424 es->sig, es->collect ? "Yes": "No", es->jmps_passed);
425 CLG_(print_bbcc)(-9, es->bbcc);
426 CLG_(print_cost)(-9, CLG_(sets).full, es->cost);
427 }
428
429 /* signal number does not need to be saved */
430 CLG_ASSERT(CLG_(current_state).sig == es->sig);
431
432 return es;
433 }
434
435 static
exec_state_restore(void)436 exec_state* exec_state_restore(void)
437 {
438 exec_state* es = top_exec_state();
439
440 CLG_(current_state).cxt = es->cxt;
441 CLG_(current_state).collect = es->collect;
442 CLG_(current_state).jmps_passed = es->jmps_passed;
443 CLG_(current_state).bbcc = es->bbcc;
444 CLG_(current_state).nonskipped = es->nonskipped;
445 CLG_(current_state).cost = es->cost;
446 CLG_(current_state).sig = es->sig;
447
448 CLG_DEBUGIF(1) {
449 CLG_DEBUG(1, " exec_state_restore(sig %d): collect %s, jmps_passed %d\n",
450 es->sig, es->collect ? "Yes": "No", es->jmps_passed);
451 CLG_(print_bbcc)(-9, es->bbcc);
452 CLG_(print_cxt)(-9, es->cxt, 0);
453 CLG_(print_cost)(-9, CLG_(sets).full, es->cost);
454 }
455
456 return es;
457 }
458
459