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 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 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 void lttng_write_mystruct2(void **to
,
73 struct lttng_mystruct2
*obj
)
77 align
= lttng_get_alignment_mystruct2(obj
);
78 size
= lttng_get_size_mystruct2(obj
);
81 *to
+= ltt_align((size_t)(*to
), align
); /* align output */
83 *len
+= ltt_align((size_t)(*to
+*len
), align
); /* C alignment, ok to do a memcpy of it */
91 #define LTTNG_ARRAY_SIZE_mystruct_myarray 10
92 typedef uint64_t lttng_array_mystruct_myarray
[LTTNG_ARRAY_SIZE_mystruct_myarray
];
94 size_t lttng_get_size_array_mystruct_myarray(
95 lttng_array_mystruct_myarray obj
)
97 size_t size
=0, locsize
;
99 locsize
= sizeof(uint64_t);
100 /* ltt_align == 0 always*/
101 //size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
102 BUG_ON(ltt_align(size
, locsize
) != 0);
103 size
+= LTTNG_ARRAY_SIZE_mystruct_myarray
* locsize
;
105 BUG_ON(size
!= LTTNG_ARRAY_SIZE_mystruct_myarray
* sizeof(uint64_t));
110 size_t lttng_get_alignment_array_mystruct_myarray(
111 lttng_array_mystruct_myarray obj
)
113 size_t align
=0, localign
;
115 localign
= sizeof(uint64_t);
116 align
= max(align
, localign
);
122 void lttng_write_array_mystruct_myarray(void **to
,
125 lttng_array_mystruct_myarray obj
)
129 align
= lttng_get_alignment_array_mystruct_myarray(obj
);
130 size
= lttng_get_size_array_mystruct_myarray(obj
);
133 *to
+= ltt_align((size_t)(*to
), align
); /* align output */
135 *len
+= ltt_align((size_t)(*to
+*len
), align
); /* C alignment, ok to do a memcpy of it */
142 typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence
;
143 struct lttng_sequence_mystruct_mysequence
{
149 size_t lttng_get_size_sequence_mystruct_mysequence(
150 lttng_sequence_mystruct_mysequence
*obj
)
152 size_t size
=0, locsize
;
154 locsize
= sizeof(unsigned int);
155 size
+= ltt_align(size
, locsize
) + locsize
;
157 locsize
= sizeof(double);
158 size
+= ltt_align(size
, locsize
) + (obj
->len
* locsize
);
163 size_t lttng_get_alignment_sequence_mystruct_mysequence(
164 lttng_sequence_mystruct_mysequence
*obj
)
166 size_t align
=0, localign
;
168 localign
= sizeof(unsigned int);
169 align
= max(align
, localign
);
171 localign
= sizeof(double);
172 align
= max(align
, localign
);
178 void lttng_write_sequence_mystruct_mysequence(void **to
,
181 lttng_sequence_mystruct_mysequence
*obj
)
187 /* Flush pending memcpy */
189 memcpy(*to
, *from
, *len
);
194 align
= lttng_get_alignment_sequence_mystruct_mysequence(obj
);
195 //no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
198 *to
+= ltt_align((size_t)(*to
), align
);
201 *to
+= ltt_align((size_t)*to
, sizeof(unsigned int));
203 varlen
+= sizeof(unsigned int);
204 memcpy(*to
, varfrom
, varlen
);
208 *to
+= ltt_align((size_t)*to
, sizeof(double));
209 varfrom
= obj
->array
;
210 varlen
+= obj
->len
* sizeof(double);
211 memcpy(*to
, varfrom
, varlen
);
215 /* Put source *from just after the C sequence */
221 union lttng_mystruct_myunion
{
223 unsigned long myulong
;
227 size_t lttng_get_size_mystruct_myunion(
228 union lttng_mystruct_myunion
*obj
)
230 size_t size
=0, locsize
;
232 locsize
= sizeof(double);
233 size
= max(size
, locsize
);
235 locsize
= sizeof(unsigned long);
236 size
= max(size
, locsize
);
238 BUG_ON(size
!= sizeof(union lttng_mystruct_myunion
));
244 size_t lttng_get_alignment_mystruct_myunion(
245 union lttng_mystruct_myunion
*obj
)
247 size_t align
=0, localign
;
249 localign
= sizeof(double);
250 align
= max(align
, localign
);
252 localign
= sizeof(unsigned long);
253 align
= max(align
, localign
);
259 void lttng_write_mystruct_myunion(void **to
,
262 union lttng_mystruct_myunion
*obj
)
266 align
= lttng_get_alignment_mystruct_myunion(obj
);
267 size
= lttng_get_size_mystruct_myunion(obj
);
270 *to
+= ltt_align((size_t)(*to
), align
); /* align output */
272 *len
+= ltt_align((size_t)(*to
+*len
), align
); /* C alignment, ok to do a memcpy of it */
279 struct lttng_mystruct
{
281 enum lttng_irq_mode mode
;
282 struct lttng_mystruct2 teststr
;
283 lttng_array_mystruct_myarray myarray
;
284 lttng_sequence_mystruct_mysequence mysequence
;
285 union lttng_mystruct_myunion myunion
;
288 size_t lttng_get_size_mystruct(
289 struct lttng_mystruct
*obj
)
291 size_t size
=0, locsize
, localign
;
293 locsize
= sizeof(unsigned int);
294 size
+= ltt_align(size
, locsize
) + locsize
;
296 locsize
= sizeof(enum lttng_irq_mode
);
297 size
+= ltt_align(size
, locsize
) + locsize
;
299 localign
= lttng_get_alignment_mystruct2(&obj
->teststr
);
300 locsize
= lttng_get_size_mystruct2(&obj
->teststr
);
301 size
+= ltt_align(size
, localign
) + locsize
;
303 localign
= lttng_get_alignment_array_mystruct_myarray(obj
->myarray
);
304 locsize
= lttng_get_size_array_mystruct_myarray(obj
->myarray
);
305 size
+= ltt_align(size
, localign
) + locsize
;
307 localign
= lttng_get_alignment_sequence_mystruct_mysequence(&obj
->mysequence
);
308 locsize
= lttng_get_size_sequence_mystruct_mysequence(&obj
->mysequence
);
309 size
+= ltt_align(size
, localign
) + locsize
;
311 localign
= lttng_get_alignment_mystruct_myunion(&obj
->myunion
);
312 locsize
= lttng_get_size_mystruct_myunion(&obj
->myunion
);
313 size
+= ltt_align(size
, localign
) + locsize
;
319 size_t lttng_get_alignment_mystruct(
320 struct lttng_mystruct
*obj
)
322 size_t align
=0, localign
;
324 localign
= sizeof(unsigned int);
325 align
= max(align
, localign
);
327 localign
= sizeof(enum lttng_irq_mode
);
328 align
= max(align
, localign
);
330 localign
= lttng_get_alignment_mystruct2(&obj
->teststr
);
331 align
= max(align
, localign
);
333 localign
= lttng_get_alignment_array_mystruct_myarray(obj
->myarray
);
334 align
= max(align
, localign
);
336 localign
= lttng_get_alignment_sequence_mystruct_mysequence(&obj
->mysequence
);
337 align
= max(align
, localign
);
339 localign
= lttng_get_alignment_mystruct_myunion(&obj
->myunion
);
340 align
= max(align
, localign
);
345 void lttng_write_mystruct(void **to
,
348 struct lttng_mystruct
*obj
)
352 align
= lttng_get_alignment_mystruct(obj
);
353 // no need : contains variable size fields.
354 // locsize = lttng_get_size_mystruct(obj);
357 *to
+= ltt_align((size_t)(*to
), align
); /* align output */
359 *len
+= ltt_align((size_t)(*to
+*len
), align
); /* C alignment, ok to do a memcpy of it */
362 /* Contains variable sized fields : must explode the structure */
364 size
= sizeof(unsigned int);
365 *len
+= ltt_align((size_t)(*to
+*len
), size
) + size
;
367 size
= sizeof(enum lttng_irq_mode
);
368 *len
+= ltt_align((size_t)(*to
+*len
), size
) + size
;
370 lttng_write_mystruct2(to
, from
, len
, &obj
->teststr
);
372 lttng_write_array_mystruct_myarray(to
, from
, len
, obj
->myarray
);
374 /* Variable length field */
375 lttng_write_sequence_mystruct_mysequence(to
, from
, len
, &obj
->mysequence
);
377 lttng_write_mystruct_myunion(to
, from
, len
, &obj
->myunion
);
379 /* Don't forget to flush last write..... */
389 struct lttng_mystruct test
;
390 test
.mysequence
.len
= 20;
391 test
.mysequence
.array
= malloc(20);
393 size_t size
= lttng_get_size_mystruct(&test
);
394 size_t align
= lttng_get_alignment_mystruct(&test
);
396 void *buf
= malloc(align
+ size
);
401 lttng_write_mystruct(&to
, &from
, &len
, &test
);
403 /* Flush pending memcpy */
405 memcpy(to
, from
, len
);
411 free(test
.mysequence
.array
);