X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fctf.c;h=16a7ba0fd66e831b0691b17f75a812ace6964017;hb=4e752ebc939db830c9d7e7c763f415744c9fc688;hp=786ba6fb120a9758570e74b1a0aa2ee50df06a4c;hpb=ec32346491f3e11fbc802a04f7dfd3259e6a8b17;p=babeltrace.git diff --git a/formats/ctf/ctf.c b/formats/ctf/ctf.c index 786ba6fb..16a7ba0f 100644 --- a/formats/ctf/ctf.c +++ b/formats/ctf/ctf.c @@ -33,8 +33,9 @@ #include #include #include -#include +#include #include +#include #include #include #include @@ -51,7 +52,7 @@ #include "metadata/ctf-parser.h" #include "metadata/ctf-ast.h" #include "events-private.h" -#include "memstream.h" +#include #define LOG2_CHAR_BIT 3 @@ -71,12 +72,15 @@ #define NSEC_PER_SEC 1000000000ULL +#define INDEX_PATH "./index/%s.idx" + int opt_clock_cycles, opt_clock_seconds, opt_clock_date, opt_clock_gmt; uint64_t opt_clock_offset; +uint64_t opt_clock_offset_ns; extern int yydebug; @@ -321,6 +325,9 @@ void ctf_print_timestamp_real(FILE *fp, ts_nsec = timestamp; + /* Add command-line offset in ns*/ + ts_nsec += opt_clock_offset_ns; + /* Add command-line offset */ ts_sec += opt_clock_offset; @@ -426,9 +433,9 @@ void ctf_print_discarded(FILE *fp, struct ctf_stream_definition *stream, } fprintf(fp, "] in trace UUID "); print_uuid(fp, stream->stream_class->trace->uuid); - if (stream->stream_class->trace->path[0]) + if (stream->stream_class->trace->parent.path[0]) fprintf(fp, ", at path: \"%s\"", - stream->stream_class->trace->path); + stream->stream_class->trace->parent.path); fprintf(fp, ", within stream id %" PRIu64, stream->stream_id); if (stream->path[0]) @@ -464,6 +471,15 @@ int ctf_read_event(struct bt_stream_pos *ppos, struct ctf_stream_definition *str */ if (unlikely(pos->offset == EOF)) return EOF; + + if (pos->content_size == 0) { + /* Stream is inactive for now (live reading). */ + return EAGAIN; + } + /* Packet only contains headers */ + if (pos->offset == pos->content_size) + return EAGAIN; + assert(pos->offset < pos->content_size); /* Read event header */ @@ -544,10 +560,15 @@ int ctf_read_event(struct bt_stream_pos *ppos, struct ctf_stream_definition *str goto error; } + if (pos->last_offset == pos->offset) { + fprintf(stderr, "[error] Invalid 0 byte event encountered.\n"); + return -EINVAL; + } + return 0; error: - fprintf(stderr, "[error] Unexpected end of stream. Either the trace data stream is corrupted or metadata description does not match data layout.\n"); + fprintf(stderr, "[error] Unexpected end of packet. Either the trace data stream is corrupted or metadata description does not match data layout.\n"); return ret; } @@ -606,7 +627,109 @@ error: return ret; } -int ctf_init_pos(struct ctf_stream_pos *pos, int fd, int open_flags) +/* + * One side-effect of this function is to unmap pos mmap base if one is + * mapped. + */ +static +int find_data_offset(struct ctf_stream_pos *pos, + struct ctf_file_stream *file_stream, + struct packet_index *packet_index) +{ + uint64_t packet_map_len = DEFAULT_HEADER_LEN, tmp_map_len; + struct stat filestats; + size_t filesize; + int ret; + + pos = &file_stream->pos; + + ret = fstat(pos->fd, &filestats); + if (ret < 0) + return ret; + filesize = filestats.st_size; + + /* Deal with empty files */ + if (!filesize) { + return 0; + } + +begin: + if (filesize - pos->mmap_offset < (packet_map_len >> LOG2_CHAR_BIT)) { + packet_map_len = (filesize - pos->mmap_offset) << LOG2_CHAR_BIT; + } + + if (pos->base_mma) { + /* unmap old base */ + ret = munmap_align(pos->base_mma); + if (ret) { + fprintf(stderr, "[error] Unable to unmap old base: %s.\n", + strerror(errno)); + return ret; + } + pos->base_mma = NULL; + } + /* map new base. Need mapping length from header. */ + pos->base_mma = mmap_align(packet_map_len >> LOG2_CHAR_BIT, PROT_READ, + MAP_PRIVATE, pos->fd, pos->mmap_offset); + assert(pos->base_mma != MAP_FAILED); + + pos->content_size = packet_map_len; + pos->packet_size = packet_map_len; + pos->offset = 0; /* Position of the packet header */ + + /* update trace_packet_header and stream_packet_context */ + if (pos->prot == PROT_READ && file_stream->parent.trace_packet_header) { + /* Read packet header */ + ret = generic_rw(&pos->parent, &file_stream->parent.trace_packet_header->p); + if (ret) { + if (ret == -EFAULT) + goto retry; + } + } + if (pos->prot == PROT_READ && file_stream->parent.stream_packet_context) { + /* Read packet context */ + ret = generic_rw(&pos->parent, &file_stream->parent.stream_packet_context->p); + if (ret) { + if (ret == -EFAULT) + goto retry; + } + } + packet_index->data_offset = pos->offset; + + /* unmap old base */ + ret = munmap_align(pos->base_mma); + if (ret) { + fprintf(stderr, "[error] Unable to unmap old base: %s.\n", + strerror(errno)); + return ret; + } + pos->base_mma = NULL; + + return 0; + + /* Retry with larger mapping */ +retry: + if (packet_map_len == ((filesize - pos->mmap_offset) << LOG2_CHAR_BIT)) { + /* + * Reached EOF, but still expecting header/context data. + */ + fprintf(stderr, "[error] Reached end of file, but still expecting header or context fields.\n"); + return -EFAULT; + } + /* Double the mapping len, and retry */ + tmp_map_len = packet_map_len << 1; + if (tmp_map_len >> 1 != packet_map_len) { + /* Overflow */ + fprintf(stderr, "[error] Packet mapping length overflow\n"); + return -EFAULT; + } + packet_map_len = tmp_map_len; + goto begin; +} + + +int ctf_init_pos(struct ctf_stream_pos *pos, struct bt_trace_descriptor *trace, + int fd, int open_flags) { pos->fd = fd; if (fd >= 0) { @@ -624,12 +747,14 @@ int ctf_init_pos(struct ctf_stream_pos *pos, int fd, int open_flags) pos->flags = MAP_PRIVATE; pos->parent.rw_table = read_dispatch_table; pos->parent.event_cb = ctf_read_event; + pos->parent.trace = trace; break; case O_RDWR: pos->prot = PROT_WRITE; /* Write has priority */ pos->flags = MAP_SHARED; pos->parent.rw_table = write_dispatch_table; pos->parent.event_cb = ctf_write_event; + pos->parent.trace = trace; if (fd >= 0) ctf_packet_seek(&pos->parent, 0, SEEK_SET); /* position for write */ break; @@ -663,7 +788,7 @@ int ctf_fini_pos(struct ctf_stream_pos *pos) /* * for SEEK_CUR: go to next packet. - * for SEEK_POS: go to packet numer (index). + * for SEEK_SET: go to packet numer (index). */ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence) { @@ -675,6 +800,14 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence) off_t off; struct packet_index *packet_index; + switch (whence) { + case SEEK_CUR: + case SEEK_SET: /* Fall-through */ + break; /* OK */ + default: + assert(0); + } + if (pos->prot == PROT_WRITE && pos->content_size_loc) *pos->content_size_loc = pos->offset; @@ -697,7 +830,7 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence) switch (whence) { case SEEK_CUR: /* The writer will add padding */ - pos->mmap_offset += WRITE_PACKET_LEN / CHAR_BIT; + pos->mmap_offset += pos->packet_size / CHAR_BIT; break; case SEEK_SET: assert(index == 0); /* only seek supported for now */ @@ -722,6 +855,9 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence) if (pos->offset == EOF) { return; } + assert(pos->cur_index < pos->packet_cycles_index->len); + assert(pos->cur_index < pos->packet_real_index->len); + /* For printing discarded event count */ packet_index = &g_array_index(pos->packet_cycles_index, struct packet_index, pos->cur_index); @@ -759,6 +895,10 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence) break; } case SEEK_SET: + if (index >= pos->packet_cycles_index->len) { + pos->offset = EOF; + return; + } packet_index = &g_array_index(pos->packet_cycles_index, struct packet_index, index); pos->last_events_discarded = packet_index->events_discarded; @@ -778,7 +918,7 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence) * case, the collection is not there, so we * cannot print the timestamps. */ - if ((&file_stream->parent)->stream_class->trace->collection) { + if ((&file_stream->parent)->stream_class->trace->parent.collection) { /* * When a stream reaches the end of the * file, we need to show the number of @@ -806,11 +946,17 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence) struct packet_index, pos->cur_index); file_stream->parent.real_timestamp = packet_index->timestamp_begin; - pos->mmap_offset = packet_index->offset; /* Lookup context/packet size in index */ + if (packet_index->data_offset == -1) { + ret = find_data_offset(pos, file_stream, packet_index); + if (ret < 0) { + return; + } + } pos->content_size = packet_index->content_size; pos->packet_size = packet_index->packet_size; + pos->mmap_offset = packet_index->offset; if (packet_index->data_offset < packet_index->content_size) { pos->offset = 0; /* will read headers */ } else if (packet_index->data_offset == packet_index->content_size) { @@ -1037,7 +1183,7 @@ int ctf_open_trace_metadata_stream_read(struct ctf_trace *td, FILE **fp, buflen = strlen(*buf); if (!buflen) { *fp = NULL; - return -ENODATA; + return -ENOENT; } *fp = babeltrace_fmemopen(*buf, buflen, "rb"); if (!*fp) { @@ -1211,6 +1357,8 @@ error: bt_definition_unref(&stream_event->event_fields->p); if (stream_event->event_context) bt_definition_unref(&stream_event->event_context->p); + fprintf(stderr, "[error] Unable to create event definition for event \"%s\".\n", + g_quark_to_string(event->name)); return NULL; } @@ -1271,8 +1419,10 @@ int create_stream_definitions(struct ctf_trace *td, struct ctf_stream_definition if (!event) continue; stream_event = create_event_definitions(td, stream, event); - if (!stream_event) + if (!stream_event) { + ret = -EINVAL; goto error_event; + } g_ptr_array_index(stream->events_by_id, i) = stream_event; } return 0; @@ -1291,9 +1441,36 @@ error: bt_definition_unref(&stream->stream_event_header->p); if (stream->stream_packet_context) bt_definition_unref(&stream->stream_packet_context->p); + fprintf(stderr, "[error] Unable to create stream (%" PRIu64 ") definitions: %s\n", + stream_class->stream_id, strerror(-ret)); return ret; } +static +int stream_assign_class(struct ctf_trace *td, + struct ctf_file_stream *file_stream, + uint64_t stream_id) +{ + struct ctf_stream_declaration *stream; + int ret; + + file_stream->parent.stream_id = stream_id; + if (stream_id >= td->streams->len) { + fprintf(stderr, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id); + return -EINVAL; + } + stream = g_ptr_array_index(td->streams, stream_id); + if (!stream) { + fprintf(stderr, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id); + return -EINVAL; + } + file_stream->parent.stream_class = stream; + ret = create_stream_definitions(td, &file_stream->parent); + if (ret) + return ret; + return 0; +} + static int create_stream_one_packet_index(struct ctf_stream_pos *pos, struct ctf_trace *td, @@ -1301,11 +1478,10 @@ int create_stream_one_packet_index(struct ctf_stream_pos *pos, size_t filesize) { struct packet_index packet_index; - struct ctf_stream_declaration *stream; - int len_index; uint64_t stream_id = 0; + uint64_t packet_map_len = DEFAULT_HEADER_LEN, tmp_map_len; int first_packet = 0; - size_t packet_map_len = DEFAULT_HEADER_LEN, tmp_map_len; + int len_index; int ret; begin: @@ -1354,6 +1530,7 @@ begin: if (ret) { if (ret == -EFAULT) goto retry; + fprintf(stderr, "[error] Unable to read packet header: %s\n", strerror(-ret)); return ret; } len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.trace_packet_header->declaration, g_quark_from_static_string("magic")); @@ -1414,18 +1591,7 @@ begin: return -EINVAL; } if (first_packet) { - file_stream->parent.stream_id = stream_id; - if (stream_id >= td->streams->len) { - fprintf(stderr, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id); - return -EINVAL; - } - stream = g_ptr_array_index(td->streams, stream_id); - if (!stream) { - fprintf(stderr, "[error] Stream %" PRIu64 " is not declared in metadata.\n", stream_id); - return -EINVAL; - } - file_stream->parent.stream_class = stream; - ret = create_stream_definitions(td, &file_stream->parent); + ret = stream_assign_class(td, file_stream, stream_id); if (ret) return ret; } @@ -1436,30 +1602,31 @@ begin: if (ret) { if (ret == -EFAULT) goto retry; + fprintf(stderr, "[error] Unable to read packet context: %s\n", strerror(-ret)); return ret; } - /* read content size from header */ - len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("content_size")); + /* read packet size from header */ + len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("packet_size")); if (len_index >= 0) { struct bt_definition *field; field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index); - packet_index.content_size = bt_get_unsigned_int(field); + packet_index.packet_size = bt_get_unsigned_int(field); } else { /* Use file size for packet size */ - packet_index.content_size = filesize * CHAR_BIT; + packet_index.packet_size = filesize * CHAR_BIT; } - /* read packet size from header */ - len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("packet_size")); + /* read content size from header */ + len_index = bt_struct_declaration_lookup_field_index(file_stream->parent.stream_packet_context->declaration, g_quark_from_static_string("content_size")); if (len_index >= 0) { struct bt_definition *field; field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index); - packet_index.packet_size = bt_get_unsigned_int(field); + packet_index.content_size = bt_get_unsigned_int(field); } else { - /* Use content size if non-zero, else file size */ - packet_index.packet_size = packet_index.content_size ? : filesize * CHAR_BIT; + /* Use packet size if non-zero, else file size */ + packet_index.content_size = packet_index.packet_size ? : filesize * CHAR_BIT; } /* read timestamp begin from header */ @@ -1469,7 +1636,7 @@ begin: field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index); packet_index.timestamp_begin = bt_get_unsigned_int(field); - if (file_stream->parent.stream_class->trace->collection) { + if (file_stream->parent.stream_class->trace->parent.collection) { packet_index.timestamp_begin = ctf_get_real_timestamp( &file_stream->parent, @@ -1484,7 +1651,7 @@ begin: field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index); packet_index.timestamp_end = bt_get_unsigned_int(field); - if (file_stream->parent.stream_class->trace->collection) { + if (file_stream->parent.stream_class->trace->parent.collection) { packet_index.timestamp_end = ctf_get_real_timestamp( &file_stream->parent, @@ -1503,9 +1670,9 @@ begin: } } else { /* Use file size for packet size */ - packet_index.content_size = filesize * CHAR_BIT; - /* Use content size if non-zero, else file size */ - packet_index.packet_size = packet_index.content_size ? : filesize * CHAR_BIT; + packet_index.packet_size = filesize * CHAR_BIT; + /* Use packet size if non-zero, else file size */ + packet_index.content_size = packet_index.packet_size ? : filesize * CHAR_BIT; } /* Validate content size and packet size values */ @@ -1521,6 +1688,16 @@ begin: return -EINVAL; } + if (packet_index.content_size < pos->offset) { + fprintf(stderr, "[error] Invalid CTF stream: content size is smaller than packet headers.\n"); + return -EINVAL; + } + + if ((packet_index.packet_size >> LOG2_CHAR_BIT) == 0) { + fprintf(stderr, "[error] Invalid CTF stream: packet size needs to be at least one byte\n"); + return -EINVAL; + } + /* Save position after header and context */ packet_index.data_offset = pos->offset; @@ -1544,6 +1721,7 @@ retry: tmp_map_len = packet_map_len << 1; if (tmp_map_len >> 1 != packet_map_len) { /* Overflow */ + fprintf(stderr, "[error] Packet mapping length overflow\n"); return -EFAULT; } packet_map_len = tmp_map_len; @@ -1564,6 +1742,30 @@ int create_stream_packet_index(struct ctf_trace *td, if (ret < 0) return ret; + /* Deal with empty files */ + if (!filestats.st_size) { + if (file_stream->parent.trace_packet_header + || file_stream->parent.stream_packet_context) { + /* + * We expect a trace packet header and/or stream packet + * context. Since a trace needs to have at least one + * packet, empty files are therefore not accepted. + */ + fprintf(stderr, "[error] Encountered an empty file, but expecting a trace packet header.\n"); + return -EINVAL; + } else { + /* + * Without trace packet header nor stream packet + * context, a one-packet trace can indeed be empty. This + * is only valid if there is only one stream class: 0. + */ + ret = stream_assign_class(td, file_stream, 0); + if (ret) + return ret; + return 0; + } + } + for (pos->mmap_offset = 0; pos->mmap_offset < filestats.st_size; ) { ret = create_stream_one_packet_index(pos, td, file_stream, filestats.st_size); @@ -1593,6 +1795,94 @@ int create_trace_definitions(struct ctf_trace *td, struct ctf_stream_definition return 0; +error: + fprintf(stderr, "[error] Unable to create trace definitions: %s\n", strerror(-ret)); + return ret; +} + +static +int import_stream_packet_index(struct ctf_trace *td, + struct ctf_file_stream *file_stream) +{ + struct ctf_stream_declaration *stream; + struct ctf_stream_pos *pos; + struct ctf_packet_index ctf_index; + struct ctf_packet_index_file_hdr index_hdr; + struct packet_index index; + int ret = 0; + int first_packet = 1; + size_t len; + + pos = &file_stream->pos; + + len = fread(&index_hdr, sizeof(index_hdr), 1, pos->index_fp); + if (len != 1) { + perror("read index file header"); + goto error; + } + + /* Check the index header */ + if (be32toh(index_hdr.magic) != CTF_INDEX_MAGIC) { + fprintf(stderr, "[error] wrong index magic\n"); + ret = -1; + goto error; + } + if (be32toh(index_hdr.index_major) != CTF_INDEX_MAJOR) { + fprintf(stderr, "[error] Incompatible index file %" PRIu64 + ".%" PRIu64 ", supported %d.%d\n", + be64toh(index_hdr.index_major), + be64toh(index_hdr.index_minor), CTF_INDEX_MAJOR, + CTF_INDEX_MINOR); + ret = -1; + goto error; + } + if (index_hdr.packet_index_len == 0) { + fprintf(stderr, "[error] Packet index length cannot be 0.\n"); + ret = -1; + goto error; + } + + while (fread(&ctf_index, index_hdr.packet_index_len, 1, + pos->index_fp) == 1) { + uint64_t stream_id; + + memset(&index, 0, sizeof(index)); + index.offset = be64toh(ctf_index.offset); + index.packet_size = be64toh(ctf_index.packet_size); + index.content_size = be64toh(ctf_index.content_size); + index.timestamp_begin = be64toh(ctf_index.timestamp_begin); + index.timestamp_end = be64toh(ctf_index.timestamp_end); + index.events_discarded = be64toh(ctf_index.events_discarded); + index.events_discarded_len = 64; + index.data_offset = -1; + stream_id = be64toh(ctf_index.stream_id); + + if (!first_packet) { + /* add index to packet array */ + g_array_append_val(file_stream->pos.packet_cycles_index, index); + continue; + } + + file_stream->parent.stream_id = stream_id; + stream = g_ptr_array_index(td->streams, stream_id); + if (!stream) { + fprintf(stderr, "[error] Stream %" PRIu64 + " is not declared in metadata.\n", + stream_id); + ret = -EINVAL; + goto error; + } + file_stream->parent.stream_class = stream; + ret = create_stream_definitions(td, &file_stream->parent); + if (ret) + goto error; + first_packet = 0; + /* add index to packet array */ + g_array_append_val(file_stream->pos.packet_cycles_index, index); + } + + ret = 0; + error: return ret; } @@ -1609,6 +1899,7 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags, int ret, fd, closeret; struct ctf_file_stream *file_stream; struct stat statbuf; + char *index_name; fd = openat(td->dirfd, path, flags); if (fd < 0) { @@ -1624,13 +1915,18 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags, goto fstat_error; } if (S_ISDIR(statbuf.st_mode)) { - fprintf(stderr, "[warning] Skipping directory '%s' found in trace\n", path); + if (strncmp(path, "index", 5) != 0) { + fprintf(stderr, "[warning] Skipping directory '%s' " + "found in trace\n", path); + } ret = 0; goto fd_is_dir_ok; } file_stream = g_new0(struct ctf_file_stream, 1); file_stream->pos.last_offset = LAST_OFFSET_POISON; + file_stream->pos.fd = -1; + file_stream->pos.index_fp = NULL; strncpy(file_stream->parent.path, path, PATH_MAX); file_stream->parent.path[PATH_MAX - 1] = '\0'; @@ -1643,7 +1939,7 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags, goto error_def; } - ret = ctf_init_pos(&file_stream->pos, fd, flags); + ret = ctf_init_pos(&file_stream->pos, &td->parent, fd, flags); if (ret) goto error_def; ret = create_trace_definitions(td, &file_stream->parent); @@ -1652,18 +1948,66 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags, /* * For now, only a single clock per trace is supported. */ - file_stream->parent.current_clock = td->single_clock; - ret = create_stream_packet_index(td, file_stream); - if (ret) - goto error_index; + file_stream->parent.current_clock = td->parent.single_clock; + + /* + * Allocate the index name for this stream and try to open it. + */ + index_name = malloc((strlen(path) + sizeof(INDEX_PATH)) * sizeof(char)); + if (!index_name) { + fprintf(stderr, "[error] Cannot allocate index filename\n"); + goto error_def; + } + snprintf(index_name, strlen(path) + sizeof(INDEX_PATH), + INDEX_PATH, path); + + if (faccessat(td->dirfd, index_name, O_RDONLY, flags) < 0) { + ret = create_stream_packet_index(td, file_stream); + if (ret) { + fprintf(stderr, "[error] Stream index creation error.\n"); + goto error_index; + } + } else { + ret = openat(td->dirfd, index_name, flags); + if (ret < 0) { + perror("Index file openat()"); + ret = -1; + goto error_free; + } + file_stream->pos.index_fp = fdopen(ret, "r"); + if (!file_stream->pos.index_fp) { + perror("fdopen() error"); + goto error_free; + } + ret = import_stream_packet_index(td, file_stream); + if (ret) { + ret = -1; + goto error_index; + } + ret = fclose(file_stream->pos.index_fp); + if (ret < 0) { + perror("close index"); + goto error_free; + } + } + free(index_name); + /* Add stream file to stream class */ g_ptr_array_add(file_stream->parent.stream_class->streams, &file_stream->parent); return 0; error_index: + if (file_stream->pos.index_fp) { + ret = fclose(file_stream->pos.index_fp); + if (ret < 0) { + perror("close index"); + } + } if (file_stream->parent.trace_packet_header) bt_definition_unref(&file_stream->parent.trace_packet_header->p); +error_free: + free(index_name); error_def: closeret = ctf_fini_pos(&file_stream->pos); if (closeret) { @@ -1690,6 +2034,7 @@ int ctf_open_trace_read(struct ctf_trace *td, struct dirent *dirent; struct dirent *diriter; size_t dirent_len; + char *ext; td->flags = flags; @@ -1708,8 +2053,8 @@ int ctf_open_trace_read(struct ctf_trace *td, ret = -errno; goto error_dirfd; } - strncpy(td->path, path, sizeof(td->path)); - td->path[sizeof(td->path) - 1] = '\0'; + strncpy(td->parent.path, path, sizeof(td->parent.path)); + td->parent.path[sizeof(td->parent.path) - 1] = '\0'; /* * Keep the metadata file separate. @@ -1745,6 +2090,13 @@ int ctf_open_trace_read(struct ctf_trace *td, || !strcmp(diriter->d_name, "..") || !strcmp(diriter->d_name, "metadata")) continue; + + /* Ignore index files : *.idx */ + ext = strrchr(diriter->d_name, '.'); + if (ext && (!strcmp(ext, ".idx"))) { + continue; + } + ret = ctf_open_file_stream_read(td, diriter->d_name, flags, packet_seek); if (ret) { @@ -1836,6 +2188,7 @@ void ctf_init_mmap_pos(struct ctf_stream_pos *pos, pos->flags = MAP_PRIVATE; pos->parent.rw_table = read_dispatch_table; pos->parent.event_cb = ctf_read_event; + pos->priv = mmap_info->priv; } static @@ -1893,7 +2246,7 @@ int ctf_open_mmap_stream_read(struct ctf_trace *td, /* * For now, only a single clock per trace is supported. */ - file_stream->parent.current_clock = td->single_clock; + file_stream->parent.current_clock = td->parent.single_clock; /* Add stream file to stream class */ g_ptr_array_add(file_stream->parent.stream_class->streams, @@ -2090,7 +2443,7 @@ void ctf_set_context(struct bt_trace_descriptor *descriptor, struct ctf_trace *td = container_of(descriptor, struct ctf_trace, parent); - td->ctx = ctx; + td->parent.ctx = ctx; } static @@ -2100,7 +2453,7 @@ void ctf_set_handle(struct bt_trace_descriptor *descriptor, struct ctf_trace *td = container_of(descriptor, struct ctf_trace, parent); - td->handle = handle; + td->parent.handle = handle; } static