a99eae5417
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>
159 lines
3.9 KiB
C
159 lines
3.9 KiB
C
/*
|
|
* 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);
|