[mirror_ubuntu-jammy-kernel.git] / arch / x86 / kernel / unwind_frame.c

// SPDX-License-Identifier: GPL-2.0-only
#include <linux/sched.h>
#include <linux/sched/task.h>
#include <linux/sched/task_stack.h>
#include <linux/interrupt.h>
#include <asm/sections.h>
#include <asm/ptrace.h>
#include <asm/bitops.h>
#include <asm/stacktrace.h>
#include <asm/unwind.h>

#define FRAME_HEADER_SIZE (sizeof(long) * 2)

unsigned long unwind_get_return_address(struct unwind_state *state)
{
	if (unwind_done(state))
		return 0;

	return __kernel_text_address(state->ip) ? state->ip : 0;
}
EXPORT_SYMBOL_GPL(unwind_get_return_address);

unsigned long *unwind_get_return_address_ptr(struct unwind_state *state)
{
	if (unwind_done(state))
		return NULL;

	return state->regs ? &state->regs->ip : state->bp + 1;
}

static void unwind_dump(struct unwind_state *state)
{
	static bool dumped_before = false;
	bool prev_zero, zero = false;
	unsigned long word, *sp;
	struct stack_info stack_info = {0};
	unsigned long visit_mask = 0;

	if (dumped_before)
		return;

	dumped_before = true;

	printk_deferred("unwind stack type:%d next_sp:%p mask:0x%lx graph_idx:%d\n",
			state->stack_info.type, state->stack_info.next_sp,
			state->stack_mask, state->graph_idx);

	for (sp = PTR_ALIGN(state->orig_sp, sizeof(long)); sp;
	     sp = PTR_ALIGN(stack_info.next_sp, sizeof(long))) {
		if (get_stack_info(sp, state->task, &stack_info, &visit_mask))
			break;

		for (; sp < stack_info.end; sp++) {

			word = READ_ONCE_NOCHECK(*sp);

			prev_zero = zero;
			zero = word == 0;

			if (zero) {
				if (!prev_zero)
					printk_deferred("%p: %0*x ...\n",
							sp, BITS_PER_LONG/4, 0);
				continue;
			}

			printk_deferred("%p: %0*lx (%pB)\n",
					sp, BITS_PER_LONG/4, word, (void *)word);
		}
	}
}

static bool in_entry_code(unsigned long ip)
{
	char *addr = (char *)ip;

	return addr >= __entry_text_start && addr < __entry_text_end;
}

static inline unsigned long *last_frame(struct unwind_state *state)
{
	return (unsigned long *)task_pt_regs(state->task) - 2;
}

static bool is_last_frame(struct unwind_state *state)
{
	return state->bp == last_frame(state);
}

#ifdef CONFIG_X86_32
#define GCC_REALIGN_WORDS 3
#else
#define GCC_REALIGN_WORDS 1
#endif

static inline unsigned long *last_aligned_frame(struct unwind_state *state)
{
	return last_frame(state) - GCC_REALIGN_WORDS;
}

static bool is_last_aligned_frame(struct unwind_state *state)
{
	unsigned long *last_bp = last_frame(state);
	unsigned long *aligned_bp = last_aligned_frame(state);

	/*
	 * GCC can occasionally decide to realign the stack pointer and change
	 * the offset of the stack frame in the prologue of a function called
	 * by head/entry code.  Examples:
	 *
	 * <start_secondary>:
	 *      push   %edi
	 *      lea    0x8(%esp),%edi
	 *      and    $0xfffffff8,%esp
	 *      pushl  -0x4(%edi)
	 *      push   %ebp
	 *      mov    %esp,%ebp
	 *
	 * <x86_64_start_kernel>:
	 *      lea    0x8(%rsp),%r10
	 *      and    $0xfffffffffffffff0,%rsp
	 *      pushq  -0x8(%r10)
	 *      push   %rbp
	 *      mov    %rsp,%rbp
	 *
	 * After aligning the stack, it pushes a duplicate copy of the return
	 * address before pushing the frame pointer.
	 */
	return (state->bp == aligned_bp && *(aligned_bp + 1) == *(last_bp + 1));
}

