Merge branch 'for-2.6.25' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc

* 'for-2.6.25' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc: (69 commits)
  [POWERPC] Add SPE registers to core dumps
  [POWERPC] Use regset code for compat PTRACE_*REGS* calls
  [POWERPC] Use generic compat_sys_ptrace
  [POWERPC] Use generic compat_ptrace_request
  [POWERPC] Use generic ptrace peekdata/pokedata
  [POWERPC] Use regset code for PTRACE_*REGS* requests
  [POWERPC] Switch to generic compat_binfmt_elf code
  [POWERPC] Switch to using user_regset-based core dumps
  [POWERPC] Add user_regset compat support
  [POWERPC] Add user_regset_view definitions
  [POWERPC] Use user_regset accessors for GPRs
  [POWERPC] ptrace accessors for special regs MSR and TRAP
  [POWERPC] Use user_regset accessors for SPE regs
  [POWERPC] Use user_regset accessors for altivec regs
  [POWERPC] Use user_regset accessors for FP regs
  [POWERPC] mpc52xx: fix compile error introduce when rebasing patch
  [POWERPC] 4xx: PCIe indirect DCR spinlock fix.
  [POWERPC] Add missing native dcr dcr_ind_lock spinlock
  [POWERPC] 4xx: Fix offset value on Warp board
  [POWERPC] 4xx: Add 440EPx Sequoia ehci dts entry
  ...

10 files changed, 555 insertions, 428 deletions

diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index 58dbfeff9b4d..0662ae46f724 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -2,6 +2,8 @@
 # Makefile for the linux kernel.
 #
 
+CFLAGS_ptrace.o         += -DUTS_MACHINE='"$(UTS_MACHINE)"'
+
 ifeq ($(CONFIG_PPC64),y)
 CFLAGS_prom_init.o      += -mno-minimal-toc
 endif
@@ -15,7 +17,7 @@ obj-y				:= semaphore.o cputable.o ptrace.o syscalls.o \
                                    init_task.o process.o systbl.o idle.o \
                                    signal.o
 obj-y                           += vdso32/
-obj-$(CONFIG_PPC64)             += setup_64.o binfmt_elf32.o sys_ppc32.o \
+obj-$(CONFIG_PPC64)             += setup_64.o sys_ppc32.o \
                                    signal_64.o ptrace32.o \
                                    paca.o cpu_setup_ppc970.o \
                                    cpu_setup_pa6t.o \
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index ed083feaf6f9..e6e49289f788 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -22,6 +22,7 @@
 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <linux/suspend.h>
+#include <linux/hrtimer.h>
 #ifdef CONFIG_PPC64
 #include <linux/time.h>
 #include <linux/hardirq.h>
@@ -312,7 +313,7 @@ int main(void)
         DEFINE(CLOCK_REALTIME, CLOCK_REALTIME);
         DEFINE(CLOCK_MONOTONIC, CLOCK_MONOTONIC);
         DEFINE(NSEC_PER_SEC, NSEC_PER_SEC);
-        DEFINE(CLOCK_REALTIME_RES, TICK_NSEC);
+        DEFINE(CLOCK_REALTIME_RES, (KTIME_MONOTONIC_RES).tv64);
 
 #ifdef CONFIG_BUG
         DEFINE(BUG_ENTRY_SIZE, sizeof(struct bug_entry));
