sh: Split out the unaligned counters and user bits.

This splits out the unaligned access counters and userspace bits in to
their own generic interface, which will allow them to be wired up on sh64
too.

Signed-off-by: Paul Mundt <lethal@linux-sh.org>

4 files changed, 198 insertions, 135 deletions

diff --git a/arch/sh/include/asm/alignment.h b/arch/sh/include/asm/alignment.h
new file mode 100644
index 000000000000..b12efecf5294
--- /dev/null
+++ b/arch/sh/include/asm/alignment.h
@@ -0,0 +1,21 @@
+#ifndef __ASM_SH_ALIGNMENT_H
+#define __ASM_SH_ALIGNMENT_H
+
+#include <linux/types.h>
+
+extern void inc_unaligned_byte_access(void);
+extern void inc_unaligned_word_access(void);
+extern void inc_unaligned_dword_access(void);
+extern void inc_unaligned_multi_access(void);
+extern void inc_unaligned_user_access(void);
+extern void inc_unaligned_kernel_access(void);
+
+#define UM_WARN         (1 << 0)
+#define UM_FIXUP        (1 << 1)
+#define UM_SIGNAL       (1 << 2)
+
+extern unsigned int unaligned_user_action(void);
+
+extern void unaligned_fixups_notify(struct task_struct *, insn_size_t, struct pt_regs *);
+
+#endif /* __ASM_SH_ALIGNMENT_H */
diff --git a/arch/sh/kernel/traps_32.c b/arch/sh/kernel/traps_32.c
index efcbdfe52f52..204def6ecb6a 100644
--- a/arch/sh/kernel/traps_32.c
+++ b/arch/sh/kernel/traps_32.c
@@ -24,11 +24,10 @@
 #include <linux/kdebug.h>
 #include <linux/kexec.h>
 #include <linux/limits.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
 #include <linux/sysfs.h>
+#include <linux/uaccess.h>
 #include <asm/system.h>
-#include <asm/uaccess.h>
+#include <asm/alignment.h>
 #include <asm/fpu.h>
 #include <asm/kprobes.h>
 #include <asm/sh_bios.h>
@@ -48,73 +47,6 @@
 #define TRAP_ILLEGAL_SLOT_INST  13
 #endif
 