static bool is_last_ftrace_frame(struct unwind_state *state)
{
	unsigned long *last_bp = last_frame(state);
	unsigned long *last_ftrace_bp = last_bp - 3;

	/*
	 * When unwinding from an ftrace handler of a function called by entry
	 * code, the stack layout of the last frame is:
	 *
	 *   bp
	 *   parent ret addr
	 *   bp
	 *   function ret addr
	 *   parent ret addr
	 *   pt_regs
	 *   -----------------
	 */
	return (state->bp == last_ftrace_bp &&
		*state->bp == *(state->bp + 2) &&
		*(state->bp + 1) == *(state->bp + 4));
}

static bool is_last_task_frame(struct unwind_state *state)
{
	return is_last_frame(state) || is_last_aligned_frame(state) ||
	       is_last_ftrace_frame(state);
}

/*
 * This determines if the frame pointer actually contains an encoded pointer to
 * pt_regs on the stack.  See ENCODE_FRAME_POINTER.
 */
#ifdef CONFIG_X86_64
static struct pt_regs *decode_frame_pointer(unsigned long *bp)
{
	unsigned long regs = (unsigned long)bp;

	if (!(regs & 0x1))
		return NULL;

	return (struct pt_regs *)(regs & ~0x1);
}
#else
static struct pt_regs *decode_frame_pointer(unsigned long *bp)
{
	unsigned long regs = (unsigned long)bp;

	if (regs & 0x80000000)
		return NULL;

	return (struct pt_regs *)(regs | 0x80000000);
}
#endif

static bool update_stack_state(struct unwind_state *state,
			       unsigned long *next_bp)
{
	struct stack_info *info = &state->stack_info;
	enum stack_type prev_type = info->type;
	struct pt_regs *regs;
	unsigned long *frame, *prev_frame_end, *addr_p, addr;
	size_t len;

	if (state->regs)
		prev_frame_end = (void *)state->regs + sizeof(*state->regs);
	else
		prev_frame_end = (void *)state->bp + FRAME_HEADER_SIZE;

	/* Is the next frame pointer an encoded pointer to pt_regs? */
	regs = decode_frame_pointer(next_bp);
	if (regs) {
		frame = (unsigned long *)regs;
		len = sizeof(*regs);
		state->got_irq = true;
	} else {
		frame = next_bp;
		len = FRAME_HEADER_SIZE;
	}

	/*
	 * If the next bp isn't on the current stack, switch to the next one.
	 *
	 * We may have to traverse multiple stacks to deal with the possibility
	 * that info->next_sp could point to an empty stack and the next bp
	 * could be on a subsequent stack.
	 */
	while (!on_stack(info, frame, len))
		if (get_stack_info(info->next_sp, state->task, info,
				   &state->stack_mask))
			return false;

	/* Make sure it only unwinds up and doesn't overlap the prev frame: */
	if (state->orig_sp && state->stack_info.type == prev_type &&
	    frame < prev_frame_end)
		return false;

	/* Move state to the next frame: */
	if (regs) {
		state->regs = regs;
		state->bp = NULL;
	} else {
		state->bp = next_bp;
		state->regs = NULL;
	}

	/* Save the return address: */
	if (state->regs && user_mode(state->regs))
		state->ip = 0;
	else {
		addr_p = unwind_get_return_address_ptr(state);
		addr = READ_ONCE_TASK_STACK(state->task, *addr_p);
		state->ip = ftrace_graph_ret_addr(state->task, &state->graph_idx,
						  addr, addr_p);
	}

	/* Save the original stack pointer for unwind_dump(): */
	if (!state->orig_sp)
		state->orig_sp = frame;

	return true;
}

