lttv/lttv/traceset.c

   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 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <lttv/traceset.h>
  24 #include <lttv/iattribute.h>
  25 #include <lttv/state.h>
  26 #include <lttv/event.h>
  27 #include <lttv/hook.h>
  28 #include <stdio.h>
  29 #include <babeltrace/babeltrace.h>
  30 #include <babeltrace/context.h>
  31 #include <babeltrace/ctf/iterator.h>
  32 #include <babeltrace/ctf/events.h>
  33
  34 /* To traverse a tree recursively */
  35 #include <fcntl.h>
  36 #include <fts.h>
  37 /* For the use of realpath*/
  38 #include <limits.h>
  39 #include <stdlib.h>
  40 /* For strcpy*/
  41 #include <string.h>
  42
  43 /* A trace is a sequence of events gathered in the same tracing session. The
  44    events may be stored in several tracefiles in the same directory.
  45    A trace set is defined when several traces are to be analyzed together,
  46    possibly to study the interactions between events in the different traces.
  47 */
  48
  49
  50 LttvTraceset *lttv_traceset_new(void)
  51 {
  52         LttvTraceset *ts;
  53         struct bt_iter_pos begin_pos;
  54
  55         ts = g_new(LttvTraceset, 1);
  56         ts->filename = NULL;
  57         ts->traces = g_ptr_array_new();
  58         ts->context = bt_context_create();
  59         ts->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
  60         //TODO remove this when we have really mecanism
  61         //s->tmpState = g_new(LttvTraceState *, 1);
  62         //lttv_trace_state_init(s->tmpState,0);
  63
  64         /*Initialize iterator to the beginning of the traces*/
  65         begin_pos.type = BT_SEEK_BEGIN;
  66         ts->iter = bt_ctf_iter_create(ts->context, &begin_pos, NULL);
  67
  68         ts->event_hooks = lttv_hooks_new();
  69
  70         ts->state_trace_handle_index = g_ptr_array_new();
  71
  72         return ts;
  73 }
  74
  75 char * lttv_traceset_name(LttvTraceset * s)
  76 {
  77         return s->filename;
  78 }
  79
  80 #ifdef BABEL_CLEANUP
  81 LttvTrace *lttv_trace_new(LttTrace *t)
  82 {
  83         LttvTrace *new_trace;
  84
  85         new_trace = g_new(LttvTrace, 1);
  86         new_trace->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
  87         new_trace->id = t;
  88         new_trace->ref_count = 0;
  89         return new_trace;
  90 }
  91 #endif
  92 /*
  93  * get_absolute_pathname : Return the unique pathname in the system
  94  *
  95  * pathname is the relative path.
  96  *
  97  * abs_pathname is being set to the absolute path.
  98  *
  99  */
 100 void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname)
 101 {
 102   abs_pathname[0] = '\0';
 103
 104   if (realpath(pathname, abs_pathname) != NULL)
 105     return;
 106   else
 107   {
 108     /* error, return the original path unmodified */
 109     strcpy(abs_pathname, pathname);
 110     return;
 111   }
 112   return;
 113 }
 114
 115
 116
 117 /*
 118  * lttv_trace_create : Create a trace from a path
 119  *
 120  * ts is the traceset in which will be contained the trace
 121  *
 122  * path is the path where to find a trace. It is not recursive.
 123  *
 124  * This function is static since a trace should always be contained in a
 125  * traceset.
 126  *
 127  * return the created trace or NULL on failure
 128  */
 129 static LttvTrace *lttv_trace_create(LttvTraceset *ts, const char *path)
 130 {
 131         int id = bt_context_add_trace(lttv_traceset_get_context(ts),
 132                 path,
 133                 "ctf",
 134                 NULL,
 135                 NULL,
 136                 NULL);
 137         if (id < 0) {
 138                 return NULL;
 139         }
 140         // Create the trace and save the trace handle id returned by babeltrace
 141         LttvTrace *new_trace;
 142
 143         new_trace = g_new(LttvTrace, 1);
 144         new_trace->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
 145         new_trace->id = id;
 146         new_trace->ref_count = 0;
 147         new_trace->traceset = ts;
 148         new_trace->state = g_new(LttvTraceState,1);
 149         lttv_trace_state_init(new_trace->state,new_trace);
 150
 151         /* Add the state to the trace_handle to state index */
 152         g_ptr_array_set_size(ts->state_trace_handle_index,id+1);
 153         g_ptr_array_index(ts->state_trace_handle_index,id) = new_trace->state;
 154
 155         return new_trace;
 156 }
 157
 158 /*
 159  * lttv_trace_create : Create and add a single trace to a traceset
 160  *
 161  * ts is the traceset in which will be contained the trace
 162  *
 163  * path is the path where to find a trace. It is not recursive.
 164  *
 165  * return a positive integer (>=0)on success or -1 on failure
 166  */
 167 static int lttv_traceset_create_trace(LttvTraceset *ts, const char *path)
 168 {
 169         LttvTrace *trace = lttv_trace_create(ts, path);
 170         if (trace == NULL) {
 171                 return -1;
 172         }
 173         lttv_traceset_add(ts, trace);
 174         return 0;
 175 }
 176
 177 LttvTraceset *lttv_traceset_copy(LttvTraceset *s_orig)
 178 {
 179         guint i;
 180         LttvTraceset *s;
 181         LttvTrace * trace;
 182
 183         s = g_new(LttvTraceset, 1);
 184         s->filename = NULL;
 185         s->traces = g_ptr_array_new();
 186         s->state_trace_handle_index = g_ptr_array_new();
 187         for(i=0;i<s_orig->traces->len;i++)
 188         {
 189                 trace = g_ptr_array_index(s_orig->traces, i);
 190                 trace->ref_count++;
 191
 192                 /* WARNING: this is an alias, not a copy. */
 193                 g_ptr_array_add(s->traces, trace);
 194
 195                 g_ptr_array_set_size(s->state_trace_handle_index,trace->id+1);
 196                 g_ptr_array_index(s->state_trace_handle_index,trace->id) = trace->state;
 197
 198         }
 199         s->context = s_orig->context;
 200         bt_context_get(s->context);
 201         s->a = LTTV_ATTRIBUTE(lttv_iattribute_deep_copy(LTTV_IATTRIBUTE(s_orig->a)));
 202         return s;
 203 }
 204
 205
 206 LttvTraceset *lttv_traceset_load(const gchar *filename)
 207 {
 208         LttvTraceset *s = g_new(LttvTraceset,1);
 209         FILE *tf;
 210
 211         s->filename = g_strdup(filename);
 212         tf = fopen(filename,"r");
 213
 214         g_critical("NOT IMPLEMENTED : load traceset data from a XML file");
 215
 216         fclose(tf);
 217         return s;
 218 }
 219
 220 gint lttv_traceset_save(LttvTraceset *s)
 221 {
 222         FILE *tf;
 223
 224         tf = fopen(s->filename, "w");
 225
 226         g_critical("NOT IMPLEMENTED : save traceset data in a XML file");
 227
 228         fclose(tf);
 229         return 0;
 230 }
 231
 232 void lttv_traceset_destroy(LttvTraceset *s)
 233 {
 234         guint i;
 235
 236         for(i=0;i<s->traces->len;i++) {
 237                 LttvTrace *trace = g_ptr_array_index(s->traces, i);
 238                 lttv_trace_unref(trace);
 239                 // todo mdenis 2012-03-27: uncomment when babeltrace gets fixed
 240                 //bt_context_remove_trace(lttv_traceset_get_context(s), trace->id);
 241                 if(lttv_trace_get_ref_number(trace) == 0)
 242                         lttv_trace_destroy(trace);
 243         }
 244         g_ptr_array_free(s->traces, TRUE);
 245         bt_context_put(s->context);
 246         g_object_unref(s->a);
 247         g_free(s);
 248 }
 249
 250 struct bt_context *lttv_traceset_get_context(LttvTraceset *s)
 251 {
 252         return s->context;
 253 }
 254
 255 LttvTraceset *lttv_trace_get_traceset(LttvTrace *trace)
 256 {
 257         return trace->traceset;
 258 }
 259
 260 LttvHooks *lttv_traceset_get_hooks(LttvTraceset *s)
 261 {
 262         return s->event_hooks;
 263 }
 264
 265 void lttv_trace_destroy(LttvTrace *t)
 266 {
 267         g_object_unref(t->a);
 268         g_free(t);
 269 }
 270
 271 void lttv_traceset_add(LttvTraceset *s, LttvTrace *t)
 272 {
 273         t->ref_count++;
 274         g_ptr_array_add(s->traces, t);
 275 }
 276
 277 int lttv_traceset_add_path(LttvTraceset *ts, char *trace_path)
 278 {
 279         FTS *tree;
 280         FTSENT *node;
 281         char * const paths[2] = { trace_path, NULL };
 282         int ret = -1;
 283
 284         gboolean metaFileFound = FALSE;
 285
 286         tree = fts_open(paths, FTS_NOCHDIR | FTS_LOGICAL, 0);
 287         if (tree == NULL) {
 288                 g_warning("Cannot traverse \"%s\" for reading.\n",
 289                                 trace_path);
 290                 return ret;
 291         }
 292
 293         int dirfd, metafd;
 294         while ((node = fts_read(tree))) {
 295
 296                 if (!(node->fts_info & FTS_D))
 297                         continue;
 298
 299                 dirfd = open(node->fts_accpath, 0);
 300                 if (dirfd < 0) {
 301                         g_warning("Unable to open trace "
 302                                         "directory file descriptor : %s.", node->fts_accpath);
 303                         ret = dirfd;
 304                         goto error;
 305                 }
 306
 307                 // Check if a metadata file exists in the current directory
 308                 metafd = openat(dirfd, "metadata", O_RDONLY);
 309                 if (metafd < 0) {
 310                         ret = close(dirfd);
 311                         if (ret < 0) {
 312                                 g_warning("Unable to open metadata "
 313                                                 "file descriptor : %s.", node->fts_accpath);
 314                                 goto error;
 315                         }
 316                 } else {
 317                         ret = close(metafd);
 318                         if (ret < 0) {
 319                                 g_warning("Unable to close metadata "
 320                                                 "file descriptor : %s.", node->fts_accpath);
 321                                 goto error;
 322                         }
 323                         ret = close(dirfd);
 324                         if (ret < 0) {
 325                                 g_warning("Unable to close trace "
 326                                                 "directory file descriptor : %s.", node->fts_accpath);
 327                                 goto error;
 328                         }
 329
 330                         ret = lttv_traceset_create_trace(ts, node->fts_accpath);
 331                         if (ret < 0) {
 332                                 g_warning("Opening trace \"%s\" from %s "
 333                                                 "for reading.", node->fts_accpath, trace_path);
 334                                 goto error;
 335                         }
 336                         metaFileFound = TRUE;
 337                 }
 338         }
 339
 340 error:
 341         ret = fts_close(tree);
 342         if (ret < 0) {
 343                 g_warning("Unable to close tree  "
 344                                 "file descriptor : %s.", trace_path);
 345         }
 346         if(metaFileFound)
 347           return ret;
 348         else
 349           return -1;
 350 }
 351
 352
 353 unsigned lttv_traceset_number(LttvTraceset *s)
 354 {
 355         return s->traces->len;
 356 }
 357
 358
 359 LttvTrace *lttv_traceset_get(LttvTraceset *s, unsigned i)
 360 {
 361         g_assert(s->traces->len > i);
 362         return ((LttvTrace *)s->traces->pdata[i]);
 363 }
 364
 365
 366 void lttv_traceset_remove(LttvTraceset *s, unsigned i)
 367 {
 368         LttvTrace * t;
 369         g_assert(s->traces->len > i);
 370         t = (LttvTrace *)s->traces->pdata[i];
 371         t->ref_count--;
 372         bt_context_remove_trace(lttv_traceset_get_context(s), t->id);
 373         g_ptr_array_remove_index(s->traces, i);
 374 }
 375
 376
 377 /* A set of attributes is attached to each trace set, trace and tracefile
 378          to store user defined data as needed. */
 379
 380 LttvAttribute *lttv_traceset_attribute(LttvTraceset *s)
 381 {
 382         return s->a;
 383 }
 384
 385
 386 LttvAttribute *lttv_trace_attribute(LttvTrace *t)
 387 {
 388         return t->a;
 389 }
 390
 391
 392 gint lttv_trace_get_id(LttvTrace *t)
 393 {
 394         return t->id;
 395 }
 396
 397 guint lttv_trace_get_ref_number(LttvTrace * t)
 398 {
 399         // todo mdenis: adapt to babeltrace
 400         return t->ref_count;
 401 }
 402
 403 guint lttv_trace_ref(LttvTrace * t)
 404 {
 405         t->ref_count++;
 406
 407         return t->ref_count;
 408 }
 409
 410 guint lttv_trace_unref(LttvTrace * t)
 411 {
 412         if(likely(t->ref_count > 0))
 413                 t->ref_count--;
 414
 415         return t->ref_count;
 416 }
 417
 418 guint lttv_trace_get_num_cpu(LttvTrace *t)
 419 {
 420 #warning "TODO - Set the right number of CPU"
 421         return 24;
 422 }
 423
 424 LttvTracesetPosition *lttv_traceset_create_position(LttvTraceset *traceset)
 425 {
 426         LttvTracesetPosition *traceset_pos;
 427
 428         traceset_pos = g_new(LttvTracesetPosition, 1);
 429
 430         /* Check if the new passed */
 431         if(traceset_pos == NULL) {
 432                 return NULL;
 433         }
 434
 435         traceset_pos->iter = traceset->iter;
 436         traceset_pos->bt_pos = bt_iter_get_pos(bt_ctf_get_iter(traceset->iter));
 437
 438         return traceset_pos;
 439 }
 440
 441 LttvTracesetPosition *lttv_traceset_create_time_position(LttvTraceset *traceset,
 442                                                                 LttTime timestamp)
 443 {
 444         LttvTracesetPosition *traceset_pos;
 445
 446         traceset_pos = g_new(LttvTracesetPosition, 1);
 447
 448         /* Check if the new passed */
 449         if(traceset_pos == NULL) {
 450                 return NULL;
 451         }
 452
 453         traceset_pos->iter = traceset->iter;
 454         traceset_pos->bt_pos = bt_iter_create_time_pos(
 455                                         bt_ctf_get_iter(traceset_pos->iter),
 456                                         ltt_time_to_uint64(timestamp));
 457
 458         return traceset_pos;
 459 }
 460
 461 void lttv_traceset_destroy_position(LttvTracesetPosition *traceset_pos)
 462 {
 463         bt_iter_free_pos(traceset_pos->bt_pos);
 464         g_free(traceset_pos);
 465 }
 466
 467 void lttv_traceset_seek_to_position(const LttvTracesetPosition *traceset_pos)
 468 {
 469         bt_iter_set_pos(bt_ctf_get_iter(traceset_pos->iter), traceset_pos->bt_pos);
 470 }
 471
 472 guint lttv_traceset_get_cpuid_from_event(LttvEvent *event)
 473 {
 474         unsigned long timestamp;
 475         unsigned int cpu_id;
 476
 477         struct bt_ctf_event *ctf_event = event->bt_event;
 478         timestamp = bt_ctf_get_timestamp(ctf_event);
 479         if (timestamp == -1ULL) {
 480                 return 0;
 481         }
 482         const struct definition *scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT);
 483         if (bt_ctf_field_get_error()) {
 484                 return 0;
 485         }
 486         cpu_id = bt_ctf_get_uint64(bt_ctf_get_field(ctf_event, scope, "cpu_id"));
 487         if (bt_ctf_field_get_error()) {
 488                 return 0;
 489         } else {
 490                 return cpu_id;
 491         }
 492 }
 493
 494 guint64 lttv_traceset_get_timestamp_first_event(LttvTraceset *ts)
 495 {
 496         LttvTracesetPosition begin_position;
 497         struct bt_iter_pos pos;
 498         begin_position.bt_pos = &pos;
 499
 500          /* Assign iterator to the beginning of the traces */
 501         begin_position.bt_pos->type = BT_SEEK_BEGIN;
 502         begin_position.iter = ts->iter;
 503
 504         return lttv_traceset_position_get_timestamp(&begin_position);
 505 }
 506
 507 /*
 508  * lttv_traceset_get_timestamp_begin : returns the  minimum timestamp of
 509  * all the traces in the traceset.
 510  *
 511  */
 512 guint64 lttv_traceset_get_timestamp_begin(LttvTraceset *traceset)
 513 {
 514         struct bt_context *bt_ctx;
 515         bt_ctx = lttv_traceset_get_context(traceset);
 516         guint64 timestamp_min, timestamp_cur = 0;
 517         int i;
 518         int trace_count;
 519         LttvTrace *currentTrace;
 520         trace_count = traceset->traces->len;
 521         if(trace_count == 0)
 522                 timestamp_min = 0;
 523         else{
 524                 timestamp_min = G_MAXUINT64;
 525                 for(i = 0; i < trace_count;i++)
 526                 {
 527                         currentTrace = g_ptr_array_index(traceset->traces,i);
 528                         timestamp_cur = bt_trace_handle_get_timestamp_begin(bt_ctx,
 529                                                                         currentTrace->id);
 530                         if(timestamp_cur < timestamp_min)
 531                                 timestamp_min = timestamp_cur;
 532                 }
 533         }
 534         return timestamp_min;
 535 }
 536
 537 /*
 538  * lttv_traceset_get_timestamp_end: returns the maximum timestamp of
 539  * all the traces in the traceset.
 540  *
 541  */
 542 guint64 lttv_traceset_get_timestamp_end(LttvTraceset *traceset)
 543 {
 544         struct bt_context *bt_ctx;
 545         bt_ctx = lttv_traceset_get_context(traceset);
 546         guint64 timestamp_max, timestamp_cur = 0;
 547         int i;
 548         int trace_count;
 549         LttvTrace *currentTrace;
 550         trace_count = traceset->traces->len;
 551
 552         if(trace_count == 0){
 553                 timestamp_max = 1;
 554         }
 555         else{
 556                 timestamp_max = 0;
 557                 for(i =0; i < trace_count;i++)
 558                 {
 559                         currentTrace = g_ptr_array_index(traceset->traces,i);
 560                         timestamp_cur = bt_trace_handle_get_timestamp_end(bt_ctx,
 561                                                                           currentTrace->id);
 562                         if(timestamp_cur > timestamp_max){
 563                                 timestamp_max = timestamp_cur;
 564                         }
 565                 }
 566         }
 567         return timestamp_max;
 568 }
 569 /*
 570  * lttv_traceset_get_time_span_real : return a TimeInterval representing the
 571  * minimum timestamp dans le maximum timestamp of the traceset.
 572  *
 573  */
 574 TimeInterval lttv_traceset_get_time_span_real(LttvTraceset *ts)
 575 {
 576         TimeInterval time_span;
 577         time_span.start_time =ltt_time_from_uint64(lttv_traceset_get_timestamp_first_event(ts));
 578         time_span.end_time = ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts));
 579         return time_span;
 580 }
 581
 582 /*
 583  * lttv_traceset_get_time_span : return a TimeInterval representing the
 584  * minimum timestamp dans le maximum timestamp of the traceset.
 585  *
 586  */
 587 TimeInterval lttv_traceset_get_time_span(LttvTraceset *ts)
 588 {
 589         TimeInterval time_span;
 590         time_span.start_time =ltt_time_from_uint64(lttv_traceset_get_timestamp_begin(ts));
 591         time_span.end_time = ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts));
 592         return time_span;
 593 }
 594
 595 const char *lttv_traceset_get_name_from_event(LttvEvent *event)
 596 {
 597         return bt_ctf_event_name(event->bt_event);
 598 }
 599
 600 guint64 lttv_traceset_position_get_timestamp(const LttvTracesetPosition *pos)
 601 {
 602         guint64 timestamp = 0;
 603         /*We save the current iterator,so we can reassign it after the seek*/
 604         LttvTracesetPosition previous_pos;
 605         previous_pos.iter = pos->iter;
 606         previous_pos.bt_pos = bt_iter_get_pos(bt_ctf_get_iter(pos->iter));
 607         /* Seek to the new desired position */
 608         lttv_traceset_seek_to_position(pos);
 609         /*Read the event*/
 610         struct bt_ctf_event *event = bt_ctf_iter_read_event(pos->iter);
 611
 612         if(event != NULL){
 613                 timestamp = bt_ctf_get_timestamp_raw(event);
 614         }
 615         /* Reassign the previously saved position */
 616         lttv_traceset_seek_to_position(&previous_pos);
 617         return timestamp;
 618 }
 619
 620 LttTime  lttv_traceset_position_get_time(const LttvTracesetPosition *pos)
 621 {
 622         return ltt_time_from_uint64(lttv_traceset_position_get_timestamp(pos));
 623 }
 624
 625 int lttv_traceset_position_compare(const LttvTracesetPosition *pos1, const LttvTracesetPosition *pos2)
 626 {
 627 #warning " TODO :Rename for lttv_traceset_position_equals && Must return COMPARAISON OF THE 2 POSITION && verify if it is the best way to compare position"
 628         if(pos1 == NULL || pos2 == NULL){
 629                 return -1;
 630         }
 631
 632         guint64 timeStampPos1,timeStampPos2;
 633         guint cpuId1, cpuId2;
 634         LttvEvent event1, event2;
 635         int ret;
 636
 637         timeStampPos1 = lttv_traceset_position_get_timestamp(pos1);
 638         timeStampPos2 = lttv_traceset_position_get_timestamp(pos2);
 639
 640         event1.bt_event = bt_ctf_iter_read_event(pos1->iter);
 641         event2.bt_event = bt_ctf_iter_read_event(pos2->iter);
 642
 643         if(event1.bt_event == NULL || event2.bt_event == NULL){
 644                 return -1;
 645         }
 646
 647         cpuId1 = lttv_traceset_get_cpuid_from_event(&event1);
 648         cpuId2 = lttv_traceset_get_cpuid_from_event(&event2);
 649
 650         if(timeStampPos1 == timeStampPos2 && cpuId1 == cpuId2){
 651                 return 0;
 652         }
 653         else{
 654                 return 1;
 655         }
 656 }