3d57eb5b |
1 | #ifndef _LTT_FACILITY_USER_GENERIC_H_ |
2 | #define _LTT_FACILITY_USER_GENERIC_H_ |
3 | |
4 | #include <sys/types.h> |
5 | #include <ltt/ltt-facility-id-user_generic.h> |
38f24d5c |
6 | #include <ltt/ltt-usertrace.h> |
3d57eb5b |
7 | |
895ad115 |
8 | #ifdef __cplusplus |
9 | extern "C" { |
10 | #endif |
11 | |
3d57eb5b |
12 | /* Named types */ |
13 | |
14 | /* Event string structures */ |
15 | static inline void lttng_write_string_user_generic_string_data( |
895ad115 |
16 | char *buffer, |
3d57eb5b |
17 | size_t *to_base, |
18 | size_t *to, |
895ad115 |
19 | const char **from, |
3d57eb5b |
20 | size_t *len, |
21 | const char * obj) |
22 | { |
23 | size_t size; |
24 | size_t align; |
25 | |
26 | /* Flush pending memcpy */ |
27 | if(*len != 0) { |
28 | if(buffer != NULL) |
29 | memcpy(buffer+*to_base+*to, *from, *len); |
30 | } |
31 | *to += *len; |
32 | *len = 0; |
33 | |
34 | align = sizeof(char); |
35 | |
36 | if(*len == 0) { |
37 | *to += ltt_align(*to, align); /* align output */ |
38 | } else { |
39 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
40 | } |
41 | |
42 | /* Contains variable sized fields : must explode the structure */ |
43 | |
44 | size = strlen(obj) + 1; /* Include final NULL char. */ |
45 | if(buffer != NULL) |
46 | memcpy(buffer+*to_base+*to, obj, size); |
47 | *to += size; |
48 | |
49 | /* Realign the *to_base on arch size, set *to to 0 */ |
50 | *to += ltt_align(*to, sizeof(void *)); |
51 | *to_base = *to_base+*to; |
52 | *to = 0; |
53 | |
54 | /* Put source *from just after the C string */ |
55 | *from += size; |
56 | } |
57 | |
58 | |
59 | /* Event string logging function */ |
895ad115 |
60 | static inline int trace_user_generic_string( |
61 | const char * lttng_param_data); |
62 | |
8a9103df |
63 | #ifndef LTT_TRACE_FAST |
3d57eb5b |
64 | static inline int trace_user_generic_string( |
65 | const char * lttng_param_data) |
66 | #ifndef LTT_TRACE |
67 | { |
68 | } |
69 | #else |
70 | { |
e36efdc5 |
71 | int ret = 0; |
895ad115 |
72 | char *buffer = NULL; |
3d57eb5b |
73 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
74 | size_t *to_base = &real_to_base; |
75 | size_t real_to = 0; |
76 | size_t *to = &real_to; |
77 | size_t real_len = 0; |
78 | size_t *len = &real_len; |
79 | size_t reserve_size; |
80 | size_t slot_size; |
895ad115 |
81 | const char *real_from; |
82 | const char **from = &real_from; |
3d57eb5b |
83 | /* For each field, calculate the field size. */ |
84 | /* size = *to_base + *to + *len */ |
85 | /* Assume that the padding for alignment starts at a |
86 | * sizeof(void *) address. */ |
87 | |
895ad115 |
88 | *from = (const char*)lttng_param_data; |
3d57eb5b |
89 | lttng_write_string_user_generic_string_data(buffer, to_base, to, from, len, lttng_param_data); |
90 | |
91 | reserve_size = *to_base + *to + *len; |
92 | { |
93 | char stack_buffer[reserve_size]; |
94 | buffer = stack_buffer; |
95 | |
96 | *to_base = *to = *len = 0; |
97 | |
895ad115 |
98 | *from = (const char*)lttng_param_data; |
3d57eb5b |
99 | lttng_write_string_user_generic_string_data(buffer, to_base, to, from, len, lttng_param_data); |
100 | |
101 | /* Flush pending memcpy */ |
102 | if(*len != 0) { |
103 | memcpy(buffer+*to_base+*to, *from, *len); |
104 | *to += *len; |
105 | *len = 0; |
106 | } |
107 | |
e619eb4e |
108 | ret = ltt_trace_generic(ltt_facility_user_generic_B1865E44, event_user_generic_string, buffer, reserve_size, LTT_BLOCKING); |
3d57eb5b |
109 | } |
110 | |
111 | return ret; |
112 | |
113 | } |
114 | #endif //LTT_TRACE |
8a9103df |
115 | #endif //!LTT_TRACE_FAST |
116 | |
117 | #ifdef LTT_TRACE_FAST |
118 | static inline int trace_user_generic_string( |
119 | const char * lttng_param_data) |
120 | #ifndef LTT_TRACE |
121 | { |
122 | } |
123 | #else |
124 | { |
125 | unsigned int index; |
126 | struct ltt_trace_info *trace = thread_trace_info; |
127 | struct ltt_buf *ltt_buf; |
895ad115 |
128 | char *buffer = NULL; |
8a9103df |
129 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
130 | size_t *to_base = &real_to_base; |
131 | size_t real_to = 0; |
132 | size_t *to = &real_to; |
133 | size_t real_len = 0; |
134 | size_t *len = &real_len; |
135 | size_t reserve_size; |
136 | size_t slot_size; |
895ad115 |
137 | const char *real_from; |
138 | const char **from = &real_from; |
8a9103df |
139 | uint64_t tsc; |
140 | size_t before_hdr_pad, after_hdr_pad, header_size; |
141 | |
ba017bc3 |
142 | if(!trace) { |
143 | ltt_thread_init(); |
144 | trace = thread_trace_info; |
145 | } |
146 | |
8a9103df |
147 | |
148 | /* For each field, calculate the field size. */ |
149 | /* size = *to_base + *to + *len */ |
150 | /* Assume that the padding for alignment starts at a |
151 | * sizeof(void *) address. */ |
152 | |
895ad115 |
153 | *from = (const char*)lttng_param_data; |
8a9103df |
154 | lttng_write_string_user_generic_string_data(buffer, to_base, to, from, len, lttng_param_data); |
155 | |
156 | reserve_size = *to_base + *to + *len; |
157 | trace->nesting++; |
e619eb4e |
158 | index = ltt_get_index_from_facility(ltt_facility_user_generic_B1865E44, |
8a9103df |
159 | event_user_generic_string); |
160 | |
161 | { |
162 | ltt_buf = ltt_get_channel_from_index(trace, index); |
163 | slot_size = 0; |
164 | buffer = ltt_reserve_slot(trace, ltt_buf, |
165 | reserve_size, &slot_size, &tsc, |
166 | &before_hdr_pad, &after_hdr_pad, &header_size); |
167 | if(!buffer) goto end; /* buffer full */ |
168 | |
169 | *to_base = *to = *len = 0; |
170 | |
171 | ltt_write_event_header(trace, ltt_buf, buffer, |
e619eb4e |
172 | ltt_facility_user_generic_B1865E44, event_user_generic_string, |
8a9103df |
173 | reserve_size, before_hdr_pad, tsc); |
174 | *to_base += before_hdr_pad + after_hdr_pad + header_size; |
175 | |
895ad115 |
176 | *from = (const char*)lttng_param_data; |
8a9103df |
177 | lttng_write_string_user_generic_string_data(buffer, to_base, to, from, len, lttng_param_data); |
178 | |
179 | /* Flush pending memcpy */ |
180 | if(*len != 0) { |
181 | memcpy(buffer+*to_base+*to, *from, *len); |
182 | *to += *len; |
183 | *len = 0; |
184 | } |
185 | |
186 | ltt_commit_slot(ltt_buf, buffer, slot_size); |
187 | |
188 | } |
189 | |
190 | end: |
191 | trace->nesting--; |
192 | } |
193 | #endif //LTT_TRACE |
194 | #endif //LTT_TRACE_FAST |
3d57eb5b |
195 | |
196 | /* Event string_pointer structures */ |
197 | static inline void lttng_write_string_user_generic_string_pointer_string( |
895ad115 |
198 | char *buffer, |
3d57eb5b |
199 | size_t *to_base, |
200 | size_t *to, |
895ad115 |
201 | const char **from, |
3d57eb5b |
202 | size_t *len, |
203 | const char * obj) |
204 | { |
205 | size_t size; |
206 | size_t align; |
207 | |
208 | /* Flush pending memcpy */ |
209 | if(*len != 0) { |
210 | if(buffer != NULL) |
211 | memcpy(buffer+*to_base+*to, *from, *len); |
212 | } |
213 | *to += *len; |
214 | *len = 0; |
215 | |
216 | align = sizeof(char); |
217 | |
218 | if(*len == 0) { |
219 | *to += ltt_align(*to, align); /* align output */ |
220 | } else { |
221 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
222 | } |
223 | |
224 | /* Contains variable sized fields : must explode the structure */ |
225 | |
226 | size = strlen(obj) + 1; /* Include final NULL char. */ |
227 | if(buffer != NULL) |
228 | memcpy(buffer+*to_base+*to, obj, size); |
229 | *to += size; |
230 | |
231 | /* Realign the *to_base on arch size, set *to to 0 */ |
232 | *to += ltt_align(*to, sizeof(void *)); |
233 | *to_base = *to_base+*to; |
234 | *to = 0; |
235 | |
236 | /* Put source *from just after the C string */ |
237 | *from += size; |
238 | } |
239 | |
240 | |
241 | /* Event string_pointer logging function */ |
895ad115 |
242 | static inline int trace_user_generic_string_pointer( |
243 | const char * lttng_param_string, |
244 | const void * lttng_param_pointer); |
245 | |
8a9103df |
246 | #ifndef LTT_TRACE_FAST |
3d57eb5b |
247 | static inline int trace_user_generic_string_pointer( |
248 | const char * lttng_param_string, |
249 | const void * lttng_param_pointer) |
250 | #ifndef LTT_TRACE |
251 | { |
252 | } |
253 | #else |
254 | { |
e36efdc5 |
255 | int ret = 0; |
895ad115 |
256 | char *buffer = NULL; |
3d57eb5b |
257 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
258 | size_t *to_base = &real_to_base; |
259 | size_t real_to = 0; |
260 | size_t *to = &real_to; |
261 | size_t real_len = 0; |
262 | size_t *len = &real_len; |
263 | size_t reserve_size; |
264 | size_t slot_size; |
3d57eb5b |
265 | size_t align; |
895ad115 |
266 | const char *real_from; |
267 | const char **from = &real_from; |
3d57eb5b |
268 | /* For each field, calculate the field size. */ |
269 | /* size = *to_base + *to + *len */ |
270 | /* Assume that the padding for alignment starts at a |
271 | * sizeof(void *) address. */ |
272 | |
895ad115 |
273 | *from = (const char*)lttng_param_string; |
3d57eb5b |
274 | lttng_write_string_user_generic_string_pointer_string(buffer, to_base, to, from, len, lttng_param_string); |
275 | |
895ad115 |
276 | *from = (const char*)<tng_param_pointer; |
3d57eb5b |
277 | align = sizeof(const void *); |
278 | |
279 | if(*len == 0) { |
280 | *to += ltt_align(*to, align); /* align output */ |
281 | } else { |
282 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
283 | } |
284 | |
285 | *len += sizeof(const void *); |
286 | |
287 | reserve_size = *to_base + *to + *len; |
288 | { |
289 | char stack_buffer[reserve_size]; |
290 | buffer = stack_buffer; |
291 | |
292 | *to_base = *to = *len = 0; |
293 | |
895ad115 |
294 | *from = (const char*)lttng_param_string; |
3d57eb5b |
295 | lttng_write_string_user_generic_string_pointer_string(buffer, to_base, to, from, len, lttng_param_string); |
296 | |
297 | /* Flush pending memcpy */ |
298 | if(*len != 0) { |
299 | memcpy(buffer+*to_base+*to, *from, *len); |
300 | *to += *len; |
301 | *len = 0; |
302 | } |
303 | |
895ad115 |
304 | *from = (const char*)<tng_param_pointer; |
3d57eb5b |
305 | align = sizeof(const void *); |
306 | |
307 | if(*len == 0) { |
308 | *to += ltt_align(*to, align); /* align output */ |
309 | } else { |
310 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
311 | } |
312 | |
313 | *len += sizeof(const void *); |
314 | |
315 | /* Flush pending memcpy */ |
316 | if(*len != 0) { |
317 | memcpy(buffer+*to_base+*to, *from, *len); |
318 | *to += *len; |
319 | *len = 0; |
320 | } |
321 | |
e619eb4e |
322 | ret = ltt_trace_generic(ltt_facility_user_generic_B1865E44, event_user_generic_string_pointer, buffer, reserve_size, LTT_BLOCKING); |
e36efdc5 |
323 | } |
324 | |
325 | return ret; |
326 | |
327 | } |
328 | #endif //LTT_TRACE |
8a9103df |
329 | #endif //!LTT_TRACE_FAST |
330 | |
331 | #ifdef LTT_TRACE_FAST |
332 | static inline int trace_user_generic_string_pointer( |
333 | const char * lttng_param_string, |
334 | const void * lttng_param_pointer) |
335 | #ifndef LTT_TRACE |
336 | { |
337 | } |
338 | #else |
339 | { |
340 | unsigned int index; |
341 | struct ltt_trace_info *trace = thread_trace_info; |
342 | struct ltt_buf *ltt_buf; |
895ad115 |
343 | char *buffer = NULL; |
8a9103df |
344 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
345 | size_t *to_base = &real_to_base; |
346 | size_t real_to = 0; |
347 | size_t *to = &real_to; |
348 | size_t real_len = 0; |
349 | size_t *len = &real_len; |
350 | size_t reserve_size; |
351 | size_t slot_size; |
352 | size_t align; |
895ad115 |
353 | const char *real_from; |
354 | const char **from = &real_from; |
8a9103df |
355 | uint64_t tsc; |
356 | size_t before_hdr_pad, after_hdr_pad, header_size; |
357 | |
ba017bc3 |
358 | if(!trace) { |
359 | ltt_thread_init(); |
360 | trace = thread_trace_info; |
361 | } |
362 | |
8a9103df |
363 | |
364 | /* For each field, calculate the field size. */ |
365 | /* size = *to_base + *to + *len */ |
366 | /* Assume that the padding for alignment starts at a |
367 | * sizeof(void *) address. */ |
368 | |
895ad115 |
369 | *from = (const char*)lttng_param_string; |
8a9103df |
370 | lttng_write_string_user_generic_string_pointer_string(buffer, to_base, to, from, len, lttng_param_string); |
371 | |
895ad115 |
372 | *from = (const char*)<tng_param_pointer; |
8a9103df |
373 | align = sizeof(const void *); |
374 | |
375 | if(*len == 0) { |
376 | *to += ltt_align(*to, align); /* align output */ |
377 | } else { |
378 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
379 | } |
380 | |
381 | *len += sizeof(const void *); |
382 | |
383 | reserve_size = *to_base + *to + *len; |
384 | trace->nesting++; |
e619eb4e |
385 | index = ltt_get_index_from_facility(ltt_facility_user_generic_B1865E44, |
8a9103df |
386 | event_user_generic_string_pointer); |
387 | |
388 | { |
389 | ltt_buf = ltt_get_channel_from_index(trace, index); |
390 | slot_size = 0; |
391 | buffer = ltt_reserve_slot(trace, ltt_buf, |
392 | reserve_size, &slot_size, &tsc, |
393 | &before_hdr_pad, &after_hdr_pad, &header_size); |
394 | if(!buffer) goto end; /* buffer full */ |
395 | |
396 | *to_base = *to = *len = 0; |
397 | |
398 | ltt_write_event_header(trace, ltt_buf, buffer, |
e619eb4e |
399 | ltt_facility_user_generic_B1865E44, event_user_generic_string_pointer, |
8a9103df |
400 | reserve_size, before_hdr_pad, tsc); |
401 | *to_base += before_hdr_pad + after_hdr_pad + header_size; |
402 | |
895ad115 |
403 | *from = (const char*)lttng_param_string; |
8a9103df |
404 | lttng_write_string_user_generic_string_pointer_string(buffer, to_base, to, from, len, lttng_param_string); |
405 | |
406 | /* Flush pending memcpy */ |
407 | if(*len != 0) { |
408 | memcpy(buffer+*to_base+*to, *from, *len); |
409 | *to += *len; |
410 | *len = 0; |
411 | } |
412 | |
895ad115 |
413 | *from = (const char*)<tng_param_pointer; |
8a9103df |
414 | align = sizeof(const void *); |
415 | |
416 | if(*len == 0) { |
417 | *to += ltt_align(*to, align); /* align output */ |
418 | } else { |
419 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
420 | } |
421 | |
422 | *len += sizeof(const void *); |
423 | |
424 | /* Flush pending memcpy */ |
425 | if(*len != 0) { |
426 | memcpy(buffer+*to_base+*to, *from, *len); |
427 | *to += *len; |
428 | *len = 0; |
429 | } |
430 | |
431 | ltt_commit_slot(ltt_buf, buffer, slot_size); |
432 | |
433 | } |
434 | |
435 | end: |
436 | trace->nesting--; |
437 | } |
438 | #endif //LTT_TRACE |
439 | #endif //LTT_TRACE_FAST |
e36efdc5 |
440 | |
441 | /* Event slow_printf structures */ |
442 | static inline void lttng_write_string_user_generic_slow_printf_string( |
895ad115 |
443 | char *buffer, |
e36efdc5 |
444 | size_t *to_base, |
445 | size_t *to, |
895ad115 |
446 | const char **from, |
e36efdc5 |
447 | size_t *len, |
448 | const char * obj) |
449 | { |
450 | size_t size; |
451 | size_t align; |
452 | |
453 | /* Flush pending memcpy */ |
454 | if(*len != 0) { |
455 | if(buffer != NULL) |
456 | memcpy(buffer+*to_base+*to, *from, *len); |
457 | } |
458 | *to += *len; |
459 | *len = 0; |
460 | |
461 | align = sizeof(char); |
462 | |
463 | if(*len == 0) { |
464 | *to += ltt_align(*to, align); /* align output */ |
465 | } else { |
466 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
467 | } |
468 | |
469 | /* Contains variable sized fields : must explode the structure */ |
470 | |
471 | size = strlen(obj) + 1; /* Include final NULL char. */ |
472 | if(buffer != NULL) |
473 | memcpy(buffer+*to_base+*to, obj, size); |
474 | *to += size; |
475 | |
476 | /* Realign the *to_base on arch size, set *to to 0 */ |
477 | *to += ltt_align(*to, sizeof(void *)); |
478 | *to_base = *to_base+*to; |
479 | *to = 0; |
480 | |
481 | /* Put source *from just after the C string */ |
482 | *from += size; |
483 | } |
484 | |
485 | |
486 | /* Event slow_printf logging function */ |
895ad115 |
487 | static inline int trace_user_generic_slow_printf_param_buffer( |
488 | char *buffer, |
489 | size_t reserve_size); |
490 | |
8a9103df |
491 | #ifndef LTT_TRACE_FAST |
e36efdc5 |
492 | static inline int trace_user_generic_slow_printf_param_buffer( |
895ad115 |
493 | char *buffer, |
e36efdc5 |
494 | size_t reserve_size) |
495 | #ifndef LTT_TRACE |
496 | { |
497 | } |
498 | #else |
499 | { |
500 | int ret = 0; |
e36efdc5 |
501 | { |
e619eb4e |
502 | ret = ltt_trace_generic(ltt_facility_user_generic_B1865E44, event_user_generic_slow_printf, buffer, reserve_size, LTT_BLOCKING); |
e90c7b86 |
503 | } |
504 | |
505 | return ret; |
506 | |
507 | } |
508 | #endif //LTT_TRACE |
8a9103df |
509 | #endif //!LTT_TRACE_FAST |
510 | |
511 | #ifdef LTT_TRACE_FAST |
512 | static inline int trace_user_generic_slow_printf( |
513 | const char * lttng_param_string) |
514 | #ifndef LTT_TRACE |
515 | { |
516 | } |
517 | #else |
518 | { |
519 | unsigned int index; |
520 | struct ltt_trace_info *trace = thread_trace_info; |
521 | struct ltt_buf *ltt_buf; |
895ad115 |
522 | char *buffer = NULL; |
8a9103df |
523 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
524 | size_t *to_base = &real_to_base; |
525 | size_t real_to = 0; |
526 | size_t *to = &real_to; |
527 | size_t real_len = 0; |
528 | size_t *len = &real_len; |
529 | size_t reserve_size; |
530 | size_t slot_size; |
895ad115 |
531 | const char *real_from; |
532 | const char **from = &real_from; |
8a9103df |
533 | uint64_t tsc; |
534 | size_t before_hdr_pad, after_hdr_pad, header_size; |
535 | |
ba017bc3 |
536 | if(!trace) { |
537 | ltt_thread_init(); |
538 | trace = thread_trace_info; |
539 | } |
540 | |
8a9103df |
541 | |
542 | /* For each field, calculate the field size. */ |
543 | /* size = *to_base + *to + *len */ |
544 | /* Assume that the padding for alignment starts at a |
545 | * sizeof(void *) address. */ |
546 | |
895ad115 |
547 | *from = (const char*)lttng_param_string; |
8a9103df |
548 | lttng_write_string_user_generic_slow_printf_string(buffer, to_base, to, from, len, lttng_param_string); |
549 | |
550 | reserve_size = *to_base + *to + *len; |
551 | trace->nesting++; |
e619eb4e |
552 | index = ltt_get_index_from_facility(ltt_facility_user_generic_B1865E44, |
8a9103df |
553 | event_user_generic_slow_printf); |
554 | |
555 | { |
556 | ltt_buf = ltt_get_channel_from_index(trace, index); |
557 | slot_size = 0; |
558 | buffer = ltt_reserve_slot(trace, ltt_buf, |
559 | reserve_size, &slot_size, &tsc, |
560 | &before_hdr_pad, &after_hdr_pad, &header_size); |
561 | if(!buffer) goto end; /* buffer full */ |
562 | |
563 | *to_base = *to = *len = 0; |
564 | |
565 | ltt_write_event_header(trace, ltt_buf, buffer, |
e619eb4e |
566 | ltt_facility_user_generic_B1865E44, event_user_generic_slow_printf, |
8a9103df |
567 | reserve_size, before_hdr_pad, tsc); |
568 | *to_base += before_hdr_pad + after_hdr_pad + header_size; |
569 | |
895ad115 |
570 | *from = (const char*)lttng_param_string; |
8a9103df |
571 | lttng_write_string_user_generic_slow_printf_string(buffer, to_base, to, from, len, lttng_param_string); |
572 | |
573 | /* Flush pending memcpy */ |
574 | if(*len != 0) { |
575 | memcpy(buffer+*to_base+*to, *from, *len); |
576 | *to += *len; |
577 | *len = 0; |
578 | } |
579 | |
580 | ltt_commit_slot(ltt_buf, buffer, slot_size); |
581 | |
582 | } |
583 | |
584 | end: |
585 | trace->nesting--; |
586 | } |
587 | #endif //LTT_TRACE |
588 | #endif //LTT_TRACE_FAST |
e90c7b86 |
589 | |
590 | /* Event function_entry structures */ |
591 | |
592 | /* Event function_entry logging function */ |
593 | static inline __attribute__((no_instrument_function)) int trace_user_generic_function_entry( |
895ad115 |
594 | const void * lttng_param_this_fn, |
595 | const void * lttng_param_call_site); |
596 | |
597 | #ifndef LTT_TRACE_FAST |
598 | static inline int trace_user_generic_function_entry( |
e90c7b86 |
599 | const void * lttng_param_this_fn, |
600 | const void * lttng_param_call_site) |
601 | #ifndef LTT_TRACE |
602 | { |
603 | } |
604 | #else |
605 | { |
606 | int ret = 0; |
895ad115 |
607 | char *buffer = NULL; |
e90c7b86 |
608 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
609 | size_t *to_base = &real_to_base; |
610 | size_t real_to = 0; |
611 | size_t *to = &real_to; |
612 | size_t real_len = 0; |
613 | size_t *len = &real_len; |
614 | size_t reserve_size; |
615 | size_t slot_size; |
616 | size_t align; |
895ad115 |
617 | const char *real_from; |
618 | const char **from = &real_from; |
e90c7b86 |
619 | /* For each field, calculate the field size. */ |
620 | /* size = *to_base + *to + *len */ |
621 | /* Assume that the padding for alignment starts at a |
622 | * sizeof(void *) address. */ |
623 | |
895ad115 |
624 | *from = (const char*)<tng_param_this_fn; |
e90c7b86 |
625 | align = sizeof(const void *); |
626 | |
627 | if(*len == 0) { |
628 | *to += ltt_align(*to, align); /* align output */ |
629 | } else { |
630 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
631 | } |
632 | |
633 | *len += sizeof(const void *); |
634 | |
895ad115 |
635 | *from = (const char*)<tng_param_call_site; |
e90c7b86 |
636 | align = sizeof(const void *); |
637 | |
638 | if(*len == 0) { |
639 | *to += ltt_align(*to, align); /* align output */ |
640 | } else { |
641 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
642 | } |
643 | |
644 | *len += sizeof(const void *); |
645 | |
646 | reserve_size = *to_base + *to + *len; |
647 | { |
648 | char stack_buffer[reserve_size]; |
649 | buffer = stack_buffer; |
650 | |
651 | *to_base = *to = *len = 0; |
652 | |
895ad115 |
653 | *from = (const char*)<tng_param_this_fn; |
e90c7b86 |
654 | align = sizeof(const void *); |
655 | |
656 | if(*len == 0) { |
657 | *to += ltt_align(*to, align); /* align output */ |
658 | } else { |
659 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
660 | } |
661 | |
662 | *len += sizeof(const void *); |
663 | |
664 | /* Flush pending memcpy */ |
665 | if(*len != 0) { |
666 | memcpy(buffer+*to_base+*to, *from, *len); |
667 | *to += *len; |
668 | *len = 0; |
669 | } |
670 | |
895ad115 |
671 | *from = (const char*)<tng_param_call_site; |
e90c7b86 |
672 | align = sizeof(const void *); |
673 | |
674 | if(*len == 0) { |
675 | *to += ltt_align(*to, align); /* align output */ |
676 | } else { |
677 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
678 | } |
679 | |
680 | *len += sizeof(const void *); |
681 | |
682 | /* Flush pending memcpy */ |
683 | if(*len != 0) { |
684 | memcpy(buffer+*to_base+*to, *from, *len); |
685 | *to += *len; |
686 | *len = 0; |
687 | } |
688 | |
e619eb4e |
689 | ret = ltt_trace_generic(ltt_facility_user_generic_B1865E44, event_user_generic_function_entry, buffer, reserve_size, LTT_BLOCKING); |
e90c7b86 |
690 | } |
691 | |
692 | return ret; |
693 | |
694 | } |
695 | #endif //LTT_TRACE |
8a9103df |
696 | #endif //!LTT_TRACE_FAST |
697 | |
698 | #ifdef LTT_TRACE_FAST |
699 | static inline __attribute__((no_instrument_function)) int trace_user_generic_function_entry( |
700 | const void * lttng_param_this_fn, |
701 | const void * lttng_param_call_site) |
702 | #ifndef LTT_TRACE |
703 | { |
704 | } |
705 | #else |
706 | { |
707 | unsigned int index; |
708 | struct ltt_trace_info *trace = thread_trace_info; |
709 | struct ltt_buf *ltt_buf; |
895ad115 |
710 | char *buffer = NULL; |
8a9103df |
711 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
712 | size_t *to_base = &real_to_base; |
713 | size_t real_to = 0; |
714 | size_t *to = &real_to; |
715 | size_t real_len = 0; |
716 | size_t *len = &real_len; |
717 | size_t reserve_size; |
718 | size_t slot_size; |
719 | size_t align; |
895ad115 |
720 | const char *real_from; |
721 | const char **from = &real_from; |
8a9103df |
722 | uint64_t tsc; |
723 | size_t before_hdr_pad, after_hdr_pad, header_size; |
724 | |
ba017bc3 |
725 | if(!trace) { |
726 | ltt_thread_init(); |
727 | trace = thread_trace_info; |
728 | } |
729 | |
8a9103df |
730 | |
731 | /* For each field, calculate the field size. */ |
732 | /* size = *to_base + *to + *len */ |
733 | /* Assume that the padding for alignment starts at a |
734 | * sizeof(void *) address. */ |
735 | |
895ad115 |
736 | *from = (const char*)<tng_param_this_fn; |
8a9103df |
737 | align = sizeof(const void *); |
738 | |
739 | if(*len == 0) { |
740 | *to += ltt_align(*to, align); /* align output */ |
741 | } else { |
742 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
743 | } |
744 | |
745 | *len += sizeof(const void *); |
746 | |
895ad115 |
747 | *from = (const char*)<tng_param_call_site; |
8a9103df |
748 | align = sizeof(const void *); |
749 | |
750 | if(*len == 0) { |
751 | *to += ltt_align(*to, align); /* align output */ |
752 | } else { |
753 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
754 | } |
755 | |
756 | *len += sizeof(const void *); |
757 | |
758 | reserve_size = *to_base + *to + *len; |
759 | trace->nesting++; |
e619eb4e |
760 | index = ltt_get_index_from_facility(ltt_facility_user_generic_B1865E44, |
8a9103df |
761 | event_user_generic_function_entry); |
762 | |
763 | { |
764 | ltt_buf = ltt_get_channel_from_index(trace, index); |
765 | slot_size = 0; |
766 | buffer = ltt_reserve_slot(trace, ltt_buf, |
767 | reserve_size, &slot_size, &tsc, |
768 | &before_hdr_pad, &after_hdr_pad, &header_size); |
769 | if(!buffer) goto end; /* buffer full */ |
770 | |
771 | *to_base = *to = *len = 0; |
772 | |
773 | ltt_write_event_header(trace, ltt_buf, buffer, |
e619eb4e |
774 | ltt_facility_user_generic_B1865E44, event_user_generic_function_entry, |
8a9103df |
775 | reserve_size, before_hdr_pad, tsc); |
776 | *to_base += before_hdr_pad + after_hdr_pad + header_size; |
777 | |
895ad115 |
778 | *from = (const char*)<tng_param_this_fn; |
8a9103df |
779 | align = sizeof(const void *); |
780 | |
781 | if(*len == 0) { |
782 | *to += ltt_align(*to, align); /* align output */ |
783 | } else { |
784 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
785 | } |
786 | |
787 | *len += sizeof(const void *); |
788 | |
789 | /* Flush pending memcpy */ |
790 | if(*len != 0) { |
791 | memcpy(buffer+*to_base+*to, *from, *len); |
792 | *to += *len; |
793 | *len = 0; |
794 | } |
795 | |
895ad115 |
796 | *from = (const char*)<tng_param_call_site; |
8a9103df |
797 | align = sizeof(const void *); |
798 | |
799 | if(*len == 0) { |
800 | *to += ltt_align(*to, align); /* align output */ |
801 | } else { |
802 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
803 | } |
804 | |
805 | *len += sizeof(const void *); |
806 | |
807 | /* Flush pending memcpy */ |
808 | if(*len != 0) { |
809 | memcpy(buffer+*to_base+*to, *from, *len); |
810 | *to += *len; |
811 | *len = 0; |
812 | } |
813 | |
814 | ltt_commit_slot(ltt_buf, buffer, slot_size); |
815 | |
816 | } |
817 | |
818 | end: |
819 | trace->nesting--; |
820 | } |
821 | #endif //LTT_TRACE |
822 | #endif //LTT_TRACE_FAST |
e90c7b86 |
823 | |
824 | /* Event function_exit structures */ |
825 | |
826 | /* Event function_exit logging function */ |
827 | static inline __attribute__((no_instrument_function)) int trace_user_generic_function_exit( |
895ad115 |
828 | const void * lttng_param_this_fn, |
829 | const void * lttng_param_call_site); |
830 | |
831 | #ifndef LTT_TRACE_FAST |
832 | static inline int trace_user_generic_function_exit( |
e90c7b86 |
833 | const void * lttng_param_this_fn, |
834 | const void * lttng_param_call_site) |
835 | #ifndef LTT_TRACE |
836 | { |
837 | } |
838 | #else |
839 | { |
840 | int ret = 0; |
895ad115 |
841 | char *buffer = NULL; |
e90c7b86 |
842 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
843 | size_t *to_base = &real_to_base; |
844 | size_t real_to = 0; |
845 | size_t *to = &real_to; |
846 | size_t real_len = 0; |
847 | size_t *len = &real_len; |
848 | size_t reserve_size; |
849 | size_t slot_size; |
850 | size_t align; |
895ad115 |
851 | const char *real_from; |
852 | const char **from = &real_from; |
e90c7b86 |
853 | /* For each field, calculate the field size. */ |
854 | /* size = *to_base + *to + *len */ |
855 | /* Assume that the padding for alignment starts at a |
856 | * sizeof(void *) address. */ |
857 | |
895ad115 |
858 | *from = (const char*)<tng_param_this_fn; |
e90c7b86 |
859 | align = sizeof(const void *); |
860 | |
861 | if(*len == 0) { |
862 | *to += ltt_align(*to, align); /* align output */ |
863 | } else { |
864 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
865 | } |
866 | |
867 | *len += sizeof(const void *); |
868 | |
895ad115 |
869 | *from = (const char*)<tng_param_call_site; |
e90c7b86 |
870 | align = sizeof(const void *); |
871 | |
872 | if(*len == 0) { |
873 | *to += ltt_align(*to, align); /* align output */ |
874 | } else { |
875 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
876 | } |
877 | |
878 | *len += sizeof(const void *); |
879 | |
880 | reserve_size = *to_base + *to + *len; |
881 | { |
882 | char stack_buffer[reserve_size]; |
883 | buffer = stack_buffer; |
884 | |
885 | *to_base = *to = *len = 0; |
886 | |
895ad115 |
887 | *from = (const char*)<tng_param_this_fn; |
e90c7b86 |
888 | align = sizeof(const void *); |
889 | |
890 | if(*len == 0) { |
891 | *to += ltt_align(*to, align); /* align output */ |
892 | } else { |
893 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
894 | } |
895 | |
896 | *len += sizeof(const void *); |
897 | |
898 | /* Flush pending memcpy */ |
899 | if(*len != 0) { |
900 | memcpy(buffer+*to_base+*to, *from, *len); |
901 | *to += *len; |
902 | *len = 0; |
903 | } |
904 | |
895ad115 |
905 | *from = (const char*)<tng_param_call_site; |
e90c7b86 |
906 | align = sizeof(const void *); |
907 | |
908 | if(*len == 0) { |
909 | *to += ltt_align(*to, align); /* align output */ |
910 | } else { |
911 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
912 | } |
913 | |
914 | *len += sizeof(const void *); |
915 | |
916 | /* Flush pending memcpy */ |
917 | if(*len != 0) { |
918 | memcpy(buffer+*to_base+*to, *from, *len); |
919 | *to += *len; |
920 | *len = 0; |
921 | } |
922 | |
e619eb4e |
923 | ret = ltt_trace_generic(ltt_facility_user_generic_B1865E44, event_user_generic_function_exit, buffer, reserve_size, LTT_BLOCKING); |
3d57eb5b |
924 | } |
925 | |
926 | return ret; |
927 | |
928 | } |
929 | #endif //LTT_TRACE |
8a9103df |
930 | #endif //!LTT_TRACE_FAST |
931 | |
932 | #ifdef LTT_TRACE_FAST |
933 | static inline __attribute__((no_instrument_function)) int trace_user_generic_function_exit( |
934 | const void * lttng_param_this_fn, |
935 | const void * lttng_param_call_site) |
936 | #ifndef LTT_TRACE |
937 | { |
938 | } |
939 | #else |
940 | { |
941 | unsigned int index; |
942 | struct ltt_trace_info *trace = thread_trace_info; |
943 | struct ltt_buf *ltt_buf; |
895ad115 |
944 | char *buffer = NULL; |
8a9103df |
945 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
946 | size_t *to_base = &real_to_base; |
947 | size_t real_to = 0; |
948 | size_t *to = &real_to; |
949 | size_t real_len = 0; |
950 | size_t *len = &real_len; |
951 | size_t reserve_size; |
952 | size_t slot_size; |
953 | size_t align; |
895ad115 |
954 | const char *real_from; |
955 | const char **from = &real_from; |
8a9103df |
956 | uint64_t tsc; |
957 | size_t before_hdr_pad, after_hdr_pad, header_size; |
958 | |
ba017bc3 |
959 | if(!trace) { |
960 | ltt_thread_init(); |
961 | trace = thread_trace_info; |
962 | } |
963 | |
8a9103df |
964 | |
965 | /* For each field, calculate the field size. */ |
966 | /* size = *to_base + *to + *len */ |
967 | /* Assume that the padding for alignment starts at a |
968 | * sizeof(void *) address. */ |
969 | |
895ad115 |
970 | *from = (const char*)<tng_param_this_fn; |
8a9103df |
971 | align = sizeof(const void *); |
972 | |
973 | if(*len == 0) { |
974 | *to += ltt_align(*to, align); /* align output */ |
975 | } else { |
976 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
977 | } |
978 | |
979 | *len += sizeof(const void *); |
980 | |
895ad115 |
981 | *from = (const char*)<tng_param_call_site; |
8a9103df |
982 | align = sizeof(const void *); |
983 | |
984 | if(*len == 0) { |
985 | *to += ltt_align(*to, align); /* align output */ |
986 | } else { |
987 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
988 | } |
989 | |
990 | *len += sizeof(const void *); |
991 | |
992 | reserve_size = *to_base + *to + *len; |
993 | trace->nesting++; |
e619eb4e |
994 | index = ltt_get_index_from_facility(ltt_facility_user_generic_B1865E44, |
8a9103df |
995 | event_user_generic_function_exit); |
996 | |
997 | { |
998 | ltt_buf = ltt_get_channel_from_index(trace, index); |
999 | slot_size = 0; |
1000 | buffer = ltt_reserve_slot(trace, ltt_buf, |
1001 | reserve_size, &slot_size, &tsc, |
1002 | &before_hdr_pad, &after_hdr_pad, &header_size); |
1003 | if(!buffer) goto end; /* buffer full */ |
1004 | |
1005 | *to_base = *to = *len = 0; |
1006 | |
1007 | ltt_write_event_header(trace, ltt_buf, buffer, |
e619eb4e |
1008 | ltt_facility_user_generic_B1865E44, event_user_generic_function_exit, |
8a9103df |
1009 | reserve_size, before_hdr_pad, tsc); |
1010 | *to_base += before_hdr_pad + after_hdr_pad + header_size; |
1011 | |
895ad115 |
1012 | *from = (const char*)<tng_param_this_fn; |
8a9103df |
1013 | align = sizeof(const void *); |
1014 | |
1015 | if(*len == 0) { |
1016 | *to += ltt_align(*to, align); /* align output */ |
1017 | } else { |
1018 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
1019 | } |
1020 | |
1021 | *len += sizeof(const void *); |
1022 | |
1023 | /* Flush pending memcpy */ |
1024 | if(*len != 0) { |
1025 | memcpy(buffer+*to_base+*to, *from, *len); |
1026 | *to += *len; |
1027 | *len = 0; |
1028 | } |
1029 | |
895ad115 |
1030 | *from = (const char*)<tng_param_call_site; |
8a9103df |
1031 | align = sizeof(const void *); |
1032 | |
1033 | if(*len == 0) { |
1034 | *to += ltt_align(*to, align); /* align output */ |
1035 | } else { |
1036 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
1037 | } |
1038 | |
1039 | *len += sizeof(const void *); |
1040 | |
1041 | /* Flush pending memcpy */ |
1042 | if(*len != 0) { |
1043 | memcpy(buffer+*to_base+*to, *from, *len); |
1044 | *to += *len; |
1045 | *len = 0; |
1046 | } |
1047 | |
1048 | ltt_commit_slot(ltt_buf, buffer, slot_size); |
1049 | |
1050 | } |
1051 | |
1052 | end: |
1053 | trace->nesting--; |
1054 | } |
1055 | #endif //LTT_TRACE |
1056 | #endif //LTT_TRACE_FAST |
3d57eb5b |
1057 | |
e619eb4e |
1058 | /* Event thread_brand structures */ |
1059 | static inline void lttng_write_string_user_generic_thread_brand_name( |
895ad115 |
1060 | char *buffer, |
e619eb4e |
1061 | size_t *to_base, |
1062 | size_t *to, |
895ad115 |
1063 | const char **from, |
e619eb4e |
1064 | size_t *len, |
1065 | const char * obj) |
1066 | { |
1067 | size_t size; |
1068 | size_t align; |
1069 | |
1070 | /* Flush pending memcpy */ |
1071 | if(*len != 0) { |
1072 | if(buffer != NULL) |
1073 | memcpy(buffer+*to_base+*to, *from, *len); |
1074 | } |
1075 | *to += *len; |
1076 | *len = 0; |
1077 | |
1078 | align = sizeof(char); |
1079 | |
1080 | if(*len == 0) { |
1081 | *to += ltt_align(*to, align); /* align output */ |
1082 | } else { |
1083 | *len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */ |
1084 | } |
1085 | |
1086 | /* Contains variable sized fields : must explode the structure */ |
1087 | |
1088 | size = strlen(obj) + 1; /* Include final NULL char. */ |
1089 | if(buffer != NULL) |
1090 | memcpy(buffer+*to_base+*to, obj, size); |
1091 | *to += size; |
1092 | |
1093 | /* Realign the *to_base on arch size, set *to to 0 */ |
1094 | *to += ltt_align(*to, sizeof(void *)); |
1095 | *to_base = *to_base+*to; |
1096 | *to = 0; |
1097 | |
1098 | /* Put source *from just after the C string */ |
1099 | *from += size; |
1100 | } |
1101 | |
1102 | |
1103 | /* Event thread_brand logging function */ |
895ad115 |
1104 | static inline int trace_user_generic_thread_brand( |
1105 | const char * lttng_param_name); |
1106 | |
e619eb4e |
1107 | #ifndef LTT_TRACE_FAST |
1108 | static inline int trace_user_generic_thread_brand( |
1109 | const char * lttng_param_name) |
1110 | #ifndef LTT_TRACE |
1111 | { |
1112 | } |
1113 | #else |
1114 | { |
1115 | int ret = 0; |
895ad115 |
1116 | char *buffer = NULL; |
e619eb4e |
1117 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
1118 | size_t *to_base = &real_to_base; |
1119 | size_t real_to = 0; |
1120 | size_t *to = &real_to; |
1121 | size_t real_len = 0; |
1122 | size_t *len = &real_len; |
1123 | size_t reserve_size; |
1124 | size_t slot_size; |
895ad115 |
1125 | const char *real_from; |
1126 | const char **from = &real_from; |
e619eb4e |
1127 | /* For each field, calculate the field size. */ |
1128 | /* size = *to_base + *to + *len */ |
1129 | /* Assume that the padding for alignment starts at a |
1130 | * sizeof(void *) address. */ |
1131 | |
895ad115 |
1132 | *from = (const char*)lttng_param_name; |
e619eb4e |
1133 | lttng_write_string_user_generic_thread_brand_name(buffer, to_base, to, from, len, lttng_param_name); |
1134 | |
1135 | reserve_size = *to_base + *to + *len; |
1136 | { |
1137 | char stack_buffer[reserve_size]; |
1138 | buffer = stack_buffer; |
1139 | |
1140 | *to_base = *to = *len = 0; |
1141 | |
895ad115 |
1142 | *from = (const char*)lttng_param_name; |
e619eb4e |
1143 | lttng_write_string_user_generic_thread_brand_name(buffer, to_base, to, from, len, lttng_param_name); |
1144 | |
1145 | /* Flush pending memcpy */ |
1146 | if(*len != 0) { |
1147 | memcpy(buffer+*to_base+*to, *from, *len); |
1148 | *to += *len; |
1149 | *len = 0; |
1150 | } |
1151 | |
1152 | ret = ltt_trace_generic(ltt_facility_user_generic_B1865E44, event_user_generic_thread_brand, buffer, reserve_size, LTT_BLOCKING); |
1153 | } |
1154 | |
1155 | return ret; |
1156 | |
1157 | } |
1158 | #endif //LTT_TRACE |
1159 | #endif //!LTT_TRACE_FAST |
1160 | |
1161 | #ifdef LTT_TRACE_FAST |
1162 | static inline int trace_user_generic_thread_brand( |
1163 | const char * lttng_param_name) |
1164 | #ifndef LTT_TRACE |
1165 | { |
1166 | } |
1167 | #else |
1168 | { |
1169 | unsigned int index; |
1170 | struct ltt_trace_info *trace = thread_trace_info; |
1171 | struct ltt_buf *ltt_buf; |
895ad115 |
1172 | char *buffer = NULL; |
e619eb4e |
1173 | size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */ |
1174 | size_t *to_base = &real_to_base; |
1175 | size_t real_to = 0; |
1176 | size_t *to = &real_to; |
1177 | size_t real_len = 0; |
1178 | size_t *len = &real_len; |
1179 | size_t reserve_size; |
1180 | size_t slot_size; |
895ad115 |
1181 | const char *real_from; |
1182 | const char **from = &real_from; |
e619eb4e |
1183 | uint64_t tsc; |
1184 | size_t before_hdr_pad, after_hdr_pad, header_size; |
1185 | |
1186 | if(!trace) { |
1187 | ltt_thread_init(); |
1188 | trace = thread_trace_info; |
1189 | } |
1190 | |
1191 | |
1192 | /* For each field, calculate the field size. */ |
1193 | /* size = *to_base + *to + *len */ |
1194 | /* Assume that the padding for alignment starts at a |
1195 | * sizeof(void *) address. */ |
1196 | |
895ad115 |
1197 | *from = (const char*)lttng_param_name; |
e619eb4e |
1198 | lttng_write_string_user_generic_thread_brand_name(buffer, to_base, to, from, len, lttng_param_name); |
1199 | |
1200 | reserve_size = *to_base + *to + *len; |
1201 | trace->nesting++; |
1202 | index = ltt_get_index_from_facility(ltt_facility_user_generic_B1865E44, |
1203 | event_user_generic_thread_brand); |
1204 | |
1205 | { |
1206 | ltt_buf = ltt_get_channel_from_index(trace, index); |
1207 | slot_size = 0; |
1208 | buffer = ltt_reserve_slot(trace, ltt_buf, |
1209 | reserve_size, &slot_size, &tsc, |
1210 | &before_hdr_pad, &after_hdr_pad, &header_size); |
1211 | if(!buffer) goto end; /* buffer full */ |
1212 | |
1213 | *to_base = *to = *len = 0; |
1214 | |
1215 | ltt_write_event_header(trace, ltt_buf, buffer, |
1216 | ltt_facility_user_generic_B1865E44, event_user_generic_thread_brand, |
1217 | reserve_size, before_hdr_pad, tsc); |
1218 | *to_base += before_hdr_pad + after_hdr_pad + header_size; |
1219 | |
895ad115 |
1220 | *from = (const char*)lttng_param_name; |
e619eb4e |
1221 | lttng_write_string_user_generic_thread_brand_name(buffer, to_base, to, from, len, lttng_param_name); |
1222 | |
1223 | /* Flush pending memcpy */ |
1224 | if(*len != 0) { |
1225 | memcpy(buffer+*to_base+*to, *from, *len); |
1226 | *to += *len; |
1227 | *len = 0; |
1228 | } |
1229 | |
1230 | ltt_commit_slot(ltt_buf, buffer, slot_size); |
1231 | |
1232 | } |
1233 | |
1234 | end: |
1235 | trace->nesting--; |
1236 | } |
1237 | #endif //LTT_TRACE |
1238 | #endif //LTT_TRACE_FAST |
1239 | |
895ad115 |
1240 | #ifdef __cplusplus |
1241 | } /* end of extern "C" */ |
1242 | #endif |
1243 | |
3d57eb5b |
1244 | #endif //_LTT_FACILITY_USER_GENERIC_H_ |