diff --git a/arch/powerpc/kernel/binfmt_elf32.c b/arch/powerpc/kernel/binfmt_elf32.c
deleted file mode 100644
index 1d45d7782d4e..000000000000
--- a/arch/powerpc/kernel/binfmt_elf32.c
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * binfmt_elf32.c: Support 32-bit PPC ELF binaries on Power3 and followons.
- * based on the SPARC64 version.
- * Copyright (C) 1995, 1996, 1997, 1998 David S. Miller (davem@redhat.com)
- * Copyright (C) 1995, 1996, 1997, 1998 Jakub Jelinek   (jj@ultra.linux.cz)
- *
- * Copyright (C) 2000,2001 Ken Aaker (kdaaker@rchland.vnet.ibm.com), IBM Corp
- * Copyright (C) 2001 Anton Blanchard (anton@au.ibm.com), IBM
- *
- * 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 <asm/processor.h>
-#include <linux/module.h>
-#include <linux/compat.h>
-#include <linux/elfcore-compat.h>
-
-#undef  ELF_ARCH
-#undef  ELF_CLASS
-#define ELF_CLASS       ELFCLASS32
-#define ELF_ARCH        EM_PPC
-
-#undef  elfhdr
-#undef  elf_phdr
-#undef  elf_note
-#undef  elf_addr_t
-#define elfhdr          elf32_hdr
-#define elf_phdr        elf32_phdr
-#define elf_note        elf32_note
-#define elf_addr_t      Elf32_Off
-
-#define elf_prstatus    compat_elf_prstatus
-#define elf_prpsinfo    compat_elf_prpsinfo
-
-#define elf_core_copy_regs compat_elf_core_copy_regs
-static inline void compat_elf_core_copy_regs(compat_elf_gregset_t *elf_regs,
-                                             struct pt_regs *regs)
-{
-        PPC_ELF_CORE_COPY_REGS((*elf_regs), regs);
-}
-
-#define elf_core_copy_task_regs compat_elf_core_copy_task_regs
-static int compat_elf_core_copy_task_regs(struct task_struct *tsk,
-                                          compat_elf_gregset_t *elf_regs)
-{
-        struct pt_regs *regs = tsk->thread.regs;
-        if (regs)
-                compat_elf_core_copy_regs(elf_regs, regs);
-        return 1;
-}
-
-#include <linux/time.h>
-
-#undef cputime_to_timeval
-#define cputime_to_timeval cputime_to_compat_timeval
-static __inline__ void
-cputime_to_compat_timeval(const cputime_t cputime, struct compat_timeval *value)
-{
-        unsigned long jiffies = cputime_to_jiffies(cputime);
-        value->tv_usec = (jiffies % HZ) * (1000000L / HZ);
-        value->tv_sec = jiffies / HZ;
-}
-
-#define init_elf_binfmt init_elf32_binfmt
-
-#include "../../../fs/binfmt_elf.c"
diff --git a/arch/powerpc/kernel/cputable.c b/arch/powerpc/kernel/cputable.c
index a4c2771b5e62..2a8f5cc5184f 100644
--- a/arch/powerpc/kernel/cputable.c
+++ b/arch/powerpc/kernel/cputable.c
@@ -959,6 +959,9 @@ static struct cpu_spec __initdata cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .cpu_setup              = __setup_cpu_603,
+                .num_pmcs               = 4,
+                .oprofile_cpu_type      = "ppc/e300",
+                .oprofile_type          = PPC_OPROFILE_FSL_EMB,
                 .platform               = "ppc603",
         },
         {       /* e300c4 (e300c1, plus one IU) */
@@ -971,6 +974,9 @@ static struct cpu_spec __initdata cpu_specs[] = {
                 .dcache_bsize           = 32,
                 .cpu_setup              = __setup_cpu_603,
                 .machine_check          = machine_check_generic,
+                .num_pmcs               = 4,
+                .oprofile_cpu_type      = "ppc/e300",
+                .oprofile_type          = PPC_OPROFILE_FSL_EMB,
                 .platform               = "ppc603",
         },
         {       /* default match, we assume split I/D cache & TB (non-601)... */
@@ -1435,7 +1441,7 @@ static struct cpu_spec __initdata cpu_specs[] = {
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
                 .oprofile_cpu_type      = "ppc/e500",
-                .oprofile_type          = PPC_OPROFILE_BOOKE,
+                .oprofile_type          = PPC_OPROFILE_FSL_EMB,
                 .machine_check          = machine_check_e500,
                 .platform               = "ppc8540",
         },
@@ -1453,7 +1459,7 @@ static struct cpu_spec __initdata cpu_specs[] = {
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
                 .oprofile_cpu_type      = "ppc/e500",
-                .oprofile_type          = PPC_OPROFILE_BOOKE,
+                .oprofile_type          = PPC_OPROFILE_FSL_EMB,
                 .machine_check          = machine_check_e500,
                 .platform               = "ppc8548",
         },
diff --git a/arch/powerpc/kernel/legacy_serial.c b/arch/powerpc/kernel/legacy_serial.c
index 76b862bd1fe9..61dd17449ddc 100644
--- a/arch/powerpc/kernel/legacy_serial.c
+++ b/arch/powerpc/kernel/legacy_serial.c
@@ -36,7 +36,8 @@ static struct legacy_serial_info {
 static struct __initdata of_device_id parents[] = {
         {.type = "soc",},
         {.type = "tsi-bridge",},
-        {.type = "opb", .compatible = "ibm,opb",},
+        {.type = "opb", },
+        {.compatible = "ibm,opb",},
         {.compatible = "simple-bus",},
         {.compatible = "wrs,epld-localbus",},
 };
diff --git a/arch/powerpc/kernel/pmc.c b/arch/powerpc/kernel/pmc.c
index ea04e0ab3f2f..0516e2d3e02e 100644
--- a/arch/powerpc/kernel/pmc.c
+++ b/arch/powerpc/kernel/pmc.c
@@ -26,7 +26,7 @@
 
 static void dummy_perf(struct pt_regs *regs)
 {
-#if defined(CONFIG_FSL_BOOKE) && !defined(CONFIG_E200)
+#if defined(CONFIG_FSL_EMB_PERFMON)
         mtpmr(PMRN_PMGC0, mfpmr(PMRN_PMGC0) & ~PMGC0_PMIE);
 #elif defined(CONFIG_PPC64) || defined(CONFIG_6xx)
         if (cur_cpu_spec->pmc_type == PPC_PMC_IBM)
diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
index 8b056d2295cc..7673e9865733 100644
--- a/arch/powerpc/kernel/ptrace.c
+++ b/arch/powerpc/kernel/ptrace.c
@@ -21,6 +21,8 @@
 #include <linux/smp.h>
 #include <linux/errno.h>
 #include <linux/ptrace.h>
+#include <linux/regset.h>
+#include <linux/elf.h>
 #include <linux/user.h>
 #include <linux/security.h>
 #include <linux/signal.h>
@@ -58,20 +60,38 @@
 #define PT_MAX_PUT_REG  PT_CCR
 #endif
 
+static unsigned long get_user_msr(struct task_struct *task)
+{
+        return task->thread.regs->msr | task->thread.fpexc_mode;
+}
+
+static int set_user_msr(struct task_struct *task, unsigned long msr)
+{
+        task->thread.regs->msr &= ~MSR_DEBUGCHANGE;
+        task->thread.regs->msr |= msr & MSR_DEBUGCHANGE;
+        return 0;
+}
+
+/*
+ * We prevent mucking around with the reserved area of trap
+ * which are used internally by the kernel.
+ */
+static int set_user_trap(struct task_struct *task, unsigned long trap)
+{
+        task->thread.regs->trap = trap & 0xfff0;
+        return 0;
+}
+
 /*
  * Get contents of register REGNO in task TASK.
  */
 unsigned long ptrace_get_reg(struct task_struct *task, int regno)
 {
-        unsigned long tmp = 0;
-
         if (task->thread.regs == NULL)
                 return -EIO;
 
-        if (regno == PT_MSR) {
-                tmp = ((unsigned long *)task->thread.regs)[PT_MSR];
-                return tmp | task->thread.fpexc_mode;
-        }
+        if (regno == PT_MSR)
+                return get_user_msr(task);
 
         if (regno < (sizeof(struct pt_regs) / sizeof(unsigned long)))
                 return ((unsigned long *)task->thread.regs)[regno];
@@ -87,40 +107,134 @@ int ptrace_put_reg(struct task_struct *task, int regno, unsigned long data)
         if (task->thread.regs == NULL)
                 return -EIO;
 
-        if (regno <= PT_MAX_PUT_REG || regno == PT_TRAP) {
-                if (regno == PT_MSR)
-                        data = (data & MSR_DEBUGCHANGE)
-                                | (task->thread.regs->msr & ~MSR_DEBUGCHANGE);
-                /* We prevent mucking around with the reserved area of trap
-                 * which are used internally by the kernel
-                 */
-                if (regno == PT_TRAP)
-                        data &= 0xfff0;
+        if (regno == PT_MSR)
+                return set_user_msr(task, data);
+        if (regno == PT_TRAP)
+                return set_user_trap(task, data);
+
+        if (regno <= PT_MAX_PUT_REG) {
                 ((unsigned long *)task->thread.regs)[regno] = data;
                 return 0;
         }
         return -EIO;
 }
 
+static int gpr_get(struct task_struct *target, const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   void *kbuf, void __user *ubuf)
+{
+        int ret;
+
+        if (target->thread.regs == NULL)
+                return -EIO;
+
+        CHECK_FULL_REGS(target->thread.regs);
+
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  target->thread.regs,
+                                  0, offsetof(struct pt_regs, msr));
+        if (!ret) {
+                unsigned long msr = get_user_msr(target);
+                ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &msr,
+                                          offsetof(struct pt_regs, msr),
+                                          offsetof(struct pt_regs, msr) +
+                                          sizeof(msr));
+        }
+
+        BUILD_BUG_ON(offsetof(struct pt_regs, orig_gpr3) !=
+                     offsetof(struct pt_regs, msr) + sizeof(long));
+
+        if (!ret)
+                ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                          &target->thread.regs->orig_gpr3,
+                                          offsetof(struct pt_regs, orig_gpr3),
+                                          sizeof(struct pt_regs));
+        if (!ret)
+                ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
+                                               sizeof(struct pt_regs), -1);
+
+        return ret;
+}
+
+static int gpr_set(struct task_struct *target, const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   const void *kbuf, const void __user *ubuf)
+{
+        unsigned long reg;
+        int ret;
+
+        if (target->thread.regs == NULL)
+                return -EIO;
+
+        CHECK_FULL_REGS(target->thread.regs);
+
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 target->thread.regs,
+                                 0, PT_MSR * sizeof(reg));
 
-static int get_fpregs(void __user *data, struct task_struct *task,
-                      int has_fpscr)
+        if (!ret && count > 0) {
+                ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &reg,
+                                         PT_MSR * sizeof(reg),
+                                         (PT_MSR + 1) * sizeof(reg));
+                if (!ret)
+                        ret = set_user_msr(target, reg);
+        }
+
+        BUILD_BUG_ON(offsetof(struct pt_regs, orig_gpr3) !=
+                     offsetof(struct pt_regs, msr) + sizeof(long));
+
+        if (!ret)
+                ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                         &target->thread.regs->orig_gpr3,
+                                         PT_ORIG_R3 * sizeof(reg),
+                                         (PT_MAX_PUT_REG + 1) * sizeof(reg));
+
+        if (PT_MAX_PUT_REG + 1 < PT_TRAP && !ret)
+                ret = user_regset_copyin_ignore(
+                        &pos, &count, &kbuf, &ubuf,
+                        (PT_MAX_PUT_REG + 1) * sizeof(reg),
+                        PT_TRAP * sizeof(reg));
+
+        if (!ret && count > 0) {
+                ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &reg,
+                                         PT_TRAP * sizeof(reg),
+                                         (PT_TRAP + 1) * sizeof(reg));
+                if (!ret)
+                        ret = set_user_trap(target, reg);
+        }
+
+        if (!ret)
+                ret = user_regset_copyin_ignore(
+                        &pos, &count, &kbuf, &ubuf,
+                        (PT_TRAP + 1) * sizeof(reg), -1);
+
+        return ret;
+}
+
+static int fpr_get(struct task_struct *target, const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   void *kbuf, void __user *ubuf)
 {
-        unsigned int count = has_fpscr ? 33 : 32;
+        flush_fp_to_thread(target);
 
-        if (copy_to_user(data, task->thread.fpr, count * sizeof(double)))
-                return -EFAULT;
-        return 0;
+        BUILD_BUG_ON(offsetof(struct thread_struct, fpscr) !=
+                     offsetof(struct thread_struct, fpr[32]));
+
+        return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                   &target->thread.fpr, 0, -1);
 }
 
