ltt/branches/poly/lttv/lttv/tracecontext.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 typedef struct _LttvTracesetContextPosition LttvTracesetContextPosition;
  78 typedef struct _LttvTraceContextPosition LttvTraceContextPosition;
  79
  80 #define LTTV_TRACESET_CONTEXT_TYPE  (lttv_traceset_context_get_type ())
  81 #define LTTV_TRACESET_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContext))
  82 #define LTTV_TRACESET_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
  83 #define LTTV_IS_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_CONTEXT_TYPE))
  84 #define LTTV_IS_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_CONTEXT_TYPE))
  85 #define LTTV_TRACESET_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
  86
  87 struct _LttvTracesetContext {
  88   GObject parent;
  89
  90   LttvTraceset *ts;
  91   LttvTraceContext **traces;
  92   LttvAttribute *a;
  93   LttvAttribute *ts_a;
  94   TimeInterval time_span;
  95   GTree *pqueue;
  96 };
  97
  98 struct _LttvTracesetContextClass {
  99   GObjectClass parent;
 100
 101   void (*init) (LttvTracesetContext *self, LttvTraceset *ts);
 102   void (*fini) (LttvTracesetContext *self);
 103   LttvTracesetContext* (*new_traceset_context) (LttvTracesetContext *self);
 104   LttvTraceContext* (*new_trace_context) (LttvTracesetContext *self);
 105   LttvTracefileContext* (*new_tracefile_context) (LttvTracesetContext *self);
 106 };
 107
 108 GType lttv_traceset_context_get_type (void);
 109
 110 void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts);
 111
 112 void lttv_context_fini(LttvTracesetContext *self);
 113
 114 LttvTracesetContext *
 115 lttv_context_new_traceset_context(LttvTracesetContext *self);
 116
 117 LttvTraceContext *
 118 lttv_context_new_trace_context(LttvTracesetContext *self);
 119
 120 LttvTracefileContext *
 121 lttv_context_new_tracefile_context(LttvTracesetContext *self);
 122
 123
 124 #define LTTV_TRACE_CONTEXT_TYPE  (lttv_trace_context_get_type ())
 125 #define LTTV_TRACE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContext))
 126 #define LTTV_TRACE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
 127 #define LTTV_IS_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_CONTEXT_TYPE))
 128 #define LTTV_IS_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_CONTEXT_TYPE))
 129 #define LTTV_TRACE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
 130
 131 struct _LttvTraceContext {
 132   GObject parent;
 133
 134   LttvTracesetContext *ts_context;
 135   guint index;                /* in ts_context->traces */
 136   LttTrace *t;
 137   LttvTrace *vt;
 138   //LttvTracefileContext **tracefiles;
 139   GArray *tracefiles;
 140   LttvAttribute *a;
 141   LttvAttribute *t_a;
 142 };
 143
 144 struct _LttvTraceContextClass {
 145   GObjectClass parent;
 146 };
 147
 148 GType lttv_trace_context_get_type (void);
 149
 150 #define LTTV_TRACEFILE_CONTEXT_TYPE  (lttv_tracefile_context_get_type ())
 151 #define LTTV_TRACEFILE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContext))
 152 #define LTTV_TRACEFILE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
 153 #define LTTV_IS_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_CONTEXT_TYPE))
 154 #define LTTV_IS_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE))
 155 #define LTTV_TRACEFILE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
 156
 157 struct _LttvTracefileContext {
 158   GObject parent;
 159
 160   LttvTraceContext *t_context;
 161  // gboolean control;
 162   guint index;                /* in ts_context->tracefiles */
 163   LttTracefile *tf;
 164  // LttEvent *e;
 165   LttvHooks *event;
 166   LttvHooksById *event_by_id;
 167   LttTime timestamp;
 168   LttvAttribute *a;
 169 };
 170
 171 struct _LttvTracefileContextClass {
 172   GObjectClass parent;
 173 };
 174
 175 GType lttv_tracefile_context_get_type (void);
 176
 177 /* Run through the events in a traceset in sorted order calling all the
 178    hooks appropriately. It starts at the current time and runs until end or
 179    nb_events are processed. */
 180
 181 void lttv_process_traceset(LttvTracesetContext *self, LttTime end,
 182     unsigned nb_events);
 183
 184 /* Save the complete tracefile information in the context */
 185 //void lttv_process_traceset_get_sync_data(LttvTracesetContext *self);
 186
 187 /* Put all the tracefiles at the tracefile context position */
 188 void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *self);
 189
 190 /* Process traceset can also be done in smaller pieces calling begin,
 191  * then seek and middle repeatedly, and end. The middle function return the
 192  * number of events processed. It will be smaller than nb_events if the end time
 193  * or end position is reached. */
 194
 195
 196 void lttv_process_traceset_begin(LttvTracesetContext *self,
 197                                  LttvHooks       *before_traceset,
 198                                  LttvHooks       *before_trace,
 199                                  LttvHooks       *before_tracefile,
 200                                  LttvHooks       *event,
 201                                  LttvHooksById   *event_by_id);
 202
 203
 204 guint lttv_process_traceset_middle(LttvTracesetContext *self,
 205                               LttTime end,
 206                               guint nb_events,
 207                               const LttvTracesetContextPosition *end_position);
 208
 209 void lttv_process_traceset_end(LttvTracesetContext *self,
 210                                LttvHooks           *after_traceset,
 211                                LttvHooks           *after_trace,
 212                                LttvHooks           *after_tracefile,
 213                                LttvHooks           *event,
 214                                LttvHooksById       *event_by_id);
 215
 216
 217 void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start);
 218
 219 gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
 220                                         const LttvTracesetContextPosition *pos);
 221
 222 void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start);
 223
 224 void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
 225     LttvHooks *before_traceset,
 226     LttvHooks *before_trace,
 227     LttvHooks *before_tracefile,
 228     LttvHooks *event,
 229     LttvHooksById *event_by_id);
 230
 231 void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
 232     LttvHooks *after_traceset,
 233     LttvHooks *after_trace,
 234     LttvHooks *after_tracefile,
 235     LttvHooks *event,
 236     LttvHooksById *event_by_id);
 237
 238 void lttv_trace_context_add_hooks(LttvTraceContext *self,
 239     LttvHooks *before_trace,
 240     LttvHooks *before_tracefile,
 241     LttvHooks *event,
 242     LttvHooksById *event_by_id);
 243
 244 void lttv_trace_context_remove_hooks(LttvTraceContext *self,
 245     LttvHooks *after_trace,
 246     LttvHooks *after_tracefile,
 247     LttvHooks *event,
 248     LttvHooksById *event_by_id);
 249
 250 void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
 251           LttvHooks *before_tracefile,
 252           LttvHooks *event,
 253           LttvHooksById *event_by_id);
 254
 255
 256 void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
 257            LttvHooks *after_tracefile,
 258            LttvHooks *event,
 259            LttvHooksById *event_by_id);
 260
 261
 262 void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *self,
 263                                             unsigned i,
 264                                             LttvHooks *event_by_id);
 265
 266 void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *self,
 267                                                unsigned i);
 268
 269 /* A LttvTraceHook has two arrays of LttvTraceHookByFacility,
 270  * indexed by facility ID and a simple array used to walk all the hooks */
 271 typedef struct _LttvTraceHook {
 272   GArray *fac_index;
 273   GArray *fac_list;
 274 } LttvTraceHook;
 275
 276 typedef struct _LttvTraceHookByFacility {
 277   LttvHook h;
 278   guint id;
 279   LttField *f1;
 280   LttField *f2;
 281   LttField *f3;
 282 } LttvTraceHookByFacility;
 283
 284
 285 /* Get the first facility corresponding to the name. As the types must be
 286  * compatible, it is relevant to use the field name and sizes of the first
 287  * facility to create data structures and assume the data will be compatible
 288  * thorough the trace */
 289 LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th);
 290
 291 LttvTraceHookByFacility *lttv_trace_hook_get_fac(
 292     LttvTraceHook *th, guint facility_id);
 293
 294 void lttv_trace_hook_destroy(LttvTraceHook *th);
 295
 296 /* Search in the trace for the id of the named event type within the named
 297    facility. Then, find the three (if non null) named fields. All that
 298    information is then used to fill the LttvTraceHook structure. This
 299    is useful to find the specific id for an event within a trace, for
 300    registering a hook using this structure as event data;
 301    it already contains the (up to three) needed fields handles. */
 302
 303 gint lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event_type,
 304     GQuark field1, GQuark field2, GQuark field3, LttvHook h, LttvTraceHook *th);
 305
 306 LttvTracefileContext *lttv_traceset_context_get_current_tfc(
 307                              LttvTracesetContext *self);
 308
 309
 310 LttvTracesetContextPosition *lttv_traceset_context_position_new();
 311
 312 void lttv_traceset_context_position_save(const LttvTracesetContext *self,
 313                                     LttvTracesetContextPosition *pos);
 314
 315 void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos);
 316
 317 void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
 318                                    const LttvTracesetContextPosition *src);
 319
 320 gint lttv_traceset_context_pos_pos_compare(
 321                           const LttvTracesetContextPosition *pos1,
 322                           const LttvTracesetContextPosition *pos2);
 323
 324 gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
 325                                     const LttvTracesetContextPosition *pos2);
 326
 327 LttTime lttv_traceset_context_position_get_time(
 328                                       const LttvTracesetContextPosition *pos);
 329
 330 gboolean lttv_process_tracefile_seek_position(LttvTracefileContext *self,
 331                                               const LttEventPosition *pos);
 332
 333
 334 #endif // PROCESSTRACE_H