X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libustconsumer%2Flowlevel.c;h=fdc4e24291cb66e4726324b4bec32432f2a13f34;hb=cd6b724338f1156ce7281f00a06ea848bec7213c;hp=7eb124b98d75263c6aef91e1b0ee98ac8c928bcc;hpb=9dc7b7ff797a5cbb1e9ffd59e053a04562f306c4;p=ust.git

diff --git a/libustconsumer/lowlevel.c b/libustconsumer/lowlevel.c
index 7eb124b..fdc4e24 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 */
@@ -118,7 +172,7 @@ void finish_consuming_dead_subbuffer(struct ustconsumer_callbacks *callbacks, st
 			/* 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;
-			DBG("writing full subbuffer (%d) with valid_length = %ld", i_subbuf, valid_length);
+			DBG("writing full subbuffer (%ld) with valid_length = %ld", i_subbuf, valid_length);
 		}
 		else {
 			/* If the subbuffer was not fully written, then we don't check data_size because
@@ -127,17 +181,24 @@ void finish_consuming_dead_subbuffer(struct ustconsumer_callbacks *callbacks, st
 			 */
 
 			valid_length = commit_seq & (buf->subbuf_size-1);
-			DBG("writing unfull subbuffer (%d) with valid_length = %ld", i_subbuf, valid_length);
+			DBG("writing unfull subbuffer (%ld) with valid_length = %ld", i_subbuf, valid_length);
 			header->data_size = valid_length;
 			header->sb_size = PAGE_ALIGN(valid_length);
 			assert(i_subbuf == (last_subbuf % buf->n_subbufs));
 		}
 
+		/* 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);
 }