-static int set_fpregs(void __user *data, struct task_struct *task,
-                      int has_fpscr)
+static int fpr_set(struct task_struct *target, const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   const void *kbuf, const void __user *ubuf)
 {
-        unsigned int count = has_fpscr ? 33 : 32;
+        flush_fp_to_thread(target);
 
-        if (copy_from_user(task->thread.fpr, data, count * sizeof(double)))
-                return -EFAULT;
-        return 0;
+        BUILD_BUG_ON(offsetof(struct thread_struct, fpscr) !=
+                     offsetof(struct thread_struct, fpr[32]));
+
+        return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                  &target->thread.fpr, 0, -1);
 }
 
 
@@ -138,56 +252,74 @@ static int set_fpregs(void __user *data, struct task_struct *task,
  * (combined (32- and 64-bit) gdb.
  */
 
-/*
- * Get contents of AltiVec register state in task TASK
- */
-static int get_vrregs(unsigned long __user *data, struct task_struct *task)
+static int vr_active(struct task_struct *target,
+                     const struct user_regset *regset)
 {
-        unsigned long regsize;
+        flush_altivec_to_thread(target);
+        return target->thread.used_vr ? regset->n : 0;
+}
 
-        /* copy AltiVec registers VR[0] .. VR[31] */
-        regsize = 32 * sizeof(vector128);
-        if (copy_to_user(data, task->thread.vr, regsize))
-                return -EFAULT;
-        data += (regsize / sizeof(unsigned long));
+static int vr_get(struct task_struct *target, const struct user_regset *regset,
+                  unsigned int pos, unsigned int count,
+                  void *kbuf, void __user *ubuf)
+{
+        int ret;
 
-        /* copy VSCR */
-        regsize = 1 * sizeof(vector128);
-        if (copy_to_user(data, &task->thread.vscr, regsize))
-                return -EFAULT;
-        data += (regsize / sizeof(unsigned long));
+        flush_altivec_to_thread(target);
 
-        /* copy VRSAVE */
-        if (put_user(task->thread.vrsave, (u32 __user *)data))
-                return -EFAULT;
+        BUILD_BUG_ON(offsetof(struct thread_struct, vscr) !=
+                     offsetof(struct thread_struct, vr[32]));
 
-        return 0;
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  &target->thread.vr, 0,
+                                  33 * sizeof(vector128));
+        if (!ret) {
+                /*
+                 * Copy out only the low-order word of vrsave.
+                 */
+                union {
+                        elf_vrreg_t reg;
+                        u32 word;
+                } vrsave;
+                memset(&vrsave, 0, sizeof(vrsave));
+                vrsave.word = target->thread.vrsave;
+                ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &vrsave,
+                                          33 * sizeof(vector128), -1);
+        }
+
+        return ret;
 }
 
