projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge rsync://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[deliverable/linux.git] / arch / parisc / kernel / traps.c
1 /*
2 * linux/arch/parisc/traps.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1999, 2000 Philipp Rumpf <prumpf@tux.org>
6 */
7
8 /*
9 * 'Traps.c' handles hardware traps and faults after we have saved some
10 * state in 'asm.s'.
11 */
12
13 #include <linux/sched.h>
14 #include <linux/kernel.h>
15 #include <linux/string.h>
16 #include <linux/errno.h>
17 #include <linux/ptrace.h>
18 #include <linux/timer.h>
19 #include <linux/mm.h>
20 #include <linux/module.h>
21 #include <linux/smp.h>
22 #include <linux/smp_lock.h>
23 #include <linux/spinlock.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/console.h>
27 #include <linux/kallsyms.h>
28
29 #include <asm/assembly.h>
30 #include <asm/system.h>
31 #include <asm/uaccess.h>
32 #include <asm/io.h>
33 #include <asm/irq.h>
34 #include <asm/traps.h>
35 #include <asm/unaligned.h>
36 #include <asm/atomic.h>
37 #include <asm/smp.h>
38 #include <asm/pdc.h>
39 #include <asm/pdc_chassis.h>
40 #include <asm/unwind.h>
41
42 #include "../math-emu/math-emu.h" /* for handle_fpe() */
43
44 #define PRINT_USER_FAULTS /* (turn this on if you want user faults to be */
45 /* dumped to the console via printk) */
46
47 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
48 DEFINE_SPINLOCK(pa_dbit_lock);
49 #endif
50
51 int printbinary(char *buf, unsigned long x, int nbits)
52 {
53 unsigned long mask = 1UL << (nbits - 1);
54 while (mask != 0) {
55 *buf++ = (mask & x ? '1' : '0');
56 mask >>= 1;
57 }
58 *buf = '\0';
59
60 return nbits;
61 }
62
63 #ifdef __LP64__
64 #define RFMT "%016lx"
65 #else
66 #define RFMT "%08lx"
67 #endif
68 #define FFMT "%016llx" /* fpregs are 64-bit always */
69
70 #define PRINTREGS(lvl,r,f,fmt,x) \
71 printk("%s%s%02d-%02d " fmt " " fmt " " fmt " " fmt "\n", \
72 lvl, f, (x), (x+3), (r)[(x)+0], (r)[(x)+1], \
73 (r)[(x)+2], (r)[(x)+3])
74
75 static void print_gr(char *level, struct pt_regs *regs)
76 {
77 int i;
78 char buf[64];
79
80 printk("%s\n", level);
81 printk("%s YZrvWESTHLNXBCVMcbcbcbcbOGFRQPDI\n", level);
82 printbinary(buf, regs->gr[0], 32);
83 printk("%sPSW: %s %s\n", level, buf, print_tainted());
84
85 for (i = 0; i < 32; i += 4)
86 PRINTREGS(level, regs->gr, "r", RFMT, i);
87 }
88
89 static void print_fr(char *level, struct pt_regs *regs)
90 {
91 int i;
92 char buf[64];
93 struct { u32 sw[2]; } s;
94
95 /* FR are 64bit everywhere. Need to use asm to get the content
96 * of fpsr/fper1, and we assume that we won't have a FP Identify
97 * in our way, otherwise we're screwed.
98 * The fldd is used to restore the T-bit if there was one, as the
99 * store clears it anyway.
100 * PA2.0 book says "thou shall not use fstw on FPSR/FPERs" - T-Bone */
101 asm volatile ("fstd %%fr0,0(%1) \n\t"
102 "fldd 0(%1),%%fr0 \n\t"
103 : "=m" (s) : "r" (&s) : "r0");
104
105 printk("%s\n", level);
106 printk("%s VZOUICununcqcqcqcqcqcrmunTDVZOUI\n", level);
107 printbinary(buf, s.sw[0], 32);
108 printk("%sFPSR: %s\n", level, buf);
109 printk("%sFPER1: %08x\n", level, s.sw[1]);
110
111 /* here we'll print fr0 again, tho it'll be meaningless */
112 for (i = 0; i < 32; i += 4)
113 PRINTREGS(level, regs->fr, "fr", FFMT, i);
114 }
115
116 void show_regs(struct pt_regs *regs)
117 {
118 int i;
119 char *level;
120 unsigned long cr30, cr31;
121
122 level = user_mode(regs) ? KERN_DEBUG : KERN_CRIT;
123
124 print_gr(level, regs);
125
126 for (i = 0; i < 8; i += 4)
127 PRINTREGS(level, regs->sr, "sr", RFMT, i);
128
129 if (user_mode(regs))
130 print_fr(level, regs);
131
132 cr30 = mfctl(30);
133 cr31 = mfctl(31);
134 printk("%s\n", level);
135 printk("%sIASQ: " RFMT " " RFMT " IAOQ: " RFMT " " RFMT "\n",
136 level, regs->iasq[0], regs->iasq[1], regs->iaoq[0], regs->iaoq[1]);
137 printk("%s IIR: %08lx ISR: " RFMT " IOR: " RFMT "\n",
138 level, regs->iir, regs->isr, regs->ior);
139 printk("%s CPU: %8d CR30: " RFMT " CR31: " RFMT "\n",
140 level, current_thread_info()->cpu, cr30, cr31);
141 printk("%s ORIG_R28: " RFMT "\n", level, regs->orig_r28);
142 printk(level);
143 print_symbol(" IAOQ[0]: %s\n", regs->iaoq[0]);
144 printk(level);
145 print_symbol(" IAOQ[1]: %s\n", regs->iaoq[1]);
146 printk(level);
147 print_symbol(" RP(r2): %s\n", regs->gr[2]);
148 }
149
150
151 void dump_stack(void)
152 {
153 show_stack(NULL, NULL);
154 }
155
156 EXPORT_SYMBOL(dump_stack);
157
158 static void do_show_stack(struct unwind_frame_info *info)
159 {
160 int i = 1;
161
162 printk("Backtrace:\n");
163 while (i <= 16) {
164 if (unwind_once(info) < 0 || info->ip == 0)
165 break;
166
167 if (__kernel_text_address(info->ip)) {
168 printk(" [<" RFMT ">] ", info->ip);
169 #ifdef CONFIG_KALLSYMS
170 print_symbol("%s\n", info->ip);
171 #else
172 if ((i & 0x03) == 0)
173 printk("\n");
174 #endif
175 i++;
176 }
177 }
178 printk("\n");
179 }
180
181 void show_stack(struct task_struct *task, unsigned long *s)
182 {
183 struct unwind_frame_info info;
184
185 if (!task) {
186 unsigned long sp;
187 struct pt_regs *r;
188
189 HERE:
190 asm volatile ("copy %%r30, %0" : "=r"(sp));
191 r = kzalloc(sizeof(struct pt_regs), GFP_KERNEL);
192 if (!r)
193 return;
194 r->iaoq[0] = (unsigned long)&&HERE;
195 r->gr[2] = (unsigned long)__builtin_return_address(0);
196 r->gr[30] = sp;
197 unwind_frame_init(&info, current, r);
198 kfree(r);
199 } else {
200 unwind_frame_init_from_blocked_task(&info, task);
201 }
202
203 do_show_stack(&info);
204 }
205
206 void die_if_kernel(char *str, struct pt_regs *regs, long err)
207 {
208 if (user_mode(regs)) {
209 if (err == 0)
210 return; /* STFU */
211
212 printk(KERN_CRIT "%s (pid %d): %s (code %ld) at " RFMT "\n",
213 current->comm, current->pid, str, err, regs->iaoq[0]);
214 #ifdef PRINT_USER_FAULTS
215 /* XXX for debugging only */
216 show_regs(regs);
217 #endif
218 return;
219 }
220
221 oops_in_progress = 1;
222
223 /* Amuse the user in a SPARC fashion */
224 printk(
225 " _______________________________ \n"
226 " < Your System ate a SPARC! Gah! >\n"
227 " ------------------------------- \n"
228 " \\ ^__^\n"
229 " \\ (xx)\\_______\n"
230 " (__)\\ )\\/\\\n"
231 " U ||----w |\n"
232 " || ||\n");
233
234 /* unlock the pdc lock if necessary */
235 pdc_emergency_unlock();
236
237 /* maybe the kernel hasn't booted very far yet and hasn't been able
238 * to initialize the serial or STI console. In that case we should
239 * re-enable the pdc console, so that the user will be able to
240 * identify the problem. */
241 if (!console_drivers)
242 pdc_console_restart();
243
244 printk(KERN_CRIT "%s (pid %d): %s (code %ld)\n",
245 current->comm, current->pid, str, err);
246 show_regs(regs);
247
248 /* Wot's wrong wif bein' racy? */
249 if (current->thread.flags & PARISC_KERNEL_DEATH) {
250 printk(KERN_CRIT "%s() recursion detected.\n", __FUNCTION__);
251 local_irq_enable();
252 while (1);
253 }
254
255 current->thread.flags |= PARISC_KERNEL_DEATH;
256 do_exit(SIGSEGV);
257 }
258
259 int syscall_ipi(int (*syscall) (struct pt_regs *), struct pt_regs *regs)
260 {
261 return syscall(regs);
262 }
263
264 /* gdb uses break 4,8 */
265 #define GDB_BREAK_INSN 0x10004
266 void handle_gdb_break(struct pt_regs *regs, int wot)
267 {
268 struct siginfo si;
269
270 si.si_code = wot;
271 si.si_addr = (void __user *) (regs->iaoq[0] & ~3);
272 si.si_signo = SIGTRAP;
273 si.si_errno = 0;
274 force_sig_info(SIGTRAP, &si, current);
275 }
276
277 void handle_break(unsigned iir, struct pt_regs *regs)
278 {
279 struct siginfo si;
280
281 switch(iir) {
282 case 0x00:
283 #ifdef PRINT_USER_FAULTS
284 printk(KERN_DEBUG "break 0,0: pid=%d command='%s'\n",
285 current->pid, current->comm);
286 #endif
287 die_if_kernel("Breakpoint", regs, 0);
288 #ifdef PRINT_USER_FAULTS
289 show_regs(regs);
290 #endif
291 si.si_code = TRAP_BRKPT;
292 si.si_addr = (void __user *) (regs->iaoq[0] & ~3);
293 si.si_signo = SIGTRAP;
294 force_sig_info(SIGTRAP, &si, current);
295 break;
296
297 case GDB_BREAK_INSN:
298 die_if_kernel("Breakpoint", regs, 0);
299 handle_gdb_break(regs, TRAP_BRKPT);
300 break;
301
302 default:
303 #ifdef PRINT_USER_FAULTS
304 printk(KERN_DEBUG "break %#08x: pid=%d command='%s'\n",
305 iir, current->pid, current->comm);
306 show_regs(regs);
307 #endif
308 si.si_signo = SIGTRAP;
309 si.si_code = TRAP_BRKPT;
310 si.si_addr = (void __user *) (regs->iaoq[0] & ~3);
311 force_sig_info(SIGTRAP, &si, current);
312 return;
313 }
314 }
315
316
317 int handle_toc(void)
318 {
319 printk(KERN_CRIT "TOC call.\n");
320 return 0;
321 }
322
323 static void default_trap(int code, struct pt_regs *regs)
324 {
325 printk(KERN_ERR "Trap %d on CPU %d\n", code, smp_processor_id());
326 show_regs(regs);
327 }
328
329 void (*cpu_lpmc) (int code, struct pt_regs *regs) = default_trap;
330
331
332 void transfer_pim_to_trap_frame(struct pt_regs *regs)
333 {
334 register int i;
335 extern unsigned int hpmc_pim_data[];
336 struct pdc_hpmc_pim_11 *pim_narrow;
337 struct pdc_hpmc_pim_20 *pim_wide;
338
339 if (boot_cpu_data.cpu_type >= pcxu) {
340
341 pim_wide = (struct pdc_hpmc_pim_20 *)hpmc_pim_data;
342
343 /*
344 * Note: The following code will probably generate a
345 * bunch of truncation error warnings from the compiler.
346 * Could be handled with an ifdef, but perhaps there
347 * is a better way.
348 */
349
350 regs->gr[0] = pim_wide->cr[22];
351
352 for (i = 1; i < 32; i++)
353 regs->gr[i] = pim_wide->gr[i];
354
355 for (i = 0; i < 32; i++)
356 regs->fr[i] = pim_wide->fr[i];
357
358 for (i = 0; i < 8; i++)
359 regs->sr[i] = pim_wide->sr[i];
360
361 regs->iasq[0] = pim_wide->cr[17];
362 regs->iasq[1] = pim_wide->iasq_back;
363 regs->iaoq[0] = pim_wide->cr[18];
364 regs->iaoq[1] = pim_wide->iaoq_back;
365
366 regs->sar = pim_wide->cr[11];
367 regs->iir = pim_wide->cr[19];
368 regs->isr = pim_wide->cr[20];
369 regs->ior = pim_wide->cr[21];
370 }
371 else {
372 pim_narrow = (struct pdc_hpmc_pim_11 *)hpmc_pim_data;
373
374 regs->gr[0] = pim_narrow->cr[22];
375
376 for (i = 1; i < 32; i++)
377 regs->gr[i] = pim_narrow->gr[i];
378
379 for (i = 0; i < 32; i++)
380 regs->fr[i] = pim_narrow->fr[i];
381
382 for (i = 0; i < 8; i++)
383 regs->sr[i] = pim_narrow->sr[i];
384
385 regs->iasq[0] = pim_narrow->cr[17];
386 regs->iasq[1] = pim_narrow->iasq_back;
387 regs->iaoq[0] = pim_narrow->cr[18];
388 regs->iaoq[1] = pim_narrow->iaoq_back;
389
390 regs->sar = pim_narrow->cr[11];
391 regs->iir = pim_narrow->cr[19];
392 regs->isr = pim_narrow->cr[20];
393 regs->ior = pim_narrow->cr[21];
394 }
395
396 /*
397 * The following fields only have meaning if we came through
398 * another path. So just zero them here.
399 */
400
401 regs->ksp = 0;
402 regs->kpc = 0;
403 regs->orig_r28 = 0;
404 }
405
406
407 /*
408 * This routine is called as a last resort when everything else
409 * has gone clearly wrong. We get called for faults in kernel space,
410 * and HPMC's.
411 */
412 void parisc_terminate(char *msg, struct pt_regs *regs, int code, unsigned long offset)
413 {
414 static DEFINE_SPINLOCK(terminate_lock);
415
416 oops_in_progress = 1;
417
418 set_eiem(0);
419 local_irq_disable();
420 spin_lock(&terminate_lock);
421
422 /* unlock the pdc lock if necessary */
423 pdc_emergency_unlock();
424
425 /* restart pdc console if necessary */
426 if (!console_drivers)
427 pdc_console_restart();
428
429 /* Not all paths will gutter the processor... */
430 switch(code){
431
432 case 1:
433 transfer_pim_to_trap_frame(regs);
434 break;
435
436 default:
437 /* Fall through */
438 break;
439
440 }
441
442 {
443 /* show_stack(NULL, (unsigned long *)regs->gr[30]); */
444 struct unwind_frame_info info;
445 unwind_frame_init(&info, current, regs);
446 do_show_stack(&info);
447 }
448
449 printk("\n");
450 printk(KERN_CRIT "%s: Code=%d regs=%p (Addr=" RFMT ")\n",
451 msg, code, regs, offset);
452 show_regs(regs);
453
454 spin_unlock(&terminate_lock);
455
456 /* put soft power button back under hardware control;
457 * if the user had pressed it once at any time, the
458 * system will shut down immediately right here. */
459 pdc_soft_power_button(0);
460
461 /* Call kernel panic() so reboot timeouts work properly
462 * FIXME: This function should be on the list of
463 * panic notifiers, and we should call panic
464 * directly from the location that we wish.
465 * e.g. We should not call panic from
466 * parisc_terminate, but rather the oter way around.
467 * This hack works, prints the panic message twice,
468 * and it enables reboot timers!
469 */
470 panic(msg);
471 }
472
473 void handle_interruption(int code, struct pt_regs *regs)
474 {
475 unsigned long fault_address = 0;
476 unsigned long fault_space = 0;
477 struct siginfo si;
478
479 if (code == 1)
480 pdc_console_restart(); /* switch back to pdc if HPMC */
481 else
482 local_irq_enable();
483
484 /* Security check:
485 * If the priority level is still user, and the
486 * faulting space is not equal to the active space
487 * then the user is attempting something in a space
488 * that does not belong to them. Kill the process.
489 *
490 * This is normally the situation when the user
491 * attempts to jump into the kernel space at the
492 * wrong offset, be it at the gateway page or a
493 * random location.
494 *
495 * We cannot normally signal the process because it
496 * could *be* on the gateway page, and processes
497 * executing on the gateway page can't have signals
498 * delivered.
499 *
500 * We merely readjust the address into the users
501 * space, at a destination address of zero, and
502 * allow processing to continue.
503 */
504 if (((unsigned long)regs->iaoq[0] & 3) &&
505 ((unsigned long)regs->iasq[0] != (unsigned long)regs->sr[7])) {
506 /* Kill the user process later */
507 regs->iaoq[0] = 0 | 3;
508 regs->iaoq[1] = regs->iaoq[0] + 4;
509 regs->iasq[0] = regs->iasq[0] = regs->sr[7];
510 regs->gr[0] &= ~PSW_B;
511 return;
512 }
513
514 #if 0
515 printk(KERN_CRIT "Interruption # %d\n", code);
516 #endif
517
518 switch(code) {
519
520 case 1:
521 /* High-priority machine check (HPMC) */
522
523 /* set up a new led state on systems shipped with a LED State panel */
524 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_HPMC);
525
526 parisc_terminate("High Priority Machine Check (HPMC)",
527 regs, code, 0);
528 /* NOT REACHED */
529
530 case 2:
531 /* Power failure interrupt */
532 printk(KERN_CRIT "Power failure interrupt !\n");
533 return;
534
535 case 3:
536 /* Recovery counter trap */
537 regs->gr[0] &= ~PSW_R;
538 if (user_space(regs))
539 handle_gdb_break(regs, TRAP_TRACE);
540 /* else this must be the start of a syscall - just let it run */
541 return;
542
543 case 5:
544 /* Low-priority machine check */
545 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_LPMC);
546
547 flush_all_caches();
548 cpu_lpmc(5, regs);
549 return;
550
551 case 6:
552 /* Instruction TLB miss fault/Instruction page fault */
553 fault_address = regs->iaoq[0];
554 fault_space = regs->iasq[0];
555 break;
556
557 case 8:
558 /* Illegal instruction trap */
559 die_if_kernel("Illegal instruction", regs, code);
560 si.si_code = ILL_ILLOPC;
561 goto give_sigill;
562
563 case 9:
564 /* Break instruction trap */
565 handle_break(regs->iir,regs);
566 return;
567
568 case 10:
569 /* Privileged operation trap */
570 die_if_kernel("Privileged operation", regs, code);
571 si.si_code = ILL_PRVOPC;
572 goto give_sigill;
573
574 case 11:
575 /* Privileged register trap */
576 if ((regs->iir & 0xffdfffe0) == 0x034008a0) {
577
578 /* This is a MFCTL cr26/cr27 to gr instruction.
579 * PCXS traps on this, so we need to emulate it.
580 */
581
582 if (regs->iir & 0x00200000)
583 regs->gr[regs->iir & 0x1f] = mfctl(27);
584 else
585 regs->gr[regs->iir & 0x1f] = mfctl(26);
586
587 regs->iaoq[0] = regs->iaoq[1];
588 regs->iaoq[1] += 4;
589 regs->iasq[0] = regs->iasq[1];
590 return;
591 }
592
593 die_if_kernel("Privileged register usage", regs, code);
594 si.si_code = ILL_PRVREG;
595 give_sigill:
596 si.si_signo = SIGILL;
597 si.si_errno = 0;
598 si.si_addr = (void __user *) regs->iaoq[0];
599 force_sig_info(SIGILL, &si, current);
600 return;
601
602 case 12:
603 /* Overflow Trap, let the userland signal handler do the cleanup */
604 si.si_signo = SIGFPE;
605 si.si_code = FPE_INTOVF;
606 si.si_addr = (void __user *) regs->iaoq[0];
607 force_sig_info(SIGFPE, &si, current);
608 return;
609
610 case 13:
611 /* Conditional Trap
612 The condition succees in an instruction which traps
613 on condition */
614 if(user_mode(regs)){
615 si.si_signo = SIGFPE;
616 /* Set to zero, and let the userspace app figure it out from
617 the insn pointed to by si_addr */
618 si.si_code = 0;
619 si.si_addr = (void __user *) regs->iaoq[0];
620 force_sig_info(SIGFPE, &si, current);
621 return;
622 }
623 /* The kernel doesn't want to handle condition codes */
624 break;
625
626 case 14:
627 /* Assist Exception Trap, i.e. floating point exception. */
628 die_if_kernel("Floating point exception", regs, 0); /* quiet */
629 handle_fpe(regs);
630 return;
631
632 case 15:
633 /* Data TLB miss fault/Data page fault */
634 /* Fall through */
635 case 16:
636 /* Non-access instruction TLB miss fault */
637 /* The instruction TLB entry needed for the target address of the FIC
638 is absent, and hardware can't find it, so we get to cleanup */
639 /* Fall through */
640 case 17:
641 /* Non-access data TLB miss fault/Non-access data page fault */
642 /* FIXME:
643 Still need to add slow path emulation code here!
644 If the insn used a non-shadow register, then the tlb
645 handlers could not have their side-effect (e.g. probe
646 writing to a target register) emulated since rfir would
647 erase the changes to said register. Instead we have to
648 setup everything, call this function we are in, and emulate
649 by hand. Technically we need to emulate:
650 fdc,fdce,pdc,"fic,4f",prober,probeir,probew, probeiw
651 */
652 fault_address = regs->ior;
653 fault_space = regs->isr;
654 break;
655
656 case 18:
657 /* PCXS only -- later cpu's split this into types 26,27 & 28 */
658 /* Check for unaligned access */
659 if (check_unaligned(regs)) {
660 handle_unaligned(regs);
661 return;
662 }
663 /* Fall Through */
664 case 26:
665 /* PCXL: Data memory access rights trap */
666 fault_address = regs->ior;
667 fault_space = regs->isr;
668 break;
669
670 case 19:
671 /* Data memory break trap */
672 regs->gr[0] |= PSW_X; /* So we can single-step over the trap */
673 /* fall thru */
674 case 21:
675 /* Page reference trap */
676 handle_gdb_break(regs, TRAP_HWBKPT);
677 return;
678
679 case 25:
680 /* Taken branch trap */
681 regs->gr[0] &= ~PSW_T;
682 if (user_space(regs))
683 handle_gdb_break(regs, TRAP_BRANCH);
684 /* else this must be the start of a syscall - just let it
685 * run.
686 */
687 return;
688
689 case 7:
690 /* Instruction access rights */
691 /* PCXL: Instruction memory protection trap */
692
693 /*
694 * This could be caused by either: 1) a process attempting
695 * to execute within a vma that does not have execute
696 * permission, or 2) an access rights violation caused by a
697 * flush only translation set up by ptep_get_and_clear().
698 * So we check the vma permissions to differentiate the two.
699 * If the vma indicates we have execute permission, then
700 * the cause is the latter one. In this case, we need to
701 * call do_page_fault() to fix the problem.
702 */
703
704 if (user_mode(regs)) {
705 struct vm_area_struct *vma;
706
707 down_read(&current->mm->mmap_sem);
708 vma = find_vma(current->mm,regs->iaoq[0]);
709 if (vma && (regs->iaoq[0] >= vma->vm_start)
710 && (vma->vm_flags & VM_EXEC)) {
711
712 fault_address = regs->iaoq[0];
713 fault_space = regs->iasq[0];
714
715 up_read(&current->mm->mmap_sem);
716 break; /* call do_page_fault() */
717 }
718 up_read(&current->mm->mmap_sem);
719 }
720 /* Fall Through */
721 case 27:
722 /* Data memory protection ID trap */
723 die_if_kernel("Protection id trap", regs, code);
724 si.si_code = SEGV_MAPERR;
725 si.si_signo = SIGSEGV;
726 si.si_errno = 0;
727 if (code == 7)
728 si.si_addr = (void __user *) regs->iaoq[0];
729 else
730 si.si_addr = (void __user *) regs->ior;
731 force_sig_info(SIGSEGV, &si, current);
732 return;
733
734 case 28:
735 /* Unaligned data reference trap */
736 handle_unaligned(regs);
737 return;
738
739 default:
740 if (user_mode(regs)) {
741 #ifdef PRINT_USER_FAULTS
742 printk(KERN_DEBUG "\nhandle_interruption() pid=%d command='%s'\n",
743 current->pid, current->comm);
744 show_regs(regs);
745 #endif
746 /* SIGBUS, for lack of a better one. */
747 si.si_signo = SIGBUS;
748 si.si_code = BUS_OBJERR;
749 si.si_errno = 0;
750 si.si_addr = (void __user *) regs->ior;
751 force_sig_info(SIGBUS, &si, current);
752 return;
753 }
754 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC);
755
756 parisc_terminate("Unexpected interruption", regs, code, 0);
757 /* NOT REACHED */
758 }
759
760 if (user_mode(regs)) {
761 if ((fault_space >> SPACEID_SHIFT) != (regs->sr[7] >> SPACEID_SHIFT)) {
762 #ifdef PRINT_USER_FAULTS
763 if (fault_space == 0)
764 printk(KERN_DEBUG "User Fault on Kernel Space ");
765 else
766 printk(KERN_DEBUG "User Fault (long pointer) (fault %d) ",
767 code);
768 printk("pid=%d command='%s'\n", current->pid, current->comm);
769 show_regs(regs);
770 #endif
771 si.si_signo = SIGSEGV;
772 si.si_errno = 0;
773 si.si_code = SEGV_MAPERR;
774 si.si_addr = (void __user *) regs->ior;
775 force_sig_info(SIGSEGV, &si, current);
776 return;
777 }
778 }
779 else {
780
781 /*
782 * The kernel should never fault on its own address space.
783 */
784
785 if (fault_space == 0)
786 {
787 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC);
788 parisc_terminate("Kernel Fault", regs, code, fault_address);
789
790 }
791 }
792
793 do_page_fault(regs, code, fault_address);
794 }
795
796
797 int __init check_ivt(void *iva)
798 {
799 int i;
800 u32 check = 0;
801 u32 *ivap;
802 u32 *hpmcp;
803 u32 length;
804 extern void os_hpmc(void);
805 extern void os_hpmc_end(void);
806
807 if (strcmp((char *)iva, "cows can fly"))
808 return -1;
809
810 ivap = (u32 *)iva;
811
812 for (i = 0; i < 8; i++)
813 *ivap++ = 0;
814
815 /* Compute Checksum for HPMC handler */
816
817 length = (u32)((unsigned long)os_hpmc_end - (unsigned long)os_hpmc);
818 ivap[7] = length;
819
820 hpmcp = (u32 *)os_hpmc;
821
822 for (i=0; i<length/4; i++)
823 check += *hpmcp++;
824
825 for (i=0; i<8; i++)
826 check += ivap[i];
827
828 ivap[5] = -check;
829
830 return 0;
831 }
832
833 #ifndef __LP64__
834 extern const void fault_vector_11;
835 #endif
836 extern const void fault_vector_20;
837
838 void __init trap_init(void)
839 {
840 void *iva;
841
842 if (boot_cpu_data.cpu_type >= pcxu)
843 iva = (void *) &fault_vector_20;
844 else
845 #ifdef __LP64__
846 panic("Can't boot 64-bit OS on PA1.1 processor!");
847 #else
848 iva = (void *) &fault_vector_11;
849 #endif
850
851 if (check_ivt(iva))
852 panic("IVT invalid");
853 }
Linux kernel - Deliverables
This page took 0.049855 seconds and 6 git commands to generate.