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