-static unsigned long se_user;
-static unsigned long se_sys;
-static unsigned long se_half;
-static unsigned long se_word;
-static unsigned long se_dword;
-static unsigned long se_multi;
-/* bitfield: 1: warn 2: fixup 4: signal -> combinations 2|4 && 1|2|4 are not
-   valid! */
-static int se_usermode = 3;
-/* 0: no warning 1: print a warning message, disabled by default */
-static int se_kernmode_warn;
-
-#ifdef CONFIG_PROC_FS
-static const char *se_usermode_action[] = {
-        "ignored",
-        "warn",
-        "fixup",
-        "fixup+warn",
-        "signal",
-        "signal+warn"
-};
-
-static int alignment_proc_show(struct seq_file *m, void *v)
-{
-        seq_printf(m, "User:\t\t%lu\n", se_user);
-        seq_printf(m, "System:\t\t%lu\n", se_sys);
-        seq_printf(m, "Half:\t\t%lu\n", se_half);
-        seq_printf(m, "Word:\t\t%lu\n", se_word);
-        seq_printf(m, "DWord:\t\t%lu\n", se_dword);
-        seq_printf(m, "Multi:\t\t%lu\n", se_multi);
-        seq_printf(m, "User faults:\t%i (%s)\n", se_usermode,
-                        se_usermode_action[se_usermode]);
-        seq_printf(m, "Kernel faults:\t%i (fixup%s)\n", se_kernmode_warn,
-                        se_kernmode_warn ? "+warn" : "");
-        return 0;
-}
-
-static int alignment_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, alignment_proc_show, NULL);
-}
-
-static ssize_t alignment_proc_write(struct file *file,
-                const char __user *buffer, size_t count, loff_t *pos)
-{
-        int *data = PDE(file->f_path.dentry->d_inode)->data;
-        char mode;
-
-        if (count > 0) {
-                if (get_user(mode, buffer))
-                        return -EFAULT;
-                if (mode >= '0' && mode <= '5')
-                        *data = mode - '0';
-        }
-        return count;
-}
-
-static const struct file_operations alignment_proc_fops = {
-        .owner          = THIS_MODULE,
-        .open           = alignment_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-        .write          = alignment_proc_write,
-};
-#endif
-
 static void dump_mem(const char *str, unsigned long bottom, unsigned long top)
 {
         unsigned long p;
@@ -266,10 +198,10 @@ static int handle_unaligned_ins(insn_size_t instruction, struct pt_regs *regs,
         count = 1<<(instruction&3);
 
         switch (count) {
-        case 1: se_half  += 1; break;
-        case 2: se_word  += 1; break;
-        case 4: se_dword += 1; break;
-        case 8: se_multi += 1; break; /* ??? */
+        case 1: inc_unaligned_byte_access(); break;
+        case 2: inc_unaligned_word_access(); break;
+        case 4: inc_unaligned_dword_access(); break;
+        case 8: inc_unaligned_multi_access(); break;
         }
 
         ret = -EFAULT;
@@ -453,18 +385,8 @@ int handle_unaligned_access(insn_size_t instruction, struct pt_regs *regs,
         rm = regs->regs[index];
 
         /* shout about fixups */
-        if (!expected) {
-                if (user_mode(regs) && (se_usermode & 1) && printk_ratelimit())
-                        pr_notice("Fixing up unaligned userspace access "
-                                  "in \"%s\" pid=%d pc=0x%p ins=0x%04hx\n",
-                                  current->comm, task_pid_nr(current),
-                                  (void *)regs->pc, instruction);
-                else if (se_kernmode_warn && printk_ratelimit())
-                        pr_notice("Fixing up unaligned kernel access "
-                                  "in \"%s\" pid=%d pc=0x%p ins=0x%04hx\n",
-                                  current->comm, task_pid_nr(current),
-                                  (void *)regs->pc, instruction);
-        }
+        if (!expected)
+                unaligned_fixups_notify(current, instruction, regs);
 
         ret = -EFAULT;
         switch (instruction&0xF000) {
@@ -617,10 +539,10 @@ asmlinkage void do_address_error(struct pt_regs *regs,
 
         if (user_mode(regs)) {
                 int si_code = BUS_ADRERR;
+                unsigned int user_action;
 
                 local_irq_enable();
-
-                se_user += 1;
+                inc_unaligned_user_access();
 
                 set_fs(USER_DS);
                 if (copy_from_user(&instruction, (insn_size_t *)(regs->pc & ~1),
@@ -631,16 +553,12 @@ asmlinkage void do_address_error(struct pt_regs *regs,
                 set_fs(oldfs);
 
                 /* shout about userspace fixups */
-                if (se_usermode & 1)
-                        printk(KERN_NOTICE "Unaligned userspace access "
-                               "in \"%s\" pid=%d pc=0x%p ins=0x%04hx\n",
-                               current->comm, current->pid, (void *)regs->pc,
-                               instruction);
+                unaligned_fixups_notify(current, instruction, regs);
 
-                if (se_usermode & 2)
+                user_action = unaligned_user_action();
+                if (user_action & UM_FIXUP)
                         goto fixup;
-
-                if (se_usermode & 4)
+                if (user_action & UM_SIGNAL)
                         goto uspace_segv;
                 else {
                         /* ignore */
@@ -660,7 +578,7 @@ fixup:
                                               &user_mem_access, 0);
                 set_fs(oldfs);
 
-                if (tmp==0)
+                if (tmp == 0)
                         return; /* sorted */
 uspace_segv:
                 printk(KERN_NOTICE "Sending SIGBUS to \"%s\" due to unaligned "
@@ -673,7 +591,7 @@ uspace_segv:
                 info.si_addr = (void __user *)address;
                 force_sig_info(SIGBUS, &info, current);
         } else {
-                se_sys += 1;
+                inc_unaligned_kernel_access();
 
                 if (regs->pc & 1)
                         die("unaligned program counter", regs, error_code);
@@ -688,11 +606,7 @@ uspace_segv:
                         die("insn faulting in do_address_error", regs, 0);
                 }
 
-                if (se_kernmode_warn)
-                        printk(KERN_NOTICE "Unaligned kernel access "
-                               "on behalf of \"%s\" pid=%d pc=0x%p ins=0x%04hx\n",
-                               current->comm, current->pid, (void *)regs->pc,
-                               instruction);
+                unaligned_fixups_notify(current, instruction, regs);
 
                 handle_unaligned_access(instruction, regs,
                                         &user_mem_access, 0);
@@ -964,34 +878,3 @@ void dump_stack(void)
         show_stack(NULL, NULL);
 }
 EXPORT_SYMBOL(dump_stack);
-
-#ifdef CONFIG_PROC_FS
-/*
- * This needs to be done after sysctl_init, otherwise sys/ will be
- * overwritten.  Actually, this shouldn't be in sys/ at all since
- * it isn't a sysctl, and it doesn't contain sysctl information.
- * We now locate it in /proc/cpu/alignment instead.
- */
-static int __init alignment_init(void)
-{
-        struct proc_dir_entry *dir, *res;
-
-        dir = proc_mkdir("cpu", NULL);
-        if (!dir)
-                return -ENOMEM;
-
-        res = proc_create_data("alignment", S_IWUSR | S_IRUGO, dir,
-                               &alignment_proc_fops, &se_usermode);
-        if (!res)
-                return -ENOMEM;
-
-        res = proc_create_data("kernel_alignment", S_IWUSR | S_IRUGO, dir,
-                               &alignment_proc_fops, &se_kernmode_warn);
-        if (!res)
-                return -ENOMEM;
-
-        return 0;
-}
-
-fs_initcall(alignment_init);
-#endif
diff --git a/arch/sh/mm/Makefile b/arch/sh/mm/Makefile
index dd5010c708e0..9fa11d655044 100644
--- a/arch/sh/mm/Makefile
+++ b/arch/sh/mm/Makefile
@@ -2,7 +2,7 @@
 # Makefile for the Linux SuperH-specific parts of the memory manager.
 #
 
-obj-y                   := cache.o init.o consistent.o mmap.o
+obj-y                   := alignment.o cache.o init.o consistent.o mmap.o
 
 cacheops-$(CONFIG_CPU_SH2)              := cache-sh2.o
 cacheops-$(CONFIG_CPU_SH2A)             := cache-sh2a.o
diff --git a/arch/sh/mm/alignment.c b/arch/sh/mm/alignment.c
new file mode 100644
index 000000000000..e615151eac3b
--- /dev/null
+++ b/arch/sh/mm/alignment.c
@@ -0,0 +1,159 @@
+/*
+ * Alignment access counters and corresponding user-space interfaces.
+ *
+ * Copyright (C) 2009 ST Microelectronics
+ * Copyright (C) 2009 - 2010 Paul Mundt
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/seq_file.h>
+#include <linux/proc_fs.h>
+#include <linux/uaccess.h>
+#include <asm/alignment.h>
+
+static unsigned long se_user;
+static unsigned long se_sys;
+static unsigned long se_half;
+static unsigned long se_word;
+static unsigned long se_dword;
+static unsigned long se_multi;
+/* bitfield: 1: warn 2: fixup 4: signal -> combinations 2|4 && 1|2|4 are not
+   valid! */
+static int se_usermode = UM_WARN | UM_FIXUP;
+/* 0: no warning 1: print a warning message, disabled by default */
+static int se_kernmode_warn;
+
+void inc_unaligned_byte_access(void)
+{
+        se_half++;
+}
+
+void inc_unaligned_word_access(void)
+{
+        se_word++;
+}
+
+void inc_unaligned_dword_access(void)
+{
+        se_dword++;
+}
+
+void inc_unaligned_multi_access(void)
+{
+        se_multi++;
+}
+
+void inc_unaligned_user_access(void)
+{
+        se_user++;
+}
+
+void inc_unaligned_kernel_access(void)
+{
+        se_sys++;
+}
+
+unsigned int unaligned_user_action(void)
+{
+        return se_usermode;
+}
+
+void unaligned_fixups_notify(struct task_struct *tsk, insn_size_t insn,
+                             struct pt_regs *regs)
+{
+        if (user_mode(regs) && (se_usermode & UM_WARN) && printk_ratelimit())
+                pr_notice("Fixing up unaligned userspace access "
+                          "in \"%s\" pid=%d pc=0x%p ins=0x%04hx\n",
+                          tsk->comm, task_pid_nr(tsk),
+                          (void *)regs->pc, insn);
+        else if (se_kernmode_warn && printk_ratelimit())
+                pr_notice("Fixing up unaligned kernel access "
+                          "in \"%s\" pid=%d pc=0x%p ins=0x%04hx\n",
+                          tsk->comm, task_pid_nr(tsk),
+                          (void *)regs->pc, insn);
+}
+
+static const char *se_usermode_action[] = {
+        "ignored",
+        "warn",
+        "fixup",
+        "fixup+warn",
+        "signal",
+        "signal+warn"
+};
+
+static int alignment_proc_show(struct seq_file *m, void *v)
+{
+        seq_printf(m, "User:\t\t%lu\n", se_user);
+        seq_printf(m, "System:\t\t%lu\n", se_sys);
+        seq_printf(m, "Half:\t\t%lu\n", se_half);
+        seq_printf(m, "Word:\t\t%lu\n", se_word);
+        seq_printf(m, "DWord:\t\t%lu\n", se_dword);
+        seq_printf(m, "Multi:\t\t%lu\n", se_multi);
+        seq_printf(m, "User faults:\t%i (%s)\n", se_usermode,
+                        se_usermode_action[se_usermode]);
+        seq_printf(m, "Kernel faults:\t%i (fixup%s)\n", se_kernmode_warn,
+                        se_kernmode_warn ? "+warn" : "");
+        return 0;
+}
+
+static int alignment_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, alignment_proc_show, NULL);
+}
+
+static ssize_t alignment_proc_write(struct file *file,
+                const char __user *buffer, size_t count, loff_t *pos)
+{
+        int *data = PDE(file->f_path.dentry->d_inode)->data;
+        char mode;
+
+        if (count > 0) {
+                if (get_user(mode, buffer))
+                        return -EFAULT;
+                if (mode >= '0' && mode <= '5')
+                        *data = mode - '0';
+        }
+        return count;
+}
+
+static const struct file_operations alignment_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = alignment_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = alignment_proc_write,
+};
+
+/*
+ * This needs to be done after sysctl_init, otherwise sys/ will be
+ * overwritten.  Actually, this shouldn't be in sys/ at all since
+ * it isn't a sysctl, and it doesn't contain sysctl information.
+ * We now locate it in /proc/cpu/alignment instead.
+ */
+static int __init alignment_init(void)
+{
+        struct proc_dir_entry *dir, *res;
+
+        dir = proc_mkdir("cpu", NULL);
+        if (!dir)
+                return -ENOMEM;
+
+        res = proc_create_data("alignment", S_IWUSR | S_IRUGO, dir,
+                               &alignment_proc_fops, &se_usermode);
+        if (!res)
+                return -ENOMEM;
+
+        res = proc_create_data("kernel_alignment", S_IWUSR | S_IRUGO, dir,
+                               &alignment_proc_fops, &se_kernmode_warn);
+        if (!res)
+                return -ENOMEM;
+
+        return 0;
+}
+fs_initcall(alignment_init);