1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
3 * lttng-context-callstack.c
5 * LTTng callstack event context.
7 * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 * Copyright (C) 2014 Francis Giraldeau <francis.giraldeau@gmail.com>
10 * The callstack context can be added to any kernel event. It records
11 * either the kernel or the userspace callstack, up to a max depth. The
12 * context is a CTF sequence, such that it uses only the space required
13 * for the number of callstack entries.
15 * It allocates callstack buffers per-CPU up to 4 interrupt nesting.
16 * This nesting limit is the same as defined in the ring buffer. It
17 * therefore uses a fixed amount of memory, proportional to the number
20 * size = cpus * nest * depth * sizeof(unsigned long)
22 * Which is 4096 bytes per CPU on 64-bit host and a depth of 128.
23 * The allocation is done at the initialization to avoid memory
24 * allocation overhead while tracing, using a shallow stack.
26 * The kernel callstack is recovered using save_stack_trace(), and the
27 * userspace callstack uses save_stack_trace_user(). They rely on frame
28 * pointers. These are usually available for the kernel, but the
29 * compiler option -fomit-frame-pointer frequently used in popular Linux
30 * distributions may cause the userspace callstack to be unreliable, and
31 * is a known limitation of this approach. If frame pointers are not
32 * available, it produces no error, but the callstack will be empty. We
33 * still provide the feature, because it works well for runtime
34 * environments having frame pointers. In the future, unwind support
35 * and/or last branch record may provide a solution to this problem.
37 * The symbol name resolution is left to the trace reader.
40 #include <linux/module.h>
41 #include <linux/slab.h>
42 #include <linux/sched.h>
43 #include <linux/utsname.h>
44 #include <linux/stacktrace.h>
45 #include <linux/spinlock.h>
46 #include <ringbuffer/backend.h>
47 #include <ringbuffer/frontend.h>
48 #include <lttng/events.h>
49 #include <lttng/tracer.h>
50 #include <lttng/endian.h>
51 #include "wrapper/vmalloc.h"
53 #ifdef CONFIG_ARCH_STACKWALK
54 #include "lttng-context-callstack-stackwalk-impl.h"
56 #include "lttng-context-callstack-legacy-impl.h"
62 void field_data_free(struct field_data
*fdata
)
66 free_percpu(fdata
->cs_percpu
);
71 struct field_data __percpu
*field_data_create(enum lttng_cs_ctx_modes mode
)
73 struct lttng_cs __percpu
*cs_set
;
74 struct field_data
*fdata
;
76 fdata
= kzalloc(sizeof(*fdata
), GFP_KERNEL
);
79 cs_set
= alloc_percpu(struct lttng_cs
);
82 lttng_cs_set_init(cs_set
);
83 fdata
->cs_percpu
= cs_set
;
88 field_data_free(fdata
);
93 void lttng_callstack_sequence_destroy(struct lttng_kernel_ctx_field
*field
)
95 struct field_data
*fdata
= field
->priv
;
97 field_data_free(fdata
);
100 static const struct lttng_kernel_event_field
*event_fields_kernel
[NR_FIELDS
] = {
101 lttng_kernel_static_event_field("_callstack_kernel_length",
102 lttng_kernel_static_type_integer_from_type(unsigned int, __BYTE_ORDER
, 10),
103 false, false, false),
104 lttng_kernel_static_event_field("callstack_kernel",
105 lttng_kernel_static_type_sequence(NULL
,
106 lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER
, 16),
108 false, false, false),
111 static const struct lttng_kernel_event_field
*event_fields_user
[NR_FIELDS
] = {
112 lttng_kernel_static_event_field("_callstack_user_length",
113 lttng_kernel_static_type_integer_from_type(unsigned int, __BYTE_ORDER
, 10),
114 false, false, false),
115 lttng_kernel_static_event_field("callstack_user",
116 lttng_kernel_static_type_sequence(NULL
,
117 lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER
, 16),
119 false, false, false),
122 const struct lttng_kernel_event_field
**lttng_cs_event_fields(enum lttng_cs_ctx_modes mode
)
125 case CALLSTACK_KERNEL
:
126 return event_fields_kernel
;
128 return event_fields_user
;
135 int __lttng_add_callstack_generic(struct lttng_kernel_ctx
**ctx
,
136 enum lttng_cs_ctx_modes mode
)
138 const struct lttng_kernel_event_field
**event_fields
;
139 struct lttng_kernel_ctx_field ctx_field
;
140 struct field_data
*fdata
;
143 ret
= init_type(mode
);
146 event_fields
= lttng_cs_event_fields(mode
);
150 for (i
= 0; i
< NR_FIELDS
; i
++) {
151 if (lttng_kernel_find_context(*ctx
, event_fields
[i
]->name
))
154 fdata
= field_data_create(mode
);
159 memset(&ctx_field
, 0, sizeof(ctx_field
));
160 ctx_field
.event_field
= event_fields
[0];
161 ctx_field
.get_size_arg
= lttng_callstack_length_get_size
;
162 ctx_field
.record
= lttng_callstack_length_record
;
163 ctx_field
.priv
= fdata
;
164 ret
= lttng_kernel_context_append(ctx
, &ctx_field
);
170 memset(&ctx_field
, 0, sizeof(ctx_field
));
171 ctx_field
.event_field
= event_fields
[1];
172 ctx_field
.get_size_arg
= lttng_callstack_sequence_get_size
;
173 ctx_field
.record
= lttng_callstack_sequence_record
;
174 ctx_field
.destroy
= lttng_callstack_sequence_destroy
;
175 ctx_field
.priv
= fdata
;
176 ret
= lttng_kernel_context_append(ctx
, &ctx_field
);
184 lttng_kernel_context_remove_last(ctx
);
186 field_data_free(fdata
);
192 * lttng_add_callstack_to_ctx - add callstack event context
194 * @ctx: the lttng_ctx pointer to initialize
195 * @type: the context type
197 * Supported callstack type supported:
198 * LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL
199 * Records the callstack of the kernel
200 * LTTNG_KERNEL_CONTEXT_CALLSTACK_USER
201 * Records the callstack of the userspace program (from the kernel)
203 * Return 0 for success, or error code.
205 int lttng_add_callstack_to_ctx(struct lttng_kernel_ctx
**ctx
, int type
)
208 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL
:
209 return __lttng_add_callstack_generic(ctx
, CALLSTACK_KERNEL
);
211 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER
:
212 return __lttng_add_callstack_generic(ctx
, CALLSTACK_USER
);
218 EXPORT_SYMBOL_GPL(lttng_add_callstack_to_ctx
);