X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=lttv%2Flttv%2Ftraceset.c;h=370fa61b3f4bae152c0f0e808042466967a844cb;hb=9b55aba047555ab16b23b0d94002826c204bb715;hp=2c99c061f4c055e1582758f4d3fdf5b8f87a4998;hpb=68573dd0176817ad827ed9e292faaa933f0093bc;p=lttv.git diff --git a/lttv/lttv/traceset.c b/lttv/lttv/traceset.c index 2c99c061..370fa61b 100644 --- a/lttv/lttv/traceset.c +++ b/lttv/lttv/traceset.c @@ -33,13 +33,13 @@ /* To traverse a tree recursively */ #include -#include /* For the use of realpath*/ #include #include /* For strcpy*/ #include - +#include +#include /* A trace is a sequence of events gathered in the same tracing session. The events may be stored in several tracefiles in the same directory. A trace set is defined when several traces are to be analyzed together, @@ -68,7 +68,11 @@ LttvTraceset *lttv_traceset_new(void) ts->event_hooks = lttv_hooks_new(); ts->state_trace_handle_index = g_ptr_array_new(); + ts->has_precomputed_states = FALSE; + ts->time_span.start_time = ltt_time_zero; + ts->time_span.end_time = ltt_time_zero; + lttv_traceset_get_time_span_real(ts); return ts; } @@ -276,80 +280,69 @@ void lttv_traceset_add(LttvTraceset *s, LttvTrace *t) int lttv_traceset_add_path(LttvTraceset *ts, char *trace_path) { - FTS *tree; - FTSENT *node; - char * const paths[2] = { trace_path, NULL }; int ret = -1; - + DIR *curdir = NULL; gboolean metaFileFound = FALSE; - - tree = fts_open(paths, FTS_NOCHDIR | FTS_LOGICAL, 0); - if (tree == NULL) { - g_warning("Cannot traverse \"%s\" for reading.\n", - trace_path); + + /* Open top level directory */ + curdir = opendir(trace_path); + if (curdir == NULL) { + g_warning("Cannot open directory %s (%s)", trace_path, strerror(errno)); return ret; } - int dirfd, metafd; - while ((node = fts_read(tree))) { - - if (!(node->fts_info & FTS_D)) - continue; - - dirfd = open(node->fts_accpath, 0); - if (dirfd < 0) { - g_warning("Unable to open trace " - "directory file descriptor : %s.", node->fts_accpath); - ret = dirfd; + // Check if a metadata file exists in the current directory + int metafd = openat(dirfd(curdir), "metadata", O_RDONLY); + if (metafd < 0) { + + } else { + ret = close(metafd); + if (ret < 0) { + g_warning("Unable to close metadata " + "file descriptor : %s.", trace_path); goto error; } + + ret = lttv_traceset_create_trace(ts, trace_path); + if (ret < 0) { + g_warning("Opening trace \"%s\" " + "for reading.", trace_path); + goto error; + } + metaFileFound = TRUE; + } - // Check if a metadata file exists in the current directory - metafd = openat(dirfd, "metadata", O_RDONLY); - if (metafd < 0) { - ret = close(dirfd); - if (ret < 0) { - g_warning("Unable to open metadata " - "file descriptor : %s.", node->fts_accpath); - goto error; - } - } else { - ret = close(metafd); - if (ret < 0) { - g_warning("Unable to close metadata " - "file descriptor : %s.", node->fts_accpath); - goto error; - } - ret = close(dirfd); - if (ret < 0) { - g_warning("Unable to close trace " - "directory file descriptor : %s.", node->fts_accpath); - goto error; - } - - ret = lttv_traceset_create_trace(ts, node->fts_accpath); - if (ret < 0) { - g_warning("Opening trace \"%s\" from %s " - "for reading.", node->fts_accpath, trace_path); - goto error; + struct dirent curentry; + struct dirent *resultentry; + while ((ret = readdir_r(curdir, &curentry, &resultentry)) == 0) { + if (resultentry == NULL) { + /* No more entry*/ + break; + } + if (curentry.d_name[0] != '.') { + if (curentry.d_type == DT_DIR) { + + char curpath[PATH_MAX]; + snprintf(curpath, PATH_MAX, "%s/%s", trace_path, curentry.d_name); + ret = lttv_traceset_add_path(ts, curpath); + if (ret >= 0) { + metaFileFound = TRUE; + } } - metaFileFound = TRUE; } } + if (ret != 0) { + g_warning("Invalid readdir"); + } + error: - ret = fts_close(tree); - if (ret < 0) { - g_warning("Unable to close tree " - "file descriptor : %s.", trace_path); - } if(metaFileFound) return ret; else return -1; } - unsigned lttv_traceset_number(LttvTraceset *s) { return s->traces->len; @@ -434,7 +427,9 @@ LttvTracesetPosition *lttv_traceset_create_current_position(LttvTraceset *traces traceset_pos->iter = traceset->iter; traceset_pos->bt_pos = bt_iter_get_pos(bt_ctf_get_iter(traceset->iter)); - + traceset_pos->timestamp = G_MAXUINT64; + traceset_pos->cpu_id = INT_MAX; + return traceset_pos; } @@ -451,10 +446,11 @@ LttvTracesetPosition *lttv_traceset_create_time_position(LttvTraceset *traceset, } traceset_pos->iter = traceset->iter; - traceset_pos->bt_pos = bt_iter_create_time_pos( + traceset_pos->bt_pos = bt_iter_create_time_pos( bt_ctf_get_iter(traceset_pos->iter), ltt_time_to_uint64(timestamp)); - + traceset_pos->timestamp = G_MAXUINT64; + traceset_pos->cpu_id = INT_MAX; return traceset_pos; } @@ -479,7 +475,7 @@ guint lttv_traceset_get_cpuid_from_event(LttvEvent *event) if (timestamp == -1ULL) { return 0; } - const struct definition *scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT); + const struct bt_definition *scope = bt_ctf_get_top_level_scope(ctf_event, BT_STREAM_PACKET_CONTEXT); if (bt_ctf_field_get_error()) { return 0; } @@ -496,6 +492,8 @@ guint64 lttv_traceset_get_timestamp_first_event(LttvTraceset *ts) LttvTracesetPosition begin_position; struct bt_iter_pos pos; begin_position.bt_pos = &pos; + begin_position.timestamp = G_MAXUINT64; + begin_position.cpu_id = INT_MAX; /* Assign iterator to the beginning of the traces */ begin_position.bt_pos->type = BT_SEEK_BEGIN; @@ -504,6 +502,21 @@ guint64 lttv_traceset_get_timestamp_first_event(LttvTraceset *ts) return lttv_traceset_position_get_timestamp(&begin_position); } +guint64 lttv_traceset_get_timestamp_last_event(LttvTraceset *ts) +{ + LttvTracesetPosition last_position; + struct bt_iter_pos pos; + last_position.bt_pos = &pos; + last_position.timestamp = G_MAXUINT64; + last_position.cpu_id = INT_MAX; + + /* Assign iterator to the last event of the traces */ + last_position.bt_pos->type = BT_SEEK_LAST; + last_position.iter = ts->iter; + + return lttv_traceset_position_get_timestamp(&last_position); +} + /* * lttv_traceset_get_timestamp_begin : returns the minimum timestamp of * all the traces in the traceset. @@ -526,7 +539,8 @@ guint64 lttv_traceset_get_timestamp_begin(LttvTraceset *traceset) { currentTrace = g_ptr_array_index(traceset->traces,i); timestamp_cur = bt_trace_handle_get_timestamp_begin(bt_ctx, - currentTrace->id); + currentTrace->id, + BT_CLOCK_REAL); if(timestamp_cur < timestamp_min) timestamp_min = timestamp_cur; } @@ -558,7 +572,8 @@ guint64 lttv_traceset_get_timestamp_end(LttvTraceset *traceset) { currentTrace = g_ptr_array_index(traceset->traces,i); timestamp_cur = bt_trace_handle_get_timestamp_end(bt_ctx, - currentTrace->id); + currentTrace->id, + BT_CLOCK_REAL); if(timestamp_cur > timestamp_max){ timestamp_max = timestamp_cur; } @@ -568,28 +583,37 @@ guint64 lttv_traceset_get_timestamp_end(LttvTraceset *traceset) } /* * lttv_traceset_get_time_span_real : return a TimeInterval representing the - * minimum timestamp dans le maximum timestamp of the traceset. + * minimum timestamp and the maximum timestamp of the traceset. * */ TimeInterval lttv_traceset_get_time_span_real(LttvTraceset *ts) { - TimeInterval time_span; - time_span.start_time =ltt_time_from_uint64(lttv_traceset_get_timestamp_first_event(ts)); - time_span.end_time = ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts)); - return time_span; + + + if(ltt_time_compare(ts->time_span.start_time, + ltt_time_zero) == 0 && ts->traces->len > 0){ + ts->time_span.start_time = ltt_time_from_uint64( + lttv_traceset_get_timestamp_first_event(ts)); + ts->time_span.end_time = ltt_time_from_uint64( + lttv_traceset_get_timestamp_last_event(ts)); + } + return ts->time_span; } /* * lttv_traceset_get_time_span : return a TimeInterval representing the - * minimum timestamp dans le maximum timestamp of the traceset. + * minimum timestamp and the maximum timestamp of the traceset. * */ TimeInterval lttv_traceset_get_time_span(LttvTraceset *ts) { - TimeInterval time_span; - time_span.start_time =ltt_time_from_uint64(lttv_traceset_get_timestamp_begin(ts)); - time_span.end_time = ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts)); - return time_span; + if(ltt_time_compare(ts->time_span.start_time, ltt_time_zero) == 0){ + ts->time_span.start_time =ltt_time_from_uint64( + lttv_traceset_get_timestamp_begin(ts)); + ts->time_span.end_time = ltt_time_from_uint64( + lttv_traceset_get_timestamp_end(ts)); + } + return ts->time_span; } const char *lttv_traceset_get_name_from_event(LttvEvent *event) @@ -597,24 +621,56 @@ const char *lttv_traceset_get_name_from_event(LttvEvent *event) return bt_ctf_event_name(event->bt_event); } -guint64 lttv_traceset_position_get_timestamp(const LttvTracesetPosition *pos) -{ - guint64 timestamp = 0; - /*We save the current iterator,so we can reassign it after the seek*/ - LttvTracesetPosition previous_pos; - previous_pos.iter = pos->iter; - previous_pos.bt_pos = bt_iter_get_pos(bt_ctf_get_iter(pos->iter)); +int set_values_position(const LttvTracesetPosition *pos) +{ + LttvTracesetPosition previous_pos; + previous_pos.iter = pos->iter; + previous_pos.bt_pos = bt_iter_get_pos(bt_ctf_get_iter(pos->iter)); /* Seek to the new desired position */ - lttv_traceset_seek_to_position(pos); + lttv_traceset_seek_to_position(pos); /*Read the event*/ - struct bt_ctf_event *event = bt_ctf_iter_read_event(pos->iter); - + struct bt_ctf_event *event = bt_ctf_iter_read_event(pos->iter); + if(event != NULL){ - timestamp = bt_ctf_get_timestamp_raw(event); + ((LttvTracesetPosition *)pos)->timestamp = bt_ctf_get_timestamp(event); + + LttvEvent lttv_event; + lttv_event.bt_event = event; + ((LttvTracesetPosition *)pos)->cpu_id = lttv_traceset_get_cpuid_from_event(<tv_event); } - /* Reassign the previously saved position */ - lttv_traceset_seek_to_position(&previous_pos); - return timestamp; + else { + /* The event is null */ + return 0; + } + + /* Reassign the previously saved position */ + lttv_traceset_seek_to_position(&previous_pos); + /*We must desallocate because the function bt_iter_get_pos() does a g_new */ + bt_iter_free_pos(previous_pos.bt_pos); + if (pos->timestamp == G_MAXUINT64) { + return 0; + } + return 1; +} + +guint64 lttv_traceset_position_get_timestamp(const LttvTracesetPosition *pos) +{ + if(pos->timestamp == G_MAXUINT64){ + if(set_values_position(pos) == 0){ + return 0; + } + } + + return pos->timestamp; +} + +int lttv_traceset_position_get_cpuid(const LttvTracesetPosition *pos){ + if(pos->cpu_id == INT_MAX ){ + if(set_values_position(pos) == 0){ + return 0; + } + } + return pos->cpu_id; } LttTime lttv_traceset_position_get_time(const LttvTracesetPosition *pos) @@ -622,35 +678,73 @@ LttTime lttv_traceset_position_get_time(const LttvTracesetPosition *pos) return ltt_time_from_uint64(lttv_traceset_position_get_timestamp(pos)); } + +/* 0 if equals, other is different */ int lttv_traceset_position_compare(const LttvTracesetPosition *pos1, const LttvTracesetPosition *pos2) { #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" if(pos1 == NULL || pos2 == NULL){ return -1; } - + + int res = -1; +#ifdef HAVE_BT_ITER_EQUALS_POS + if(pos1->timestamp == G_MAXUINT64 || pos2->timestamp == G_MAXUINT64) { + res = bt_iter_equals_pos(pos1->bt_pos, pos2->bt_pos); + } +#endif + if (res < 0) { + + guint64 timeStampPos1,timeStampPos2; + guint cpuId1, cpuId2; + + timeStampPos1 = lttv_traceset_position_get_timestamp(pos1); + timeStampPos2 = lttv_traceset_position_get_timestamp(pos2); + + if (timeStampPos1 == timeStampPos2) { + + cpuId1 = lttv_traceset_position_get_cpuid(pos1); + cpuId2 = lttv_traceset_position_get_cpuid(pos2); + + if(cpuId1 == cpuId2){ + return 0; + } + } + return 1; + } else { + + return !res; + } +} + +int lttv_traceset_position_time_compare(const LttvTracesetPosition *pos1, + const LttvTracesetPosition *pos2) +{ guint64 timeStampPos1,timeStampPos2; - guint cpuId1, cpuId2; - LttvEvent event1, event2; - int ret; - - timeStampPos1 = lttv_traceset_position_get_timestamp(pos1); + + timeStampPos1 = lttv_traceset_position_get_timestamp(pos1); timeStampPos2 = lttv_traceset_position_get_timestamp(pos2); - event1.bt_event = bt_ctf_iter_read_event(pos1->iter); - event2.bt_event = bt_ctf_iter_read_event(pos2->iter); - - if(event1.bt_event == NULL || event2.bt_event == NULL){ - return -1; - } + return timeStampPos1 - timeStampPos2; +} +int lttv_traceset_position_compare_current(const LttvTraceset *ts, + const LttvTracesetPosition *pos) +{ + int result = 0; + LttvTracesetPosition *curPos = lttv_traceset_create_current_position(ts); - cpuId1 = lttv_traceset_get_cpuid_from_event(&event1); - cpuId2 = lttv_traceset_get_cpuid_from_event(&event2); - - if(timeStampPos1 == timeStampPos2 && cpuId1 == cpuId2){ - return 0; - } - else{ - return 1; - } + result = lttv_traceset_position_compare(curPos,pos); + + lttv_traceset_destroy_position(curPos); + + return result; +} + +LttTime lttv_traceset_get_current_time(const LttvTraceset *ts) +{ + LttvTracesetPosition *curPos = lttv_traceset_create_current_position(ts); + guint64 currentTimestamp = lttv_traceset_position_get_timestamp(curPos); + lttv_traceset_destroy_position(curPos); + + return ltt_time_from_uint64(currentTimestamp); }