[linux-2.6-block.git] / arch / s390 / kernel / unwind_bc.c

/* SPDX-License-Identifier: GPL-2.0 */
#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>

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);

static bool outside_of_stack(struct unwind_state *state, unsigned long sp)
{
	return (sp <= state->sp) ||
		(sp + sizeof(struct stack_frame) > state->stack_info.end);
}

static bool update_stack_info(struct unwind_state *state, unsigned long sp)
{
	struct stack_info *info = &state->stack_info;
	unsigned long *mask = &state->stack_mask;

	/* New stack pointer leaves the current stack */
	if (get_stack_info(sp, state->task, info, mask) != 0 ||
	    !on_stack(info, sp, sizeof(struct stack_frame)))
		/* 'sp' does not point to a valid stack */
		return false;
	return true;
}

bool unwind_next_frame(struct unwind_state *state)
{
	struct stack_info *info = &state->stack_info;
	struct stack_frame *sf;
	struct pt_regs *regs;
	unsigned long sp, ip;
	bool reliable;

	regs = state->regs;
	if (unlikely(regs)) {
		sp = READ_ONCE_TASK_STACK(state->task, regs->gprs[15]);
		if (unlikely(outside_of_stack(state, sp))) {
			if (!update_stack_info(state, sp))
				goto out_err;
		}
		sf = (struct stack_frame *) sp;
		ip = READ_ONCE_TASK_STACK(state->task, sf->gprs[8]);
		reliable = false;
		regs = NULL;
	} else {
		sf = (struct stack_frame *) state->sp;
		sp = READ_ONCE_TASK_STACK(state->task, sf->back_chain);
		if (likely(sp)) {
			/* Non-zero back-chain points to the previous frame */
			if (unlikely(outside_of_stack(state, sp))) {
				if (!update_stack_info(state, sp))
					goto out_err;
			}
			sf = (struct stack_frame *) sp;
			ip = READ_ONCE_TASK_STACK(state->task, sf->gprs[8]);
			reliable = true;
		} else {
			/* No back-chain, look for a pt_regs structure */
			sp = state->sp + STACK_FRAME_OVERHEAD;
			if (!on_stack(info, sp, sizeof(struct pt_regs)))
				goto out_stop;
			regs = (struct pt_regs *) sp;
			if (user_mode(regs))
				goto out_stop;
			ip = READ_ONCE_TASK_STACK(state->task, regs->psw.addr);
			reliable = true;
		}
	}

#ifdef CONFIG_FUNCTION_GRAPH_TRACER
	/* Decode any ftrace redirection */
	if (ip == (unsigned long) return_to_handler)
		ip = ftrace_graph_ret_addr(state->task, &state->graph_idx,
					   ip, (void *) sp);
#endif

	/* Update unwind state */
	state->sp = sp;
	state->ip = ip;
	state->regs = regs;
	state->reliable = reliable;
	return true;

out_err:
	state->error = true;
out_stop:
	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 sp)
{
	struct stack_info *info = &state->stack_info;
	unsigned long *mask = &state->stack_mask;
	struct stack_frame *sf;
	unsigned long ip;
	bool reliable;

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

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

	/* Get current stack pointer and initialize stack info */
	if (get_stack_info(sp, task, info, mask) != 0 ||
	    !on_stack(info, sp, sizeof(struct stack_frame))) {
		/* Something is wrong with the stack pointer */
		info->type = STACK_TYPE_UNKNOWN;
		state->error = true;
		return;
	}

	/* Get the instruction pointer from pt_regs or the stack frame */
	if (regs) {
		ip = READ_ONCE_TASK_STACK(state->task, regs->psw.addr);
		reliable = true;
	} else {
		sf = (struct stack_frame *) sp;
		ip = READ_ONCE_TASK_STACK(state->task, sf->gprs[8]);
		reliable = false;
	}

#ifdef CONFIG_FUNCTION_GRAPH_TRACER
	/* Decode any ftrace redirection */
	if (ip == (unsigned long) return_to_handler)
		ip = ftrace_graph_ret_addr(state->task, &state->graph_idx,
					   ip, NULL);
#endif

	/* Update unwind state */
	state->sp = sp;
	state->ip = ip;
	state->reliable = reliable;
}
EXPORT_SYMBOL_GPL(__unwind_start);
Commit	Line	Data
78c98f90 MS	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#include <linux/sched.h>
	3	#include <linux/sched/task.h>
	4	#include <linux/sched/task_stack.h>
	5	#include <linux/interrupt.h>
	6	#include <asm/sections.h>
	7	#include <asm/ptrace.h>
	8	#include <asm/bitops.h>
	9	#include <asm/stacktrace.h>
	10	#include <asm/unwind.h>
	11
	12	unsigned long unwind_get_return_address(struct unwind_state *state)
	13	{
	14	if (unwind_done(state))
	15	return 0;
	16	return __kernel_text_address(state->ip) ? state->ip : 0;
	17	}
	18	EXPORT_SYMBOL_GPL(unwind_get_return_address);
	19
	20	static bool outside_of_stack(struct unwind_state *state, unsigned long sp)
	21	{
	22	return (sp <= state->sp) \|\|
	23	(sp + sizeof(struct stack_frame) > state->stack_info.end);
	24	}
	25
	26	static bool update_stack_info(struct unwind_state *state, unsigned long sp)
	27	{
	28	struct stack_info *info = &state->stack_info;
	29	unsigned long *mask = &state->stack_mask;
	30
	31	/* New stack pointer leaves the current stack */
	32	if (get_stack_info(sp, state->task, info, mask) != 0 \|\|
	33	!on_stack(info, sp, sizeof(struct stack_frame)))
	34	/* 'sp' does not point to a valid stack */
	35	return false;
	36	return true;
	37	}
	38
	39	bool unwind_next_frame(struct unwind_state *state)
	40	{
	41	struct stack_info *info = &state->stack_info;
	42	struct stack_frame *sf;
	43	struct pt_regs *regs;
	44	unsigned long sp, ip;
	45	bool reliable;
	46
	47	regs = state->regs;
	48	if (unlikely(regs)) {
	49	sp = READ_ONCE_TASK_STACK(state->task, regs->gprs[15]);
	50	if (unlikely(outside_of_stack(state, sp))) {
	51	if (!update_stack_info(state, sp))
	52	goto out_err;
	53	}
	54	sf = (struct stack_frame *) sp;
	55	ip = READ_ONCE_TASK_STACK(state->task, sf->gprs[8]);
	56	reliable = false;
	57	regs = NULL;
	58	} else {
	59	sf = (struct stack_frame *) state->sp;
	60	sp = READ_ONCE_TASK_STACK(state->task, sf->back_chain);
	61	if (likely(sp)) {
	62	/* Non-zero back-chain points to the previous frame */
	63	if (unlikely(outside_of_stack(state, sp))) {
	64	if (!update_stack_info(state, sp))
65	goto out_err;
66	}
67	sf = (struct stack_frame *) sp;
68	ip = READ_ONCE_TASK_STACK(state->task, sf->gprs[8]);
69	reliable = true;
70	} else {
71	/* No back-chain, look for a pt_regs structure */
72	sp = state->sp + STACK_FRAME_OVERHEAD;
73	if (!on_stack(info, sp, sizeof(struct pt_regs)))
74	goto out_stop;
75	regs = (struct pt_regs *) sp;
76	if (user_mode(regs))
77	goto out_stop;
78	ip = READ_ONCE_TASK_STACK(state->task, regs->psw.addr);
79	reliable = true;
80	}
81	}
82
83	#ifdef CONFIG_FUNCTION_GRAPH_TRACER
84	/* Decode any ftrace redirection */
85	if (ip == (unsigned long) return_to_handler)
86	ip = ftrace_graph_ret_addr(state->task, &state->graph_idx,
ec7bf478	87	ip, (void *) sp);
78c98f90 MS	88	#endif
	89
	90	/* Update unwind state */
	91	state->sp = sp;
	92	state->ip = ip;
	93	state->regs = regs;
	94	state->reliable = reliable;
	95	return true;
	96
	97	out_err:
	98	state->error = true;
	99	out_stop:
	100	state->stack_info.type = STACK_TYPE_UNKNOWN;
	101	return false;
	102	}
	103	EXPORT_SYMBOL_GPL(unwind_next_frame);
	104
	105	void __unwind_start(struct unwind_state state, struct task_struct task,
	106	struct pt_regs *regs, unsigned long sp)
	107	{
	108	struct stack_info *info = &state->stack_info;
	109	unsigned long *mask = &state->stack_mask;
	110	struct stack_frame *sf;
	111	unsigned long ip;
	112	bool reliable;
	113
	114	memset(state, 0, sizeof(*state));
	115	state->task = task;
	116	state->regs = regs;
	117
	118	/* Don't even attempt to start from user mode regs: */
	119	if (regs && user_mode(regs)) {
	120	info->type = STACK_TYPE_UNKNOWN;
	121	return;
	122	}
	123
	124	/* Get current stack pointer and initialize stack info */
	125	if (get_stack_info(sp, task, info, mask) != 0 \|\|
	126	!on_stack(info, sp, sizeof(struct stack_frame))) {
	127	/* Something is wrong with the stack pointer */
	128	info->type = STACK_TYPE_UNKNOWN;
	129	state->error = true;
	130	return;
	131	}
	132
	133	/* Get the instruction pointer from pt_regs or the stack frame */
	134	if (regs) {
	135	ip = READ_ONCE_TASK_STACK(state->task, regs->psw.addr);
	136	reliable = true;
	137	} else {
	138	sf = (struct stack_frame *) sp;
	139	ip = READ_ONCE_TASK_STACK(state->task, sf->gprs[8]);
	140	reliable = false;
	141	}
	142
	143	#ifdef CONFIG_FUNCTION_GRAPH_TRACER
	144	/* Decode any ftrace redirection */
	145	if (ip == (unsigned long) return_to_handler)
	146	ip = ftrace_graph_ret_addr(state->task, &state->graph_idx,
	147	ip, NULL);
	148	#endif
	149
	150	/* Update unwind state */
	151	state->sp = sp;
152	state->ip = ip;
153	state->reliable = reliable;
154	}
155	EXPORT_SYMBOL_GPL(__unwind_start);