1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
3 * lttng-context-callstack-legacy-impl.h
5 * LTTng callstack event context, legacy implementation. Targets
6 * kernels and architectures not yet using the stacktrace common
7 * infrastructure introduced in the upstream Linux kernel by commit
8 * 214d8ca6ee "stacktrace: Provide common infrastructure" (merged in
9 * Linux 5.2, then gradually introduced within architectures).
11 * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
12 * Copyright (C) 2014 Francis Giraldeau <francis.giraldeau@gmail.com>
15 #define MAX_ENTRIES 128
17 enum lttng_cs_ctx_modes
{
23 struct lttng_cs_dispatch
{
24 struct stack_trace stack_trace
;
25 unsigned long entries
[MAX_ENTRIES
];
29 struct lttng_cs_dispatch dispatch
[RING_BUFFER_MAX_NESTING
];
33 struct lttng_cs __percpu
*cs_percpu
;
34 enum lttng_cs_ctx_modes mode
;
37 struct lttng_cs_type
{
39 const char *length_name
;
40 const char *save_func_name
;
41 void (*save_func
)(struct stack_trace
*trace
);
44 static struct lttng_cs_type cs_types
[] = {
46 .name
= "callstack_kernel",
47 .length_name
= "_callstack_kernel_length",
48 .save_func_name
= "save_stack_trace",
52 .name
= "callstack_user",
53 .length_name
= "_callstack_user_length",
54 .save_func_name
= "save_stack_trace_user",
60 int init_type(enum lttng_cs_ctx_modes mode
)
64 if (cs_types
[mode
].save_func
)
66 func
= kallsyms_lookup_funcptr(cs_types
[mode
].save_func_name
);
68 printk(KERN_WARNING
"LTTng: symbol lookup failed: %s\n",
69 cs_types
[mode
].save_func_name
);
72 cs_types
[mode
].save_func
= (void *) func
;
77 void lttng_cs_set_init(struct lttng_cs __percpu
*cs_set
)
81 for_each_possible_cpu(cpu
) {
84 cs
= per_cpu_ptr(cs_set
, cpu
);
85 for (i
= 0; i
< RING_BUFFER_MAX_NESTING
; i
++) {
86 struct lttng_cs_dispatch
*dispatch
;
88 dispatch
= &cs
->dispatch
[i
];
89 dispatch
->stack_trace
.entries
= dispatch
->entries
;
90 dispatch
->stack_trace
.max_entries
= MAX_ENTRIES
;
95 /* Keep track of nesting inside userspace callstack context code */
96 DEFINE_PER_CPU(int, callstack_user_nesting
);
99 struct stack_trace
*stack_trace_context(struct lttng_kernel_ctx_field
*field
,
100 struct lib_ring_buffer_ctx
*ctx
)
102 int buffer_nesting
, cs_user_nesting
;
104 struct field_data
*fdata
= field
->priv
;
107 * Do not gather the userspace callstack context when the event was
108 * triggered by the userspace callstack context saving mechanism.
110 cs_user_nesting
= per_cpu(callstack_user_nesting
, ctx
->cpu
);
112 if (fdata
->mode
== CALLSTACK_USER
&& cs_user_nesting
>= 1)
116 * get_cpu() is not required, preemption is already
117 * disabled while event is written.
119 * max nesting is checked in lib_ring_buffer_get_cpu().
120 * Check it again as a safety net.
122 cs
= per_cpu_ptr(fdata
->cs_percpu
, ctx
->cpu
);
123 buffer_nesting
= per_cpu(lib_ring_buffer_nesting
, ctx
->cpu
) - 1;
124 if (buffer_nesting
>= RING_BUFFER_MAX_NESTING
)
127 return &cs
->dispatch
[buffer_nesting
].stack_trace
;
131 size_t lttng_callstack_length_get_size(size_t offset
, struct lttng_kernel_ctx_field
*field
,
132 struct lib_ring_buffer_ctx
*ctx
,
133 struct lttng_channel
*chan
)
135 size_t orig_offset
= offset
;
137 offset
+= lib_ring_buffer_align(offset
, lttng_alignof(unsigned int));
138 offset
+= sizeof(unsigned int);
139 return offset
- orig_offset
;
143 * In order to reserve the correct size, the callstack is computed. The
144 * resulting callstack is saved to be accessed in the record step.
147 size_t lttng_callstack_sequence_get_size(size_t offset
, struct lttng_kernel_ctx_field
*field
,
148 struct lib_ring_buffer_ctx
*ctx
,
149 struct lttng_channel
*chan
)
151 struct stack_trace
*trace
;
152 struct field_data
*fdata
= field
->priv
;
153 size_t orig_offset
= offset
;
155 /* do not write data if no space is available */
156 trace
= stack_trace_context(field
, ctx
);
157 if (unlikely(!trace
)) {
158 offset
+= lib_ring_buffer_align(offset
, lttng_alignof(unsigned long));
159 return offset
- orig_offset
;
162 /* reset stack trace, no need to clear memory */
163 trace
->nr_entries
= 0;
165 if (fdata
->mode
== CALLSTACK_USER
)
166 ++per_cpu(callstack_user_nesting
, ctx
->cpu
);
168 /* do the real work and reserve space */
169 cs_types
[fdata
->mode
].save_func(trace
);
171 if (fdata
->mode
== CALLSTACK_USER
)
172 per_cpu(callstack_user_nesting
, ctx
->cpu
)--;
175 * Remove final ULONG_MAX delimiter. If we cannot find it, add
176 * our own marker to show that the stack is incomplete. This is
177 * more compact for a trace.
179 if (trace
->nr_entries
> 0
180 && trace
->entries
[trace
->nr_entries
- 1] == ULONG_MAX
) {
183 offset
+= lib_ring_buffer_align(offset
, lttng_alignof(unsigned long));
184 offset
+= sizeof(unsigned long) * trace
->nr_entries
;
185 /* Add our own ULONG_MAX delimiter to show incomplete stack. */
186 if (trace
->nr_entries
== trace
->max_entries
)
187 offset
+= sizeof(unsigned long);
188 return offset
- orig_offset
;
192 void lttng_callstack_length_record(struct lttng_kernel_ctx_field
*field
,
193 struct lib_ring_buffer_ctx
*ctx
,
194 struct lttng_channel
*chan
)
196 struct stack_trace
*trace
= stack_trace_context(field
, ctx
);
197 unsigned int nr_seq_entries
;
199 lib_ring_buffer_align_ctx(ctx
, lttng_alignof(unsigned int));
200 if (unlikely(!trace
)) {
203 nr_seq_entries
= trace
->nr_entries
;
204 if (trace
->nr_entries
== trace
->max_entries
)
207 chan
->ops
->event_write(ctx
, &nr_seq_entries
, sizeof(unsigned int));
210 void lttng_callstack_sequence_record(struct lttng_kernel_ctx_field
*field
,
211 struct lib_ring_buffer_ctx
*ctx
,
212 struct lttng_channel
*chan
)
214 struct stack_trace
*trace
= stack_trace_context(field
, ctx
);
215 unsigned int nr_seq_entries
;
217 lib_ring_buffer_align_ctx(ctx
, lttng_alignof(unsigned long));
218 if (unlikely(!trace
)) {
221 nr_seq_entries
= trace
->nr_entries
;
222 if (trace
->nr_entries
== trace
->max_entries
)
224 chan
->ops
->event_write(ctx
, trace
->entries
,
225 sizeof(unsigned long) * trace
->nr_entries
);
226 /* Add our own ULONG_MAX delimiter to show incomplete stack. */
227 if (trace
->nr_entries
== trace
->max_entries
) {
228 unsigned long delim
= ULONG_MAX
;
230 chan
->ops
->event_write(ctx
, &delim
, sizeof(unsigned long));