2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* 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) 1994 - 1999, 2000 by Ralf Baechle and others.
|
2006-02-08 14:38:18 +01:00
|
|
|
* Copyright (C) 2005, 2006 by Ralf Baechle (ralf@linux-mips.org)
|
2005-04-17 00:20:36 +02:00
|
|
|
* Copyright (C) 1999, 2000 Silicon Graphics, Inc.
|
|
|
|
* Copyright (C) 2004 Thiemo Seufer
|
2013-03-25 19:18:07 +01:00
|
|
|
* Copyright (C) 2013 Imagination Technologies Ltd.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/sched.h>
|
2007-10-12 00:46:09 +02:00
|
|
|
#include <linux/tick.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/unistd.h>
|
2011-07-29 00:46:31 +02:00
|
|
|
#include <linux/export.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/mman.h>
|
|
|
|
#include <linux/personality.h>
|
|
|
|
#include <linux/sys.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/completion.h>
|
2006-02-07 17:48:03 +01:00
|
|
|
#include <linux/kallsyms.h>
|
2007-07-19 14:04:21 +02:00
|
|
|
#include <linux/random.h>
|
2015-01-08 13:17:37 +01:00
|
|
|
#include <linux/prctl.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-19 14:04:21 +02:00
|
|
|
#include <asm/asm.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/bootinfo.h>
|
|
|
|
#include <asm/cpu.h>
|
2005-05-31 13:49:19 +02:00
|
|
|
#include <asm/dsp.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/fpu.h>
|
2014-01-27 16:23:11 +01:00
|
|
|
#include <asm/msa.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/mipsregs.h>
|
|
|
|
#include <asm/processor.h>
|
2014-07-23 15:40:15 +02:00
|
|
|
#include <asm/reg.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/elf.h>
|
|
|
|
#include <asm/isadep.h>
|
|
|
|
#include <asm/inst.h>
|
2006-09-26 16:44:01 +02:00
|
|
|
#include <asm/stacktrace.h>
|
2014-10-22 08:39:56 +02:00
|
|
|
#include <asm/irq_regs.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2013-03-21 22:49:52 +01:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
void arch_cpu_idle_dead(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2013-03-21 22:49:52 +01:00
|
|
|
/* What the heck is this check doing ? */
|
2015-03-05 01:19:17 +01:00
|
|
|
if (!cpumask_test_cpu(smp_processor_id(), &cpu_callin_map))
|
2013-03-21 22:49:52 +01:00
|
|
|
play_dead();
|
|
|
|
}
|
|
|
|
#endif
|
2009-06-23 11:00:31 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
asmlinkage void ret_from_fork(void);
|
2012-10-09 22:27:45 +02:00
|
|
|
asmlinkage void ret_from_kernel_thread(void);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
|
|
|
|
{
|
|
|
|
unsigned long status;
|
|
|
|
|
|
|
|
/* New thread loses kernel privileges. */
|
2007-12-13 23:42:19 +01:00
|
|
|
status = regs->cp0_status & ~(ST0_CU0|ST0_CU1|ST0_FR|KU_MASK);
|
2005-04-17 00:20:36 +02:00
|
|
|
status |= KU_USER;
|
|
|
|
regs->cp0_status = status;
|
2016-02-01 14:50:36 +01:00
|
|
|
lose_fpu(0);
|
|
|
|
clear_thread_flag(TIF_MSA_CTX_LIVE);
|
2005-04-17 00:20:36 +02:00
|
|
|
clear_used_math();
|
2013-11-19 18:30:38 +01:00
|
|
|
init_dsp();
|
2005-04-17 00:20:36 +02:00
|
|
|
regs->cp0_epc = pc;
|
|
|
|
regs->regs[29] = sp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void exit_thread(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
MIPS: fork: Fix MSA/FPU/DSP context duplication race
There is a race in the MIPS fork code which allows the child to get a
stale copy of parent MSA/FPU/DSP state that is active in hardware
registers when the fork() is called. This is because copy_thread() saves
the live register state into the child context only if the hardware is
currently in use, apparently on the assumption that the hardware state
cannot have been saved and disabled since the initial duplication of the
task_struct. However preemption is certainly possible during this
window.
An example sequence of events is as follows:
1) The parent userland process puts important data into saved floating
point registers ($f20-$f31), which are then dirty compared to the
process' stored context.
2) The parent process calls fork() which does a clone system call.
3) In the kernel, do_fork() -> copy_process() -> dup_task_struct() ->
arch_dup_task_struct() (which uses the weakly defined default
implementation). This duplicates the parent process' task context,
which includes a stale version of its FP context from when it was
last saved, probably some time before (1).
4) At some point before copy_process() calls copy_thread(), such as when
duplicating the memory map, the process is desceduled. Perhaps it is
preempted asynchronously, or perhaps it sleeps while blocked on a
mutex. The dirty FP state in the FP registers is saved to the parent
process' context and the FPU is disabled.
5) When the process is rescheduled again it continues copying state
until it gets to copy_thread(), which checks whether the FPU is in
use, so that it can copy that dirty state to the child process' task
context. Because of the deschedule however the FPU is not in use, so
the child process' context is left with stale FP context from the
last time the parent saved it (some time before (1)).
6) When the new child process is scheduled it reads the important data
from the saved floating point register, and ends up doing a NULL
pointer dereference as a result of the stale data.
This use of saved floating point registers across function calls can be
triggered fairly easily by explicitly using inline asm with a current
(MIPS R2) compiler, but is far more likely to happen unintentionally
with a MIPS R6 compiler where the FP registers are more likely to get
used as scratch registers for storing non-fp data.
It is easily fixed, in the same way that other architectures do it, by
overriding the implementation of arch_dup_task_struct() to sync the
dirty hardware state to the parent process' task context *prior* to
duplicating it, rather than copying straight to the child process' task
context in copy_thread(). Note, the FPU hardware is not disabled so the
parent process may continue executing with the live register context,
but now the child process is guaranteed to have an identical copy of it
at that point.
Signed-off-by: James Hogan <james.hogan@imgtec.com>
Reported-by: Matthew Fortune <matthew.fortune@imgtec.com>
Tested-by: Markos Chandras <markos.chandras@imgtec.com>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Paul Burton <paul.burton@imgtec.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/9075/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2015-01-19 11:30:54 +01:00
|
|
|
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Save any process state which is live in hardware registers to the
|
|
|
|
* parent context prior to duplication. This prevents the new child
|
|
|
|
* state becoming stale if the parent is preempted before copy_thread()
|
|
|
|
* gets a chance to save the parent's live hardware registers to the
|
|
|
|
* child context.
|
|
|
|
*/
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
if (is_msa_enabled())
|
|
|
|
save_msa(current);
|
|
|
|
else if (is_fpu_owner())
|
|
|
|
_save_fp(current);
|
|
|
|
|
|
|
|
save_dsp(current);
|
|
|
|
|
|
|
|
preempt_enable();
|
|
|
|
|
|
|
|
*dst = *src;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-13 19:14:41 +01:00
|
|
|
/*
|
|
|
|
* Copy architecture-specific thread state
|
|
|
|
*/
|
2009-04-03 01:56:59 +02:00
|
|
|
int copy_thread(unsigned long clone_flags, unsigned long usp,
|
2015-03-13 19:14:41 +01:00
|
|
|
unsigned long kthread_arg, struct task_struct *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-01-12 10:06:08 +01:00
|
|
|
struct thread_info *ti = task_thread_info(p);
|
2012-10-23 04:51:14 +02:00
|
|
|
struct pt_regs *childregs, *regs = current_pt_regs();
|
2009-07-08 19:07:50 +02:00
|
|
|
unsigned long childksp;
|
2005-04-13 19:43:59 +02:00
|
|
|
p->set_child_tid = p->clear_child_tid = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-01-12 10:06:08 +01:00
|
|
|
childksp = (unsigned long)task_stack_page(p) + THREAD_SIZE - 32;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* set up new TSS. */
|
|
|
|
childregs = (struct pt_regs *) childksp - 1;
|
2009-07-08 19:07:50 +02:00
|
|
|
/* Put the stack after the struct pt_regs. */
|
|
|
|
childksp = (unsigned long) childregs;
|
2012-10-09 22:27:45 +02:00
|
|
|
p->thread.cp0_status = read_c0_status() & ~(ST0_CU2|ST0_CU1);
|
|
|
|
if (unlikely(p->flags & PF_KTHREAD)) {
|
2015-03-13 19:14:41 +01:00
|
|
|
/* kernel thread */
|
2012-10-09 22:27:45 +02:00
|
|
|
unsigned long status = p->thread.cp0_status;
|
|
|
|
memset(childregs, 0, sizeof(struct pt_regs));
|
|
|
|
ti->addr_limit = KERNEL_DS;
|
|
|
|
p->thread.reg16 = usp; /* fn */
|
2015-03-13 19:14:41 +01:00
|
|
|
p->thread.reg17 = kthread_arg;
|
2012-10-09 22:27:45 +02:00
|
|
|
p->thread.reg29 = childksp;
|
|
|
|
p->thread.reg31 = (unsigned long) ret_from_kernel_thread;
|
|
|
|
#if defined(CONFIG_CPU_R3000) || defined(CONFIG_CPU_TX39XX)
|
|
|
|
status = (status & ~(ST0_KUP | ST0_IEP | ST0_IEC)) |
|
|
|
|
((status & (ST0_KUC | ST0_IEC)) << 2);
|
|
|
|
#else
|
|
|
|
status |= ST0_EXL;
|
|
|
|
#endif
|
|
|
|
childregs->cp0_status = status;
|
|
|
|
return 0;
|
|
|
|
}
|
2015-03-13 19:14:41 +01:00
|
|
|
|
|
|
|
/* user thread */
|
2005-04-17 00:20:36 +02:00
|
|
|
*childregs = *regs;
|
2013-01-22 12:59:30 +01:00
|
|
|
childregs->regs[7] = 0; /* Clear error flag */
|
|
|
|
childregs->regs[2] = 0; /* Child gets zero as return value */
|
2012-12-27 17:52:32 +01:00
|
|
|
if (usp)
|
|
|
|
childregs->regs[29] = usp;
|
2012-10-09 22:27:45 +02:00
|
|
|
ti->addr_limit = USER_DS;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
p->thread.reg29 = (unsigned long) childregs;
|
|
|
|
p->thread.reg31 = (unsigned long) ret_from_fork;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* New tasks lose permission to use the fpu. This accelerates context
|
|
|
|
* switching for most programs since they don't use the fpu.
|
|
|
|
*/
|
|
|
|
childregs->cp0_status &= ~(ST0_CU2|ST0_CU1);
|
|
|
|
|
|
|
|
clear_tsk_thread_flag(p, TIF_USEDFPU);
|
2014-07-11 17:47:05 +02:00
|
|
|
clear_tsk_thread_flag(p, TIF_USEDMSA);
|
|
|
|
clear_tsk_thread_flag(p, TIF_MSA_CTX_LIVE);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-04-05 10:45:47 +02:00
|
|
|
#ifdef CONFIG_MIPS_MT_FPAFF
|
2008-09-09 15:19:10 +02:00
|
|
|
clear_tsk_thread_flag(p, TIF_FPUBOUND);
|
2006-04-05 10:45:47 +02:00
|
|
|
#endif /* CONFIG_MIPS_MT_FPAFF */
|
|
|
|
|
2005-04-13 19:43:59 +02:00
|
|
|
if (clone_flags & CLONE_SETTLS)
|
|
|
|
ti->tp_value = regs->regs[7];
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-12 19:08:54 +02:00
|
|
|
#ifdef CONFIG_CC_STACKPROTECTOR
|
|
|
|
#include <linux/stackprotector.h>
|
|
|
|
unsigned long __stack_chk_guard __read_mostly;
|
|
|
|
EXPORT_SYMBOL(__stack_chk_guard);
|
|
|
|
#endif
|
|
|
|
|
2006-08-18 16:18:09 +02:00
|
|
|
struct mips_frame_info {
|
|
|
|
void *func;
|
|
|
|
unsigned long func_size;
|
|
|
|
int frame_size;
|
|
|
|
int pc_offset;
|
|
|
|
};
|
2005-02-21 11:55:16 +01:00
|
|
|
|
2013-05-12 17:05:34 +02:00
|
|
|
#define J_TARGET(pc,target) \
|
|
|
|
(((unsigned long)(pc) & 0xf0000000) | ((target) << 2))
|
|
|
|
|
2006-08-03 09:29:15 +02:00
|
|
|
static inline int is_ra_save_ins(union mips_instruction *ip)
|
|
|
|
{
|
2013-03-25 19:18:07 +01:00
|
|
|
#ifdef CONFIG_CPU_MICROMIPS
|
|
|
|
union mips_instruction mmi;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* swsp ra,offset
|
|
|
|
* swm16 reglist,offset(sp)
|
|
|
|
* swm32 reglist,offset(sp)
|
|
|
|
* sw32 ra,offset(sp)
|
|
|
|
* jradiussp - NOT SUPPORTED
|
|
|
|
*
|
|
|
|
* microMIPS is way more fun...
|
|
|
|
*/
|
|
|
|
if (mm_insn_16bit(ip->halfword[0])) {
|
|
|
|
mmi.word = (ip->halfword[0] << 16);
|
2014-10-21 14:12:49 +02:00
|
|
|
return (mmi.mm16_r5_format.opcode == mm_swsp16_op &&
|
|
|
|
mmi.mm16_r5_format.rt == 31) ||
|
|
|
|
(mmi.mm16_m_format.opcode == mm_pool16c_op &&
|
|
|
|
mmi.mm16_m_format.func == mm_swm16_op);
|
2013-03-25 19:18:07 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
mmi.halfword[0] = ip->halfword[1];
|
|
|
|
mmi.halfword[1] = ip->halfword[0];
|
2014-10-21 14:12:49 +02:00
|
|
|
return (mmi.mm_m_format.opcode == mm_pool32b_op &&
|
|
|
|
mmi.mm_m_format.rd > 9 &&
|
|
|
|
mmi.mm_m_format.base == 29 &&
|
|
|
|
mmi.mm_m_format.func == mm_swm32_func) ||
|
|
|
|
(mmi.i_format.opcode == mm_sw32_op &&
|
|
|
|
mmi.i_format.rs == 29 &&
|
|
|
|
mmi.i_format.rt == 31);
|
2013-03-25 19:18:07 +01:00
|
|
|
}
|
|
|
|
#else
|
2006-08-03 09:29:15 +02:00
|
|
|
/* sw / sd $ra, offset($sp) */
|
|
|
|
return (ip->i_format.opcode == sw_op || ip->i_format.opcode == sd_op) &&
|
|
|
|
ip->i_format.rs == 29 &&
|
|
|
|
ip->i_format.rt == 31;
|
2013-03-25 19:18:07 +01:00
|
|
|
#endif
|
2006-08-03 09:29:15 +02:00
|
|
|
}
|
|
|
|
|
MIPS: Fix sibling call handling in get_frame_info
Given a function, get_frame_info() analyzes its instructions
to figure out frame size and return address. get_frame_info()
works as follows:
1. analyze up to 128 instructions if the function size is unknown
2. search for 'addiu/daddiu sp,sp,-immed' for frame size
3. search for 'sw ra,offset(sp)' for return address
4. end search when it sees jr/jal/jalr
This leads to an issue when the given function is a sibling
call, example shown as follows.
801ca110 <schedule>:
801ca110: 8f820000 lw v0,0(gp)
801ca114: 8c420000 lw v0,0(v0)
801ca118: 080726f0 j 801c9bc0 <__schedule>
801ca11c: 00000000 nop
801ca120 <io_schedule>:
801ca120: 27bdffe8 addiu sp,sp,-24
801ca124: 3c028022 lui v0,0x8022
801ca128: afbf0014 sw ra,20(sp)
In this case, get_frame_info() cannot properly detect schedule's
frame info, and eventually returns io_schedule's instead.
This patch adds 'j' to the end search condition to workaround
sibling call cases.
Signed-off-by: Tony Wu <tung7970@gmail.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5236/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-05-12 17:04:29 +02:00
|
|
|
static inline int is_jump_ins(union mips_instruction *ip)
|
2006-08-03 09:29:15 +02:00
|
|
|
{
|
2013-03-25 19:18:07 +01:00
|
|
|
#ifdef CONFIG_CPU_MICROMIPS
|
|
|
|
/*
|
|
|
|
* jr16,jrc,jalr16,jalr16
|
|
|
|
* jal
|
|
|
|
* jalr/jr,jalr.hb/jr.hb,jalrs,jalrs.hb
|
|
|
|
* jraddiusp - NOT SUPPORTED
|
|
|
|
*
|
|
|
|
* microMIPS is kind of more fun...
|
|
|
|
*/
|
|
|
|
union mips_instruction mmi;
|
|
|
|
|
|
|
|
mmi.word = (ip->halfword[0] << 16);
|
|
|
|
|
|
|
|
if ((mmi.mm16_r5_format.opcode == mm_pool16c_op &&
|
|
|
|
(mmi.mm16_r5_format.rt & mm_jr16_op) == mm_jr16_op) ||
|
|
|
|
ip->j_format.opcode == mm_jal32_op)
|
|
|
|
return 1;
|
|
|
|
if (ip->r_format.opcode != mm_pool32a_op ||
|
|
|
|
ip->r_format.func != mm_pool32axf_op)
|
|
|
|
return 0;
|
2014-10-21 14:12:49 +02:00
|
|
|
return ((ip->u_format.uimmediate >> 6) & mm_jalr_op) == mm_jalr_op;
|
2013-03-25 19:18:07 +01:00
|
|
|
#else
|
MIPS: Fix sibling call handling in get_frame_info
Given a function, get_frame_info() analyzes its instructions
to figure out frame size and return address. get_frame_info()
works as follows:
1. analyze up to 128 instructions if the function size is unknown
2. search for 'addiu/daddiu sp,sp,-immed' for frame size
3. search for 'sw ra,offset(sp)' for return address
4. end search when it sees jr/jal/jalr
This leads to an issue when the given function is a sibling
call, example shown as follows.
801ca110 <schedule>:
801ca110: 8f820000 lw v0,0(gp)
801ca114: 8c420000 lw v0,0(v0)
801ca118: 080726f0 j 801c9bc0 <__schedule>
801ca11c: 00000000 nop
801ca120 <io_schedule>:
801ca120: 27bdffe8 addiu sp,sp,-24
801ca124: 3c028022 lui v0,0x8022
801ca128: afbf0014 sw ra,20(sp)
In this case, get_frame_info() cannot properly detect schedule's
frame info, and eventually returns io_schedule's instead.
This patch adds 'j' to the end search condition to workaround
sibling call cases.
Signed-off-by: Tony Wu <tung7970@gmail.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5236/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-05-12 17:04:29 +02:00
|
|
|
if (ip->j_format.opcode == j_op)
|
|
|
|
return 1;
|
2006-08-03 09:29:15 +02:00
|
|
|
if (ip->j_format.opcode == jal_op)
|
|
|
|
return 1;
|
|
|
|
if (ip->r_format.opcode != spec_op)
|
|
|
|
return 0;
|
|
|
|
return ip->r_format.func == jalr_op || ip->r_format.func == jr_op;
|
2013-03-25 19:18:07 +01:00
|
|
|
#endif
|
2006-08-03 09:29:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_sp_move_ins(union mips_instruction *ip)
|
|
|
|
{
|
2013-03-25 19:18:07 +01:00
|
|
|
#ifdef CONFIG_CPU_MICROMIPS
|
|
|
|
/*
|
|
|
|
* addiusp -imm
|
|
|
|
* addius5 sp,-imm
|
|
|
|
* addiu32 sp,sp,-imm
|
|
|
|
* jradiussp - NOT SUPPORTED
|
|
|
|
*
|
|
|
|
* microMIPS is not more fun...
|
|
|
|
*/
|
|
|
|
if (mm_insn_16bit(ip->halfword[0])) {
|
|
|
|
union mips_instruction mmi;
|
|
|
|
|
|
|
|
mmi.word = (ip->halfword[0] << 16);
|
2014-10-21 14:12:49 +02:00
|
|
|
return (mmi.mm16_r3_format.opcode == mm_pool16d_op &&
|
|
|
|
mmi.mm16_r3_format.simmediate && mm_addiusp_func) ||
|
|
|
|
(mmi.mm16_r5_format.opcode == mm_pool16d_op &&
|
|
|
|
mmi.mm16_r5_format.rt == 29);
|
2013-03-25 19:18:07 +01:00
|
|
|
}
|
2014-10-21 14:12:49 +02:00
|
|
|
return ip->mm_i_format.opcode == mm_addiu32_op &&
|
|
|
|
ip->mm_i_format.rt == 29 && ip->mm_i_format.rs == 29;
|
2013-03-25 19:18:07 +01:00
|
|
|
#else
|
2006-08-03 09:29:15 +02:00
|
|
|
/* addiu/daddiu sp,sp,-imm */
|
|
|
|
if (ip->i_format.rs != 29 || ip->i_format.rt != 29)
|
|
|
|
return 0;
|
|
|
|
if (ip->i_format.opcode == addiu_op || ip->i_format.opcode == daddiu_op)
|
|
|
|
return 1;
|
2013-03-25 19:18:07 +01:00
|
|
|
#endif
|
2006-08-03 09:29:15 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 16:27:20 +02:00
|
|
|
static int get_frame_info(struct mips_frame_info *info)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2013-03-25 19:18:07 +01:00
|
|
|
#ifdef CONFIG_CPU_MICROMIPS
|
|
|
|
union mips_instruction *ip = (void *) (((char *) info->func) - 1);
|
|
|
|
#else
|
2006-08-03 09:29:15 +02:00
|
|
|
union mips_instruction *ip = info->func;
|
2013-03-25 19:18:07 +01:00
|
|
|
#endif
|
2006-08-18 16:18:08 +02:00
|
|
|
unsigned max_insns = info->func_size / sizeof(union mips_instruction);
|
|
|
|
unsigned i;
|
2006-08-03 09:29:15 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
info->pc_offset = -1;
|
2006-02-07 17:48:03 +01:00
|
|
|
info->frame_size = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-08-18 16:18:08 +02:00
|
|
|
if (!ip)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
if (max_insns == 0)
|
|
|
|
max_insns = 128U; /* unknown function size */
|
|
|
|
max_insns = min(128U, max_insns);
|
|
|
|
|
2006-08-03 09:29:15 +02:00
|
|
|
for (i = 0; i < max_insns; i++, ip++) {
|
|
|
|
|
MIPS: Fix sibling call handling in get_frame_info
Given a function, get_frame_info() analyzes its instructions
to figure out frame size and return address. get_frame_info()
works as follows:
1. analyze up to 128 instructions if the function size is unknown
2. search for 'addiu/daddiu sp,sp,-immed' for frame size
3. search for 'sw ra,offset(sp)' for return address
4. end search when it sees jr/jal/jalr
This leads to an issue when the given function is a sibling
call, example shown as follows.
801ca110 <schedule>:
801ca110: 8f820000 lw v0,0(gp)
801ca114: 8c420000 lw v0,0(v0)
801ca118: 080726f0 j 801c9bc0 <__schedule>
801ca11c: 00000000 nop
801ca120 <io_schedule>:
801ca120: 27bdffe8 addiu sp,sp,-24
801ca124: 3c028022 lui v0,0x8022
801ca128: afbf0014 sw ra,20(sp)
In this case, get_frame_info() cannot properly detect schedule's
frame info, and eventually returns io_schedule's instead.
This patch adds 'j' to the end search condition to workaround
sibling call cases.
Signed-off-by: Tony Wu <tung7970@gmail.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/5236/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2013-05-12 17:04:29 +02:00
|
|
|
if (is_jump_ins(ip))
|
2006-02-07 17:48:03 +01:00
|
|
|
break;
|
2006-08-03 09:29:20 +02:00
|
|
|
if (!info->frame_size) {
|
|
|
|
if (is_sp_move_ins(ip))
|
2013-03-25 19:18:07 +01:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_CPU_MICROMIPS
|
|
|
|
if (mm_insn_16bit(ip->halfword[0]))
|
|
|
|
{
|
|
|
|
unsigned short tmp;
|
|
|
|
|
|
|
|
if (ip->halfword[0] & mm_addiusp_func)
|
|
|
|
{
|
|
|
|
tmp = (((ip->halfword[0] >> 1) & 0x1ff) << 2);
|
|
|
|
info->frame_size = -(signed short)(tmp | ((tmp & 0x100) ? 0xfe00 : 0));
|
|
|
|
} else {
|
|
|
|
tmp = (ip->halfword[0] >> 1);
|
|
|
|
info->frame_size = -(signed short)(tmp & 0xf);
|
|
|
|
}
|
|
|
|
ip = (void *) &ip->halfword[1];
|
|
|
|
ip--;
|
|
|
|
} else
|
|
|
|
#endif
|
2006-08-03 09:29:20 +02:00
|
|
|
info->frame_size = - ip->i_format.simmediate;
|
2013-03-25 19:18:07 +01:00
|
|
|
}
|
2006-08-03 09:29:20 +02:00
|
|
|
continue;
|
2006-02-07 17:48:03 +01:00
|
|
|
}
|
2006-08-03 09:29:20 +02:00
|
|
|
if (info->pc_offset == -1 && is_ra_save_ins(ip)) {
|
2006-02-07 17:48:03 +01:00
|
|
|
info->pc_offset =
|
|
|
|
ip->i_format.simmediate / sizeof(long);
|
2006-08-03 09:29:20 +02:00
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
2006-07-29 16:27:20 +02:00
|
|
|
if (info->frame_size && info->pc_offset >= 0) /* nested */
|
|
|
|
return 0;
|
|
|
|
if (info->pc_offset < 0) /* leaf */
|
|
|
|
return 1;
|
|
|
|
/* prologue seems boggus... */
|
2006-08-18 16:18:08 +02:00
|
|
|
err:
|
2006-07-29 16:27:20 +02:00
|
|
|
return -1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-18 16:18:09 +02:00
|
|
|
static struct mips_frame_info schedule_mfi __read_mostly;
|
|
|
|
|
2013-05-12 17:05:34 +02:00
|
|
|
#ifdef CONFIG_KALLSYMS
|
|
|
|
static unsigned long get___schedule_addr(void)
|
|
|
|
{
|
|
|
|
return kallsyms_lookup_name("__schedule");
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static unsigned long get___schedule_addr(void)
|
|
|
|
{
|
|
|
|
union mips_instruction *ip = (void *)schedule;
|
|
|
|
int max_insns = 8;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < max_insns; i++, ip++) {
|
|
|
|
if (ip->j_format.opcode == j_op)
|
|
|
|
return J_TARGET(ip, ip->j_format.target);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int __init frame_info_init(void)
|
|
|
|
{
|
2006-08-18 16:18:09 +02:00
|
|
|
unsigned long size = 0;
|
2006-02-07 17:48:03 +01:00
|
|
|
#ifdef CONFIG_KALLSYMS
|
2006-08-18 16:18:09 +02:00
|
|
|
unsigned long ofs;
|
2013-05-12 17:05:34 +02:00
|
|
|
#endif
|
|
|
|
unsigned long addr;
|
2006-08-18 16:18:09 +02:00
|
|
|
|
2013-05-12 17:05:34 +02:00
|
|
|
addr = get___schedule_addr();
|
|
|
|
if (!addr)
|
|
|
|
addr = (unsigned long)schedule;
|
|
|
|
|
|
|
|
#ifdef CONFIG_KALLSYMS
|
|
|
|
kallsyms_lookup_size_offset(addr, &size, &ofs);
|
2006-02-07 17:48:03 +01:00
|
|
|
#endif
|
2013-05-12 17:05:34 +02:00
|
|
|
schedule_mfi.func = (void *)addr;
|
2006-08-18 16:18:09 +02:00
|
|
|
schedule_mfi.func_size = size;
|
|
|
|
|
|
|
|
get_frame_info(&schedule_mfi);
|
2006-08-03 09:29:18 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Without schedule() frame info, result given by
|
|
|
|
* thread_saved_pc() and get_wchan() are not reliable.
|
|
|
|
*/
|
2006-08-18 16:18:09 +02:00
|
|
|
if (schedule_mfi.pc_offset < 0)
|
2006-08-03 09:29:18 +02:00
|
|
|
printk("Can't analyze schedule() prologue at %p\n", schedule);
|
2006-02-07 17:48:03 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
arch_initcall(frame_info_init);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return saved PC of a blocked thread.
|
|
|
|
*/
|
|
|
|
unsigned long thread_saved_pc(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
struct thread_struct *t = &tsk->thread;
|
|
|
|
|
|
|
|
/* New born processes are a special case */
|
|
|
|
if (t->reg31 == (unsigned long) ret_from_fork)
|
|
|
|
return t->reg31;
|
2006-08-18 16:18:09 +02:00
|
|
|
if (schedule_mfi.pc_offset < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2006-08-18 16:18:09 +02:00
|
|
|
return ((unsigned long *)t->reg29)[schedule_mfi.pc_offset];
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-29 16:27:20 +02:00
|
|
|
#ifdef CONFIG_KALLSYMS
|
2011-05-13 14:38:04 +02:00
|
|
|
/* generic stack unwinding function */
|
|
|
|
unsigned long notrace unwind_stack_by_address(unsigned long stack_page,
|
|
|
|
unsigned long *sp,
|
|
|
|
unsigned long pc,
|
|
|
|
unsigned long *ra)
|
2006-07-29 16:27:20 +02:00
|
|
|
{
|
|
|
|
struct mips_frame_info info;
|
|
|
|
unsigned long size, ofs;
|
2006-08-03 09:29:21 +02:00
|
|
|
int leaf;
|
2006-09-29 11:02:51 +02:00
|
|
|
extern void ret_from_irq(void);
|
|
|
|
extern void ret_from_exception(void);
|
2006-07-29 16:27:20 +02:00
|
|
|
|
|
|
|
if (!stack_page)
|
|
|
|
return 0;
|
|
|
|
|
2006-09-29 11:02:51 +02:00
|
|
|
/*
|
|
|
|
* If we reached the bottom of interrupt context,
|
|
|
|
* return saved pc in pt_regs.
|
|
|
|
*/
|
|
|
|
if (pc == (unsigned long)ret_from_irq ||
|
|
|
|
pc == (unsigned long)ret_from_exception) {
|
|
|
|
struct pt_regs *regs;
|
|
|
|
if (*sp >= stack_page &&
|
|
|
|
*sp + sizeof(*regs) <= stack_page + THREAD_SIZE - 32) {
|
|
|
|
regs = (struct pt_regs *)*sp;
|
|
|
|
pc = regs->cp0_epc;
|
2015-12-04 23:25:01 +01:00
|
|
|
if (!user_mode(regs) && __kernel_text_address(pc)) {
|
2006-09-29 11:02:51 +02:00
|
|
|
*sp = regs->regs[29];
|
|
|
|
*ra = regs->regs[31];
|
|
|
|
return pc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2006-10-13 13:37:35 +02:00
|
|
|
if (!kallsyms_lookup_size_offset(pc, &size, &ofs))
|
2006-07-29 16:27:20 +02:00
|
|
|
return 0;
|
2006-08-18 16:18:07 +02:00
|
|
|
/*
|
2011-03-31 03:57:33 +02:00
|
|
|
* Return ra if an exception occurred at the first instruction
|
2006-08-18 16:18:07 +02:00
|
|
|
*/
|
2006-09-29 11:02:51 +02:00
|
|
|
if (unlikely(ofs == 0)) {
|
|
|
|
pc = *ra;
|
|
|
|
*ra = 0;
|
|
|
|
return pc;
|
|
|
|
}
|
2006-07-29 16:27:20 +02:00
|
|
|
|
|
|
|
info.func = (void *)(pc - ofs);
|
|
|
|
info.func_size = ofs; /* analyze from start to ofs */
|
2006-08-03 09:29:21 +02:00
|
|
|
leaf = get_frame_info(&info);
|
|
|
|
if (leaf < 0)
|
2006-07-29 16:27:20 +02:00
|
|
|
return 0;
|
2006-08-03 09:29:21 +02:00
|
|
|
|
|
|
|
if (*sp < stack_page ||
|
|
|
|
*sp + info.frame_size > stack_page + THREAD_SIZE - 32)
|
2006-07-29 16:27:20 +02:00
|
|
|
return 0;
|
|
|
|
|
2006-08-03 09:29:21 +02:00
|
|
|
if (leaf)
|
|
|
|
/*
|
|
|
|
* For some extreme cases, get_frame_info() can
|
|
|
|
* consider wrongly a nested function as a leaf
|
|
|
|
* one. In that cases avoid to return always the
|
|
|
|
* same value.
|
|
|
|
*/
|
2006-09-29 11:02:51 +02:00
|
|
|
pc = pc != *ra ? *ra : 0;
|
2006-08-03 09:29:21 +02:00
|
|
|
else
|
|
|
|
pc = ((unsigned long *)(*sp))[info.pc_offset];
|
|
|
|
|
|
|
|
*sp += info.frame_size;
|
2006-09-29 11:02:51 +02:00
|
|
|
*ra = 0;
|
2006-08-03 09:29:21 +02:00
|
|
|
return __kernel_text_address(pc) ? pc : 0;
|
2006-07-29 16:27:20 +02:00
|
|
|
}
|
2011-05-13 14:38:04 +02:00
|
|
|
EXPORT_SYMBOL(unwind_stack_by_address);
|
|
|
|
|
|
|
|
/* used by show_backtrace() */
|
|
|
|
unsigned long unwind_stack(struct task_struct *task, unsigned long *sp,
|
|
|
|
unsigned long pc, unsigned long *ra)
|
|
|
|
{
|
|
|
|
unsigned long stack_page = (unsigned long)task_stack_page(task);
|
|
|
|
return unwind_stack_by_address(stack_page, sp, pc, ra);
|
|
|
|
}
|
2006-07-29 16:27:20 +02:00
|
|
|
#endif
|
2006-08-18 16:18:09 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* get_wchan - a maintenance nightmare^W^Wpain in the ass ...
|
|
|
|
*/
|
|
|
|
unsigned long get_wchan(struct task_struct *task)
|
|
|
|
{
|
|
|
|
unsigned long pc = 0;
|
|
|
|
#ifdef CONFIG_KALLSYMS
|
|
|
|
unsigned long sp;
|
2006-09-29 11:02:51 +02:00
|
|
|
unsigned long ra = 0;
|
2006-08-18 16:18:09 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!task || task == current || task->state == TASK_RUNNING)
|
|
|
|
goto out;
|
|
|
|
if (!task_stack_page(task))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
pc = thread_saved_pc(task);
|
|
|
|
|
|
|
|
#ifdef CONFIG_KALLSYMS
|
|
|
|
sp = task->thread.reg29 + schedule_mfi.frame_size;
|
|
|
|
|
|
|
|
while (in_sched_functions(pc))
|
2006-09-29 11:02:51 +02:00
|
|
|
pc = unwind_stack(task, &sp, pc, &ra);
|
2006-08-18 16:18:09 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
out:
|
|
|
|
return pc;
|
|
|
|
}
|
2007-07-19 14:04:21 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't forget that the stack pointer must be aligned on a 8 bytes
|
|
|
|
* boundary for 32-bits ABI and 16 bytes for 64-bits ABI.
|
|
|
|
*/
|
|
|
|
unsigned long arch_align_stack(unsigned long sp)
|
|
|
|
{
|
|
|
|
if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
|
|
|
|
sp -= get_random_int() & ~PAGE_MASK;
|
|
|
|
|
|
|
|
return sp & ALMASK;
|
|
|
|
}
|
2014-10-22 08:39:56 +02:00
|
|
|
|
|
|
|
static void arch_dump_stack(void *info)
|
|
|
|
{
|
|
|
|
struct pt_regs *regs;
|
|
|
|
|
|
|
|
regs = get_irq_regs();
|
|
|
|
|
|
|
|
if (regs)
|
|
|
|
show_regs(regs);
|
|
|
|
|
|
|
|
dump_stack();
|
|
|
|
}
|
|
|
|
|
|
|
|
void arch_trigger_all_cpu_backtrace(bool include_self)
|
|
|
|
{
|
|
|
|
smp_call_function(arch_dump_stack, NULL, 1);
|
|
|
|
}
|
2015-01-08 13:17:37 +01:00
|
|
|
|
|
|
|
int mips_get_process_fp_mode(struct task_struct *task)
|
|
|
|
{
|
|
|
|
int value = 0;
|
|
|
|
|
|
|
|
if (!test_tsk_thread_flag(task, TIF_32BIT_FPREGS))
|
|
|
|
value |= PR_FP_MODE_FR;
|
|
|
|
if (test_tsk_thread_flag(task, TIF_HYBRID_FPREGS))
|
|
|
|
value |= PR_FP_MODE_FRE;
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2016-04-21 13:43:58 +02:00
|
|
|
static void prepare_for_fp_mode_switch(void *info)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm = info;
|
|
|
|
|
|
|
|
if (current->mm == mm)
|
|
|
|
lose_fpu(1);
|
|
|
|
}
|
|
|
|
|
2015-01-08 13:17:37 +01:00
|
|
|
int mips_set_process_fp_mode(struct task_struct *task, unsigned int value)
|
|
|
|
{
|
|
|
|
const unsigned int known_bits = PR_FP_MODE_FR | PR_FP_MODE_FRE;
|
|
|
|
struct task_struct *t;
|
2016-04-21 13:43:58 +02:00
|
|
|
int max_users;
|
2015-01-08 13:17:37 +01:00
|
|
|
|
|
|
|
/* Check the value is valid */
|
|
|
|
if (value & ~known_bits)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
/* Avoid inadvertently triggering emulation */
|
|
|
|
if ((value & PR_FP_MODE_FR) && cpu_has_fpu &&
|
|
|
|
!(current_cpu_data.fpu_id & MIPS_FPIR_F64))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
if ((value & PR_FP_MODE_FRE) && cpu_has_fpu && !cpu_has_fre)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2015-01-13 14:01:49 +01:00
|
|
|
/* FR = 0 not supported in MIPS R6 */
|
|
|
|
if (!(value & PR_FP_MODE_FR) && cpu_has_fpu && cpu_has_mips_r6)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2016-04-21 13:43:57 +02:00
|
|
|
/* Proceed with the mode switch */
|
|
|
|
preempt_disable();
|
|
|
|
|
2015-01-08 13:17:37 +01:00
|
|
|
/* Save FP & vector context, then disable FPU & MSA */
|
|
|
|
if (task->signal == current->signal)
|
|
|
|
lose_fpu(1);
|
|
|
|
|
|
|
|
/* Prevent any threads from obtaining live FP context */
|
|
|
|
atomic_set(&task->mm->context.fp_mode_switching, 1);
|
|
|
|
smp_mb__after_atomic();
|
|
|
|
|
|
|
|
/*
|
2016-04-21 13:43:58 +02:00
|
|
|
* If there are multiple online CPUs then force any which are running
|
|
|
|
* threads in this process to lose their FPU context, which they can't
|
|
|
|
* regain until fp_mode_switching is cleared later.
|
2015-01-08 13:17:37 +01:00
|
|
|
*/
|
|
|
|
if (num_online_cpus() > 1) {
|
2016-04-21 13:43:58 +02:00
|
|
|
/* No need to send an IPI for the local CPU */
|
|
|
|
max_users = (task->mm == current->mm) ? 1 : 0;
|
2015-01-08 13:17:37 +01:00
|
|
|
|
2016-04-21 13:43:58 +02:00
|
|
|
if (atomic_read(¤t->mm->mm_users) > max_users)
|
|
|
|
smp_call_function(prepare_for_fp_mode_switch,
|
|
|
|
(void *)current->mm, 1);
|
2015-01-08 13:17:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There are now no threads of the process with live FP context, so it
|
|
|
|
* is safe to proceed with the FP mode switch.
|
|
|
|
*/
|
|
|
|
for_each_thread(task, t) {
|
|
|
|
/* Update desired FP register width */
|
|
|
|
if (value & PR_FP_MODE_FR) {
|
|
|
|
clear_tsk_thread_flag(t, TIF_32BIT_FPREGS);
|
|
|
|
} else {
|
|
|
|
set_tsk_thread_flag(t, TIF_32BIT_FPREGS);
|
|
|
|
clear_tsk_thread_flag(t, TIF_MSA_CTX_LIVE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update desired FP single layout */
|
|
|
|
if (value & PR_FP_MODE_FRE)
|
|
|
|
set_tsk_thread_flag(t, TIF_HYBRID_FPREGS);
|
|
|
|
else
|
|
|
|
clear_tsk_thread_flag(t, TIF_HYBRID_FPREGS);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allow threads to use FP again */
|
|
|
|
atomic_set(&task->mm->context.fp_mode_switching, 0);
|
2016-04-21 13:43:57 +02:00
|
|
|
preempt_enable();
|
2015-01-08 13:17:37 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|