1 #include <linux/module.h>
2 #include <linux/sort.h>
3 #include <asm/ptrace.h>
4 #include <asm/stacktrace.h>
5 #include <asm/unwind.h>
6 #include <asm/orc_types.h>
7 #include <asm/orc_lookup.h>
8 #include <asm/sections.h>
10 #define orc_warn(fmt, ...) \
11 printk_deferred_once(KERN_WARNING pr_fmt("WARNING: " fmt), ##__VA_ARGS__)
13 extern int __start_orc_unwind_ip
[];
14 extern int __stop_orc_unwind_ip
[];
15 extern struct orc_entry __start_orc_unwind
[];
16 extern struct orc_entry __stop_orc_unwind
[];
18 static DEFINE_MUTEX(sort_mutex
);
19 int *cur_orc_ip_table
= __start_orc_unwind_ip
;
20 struct orc_entry
*cur_orc_table
= __start_orc_unwind
;
22 unsigned int lookup_num_blocks
;
25 static inline unsigned long orc_ip(const int *ip
)
27 return (unsigned long)ip
+ *ip
;
30 static struct orc_entry
*__orc_find(int *ip_table
, struct orc_entry
*u_table
,
31 unsigned int num_entries
, unsigned long ip
)
33 int *first
= ip_table
;
34 int *last
= ip_table
+ num_entries
- 1;
35 int *mid
= first
, *found
= first
;
41 * Do a binary range search to find the rightmost duplicate of a given
42 * starting address. Some entries are section terminators which are
43 * "weak" entries for ensuring there are no gaps. They should be
44 * ignored when they conflict with a real entry.
46 while (first
<= last
) {
47 mid
= first
+ ((last
- first
) / 2);
49 if (orc_ip(mid
) <= ip
) {
56 return u_table
+ (found
- ip_table
);
60 static struct orc_entry
*orc_module_find(unsigned long ip
)
64 mod
= __module_address(ip
);
65 if (!mod
|| !mod
->arch
.orc_unwind
|| !mod
->arch
.orc_unwind_ip
)
67 return __orc_find(mod
->arch
.orc_unwind_ip
, mod
->arch
.orc_unwind
,
68 mod
->arch
.num_orcs
, ip
);
71 static struct orc_entry
*orc_module_find(unsigned long ip
)
77 static struct orc_entry
*orc_find(unsigned long ip
)
82 /* For non-init vmlinux addresses, use the fast lookup table: */
83 if (ip
>= LOOKUP_START_IP
&& ip
< LOOKUP_STOP_IP
) {
84 unsigned int idx
, start
, stop
;
86 idx
= (ip
- LOOKUP_START_IP
) / LOOKUP_BLOCK_SIZE
;
88 if (unlikely((idx
>= lookup_num_blocks
-1))) {
89 orc_warn("WARNING: bad lookup idx: idx=%u num=%u ip=%pB\n",
90 idx
, lookup_num_blocks
, (void *)ip
);
94 start
= orc_lookup
[idx
];
95 stop
= orc_lookup
[idx
+ 1] + 1;
97 if (unlikely((__start_orc_unwind
+ start
>= __stop_orc_unwind
) ||
98 (__start_orc_unwind
+ stop
> __stop_orc_unwind
))) {
99 orc_warn("WARNING: bad lookup value: idx=%u num=%u start=%u stop=%u ip=%pB\n",
100 idx
, lookup_num_blocks
, start
, stop
, (void *)ip
);
104 return __orc_find(__start_orc_unwind_ip
+ start
,
105 __start_orc_unwind
+ start
, stop
- start
, ip
);
108 /* vmlinux .init slow lookup: */
109 if (ip
>= (unsigned long)_sinittext
&& ip
< (unsigned long)_einittext
)
110 return __orc_find(__start_orc_unwind_ip
, __start_orc_unwind
,
111 __stop_orc_unwind_ip
- __start_orc_unwind_ip
, ip
);
114 return orc_module_find(ip
);
117 static void orc_sort_swap(void *_a
, void *_b
, int size
)
119 struct orc_entry
*orc_a
, *orc_b
;
120 struct orc_entry orc_tmp
;
121 int *a
= _a
, *b
= _b
, tmp
;
124 /* Swap the .orc_unwind_ip entries: */
129 /* Swap the corresponding .orc_unwind entries: */
130 orc_a
= cur_orc_table
+ (a
- cur_orc_ip_table
);
131 orc_b
= cur_orc_table
+ (b
- cur_orc_ip_table
);
137 static int orc_sort_cmp(const void *_a
, const void *_b
)
139 struct orc_entry
*orc_a
;
140 const int *a
= _a
, *b
= _b
;
141 unsigned long a_val
= orc_ip(a
);
142 unsigned long b_val
= orc_ip(b
);
150 * The "weak" section terminator entries need to always be on the left
151 * to ensure the lookup code skips them in favor of real entries.
152 * These terminator entries exist to handle any gaps created by
153 * whitelisted .o files which didn't get objtool generation.
155 orc_a
= cur_orc_table
+ (a
- cur_orc_ip_table
);
156 return orc_a
->sp_reg
== ORC_REG_UNDEFINED
? -1 : 1;
159 #ifdef CONFIG_MODULES
160 void unwind_module_init(struct module
*mod
, void *_orc_ip
, size_t orc_ip_size
,
161 void *_orc
, size_t orc_size
)
163 int *orc_ip
= _orc_ip
;
164 struct orc_entry
*orc
= _orc
;
165 unsigned int num_entries
= orc_ip_size
/ sizeof(int);
167 WARN_ON_ONCE(orc_ip_size
% sizeof(int) != 0 ||
168 orc_size
% sizeof(*orc
) != 0 ||
169 num_entries
!= orc_size
/ sizeof(*orc
));
172 * The 'cur_orc_*' globals allow the orc_sort_swap() callback to
173 * associate an .orc_unwind_ip table entry with its corresponding
174 * .orc_unwind entry so they can both be swapped.
176 mutex_lock(&sort_mutex
);
177 cur_orc_ip_table
= orc_ip
;
179 sort(orc_ip
, num_entries
, sizeof(int), orc_sort_cmp
, orc_sort_swap
);
180 mutex_unlock(&sort_mutex
);
182 mod
->arch
.orc_unwind_ip
= orc_ip
;
183 mod
->arch
.orc_unwind
= orc
;
184 mod
->arch
.num_orcs
= num_entries
;
188 void __init
unwind_init(void)
190 size_t orc_ip_size
= (void *)__stop_orc_unwind_ip
- (void *)__start_orc_unwind_ip
;
191 size_t orc_size
= (void *)__stop_orc_unwind
- (void *)__start_orc_unwind
;
192 size_t num_entries
= orc_ip_size
/ sizeof(int);
193 struct orc_entry
*orc
;
196 if (!num_entries
|| orc_ip_size
% sizeof(int) != 0 ||
197 orc_size
% sizeof(struct orc_entry
) != 0 ||
198 num_entries
!= orc_size
/ sizeof(struct orc_entry
)) {
199 orc_warn("WARNING: Bad or missing .orc_unwind table. Disabling unwinder.\n");
203 /* Sort the .orc_unwind and .orc_unwind_ip tables: */
204 sort(__start_orc_unwind_ip
, num_entries
, sizeof(int), orc_sort_cmp
,
207 /* Initialize the fast lookup table: */
208 lookup_num_blocks
= orc_lookup_end
- orc_lookup
;
209 for (i
= 0; i
< lookup_num_blocks
-1; i
++) {
210 orc
= __orc_find(__start_orc_unwind_ip
, __start_orc_unwind
,
212 LOOKUP_START_IP
+ (LOOKUP_BLOCK_SIZE
* i
));
214 orc_warn("WARNING: Corrupt .orc_unwind table. Disabling unwinder.\n");
218 orc_lookup
[i
] = orc
- __start_orc_unwind
;
221 /* Initialize the ending block: */
222 orc
= __orc_find(__start_orc_unwind_ip
, __start_orc_unwind
, num_entries
,
225 orc_warn("WARNING: Corrupt .orc_unwind table. Disabling unwinder.\n");
228 orc_lookup
[lookup_num_blocks
-1] = orc
- __start_orc_unwind
;
233 unsigned long unwind_get_return_address(struct unwind_state
*state
)
235 if (unwind_done(state
))
238 return __kernel_text_address(state
->ip
) ? state
->ip
: 0;
240 EXPORT_SYMBOL_GPL(unwind_get_return_address
);
242 unsigned long *unwind_get_return_address_ptr(struct unwind_state
*state
)
244 if (unwind_done(state
))
248 return &state
->regs
->ip
;
251 return (unsigned long *)state
->sp
- 1;
256 static bool stack_access_ok(struct unwind_state
*state
, unsigned long addr
,
259 struct stack_info
*info
= &state
->stack_info
;
262 * If the address isn't on the current stack, switch to the next one.
264 * We may have to traverse multiple stacks to deal with the possibility
265 * that info->next_sp could point to an empty stack and the address
266 * could be on a subsequent stack.
268 while (!on_stack(info
, (void *)addr
, len
))
269 if (get_stack_info(info
->next_sp
, state
->task
, info
,
276 static bool deref_stack_reg(struct unwind_state
*state
, unsigned long addr
,
279 if (!stack_access_ok(state
, addr
, sizeof(long)))
282 *val
= READ_ONCE_NOCHECK(*(unsigned long *)addr
);
286 #define REGS_SIZE (sizeof(struct pt_regs))
287 #define SP_OFFSET (offsetof(struct pt_regs, sp))
288 #define IRET_REGS_SIZE (REGS_SIZE - offsetof(struct pt_regs, ip))
289 #define IRET_SP_OFFSET (SP_OFFSET - offsetof(struct pt_regs, ip))
291 static bool deref_stack_regs(struct unwind_state
*state
, unsigned long addr
,
292 unsigned long *ip
, unsigned long *sp
, bool full
)
294 size_t regs_size
= full
? REGS_SIZE
: IRET_REGS_SIZE
;
295 size_t sp_offset
= full
? SP_OFFSET
: IRET_SP_OFFSET
;
296 struct pt_regs
*regs
= (struct pt_regs
*)(addr
+ regs_size
- REGS_SIZE
);
298 if (IS_ENABLED(CONFIG_X86_64
)) {
299 if (!stack_access_ok(state
, addr
, regs_size
))
308 if (!stack_access_ok(state
, addr
, sp_offset
))
313 if (user_mode(regs
)) {
314 if (!stack_access_ok(state
, addr
+ sp_offset
,
315 REGS_SIZE
- SP_OFFSET
))
320 *sp
= (unsigned long)®s
->sp
;
325 bool unwind_next_frame(struct unwind_state
*state
)
327 unsigned long ip_p
, sp
, orig_ip
, prev_sp
= state
->sp
;
328 enum stack_type prev_type
= state
->stack_info
.type
;
329 struct orc_entry
*orc
;
330 struct pt_regs
*ptregs
;
331 bool indirect
= false;
333 if (unwind_done(state
))
336 /* Don't let modules unload while we're reading their ORC data. */
339 /* Have we reached the end? */
340 if (state
->regs
&& user_mode(state
->regs
))
344 * Find the orc_entry associated with the text address.
346 * Decrement call return addresses by one so they work for sibling
347 * calls and calls to noreturn functions.
349 orc
= orc_find(state
->signal
? state
->ip
: state
->ip
- 1);
350 if (!orc
|| orc
->sp_reg
== ORC_REG_UNDEFINED
)
354 /* Find the previous frame's stack: */
355 switch (orc
->sp_reg
) {
357 sp
= state
->sp
+ orc
->sp_offset
;
361 sp
= state
->bp
+ orc
->sp_offset
;
364 case ORC_REG_SP_INDIRECT
:
365 sp
= state
->sp
+ orc
->sp_offset
;
369 case ORC_REG_BP_INDIRECT
:
370 sp
= state
->bp
+ orc
->sp_offset
;
375 if (!state
->regs
|| !state
->full_regs
) {
376 orc_warn("missing regs for base reg R10 at ip %pB\n",
380 sp
= state
->regs
->r10
;
384 if (!state
->regs
|| !state
->full_regs
) {
385 orc_warn("missing regs for base reg R13 at ip %pB\n",
389 sp
= state
->regs
->r13
;
393 if (!state
->regs
|| !state
->full_regs
) {
394 orc_warn("missing regs for base reg DI at ip %pB\n",
398 sp
= state
->regs
->di
;
402 if (!state
->regs
|| !state
->full_regs
) {
403 orc_warn("missing regs for base reg DX at ip %pB\n",
407 sp
= state
->regs
->dx
;
411 orc_warn("unknown SP base reg %d for ip %pB\n",
412 orc
->sp_reg
, (void *)state
->ip
);
417 if (!deref_stack_reg(state
, sp
, &sp
))
421 /* Find IP, SP and possibly regs: */
424 ip_p
= sp
- sizeof(long);
426 if (!deref_stack_reg(state
, ip_p
, &state
->ip
))
429 state
->ip
= ftrace_graph_ret_addr(state
->task
, &state
->graph_idx
,
430 state
->ip
, (void *)ip_p
);
434 state
->signal
= false;
438 if (!deref_stack_regs(state
, sp
, &state
->ip
, &state
->sp
, true)) {
439 orc_warn("can't dereference registers at %p for ip %pB\n",
440 (void *)sp
, (void *)orig_ip
);
444 state
->regs
= (struct pt_regs
*)sp
;
445 state
->full_regs
= true;
446 state
->signal
= true;
449 case ORC_TYPE_REGS_IRET
:
450 if (!deref_stack_regs(state
, sp
, &state
->ip
, &state
->sp
, false)) {
451 orc_warn("can't dereference iret registers at %p for ip %pB\n",
452 (void *)sp
, (void *)orig_ip
);
456 ptregs
= container_of((void *)sp
, struct pt_regs
, ip
);
457 if ((unsigned long)ptregs
>= prev_sp
&&
458 on_stack(&state
->stack_info
, ptregs
, REGS_SIZE
)) {
459 state
->regs
= ptregs
;
460 state
->full_regs
= false;
464 state
->signal
= true;
468 orc_warn("unknown .orc_unwind entry type %d for ip %pB\n",
469 orc
->type
, (void *)orig_ip
);
474 switch (orc
->bp_reg
) {
475 case ORC_REG_UNDEFINED
:
476 if (state
->regs
&& state
->full_regs
)
477 state
->bp
= state
->regs
->bp
;
480 case ORC_REG_PREV_SP
:
481 if (!deref_stack_reg(state
, sp
+ orc
->bp_offset
, &state
->bp
))
486 if (!deref_stack_reg(state
, state
->bp
+ orc
->bp_offset
, &state
->bp
))
491 orc_warn("unknown BP base reg %d for ip %pB\n",
492 orc
->bp_reg
, (void *)orig_ip
);
496 /* Prevent a recursive loop due to bad ORC data: */
497 if (state
->stack_info
.type
== prev_type
&&
498 on_stack(&state
->stack_info
, (void *)state
->sp
, sizeof(long)) &&
499 state
->sp
<= prev_sp
) {
500 orc_warn("stack going in the wrong direction? ip=%pB\n",
510 state
->stack_info
.type
= STACK_TYPE_UNKNOWN
;
513 EXPORT_SYMBOL_GPL(unwind_next_frame
);
515 void __unwind_start(struct unwind_state
*state
, struct task_struct
*task
,
516 struct pt_regs
*regs
, unsigned long *first_frame
)
518 memset(state
, 0, sizeof(*state
));
522 * Refuse to unwind the stack of a task while it's executing on another
523 * CPU. This check is racy, but that's ok: the unwinder has other
524 * checks to prevent it from going off the rails.
526 if (task_on_another_cpu(task
))
533 state
->ip
= regs
->ip
;
534 state
->sp
= kernel_stack_pointer(regs
);
535 state
->bp
= regs
->bp
;
537 state
->full_regs
= true;
538 state
->signal
= true;
540 } else if (task
== current
) {
541 asm volatile("lea (%%rip), %0\n\t"
544 : "=r" (state
->ip
), "=r" (state
->sp
),
548 struct inactive_task_frame
*frame
= (void *)task
->thread
.sp
;
550 state
->sp
= task
->thread
.sp
;
551 state
->bp
= READ_ONCE_NOCHECK(frame
->bp
);
552 state
->ip
= READ_ONCE_NOCHECK(frame
->ret_addr
);
555 if (get_stack_info((unsigned long *)state
->sp
, state
->task
,
556 &state
->stack_info
, &state
->stack_mask
))
560 * The caller can provide the address of the first frame directly
561 * (first_frame) or indirectly (regs->sp) to indicate which stack frame
562 * to start unwinding at. Skip ahead until we reach it.
565 /* When starting from regs, skip the regs frame: */
567 unwind_next_frame(state
);
571 /* Otherwise, skip ahead to the user-specified starting frame: */
572 while (!unwind_done(state
) &&
573 (!on_stack(&state
->stack_info
, first_frame
, sizeof(long)) ||
574 state
->sp
<= (unsigned long)first_frame
))
575 unwind_next_frame(state
);
580 state
->stack_info
.type
= STACK_TYPE_UNKNOWN
;
583 EXPORT_SYMBOL_GPL(__unwind_start
);