]>
Commit | Line | Data |
---|---|---|
88278ca2 | 1 | /* |
1da177e4 LT |
2 | * unaligned.c: Unaligned load/store trap handling with special |
3 | * cases for the kernel to do them more quickly. | |
4 | * | |
5 | * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu) | |
6 | * Copyright (C) 1996 Jakub Jelinek (jj@sunsite.mff.cuni.cz) | |
7 | */ | |
8 | ||
9 | ||
10 | #include <linux/kernel.h> | |
11 | #include <linux/sched.h> | |
12 | #include <linux/mm.h> | |
1da177e4 LT |
13 | #include <asm/ptrace.h> |
14 | #include <asm/processor.h> | |
1da177e4 LT |
15 | #include <asm/uaccess.h> |
16 | #include <linux/smp.h> | |
121dd5f2 | 17 | #include <linux/perf_event.h> |
1da177e4 | 18 | |
9edfae3f SR |
19 | #include <asm/setup.h> |
20 | ||
21 | #include "kernel.h" | |
22 | ||
1da177e4 LT |
23 | enum direction { |
24 | load, /* ld, ldd, ldh, ldsh */ | |
25 | store, /* st, std, sth, stsh */ | |
26 | both, /* Swap, ldstub, etc. */ | |
27 | fpload, | |
28 | fpstore, | |
29 | invalid, | |
30 | }; | |
31 | ||
1da177e4 LT |
32 | static inline enum direction decode_direction(unsigned int insn) |
33 | { | |
34 | unsigned long tmp = (insn >> 21) & 1; | |
35 | ||
36 | if(!tmp) | |
37 | return load; | |
38 | else { | |
39 | if(((insn>>19)&0x3f) == 15) | |
40 | return both; | |
41 | else | |
42 | return store; | |
43 | } | |
44 | } | |
45 | ||
46 | /* 8 = double-word, 4 = word, 2 = half-word */ | |
47 | static inline int decode_access_size(unsigned int insn) | |
48 | { | |
49 | insn = (insn >> 19) & 3; | |
50 | ||
51 | if(!insn) | |
52 | return 4; | |
53 | else if(insn == 3) | |
54 | return 8; | |
55 | else if(insn == 2) | |
56 | return 2; | |
57 | else { | |
58 | printk("Impossible unaligned trap. insn=%08x\n", insn); | |
59 | die_if_kernel("Byte sized unaligned access?!?!", current->thread.kregs); | |
60 | return 4; /* just to keep gcc happy. */ | |
61 | } | |
62 | } | |
63 | ||
64 | /* 0x400000 = signed, 0 = unsigned */ | |
65 | static inline int decode_signedness(unsigned int insn) | |
66 | { | |
67 | return (insn & 0x400000); | |
68 | } | |
69 | ||
70 | static inline void maybe_flush_windows(unsigned int rs1, unsigned int rs2, | |
71 | unsigned int rd) | |
72 | { | |
73 | if(rs2 >= 16 || rs1 >= 16 || rd >= 16) { | |
74 | /* Wheee... */ | |
75 | __asm__ __volatile__("save %sp, -0x40, %sp\n\t" | |
76 | "save %sp, -0x40, %sp\n\t" | |
77 | "save %sp, -0x40, %sp\n\t" | |
78 | "save %sp, -0x40, %sp\n\t" | |
79 | "save %sp, -0x40, %sp\n\t" | |
80 | "save %sp, -0x40, %sp\n\t" | |
81 | "save %sp, -0x40, %sp\n\t" | |
82 | "restore; restore; restore; restore;\n\t" | |
83 | "restore; restore; restore;\n\t"); | |
84 | } | |
85 | } | |
86 | ||
87 | static inline int sign_extend_imm13(int imm) | |
88 | { | |
89 | return imm << 19 >> 19; | |
90 | } | |
91 | ||
92 | static inline unsigned long fetch_reg(unsigned int reg, struct pt_regs *regs) | |
93 | { | |
4d7b92ad | 94 | struct reg_window32 *win; |
1da177e4 LT |
95 | |
96 | if(reg < 16) | |
97 | return (!reg ? 0 : regs->u_regs[reg]); | |
98 | ||
99 | /* Ho hum, the slightly complicated case. */ | |
4d7b92ad | 100 | win = (struct reg_window32 *) regs->u_regs[UREG_FP]; |
1da177e4 LT |
101 | return win->locals[reg - 16]; /* yes, I know what this does... */ |
102 | } | |
103 | ||
104 | static inline unsigned long safe_fetch_reg(unsigned int reg, struct pt_regs *regs) | |
105 | { | |
4d7b92ad | 106 | struct reg_window32 __user *win; |
1da177e4 LT |
107 | unsigned long ret; |
108 | ||
109 | if (reg < 16) | |
110 | return (!reg ? 0 : regs->u_regs[reg]); | |
111 | ||
112 | /* Ho hum, the slightly complicated case. */ | |
4d7b92ad | 113 | win = (struct reg_window32 __user *) regs->u_regs[UREG_FP]; |
1da177e4 LT |
114 | |
115 | if ((unsigned long)win & 3) | |
116 | return -1; | |
117 | ||
118 | if (get_user(ret, &win->locals[reg - 16])) | |
119 | return -1; | |
120 | ||
121 | return ret; | |
122 | } | |
123 | ||
124 | static inline unsigned long *fetch_reg_addr(unsigned int reg, struct pt_regs *regs) | |
125 | { | |
4d7b92ad | 126 | struct reg_window32 *win; |
1da177e4 LT |
127 | |
128 | if(reg < 16) | |
129 | return ®s->u_regs[reg]; | |
4d7b92ad | 130 | win = (struct reg_window32 *) regs->u_regs[UREG_FP]; |
1da177e4 LT |
131 | return &win->locals[reg - 16]; |
132 | } | |
133 | ||
134 | static unsigned long compute_effective_address(struct pt_regs *regs, | |
135 | unsigned int insn) | |
136 | { | |
137 | unsigned int rs1 = (insn >> 14) & 0x1f; | |
138 | unsigned int rs2 = insn & 0x1f; | |
139 | unsigned int rd = (insn >> 25) & 0x1f; | |
140 | ||
141 | if(insn & 0x2000) { | |
142 | maybe_flush_windows(rs1, 0, rd); | |
143 | return (fetch_reg(rs1, regs) + sign_extend_imm13(insn)); | |
144 | } else { | |
145 | maybe_flush_windows(rs1, rs2, rd); | |
146 | return (fetch_reg(rs1, regs) + fetch_reg(rs2, regs)); | |
147 | } | |
148 | } | |
149 | ||
150 | unsigned long safe_compute_effective_address(struct pt_regs *regs, | |
151 | unsigned int insn) | |
152 | { | |
153 | unsigned int rs1 = (insn >> 14) & 0x1f; | |
154 | unsigned int rs2 = insn & 0x1f; | |
155 | unsigned int rd = (insn >> 25) & 0x1f; | |
156 | ||
157 | if(insn & 0x2000) { | |
158 | maybe_flush_windows(rs1, 0, rd); | |
159 | return (safe_fetch_reg(rs1, regs) + sign_extend_imm13(insn)); | |
160 | } else { | |
161 | maybe_flush_windows(rs1, rs2, rd); | |
162 | return (safe_fetch_reg(rs1, regs) + safe_fetch_reg(rs2, regs)); | |
163 | } | |
164 | } | |
165 | ||
166 | /* This is just to make gcc think panic does return... */ | |
167 | static void unaligned_panic(char *str) | |
168 | { | |
e7fbaf01 | 169 | panic("%s", str); |
1da177e4 LT |
170 | } |
171 | ||
f0e98c38 DM |
172 | /* una_asm.S */ |
173 | extern int do_int_load(unsigned long *dest_reg, int size, | |
174 | unsigned long *saddr, int is_signed); | |
175 | extern int __do_int_store(unsigned long *dst_addr, int size, | |
176 | unsigned long *src_val); | |
177 | ||
178 | static int do_int_store(int reg_num, int size, unsigned long *dst_addr, | |
179 | struct pt_regs *regs) | |
180 | { | |
181 | unsigned long zero[2] = { 0, 0 }; | |
182 | unsigned long *src_val; | |
183 | ||
184 | if (reg_num) | |
185 | src_val = fetch_reg_addr(reg_num, regs); | |
186 | else { | |
187 | src_val = &zero[0]; | |
188 | if (size == 8) | |
189 | zero[1] = fetch_reg(1, regs); | |
190 | } | |
191 | return __do_int_store(dst_addr, size, src_val); | |
192 | } | |
1da177e4 LT |
193 | |
194 | extern void smp_capture(void); | |
195 | extern void smp_release(void); | |
196 | ||
1da177e4 LT |
197 | static inline void advance(struct pt_regs *regs) |
198 | { | |
199 | regs->pc = regs->npc; | |
200 | regs->npc += 4; | |
201 | } | |
202 | ||
203 | static inline int floating_point_load_or_store_p(unsigned int insn) | |
204 | { | |
205 | return (insn >> 24) & 1; | |
206 | } | |
207 | ||
208 | static inline int ok_for_kernel(unsigned int insn) | |
209 | { | |
210 | return !floating_point_load_or_store_p(insn); | |
211 | } | |
212 | ||
f0e98c38 | 213 | static void kernel_mna_trap_fault(struct pt_regs *regs, unsigned int insn) |
1da177e4 LT |
214 | { |
215 | unsigned long g2 = regs->u_regs [UREG_G2]; | |
216 | unsigned long fixup = search_extables_range(regs->pc, &g2); | |
217 | ||
218 | if (!fixup) { | |
219 | unsigned long address = compute_effective_address(regs, insn); | |
220 | if(address < PAGE_SIZE) { | |
221 | printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference in mna handler"); | |
222 | } else | |
223 | printk(KERN_ALERT "Unable to handle kernel paging request in mna handler"); | |
224 | printk(KERN_ALERT " at virtual address %08lx\n",address); | |
225 | printk(KERN_ALERT "current->{mm,active_mm}->context = %08lx\n", | |
226 | (current->mm ? current->mm->context : | |
227 | current->active_mm->context)); | |
228 | printk(KERN_ALERT "current->{mm,active_mm}->pgd = %08lx\n", | |
229 | (current->mm ? (unsigned long) current->mm->pgd : | |
230 | (unsigned long) current->active_mm->pgd)); | |
231 | die_if_kernel("Oops", regs); | |
232 | /* Not reached */ | |
233 | } | |
234 | regs->pc = fixup; | |
235 | regs->npc = regs->pc + 4; | |
236 | regs->u_regs [UREG_G2] = g2; | |
237 | } | |
238 | ||
239 | asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn) | |
240 | { | |
241 | enum direction dir = decode_direction(insn); | |
242 | int size = decode_access_size(insn); | |
243 | ||
244 | if(!ok_for_kernel(insn) || dir == both) { | |
245 | printk("Unsupported unaligned load/store trap for kernel at <%08lx>.\n", | |
246 | regs->pc); | |
247 | unaligned_panic("Wheee. Kernel does fpu/atomic unaligned load/store."); | |
1da177e4 LT |
248 | } else { |
249 | unsigned long addr = compute_effective_address(regs, insn); | |
f0e98c38 | 250 | int err; |
1da177e4 | 251 | |
a8b0ca17 | 252 | perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, regs, addr); |
f0e98c38 | 253 | switch (dir) { |
1da177e4 | 254 | case load: |
f0e98c38 DM |
255 | err = do_int_load(fetch_reg_addr(((insn>>25)&0x1f), |
256 | regs), | |
257 | size, (unsigned long *) addr, | |
258 | decode_signedness(insn)); | |
1da177e4 LT |
259 | break; |
260 | ||
261 | case store: | |
f0e98c38 DM |
262 | err = do_int_store(((insn>>25)&0x1f), size, |
263 | (unsigned long *) addr, regs); | |
1da177e4 | 264 | break; |
1da177e4 LT |
265 | default: |
266 | panic("Impossible kernel unaligned trap."); | |
267 | /* Not reached... */ | |
268 | } | |
f0e98c38 DM |
269 | if (err) |
270 | kernel_mna_trap_fault(regs, insn); | |
271 | else | |
272 | advance(regs); | |
1da177e4 LT |
273 | } |
274 | } | |
275 | ||
276 | static inline int ok_for_user(struct pt_regs *regs, unsigned int insn, | |
277 | enum direction dir) | |
278 | { | |
279 | unsigned int reg; | |
280 | int check = (dir == load) ? VERIFY_READ : VERIFY_WRITE; | |
281 | int size = ((insn >> 19) & 3) == 3 ? 8 : 4; | |
282 | ||
283 | if ((regs->pc | regs->npc) & 3) | |
284 | return 0; | |
285 | ||
286 | /* Must access_ok() in all the necessary places. */ | |
287 | #define WINREG_ADDR(regnum) \ | |
288 | ((void __user *)(((unsigned long *)regs->u_regs[UREG_FP])+(regnum))) | |
289 | ||
290 | reg = (insn >> 25) & 0x1f; | |
291 | if (reg >= 16) { | |
292 | if (!access_ok(check, WINREG_ADDR(reg - 16), size)) | |
293 | return -EFAULT; | |
294 | } | |
295 | reg = (insn >> 14) & 0x1f; | |
296 | if (reg >= 16) { | |
297 | if (!access_ok(check, WINREG_ADDR(reg - 16), size)) | |
298 | return -EFAULT; | |
299 | } | |
300 | if (!(insn & 0x2000)) { | |
301 | reg = (insn & 0x1f); | |
302 | if (reg >= 16) { | |
303 | if (!access_ok(check, WINREG_ADDR(reg - 16), size)) | |
304 | return -EFAULT; | |
305 | } | |
306 | } | |
307 | #undef WINREG_ADDR | |
308 | return 0; | |
309 | } | |
310 | ||
f0e98c38 | 311 | static void user_mna_trap_fault(struct pt_regs *regs, unsigned int insn) |
1da177e4 LT |
312 | { |
313 | siginfo_t info; | |
314 | ||
315 | info.si_signo = SIGBUS; | |
316 | info.si_errno = 0; | |
317 | info.si_code = BUS_ADRALN; | |
318 | info.si_addr = (void __user *)safe_compute_effective_address(regs, insn); | |
319 | info.si_trapno = 0; | |
320 | send_sig_info(SIGBUS, &info, current); | |
321 | } | |
322 | ||
323 | asmlinkage void user_unaligned_trap(struct pt_regs *regs, unsigned int insn) | |
324 | { | |
325 | enum direction dir; | |
326 | ||
1da177e4 LT |
327 | if(!(current->thread.flags & SPARC_FLAG_UNALIGNED) || |
328 | (((insn >> 30) & 3) != 3)) | |
329 | goto kill_user; | |
330 | dir = decode_direction(insn); | |
331 | if(!ok_for_user(regs, insn, dir)) { | |
332 | goto kill_user; | |
333 | } else { | |
f0e98c38 | 334 | int err, size = decode_access_size(insn); |
1da177e4 LT |
335 | unsigned long addr; |
336 | ||
337 | if(floating_point_load_or_store_p(insn)) { | |
338 | printk("User FPU load/store unaligned unsupported.\n"); | |
339 | goto kill_user; | |
340 | } | |
341 | ||
342 | addr = compute_effective_address(regs, insn); | |
a8b0ca17 | 343 | perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, regs, addr); |
1da177e4 LT |
344 | switch(dir) { |
345 | case load: | |
f0e98c38 DM |
346 | err = do_int_load(fetch_reg_addr(((insn>>25)&0x1f), |
347 | regs), | |
348 | size, (unsigned long *) addr, | |
349 | decode_signedness(insn)); | |
1da177e4 LT |
350 | break; |
351 | ||
352 | case store: | |
f0e98c38 DM |
353 | err = do_int_store(((insn>>25)&0x1f), size, |
354 | (unsigned long *) addr, regs); | |
1da177e4 LT |
355 | break; |
356 | ||
357 | case both: | |
1da177e4 LT |
358 | /* |
359 | * This was supported in 2.4. However, we question | |
360 | * the value of SWAP instruction across word boundaries. | |
361 | */ | |
362 | printk("Unaligned SWAP unsupported.\n"); | |
f0e98c38 | 363 | err = -EFAULT; |
1da177e4 LT |
364 | break; |
365 | ||
366 | default: | |
367 | unaligned_panic("Impossible user unaligned trap."); | |
1da177e4 LT |
368 | goto out; |
369 | } | |
f0e98c38 DM |
370 | if (err) |
371 | goto kill_user; | |
372 | else | |
373 | advance(regs); | |
1da177e4 LT |
374 | goto out; |
375 | } | |
376 | ||
377 | kill_user: | |
378 | user_mna_trap_fault(regs, insn); | |
379 | out: | |
b19f8200 | 380 | ; |
1da177e4 | 381 | } |