projects / deliverable / lttng-modules.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
uprobe: Receive file descriptor from session instead of path to file
[deliverable/lttng-modules.git] / lttng-events.h
... / ...
CommitLineData
1/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
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 <linux/version.h>
14#include <linux/list.h>
15#include <linux/kprobes.h>
16#include <linux/kref.h>
17#include <lttng-cpuhotplug.h>
18#include <wrapper/uuid.h>
19#include <wrapper/uprobes.h>
20#include <lttng-tracer.h>
21#include <lttng-abi.h>
22#include <lttng-abi-old.h>
23
24#define lttng_is_signed_type(type) (((type)(-1)) < 0)
25
26struct lttng_channel;
27struct lttng_session;
28struct lttng_metadata_cache;
29struct lib_ring_buffer_ctx;
30struct perf_event;
31struct perf_event_attr;
32struct lib_ring_buffer_config;
33
34/* Type description */
35
36enum abstract_types {
37 atype_integer,
38 atype_enum,
39 atype_array,
40 atype_sequence,
41 atype_string,
42 atype_struct,
43 atype_array_compound, /* Array of compound types. */
44 atype_sequence_compound, /* Sequence of compound types. */
45 atype_variant,
46 atype_array_bitfield,
47 atype_sequence_bitfield,
48 NR_ABSTRACT_TYPES,
49};
50
51enum lttng_string_encodings {
52 lttng_encode_none = 0,
53 lttng_encode_UTF8 = 1,
54 lttng_encode_ASCII = 2,
55 NR_STRING_ENCODINGS,
56};
57
58enum channel_type {
59 PER_CPU_CHANNEL,
60 METADATA_CHANNEL,
61};
62
63struct lttng_enum_value {
64 unsigned long long value;
65 unsigned int signedness:1;
66};
67
68struct lttng_enum_entry {
69 struct lttng_enum_value start, end; /* start and end are inclusive */
70 const char *string;
71 struct {
72 unsigned int is_auto:1;
73 } options;
74};
75
76#define __type_integer(_type, _size, _alignment, _signedness, \
77 _byte_order, _base, _encoding) \
78 { \
79 .atype = atype_integer, \
80 .u.basic.integer = \
81 { \
82 .size = (_size) ? : sizeof(_type) * CHAR_BIT, \
83 .alignment = (_alignment) ? : lttng_alignof(_type) * CHAR_BIT, \
84 .signedness = (_signedness) >= 0 ? (_signedness) : lttng_is_signed_type(_type), \
85 .reverse_byte_order = _byte_order != __BYTE_ORDER, \
86 .base = _base, \
87 .encoding = lttng_encode_##_encoding, \
88 }, \
89 } \
90
91struct lttng_integer_type {
92 unsigned int size; /* in bits */
93 unsigned short alignment; /* in bits */
94 unsigned int signedness:1,
95 reverse_byte_order:1;
96 unsigned int base; /* 2, 8, 10, 16, for pretty print */
97 enum lttng_string_encodings encoding;
98};
99
100union _lttng_basic_type {
101 struct lttng_integer_type integer;
102 struct {
103 const struct lttng_enum_desc *desc; /* Enumeration mapping */
104 struct lttng_integer_type container_type;
105 } enumeration;
106 struct {
107 enum lttng_string_encodings encoding;
108 } string;
109};
110
111struct lttng_basic_type {
112 enum abstract_types atype;
113 union {
114 union _lttng_basic_type basic;
115 } u;
116};
117
118struct lttng_type {
119 enum abstract_types atype;
120 union {
121 union _lttng_basic_type basic;
122 struct {
123 struct lttng_basic_type elem_type;
124 unsigned int length; /* num. elems. */
125 unsigned int elem_alignment; /* alignment override */
126 } array;
127 struct {
128 struct lttng_basic_type length_type;
129 struct lttng_basic_type elem_type;
130 unsigned int elem_alignment; /* alignment override */
131 } sequence;
132 struct {
133 uint32_t nr_fields;
134 struct lttng_event_field *fields; /* Array of fields. */
135 } _struct;
136 struct {
137 struct lttng_type *elem_type;
138 unsigned int length; /* num. elems. */
139 } array_compound;
140 struct {
141 struct lttng_type *elem_type;
142 const char *length_name;
143 } sequence_compound;
144 struct {
145 const char *tag_name;
146 struct lttng_event_field *choices; /* Array of fields. */
147 uint32_t nr_choices;
148 } variant;
149 } u;
150};
151
152struct lttng_enum_desc {
153 const char *name;
154 const struct lttng_enum_entry *entries;
155 unsigned int nr_entries;
156};
157
158/* Event field description */
159
160struct lttng_event_field {
161 const char *name;
162 struct lttng_type type;
163 unsigned int nowrite:1, /* do not write into trace */
164 user:1; /* fetch from user-space */
165};
166
167union lttng_ctx_value {
168 int64_t s64;
169 const char *str;
170 double d;
171};
172
173/*
174 * We need to keep this perf counter field separately from struct
175 * lttng_ctx_field because cpu hotplug needs fixed-location addresses.
176 */
177struct lttng_perf_counter_field {
178#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
179 struct lttng_cpuhp_node cpuhp_prepare;
180 struct lttng_cpuhp_node cpuhp_online;
181#else
182 struct notifier_block nb;
183 int hp_enable;
184#endif
185 struct perf_event_attr *attr;
186 struct perf_event **e; /* per-cpu array */
187};
188
189struct lttng_probe_ctx {
190 struct lttng_event *event;
191 uint8_t interruptible;
192};
193
194struct lttng_ctx_field {
195 struct lttng_event_field event_field;
196 size_t (*get_size)(size_t offset);
197 size_t (*get_size_arg)(size_t offset, struct lttng_ctx_field *field,
198 struct lib_ring_buffer_ctx *ctx,
199 struct lttng_channel *chan);
200 void (*record)(struct lttng_ctx_field *field,
201 struct lib_ring_buffer_ctx *ctx,
202 struct lttng_channel *chan);
203 void (*get_value)(struct lttng_ctx_field *field,
204 struct lttng_probe_ctx *lttng_probe_ctx,
205 union lttng_ctx_value *value);
206 union {
207 struct lttng_perf_counter_field *perf_counter;
208 } u;
209 void (*destroy)(struct lttng_ctx_field *field);
210 /*
211 * Private data to keep state between get_size and record.
212 * User must perform its own synchronization to protect against
213 * concurrent and reentrant contexts.
214 */
215 void *priv;
216};
217
218struct lttng_ctx {
219 struct lttng_ctx_field *fields;
220 unsigned int nr_fields;
221 unsigned int allocated_fields;
222 size_t largest_align; /* in bytes */
223};
224
225struct lttng_event_desc {
226 const char *name; /* lttng-modules name */
227 const char *kname; /* Linux kernel name (tracepoints) */
228 void *probe_callback;
229 const struct lttng_event_ctx *ctx; /* context */
230 const struct lttng_event_field *fields; /* event payload */
231 unsigned int nr_fields;
232 struct module *owner;
233};
234
235struct lttng_probe_desc {
236 const char *provider;
237 const struct lttng_event_desc **event_desc;
238 unsigned int nr_events;
239 struct list_head head; /* chain registered probes */
240 struct list_head lazy_init_head;
241 int lazy; /* lazy registration */
242};
243
244struct lttng_krp; /* Kretprobe handling */
245
246enum lttng_event_type {
247 LTTNG_TYPE_EVENT = 0,
248 LTTNG_TYPE_ENABLER = 1,
249};
250
251struct lttng_filter_bytecode_node {
252 struct list_head node;
253 struct lttng_enabler *enabler;
254 /*
255 * struct lttng_kernel_filter_bytecode has var. sized array, must be
256 * last field.
257 */
258 struct lttng_kernel_filter_bytecode bc;
259};
260
261/*
262 * Filter return value masks.
263 */
264enum lttng_filter_ret {
265 LTTNG_FILTER_DISCARD = 0,
266 LTTNG_FILTER_RECORD_FLAG = (1ULL << 0),
267 /* Other bits are kept for future use. */
268};
269
270struct lttng_bytecode_runtime {
271 /* Associated bytecode */
272 struct lttng_filter_bytecode_node *bc;
273 uint64_t (*filter)(void *filter_data, struct lttng_probe_ctx *lttng_probe_ctx,
274 const char *filter_stack_data);
275 int link_failed;
276 struct list_head node; /* list of bytecode runtime in event */
277 struct lttng_event *event;
278};
279
280/*
281 * Objects in a linked-list of enablers, owned by an event.
282 */
283struct lttng_enabler_ref {
284 struct list_head node; /* enabler ref list */
285 struct lttng_enabler *ref; /* backward ref */
286};
287
288/*
289 * lttng_event structure is referred to by the tracing fast path. It must be
290 * kept small.
291 */
292struct lttng_event {
293 enum lttng_event_type evtype; /* First field. */
294 unsigned int id;
295 struct lttng_channel *chan;
296 int enabled;
297 const struct lttng_event_desc *desc;
298 void *filter;
299 struct lttng_ctx *ctx;
300 enum lttng_kernel_instrumentation instrumentation;
301 union {
302 struct {
303 struct kprobe kp;
304 char *symbol_name;
305 } kprobe;
306 struct {
307 struct lttng_krp *lttng_krp;
308 char *symbol_name;
309 } kretprobe;
310 struct {
311 char *symbol_name;
312 } ftrace;
313 struct {
314 struct uprobe_consumer up_consumer;
315 struct inode *inode;
316 loff_t offset;
317 } uprobe;
318 } u;
319 struct list_head list; /* Event list in session */
320 unsigned int metadata_dumped:1;
321
322 /* Backward references: list of lttng_enabler_ref (ref to enablers) */
323 struct list_head enablers_ref_head;
324 struct hlist_node hlist; /* session ht of events */
325 int registered; /* has reg'd tracepoint probe */
326 /* list of struct lttng_bytecode_runtime, sorted by seqnum */
327 struct list_head bytecode_runtime_head;
328 int has_enablers_without_bytecode;
329};
330
331enum lttng_enabler_type {
332 LTTNG_ENABLER_STAR_GLOB,
333 LTTNG_ENABLER_NAME,
334};
335
336/*
337 * Enabler field, within whatever object is enabling an event. Target of
338 * backward reference.
339 */
340struct lttng_enabler {
341 enum lttng_event_type evtype; /* First field. */
342
343 enum lttng_enabler_type type;
344
345 struct list_head node; /* per-session list of enablers */
346 /* head list of struct lttng_ust_filter_bytecode_node */
347 struct list_head filter_bytecode_head;
348
349 struct lttng_kernel_event event_param;
350 struct lttng_channel *chan;
351 struct lttng_ctx *ctx;
352 unsigned int enabled:1;
353};
354
355struct lttng_channel_ops {
356 struct channel *(*channel_create)(const char *name,
357 struct lttng_channel *lttng_chan,
358 void *buf_addr,
359 size_t subbuf_size, size_t num_subbuf,
360 unsigned int switch_timer_interval,
361 unsigned int read_timer_interval);
362 void (*channel_destroy)(struct channel *chan);
363 struct lib_ring_buffer *(*buffer_read_open)(struct channel *chan);
364 int (*buffer_has_read_closed_stream)(struct channel *chan);
365 void (*buffer_read_close)(struct lib_ring_buffer *buf);
366 int (*event_reserve)(struct lib_ring_buffer_ctx *ctx,
367 uint32_t event_id);
368 void (*event_commit)(struct lib_ring_buffer_ctx *ctx);
369 void (*event_write)(struct lib_ring_buffer_ctx *ctx, const void *src,
370 size_t len);
371 void (*event_write_from_user)(struct lib_ring_buffer_ctx *ctx,
372 const void *src, size_t len);
373 void (*event_memset)(struct lib_ring_buffer_ctx *ctx,
374 int c, size_t len);
375 void (*event_strcpy)(struct lib_ring_buffer_ctx *ctx, const char *src,
376 size_t len);
377 void (*event_strcpy_from_user)(struct lib_ring_buffer_ctx *ctx,
378 const char __user *src, size_t len);
379 /*
380 * packet_avail_size returns the available size in the current
381 * packet. Note that the size returned is only a hint, since it
382 * may change due to concurrent writes.
383 */
384 size_t (*packet_avail_size)(struct channel *chan);
385 wait_queue_head_t *(*get_writer_buf_wait_queue)(struct channel *chan, int cpu);
386 wait_queue_head_t *(*get_hp_wait_queue)(struct channel *chan);
387 int (*is_finalized)(struct channel *chan);
388 int (*is_disabled)(struct channel *chan);
389 int (*timestamp_begin) (const struct lib_ring_buffer_config *config,
390 struct lib_ring_buffer *bufb,
391 uint64_t *timestamp_begin);
392 int (*timestamp_end) (const struct lib_ring_buffer_config *config,
393 struct lib_ring_buffer *bufb,
394 uint64_t *timestamp_end);
395 int (*events_discarded) (const struct lib_ring_buffer_config *config,
396 struct lib_ring_buffer *bufb,
397 uint64_t *events_discarded);
398 int (*content_size) (const struct lib_ring_buffer_config *config,
399 struct lib_ring_buffer *bufb,
400 uint64_t *content_size);
401 int (*packet_size) (const struct lib_ring_buffer_config *config,
402 struct lib_ring_buffer *bufb,
403 uint64_t *packet_size);
404 int (*stream_id) (const struct lib_ring_buffer_config *config,
405 struct lib_ring_buffer *bufb,
406 uint64_t *stream_id);
407 int (*current_timestamp) (const struct lib_ring_buffer_config *config,
408 struct lib_ring_buffer *bufb,
409 uint64_t *ts);
410 int (*sequence_number) (const struct lib_ring_buffer_config *config,
411 struct lib_ring_buffer *bufb,
412 uint64_t *seq);
413 int (*instance_id) (const struct lib_ring_buffer_config *config,
414 struct lib_ring_buffer *bufb,
415 uint64_t *id);
416};
417
418struct lttng_transport {
419 char *name;
420 struct module *owner;
421 struct list_head node;
422 struct lttng_channel_ops ops;
423};
424
425struct lttng_syscall_filter;
426
427#define LTTNG_EVENT_HT_BITS 12
428#define LTTNG_EVENT_HT_SIZE (1U << LTTNG_EVENT_HT_BITS)
429
430struct lttng_event_ht {
431 struct hlist_head table[LTTNG_EVENT_HT_SIZE];
432};
433
434struct lttng_channel {
435 unsigned int id;
436 struct channel *chan; /* Channel buffers */
437 int enabled;
438 struct lttng_ctx *ctx;
439 /* Event ID management */
440 struct lttng_session *session;
441 struct file *file; /* File associated to channel */
442 unsigned int free_event_id; /* Next event ID to allocate */
443 struct list_head list; /* Channel list */
444 struct lttng_channel_ops *ops;
445 struct lttng_transport *transport;
446 struct lttng_event **sc_table; /* for syscall tracing */
447 struct lttng_event **compat_sc_table;
448 struct lttng_event **sc_exit_table; /* for syscall exit tracing */
449 struct lttng_event **compat_sc_exit_table;
450 struct lttng_event *sc_unknown; /* for unknown syscalls */
451 struct lttng_event *sc_compat_unknown;
452 struct lttng_event *sc_exit_unknown;
453 struct lttng_event *compat_sc_exit_unknown;
454 struct lttng_syscall_filter *sc_filter;
455 int header_type; /* 0: unset, 1: compact, 2: large */
456 enum channel_type channel_type;
457 unsigned int metadata_dumped:1,
458 sys_enter_registered:1,
459 sys_exit_registered:1,
460 syscall_all:1,
461 tstate:1; /* Transient enable state */
462};
463
464struct lttng_metadata_stream {
465 void *priv; /* Ring buffer private data */
466 struct lttng_metadata_cache *metadata_cache;
467 unsigned int metadata_in; /* Bytes read from the cache */
468 unsigned int metadata_out; /* Bytes consumed from stream */
469 int finalized; /* Has channel been finalized */
470 wait_queue_head_t read_wait; /* Reader buffer-level wait queue */
471 struct list_head list; /* Stream list */
472 struct lttng_transport *transport;
473 uint64_t version; /* Current version of the metadata cache */
474};
475
476#define LTTNG_DYNAMIC_LEN_STACK_SIZE 128
477
478struct lttng_dynamic_len_stack {
479 size_t stack[LTTNG_DYNAMIC_LEN_STACK_SIZE];
480 size_t offset;
481};
482
483DECLARE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);
484
485/*
486 * struct lttng_pid_tracker declared in header due to deferencing of *v
487 * in RCU_INITIALIZER(v).
488 */
489#define LTTNG_PID_HASH_BITS 6
490#define LTTNG_PID_TABLE_SIZE (1 << LTTNG_PID_HASH_BITS)
491
492struct lttng_pid_tracker {
493 struct hlist_head pid_hash[LTTNG_PID_TABLE_SIZE];
494};
495
496struct lttng_pid_hash_node {
497 struct hlist_node hlist;
498 int pid;
499};
500
501struct lttng_session {
502 int active; /* Is trace session active ? */
503 int been_active; /* Has trace session been active ? */
504 struct file *file; /* File associated to session */
505 struct list_head chan; /* Channel list head */
506 struct list_head events; /* Event list head */
507 struct list_head list; /* Session list */
508 unsigned int free_chan_id; /* Next chan ID to allocate */
509 uuid_le uuid; /* Trace session unique ID */
510 struct lttng_metadata_cache *metadata_cache;
511 struct lttng_pid_tracker *pid_tracker;
512 unsigned int metadata_dumped:1,
513 tstate:1; /* Transient enable state */
514 /* List of enablers */
515 struct list_head enablers_head;
516 /* Hash table of events */
517 struct lttng_event_ht events_ht;
518};
519
520struct lttng_metadata_cache {
521 char *data; /* Metadata cache */
522 unsigned int cache_alloc; /* Metadata allocated size (bytes) */
523 unsigned int metadata_written; /* Number of bytes written in metadata cache */
524 struct kref refcount; /* Metadata cache usage */
525 struct list_head metadata_stream; /* Metadata stream list */
526 uuid_le uuid; /* Trace session unique ID (copy) */
527 struct mutex lock; /* Produce/consume lock */
528 uint64_t version; /* Current version of the metadata */
529};
530
531void lttng_lock_sessions(void);
532void lttng_unlock_sessions(void);
533
534struct list_head *lttng_get_probe_list_head(void);
535
536struct lttng_enabler *lttng_enabler_create(enum lttng_enabler_type type,
537 struct lttng_kernel_event *event_param,
538 struct lttng_channel *chan);
539
540int lttng_enabler_enable(struct lttng_enabler *enabler);
541int lttng_enabler_disable(struct lttng_enabler *enabler);
542int lttng_fix_pending_events(void);
543int lttng_session_active(void);
544
545struct lttng_session *lttng_session_create(void);
546int lttng_session_enable(struct lttng_session *session);
547int lttng_session_disable(struct lttng_session *session);
548void lttng_session_destroy(struct lttng_session *session);
549int lttng_session_metadata_regenerate(struct lttng_session *session);
550int lttng_session_statedump(struct lttng_session *session);
551void metadata_cache_destroy(struct kref *kref);
552
553struct lttng_channel *lttng_channel_create(struct lttng_session *session,
554 const char *transport_name,
555 void *buf_addr,
556 size_t subbuf_size, size_t num_subbuf,
557 unsigned int switch_timer_interval,
558 unsigned int read_timer_interval,
559 enum channel_type channel_type);
560struct lttng_channel *lttng_global_channel_create(struct lttng_session *session,
561 int overwrite, 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
566void lttng_metadata_channel_destroy(struct lttng_channel *chan);
567struct lttng_event *lttng_event_create(struct lttng_channel *chan,
568 struct lttng_kernel_event *event_param,
569 void *filter,
570 const struct lttng_event_desc *event_desc,
571 enum lttng_kernel_instrumentation itype);
572struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
573 struct lttng_kernel_event *event_param,
574 void *filter,
575 const struct lttng_event_desc *event_desc,
576 enum lttng_kernel_instrumentation itype);
577struct lttng_event *lttng_event_compat_old_create(struct lttng_channel *chan,
578 struct lttng_kernel_old_event *old_event_param,
579 void *filter,
580 const struct lttng_event_desc *internal_desc);
581
582int lttng_channel_enable(struct lttng_channel *channel);
583int lttng_channel_disable(struct lttng_channel *channel);
584int lttng_event_enable(struct lttng_event *event);
585int lttng_event_disable(struct lttng_event *event);
586
587void lttng_transport_register(struct lttng_transport *transport);
588void lttng_transport_unregister(struct lttng_transport *transport);
589
590void synchronize_trace(void);
591int lttng_abi_init(void);
592int lttng_abi_compat_old_init(void);
593void lttng_abi_exit(void);
594void lttng_abi_compat_old_exit(void);
595
596int lttng_probe_register(struct lttng_probe_desc *desc);
597void lttng_probe_unregister(struct lttng_probe_desc *desc);
598const struct lttng_event_desc *lttng_event_get(const char *name);
599void lttng_event_put(const struct lttng_event_desc *desc);
600int lttng_probes_init(void);
601void lttng_probes_exit(void);
602
603int lttng_metadata_output_channel(struct lttng_metadata_stream *stream,
604 struct channel *chan);
605
606int lttng_pid_tracker_get_node_pid(const struct lttng_pid_hash_node *node);
607struct lttng_pid_tracker *lttng_pid_tracker_create(void);
608void lttng_pid_tracker_destroy(struct lttng_pid_tracker *lpf);
609bool lttng_pid_tracker_lookup(struct lttng_pid_tracker *lpf, int pid);
610int lttng_pid_tracker_add(struct lttng_pid_tracker *lpf, int pid);
611int lttng_pid_tracker_del(struct lttng_pid_tracker *lpf, int pid);
612
613int lttng_session_track_pid(struct lttng_session *session, int pid);
614int lttng_session_untrack_pid(struct lttng_session *session, int pid);
615
616int lttng_session_list_tracker_pids(struct lttng_session *session);
617
618void lttng_clock_ref(void);
619void lttng_clock_unref(void);
620
621#if defined(CONFIG_HAVE_SYSCALL_TRACEPOINTS)
622int lttng_syscalls_register(struct lttng_channel *chan, void *filter);
623int lttng_syscalls_unregister(struct lttng_channel *chan);
624int lttng_syscall_filter_enable(struct lttng_channel *chan,
625 const char *name);
626int lttng_syscall_filter_disable(struct lttng_channel *chan,
627 const char *name);
628long lttng_channel_syscall_mask(struct lttng_channel *channel,
629 struct lttng_kernel_syscall_mask __user *usyscall_mask);
630#else
631static inline int lttng_syscalls_register(struct lttng_channel *chan, void *filter)
632{
633 return -ENOSYS;
634}
635
636static inline int lttng_syscalls_unregister(struct lttng_channel *chan)
637{
638 return 0;
639}
640
641static inline int lttng_syscall_filter_enable(struct lttng_channel *chan,
642 const char *name)
643{
644 return -ENOSYS;
645}
646
647static inline int lttng_syscall_filter_disable(struct lttng_channel *chan,
648 const char *name)
649{
650 return -ENOSYS;
651}
652
653static inline long lttng_channel_syscall_mask(struct lttng_channel *channel,
654 struct lttng_kernel_syscall_mask __user *usyscall_mask)
655{
656 return -ENOSYS;
657}
658#endif
659
660void lttng_filter_sync_state(struct lttng_bytecode_runtime *runtime);
661int lttng_enabler_attach_bytecode(struct lttng_enabler *enabler,
662 struct lttng_kernel_filter_bytecode __user *bytecode);
663void lttng_enabler_event_link_bytecode(struct lttng_event *event,
664 struct lttng_enabler *enabler);
665
666int lttng_probes_init(void);
667
668extern struct lttng_ctx *lttng_static_ctx;
669
670int lttng_context_init(void);
671void lttng_context_exit(void);
672struct lttng_ctx_field *lttng_append_context(struct lttng_ctx **ctx);
673void lttng_context_update(struct lttng_ctx *ctx);
674int lttng_find_context(struct lttng_ctx *ctx, const char *name);
675int lttng_get_context_index(struct lttng_ctx *ctx, const char *name);
676void lttng_remove_context_field(struct lttng_ctx **ctx,
677 struct lttng_ctx_field *field);
678void lttng_destroy_context(struct lttng_ctx *ctx);
679int lttng_add_pid_to_ctx(struct lttng_ctx **ctx);
680int lttng_add_cpu_id_to_ctx(struct lttng_ctx **ctx);
681int lttng_add_procname_to_ctx(struct lttng_ctx **ctx);
682int lttng_add_prio_to_ctx(struct lttng_ctx **ctx);
683int lttng_add_nice_to_ctx(struct lttng_ctx **ctx);
684int lttng_add_vpid_to_ctx(struct lttng_ctx **ctx);
685int lttng_add_tid_to_ctx(struct lttng_ctx **ctx);
686int lttng_add_vtid_to_ctx(struct lttng_ctx **ctx);
687int lttng_add_ppid_to_ctx(struct lttng_ctx **ctx);
688int lttng_add_vppid_to_ctx(struct lttng_ctx **ctx);
689int lttng_add_hostname_to_ctx(struct lttng_ctx **ctx);
690int lttng_add_interruptible_to_ctx(struct lttng_ctx **ctx);
691int lttng_add_need_reschedule_to_ctx(struct lttng_ctx **ctx);
692#if defined(CONFIG_PREEMPT_RT_FULL) || defined(CONFIG_PREEMPT)
693int lttng_add_preemptible_to_ctx(struct lttng_ctx **ctx);
694#else
695static inline
696int lttng_add_preemptible_to_ctx(struct lttng_ctx **ctx)
697{
698 return -ENOSYS;
699}
700#endif
701#ifdef CONFIG_PREEMPT_RT_FULL
702int lttng_add_migratable_to_ctx(struct lttng_ctx **ctx);
703#else
704static inline
705int lttng_add_migratable_to_ctx(struct lttng_ctx **ctx)
706{
707 return -ENOSYS;
708}
709#endif
710
711int lttng_add_callstack_to_ctx(struct lttng_ctx **ctx, int type);
712
713#if defined(CONFIG_PERF_EVENTS) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
714int lttng_add_perf_counter_to_ctx(uint32_t type,
715 uint64_t config,
716 const char *name,
717 struct lttng_ctx **ctx);
718int lttng_cpuhp_perf_counter_online(unsigned int cpu,
719 struct lttng_cpuhp_node *node);
720int lttng_cpuhp_perf_counter_dead(unsigned int cpu,
721 struct lttng_cpuhp_node *node);
722#else
723static inline
724int lttng_add_perf_counter_to_ctx(uint32_t type,
725 uint64_t config,
726 const char *name,
727 struct lttng_ctx **ctx)
728{
729 return -ENOSYS;
730}
731static inline
732int lttng_cpuhp_perf_counter_online(unsigned int cpu,
733 struct lttng_cpuhp_node *node)
734{
735 return 0;
736}
737static inline
738int lttng_cpuhp_perf_counter_dead(unsigned int cpu,
739 struct lttng_cpuhp_node *node)
740{
741 return 0;
742}
743#endif
744
745int lttng_logger_init(void);
746void lttng_logger_exit(void);
747
748extern int lttng_statedump_start(struct lttng_session *session);
749
750#ifdef CONFIG_KPROBES
751int lttng_kprobes_register(const char *name,
752 const char *symbol_name,
753 uint64_t offset,
754 uint64_t addr,
755 struct lttng_event *event);
756void lttng_kprobes_unregister(struct lttng_event *event);
757void lttng_kprobes_destroy_private(struct lttng_event *event);
758#else
759static inline
760int lttng_kprobes_register(const char *name,
761 const char *symbol_name,
762 uint64_t offset,
763 uint64_t addr,
764 struct lttng_event *event)
765{
766 return -ENOSYS;
767}
768
769static inline
770void lttng_kprobes_unregister(struct lttng_event *event)
771{
772}
773
774static inline
775void lttng_kprobes_destroy_private(struct lttng_event *event)
776{
777}
778#endif
779
780#ifdef CONFIG_UPROBES
781int lttng_uprobes_register(const char *name,
782 int fd,
783 uint64_t offset,
784 struct lttng_event *event);
785void lttng_uprobes_unregister(struct lttng_event *event);
786void lttng_uprobes_destroy_private(struct lttng_event *event);
787#else
788static inline
789int lttng_uprobes_register(const char *name,
790 int fd,
791 uint64_t offset,
792 struct lttng_event *event)
793{
794 return -ENOSYS;
795}
796
797static inline
798void lttng_uprobes_unregister(struct lttng_event *event)
799{
800}
801
802static inline
803void lttng_uprobes_destroy_private(struct lttng_event *event)
804{
805}
806#endif
807
808#ifdef CONFIG_KRETPROBES
809int lttng_kretprobes_register(const char *name,
810 const char *symbol_name,
811 uint64_t offset,
812 uint64_t addr,
813 struct lttng_event *event_entry,
814 struct lttng_event *event_exit);
815void lttng_kretprobes_unregister(struct lttng_event *event);
816void lttng_kretprobes_destroy_private(struct lttng_event *event);
817int lttng_kretprobes_event_enable_state(struct lttng_event *event,
818 int enable);
819#else
820static inline
821int lttng_kretprobes_register(const char *name,
822 const char *symbol_name,
823 uint64_t offset,
824 uint64_t addr,
825 struct lttng_event *event_entry,
826 struct lttng_event *event_exit)
827{
828 return -ENOSYS;
829}
830
831static inline
832void lttng_kretprobes_unregister(struct lttng_event *event)
833{
834}
835
836static inline
837void lttng_kretprobes_destroy_private(struct lttng_event *event)
838{
839}
840
841static inline
842int lttng_kretprobes_event_enable_state(struct lttng_event *event,
843 int enable)
844{
845 return -ENOSYS;
846}
847#endif
848
849#if defined(CONFIG_DYNAMIC_FTRACE) && !defined(LTTNG_FTRACE_MISSING_HEADER)
850int lttng_ftrace_register(const char *name,
851 const char *symbol_name,
852 struct lttng_event *event);
853void lttng_ftrace_unregister(struct lttng_event *event);
854void lttng_ftrace_destroy_private(struct lttng_event *event);
855#else
856static inline
857int lttng_ftrace_register(const char *name,
858 const char *symbol_name,
859 struct lttng_event *event)
860{
861 return -ENOSYS;
862}
863
864static inline
865void lttng_ftrace_unregister(struct lttng_event *event)
866{
867}
868
869static inline
870void lttng_ftrace_destroy_private(struct lttng_event *event)
871{
872}
873#endif
874
875int lttng_calibrate(struct lttng_kernel_calibrate *calibrate);
876
877extern const struct file_operations lttng_tracepoint_list_fops;
878extern const struct file_operations lttng_syscall_list_fops;
879
880#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
881#define TRACEPOINT_HAS_DATA_ARG
882#endif
883
884#endif /* _LTTNG_EVENTS_H */
LTTng modules - Deliverables
This page took 0.027622 seconds and 5 git commands to generate.