Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
ssize_t len;
char *line = NULL, *nl;
size_t linesize;
ssize_t len;
char *line = NULL, *nl;
size_t linesize;
memset(&pos, 0, sizeof(pos));
memset(&pos, 0, sizeof(pos));
- ctf_init_pos(&pos, output, O_RDWR);
-
+ ret = ctf_init_pos(&pos, output, O_RDWR);
+ if (ret) {
+ fprintf(stderr, "Error in ctf_init_pos\n");
+ return;
+ }
write_packet_header(&pos, s_uuid);
write_packet_context(&pos);
for (;;) {
write_packet_header(&pos, s_uuid);
write_packet_context(&pos);
for (;;) {
trace_string(line, &pos, strlen(line) + 1);
}
}
trace_string(line, &pos, strlen(line) + 1);
}
}
+ ret = ctf_fini_pos(&pos);
+ if (ret) {
+ fprintf(stderr, "Error in ctf_fini_pos\n");
+ }
print_metadata(metadata_fp);
trace_text(stdin, fd);
print_metadata(metadata_fp);
trace_text(stdin, fd);
+ ret = close(fd);
+ if (ret)
+ perror("close");
exit(EXIT_SUCCESS);
/* error handling */
exit(EXIT_SUCCESS);
/* error handling */
-void bt_dummy_close_trace(struct trace_descriptor *td)
+int bt_dummy_close_trace(struct trace_descriptor *td)
{
struct ctf_text_stream_pos *pos =
container_of(td, struct ctf_text_stream_pos,
trace_descriptor);
free(pos);
{
struct ctf_text_stream_pos *pos =
container_of(td, struct ctf_text_stream_pos,
trace_descriptor);
free(pos);
void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence), FILE *metadata_fp);
static
void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence), FILE *metadata_fp);
static
-void ctf_text_close_trace(struct trace_descriptor *descriptor);
+int ctf_text_close_trace(struct trace_descriptor *descriptor);
static
rw_dispatch write_dispatch_table[] = {
static
rw_dispatch write_dispatch_table[] = {
-void ctf_text_close_trace(struct trace_descriptor *td)
+int ctf_text_close_trace(struct trace_descriptor *td)
struct ctf_text_stream_pos *pos =
container_of(td, struct ctf_text_stream_pos, trace_descriptor);
struct ctf_text_stream_pos *pos =
container_of(td, struct ctf_text_stream_pos, trace_descriptor);
+ ret = fclose(pos->fp);
+ if (ret) {
+ perror("Error on fclose");
+ return -1;
+ }
struct bt_trace_handle *handle);
static
struct bt_trace_handle *handle);
static
-void ctf_close_trace(struct trace_descriptor *descriptor);
+int ctf_close_trace(struct trace_descriptor *descriptor);
static
uint64_t ctf_timestamp_begin(struct trace_descriptor *descriptor,
struct bt_trace_handle *handle, enum bt_clock_type type);
static
uint64_t ctf_timestamp_begin(struct trace_descriptor *descriptor,
struct bt_trace_handle *handle, enum bt_clock_type type);
-void ctf_init_pos(struct ctf_stream_pos *pos, int fd, int open_flags)
+int ctf_init_pos(struct ctf_stream_pos *pos, int fd, int open_flags)
{
pos->fd = fd;
if (fd >= 0) {
{
pos->fd = fd;
if (fd >= 0) {
-void ctf_fini_pos(struct ctf_stream_pos *pos)
+int ctf_fini_pos(struct ctf_stream_pos *pos)
if (ret) {
fprintf(stderr, "[error] Unable to unmap old base: %s.\n",
strerror(errno));
if (ret) {
fprintf(stderr, "[error] Unable to unmap old base: %s.\n",
strerror(errno));
}
}
if (pos->packet_cycles_index)
(void) g_array_free(pos->packet_cycles_index, TRUE);
if (pos->packet_real_index)
(void) g_array_free(pos->packet_real_index, TRUE);
}
}
if (pos->packet_cycles_index)
(void) g_array_free(pos->packet_cycles_index, TRUE);
if (pos->packet_real_index)
(void) g_array_free(pos->packet_real_index, TRUE);
/* close to flush the buffer */
ret = babeltrace_close_memstream(buf, &size, out);
if (ret < 0) {
/* close to flush the buffer */
ret = babeltrace_close_memstream(buf, &size, out);
if (ret < 0) {
perror("babeltrace_flush_memstream");
perror("babeltrace_flush_memstream");
- fclose(in);
- return -errno;
+ ret = -errno;
+ closeret = fclose(in);
+ if (closeret) {
+ perror("Error in fclose");
+ }
+ return ret;
+ }
+ ret = fclose(in);
+ if (ret) {
+ perror("Error in fclose");
/* open for reading */
*fp = babeltrace_fmemopen(*buf, strlen(*buf), "rb");
if (!*fp) {
/* open for reading */
*fp = babeltrace_fmemopen(*buf, strlen(*buf), "rb");
if (!*fp) {
struct ctf_file_stream *metadata_stream;
FILE *fp;
char *buf = NULL;
struct ctf_file_stream *metadata_stream;
FILE *fp;
char *buf = NULL;
metadata_stream = g_new0(struct ctf_file_stream, 1);
metadata_stream->pos.last_offset = LAST_OFFSET_POISON;
metadata_stream = g_new0(struct ctf_file_stream, 1);
metadata_stream->pos.last_offset = LAST_OFFSET_POISON;
} else {
fprintf(stderr, "[error] packet_seek function undefined.\n");
ret = -1;
} else {
fprintf(stderr, "[error] packet_seek function undefined.\n");
ret = -1;
metadata_stream->pos.fd = openat(td->dirfd, "metadata", O_RDONLY);
if (metadata_stream->pos.fd < 0) {
fprintf(stderr, "Unable to open metadata.\n");
metadata_stream->pos.fd = openat(td->dirfd, "metadata", O_RDONLY);
if (metadata_stream->pos.fd < 0) {
fprintf(stderr, "Unable to open metadata.\n");
- return metadata_stream->pos.fd;
+ g_free(metadata_stream);
+ ret = -1;
+ goto end_free;
}
fp = fdopen(metadata_stream->pos.fd, "r");
}
fp = fdopen(metadata_stream->pos.fd, "r");
ret = -errno;
goto end_stream;
}
ret = -errno;
goto end_stream;
}
+ /* fd now belongs to fp */
+ metadata_stream->pos.fd = -1;
}
if (babeltrace_debug)
yydebug = 1;
}
if (babeltrace_debug)
yydebug = 1;
ctf_scanner_free(scanner);
end_scanner_alloc:
end_packet_read:
ctf_scanner_free(scanner);
end_scanner_alloc:
end_packet_read:
+ if (fp) {
+ closeret = fclose(fp);
+ if (closeret) {
+ perror("Error on fclose");
+ }
+ }
- if (metadata_stream->pos.fd >= 0)
- close(metadata_stream->pos.fd);
+ if (metadata_stream->pos.fd >= 0) {
+ closeret = close(metadata_stream->pos.fd);
+ if (closeret) {
+ perror("Error on metadata stream fd close");
+ }
+ }
+end_free:
if (ret)
g_free(metadata_stream);
return ret;
if (ret)
g_free(metadata_stream);
return ret;
void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence))
{
void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence))
{
struct ctf_file_stream *file_stream;
struct stat statbuf;
struct ctf_file_stream *file_stream;
struct stat statbuf;
- ctf_init_pos(&file_stream->pos, fd, flags);
+ ret = ctf_init_pos(&file_stream->pos, fd, flags);
+ if (ret)
+ goto error_def;
ret = create_trace_definitions(td, &file_stream->parent);
if (ret)
goto error_def;
ret = create_trace_definitions(td, &file_stream->parent);
if (ret)
goto error_def;
if (file_stream->parent.trace_packet_header)
definition_unref(&file_stream->parent.trace_packet_header->p);
error_def:
if (file_stream->parent.trace_packet_header)
definition_unref(&file_stream->parent.trace_packet_header->p);
error_def:
- ctf_fini_pos(&file_stream->pos);
+ closeret = ctf_fini_pos(&file_stream->pos);
+ if (closeret) {
+ fprintf(stderr, "Error on ctf_fini_pos\n");
+ }
g_free(file_stream);
fd_is_dir_ok:
fstat_error:
g_free(file_stream);
fd_is_dir_ok:
fstat_error:
+ closeret = close(fd);
+ if (closeret) {
+ perror("Error on fd close");
+ }
void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence), FILE *metadata_fp)
{
void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence), FILE *metadata_fp)
{
struct dirent *dirent;
struct dirent *diriter;
size_t dirent_len;
struct dirent *dirent;
struct dirent *diriter;
size_t dirent_len;
readdir_error:
free(dirent);
error_metadata:
readdir_error:
free(dirent);
error_metadata:
+ closeret = close(td->dirfd);
+ if (closeret) {
+ perror("Error on fd close");
+ }
+ closeret = closedir(td->dir);
+ if (closeret) {
+ perror("Error on closedir");
+ }
-void ctf_close_file_stream(struct ctf_file_stream *file_stream)
+int ctf_close_file_stream(struct ctf_file_stream *file_stream)
- ctf_fini_pos(&file_stream->pos);
- close(file_stream->pos.fd);
+ int ret;
+
+ ret = ctf_fini_pos(&file_stream->pos);
+ if (ret) {
+ fprintf(stderr, "Error on ctf_fini_pos\n");
+ return -1;
+ }
+ ret = close(file_stream->pos.fd);
+ if (ret) {
+ perror("Error closing file fd");
+ return -1;
+ }
+ return 0;
-void ctf_close_trace(struct trace_descriptor *tdp)
+int ctf_close_trace(struct trace_descriptor *tdp)
{
struct ctf_trace *td = container_of(tdp, struct ctf_trace, parent);
{
struct ctf_trace *td = container_of(tdp, struct ctf_trace, parent);
if (td->streams) {
for (i = 0; i < td->streams->len; i++) {
if (td->streams) {
for (i = 0; i < td->streams->len; i++) {
struct ctf_file_stream *file_stream;
file_stream = container_of(g_ptr_array_index(stream->streams, j),
struct ctf_file_stream, parent);
struct ctf_file_stream *file_stream;
file_stream = container_of(g_ptr_array_index(stream->streams, j),
struct ctf_file_stream, parent);
- ctf_close_file_stream(file_stream);
+ ret = ctf_close_file_stream(file_stream);
+ if (ret)
+ return ret;
}
}
}
ctf_destroy_metadata(td);
}
}
}
ctf_destroy_metadata(td);
- close(td->dirfd);
- closedir(td->dir);
+ ret = close(td->dirfd);
+ if (ret) {
+ perror("Error closing dirfd");
+ return ret;
+ }
+ ret = closedir(td->dir);
+ if (ret) {
+ perror("Error closedir");
+ return ret;
+ }
void ctf_packet_seek(struct stream_pos *pos, size_t index, int whence);
void ctf_packet_seek(struct stream_pos *pos, size_t index, int whence);
-void ctf_init_pos(struct ctf_stream_pos *pos, int fd, int open_flags);
-void ctf_fini_pos(struct ctf_stream_pos *pos);
+int ctf_init_pos(struct ctf_stream_pos *pos, int fd, int open_flags);
+int ctf_fini_pos(struct ctf_stream_pos *pos);
/*
* move_pos - move position of a relative bit offset
/*
* move_pos - move position of a relative bit offset
void (*packet_seek)(struct stream_pos *pos,
size_t index, int whence),
FILE *metadata_fp);
void (*packet_seek)(struct stream_pos *pos,
size_t index, int whence),
FILE *metadata_fp);
- void (*close_trace)(struct trace_descriptor *descriptor);
+ int (*close_trace)(struct trace_descriptor *descriptor);
void (*set_context)(struct trace_descriptor *descriptor,
struct bt_context *ctx);
void (*set_handle)(struct trace_descriptor *descriptor,
void (*set_context)(struct trace_descriptor *descriptor,
struct bt_context *ctx);
void (*set_handle)(struct trace_descriptor *descriptor,
struct trace_descriptor *td;
struct format *fmt;
struct bt_trace_handle *handle;
struct trace_descriptor *td;
struct format *fmt;
struct bt_trace_handle *handle;
if (!ctx || !format_name || (!path && !stream_list))
return -EINVAL;
if (!ctx || !format_name || (!path && !stream_list))
return -EINVAL;
return handle->id;
error:
return handle->id;
error:
+ closeret = fmt->close_trace(td);
+ if (closeret) {
+ fprintf(stderr, "Error in close_trace callback\n");
+ }
int bt_context_remove_trace(struct bt_context *ctx, int handle_id)
{
struct bt_trace_handle *handle;
int bt_context_remove_trace(struct bt_context *ctx, int handle_id)
{
struct bt_trace_handle *handle;
if (!ctx)
return -EINVAL;
if (!ctx)
return -EINVAL;
/* Remove from containers */
trace_collection_remove(ctx->tc, handle->td);
/* Close the trace */
/* Remove from containers */
trace_collection_remove(ctx->tc, handle->td);
/* Close the trace */
- handle->format->close_trace(handle->td);
-
+ ret = handle->format->close_trace(handle->td);
+ if (ret) {
+ fprintf(stderr, "Error in close_trace callback\n");
+ return ret;
+ }
/* Remove and free the handle */
g_hash_table_remove(ctx->trace_handles,
(gpointer) (unsigned long) handle_id);
/* Remove and free the handle */
g_hash_table_remove(ctx->trace_handles,
(gpointer) (unsigned long) handle_id);