X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=genevent-new%2Fgentest.c;h=753ac4d7895663e5d0b668ce059fde17e1d9ebbb;hb=ba899d3dc9f7c730c8bf699617d5f7a22d196f37;hp=ae71da7250f04d6b4a971156959051b4ae4ef9da;hpb=1a42a214239da3d0f285e88f04f736d2481d0f48;p=lttv.git

diff --git a/genevent-new/gentest.c b/genevent-new/gentest.c
index ae71da72..753ac4d7 100644
--- a/genevent-new/gentest.c
+++ b/genevent-new/gentest.c
@@ -1,18 +1,23 @@
 
+#define __KERNEL__
+
 #include <assert.h>
 #include <sys/types.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include <linux/compiler.h>
+
 #define min(a,b) (((a)<(b))?a:b)
 #define max(a,b) (((a)>(b))?a:b)
 #define BUG_ON(a) assert(!(a))
 
+// Useful outside __KERNEL__. Not used here because inline is already redefined.
 #define force_inline inline __attribute__((always_inline))
 
 /* Calculate the offset needed to align the type */
-static force_inline unsigned int ltt_align(size_t align_drift,
+static inline unsigned int ltt_align(size_t align_drift,
 																		 size_t size_of_type)
 {
 	size_t alignment = min(sizeof(void*), size_of_type);
@@ -39,8 +44,8 @@ struct lttng_mystruct2 {
 	//struct lttng_mystruct teststr1;
 };
 
-
-static force_inline size_t lttng_get_size_mystruct2(
+#if 0
+static inline size_t lttng_get_size_mystruct2(
 		struct lttng_mystruct2 * obj)
 {
 	size_t size=0, locsize;
@@ -55,8 +60,9 @@ static force_inline size_t lttng_get_size_mystruct2(
 
 	return sizeof(struct lttng_mystruct2);
 }
+#endif //0
 
-static force_inline size_t lttng_get_alignment_mystruct2(
+static inline size_t lttng_get_alignment_mystruct2(
 		struct lttng_mystruct2 *obj)
 {
 	size_t align=0, localign;
@@ -70,8 +76,9 @@ static force_inline size_t lttng_get_alignment_mystruct2(
 	return align;
 }
 
-static force_inline void lttng_write_mystruct2(
-		void **to_base,
+static inline void lttng_write_mystruct2(
+		void *buffer,
+		size_t *to_base,
 		size_t *to,
 		void **from,
 		size_t *len,
@@ -80,7 +87,8 @@ static force_inline void lttng_write_mystruct2(
 	size_t align, size;
 
 	align = lttng_get_alignment_mystruct2(obj);
-	size = lttng_get_size_mystruct2(obj);
+	//size = lttng_get_size_mystruct2(obj);
+	size = sizeof(struct lttng_mystruct2);
 
 	if(*len == 0) {
 		*to += ltt_align(*to, align);	/* align output */
@@ -96,7 +104,8 @@ static force_inline void lttng_write_mystruct2(
 #define LTTNG_ARRAY_SIZE_mystruct_myarray 10
 typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
 
-static force_inline size_t lttng_get_size_array_mystruct_myarray(
+#if 0
+static inline size_t lttng_get_size_array_mystruct_myarray(
 		lttng_array_mystruct_myarray obj)
 {
 	size_t size=0, locsize;
@@ -107,12 +116,13 @@ static force_inline size_t lttng_get_size_array_mystruct_myarray(
 	BUG_ON(ltt_align(size, locsize) != 0);
 	size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
 
-	BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));
+	BUG_ON(sizeof(lttng_array_mystruct_myarray) != size);
 
-	return size;
+	return sizeof(lttng_array_mystruct_myarray);
 }
+#endif //0
 
-static force_inline size_t lttng_get_alignment_array_mystruct_myarray(
+static inline size_t lttng_get_alignment_array_mystruct_myarray(
 		lttng_array_mystruct_myarray obj)
 {
 	size_t align=0, localign;
@@ -124,8 +134,9 @@ static force_inline size_t lttng_get_alignment_array_mystruct_myarray(
 }
 
 
-static force_inline void lttng_write_array_mystruct_myarray(
-		void **to_base,
+static inline void lttng_write_array_mystruct_myarray(
+		void *buffer,
+		size_t *to_base,
 		size_t *to,
 		void **from,
 		size_t *len,
@@ -134,7 +145,8 @@ static force_inline void lttng_write_array_mystruct_myarray(
 	size_t align, size;
 	
 	align = lttng_get_alignment_array_mystruct_myarray(obj);
-	size = lttng_get_size_array_mystruct_myarray(obj);
+	//size = lttng_get_size_array_mystruct_myarray(obj);
+	size = sizeof(lttng_array_mystruct_myarray);
 
 	if(*len == 0) {
 		*to += ltt_align(*to, align);	/* align output */
@@ -143,6 +155,13 @@ static force_inline void lttng_write_array_mystruct_myarray(
 	}
 	
 	*len += size;
+#if 0
+	/* For varlen child : let the child align itself. */
+	for(unsigned int i=0; i<LTTNG_ARRAY_SIZE_mystruct_myarray; i++) {
+		lttng_write_child(buffer, to_base, to, from, len, obj[i]);
+	}
+#endif //0
+
 }
 
 
@@ -152,8 +171,8 @@ struct lttng_sequence_mystruct_mysequence {
 	double *array;
 };
 
-
-static force_inline size_t lttng_get_size_sequence_mystruct_mysequence(
+#if 0
+static inline size_t lttng_get_size_sequence_mystruct_mysequence(
 																 lttng_sequence_mystruct_mysequence *obj)
 {
 	size_t size=0, locsize;
@@ -164,10 +183,15 @@ static force_inline size_t lttng_get_size_sequence_mystruct_mysequence(
 	locsize = sizeof(double);
 	size += ltt_align(size, locsize) + (obj->len * locsize);
 
+	/* Realign on arch size */
+	locsize = sizeof(void *);
+	size += ltt_align(size, locsize);
+
 	return size;
 }
+#endif //0
 
-static force_inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
+static inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
 																 lttng_sequence_mystruct_mysequence *obj)
 {
 	size_t align=0, localign;
@@ -182,23 +206,24 @@ static force_inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
 }
 
 
-static force_inline void lttng_write_sequence_mystruct_mysequence(
-		void **to_base,
+static inline void lttng_write_sequence_mystruct_mysequence(
+		void *buffer,
+		size_t *to_base,
 		size_t *to,
 		void **from,
 		size_t *len,
 		lttng_sequence_mystruct_mysequence *obj)
 {
 	size_t align;
-	void *varfrom;
-	size_t varlen=0;
+	size_t size;
 	
 	/* Flush pending memcpy */
 	if(*len != 0) {
-		memcpy(*to_base+*to, *from, *len);
-		*to += *len;
-		*len = 0;
+		if(buffer != NULL)
+			memcpy(buffer+*to_base+*to, *from, *len);
 	}
+	*to += *len;
+	*len = 0;
 
 	align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
 	//no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
@@ -207,19 +232,25 @@ static force_inline void lttng_write_sequence_mystruct_mysequence(
 	*to += ltt_align(*to, align);	/* *len = 0 in this function */
 	
 	/* Copy members */
-	*to += ltt_align(*to, sizeof(unsigned int));
-	varfrom = &obj->len;
-	varlen += sizeof(unsigned int);
-	memcpy(*to_base+*to, varfrom, varlen);
-	*to += varlen;
-	varlen = 0;
-
-	*to += ltt_align(*to, sizeof(double));
-	varfrom = obj->array;
-	varlen += obj->len * sizeof(double);
-	memcpy(*to_base+*to, varfrom, varlen);
-	*to += varlen;
-	varlen = 0;
+	size = sizeof(unsigned int);
+	*to += ltt_align(*to, size);
+	if(buffer != NULL)
+		memcpy(buffer+*to_base+*to, &obj->len, size);
+	*to += size;
+
+	size =  sizeof(double);
+	*to += ltt_align(*to, size);
+	size = obj->len * sizeof(double);
+	if(buffer != NULL)
+		memcpy(buffer+*to_base+*to, obj->array, size);
+	*to += size;
+#if 0
+	/* If varlen child : let child align itself */
+	for(unsigned int i=0; i<obj->len; i++) {
+		lttng_write_child(buffer, to_base, to, from, len, obj->array[i]);
+	}
+#endif //0
+	
 
 	/* Realign the *to_base on arch size, set *to to 0 */
 	*to = ltt_align(*to, sizeof(void *));
@@ -237,8 +268,8 @@ union lttng_mystruct_myunion {
 	unsigned long myulong;
 };
 
-
-static force_inline size_t lttng_get_size_mystruct_myunion(
+#if 0
+static inline size_t lttng_get_size_mystruct_myunion(
 																 union lttng_mystruct_myunion *obj)
 {
 	size_t size=0, locsize;
@@ -251,11 +282,11 @@ static force_inline size_t lttng_get_size_mystruct_myunion(
 
 	BUG_ON(size != sizeof(union lttng_mystruct_myunion));
 
-	return size;
+	return sizeof(union lttng_mystruct_myunion);
 }
+#endif //0
 
-
-static force_inline size_t lttng_get_alignment_mystruct_myunion(
+static inline size_t lttng_get_alignment_mystruct_myunion(
 																 union lttng_mystruct_myunion *obj)
 {
 	size_t align=0, localign;
@@ -270,8 +301,9 @@ static force_inline size_t lttng_get_alignment_mystruct_myunion(
 }
 
 
-static force_inline void lttng_write_mystruct_myunion(
-		void **to_base,
+static inline void lttng_write_mystruct_myunion(
+		void *buffer,
+		size_t *to_base,
 		size_t *to,
 		void **from,
 		size_t *len,
@@ -280,7 +312,8 @@ static force_inline void lttng_write_mystruct_myunion(
 	size_t align, size;
 	
 	align = lttng_get_alignment_mystruct_myunion(obj);
-	size = lttng_get_size_mystruct_myunion(obj);
+	//size = lttng_get_size_mystruct_myunion(obj);
+	size = sizeof(union lttng_mystruct_myunion);
 
 	if(*len == 0) {
 		*to += ltt_align(*to, align);	/* align output */
@@ -289,6 +322,8 @@ static force_inline void lttng_write_mystruct_myunion(
 	}
 	
 	*len += size;
+
+	/* Assert : no varlen child. */
 }
 
 
@@ -301,7 +336,8 @@ struct lttng_mystruct {
 	union lttng_mystruct_myunion myunion;
 };
 
-static force_inline size_t lttng_get_size_mystruct(
+#if 0
+static inline size_t lttng_get_size_mystruct(
 		struct lttng_mystruct *obj)
 {
 	size_t size=0, locsize, localign;
@@ -330,9 +366,9 @@ static force_inline size_t lttng_get_size_mystruct(
 
 	return size;
 }
+#endif //0
 
-
-static force_inline size_t lttng_get_alignment_mystruct(
+static inline size_t lttng_get_alignment_mystruct(
 		struct lttng_mystruct *obj)
 {
 	size_t align=0, localign;
@@ -358,8 +394,9 @@ static force_inline size_t lttng_get_alignment_mystruct(
 	return align;
 }
 
-static force_inline void lttng_write_mystruct(
-		void **to_base,
+static inline void lttng_write_mystruct(
+		void *buffer,
+		size_t *to_base,
 		size_t *to,
 		void **from,
 		size_t *len,
@@ -387,18 +424,17 @@ static force_inline void lttng_write_mystruct(
 	size += ltt_align(*to+*len, size) + size;
 	*len += size;
 
-	lttng_write_mystruct2(to_base, to, from, len, &obj->teststr);
+	lttng_write_mystruct2(buffer, to_base, to, from, len, &obj->teststr);
 
-	lttng_write_array_mystruct_myarray(to_base, to, from, len, obj->myarray);
+	lttng_write_array_mystruct_myarray(buffer, to_base, to, from, len, obj->myarray);
 
 	/* Variable length field */
-	lttng_write_sequence_mystruct_mysequence(to_base, to, from, len, &obj->mysequence);
-	*to = 0;	/* Force the compiler to know it's 0 */
-	/* After this previous write, we are sure that *to is 0, and *to_base is
-	 * aligned on the architecture size : to rest of alignment will be calculated
-	 * statically. */
+	lttng_write_sequence_mystruct_mysequence(buffer, to_base, to, from, len, &obj->mysequence);
+	/* After this previous write, we are sure that *to is 0, *len is 0 and 
+	 * *to_base is aligned on the architecture size : to rest of alignment will
+	 * be calculated statically. */
 
-	lttng_write_mystruct_myunion(to_base, to, from, len, &obj->myunion);
+	lttng_write_mystruct_myunion(buffer, to_base, to, from, len, &obj->myunion);
 
 	/* Don't forget to flush last write..... */
 }
@@ -415,25 +451,35 @@ void test()
 	test.mysequence.len = 20;
 	test.mysequence.array = malloc(20);
 
-	size_t size = lttng_get_size_mystruct(&test);
-	size_t align = lttng_get_alignment_mystruct(&test);
-
-	void *buf = malloc(align + size);
-	void *to_base = buf;	/* the buffer is allocated on arch_size alignment */
+	//size_t size = lttng_get_size_mystruct(&test);
+	//size_t align = lttng_get_alignment_mystruct(&test);
+	//
+	size_t to_base = 0;	/* the buffer is allocated on arch_size alignment */
 	size_t to = 0;
 	void *from = &test;
 	size_t len = 0;
 
-	lttng_write_mystruct(&to_base, &to, &from, &len, &test);
+	/* Get size */
+	lttng_write_mystruct(NULL, &to_base, &to, &from, &len, &test);
+	/* Size = to_base + to + len */
+	
+	void *buffer = malloc(to_base + to + len);
+	to_base = 0;	/* the buffer is allocated on arch_size alignment */
+	to = 0;
+	from = &test;
+	len = 0;
+
+	lttng_write_mystruct(buffer, &to_base, &to, &from, &len, &test);
 	/* Final flush */
 	/* Flush pending memcpy */
 	if(len != 0) {
-		memcpy(to_base+to, from, len);
+		// Assert buffer != NULL */
+		memcpy(buffer+to_base+to, from, len);
 		to += len;
 		from += len;
 		len = 0;
 	}
 	
 	free(test.mysequence.array);
-	free(buf);
+	free(buffer);
 }