bool unwind_next_frame(struct unwind_state *state)
{
	struct pt_regs *regs;
	unsigned long *next_bp;

	if (unwind_done(state))
		return false;

	/* Have we reached the end? */
	if (state->regs && user_mode(state->regs))
		goto the_end;

	if (is_last_task_frame(state)) {
		regs = task_pt_regs(state->task);

		/*
		 * kthreads (other than the boot CPU's idle thread) have some
		 * partial regs at the end of their stack which were placed
		 * there by copy_thread().  But the regs don't have any
		 * useful information, so we can skip them.
		 *
		 * This user_mode() check is slightly broader than a PF_KTHREAD
		 * check because it also catches the awkward situation where a
		 * newly forked kthread transitions into a user task by calling
		 * kernel_execve(), which eventually clears PF_KTHREAD.
		 */
		if (!user_mode(regs))
			goto the_end;

		/*
		 * We're almost at the end, but not quite: there's still the
		 * syscall regs frame.  Entry code doesn't encode the regs
		 * pointer for syscalls, so we have to set it manually.
		 */
		state->regs = regs;
		state->bp = NULL;
		state->ip = 0;
		return true;
	}

	/* Get the next frame pointer: */
	if (state->next_bp) {
		next_bp = state->next_bp;
		state->next_bp = NULL;
	} else if (state->regs) {
		next_bp = (unsigned long *)state->regs->bp;
	} else {
		next_bp = (unsigned long *)READ_ONCE_TASK_STACK(state->task, *state->bp);
	}

	/* Move to the next frame if it's safe: */
	if (!update_stack_state(state, next_bp))
		goto bad_address;

	return true;

bad_address:
	state->error = true;

	/*
	 * When unwinding a non-current task, the task might actually be
	 * running on another CPU, in which case it could be modifying its
	 * stack while we're reading it.  This is generally not a problem and
	 * can be ignored as long as the caller understands that unwinding
	 * another task will not always succeed.
	 */
	if (state->task != current)
		goto the_end;

	/*
	 * Don't warn if the unwinder got lost due to an interrupt in entry
	 * code or in the C handler before the first frame pointer got set up:
	 */
	if (state->got_irq && in_entry_code(state->ip))
		goto the_end;
	if (state->regs &&
	    state->regs->sp >= (unsigned long)last_aligned_frame(state) &&
	    state->regs->sp < (unsigned long)task_pt_regs(state->task))
		goto the_end;

	/*
	 * There are some known frame pointer issues on 32-bit.  Disable
	 * unwinder warnings on 32-bit until it gets objtool support.
	 */
	if (IS_ENABLED(CONFIG_X86_32))
		goto the_end;

	if (state->task != current)
		goto the_end;

	if (state->regs) {
		printk_deferred_once(KERN_WARNING
			"WARNING: kernel stack regs at %p in %s:%d has bad 'bp' value %p\n",
			state->regs, state->task->comm,
			state->task->pid, next_bp);
		unwind_dump(state);
	} else {
		printk_deferred_once(KERN_WARNING
			"WARNING: kernel stack frame pointer at %p in %s:%d has bad value %p\n",
			state->bp, state->task->comm,
			state->task->pid, next_bp);
		unwind_dump(state);
	}
the_end:
	state->stack_info.type = STACK_TYPE_UNKNOWN;
	return false;
}
EXPORT_SYMBOL_GPL(unwind_next_frame);

void __unwind_start(struct unwind_state *state, struct task_struct *task,
		    struct pt_regs *regs, unsigned long *first_frame)
{
	unsigned long *bp;

	memset(state, 0, sizeof(*state));
	state->task = task;
	state->got_irq = (regs);

	/* Don't even attempt to start from user mode regs: */
	if (regs && user_mode(regs)) {
		state->stack_info.type = STACK_TYPE_UNKNOWN;
		return;
	}

	bp = get_frame_pointer(task, regs);

	/*
	 * If we crash with IP==0, the last successfully executed instruction
	 * was probably an indirect function call with a NULL function pointer.
	 * That means that SP points into the middle of an incomplete frame:
	 * *SP is a return pointer, and *(SP-sizeof(unsigned long)) is where we
	 * would have written a frame pointer if we hadn't crashed.
	 * Pretend that the frame is complete and that BP points to it, but save
	 * the real BP so that we can use it when looking for the next frame.
	 */
	if (regs && regs->ip == 0 && (unsigned long *)regs->sp >= first_frame) {
		state->next_bp = bp;
		bp = ((unsigned long *)regs->sp) - 1;
	}

	/* Initialize stack info and make sure the frame data is accessible: */
	get_stack_info(bp, state->task, &state->stack_info,
		       &state->stack_mask);
	update_stack_state(state, bp);

	/*
	 * The caller can provide the address of the first frame directly
	 * (first_frame) or indirectly (regs->sp) to indicate which stack frame
	 * to start unwinding at.  Skip ahead until we reach it.
	 */
	while (!unwind_done(state) &&
	       (!on_stack(&state->stack_info, first_frame, sizeof(long)) ||
			(state->next_bp == NULL && state->bp < first_frame)))
		unwind_next_frame(state);
}
EXPORT_SYMBOL_GPL(__unwind_start);
Commit	Line	Data
457c8996	1	// SPDX-License-Identifier: GPL-2.0-only
7c7900f8	2	#include <linux/sched.h>
29930025	3	#include <linux/sched/task.h>
68db0cf1	4	#include <linux/sched/task_stack.h>
a8b7a923 JP	5	#include <linux/interrupt.h>
a8b7a923 JP	6	#include <asm/sections.h>
7c7900f8 JP	7	#include <asm/ptrace.h>
	8	#include <asm/bitops.h>
	9	#include <asm/stacktrace.h>
	10	#include <asm/unwind.h>
	11
	12	#define FRAME_HEADER_SIZE (sizeof(long) * 2)
	13
