ltt/branches/poly/include/lttv/processTrace.h

   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 #ifndef PROCESSTRACE_H
  20 #define PROCESSTRACE_H
  21
  22 #include <lttv/traceset.h>
  23 #include <lttv/attribute.h>
  24 #include <lttv/hook.h>
  25 #include <ltt/ltt.h>
  26
  27 /* This is the generic part of trace processing. All events within a
  28    certain time interval are accessed and processing hooks are called for
  29    each. The events are examined in monotonically increasing time to more
  30    closely follow the traced system behavior.
  31
  32    Hooks are called at several different places during the processing:
  33    before traceset, after traceset, check trace, before trace, after trace,
  34    check tracefile, before tracefile, after tracefile,
  35    check_event, before_event, before_event_by_id,
  36    after_event, after_event_by_id.
  37
  38    In each case the "check" hooks are called first to determine if further
  39    processing of the trace, tracefile or event is wanted. Then, the before
  40    hooks and the after hooks are called. The before hooks for a traceset
  41    are called before those for the contained traces, which are called before
  42    those for the contained tracefiles. The after hooks are called in reverse
  43    order. The event hooks are called after all the before_tracefile hooks
  44    and before all the after_tracefile hooks.
  45
  46    The hooks receive two arguments, the hook_data and call_data. The hook_data
  47    is specified when the hook is registered and typically links to the
  48    object registering the hook (e.g. a graphical events viewer). The call_data
  49    must contain all the context related to the call. The traceset hooks receive
  50    the LttvTracesetContext provided by the caller. The trace hooks receive
  51    the LttvTraceContext from the traces array in the LttvTracesetContext.
  52    The tracefile and event hooks receive the LttvTracefileContext from
  53    the tracefiles array in the LttvTraceContext. The LttEvent and LttTime
  54    fields in the tracefile context are set to the current event and current
  55    event time before calling the event hooks. No other context field is
  56    modified.
  57
  58    The contexts in the traces and tracefiles arrays must be allocated by
  59    the caller, either before the call or during the before hooks of the
  60    enclosing traceset or trace. The order in the traces array must
  61    correspond to the lttv_traceset_get function. The order in the tracefiles
  62    arrays must correspond to the ltt_trace_control_tracefile_get and
  63    ltt_trace_per_cpu_tracefile_get functions. The traceset, trace and
  64    tracefile contexts may be subtyped as needed. Indeed, both the contexts
  65    and the hooks are defined by the caller. */
  66
  67
  68 typedef struct _LttvTracesetContext LttvTracesetContext;
  69 typedef struct _LttvTracesetContextClass LttvTracesetContextClass;
  70
  71 typedef struct _LttvTraceContext LttvTraceContext;
  72 typedef struct _LttvTraceContextClass LttvTraceContextClass;
  73
  74 typedef struct _LttvTracefileContext LttvTracefileContext;
  75 typedef struct _LttvTracefileContextClass LttvTracefileContextClass;
  76
  77 #define LTTV_TRACESET_CONTEXT_TYPE  (lttv_traceset_context_get_type ())
  78 #define LTTV_TRACESET_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContext))
  79 #define LTTV_TRACESET_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
  80 #define LTTV_IS_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_CONTEXT_TYPE))
  81 #define LTTV_IS_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_CONTEXT_TYPE))
  82 #define LTTV_TRACESET_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
  83
  84 struct _LttvTracesetContext {
  85   GObject parent;
  86
  87   LttvTraceset *ts;
  88   LttvHooks *before;
  89   LttvHooks *after;
  90   LttvTraceContext **traces;
  91   LttvAttribute *a;
  92   LttvAttribute *ts_a;
  93   TimeInterval *Time_Span;
  94   GTree *pqueue;
  95 };
  96
  97 struct _LttvTracesetContextClass {
  98   GObjectClass parent;
  99
 100   void (*init) (LttvTracesetContext *self, LttvTraceset *ts);
 101   void (*fini) (LttvTracesetContext *self);
 102   LttvTracesetContext* (*new_traceset_context) (LttvTracesetContext *self);
 103   LttvTraceContext* (*new_trace_context) (LttvTracesetContext *self);
 104   LttvTracefileContext* (*new_tracefile_context) (LttvTracesetContext *self);
 105 };
 106
 107 GType lttv_traceset_context_get_type (void);
 108
 109 void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts);
 110
 111 void lttv_context_fini(LttvTracesetContext *self);
 112
 113 LttvTracesetContext *
 114 lttv_context_new_traceset_context(LttvTracesetContext *self);
 115
 116 LttvTraceContext *
 117 lttv_context_new_trace_context(LttvTracesetContext *self);
 118
 119 LttvTracefileContext *
 120 lttv_context_new_tracefile_context(LttvTracesetContext *self);
 121
 122
 123 #define LTTV_TRACE_CONTEXT_TYPE  (lttv_trace_context_get_type ())
 124 #define LTTV_TRACE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContext))
 125 #define LTTV_TRACE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
 126 #define LTTV_IS_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_CONTEXT_TYPE))
 127 #define LTTV_IS_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_CONTEXT_TYPE))
 128 #define LTTV_TRACE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
 129
 130 struct _LttvTraceContext {
 131   GObject parent;
 132
 133   LttvTracesetContext *ts_context;
 134   guint index;                /* in ts_context->traces */
 135   LttTrace *t;
 136   LttvTrace *vt;
 137   LttvHooks *check;
 138   LttvHooks *before;
 139   LttvHooks *after;
 140   LttvTracefileContext **tracefiles;
 141   LttvAttribute *a;
 142   LttvAttribute *t_a;
 143 };
 144
 145 struct _LttvTraceContextClass {
 146   GObjectClass parent;
 147 };
 148
 149 GType lttv_trace_context_get_type (void);
 150
 151 #define LTTV_TRACEFILE_CONTEXT_TYPE  (lttv_tracefile_context_get_type ())
 152 #define LTTV_TRACEFILE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContext))
 153 #define LTTV_TRACEFILE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
 154 #define LTTV_IS_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_CONTEXT_TYPE))
 155 #define LTTV_IS_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE))
 156 #define LTTV_TRACEFILE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
 157
 158 struct _LttvTracefileContext {
 159   GObject parent;
 160
 161   LttvTraceContext *t_context;
 162   gboolean control;
 163   guint index;                /* in ts_context->tracefiles */
 164   LttTracefile *tf;
 165   LttvHooks *check;
 166   LttvHooks *before;
 167   LttvHooks *after;
 168   LttEvent *e;
 169   LttvHooks *check_event;
 170   LttvHooks *before_event;
 171   LttvHooksById *before_event_by_id;
 172   LttvHooks *after_event;
 173   LttvHooksById *after_event_by_id;
 174   LttTime timestamp;
 175   LttvAttribute *a;
 176 };
 177
 178 struct _LttvTracefileContextClass {
 179   GObjectClass parent;
 180 };
 181
 182 GType lttv_tracefile_context_get_type (void);
 183
 184 /* Run through the events in a traceset in sorted order calling all the
 185    hooks appropriately. It starts at the current time and runs until end or
 186    nb_events are processed. */
 187
 188 void lttv_process_traceset(LttvTracesetContext *self, LttTime end,
 189     unsigned nb_events);
 190
 191 /* Process traceset can also be done in smaller pieces calling begin, middle
 192    repeatedly, and end. The middle function return the number of events
 193    processed. It may be larger than nb_events if several events have the
 194    same timestamp. It will be smaller than nb_events if the end time
 195    is reached. */
 196
 197 void lttv_process_traceset_begin(LttvTracesetContext *self, LttTime end);
 198
 199 guint lttv_process_traceset_middle(LttvTracesetContext *self, LttTime end,
 200     unsigned nb_events);
 201
 202 void lttv_process_traceset_end(LttvTracesetContext *self);
 203
 204
 205 void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start);
 206
 207 void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start);
 208
 209 void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
 210     LttvHooks *before_traceset,
 211     LttvHooks *after_traceset,
 212     LttvHooks *check_trace,
 213     LttvHooks *before_trace,
 214     LttvHooks *after_trace,
 215     LttvHooks *check_tracefile,
 216     LttvHooks *before_tracefile,
 217     LttvHooks *after_tracefile,
 218     LttvHooks *check_event,
 219     LttvHooks *before_event,
 220     LttvHooks *after_event);
 221
 222 void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
 223     LttvHooks *before_traceset,
 224     LttvHooks *after_traceset,
 225     LttvHooks *check_trace,
 226     LttvHooks *before_trace,
 227     LttvHooks *after_trace,
 228     LttvHooks *check_tracefile,
 229     LttvHooks *before_tracefile,
 230     LttvHooks *after_tracefile,
 231     LttvHooks *check_event,
 232     LttvHooks *before_event,
 233     LttvHooks *after_event);
 234
 235 void lttv_trace_context_add_hooks(LttvTraceContext *self,
 236                                   LttvHooks *check_trace,
 237                                   LttvHooks *before_trace,
 238                                   LttvHooks *after_trace);
 239
 240 void lttv_trace_context_remove_hooks(LttvTraceContext *self,
 241                                      LttvHooks *check_trace,
 242                                      LttvHooks *before_trace,
 243                                      LttvHooks *after_trace);
 244
 245 void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
 246                                       LttvHooks *check_tracefile,
 247                                       LttvHooks *before_tracefile,
 248                                       LttvHooks *after_tracefile,
 249                                       LttvHooks *check_event,
 250                                       LttvHooks *before_event,
 251                                       LttvHooks *after_event);
 252
 253 void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
 254                                          LttvHooks *check_tracefile,
 255                                          LttvHooks *before_tracefile,
 256                                          LttvHooks *after_tracefile,
 257                                          LttvHooks *check_event,
 258                                          LttvHooks *before_event,
 259                                          LttvHooks *after_event);
 260
 261 void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *self,
 262                                             unsigned i,
 263                                             LttvHooks *before_event_by_id,
 264                                             LttvHooks *after_event_by_id);
 265
 266 void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *self,
 267                                                unsigned i);
 268
 269 typedef struct _LttvTraceHook {
 270   LttvHook h;
 271   guint id;
 272   LttField *f1;
 273   LttField *f2;
 274   LttField *f3;
 275 } LttvTraceHook;
 276
 277
 278 /* Search in the trace for the id of the named event type within the named
 279    facility. Then, find the three (if non null) named fields. All that
 280    information is then used to fill the LttvTraceHook structure. This
 281    is useful to find the specific id for an event within a trace, for
 282    registering a hook using this structure as event data;
 283    it already contains the (up to three) needed fields handles. */
 284
 285 void lttv_trace_find_hook(LttTrace *t, char *facility, char *event_type,
 286     char *field1, char *field2, char *field3, LttvHook h, LttvTraceHook *th);
 287
 288 #endif // PROCESSTRACE_H