-/*
- * Write contents of AltiVec register state into task TASK.
- */
-static int set_vrregs(struct task_struct *task, unsigned long __user *data)
+static int vr_set(struct task_struct *target, const struct user_regset *regset,
+                  unsigned int pos, unsigned int count,
+                  const void *kbuf, const void __user *ubuf)
 {
-        unsigned long regsize;
+        int ret;
 
-        /* copy AltiVec registers VR[0] .. VR[31] */
-        regsize = 32 * sizeof(vector128);
-        if (copy_from_user(task->thread.vr, data, regsize))
-                return -EFAULT;
-        data += (regsize / sizeof(unsigned long));
+        flush_altivec_to_thread(target);
 
-        /* copy VSCR */
-        regsize = 1 * sizeof(vector128);
-        if (copy_from_user(&task->thread.vscr, data, regsize))
-                return -EFAULT;
-        data += (regsize / sizeof(unsigned long));
+        BUILD_BUG_ON(offsetof(struct thread_struct, vscr) !=
+                     offsetof(struct thread_struct, vr[32]));
 
-        /* copy VRSAVE */
-        if (get_user(task->thread.vrsave, (u32 __user *)data))
-                return -EFAULT;
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &target->thread.vr, 0, 33 * sizeof(vector128));
+        if (!ret && count > 0) {
+                /*
+                 * We use only the first word of vrsave.
+                 */
+                union {
+                        elf_vrreg_t reg;
+                        u32 word;
+                } vrsave;
+                memset(&vrsave, 0, sizeof(vrsave));
+                vrsave.word = target->thread.vrsave;
+                ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &vrsave,
+                                         33 * sizeof(vector128), -1);
+                if (!ret)
+                        target->thread.vrsave = vrsave.word;
+        }
 
-        return 0;
+        return ret;
 }
 #endif /* CONFIG_ALTIVEC */
 
@@ -203,57 +335,273 @@ static int set_vrregs(struct task_struct *task, unsigned long __user *data)
  * }
  */
 
-/*
- * Get contents of SPE register state in task TASK.
- */
-static int get_evrregs(unsigned long *data, struct task_struct *task)
+static int evr_active(struct task_struct *target,
+                      const struct user_regset *regset)
 {
-        int i;
+        flush_spe_to_thread(target);
+        return target->thread.used_spe ? regset->n : 0;
+}
 
-        if (!access_ok(VERIFY_WRITE, data, 35 * sizeof(unsigned long)))
-                return -EFAULT;
+static int evr_get(struct task_struct *target, const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   void *kbuf, void __user *ubuf)
+{
+        int ret;
 
-        /* copy SPEFSCR */
-        if (__put_user(task->thread.spefscr, &data[34]))
-                return -EFAULT;
+        flush_spe_to_thread(target);
 
-        /* copy SPE registers EVR[0] .. EVR[31] */
-        for (i = 0; i < 32; i++, data++)
-                if (__put_user(task->thread.evr[i], data))
-                        return -EFAULT;
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  &target->thread.evr,
+                                  0, sizeof(target->thread.evr));
 
-        /* copy ACC */
-        if (__put_user64(task->thread.acc, (unsigned long long *)data))
-                return -EFAULT;
+        BUILD_BUG_ON(offsetof(struct thread_struct, acc) + sizeof(u64) !=
+                     offsetof(struct thread_struct, spefscr));
 
-        return 0;
+        if (!ret)
+                ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                          &target->thread.acc,
+                                          sizeof(target->thread.evr), -1);
+
+        return ret;
+}
+
+static int evr_set(struct task_struct *target, const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   const void *kbuf, const void __user *ubuf)
+{
+        int ret;
+
+        flush_spe_to_thread(target);
+
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &target->thread.evr,
+                                 0, sizeof(target->thread.evr));
+
+        BUILD_BUG_ON(offsetof(struct thread_struct, acc) + sizeof(u64) !=
+                     offsetof(struct thread_struct, spefscr));
+
+        if (!ret)
+                ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                         &target->thread.acc,
+                                         sizeof(target->thread.evr), -1);
+
+        return ret;
 }
+#endif /* CONFIG_SPE */
+
 
 /*
- * Write contents of SPE register state into task TASK.
+ * These are our native regset flavors.
  */