ee9f8fce JP	14	unsigned long unwind_get_return_address(struct unwind_state *state)
	15	{
	16	if (unwind_done(state))
	17	return 0;
	18
	19	return __kernel_text_address(state->ip) ? state->ip : 0;
	20	}
	21	EXPORT_SYMBOL_GPL(unwind_get_return_address);
	22
	23	unsigned long unwind_get_return_address_ptr(struct unwind_state state)
	24	{
	25	if (unwind_done(state))
	26	return NULL;
	27
	28	return state->regs ? &state->regs->ip : state->bp + 1;
	29	}
84936118	30
aa4f8534	31	static void unwind_dump(struct unwind_state *state)
8b5e99f0 JP	32	{
	33	static bool dumped_before = false;
	34	bool prev_zero, zero = false;
aa4f8534	35	unsigned long word, *sp;
262fa734 JP	36	struct stack_info stack_info = {0};
262fa734 JP	37	unsigned long visit_mask = 0;
8b5e99f0 JP	38
	39	if (dumped_before)
	40	return;
	41
	42	dumped_before = true;
	43
4ea3d741	44	printk_deferred("unwind stack type:%d next_sp:%p mask:0x%lx graph_idx:%d\n",
8b5e99f0 JP	45	state->stack_info.type, state->stack_info.next_sp,
	46	state->stack_mask, state->graph_idx);
	47
99bd28a4 JP	48	for (sp = PTR_ALIGN(state->orig_sp, sizeof(long)); sp;
99bd28a4 JP	49	sp = PTR_ALIGN(stack_info.next_sp, sizeof(long))) {
262fa734 JP	50	if (get_stack_info(sp, state->task, &stack_info, &visit_mask))
262fa734 JP	51	break;
8b5e99f0	52
262fa734	53	for (; sp < stack_info.end; sp++) {
8b5e99f0	54
262fa734 JP	55	word = READ_ONCE_NOCHECK(*sp);
	56
	57	prev_zero = zero;
	58	zero = word == 0;
8b5e99f0	59
262fa734 JP	60	if (zero) {
	61	if (!prev_zero)
	62	printk_deferred("%p: %0*x ...\n",
	63	sp, BITS_PER_LONG/4, 0);
	64	continue;
	65	}
	66
	67	printk_deferred("%p: %0*lx (%pB)\n",
	68	sp, BITS_PER_LONG/4, word, (void *)word);
	69	}
8b5e99f0 JP	70	}
	71	}
	72
a8b7a923 JP	73	static bool in_entry_code(unsigned long ip)
	74	{
	75	char addr = (char )ip;
	76
f0178fc0	77	return addr >= __entry_text_start && addr < __entry_text_end;
a8b7a923 JP	78	}
a8b7a923 JP	79
b0d50c7b JP	80	static inline unsigned long last_frame(struct unwind_state state)
	81	{
	82	return (unsigned long *)task_pt_regs(state->task) - 2;
	83	}
	84
519fb5c3 JP	85	static bool is_last_frame(struct unwind_state *state)
	86	{
	87	return state->bp == last_frame(state);
	88	}
	89
87a6b297 JP	90	#ifdef CONFIG_X86_32
	91	#define GCC_REALIGN_WORDS 3
	92	#else
	93	#define GCC_REALIGN_WORDS 1
	94	#endif
	95
b0d50c7b JP	96	static inline unsigned long last_aligned_frame(struct unwind_state state)
	97	{
	98	return last_frame(state) - GCC_REALIGN_WORDS;
	99	}
	100
