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


0f6b5ab9d4e2b09e8e2742dc3fab9d4ffe3b4b0b
[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_kernel_channel_buffer;
29 struct lttng_kernel_session;
30 struct lttng_kernel_ring_buffer_ctx;
31
32 /* Type description */
33
34 enum lttng_kernel_type {
35 lttng_kernel_type_integer,
36 lttng_kernel_type_string,
37 lttng_kernel_type_enum,
38 lttng_kernel_type_array,
39 lttng_kernel_type_sequence,
40 lttng_kernel_type_struct,
41 lttng_kernel_type_variant,
42 NR_LTTNG_KERNEL_TYPES,
43 };
44
45 enum lttng_kernel_string_encoding {
46 lttng_kernel_string_encoding_none = 0,
47 lttng_kernel_string_encoding_UTF8 = 1,
48 lttng_kernel_string_encoding_ASCII = 2,
49 NR_LTTNG_KERNEL_STRING_ENCODING,
50 };
51
52 struct lttng_kernel_enum_value {
53 unsigned long long value;
54 unsigned int signedness:1;
55 };
56
57 struct lttng_kernel_enum_entry {
58 struct lttng_kernel_enum_value start, end; /* start and end are inclusive */
59 const char *string;
60 struct {
61 unsigned int is_auto:1;
62 } options;
63 };
64
65 /*
66 * struct lttng_kernel_type_common is fixed-size. Its children inherits
67 * from it by embedding struct lttng_kernel_type_common as its first field.
68 */
69 struct lttng_kernel_type_common {
70 enum lttng_kernel_type type;
71 };
72
73 struct lttng_kernel_type_integer {
74 struct lttng_kernel_type_common parent;
75 unsigned int size; /* in bits */
76 unsigned short alignment; /* in bits */
77 unsigned int signedness:1,
78 reverse_byte_order:1;
79 unsigned int base; /* 2, 8, 10, 16, for pretty print */
80 };
81
82 struct lttng_kernel_type_string {
83 struct lttng_kernel_type_common parent;
84 enum lttng_kernel_string_encoding encoding;
85 };
86
87 struct lttng_kernel_type_enum {
88 struct lttng_kernel_type_common parent;
89 const struct lttng_kernel_enum_desc *desc; /* Enumeration mapping */
90 const struct lttng_kernel_type_common *container_type;
91 };
92
93 struct lttng_kernel_type_array {
94 struct lttng_kernel_type_common parent;
95 const struct lttng_kernel_type_common *elem_type;
96 unsigned int length; /* Num. elems. */
97 unsigned int alignment;
98 enum lttng_kernel_string_encoding encoding;
99 };
100
101 struct lttng_kernel_type_sequence {
102 struct lttng_kernel_type_common parent;
103 const char *length_name; /* Length field name. If NULL, use previous field. */
104 const struct lttng_kernel_type_common *elem_type;
105 unsigned int alignment; /* Alignment before elements. */
106 enum lttng_kernel_string_encoding encoding;
107 };
108
109 struct lttng_kernel_type_struct {
110 struct lttng_kernel_type_common parent;
111 unsigned int nr_fields;
112 const struct lttng_kernel_event_field * const *fields; /* Array of pointers to fields. */
113 unsigned int alignment;
114 };
115
116 struct lttng_kernel_type_variant {
117 struct lttng_kernel_type_common parent;
118 const char *tag_name; /* Tag field name. If NULL, use previous field. */
119 const struct lttng_kernel_event_field * const *choices; /* Array of pointers to fields. */
120 unsigned int nr_choices;
121 unsigned int alignment;
122 };
123
124 struct lttng_kernel_enum_desc {
125 const char *name;
126 const struct lttng_kernel_enum_entry * const *entries;
127 unsigned int nr_entries;
128 const struct lttng_kernel_probe_desc *probe_desc;
129 };
130
131 /* Event field description */
132
133 struct lttng_kernel_event_field {
134 const char *name;
135 const struct lttng_kernel_type_common *type;
136 unsigned int nowrite:1, /* do not write into trace */
137 user:1, /* fetch from user-space */
138 nofilter:1; /* do not consider for filter */
139 };
140
141 #ifndef PARAMS
142 #define PARAMS(args...) args
143 #endif
144
145 #define lttng_kernel_static_type_integer(_size, _alignment, _signedness, _byte_order, _base) \
146 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_integer, { \
147 .parent = { \
148 .type = lttng_kernel_type_integer, \
149 }, \
150 .size = (_size), \
151 .alignment = (_alignment), \
152 .signedness = (_signedness), \
153 .reverse_byte_order = (_byte_order) != __BYTE_ORDER, \
154 .base = (_base), \
155 }))
156
157 #define lttng_kernel_static_type_integer_from_type(_type, _byte_order, _base) \
158 lttng_kernel_static_type_integer(sizeof(_type) * CHAR_BIT, \
159 lttng_alignof(_type) * CHAR_BIT, \
160 lttng_is_signed_type(_type), \
161 _byte_order, \
162 _base)
163
164 #define lttng_kernel_static_type_enum(_desc, _container_type) \
165 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_enum, { \
166 .parent = { \
167 .type = lttng_kernel_type_enum, \
168 }, \
169 .desc = (_desc), \
170 .container_type = (_container_type), \
171 }))
172
173 #define lttng_kernel_static_type_array(_length, _elem_type, _alignment, _encoding) \
174 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_array, { \
175 .parent = { \
176 .type = lttng_kernel_type_array, \
177 }, \
178 .length = (_length), \
179 .alignment = (_alignment), \
180 .encoding = lttng_kernel_string_encoding_##_encoding, \
181 .elem_type = (_elem_type), \
182 }))
183
184 #define lttng_kernel_static_type_array_text(_length) \
185 lttng_kernel_static_type_array(_length, \
186 lttng_kernel_static_type_integer(sizeof(char) * CHAR_BIT, \
187 lttng_alignof(char) * CHAR_BIT, lttng_is_signed_type(char), \
188 __BYTE_ORDER, 10), \
189 0, UTF8)
190
191 #define lttng_kernel_static_type_sequence(_length_name, _elem_type, _alignment, _encoding) \
192 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_sequence, { \
193 .parent = { \
194 .type = lttng_kernel_type_sequence, \
195 }, \
196 .length_name = (_length_name), \
197 .alignment = (_alignment), \
198 .encoding = lttng_kernel_string_encoding_##_encoding, \
199 .elem_type = (_elem_type), \
200 }))
201
202 #define lttng_kernel_static_type_string(_encoding) \
203 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_string, { \
204 .parent = { \
205 .type = lttng_kernel_type_string, \
206 }, \
207 .encoding = lttng_kernel_string_encoding_##_encoding, \
208 }))
209
210 #define lttng_kernel_static_type_struct_init(_nr_fields, _fields, _alignment) \
211 { \
212 .parent = { \
213 .type = lttng_kernel_type_struct, \
214 }, \
215 .nr_fields = (_nr_fields), \
216 .fields = _fields, \
217 .alignment = (_alignment), \
218 }
219
220 #define lttng_kernel_static_type_struct(_nr_fields, _fields, _alignment) \
221 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_struct, \
222 lttng_kernel_static_type_struct_init(_nr_fields, PARAMS(_fields), _alignment) \
223 ))
224
225 #define lttng_kernel_static_type_variant(_nr_choices, _choices, _tag_name, _alignment) \
226 ((const struct lttng_kernel_type_common *) __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_type_variant, { \
227 .parent = { \
228 .type = lttng_kernel_type_variant, \
229 }, \
230 .tag_name = (_tag_name), \
231 .choices = _choices, \
232 .nr_choices = (_nr_choices), \
233 .alignment = (_alignment), \
234 }))
235
236 #define lttng_kernel_static_event_field(_name, _type, _nowrite, _user, _nofilter) \
237 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field, { \
238 .name = (_name), \
239 .type = (_type), \
240 .nowrite = (_nowrite), \
241 .user = (_user), \
242 .nofilter = (_nofilter), \
243 })
244
245 #define lttng_kernel_static_event_field_array(_fields...) \
246 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_event_field *, \
247 _fields \
248 )
249
250 #define lttng_kernel_static_enum_entry_value(_string, _value) \
251 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
252 .start = { \
253 .signedness = lttng_is_signed_type(__typeof__(_value)), \
254 .value = lttng_is_signed_type(__typeof__(_value)) ? \
255 (long long) (_value) : (_value), \
256 }, \
257 .end = { \
258 .signedness = lttng_is_signed_type(__typeof__(_value)), \
259 .value = lttng_is_signed_type(__typeof__(_value)) ? \
260 (long long) (_value) : (_value), \
261 }, \
262 .string = (_string), \
263 }),
264
265 #define lttng_kernel_static_enum_entry_range(_string, _range_start, _range_end) \
266 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
267 .start = { \
268 .signedness = lttng_is_signed_type(__typeof__(_range_start)), \
269 .value = lttng_is_signed_type(__typeof__(_range_start)) ? \
270 (long long) (_range_start) : (_range_start), \
271 }, \
272 .end = { \
273 .signedness = lttng_is_signed_type(__typeof__(_range_end)), \
274 .value = lttng_is_signed_type(__typeof__(_range_end)) ? \
275 (long long) (_range_end) : (_range_end), \
276 }, \
277 .string = (_string), \
278 }),
279
280 #define lttng_kernel_static_enum_entry_auto(_string) \
281 __LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_enum_entry, { \
282 .start = { \
283 .signedness = -1, \
284 .value = -1, \
285 }, \
286 .end = { \
287 .signedness = -1, \
288 .value = -1, \
289 }, \
290 .string = (_string), \
291 .options = { \
292 .is_auto = 1, \
293 } \
294 }),
295
296 struct lttng_kernel_probe_ctx {
297 struct lttng_kernel_event_common *event;
298 uint8_t interruptible;
299 };
300
301 struct lttng_kernel_tracepoint_class {
302 void (*probe_callback)(void);
303 const struct lttng_kernel_event_field * const *fields; /* event payload */
304 unsigned int nr_fields;
305 const struct lttng_kernel_probe_desc *probe_desc;
306 };
307
308 struct lttng_kernel_event_desc {
309 const char *event_name; /* lttng-modules name */
310 const char *event_kname; /* Linux kernel name (tracepoints) */
311 const struct lttng_kernel_probe_desc *probe_desc;
312 const struct lttng_kernel_tracepoint_class *tp_class;
313 struct module *owner;
314 };
315
316 struct lttng_kernel_probe_desc {
317 const char *provider_name;
318 const struct lttng_kernel_event_desc * const *event_desc;
319 unsigned int nr_events;
320 struct list_head head; /* chain registered probes */
321 struct list_head lazy_init_head;
322 int lazy; /* lazy registration */
323 };
324
325 /*
326 * Result of the run_filter() callback.
327 */
328 enum lttng_kernel_event_filter_result {
329 LTTNG_KERNEL_EVENT_FILTER_ACCEPT = 0,
330 LTTNG_KERNEL_EVENT_FILTER_REJECT = 1,
331 };
332
333 struct lttng_kernel_event_common_private;
334
335 enum lttng_kernel_event_type {
336 LTTNG_KERNEL_EVENT_TYPE_RECORDER = 0,
337 LTTNG_KERNEL_EVENT_TYPE_NOTIFIER = 1,
338 };
339
340 struct lttng_kernel_event_common {
341 struct lttng_kernel_event_common_private *priv; /* Private event interface */
342
343 enum lttng_kernel_event_type type;
344 /* Get child with container_of(). */
345
346 int enabled;
347 int eval_filter; /* Need to evaluate filters */
348 int (*run_filter)(const struct lttng_kernel_event_common *event,
349 const char *stack_data,
350 struct lttng_kernel_probe_ctx *probe_ctx,
351 void *filter_ctx);
352 };
353
354 struct lttng_kernel_event_recorder_private;
355
356 struct lttng_kernel_event_recorder {
357 struct lttng_kernel_event_common parent;
358 struct lttng_kernel_event_recorder_private *priv; /* Private event record interface */
359
360 struct lttng_kernel_channel_buffer *chan;
361 };
362
363 struct lttng_kernel_notification_ctx {
364 int eval_capture; /* Capture evaluation available. */
365 };
366
367 struct lttng_kernel_event_notifier_private;
368
369 struct lttng_kernel_event_notifier {
370 struct lttng_kernel_event_common parent;
371 struct lttng_kernel_event_notifier_private *priv; /* Private event notifier interface */
372
373 int eval_capture; /* Need to evaluate capture */
374 void (*notification_send)(struct lttng_kernel_event_notifier *event_notifier,
375 const char *stack_data,
376 struct lttng_kernel_probe_ctx *probe_ctx,
377 struct lttng_kernel_notification_ctx *notif_ctx);
378 };
379
380 struct lttng_kernel_channel_buffer_ops {
381 struct lttng_kernel_channel_buffer_ops_private *priv; /* Private channel buffer ops interface. */
382
383 int (*event_reserve)(struct lttng_kernel_ring_buffer_ctx *ctx);
384 void (*event_commit)(struct lttng_kernel_ring_buffer_ctx *ctx);
385 void (*event_write)(struct lttng_kernel_ring_buffer_ctx *ctx, const void *src,
386 size_t len);
387 void (*event_write_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
388 const void *src, size_t len);
389 void (*event_memset)(struct lttng_kernel_ring_buffer_ctx *ctx,
390 int c, size_t len);
391 void (*event_strcpy)(struct lttng_kernel_ring_buffer_ctx *ctx, const char *src,
392 size_t len);
393 void (*event_strcpy_from_user)(struct lttng_kernel_ring_buffer_ctx *ctx,
394 const char __user *src, size_t len);
395 void (*lost_event_too_big)(struct lttng_kernel_channel_buffer *lttng_channel);
396 };
397
398 enum lttng_kernel_channel_type {
399 LTTNG_KERNEL_CHANNEL_TYPE_BUFFER = 0,
400 };
401
402 struct lttng_kernel_channel_common_private;
403
404 /* Use container_of() to get child. */
405 struct lttng_kernel_channel_common {
406 struct lttng_kernel_channel_common_private *priv; /* Private channel interface. */
407
408 enum lttng_kernel_channel_type type;
409
410 int enabled;
411 struct lttng_kernel_session *session;
412 };
413
414 struct lttng_kernel_channel_buffer_private;
415
416 struct lttng_kernel_channel_buffer {
417 struct lttng_kernel_channel_common parent;
418 struct lttng_kernel_channel_buffer_private *priv;
419
420 struct lttng_kernel_channel_buffer_ops *ops;
421 };
422
423 #define LTTNG_DYNAMIC_LEN_STACK_SIZE 128
424
425 struct lttng_dynamic_len_stack {
426 size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE];
427 size_t offset;
428 };
429
430 DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);
431
432 /*
433 * struct lttng_kernel_id_tracker declared in header due to deferencing of *v
434 * in RCU_INITIALIZER(v).
435 */
436 #define LTTNG_ID_HASH_BITS 6
437 #define LTTNG_ID_TABLE_SIZE (1 << LTTNG_ID_HASH_BITS)
438
439 struct lttng_kernel_id_tracker_rcu {
440 struct hlist_head id_hash[LTTNG_ID_TABLE_SIZE];
441 };
442
443 struct lttng_kernel_id_tracker {
444 struct lttng_kernel_id_tracker_private *priv; /* Private API */
445
446 struct lttng_kernel_id_tracker_rcu *p; /* RCU dereferenced. */
447 };
448
449 struct lttng_kernel_session_private;
450
451 struct lttng_kernel_session {
452 struct lttng_kernel_session_private *priv; /* Private session interface */
453
454 int active; /* Is trace session active ? */
455
456 struct lttng_kernel_id_tracker pid_tracker;
457 struct lttng_kernel_id_tracker vpid_tracker;
458 struct lttng_kernel_id_tracker uid_tracker;
459 struct lttng_kernel_id_tracker vuid_tracker;
460 struct lttng_kernel_id_tracker gid_tracker;
461 struct lttng_kernel_id_tracker vgid_tracker;
462 };
463
464 int lttng_kernel_probe_register(struct lttng_kernel_probe_desc *desc);
465 void lttng_kernel_probe_unregister(struct lttng_kernel_probe_desc *desc);
466
467 bool lttng_id_tracker_lookup(struct lttng_kernel_id_tracker_rcu *p, int id);
468
469 #endif /* _LTTNG_EVENTS_H */
LTTng 2.0/0.x modules
This page took 0.03738 seconds and 3 git commands to generate.