-static int set_evrregs(struct task_struct *task, unsigned long *data)
+enum powerpc_regset {
+        REGSET_GPR,
+        REGSET_FPR,
+#ifdef CONFIG_ALTIVEC
+        REGSET_VMX,
+#endif
+#ifdef CONFIG_SPE
+        REGSET_SPE,
+#endif
+};
+
+static const struct user_regset native_regsets[] = {
+        [REGSET_GPR] = {
+                .core_note_type = NT_PRSTATUS, .n = ELF_NGREG,
+                .size = sizeof(long), .align = sizeof(long),
+                .get = gpr_get, .set = gpr_set
+        },
+        [REGSET_FPR] = {
+                .core_note_type = NT_PRFPREG, .n = ELF_NFPREG,
+                .size = sizeof(double), .align = sizeof(double),
+                .get = fpr_get, .set = fpr_set
+        },
+#ifdef CONFIG_ALTIVEC
+        [REGSET_VMX] = {
+                .core_note_type = NT_PPC_VMX, .n = 34,
+                .size = sizeof(vector128), .align = sizeof(vector128),
+                .active = vr_active, .get = vr_get, .set = vr_set
+        },
+#endif
+#ifdef CONFIG_SPE
+        [REGSET_SPE] = {
+                .n = 35,
+                .size = sizeof(u32), .align = sizeof(u32),
+                .active = evr_active, .get = evr_get, .set = evr_set
+        },
+#endif
+};
+
+static const struct user_regset_view user_ppc_native_view = {
+        .name = UTS_MACHINE, .e_machine = ELF_ARCH, .ei_osabi = ELF_OSABI,
+        .regsets = native_regsets, .n = ARRAY_SIZE(native_regsets)
+};
+
+#ifdef CONFIG_PPC64
+#include <linux/compat.h>
+
+static int gpr32_get(struct task_struct *target,
+                     const struct user_regset *regset,
+                     unsigned int pos, unsigned int count,
+                     void *kbuf, void __user *ubuf)
 {
-        int i;
+        const unsigned long *regs = &target->thread.regs->gpr[0];
+        compat_ulong_t *k = kbuf;
+        compat_ulong_t __user *u = ubuf;
+        compat_ulong_t reg;
+
+        if (target->thread.regs == NULL)
+                return -EIO;
+
+        CHECK_FULL_REGS(target->thread.regs);
 
-        if (!access_ok(VERIFY_READ, data, 35 * sizeof(unsigned long)))
-                return -EFAULT;
+        pos /= sizeof(reg);
+        count /= sizeof(reg);
 
-        /* copy SPEFSCR */
-        if (__get_user(task->thread.spefscr, &data[34]))
-                return -EFAULT;
+        if (kbuf)
+                for (; count > 0 && pos < PT_MSR; --count)
+                        *k++ = regs[pos++];
+        else
+                for (; count > 0 && pos < PT_MSR; --count)
+                        if (__put_user((compat_ulong_t) regs[pos++], u++))
+                                return -EFAULT;
 
-        /* copy SPE registers EVR[0] .. EVR[31] */
-        for (i = 0; i < 32; i++, data++)
-                if (__get_user(task->thread.evr[i], data))
+        if (count > 0 && pos == PT_MSR) {
+                reg = get_user_msr(target);
+                if (kbuf)
+                        *k++ = reg;
+                else if (__put_user(reg, u++))
                         return -EFAULT;
-        /* copy ACC */
-        if (__get_user64(task->thread.acc, (unsigned long long*)data))
-                return -EFAULT;
+                ++pos;
+                --count;
+        }
 
-        return 0;
+        if (kbuf)
+                for (; count > 0 && pos < PT_REGS_COUNT; --count)
+                        *k++ = regs[pos++];
+        else
+                for (; count > 0 && pos < PT_REGS_COUNT; --count)
+                        if (__put_user((compat_ulong_t) regs[pos++], u++))
+                                return -EFAULT;
+
+        kbuf = k;
+        ubuf = u;
+        pos *= sizeof(reg);
+        count *= sizeof(reg);
+        return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
+                                        PT_REGS_COUNT * sizeof(reg), -1);
+}
+
+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)
+{
+        unsigned long *regs = &target->thread.regs->gpr[0];
+        const compat_ulong_t *k = kbuf;
+        const compat_ulong_t __user *u = ubuf;
+        compat_ulong_t reg;
+
+        if (target->thread.regs == NULL)
+                return -EIO;
+
+        CHECK_FULL_REGS(target->thread.regs);
+
+        pos /= sizeof(reg);
+        count /= sizeof(reg);
+
+        if (kbuf)
+                for (; count > 0 && pos < PT_MSR; --count)
+                        regs[pos++] = *k++;
+        else
+                for (; count > 0 && pos < PT_MSR; --count) {
+                        if (__get_user(reg, u++))
+                                return -EFAULT;
+                        regs[pos++] = reg;
+                }
+
+
+        if (count > 0 && pos == PT_MSR) {
+                if (kbuf)
+                        reg = *k++;
+                else if (__get_user(reg, u++))
+                        return -EFAULT;
+                set_user_msr(target, reg);
+                ++pos;
+                --count;
+        }
+
+        if (kbuf)
+                for (; count > 0 && pos <= PT_MAX_PUT_REG; --count)
+                        regs[pos++] = *k++;
+        else
+                for (; count > 0 && pos <= PT_MAX_PUT_REG; --count) {
+                        if (__get_user(reg, u++))
+                                return -EFAULT;
+                        regs[pos++] = reg;
+                }
+
+        if (count > 0 && pos == PT_TRAP) {
+                if (kbuf)
+                        reg = *k++;
+                else if (__get_user(reg, u++))
+                        return -EFAULT;
+                set_user_trap(target, reg);
+                ++pos;
+                --count;
+        }
+
+        kbuf = k;
+        ubuf = u;
+        pos *= sizeof(reg);
+        count *= sizeof(reg);
+        return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
+                                         (PT_TRAP + 1) * sizeof(reg), -1);
+}
+
+/*
+ * These are the regset flavors matching the CONFIG_PPC32 native set.
+ */
+static const struct user_regset compat_regsets[] = {
+        [REGSET_GPR] = {
+                .core_note_type = NT_PRSTATUS, .n = ELF_NGREG,
+                .size = sizeof(compat_long_t), .align = sizeof(compat_long_t),
+                .get = gpr32_get, .set = gpr32_set
+        },
+        [REGSET_FPR] = {
+                .core_note_type = NT_PRFPREG, .n = ELF_NFPREG,
+                .size = sizeof(double), .align = sizeof(double),
+                .get = fpr_get, .set = fpr_set
+        },
+#ifdef CONFIG_ALTIVEC
+        [REGSET_VMX] = {
+                .core_note_type = NT_PPC_VMX, .n = 34,
+                .size = sizeof(vector128), .align = sizeof(vector128),
+                .active = vr_active, .get = vr_get, .set = vr_set
+        },
+#endif
+#ifdef CONFIG_SPE
+        [REGSET_SPE] = {
+                .core_note_type = NT_PPC_SPE, .n = 35,
+                .size = sizeof(u32), .align = sizeof(u32),
+                .active = evr_active, .get = evr_get, .set = evr_set
+        },
+#endif
+};
+
+static const struct user_regset_view user_ppc_compat_view = {
+        .name = "ppc", .e_machine = EM_PPC, .ei_osabi = ELF_OSABI,
+        .regsets = compat_regsets, .n = ARRAY_SIZE(compat_regsets)
+};
+#endif  /* CONFIG_PPC64 */
+
+const struct user_regset_view *task_user_regset_view(struct task_struct *task)
+{
+#ifdef CONFIG_PPC64
+        if (test_tsk_thread_flag(task, TIF_32BIT))
+                return &user_ppc_compat_view;
+#endif
+        return &user_ppc_native_view;
 }
