1376 lines · 32.8 KB · C
RawDownload
/* * This file is subject to the terms and conditions of the GNU General Public * License.  See the file "COPYING" in the main directory of this archive * for more details. * * Copyright (C) 1992 Ross Biro * Copyright (C) Linus Torvalds * Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle * Copyright (C) 1996 David S. Miller * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com * Copyright (C) 1999 MIPS Technologies, Inc. * Copyright (C) 2000 Ulf Carlsson * * At this time Linux/MIPS64 only supports syscall tracing, even for 32-bit * binaries. */#include <linux/compiler.h>#include <linux/context_tracking.h>#include <linux/elf.h>#include <linux/kernel.h>#include <linux/sched.h>#include <linux/sched/task_stack.h>#include <linux/mm.h>#include <linux/errno.h>#include <linux/ptrace.h>#include <linux/regset.h>#include <linux/smp.h>#include <linux/security.h>#include <linux/stddef.h>#include <linux/audit.h>#include <linux/seccomp.h>#include <linux/ftrace.h> #include <asm/branch.h>#include <asm/byteorder.h>#include <asm/cpu.h>#include <asm/cpu-info.h>#include <asm/dsp.h>#include <asm/fpu.h>#include <asm/mipsregs.h>#include <asm/mipsmtregs.h>#include <asm/page.h>#include <asm/processor.h>#include <asm/syscall.h>#include <linux/uaccess.h>#include <asm/bootinfo.h>#include <asm/reg.h> #define CREATE_TRACE_POINTS#include <trace/events/syscalls.h> unsigned long exception_ip(struct pt_regs *regs){	return exception_epc(regs);}EXPORT_SYMBOL(exception_ip); /* * Called by kernel/ptrace.c when detaching.. * * Make sure single step bits etc are not set. */void ptrace_disable(struct task_struct *child){	/* Don't load the watchpoint registers for the ex-child. */	clear_tsk_thread_flag(child, TIF_LOAD_WATCH);} /* * Read a general register set.	 We always use the 64-bit format, even * for 32-bit kernels and for 32-bit processes on a 64-bit kernel. * Registers are sign extended to fill the available space. */int ptrace_getregs(struct task_struct *child, struct user_pt_regs __user *data){	struct pt_regs *regs;	int i; 	if (!access_ok(data, 38 * 8))		return -EIO; 	regs = task_pt_regs(child); 	for (i = 0; i < 32; i++)		__put_user((long)regs->regs[i], (__s64 __user *)&data->regs[i]);	__put_user((long)regs->lo, (__s64 __user *)&data->lo);	__put_user((long)regs->hi, (__s64 __user *)&data->hi);	__put_user((long)regs->cp0_epc, (__s64 __user *)&data->cp0_epc);	__put_user((long)regs->cp0_badvaddr, (__s64 __user *)&data->cp0_badvaddr);	__put_user((long)regs->cp0_status, (__s64 __user *)&data->cp0_status);	__put_user((long)regs->cp0_cause, (__s64 __user *)&data->cp0_cause); 	return 0;} /* * Write a general register set.  As for PTRACE_GETREGS, we always use * the 64-bit format.  On a 32-bit kernel only the lower order half * (according to endianness) will be used. */int ptrace_setregs(struct task_struct *child, struct user_pt_regs __user *data){	struct pt_regs *regs;	int i; 	if (!access_ok(data, 38 * 8))		return -EIO; 	regs = task_pt_regs(child); 	for (i = 0; i < 32; i++)		__get_user(regs->regs[i], (__s64 __user *)&data->regs[i]);	__get_user(regs->lo, (__s64 __user *)&data->lo);	__get_user(regs->hi, (__s64 __user *)&data->hi);	__get_user(regs->cp0_epc, (__s64 __user *)&data->cp0_epc); 	/* badvaddr, status, and cause may not be written.  */ 	/* System call number may have been changed */	mips_syscall_update_nr(child, regs); 	return 0;} int ptrace_get_watch_regs(struct task_struct *child,			  struct pt_watch_regs __user *addr){	enum pt_watch_style style;	int i; 	if (!cpu_has_watch || boot_cpu_data.watch_reg_use_cnt == 0)		return -EIO;	if (!access_ok(addr, sizeof(struct pt_watch_regs)))		return -EIO; #ifdef CONFIG_32BIT	style = pt_watch_style_mips32;#define WATCH_STYLE mips32#else	style = pt_watch_style_mips64;#define WATCH_STYLE mips64#endif 	__put_user(style, &addr->style);	__put_user(boot_cpu_data.watch_reg_use_cnt,		   &addr->WATCH_STYLE.num_valid);	for (i = 0; i < boot_cpu_data.watch_reg_use_cnt; i++) {		__put_user(child->thread.watch.mips3264.watchlo[i],			   &addr->WATCH_STYLE.watchlo[i]);		__put_user(child->thread.watch.mips3264.watchhi[i] &				(MIPS_WATCHHI_MASK | MIPS_WATCHHI_IRW),			   &addr->WATCH_STYLE.watchhi[i]);		__put_user(boot_cpu_data.watch_reg_masks[i],			   &addr->WATCH_STYLE.watch_masks[i]);	}	for (; i < 8; i++) {		__put_user(0, &addr->WATCH_STYLE.watchlo[i]);		__put_user(0, &addr->WATCH_STYLE.watchhi[i]);		__put_user(0, &addr->WATCH_STYLE.watch_masks[i]);	} 	return 0;} int ptrace_set_watch_regs(struct task_struct *child,			  struct pt_watch_regs __user *addr){	int i;	int watch_active = 0;	unsigned long lt[NUM_WATCH_REGS];	u16 ht[NUM_WATCH_REGS]; 	if (!cpu_has_watch || boot_cpu_data.watch_reg_use_cnt == 0)		return -EIO;	if (!access_ok(addr, sizeof(struct pt_watch_regs)))		return -EIO;	/* Check the values. */	for (i = 0; i < boot_cpu_data.watch_reg_use_cnt; i++) {		__get_user(lt[i], &addr->WATCH_STYLE.watchlo[i]);#ifdef CONFIG_32BIT		if (lt[i] & __UA_LIMIT)			return -EINVAL;#else		if (test_tsk_thread_flag(child, TIF_32BIT_ADDR)) {			if (lt[i] & 0xffffffff80000000UL)				return -EINVAL;		} else {			if (lt[i] & __UA_LIMIT)				return -EINVAL;		}#endif		__get_user(ht[i], &addr->WATCH_STYLE.watchhi[i]);		if (ht[i] & ~MIPS_WATCHHI_MASK)			return -EINVAL;	}	/* Install them. */	for (i = 0; i < boot_cpu_data.watch_reg_use_cnt; i++) {		if (lt[i] & MIPS_WATCHLO_IRW)			watch_active = 1;		child->thread.watch.mips3264.watchlo[i] = lt[i];		/* Set the G bit. */		child->thread.watch.mips3264.watchhi[i] = ht[i];	} 	if (watch_active)		set_tsk_thread_flag(child, TIF_LOAD_WATCH);	else		clear_tsk_thread_flag(child, TIF_LOAD_WATCH); 	return 0;} /* regset get/set implementations */ #if defined(CONFIG_32BIT) || defined(CONFIG_MIPS32_O32) static int gpr32_get(struct task_struct *target,		     const struct user_regset *regset,		     struct membuf to){	struct pt_regs *regs = task_pt_regs(target);	u32 uregs[ELF_NGREG] = {}; 	mips_dump_regs32(uregs, regs);	return membuf_write(&to, uregs, sizeof(uregs));} static int gpr32_set(struct task_struct *target,		     const struct user_regset *regset,		     unsigned int pos, unsigned int count,		     const void *kbuf, const void __user *ubuf){	struct pt_regs *regs = task_pt_regs(target);	u32 uregs[ELF_NGREG];	unsigned start, num_regs, i;	int err; 	start = pos / sizeof(u32);	num_regs = count / sizeof(u32); 	if (start + num_regs > ELF_NGREG)		return -EIO; 	err = user_regset_copyin(&pos, &count, &kbuf, &ubuf, uregs, 0,				 sizeof(uregs));	if (err)		return err; 	for (i = start; i < num_regs; i++) {		/*		 * Cast all values to signed here so that if this is a 64-bit		 * kernel, the supplied 32-bit values will be sign extended.		 */		switch (i) {		case MIPS32_EF_R1 ... MIPS32_EF_R25:			/* k0/k1 are ignored. */		case MIPS32_EF_R28 ... MIPS32_EF_R31:			regs->regs[i - MIPS32_EF_R0] = (s32)uregs[i];			break;		case MIPS32_EF_LO:			regs->lo = (s32)uregs[i];			break;		case MIPS32_EF_HI:			regs->hi = (s32)uregs[i];			break;		case MIPS32_EF_CP0_EPC:			regs->cp0_epc = (s32)uregs[i];			break;		}	} 	/* System call number may have been changed */	mips_syscall_update_nr(target, regs); 	return 0;} #endif /* CONFIG_32BIT || CONFIG_MIPS32_O32 */ #ifdef CONFIG_64BIT static int gpr64_get(struct task_struct *target,		     const struct user_regset *regset,		     struct membuf to){	struct pt_regs *regs = task_pt_regs(target);	u64 uregs[ELF_NGREG] = {}; 	mips_dump_regs64(uregs, regs);	return membuf_write(&to, uregs, sizeof(uregs));} static int gpr64_set(struct task_struct *target,		     const struct user_regset *regset,		     unsigned int pos, unsigned int count,		     const void *kbuf, const void __user *ubuf){	struct pt_regs *regs = task_pt_regs(target);	u64 uregs[ELF_NGREG];	unsigned start, num_regs, i;	int err; 	start = pos / sizeof(u64);	num_regs = count / sizeof(u64); 	if (start + num_regs > ELF_NGREG)		return -EIO; 	err = user_regset_copyin(&pos, &count, &kbuf, &ubuf, uregs, 0,				 sizeof(uregs));	if (err)		return err; 	for (i = start; i < num_regs; i++) {		switch (i) {		case MIPS64_EF_R1 ... MIPS64_EF_R25:			/* k0/k1 are ignored. */		case MIPS64_EF_R28 ... MIPS64_EF_R31:			regs->regs[i - MIPS64_EF_R0] = uregs[i];			break;		case MIPS64_EF_LO:			regs->lo = uregs[i];			break;		case MIPS64_EF_HI:			regs->hi = uregs[i];			break;		case MIPS64_EF_CP0_EPC:			regs->cp0_epc = uregs[i];			break;		}	} 	/* System call number may have been changed */	mips_syscall_update_nr(target, regs); 	return 0;} #endif /* CONFIG_64BIT */  #ifdef CONFIG_MIPS_FP_SUPPORT /* * Poke at FCSR according to its mask.  Set the Cause bits even * if a corresponding Enable bit is set.  This will be noticed at * the time the thread is switched to and SIGFPE thrown accordingly. */static void ptrace_setfcr31(struct task_struct *child, u32 value){	u32 fcr31;	u32 mask; 	fcr31 = child->thread.fpu.fcr31;	mask = boot_cpu_data.fpu_msk31;	child->thread.fpu.fcr31 = (value & ~mask) | (fcr31 & mask);} int ptrace_getfpregs(struct task_struct *child, __u32 __user *data){	int i; 	if (!access_ok(data, 33 * 8))		return -EIO; 	if (tsk_used_math(child)) {		union fpureg *fregs = get_fpu_regs(child);		for (i = 0; i < 32; i++)			__put_user(get_fpr64(&fregs[i], 0),				   i + (__u64 __user *)data);	} else {		for (i = 0; i < 32; i++)			__put_user((__u64) -1, i + (__u64 __user *) data);	} 	__put_user(child->thread.fpu.fcr31, data + 64);	__put_user(boot_cpu_data.fpu_id, data + 65); 	return 0;} int ptrace_setfpregs(struct task_struct *child, __u32 __user *data){	union fpureg *fregs;	u64 fpr_val;	u32 value;	int i; 	if (!access_ok(data, 33 * 8))		return -EIO; 	init_fp_ctx(child);	fregs = get_fpu_regs(child); 	for (i = 0; i < 32; i++) {		__get_user(fpr_val, i + (__u64 __user *)data);		set_fpr64(&fregs[i], 0, fpr_val);	} 	__get_user(value, data + 64);	ptrace_setfcr31(child, value); 	/* FIR may not be written.  */ 	return 0;} /* * Copy the floating-point context to the supplied NT_PRFPREG buffer, * !CONFIG_CPU_HAS_MSA variant.  FP context's general register slots * correspond 1:1 to buffer slots.  Only general registers are copied. */static void fpr_get_fpa(struct task_struct *target,		       struct membuf *to){	membuf_write(to, &target->thread.fpu,			NUM_FPU_REGS * sizeof(elf_fpreg_t));} /* * Copy the floating-point context to the supplied NT_PRFPREG buffer, * CONFIG_CPU_HAS_MSA variant.  Only lower 64 bits of FP context's * general register slots are copied to buffer slots.  Only general * registers are copied. */static void fpr_get_msa(struct task_struct *target, struct membuf *to){	unsigned int i; 	BUILD_BUG_ON(sizeof(u64) != sizeof(elf_fpreg_t));	for (i = 0; i < NUM_FPU_REGS; i++)		membuf_store(to, get_fpr64(&target->thread.fpu.fpr[i], 0));} /* * Copy the floating-point context to the supplied NT_PRFPREG buffer. * Choose the appropriate helper for general registers, and then copy * the FCSR and FIR registers separately. */static int fpr_get(struct task_struct *target,		   const struct user_regset *regset,		   struct membuf to){	if (sizeof(target->thread.fpu.fpr[0]) == sizeof(elf_fpreg_t))		fpr_get_fpa(target, &to);	else		fpr_get_msa(target, &to); 	membuf_write(&to, &target->thread.fpu.fcr31, sizeof(u32));	membuf_write(&to, &boot_cpu_data.fpu_id, sizeof(u32));	return 0;} /* * Copy the supplied NT_PRFPREG buffer to the floating-point context, * !CONFIG_CPU_HAS_MSA variant.   Buffer slots correspond 1:1 to FP * context's general register slots.  Only general registers are copied. */static int fpr_set_fpa(struct task_struct *target,		       unsigned int *pos, unsigned int *count,		       const void **kbuf, const void __user **ubuf){	return user_regset_copyin(pos, count, kbuf, ubuf,				  &target->thread.fpu,				  0, NUM_FPU_REGS * sizeof(elf_fpreg_t));} /* * Copy the supplied NT_PRFPREG buffer to the floating-point context, * CONFIG_CPU_HAS_MSA variant.  Buffer slots are copied to lower 64 * bits only of FP context's general register slots.  Only general * registers are copied. */static int fpr_set_msa(struct task_struct *target,		       unsigned int *pos, unsigned int *count,		       const void **kbuf, const void __user **ubuf){	unsigned int i;	u64 fpr_val;	int err; 	BUILD_BUG_ON(sizeof(fpr_val) != sizeof(elf_fpreg_t));	for (i = 0; i < NUM_FPU_REGS && *count > 0; i++) {		err = user_regset_copyin(pos, count, kbuf, ubuf,					 &fpr_val, i * sizeof(elf_fpreg_t),					 (i + 1) * sizeof(elf_fpreg_t));		if (err)			return err;		set_fpr64(&target->thread.fpu.fpr[i], 0, fpr_val);	} 	return 0;} /* * Copy the supplied NT_PRFPREG buffer to the floating-point context. * Choose the appropriate helper for general registers, and then copy * the FCSR register separately.  Ignore the incoming FIR register * contents though, as the register is read-only. *

Lines 1–500 of 1376.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t