[ltt-dev] [UST PATCH] Code base to fix the print errors in UST (v3)
Yannick Brosseau
yannick.brosseau at gmail.com
Wed Mar 2 12:30:42 EST 2011
From: David Goulet <david.goulet at polymtl.ca>
Update:
v2: Use commit_seq instead of commit_count to fix a consumerd segfault when accessing
commit_count, since it is not mapped.
v3: Remove commented out code
Signed-off-by: Yannick Brosseau <yannick.brosseau at gmail.com>
Signed-off-by: David Goulet <david.goulet at polymtl.ca>
---
include/ust/ustconsumer.h | 4 ++
libust/buffers.c | 80 ---------------------------------------
libustconsumer/libustconsumer.c | 4 ++
libustconsumer/lowlevel.c | 72 ++++++++++++++++++++++++++++++++---
4 files changed, 74 insertions(+), 86 deletions(-)
diff --git a/include/ust/ustconsumer.h b/include/ust/ustconsumer.h
index e07b75e..f99f8f1 100644
--- a/include/ust/ustconsumer.h
+++ b/include/ust/ustconsumer.h
@@ -57,6 +57,10 @@ struct buffer_info {
int n_subbufs;
/* size of each subbuffer */
int subbuf_size;
+ /* subbuf size count order */
+ int subbuf_size_order;
+ /* alloc size of all subbuf */
+ int alloc_size;
/* the buffer information struct */
void *bufstruct_mem;
diff --git a/libust/buffers.c b/libust/buffers.c
index 4011b64..4518842 100644
--- a/libust/buffers.c
+++ b/libust/buffers.c
@@ -254,8 +254,6 @@ unmap_buf:
return -1;
}
-static void ltt_relay_print_buffer_errors(struct ust_channel *chan, int cpu);
-
static void close_buf(struct ust_buffer *buf)
{
struct ust_channel *chan = buf->chan;
@@ -267,8 +265,6 @@ static void close_buf(struct ust_buffer *buf)
PERROR("shmdt");
}
- free(buf->commit_count);
-
result = close(buf->data_ready_fd_read);
if (result < 0) {
PERROR("close");
@@ -278,9 +274,6 @@ static void close_buf(struct ust_buffer *buf)
if (result < 0 && errno != EBADF) {
PERROR("close");
}
-
- /* FIXME: This spews out errors, are they real?:
- * ltt_relay_print_buffer_errors(chan, cpu); */
}
@@ -517,78 +510,6 @@ int ust_buffers_put_subbuf(struct ust_buffer *buf, unsigned long uconsumed_old)
return 0;
}
-static void ltt_relay_print_subbuffer_errors(
- struct ust_channel *channel,
- long cons_off, int cpu)
-{
- struct ust_buffer *ltt_buf = channel->buf[cpu];
- long cons_idx, commit_count, commit_count_sb, write_offset;
-
- cons_idx = SUBBUF_INDEX(cons_off, channel);
- commit_count = uatomic_read(<t_buf->commit_count[cons_idx].cc);
- commit_count_sb = uatomic_read(<t_buf->commit_count[cons_idx].cc_sb);
-
- /*
- * No need to order commit_count and write_offset reads because we
- * execute after trace is stopped when there are no readers left.
- */
- write_offset = uatomic_read(<t_buf->offset);
- WARN( "LTT : unread channel %s offset is %ld "
- "and cons_off : %ld (cpu %d)\n",
- channel->channel_name, write_offset, cons_off, cpu);
- /* Check each sub-buffer for non filled commit count */
- if (((commit_count - channel->subbuf_size) & channel->commit_count_mask)
- - (BUFFER_TRUNC(cons_off, channel) >> channel->n_subbufs_order) != 0) {
- ERR("LTT : %s : subbuffer %lu has non filled "
- "commit count [cc, cc_sb] [%lu,%lu].\n",
- channel->channel_name, cons_idx, commit_count, commit_count_sb);
- }
- ERR("LTT : %s : commit count : %lu, subbuf size %zd\n",
- channel->channel_name, commit_count,
- channel->subbuf_size);
-}
-
-static void ltt_relay_print_errors(struct ust_trace *trace,
- struct ust_channel *channel, int cpu)
-{
- struct ust_buffer *ltt_buf = channel->buf[cpu];
- long cons_off;
-
- /*
- * Can be called in the error path of allocation when
- * trans_channel_data is not yet set.
- */
- if (!channel)
- return;
-
-//ust// for (cons_off = 0; cons_off < rchan->alloc_size;
-//ust// cons_off = SUBBUF_ALIGN(cons_off, rchan))
-//ust// ust_buffers_print_written(ltt_chan, cons_off, cpu);
- for (cons_off = uatomic_read(<t_buf->consumed);
- (SUBBUF_TRUNC(uatomic_read(<t_buf->offset),
- channel)
- - cons_off) > 0;
- cons_off = SUBBUF_ALIGN(cons_off, channel))
- ltt_relay_print_subbuffer_errors(channel, cons_off, cpu);
-}
-
-static void ltt_relay_print_buffer_errors(struct ust_channel *channel, int cpu)
-{
- struct ust_trace *trace = channel->trace;
- struct ust_buffer *ltt_buf = channel->buf[cpu];
-
- if (uatomic_read(<t_buf->events_lost))
- ERR("channel %s: %ld events lost (cpu %d)",
- channel->channel_name,
- uatomic_read(<t_buf->events_lost), cpu);
- if (uatomic_read(<t_buf->corrupted_subbuffers))
- ERR("channel %s : %ld corrupted subbuffers (cpu %d)",
- channel->channel_name,
- uatomic_read(<t_buf->corrupted_subbuffers), cpu);
-
- ltt_relay_print_errors(trace, channel, cpu);
-}
-
static int map_buf_structs(struct ust_channel *chan)
{
void *ptr;
@@ -721,7 +642,6 @@ static void remove_channel(struct ust_channel *chan)
free(chan->buf_struct_shmids);
free(chan->buf);
-
}
static void ltt_relay_async_wakeup_chan(struct ust_channel *ltt_channel)
diff --git a/libustconsumer/libustconsumer.c b/libustconsumer/libustconsumer.c
index c51b106..ef54fe8 100644
--- a/libustconsumer/libustconsumer.c
+++ b/libustconsumer/libustconsumer.c
@@ -353,6 +353,10 @@ struct buffer_info *connect_buffer(struct ustconsumer_instance *instance, pid_t
goto close_fifo;
}
+ /* Set subbuffer's information */
+ buf->subbuf_size_order = get_count_order(buf->subbuf_size);
+ buf->alloc_size = buf->subbuf_size * buf->n_subbufs;
+
/* attach memory */
buf->mem = shmat(buf->shmid, NULL, 0);
if(buf->mem == (void *) 0) {
diff --git a/libustconsumer/lowlevel.c b/libustconsumer/lowlevel.c
index 730dd11..c942fd0 100644
--- a/libustconsumer/lowlevel.c
+++ b/libustconsumer/lowlevel.c
@@ -31,6 +31,66 @@
#define LTT_MAGIC_NUMBER 0x00D6B7ED
#define LTT_REV_MAGIC_NUMBER 0xEDB7D600
+
+static void ltt_relay_print_subbuffer_errors(
+ struct buffer_info *buf,
+ long cons_off, int cpu)
+{
+ struct ust_buffer *ust_buf = buf->bufstruct_mem;
+ long cons_idx, commit_count, commit_count_mask, write_offset;
+
+ cons_idx = SUBBUF_INDEX(cons_off, buf);
+ commit_count = uatomic_read(&ust_buf->commit_seq[cons_idx]);
+ commit_count_mask = (~0UL >> get_count_order(buf->n_subbufs));
+
+ /*
+ * No need to order commit_count and write_offset reads because we
+ * execute after trace is stopped when there are no readers left.
+ */
+ write_offset = uatomic_read(&ust_buf->offset);
+ WARN( "LTT : unread channel %s offset is %ld "
+ "and cons_off : %ld (cpu %d)\n",
+ buf->channel, write_offset, cons_off, cpu);
+ /* Check each sub-buffer for non filled commit count */
+ if (((commit_count - buf->subbuf_size) & commit_count_mask)
+ - (BUFFER_TRUNC(cons_off, buf) >> get_count_order(buf->n_subbufs)) != 0) {
+ ERR("LTT : %s : subbuffer %lu has non filled "
+ "commit count [seq] [%lu].\n",
+ buf->channel, cons_idx, commit_count);
+ }
+ ERR("LTT : %s : commit count : %lu, subbuf size %d\n",
+ buf->channel, commit_count,
+ buf->subbuf_size);
+}
+
+static void ltt_relay_print_errors(struct buffer_info *buf, int cpu)
+{
+ struct ust_buffer *ust_buf = buf->bufstruct_mem;
+ long cons_off;
+
+ for (cons_off = uatomic_read(&ust_buf->consumed);
+ (SUBBUF_TRUNC(uatomic_read(&ust_buf->offset), buf)
+ - cons_off) > 0;
+ cons_off = SUBBUF_ALIGN(cons_off, buf))
+ ltt_relay_print_subbuffer_errors(buf, cons_off, cpu);
+}
+
+static void ltt_relay_print_buffer_errors(struct buffer_info *buf, int cpu)
+{
+ struct ust_buffer *ust_buf = buf->bufstruct_mem;
+
+ if (uatomic_read(&ust_buf->events_lost))
+ ERR("channel %s: %ld events lost (cpu %d)",
+ buf->channel,
+ uatomic_read(&ust_buf->events_lost), cpu);
+ if (uatomic_read(&ust_buf->corrupted_subbuffers))
+ ERR("channel %s : %ld corrupted subbuffers (cpu %d)",
+ buf->channel,
+ uatomic_read(&ust_buf->corrupted_subbuffers), cpu);
+
+ ltt_relay_print_errors(buf, cpu);
+}
+
/* Returns the size of a subbuffer size. This is the size that
* will need to be written to disk.
*
@@ -103,12 +163,6 @@ void finish_consuming_dead_subbuffer(struct ustconsumer_callbacks *callbacks, st
struct ltt_subbuffer_header *header = (struct ltt_subbuffer_header *)((char *)buf->mem+i_subbuf*buf->subbuf_size);
- if((commit_seq & commit_seq_mask) == 0) {
- /* There is nothing to do. */
- /* FIXME: is this needed? */
- break;
- }
-
/* Check if subbuf was fully written. This is from Mathieu's algorithm/paper. */
/* FIXME: not sure data_size = 0xffffffff when the buffer is not full. It might
* take the value of the header size initially */
@@ -136,9 +190,15 @@ void finish_consuming_dead_subbuffer(struct ustconsumer_callbacks *callbacks, st
/* TODO: check on_read_partial_subbuffer return value */
if(callbacks->on_read_partial_subbuffer)
callbacks->on_read_partial_subbuffer(callbacks, buf, i_subbuf, valid_length);
+
+ /* Manually increment the consumed offset */
+ /* TODO ybrosseau 2011-03-02: Should only be done if the previous read was successful */
+ uatomic_add(&ustbuf->consumed, buf->subbuf_size);
if(i_subbuf == last_subbuf % buf->n_subbufs)
break;
}
+
+ ltt_relay_print_buffer_errors(buf, buf->channel_cpu);
}
--
1.7.2.3
More information about the lttng-dev
mailing list