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 <string.h>
  23 #include <lttv/traceset.h>
  24 #include <lttv/attribute.h>
  25 #include <lttv/hook.h>
  26 #include <ltt/ltt.h>
  27 #include <ltt/marker.h>
  28
  29 /* This is the generic part of trace processing. All events within a
  30    certain time interval are accessed and processing hooks are called for
  31    each. The events are examined in monotonically increasing time to more
  32    closely follow the traced system behavior.
  33
  34    Hooks are called at several different places during the processing:
  35    before traceset, after traceset, check trace, before trace, after trace,
  36    check tracefile, before tracefile, after tracefile,
  37    check_event, before_event, before_event_by_id,
  38    after_event, after_event_by_id.
  39
  40    In each case the "check" hooks are called first to determine if further
  41    processing of the trace, tracefile or event is wanted. Then, the before
  42    hooks and the after hooks are called. The before hooks for a traceset
  43    are called before those for the contained traces, which are called before
  44    those for the contained tracefiles. The after hooks are called in reverse
  45    order. The event hooks are called after all the before_tracefile hooks
  46    and before all the after_tracefile hooks.
  47
  48    The hooks receive two arguments, the hook_data and call_data. The hook_data
  49    is specified when the hook is registered and typically links to the
  50    object registering the hook (e.g. a graphical events viewer). The call_data
  51    must contain all the context related to the call. The traceset hooks receive
  52    the LttvTracesetContext provided by the caller. The trace hooks receive
  53    the LttvTraceContext from the traces array in the LttvTracesetContext.
  54    The tracefile and event hooks receive the LttvTracefileContext from
  55    the tracefiles array in the LttvTraceContext. The LttEvent and LttTime
  56    fields in the tracefile context are set to the current event and current
  57    event time before calling the event hooks. No other context field is
  58    modified.
  59
  60    The contexts in the traces and tracefiles arrays must be allocated by
  61    the caller, either before the call or during the before hooks of the
  62    enclosing traceset or trace. The order in the traces array must
  63    correspond to the lttv_traceset_get function. The order in the tracefiles
  64    arrays must correspond to the ltt_trace_control_tracefile_get and
  65    ltt_trace_per_cpu_tracefile_get functions. The traceset, trace and
  66    tracefile contexts may be subtyped as needed. Indeed, both the contexts
  67    and the hooks are defined by the caller. */
  68
  69
  70 typedef struct _LttvTracesetContext LttvTracesetContext;
  71 typedef struct _LttvTracesetContextClass LttvTracesetContextClass;
  72
  73 typedef struct _LttvTraceContext LttvTraceContext;
  74 typedef struct _LttvTraceContextClass LttvTraceContextClass;
  75
  76 typedef struct _LttvTracefileContext LttvTracefileContext;
  77 typedef struct _LttvTracefileContextClass LttvTracefileContextClass;
  78
  79 typedef struct _LttvTracesetContextPosition LttvTracesetContextPosition;
  80 typedef struct _LttvTraceContextPosition LttvTraceContextPosition;
  81
  82 #ifndef LTTVFILTER_TYPE_DEFINED
  83 typedef struct _LttvFilter LttvFilter;
  84 #define LTTVFILTER_TYPE_DEFINED
  85 #endif
  86
  87 #define LTTV_TRACESET_CONTEXT_TYPE  (lttv_traceset_context_get_type ())
  88 #define LTTV_TRACESET_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContext))
  89 #define LTTV_TRACESET_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
  90 #define LTTV_IS_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_CONTEXT_TYPE))
  91 #define LTTV_IS_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_CONTEXT_TYPE))
  92 #define LTTV_TRACESET_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
  93
  94 struct _LttvTracesetContext {
  95         GObject parent;
  96
  97         LttvTraceset *ts;
  98         LttvTraceContext **traces;
  99         LttvAttribute *a;
 100         LttvAttribute *ts_a;
 101         TimeInterval time_span;
 102         GTree *pqueue;
 103
 104         LttvTracesetContextPosition *sync_position;   /* position at which to sync the
 105                                                          trace context */
 106 };
 107
 108 struct _LttvTracesetContextClass {
 109         GObjectClass parent;
 110
 111         void (*init) (LttvTracesetContext *self, LttvTraceset *ts);
 112         void (*fini) (LttvTracesetContext *self);
 113         LttvTracesetContext* (*new_traceset_context) (LttvTracesetContext *self);
 114         LttvTraceContext* (*new_trace_context) (LttvTracesetContext *self);
 115         LttvTracefileContext* (*new_tracefile_context) (LttvTracesetContext *self);
 116 };
 117
 118 GType lttv_traceset_context_get_type (void);
 119
 120 void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts);
 121
 122 void lttv_context_fini(LttvTracesetContext *self);
 123
 124 LttvTracesetContext *
 125 lttv_context_new_traceset_context(LttvTracesetContext *self);
 126
 127 LttvTraceContext *
 128 lttv_context_new_trace_context(LttvTracesetContext *self);
 129
 130 LttvTracefileContext *
 131 lttv_context_new_tracefile_context(LttvTracesetContext *self);
 132
 133
 134 #define LTTV_TRACE_CONTEXT_TYPE  (lttv_trace_context_get_type ())
 135 #define LTTV_TRACE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContext))
 136 #define LTTV_TRACE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
 137 #define LTTV_IS_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_CONTEXT_TYPE))
 138 #define LTTV_IS_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_CONTEXT_TYPE))
 139 #define LTTV_TRACE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
 140
 141 struct _LttvTraceContext {
 142         GObject parent;
 143
 144         LttvTracesetContext *ts_context;
 145         guint index;                /* in ts_context->traces */
 146         LttTrace *t;
 147         LttvTrace *vt;
 148         //LttvTracefileContext **tracefiles;
 149         GArray *tracefiles;
 150         LttvAttribute *a;
 151         LttvAttribute *t_a;
 152         TimeInterval time_span;
 153 };
 154
 155 struct _LttvTraceContextClass {
 156         GObjectClass parent;
 157 };
 158
 159 GType lttv_trace_context_get_type (void);
 160
 161 #define LTTV_TRACEFILE_CONTEXT_TYPE  (lttv_tracefile_context_get_type ())
 162 #define LTTV_TRACEFILE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContext))
 163 #define LTTV_TRACEFILE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
 164 #define LTTV_IS_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_CONTEXT_TYPE))
 165 #define LTTV_IS_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE))
 166 #define LTTV_TRACEFILE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
 167
 168 struct _LttvTracefileContext {
 169         GObject parent;
 170
 171         LttvTraceContext *t_context;
 172  // gboolean control;
 173         guint index;                /* in ts_context->tracefiles */
 174         LttTracefile *tf;
 175  // LttEvent *e;
 176         LttvHooks *event;
 177         LttvHooksById *event_by_id;
 178         LttTime timestamp;
 179         LttvAttribute *a;
 180         gint target_pid;          /* Target PID of the event.
 181                                 Updated by state.c. -1 means unset. */
 182 };
 183
 184 struct _LttvTracefileContextClass {
 185         GObjectClass parent;
 186 };
 187
 188 GType lttv_tracefile_context_get_type (void);
 189
 190 /* Run through the events in a traceset in sorted order calling all the
 191          hooks appropriately. It starts at the current time and runs until end or
 192          nb_events are processed. */
 193
 194 void lttv_process_traceset(LttvTracesetContext *self, LttTime end,
 195                 unsigned nb_events);
 196
 197 /* Process traceset can also be done in smaller pieces calling begin,
 198  * then seek and middle repeatedly, and end. The middle function return the
 199  * number of events processed. It will be smaller than nb_events if the end time
 200  * or end position is reached. */
 201
 202
 203 void lttv_process_traceset_begin(LttvTracesetContext *self,
 204                 LttvHooks *before_traceset,
 205                 LttvHooks *before_trace,
 206                 LttvHooks *before_tracefile,
 207                 LttvHooks *event,
 208                 LttvHooksByIdChannelArray *event_by_id_channel);
 209
 210
 211 guint lttv_process_traceset_middle(LttvTracesetContext *self,
 212                 LttTime end,
 213                 gulong nb_events,
 214                 const LttvTracesetContextPosition *end_position);
 215
 216 void lttv_process_traceset_end(LttvTracesetContext *self,
 217                 LttvHooks *after_traceset,
 218                 LttvHooks *after_trace,
 219                 LttvHooks *after_tracefile,
 220                 LttvHooks *event,
 221                 LttvHooksByIdChannelArray *event_by_id_channel);
 222
 223 guint lttv_process_traceset_update(LttvTracesetContext *self);
 224
 225
 226 void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start);
 227
 228 void lttv_traceset_context_compute_time_span(LttvTracesetContext *self,
 229                 TimeInterval *time_span);
 230
 231 gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
 232                 const LttvTracesetContextPosition *pos);
 233
 234 void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start);
 235
 236 void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
 237                 LttvHooks *before_traceset,
 238                 LttvHooks *before_trace,
 239                 LttvHooks *before_tracefile,
 240                 LttvHooks *event,
 241                 LttvHooksByIdChannelArray *event_by_id_channel);
 242
 243 void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
 244                 LttvHooks *after_traceset,
 245                 LttvHooks *after_trace,
 246                 LttvHooks *after_tracefile,
 247                 LttvHooks *event,
 248                 LttvHooksByIdChannelArray *event_by_id_channel);
 249
 250 void lttv_trace_context_add_hooks(LttvTraceContext *self,
 251                 LttvHooks *before_trace,
 252                 LttvHooks *before_tracefile,
 253                 LttvHooks *event,
 254                 LttvHooksByIdChannelArray *event_by_id_channel);
 255
 256 void lttv_trace_context_remove_hooks(LttvTraceContext *self,
 257                 LttvHooks *after_trace,
 258                 LttvHooks *after_tracefile,
 259                 LttvHooks *event,
 260                 LttvHooksByIdChannelArray *event_by_id_channel);
 261
 262 void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
 263                 LttvHooks *before_tracefile,
 264                 LttvHooks *event,
 265                 LttvHooksById *event_by_id);
 266
 267
 268 void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
 269                 LttvHooks *after_tracefile,
 270                 LttvHooks *event,
 271                 LttvHooksById *event_by_id);
 272
 273 typedef struct _LttvTraceHook {
 274         LttvHook h;
 275         struct marker_data *mdata;
 276         GQuark channel;
 277         guint16 id;  /* id of the marker associated with this hook */
 278         GPtrArray *fields;  /* struct marker_fields pointers */
 279         gpointer hook_data;
 280 } LttvTraceHook;
 281
 282 /* Get the head of marker list corresponding to the given trace hook.
 283  */
 284 struct marker_info *lttv_trace_hook_get_marker(LttTrace *t, LttvTraceHook *th);
 285
 286 /* Remove the hooks from the array. Does not free the array itself. */
 287 void lttv_trace_hook_remove_all(GArray **th);
 288
 289 /* Search in the trace for the id of the named event type within the named
 290    facility. Then, find the three (if non null) named fields. All that
 291    information is then used to fill the LttvTraceHook structure. This
 292    is useful to find the specific id for an event within a trace, for
 293    registering a hook using this structure as event data;
 294    it already contains the (up to three) needed fields handles.
 295    Returns the modified LttvTraceHook array.
 296    Prints warnings if events or markers are not found. returns 1 on error,
 297    0 on success.
 298    Adds the hooks to the trace_hooks array.
 299  */
 300
 301 int lttv_trace_find_hook(LttTrace *t, GQuark facility_name, GQuark event_name,
 302                 GQuark fields[], LttvHook h, gpointer hook_data,
 303                 GArray **trace_hooks);
 304
 305 static inline struct marker_field *
 306 lttv_trace_get_hook_field(LttvTraceHook *hook, unsigned int index)
 307 {
 308         return g_ptr_array_index(hook->fields, index);
 309 }
 310
 311 #if 0
 312 static inline GQuark lttv_merge_facility_event_name(GQuark fac, GQuark ev)
 313 {
 314         char *tmp;
 315         const char *sfac, *sev;
 316         GQuark ret;
 317
 318         sfac = g_quark_to_string(fac);
 319         sev = g_quark_to_string(ev);
 320         tmp = g_new(char, strlen(sfac) + strlen(sev) + 3); /* 3: _ \0 \0 */
 321         strcpy(tmp, sfac);
 322         strcat(tmp, "_");
 323         strcat(tmp, sev);
 324         ret = g_quark_from_string(tmp);
 325         g_free(tmp);
 326         return ret;
 327 }
 328 #endif //0
 329
 330 LttvTracefileContext *
 331 lttv_traceset_context_get_current_tfc(LttvTracesetContext *self);
 332
 333
 334 LttvTracesetContextPosition *
 335 lttv_traceset_context_position_new(const LttvTracesetContext *self);
 336
 337 void lttv_traceset_context_position_save(const LttvTracesetContext *self,
 338                 LttvTracesetContextPosition *pos);
 339
 340 void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos);
 341
 342 void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
 343                 const LttvTracesetContextPosition *src);
 344
 345 gint
 346 lttv_traceset_context_pos_pos_compare(const LttvTracesetContextPosition *pos1,
 347                 const LttvTracesetContextPosition *pos2);
 348
 349 gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
 350                 const LttvTracesetContextPosition *pos2);
 351
 352 LttTime
 353 lttv_traceset_context_position_get_time(const LttvTracesetContextPosition *pos);
 354
 355 gint compare_tracefile(gconstpointer a, gconstpointer b);
 356
 357
 358 /* Synchronisation helpers : save/restore synchronization between ltt traces and
 359  * a traceset context. */
 360 void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *tsc);
 361
 362 void lttv_process_traceset_get_sync_data(LttvTracesetContext *tsc);
 363
 364 /* Seek n events forward and backward (without filtering) : only use these where
 365  * necessary : the seek backward is costy. */
 366
 367 #define BACKWARD_SEEK_MUL 2 /* Multiplication factor of time_offset between
 368                                backward seek iterations */
 369
 370 static const LttTime seek_back_default_offset = { 1, 0 };
 371
 372 typedef gboolean check_handler(guint count, gboolean *stop_flag, gpointer data);
 373
 374 guint lttv_process_traceset_seek_n_forward(LttvTracesetContext *self,
 375                 guint n,
 376                 check_handler *check,
 377                 gboolean *stop_flag,
 378                 LttvFilter *filter1,
 379                 LttvFilter *filter2,
 380                 LttvFilter *filter3,
 381                 gpointer data);
 382
 383 typedef void (*seek_time_fct)(LttvTracesetContext *self, LttTime start);
 384
 385 /* If first_offset is ltt_time_zero, it will choose a default value */
 386 guint lttv_process_traceset_seek_n_backward(LttvTracesetContext *self,
 387                 guint n,
 388                 LttTime first_offset,
 389                 seek_time_fct,
 390                 check_handler *check,
 391                 gboolean *stop_flag,
 392                 LttvFilter *filter1,
 393                 LttvFilter *filter2,
 394                 LttvFilter *filter3,
 395                 gpointer data);
 396
 397 #define FIELD_ARRAY(val...) ((GQuark[]){ val, 0 })
 398
 399 #endif // PROCESSTRACE_H