mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
147 lines
3.9 KiB
147 lines
3.9 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* Performance counter callchain support - powerpc architecture code |
|
* |
|
* Copyright © 2009 Paul Mackerras, IBM Corporation. |
|
*/ |
|
#include <linux/kernel.h> |
|
#include <linux/sched.h> |
|
#include <linux/perf_event.h> |
|
#include <linux/percpu.h> |
|
#include <linux/uaccess.h> |
|
#include <linux/mm.h> |
|
#include <asm/ptrace.h> |
|
#include <asm/sigcontext.h> |
|
#include <asm/ucontext.h> |
|
#include <asm/vdso.h> |
|
#include <asm/pte-walk.h> |
|
|
|
#include "callchain.h" |
|
|
|
/* |
|
* On 64-bit we don't want to invoke hash_page on user addresses from |
|
* interrupt context, so if the access faults, we read the page tables |
|
* to find which page (if any) is mapped and access it directly. Radix |
|
* has no need for this so it doesn't use read_user_stack_slow. |
|
*/ |
|
int read_user_stack_slow(const void __user *ptr, void *buf, int nb) |
|
{ |
|
|
|
unsigned long addr = (unsigned long) ptr; |
|
unsigned long offset; |
|
struct page *page; |
|
void *kaddr; |
|
|
|
if (get_user_page_fast_only(addr, FOLL_WRITE, &page)) { |
|
kaddr = page_address(page); |
|
|
|
/* align address to page boundary */ |
|
offset = addr & ~PAGE_MASK; |
|
|
|
memcpy(buf, kaddr + offset, nb); |
|
put_page(page); |
|
return 0; |
|
} |
|
return -EFAULT; |
|
} |
|
|
|
static int read_user_stack_64(const unsigned long __user *ptr, unsigned long *ret) |
|
{ |
|
return __read_user_stack(ptr, ret, sizeof(*ret)); |
|
} |
|
|
|
/* |
|
* 64-bit user processes use the same stack frame for RT and non-RT signals. |
|
*/ |
|
struct signal_frame_64 { |
|
char dummy[__SIGNAL_FRAMESIZE]; |
|
struct ucontext uc; |
|
unsigned long unused[2]; |
|
unsigned int tramp[6]; |
|
struct siginfo *pinfo; |
|
void *puc; |
|
struct siginfo info; |
|
char abigap[288]; |
|
}; |
|
|
|
static int is_sigreturn_64_address(unsigned long nip, unsigned long fp) |
|
{ |
|
if (nip == fp + offsetof(struct signal_frame_64, tramp)) |
|
return 1; |
|
if (current->mm->context.vdso && |
|
nip == VDSO64_SYMBOL(current->mm->context.vdso, sigtramp_rt64)) |
|
return 1; |
|
return 0; |
|
} |
|
|
|
/* |
|
* Do some sanity checking on the signal frame pointed to by sp. |
|
* We check the pinfo and puc pointers in the frame. |
|
*/ |
|
static int sane_signal_64_frame(unsigned long sp) |
|
{ |
|
struct signal_frame_64 __user *sf; |
|
unsigned long pinfo, puc; |
|
|
|
sf = (struct signal_frame_64 __user *) sp; |
|
if (read_user_stack_64((unsigned long __user *) &sf->pinfo, &pinfo) || |
|
read_user_stack_64((unsigned long __user *) &sf->puc, &puc)) |
|
return 0; |
|
return pinfo == (unsigned long) &sf->info && |
|
puc == (unsigned long) &sf->uc; |
|
} |
|
|
|
void perf_callchain_user_64(struct perf_callchain_entry_ctx *entry, |
|
struct pt_regs *regs) |
|
{ |
|
unsigned long sp, next_sp; |
|
unsigned long next_ip; |
|
unsigned long lr; |
|
long level = 0; |
|
struct signal_frame_64 __user *sigframe; |
|
unsigned long __user *fp, *uregs; |
|
|
|
next_ip = perf_instruction_pointer(regs); |
|
lr = regs->link; |
|
sp = regs->gpr[1]; |
|
perf_callchain_store(entry, next_ip); |
|
|
|
while (entry->nr < entry->max_stack) { |
|
fp = (unsigned long __user *) sp; |
|
if (invalid_user_sp(sp) || read_user_stack_64(fp, &next_sp)) |
|
return; |
|
if (level > 0 && read_user_stack_64(&fp[2], &next_ip)) |
|
return; |
|
|
|
/* |
|
* Note: the next_sp - sp >= signal frame size check |
|
* is true when next_sp < sp, which can happen when |
|
* transitioning from an alternate signal stack to the |
|
* normal stack. |
|
*/ |
|
if (next_sp - sp >= sizeof(struct signal_frame_64) && |
|
(is_sigreturn_64_address(next_ip, sp) || |
|
(level <= 1 && is_sigreturn_64_address(lr, sp))) && |
|
sane_signal_64_frame(sp)) { |
|
/* |
|
* This looks like an signal frame |
|
*/ |
|
sigframe = (struct signal_frame_64 __user *) sp; |
|
uregs = sigframe->uc.uc_mcontext.gp_regs; |
|
if (read_user_stack_64(&uregs[PT_NIP], &next_ip) || |
|
read_user_stack_64(&uregs[PT_LNK], &lr) || |
|
read_user_stack_64(&uregs[PT_R1], &sp)) |
|
return; |
|
level = 0; |
|
perf_callchain_store_context(entry, PERF_CONTEXT_USER); |
|
perf_callchain_store(entry, next_ip); |
|
continue; |
|
} |
|
|
|
if (level == 0) |
|
next_ip = lr; |
|
perf_callchain_store(entry, next_ip); |
|
++level; |
|
sp = next_sp; |
|
} |
|
}
|
|
|