lttv/lttv/traceset-process.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Michel Dagenais
   3  * Copyright (C) 2012 Yannick Brosseau
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License Version 2 as
   7  * published by the Free Software Foundation;
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  17  * MA 02111-1307, USA.
  18  */
  19 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <lttv/traceset-process.h>
  24 #include <lttv/traceset.h>
  25 #include <lttv/event.h>
  26 #include <babeltrace/context.h>
  27 #include <babeltrace/iterator.h>
  28
  29 #include <babeltrace/ctf/events.h>
  30 #include <babeltrace/ctf/iterator.h>
  31
  32 void lttv_process_traceset_begin(LttvTraceset *traceset,
  33                 LttvHooks *before_traceset,
  34                 LttvHooks *before_trace,
  35                 LttvHooks *event)
  36 {
  37         struct bt_iter_pos begin_pos;
  38         /* simply add hooks in context. _before hooks are called by add_hooks. */
  39         /* It calls all before_traceset, before_trace, and before_tracefile hooks. */
  40         lttv_traceset_add_hooks(traceset,
  41                                 before_traceset,
  42                                 before_trace,
  43                                 event);
  44
  45
  46
  47         begin_pos.type = BT_SEEK_BEGIN;
  48
  49         if(!traceset->iter) {
  50         traceset->iter = bt_ctf_iter_create(lttv_traceset_get_context(traceset),
  51                                         &begin_pos,
  52                                         NULL);
  53         }
  54 }
  55
  56 guint lttv_process_traceset_middle(LttvTraceset *traceset,
  57                 LttTime end,
  58                 gulong nb_events,
  59                 const LttvTracesetPosition *end_position)
  60 {
  61
  62         unsigned count = 0;
  63
  64         struct bt_ctf_event *bt_event;
  65
  66         LttvEvent event;
  67
  68         while(TRUE) {
  69
  70                 if((count >= nb_events) && (nb_events != G_MAXULONG)) {
  71                         break;
  72                 }
  73
  74                 if((bt_event = bt_ctf_iter_read_event(traceset->iter)) != NULL) {
  75
  76                         count++;
  77
  78                         event.bt_event = bt_event;
  79
  80                         /* Retreive the associated state */
  81                         event.state = g_ptr_array_index(traceset->state_trace_handle_index,
  82                                                         bt_ctf_event_get_handle_id(bt_event));
  83
  84                         lttv_hooks_call(traceset->event_hooks, &event);
  85
  86                         if(bt_iter_next(bt_ctf_get_iter(traceset->iter)) < 0) {
  87                                 printf("ERROR NEXT\n");
  88                                 break;
  89                         }
  90                 } else {
  91                         /* READ FAILED */
  92
  93                         break;
  94
  95                 }
  96         }
  97
  98
  99
 100         return count;
 101 }
 102
 103 void lttv_process_traceset_end(LttvTraceset *traceset,
 104                                LttvHooks *after_traceset,
 105                                LttvHooks *after_trace,
 106                                LttvHooks *event)
 107 {
 108         /* Remove hooks from context. _after hooks are called by remove_hooks. */
 109         /* It calls all after_traceset, after_trace, and after_tracefile hooks. */
 110         lttv_traceset_remove_hooks(traceset,
 111                                    after_traceset,
 112                                    after_trace,
 113                                    event);
 114
 115 }
 116
 117
 118 void lttv_traceset_add_hooks(LttvTraceset *traceset,
 119                              LttvHooks *before_traceset,
 120                              LttvHooks *before_trace,
 121                              LttvHooks *event)
 122 {
 123
 124         guint i, nb_trace;
 125
 126         LttvTrace *trace;
 127
 128         lttv_hooks_call(before_traceset, traceset);
 129
 130         lttv_hooks_add_list(traceset->event_hooks, event);
 131
 132         nb_trace = lttv_traceset_number(traceset);
 133
 134         for(i = 0 ; i < nb_trace ; i++) {
 135                 trace = (LttvTrace *)g_ptr_array_index(traceset->traces,i);
 136                 lttv_trace_add_hooks(trace,
 137                                              before_trace,
 138                                              event
 139                                              );
 140         }
 141 }
 142 void lttv_traceset_remove_hooks(LttvTraceset *traceset,
 143                                 LttvHooks *after_traceset,
 144                                 LttvHooks *after_trace,
 145                                 LttvHooks *event)
 146 {
 147
 148         guint i, nb_trace;
 149
 150         LttvTrace *trace;
 151
 152         nb_trace = lttv_traceset_number(traceset);
 153
 154         for(i = 0 ; i < nb_trace ; i++) {
 155                 trace = (LttvTrace *)g_ptr_array_index(traceset->traces,i);
 156                 lttv_trace_remove_hooks(trace,
 157                                                 after_trace,
 158                                                 event);
 159
 160         }
 161
 162         lttv_hooks_call(after_traceset, traceset);
 163
 164
 165 }
 166
 167
 168 void lttv_trace_add_hooks(LttvTrace *trace,
 169                           LttvHooks *before_trace,
 170                           LttvHooks *event)
 171 {
 172         lttv_hooks_call(before_trace, trace);
 173 }
 174
 175 void lttv_trace_remove_hooks(LttvTrace *trace,
 176                              LttvHooks *after_trace,
 177                              LttvHooks *event)
 178
 179 {
 180         lttv_hooks_call(after_trace, trace);
 181
 182 }
 183
 184 void lttv_process_traceset_seek_time(LttvTraceset *traceset, LttTime start)
 185 {
 186         struct bt_iter_pos seekpos;
 187         int ret;
 188         if (traceset->iter == NULL) {
 189                 g_warning("Iterator not valid in seek_time");
 190                 return;
 191         }
 192         seekpos.type = BT_SEEK_TIME;
 193         seekpos.u.seek_time = ltt_time_to_uint64(start);
 194
 195         ret = bt_iter_set_pos(bt_ctf_get_iter(traceset->iter), &seekpos);
 196         if(ret < 0) {
 197                 printf("Seek by time error: %s,\n",strerror(-ret));
 198         }
 199
 200 }