-#endif /* CONFIG_SPE */
 
 
 void user_enable_single_step(struct task_struct *task)
@@ -323,55 +671,29 @@ void ptrace_disable(struct task_struct *child)
 static long arch_ptrace_old(struct task_struct *child, long request, long addr,
                             long data)
 {
-        int ret = -EPERM;
-
-        switch(request) {
-        case PPC_PTRACE_GETREGS: { /* Get GPRs 0 - 31. */
-                int i;
-                unsigned long *reg = &((unsigned long *)child->thread.regs)[0];
-                unsigned long __user *tmp = (unsigned long __user *)addr;
-
-                CHECK_FULL_REGS(child->thread.regs);
-                for (i = 0; i < 32; i++) {
-                        ret = put_user(*reg, tmp);
-                        if (ret)
-                                break;
-                        reg++;
-                        tmp++;
-                }
-                break;
-        }
-
-        case PPC_PTRACE_SETREGS: { /* Set GPRs 0 - 31. */
-                int i;
-                unsigned long *reg = &((unsigned long *)child->thread.regs)[0];
-                unsigned long __user *tmp = (unsigned long __user *)addr;
-
-                CHECK_FULL_REGS(child->thread.regs);
-                for (i = 0; i < 32; i++) {
-                        ret = get_user(*reg, tmp);
-                        if (ret)
-                                break;
-                        reg++;
-                        tmp++;
-                }
-                break;
-        }
-
-        case PPC_PTRACE_GETFPREGS: { /* Get FPRs 0 - 31. */
-                flush_fp_to_thread(child);
-                ret = get_fpregs((void __user *)addr, child, 0);
-                break;
-        }
-
-        case PPC_PTRACE_SETFPREGS: { /* Get FPRs 0 - 31. */
-                flush_fp_to_thread(child);
-                ret = set_fpregs((void __user *)addr, child, 0);
-                break;
+        switch (request) {
+        case PPC_PTRACE_GETREGS:        /* Get GPRs 0 - 31. */
+                return copy_regset_to_user(child, &user_ppc_native_view,
+                                           REGSET_GPR, 0, 32 * sizeof(long),
+                                           (void __user *) data);
+
+        case PPC_PTRACE_SETREGS:        /* Set GPRs 0 - 31. */
+                return copy_regset_from_user(child, &user_ppc_native_view,
+                                             REGSET_GPR, 0, 32 * sizeof(long),
+                                             (const void __user *) data);
+
+        case PPC_PTRACE_GETFPREGS:      /* Get FPRs 0 - 31. */
+                return copy_regset_to_user(child, &user_ppc_native_view,
+                                           REGSET_FPR, 0, 32 * sizeof(double),
+                                           (void __user *) data);
+
+        case PPC_PTRACE_SETFPREGS:      /* Set FPRs 0 - 31. */
+                return copy_regset_from_user(child, &user_ppc_native_view,
+                                             REGSET_FPR, 0, 32 * sizeof(double),
+                                             (const void __user *) data);
         }
 
-        }
-        return ret;
+        return -EPERM;
 }
 
 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
@@ -379,12 +701,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         int ret = -EPERM;
 
         switch (request) {
-        /* when I and D space are separate, these will need to be fixed. */
-        case PTRACE_PEEKTEXT: /* read word at location addr. */
-        case PTRACE_PEEKDATA:
-                ret = generic_ptrace_peekdata(child, addr, data);
-                break;
-
         /* read the word at location addr in the USER area. */
         case PTRACE_PEEKUSR: {
                 unsigned long index, tmp;
@@ -412,12 +728,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 break;
         }
 
-        /* If I and D space are separate, this will have to be fixed. */
-        case PTRACE_POKETEXT: /* write the word at location addr. */
-        case PTRACE_POKEDATA:
-                ret = generic_ptrace_pokedata(child, addr, data);
-                break;
-
         /* write the word at location addr in the USER area */
         case PTRACE_POKEUSR: {
                 unsigned long index;
@@ -462,85 +772,60 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 #ifdef CONFIG_PPC64
         case PTRACE_GETREGS64:
 #endif
-        case PTRACE_GETREGS: { /* Get all pt_regs from the child. */
-                int ui;
-                if (!access_ok(VERIFY_WRITE, (void __user *)data,
-                               sizeof(struct pt_regs))) {
-                        ret = -EIO;
-                        break;
-                }
-                CHECK_FULL_REGS(child->thread.regs);
-                ret = 0;
-                for (ui = 0; ui < PT_REGS_COUNT; ui ++) {
-                        ret |= __put_user(ptrace_get_reg(child, ui),
-                                          (unsigned long __user *) data);
-                        data += sizeof(long);
-                }
-                break;
-        }
+        case PTRACE_GETREGS:    /* Get all pt_regs from the child. */
+                return copy_regset_to_user(child, &user_ppc_native_view,
+                                           REGSET_GPR,
+                                           0, sizeof(struct pt_regs),
+                                           (void __user *) data);
 
 #ifdef CONFIG_PPC64
         case PTRACE_SETREGS64:
 #endif
-        case PTRACE_SETREGS: { /* Set all gp regs in the child. */
-                unsigned long tmp;
-                int ui;
-                if (!access_ok(VERIFY_READ, (void __user *)data,
-                               sizeof(struct pt_regs))) {
-                        ret = -EIO;
-                        break;
-                }
-                CHECK_FULL_REGS(child->thread.regs);
-                ret = 0;
-                for (ui = 0; ui < PT_REGS_COUNT; ui ++) {
-                        ret = __get_user(tmp, (unsigned long __user *) data);
-                        if (ret)
-                                break;
-                        ptrace_put_reg(child, ui, tmp);
-                        data += sizeof(long);
-                }
-                break;
-        }
-
-        case PTRACE_GETFPREGS: { /* Get the child FPU state (FPR0...31 + FPSCR) */
-                flush_fp_to_thread(child);
-                ret = get_fpregs((void __user *)data, child, 1);
-                break;
-        }
-
-        case PTRACE_SETFPREGS: { /* Set the child FPU state (FPR0...31 + FPSCR) */
-                flush_fp_to_thread(child);
-                ret = set_fpregs((void __user *)data, child, 1);
-                break;
-        }
+        case PTRACE_SETREGS:    /* Set all gp regs in the child. */
+                return copy_regset_from_user(child, &user_ppc_native_view,
+                                             REGSET_GPR,
+                                             0, sizeof(struct pt_regs),
+                                             (const void __user *) data);
+
+        case PTRACE_GETFPREGS: /* Get the child FPU state (FPR0...31 + FPSCR) */
+                return copy_regset_to_user(child, &user_ppc_native_view,
+                                           REGSET_FPR,
+                                           0, sizeof(elf_fpregset_t),
+                                           (void __user *) data);
+
+        case PTRACE_SETFPREGS: /* Set the child FPU state (FPR0...31 + FPSCR) */
+                return copy_regset_from_user(child, &user_ppc_native_view,
+                                             REGSET_FPR,
+                                             0, sizeof(elf_fpregset_t),
+                                             (const void __user *) data);
 
 #ifdef CONFIG_ALTIVEC
         case PTRACE_GETVRREGS:
-                /* Get the child altivec register state. */
-                flush_altivec_to_thread(child);
-                ret = get_vrregs((unsigned long __user *)data, child);
-                break;
+                return copy_regset_to_user(child, &user_ppc_native_view,
+                                           REGSET_VMX,
+                                           0, (33 * sizeof(vector128) +
+                                               sizeof(u32)),
+                                           (void __user *) data);
 
         case PTRACE_SETVRREGS:
-                /* Set the child altivec register state. */
-                flush_altivec_to_thread(child);
-                ret = set_vrregs(child, (unsigned long __user *)data);
-                break;
+                return copy_regset_from_user(child, &user_ppc_native_view,
+                                             REGSET_VMX,
+                                             0, (33 * sizeof(vector128) +
+                                                 sizeof(u32)),
+                                             (const void __user *) data);
 #endif
 #ifdef CONFIG_SPE
         case PTRACE_GETEVRREGS:
                 /* Get the child spe register state. */
-                flush_spe_to_thread(child);
-                ret = get_evrregs((unsigned long __user *)data, child);
-                break;
+                return copy_regset_to_user(child, &user_ppc_native_view,
+                                           REGSET_SPE, 0, 35 * sizeof(u32),
+                                           (void __user *) data);
 
         case PTRACE_SETEVRREGS:
                 /* Set the child spe register state. */
-                /* this is to clear the MSR_SPE bit to force a reload
-                 * of register state from memory */
-                flush_spe_to_thread(child);
-                ret = set_evrregs(child, (unsigned long __user *)data);
-                break;
+                return copy_regset_from_user(child, &user_ppc_native_view,
+                                             REGSET_SPE, 0, 35 * sizeof(u32),
+                                             (const void __user *) data);
 #endif
 
         /* Old reverse args ptrace callss */
diff --git a/arch/powerpc/kernel/ptrace32.c b/arch/powerpc/kernel/ptrace32.c
index fea6206ff90f..4c1de6af4c09 100644
--- a/arch/powerpc/kernel/ptrace32.c
+++ b/arch/powerpc/kernel/ptrace32.c
@@ -24,9 +24,11 @@
 #include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/ptrace.h>
+#include <linux/regset.h>
 #include <linux/user.h>
 #include <linux/security.h>
 #include <linux/signal.h>
+#include <linux/compat.h>
 
 #include <asm/uaccess.h>
 #include <asm/page.h>
@@ -45,87 +47,31 @@
 static long compat_ptrace_old(struct task_struct *child, long request,
                               long addr, long data)
 {
-        int ret = -EPERM;
-
-        switch(request) {
-        case PPC_PTRACE_GETREGS: { /* Get GPRs 0 - 31. */
-                int i;
-                unsigned long *reg = &((unsigned long *)child->thread.regs)[0];
-                unsigned int __user *tmp = (unsigned int __user *)addr;
-
-                CHECK_FULL_REGS(child->thread.regs);
-                for (i = 0; i < 32; i++) {
-                        ret = put_user(*reg, tmp);
-                        if (ret)
-                                break;
-                        reg++;
-                        tmp++;
-                }
-                break;
-        }
-
-        case PPC_PTRACE_SETREGS: { /* Set GPRs 0 - 31. */
-                int i;
-                unsigned long *reg = &((unsigned long *)child->thread.regs)[0];
-                unsigned int __user *tmp = (unsigned int __user *)addr;
-
-                CHECK_FULL_REGS(child->thread.regs);
-                for (i = 0; i < 32; i++) {
-                        ret = get_user(*reg, tmp);
-                        if (ret)
-                                break;
-                        reg++;
-                        tmp++;
-                }
-                break;
+        switch (request) {
+        case PPC_PTRACE_GETREGS:        /* Get GPRs 0 - 31. */
+                return copy_regset_to_user(child,
+                                           task_user_regset_view(current), 0,
+                                           0, 32 * sizeof(compat_long_t),
+                                           compat_ptr(data));
+
+        case PPC_PTRACE_SETREGS:        /* Set GPRs 0 - 31. */
+                return copy_regset_from_user(child,
+                                             task_user_regset_view(current), 0,
+                                             0, 32 * sizeof(compat_long_t),
+                                             compat_ptr(data));
         }
 
-        }
-        return ret;
+        return -EPERM;
 }
 
-long compat_sys_ptrace(int request, int pid, unsigned long addr,
-                       unsigned long data)
+long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
+                        compat_ulong_t caddr, compat_ulong_t cdata)
 {
-        struct task_struct *child;
+        unsigned long addr = caddr;
+        unsigned long data = cdata;
         int ret;
 
-        lock_kernel();
-        if (request == PTRACE_TRACEME) {
-                ret = ptrace_traceme();
-                goto out;
-        }
-
-        child = ptrace_get_task_struct(pid);
-        if (IS_ERR(child)) {
-                ret = PTR_ERR(child);
-                goto out;
-        }
-
-        if (request == PTRACE_ATTACH) {
-                ret = ptrace_attach(child);
-                goto out_tsk;
-        }
-
-        ret = ptrace_check_attach(child, request == PTRACE_KILL);
-        if (ret < 0)
-                goto out_tsk;
-
         switch (request) {
-        /* when I and D space are separate, these will need to be fixed. */
-        case PTRACE_PEEKTEXT: /* read word at location addr. */ 
-        case PTRACE_PEEKDATA: {
-                unsigned int tmp;
-                int copied;
-
-                copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
-                ret = -EIO;
-                if (copied != sizeof(tmp))
-                        break;
-                ret = put_user(tmp, (u32 __user *)data);
-                break;
-        }
-
         /*
          * Read 4 bytes of the other process' storage
          *  data is a pointer specifying where the user wants the
@@ -225,19 +171,6 @@ long compat_sys_ptrace(int request, int pid, unsigned long addr,
                 break;
         }
 
-        /* If I and D space are separate, this will have to be fixed. */
-        case PTRACE_POKETEXT: /* write the word at location addr. */
-        case PTRACE_POKEDATA: {
-                unsigned int tmp;
-                tmp = data;
-                ret = 0;
-                if (access_process_vm(child, addr, &tmp, sizeof(tmp), 1)
-                                == sizeof(tmp))
-                        break;
-                ret = -EIO;
-                break;
-        }
-
         /*
          * Write 4 bytes into the other process' storage
          *  data is the 4 bytes that the user wants written
@@ -337,46 +270,17 @@ long compat_sys_ptrace(int request, int pid, unsigned long addr,
                 break;
         }
 
-        case PTRACE_GETEVENTMSG:
-                ret = put_user(child->ptrace_message, (unsigned int __user *) data);
-                break;
+        case PTRACE_GETREGS:    /* Get all pt_regs from the child. */
+                return copy_regset_to_user(
+                        child, task_user_regset_view(current), 0,
+                        0, PT_REGS_COUNT * sizeof(compat_long_t),
+                        compat_ptr(data));
 
-        case PTRACE_GETREGS: { /* Get all pt_regs from the child. */
-                int ui;
-                if (!access_ok(VERIFY_WRITE, (void __user *)data,
-                               PT_REGS_COUNT * sizeof(int))) {
-                        ret = -EIO;
-                        break;
-                }
-                CHECK_FULL_REGS(child->thread.regs);
-                ret = 0;
-                for (ui = 0; ui < PT_REGS_COUNT; ui ++) {
-                        ret |= __put_user(ptrace_get_reg(child, ui),
-                                          (unsigned int __user *) data);
-                        data += sizeof(int);
-                }
-                break;
-        }
-
-        case PTRACE_SETREGS: { /* Set all gp regs in the child. */
-                unsigned long tmp;
-                int ui;
-                if (!access_ok(VERIFY_READ, (void __user *)data,
-                               PT_REGS_COUNT * sizeof(int))) {
-                        ret = -EIO;
-                        break;
-                }
-                CHECK_FULL_REGS(child->thread.regs);
-                ret = 0;
-                for (ui = 0; ui < PT_REGS_COUNT; ui ++) {
-                        ret = __get_user(tmp, (unsigned int __user *) data);
-                        if (ret)
-                                break;
-                        ptrace_put_reg(child, ui, tmp);
-                        data += sizeof(int);
-                }
-                break;
-        }
+        case PTRACE_SETREGS:    /* Set all gp regs in the child. */
+                return copy_regset_from_user(
+                        child, task_user_regset_view(current), 0,
+                        0, PT_REGS_COUNT * sizeof(compat_long_t),
+                        compat_ptr(data));
 
         case PTRACE_GETFPREGS:
         case PTRACE_SETFPREGS:
@@ -402,12 +306,9 @@ long compat_sys_ptrace(int request, int pid, unsigned long addr,
                 break;
 
         default:
-                ret = ptrace_request(child, request, addr, data);
+                ret = compat_ptrace_request(child, request, addr, data);
                 break;
         }
-out_tsk:
-        put_task_struct(child);
-out:
-        unlock_kernel();
+
         return ret;
 }
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index 848a20475db8..4b5b7ff4f78b 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -54,7 +54,7 @@
 #endif
 #include <asm/kexec.h>
 
-#ifdef CONFIG_DEBUGGER
+#if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC)
 int (*__debugger)(struct pt_regs *regs);
 int (*__debugger_ipi)(struct pt_regs *regs);
 int (*__debugger_bpt)(struct pt_regs *regs);
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index f0bad7070fb5..f98867252ee2 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -176,7 +176,7 @@ static void __devinit vio_dev_release(struct device *dev)
  * Returns a pointer to the created vio_dev or NULL if node has
  * NULL device_type or compatible fields.
  */
-struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
+struct vio_dev *vio_register_device_node(struct device_node *of_node)
 {
         struct vio_dev *viodev;
         const unsigned int *unit_address;