projects / lttv.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
add eventdefs exclusion in open_tracefiles
[lttv.git] / ltt / branches / poly / lttv / lttv / tracecontext.c
... / ...
CommitLineData
1/* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Michel Dagenais
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
16 * MA 02111-1307, USA.
17 */
18
19#ifdef HAVE_CONFIG_H
20#include <config.h>
21#endif
22
23#include <string.h>
24#include <lttv/tracecontext.h>
25#include <ltt/event.h>
26#include <ltt/facility.h>
27#include <ltt/trace.h>
28#include <ltt/type.h>
29#include <errno.h>
30
31
32
33
34gint compare_tracefile(gconstpointer a, gconstpointer b)
35{
36 gint comparison = 0;
37
38 const LttvTracefileContext *trace_a = (const LttvTracefileContext *)a;
39 const LttvTracefileContext *trace_b = (const LttvTracefileContext *)b;
40
41 if(likely(trace_a != trace_b)) {
42 comparison = ltt_time_compare(trace_b->timestamp, trace_a->timestamp);
43 if(unlikely(comparison == 0)) {
44 if(trace_a->index < trace_b->index) comparison = -1;
45 else if(trace_a->index > trace_b->index) comparison = 1;
46 else if(trace_a->t_context->index < trace_b->t_context->index)
47 comparison = -1;
48 else if(trace_a->t_context->index > trace_b->t_context->index)
49 comparison = 1;
50 }
51 }
52 return comparison;
53}
54
55struct _LttvTracesetContextPosition {
56 GArray *ep; /* Array of LttEventPosition */
57 GArray *tfc; /* Array of corresponding
58 TracefileContext* */
59 LttTime timestamp; /* Current time at the saved position */
60};
61
62void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts)
63{
64 LTTV_TRACESET_CONTEXT_GET_CLASS(self)->init(self, ts);
65}
66
67
68void lttv_context_fini(LttvTracesetContext *self)
69{
70 LTTV_TRACESET_CONTEXT_GET_CLASS(self)->fini(self);
71}
72
73
74LttvTracesetContext *
75lttv_context_new_traceset_context(LttvTracesetContext *self)
76{
77 return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_traceset_context(self);
78}
79
80
81
82
83LttvTraceContext *
84lttv_context_new_trace_context(LttvTracesetContext *self)
85{
86 return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self);
87}
88
89
90LttvTracefileContext *
91lttv_context_new_tracefile_context(LttvTracesetContext *self)
92{
93 return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_tracefile_context(self);
94}
95
96/****************************************************************************
97 * lttv_traceset_context_compute_time_span
98 *
99 * Keep the time span is sync with on the fly addition and removal of traces
100 * in a trace set. It must be called each time a trace is added/removed from
101 * the traceset. It could be more efficient to call it only once a bunch
102 * of traces are loaded, but the calculation is not long, so it's not
103 * critical.
104 *
105 * Author : Xang Xiu Yang
106 ***************************************************************************/
107static void lttv_traceset_context_compute_time_span(
108 LttvTracesetContext *self,
109 TimeInterval *time_span)
110{
111 LttvTraceset * traceset = self->ts;
112 int numTraces = lttv_traceset_number(traceset);
113 int i;
114 LttTime s, e;
115 LttvTraceContext *tc;
116 LttTrace * trace;
117
118 time_span->start_time.tv_sec = 0;
119 time_span->start_time.tv_nsec = 0;
120 time_span->end_time.tv_sec = 0;
121 time_span->end_time.tv_nsec = 0;
122
123 for(i=0; i<numTraces;i++){
124 tc = self->traces[i];
125 trace = tc->t;
126
127 ltt_trace_time_span_get(trace, &s, &e);
128
129 if(i==0){
130 time_span->start_time = s;
131 time_span->end_time = e;
132 }else{
133 if(s.tv_sec < time_span->start_time.tv_sec
134 || (s.tv_sec == time_span->start_time.tv_sec
135 && s.tv_nsec < time_span->start_time.tv_nsec))
136 time_span->start_time = s;
137 if(e.tv_sec > time_span->end_time.tv_sec
138 || (e.tv_sec == time_span->end_time.tv_sec
139 && e.tv_nsec > time_span->end_time.tv_nsec))
140 time_span->end_time = e;
141 }
142 }
143}
144
145static void init_tracefile_context(LttTracefile *tracefile,
146 LttvTraceContext *tc)
147{
148 LttvTracefileContext *tfc;
149 LttvTracesetContext *tsc = tc->ts_context;
150
151 tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->new_tracefile_context(tsc);
152
153 tfc->index = tc->tracefiles->len;
154 tc->tracefiles = g_array_append_val(tc->tracefiles, tfc);
155
156 tfc->tf = tracefile;
157
158 tfc->t_context = tc;
159 tfc->event = lttv_hooks_new();
160 tfc->event_by_id = lttv_hooks_by_id_new();
161 tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
162}
163
164
165static void
166init(LttvTracesetContext *self, LttvTraceset *ts)
167{
168 guint i, nb_trace;
169
170 LttvTraceContext *tc;
171
172 GData **tracefiles_groups;
173
174 struct compute_tracefile_group_args args;
175
176 nb_trace = lttv_traceset_number(ts);
177 self->ts = ts;
178 self->traces = g_new(LttvTraceContext *, nb_trace);
179 self->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
180 self->ts_a = lttv_traceset_attribute(ts);
181 for(i = 0 ; i < nb_trace ; i++) {
182 tc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self);
183 self->traces[i] = tc;
184
185 tc->ts_context = self;
186 tc->index = i;
187 tc->vt = lttv_traceset_get(ts, i);
188 tc->t = lttv_trace(tc->vt);
189 tc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
190 tc->t_a = lttv_trace_attribute(tc->vt);
191 tc->tracefiles = g_array_sized_new(FALSE, TRUE,
192 sizeof(LttvTracefileContext*), 10);
193
194 tracefiles_groups = ltt_trace_get_tracefiles_groups(tc->t);
195 if(tracefiles_groups != NULL) {
196 args.func = (ForEachTraceFileFunc)init_tracefile_context;
197 args.func_args = tc;
198
199 g_datalist_foreach(tracefiles_groups,
200 (GDataForeachFunc)compute_tracefile_group,
201 &args);
202 }
203
204#if 0
205 nb_control = ltt_trace_control_tracefile_number(tc->t);
206 nb_per_cpu = ltt_trace_per_cpu_tracefile_number(tc->t);
207 nb_tracefile = nb_control + nb_per_cpu;
208 tc->tracefiles = g_new(LttvTracefileContext *, nb_tracefile);
209
210 for(j = 0 ; j < nb_tracefile ; j++) {
211 tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_tracefile_context(self);
212 tc->tracefiles[j] = tfc;
213 tfc->index = j;
214
215 if(j < nb_control) {
216 tfc->control = TRUE;
217 tfc->tf = ltt_trace_control_tracefile_get(tc->t, j);
218 }
219 else {
220 tfc->control = FALSE;
221 tfc->tf = ltt_trace_per_cpu_tracefile_get(tc->t, j - nb_control);
222 }
223
224 tfc->t_context = tc;
225 tfc->e = ltt_event_new();
226 tfc->event = lttv_hooks_new();
227 tfc->event_by_id = lttv_hooks_by_id_new();
228 tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
229 }
230#endif //0
231
232 }
233 self->pqueue = g_tree_new(compare_tracefile);
234 lttv_process_traceset_seek_time(self, ltt_time_zero);
235 lttv_traceset_context_compute_time_span(self, &self->time_span);
236
237}
238
239
240void fini(LttvTracesetContext *self)
241{
242 guint i, j, nb_trace, nb_tracefile;
243
244 LttvTraceContext *tc;
245
246 LttvTracefileContext **tfc;
247
248 LttvTraceset *ts = self->ts;
249
250 g_tree_destroy(self->pqueue);
251 g_object_unref(self->a);
252
253 nb_trace = lttv_traceset_number(ts);
254
255 for(i = 0 ; i < nb_trace ; i++) {
256 tc = self->traces[i];
257
258 g_object_unref(tc->a);
259
260 nb_tracefile = tc->tracefiles->len;
261
262 for(j = 0 ; j < nb_tracefile ; j++) {
263 tfc = &g_array_index(tc->tracefiles, LttvTracefileContext*, j);
264 lttv_hooks_destroy((*tfc)->event);
265 lttv_hooks_by_id_destroy((*tfc)->event_by_id);
266 g_object_unref((*tfc)->a);
267 g_object_unref(*tfc);
268 }
269 g_array_free(tc->tracefiles, TRUE);
270 g_object_unref(tc);
271 }
272 g_free(self->traces);
273}
274
275
276void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
277 LttvHooks *before_traceset,
278 LttvHooks *before_trace,
279 LttvHooks *before_tracefile,
280 LttvHooks *event,
281 LttvHooksById *event_by_id)
282{
283 LttvTraceset *ts = self->ts;
284
285 guint i, nb_trace;
286
287 LttvTraceContext *tc;
288
289 lttv_hooks_call(before_traceset, self);
290
291 nb_trace = lttv_traceset_number(ts);
292
293 for(i = 0 ; i < nb_trace ; i++) {
294 tc = self->traces[i];
295 lttv_trace_context_add_hooks(tc,
296 before_trace,
297 before_tracefile,
298 event,
299 event_by_id);
300 }
301}
302
303
304void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
305 LttvHooks *after_traceset,
306 LttvHooks *after_trace,
307 LttvHooks *after_tracefile,
308 LttvHooks *event,
309 LttvHooksById *event_by_id)
310{
311
312 LttvTraceset *ts = self->ts;
313
314 guint i, nb_trace;
315
316 LttvTraceContext *tc;
317
318 nb_trace = lttv_traceset_number(ts);
319
320 for(i = 0 ; i < nb_trace ; i++) {
321 tc = self->traces[i];
322 lttv_trace_context_remove_hooks(tc,
323 after_trace,
324 after_tracefile,
325 event,
326 event_by_id);
327 }
328
329 lttv_hooks_call(after_traceset, self);
330
331
332}
333
334void lttv_trace_context_add_hooks(LttvTraceContext *self,
335 LttvHooks *before_trace,
336 LttvHooks *before_tracefile,
337 LttvHooks *event,
338 LttvHooksById *event_by_id)
339{
340 guint i, nb_tracefile;
341
342 LttvTracefileContext **tfc;
343
344 lttv_hooks_call(before_trace, self);
345
346 nb_tracefile = self->tracefiles->len;
347
348 for(i = 0 ; i < nb_tracefile ; i++) {
349 tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
350 lttv_tracefile_context_add_hooks(*tfc,
351 before_tracefile,
352 event,
353 event_by_id);
354 }
355}
356
357
358
359void lttv_trace_context_remove_hooks(LttvTraceContext *self,
360 LttvHooks *after_trace,
361 LttvHooks *after_tracefile,
362 LttvHooks *event,
363 LttvHooksById *event_by_id)
364{
365 guint i, nb_tracefile;
366
367 LttvTracefileContext **tfc;
368
369 nb_tracefile = self->tracefiles->len;
370
371 for(i = 0 ; i < nb_tracefile ; i++) {
372 tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
373 lttv_tracefile_context_remove_hooks(*tfc,
374 after_tracefile,
375 event,
376 event_by_id);
377 }
378
379 lttv_hooks_call(after_trace, self);
380}
381
382void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
383 LttvHooks *before_tracefile,
384 LttvHooks *event,
385 LttvHooksById *event_by_id)
386{
387 guint i, index;
388
389 LttvHooks *hook;
390
391 lttv_hooks_call(before_tracefile, self);
392 lttv_hooks_add_list(self->event, event);
393 if(event_by_id != NULL) {
394 for(i = 0; i < event_by_id->array->len; i++) {
395 index = g_array_index(event_by_id->array, guint, i);
396 hook = lttv_hooks_by_id_find(self->event_by_id, index);
397 lttv_hooks_add_list(hook, lttv_hooks_by_id_get(event_by_id, index));
398 }
399 }
400}
401
402void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
403 LttvHooks *after_tracefile,
404 LttvHooks *event,
405 LttvHooksById *event_by_id)
406{
407 guint i, index;
408
409 LttvHooks *hook;
410
411 lttv_hooks_remove_list(self->event, event);
412 if(event_by_id != NULL) {
413 for(i = 0; i < event_by_id->array->len; i++) {
414 index = g_array_index(event_by_id->array, guint, i);
415 hook = lttv_hooks_by_id_get(self->event_by_id, index);
416 if(hook != NULL)
417 lttv_hooks_remove_list(hook, lttv_hooks_by_id_get(event_by_id, index));
418 }
419 }
420
421 lttv_hooks_call(after_tracefile, self);
422}
423
424
425
426void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *tfc,
427 unsigned i,
428 LttvHooks *event_by_id)
429{
430 LttvHooks * h;
431 h = lttv_hooks_by_id_find(tfc->event_by_id, i);
432 lttv_hooks_add_list(h, event_by_id);
433}
434
435void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *tfc,
436 unsigned i)
437{
438 lttv_hooks_by_id_remove(tfc->event_by_id, i);
439}
440
441static LttvTracesetContext *
442new_traceset_context(LttvTracesetContext *self)
443{
444 return g_object_new(LTTV_TRACESET_CONTEXT_TYPE, NULL);
445}
446
447
448static LttvTraceContext *
449new_trace_context(LttvTracesetContext *self)
450{
451 return g_object_new(LTTV_TRACE_CONTEXT_TYPE, NULL);
452}
453
454
455static LttvTracefileContext *
456new_tracefile_context(LttvTracesetContext *self)
457{
458 return g_object_new(LTTV_TRACEFILE_CONTEXT_TYPE, NULL);
459}
460
461
462static void
463traceset_context_instance_init (GTypeInstance *instance, gpointer g_class)
464{
465 /* Be careful of anything which would not work well with shallow copies */
466}
467
468
469static void
470traceset_context_finalize (LttvTracesetContext *self)
471{
472 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACESET_CONTEXT_TYPE)))
473 ->finalize(G_OBJECT(self));
474}
475
476
477static void
478traceset_context_class_init (LttvTracesetContextClass *klass)
479{
480 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
481
482 gobject_class->finalize = (void (*)(GObject *self))traceset_context_finalize;
483 klass->init = init;
484 klass->fini = fini;
485 klass->new_traceset_context = new_traceset_context;
486 klass->new_trace_context = new_trace_context;
487 klass->new_tracefile_context = new_tracefile_context;
488}
489
490
491GType
492lttv_traceset_context_get_type(void)
493{
494 static GType type = 0;
495 if (type == 0) {
496 static const GTypeInfo info = {
497 sizeof (LttvTracesetContextClass),
498 NULL, /* base_init */
499 NULL, /* base_finalize */
500 (GClassInitFunc) traceset_context_class_init, /* class_init */
501 NULL, /* class_finalize */
502 NULL, /* class_data */
503 sizeof (LttvTracesetContext),
504 0, /* n_preallocs */
505 (GInstanceInitFunc) traceset_context_instance_init, /* instance_init */
506 NULL /* Value handling */
507 };
508
509 type = g_type_register_static (G_TYPE_OBJECT, "LttvTracesetContextType",
510 &info, 0);
511 }
512 return type;
513}
514
515
516static void
517trace_context_instance_init (GTypeInstance *instance, gpointer g_class)
518{
519 /* Be careful of anything which would not work well with shallow copies */
520}
521
522
523static void
524trace_context_finalize (LttvTraceContext *self)
525{
526 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACE_CONTEXT_TYPE)))->
527 finalize(G_OBJECT(self));
528}
529
530
531static void
532trace_context_class_init (LttvTraceContextClass *klass)
533{
534 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
535
536 gobject_class->finalize = (void (*)(GObject *self)) trace_context_finalize;
537}
538
539
540GType
541lttv_trace_context_get_type(void)
542{
543 static GType type = 0;
544 if (type == 0) {
545 static const GTypeInfo info = {
546 sizeof (LttvTraceContextClass),
547 NULL, /* base_init */
548 NULL, /* base_finalize */
549 (GClassInitFunc) trace_context_class_init, /* class_init */
550 NULL, /* class_finalize */
551 NULL, /* class_data */
552 sizeof (LttvTraceContext),
553 0, /* n_preallocs */
554 (GInstanceInitFunc) trace_context_instance_init, /* instance_init */
555 NULL /* Value handling */
556 };
557
558 type = g_type_register_static (G_TYPE_OBJECT, "LttvTraceContextType",
559 &info, 0);
560 }
561 return type;
562}
563
564
565static void
566tracefile_context_instance_init (GTypeInstance *instance, gpointer g_class)
567{
568 /* Be careful of anything which would not work well with shallow copies */
569}
570
571
572static void
573tracefile_context_finalize (LttvTracefileContext *self)
574{
575 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACEFILE_CONTEXT_TYPE)))
576 ->finalize(G_OBJECT(self));
577}
578
579
580static void
581tracefile_context_class_init (LttvTracefileContextClass *klass)
582{
583 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
584
585 gobject_class->finalize = (void (*)(GObject *self))tracefile_context_finalize;
586}
587
588
589GType
590lttv_tracefile_context_get_type(void)
591{
592 static GType type = 0;
593 if (type == 0) {
594 static const GTypeInfo info = {
595 sizeof (LttvTracefileContextClass),
596 NULL, /* base_init */
597 NULL, /* base_finalize */
598 (GClassInitFunc) tracefile_context_class_init, /* class_init */
599 NULL, /* class_finalize */
600 NULL, /* class_data */
601 sizeof (LttvTracefileContext),
602 0, /* n_preallocs */
603 (GInstanceInitFunc) tracefile_context_instance_init, /* instance_init */
604 NULL /* Value handling */
605 };
606
607 type = g_type_register_static (G_TYPE_OBJECT, "LttvTracefileContextType",
608 &info, 0);
609 }
610 return type;
611}
612
613
614
615static gboolean get_first(gpointer key, gpointer value, gpointer user_data) {
616 g_assert(key == value);
617 *((LttvTracefileContext **)user_data) = (LttvTracefileContext *)value;
618 return TRUE;
619}
620
621static gboolean test_tree(gpointer key, gpointer value, gpointer user_data) {
622
623 LttvTracefileContext *tfc = (LttvTracefileContext *)key;
624
625 g_debug("Tracefile name %s, time %lu.%lu, tfi %u, ti %u",
626 g_quark_to_string(ltt_tracefile_name(tfc->tf)),
627 tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec,
628 tfc->index, tfc->t_context->index);
629
630 if(((LttvTracefileContext *)user_data) == (LttvTracefileContext *)value) {
631 g_assert(compare_tracefile(user_data, value) == 0);
632 } else
633 g_assert(compare_tracefile(user_data, value) != 0);
634
635 //g_assert(((LttvTracefileContext *)user_data) != (LttvTracefileContext *)value);
636 return FALSE;
637}
638
639
640
641void lttv_process_traceset_begin(LttvTracesetContext *self,
642 LttvHooks *before_traceset,
643 LttvHooks *before_trace,
644 LttvHooks *before_tracefile,
645 LttvHooks *event,
646 LttvHooksById *event_by_id)
647{
648
649 /* simply add hooks in context. _before hooks are called by add_hooks. */
650 /* It calls all before_traceset, before_trace, and before_tracefile hooks. */
651 lttv_traceset_context_add_hooks(self,
652 before_traceset,
653 before_trace,
654 before_tracefile,
655 event,
656 event_by_id);
657
658}
659
660/* Note : a _middle must be preceded from a _seek or another middle */
661guint lttv_process_traceset_middle(LttvTracesetContext *self,
662 LttTime end,
663 guint nb_events,
664 const LttvTracesetContextPosition *end_position)
665{
666 GTree *pqueue = self->pqueue;
667
668 guint fac_id, ev_id, id;
669
670 LttvTracefileContext *tfc;
671
672 LttEvent *e;
673
674 unsigned count = 0;
675
676 guint read_ret = FALSE;
677
678 gboolean last_ret = FALSE; /* return value of the last hook list called */
679
680 /* Get the next event from the pqueue, call its hooks,
681 reinsert in the pqueue the following event from the same tracefile
682 unless the tracefile is finished or the event is later than the
683 end time. */
684
685 while(TRUE) {
686 tfc = NULL;
687 g_tree_foreach(pqueue, get_first, &tfc);
688 /* End of traceset : tfc is NULL */
689 if(unlikely(tfc == NULL))
690 {
691 return count;
692 }
693
694 /* Have we reached :
695 * - the maximum number of events specified?
696 * - the end position ?
697 * - the end time ?
698 * then the read is finished. We leave the queue in the same state and
699 * break the loop.
700 */
701
702 if(unlikely(last_ret == TRUE ||
703 ((count >= nb_events) && (nb_events != G_MAXULONG)) ||
704 (end_position!=NULL&&lttv_traceset_context_ctx_pos_compare(self,
705 end_position) == 0)||
706 ltt_time_compare(end, tfc->timestamp) <= 0))
707 {
708 return count;
709 }
710
711 /* Get the tracefile with an event for the smallest time found. If two
712 or more tracefiles have events for the same time, hope that lookup
713 and remove are consistent. */
714
715#ifdef DEBUG
716 g_debug("test tree before remove");
717 g_tree_foreach(pqueue, test_tree, tfc);
718#endif //DEBUG
719 g_tree_remove(pqueue, tfc);
720
721#ifdef DEBUG
722 g_debug("test tree after remove");
723 g_tree_foreach(pqueue, test_tree, tfc);
724#endif //DEBUG
725
726 count++;
727
728 e = ltt_tracefile_get_event(tfc->tf);
729 fac_id = ltt_event_facility_id(e);
730 ev_id = ltt_event_eventtype_id(e);
731 id = GET_HOOK_ID(fac_id, ev_id);
732 last_ret = lttv_hooks_call_merge(tfc->event, tfc,
733 lttv_hooks_by_id_get(tfc->event_by_id, id), tfc);
734
735 read_ret = ltt_tracefile_read(tfc->tf);
736
737 if(likely(!read_ret)) {
738 g_debug("An event is ready");
739 tfc->timestamp = ltt_event_time(e);
740
741 g_tree_insert(pqueue, tfc, tfc);
742 } else {
743 tfc->timestamp = ltt_time_infinite;
744
745 if(read_ret == ERANGE)
746 g_debug("End of trace");
747 else
748 g_error("Error happened in lttv_process_traceset_middle");
749 }
750 }
751}
752
753
754void lttv_process_traceset_end(LttvTracesetContext *self,
755 LttvHooks *after_traceset,
756 LttvHooks *after_trace,
757 LttvHooks *after_tracefile,
758 LttvHooks *event,
759 LttvHooksById *event_by_id)
760{
761 /* Remove hooks from context. _after hooks are called by remove_hooks. */
762 /* It calls all after_traceset, after_trace, and after_tracefile hooks. */
763 lttv_traceset_context_remove_hooks(self,
764 after_traceset,
765 after_trace,
766 after_tracefile,
767 event,
768 event_by_id);
769}
770
771/* Subtile modification :
772 * if tracefile has no event at or after the time requested, it is not put in
773 * the queue, as the next read would fail. */
774void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start)
775{
776 guint i, nb_tracefile;
777
778 gint ret;
779
780 LttvTracefileContext **tfc;
781
782 GTree *pqueue = self->ts_context->pqueue;
783
784 nb_tracefile = self->tracefiles->len;
785
786 for(i = 0 ; i < nb_tracefile ; i++) {
787 tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
788
789 g_tree_remove(pqueue, *tfc);
790
791 ret = ltt_tracefile_seek_time((*tfc)->tf, start);
792 if(ret == EPERM) g_error("error in lttv_process_trace_seek_time seek");
793
794 if(ret == 0) { /* not ERANGE especially */
795 (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf));
796 g_tree_insert(pqueue, (*tfc), (*tfc));
797 } else {
798 (*tfc)->timestamp = ltt_time_infinite;
799 }
800 }
801}
802
803
804void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start)
805{
806 guint i, nb_trace;
807
808 LttvTraceContext *tc;
809
810 nb_trace = lttv_traceset_number(self->ts);
811 for(i = 0 ; i < nb_trace ; i++) {
812 tc = self->traces[i];
813 lttv_process_trace_seek_time(tc, start);
814 }
815}
816
817
818gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
819 const LttvTracesetContextPosition *pos)
820{
821 guint i;
822
823 g_tree_destroy(self->pqueue);
824 self->pqueue = g_tree_new(compare_tracefile);
825
826 for(i=0;i<pos->ep->len; i++) {
827 LttEventPosition **ep = &g_array_index(pos->ep, LttEventPosition*, i);
828 LttvTracefileContext **tfc =
829 &g_array_index(pos->tfc, LttvTracefileContext*, i);
830 if(*ep != NULL) {
831 g_assert(ltt_tracefile_seek_position((*tfc)->tf, *ep) == 0);
832 (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf));
833 g_tree_insert(self->pqueue, (*tfc), (*tfc));
834 } else {
835 (*tfc)->timestamp = ltt_time_infinite;
836 }
837 }
838 return TRUE;
839}
840
841
842
843static LttField *
844find_field(LttEventType *et, const GQuark field)
845{
846 LttType *t;
847
848 LttField *f;
849
850 guint i, nb;
851
852 GQuark name;
853
854 /* Field is unset */
855 if(field == 0) return NULL;
856
857 f = ltt_eventtype_field(et);
858 t = ltt_eventtype_type(et);
859 g_assert(ltt_type_class(t) == LTT_STRUCT);
860 nb = ltt_type_member_number(t);
861 for(i = 0 ; i < nb ; i++) {
862 ltt_type_member_type(t, i, &name);
863 if(name == field) break;
864 }
865 g_assert(i < nb);
866 return ltt_field_member(f, i);
867}
868
869LttvTraceHookByFacility *lttv_trace_hook_get_fac(LttvTraceHook *th,
870 guint facility_id)
871{
872 return &g_array_index(th->fac_index, LttvTraceHookByFacility, facility_id);
873}
874
875/* Get the first facility corresponding to the name. As the types must be
876 * compatible, it is relevant to use the field name and sizes of the first
877 * facility to create data structures and assume the data will be compatible
878 * thorough the trace */
879LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th)
880{
881 g_assert(th->fac_list->len > 0);
882 return g_array_index(th->fac_list, LttvTraceHookByFacility*, 0);
883}
884
885
886/* Returns 0 on success, -1 if fails. */
887gint
888lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event,
889 GQuark field1, GQuark field2, GQuark field3, LttvHook h, LttvTraceHook *th)
890{
891 LttFacility *f;
892
893 LttEventType *et, *first_et;
894
895 GArray *facilities;
896
897 guint i, fac_id, ev_id;
898
899 LttvTraceHookByFacility *thf, *first_thf;
900
901 facilities = ltt_trace_facility_get_by_name(t, facility);
902
903 if(unlikely(facilities == NULL)) goto facility_error;
904
905 th->fac_index = g_array_sized_new(FALSE, TRUE,
906 sizeof(LttvTraceHookByFacility),
907 NUM_FACILITIES);
908 th->fac_index = g_array_set_size(th->fac_index, NUM_FACILITIES);
909
910 th->fac_list = g_array_sized_new(FALSE, TRUE,
911 sizeof(LttvTraceHookByFacility*),
912 facilities->len);
913 th->fac_list = g_array_set_size(th->fac_list, facilities->len);
914
915 fac_id = g_array_index(facilities, guint, 0);
916 f = ltt_trace_get_facility_by_num(t, fac_id);
917
918 et = ltt_facility_eventtype_get_by_name(f, event);
919 if(unlikely(et == NULL)) goto event_error;
920
921 thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
922 g_array_index(th->fac_list, LttvTraceHookByFacility*, 0) = thf;
923
924 ev_id = ltt_eventtype_id(et);
925
926 thf->h = h;
927 thf->id = GET_HOOK_ID(fac_id, ev_id);
928 thf->f1 = find_field(et, field1);
929 thf->f2 = find_field(et, field2);
930 thf->f3 = find_field(et, field3);
931
932 first_thf = thf;
933 first_et = et;
934
935 /* Check for type compatibility too */
936 for(i=1;i<facilities->len;i++) {
937 fac_id = g_array_index(facilities, guint, i);
938 f = ltt_trace_get_facility_by_num(t, fac_id);
939
940 et = ltt_facility_eventtype_get_by_name(f, ltt_eventtype_name(et));
941 if(unlikely(et == NULL)) goto event_error;
942
943 thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
944 g_array_index(th->fac_list, LttvTraceHookByFacility*, i) = thf;
945 ev_id = ltt_eventtype_id(et);
946 thf->h = h;
947 thf->id = GET_HOOK_ID(fac_id, ev_id);
948 thf->f1 = find_field(et, field1);
949 if(check_fields_compatibility(first_et, et,
950 first_thf->f1, thf->f1))
951 goto type_error;
952
953 thf->f2 = find_field(et, field2);
954 if(check_fields_compatibility(first_et, et,
955 first_thf->f2, thf->f2))
956 goto type_error;
957
958 thf->f3 = find_field(et, field3);
959 if(check_fields_compatibility(first_et, et,
960 first_thf->f3, thf->f3))
961 goto type_error;
962 }
963
964 return 0;
965
966type_error:
967 goto free;
968event_error:
969 g_error("Event type %s does not exist",
970 g_quark_to_string(ltt_eventtype_name(et)));
971 goto free;
972facility_error:
973 g_error("No %s facility", g_quark_to_string(facility));
974 goto free;
975free:
976 g_array_free(th->fac_index, TRUE);
977 g_array_free(th->fac_list, TRUE);
978 th->fac_index = NULL;
979 th->fac_list = NULL;
980 return -1;
981}
982
983void lttv_trace_hook_destroy(LttvTraceHook *th)
984{
985 g_array_free(th->fac_index, TRUE);
986 g_array_free(th->fac_list, TRUE);
987}
988
989
990LttvTracesetContextPosition *lttv_traceset_context_position_new()
991{
992 LttvTracesetContextPosition *pos = g_new(LttvTracesetContextPosition,1);
993 pos->ep = g_array_sized_new(FALSE, TRUE, sizeof(LttEventPosition*),
994 10);
995 pos->tfc = g_array_sized_new(FALSE, TRUE, sizeof(LttvTracefileContext*),
996 10);
997 pos->timestamp = ltt_time_infinite;
998 return pos;
999}
1000
1001/* Save all positions, the ones not in the pqueue will have NULL
1002 * ep. */
1003void lttv_traceset_context_position_save(const LttvTracesetContext *self,
1004 LttvTracesetContextPosition *pos)
1005{
1006 guint i;
1007 guint num_traces = lttv_traceset_number(self->ts);
1008
1009 for(i=0; i<num_traces;i++) {
1010 GArray * tracefiles = self->traces[i]->tracefiles;
1011 guint j;
1012 guint num_tracefiles = tracefiles->len;
1013
1014 for(j=0;j<num_tracefiles;j++) {
1015 LttvTracefileContext **tfc = &g_array_index(tracefiles,
1016 LttvTracefileContext*, j);
1017
1018 LttEvent *event = ltt_tracefile_get_event((*tfc)->tf);
1019 LttEventPosition *ep;
1020
1021 if(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0) {
1022 ep = ltt_event_position_new();
1023 ltt_event_position(event, ep);
1024 if(ltt_time_compare((*tfc)->timestamp, pos->timestamp) < 0)
1025 pos->timestamp = (*tfc)->timestamp;
1026 } else {
1027 ep = NULL;
1028 }
1029 g_array_append_val(pos->tfc, *tfc);
1030 g_array_append_val(pos->ep, ep);
1031 }
1032
1033 }
1034}
1035
1036void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos)
1037{
1038 int i;
1039 LttEventPosition **ep;
1040
1041 for(i=0;i<pos->ep->len;i++) {
1042 ep = &g_array_index(pos->ep, LttEventPosition*, i);
1043 if(*ep != NULL)
1044 g_free(*ep);
1045 }
1046 g_array_free(pos->ep, TRUE);
1047 g_array_free(pos->tfc, TRUE);
1048 g_free(pos);
1049}
1050
1051void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
1052 const LttvTracesetContextPosition *src)
1053{
1054 int i;
1055 LttEventPosition **src_ep, **dest_ep;
1056
1057 g_array_set_size(dest->ep, src->ep->len);
1058 g_array_set_size(dest->tfc, src->tfc->len);
1059
1060 for(i=0;i<src->ep->len;i++) {
1061 src_ep = &g_array_index(src->ep, LttEventPosition*, i);
1062 dest_ep = &g_array_index(dest->ep, LttEventPosition*, i);
1063 if(*src_ep != NULL) {
1064 *dest_ep = ltt_event_position_new();
1065 ltt_event_position_copy(
1066 *dest_ep,
1067 *src_ep);
1068 } else
1069 *dest_ep = NULL;
1070 }
1071 for(i=0;i<src->tfc->len;i++) {
1072 g_array_index(dest->tfc, LttvTracefileContext*, i) =
1073 g_array_index(src->tfc, LttvTracefileContext*, i);
1074 }
1075 dest->timestamp = src->timestamp;
1076}
1077
1078gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
1079 const LttvTracesetContextPosition *pos)
1080{
1081 int i;
1082 int ret = 0;
1083
1084 for(i=0;i<pos->ep->len;i++) {
1085 LttEventPosition *ep = g_array_index(pos->ep, LttEventPosition*, i);
1086 LttvTracefileContext *tfc =
1087 g_array_index(pos->tfc, LttvTracefileContext*, i);
1088
1089 if(ep == NULL) {
1090 if(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0) {
1091 ret = -1;
1092 }
1093 } else {
1094 if(ltt_time_compare(tfc->timestamp, ltt_time_infinite) == 0) {
1095 ret = 1;
1096 } else {
1097 LttEvent *event = ltt_tracefile_get_event(tfc->tf);
1098
1099 ret = ltt_event_position_compare((LttEventPosition*)event,
1100 ep);
1101 }
1102 }
1103 if(ret != 0) return ret;
1104
1105 }
1106 return 0;
1107}
1108
1109
1110gint lttv_traceset_context_pos_pos_compare(
1111 const LttvTracesetContextPosition *pos1,
1112 const LttvTracesetContextPosition *pos2)
1113{
1114 int i, j;
1115 int ret;
1116
1117 for(i=0;i<pos1->ep->len;i++) {
1118 LttEventPosition *ep1 = g_array_index(pos1->ep, LttEventPosition*, i);
1119 LttvTracefileContext *tfc1 = g_array_index(pos1->tfc,
1120 LttvTracefileContext*, i);
1121
1122 if(ep1 != NULL) {
1123 for(j=0;j<pos2->ep->len;j++) {
1124 LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j);
1125 LttvTracefileContext *tfc2 = g_array_index(pos2->tfc,
1126 LttvTracefileContext*, j);
1127 if(tfc1 == tfc2) {
1128 if(ep2 != NULL)
1129 ret = ltt_event_position_compare(ep1, ep2);
1130 else
1131 ret = -1;
1132
1133 if(ret != 0) return ret;
1134 }
1135 }
1136 } else {
1137 for(j=0;j<pos2->ep->len;j++) {
1138 LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j);
1139 LttvTracefileContext *tfc2 = g_array_index(pos2->tfc,
1140 LttvTracefileContext*, j);
1141 if(tfc1 == tfc2) {
1142 if(ep2 != NULL) ret = 1;
1143 }
1144 }
1145 }
1146 }
1147 return 0;
1148}
1149
1150
1151LttTime lttv_traceset_context_position_get_time(
1152 const LttvTracesetContextPosition *pos)
1153{
1154 return pos->timestamp;
1155}
1156
1157
1158LttvTracefileContext *lttv_traceset_context_get_current_tfc(LttvTracesetContext *self)
1159{
1160 GTree *pqueue = self->pqueue;
1161 LttvTracefileContext *tfc = NULL;
1162
1163 g_tree_foreach(pqueue, get_first, &tfc);
1164
1165 return tfc;
1166}
LTTng 2.x Viewer (LTTV)
This page took 0.027971 seconds and 4 git commands to generate.