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