519fb5c3	101	static bool is_last_aligned_frame(struct unwind_state *state)
acb4608a	102	{
b0d50c7b JP	103	unsigned long *last_bp = last_frame(state);
b0d50c7b JP	104	unsigned long *aligned_bp = last_aligned_frame(state);
acb4608a	105
8023e0e2	106	/*
519fb5c3 JP	107	* GCC can occasionally decide to realign the stack pointer and change
	108	* the offset of the stack frame in the prologue of a function called
	109	* by head/entry code. Examples:
87a6b297 JP	110	*
	111	* <start_secondary>:
	112	* push %edi
	113	* lea 0x8(%esp),%edi
	114	* and $0xfffffff8,%esp
	115	* pushl -0x4(%edi)
	116	* push %ebp
	117	* mov %esp,%ebp
	118	*
	119	* <x86_64_start_kernel>:
	120	* lea 0x8(%rsp),%r10
	121	* and $0xfffffffffffffff0,%rsp
	122	* pushq -0x8(%r10)
	123	* push %rbp
	124	* mov %rsp,%rbp
	125	*
519fb5c3 JP	126	* After aligning the stack, it pushes a duplicate copy of the return
	127	* address before pushing the frame pointer.
	128	*/
	129	return (state->bp == aligned_bp && (aligned_bp + 1) == (last_bp + 1));
	130	}
	131
	132	static bool is_last_ftrace_frame(struct unwind_state *state)
	133	{
	134	unsigned long *last_bp = last_frame(state);
	135	unsigned long *last_ftrace_bp = last_bp - 3;
	136
	137	/*
	138	* When unwinding from an ftrace handler of a function called by entry
	139	* code, the stack layout of the last frame is:
	140	*
	141	* bp
	142	* parent ret addr
	143	* bp
	144	* function ret addr
	145	* parent ret addr
	146	* pt_regs
	147	* -----------------
8023e0e2	148	*/
519fb5c3 JP	149	return (state->bp == last_ftrace_bp &&
	150	state->bp == (state->bp + 2) &&
	151	(state->bp + 1) == (state->bp + 4));
	152	}
	153
	154	static bool is_last_task_frame(struct unwind_state *state)
	155	{
	156	return is_last_frame(state) \|\| is_last_aligned_frame(state) \|\|
	157	is_last_ftrace_frame(state);
acb4608a JP	158	}
acb4608a JP	159
946c1911 JP	160	/*
	161	* This determines if the frame pointer actually contains an encoded pointer to
	162	* pt_regs on the stack. See ENCODE_FRAME_POINTER.
	163	*/
5c99b692	164	#ifdef CONFIG_X86_64
946c1911 JP	165	static struct pt_regs decode_frame_pointer(unsigned long bp)
	166	{
	167	unsigned long regs = (unsigned long)bp;
	168
	169	if (!(regs & 0x1))
	170	return NULL;
	171
	172	return (struct pt_regs *)(regs & ~0x1);
	173	}
5c99b692 JP	174	#else
	175	static struct pt_regs decode_frame_pointer(unsigned long bp)
	176	{
	177	unsigned long regs = (unsigned long)bp;
	178
	179	if (regs & 0x80000000)
	180	return NULL;
	181
	182	return (struct pt_regs *)(regs \| 0x80000000);
	183	}
	184	#endif
