projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
comment field id of LttvTraceHook
[lttv.git] / ltt / branches / poly / lttv / lttv / tracecontext.c
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/lttv.h>
25 #include <lttv/tracecontext.h>
26 #include <ltt/event.h>
27 #include <ltt/trace.h>
28 #include <lttv/filter.h>
29 #include <errno.h>
30
31 #define min(a,b) (((a)<(b))?(a):(b))
32
33
34 gint 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_a->timestamp, trace_b->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
55 typedef struct _LttvTracefileContextPosition {
56 LttEventPosition *event;
57 LttvTracefileContext *tfc;
58 gboolean used; /* Tells if the tfc is at end of traceset position */
59 } LttvTracefileContextPosition;
60
61
62 struct _LttvTracesetContextPosition {
63 GArray *tfcp; /* Array of LttvTracefileContextPosition */
64 LttTime timestamp; /* Current time at the saved position */
65 /* If ltt_time_infinite : no position is
66 * set, else, a position is set (may be end
67 * of trace, with ep->len == 0) */
68 };
69
70 void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts)
71 {
72 LTTV_TRACESET_CONTEXT_GET_CLASS(self)->init(self, ts);
73 }
74
75
76 void lttv_context_fini(LttvTracesetContext *self)
77 {
78 LTTV_TRACESET_CONTEXT_GET_CLASS(self)->fini(self);
79 }
80
81
82 LttvTracesetContext *
83 lttv_context_new_traceset_context(LttvTracesetContext *self)
84 {
85 return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_traceset_context(self);
86 }
87
88
89
90
91 LttvTraceContext *
92 lttv_context_new_trace_context(LttvTracesetContext *self)
93 {
94 return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self);
95 }
96
97
98 LttvTracefileContext *
99 lttv_context_new_tracefile_context(LttvTracesetContext *self)
100 {
101 return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_tracefile_context(self);
102 }
103
104 /****************************************************************************
105 * lttv_traceset_context_compute_time_span
106 *
107 * Keep the time span is sync with on the fly addition and removal of traces
108 * in a trace set. It must be called each time a trace is added/removed from
109 * the traceset. It could be more efficient to call it only once a bunch
110 * of traces are loaded, but the calculation is not long, so it's not
111 * critical.
112 *
113 * Author : Xang Xiu Yang
114 ***************************************************************************/
115 static void lttv_traceset_context_compute_time_span(
116 LttvTracesetContext *self,
117 TimeInterval *time_span)
118 {
119 LttvTraceset * traceset = self->ts;
120 int numTraces = lttv_traceset_number(traceset);
121 int i;
122 LttTime s, e;
123 LttvTraceContext *tc;
124 LttTrace * trace;
125
126 time_span->start_time.tv_sec = 0;
127 time_span->start_time.tv_nsec = 0;
128 time_span->end_time.tv_sec = 0;
129 time_span->end_time.tv_nsec = 0;
130
131 for(i=0; i<numTraces;i++){
132 tc = self->traces[i];
133 trace = tc->t;
134
135 ltt_trace_time_span_get(trace, &s, &e);
136 tc->time_span.start_time = s;
137 tc->time_span.end_time = e;
138
139 if(i==0){
140 time_span->start_time = s;
141 time_span->end_time = e;
142 }else{
143 if(s.tv_sec < time_span->start_time.tv_sec
144 || (s.tv_sec == time_span->start_time.tv_sec
145 && s.tv_nsec < time_span->start_time.tv_nsec))
146 time_span->start_time = s;
147 if(e.tv_sec > time_span->end_time.tv_sec
148 || (e.tv_sec == time_span->end_time.tv_sec
149 && e.tv_nsec > time_span->end_time.tv_nsec))
150 time_span->end_time = e;
151 }
152 }
153 }
154
155 static void init_tracefile_context(LttTracefile *tracefile,
156 LttvTraceContext *tc)
157 {
158 LttvTracefileContext *tfc;
159 LttvTracesetContext *tsc = tc->ts_context;
160
161 tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->new_tracefile_context(tsc);
162
163 tfc->index = tc->tracefiles->len;
164 tc->tracefiles = g_array_append_val(tc->tracefiles, tfc);
165
166 tfc->tf = tracefile;
167
168 tfc->t_context = tc;
169 tfc->event = lttv_hooks_new();
170 tfc->event_by_id = lttv_hooks_by_id_new();
171 tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
172 tfc->target_pid = -1;
173 }
174
175
176 static void
177 init(LttvTracesetContext *self, LttvTraceset *ts)
178 {
179 guint i, nb_trace;
180
181 LttvTraceContext *tc;
182
183 GData **tracefiles_groups;
184
185 struct compute_tracefile_group_args args;
186
187 nb_trace = lttv_traceset_number(ts);
188 self->ts = ts;
189 self->traces = g_new(LttvTraceContext *, nb_trace);
190 self->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
191 self->ts_a = lttv_traceset_attribute(ts);
192 for(i = 0 ; i < nb_trace ; i++) {
193 tc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self);
194 self->traces[i] = tc;
195
196 tc->ts_context = self;
197 tc->index = i;
198 tc->vt = lttv_traceset_get(ts, i);
199 tc->t = lttv_trace(tc->vt);
200 tc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
201 tc->t_a = lttv_trace_attribute(tc->vt);
202 tc->tracefiles = g_array_sized_new(FALSE, TRUE,
203 sizeof(LttvTracefileContext*), 10);
204
205 tracefiles_groups = ltt_trace_get_tracefiles_groups(tc->t);
206 if(tracefiles_groups != NULL) {
207 args.func = (ForEachTraceFileFunc)init_tracefile_context;
208 args.func_args = tc;
209
210 g_datalist_foreach(tracefiles_groups,
211 (GDataForeachFunc)compute_tracefile_group,
212 &args);
213 }
214
215 #if 0
216 nb_control = ltt_trace_control_tracefile_number(tc->t);
217 nb_per_cpu = ltt_trace_per_cpu_tracefile_number(tc->t);
218 nb_tracefile = nb_control + nb_per_cpu;
219 tc->tracefiles = g_new(LttvTracefileContext *, nb_tracefile);
220
221 for(j = 0 ; j < nb_tracefile ; j++) {
222 tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_tracefile_context(self);
223 tc->tracefiles[j] = tfc;
224 tfc->index = j;
225
226 if(j < nb_control) {
227 tfc->control = TRUE;
228 tfc->tf = ltt_trace_control_tracefile_get(tc->t, j);
229 }
230 else {
231 tfc->control = FALSE;
232 tfc->tf = ltt_trace_per_cpu_tracefile_get(tc->t, j - nb_control);
233 }
234
235 tfc->t_context = tc;
236 tfc->e = ltt_event_new();
237 tfc->event = lttv_hooks_new();
238 tfc->event_by_id = lttv_hooks_by_id_new();
239 tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
240 }
241 #endif //0
242
243 }
244 self->sync_position = lttv_traceset_context_position_new(self);
245 self->pqueue = g_tree_new(compare_tracefile);
246 lttv_process_traceset_seek_time(self, ltt_time_zero);
247 lttv_traceset_context_compute_time_span(self, &self->time_span);
248
249 }
250
251
252 void fini(LttvTracesetContext *self)
253 {
254 guint i, j, nb_trace, nb_tracefile;
255
256 LttvTraceContext *tc;
257
258 LttvTracefileContext **tfc;
259
260 LttvTraceset *ts = self->ts;
261
262 g_tree_destroy(self->pqueue);
263 g_object_unref(self->a);
264 lttv_traceset_context_position_destroy(self->sync_position);
265
266 nb_trace = lttv_traceset_number(ts);
267
268 for(i = 0 ; i < nb_trace ; i++) {
269 tc = self->traces[i];
270
271 g_object_unref(tc->a);
272
273 nb_tracefile = tc->tracefiles->len;
274
275 for(j = 0 ; j < nb_tracefile ; j++) {
276 tfc = &g_array_index(tc->tracefiles, LttvTracefileContext*, j);
277 lttv_hooks_destroy((*tfc)->event);
278 lttv_hooks_by_id_destroy((*tfc)->event_by_id);
279 g_object_unref((*tfc)->a);
280 g_object_unref(*tfc);
281 }
282 g_array_free(tc->tracefiles, TRUE);
283 g_object_unref(tc);
284 }
285 g_free(self->traces);
286 }
287
288
289 void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
290 LttvHooks *before_traceset,
291 LttvHooks *before_trace,
292 LttvHooks *before_tracefile,
293 LttvHooks *event,
294 LttvHooksById *event_by_id)
295 {
296 LttvTraceset *ts = self->ts;
297
298 guint i, nb_trace;
299
300 LttvTraceContext *tc;
301
302 lttv_hooks_call(before_traceset, self);
303
304 nb_trace = lttv_traceset_number(ts);
305
306 for(i = 0 ; i < nb_trace ; i++) {
307 tc = self->traces[i];
308 lttv_trace_context_add_hooks(tc,
309 before_trace,
310 before_tracefile,
311 event,
312 event_by_id);
313 }
314 }
315
316
317 void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
318 LttvHooks *after_traceset,
319 LttvHooks *after_trace,
320 LttvHooks *after_tracefile,
321 LttvHooks *event,
322 LttvHooksById *event_by_id)
323 {
324
325 LttvTraceset *ts = self->ts;
326
327 guint i, nb_trace;
328
329 LttvTraceContext *tc;
330
331 nb_trace = lttv_traceset_number(ts);
332
333 for(i = 0 ; i < nb_trace ; i++) {
334 tc = self->traces[i];
335 lttv_trace_context_remove_hooks(tc,
336 after_trace,
337 after_tracefile,
338 event,
339 event_by_id);
340 }
341
342 lttv_hooks_call(after_traceset, self);
343
344
345 }
346
347 void lttv_trace_context_add_hooks(LttvTraceContext *self,
348 LttvHooks *before_trace,
349 LttvHooks *before_tracefile,
350 LttvHooks *event,
351 LttvHooksById *event_by_id)
352 {
353 guint i, nb_tracefile;
354
355 LttvTracefileContext **tfc;
356
357 lttv_hooks_call(before_trace, self);
358
359 nb_tracefile = self->tracefiles->len;
360
361 for(i = 0 ; i < nb_tracefile ; i++) {
362 tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
363 lttv_tracefile_context_add_hooks(*tfc,
364 before_tracefile,
365 event,
366 event_by_id);
367 }
368 }
369
370
371
372 void lttv_trace_context_remove_hooks(LttvTraceContext *self,
373 LttvHooks *after_trace,
374 LttvHooks *after_tracefile,
375 LttvHooks *event,
376 LttvHooksById *event_by_id)
377 {
378 guint i, nb_tracefile;
379
380 LttvTracefileContext **tfc;
381
382 nb_tracefile = self->tracefiles->len;
383
384 for(i = 0 ; i < nb_tracefile ; i++) {
385 tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
386 lttv_tracefile_context_remove_hooks(*tfc,
387 after_tracefile,
388 event,
389 event_by_id);
390 }
391
392 lttv_hooks_call(after_trace, self);
393 }
394
395 void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
396 LttvHooks *before_tracefile,
397 LttvHooks *event,
398 LttvHooksById *event_by_id)
399 {
400 guint i, index;
401
402 LttvHooks *hook;
403
404 lttv_hooks_call(before_tracefile, self);
405 lttv_hooks_add_list(self->event, event);
406 if(event_by_id != NULL) {
407 for(i = 0; i < event_by_id->array->len; i++) {
408 index = g_array_index(event_by_id->array, guint, i);
409 hook = lttv_hooks_by_id_find(self->event_by_id, index);
410 lttv_hooks_add_list(hook, lttv_hooks_by_id_get(event_by_id, index));
411 }
412 }
413 }
414
415 void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
416 LttvHooks *after_tracefile,
417 LttvHooks *event,
418 LttvHooksById *event_by_id)
419 {
420 guint i, index;
421
422 LttvHooks *hook;
423
424 lttv_hooks_remove_list(self->event, event);
425 if(event_by_id != NULL) {
426 for(i = 0; i < event_by_id->array->len; i++) {
427 index = g_array_index(event_by_id->array, guint, i);
428 hook = lttv_hooks_by_id_get(self->event_by_id, index);
429 if(hook != NULL)
430 lttv_hooks_remove_list(hook, lttv_hooks_by_id_get(event_by_id, index));
431 }
432 }
433
434 lttv_hooks_call(after_tracefile, self);
435 }
436
437
438
439 void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *tfc,
440 unsigned i,
441 LttvHooks *event_by_id)
442 {
443 LttvHooks * h;
444 h = lttv_hooks_by_id_find(tfc->event_by_id, i);
445 lttv_hooks_add_list(h, event_by_id);
446 }
447
448 void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *tfc,
449 unsigned i)
450 {
451 lttv_hooks_by_id_remove(tfc->event_by_id, i);
452 }
453
454 static LttvTracesetContext *
455 new_traceset_context(LttvTracesetContext *self)
456 {
457 return g_object_new(LTTV_TRACESET_CONTEXT_TYPE, NULL);
458 }
459
460
461 static LttvTraceContext *
462 new_trace_context(LttvTracesetContext *self)
463 {
464 return g_object_new(LTTV_TRACE_CONTEXT_TYPE, NULL);
465 }
466
467
468 static LttvTracefileContext *
469 new_tracefile_context(LttvTracesetContext *self)
470 {
471 return g_object_new(LTTV_TRACEFILE_CONTEXT_TYPE, NULL);
472 }
473
474
475 static void
476 traceset_context_instance_init (GTypeInstance *instance, gpointer g_class)
477 {
478 /* Be careful of anything which would not work well with shallow copies */
479 }
480
481
482 static void
483 traceset_context_finalize (LttvTracesetContext *self)
484 {
485 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACESET_CONTEXT_TYPE)))
486 ->finalize(G_OBJECT(self));
487 }
488
489
490 static void
491 traceset_context_class_init (LttvTracesetContextClass *klass)
492 {
493 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
494
495 gobject_class->finalize = (void (*)(GObject *self))traceset_context_finalize;
496 klass->init = init;
497 klass->fini = fini;
498 klass->new_traceset_context = new_traceset_context;
499 klass->new_trace_context = new_trace_context;
500 klass->new_tracefile_context = new_tracefile_context;
501 }
502
503
504 GType
505 lttv_traceset_context_get_type(void)
506 {
507 static GType type = 0;
508 if (type == 0) {
509 static const GTypeInfo info = {
510 sizeof (LttvTracesetContextClass),
511 NULL, /* base_init */
512 NULL, /* base_finalize */
513 (GClassInitFunc) traceset_context_class_init, /* class_init */
514 NULL, /* class_finalize */
515 NULL, /* class_data */
516 sizeof (LttvTracesetContext),
517 0, /* n_preallocs */
518 (GInstanceInitFunc) traceset_context_instance_init, /* instance_init */
519 NULL /* Value handling */
520 };
521
522 type = g_type_register_static (G_TYPE_OBJECT, "LttvTracesetContextType",
523 &info, 0);
524 }
525 return type;
526 }
527
528
529 static void
530 trace_context_instance_init (GTypeInstance *instance, gpointer g_class)
531 {
532 /* Be careful of anything which would not work well with shallow copies */
533 }
534
535
536 static void
537 trace_context_finalize (LttvTraceContext *self)
538 {
539 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACE_CONTEXT_TYPE)))->
540 finalize(G_OBJECT(self));
541 }
542
543
544 static void
545 trace_context_class_init (LttvTraceContextClass *klass)
546 {
547 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
548
549 gobject_class->finalize = (void (*)(GObject *self)) trace_context_finalize;
550 }
551
552
553 GType
554 lttv_trace_context_get_type(void)
555 {
556 static GType type = 0;
557 if (type == 0) {
558 static const GTypeInfo info = {
559 sizeof (LttvTraceContextClass),
560 NULL, /* base_init */
561 NULL, /* base_finalize */
562 (GClassInitFunc) trace_context_class_init, /* class_init */
563 NULL, /* class_finalize */
564 NULL, /* class_data */
565 sizeof (LttvTraceContext),
566 0, /* n_preallocs */
567 (GInstanceInitFunc) trace_context_instance_init, /* instance_init */
568 NULL /* Value handling */
569 };
570
571 type = g_type_register_static (G_TYPE_OBJECT, "LttvTraceContextType",
572 &info, 0);
573 }
574 return type;
575 }
576
577
578 static void
579 tracefile_context_instance_init (GTypeInstance *instance, gpointer g_class)
580 {
581 /* Be careful of anything which would not work well with shallow copies */
582 }
583
584
585 static void
586 tracefile_context_finalize (LttvTracefileContext *self)
587 {
588 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACEFILE_CONTEXT_TYPE)))
589 ->finalize(G_OBJECT(self));
590 }
591
592
593 static void
594 tracefile_context_class_init (LttvTracefileContextClass *klass)
595 {
596 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
597
598 gobject_class->finalize = (void (*)(GObject *self))tracefile_context_finalize;
599 }
600
601
602 GType
603 lttv_tracefile_context_get_type(void)
604 {
605 static GType type = 0;
606 if (type == 0) {
607 static const GTypeInfo info = {
608 sizeof (LttvTracefileContextClass),
609 NULL, /* base_init */
610 NULL, /* base_finalize */
611 (GClassInitFunc) tracefile_context_class_init, /* class_init */
612 NULL, /* class_finalize */
613 NULL, /* class_data */
614 sizeof (LttvTracefileContext),
615 0, /* n_preallocs */
616 (GInstanceInitFunc) tracefile_context_instance_init, /* instance_init */
617 NULL /* Value handling */
618 };
619
620 type = g_type_register_static (G_TYPE_OBJECT, "LttvTracefileContextType",
621 &info, 0);
622 }
623 return type;
624 }
625
626
627
628 static gboolean get_first(gpointer key, gpointer value, gpointer user_data) {
629 g_assert(key == value);
630 *((LttvTracefileContext **)user_data) = (LttvTracefileContext *)value;
631 return TRUE;
632 }
633
634 #ifdef DEBUG
635 // Test to see if pqueue is traversed in the right order.
636 static LttTime test_time;
637
638 static gboolean test_tree(gpointer key, gpointer value, gpointer user_data) {
639
640 LttvTracefileContext *tfc = (LttvTracefileContext *)key;
641
642 g_debug("Tracefile name %s, time %lu.%lu, tfi %u, ti %u",
643 g_quark_to_string(ltt_tracefile_name(tfc->tf)),
644 tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec,
645 tfc->index, tfc->t_context->index);
646
647 if(user_data != NULL) {
648 if(((LttvTracefileContext *)user_data) == (LttvTracefileContext *)value) {
649 g_assert(compare_tracefile(user_data, value) == 0);
650 } else
651 g_assert(compare_tracefile(user_data, value) != 0);
652 }
653 g_assert(ltt_time_compare(test_time, tfc->timestamp) <= 0);
654 test_time.tv_sec = tfc->timestamp.tv_sec;
655 test_time.tv_nsec = tfc->timestamp.tv_nsec;
656
657
658 //g_assert(((LttvTracefileContext *)user_data) != (LttvTracefileContext *)value);
659 return FALSE;
660 }
661 #endif //DEBUG
662
663
664
665 void lttv_process_traceset_begin(LttvTracesetContext *self,
666 LttvHooks *before_traceset,
667 LttvHooks *before_trace,
668 LttvHooks *before_tracefile,
669 LttvHooks *event,
670 LttvHooksById *event_by_id)
671 {
672
673 /* simply add hooks in context. _before hooks are called by add_hooks. */
674 /* It calls all before_traceset, before_trace, and before_tracefile hooks. */
675 lttv_traceset_context_add_hooks(self,
676 before_traceset,
677 before_trace,
678 before_tracefile,
679 event,
680 event_by_id);
681
682 }
683
684 //enum read_state { LAST_NONE, LAST_OK, LAST_EMPTY };
685
686 /* Note : a _middle must be preceded from a _seek or another middle */
687 guint lttv_process_traceset_middle(LttvTracesetContext *self,
688 LttTime end,
689 guint nb_events,
690 const LttvTracesetContextPosition *end_position)
691 {
692 GTree *pqueue = self->pqueue;
693
694 guint fac_id, ev_id, id;
695
696 LttvTracefileContext *tfc;
697
698 LttEvent *e;
699
700 unsigned count = 0;
701
702 guint read_ret;
703
704 //enum read_state last_read_state = LAST_NONE;
705
706 gint last_ret = 0; /* return value of the last hook list called */
707
708 /* Get the next event from the pqueue, call its hooks,
709 reinsert in the pqueue the following event from the same tracefile
710 unless the tracefile is finished or the event is later than the
711 end time. */
712
713 while(TRUE) {
714 tfc = NULL;
715 g_tree_foreach(pqueue, get_first, &tfc);
716 /* End of traceset : tfc is NULL */
717 if(unlikely(tfc == NULL))
718 {
719 return count;
720 }
721
722 /* Have we reached :
723 * - the maximum number of events specified?
724 * - the end position ?
725 * - the end time ?
726 * then the read is finished. We leave the queue in the same state and
727 * break the loop.
728 */
729
730 if(unlikely(last_ret == TRUE ||
731 ((count >= nb_events) && (nb_events != G_MAXULONG)) ||
732 (end_position!=NULL&&lttv_traceset_context_ctx_pos_compare(self,
733 end_position) == 0)||
734 ltt_time_compare(end, tfc->timestamp) <= 0))
735 {
736 return count;
737 }
738
739 /* Get the tracefile with an event for the smallest time found. If two
740 or more tracefiles have events for the same time, hope that lookup
741 and remove are consistent. */
742
743 #ifdef DEBUG
744 test_time.tv_sec = 0;
745 test_time.tv_nsec = 0;
746 g_debug("test tree before remove");
747 g_tree_foreach(pqueue, test_tree, tfc);
748 #endif //DEBUG
749 g_tree_remove(pqueue, tfc);
750
751 #ifdef DEBUG
752 test_time.tv_sec = 0;
753 test_time.tv_nsec = 0;
754 g_debug("test tree after remove");
755 g_tree_foreach(pqueue, test_tree, tfc);
756 #endif //DEBUG
757
758
759 e = ltt_tracefile_get_event(tfc->tf);
760
761 //if(last_read_state != LAST_EMPTY) {
762 /* Only call hooks if the last read has given an event or if we are at the
763 * first pass (not if last read returned end of tracefile) */
764 count++;
765
766 fac_id = ltt_event_facility_id(e);
767 ev_id = ltt_event_eventtype_id(e);
768 id = GET_HOOK_ID(fac_id, ev_id);
769 tfc->target_pid = -1; /* unset target PID */
770 /* Hooks :
771 * return values : 0 : continue read, 1 : go to next position and stop read,
772 * 2 : stay at the current position and stop read */
773 last_ret = lttv_hooks_call_merge(tfc->event, tfc,
774 lttv_hooks_by_id_get(tfc->event_by_id, id), tfc);
775
776 #if 0
777 /* This is buggy : it won't work well with state computation */
778 if(unlikely(last_ret == 2)) {
779 /* This is a case where we want to stay at this position and stop read. */
780 g_tree_insert(pqueue, tfc, tfc);
781 return count - 1;
782 }
783 #endif //0
784 read_ret = ltt_tracefile_read(tfc->tf);
785
786
787 if(likely(!read_ret)) {
788 //g_debug("An event is ready");
789 tfc->timestamp = ltt_event_time(e);
790 g_assert(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0);
791 g_tree_insert(pqueue, tfc, tfc);
792 #ifdef DEBUG
793 test_time.tv_sec = 0;
794 test_time.tv_nsec = 0;
795 g_debug("test tree after event ready");
796 g_tree_foreach(pqueue, test_tree, NULL);
797 #endif //DEBUG
798
799 //last_read_state = LAST_OK;
800 } else {
801 tfc->timestamp = ltt_time_infinite;
802
803 if(read_ret == ERANGE) {
804 // last_read_state = LAST_EMPTY;
805 g_debug("End of trace");
806 } else
807 g_error("Error happened in lttv_process_traceset_middle");
808 }
809 }
810 }
811
812
813 void lttv_process_traceset_end(LttvTracesetContext *self,
814 LttvHooks *after_traceset,
815 LttvHooks *after_trace,
816 LttvHooks *after_tracefile,
817 LttvHooks *event,
818 LttvHooksById *event_by_id)
819 {
820 /* Remove hooks from context. _after hooks are called by remove_hooks. */
821 /* It calls all after_traceset, after_trace, and after_tracefile hooks. */
822 lttv_traceset_context_remove_hooks(self,
823 after_traceset,
824 after_trace,
825 after_tracefile,
826 event,
827 event_by_id);
828 }
829
830 /* Subtile modification :
831 * if tracefile has no event at or after the time requested, it is not put in
832 * the queue, as the next read would fail.
833 *
834 * Don't forget to empty the traceset pqueue before calling this.
835 */
836 void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start)
837 {
838 guint i, nb_tracefile;
839
840 gint ret;
841
842 LttvTracefileContext **tfc;
843
844 nb_tracefile = self->tracefiles->len;
845
846 GTree *pqueue = self->ts_context->pqueue;
847
848 for(i = 0 ; i < nb_tracefile ; i++) {
849 tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
850
851 g_tree_remove(pqueue, *tfc);
852
853 ret = ltt_tracefile_seek_time((*tfc)->tf, start);
854 if(ret == EPERM) g_error("error in lttv_process_trace_seek_time seek");
855
856 if(ret == 0) { /* not ERANGE especially */
857 (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf));
858 g_assert(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0);
859 g_tree_insert(pqueue, (*tfc), (*tfc));
860 } else {
861 (*tfc)->timestamp = ltt_time_infinite;
862 }
863 }
864 #ifdef DEBUG
865 test_time.tv_sec = 0;
866 test_time.tv_nsec = 0;
867 g_debug("test tree after seek_time");
868 g_tree_foreach(pqueue, test_tree, NULL);
869 #endif //DEBUG
870
871
872
873 }
874
875
876 void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start)
877 {
878 guint i, nb_trace;
879
880 LttvTraceContext *tc;
881
882 //g_tree_destroy(self->pqueue);
883 //self->pqueue = g_tree_new(compare_tracefile);
884
885 nb_trace = lttv_traceset_number(self->ts);
886 for(i = 0 ; i < nb_trace ; i++) {
887 tc = self->traces[i];
888 lttv_process_trace_seek_time(tc, start);
889 }
890 }
891
892
893 gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
894 const LttvTracesetContextPosition *pos)
895 {
896 guint i;
897 /* If a position is set, seek the traceset to this position */
898 if(ltt_time_compare(pos->timestamp, ltt_time_infinite) != 0) {
899
900 /* Test to see if the traces has been added to the trace set :
901 * It should NEVER happen. Clear all positions if a new trace comes in. */
902 /* FIXME I know this test is not optimal : should keep a number of
903 * tracefiles variable in the traceset.. eventually */
904 guint num_traces = lttv_traceset_number(self->ts);
905 guint tf_count = 0;
906 for(i=0; i<num_traces;i++) {
907 GArray * tracefiles = self->traces[i]->tracefiles;
908 guint j;
909 guint num_tracefiles = tracefiles->len;
910 for(j=0;j<num_tracefiles;j++)
911 tf_count++;
912 }
913 g_assert(tf_count == pos->tfcp->len);
914
915
916 //g_tree_destroy(self->pqueue);
917 //self->pqueue = g_tree_new(compare_tracefile);
918
919 for(i=0;i<pos->tfcp->len; i++) {
920 LttvTracefileContextPosition *tfcp =
921 &g_array_index(pos->tfcp, LttvTracefileContextPosition, i);
922
923 g_tree_remove(self->pqueue, tfcp->tfc);
924
925 if(tfcp->used == TRUE) {
926 if(ltt_tracefile_seek_position(tfcp->tfc->tf, tfcp->event) != 0)
927 return 1;
928 tfcp->tfc->timestamp =
929 ltt_event_time(ltt_tracefile_get_event(tfcp->tfc->tf));
930 g_assert(ltt_time_compare(tfcp->tfc->timestamp,
931 ltt_time_infinite) != 0);
932 g_tree_insert(self->pqueue, tfcp->tfc, tfcp->tfc);
933
934 } else {
935 tfcp->tfc->timestamp = ltt_time_infinite;
936 }
937 }
938 }
939 #ifdef DEBUG
940 test_time.tv_sec = 0;
941 test_time.tv_nsec = 0;
942 g_debug("test tree after seek_position");
943 g_tree_foreach(self->pqueue, test_tree, NULL);
944 #endif //DEBUG
945
946
947
948 return 0;
949 }
950
951
952
953 static LttField *
954 find_field(LttEventType *et, const GQuark field)
955 {
956 LttField *f;
957
958 if(field == 0) return NULL;
959
960 f = ltt_eventtype_field_by_name(et, field);
961 if (!f) {
962 g_warning("Cannot find field %s in event %s.%s", g_quark_to_string(field),
963 g_quark_to_string(ltt_facility_name(ltt_eventtype_facility(et))),
964 g_quark_to_string(ltt_eventtype_name(et)));
965 }
966
967 return f;
968 }
969
970 LttvTraceHookByFacility *lttv_trace_hook_get_fac(LttvTraceHook *th,
971 guint facility_id)
972 {
973 return &g_array_index(th->fac_index, LttvTraceHookByFacility, facility_id);
974 }
975
976 struct marker_info *lttv_trace_hook_get_marker(LttvTraceHook *th)
977 {
978 g_assert(th->fac_list->len > 0);
979 return g_array_index(th->fac_list, LttvTraceHookByFacility*, 0);
980 }
981
982
983 /* Returns 0 on success, -1 if fails. */
984 gint
985 lttv_trace_find_hook(LttTrace *t, GQuark event,
986 GQuark field1, GQuark field2, GQuark field3, LttvHook h, gpointer hook_data,
987 LttvTraceHook *th)
988 {
989 LttEventType *et, *first_et;
990
991 struct marker_info *info;
992
993 guint i, ev_id;
994
995 head = marker_get_info_from_name(t, event);
996
997 if(unlikely(head == NULL))
998 goto facility_error;
999
1000 ev_id = marker_get_id_from_info(t, info);
1001
1002 th->h = h;
1003 th->id = ev_id;
1004 th->f1 = find_field(et, field1);
1005 th->f2 = find_field(et, field2);
1006 th->f3 = find_field(et, field3);
1007 th->hook_data = hook_data;
1008
1009 first_thf = thf;
1010 first_et = et;
1011
1012 /* Check for type compatibility too */
1013 for(i=1;i<facilities->len;i++) {
1014 fac_id = g_array_index(facilities, guint, i);
1015 f = ltt_trace_get_facility_by_num(t, fac_id);
1016
1017 et = ltt_facility_eventtype_get_by_name(f, event);
1018 if(unlikely(et == NULL)) goto event_error;
1019
1020 thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
1021 g_array_index(th->fac_list, LttvTraceHookByFacility*, i) = thf;
1022 ev_id = ltt_eventtype_id(et);
1023 thf->h = h;
1024 thf->id = GET_HOOK_ID(fac_id, ev_id);
1025 thf->f1 = find_field(et, field1);
1026 if(check_fields_compatibility(first_et, et,
1027 first_thf->f1, thf->f1))
1028 goto type_error;
1029
1030 thf->f2 = find_field(et, field2);
1031 if(check_fields_compatibility(first_et, et,
1032 first_thf->f2, thf->f2))
1033 goto type_error;
1034
1035 thf->f3 = find_field(et, field3);
1036 if(check_fields_compatibility(first_et, et,
1037 first_thf->f3, thf->f3))
1038 goto type_error;
1039 thf->hook_data = hook_data;
1040 }
1041
1042 return 0;
1043
1044 type_error:
1045 goto free;
1046 event_error:
1047 g_error("Event type does not exist for event %s",
1048 g_quark_to_string(event));
1049 goto free;
1050 facility_error:
1051 //Ignore this type of error : some facilities are not required.
1052 //g_error("No %s facility", g_quark_to_string(facility));
1053 return -1;
1054 free:
1055 g_array_free(th->fac_index, TRUE);
1056 g_array_free(th->fac_list, TRUE);
1057 th->fac_index = NULL;
1058 th->fac_list = NULL;
1059 return -1;
1060 }
1061
1062 void lttv_trace_hook_destroy(LttvTraceHook *th)
1063 {
1064 g_array_free(th->fac_index, TRUE);
1065 g_array_free(th->fac_list, TRUE);
1066 }
1067
1068
1069
1070
1071 LttvTracesetContextPosition *lttv_traceset_context_position_new(
1072 const LttvTracesetContext *self)
1073 {
1074 guint num_traces = lttv_traceset_number(self->ts);
1075 guint tf_count = 0;
1076 guint i;
1077
1078 for(i=0; i<num_traces;i++) {
1079 GArray * tracefiles = self->traces[i]->tracefiles;
1080 guint j;
1081 guint num_tracefiles = tracefiles->len;
1082 for(j=0;j<num_tracefiles;j++)
1083 tf_count++;
1084 }
1085 LttvTracesetContextPosition *pos =
1086 g_new(LttvTracesetContextPosition, 1);
1087 pos->tfcp = g_array_sized_new(FALSE, TRUE,
1088 sizeof(LttvTracefileContextPosition),
1089 tf_count);
1090 g_array_set_size(pos->tfcp, tf_count);
1091 for(i=0;i<pos->tfcp->len;i++) {
1092 LttvTracefileContextPosition *tfcp =
1093 &g_array_index(pos->tfcp, LttvTracefileContextPosition, i);
1094 tfcp->event = ltt_event_position_new();
1095 }
1096
1097 pos->timestamp = ltt_time_infinite;
1098 return pos;
1099 }
1100
1101 /* Save all positions, the ones with infinite time will have NULL
1102 * ep. */
1103 /* note : a position must be destroyed when a trace is added/removed from a
1104 * traceset */
1105 void lttv_traceset_context_position_save(const LttvTracesetContext *self,
1106 LttvTracesetContextPosition *pos)
1107 {
1108 guint i;
1109 guint num_traces = lttv_traceset_number(self->ts);
1110 guint tf_count = 0;
1111
1112 pos->timestamp = ltt_time_infinite;
1113
1114 for(i=0; i<num_traces;i++) {
1115 GArray * tracefiles = self->traces[i]->tracefiles;
1116 guint j;
1117 guint num_tracefiles = tracefiles->len;
1118
1119 for(j=0;j<num_tracefiles;j++) {
1120 g_assert(tf_count < pos->tfcp->len);
1121 LttvTracefileContext **tfc = &g_array_index(tracefiles,
1122 LttvTracefileContext*, j);
1123 LttvTracefileContextPosition *tfcp =
1124 &g_array_index(pos->tfcp, LttvTracefileContextPosition, tf_count);
1125
1126 tfcp->tfc = *tfc;
1127
1128 if(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0) {
1129 LttEvent *event = ltt_tracefile_get_event((*tfc)->tf);
1130 ltt_event_position(event, tfcp->event);
1131 if(ltt_time_compare((*tfc)->timestamp, pos->timestamp) < 0)
1132 pos->timestamp = (*tfc)->timestamp;
1133 tfcp->used = TRUE;
1134 } else {
1135 tfcp->used = FALSE;
1136 }
1137
1138 //g_array_append_val(pos->tfc, *tfc);
1139 //g_array_append_val(pos->ep, ep);
1140 tf_count++;
1141 }
1142
1143 }
1144 }
1145
1146 void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos)
1147 {
1148 int i;
1149
1150 for(i=0;i<pos->tfcp->len;i++) {
1151 LttvTracefileContextPosition *tfcp =
1152 &g_array_index(pos->tfcp, LttvTracefileContextPosition, i);
1153 g_free(tfcp->event);
1154 tfcp->event = NULL;
1155 tfcp->used = FALSE;
1156 }
1157 g_array_free(pos->tfcp, TRUE);
1158 g_free(pos);
1159 }
1160
1161 void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
1162 const LttvTracesetContextPosition *src)
1163 {
1164 int i;
1165 LttvTracefileContextPosition *src_tfcp, *dest_tfcp;
1166
1167 g_assert(src->tfcp->len == src->tfcp->len);
1168
1169 for(i=0;i<src->tfcp->len;i++) {
1170 src_tfcp =
1171 &g_array_index(src->tfcp, LttvTracefileContextPosition, i);
1172 dest_tfcp =
1173 &g_array_index(dest->tfcp, LttvTracefileContextPosition, i);
1174
1175 dest_tfcp->used = src_tfcp->used;
1176 dest_tfcp->tfc = src_tfcp->tfc;
1177
1178 if(src_tfcp->used) {
1179 ltt_event_position_copy(
1180 dest_tfcp->event,
1181 src_tfcp->event);
1182 }
1183 }
1184 dest->timestamp = src->timestamp;
1185 }
1186
1187 gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
1188 const LttvTracesetContextPosition *pos)
1189 {
1190 int i;
1191 int ret = 0;
1192
1193 if(pos->tfcp->len == 0) {
1194 if(lttv_traceset_number(self->ts) == 0) return 0;
1195 else return 1;
1196 }
1197 if(lttv_traceset_number(self->ts) == 0)
1198 return -1;
1199
1200 for(i=0;i<pos->tfcp->len;i++) {
1201 LttvTracefileContextPosition *tfcp =
1202 &g_array_index(pos->tfcp, LttvTracefileContextPosition, i);
1203
1204 if(tfcp->used == FALSE) {
1205 if(ltt_time_compare(tfcp->tfc->timestamp, ltt_time_infinite) < 0) {
1206 ret = -1;
1207 }
1208 } else {
1209 if(ltt_time_compare(tfcp->tfc->timestamp, ltt_time_infinite) == 0) {
1210 ret = 1;
1211 } else {
1212 LttEvent *event = ltt_tracefile_get_event(tfcp->tfc->tf);
1213
1214 ret = ltt_event_position_compare((LttEventPosition*)event,
1215 tfcp->event);
1216 }
1217 }
1218 if(ret != 0) return ret;
1219
1220 }
1221 return 0;
1222 }
1223
1224
1225 gint lttv_traceset_context_pos_pos_compare(
1226 const LttvTracesetContextPosition *pos1,
1227 const LttvTracesetContextPosition *pos2)
1228 {
1229 int i, j;
1230 int ret = 0;
1231
1232 if(ltt_time_compare(pos1->timestamp, ltt_time_infinite) == 0) {
1233 if(ltt_time_compare(pos2->timestamp, ltt_time_infinite) == 0)
1234 return 0;
1235 else
1236 return 1;
1237 }
1238 if(ltt_time_compare(pos2->timestamp, ltt_time_infinite) == 0)
1239 return -1;
1240
1241 for(i=0;i<pos1->tfcp->len;i++) {
1242 LttvTracefileContextPosition *tfcp1 =
1243 &g_array_index(pos1->tfcp, LttvTracefileContextPosition, i);
1244
1245 if(tfcp1->used == TRUE) {
1246 for(j=0;j<pos2->tfcp->len;j++) {
1247 LttvTracefileContextPosition *tfcp2 =
1248 &g_array_index(pos2->tfcp, LttvTracefileContextPosition, j);
1249
1250 if(tfcp1->tfc == tfcp2->tfc) {
1251 if(tfcp2->used == TRUE)
1252 ret = ltt_event_position_compare(tfcp1->event, tfcp2->event);
1253 else
1254 ret = -1;
1255
1256 if(ret != 0) return ret;
1257 }
1258 }
1259
1260 } else {
1261 for(j=0;j<pos2->tfcp->len;j++) {
1262 LttvTracefileContextPosition *tfcp2 =
1263 &g_array_index(pos2->tfcp, LttvTracefileContextPosition, j);
1264
1265 if(tfcp1->tfc == tfcp2->tfc)
1266 if(tfcp2->used == TRUE) ret = 1;
1267 if(ret != 0) return ret;
1268 }
1269 }
1270 }
1271 return 0;
1272 }
1273
1274
1275 LttTime lttv_traceset_context_position_get_time(
1276 const LttvTracesetContextPosition *pos)
1277 {
1278 return pos->timestamp;
1279 }
1280
1281
1282 LttvTracefileContext *lttv_traceset_context_get_current_tfc(LttvTracesetContext *self)
1283 {
1284 GTree *pqueue = self->pqueue;
1285 LttvTracefileContext *tfc = NULL;
1286
1287 g_tree_foreach(pqueue, get_first, &tfc);
1288
1289 return tfc;
1290 }
1291
1292 /* lttv_process_traceset_synchronize_tracefiles
1293 *
1294 * Use the sync_position field of the trace set context to synchronize each
1295 * tracefile with the previously saved position.
1296 *
1297 * If no previous position has been saved, it simply does nothing.
1298 */
1299 void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *tsc)
1300 {
1301 g_assert(lttv_process_traceset_seek_position(tsc, tsc->sync_position) == 0);
1302 }
1303
1304
1305
1306
1307 void lttv_process_traceset_get_sync_data(LttvTracesetContext *tsc)
1308 {
1309 lttv_traceset_context_position_save(tsc, tsc->sync_position);
1310 }
1311
1312 struct seek_back_data {
1313 guint first_event; /* Index of the first event in the array : we will always
1314 overwrite at this position : this is a circular array.
1315 */
1316 guint events_found;
1317 guint n; /* number of events requested */
1318 GPtrArray *array; /* array of LttvTracesetContextPositions pointers */
1319 LttvFilter *filter1;
1320 LttvFilter *filter2;
1321 LttvFilter *filter3;
1322 gpointer data;
1323 check_handler *check;
1324 gboolean *stop_flag;
1325 guint raw_event_count;
1326 };
1327
1328 static gint seek_back_event_hook(void *hook_data, void* call_data)
1329 {
1330 struct seek_back_data *sd = (struct seek_back_data*)hook_data;
1331 LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1332 LttvTracesetContext *tsc = tfc->t_context->ts_context;
1333 LttvTracesetContextPosition *pos;
1334
1335 if(sd->check && sd->check(sd->raw_event_count, sd->stop_flag, sd->data))
1336 return TRUE;
1337 sd->raw_event_count++;
1338
1339 if(sd->filter1 != NULL && sd->filter1->head != NULL &&
1340 !lttv_filter_tree_parse(sd->filter1->head,
1341 ltt_tracefile_get_event(tfc->tf),
1342 tfc->tf,
1343 tfc->t_context->t,
1344 tfc,NULL,NULL)) {
1345 return FALSE;
1346 }
1347 if(sd->filter2 != NULL && sd->filter2->head != NULL &&
1348 !lttv_filter_tree_parse(sd->filter2->head,
1349 ltt_tracefile_get_event(tfc->tf),
1350 tfc->tf,
1351 tfc->t_context->t,
1352 tfc,NULL,NULL)) {
1353 return FALSE;
1354 }
1355 if(sd->filter3 != NULL && sd->filter3->head != NULL &&
1356 !lttv_filter_tree_parse(sd->filter3->head,
1357 ltt_tracefile_get_event(tfc->tf),
1358 tfc->tf,
1359 tfc->t_context->t,
1360 tfc,NULL,NULL)) {
1361 return FALSE;
1362 }
1363
1364 pos = (LttvTracesetContextPosition*)g_ptr_array_index (sd->array,
1365 sd->first_event);
1366
1367 lttv_traceset_context_position_save(tsc, pos);
1368
1369 if(sd->first_event >= sd->array->len - 1) sd->first_event = 0;
1370 else sd->first_event++;
1371
1372 sd->events_found = min(sd->n, sd->events_found + 1);
1373
1374 return FALSE;
1375 }
1376
1377 /* Seek back n events back from the current position.
1378 *
1379 * Parameters :
1380 * @self The trace set context
1381 * @n number of events to jump over
1382 * @first_offset The initial offset value used.
1383 * never put first_offset at ltt_time_zero.
1384 * @time_seeker Function pointer of the function to use to seek time :
1385 * either lttv_process_traceset_seek_time
1386 * or lttv_state_traceset_seek_time_closest
1387 * @filter The filter to call.
1388 *
1389 * Return value : the number of events found (might be lower than the number
1390 * requested if beginning of traceset is reached).
1391 *
1392 * The first search will go back first_offset and try to find the last n events
1393 * matching the filter. If there are not enough, it will try to go back from the
1394 * new trace point from first_offset*2, and so on, until beginning of trace or n
1395 * events are found.
1396 *
1397 * Note : this function does not take in account the LttvFilter : use the
1398 * similar function found in state.c instead.
1399 *
1400 * Note2 : the caller must make sure that the LttvTracesetContext does not
1401 * contain any hook, as process_traceset_middle is used in this routine.
1402 */
1403 guint lttv_process_traceset_seek_n_backward(LttvTracesetContext *self,
1404 guint n, LttTime first_offset,
1405 seek_time_fct time_seeker,
1406 check_handler *check,
1407 gboolean *stop_flag,
1408 LttvFilter *filter1,
1409 LttvFilter *filter2,
1410 LttvFilter *filter3,
1411 gpointer data)
1412 {
1413 if(lttv_traceset_number(self->ts) == 0) return 0;
1414 g_assert(ltt_time_compare(first_offset, ltt_time_zero) != 0);
1415
1416 guint i;
1417 LttvTracesetContextPosition *next_iter_end_pos =
1418 lttv_traceset_context_position_new(self);
1419 LttvTracesetContextPosition *end_pos =
1420 lttv_traceset_context_position_new(self);
1421 LttvTracesetContextPosition *saved_pos =
1422 lttv_traceset_context_position_new(self);
1423 LttTime time;
1424 LttTime asked_time;
1425 LttTime time_offset;
1426 struct seek_back_data sd;
1427 LttvHooks *hooks = lttv_hooks_new();
1428
1429 sd.first_event = 0;
1430 sd.events_found = 0;
1431 sd.array = g_ptr_array_sized_new(n);
1432 sd.filter1 = filter1;
1433 sd.filter2 = filter2;
1434 sd.filter3 = filter3;
1435 sd.data = data;
1436 sd.n = n;
1437 sd.check = check;
1438 sd.stop_flag = stop_flag;
1439 sd.raw_event_count = 0;
1440 g_ptr_array_set_size(sd.array, n);
1441 for(i=0;i<n;i++) {
1442 g_ptr_array_index (sd.array, i) = lttv_traceset_context_position_new(self);
1443 }
1444
1445 lttv_traceset_context_position_save(self, next_iter_end_pos);
1446 lttv_traceset_context_position_save(self, saved_pos);
1447 /* Get the current time from which we will offset */
1448 time = lttv_traceset_context_position_get_time(next_iter_end_pos);
1449 /* the position saved might be end of traceset... */
1450 if(ltt_time_compare(time, self->time_span.end_time) > 0) {
1451 time = self->time_span.end_time;
1452 }
1453 asked_time = time;
1454 time_offset = first_offset;
1455
1456 lttv_hooks_add(hooks, seek_back_event_hook, &sd, LTTV_PRIO_DEFAULT);
1457
1458 lttv_process_traceset_begin(self, NULL, NULL, NULL, hooks, NULL);
1459
1460 while(1) {
1461 /* stop criteria : - n events found
1462 * - asked_time < beginning of trace */
1463 if(ltt_time_compare(asked_time, self->time_span.start_time) < 0) break;
1464
1465 lttv_traceset_context_position_copy(end_pos, next_iter_end_pos);
1466
1467 /* We must seek the traceset back to time - time_offset */
1468 /* this time becomes the new reference time */
1469 time = ltt_time_sub(time, time_offset);
1470 asked_time = time;
1471
1472 time_seeker(self, time);
1473 lttv_traceset_context_position_save(self, next_iter_end_pos);
1474 /* Resync the time in case of a seek_closest */
1475 time = lttv_traceset_context_position_get_time(next_iter_end_pos);
1476 if(ltt_time_compare(time, self->time_span.end_time) > 0) {
1477 time = self->time_span.end_time;
1478 }
1479
1480 /* Process the traceset, calling a hook which adds events
1481 * to the array, overwriting the tail. It changes first_event and
1482 * events_found too. */
1483 /* We would like to have a clean context here : no other hook than our's */
1484
1485 lttv_process_traceset_middle(self, ltt_time_infinite,
1486 G_MAXUINT, end_pos);
1487
1488 if(sd.events_found < n) {
1489 if(sd.first_event > 0) {
1490 /* Save the first position */
1491 LttvTracesetContextPosition *pos =
1492 (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, 0);
1493 lttv_traceset_context_position_copy(saved_pos, pos);
1494 }
1495 g_assert(n-sd.events_found <= sd.array->len);
1496 /* Change array size to n - events_found */
1497 for(i=n-sd.events_found;i<sd.array->len;i++) {
1498 LttvTracesetContextPosition *pos =
1499 (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, i);
1500 lttv_traceset_context_position_destroy(pos);
1501 }
1502 g_ptr_array_set_size(sd.array, n-sd.events_found);
1503 sd.first_event = 0;
1504
1505 } else break; /* Second end criterion : n events found */
1506
1507 time_offset = ltt_time_mul(time_offset, BACKWARD_SEEK_MUL);
1508 }
1509
1510 lttv_traceset_context_position_destroy(end_pos);
1511 lttv_traceset_context_position_destroy(next_iter_end_pos);
1512
1513 lttv_process_traceset_end(self, NULL, NULL, NULL, hooks, NULL);
1514
1515 if(sd.events_found >= n) {
1516 /* Seek the traceset to the first event in the circular array */
1517 LttvTracesetContextPosition *pos =
1518 (LttvTracesetContextPosition*)g_ptr_array_index (sd.array,
1519 sd.first_event);
1520 g_assert(lttv_process_traceset_seek_position(self, pos) == 0);
1521 } else {
1522 /* Will seek to the last saved position : in the worst case, it will be the
1523 * original position (if events_found is 0) */
1524 g_assert(lttv_process_traceset_seek_position(self, saved_pos) == 0);
1525 }
1526
1527 for(i=0;i<sd.array->len;i++) {
1528 LttvTracesetContextPosition *pos =
1529 (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, i);
1530 lttv_traceset_context_position_destroy(pos);
1531 }
1532 g_ptr_array_free(sd.array, TRUE);
1533
1534 lttv_hooks_destroy(hooks);
1535
1536 lttv_traceset_context_position_destroy(saved_pos);
1537
1538 return sd.events_found;
1539 }
1540
1541
1542 struct seek_forward_data {
1543 guint event_count; /* event counter */
1544 guint n; /* requested number of events to jump over */
1545 LttvFilter *filter1;
1546 LttvFilter *filter2;
1547 LttvFilter *filter3;
1548 gpointer data;
1549 check_handler *check;
1550 gboolean *stop_flag;
1551 guint raw_event_count; /* event counter */
1552 };
1553
1554 static gint seek_forward_event_hook(void *hook_data, void* call_data)
1555 {
1556 struct seek_forward_data *sd = (struct seek_forward_data*)hook_data;
1557 LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1558
1559 if(sd->check && sd->check(sd->raw_event_count, sd->stop_flag, sd->data))
1560 return TRUE;
1561 sd->raw_event_count++;
1562
1563 if(sd->filter1 != NULL && sd->filter1->head != NULL &&
1564 !lttv_filter_tree_parse(sd->filter1->head,
1565 ltt_tracefile_get_event(tfc->tf),
1566 tfc->tf,
1567 tfc->t_context->t,
1568 tfc,NULL,NULL)) {
1569 return FALSE;
1570 }
1571 if(sd->filter2 != NULL && sd->filter2->head != NULL &&
1572 !lttv_filter_tree_parse(sd->filter2->head,
1573 ltt_tracefile_get_event(tfc->tf),
1574 tfc->tf,
1575 tfc->t_context->t,
1576 tfc,NULL,NULL)) {
1577 return FALSE;
1578 }
1579 if(sd->filter3 != NULL && sd->filter3->head != NULL &&
1580 !lttv_filter_tree_parse(sd->filter3->head,
1581 ltt_tracefile_get_event(tfc->tf),
1582 tfc->tf,
1583 tfc->t_context->t,
1584 tfc,NULL,NULL)) {
1585 return FALSE;
1586 }
1587
1588 sd->event_count++;
1589 if(sd->event_count >= sd->n)
1590 return TRUE;
1591 }
1592
1593 /* Seek back n events forward from the current position (1 to n)
1594 * 0 is ok too, but it will actually do nothing.
1595 *
1596 * Parameters :
1597 * @self the trace set context
1598 * @n number of events to jump over
1599 * @filter filter to call.
1600 *
1601 * returns : the number of events jumped over (may be less than requested if end
1602 * of traceset reached) */
1603 guint lttv_process_traceset_seek_n_forward(LttvTracesetContext *self,
1604 guint n,
1605 check_handler *check,
1606 gboolean *stop_flag,
1607 LttvFilter *filter1,
1608 LttvFilter *filter2,
1609 LttvFilter *filter3,
1610 gpointer data)
1611 {
1612 struct seek_forward_data sd;
1613 sd.event_count = 0;
1614 sd.n = n;
1615 sd.filter1 = filter1;
1616 sd.filter2 = filter2;
1617 sd.filter3 = filter3;
1618 sd.data = data;
1619 sd.check = check;
1620 sd.stop_flag = stop_flag;
1621 sd.raw_event_count = 0;
1622
1623 if(sd.event_count >= sd.n) return sd.event_count;
1624
1625 LttvHooks *hooks = lttv_hooks_new();
1626
1627 lttv_hooks_add(hooks, seek_forward_event_hook, &sd, LTTV_PRIO_DEFAULT);
1628
1629 lttv_process_traceset_begin(self, NULL, NULL, NULL, hooks, NULL);
1630
1631 /* it will end on the end of traceset, or the fact that the
1632 * hook returns TRUE.
1633 */
1634 lttv_process_traceset_middle(self, ltt_time_infinite,
1635 G_MAXUINT, NULL);
1636
1637 /* Here, our position is either the end of traceset, or the exact position
1638 * after n events : leave it like this. This might be placed on an event that
1639 * will be filtered out, we don't care : all we know is that the following
1640 * event filtered in will be the right one. */
1641
1642 lttv_process_traceset_end(self, NULL, NULL, NULL, hooks, NULL);
1643
1644 lttv_hooks_destroy(hooks);
1645
1646 return sd.event_count;
1647 }
1648
1649
LTTng 2.x Viewer (LTTV)
This page took 0.065599 seconds and 5 git commands to generate.