X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ustd%2Flowlevel.c;h=65657490d6044d13ce3aa31aa1797d7637aab3ef;hb=54b7447337f23516c8249065a459372b4fdd9326;hp=6295a8bc5a4391d6cd7b38b45c07dad66c1950c7;hpb=b73a4c471dc987ea8548632dffb3c7050de77dd0;p=ust.git

diff --git a/ustd/lowlevel.c b/ustd/lowlevel.c
index 6295a8b..6565749 100644
--- a/ustd/lowlevel.c
+++ b/ustd/lowlevel.c
@@ -16,6 +16,7 @@
  */
 
 #include <assert.h>
+#include <byteswap.h>
 
 #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;
@@ -56,7 +91,7 @@ void finish_consuming_dead_subbuffer(struct buffer_info *buf)
 	}
 
 	/* Iterate on subbuffers to recover. */
-	for(i_subbuf=first_subbuf; ; i_subbuf++, i_subbuf %= buf->n_subbufs) {
+	for(i_subbuf = first_subbuf % buf->n_subbufs; ; i_subbuf++, i_subbuf %= buf->n_subbufs) {
 		void *tmp;
 		/* commit_seq is the offset in the buffer of the end of the last sequential commit.
 		 * Bytes beyond this limit cannot be recovered. This is a free-running counter. */
@@ -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,20 +113,21 @@ 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) {
-			/* If it was, we only check the lost_size. This is the lost padding at the end of
- 			 * the subbuffer. */
-			valid_length = (unsigned long)buf->subbuf_size - header->lost_size;
+		    - (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;
 		}
 		else {
-			/* If the subbuffer was not fully written, then we don't check lost_size because
+			/* If the subbuffer was not fully written, then we don't check data_size because
 			 * it hasn't been written yet. Instead we check commit_seq and use it to choose
-			 * a value for lost_size. The viewer will need this value when parsing.
+			 * a value for data_size. The viewer will need this value when parsing.
 			 */
 
 			valid_length = commit_seq & (buf->subbuf_size-1);
-			header->lost_size = buf->subbuf_size-valid_length;
+			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;