// SPDX-License-Identifier: GPL-2.0/** Generic interfaces for unwinding user space*/#include <linux/kernel.h>#include <linux/sched.h>#include <linux/sched/task_stack.h>#include <linux/unwind_user.h>#include <linux/uaccess.h> #define for_each_user_frame(state) \	for (unwind_user_start(state); !(state)->done; unwind_user_next(state)) static inline intget_user_word(unsigned long *word, unsigned long base, int off, unsigned int ws){	unsigned long __user *addr = (void __user *)base + off;#ifdef CONFIG_COMPAT	if (ws == sizeof(int)) {		unsigned int data;		int ret = get_user(data, (unsigned int __user *)addr);		*word = data;		return ret;	}#endif	return get_user(*word, addr);} static int unwind_user_next_common(struct unwind_user_state *state,				   const struct unwind_user_frame *frame){	unsigned long cfa, fp, ra; 	/* Get the Canonical Frame Address (CFA) */	if (frame->use_fp) {		if (state->fp < state->sp)			return -EINVAL;		cfa = state->fp;	} else {		cfa = state->sp;	}	cfa += frame->cfa_off; 	/* Make sure that stack is not going in wrong direction */	if (cfa <= state->sp)		return -EINVAL; 	/* Make sure that the address is word aligned */	if (cfa & (state->ws - 1))		return -EINVAL; 	/* Get the Return Address (RA) */	if (get_user_word(&ra, cfa, frame->ra_off, state->ws))		return -EINVAL; 	/* Get the Frame Pointer (FP) */	if (frame->fp_off && get_user_word(&fp, cfa, frame->fp_off, state->ws))		return -EINVAL; 	state->ip = ra;	state->sp = cfa;	if (frame->fp_off)		state->fp = fp;	state->topmost = false;	return 0;} static int unwind_user_next_fp(struct unwind_user_state *state){	struct pt_regs *regs = task_pt_regs(current); 	if (state->topmost && unwind_user_at_function_start(regs)) {		const struct unwind_user_frame fp_entry_frame = {			ARCH_INIT_USER_FP_ENTRY_FRAME(state->ws)		};		return unwind_user_next_common(state, &fp_entry_frame);	} 	const struct unwind_user_frame fp_frame = {		ARCH_INIT_USER_FP_FRAME(state->ws)	};	return unwind_user_next_common(state, &fp_frame);} static int unwind_user_next(struct unwind_user_state *state){	unsigned long iter_mask = state->available_types;	unsigned int bit; 	if (state->done)		return -EINVAL; 	for_each_set_bit(bit, &iter_mask, NR_UNWIND_USER_TYPE_BITS) {		enum unwind_user_type type = BIT(bit); 		state->current_type = type;		switch (type) {		case UNWIND_USER_TYPE_FP:			if (!unwind_user_next_fp(state))				return 0;			continue;		default:			WARN_ONCE(1, "Undefined unwind bit %d", bit);			break;		}		break;	} 	/* No successful unwind method. */	state->current_type = UNWIND_USER_TYPE_NONE;	state->done = true;	return -EINVAL;} static int unwind_user_start(struct unwind_user_state *state){	struct pt_regs *regs = task_pt_regs(current); 	memset(state, 0, sizeof(*state)); 	if ((current->flags & PF_KTHREAD) || !user_mode(regs)) {		state->done = true;		return -EINVAL;	} 	if (IS_ENABLED(CONFIG_HAVE_UNWIND_USER_FP))		state->available_types |= UNWIND_USER_TYPE_FP; 	state->ip = instruction_pointer(regs);	state->sp = user_stack_pointer(regs);	state->fp = frame_pointer(regs);	state->ws = unwind_user_word_size(regs);	if (!state->ws) {		state->done = true;		return -EINVAL;	}	state->topmost = true; 	return 0;} int unwind_user(struct unwind_stacktrace *trace, unsigned int max_entries){	struct unwind_user_state state; 	trace->nr = 0; 	if (!max_entries)		return -EINVAL; 	if (current->flags & PF_KTHREAD)		return 0; 	for_each_user_frame(&state) {		trace->entries[trace->nr++] = state.ip;		if (trace->nr >= max_entries)			break;	} 	return 0;}