2005-09-26 02:04:21 -04:00
|
|
|
/*
|
|
|
|
* Derived from "arch/i386/kernel/process.c"
|
|
|
|
* Copyright (C) 1995 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Updated and modified by Cort Dougan (cort@cs.nmt.edu) and
|
|
|
|
* Paul Mackerras (paulus@cs.anu.edu.au)
|
|
|
|
*
|
|
|
|
* PowerPC version
|
|
|
|
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/user.h>
|
|
|
|
#include <linux/elf.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/prctl.h>
|
|
|
|
#include <linux/init_task.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kallsyms.h>
|
|
|
|
#include <linux/mqueue.h>
|
|
|
|
#include <linux/hardirq.h>
|
2005-10-10 08:29:05 -04:00
|
|
|
#include <linux/utsname.h>
|
2005-09-26 02:04:21 -04:00
|
|
|
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/mmu.h>
|
|
|
|
#include <asm/prom.h>
|
2005-11-06 21:12:03 -05:00
|
|
|
#include <asm/machdep.h>
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-23 18:06:59 -05:00
|
|
|
#include <asm/time.h>
|
2006-03-22 18:00:08 -05:00
|
|
|
#include <asm/syscalls.h>
|
2005-10-10 08:29:05 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
#include <asm/firmware.h>
|
|
|
|
#endif
|
2005-09-26 02:04:21 -04:00
|
|
|
|
|
|
|
extern unsigned long _get_SP(void);
|
|
|
|
|
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
struct task_struct *last_task_used_math = NULL;
|
|
|
|
struct task_struct *last_task_used_altivec = NULL;
|
|
|
|
struct task_struct *last_task_used_spe = NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure the floating-point register state in the
|
|
|
|
* the thread_struct is up to date for task tsk.
|
|
|
|
*/
|
|
|
|
void flush_fp_to_thread(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
if (tsk->thread.regs) {
|
|
|
|
/*
|
|
|
|
* We need to disable preemption here because if we didn't,
|
|
|
|
* another process could get scheduled after the regs->msr
|
|
|
|
* test but before we have finished saving the FP registers
|
|
|
|
* to the thread_struct. That process could take over the
|
|
|
|
* FPU, and then when we get scheduled again we would store
|
|
|
|
* bogus values for the remaining FP registers.
|
|
|
|
*/
|
|
|
|
preempt_disable();
|
|
|
|
if (tsk->thread.regs->msr & MSR_FP) {
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
|
|
* This should only ever be called for current or
|
|
|
|
* for a stopped child process. Since we save away
|
|
|
|
* the FP register state on context switch on SMP,
|
|
|
|
* there is something wrong if a stopped child appears
|
|
|
|
* to still have its FP state in the CPU registers.
|
|
|
|
*/
|
|
|
|
BUG_ON(tsk != current);
|
|
|
|
#endif
|
2007-08-28 22:15:53 -04:00
|
|
|
giveup_fpu(tsk);
|
2005-09-26 02:04:21 -04:00
|
|
|
}
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void enable_kernel_fp(void)
|
|
|
|
{
|
|
|
|
WARN_ON(preemptible());
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
if (current->thread.regs && (current->thread.regs->msr & MSR_FP))
|
|
|
|
giveup_fpu(current);
|
|
|
|
else
|
|
|
|
giveup_fpu(NULL); /* just enables FP for kernel */
|
|
|
|
#else
|
|
|
|
giveup_fpu(last_task_used_math);
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(enable_kernel_fp);
|
|
|
|
|
|
|
|
int dump_task_fpu(struct task_struct *tsk, elf_fpregset_t *fpregs)
|
|
|
|
{
|
|
|
|
if (!tsk->thread.regs)
|
|
|
|
return 0;
|
|
|
|
flush_fp_to_thread(current);
|
|
|
|
|
|
|
|
memcpy(fpregs, &tsk->thread.fpr[0], sizeof(*fpregs));
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
void enable_kernel_altivec(void)
|
|
|
|
{
|
|
|
|
WARN_ON(preemptible());
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
if (current->thread.regs && (current->thread.regs->msr & MSR_VEC))
|
|
|
|
giveup_altivec(current);
|
|
|
|
else
|
|
|
|
giveup_altivec(NULL); /* just enable AltiVec for kernel - force */
|
|
|
|
#else
|
|
|
|
giveup_altivec(last_task_used_altivec);
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(enable_kernel_altivec);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure the VMX/Altivec register state in the
|
|
|
|
* the thread_struct is up to date for task tsk.
|
|
|
|
*/
|
|
|
|
void flush_altivec_to_thread(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
if (tsk->thread.regs) {
|
|
|
|
preempt_disable();
|
|
|
|
if (tsk->thread.regs->msr & MSR_VEC) {
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
BUG_ON(tsk != current);
|
|
|
|
#endif
|
2007-08-28 22:15:53 -04:00
|
|
|
giveup_altivec(tsk);
|
2005-09-26 02:04:21 -04:00
|
|
|
}
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-17 02:25:40 -04:00
|
|
|
int dump_task_altivec(struct task_struct *tsk, elf_vrregset_t *vrregs)
|
2005-09-26 02:04:21 -04:00
|
|
|
{
|
2007-10-17 02:25:40 -04:00
|
|
|
/* ELF_NVRREG includes the VSCR and VRSAVE which we need to save
|
|
|
|
* separately, see below */
|
|
|
|
const int nregs = ELF_NVRREG - 2;
|
|
|
|
elf_vrreg_t *reg;
|
|
|
|
u32 *dest;
|
|
|
|
|
|
|
|
if (tsk == current)
|
|
|
|
flush_altivec_to_thread(tsk);
|
|
|
|
|
|
|
|
reg = (elf_vrreg_t *)vrregs;
|
|
|
|
|
|
|
|
/* copy the 32 vr registers */
|
|
|
|
memcpy(reg, &tsk->thread.vr[0], nregs * sizeof(*reg));
|
|
|
|
reg += nregs;
|
|
|
|
|
|
|
|
/* copy the vscr */
|
|
|
|
memcpy(reg, &tsk->thread.vscr, sizeof(*reg));
|
|
|
|
reg++;
|
|
|
|
|
|
|
|
/* vrsave is stored in the high 32bit slot of the final 128bits */
|
|
|
|
memset(reg, 0, sizeof(*reg));
|
|
|
|
dest = (u32 *)reg;
|
|
|
|
*dest = tsk->thread.vrsave;
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
|
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
|
|
|
|
void enable_kernel_spe(void)
|
|
|
|
{
|
|
|
|
WARN_ON(preemptible());
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
if (current->thread.regs && (current->thread.regs->msr & MSR_SPE))
|
|
|
|
giveup_spe(current);
|
|
|
|
else
|
|
|
|
giveup_spe(NULL); /* just enable SPE for kernel - force */
|
|
|
|
#else
|
|
|
|
giveup_spe(last_task_used_spe);
|
|
|
|
#endif /* __SMP __ */
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(enable_kernel_spe);
|
|
|
|
|
|
|
|
void flush_spe_to_thread(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
if (tsk->thread.regs) {
|
|
|
|
preempt_disable();
|
|
|
|
if (tsk->thread.regs->msr & MSR_SPE) {
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
BUG_ON(tsk != current);
|
|
|
|
#endif
|
2007-08-28 22:15:53 -04:00
|
|
|
giveup_spe(tsk);
|
2005-09-26 02:04:21 -04:00
|
|
|
}
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int dump_spe(struct pt_regs *regs, elf_vrregset_t *evrregs)
|
|
|
|
{
|
|
|
|
flush_spe_to_thread(current);
|
|
|
|
/* We copy u32 evr[32] + u64 acc + u32 spefscr -> 35 */
|
|
|
|
memcpy(evrregs, ¤t->thread.evr[0], sizeof(u32) * 35);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SPE */
|
|
|
|
|
2006-01-11 06:11:39 -05:00
|
|
|
#ifndef CONFIG_SMP
|
2005-11-29 21:20:54 -05:00
|
|
|
/*
|
|
|
|
* If we are doing lazy switching of CPU state (FP, altivec or SPE),
|
|
|
|
* and the current task has some state, discard it.
|
|
|
|
*/
|
2006-01-11 06:11:39 -05:00
|
|
|
void discard_lazy_cpu_state(void)
|
2005-11-29 21:20:54 -05:00
|
|
|
{
|
|
|
|
preempt_disable();
|
|
|
|
if (last_task_used_math == current)
|
|
|
|
last_task_used_math = NULL;
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
if (last_task_used_altivec == current)
|
|
|
|
last_task_used_altivec = NULL;
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
if (last_task_used_spe == current)
|
|
|
|
last_task_used_spe = NULL;
|
|
|
|
#endif
|
|
|
|
preempt_enable();
|
|
|
|
}
|
2006-01-11 06:11:39 -05:00
|
|
|
#endif /* CONFIG_SMP */
|
2005-11-29 21:20:54 -05:00
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
int set_dabr(unsigned long dabr)
|
|
|
|
{
|
2007-06-04 01:15:48 -04:00
|
|
|
#ifdef CONFIG_PPC_MERGE /* XXX for now */
|
2005-11-02 23:30:49 -05:00
|
|
|
if (ppc_md.set_dabr)
|
|
|
|
return ppc_md.set_dabr(dabr);
|
2007-06-04 01:15:48 -04:00
|
|
|
#endif
|
2005-09-26 02:04:21 -04:00
|
|
|
|
2007-06-04 01:15:48 -04:00
|
|
|
/* XXX should we have a CPU_FTR_HAS_DABR ? */
|
|
|
|
#if defined(CONFIG_PPC64) || defined(CONFIG_6xx)
|
2005-11-02 23:30:49 -05:00
|
|
|
mtspr(SPRN_DABR, dabr);
|
2007-06-04 01:15:48 -04:00
|
|
|
#endif
|
2005-11-02 23:30:49 -05:00
|
|
|
return 0;
|
2005-09-26 02:04:21 -04:00
|
|
|
}
|
|
|
|
|
2005-10-10 08:29:05 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
DEFINE_PER_CPU(struct cpu_usage, cpu_usage_array);
|
|
|
|
#endif
|
2005-09-26 02:04:21 -04:00
|
|
|
|
2007-06-04 01:15:48 -04:00
|
|
|
static DEFINE_PER_CPU(unsigned long, current_dabr);
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
struct task_struct *__switch_to(struct task_struct *prev,
|
|
|
|
struct task_struct *new)
|
|
|
|
{
|
|
|
|
struct thread_struct *new_thread, *old_thread;
|
|
|
|
unsigned long flags;
|
|
|
|
struct task_struct *last;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/* avoid complexity of lazy save/restore of fpu
|
|
|
|
* by just saving it every time we switch out if
|
|
|
|
* this task used the fpu during the last quantum.
|
|
|
|
*
|
|
|
|
* If it tries to use the fpu again, it'll trap and
|
|
|
|
* reload its fp regs. So we don't have to do a restore
|
|
|
|
* every switch, just a save.
|
|
|
|
* -- Cort
|
|
|
|
*/
|
|
|
|
if (prev->thread.regs && (prev->thread.regs->msr & MSR_FP))
|
|
|
|
giveup_fpu(prev);
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
/*
|
|
|
|
* If the previous thread used altivec in the last quantum
|
|
|
|
* (thus changing altivec regs) then save them.
|
|
|
|
* We used to check the VRSAVE register but not all apps
|
|
|
|
* set it, so we don't rely on it now (and in fact we need
|
|
|
|
* to save & restore VSCR even if VRSAVE == 0). -- paulus
|
|
|
|
*
|
|
|
|
* On SMP we always save/restore altivec regs just to avoid the
|
|
|
|
* complexity of changing processors.
|
|
|
|
* -- Cort
|
|
|
|
*/
|
|
|
|
if (prev->thread.regs && (prev->thread.regs->msr & MSR_VEC))
|
|
|
|
giveup_altivec(prev);
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
/*
|
|
|
|
* If the previous thread used spe in the last quantum
|
|
|
|
* (thus changing spe regs) then save them.
|
|
|
|
*
|
|
|
|
* On SMP we always save/restore spe regs just to avoid the
|
|
|
|
* complexity of changing processors.
|
|
|
|
*/
|
|
|
|
if ((prev->thread.regs && (prev->thread.regs->msr & MSR_SPE)))
|
|
|
|
giveup_spe(prev);
|
2005-09-30 23:49:08 -04:00
|
|
|
#endif /* CONFIG_SPE */
|
|
|
|
|
|
|
|
#else /* CONFIG_SMP */
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
/* Avoid the trap. On smp this this never happens since
|
|
|
|
* we don't set last_task_used_altivec -- Cort
|
|
|
|
*/
|
|
|
|
if (new->thread.regs && last_task_used_altivec == new)
|
|
|
|
new->thread.regs->msr |= MSR_VEC;
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
#ifdef CONFIG_SPE
|
2005-09-26 02:04:21 -04:00
|
|
|
/* Avoid the trap. On smp this this never happens since
|
|
|
|
* we don't set last_task_used_spe
|
|
|
|
*/
|
|
|
|
if (new->thread.regs && last_task_used_spe == new)
|
|
|
|
new->thread.regs->msr |= MSR_SPE;
|
|
|
|
#endif /* CONFIG_SPE */
|
2005-09-30 23:49:08 -04:00
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
|
|
|
if (unlikely(__get_cpu_var(current_dabr) != new->thread.dabr)) {
|
|
|
|
set_dabr(new->thread.dabr);
|
|
|
|
__get_cpu_var(current_dabr) = new->thread.dabr;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_thread = &new->thread;
|
|
|
|
old_thread = ¤t->thread;
|
2005-10-10 08:29:05 -04:00
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
/*
|
|
|
|
* Collect processor utilization data per process
|
|
|
|
*/
|
|
|
|
if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
|
|
|
|
struct cpu_usage *cu = &__get_cpu_var(cpu_usage_array);
|
|
|
|
long unsigned start_tb, current_tb;
|
|
|
|
start_tb = old_thread->start_tb;
|
|
|
|
cu->current_tb = current_tb = mfspr(SPRN_PURR);
|
|
|
|
old_thread->accum_tb += (current_tb - start_tb);
|
|
|
|
new_thread->start_tb = current_tb;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
local_irq_save(flags);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-23 18:06:59 -05:00
|
|
|
|
|
|
|
account_system_vtime(current);
|
|
|
|
account_process_vtime(current);
|
|
|
|
calculate_steal_time();
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
last = _switch(old_thread, new_thread);
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
return last;
|
|
|
|
}
|
|
|
|
|
2005-10-10 08:29:05 -04:00
|
|
|
static int instructions_to_print = 16;
|
|
|
|
|
|
|
|
static void show_instructions(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
unsigned long pc = regs->nip - (instructions_to_print * 3 / 4 *
|
|
|
|
sizeof(int));
|
|
|
|
|
|
|
|
printk("Instruction dump:");
|
|
|
|
|
|
|
|
for (i = 0; i < instructions_to_print; i++) {
|
|
|
|
int instr;
|
|
|
|
|
|
|
|
if (!(i % 8))
|
|
|
|
printk("\n");
|
|
|
|
|
2007-09-27 14:38:55 -04:00
|
|
|
#if !defined(CONFIG_BOOKE)
|
|
|
|
/* If executing with the IMMU off, adjust pc rather
|
|
|
|
* than print XXXXXXXX.
|
|
|
|
*/
|
|
|
|
if (!(regs->msr & MSR_IR))
|
|
|
|
pc = (unsigned long)phys_to_virt(pc);
|
|
|
|
#endif
|
|
|
|
|
2006-03-23 01:38:10 -05:00
|
|
|
/* We use __get_user here *only* to avoid an OOPS on a
|
|
|
|
* bad address because the pc *should* only be a
|
|
|
|
* kernel address.
|
|
|
|
*/
|
2006-10-12 22:17:16 -04:00
|
|
|
if (!__kernel_text_address(pc) ||
|
|
|
|
__get_user(instr, (unsigned int __user *)pc)) {
|
2005-10-10 08:29:05 -04:00
|
|
|
printk("XXXXXXXX ");
|
|
|
|
} else {
|
|
|
|
if (regs->nip == pc)
|
|
|
|
printk("<%08x> ", instr);
|
|
|
|
else
|
|
|
|
printk("%08x ", instr);
|
|
|
|
}
|
|
|
|
|
|
|
|
pc += sizeof(int);
|
|
|
|
}
|
|
|
|
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct regbit {
|
|
|
|
unsigned long bit;
|
|
|
|
const char *name;
|
|
|
|
} msr_bits[] = {
|
|
|
|
{MSR_EE, "EE"},
|
|
|
|
{MSR_PR, "PR"},
|
|
|
|
{MSR_FP, "FP"},
|
|
|
|
{MSR_ME, "ME"},
|
|
|
|
{MSR_IR, "IR"},
|
|
|
|
{MSR_DR, "DR"},
|
|
|
|
{0, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static void printbits(unsigned long val, struct regbit *bits)
|
|
|
|
{
|
|
|
|
const char *sep = "";
|
|
|
|
|
|
|
|
printk("<");
|
|
|
|
for (; bits->bit; ++bits)
|
|
|
|
if (val & bits->bit) {
|
|
|
|
printk("%s%s", sep, bits->name);
|
|
|
|
sep = ",";
|
|
|
|
}
|
|
|
|
printk(">");
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
2007-03-20 21:38:19 -04:00
|
|
|
#define REG "%016lx"
|
2005-10-10 08:29:05 -04:00
|
|
|
#define REGS_PER_LINE 4
|
|
|
|
#define LAST_VOLATILE 13
|
|
|
|
#else
|
2007-03-20 21:38:19 -04:00
|
|
|
#define REG "%08lx"
|
2005-10-10 08:29:05 -04:00
|
|
|
#define REGS_PER_LINE 8
|
|
|
|
#define LAST_VOLATILE 12
|
|
|
|
#endif
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
void show_regs(struct pt_regs * regs)
|
|
|
|
{
|
|
|
|
int i, trap;
|
|
|
|
|
2005-10-10 08:29:05 -04:00
|
|
|
printk("NIP: "REG" LR: "REG" CTR: "REG"\n",
|
|
|
|
regs->nip, regs->link, regs->ctr);
|
|
|
|
printk("REGS: %p TRAP: %04lx %s (%s)\n",
|
2006-10-02 05:18:13 -04:00
|
|
|
regs, regs->trap, print_tainted(), init_utsname()->release);
|
2005-10-10 08:29:05 -04:00
|
|
|
printk("MSR: "REG" ", regs->msr);
|
|
|
|
printbits(regs->msr, msr_bits);
|
2007-03-20 21:38:19 -04:00
|
|
|
printk(" CR: %08lx XER: %08lx\n", regs->ccr, regs->xer);
|
2005-09-26 02:04:21 -04:00
|
|
|
trap = TRAP(regs);
|
|
|
|
if (trap == 0x300 || trap == 0x600)
|
2007-07-26 01:46:15 -04:00
|
|
|
#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
|
|
|
|
printk("DEAR: "REG", ESR: "REG"\n", regs->dar, regs->dsisr);
|
|
|
|
#else
|
2005-10-10 08:29:05 -04:00
|
|
|
printk("DAR: "REG", DSISR: "REG"\n", regs->dar, regs->dsisr);
|
2007-07-26 01:46:15 -04:00
|
|
|
#endif
|
2005-10-10 08:29:05 -04:00
|
|
|
printk("TASK = %p[%d] '%s' THREAD: %p",
|
2007-10-19 02:40:41 -04:00
|
|
|
current, task_pid_nr(current), current->comm, task_thread_info(current));
|
2005-09-26 02:04:21 -04:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
printk(" CPU: %d", smp_processor_id());
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
|
|
|
for (i = 0; i < 32; i++) {
|
2005-10-10 08:29:05 -04:00
|
|
|
if ((i % REGS_PER_LINE) == 0)
|
2005-09-26 02:04:21 -04:00
|
|
|
printk("\n" KERN_INFO "GPR%02d: ", i);
|
2005-10-10 08:29:05 -04:00
|
|
|
printk(REG " ", regs->gpr[i]);
|
|
|
|
if (i == LAST_VOLATILE && !FULL_REGS(regs))
|
2005-09-26 02:04:21 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
printk("\n");
|
|
|
|
#ifdef CONFIG_KALLSYMS
|
|
|
|
/*
|
|
|
|
* Lookup NIP late so we have the best change of getting the
|
|
|
|
* above info out without failing
|
|
|
|
*/
|
2005-10-10 08:29:05 -04:00
|
|
|
printk("NIP ["REG"] ", regs->nip);
|
2005-09-26 02:04:21 -04:00
|
|
|
print_symbol("%s\n", regs->nip);
|
2005-10-10 08:29:05 -04:00
|
|
|
printk("LR ["REG"] ", regs->link);
|
2005-09-26 02:04:21 -04:00
|
|
|
print_symbol("%s\n", regs->link);
|
|
|
|
#endif
|
|
|
|
show_stack(current, (unsigned long *) regs->gpr[1]);
|
2005-10-10 08:29:05 -04:00
|
|
|
if (!user_mode(regs))
|
|
|
|
show_instructions(regs);
|
2005-09-26 02:04:21 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void exit_thread(void)
|
|
|
|
{
|
2005-11-29 21:20:54 -05:00
|
|
|
discard_lazy_cpu_state();
|
2005-09-26 02:04:21 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void flush_thread(void)
|
|
|
|
{
|
2005-10-10 08:29:05 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
struct thread_info *t = current_thread_info();
|
|
|
|
|
2007-03-10 03:23:03 -05:00
|
|
|
if (test_ti_thread_flag(t, TIF_ABI_PENDING)) {
|
|
|
|
clear_ti_thread_flag(t, TIF_ABI_PENDING);
|
|
|
|
if (test_ti_thread_flag(t, TIF_32BIT))
|
|
|
|
clear_ti_thread_flag(t, TIF_32BIT);
|
|
|
|
else
|
|
|
|
set_ti_thread_flag(t, TIF_32BIT);
|
|
|
|
}
|
2005-10-10 08:29:05 -04:00
|
|
|
#endif
|
|
|
|
|
2005-11-29 21:20:54 -05:00
|
|
|
discard_lazy_cpu_state();
|
2005-09-26 02:04:21 -04:00
|
|
|
|
|
|
|
if (current->thread.dabr) {
|
|
|
|
current->thread.dabr = 0;
|
|
|
|
set_dabr(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
release_thread(struct task_struct *t)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This gets called before we allocate a new thread and copy
|
|
|
|
* the current task into it.
|
|
|
|
*/
|
|
|
|
void prepare_to_copy(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
flush_fp_to_thread(current);
|
|
|
|
flush_altivec_to_thread(current);
|
|
|
|
flush_spe_to_thread(current);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy a thread..
|
|
|
|
*/
|
2005-10-10 08:29:05 -04:00
|
|
|
int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
|
|
|
|
unsigned long unused, struct task_struct *p,
|
|
|
|
struct pt_regs *regs)
|
2005-09-26 02:04:21 -04:00
|
|
|
{
|
|
|
|
struct pt_regs *childregs, *kregs;
|
|
|
|
extern void ret_from_fork(void);
|
2006-01-12 04:06:02 -05:00
|
|
|
unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE;
|
2005-09-26 02:04:21 -04:00
|
|
|
|
|
|
|
CHECK_FULL_REGS(regs);
|
|
|
|
/* Copy registers */
|
|
|
|
sp -= sizeof(struct pt_regs);
|
|
|
|
childregs = (struct pt_regs *) sp;
|
|
|
|
*childregs = *regs;
|
|
|
|
if ((childregs->msr & MSR_PR) == 0) {
|
|
|
|
/* for kernel thread, set `current' and stackptr in new task */
|
|
|
|
childregs->gpr[1] = sp + sizeof(struct pt_regs);
|
2005-10-10 08:29:05 -04:00
|
|
|
#ifdef CONFIG_PPC32
|
2005-09-26 02:04:21 -04:00
|
|
|
childregs->gpr[2] = (unsigned long) p;
|
2005-10-10 08:29:05 -04:00
|
|
|
#else
|
2006-01-12 04:06:01 -05:00
|
|
|
clear_tsk_thread_flag(p, TIF_32BIT);
|
2005-10-10 08:29:05 -04:00
|
|
|
#endif
|
2005-09-26 02:04:21 -04:00
|
|
|
p->thread.regs = NULL; /* no user register state */
|
|
|
|
} else {
|
|
|
|
childregs->gpr[1] = usp;
|
|
|
|
p->thread.regs = childregs;
|
2005-10-10 08:29:05 -04:00
|
|
|
if (clone_flags & CLONE_SETTLS) {
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
if (!test_thread_flag(TIF_32BIT))
|
|
|
|
childregs->gpr[13] = childregs->gpr[6];
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
childregs->gpr[2] = childregs->gpr[6];
|
|
|
|
}
|
2005-09-26 02:04:21 -04:00
|
|
|
}
|
|
|
|
childregs->gpr[3] = 0; /* Result from fork() */
|
|
|
|
sp -= STACK_FRAME_OVERHEAD;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The way this works is that at some point in the future
|
|
|
|
* some task will call _switch to switch to the new task.
|
|
|
|
* That will pop off the stack frame created below and start
|
|
|
|
* the new task running at ret_from_fork. The new task will
|
|
|
|
* do some house keeping and then return from the fork or clone
|
|
|
|
* system call, using the stack frame created above.
|
|
|
|
*/
|
|
|
|
sp -= sizeof(struct pt_regs);
|
|
|
|
kregs = (struct pt_regs *) sp;
|
|
|
|
sp -= STACK_FRAME_OVERHEAD;
|
|
|
|
p->thread.ksp = sp;
|
|
|
|
|
2005-10-10 08:29:05 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
if (cpu_has_feature(CPU_FTR_SLB)) {
|
2007-10-11 06:37:10 -04:00
|
|
|
unsigned long sp_vsid;
|
2005-11-06 19:06:55 -05:00
|
|
|
unsigned long llp = mmu_psize_defs[mmu_linear_psize].sllp;
|
2005-10-10 08:29:05 -04:00
|
|
|
|
2007-10-11 06:37:10 -04:00
|
|
|
if (cpu_has_feature(CPU_FTR_1T_SEGMENT))
|
|
|
|
sp_vsid = get_kernel_vsid(sp, MMU_SEGSIZE_1T)
|
|
|
|
<< SLB_VSID_SHIFT_1T;
|
|
|
|
else
|
|
|
|
sp_vsid = get_kernel_vsid(sp, MMU_SEGSIZE_256M)
|
|
|
|
<< SLB_VSID_SHIFT;
|
2005-11-06 19:06:55 -05:00
|
|
|
sp_vsid |= SLB_VSID_KERNEL | llp;
|
2005-10-10 08:29:05 -04:00
|
|
|
p->thread.ksp_vsid = sp_vsid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The PPC64 ABI makes use of a TOC to contain function
|
|
|
|
* pointers. The function (ret_from_except) is actually a pointer
|
|
|
|
* to the TOC entry. The first entry is a pointer to the actual
|
|
|
|
* function.
|
|
|
|
*/
|
|
|
|
kregs->nip = *((unsigned long *)ret_from_fork);
|
|
|
|
#else
|
|
|
|
kregs->nip = (unsigned long)ret_from_fork;
|
|
|
|
#endif
|
2005-09-26 02:04:21 -04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up a thread for executing a new program
|
|
|
|
*/
|
2005-10-10 08:29:05 -04:00
|
|
|
void start_thread(struct pt_regs *regs, unsigned long start, unsigned long sp)
|
2005-09-26 02:04:21 -04:00
|
|
|
{
|
2005-10-21 02:01:33 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
unsigned long load_addr = regs->gpr[2]; /* saved by ELF_PLAT_INIT */
|
|
|
|
#endif
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
set_fs(USER_DS);
|
2005-10-10 08:29:05 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we exec out of a kernel thread then thread.regs will not be
|
|
|
|
* set. Do it now.
|
|
|
|
*/
|
|
|
|
if (!current->thread.regs) {
|
2006-01-12 04:06:02 -05:00
|
|
|
struct pt_regs *regs = task_stack_page(current) + THREAD_SIZE;
|
|
|
|
current->thread.regs = regs - 1;
|
2005-10-10 08:29:05 -04:00
|
|
|
}
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
memset(regs->gpr, 0, sizeof(regs->gpr));
|
|
|
|
regs->ctr = 0;
|
|
|
|
regs->link = 0;
|
|
|
|
regs->xer = 0;
|
|
|
|
regs->ccr = 0;
|
|
|
|
regs->gpr[1] = sp;
|
2005-10-10 08:29:05 -04:00
|
|
|
|
2007-09-24 19:52:44 -04:00
|
|
|
/*
|
|
|
|
* We have just cleared all the nonvolatile GPRs, so make
|
|
|
|
* FULL_REGS(regs) return true. This is necessary to allow
|
|
|
|
* ptrace to examine the thread immediately after exec.
|
|
|
|
*/
|
|
|
|
regs->trap &= ~1UL;
|
|
|
|
|
2005-10-10 08:29:05 -04:00
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
regs->mq = 0;
|
|
|
|
regs->nip = start;
|
2005-09-26 02:04:21 -04:00
|
|
|
regs->msr = MSR_USER;
|
2005-10-10 08:29:05 -04:00
|
|
|
#else
|
2005-10-12 23:40:54 -04:00
|
|
|
if (!test_thread_flag(TIF_32BIT)) {
|
2005-10-21 02:01:33 -04:00
|
|
|
unsigned long entry, toc;
|
2005-10-10 08:29:05 -04:00
|
|
|
|
|
|
|
/* start is a relocated pointer to the function descriptor for
|
|
|
|
* the elf _start routine. The first entry in the function
|
|
|
|
* descriptor is the entry address of _start and the second
|
|
|
|
* entry is the TOC value we need to use.
|
|
|
|
*/
|
|
|
|
__get_user(entry, (unsigned long __user *)start);
|
|
|
|
__get_user(toc, (unsigned long __user *)start+1);
|
|
|
|
|
|
|
|
/* Check whether the e_entry function descriptor entries
|
|
|
|
* need to be relocated before we can use them.
|
|
|
|
*/
|
|
|
|
if (load_addr != 0) {
|
|
|
|
entry += load_addr;
|
|
|
|
toc += load_addr;
|
|
|
|
}
|
|
|
|
regs->nip = entry;
|
|
|
|
regs->gpr[2] = toc;
|
|
|
|
regs->msr = MSR_USER64;
|
2005-10-12 23:40:54 -04:00
|
|
|
} else {
|
|
|
|
regs->nip = start;
|
|
|
|
regs->gpr[2] = 0;
|
|
|
|
regs->msr = MSR_USER32;
|
2005-10-10 08:29:05 -04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-11-29 21:20:54 -05:00
|
|
|
discard_lazy_cpu_state();
|
2005-09-26 02:04:21 -04:00
|
|
|
memset(current->thread.fpr, 0, sizeof(current->thread.fpr));
|
[PATCH] powerpc: Fix handling of fpscr on 64-bit
The recent merge of fpu.S broken the handling of fpscr for
ARCH=powerpc and CONFIG_PPC64=y. FP registers could be corrupted,
leading to strange random application crashes.
The confusion arises, because the thread_struct has (and requires) a
64-bit area to save the fpscr, because we use load/store double
instructions to get it in to/out of the FPU. However, only the low
32-bits are actually used, so we want to treat it as a 32-bit quantity
when manipulating its bits to avoid extra load/stores on 32-bit. This
patch replaces the current definition with a structure of two 32-bit
quantities (pad and val), to clarify things as much as is possible.
The 'val' field is used when manipulating bits, the structure itself
is used when obtaining the address for loading/unloading the value
from the FPU.
While we're at it, consolidate the 4 (!) almost identical versions of
cvt_fd() and cvt_df() (arch/ppc/kernel/misc.S,
arch/ppc64/kernel/misc.S, arch/powerpc/kernel/misc_32.S,
arch/powerpc/kernel/misc_64.S) into a single version in fpu.S. The
new version takes a pointer to thread_struct and applies the correct
offset itself, rather than a pointer to the fpscr field itself, again
to avoid confusion as to which is the correct field to use.
Finally, this patch makes ARCH=ppc64 also use the consolidated fpu.S
code, which it previously did not.
Built for G5 (ARCH=ppc64 and ARCH=powerpc), 32-bit powermac (ARCH=ppc
and ARCH=powerpc) and Walnut (ARCH=ppc, CONFIG_MATH_EMULATION=y).
Booted on G5 (ARCH=powerpc) and things which previously fell over no
longer do.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-10-27 02:27:25 -04:00
|
|
|
current->thread.fpscr.val = 0;
|
2005-09-26 02:04:21 -04:00
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
memset(current->thread.vr, 0, sizeof(current->thread.vr));
|
|
|
|
memset(¤t->thread.vscr, 0, sizeof(current->thread.vscr));
|
2005-10-10 08:29:05 -04:00
|
|
|
current->thread.vscr.u[3] = 0x00010000; /* Java mode disabled */
|
2005-09-26 02:04:21 -04:00
|
|
|
current->thread.vrsave = 0;
|
|
|
|
current->thread.used_vr = 0;
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
memset(current->thread.evr, 0, sizeof(current->thread.evr));
|
|
|
|
current->thread.acc = 0;
|
|
|
|
current->thread.spefscr = 0;
|
|
|
|
current->thread.used_spe = 0;
|
|
|
|
#endif /* CONFIG_SPE */
|
|
|
|
}
|
|
|
|
|
|
|
|
#define PR_FP_ALL_EXCEPT (PR_FP_EXC_DIV | PR_FP_EXC_OVF | PR_FP_EXC_UND \
|
|
|
|
| PR_FP_EXC_RES | PR_FP_EXC_INV)
|
|
|
|
|
|
|
|
int set_fpexc_mode(struct task_struct *tsk, unsigned int val)
|
|
|
|
{
|
|
|
|
struct pt_regs *regs = tsk->thread.regs;
|
|
|
|
|
|
|
|
/* This is a bit hairy. If we are an SPE enabled processor
|
|
|
|
* (have embedded fp) we store the IEEE exception enable flags in
|
|
|
|
* fpexc_mode. fpexc_mode is also used for setting FP exception
|
|
|
|
* mode (asyn, precise, disabled) for 'Classic' FP. */
|
|
|
|
if (val & PR_FP_EXC_SW_ENABLE) {
|
|
|
|
#ifdef CONFIG_SPE
|
2007-09-13 02:44:20 -04:00
|
|
|
if (cpu_has_feature(CPU_FTR_SPE)) {
|
|
|
|
tsk->thread.fpexc_mode = val &
|
|
|
|
(PR_FP_EXC_SW_ENABLE | PR_FP_ALL_EXCEPT);
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2005-09-26 02:04:21 -04:00
|
|
|
#else
|
|
|
|
return -EINVAL;
|
|
|
|
#endif
|
|
|
|
}
|
2005-10-10 08:29:05 -04:00
|
|
|
|
|
|
|
/* on a CONFIG_SPE this does not hurt us. The bits that
|
|
|
|
* __pack_fe01 use do not overlap with bits used for
|
|
|
|
* PR_FP_EXC_SW_ENABLE. Additionally, the MSR[FE0,FE1] bits
|
|
|
|
* on CONFIG_SPE implementations are reserved so writing to
|
|
|
|
* them does not change anything */
|
|
|
|
if (val > PR_FP_EXC_PRECISE)
|
|
|
|
return -EINVAL;
|
|
|
|
tsk->thread.fpexc_mode = __pack_fe01(val);
|
|
|
|
if (regs != NULL && (regs->msr & MSR_FP) != 0)
|
|
|
|
regs->msr = (regs->msr & ~(MSR_FE0|MSR_FE1))
|
|
|
|
| tsk->thread.fpexc_mode;
|
2005-09-26 02:04:21 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_fpexc_mode(struct task_struct *tsk, unsigned long adr)
|
|
|
|
{
|
|
|
|
unsigned int val;
|
|
|
|
|
|
|
|
if (tsk->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE)
|
|
|
|
#ifdef CONFIG_SPE
|
2007-09-13 02:44:20 -04:00
|
|
|
if (cpu_has_feature(CPU_FTR_SPE))
|
|
|
|
val = tsk->thread.fpexc_mode;
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
2005-09-26 02:04:21 -04:00
|
|
|
#else
|
|
|
|
return -EINVAL;
|
|
|
|
#endif
|
|
|
|
else
|
|
|
|
val = __unpack_fe01(tsk->thread.fpexc_mode);
|
|
|
|
return put_user(val, (unsigned int __user *) adr);
|
|
|
|
}
|
|
|
|
|
2006-06-07 02:14:40 -04:00
|
|
|
int set_endian(struct task_struct *tsk, unsigned int val)
|
|
|
|
{
|
|
|
|
struct pt_regs *regs = tsk->thread.regs;
|
|
|
|
|
|
|
|
if ((val == PR_ENDIAN_LITTLE && !cpu_has_feature(CPU_FTR_REAL_LE)) ||
|
|
|
|
(val == PR_ENDIAN_PPC_LITTLE && !cpu_has_feature(CPU_FTR_PPC_LE)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (regs == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (val == PR_ENDIAN_BIG)
|
|
|
|
regs->msr &= ~MSR_LE;
|
|
|
|
else if (val == PR_ENDIAN_LITTLE || val == PR_ENDIAN_PPC_LITTLE)
|
|
|
|
regs->msr |= MSR_LE;
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_endian(struct task_struct *tsk, unsigned long adr)
|
|
|
|
{
|
|
|
|
struct pt_regs *regs = tsk->thread.regs;
|
|
|
|
unsigned int val;
|
|
|
|
|
|
|
|
if (!cpu_has_feature(CPU_FTR_PPC_LE) &&
|
|
|
|
!cpu_has_feature(CPU_FTR_REAL_LE))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (regs == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (regs->msr & MSR_LE) {
|
|
|
|
if (cpu_has_feature(CPU_FTR_REAL_LE))
|
|
|
|
val = PR_ENDIAN_LITTLE;
|
|
|
|
else
|
|
|
|
val = PR_ENDIAN_PPC_LITTLE;
|
|
|
|
} else
|
|
|
|
val = PR_ENDIAN_BIG;
|
|
|
|
|
|
|
|
return put_user(val, (unsigned int __user *)adr);
|
|
|
|
}
|
|
|
|
|
2006-06-07 02:15:39 -04:00
|
|
|
int set_unalign_ctl(struct task_struct *tsk, unsigned int val)
|
|
|
|
{
|
|
|
|
tsk->thread.align_ctl = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_unalign_ctl(struct task_struct *tsk, unsigned long adr)
|
|
|
|
{
|
|
|
|
return put_user(tsk->thread.align_ctl, (unsigned int __user *)adr);
|
|
|
|
}
|
|
|
|
|
2005-10-10 08:29:05 -04:00
|
|
|
#define TRUNC_PTR(x) ((typeof(x))(((unsigned long)(x)) & 0xffffffff))
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
int sys_clone(unsigned long clone_flags, unsigned long usp,
|
|
|
|
int __user *parent_tidp, void __user *child_threadptr,
|
|
|
|
int __user *child_tidp, int p6,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
CHECK_FULL_REGS(regs);
|
|
|
|
if (usp == 0)
|
|
|
|
usp = regs->gpr[1]; /* stack pointer for child */
|
2005-10-10 08:29:05 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
if (test_thread_flag(TIF_32BIT)) {
|
|
|
|
parent_tidp = TRUNC_PTR(parent_tidp);
|
|
|
|
child_tidp = TRUNC_PTR(child_tidp);
|
|
|
|
}
|
|
|
|
#endif
|
2005-09-26 02:04:21 -04:00
|
|
|
return do_fork(clone_flags, usp, regs, 0, parent_tidp, child_tidp);
|
|
|
|
}
|
|
|
|
|
|
|
|
int sys_fork(unsigned long p1, unsigned long p2, unsigned long p3,
|
|
|
|
unsigned long p4, unsigned long p5, unsigned long p6,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
CHECK_FULL_REGS(regs);
|
|
|
|
return do_fork(SIGCHLD, regs->gpr[1], regs, 0, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
int sys_vfork(unsigned long p1, unsigned long p2, unsigned long p3,
|
|
|
|
unsigned long p4, unsigned long p5, unsigned long p6,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
CHECK_FULL_REGS(regs);
|
|
|
|
return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gpr[1],
|
|
|
|
regs, 0, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2,
|
|
|
|
unsigned long a3, unsigned long a4, unsigned long a5,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
int error;
|
2005-10-10 08:29:05 -04:00
|
|
|
char *filename;
|
2005-09-26 02:04:21 -04:00
|
|
|
|
|
|
|
filename = getname((char __user *) a0);
|
|
|
|
error = PTR_ERR(filename);
|
|
|
|
if (IS_ERR(filename))
|
|
|
|
goto out;
|
|
|
|
flush_fp_to_thread(current);
|
|
|
|
flush_altivec_to_thread(current);
|
|
|
|
flush_spe_to_thread(current);
|
2005-09-28 06:28:14 -04:00
|
|
|
error = do_execve(filename, (char __user * __user *) a1,
|
|
|
|
(char __user * __user *) a2, regs);
|
2005-09-26 02:04:21 -04:00
|
|
|
if (error == 0) {
|
|
|
|
task_lock(current);
|
|
|
|
current->ptrace &= ~PT_DTRACE;
|
|
|
|
task_unlock(current);
|
|
|
|
}
|
|
|
|
putname(filename);
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-02-18 19:42:42 -05:00
|
|
|
#ifdef CONFIG_IRQSTACKS
|
|
|
|
static inline int valid_irq_stack(unsigned long sp, struct task_struct *p,
|
|
|
|
unsigned long nbytes)
|
|
|
|
{
|
|
|
|
unsigned long stack_page;
|
|
|
|
unsigned long cpu = task_cpu(p);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Avoid crashing if the stack has overflowed and corrupted
|
|
|
|
* task_cpu(p), which is in the thread_info struct.
|
|
|
|
*/
|
|
|
|
if (cpu < NR_CPUS && cpu_possible(cpu)) {
|
|
|
|
stack_page = (unsigned long) hardirq_ctx[cpu];
|
|
|
|
if (sp >= stack_page + sizeof(struct thread_struct)
|
|
|
|
&& sp <= stack_page + THREAD_SIZE - nbytes)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
stack_page = (unsigned long) softirq_ctx[cpu];
|
|
|
|
if (sp >= stack_page + sizeof(struct thread_struct)
|
|
|
|
&& sp <= stack_page + THREAD_SIZE - nbytes)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
#define valid_irq_stack(sp, p, nb) 0
|
|
|
|
#endif /* CONFIG_IRQSTACKS */
|
|
|
|
|
2006-03-26 19:46:18 -05:00
|
|
|
int validate_sp(unsigned long sp, struct task_struct *p,
|
2005-09-26 02:04:21 -04:00
|
|
|
unsigned long nbytes)
|
|
|
|
{
|
2006-01-12 04:06:02 -05:00
|
|
|
unsigned long stack_page = (unsigned long)task_stack_page(p);
|
2005-09-26 02:04:21 -04:00
|
|
|
|
|
|
|
if (sp >= stack_page + sizeof(struct thread_struct)
|
|
|
|
&& sp <= stack_page + THREAD_SIZE - nbytes)
|
|
|
|
return 1;
|
|
|
|
|
2007-02-18 19:42:42 -05:00
|
|
|
return valid_irq_stack(sp, p, nbytes);
|
2005-09-26 02:04:21 -04:00
|
|
|
}
|
|
|
|
|
2005-10-10 08:29:05 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
#define MIN_STACK_FRAME 112 /* same as STACK_FRAME_OVERHEAD, in fact */
|
|
|
|
#define FRAME_LR_SAVE 2
|
|
|
|
#define INT_FRAME_SIZE (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD + 288)
|
|
|
|
#define REGS_MARKER 0x7265677368657265ul
|
|
|
|
#define FRAME_MARKER 12
|
|
|
|
#else
|
|
|
|
#define MIN_STACK_FRAME 16
|
|
|
|
#define FRAME_LR_SAVE 1
|
|
|
|
#define INT_FRAME_SIZE (sizeof(struct pt_regs) + STACK_FRAME_OVERHEAD)
|
|
|
|
#define REGS_MARKER 0x72656773ul
|
|
|
|
#define FRAME_MARKER 2
|
2005-09-26 02:04:21 -04:00
|
|
|
#endif
|
|
|
|
|
2006-03-26 19:46:18 -05:00
|
|
|
EXPORT_SYMBOL(validate_sp);
|
|
|
|
|
2005-09-26 02:04:21 -04:00
|
|
|
unsigned long get_wchan(struct task_struct *p)
|
|
|
|
{
|
|
|
|
unsigned long ip, sp;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
if (!p || p == current || p->state == TASK_RUNNING)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
sp = p->thread.ksp;
|
2005-10-10 08:29:05 -04:00
|
|
|
if (!validate_sp(sp, p, MIN_STACK_FRAME))
|
2005-09-26 02:04:21 -04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
sp = *(unsigned long *)sp;
|
2005-10-10 08:29:05 -04:00
|
|
|
if (!validate_sp(sp, p, MIN_STACK_FRAME))
|
2005-09-26 02:04:21 -04:00
|
|
|
return 0;
|
|
|
|
if (count > 0) {
|
2005-10-10 08:29:05 -04:00
|
|
|
ip = ((unsigned long *)sp)[FRAME_LR_SAVE];
|
2005-09-26 02:04:21 -04:00
|
|
|
if (!in_sched_functions(ip))
|
|
|
|
return ip;
|
|
|
|
}
|
|
|
|
} while (count++ < 16);
|
|
|
|
return 0;
|
|
|
|
}
|
2005-10-10 08:29:05 -04:00
|
|
|
|
|
|
|
static int kstack_depth_to_print = 64;
|
|
|
|
|
|
|
|
void show_stack(struct task_struct *tsk, unsigned long *stack)
|
|
|
|
{
|
|
|
|
unsigned long sp, ip, lr, newsp;
|
|
|
|
int count = 0;
|
|
|
|
int firstframe = 1;
|
|
|
|
|
|
|
|
sp = (unsigned long) stack;
|
|
|
|
if (tsk == NULL)
|
|
|
|
tsk = current;
|
|
|
|
if (sp == 0) {
|
|
|
|
if (tsk == current)
|
|
|
|
asm("mr %0,1" : "=r" (sp));
|
|
|
|
else
|
|
|
|
sp = tsk->thread.ksp;
|
|
|
|
}
|
|
|
|
|
|
|
|
lr = 0;
|
|
|
|
printk("Call Trace:\n");
|
|
|
|
do {
|
|
|
|
if (!validate_sp(sp, tsk, MIN_STACK_FRAME))
|
|
|
|
return;
|
|
|
|
|
|
|
|
stack = (unsigned long *) sp;
|
|
|
|
newsp = stack[0];
|
|
|
|
ip = stack[FRAME_LR_SAVE];
|
|
|
|
if (!firstframe || ip != lr) {
|
|
|
|
printk("["REG"] ["REG"] ", sp, ip);
|
|
|
|
print_symbol("%s", ip);
|
|
|
|
if (firstframe)
|
|
|
|
printk(" (unreliable)");
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
firstframe = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if this is an exception frame.
|
|
|
|
* We look for the "regshere" marker in the current frame.
|
|
|
|
*/
|
|
|
|
if (validate_sp(sp, tsk, INT_FRAME_SIZE)
|
|
|
|
&& stack[FRAME_MARKER] == REGS_MARKER) {
|
|
|
|
struct pt_regs *regs = (struct pt_regs *)
|
|
|
|
(sp + STACK_FRAME_OVERHEAD);
|
|
|
|
printk("--- Exception: %lx", regs->trap);
|
|
|
|
print_symbol(" at %s\n", regs->nip);
|
|
|
|
lr = regs->link;
|
|
|
|
print_symbol(" LR = %s\n", lr);
|
|
|
|
firstframe = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
sp = newsp;
|
|
|
|
} while (count++ < kstack_depth_to_print);
|
|
|
|
}
|
|
|
|
|
|
|
|
void dump_stack(void)
|
|
|
|
{
|
|
|
|
show_stack(current, NULL);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dump_stack);
|
2006-02-12 22:48:35 -05:00
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
void ppc64_runlatch_on(void)
|
|
|
|
{
|
|
|
|
unsigned long ctrl;
|
|
|
|
|
|
|
|
if (cpu_has_feature(CPU_FTR_CTRL) && !test_thread_flag(TIF_RUNLATCH)) {
|
|
|
|
HMT_medium();
|
|
|
|
|
|
|
|
ctrl = mfspr(SPRN_CTRLF);
|
|
|
|
ctrl |= CTRL_RUNLATCH;
|
|
|
|
mtspr(SPRN_CTRLT, ctrl);
|
|
|
|
|
|
|
|
set_thread_flag(TIF_RUNLATCH);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ppc64_runlatch_off(void)
|
|
|
|
{
|
|
|
|
unsigned long ctrl;
|
|
|
|
|
|
|
|
if (cpu_has_feature(CPU_FTR_CTRL) && test_thread_flag(TIF_RUNLATCH)) {
|
|
|
|
HMT_medium();
|
|
|
|
|
|
|
|
clear_thread_flag(TIF_RUNLATCH);
|
|
|
|
|
|
|
|
ctrl = mfspr(SPRN_CTRLF);
|
|
|
|
ctrl &= ~CTRL_RUNLATCH;
|
|
|
|
mtspr(SPRN_CTRLT, ctrl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|