946c1911	185
5ed8d8bb JP	186	static bool update_stack_state(struct unwind_state *state,
5ed8d8bb JP	187	unsigned long *next_bp)
7c7900f8 JP	188	{
7c7900f8 JP	189	struct stack_info *info = &state->stack_info;
5ed8d8bb JP	190	enum stack_type prev_type = info->type;
5ed8d8bb JP	191	struct pt_regs *regs;
6bcdf9d5	192	unsigned long frame, prev_frame_end, *addr_p, addr;
5ed8d8bb JP	193	size_t len;
	194
	195	if (state->regs)
3c88c692	196	prev_frame_end = (void )state->regs + sizeof(state->regs);
5ed8d8bb JP	197	else
	198	prev_frame_end = (void *)state->bp + FRAME_HEADER_SIZE;
	199
	200	/* Is the next frame pointer an encoded pointer to pt_regs? */
	201	regs = decode_frame_pointer(next_bp);
	202	if (regs) {
	203	frame = (unsigned long *)regs;
3c88c692	204	len = sizeof(*regs);
a8b7a923	205	state->got_irq = true;
5ed8d8bb JP	206	} else {
	207	frame = next_bp;
	208	len = FRAME_HEADER_SIZE;
	209	}
7c7900f8 JP	210
7c7900f8 JP	211	/*
5ed8d8bb	212	* If the next bp isn't on the current stack, switch to the next one.
7c7900f8 JP	213	*
7c7900f8 JP	214	* We may have to traverse multiple stacks to deal with the possibility
5ed8d8bb JP	215	* that info->next_sp could point to an empty stack and the next bp
5ed8d8bb JP	216	* could be on a subsequent stack.
7c7900f8	217	*/
5ed8d8bb	218	while (!on_stack(info, frame, len))
7c7900f8 JP	219	if (get_stack_info(info->next_sp, state->task, info,
	220	&state->stack_mask))
	221	return false;
	222
5ed8d8bb JP	223	/* Make sure it only unwinds up and doesn't overlap the prev frame: */
	224	if (state->orig_sp && state->stack_info.type == prev_type &&
	225	frame < prev_frame_end)
	226	return false;
	227
	228	/* Move state to the next frame: */
	229	if (regs) {
	230	state->regs = regs;
	231	state->bp = NULL;
	232	} else {
	233	state->bp = next_bp;
	234	state->regs = NULL;
	235	}
	236
6bcdf9d5 JP	237	/* Save the return address: */
	238	if (state->regs && user_mode(state->regs))
	239	state->ip = 0;
	240	else {
	241	addr_p = unwind_get_return_address_ptr(state);
	242	addr = READ_ONCE_TASK_STACK(state->task, *addr_p);
	243	state->ip = ftrace_graph_ret_addr(state->task, &state->graph_idx,
	244	addr, addr_p);
	245	}
	246
5ed8d8bb	247	/* Save the original stack pointer for unwind_dump(): */
262fa734	248	if (!state->orig_sp)
5ed8d8bb	249	state->orig_sp = frame;
8b5e99f0	250
7c7900f8 JP	251	return true;
	252	}
	253
	254	bool unwind_next_frame(struct unwind_state *state)
	255	{
946c1911	256	struct pt_regs *regs;
5ed8d8bb	257	unsigned long *next_bp;
7c7900f8 JP	258
	259	if (unwind_done(state))
	260	return false;
	261
5ed8d8bb	262	/* Have we reached the end? */
946c1911 JP	263	if (state->regs && user_mode(state->regs))
	264	goto the_end;
	265
acb4608a JP	266	if (is_last_task_frame(state)) {
	267	regs = task_pt_regs(state->task);
	268
	269	/*
	270	* kthreads (other than the boot CPU's idle thread) have some
	271	* partial regs at the end of their stack which were placed
714acdbd	272	* there by copy_thread(). But the regs don't have any
acb4608a JP	273	* useful information, so we can skip them.
	274	*
	275	* This user_mode() check is slightly broader than a PF_KTHREAD
	276	* check because it also catches the awkward situation where a
	277	* newly forked kthread transitions into a user task by calling
be619f7f	278	* kernel_execve(), which eventually clears PF_KTHREAD.
acb4608a JP	279	*/
	280	if (!user_mode(regs))
	281	goto the_end;
	282
	283	/*
	284	* We're almost at the end, but not quite: there's still the
	285	* syscall regs frame. Entry code doesn't encode the regs
	286	* pointer for syscalls, so we have to set it manually.
	287	*/
	288	state->regs = regs;
	289	state->bp = NULL;
6bcdf9d5	290	state->ip = 0;
acb4608a JP	291	return true;
	292	}
	293
5ed8d8bb	294	/* Get the next frame pointer: */
f4f34e1b JH	295	if (state->next_bp) {
	296	next_bp = state->next_bp;
	297	state->next_bp = NULL;
	298	} else if (state->regs) {
946c1911	299	next_bp = (unsigned long *)state->regs->bp;
f4f34e1b	300	} else {
5ed8d8bb	301	next_bp = (unsigned long )READ_ONCE_TASK_STACK(state->task, state->bp);
f4f34e1b	302	}
946c1911	303
5ed8d8bb	304	/* Move to the next frame if it's safe: */
a8b7a923	305	if (!update_stack_state(state, next_bp))
c32c47c6	306	goto bad_address;
c32c47c6	307
7c7900f8	308	return true;
946c1911	309
c32c47c6	310	bad_address:
af085d90 JP	311	state->error = true;
af085d90 JP	312
900742d8 JP	313	/*
	314	* When unwinding a non-current task, the task might actually be
	315	* running on another CPU, in which case it could be modifying its
	316	* stack while we're reading it. This is generally not a problem and
	317	* can be ignored as long as the caller understands that unwinding
	318	* another task will not always succeed.
	319	*/
	320	if (state->task != current)
	321	goto the_end;
	322
a8b7a923 JP	323	/*
a8b7a923 JP	324	* Don't warn if the unwinder got lost due to an interrupt in entry
b0d50c7b	325	* code or in the C handler before the first frame pointer got set up:
a8b7a923 JP	326	*/
	327	if (state->got_irq && in_entry_code(state->ip))
	328	goto the_end;
b0d50c7b JP	329	if (state->regs &&
	330	state->regs->sp >= (unsigned long)last_aligned_frame(state) &&
	331	state->regs->sp < (unsigned long)task_pt_regs(state->task))
	332	goto the_end;
a8b7a923	333
d4a2d031 JP	334	/*
	335	* There are some known frame pointer issues on 32-bit. Disable
	336	* unwinder warnings on 32-bit until it gets objtool support.
	337	*/
	338	if (IS_ENABLED(CONFIG_X86_32))
	339	goto the_end;
	340
b08418b5 JP	341	if (state->task != current)
	342	goto the_end;
	343
24d86f59 JP	344	if (state->regs) {
	345	printk_deferred_once(KERN_WARNING
	346	"WARNING: kernel stack regs at %p in %s:%d has bad 'bp' value %p\n",
	347	state->regs, state->task->comm,
5ed8d8bb	348	state->task->pid, next_bp);
aa4f8534	349	unwind_dump(state);
24d86f59 JP	350	} else {
	351	printk_deferred_once(KERN_WARNING
	352	"WARNING: kernel stack frame pointer at %p in %s:%d has bad value %p\n",
	353	state->bp, state->task->comm,
5ed8d8bb	354	state->task->pid, next_bp);
aa4f8534	355	unwind_dump(state);
24d86f59	356	}
946c1911 JP	357	the_end:
	358	state->stack_info.type = STACK_TYPE_UNKNOWN;
	359	return false;
7c7900f8 JP	360	}
	361	EXPORT_SYMBOL_GPL(unwind_next_frame);
	362
	363	void __unwind_start(struct unwind_state state, struct task_struct task,
	364	struct pt_regs regs, unsigned long first_frame)
	365	{
5ed8d8bb	366	unsigned long *bp;
946c1911	367
7c7900f8 JP	368	memset(state, 0, sizeof(*state));
7c7900f8 JP	369	state->task = task;
a8b7a923	370	state->got_irq = (regs);
7c7900f8	371
5ed8d8bb	372	/* Don't even attempt to start from user mode regs: */
7c7900f8 JP	373	if (regs && user_mode(regs)) {
	374	state->stack_info.type = STACK_TYPE_UNKNOWN;
	375	return;
	376	}
	377
946c1911	378	bp = get_frame_pointer(task, regs);
7c7900f8	379
f4f34e1b JH	380	/*
	381	* If we crash with IP==0, the last successfully executed instruction
	382	* was probably an indirect function call with a NULL function pointer.
	383	* That means that SP points into the middle of an incomplete frame:
	384	* SP is a return pointer, and (SP-sizeof(unsigned long)) is where we
	385	* would have written a frame pointer if we hadn't crashed.
	386	* Pretend that the frame is complete and that BP points to it, but save
	387	* the real BP so that we can use it when looking for the next frame.
	388	*/
3c88c692	389	if (regs && regs->ip == 0 && (unsigned long *)regs->sp >= first_frame) {
f4f34e1b	390	state->next_bp = bp;
3c88c692	391	bp = ((unsigned long *)regs->sp) - 1;
f4f34e1b JH	392	}
f4f34e1b JH	393
5ed8d8bb JP	394	/* Initialize stack info and make sure the frame data is accessible: */
5ed8d8bb JP	395	get_stack_info(bp, state->task, &state->stack_info,
7c7900f8	396	&state->stack_mask);
5ed8d8bb	397	update_stack_state(state, bp);
7c7900f8 JP	398
	399	/*
	400	* The caller can provide the address of the first frame directly
	401	* (first_frame) or indirectly (regs->sp) to indicate which stack frame
	402	* to start unwinding at. Skip ahead until we reach it.
	403	*/
	404	while (!unwind_done(state) &&
	405	(!on_stack(&state->stack_info, first_frame, sizeof(long)) \|\|
f4f34e1b	406	(state->next_bp == NULL && state->bp < first_frame)))
7c7900f8 JP	407	unwind_next_frame(state);
	408	}
	409	EXPORT_SYMBOL_GPL(__unwind_start);