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 typedef struct _LttvTraceState LttvTraceState;
  88
  89
  90 #define LTTV_TRACESET_CONTEXT_TYPE  (lttv_traceset_context_get_type ())
  91 #define LTTV_TRACESET_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContext))
  92 #define LTTV_TRACESET_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
  93 #define LTTV_IS_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_CONTEXT_TYPE))
  94 #define LTTV_IS_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_CONTEXT_TYPE))
  95 #define LTTV_TRACESET_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
  96
  97 struct _LttvTracesetContext {
  98         GObject parent;
  99
 100         LttvTraceset *ts;
 101         LttvTraceContext **traces;
 102         LttvAttribute *a;
 103         LttvAttribute *ts_a;
 104         TimeInterval time_span;
 105         GTree *pqueue;
 106         struct bt_ctf_iter *iter;
 107         /* TODO ybrosseau: Added for babeltrace proto */
 108         LttvHooks *event_hooks;
 109         LttvTraceState *tmpState; /* Remove when we have the state in LttvTrace */
 110
 111         LttvTracesetContextPosition *sync_position;   /* position at which to sync the
 112                                                          trace context */
 113 };
 114
 115 struct _LttvTracesetContextClass {
 116         GObjectClass parent;
 117
 118         void (*init) (LttvTracesetContext *self, LttvTraceset *ts);
 119         void (*fini) (LttvTracesetContext *self);
 120         LttvTracesetContext* (*new_traceset_context) (LttvTracesetContext *self);
 121         LttvTraceContext* (*new_trace_context) (LttvTracesetContext *self);
 122         LttvTracefileContext* (*new_tracefile_context) (LttvTracesetContext *self);
 123 };
 124
 125 GType lttv_traceset_context_get_type (void);
 126
 127 void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts);
 128
 129 void lttv_context_fini(LttvTracesetContext *self);
 130
 131 LttvTracesetContext *
 132 lttv_context_new_traceset_context(LttvTracesetContext *self);
 133
 134 LttvTraceContext *
 135 lttv_context_new_trace_context(LttvTracesetContext *self);
 136
 137 LttvTracefileContext *
 138 lttv_context_new_tracefile_context(LttvTracesetContext *self);
 139
 140
 141 #define LTTV_TRACE_CONTEXT_TYPE  (lttv_trace_context_get_type ())
 142 #define LTTV_TRACE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContext))
 143 #define LTTV_TRACE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
 144 #define LTTV_IS_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_CONTEXT_TYPE))
 145 #define LTTV_IS_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_CONTEXT_TYPE))
 146 #define LTTV_TRACE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
 147
 148 struct _LttvTraceContext {
 149         GObject parent;
 150
 151         LttvTracesetContext *ts_context;
 152         guint index;                /* in ts_context->traces */
 153         LttTrace *t;
 154         LttvTrace *vt;
 155         //LttvTracefileContext **tracefiles;
 156         GArray *tracefiles;
 157         LttvAttribute *a;
 158         LttvAttribute *t_a;
 159         TimeInterval time_span;
 160 };
 161
 162 struct _LttvTraceContextClass {
 163         GObjectClass parent;
 164 };
 165
 166 GType lttv_trace_context_get_type (void);
 167
 168 #define LTTV_TRACEFILE_CONTEXT_TYPE  (lttv_tracefile_context_get_type ())
 169 #define LTTV_TRACEFILE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContext))
 170 #define LTTV_TRACEFILE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
 171 #define LTTV_IS_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_CONTEXT_TYPE))
 172 #define LTTV_IS_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE))
 173 #define LTTV_TRACEFILE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
 174
 175 struct _LttvTracefileContext {
 176         GObject parent;
 177
 178         LttvTraceContext *t_context;
 179  // gboolean control;
 180         guint index;                /* in ts_context->tracefiles */
 181         LttTracefile *tf;
 182  // LttEvent *e;
 183         LttvHooks *event;
 184         LttvHooksById *event_by_id;
 185         LttTime timestamp;
 186         LttvAttribute *a;
 187         gint target_pid;          /* Target PID of the event.
 188                                 Updated by state.c. -1 means unset. */
 189 };
 190
 191 struct _LttvTracefileContextClass {
 192         GObjectClass parent;
 193 };
 194
 195 GType lttv_tracefile_context_get_type (void);
 196
 197 /* Run through the events in a traceset in sorted order calling all the
 198          hooks appropriately. It starts at the current time and runs until end or
 199          nb_events are processed. */
 200
 201 void lttv_process_traceset(LttvTracesetContext *self, LttTime end,
 202                 unsigned nb_events);
 203
 204 /* Process traceset can also be done in smaller pieces calling begin,
 205  * then seek and middle repeatedly, and end. The middle function return the
 206  * number of events processed. It will be smaller than nb_events if the end time
 207  * or end position is reached. */
 208
 209
 210 void lttv_process_traceset_begin(LttvTracesetContext *self,
 211                 LttvHooks *before_traceset,
 212                 LttvHooks *before_trace,
 213                 LttvHooks *before_tracefile,
 214                 LttvHooks *event,
 215                 LttvHooksByIdChannelArray *event_by_id_channel);
 216
 217
 218 guint lttv_process_traceset_middle(LttvTracesetContext *self,
 219                 LttTime end,
 220                 gulong nb_events,
 221                 const LttvTracesetContextPosition *end_position);
 222
 223 void lttv_process_traceset_end(LttvTracesetContext *self,
 224                 LttvHooks *after_traceset,
 225                 LttvHooks *after_trace,
 226                 LttvHooks *after_tracefile,
 227                 LttvHooks *event,
 228                 LttvHooksByIdChannelArray *event_by_id_channel);
 229
 230 guint lttv_process_traceset_update(LttvTracesetContext *self);
 231
 232
 233 void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start);
 234
 235 void lttv_traceset_context_compute_time_span(LttvTracesetContext *self,
 236                 TimeInterval *time_span);
 237
 238 gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
 239                 const LttvTracesetContextPosition *pos);
 240
 241 void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start);
 242
 243 void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
 244                 LttvHooks *before_traceset,
 245                 LttvHooks *before_trace,
 246                 LttvHooks *before_tracefile,
 247                 LttvHooks *event,
 248                 LttvHooksByIdChannelArray *event_by_id_channel);
 249
 250 void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
 251                 LttvHooks *after_traceset,
 252                 LttvHooks *after_trace,
 253                 LttvHooks *after_tracefile,
 254                 LttvHooks *event,
 255                 LttvHooksByIdChannelArray *event_by_id_channel);
 256
 257 void lttv_trace_context_add_hooks(LttvTraceContext *self,
 258                 LttvHooks *before_trace,
 259                 LttvHooks *before_tracefile,
 260                 LttvHooks *event,
 261                 LttvHooksByIdChannelArray *event_by_id_channel);
 262
 263 void lttv_trace_context_remove_hooks(LttvTraceContext *self,
 264                 LttvHooks *after_trace,
 265                 LttvHooks *after_tracefile,
 266                 LttvHooks *event,
 267                 LttvHooksByIdChannelArray *event_by_id_channel);
 268
 269 void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
 270                 LttvHooks *before_tracefile,
 271                 LttvHooks *event,
 272                 LttvHooksById *event_by_id);
 273
 274
 275 void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
 276                 LttvHooks *after_tracefile,
 277                 LttvHooks *event,
 278                 LttvHooksById *event_by_id);
 279
 280 typedef struct _LttvTraceHook {
 281         LttvHook h;
 282         struct marker_data *mdata;
 283         GQuark channel;
 284         guint16 id;  /* id of the marker associated with this hook */
 285         GPtrArray *fields;  /* struct marker_fields pointers */
 286         gpointer hook_data;
 287 } LttvTraceHook;
 288
 289 /* Get the head of marker list corresponding to the given trace hook.
 290  */
 291 struct marker_info *lttv_trace_hook_get_marker(LttTrace *t, LttvTraceHook *th);
 292
 293 /* Remove the hooks from the array. Does not free the array itself. */
 294 void lttv_trace_hook_remove_all(GArray **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    Returns the modified LttvTraceHook array.
 303    Prints warnings if events or markers are not found. returns 1 on error,
 304    0 on success.
 305    Adds the hooks to the trace_hooks array.
 306  */
 307
 308 int lttv_trace_find_hook(LttTrace *t, GQuark facility_name, GQuark event_name,
 309                 GQuark fields[], LttvHook h, gpointer hook_data,
 310                 GArray **trace_hooks);
 311
 312 static inline struct marker_field *
 313 lttv_trace_get_hook_field(LttvTraceHook *hook, unsigned int index)
 314 {
 315         return g_ptr_array_index(hook->fields, index);
 316 }
 317
 318 #if 0
 319 static inline GQuark lttv_merge_facility_event_name(GQuark fac, GQuark ev)
 320 {
 321         char *tmp;
 322         const char *sfac, *sev;
 323         GQuark ret;
 324
 325         sfac = g_quark_to_string(fac);
 326         sev = g_quark_to_string(ev);
 327         tmp = g_new(char, strlen(sfac) + strlen(sev) + 3); /* 3: _ \0 \0 */
 328         strcpy(tmp, sfac);
 329         strcat(tmp, "_");
 330         strcat(tmp, sev);
 331         ret = g_quark_from_string(tmp);
 332         g_free(tmp);
 333         return ret;
 334 }
 335 #endif //0
 336
 337 LttvTracefileContext *
 338 lttv_traceset_context_get_current_tfc(LttvTracesetContext *self);
 339
 340
 341 LttvTracesetContextPosition *
 342 lttv_traceset_context_position_new(const LttvTracesetContext *self);
 343
 344 void lttv_traceset_context_position_save(const LttvTracesetContext *self,
 345                 LttvTracesetContextPosition *pos);
 346
 347 void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos);
 348
 349 void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
 350                 const LttvTracesetContextPosition *src);
 351
 352 gint
 353 lttv_traceset_context_pos_pos_compare(const LttvTracesetContextPosition *pos1,
 354                 const LttvTracesetContextPosition *pos2);
 355
 356 gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
 357                 const LttvTracesetContextPosition *pos2);
 358
 359 LttTime
 360 lttv_traceset_context_position_get_time(const LttvTracesetContextPosition *pos);
 361
 362 gint compare_tracefile(gconstpointer a, gconstpointer b);
 363
 364
 365 /* Synchronisation helpers : save/restore synchronization between ltt traces and
 366  * a traceset context. */
 367 void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *tsc);
 368
 369 void lttv_process_traceset_get_sync_data(LttvTracesetContext *tsc);
 370
 371 /* Seek n events forward and backward (without filtering) : only use these where
 372  * necessary : the seek backward is costy. */
 373
 374 #define BACKWARD_SEEK_MUL 2 /* Multiplication factor of time_offset between
 375                                backward seek iterations */
 376
 377 static const LttTime seek_back_default_offset = { 1, 0 };
 378
 379 typedef gboolean check_handler(guint count, gboolean *stop_flag, gpointer data);
 380
 381 guint lttv_process_traceset_seek_n_forward(LttvTracesetContext *self,
 382                 guint n,
 383                 check_handler *check,
 384                 gboolean *stop_flag,
 385                 LttvFilter *filter1,
 386                 LttvFilter *filter2,
 387                 LttvFilter *filter3,
 388                 gpointer data);
 389
 390 typedef void (*seek_time_fct)(LttvTracesetContext *self, LttTime start);
 391
 392 /* If first_offset is ltt_time_zero, it will choose a default value */
 393 guint lttv_process_traceset_seek_n_backward(LttvTracesetContext *self,
 394                 guint n,
 395                 LttTime first_offset,
 396                 seek_time_fct,
 397                 check_handler *check,
 398                 gboolean *stop_flag,
 399                 LttvFilter *filter1,
 400                 LttvFilter *filter2,
 401                 LttvFilter *filter3,
 402                 gpointer data);
 403
 404 #define FIELD_ARRAY(val...) ((GQuark[]){ val, 0 })
 405
 406 #endif // PROCESSTRACE_H