projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
tracecontext.c: start conversion
[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 LttvTracefileContext *tfc;
695
696 LttEvent *e;
697
698 unsigned count = 0;
699
700 guint read_ret;
701
702 //enum read_state last_read_state = LAST_NONE;
703
704 gint last_ret = 0; /* return value of the last hook list called */
705
706 /* Get the next event from the pqueue, call its hooks,
707 reinsert in the pqueue the following event from the same tracefile
708 unless the tracefile is finished or the event is later than the
709 end time. */
710
711 while(TRUE) {
712 tfc = NULL;
713 g_tree_foreach(pqueue, get_first, &tfc);
714 /* End of traceset : tfc is NULL */
715 if(unlikely(tfc == NULL))
716 {
717 return count;
718 }
719
720 /* Have we reached :
721 * - the maximum number of events specified?
722 * - the end position ?
723 * - the end time ?
724 * then the read is finished. We leave the queue in the same state and
725 * break the loop.
726 */
727
728 if(unlikely(last_ret == TRUE ||
729 ((count >= nb_events) && (nb_events != G_MAXULONG)) ||
730 (end_position!=NULL&&lttv_traceset_context_ctx_pos_compare(self,
731 end_position) == 0)||
732 ltt_time_compare(end, tfc->timestamp) <= 0))
733 {
734 return count;
735 }
736
737 /* Get the tracefile with an event for the smallest time found. If two
738 or more tracefiles have events for the same time, hope that lookup
739 and remove are consistent. */
740
741 #ifdef DEBUG
742 test_time.tv_sec = 0;
743 test_time.tv_nsec = 0;
744 g_debug("test tree before remove");
745 g_tree_foreach(pqueue, test_tree, tfc);
746 #endif //DEBUG
747 g_tree_remove(pqueue, tfc);
748
749 #ifdef DEBUG
750 test_time.tv_sec = 0;
751 test_time.tv_nsec = 0;
752 g_debug("test tree after remove");
753 g_tree_foreach(pqueue, test_tree, tfc);
754 #endif //DEBUG
755
756
757 e = ltt_tracefile_get_event(tfc->tf);
758
759 //if(last_read_state != LAST_EMPTY) {
760 /* Only call hooks if the last read has given an event or if we are at the
761 * first pass (not if last read returned end of tracefile) */
762 count++;
763
764 tfc->target_pid = -1; /* unset target PID */
765 /* Hooks :
766 * return values : 0 : continue read, 1 : go to next position and stop read,
767 * 2 : stay at the current position and stop read */
768 last_ret = lttv_hooks_call_merge(tfc->event, tfc,
769 lttv_hooks_by_id_get(tfc->event_by_id, e->event_id), tfc);
770
771 #if 0
772 /* This is buggy : it won't work well with state computation */
773 if(unlikely(last_ret == 2)) {
774 /* This is a case where we want to stay at this position and stop read. */
775 g_tree_insert(pqueue, tfc, tfc);
776 return count - 1;
777 }
778 #endif //0
779 read_ret = ltt_tracefile_read(tfc->tf);
780
781
782 if(likely(!read_ret)) {
783 //g_debug("An event is ready");
784 tfc->timestamp = ltt_event_time(e);
785 g_assert(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0);
786 g_tree_insert(pqueue, tfc, tfc);
787 #ifdef DEBUG
788 test_time.tv_sec = 0;
789 test_time.tv_nsec = 0;
790 g_debug("test tree after event ready");
791 g_tree_foreach(pqueue, test_tree, NULL);
792 #endif //DEBUG
793
794 //last_read_state = LAST_OK;
795 } else {
796 tfc->timestamp = ltt_time_infinite;
797
798 if(read_ret == ERANGE) {
799 // last_read_state = LAST_EMPTY;
800 g_debug("End of trace");
801 } else
802 g_error("Error happened in lttv_process_traceset_middle");
803 }
804 }
805 }
806
807
808 void lttv_process_traceset_end(LttvTracesetContext *self,
809 LttvHooks *after_traceset,
810 LttvHooks *after_trace,
811 LttvHooks *after_tracefile,
812 LttvHooks *event,
813 LttvHooksById *event_by_id)
814 {
815 /* Remove hooks from context. _after hooks are called by remove_hooks. */
816 /* It calls all after_traceset, after_trace, and after_tracefile hooks. */
817 lttv_traceset_context_remove_hooks(self,
818 after_traceset,
819 after_trace,
820 after_tracefile,
821 event,
822 event_by_id);
823 }
824
825 /* Subtile modification :
826 * if tracefile has no event at or after the time requested, it is not put in
827 * the queue, as the next read would fail.
828 *
829 * Don't forget to empty the traceset pqueue before calling this.
830 */
831 void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start)
832 {
833 guint i, nb_tracefile;
834
835 gint ret;
836
837 LttvTracefileContext **tfc;
838
839 nb_tracefile = self->tracefiles->len;
840
841 GTree *pqueue = self->ts_context->pqueue;
842
843 for(i = 0 ; i < nb_tracefile ; i++) {
844 tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
845
846 g_tree_remove(pqueue, *tfc);
847
848 ret = ltt_tracefile_seek_time((*tfc)->tf, start);
849 if(ret == EPERM) g_error("error in lttv_process_trace_seek_time seek");
850
851 if(ret == 0) { /* not ERANGE especially */
852 (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf));
853 g_assert(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0);
854 g_tree_insert(pqueue, (*tfc), (*tfc));
855 } else {
856 (*tfc)->timestamp = ltt_time_infinite;
857 }
858 }
859 #ifdef DEBUG
860 test_time.tv_sec = 0;
861 test_time.tv_nsec = 0;
862 g_debug("test tree after seek_time");
863 g_tree_foreach(pqueue, test_tree, NULL);
864 #endif //DEBUG
865
866
867
868 }
869
870
871 void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start)
872 {
873 guint i, nb_trace;
874
875 LttvTraceContext *tc;
876
877 //g_tree_destroy(self->pqueue);
878 //self->pqueue = g_tree_new(compare_tracefile);
879
880 nb_trace = lttv_traceset_number(self->ts);
881 for(i = 0 ; i < nb_trace ; i++) {
882 tc = self->traces[i];
883 lttv_process_trace_seek_time(tc, start);
884 }
885 }
886
887
888 gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
889 const LttvTracesetContextPosition *pos)
890 {
891 guint i;
892 /* If a position is set, seek the traceset to this position */
893 if(ltt_time_compare(pos->timestamp, ltt_time_infinite) != 0) {
894
895 /* Test to see if the traces has been added to the trace set :
896 * It should NEVER happen. Clear all positions if a new trace comes in. */
897 /* FIXME I know this test is not optimal : should keep a number of
898 * tracefiles variable in the traceset.. eventually */
899 guint num_traces = lttv_traceset_number(self->ts);
900 guint tf_count = 0;
901 for(i=0; i<num_traces;i++) {
902 GArray * tracefiles = self->traces[i]->tracefiles;
903 guint j;
904 guint num_tracefiles = tracefiles->len;
905 for(j=0;j<num_tracefiles;j++)
906 tf_count++;
907 }
908 g_assert(tf_count == pos->tfcp->len);
909
910
911 //g_tree_destroy(self->pqueue);
912 //self->pqueue = g_tree_new(compare_tracefile);
913
914 for(i=0;i<pos->tfcp->len; i++) {
915 LttvTracefileContextPosition *tfcp =
916 &g_array_index(pos->tfcp, LttvTracefileContextPosition, i);
917
918 g_tree_remove(self->pqueue, tfcp->tfc);
919
920 if(tfcp->used == TRUE) {
921 if(ltt_tracefile_seek_position(tfcp->tfc->tf, tfcp->event) != 0)
922 return 1;
923 tfcp->tfc->timestamp =
924 ltt_event_time(ltt_tracefile_get_event(tfcp->tfc->tf));
925 g_assert(ltt_time_compare(tfcp->tfc->timestamp,
926 ltt_time_infinite) != 0);
927 g_tree_insert(self->pqueue, tfcp->tfc, tfcp->tfc);
928
929 } else {
930 tfcp->tfc->timestamp = ltt_time_infinite;
931 }
932 }
933 }
934 #ifdef DEBUG
935 test_time.tv_sec = 0;
936 test_time.tv_nsec = 0;
937 g_debug("test tree after seek_position");
938 g_tree_foreach(self->pqueue, test_tree, NULL);
939 #endif //DEBUG
940
941
942
943 return 0;
944 }
945
946
947 #if 0 // pmf: temporary disable
948 static LttField *
949 find_field(LttEventType *et, const GQuark field)
950 {
951 LttField *f;
952
953 if(field == 0) return NULL;
954
955 f = ltt_eventtype_field_by_name(et, field);
956 if (!f) {
957 g_warning("Cannot find field %s in event %s.%s", g_quark_to_string(field),
958 g_quark_to_string(ltt_facility_name(ltt_eventtype_facility(et))),
959 g_quark_to_string(ltt_eventtype_name(et)));
960 }
961
962 return f;
963 }
964 #endif
965
966 struct marker_info *lttv_trace_hook_get_marker(LttTrace *t, LttvTraceHook *th)
967 {
968 return marker_get_info_from_id(t, th->id);
969 }
970
971
972 /* Returns 0 on success, -1 if fails. */
973 gint
974 lttv_trace_find_hook(LttTrace *t, GQuark event,
975 GQuark field1, GQuark field2, GQuark field3, LttvHook h, gpointer hook_data,
976 LttvTraceHook *th)
977 {
978 // LttEventType *et, *first_et;
979
980 struct marker_info *info;
981
982 guint i, ev_id;
983
984 info = marker_get_info_from_name(t, event);
985
986 if(unlikely(info == NULL))
987 goto facility_error;
988
989 ev_id = marker_get_id_from_info(t, info);
990
991 th->h = h;
992 th->id = ev_id;
993 th->f1 = find_field(et, field1);
994 th->f2 = find_field(et, field2);
995 th->f3 = find_field(et, field3);
996 th->hook_data = hook_data;
997
998 // first_thf = thf;
999 // first_et = et;
1000
1001 /* Check for type compatibility too */
1002 // for(i=1;i<facilities->len;i++) {
1003 // fac_id = g_array_index(facilities, guint, i);
1004 // f = ltt_trace_get_facility_by_num(t, fac_id);
1005
1006 // et = ltt_facility_eventtype_get_by_name(f, event);
1007 // if(unlikely(et == NULL)) goto event_error;
1008
1009 // thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
1010 // g_array_index(th->fac_list, LttvTraceHookByFacility*, i) = thf;
1011 // ev_id = ltt_eventtype_id(et);
1012 thf->h = h;
1013 thf->id = GET_HOOK_ID(fac_id, ev_id);
1014 thf->f1 = find_field(et, field1);
1015 if(check_fields_compatibility(first_et, et,
1016 first_thf->f1, thf->f1))
1017 goto type_error;
1018
1019 thf->f2 = find_field(et, field2);
1020 if(check_fields_compatibility(first_et, et,
1021 first_thf->f2, thf->f2))
1022 goto type_error;
1023
1024 thf->f3 = find_field(et, field3);
1025 if(check_fields_compatibility(first_et, et,
1026 first_thf->f3, thf->f3))
1027 goto type_error;
1028 thf->hook_data = hook_data;
1029 // }
1030
1031 return 0;
1032
1033 type_error:
1034 goto free;
1035 event_error:
1036 g_error("Event type does not exist for event %s",
1037 g_quark_to_string(event));
1038 goto free;
1039 facility_error:
1040 //Ignore this type of error : some facilities are not required.
1041 //g_error("No %s facility", g_quark_to_string(facility));
1042 return -1;
1043 free:
1044 // g_array_free(th->fac_index, TRUE);
1045 // g_array_free(th->fac_list, TRUE);
1046 // th->fac_index = NULL;
1047 // th->fac_list = NULL;
1048 return -1;
1049 }
1050
1051 void lttv_trace_hook_destroy(LttvTraceHook *th)
1052 {
1053 // nothing to do
1054 }
1055
1056
1057
1058
1059 LttvTracesetContextPosition *lttv_traceset_context_position_new(
1060 const LttvTracesetContext *self)
1061 {
1062 guint num_traces = lttv_traceset_number(self->ts);
1063 guint tf_count = 0;
1064 guint i;
1065
1066 for(i=0; i<num_traces;i++) {
1067 GArray * tracefiles = self->traces[i]->tracefiles;
1068 guint j;
1069 guint num_tracefiles = tracefiles->len;
1070 for(j=0;j<num_tracefiles;j++)
1071 tf_count++;
1072 }
1073 LttvTracesetContextPosition *pos =
1074 g_new(LttvTracesetContextPosition, 1);
1075 pos->tfcp = g_array_sized_new(FALSE, TRUE,
1076 sizeof(LttvTracefileContextPosition),
1077 tf_count);
1078 g_array_set_size(pos->tfcp, tf_count);
1079 for(i=0;i<pos->tfcp->len;i++) {
1080 LttvTracefileContextPosition *tfcp =
1081 &g_array_index(pos->tfcp, LttvTracefileContextPosition, i);
1082 tfcp->event = ltt_event_position_new();
1083 }
1084
1085 pos->timestamp = ltt_time_infinite;
1086 return pos;
1087 }
1088
1089 /* Save all positions, the ones with infinite time will have NULL
1090 * ep. */
1091 /* note : a position must be destroyed when a trace is added/removed from a
1092 * traceset */
1093 void lttv_traceset_context_position_save(const LttvTracesetContext *self,
1094 LttvTracesetContextPosition *pos)
1095 {
1096 guint i;
1097 guint num_traces = lttv_traceset_number(self->ts);
1098 guint tf_count = 0;
1099
1100 pos->timestamp = ltt_time_infinite;
1101
1102 for(i=0; i<num_traces;i++) {
1103 GArray * tracefiles = self->traces[i]->tracefiles;
1104 guint j;
1105 guint num_tracefiles = tracefiles->len;
1106
1107 for(j=0;j<num_tracefiles;j++) {
1108 g_assert(tf_count < pos->tfcp->len);
1109 LttvTracefileContext **tfc = &g_array_index(tracefiles,
1110 LttvTracefileContext*, j);
1111 LttvTracefileContextPosition *tfcp =
1112 &g_array_index(pos->tfcp, LttvTracefileContextPosition, tf_count);
1113
1114 tfcp->tfc = *tfc;
1115
1116 if(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0) {
1117 LttEvent *event = ltt_tracefile_get_event((*tfc)->tf);
1118 ltt_event_position(event, tfcp->event);
1119 if(ltt_time_compare((*tfc)->timestamp, pos->timestamp) < 0)
1120 pos->timestamp = (*tfc)->timestamp;
1121 tfcp->used = TRUE;
1122 } else {
1123 tfcp->used = FALSE;
1124 }
1125
1126 //g_array_append_val(pos->tfc, *tfc);
1127 //g_array_append_val(pos->ep, ep);
1128 tf_count++;
1129 }
1130
1131 }
1132 }
1133
1134 void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos)
1135 {
1136 int i;
1137
1138 for(i=0;i<pos->tfcp->len;i++) {
1139 LttvTracefileContextPosition *tfcp =
1140 &g_array_index(pos->tfcp, LttvTracefileContextPosition, i);
1141 g_free(tfcp->event);
1142 tfcp->event = NULL;
1143 tfcp->used = FALSE;
1144 }
1145 g_array_free(pos->tfcp, TRUE);
1146 g_free(pos);
1147 }
1148
1149 void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
1150 const LttvTracesetContextPosition *src)
1151 {
1152 int i;
1153 LttvTracefileContextPosition *src_tfcp, *dest_tfcp;
1154
1155 g_assert(src->tfcp->len == src->tfcp->len);
1156
1157 for(i=0;i<src->tfcp->len;i++) {
1158 src_tfcp =
1159 &g_array_index(src->tfcp, LttvTracefileContextPosition, i);
1160 dest_tfcp =
1161 &g_array_index(dest->tfcp, LttvTracefileContextPosition, i);
1162
1163 dest_tfcp->used = src_tfcp->used;
1164 dest_tfcp->tfc = src_tfcp->tfc;
1165
1166 if(src_tfcp->used) {
1167 ltt_event_position_copy(
1168 dest_tfcp->event,
1169 src_tfcp->event);
1170 }
1171 }
1172 dest->timestamp = src->timestamp;
1173 }
1174
1175 gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
1176 const LttvTracesetContextPosition *pos)
1177 {
1178 int i;
1179 int ret = 0;
1180
1181 if(pos->tfcp->len == 0) {
1182 if(lttv_traceset_number(self->ts) == 0) return 0;
1183 else return 1;
1184 }
1185 if(lttv_traceset_number(self->ts) == 0)
1186 return -1;
1187
1188 for(i=0;i<pos->tfcp->len;i++) {
1189 LttvTracefileContextPosition *tfcp =
1190 &g_array_index(pos->tfcp, LttvTracefileContextPosition, i);
1191
1192 if(tfcp->used == FALSE) {
1193 if(ltt_time_compare(tfcp->tfc->timestamp, ltt_time_infinite) < 0) {
1194 ret = -1;
1195 }
1196 } else {
1197 if(ltt_time_compare(tfcp->tfc->timestamp, ltt_time_infinite) == 0) {
1198 ret = 1;
1199 } else {
1200 LttEvent *event = ltt_tracefile_get_event(tfcp->tfc->tf);
1201
1202 ret = ltt_event_position_compare((LttEventPosition*)event,
1203 tfcp->event);
1204 }
1205 }
1206 if(ret != 0) return ret;
1207
1208 }
1209 return 0;
1210 }
1211
1212
1213 gint lttv_traceset_context_pos_pos_compare(
1214 const LttvTracesetContextPosition *pos1,
1215 const LttvTracesetContextPosition *pos2)
1216 {
1217 int i, j;
1218 int ret = 0;
1219
1220 if(ltt_time_compare(pos1->timestamp, ltt_time_infinite) == 0) {
1221 if(ltt_time_compare(pos2->timestamp, ltt_time_infinite) == 0)
1222 return 0;
1223 else
1224 return 1;
1225 }
1226 if(ltt_time_compare(pos2->timestamp, ltt_time_infinite) == 0)
1227 return -1;
1228
1229 for(i=0;i<pos1->tfcp->len;i++) {
1230 LttvTracefileContextPosition *tfcp1 =
1231 &g_array_index(pos1->tfcp, LttvTracefileContextPosition, i);
1232
1233 if(tfcp1->used == TRUE) {
1234 for(j=0;j<pos2->tfcp->len;j++) {
1235 LttvTracefileContextPosition *tfcp2 =
1236 &g_array_index(pos2->tfcp, LttvTracefileContextPosition, j);
1237
1238 if(tfcp1->tfc == tfcp2->tfc) {
1239 if(tfcp2->used == TRUE)
1240 ret = ltt_event_position_compare(tfcp1->event, tfcp2->event);
1241 else
1242 ret = -1;
1243
1244 if(ret != 0) return ret;
1245 }
1246 }
1247
1248 } else {
1249 for(j=0;j<pos2->tfcp->len;j++) {
1250 LttvTracefileContextPosition *tfcp2 =
1251 &g_array_index(pos2->tfcp, LttvTracefileContextPosition, j);
1252
1253 if(tfcp1->tfc == tfcp2->tfc)
1254 if(tfcp2->used == TRUE) ret = 1;
1255 if(ret != 0) return ret;
1256 }
1257 }
1258 }
1259 return 0;
1260 }
1261
1262
1263 LttTime lttv_traceset_context_position_get_time(
1264 const LttvTracesetContextPosition *pos)
1265 {
1266 return pos->timestamp;
1267 }
1268
1269
1270 LttvTracefileContext *lttv_traceset_context_get_current_tfc(LttvTracesetContext *self)
1271 {
1272 GTree *pqueue = self->pqueue;
1273 LttvTracefileContext *tfc = NULL;
1274
1275 g_tree_foreach(pqueue, get_first, &tfc);
1276
1277 return tfc;
1278 }
1279
1280 /* lttv_process_traceset_synchronize_tracefiles
1281 *
1282 * Use the sync_position field of the trace set context to synchronize each
1283 * tracefile with the previously saved position.
1284 *
1285 * If no previous position has been saved, it simply does nothing.
1286 */
1287 void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *tsc)
1288 {
1289 g_assert(lttv_process_traceset_seek_position(tsc, tsc->sync_position) == 0);
1290 }
1291
1292
1293
1294
1295 void lttv_process_traceset_get_sync_data(LttvTracesetContext *tsc)
1296 {
1297 lttv_traceset_context_position_save(tsc, tsc->sync_position);
1298 }
1299
1300 struct seek_back_data {
1301 guint first_event; /* Index of the first event in the array : we will always
1302 overwrite at this position : this is a circular array.
1303 */
1304 guint events_found;
1305 guint n; /* number of events requested */
1306 GPtrArray *array; /* array of LttvTracesetContextPositions pointers */
1307 LttvFilter *filter1;
1308 LttvFilter *filter2;
1309 LttvFilter *filter3;
1310 gpointer data;
1311 check_handler *check;
1312 gboolean *stop_flag;
1313 guint raw_event_count;
1314 };
1315
1316 static gint seek_back_event_hook(void *hook_data, void* call_data)
1317 {
1318 struct seek_back_data *sd = (struct seek_back_data*)hook_data;
1319 LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1320 LttvTracesetContext *tsc = tfc->t_context->ts_context;
1321 LttvTracesetContextPosition *pos;
1322
1323 if(sd->check && sd->check(sd->raw_event_count, sd->stop_flag, sd->data))
1324 return TRUE;
1325 sd->raw_event_count++;
1326
1327 if(sd->filter1 != NULL && sd->filter1->head != NULL &&
1328 !lttv_filter_tree_parse(sd->filter1->head,
1329 ltt_tracefile_get_event(tfc->tf),
1330 tfc->tf,
1331 tfc->t_context->t,
1332 tfc,NULL,NULL)) {
1333 return FALSE;
1334 }
1335 if(sd->filter2 != NULL && sd->filter2->head != NULL &&
1336 !lttv_filter_tree_parse(sd->filter2->head,
1337 ltt_tracefile_get_event(tfc->tf),
1338 tfc->tf,
1339 tfc->t_context->t,
1340 tfc,NULL,NULL)) {
1341 return FALSE;
1342 }
1343 if(sd->filter3 != NULL && sd->filter3->head != NULL &&
1344 !lttv_filter_tree_parse(sd->filter3->head,
1345 ltt_tracefile_get_event(tfc->tf),
1346 tfc->tf,
1347 tfc->t_context->t,
1348 tfc,NULL,NULL)) {
1349 return FALSE;
1350 }
1351
1352 pos = (LttvTracesetContextPosition*)g_ptr_array_index (sd->array,
1353 sd->first_event);
1354
1355 lttv_traceset_context_position_save(tsc, pos);
1356
1357 if(sd->first_event >= sd->array->len - 1) sd->first_event = 0;
1358 else sd->first_event++;
1359
1360 sd->events_found = min(sd->n, sd->events_found + 1);
1361
1362 return FALSE;
1363 }
1364
1365 /* Seek back n events back from the current position.
1366 *
1367 * Parameters :
1368 * @self The trace set context
1369 * @n number of events to jump over
1370 * @first_offset The initial offset value used.
1371 * never put first_offset at ltt_time_zero.
1372 * @time_seeker Function pointer of the function to use to seek time :
1373 * either lttv_process_traceset_seek_time
1374 * or lttv_state_traceset_seek_time_closest
1375 * @filter The filter to call.
1376 *
1377 * Return value : the number of events found (might be lower than the number
1378 * requested if beginning of traceset is reached).
1379 *
1380 * The first search will go back first_offset and try to find the last n events
1381 * matching the filter. If there are not enough, it will try to go back from the
1382 * new trace point from first_offset*2, and so on, until beginning of trace or n
1383 * events are found.
1384 *
1385 * Note : this function does not take in account the LttvFilter : use the
1386 * similar function found in state.c instead.
1387 *
1388 * Note2 : the caller must make sure that the LttvTracesetContext does not
1389 * contain any hook, as process_traceset_middle is used in this routine.
1390 */
1391 guint lttv_process_traceset_seek_n_backward(LttvTracesetContext *self,
1392 guint n, LttTime first_offset,
1393 seek_time_fct time_seeker,
1394 check_handler *check,
1395 gboolean *stop_flag,
1396 LttvFilter *filter1,
1397 LttvFilter *filter2,
1398 LttvFilter *filter3,
1399 gpointer data)
1400 {
1401 if(lttv_traceset_number(self->ts) == 0) return 0;
1402 g_assert(ltt_time_compare(first_offset, ltt_time_zero) != 0);
1403
1404 guint i;
1405 LttvTracesetContextPosition *next_iter_end_pos =
1406 lttv_traceset_context_position_new(self);
1407 LttvTracesetContextPosition *end_pos =
1408 lttv_traceset_context_position_new(self);
1409 LttvTracesetContextPosition *saved_pos =
1410 lttv_traceset_context_position_new(self);
1411 LttTime time;
1412 LttTime asked_time;
1413 LttTime time_offset;
1414 struct seek_back_data sd;
1415 LttvHooks *hooks = lttv_hooks_new();
1416
1417 sd.first_event = 0;
1418 sd.events_found = 0;
1419 sd.array = g_ptr_array_sized_new(n);
1420 sd.filter1 = filter1;
1421 sd.filter2 = filter2;
1422 sd.filter3 = filter3;
1423 sd.data = data;
1424 sd.n = n;
1425 sd.check = check;
1426 sd.stop_flag = stop_flag;
1427 sd.raw_event_count = 0;
1428 g_ptr_array_set_size(sd.array, n);
1429 for(i=0;i<n;i++) {
1430 g_ptr_array_index (sd.array, i) = lttv_traceset_context_position_new(self);
1431 }
1432
1433 lttv_traceset_context_position_save(self, next_iter_end_pos);
1434 lttv_traceset_context_position_save(self, saved_pos);
1435 /* Get the current time from which we will offset */
1436 time = lttv_traceset_context_position_get_time(next_iter_end_pos);
1437 /* the position saved might be end of traceset... */
1438 if(ltt_time_compare(time, self->time_span.end_time) > 0) {
1439 time = self->time_span.end_time;
1440 }
1441 asked_time = time;
1442 time_offset = first_offset;
1443
1444 lttv_hooks_add(hooks, seek_back_event_hook, &sd, LTTV_PRIO_DEFAULT);
1445
1446 lttv_process_traceset_begin(self, NULL, NULL, NULL, hooks, NULL);
1447
1448 while(1) {
1449 /* stop criteria : - n events found
1450 * - asked_time < beginning of trace */
1451 if(ltt_time_compare(asked_time, self->time_span.start_time) < 0) break;
1452
1453 lttv_traceset_context_position_copy(end_pos, next_iter_end_pos);
1454
1455 /* We must seek the traceset back to time - time_offset */
1456 /* this time becomes the new reference time */
1457 time = ltt_time_sub(time, time_offset);
1458 asked_time = time;
1459
1460 time_seeker(self, time);
1461 lttv_traceset_context_position_save(self, next_iter_end_pos);
1462 /* Resync the time in case of a seek_closest */
1463 time = lttv_traceset_context_position_get_time(next_iter_end_pos);
1464 if(ltt_time_compare(time, self->time_span.end_time) > 0) {
1465 time = self->time_span.end_time;
1466 }
1467
1468 /* Process the traceset, calling a hook which adds events
1469 * to the array, overwriting the tail. It changes first_event and
1470 * events_found too. */
1471 /* We would like to have a clean context here : no other hook than our's */
1472
1473 lttv_process_traceset_middle(self, ltt_time_infinite,
1474 G_MAXUINT, end_pos);
1475
1476 if(sd.events_found < n) {
1477 if(sd.first_event > 0) {
1478 /* Save the first position */
1479 LttvTracesetContextPosition *pos =
1480 (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, 0);
1481 lttv_traceset_context_position_copy(saved_pos, pos);
1482 }
1483 g_assert(n-sd.events_found <= sd.array->len);
1484 /* Change array size to n - events_found */
1485 for(i=n-sd.events_found;i<sd.array->len;i++) {
1486 LttvTracesetContextPosition *pos =
1487 (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, i);
1488 lttv_traceset_context_position_destroy(pos);
1489 }
1490 g_ptr_array_set_size(sd.array, n-sd.events_found);
1491 sd.first_event = 0;
1492
1493 } else break; /* Second end criterion : n events found */
1494
1495 time_offset = ltt_time_mul(time_offset, BACKWARD_SEEK_MUL);
1496 }
1497
1498 lttv_traceset_context_position_destroy(end_pos);
1499 lttv_traceset_context_position_destroy(next_iter_end_pos);
1500
1501 lttv_process_traceset_end(self, NULL, NULL, NULL, hooks, NULL);
1502
1503 if(sd.events_found >= n) {
1504 /* Seek the traceset to the first event in the circular array */
1505 LttvTracesetContextPosition *pos =
1506 (LttvTracesetContextPosition*)g_ptr_array_index (sd.array,
1507 sd.first_event);
1508 g_assert(lttv_process_traceset_seek_position(self, pos) == 0);
1509 } else {
1510 /* Will seek to the last saved position : in the worst case, it will be the
1511 * original position (if events_found is 0) */
1512 g_assert(lttv_process_traceset_seek_position(self, saved_pos) == 0);
1513 }
1514
1515 for(i=0;i<sd.array->len;i++) {
1516 LttvTracesetContextPosition *pos =
1517 (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, i);
1518 lttv_traceset_context_position_destroy(pos);
1519 }
1520 g_ptr_array_free(sd.array, TRUE);
1521
1522 lttv_hooks_destroy(hooks);
1523
1524 lttv_traceset_context_position_destroy(saved_pos);
1525
1526 return sd.events_found;
1527 }
1528
1529
1530 struct seek_forward_data {
1531 guint event_count; /* event counter */
1532 guint n; /* requested number of events to jump over */
1533 LttvFilter *filter1;
1534 LttvFilter *filter2;
1535 LttvFilter *filter3;
1536 gpointer data;
1537 check_handler *check;
1538 gboolean *stop_flag;
1539 guint raw_event_count; /* event counter */
1540 };
1541
1542 static gint seek_forward_event_hook(void *hook_data, void* call_data)
1543 {
1544 struct seek_forward_data *sd = (struct seek_forward_data*)hook_data;
1545 LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1546
1547 if(sd->check && sd->check(sd->raw_event_count, sd->stop_flag, sd->data))
1548 return TRUE;
1549 sd->raw_event_count++;
1550
1551 if(sd->filter1 != NULL && sd->filter1->head != NULL &&
1552 !lttv_filter_tree_parse(sd->filter1->head,
1553 ltt_tracefile_get_event(tfc->tf),
1554 tfc->tf,
1555 tfc->t_context->t,
1556 tfc,NULL,NULL)) {
1557 return FALSE;
1558 }
1559 if(sd->filter2 != NULL && sd->filter2->head != NULL &&
1560 !lttv_filter_tree_parse(sd->filter2->head,
1561 ltt_tracefile_get_event(tfc->tf),
1562 tfc->tf,
1563 tfc->t_context->t,
1564 tfc,NULL,NULL)) {
1565 return FALSE;
1566 }
1567 if(sd->filter3 != NULL && sd->filter3->head != NULL &&
1568 !lttv_filter_tree_parse(sd->filter3->head,
1569 ltt_tracefile_get_event(tfc->tf),
1570 tfc->tf,
1571 tfc->t_context->t,
1572 tfc,NULL,NULL)) {
1573 return FALSE;
1574 }
1575
1576 sd->event_count++;
1577 if(sd->event_count >= sd->n)
1578 return TRUE;
1579 }
1580
1581 /* Seek back n events forward from the current position (1 to n)
1582 * 0 is ok too, but it will actually do nothing.
1583 *
1584 * Parameters :
1585 * @self the trace set context
1586 * @n number of events to jump over
1587 * @filter filter to call.
1588 *
1589 * returns : the number of events jumped over (may be less than requested if end
1590 * of traceset reached) */
1591 guint lttv_process_traceset_seek_n_forward(LttvTracesetContext *self,
1592 guint n,
1593 check_handler *check,
1594 gboolean *stop_flag,
1595 LttvFilter *filter1,
1596 LttvFilter *filter2,
1597 LttvFilter *filter3,
1598 gpointer data)
1599 {
1600 struct seek_forward_data sd;
1601 sd.event_count = 0;
1602 sd.n = n;
1603 sd.filter1 = filter1;
1604 sd.filter2 = filter2;
1605 sd.filter3 = filter3;
1606 sd.data = data;
1607 sd.check = check;
1608 sd.stop_flag = stop_flag;
1609 sd.raw_event_count = 0;
1610
1611 if(sd.event_count >= sd.n) return sd.event_count;
1612
1613 LttvHooks *hooks = lttv_hooks_new();
1614
1615 lttv_hooks_add(hooks, seek_forward_event_hook, &sd, LTTV_PRIO_DEFAULT);
1616
1617 lttv_process_traceset_begin(self, NULL, NULL, NULL, hooks, NULL);
1618
1619 /* it will end on the end of traceset, or the fact that the
1620 * hook returns TRUE.
1621 */
1622 lttv_process_traceset_middle(self, ltt_time_infinite,
1623 G_MAXUINT, NULL);
1624
1625 /* Here, our position is either the end of traceset, or the exact position
1626 * after n events : leave it like this. This might be placed on an event that
1627 * will be filtered out, we don't care : all we know is that the following
1628 * event filtered in will be the right one. */
1629
1630 lttv_process_traceset_end(self, NULL, NULL, NULL, hooks, NULL);
1631
1632 lttv_hooks_destroy(hooks);
1633
1634 return sd.event_count;
1635 }
1636
1637
LTTng 2.x Viewer (LTTV)
This page took 0.062616 seconds and 4 git commands to generate.