Return to f002509 CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / gnot

Annotation of lucent/sys/src/9/gnot/f002509, revision 1.1.1.1

1.1       root        1: #include       "u.h"
                      2: #include       "../port/lib.h"
                      3: #include       "mem.h"
                      4: #include       "dat.h"
                      5: #include       "fns.h"
                      6: #include       "ureg.h"
                      7: #include       "../port/error.h"
                      8: 
                      9: #define        FORMAT(ur)      ((((ur)->vo)>>12)&0xF)
                     10: #define        OFFSET(ur)      (((ur)->vo)&0xFFF)
                     11: 
                     12: 
                     13: struct FFrame
                     14: {
                     15:        ushort  ireg0;                  /* internal register */
                     16:        ushort  ssw;                    /* special status word */
                     17:        ushort  ipsc;                   /* instr. pipe stage c */
                     18:        ushort  ipsb;                   /* instr. pipe stage b */
                     19:        ulong   addr;                   /* data cycle fault address */
                     20:        ushort  ireg1;                  /* internal register */
                     21:        ushort  ireg2;                  /* internal register */
                     22:        ulong   dob;                    /* data output buffer */
                     23:        ushort  ireg3[4];               /* more stuff */
                     24:        ulong   baddr;                  /* stage b address */
                     25:        ushort  ireg4[26];              /* more more stuff */
                     26: };
                     27: 
                     28: /*
                     29:  * SSW bits
                     30:  */
                     31: #define        RW      0x0040          /* read/write for data cycle */
                     32: #define        FC      0x8000          /* fault on stage C of instruction pipe */
                     33: #define        FB      0x4000          /* fault on stage B of instruction pipe */
                     34: #define        RC      0x2000          /* rerun flag for stage C of instruction pipe */
                     35: #define        RB      0x1000          /* rerun flag for stage B of instruction pipe */
                     36: #define        DF      0x0100          /* fault/rerun flag for data cycle */
                     37: #define        RM      0x0080          /* read-modify-write on data cycle */
                     38: #define        READ    0x0040
                     39: #define        WRITE   0x0000
                     40: #define        SIZ     0x0030          /* size code for data cycle */
                     41: #define        FC2     0x0004          /* address space for data cycle */
                     42: #define        FC1     0x0002
                     43: #define        FC0     0x0001
                     44: 
                     45: void
                     46: fault68020(Ureg *ur, FFrame *f)
                     47: {
                     48:        ulong addr, badvaddr;
                     49:        int user, read, insyscall;
                     50:        char buf[ERRLEN];
                     51: 
                     52:        if(u == 0){
                     53:                dumpregs(ur);
                     54:                panic("fault u==0 pc=%lux", ur->pc);
                     55:        }
                     56:        insyscall = u->p->insyscall;
                     57:        u->p->insyscall = 1;
                     58:        addr = 0;       /* set */
                     59:        if(f->ssw & DF)
                     60:                addr = f->addr;
                     61:        else if(FORMAT(ur) == 0xA){
                     62:                if(f->ssw & FC)
                     63:                        addr = ur->pc+2;
                     64:                else if(f->ssw & FB)
                     65:                        addr = ur->pc+4;
                     66:                else
                     67:                        panic("prefetch pagefault");
                     68:        }else if(FORMAT(ur) == 0xB){
                     69:                if(f->ssw & FC)
                     70:                        addr = f->baddr-2;
                     71:                else if(f->ssw & FB)
                     72:                        addr = f->baddr;
                     73:                else
                     74:                        panic("prefetch pagefault");
                     75:        }else
                     76:                panic("prefetch format");
                     77: 
                     78:        addr &= VAMASK;
                     79:        badvaddr = addr;
                     80:        addr &= ~(BY2PG-1);
                     81:        user = !(ur->sr&SUPER);
                     82:        if(user)
                     83:                u->dbgreg = ur;
                     84: 
                     85:        if(f->ssw & DF)
                     86:                read = (f->ssw&READ) && !(f->ssw&RM);
                     87:        else
                     88:                read = f->ssw&(FB|FC);
                     89: 
                     90: /* print("fault pc=%lux addr=%lux read %d\n", ur->pc, badvaddr, read); /**/
                     91: 
                     92:        if(fault(addr, read) < 0){
                     93:                if(user){
                     94:                        sprint(buf, "sys: trap: fault %s addr=0x%lux",
                     95:                                read? "read" : "write", badvaddr);
                     96:                        postnote(u->p, 1, buf, NDebug);
                     97:                        notify(ur);
                     98:                        return;
                     99:                }
                    100:                dumpregs(ur);
                    101:                panic("fault: 0x%lux", badvaddr);
                    102:        }
                    103:        u->p->insyscall = insyscall;
                    104: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.