7 #define min(a,b) (((a)<(b))?a:b)
8 #define max(a,b) (((a)>(b))?a:b)
9 #define BUG_ON(a) assert(!(a))
11 /* Calculate the offset needed to align the type */
12 static inline unsigned int ltt_align(size_t align_drift
,
15 size_t alignment
= min(sizeof(void*), size_of_type
);
17 return ((alignment
- align_drift
) & (alignment
-1));
23 enum lttng_tasklet_priority
{
33 struct lttng_mystruct2
{
35 enum lttng_irq_mode mode
;
36 //struct lttng_mystruct teststr1;
40 static inline size_t lttng_get_size_mystruct2(
41 struct lttng_mystruct2
* obj
)
43 size_t size
=0, locsize
;
45 locsize
= sizeof(unsigned int);
46 size
+= ltt_align(size
, locsize
) + locsize
;
48 locsize
= sizeof(enum lttng_irq_mode
);
49 size
+= ltt_align(size
, locsize
) + locsize
;
51 BUG_ON(sizeof(struct lttng_mystruct2
) != size
);
53 return sizeof(struct lttng_mystruct2
);
56 static inline size_t lttng_get_alignment_mystruct2(
57 struct lttng_mystruct2
*obj
)
59 size_t align
=0, localign
;
61 localign
= sizeof(unsigned int);
62 align
= max(align
, localign
);
64 localign
= sizeof(enum lttng_irq_mode
);
65 align
= max(align
, localign
);
70 static inline size_t lttng_write_mystruct2(
75 struct lttng_mystruct2
*obj
)
77 size_t align
, size
, varalign
;
79 align
= lttng_get_alignment_mystruct2(obj
);
80 size
= lttng_get_size_mystruct2(obj
);
83 varalign
= ltt_align(*to
, align
); /* align output */
86 varalign
= ltt_align(*to
+*len
, align
); /* C alignment, ok to do a memcpy of it */
97 #define LTTNG_ARRAY_SIZE_mystruct_myarray 10
98 typedef uint64_t lttng_array_mystruct_myarray
[LTTNG_ARRAY_SIZE_mystruct_myarray
];
100 static inline size_t lttng_get_size_array_mystruct_myarray(
101 lttng_array_mystruct_myarray obj
)
103 size_t size
=0, locsize
;
105 locsize
= sizeof(uint64_t);
106 /* ltt_align == 0 always*/
107 //size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
108 BUG_ON(ltt_align(size
, locsize
) != 0);
109 size
+= LTTNG_ARRAY_SIZE_mystruct_myarray
* locsize
;
111 BUG_ON(size
!= LTTNG_ARRAY_SIZE_mystruct_myarray
* sizeof(uint64_t));
116 static inline size_t lttng_get_alignment_array_mystruct_myarray(
117 lttng_array_mystruct_myarray obj
)
119 size_t align
=0, localign
;
121 localign
= sizeof(uint64_t);
122 align
= max(align
, localign
);
128 static inline size_t lttng_write_array_mystruct_myarray(
133 lttng_array_mystruct_myarray obj
)
135 size_t align
, size
, varalign
;
137 align
= lttng_get_alignment_array_mystruct_myarray(obj
);
138 size
= lttng_get_size_array_mystruct_myarray(obj
);
141 varalign
= ltt_align(*to
, align
); /* align output */
144 varalign
= ltt_align(*to
+*len
, align
); /* C alignment, ok to do a memcpy of it */
150 return varalign
+ size
; /* offset in the from */
154 typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence
;
155 struct lttng_sequence_mystruct_mysequence
{
161 static inline size_t lttng_get_size_sequence_mystruct_mysequence(
162 lttng_sequence_mystruct_mysequence
*obj
)
164 size_t size
=0, locsize
;
166 locsize
= sizeof(unsigned int);
167 size
+= ltt_align(size
, locsize
) + locsize
;
169 locsize
= sizeof(double);
170 size
+= ltt_align(size
, locsize
) + (obj
->len
* locsize
);
175 static inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
176 lttng_sequence_mystruct_mysequence
*obj
)
178 size_t align
=0, localign
;
180 localign
= sizeof(unsigned int);
181 align
= max(align
, localign
);
183 localign
= sizeof(double);
184 align
= max(align
, localign
);
190 static inline size_t lttng_write_sequence_mystruct_mysequence(
195 lttng_sequence_mystruct_mysequence
*obj
)
203 /* Flush pending memcpy */
205 memcpy(buf
+*to
, *from
, *len
);
210 align
= lttng_get_alignment_sequence_mystruct_mysequence(obj
);
211 //no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
214 varalign
= ltt_align((size_t)(*to
), align
);
218 varalign
= ltt_align(size
, sizeof(unsigned int));
221 varlen
+= sizeof(unsigned int);
222 memcpy(buf
+*to
+size
, varfrom
, varlen
);
226 varalign
= ltt_align(size
, sizeof(double));
228 varfrom
= obj
->array
;
229 varlen
+= obj
->len
* sizeof(double);
230 memcpy(buf
+*to
+size
, varfrom
, varlen
);
236 /* Put source *from just after the C sequence */
244 union lttng_mystruct_myunion
{
246 unsigned long myulong
;
250 static inline size_t lttng_get_size_mystruct_myunion(
251 union lttng_mystruct_myunion
*obj
)
253 size_t size
=0, locsize
;
255 locsize
= sizeof(double);
256 size
= max(size
, locsize
);
258 locsize
= sizeof(unsigned long);
259 size
= max(size
, locsize
);
261 BUG_ON(size
!= sizeof(union lttng_mystruct_myunion
));
267 static inline size_t lttng_get_alignment_mystruct_myunion(
268 union lttng_mystruct_myunion
*obj
)
270 size_t align
=0, localign
;
272 localign
= sizeof(double);
273 align
= max(align
, localign
);
275 localign
= sizeof(unsigned long);
276 align
= max(align
, localign
);
282 static inline size_t lttng_write_mystruct_myunion(
287 union lttng_mystruct_myunion
*obj
)
289 size_t align
, size
, varalign
;
291 align
= lttng_get_alignment_mystruct_myunion(obj
);
292 size
= lttng_get_size_mystruct_myunion(obj
);
295 varalign
= ltt_align(*to
, align
); /* align output */
298 varalign
= ltt_align(*to
+*len
, align
); /* C alignment, ok to do a memcpy of it */
304 return varalign
+ size
;
308 struct lttng_mystruct
{
310 enum lttng_irq_mode mode
;
311 struct lttng_mystruct2 teststr
;
312 lttng_array_mystruct_myarray myarray
;
313 lttng_sequence_mystruct_mysequence mysequence
;
314 union lttng_mystruct_myunion myunion
;
317 static inline size_t lttng_get_size_mystruct(
318 struct lttng_mystruct
*obj
)
320 size_t size
=0, locsize
, localign
;
322 locsize
= sizeof(unsigned int);
323 size
+= ltt_align(size
, locsize
) + locsize
;
325 locsize
= sizeof(enum lttng_irq_mode
);
326 size
+= ltt_align(size
, locsize
) + locsize
;
328 localign
= lttng_get_alignment_mystruct2(&obj
->teststr
);
329 locsize
= lttng_get_size_mystruct2(&obj
->teststr
);
330 size
+= ltt_align(size
, localign
) + locsize
;
332 localign
= lttng_get_alignment_array_mystruct_myarray(obj
->myarray
);
333 locsize
= lttng_get_size_array_mystruct_myarray(obj
->myarray
);
334 size
+= ltt_align(size
, localign
) + locsize
;
336 localign
= lttng_get_alignment_sequence_mystruct_mysequence(&obj
->mysequence
);
337 locsize
= lttng_get_size_sequence_mystruct_mysequence(&obj
->mysequence
);
338 size
+= ltt_align(size
, localign
) + locsize
;
340 localign
= lttng_get_alignment_mystruct_myunion(&obj
->myunion
);
341 locsize
= lttng_get_size_mystruct_myunion(&obj
->myunion
);
342 size
+= ltt_align(size
, localign
) + locsize
;
348 static inline size_t lttng_get_alignment_mystruct(
349 struct lttng_mystruct
*obj
)
351 size_t align
=0, localign
;
353 localign
= sizeof(unsigned int);
354 align
= max(align
, localign
);
356 localign
= sizeof(enum lttng_irq_mode
);
357 align
= max(align
, localign
);
359 localign
= lttng_get_alignment_mystruct2(&obj
->teststr
);
360 align
= max(align
, localign
);
362 localign
= lttng_get_alignment_array_mystruct_myarray(obj
->myarray
);
363 align
= max(align
, localign
);
365 localign
= lttng_get_alignment_sequence_mystruct_mysequence(&obj
->mysequence
);
366 align
= max(align
, localign
);
368 localign
= lttng_get_alignment_mystruct_myunion(&obj
->myunion
);
369 align
= max(align
, localign
);
374 static inline void lttng_write_mystruct(
379 struct lttng_mystruct
*obj
)
381 size_t align
, size
=0, locsize
;
383 align
= lttng_get_alignment_mystruct(obj
);
384 // no need : contains variable size fields.
385 // locsize = lttng_get_size_mystruct(obj);
388 *to
+= ltt_align(*to
, align
); /* align output */
390 *len
+= ltt_align(*to
+*len
, align
); /* C alignment, ok to do a memcpy of it */
393 /* Contains variable sized fields : must explode the structure */
395 locsize
= sizeof(unsigned int);
396 locsize
+= ltt_align(size
, locsize
) + locsize
;
400 locsize
= sizeof(enum lttng_irq_mode
);
401 locsize
+= ltt_align(size
, locsize
) + locsize
;
405 size
+= lttng_write_mystruct2(buf
, to
, from
, len
, &obj
->teststr
);
407 size
+= lttng_write_array_mystruct_myarray(buf
, to
, from
, len
, obj
->myarray
);
409 /* Variable length field */
410 size
+= lttng_write_sequence_mystruct_mysequence(buf
, to
, from
, len
, &obj
->mysequence
);
412 size
+= lttng_write_mystruct_myunion(buf
, to
, from
, len
, &obj
->myunion
);
414 /* Don't forget to flush last write..... */
425 struct lttng_mystruct test
;
426 test
.mysequence
.len
= 20;
427 test
.mysequence
.array
= malloc(20);
429 size_t size
= lttng_get_size_mystruct(&test
);
430 size_t align
= lttng_get_alignment_mystruct(&test
);
432 void *buf
= malloc(align
+ size
);
437 lttng_write_mystruct(buf
, &to
, &from
, &len
, &test
);
439 /* Flush pending memcpy */
441 memcpy(buf
+to
, from
, len
);
447 free(test
.mysequence
.array
);