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