projects / lttng-modules.git / blob
? search:


2ceec317d604edc11c0a12d7b5cd3fd7b110ab86
[lttng-modules.git] / include / lttng / events.h
1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
2 *
3 * lttng/events.h
4 *
5 * Holds LTTng per-session event registry.
6 *
7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 */
9
10 #ifndef _LTTNG_EVENTS_H
11 #define _LTTNG_EVENTS_H
12
13 #include <lttng/kernel-version.h>
14 #include <linux/list.h>
15 #include <linux/kprobes.h>
16 #include <linux/kref.h>
17 #include <linux/uuid.h>
18 #include <linux/irq_work.h>
19 #include <wrapper/uprobes.h>
20 #include <lttng/cpuhotplug.h>
21 #include <lttng/tracer.h>
22 #include <lttng/abi.h>
23 #include <lttng/abi-old.h>
24 #include <lttng/endian.h>
25
26 #define lttng_is_signed_type(type) (((type) -1) < (type) 1)
27
28 struct lttng_channel;
29 struct lttng_session;
30 struct lttng_metadata_cache;
31 struct lib_ring_buffer_ctx;
32 struct perf_event;
33 struct perf_event_attr;
34 struct lib_ring_buffer_config;
35
36 /* Type description */
37
38 enum lttng_kernel_type {
39 lttng_kernel_type_integer,
40 lttng_kernel_type_string,
41 lttng_kernel_type_enum,
42 lttng_kernel_type_array,
43 lttng_kernel_type_sequence,
44 lttng_kernel_type_struct,
45 lttng_kernel_type_variant,
46 NR_LTTNG_KERNEL_TYPES,
47 };
48
49 enum lttng_kernel_string_encoding {
50 lttng_kernel_string_encoding_none = 0,
51 lttng_kernel_string_encoding_UTF8 = 1,
52 lttng_kernel_string_encoding_ASCII = 2,
53 NR_LTTNG_KERNEL_STRING_ENCODING,
54 };
55
56 enum channel_type {
57 PER_CPU_CHANNEL,
58 METADATA_CHANNEL,
59 };
60
61 struct lttng_kernel_enum_value {
62 unsigned long long value;
63 unsigned int signedness:1;
64 };
65
66 struct lttng_kernel_enum_entry {
67 struct lttng_kernel_enum_value start, end; /* start and end are inclusive */
68 const char *string;
69 struct {
70 unsigned int is_auto:1;
71 } options;
72 };
73
74 /*
75 * struct lttng_kernel_type_common is fixed-size. Its children inherits
76 * from it by embedding struct lttng_kernel_type_common as its first field.
77 */
78 struct lttng_kernel_type_common {
79 enum lttng_kernel_type type;
80 };
81
82 struct lttng_kernel_type_integer {
83 struct lttng_kernel_type_common parent;
84 unsigned int size; /* in bits */
85 unsigned short alignment; /* in bits */
86 unsigned int signedness:1,
87 reverse_byte_order:1;
88 unsigned int base; /* 2, 8, 10, 16, for pretty print */
89 };
90
91 struct lttng_kernel_type_string {
92 struct lttng_kernel_type_common parent;
93 enum lttng_kernel_string_encoding encoding;
94 };
95
96 struct lttng_kernel_type_enum {
97 struct lttng_kernel_type_common parent;
98 const struct lttng_kernel_enum_desc *desc; /* Enumeration mapping */
99 const struct lttng_kernel_type_common *container_type;
100 };
101
102 struct lttng_kernel_type_array {
103 struct lttng_kernel_type_common parent;
104 const struct lttng_kernel_type_common *elem_type;
105 unsigned int length; /* Num. elems. */
106 unsigned int alignment;
107 enum lttng_kernel_string_encoding encoding;
108 };
109
110 struct lttng_kernel_type_sequence {
111 struct lttng_kernel_type_common parent;
112 const char *length_name; /* Length field name. */
113 const struct lttng_kernel_type_common *elem_type;
114 unsigned int alignment; /* Alignment before elements. */
115 enum lttng_kernel_string_encoding encoding;
116 };
117
118 struct lttng_kernel_type_struct {
119 struct lttng_kernel_type_common parent;
120 unsigned int nr_fields;
121 const struct lttng_kernel_event_field **fields; /* Array of pointers to fields. */
122 unsigned int alignment;
123 };
124
125 struct lttng_kernel_type_variant {
126 struct lttng_kernel_type_common parent;
127 const char *tag_name;
128 const struct lttng_kernel_event_field **choices; /* Array of pointers to fields. */
129 unsigned int nr_choices;
130 unsigned int alignment;
131 };
132
133 struct lttng_kernel_enum_desc {
134 const char *name;
135 const struct lttng_kernel_enum_entry **entries;
136 unsigned int nr_entries;
137 };
138
139 /* Event field description */
140
141 struct lttng_kernel_event_field {
142 const char *name;
143 const struct lttng_kernel_type_common *type;
144 unsigned int nowrite:1, /* do not write into trace */
145 user:1, /* fetch from user-space */
146 nofilter:1; /* do not consider for filter */
147 };
148
149 #define lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _base) \
150 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_integer, { \
151 .parent = { \
152 .type = lttng_kernel_type_integer, \
153 }, \
154 .size = (_size), \
155 .alignment = (_alignment), \
156 .signedness = (_signedness), \
157 .reverse_byte_order = (_byte_order) != __BYTE_ORDER, \
158 .base = (_base), \
159 }))
160
161 #define lttng_kernel_static_type_integer_from_type(_type, _byte_order, _base) \
162 lttng_kernel_static_type_integer(sizeof(_type) * CHAR_BIT, \
163 lttng_alignof(_type) * CHAR_BIT, \
164 lttng_is_signed_type(_type), \
165 _byte_order, \
166 _base)
167
168 #define lttng_kernel_static_type_enum(_desc, _container_type) \
169 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_enum, { \
170 .parent = { \
171 .type = lttng_kernel_type_enum, \
172 }, \
173 .desc = (_desc), \
174 .container_type = (_container_type), \
175 }))
176
177 #define lttng_kernel_static_type_array(_length, _elem_type, _alignment, _encoding) \
178 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_array, { \
179 .parent = { \
180 .type = lttng_kernel_type_array, \
181 }, \
182 .length = (_length), \
183 .alignment = (_alignment), \
184 .encoding = lttng_kernel_string_encoding_##_encoding, \
185 .elem_type = (_elem_type), \
186 }))
187
188 #define lttng_kernel_static_type_array_text(_length) \
189 lttng_kernel_static_type_array(_length, \
190 lttng_kernel_static_type_integer(sizeof(char) * CHAR_BIT, \
191 lttng_alignof(char) * CHAR_BIT, lttng_is_signed_type(char), \
192 __BYTE_ORDER, 10), \
193 0, UTF8)
194
195 #define lttng_kernel_static_type_sequence(_length_name, _elem_type, _alignment, _encoding) \
196 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_sequence, { \
197 .parent = { \
198 .type = lttng_kernel_type_sequence, \
199 }, \
200 .length_name = (_length_name), \
201 .alignment = (_alignment), \
202 .encoding = lttng_kernel_string_encoding_##_encoding, \
203 .elem_type = (_elem_type), \
204 }))
205
206 #define lttng_kernel_static_type_string(_encoding) \
207 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_string, { \
208 .parent = { \
209 .type = lttng_kernel_type_string, \
210 }, \
211 .encoding = lttng_kernel_string_encoding_##_encoding, \
212 }))
213
214 #define lttng_kernel_static_type_struct(_nr_fields, _fields, _alignment) \
215 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_struct, { \
216 .parent = { \
217 .type = lttng_kernel_type_struct, \
218 }, \
219 .nr_fields = (_nr_fields), \
220 .fields = _fields, \
221 .alignment = (_alignment), \
222 }))
223
224 #define lttng_kernel_static_type_variant(_nr_choices, _choices, _tag_name, _alignment) \
225 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_variant, { \
226 .parent = { \
227 .type = lttng_kernel_type_variant, \
228 }, \
229 .tag_name = (_tag_name), \
230 .choices = _choices, \
231 .nr_choices = (_nr_choices), \
232 .alignment = (_alignment), \
233 }))
234
235 #define lttng_kernel_static_event_field(_name, _type, _nowrite, _user, _nofilter) \
236 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field, { \
237 .name = (_name), \
238 .type = (_type), \
239 .nowrite = (_nowrite), \
240 .user = (_user), \
241 .nofilter = (_nofilter), \
242 })
243
244 #define lttng_kernel_static_event_field_array(_fields...) \
245 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field *, \
246 _fields \
247 )
248
249 #define lttng_kernel_static_ctx_field(_event_field, _get_size, _get_size_arg, _record, _get_value, _destroy, _priv) \
250 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_ctx_field, { \
251 .event_field = (_event_field), \
252 .get_size = (_get_size), \
253 .get_size_arg = (_get_size_arg), \
254 .record = (_record), \
255 .get_value = (_get_value), \
256 .destroy = (_destroy), \
257 .priv = (_priv), \
258 })
259
260 #define lttng_kernel_static_enum_entry_value(_string, _value) \
261 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
262 .start = { \
263 .signedness = lttng_is_signed_type(__typeof__(_value)), \
264 .value = lttng_is_signed_type(__typeof__(_value)) ? \
265 (long long) (_value) : (_value), \
266 }, \
267 .end = { \
268 .signedness = lttng_is_signed_type(__typeof__(_value)), \
269 .value = lttng_is_signed_type(__typeof__(_value)) ? \
270 (long long) (_value) : (_value), \
271 }, \
272 .string = (_string), \
273 }),
274
275 #define lttng_kernel_static_enum_entry_range(_string, _range_start, _range_end) \
276 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
277 .start = { \
278 .signedness = lttng_is_signed_type(__typeof__(_range_start)), \
279 .value = lttng_is_signed_type(__typeof__(_range_start)) ? \
280 (long long) (_range_start) : (_range_start), \
281 }, \
282 .end = { \
283 .signedness = lttng_is_signed_type(__typeof__(_range_end)), \
284 .value = lttng_is_signed_type(__typeof__(_range_end)) ? \
285 (long long) (_range_end) : (_range_end), \
286 }, \
287 .string = (_string), \
288 }),
289
290 #define lttng_kernel_static_enum_entry_auto(_string) \
291 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
292 .start = { \
293 .signedness = -1, \
294 .value = -1, \
295 }, \
296 .end = { \
297 .signedness = -1, \
298 .value = -1, \
299 }, \
300 .string = (_string), \
301 .options = { \
302 .is_auto = 1, \
303 } \
304 }),
305
306 union lttng_ctx_value {
307 int64_t s64;
308 const char *str;
309 double d;
310 };
311
312 /*
313 * We need to keep this perf counter field separately from struct
314 * lttng_kernel_ctx_field because cpu hotplug needs fixed-location addresses.
315 */
316 struct lttng_perf_counter_field {
317 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0))
318 struct lttng_cpuhp_node cpuhp_prepare;
319 struct lttng_cpuhp_node cpuhp_online;
320 #else
321 struct notifier_block nb;
322 int hp_enable;
323 #endif
324 struct perf_event_attr *attr;
325 struct perf_event **e; /* per-cpu array */
326 char *name;
327 struct lttng_kernel_event_field *event_field;
328 };
329
330 struct lttng_probe_ctx {
331 struct lttng_kernel_event_common *event;
332 uint8_t interruptible;
333 };
334
335 struct lttng_kernel_ctx_field {
336 const struct lttng_kernel_event_field *event_field;
337 size_t (*get_size)(size_t offset);
338 size_t (*get_size_arg)(size_t offset, struct lttng_kernel_ctx_field *field,
339 struct lib_ring_buffer_ctx *ctx,
340 struct lttng_channel *chan);
341 void (*record)(struct lttng_kernel_ctx_field *field,
342 struct lib_ring_buffer_ctx *ctx,
343 struct lttng_channel *chan);
344 void (*get_value)(struct lttng_kernel_ctx_field *field,
345 struct lttng_probe_ctx *lttng_probe_ctx,
346 union lttng_ctx_value *value);
347 void (*destroy)(struct lttng_kernel_ctx_field *field);
348 void *priv;
349 };
350
351 struct lttng_kernel_ctx {
352 struct lttng_kernel_ctx_field *fields;
353 unsigned int nr_fields;
354 unsigned int allocated_fields;
355 size_t largest_align; /* in bytes */
356 };
357
358 struct lttng_kernel_event_desc {
359 const char *event_name; /* lttng-modules name */
360 const char *event_kname; /* Linux kernel name (tracepoints) */
361 const struct lttng_kernel_probe_desc *probe_desc;
362 void (*probe_callback)(void);
363 const struct lttng_kernel_event_field **fields; /* event payload */
364 unsigned int nr_fields;
365 struct module *owner;
366 };
367
368 struct lttng_kernel_probe_desc {
369 const char *provider_name;
370 const struct lttng_kernel_event_desc **event_desc;
371 unsigned int nr_events;
372 struct list_head head; /* chain registered probes */
373 struct list_head lazy_init_head;
374 int lazy; /* lazy registration */
375 };
376
377 struct lttng_krp; /* Kretprobe handling */
378
379 enum lttng_bytecode_node_type {
380 LTTNG_BYTECODE_NODE_TYPE_FILTER,
381 LTTNG_BYTECODE_NODE_TYPE_CAPTURE,
382 };
383
384 struct lttng_bytecode_node {
385 enum lttng_bytecode_node_type type;
386 struct list_head node;
387 struct lttng_enabler *enabler;
388 struct {
389 uint32_t len;
390 uint32_t reloc_offset;
391 uint64_t seqnum;
392 char data[];
393 } bc;
394 };
395
396 /*
397 * Bytecode interpreter return value masks.
398 */
399 enum lttng_bytecode_interpreter_ret {
400 LTTNG_INTERPRETER_DISCARD = 0,
401 LTTNG_INTERPRETER_RECORD_FLAG = (1ULL << 0),
402 /* Other bits are kept for future use. */
403 };
404
405 struct lttng_interpreter_output;
406
407 struct lttng_bytecode_runtime {
408 /* Associated bytecode */
409 struct lttng_bytecode_node *bc;
410 union {
411 uint64_t (*filter)(void *filter_data,
412 struct lttng_probe_ctx *lttng_probe_ctx,
413 const char *filter_stack_data);
414 uint64_t (*capture)(void *filter_data,
415 struct lttng_probe_ctx *lttng_probe_ctx,
416 const char *capture_stack_data,
417 struct lttng_interpreter_output *output);
418 } interpreter_funcs;
419 int link_failed;
420 struct list_head node; /* list of bytecode runtime in event */
421 struct lttng_kernel_ctx *ctx;
422 };
423
424 /*
425 * Objects in a linked-list of enablers, owned by an event.
426 */
427 struct lttng_enabler_ref {
428 struct list_head node; /* enabler ref list */
429 struct lttng_enabler *ref; /* backward ref */
430 };
431
432 struct lttng_uprobe_handler {
433 struct lttng_kernel_event_common *event;
434 loff_t offset;
435 struct uprobe_consumer up_consumer;
436 struct list_head node;
437 };
438
439 struct lttng_kprobe {
440 struct kprobe kp;
441 char *symbol_name;
442 };
443
444 struct lttng_uprobe {
445 struct inode *inode;
446 struct list_head head;
447 };
448
449 enum lttng_syscall_entryexit {
450 LTTNG_SYSCALL_ENTRY,
451 LTTNG_SYSCALL_EXIT,
452 };
453
454 enum lttng_syscall_abi {
455 LTTNG_SYSCALL_ABI_NATIVE,
456 LTTNG_SYSCALL_ABI_COMPAT,
457 };
458
459 struct lttng_kernel_event_common_private;
460
461 enum lttng_kernel_event_type {
462 LTTNG_KERNEL_EVENT_TYPE_RECORDER = 0,
463 LTTNG_KERNEL_EVENT_TYPE_NOTIFIER = 1,
464 };
465
466 struct lttng_kernel_event_common {
467 struct lttng_kernel_event_common_private *priv; /* Private event interface */
468
469 enum lttng_kernel_event_type type;
470 /* Get child with container_of(). */
471
472 int enabled;
473 int eval_filter; /* Need to evaluate filters */
474 int (*run_filter)(struct lttng_kernel_event_common *event,
475 const char *stack_data,
476 void *filter_ctx);
477 };
478
479 struct lttng_kernel_event_recorder_private;
480
481 struct lttng_kernel_event_recorder {
482 struct lttng_kernel_event_common parent;
483 struct lttng_kernel_event_recorder_private *priv; /* Private event record interface */
484
485 struct lttng_channel *chan;
486 };
487
488 struct lttng_kernel_notification_ctx {
489 int eval_capture; /* Capture evaluation available. */
490 };
491
492 struct lttng_kernel_event_notifier_private;
493
494 struct lttng_kernel_event_notifier {
495 struct lttng_kernel_event_common parent;
496 struct lttng_kernel_event_notifier_private *priv; /* Private event notifier interface */
497
498 int eval_capture; /* Need to evaluate capture */
499 void (*notification_send)(struct lttng_kernel_event_notifier *event_notifier,
500 struct lttng_probe_ctx *probe_ctx,
501 const char *stack_data,
502 struct lttng_kernel_notification_ctx *notif_ctx);
503 };
504
505 enum lttng_enabler_format_type {
506 LTTNG_ENABLER_FORMAT_STAR_GLOB,
507 LTTNG_ENABLER_FORMAT_NAME,
508 };
509
510 /*
511 * Enabler field, within whatever object is enabling an event. Target of
512 * backward reference.
513 */
514 struct lttng_enabler {
515 enum lttng_enabler_format_type format_type;
516
517 /* head list of struct lttng_bytecode_node */
518 struct list_head filter_bytecode_head;
519
520 struct lttng_kernel_abi_event event_param;
521 unsigned int enabled:1;
522
523 uint64_t user_token; /* User-provided token. */
524 };
525
526 struct lttng_event_enabler {
527 struct lttng_enabler base;
528 struct list_head node; /* per-session list of enablers */
529 struct lttng_channel *chan;
530 };
531
532 struct lttng_event_notifier_enabler {
533 struct lttng_enabler base;
534 uint64_t error_counter_index;
535 struct list_head node; /* List of event_notifier enablers */
536 struct lttng_event_notifier_group *group;
537
538 /* head list of struct lttng_bytecode_node */
539 struct list_head capture_bytecode_head;
540 uint64_t num_captures;
541 };
542
543
544 static inline
545 struct lttng_enabler *lttng_event_enabler_as_enabler(
546 struct lttng_event_enabler *event_enabler)
547 {
548 return &event_enabler->base;
549 }
550
551 static inline
552 struct lttng_enabler *lttng_event_notifier_enabler_as_enabler(
553 struct lttng_event_notifier_enabler *event_notifier_enabler)
554 {
555 return &event_notifier_enabler->base;
556 }
557
558 struct lttng_channel_ops {
559 struct channel *(*channel_create)(const char *name,
560 void *priv,
561 void *buf_addr,
562 size_t subbuf_size, size_t num_subbuf,
563 unsigned int switch_timer_interval,
564 unsigned int read_timer_interval);
565 void (*channel_destroy)(struct channel *chan);
566 struct lib_ring_buffer *(*buffer_read_open)(struct channel *chan);
567 int (*buffer_has_read_closed_stream)(struct channel *chan);
568 void (*buffer_read_close)(struct lib_ring_buffer *buf);
569 int (*event_reserve)(struct lib_ring_buffer_ctx *ctx,
570 uint32_t event_id);
571 void (*event_commit)(struct lib_ring_buffer_ctx *ctx);
572 void (*event_write)(struct lib_ring_buffer_ctx *ctx, const void *src,
573 size_t len);
574 void (*event_write_from_user)(struct lib_ring_buffer_ctx *ctx,
575 const void *src, size_t len);
576 void (*event_memset)(struct lib_ring_buffer_ctx *ctx,
577 int c, size_t len);
578 void (*event_strcpy)(struct lib_ring_buffer_ctx *ctx, const char *src,
579 size_t len);
580 void (*event_strcpy_from_user)(struct lib_ring_buffer_ctx *ctx,
581 const char __user *src, size_t len);
582 /*
583 * packet_avail_size returns the available size in the current
584 * packet. Note that the size returned is only a hint, since it
585 * may change due to concurrent writes.
586 */
587 size_t (*packet_avail_size)(struct channel *chan);
588 wait_queue_head_t *(*get_writer_buf_wait_queue)(struct channel *chan, int cpu);
589 wait_queue_head_t *(*get_hp_wait_queue)(struct channel *chan);
590 int (*is_finalized)(struct channel *chan);
591 int (*is_disabled)(struct channel *chan);
592 int (*timestamp_begin) (const struct lib_ring_buffer_config *config,
593 struct lib_ring_buffer *bufb,
594 uint64_t *timestamp_begin);
595 int (*timestamp_end) (const struct lib_ring_buffer_config *config,
596 struct lib_ring_buffer *bufb,
597 uint64_t *timestamp_end);
598 int (*events_discarded) (const struct lib_ring_buffer_config *config,
599 struct lib_ring_buffer *bufb,
600 uint64_t *events_discarded);
601 int (*content_size) (const struct lib_ring_buffer_config *config,
602 struct lib_ring_buffer *bufb,
603 uint64_t *content_size);
604 int (*packet_size) (const struct lib_ring_buffer_config *config,
605 struct lib_ring_buffer *bufb,
606 uint64_t *packet_size);
607 int (*stream_id) (const struct lib_ring_buffer_config *config,
608 struct lib_ring_buffer *bufb,
609 uint64_t *stream_id);
610 int (*current_timestamp) (const struct lib_ring_buffer_config *config,
611 struct lib_ring_buffer *bufb,
612 uint64_t *ts);
613 int (*sequence_number) (const struct lib_ring_buffer_config *config,
614 struct lib_ring_buffer *bufb,
615 uint64_t *seq);
616 int (*instance_id) (const struct lib_ring_buffer_config *config,
617 struct lib_ring_buffer *bufb,
618 uint64_t *id);
619 };
620
621 struct lttng_counter_ops {
622 struct lib_counter *(*counter_create)(size_t nr_dimensions,
623 const size_t *max_nr_elem, /* for each dimension */
624 int64_t global_sum_step);
625 void (*counter_destroy)(struct lib_counter *counter);
626 int (*counter_add)(struct lib_counter *counter, const size_t *dimension_indexes,
627 int64_t v);
628 /*
629 * counter_read reads a specific cpu's counter if @cpu >= 0, or
630 * the global aggregation counter if @cpu == -1.
631 */
632 int (*counter_read)(struct lib_counter *counter, const size_t *dimension_indexes, int cpu,
633 int64_t *value, bool *overflow, bool *underflow);
634 /*
635 * counter_aggregate returns the total sum of all per-cpu counters and
636 * the global aggregation counter.
637 */
638 int (*counter_aggregate)(struct lib_counter *counter, const size_t *dimension_indexes,
639 int64_t *value, bool *overflow, bool *underflow);
640 int (*counter_clear)(struct lib_counter *counter, const size_t *dimension_indexes);
641 };
642
643 struct lttng_transport {
644 char *name;
645 struct module *owner;
646 struct list_head node;
647 struct lttng_channel_ops ops;
648 };
649
650 struct lttng_counter_transport {
651 char *name;
652 struct module *owner;
653 struct list_head node;
654 struct lttng_counter_ops ops;
655 };
656
657 struct lttng_syscall_filter;
658
659 #define LTTNG_EVENT_HT_BITS 12
660 #define LTTNG_EVENT_HT_SIZE (1U << LTTNG_EVENT_HT_BITS)
661
662 struct lttng_event_ht {
663 struct hlist_head table[LTTNG_EVENT_HT_SIZE];
664 };
665
666 #define LTTNG_EVENT_NOTIFIER_HT_BITS 12
667 #define LTTNG_EVENT_NOTIFIER_HT_SIZE (1U << LTTNG_EVENT_NOTIFIER_HT_BITS)
668
669 struct lttng_event_notifier_ht {
670 struct hlist_head table[LTTNG_EVENT_NOTIFIER_HT_SIZE];
671 };
672
673 struct lttng_channel {
674 unsigned int id;
675 struct channel *chan; /* Channel buffers */
676 int enabled;
677 struct lttng_kernel_ctx *ctx;
678 /* Event ID management */
679 struct lttng_session *session;
680 struct file *file; /* File associated to channel */
681 unsigned int free_event_id; /* Next event ID to allocate */
682 struct list_head list; /* Channel list */
683 struct lttng_channel_ops *ops;
684 struct lttng_transport *transport;
685 struct hlist_head *sc_table; /* for syscall tracing */
686 struct hlist_head *compat_sc_table;
687 struct hlist_head *sc_exit_table; /* for syscall exit tracing */
688 struct hlist_head *compat_sc_exit_table;
689 struct hlist_head sc_unknown; /* for unknown syscalls */
690 struct hlist_head sc_compat_unknown;
691 struct hlist_head sc_exit_unknown;
692 struct hlist_head compat_sc_exit_unknown;
693 struct lttng_syscall_filter *sc_filter;
694 int header_type; /* 0: unset, 1: compact, 2: large */
695 enum channel_type channel_type;
696 int syscall_all_entry;
697 int syscall_all_exit;
698 unsigned int metadata_dumped:1,
699 sys_enter_registered:1,
700 sys_exit_registered:1,
701 tstate:1; /* Transient enable state */
702 };
703
704 struct lttng_metadata_stream {
705 void *priv; /* Ring buffer private data */
706 struct lttng_metadata_cache *metadata_cache;
707 unsigned int metadata_in; /* Bytes read from the cache */
708 unsigned int metadata_out; /* Bytes consumed from stream */
709 int finalized; /* Has channel been finalized */
710 wait_queue_head_t read_wait; /* Reader buffer-level wait queue */
711 struct list_head list; /* Stream list */
712 struct lttng_transport *transport;
713 uint64_t version; /* Current version of the metadata cache */
714 bool coherent; /* Stream in a coherent state */
715 };
716
717 #define LTTNG_DYNAMIC_LEN_STACK_SIZE 128
718
719 struct lttng_dynamic_len_stack {
720 size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE];
721 size_t offset;
722 };
723
724 DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);
725
726 /*
727 * struct lttng_id_tracker declared in header due to deferencing of *v
728 * in RCU_INITIALIZER(v).
729 */
730 #define LTTNG_ID_HASH_BITS 6
731 #define LTTNG_ID_TABLE_SIZE (1 << LTTNG_ID_HASH_BITS)
732
733 enum tracker_type {
734 TRACKER_PID,
735 TRACKER_VPID,
736 TRACKER_UID,
737 TRACKER_VUID,
738 TRACKER_GID,
739 TRACKER_VGID,
740
741 TRACKER_UNKNOWN,
742 };
743
744 struct lttng_id_tracker_rcu {
745 struct hlist_head id_hash[LTTNG_ID_TABLE_SIZE];
746 };
747
748 struct lttng_id_tracker {
749 struct lttng_session *session;
750 enum tracker_type tracker_type;
751 struct lttng_id_tracker_rcu *p; /* RCU dereferenced. */
752 };
753
754 struct lttng_id_hash_node {
755 struct hlist_node hlist;
756 int id;
757 };
758
759 struct lttng_session {
760 int active; /* Is trace session active ? */
761 int been_active; /* Has trace session been active ? */
762 struct file *file; /* File associated to session */
763 struct list_head chan; /* Channel list head */
764 struct list_head events; /* Event list head */
765 struct list_head list; /* Session list */
766 unsigned int free_chan_id; /* Next chan ID to allocate */
767 uuid_le uuid; /* Trace session unique ID */
768 struct lttng_metadata_cache *metadata_cache;
769 struct lttng_id_tracker pid_tracker;
770 struct lttng_id_tracker vpid_tracker;
771 struct lttng_id_tracker uid_tracker;
772 struct lttng_id_tracker vuid_tracker;
773 struct lttng_id_tracker gid_tracker;
774 struct lttng_id_tracker vgid_tracker;
775 unsigned int metadata_dumped:1,
776 tstate:1; /* Transient enable state */
777 /* List of event enablers */
778 struct list_head enablers_head;
779 /* Hash table of events */
780 struct lttng_event_ht events_ht;
781 char name[LTTNG_KERNEL_ABI_SESSION_NAME_LEN];
782 char creation_time[LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN];
783 };
784
785 struct lttng_counter {
786 struct file *file; /* File associated to counter. */
787 struct file *owner;
788 struct lttng_counter_transport *transport;
789 struct lib_counter *counter;
790 struct lttng_counter_ops *ops;
791 };
792
793 struct lttng_event_notifier_group {
794 struct file *file; /* File associated to event notifier group */
795 struct file *notif_file; /* File used to expose notifications to userspace. */
796 struct list_head node; /* event notifier group list */
797 struct list_head enablers_head; /* List of enablers */
798 struct list_head event_notifiers_head; /* List of event notifier */
799 struct lttng_event_notifier_ht event_notifiers_ht; /* Hash table of event notifiers */
800 struct lttng_channel_ops *ops;
801 struct lttng_transport *transport;
802 struct channel *chan; /* Ring buffer channel for event notifier group. */
803 struct lib_ring_buffer *buf; /* Ring buffer for event notifier group. */
804 wait_queue_head_t read_wait;
805 struct irq_work wakeup_pending; /* Pending wakeup irq work. */
806 struct lttng_kernel_event_notifier *sc_unknown; /* for unknown syscalls */
807 struct lttng_kernel_event_notifier *sc_compat_unknown;
808
809 struct lttng_syscall_filter *sc_filter;
810
811 struct hlist_head *event_notifier_syscall_dispatch;
812 struct hlist_head *event_notifier_compat_syscall_dispatch;
813 struct hlist_head *event_notifier_exit_syscall_dispatch;
814 struct hlist_head *event_notifier_exit_compat_syscall_dispatch;
815
816 struct hlist_head event_notifier_unknown_syscall_dispatch;
817 struct hlist_head event_notifier_compat_unknown_syscall_dispatch;
818 struct hlist_head event_notifier_exit_unknown_syscall_dispatch;
819 struct hlist_head event_notifier_exit_compat_unknown_syscall_dispatch;
820
821 int syscall_all_entry;
822 int syscall_all_exit;
823
824 unsigned int sys_enter_registered:1, sys_exit_registered:1;
825
826 struct lttng_counter *error_counter;
827 size_t error_counter_len;
828 };
829
830 struct lttng_metadata_cache {
831 char *data; /* Metadata cache */
832 unsigned int cache_alloc; /* Metadata allocated size (bytes) */
833 unsigned int metadata_written; /* Number of bytes written in metadata cache */
834 atomic_t producing; /* Metadata being produced (incomplete) */
835 struct kref refcount; /* Metadata cache usage */
836 struct list_head metadata_stream; /* Metadata stream list */
837 uuid_le uuid; /* Trace session unique ID (copy) */
838 struct mutex lock; /* Produce/consume lock */
839 uint64_t version; /* Current version of the metadata */
840 };
841
842 void lttng_lock_sessions(void);
843 void lttng_unlock_sessions(void);
844
845 struct list_head *lttng_get_probe_list_head(void);
846
847 struct lttng_event_enabler *lttng_event_enabler_create(
848 enum lttng_enabler_format_type format_type,
849 struct lttng_kernel_abi_event *event_param,
850 struct lttng_channel *chan);
851
852 int lttng_event_enabler_enable(struct lttng_event_enabler *event_enabler);
853 int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler);
854 struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create(
855 struct lttng_event_notifier_group *event_notifier_group,
856 enum lttng_enabler_format_type format_type,
857 struct lttng_kernel_abi_event_notifier *event_notifier_param);
858
859 int lttng_event_notifier_enabler_enable(
860 struct lttng_event_notifier_enabler *event_notifier_enabler);
861 int lttng_event_notifier_enabler_disable(
862 struct lttng_event_notifier_enabler *event_notifier_enabler);
863 int lttng_fix_pending_events(void);
864 int lttng_fix_pending_event_notifiers(void);
865 int lttng_session_active(void);
866 bool lttng_event_notifier_active(void);
867
868 struct lttng_session *lttng_session_create(void);
869 int lttng_session_enable(struct lttng_session *session);
870 int lttng_session_disable(struct lttng_session *session);
871 void lttng_session_destroy(struct lttng_session *session);
872 int lttng_session_metadata_regenerate(struct lttng_session *session);
873 int lttng_session_statedump(struct lttng_session *session);
874 void metadata_cache_destroy(struct kref *kref);
875
876 struct lttng_counter *lttng_kernel_counter_create(
877 const char *counter_transport_name, size_t number_dimensions,
878 const size_t *dimensions_sizes);
879 int lttng_kernel_counter_read(struct lttng_counter *counter,
880 const size_t *dimension_indexes, int32_t cpu,
881 int64_t *val, bool *overflow, bool *underflow);
882 int lttng_kernel_counter_aggregate(struct lttng_counter *counter,
883 const size_t *dimension_indexes, int64_t *val,
884 bool *overflow, bool *underflow);
885 int lttng_kernel_counter_clear(struct lttng_counter *counter,
886 const size_t *dimension_indexes);
887
888
889 struct lttng_event_notifier_group *lttng_event_notifier_group_create(void);
890 int lttng_event_notifier_group_create_error_counter(
891 struct file *event_notifier_group_file,
892 const struct lttng_kernel_abi_counter_conf *error_counter_conf);
893 void lttng_event_notifier_group_destroy(
894 struct lttng_event_notifier_group *event_notifier_group);
895
896 struct lttng_channel *lttng_channel_create(struct lttng_session *session,
897 const char *transport_name,
898 void *buf_addr,
899 size_t subbuf_size, size_t num_subbuf,
900 unsigned int switch_timer_interval,
901 unsigned int read_timer_interval,
902 enum channel_type channel_type);
903 struct lttng_channel *lttng_global_channel_create(struct lttng_session *session,
904 int overwrite, void *buf_addr,
905 size_t subbuf_size, size_t num_subbuf,
906 unsigned int switch_timer_interval,
907 unsigned int read_timer_interval);
908
909 void lttng_metadata_channel_destroy(struct lttng_channel *chan);
910 struct lttng_kernel_event_recorder *lttng_kernel_event_recorder_create(struct lttng_channel *chan,
911 struct lttng_kernel_abi_event *event_param,
912 const struct lttng_kernel_event_desc *event_desc,
913 enum lttng_kernel_abi_instrumentation itype);
914 struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct lttng_channel *chan,
915 struct lttng_kernel_abi_event *event_param,
916 const struct lttng_kernel_event_desc *event_desc,
917 enum lttng_kernel_abi_instrumentation itype);
918 struct lttng_kernel_event_recorder *lttng_event_compat_old_create(struct lttng_channel *chan,
919 struct lttng_kernel_abi_old_event *old_event_param,
920 const struct lttng_kernel_event_desc *internal_desc);
921
922 struct lttng_kernel_event_notifier *lttng_event_notifier_create(
923 const struct lttng_kernel_event_desc *event_notifier_desc,
924 uint64_t id,
925 uint64_t error_counter_idx,
926 struct lttng_event_notifier_group *event_notifier_group,
927 struct lttng_kernel_abi_event_notifier *event_notifier_param,
928 enum lttng_kernel_abi_instrumentation itype);
929 struct lttng_kernel_event_notifier *_lttng_event_notifier_create(
930 const struct lttng_kernel_event_desc *event_notifier_desc,
931 uint64_t id,
932 uint64_t error_counter_idx,
933 struct lttng_event_notifier_group *event_notifier_group,
934 struct lttng_kernel_abi_event_notifier *event_notifier_param,
935 enum lttng_kernel_abi_instrumentation itype);
936
937 int lttng_channel_enable(struct lttng_channel *channel);
938 int lttng_channel_disable(struct lttng_channel *channel);
939 int lttng_event_enable(struct lttng_kernel_event_common *event);
940 int lttng_event_disable(struct lttng_kernel_event_common *event);
941
942 void lttng_transport_register(struct lttng_transport *transport);
943 void lttng_transport_unregister(struct lttng_transport *transport);
944
945 void lttng_counter_transport_register(struct lttng_counter_transport *transport);
946 void lttng_counter_transport_unregister(struct lttng_counter_transport *transport);
947
948 void synchronize_trace(void);
949 int lttng_abi_init(void);
950 int lttng_abi_compat_old_init(void);
951 void lttng_abi_exit(void);
952 void lttng_abi_compat_old_exit(void);
953
954 int lttng_probe_register(struct lttng_kernel_probe_desc *desc);
955 void lttng_probe_unregister(struct lttng_kernel_probe_desc *desc);
956 const struct lttng_kernel_event_desc *lttng_event_desc_get(const char *name);
957 void lttng_event_desc_put(const struct lttng_kernel_event_desc *desc);
958 int lttng_probes_init(void);
959 void lttng_probes_exit(void);
960
961 int lttng_metadata_output_channel(struct lttng_metadata_stream *stream,
962 struct channel *chan, bool *coherent);
963
964 int lttng_id_tracker_get_node_id(const struct lttng_id_hash_node *node);
965 int lttng_id_tracker_empty_set(struct lttng_id_tracker *lf);
966 void lttng_id_tracker_destroy(struct lttng_id_tracker *lf, bool rcu);
967 bool lttng_id_tracker_lookup(struct lttng_id_tracker_rcu *p, int id);
968 int lttng_id_tracker_add(struct lttng_id_tracker *lf, int id);
969 int lttng_id_tracker_del(struct lttng_id_tracker *lf, int id);
970
971 int lttng_session_track_id(struct lttng_session *session,
972 enum tracker_type tracker_type, int id);
973 int lttng_session_untrack_id(struct lttng_session *session,
974 enum tracker_type tracker_type, int id);
975
976 int lttng_session_list_tracker_ids(struct lttng_session *session,
977 enum tracker_type tracker_type);
978
979 void lttng_clock_ref(void);
980 void lttng_clock_unref(void);
981
982 int lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc,
983 struct lttng_enabler *enabler);
984
985 #if defined(CONFIG_HAVE_SYSCALL_TRACEPOINTS)
986 int lttng_syscalls_register_event(struct lttng_event_enabler *event_enabler);
987 int lttng_syscalls_unregister_channel(struct lttng_channel *chan);
988 int lttng_syscalls_destroy_event(struct lttng_channel *chan);
989 int lttng_syscall_filter_enable_event(
990 struct lttng_channel *chan,
991 struct lttng_kernel_event_recorder *event);
992 int lttng_syscall_filter_disable_event(
993 struct lttng_channel *chan,
994 struct lttng_kernel_event_recorder *event);
995
996 long lttng_channel_syscall_mask(struct lttng_channel *channel,
997 struct lttng_kernel_abi_syscall_mask __user *usyscall_mask);
998
999 int lttng_syscalls_register_event_notifier(
1000 struct lttng_event_notifier_enabler *event_notifier_enabler);
1001 int lttng_syscalls_create_matching_event_notifiers(
1002 struct lttng_event_notifier_enabler *event_notifier_enabler);
1003 int lttng_syscalls_unregister_event_notifier_group(struct lttng_event_notifier_group *group);
1004 int lttng_syscall_filter_enable_event_notifier(struct lttng_kernel_event_notifier *event_notifier);
1005 int lttng_syscall_filter_disable_event_notifier(struct lttng_kernel_event_notifier *event_notifier);
1006 #else
1007 static inline int lttng_syscalls_register_event(
1008 struct lttng_event_enabler *event_enabler)
1009 {
1010 return -ENOSYS;
1011 }
1012
1013 static inline int lttng_syscalls_unregister_channel(struct lttng_channel *chan)
1014 {
1015 return 0;
1016 }
1017
1018 static inline int lttng_syscalls_destroy(struct lttng_channel *chan)
1019 {
1020 return 0;
1021 }
1022
1023 static inline int lttng_syscall_filter_enable_event(struct lttng_channel *chan,
1024 struct lttng_kernel_event_recorder *event);
1025 {
1026 return -ENOSYS;
1027 }
1028
1029 static inline int lttng_syscall_filter_disable_event(struct lttng_channel *chan,
1030 struct lttng_kernel_event_recorder *event);
1031 {
1032 return -ENOSYS;
1033 }
1034
1035 static inline long lttng_channel_syscall_mask(struct lttng_channel *channel,
1036 struct lttng_kernel_syscall_mask __user *usyscall_mask)
1037 {
1038 return -ENOSYS;
1039 }
1040
1041 static inline int lttng_syscalls_register_event_notifier(
1042 struct lttng_event_notifier_group *group)
1043 {
1044 return -ENOSYS;
1045 }
1046
1047 static inline int lttng_syscalls_unregister_event_notifier_group(
1048 struct lttng_event_notifier_group *group)
1049 {
1050 return 0;
1051 }
1052
1053 static inline int lttng_syscall_filter_enable_event_notifier(
1054 struct lttng_event_notifier_group *group,
1055 const char *name)
1056 {
1057 return -ENOSYS;
1058 }
1059
1060 static inline int lttng_syscall_filter_disable_event_notifier(
1061 struct lttng_event_notifier_group *group,
1062 const char *name)
1063 {
1064 return -ENOSYS;
1065 }
1066
1067 #endif
1068
1069 int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event_enabler,
1070 struct lttng_kernel_abi_filter_bytecode __user *bytecode);
1071 int lttng_event_notifier_enabler_attach_filter_bytecode(
1072 struct lttng_event_notifier_enabler *event_notifier_enabler,
1073 struct lttng_kernel_abi_filter_bytecode __user *bytecode);
1074 int lttng_event_notifier_enabler_attach_capture_bytecode(
1075 struct lttng_event_notifier_enabler *event_notifier_enabler,
1076 struct lttng_kernel_abi_capture_bytecode __user *bytecode);
1077
1078 void lttng_enabler_link_bytecode(const struct lttng_kernel_event_desc *event_desc,
1079 struct lttng_kernel_ctx *ctx,
1080 struct list_head *instance_bytecode_runtime_head,
1081 struct list_head *enabler_bytecode_runtime_head);
1082 void lttng_free_event_filter_runtime(struct lttng_kernel_event_common *event);
1083
1084 int lttng_probes_init(void);
1085
1086 extern struct lttng_kernel_ctx *lttng_static_ctx;
1087
1088 int lttng_context_init(void);
1089 void lttng_context_exit(void);
1090 int lttng_kernel_context_append(struct lttng_kernel_ctx **ctx_p,
1091 const struct lttng_kernel_ctx_field *f);
1092 void lttng_kernel_context_remove_last(struct lttng_kernel_ctx **ctx_p);
1093 struct lttng_kernel_ctx_field *lttng_kernel_get_context_field_from_index(struct lttng_kernel_ctx *ctx,
1094 size_t index);
1095 int lttng_kernel_find_context(struct lttng_kernel_ctx *ctx, const char *name);
1096 int lttng_kernel_get_context_index(struct lttng_kernel_ctx *ctx, const char *name);
1097 void lttng_kernel_destroy_context(struct lttng_kernel_ctx *ctx);
1098 int lttng_add_pid_to_ctx(struct lttng_kernel_ctx **ctx);
1099 int lttng_add_cpu_id_to_ctx(struct lttng_kernel_ctx **ctx);
1100 int lttng_add_procname_to_ctx(struct lttng_kernel_ctx **ctx);
1101 int lttng_add_prio_to_ctx(struct lttng_kernel_ctx **ctx);
1102 int lttng_add_nice_to_ctx(struct lttng_kernel_ctx **ctx);
1103 int lttng_add_vpid_to_ctx(struct lttng_kernel_ctx **ctx);
1104 int lttng_add_tid_to_ctx(struct lttng_kernel_ctx **ctx);
1105 int lttng_add_vtid_to_ctx(struct lttng_kernel_ctx **ctx);
1106 int lttng_add_ppid_to_ctx(struct lttng_kernel_ctx **ctx);
1107 int lttng_add_vppid_to_ctx(struct lttng_kernel_ctx **ctx);
1108 int lttng_add_hostname_to_ctx(struct lttng_kernel_ctx **ctx);
1109 int lttng_add_interruptible_to_ctx(struct lttng_kernel_ctx **ctx);
1110 int lttng_add_need_reschedule_to_ctx(struct lttng_kernel_ctx **ctx);
1111 #if defined(CONFIG_PREEMPT_RT_FULL) || defined(CONFIG_PREEMPT)
1112 int lttng_add_preemptible_to_ctx(struct lttng_kernel_ctx **ctx);
1113 #else
1114 static inline
1115 int lttng_add_preemptible_to_ctx(struct lttng_kernel_ctx **ctx)
1116 {
1117 return -ENOSYS;
1118 }
1119 #endif
1120 #ifdef CONFIG_PREEMPT_RT_FULL
1121 int lttng_add_migratable_to_ctx(struct lttng_kernel_ctx **ctx);
1122 #else
1123 static inline
1124 int lttng_add_migratable_to_ctx(struct lttng_kernel_ctx **ctx)
1125 {
1126 return -ENOSYS;
1127 }
1128 #endif
1129
1130 int lttng_add_callstack_to_ctx(struct lttng_kernel_ctx **ctx, int type);
1131
1132 #if defined(CONFIG_CGROUPS) && \
1133 ((LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,6,0)) || \
1134 LTTNG_UBUNTU_KERNEL_RANGE(4,4,0,0, 4,5,0,0))
1135 int lttng_add_cgroup_ns_to_ctx(struct lttng_kernel_ctx **ctx);
1136 #else
1137 static inline
1138 int lttng_add_cgroup_ns_to_ctx(struct lttng_kernel_ctx **ctx)
1139 {
1140 return -ENOSYS;
1141 }
1142 #endif
1143
1144 #if defined(CONFIG_IPC_NS) && \
1145 (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,8,0))
1146 int lttng_add_ipc_ns_to_ctx(struct lttng_kernel_ctx **ctx);
1147 #else
1148 static inline
1149 int lttng_add_ipc_ns_to_ctx(struct lttng_kernel_ctx **ctx)
1150 {
1151 return -ENOSYS;
1152 }
1153 #endif
1154
1155 #if !defined(LTTNG_MNT_NS_MISSING_HEADER) && \
1156 (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,8,0))
1157 int lttng_add_mnt_ns_to_ctx(struct lttng_kernel_ctx **ctx);
1158 #else
1159 static inline
1160 int lttng_add_mnt_ns_to_ctx(struct lttng_kernel_ctx **ctx)
1161 {
1162 return -ENOSYS;
1163 }
1164 #endif
1165
1166 #if defined(CONFIG_NET_NS) && \
1167 (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,8,0))
1168 int lttng_add_net_ns_to_ctx(struct lttng_kernel_ctx **ctx);
1169 #else
1170 static inline
1171 int lttng_add_net_ns_to_ctx(struct lttng_kernel_ctx **ctx)
1172 {
1173 return -ENOSYS;
1174 }
1175 #endif
1176
1177 #if defined(CONFIG_PID_NS) && \
1178 (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,8,0))
1179 int lttng_add_pid_ns_to_ctx(struct lttng_kernel_ctx **ctx);
1180 #else
1181 static inline
1182 int lttng_add_pid_ns_to_ctx(struct lttng_kernel_ctx **ctx)
1183 {
1184 return -ENOSYS;
1185 }
1186 #endif
1187
1188 #if defined(CONFIG_USER_NS) && \
1189 (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,8,0))
1190 int lttng_add_user_ns_to_ctx(struct lttng_kernel_ctx **ctx);
1191 #else
1192 static inline
1193 int lttng_add_user_ns_to_ctx(struct lttng_kernel_ctx **ctx)
1194 {
1195 return -ENOSYS;
1196 }
1197 #endif
1198
1199 #if defined(CONFIG_UTS_NS) && \
1200 (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,8,0))
1201 int lttng_add_uts_ns_to_ctx(struct lttng_kernel_ctx **ctx);
1202 #else
1203 static inline
1204 int lttng_add_uts_ns_to_ctx(struct lttng_kernel_ctx **ctx)
1205 {
1206 return -ENOSYS;
1207 }
1208 #endif
1209
1210 #if defined(CONFIG_TIME_NS) && \
1211 (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
1212 int lttng_add_time_ns_to_ctx(struct lttng_kernel_ctx **ctx);
1213 #else
1214 static inline
1215 int lttng_add_time_ns_to_ctx(struct lttng_kernel_ctx **ctx)
1216 {
1217 return -ENOSYS;
1218 }
1219 #endif
1220
1221 int lttng_add_uid_to_ctx(struct lttng_kernel_ctx **ctx);
1222 int lttng_add_euid_to_ctx(struct lttng_kernel_ctx **ctx);
1223 int lttng_add_suid_to_ctx(struct lttng_kernel_ctx **ctx);
1224 int lttng_add_gid_to_ctx(struct lttng_kernel_ctx **ctx);
1225 int lttng_add_egid_to_ctx(struct lttng_kernel_ctx **ctx);
1226 int lttng_add_sgid_to_ctx(struct lttng_kernel_ctx **ctx);
1227 int lttng_add_vuid_to_ctx(struct lttng_kernel_ctx **ctx);
1228 int lttng_add_veuid_to_ctx(struct lttng_kernel_ctx **ctx);
1229 int lttng_add_vsuid_to_ctx(struct lttng_kernel_ctx **ctx);
1230 int lttng_add_vgid_to_ctx(struct lttng_kernel_ctx **ctx);
1231 int lttng_add_vegid_to_ctx(struct lttng_kernel_ctx **ctx);
1232 int lttng_add_vsgid_to_ctx(struct lttng_kernel_ctx **ctx);
1233
1234 #if defined(CONFIG_PERF_EVENTS)
1235 int lttng_add_perf_counter_to_ctx(uint32_t type,
1236 uint64_t config,
1237 const char *name,
1238 struct lttng_kernel_ctx **ctx);
1239 int lttng_cpuhp_perf_counter_online(unsigned int cpu,
1240 struct lttng_cpuhp_node *node);
1241 int lttng_cpuhp_perf_counter_dead(unsigned int cpu,
1242 struct lttng_cpuhp_node *node);
1243 #else
1244 static inline
1245 int lttng_add_perf_counter_to_ctx(uint32_t type,
1246 uint64_t config,
1247 const char *name,
1248 struct lttng_kernel_ctx **ctx)
1249 {
1250 return -ENOSYS;
1251 }
1252 static inline
1253 int lttng_cpuhp_perf_counter_online(unsigned int cpu,
1254 struct lttng_cpuhp_node *node)
1255 {
1256 return 0;
1257 }
1258 static inline
1259 int lttng_cpuhp_perf_counter_dead(unsigned int cpu,
1260 struct lttng_cpuhp_node *node)
1261 {
1262 return 0;
1263 }
1264 #endif
1265
1266 int lttng_logger_init(void);
1267 void lttng_logger_exit(void);
1268
1269 extern int lttng_statedump_start(struct lttng_session *session);
1270
1271 #ifdef CONFIG_KPROBES
1272 int lttng_kprobes_register_event(const char *name,
1273 const char *symbol_name,
1274 uint64_t offset,
1275 uint64_t addr,
1276 struct lttng_kernel_event_recorder *event);
1277 void lttng_kprobes_unregister_event(struct lttng_kernel_event_recorder *event);
1278 void lttng_kprobes_destroy_event_private(struct lttng_kernel_event_recorder *event);
1279 int lttng_kprobes_register_event_notifier(const char *symbol_name,
1280 uint64_t offset,
1281 uint64_t addr,
1282 struct lttng_kernel_event_notifier *event_notifier);
1283 void lttng_kprobes_unregister_event_notifier(struct lttng_kernel_event_notifier *event_notifier);
1284 void lttng_kprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier *event_notifier);
1285 #else
1286 static inline
1287 int lttng_kprobes_register_event(const char *name,
1288 const char *symbol_name,
1289 uint64_t offset,
1290 uint64_t addr,
1291 struct lttng_kernel_event_recorder *event)
1292 {
1293 return -ENOSYS;
1294 }
1295
1296 static inline
1297 void lttng_kprobes_unregister_event(struct lttng_kernel_event_recorder *event)
1298 {
1299 }
1300
1301 static inline
1302 void lttng_kprobes_destroy_event_private(struct lttng_kernel_event_recorder *event)
1303 {
1304 }
1305
1306 static inline
1307 int lttng_kprobes_register_event_notifier(const char *symbol_name,
1308 uint64_t offset,
1309 uint64_t addr,
1310 struct lttng_kernel_event_notifier *event_notifier)
1311 {
1312 return -ENOSYS;
1313 }
1314
1315 static inline
1316 void lttng_kprobes_unregister_event_notifier(struct lttng_kernel_event_notifier *event_notifier)
1317 {
1318 }
1319
1320 static inline
1321 void lttng_kprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier *event_notifier)
1322 {
1323 }
1324 #endif
1325
1326 int lttng_event_add_callsite(struct lttng_kernel_event_common *event,
1327 struct lttng_kernel_abi_event_callsite __user *callsite);
1328
1329 #ifdef CONFIG_UPROBES
1330 int lttng_uprobes_register_event(const char *name,
1331 int fd, struct lttng_kernel_event_recorder *event);
1332 int lttng_uprobes_event_add_callsite(struct lttng_kernel_event_common *event,
1333 struct lttng_kernel_abi_event_callsite __user *callsite);
1334 void lttng_uprobes_unregister_event(struct lttng_kernel_event_recorder *event);
1335 void lttng_uprobes_destroy_event_private(struct lttng_kernel_event_recorder *event);
1336 int lttng_uprobes_register_event_notifier(const char *name,
1337 int fd, struct lttng_kernel_event_notifier *event_notifier);
1338 void lttng_uprobes_unregister_event_notifier(struct lttng_kernel_event_notifier *event_notifier);
1339 void lttng_uprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier *event_notifier);
1340 #else
1341 static inline
1342 int lttng_uprobes_register_event(const char *name,
1343 int fd, struct lttng_kernel_event_recorder *event)
1344 {
1345 return -ENOSYS;
1346 }
1347
1348 static inline
1349 int lttng_uprobes_event_add_callsite(struct lttng_kernel_event_common *event,
1350 struct lttng_kernel_abi_event_callsite __user *callsite)
1351 {
1352 return -ENOSYS;
1353 }
1354
1355 static inline
1356 void lttng_uprobes_unregister_event(struct lttng_kernel_event_recorder *event)
1357 {
1358 }
1359
1360 static inline
1361 void lttng_uprobes_destroy_event_private(struct lttng_kernel_event_recorder *event)
1362 {
1363 }
1364
1365 static inline
1366 int lttng_uprobes_register_event_notifier(const char *name,
1367 int fd, struct lttng_kernel_event_notifier *event_notifier)
1368 {
1369 return -ENOSYS;
1370 }
1371
1372 static inline
1373 void lttng_uprobes_unregister_event_notifier(struct lttng_kernel_event_notifier *event_notifier)
1374 {
1375 }
1376
1377 static inline
1378 void lttng_uprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier *event_notifier)
1379 {
1380 }
1381 #endif
1382
1383 #ifdef CONFIG_KRETPROBES
1384 int lttng_kretprobes_register(const char *name,
1385 const char *symbol_name,
1386 uint64_t offset,
1387 uint64_t addr,
1388 struct lttng_kernel_event_recorder *event_entry,
1389 struct lttng_kernel_event_recorder *event_exit);
1390 void lttng_kretprobes_unregister(struct lttng_kernel_event_recorder *event);
1391 void lttng_kretprobes_destroy_private(struct lttng_kernel_event_recorder *event);
1392 int lttng_kretprobes_event_enable_state(struct lttng_kernel_event_common *event,
1393 int enable);
1394 #else
1395 static inline
1396 int lttng_kretprobes_register(const char *name,
1397 const char *symbol_name,
1398 uint64_t offset,
1399 uint64_t addr,
1400 struct lttng_kernel_event_recorder *event_entry,
1401 struct lttng_kernel_event_recorder *event_exit)
1402 {
1403 return -ENOSYS;
1404 }
1405
1406 static inline
1407 void lttng_kretprobes_unregister(struct lttng_kernel_event_recorder *event)
1408 {
1409 }
1410
1411 static inline
1412 void lttng_kretprobes_destroy_private(struct lttng_kernel_event_recorder *event)
1413 {
1414 }
1415
1416 static inline
1417 int lttng_kretprobes_event_enable_state(struct lttng_kernel_event_common *event,
1418 int enable)
1419 {
1420 return -ENOSYS;
1421 }
1422 #endif
1423
1424 int lttng_calibrate(struct lttng_kernel_abi_calibrate *calibrate);
1425
1426 extern const struct file_operations lttng_tracepoint_list_fops;
1427 extern const struct file_operations lttng_syscall_list_fops;
1428
1429 #define TRACEPOINT_HAS_DATA_ARG
1430
1431 #endif /* _LTTNG_EVENTS_H */
LTTng 2.0/0.x modules
This page took 0.083781 seconds and 3 git commands to generate.