8 files changed, 337 insertions, 195 deletions

diff --git a/arch/arm/kernel/leds.c b/arch/arm/kernel/leds.c
index 31a316c1777b..0f107dcb0347 100644
--- a/arch/arm/kernel/leds.c
+++ b/arch/arm/kernel/leds.c
@@ -10,6 +10,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/sysdev.h>
+#include <linux/syscore_ops.h>
 
 #include <asm/leds.h>
 
@@ -69,36 +70,37 @@ static ssize_t leds_store(struct sys_device *dev,
 
 static SYSDEV_ATTR(event, 0200, NULL, leds_store);
 
-static int leds_suspend(struct sys_device *dev, pm_message_t state)
+static struct sysdev_class leds_sysclass = {
+        .name           = "leds",
+};
+
+static struct sys_device leds_device = {
+        .id             = 0,
+        .cls            = &leds_sysclass,
+};
+
+static int leds_suspend(void)
 {
         leds_event(led_stop);
         return 0;
 }
 
-static int leds_resume(struct sys_device *dev)
+static void leds_resume(void)
 {
         leds_event(led_start);
-        return 0;
 }
 
-static int leds_shutdown(struct sys_device *dev)
+static void leds_shutdown(void)
 {
         leds_event(led_halted);
-        return 0;
 }
 
-static struct sysdev_class leds_sysclass = {
-        .name           = "leds",
+static struct syscore_ops leds_syscore_ops = {
         .shutdown       = leds_shutdown,
         .suspend        = leds_suspend,
         .resume         = leds_resume,
 };
 
-static struct sys_device leds_device = {
-        .id             = 0,
-        .cls            = &leds_sysclass,
-};
-
 static int __init leds_init(void)
 {
         int ret;
@@ -107,6 +109,8 @@ static int __init leds_init(void)
                 ret = sysdev_register(&leds_device);
         if (ret == 0)
                 ret = sysdev_create_file(&leds_device, &attr_event);
+        if (ret == 0)
+                register_syscore_ops(&leds_syscore_ops);
         return ret;
 }
 
diff --git a/arch/arm/kernel/perf_event.c b/arch/arm/kernel/perf_event.c
index 139e3c827369..d53c0abc4dd3 100644
--- a/arch/arm/kernel/perf_event.c
+++ b/arch/arm/kernel/perf_event.c
@@ -560,11 +560,6 @@ static int armpmu_event_init(struct perf_event *event)
         event->destroy = hw_perf_event_destroy;
 
         if (!atomic_inc_not_zero(&active_events)) {
-                if (atomic_read(&active_events) > armpmu->num_events) {
-                        atomic_dec(&active_events);
-                        return -ENOSPC;
-                }
-
                 mutex_lock(&pmu_reserve_mutex);
                 if (atomic_read(&active_events) == 0) {
                         err = armpmu_reserve_hardware();
diff --git a/arch/arm/kernel/ptrace.c b/arch/arm/kernel/ptrace.c
index 8182f45ca493..97260060bf26 100644
--- a/arch/arm/kernel/ptrace.c
+++ b/arch/arm/kernel/ptrace.c
@@ -21,6 +21,7 @@
 #include <linux/uaccess.h>
 #include <linux/perf_event.h>
 #include <linux/hw_breakpoint.h>
+#include <linux/regset.h>
 
 #include <asm/pgtable.h>
 #include <asm/system.h>
@@ -308,58 +309,6 @@ static int ptrace_write_user(struct task_struct *tsk, unsigned long off,
         return put_user_reg(tsk, off >> 2, val);
 }
 
-/*
- * Get all user integer registers.
- */
-static int ptrace_getregs(struct task_struct *tsk, void __user *uregs)
-{
-        struct pt_regs *regs = task_pt_regs(tsk);
-
-        return copy_to_user(uregs, regs, sizeof(struct pt_regs)) ? -EFAULT : 0;
-}
-
-/*
- * Set all user integer registers.
- */
-static int ptrace_setregs(struct task_struct *tsk, void __user *uregs)
-{
-        struct pt_regs newregs;
-        int ret;
-
-        ret = -EFAULT;
-        if (copy_from_user(&newregs, uregs, sizeof(struct pt_regs)) == 0) {
-                struct pt_regs *regs = task_pt_regs(tsk);
-
-                ret = -EINVAL;
-                if (valid_user_regs(&newregs)) {
-                        *regs = newregs;
-                        ret = 0;
-                }
-        }
-
-        return ret;
-}
-
-/*
- * Get the child FPU state.
- */
-static int ptrace_getfpregs(struct task_struct *tsk, void __user *ufp)
-{
-        return copy_to_user(ufp, &task_thread_info(tsk)->fpstate,
-                            sizeof(struct user_fp)) ? -EFAULT : 0;
-}
-
-/*
- * Set the child FPU state.
- */
-static int ptrace_setfpregs(struct task_struct *tsk, void __user *ufp)
-{
-        struct thread_info *thread = task_thread_info(tsk);
-        thread->used_cp[1] = thread->used_cp[2] = 1;
-        return copy_from_user(&thread->fpstate, ufp,
-                              sizeof(struct user_fp)) ? -EFAULT : 0;
-}
-
 #ifdef CONFIG_IWMMXT
 
 /*
@@ -418,56 +367,6 @@ static int ptrace_setcrunchregs(struct task_struct *tsk, void __user *ufp)
 }
 #endif
 
-#ifdef CONFIG_VFP
-/*
- * Get the child VFP state.
- */
-static int ptrace_getvfpregs(struct task_struct *tsk, void __user *data)
-{
-        struct thread_info *thread = task_thread_info(tsk);
-        union vfp_state *vfp = &thread->vfpstate;
-        struct user_vfp __user *ufp = data;
-
-        vfp_sync_hwstate(thread);
-
-        /* copy the floating point registers */
-        if (copy_to_user(&ufp->fpregs, &vfp->hard.fpregs,
-                         sizeof(vfp->hard.fpregs)))
-                return -EFAULT;
-
-        /* copy the status and control register */
-        if (put_user(vfp->hard.fpscr, &ufp->fpscr))
-                return -EFAULT;
-
-        return 0;
-}
-
-/*
- * Set the child VFP state.
- */
-static int ptrace_setvfpregs(struct task_struct *tsk, void __user *data)
-{
-        struct thread_info *thread = task_thread_info(tsk);
-        union vfp_state *vfp = &thread->vfpstate;
-        struct user_vfp __user *ufp = data;
-
-        vfp_sync_hwstate(thread);
-
-        /* copy the floating point registers */
-        if (copy_from_user(&vfp->hard.fpregs, &ufp->fpregs,
-                           sizeof(vfp->hard.fpregs)))
-                return -EFAULT;
-
-        /* copy the status and control register */
-        if (get_user(vfp->hard.fpscr, &ufp->fpscr))
-                return -EFAULT;
-
-        vfp_flush_hwstate(thread);
-
-        return 0;
-}
-#endif
-
 #ifdef CONFIG_HAVE_HW_BREAKPOINT
 /*
  * Convert a virtual register number into an index for a thread_info
@@ -694,6 +593,219 @@ out:
 }
 #endif
 
+/* regset get/set implementations */
+
+static int gpr_get(struct task_struct *target,
+                   const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   void *kbuf, void __user *ubuf)
+{
+        struct pt_regs *regs = task_pt_regs(target);
+
+        return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                   regs,
+                                   0, sizeof(*regs));
+}
+
+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)
+{
+        int ret;
+        struct pt_regs newregs;
+
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &newregs,
+                                 0, sizeof(newregs));
+        if (ret)
+                return ret;
+
+        if (!valid_user_regs(&newregs))
+                return -EINVAL;
+
+        *task_pt_regs(target) = newregs;
+        return 0;
+}
+
+static int fpa_get(struct task_struct *target,
+                   const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   void *kbuf, void __user *ubuf)
+{
+        return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                   &task_thread_info(target)->fpstate,
+                                   0, sizeof(struct user_fp));
+}
+
+static int fpa_set(struct task_struct *target,
+                   const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   const void *kbuf, const void __user *ubuf)
+{
+        struct thread_info *thread = task_thread_info(target);
+
+        thread->used_cp[1] = thread->used_cp[2] = 1;
+
+        return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                &thread->fpstate,
+                0, sizeof(struct user_fp));
+}
+
+#ifdef CONFIG_VFP
+/*
+ * VFP register get/set implementations.
+ *
+ * With respect to the kernel, struct user_fp is divided into three chunks:
+ * 16 or 32 real VFP registers (d0-d15 or d0-31)
+ *      These are transferred to/from the real registers in the task's
+ *      vfp_hard_struct.  The number of registers depends on the kernel
+ *      configuration.
+ *
+ * 16 or 0 fake VFP registers (d16-d31 or empty)
+ *      i.e., the user_vfp structure has space for 32 registers even if
+ *      the kernel doesn't have them all.
+ *
+ *      vfp_get() reads this chunk as zero where applicable
+ *      vfp_set() ignores this chunk
+ *
+ * 1 word for the FPSCR
+ *
+ * The bounds-checking logic built into user_regset_copyout and friends
+ * means that we can make a simple sequence of calls to map the relevant data
+ * to/from the specified slice of the user regset structure.
+ */
+static int vfp_get(struct task_struct *target,
+                   const struct user_regset *regset,
+                   unsigned int pos, unsigned int count,
+                   void *kbuf, void __user *ubuf)
+{
+        int ret;
+        struct thread_info *thread = task_thread_info(target);
+        struct vfp_hard_struct const *vfp = &thread->vfpstate.hard;
+        const size_t user_fpregs_offset = offsetof(struct user_vfp, fpregs);
+        const size_t user_fpscr_offset = offsetof(struct user_vfp, fpscr);
+
+        vfp_sync_hwstate(thread);
+
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  &vfp->fpregs,
+                                  user_fpregs_offset,
+                                  user_fpregs_offset + sizeof(vfp->fpregs));
+        if (ret)
+                return ret;
+
+        ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
+                                       user_fpregs_offset + sizeof(vfp->fpregs),
+                                       user_fpscr_offset);
+        if (ret)
+                return ret;
+
+        return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                   &vfp->fpscr,
+                                   user_fpscr_offset,
+                                   user_fpscr_offset + sizeof(vfp->fpscr));
+}
+
+/*
+ * For vfp_set() a read-modify-write is done on the VFP registers,
+ * in order to avoid writing back a half-modified set of registers on
+ * failure.
+ */
+static int vfp_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;
+        struct thread_info *thread = task_thread_info(target);
+        struct vfp_hard_struct new_vfp = thread->vfpstate.hard;
+        const size_t user_fpregs_offset = offsetof(struct user_vfp, fpregs);
+        const size_t user_fpscr_offset = offsetof(struct user_vfp, fpscr);
+
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                  &new_vfp.fpregs,
+                                  user_fpregs_offset,
+                                  user_fpregs_offset + sizeof(new_vfp.fpregs));
+        if (ret)
+                return ret;
+
+        ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
+                                user_fpregs_offset + sizeof(new_vfp.fpregs),
+                                user_fpscr_offset);
+        if (ret)
+                return ret;
+
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &new_vfp.fpscr,
+                                 user_fpscr_offset,
+                                 user_fpscr_offset + sizeof(new_vfp.fpscr));
+        if (ret)
+                return ret;
+
+        vfp_sync_hwstate(thread);
+        thread->vfpstate.hard = new_vfp;
+        vfp_flush_hwstate(thread);
+
+        return 0;
+}
+#endif /* CONFIG_VFP */
+
+enum arm_regset {
+        REGSET_GPR,
+        REGSET_FPR,
+#ifdef CONFIG_VFP
+        REGSET_VFP,
+#endif
+};
+
+static const struct user_regset arm_regsets[] = {
+        [REGSET_GPR] = {
+                .core_note_type = NT_PRSTATUS,
+                .n = ELF_NGREG,
+                .size = sizeof(u32),
+                .align = sizeof(u32),
+                .get = gpr_get,
+                .set = gpr_set
+        },
+        [REGSET_FPR] = {
+                /*
+                 * For the FPA regs in fpstate, the real fields are a mixture
+                 * of sizes, so pretend that the registers are word-sized:
+                 */
+                .core_note_type = NT_PRFPREG,
+                .n = sizeof(struct user_fp) / sizeof(u32),
+                .size = sizeof(u32),
+                .align = sizeof(u32),
+                .get = fpa_get,
+                .set = fpa_set
+        },
+#ifdef CONFIG_VFP
+        [REGSET_VFP] = {
+                /*
+                 * Pretend that the VFP regs are word-sized, since the FPSCR is
+                 * a single word dangling at the end of struct user_vfp:
+                 */
+                .core_note_type = NT_ARM_VFP,
+                .n = ARM_VFPREGS_SIZE / sizeof(u32),
+                .size = sizeof(u32),
+                .align = sizeof(u32),
+                .get = vfp_get,
+                .set = vfp_set
+        },
+#endif /* CONFIG_VFP */
+};
+
+static const struct user_regset_view user_arm_view = {
+        .name = "arm", .e_machine = ELF_ARCH, .ei_osabi = ELF_OSABI,
+        .regsets = arm_regsets, .n = ARRAY_SIZE(arm_regsets)
+};
+
+const struct user_regset_view *task_user_regset_view(struct task_struct *task)
+{
+        return &user_arm_view;
+}
+
 long arch_ptrace(struct task_struct *child, long request,
                  unsigned long addr, unsigned long data)
 {
@@ -710,19 +822,31 @@ long arch_ptrace(struct task_struct *child, long request,
                         break;
 
                 case PTRACE_GETREGS:
-                        ret = ptrace_getregs(child, datap);
+                        ret = copy_regset_to_user(child,
+                                                  &user_arm_view, REGSET_GPR,
+                                                  0, sizeof(struct pt_regs),
+                                                  datap);
                         break;
 
                 case PTRACE_SETREGS:
-                        ret = ptrace_setregs(child, datap);
+                        ret = copy_regset_from_user(child,
+                                                    &user_arm_view, REGSET_GPR,
+                                                    0, sizeof(struct pt_regs),
+                                                    datap);
                         break;
 
                 case PTRACE_GETFPREGS:
-                        ret = ptrace_getfpregs(child, datap);
+                        ret = copy_regset_to_user(child,
+                                                  &user_arm_view, REGSET_FPR,
+                                                  0, sizeof(union fp_state),
+                                                  datap);
                         break;
-                
+
                 case PTRACE_SETFPREGS:
-                        ret = ptrace_setfpregs(child, datap);
+                        ret = copy_regset_from_user(child,
+                                                    &user_arm_view, REGSET_FPR,
+                                                    0, sizeof(union fp_state),
+                                                    datap);
                         break;
 
 #ifdef CONFIG_IWMMXT
@@ -757,11 +881,17 @@ long arch_ptrace(struct task_struct *child, long request,
 
 #ifdef CONFIG_VFP
                 case PTRACE_GETVFPREGS:
-                        ret = ptrace_getvfpregs(child, datap);
+                        ret = copy_regset_to_user(child,
+                                                  &user_arm_view, REGSET_VFP,
+                                                  0, ARM_VFPREGS_SIZE,
+                                                  datap);
                         break;
 
                 case PTRACE_SETVFPREGS:
-                        ret = ptrace_setvfpregs(child, datap);
+                        ret = copy_regset_from_user(child,
+                                                    &user_arm_view, REGSET_VFP,
+                                                    0, ARM_VFPREGS_SIZE,
+                                                    datap);
                         break;
 #endif
 
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index 05db25ef3dd5..ed11fb08b05a 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -661,11 +661,16 @@ __tagtable(ATAG_REVISION, parse_tag_revision);
 
 static int __init parse_tag_cmdline(const struct tag *tag)
 {
-#ifndef CONFIG_CMDLINE_FORCE
-        strlcpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE);
-#else
+#if defined(CONFIG_CMDLINE_EXTEND)
+        strlcat(default_command_line, " ", COMMAND_LINE_SIZE);
+        strlcat(default_command_line, tag->u.cmdline.cmdline,
+                COMMAND_LINE_SIZE);
+#elif defined(CONFIG_CMDLINE_FORCE)
         pr_warning("Ignoring tag cmdline (using the default kernel command line)\n");
-#endif /* CONFIG_CMDLINE_FORCE */
+#else
+        strlcpy(default_command_line, tag->u.cmdline.cmdline,
+                COMMAND_LINE_SIZE);
+#endif
         return 0;
 }
 
diff --git a/arch/arm/kernel/signal.c b/arch/arm/kernel/signal.c
index cb8398317644..0340224cf73c 100644
--- a/arch/arm/kernel/signal.c
+++ b/arch/arm/kernel/signal.c
@@ -597,19 +597,13 @@ setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
         return err;
 }
 
-static inline void setup_syscall_restart(struct pt_regs *regs)
-{
-        regs->ARM_r0 = regs->ARM_ORIG_r0;
-        regs->ARM_pc -= thumb_mode(regs) ? 2 : 4;
-}
-
 /*
  * OK, we're invoking a handler
  */     
 static int
 handle_signal(unsigned long sig, struct k_sigaction *ka,
               siginfo_t *info, sigset_t *oldset,
-              struct pt_regs * regs, int syscall)
+              struct pt_regs * regs)
 {
         struct thread_info *thread = current_thread_info();
         struct task_struct *tsk = current;
@@ -617,26 +611,6 @@ handle_signal(unsigned long sig, struct k_sigaction *ka,
         int ret;
 
         /*
-         * If we were from a system call, check for system call restarting...
-         */
-        if (syscall) {
-                switch (regs->ARM_r0) {
-                case -ERESTART_RESTARTBLOCK:
-                case -ERESTARTNOHAND:
-                        regs->ARM_r0 = -EINTR;
-                        break;
-                case -ERESTARTSYS:
-                        if (!(ka->sa.sa_flags & SA_RESTART)) {
-                                regs->ARM_r0 = -EINTR;
-                                break;
-                        }
-                        /* fallthrough */
-                case -ERESTARTNOINTR:
-                        setup_syscall_restart(regs);
-                }
-        }
-
-        /*
          * translate the signal
          */
         if (usig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
@@ -685,6 +659,7 @@ handle_signal(unsigned long sig, struct k_sigaction *ka,
  */
 static void do_signal(struct pt_regs *regs, int syscall)
 {
+        unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
         struct k_sigaction ka;
         siginfo_t info;
         int signr;
@@ -698,18 +673,61 @@ static void do_signal(struct pt_regs *regs, int syscall)
         if (!user_mode(regs))
                 return;
 
+        /*
+         * If we were from a system call, check for system call restarting...
+         */
+        if (syscall) {
+                continue_addr = regs->ARM_pc;
+                restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
+                retval = regs->ARM_r0;
+
+                /*
+                 * Prepare for system call restart.  We do this here so that a
+                 * debugger will see the already changed PSW.
+                 */
+                switch (retval) {
+                case -ERESTARTNOHAND:
+                case -ERESTARTSYS:
+                case -ERESTARTNOINTR:
+                        regs->ARM_r0 = regs->ARM_ORIG_r0;
+                        regs->ARM_pc = restart_addr;
+                        break;
+                case -ERESTART_RESTARTBLOCK:
+                        regs->ARM_r0 = -EINTR;
+                        break;
+                }
+        }
+
         if (try_to_freeze())
                 goto no_signal;
 
+        /*
+         * Get the signal to deliver.  When running under ptrace, at this
+         * point the debugger may change all our registers ...
+         */
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
         if (signr > 0) {
                 sigset_t *oldset;
 
+                /*
+                 * Depending on the signal settings we may need to revert the
+                 * decision to restart the system call.  But skip this if a
+                 * debugger has chosen to restart at a different PC.
+                 */
+                if (regs->ARM_pc == restart_addr) {
+                        if (retval == -ERESTARTNOHAND
+                            || (retval == -ERESTARTSYS
+                                && !(ka.sa.sa_flags & SA_RESTART))) {
+                                regs->ARM_r0 = -EINTR;
+                                regs->ARM_pc = continue_addr;
+                        }
+                }
+
                 if (test_thread_flag(TIF_RESTORE_SIGMASK))
                         oldset = &current->saved_sigmask;
                 else
                         oldset = &current->blocked;
-                if (handle_signal(signr, &ka, &info, oldset, regs, syscall) == 0) {
+                if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
                         /*
                          * A signal was successfully delivered; the saved
                          * sigmask will have been stored in the signal frame,
@@ -723,11 +741,14 @@ static void do_signal(struct pt_regs *regs, int syscall)
         }
 
  no_signal:
-        /*
-         * No signal to deliver to the process - restart the syscall.
-         */
         if (syscall) {
-                if (regs->ARM_r0 == -ERESTART_RESTARTBLOCK) {
+                /*
+                 * Handle restarting a different system call.  As above,
+                 * if a debugger has chosen to restart at a different PC,
+                 * ignore the restart.
+                 */
+                if (retval == -ERESTART_RESTARTBLOCK
+                    && regs->ARM_pc == continue_addr) {
                         if (thumb_mode(regs)) {
                                 regs->ARM_r7 = __NR_restart_syscall - __NR_SYSCALL_BASE;
                                 regs->ARM_pc -= 2;
@@ -750,11 +771,6 @@ static void do_signal(struct pt_regs *regs, int syscall)
 #endif
                         }
                 }
-                if (regs->ARM_r0 == -ERESTARTNOHAND ||
-                    regs->ARM_r0 == -ERESTARTSYS ||
-                    regs->ARM_r0 == -ERESTARTNOINTR) {
-                        setup_syscall_restart(regs);
-                }
 
                 /* If there's no signal to deliver, we just put the saved sigmask
                  * back.
diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c
index f29b8a29b174..d439a8f4c078 100644
--- a/arch/arm/kernel/smp.c
+++ b/arch/arm/kernel/smp.c
@@ -376,6 +376,13 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
         }
 }
 
+static void (*smp_cross_call)(const struct cpumask *, unsigned int);
+
+void __init set_smp_cross_call(void (*fn)(const struct cpumask *, unsigned int))
+{
+        smp_cross_call = fn;
+}
+
 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 {
         smp_cross_call(mask, IPI_CALL_FUNC);
@@ -560,10 +567,7 @@ asmlinkage void __exception_irq_entry do_IPI(int ipinr, struct pt_regs *regs)
                 break;
 
         case IPI_RESCHEDULE:
-                /*
-                 * nothing more to do - eveything is
-                 * done on the interrupt return path
-                 */
+                scheduler_ipi();
                 break;
 
         case IPI_CALL_FUNC:
diff --git a/arch/arm/kernel/time.c b/arch/arm/kernel/time.c
index 1ff46cabc7ef..cb634c3e28e9 100644
--- a/arch/arm/kernel/time.c
+++ b/arch/arm/kernel/time.c
@@ -21,7 +21,7 @@
 #include <linux/timex.h>
 #include <linux/errno.h>
 #include <linux/profile.h>
-#include <linux/sysdev.h>
+#include <linux/syscore_ops.h>
 #include <linux/timer.h>
 #include <linux/irq.h>
 
@@ -115,48 +115,37 @@ void timer_tick(void)
 #endif
 
 #if defined(CONFIG_PM) && !defined(CONFIG_GENERIC_CLOCKEVENTS)
-static int timer_suspend(struct sys_device *dev, pm_message_t state)
+static int timer_suspend(void)
 {
-        struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
-
-        if (timer->suspend != NULL)
-                timer->suspend();
+        if (system_timer->suspend)
+                system_timer->suspend();
 
         return 0;
 }
 
-static int timer_resume(struct sys_device *dev)
+static void timer_resume(void)
 {
-        struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
-
-        if (timer->resume != NULL)
-                timer->resume();
-
-        return 0;
+        if (system_timer->resume)
+                system_timer->resume();
 }
 #else
 #define timer_suspend NULL
 #define timer_resume NULL
 #endif
 
-static struct sysdev_class timer_sysclass = {
-        .name           = "timer",
+static struct syscore_ops timer_syscore_ops = {
         .suspend        = timer_suspend,
         .resume         = timer_resume,
 };
 
-static int __init timer_init_sysfs(void)
+static int __init timer_init_syscore_ops(void)
 {
-        int ret = sysdev_class_register(&timer_sysclass);
-        if (ret == 0) {
-                system_timer->dev.cls = &timer_sysclass;
-                ret = sysdev_register(&system_timer->dev);
-        }
+        register_syscore_ops(&timer_syscore_ops);
 
-        return ret;
+        return 0;
 }
 
-device_initcall(timer_init_sysfs);
+device_initcall(timer_init_syscore_ops);
 
 void __init time_init(void)
 {
diff --git a/arch/arm/kernel/traps.c b/arch/arm/kernel/traps.c
index 3b54ad19d489..d52eec268b47 100644
--- a/arch/arm/kernel/traps.c
+++ b/arch/arm/kernel/traps.c
@@ -234,7 +234,6 @@ static int __die(const char *str, int err, struct thread_info *thread, struct pt
 
         printk(KERN_EMERG "Internal error: %s: %x [#%d]" S_PREEMPT S_SMP "\n",
                str, err, ++die_counter);
-        sysfs_printk_last_file();
 
         /* trap and error numbers are mostly meaningless on ARM */
         ret = notify_die(DIE_OOPS, str, regs, err, tsk->thread.trap_no, SIGSEGV);