+#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 inline unsigned int ltt_align(size_t align_drift,
size_t size_of_type)
return align;
}
-static inline size_t lttng_write_mystruct2(
- void *buf,
+static inline void lttng_write_mystruct2(
+ void **to_base,
size_t *to,
void **from,
size_t *len,
struct lttng_mystruct2 *obj)
{
- size_t align, size, varalign;
+ size_t align, size;
align = lttng_get_alignment_mystruct2(obj);
size = lttng_get_size_mystruct2(obj);
if(*len == 0) {
- varalign = ltt_align(*to, align); /* align output */
- *to += varalign;
+ *to += ltt_align(*to, align); /* align output */
} else {
- varalign = ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
- *len += varalign;
+ *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
}
*len += size;
-
- return varalign+size;
}
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);
}
static inline size_t lttng_get_alignment_array_mystruct_myarray(
}
-static inline size_t lttng_write_array_mystruct_myarray(
- void *buf,
+static inline void lttng_write_array_mystruct_myarray(
+ void **to_base,
size_t *to,
void **from,
size_t *len,
lttng_array_mystruct_myarray obj)
{
- size_t align, size, varalign;
+ size_t align, size;
align = lttng_get_alignment_array_mystruct_myarray(obj);
size = lttng_get_size_array_mystruct_myarray(obj);
if(*len == 0) {
- varalign = ltt_align(*to, align); /* align output */
- *to += varalign;
+ *to += ltt_align(*to, align); /* align output */
} else {
- varalign = ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
- *len += varalign;
+ *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
}
*len += size;
-
- return varalign + size; /* offset in the from */
}
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;
}
}
-static inline size_t lttng_write_sequence_mystruct_mysequence(
- void *buf,
+static inline void lttng_write_sequence_mystruct_mysequence(
+ void **to_base,
size_t *to,
void **from,
size_t *len,
lttng_sequence_mystruct_mysequence *obj)
{
size_t align;
- size_t size=0;
void *varfrom;
size_t varlen=0;
- size_t varalign=0;
/* Flush pending memcpy */
if(*len != 0) {
- memcpy(buf+*to, *from, *len);
+ memcpy(*to_base+*to, *from, *len);
*to += *len;
*len = 0;
}
//no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
/* Align output */
- varalign = ltt_align((size_t)(*to), align);
- size += varalign;
+ *to += ltt_align(*to, align); /* *len = 0 in this function */
/* Copy members */
- varalign = ltt_align(size, sizeof(unsigned int));
- size += varalign;
+ *to += ltt_align(*to, sizeof(unsigned int));
varfrom = &obj->len;
varlen += sizeof(unsigned int);
- memcpy(buf+*to+size, varfrom, varlen);
- size += varlen;
+ memcpy(*to_base+*to, varfrom, varlen);
+ *to += varlen;
varlen = 0;
- varalign = ltt_align(size, sizeof(double));
- size += varalign;
+ *to += ltt_align(*to, sizeof(double));
varfrom = obj->array;
varlen += obj->len * sizeof(double);
- memcpy(buf+*to+size, varfrom, varlen);
- size += varlen;
+ memcpy(*to_base+*to, varfrom, varlen);
+ *to += varlen;
varlen = 0;
- *to += size;
+ /* Realign the *to_base on arch size, set *to to 0 */
+ *to = ltt_align(*to, sizeof(void *));
+ *to_base = *to_base+*to;
+ *to = 0;
/* Put source *from just after the C sequence */
*from = obj+1;
-
- return size;
}
BUG_ON(size != sizeof(union lttng_mystruct_myunion));
- return size;
+ return sizeof(union lttng_mystruct_myunion);
}
}
-static inline size_t lttng_write_mystruct_myunion(
- void *buf,
+static inline void lttng_write_mystruct_myunion(
+ void **to_base,
size_t *to,
void **from,
size_t *len,
union lttng_mystruct_myunion *obj)
{
- size_t align, size, varalign;
+ size_t align, size;
align = lttng_get_alignment_mystruct_myunion(obj);
size = lttng_get_size_mystruct_myunion(obj);
if(*len == 0) {
- varalign = ltt_align(*to, align); /* align output */
- *to += varalign;
+ *to += ltt_align(*to, align); /* align output */
} else {
- varalign = ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
- *len += varalign;
+ *len += ltt_align(*to+*len, align); /* C alignment, ok to do a memcpy of it */
}
*len += size;
-
- return varalign + size;
}
}
static inline void lttng_write_mystruct(
- void *buf,
+ void **to_base,
size_t *to,
void **from,
size_t *len,
struct lttng_mystruct *obj)
{
- size_t align, size=0, locsize;
+ size_t align, size;
align = lttng_get_alignment_mystruct(obj);
// no need : contains variable size fields.
/* Contains variable sized fields : must explode the structure */
- locsize = sizeof(unsigned int);
- locsize += ltt_align(size, locsize) + locsize;
- *len += locsize;
- size += locsize;
+ size = sizeof(unsigned int);
+ size += ltt_align(*to+*len, size) + size;
+ *len += size;
- locsize = sizeof(enum lttng_irq_mode);
- locsize += ltt_align(size, locsize) + locsize;
- *len += locsize;
- size += locsize;
+ size = sizeof(enum lttng_irq_mode);
+ size += ltt_align(*to+*len, size) + size;
+ *len += size;
- size += lttng_write_mystruct2(buf, to, from, len, &obj->teststr);
+ lttng_write_mystruct2(to_base, to, from, len, &obj->teststr);
- size += lttng_write_array_mystruct_myarray(buf, to, from, len, obj->myarray);
+ lttng_write_array_mystruct_myarray(to_base, to, from, len, obj->myarray);
/* Variable length field */
- size += lttng_write_sequence_mystruct_mysequence(buf, to, from, len, &obj->mysequence);
-
- size += lttng_write_mystruct_myunion(buf, to, from, len, &obj->myunion);
+ 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_mystruct_myunion(to_base, to, from, len, &obj->myunion);
/* Don't forget to flush last write..... */
}
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 to = 0;
void *from = &test;
size_t len = 0;
- lttng_write_mystruct(buf, &to, &from, &len, &test);
+ lttng_write_mystruct(&to_base, &to, &from, &len, &test);
/* Final flush */
/* Flush pending memcpy */
if(len != 0) {
- memcpy(buf+to, from, len);
+ memcpy(to_base+to, from, len);
to += len;
from += len;
len = 0;
projects / lttv.git / blobdiff