// SPDX-License-Identifier: GPL-2.0/* * Stack trace management functions * *  Copyright IBM Corp. 2006 */ #include <linux/perf_event.h>#include <linux/stacktrace.h>#include <linux/uaccess.h>#include <asm/asm-offsets.h>#include <asm/stacktrace.h>#include <asm/unwind.h>#include <asm/kprobes.h>#include <asm/ptrace.h> void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,		     struct task_struct *task, struct pt_regs *regs){	struct unwind_state state;	unsigned long addr; 	unwind_for_each_frame(&state, task, regs, 0) {		addr = unwind_get_return_address(&state);		if (!addr || !consume_entry(cookie, addr))			break;	}} int arch_stack_walk_reliable(stack_trace_consume_fn consume_entry,			     void *cookie, struct task_struct *task){	struct unwind_state state;	unsigned long addr; 	unwind_for_each_frame(&state, task, NULL, 0) {		if (state.stack_info.type != STACK_TYPE_TASK)			return -EINVAL; 		if (state.regs)			return -EINVAL; 		addr = unwind_get_return_address(&state);		if (!addr)			return -EINVAL; #ifdef CONFIG_RETHOOK		/*		 * Mark stacktraces with krethook functions on them		 * as unreliable.		 */		if (state.ip == (unsigned long)arch_rethook_trampoline)			return -EINVAL;#endif 		if (!consume_entry(cookie, addr))			return -EINVAL;	} 	/* Check for stack corruption */	if (unwind_error(&state))		return -EINVAL;	return 0;} static inline bool store_ip(stack_trace_consume_fn consume_entry, void *cookie,			    struct perf_callchain_entry_ctx *entry, bool perf,			    unsigned long ip){#ifdef CONFIG_PERF_EVENTS	if (perf) {		if (perf_callchain_store(entry, ip))			return false;		return true;	}#endif	return consume_entry(cookie, ip);} static inline bool ip_invalid(unsigned long ip){	/*	 * Perform some basic checks if an instruction address taken	 * from unreliable source is invalid.	 */	if (ip & 1)		return true;	if (ip < mmap_min_addr)		return true;	if (ip >= current->mm->context.asce_limit)		return true;	return false;} static inline bool ip_within_vdso(unsigned long ip){	return in_range(ip, current->mm->context.vdso_base, vdso_text_size());} void arch_stack_walk_user_common(stack_trace_consume_fn consume_entry, void *cookie,				 struct perf_callchain_entry_ctx *entry,				 const struct pt_regs *regs, bool perf){	struct stack_frame_vdso_wrapper __user *sf_vdso;	struct stack_frame_user __user *sf;	unsigned long ip, sp; 	if (!current->mm)		return;	ip = instruction_pointer(regs);	if (!store_ip(consume_entry, cookie, entry, perf, ip))		return;	sf = (void __user *)user_stack_pointer(regs);	pagefault_disable();	while (1) {		if (__get_user(sp, &sf->back_chain))			break;		/*		 * VDSO entry code has a non-standard stack frame layout.		 * See VDSO user wrapper code for details.		 */		if (!sp && ip_within_vdso(ip)) {			sf_vdso = (void __user *)sf;			if (__get_user(ip, &sf_vdso->return_address))				break;			sp = (unsigned long)sf + STACK_FRAME_VDSO_OVERHEAD;			sf = (void __user *)sp;			if (__get_user(sp, &sf->back_chain))				break;		} else {			sf = (void __user *)sp;			if (__get_user(ip, &sf->gprs[8]))				break;		}		/* Validate SP and RA (ABI requires SP to be 8 byte aligned). */		if (sp & 0x7 || ip_invalid(ip))			break;		if (!store_ip(consume_entry, cookie, entry, perf, ip))			break;	}	pagefault_enable();} void arch_stack_walk_user(stack_trace_consume_fn consume_entry, void *cookie,			  const struct pt_regs *regs){	arch_stack_walk_user_common(consume_entry, cookie, NULL, regs, false);}