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