1 /* 2 * linux/arch/nios2/kernel/misaligned.c 3 * 4 * basic emulation for mis-aligned accesses on the NIOS II cpu 5 * modelled after the version for arm in arm/alignment.c 6 * 7 * Brad Parker <brad@heeltoe.com> 8 * Copyright (C) 2010 Ambient Corporation 9 * Copyright (c) 2010 Altera Corporation, San Jose, California, USA. 10 * Copyright (c) 2010 Arrow Electronics, Inc. 11 * 12 * This file is subject to the terms and conditions of the GNU General 13 * Public License. See the file COPYING in the main directory of 14 * this archive for more details. 15 */ 16 17 #include <linux/errno.h> 18 #include <linux/string.h> 19 #include <linux/proc_fs.h> 20 #include <linux/init.h> 21 #include <linux/sched.h> 22 #include <linux/uaccess.h> 23 #include <linux/seq_file.h> 24 25 #include <asm/traps.h> 26 #include <asm/unaligned.h> 27 28 /* instructions we emulate */ 29 #define INST_LDHU 0x0b 30 #define INST_STH 0x0d 31 #define INST_LDH 0x0f 32 #define INST_STW 0x15 33 #define INST_LDW 0x17 34 35 static unsigned long ma_user, ma_kern, ma_skipped, ma_half, ma_word; 36 37 static unsigned int ma_usermode; 38 #define UM_WARN 0x01 39 #define UM_FIXUP 0x02 40 #define UM_SIGNAL 0x04 41 #define KM_WARN 0x08 42 43 /* see arch/nios2/include/asm/ptrace.h */ 44 static u8 sys_stack_frame_reg_offset[] = { 45 /* struct pt_regs */ 46 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 0, 47 /* struct switch_stack */ 48 16, 17, 18, 19, 20, 21, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0 49 }; 50 51 static int reg_offsets[32]; 52 53 static inline u32 get_reg_val(struct pt_regs *fp, int reg) 54 { 55 u8 *p = ((u8 *)fp) + reg_offsets[reg]; 56 57 return *(u32 *)p; 58 } 59 60 static inline void put_reg_val(struct pt_regs *fp, int reg, u32 val) 61 { 62 u8 *p = ((u8 *)fp) + reg_offsets[reg]; 63 *(u32 *)p = val; 64 } 65 66 /* 67 * (mis)alignment handler 68 */ 69 asmlinkage void handle_unaligned_c(struct pt_regs *fp, int cause) 70 { 71 u32 isn, addr, val; 72 int in_kernel; 73 u8 a, b, d0, d1, d2, d3; 74 s16 imm16; 75 unsigned int fault; 76 77 /* back up one instruction */ 78 fp->ea -= 4; 79 80 if (fixup_exception(fp)) { 81 ma_skipped++; 82 return; 83 } 84 85 in_kernel = !user_mode(fp); 86 87 isn = *(unsigned long *)(fp->ea); 88 89 fault = 0; 90 91 /* do fixup if in kernel or mode turned on */ 92 if (in_kernel || (ma_usermode & UM_FIXUP)) { 93 /* decompose instruction */ 94 a = (isn >> 27) & 0x1f; 95 b = (isn >> 22) & 0x1f; 96 imm16 = (isn >> 6) & 0xffff; 97 addr = get_reg_val(fp, a) + imm16; 98 99 /* do fixup to saved registers */ 100 switch (isn & 0x3f) { 101 case INST_LDHU: 102 fault |= __get_user(d0, (u8 *)(addr+0)); 103 fault |= __get_user(d1, (u8 *)(addr+1)); 104 val = (d1 << 8) | d0; 105 put_reg_val(fp, b, val); 106 ma_half++; 107 break; 108 case INST_STH: 109 val = get_reg_val(fp, b); 110 d1 = val >> 8; 111 d0 = val >> 0; 112 113 pr_debug("sth: ra=%d (%08x) rb=%d (%08x), imm16 %04x addr %08x val %08x\n", 114 a, get_reg_val(fp, a), 115 b, get_reg_val(fp, b), 116 imm16, addr, val); 117 118 if (in_kernel) { 119 *(u8 *)(addr+0) = d0; 120 *(u8 *)(addr+1) = d1; 121 } else { 122 fault |= __put_user(d0, (u8 *)(addr+0)); 123 fault |= __put_user(d1, (u8 *)(addr+1)); 124 } 125 ma_half++; 126 break; 127 case INST_LDH: 128 fault |= __get_user(d0, (u8 *)(addr+0)); 129 fault |= __get_user(d1, (u8 *)(addr+1)); 130 val = (short)((d1 << 8) | d0); 131 put_reg_val(fp, b, val); 132 ma_half++; 133 break; 134 case INST_STW: 135 val = get_reg_val(fp, b); 136 d3 = val >> 24; 137 d2 = val >> 16; 138 d1 = val >> 8; 139 d0 = val >> 0; 140 if (in_kernel) { 141 *(u8 *)(addr+0) = d0; 142 *(u8 *)(addr+1) = d1; 143 *(u8 *)(addr+2) = d2; 144 *(u8 *)(addr+3) = d3; 145 } else { 146 fault |= __put_user(d0, (u8 *)(addr+0)); 147 fault |= __put_user(d1, (u8 *)(addr+1)); 148 fault |= __put_user(d2, (u8 *)(addr+2)); 149 fault |= __put_user(d3, (u8 *)(addr+3)); 150 } 151 ma_word++; 152 break; 153 case INST_LDW: 154 fault |= __get_user(d0, (u8 *)(addr+0)); 155 fault |= __get_user(d1, (u8 *)(addr+1)); 156 fault |= __get_user(d2, (u8 *)(addr+2)); 157 fault |= __get_user(d3, (u8 *)(addr+3)); 158 val = (d3 << 24) | (d2 << 16) | (d1 << 8) | d0; 159 put_reg_val(fp, b, val); 160 ma_word++; 161 break; 162 } 163 } 164 165 addr = RDCTL(CTL_BADADDR); 166 cause >>= 2; 167 168 if (fault) { 169 if (in_kernel) { 170 pr_err("fault during kernel misaligned fixup @ %#lx; addr 0x%08x; isn=0x%08x\n", 171 fp->ea, (unsigned int)addr, 172 (unsigned int)isn); 173 } else { 174 pr_err("fault during user misaligned fixup @ %#lx; isn=%08x addr=0x%08x sp=0x%08lx pid=%d\n", 175 fp->ea, 176 (unsigned int)isn, addr, fp->sp, 177 current->pid); 178 179 _exception(SIGSEGV, fp, SEGV_MAPERR, fp->ea); 180 return; 181 } 182 } 183 184 /* 185 * kernel mode - 186 * note exception and skip bad instruction (return) 187 */ 188 if (in_kernel) { 189 ma_kern++; 190 fp->ea += 4; 191 192 if (ma_usermode & KM_WARN) { 193 pr_err("kernel unaligned access @ %#lx; BADADDR 0x%08x; cause=%d, isn=0x%08x\n", 194 fp->ea, 195 (unsigned int)addr, cause, 196 (unsigned int)isn); 197 /* show_regs(fp); */ 198 } 199 200 return; 201 } 202 203 ma_user++; 204 205 /* 206 * user mode - 207 * possibly warn, 208 * possibly send SIGBUS signal to process 209 */ 210 if (ma_usermode & UM_WARN) { 211 pr_err("user unaligned access @ %#lx; isn=0x%08lx ea=0x%08lx ra=0x%08lx sp=0x%08lx\n", 212 (unsigned long)addr, (unsigned long)isn, 213 fp->ea, fp->ra, fp->sp); 214 } 215 216 if (ma_usermode & UM_SIGNAL) 217 _exception(SIGBUS, fp, BUS_ADRALN, fp->ea); 218 else 219 fp->ea += 4; /* else advance */ 220 } 221 222 static void __init misaligned_calc_reg_offsets(void) 223 { 224 int i, r, offset; 225 226 /* pre-calc offsets of registers on sys call stack frame */ 227 offset = 0; 228 229 /* struct pt_regs */ 230 for (i = 0; i < 16; i++) { 231 r = sys_stack_frame_reg_offset[i]; 232 reg_offsets[r] = offset; 233 offset += 4; 234 } 235 236 /* struct switch_stack */ 237 offset = -sizeof(struct switch_stack); 238 for (i = 16; i < 32; i++) { 239 r = sys_stack_frame_reg_offset[i]; 240 reg_offsets[r] = offset; 241 offset += 4; 242 } 243 } 244 245 246 static int __init misaligned_init(void) 247 { 248 /* default mode - silent fix */ 249 ma_usermode = UM_FIXUP | KM_WARN; 250 251 misaligned_calc_reg_offsets(); 252 253 return 0; 254 } 255 256 fs_initcall(misaligned_init); 257