From 02af3e607f471e9fcfe7ea6902cab56efb4c4516 Mon Sep 17 00:00:00 2001 From: Pierre-Marc Fournier Date: Thu, 11 Feb 2010 19:21:04 -0500 Subject: [PATCH] fix support for trace format 2.5 --- libust/buffers.c | 4 +++- ustd/lowlevel.c | 53 ++++++++++++++++++++++++++++++++++++++++++------ ustd/ustd.c | 25 ++++++++++++++++++----- ustd/ustd.h | 1 + 4 files changed, 71 insertions(+), 12 deletions(-) diff --git a/libust/buffers.c b/libust/buffers.c index 33c9589..a36453d 100644 --- a/libust/buffers.c +++ b/libust/buffers.c @@ -307,7 +307,9 @@ static void ltt_buffer_begin(struct ust_buffer *buf, subbuf_idx * buf->chan->subbuf_size); header->cycle_count_begin = tsc; - header->data_size = 0xFFFFFFFF; /* for debugging */ + header->data_size = 0xFFFFFFFF; /* for recognizing crashed buffers */ + header->sb_size = 0xFFFFFFFF; /* for recognizing crashed buffers */ + /* FIXME: add memory barrier? */ ltt_write_trace_header(channel->trace, header); } diff --git a/ustd/lowlevel.c b/ustd/lowlevel.c index bce1d20..d8d4cfa 100644 --- a/ustd/lowlevel.c +++ b/ustd/lowlevel.c @@ -16,6 +16,7 @@ */ #include +#include #include "buffers.h" #include "tracer.h" @@ -26,6 +27,40 @@ #define USTD_BUFFER_TRUNC(offset, bufinfo) \ ((offset) & (~(((bufinfo)->subbuf_size*(bufinfo)->n_subbufs)-1))) +#define LTT_MAGIC_NUMBER 0x00D6B7ED +#define LTT_REV_MAGIC_NUMBER 0xEDB7D600 + +/* Returns the size of a subbuffer size. This is the size that + * will need to be written to disk. + * + * @subbuffer: pointer to the beginning of the subbuffer (the + * beginning of its header) + */ + +size_t subbuffer_data_size(void *subbuf) +{ + struct ltt_subbuffer_header *header = subbuf; + int reverse; + u32 data_size; + + if(header->magic_number == LTT_MAGIC_NUMBER) { + reverse = 0; + } + else if(header->magic_number == LTT_REV_MAGIC_NUMBER) { + reverse = 1; + } + else { + return -1; + } + + data_size = header->sb_size; + if(reverse) + data_size = bswap_32(data_size); + + return data_size; +} + + void finish_consuming_dead_subbuffer(struct buffer_info *buf) { struct ust_buffer *ustbuf = buf->bufstruct_mem; @@ -68,6 +103,8 @@ void finish_consuming_dead_subbuffer(struct buffer_info *buf) struct ltt_subbuffer_header *header = (struct ltt_subbuffer_header *)((char *)buf->mem+i_subbuf*buf->subbuf_size); + int pad_size; + if((commit_seq & commit_seq_mask) == 0) { /* There is nothing to do. */ /* FIXME: is this needed? */ @@ -76,8 +113,8 @@ void finish_consuming_dead_subbuffer(struct buffer_info *buf) /* Check if subbuf was fully written. This is from Mathieu's algorithm/paper. */ if (((commit_seq - buf->subbuf_size) & commit_seq_mask) - - (USTD_BUFFER_TRUNC(consumed_offset, buf) >> n_subbufs_order) - == 0) { + - (USTD_BUFFER_TRUNC(consumed_offset, buf) >> n_subbufs_order) == 0 + && header->data_size != 0xffffffff && header->sb_size != 0xffffffff) { /* If it was, we only check the data_size. This is the amount of valid data at * the beginning of the subbuffer. */ valid_length = header->data_size; @@ -90,6 +127,7 @@ void finish_consuming_dead_subbuffer(struct buffer_info *buf) valid_length = commit_seq & (buf->subbuf_size-1); header->data_size = valid_length; + header->sb_size = PAGE_ALIGN(valid_length); assert(i_subbuf == (last_subbuf % buf->n_subbufs)); } @@ -97,10 +135,13 @@ void finish_consuming_dead_subbuffer(struct buffer_info *buf) patient_write(buf->file_fd, buf->mem + i_subbuf * buf->subbuf_size, valid_length); /* pad with empty bytes */ - tmp = malloc(buf->subbuf_size-valid_length); - memset(tmp, 0, buf->subbuf_size-valid_length); - patient_write(buf->file_fd, tmp, buf->subbuf_size-valid_length); - free(tmp); + pad_size = PAGE_ALIGN(valid_length)-valid_length; + if(pad_size) { + tmp = malloc(pad_size); + memset(tmp, 0, pad_size); + patient_write(buf->file_fd, tmp, pad_size); + free(tmp); + } if(i_subbuf == last_subbuf % buf->n_subbufs) break; diff --git a/ustd/ustd.c b/ustd/ustd.c index 969c192..21da4eb 100644 --- a/ustd/ustd.c +++ b/ustd/ustd.c @@ -359,6 +359,24 @@ struct buffer_info *connect_buffer(pid_t pid, const char *bufname) return buf; } +int write_current_subbuffer(struct buffer_info *buf) +{ + int result; + + void *subbuf_mem = buf->mem + (buf->consumed_old & (buf->n_subbufs * buf->subbuf_size-1)); + + size_t cur_sb_size = subbuffer_data_size(subbuf_mem); + + result = patient_write(buf->file_fd, subbuf_mem, cur_sb_size); + if(result == -1) { + PERROR("write"); + /* FIXME: maybe drop this trace */ + return 0; + } + + return 0; +} + int consumer_loop(struct buffer_info *buf) { int result; @@ -382,11 +400,8 @@ int consumer_loop(struct buffer_info *buf) } /* write data to file */ - result = patient_write(buf->file_fd, buf->mem + (buf->consumed_old & (buf->n_subbufs * buf->subbuf_size-1)), buf->subbuf_size); - if(result == -1) { - PERROR("write"); - /* FIXME: maybe drop this trace */ - } + write_current_subbuffer(buf); + /* FIXME: handle return value? */ /* put the subbuffer */ /* FIXME: we actually should unput the buffer before consuming... */ diff --git a/ustd/ustd.h b/ustd/ustd.h index 8d5becd..5be186a 100644 --- a/ustd/ustd.h +++ b/ustd/ustd.h @@ -33,5 +33,6 @@ struct buffer_info { }; void finish_consuming_dead_subbuffer(struct buffer_info *buf); +size_t subbuffer_data_size(void *subbuf); #endif /* USTD_H */ -- 2.34.1