1// SPDX-License-Identifier: GPL-2.0-or-later
2/**
3 * Copyright (C) 2005 Brian Rogan <bcr6@cornell.edu>, IBM
4 *
5**/
6
7#include <linux/time.h>
8#include <linux/oprofile.h>
9#include <linux/sched.h>
10#include <asm/processor.h>
11#include <linux/uaccess.h>
12#include <linux/compat.h>
13#include <asm/oprofile_impl.h>
14
15#define STACK_SP(STACK)		*(STACK)
16
17#define STACK_LR64(STACK)	*((unsigned long *)(STACK) + 2)
18#define STACK_LR32(STACK)	*((unsigned int *)(STACK) + 1)
19
20#ifdef CONFIG_PPC64
21#define STACK_LR(STACK)		STACK_LR64(STACK)
22#else
23#define STACK_LR(STACK)		STACK_LR32(STACK)
24#endif
25
26static unsigned int user_getsp32(unsigned int sp, int is_first)
27{
28	unsigned int stack_frame[2];
29	void __user *p = compat_ptr(sp);
30
31	/*
32	 * The most likely reason for this is that we returned -EFAULT,
33	 * which means that we've done all that we can do from
34	 * interrupt context.
35	 */
36	if (copy_from_user_nofault(stack_frame, (void __user *)p,
37			sizeof(stack_frame)))
38		return 0;
39
40	if (!is_first)
41		oprofile_add_trace(STACK_LR32(stack_frame));
42
43	/*
44	 * We do not enforce increasing stack addresses here because
45	 * we may transition to a different stack, eg a signal handler.
46	 */
47	return STACK_SP(stack_frame);
48}
49
50#ifdef CONFIG_PPC64
51static unsigned long user_getsp64(unsigned long sp, int is_first)
52{
53	unsigned long stack_frame[3];
54
55	if (copy_from_user_nofault(stack_frame, (void __user *)sp,
56			sizeof(stack_frame)))
57		return 0;
58
59	if (!is_first)
60		oprofile_add_trace(STACK_LR64(stack_frame));
61
62	return STACK_SP(stack_frame);
63}
64#endif
65
66static unsigned long kernel_getsp(unsigned long sp, int is_first)
67{
68	unsigned long *stack_frame = (unsigned long *)sp;
69
70	if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD))
71		return 0;
72
73	if (!is_first)
74		oprofile_add_trace(STACK_LR(stack_frame));
75
76	/*
77	 * We do not enforce increasing stack addresses here because
78	 * we might be transitioning from an interrupt stack to a kernel
79	 * stack. validate_sp() is designed to understand this, so just
80	 * use it.
81	 */
82	return STACK_SP(stack_frame);
83}
84
85void op_powerpc_backtrace(struct pt_regs * const regs, unsigned int depth)
86{
87	unsigned long sp = regs->gpr[1];
88	int first_frame = 1;
89
90	/* We ditch the top stackframe so need to loop through an extra time */
91	depth += 1;
92
93	if (!user_mode(regs)) {
94		while (depth--) {
95			sp = kernel_getsp(sp, first_frame);
96			if (!sp)
97				break;
98			first_frame = 0;
99		}
100	} else {
101#ifdef CONFIG_PPC64
102		if (!is_32bit_task()) {
103			while (depth--) {
104				sp = user_getsp64(sp, first_frame);
105				if (!sp)
106					break;
107				first_frame = 0;
108			}
109			return;
110		}
111#endif
112
113		while (depth--) {
114			sp = user_getsp32(sp, first_frame);
115			if (!sp)
116				break;
117			first_frame = 0;
118		}
119	}
120}
121