Return to Locore.c CVS log

Up to [CSRG BSD Unix] / 42BSD / sys / vax

Annotation of 42BSD/sys/vax/Locore.c, revision 1.1

1.1     ! root        1: /*     Locore.c        6.1     83/08/11        */
        !             2: 
        !             3: #include "dz.h"
        !             4: #include "mba.h"
        !             5: #include "uba.h"
        !             6: 
        !             7: #include "../machine/pte.h"
        !             8: 
        !             9: #include "../h/param.h"
        !            10: #include "../h/systm.h"
        !            11: #include "../h/dir.h"
        !            12: #include "../h/user.h"
        !            13: #include "../h/vm.h"
        !            14: #include "../h/tty.h"
        !            15: #include "../h/proc.h"
        !            16: #include "../h/buf.h"
        !            17: #include "../h/msgbuf.h"
        !            18: #include "../h/mbuf.h"
        !            19: #include "../h/protosw.h"
        !            20: #include "../h/domain.h"
        !            21: 
        !            22: #include "../vax/nexus.h"
        !            23: #include "../vaxuba/ubavar.h"
        !            24: #include "../vaxuba/ubareg.h"
        !            25: 
        !            26: /*
        !            27:  * Pseudo file for lint to show what is used/defined in locore.s.
        !            28:  */
        !            29: 
        !            30: struct scb scb;
        !            31: int    (*UNIvec[128])();
        !            32: #if NUBA > 1
        !            33: int    (*UNI1vec[128])();
        !            34: #endif
        !            35: struct rpb rpb;
        !            36: int    intstack[3*128];
        !            37: 
        !            38: int    masterpaddr;            /* p_addr of current process on master cpu */
        !            39: 
        !            40: struct user u;
        !            41: 
        !            42: doadump() { dumpsys(); }
        !            43: 
        !            44: Xmba3int() { }
        !            45: Xmba2int() { }
        !            46: Xmba1int() { }
        !            47: Xmba0int() { }
        !            48: 
        !            49: lowinit()
        !            50: {
        !            51:        extern int dumpmag;
        !            52:        extern struct domain unixdomain;
        !            53: #ifdef PUP
        !            54:        extern struct domain pupdomain;
        !            55: #endif
        !            56: #ifdef INET
        !            57:        extern struct domain inetdomain;
        !            58: #endif
        !            59: #include "imp.h"
        !            60: #if NIMP > 0
        !            61:        extern struct domain impdomain;
        !            62: #endif
        !            63: 
        !            64:        /* cpp messes these up for lint so put them here */
        !            65:        unixdomain.dom_next = domains;
        !            66:        domains = &unixdomain;
        !            67: #ifdef PUP
        !            68:        pupdomain.dom_next = domains;
        !            69:        domains = &pupdomain;
        !            70: #endif
        !            71: #ifdef INET
        !            72:        inetdomain.dom_next = domains;
        !            73:        domains = &inetdomain;
        !            74: #endif
        !            75: #if NIMP > 0
        !            76:        impdomain.dom_next = domains;
        !            77:        domains = &impdomain;
        !            78: #endif
        !            79:        dumpmag = 0;                    /* used only by savecore */
        !            80: 
        !            81:        /*
        !            82:         * Pseudo-uses of globals.
        !            83:         */
        !            84:        lowinit();
        !            85:        intstack[0] = intstack[1];
        !            86:        rpb = rpb;
        !            87:        scb = scb;
        !            88:        maxmem = physmem = freemem = 0;
        !            89:        u = u;
        !            90:        fixctlrmask();
        !            91:        main(0);
        !            92:        Xustray();
        !            93: 
        !            94:        /*
        !            95:         * Routines called from interrupt vectors.
        !            96:         */
        !            97:        panic("Machine check");
        !            98:        printf("Write timeout");
        !            99:        (*UNIvec[0])();
        !           100: #if NUBA > 1
        !           101:        (*UNI1vec[0])();
        !           102: #endif
        !           103:        ubaerror(0, (struct uba_hd *)0, 0, 0, (struct uba_regs *)0);
        !           104:        cnrint(0);
        !           105:        cnxint(0);
        !           106:        consdin();
        !           107:        consdout();
        !           108: #if NDZ > 0
        !           109:        dzdma();
        !           110: #endif
        !           111: #if NMBA > 0
        !           112:        mbintr(0);
        !           113: #endif
        !           114:        hardclock((caddr_t)0, 0);
        !           115:        softclock((caddr_t)0, 0);
        !           116:        trap(0, 0, (unsigned)0, 0, 0);
        !           117:        syscall(0, 0, (unsigned)0, 0, 0);
        !           118:        ipintr();
        !           119:        rawintr();
        !           120: 
        !           121:        if (vmemall((struct pte *)0, 0, (struct proc *)0, 0))
        !           122:                return;         /* use value */
        !           123:        machinecheck((caddr_t)0);
        !           124:        memerr();
        !           125:        boothowto = 0;
        !           126: }
        !           127: 
        !           128: consdin() { }
        !           129: consdout() { }
        !           130: #if NDZ > 0
        !           131: dzdma() { dzxint((struct tty *)0); }
        !           132: #endif
        !           133: 
        !           134: int    catcher[256];
        !           135: int    cold = 1;
        !           136: 
        !           137: Xustray() { }
        !           138: 
        !           139: struct pte Sysmap[6*NPTEPG];
        !           140: char   Sysbase[6*NPTEPG*NBPG];
        !           141: int    umbabeg;
        !           142: struct pte Nexmap[16][16];
        !           143: struct nexus nexus[MAXNNEXUS];
        !           144: struct pte UMEMmap[MAXNUBA][512];
        !           145: char   umem[MAXNUBA][512*NBPG];
        !           146: int    umbaend;
        !           147: struct pte Usrptmap[USRPTSIZE];
        !           148: struct pte usrpt[USRPTSIZE*NPTEPG];
        !           149: struct pte Forkmap[UPAGES];
        !           150: struct user forkutl;
        !           151: struct pte Xswapmap[UPAGES];
        !           152: struct user xswaputl;
        !           153: struct pte Xswap2map[UPAGES];
        !           154: struct user xswap2utl;
        !           155: struct pte Swapmap[UPAGES];
        !           156: struct user swaputl;
        !           157: struct pte Pushmap[UPAGES];
        !           158: struct user pushutl;
        !           159: struct pte Vfmap[UPAGES];
        !           160: struct user vfutl;
        !           161: struct pte CMAP1;
        !           162: char   CADDR1[NBPG];
        !           163: struct pte CMAP2;
        !           164: char   CADDR2[NBPG];
        !           165: struct pte mmap[1];
        !           166: char   vmmap[NBPG];
        !           167: struct pte Mbmap[NMBCLUSTERS/CLSIZE];
        !           168: struct mbuf mbutl[NMBCLUSTERS*CLBYTES/sizeof (struct mbuf)];
        !           169: struct pte msgbufmap[CLSIZE];
        !           170: struct msgbuf msgbuf;
        !           171: struct pte camap[32];
        !           172: int    cabase;
        !           173: #ifdef unneeded
        !           174: char   caspace[32*NBPG];
        !           175: #endif
        !           176: int    calimit;
        !           177: 
        !           178: /*ARGSUSED*/
        !           179: badaddr(addr, len) caddr_t addr; int len; { return (0); }
        !           180: 
        !           181: /*ARGSUSED*/
        !           182: copyin(udaddr, kaddr, n) caddr_t udaddr, kaddr; unsigned n; { return (0); }
        !           183: 
        !           184: /*ARGSUSED*/
        !           185: copyout(kaddr, udaddr, n) caddr_t kaddr, udaddr; unsigned n; { return (0); }
        !           186: 
        !           187: /*ARGSUSED*/
        !           188: setjmp(lp) label_t *lp; { return (0); }
        !           189: 
        !           190: /*ARGSUSED*/
        !           191: longjmp(lp) label_t *lp; { /*NOTREACHED*/ }
        !           192: 
        !           193: /*ARGSUSED*/
        !           194: setrq(p) struct proc *p; { }
        !           195: 
        !           196: /*ARGSUSED*/
        !           197: remrq(p) struct proc *p; { }
        !           198: 
        !           199: swtch() { if (whichqs) whichqs = 0; if (masterpaddr) masterpaddr = 0; }
        !           200: 
        !           201: /*ARGSUSED*/
        !           202: resume(pcbpf) unsigned pcbpf; { }
        !           203: 
        !           204: /*ARGSUSED*/
        !           205: fubyte(base) caddr_t base; { return (0); }
        !           206: 
        !           207: /*ARGSUSED*/
        !           208: subyte(base, i) caddr_t base; { return (0); }
        !           209: 
        !           210: /*ARGSUSED*/
        !           211: suibyte(base, i) caddr_t base; { return (0); }
        !           212: 
        !           213: /*ARGSUSED*/
        !           214: fuword(base) caddr_t base; { return (0); }
        !           215: 
        !           216: /*ARGSUSED*/
        !           217: fuiword(base) caddr_t base; { return (0); }
        !           218: 
        !           219: /*ARGSUSED*/
        !           220: suword(base, i) caddr_t base; { return (0); }
        !           221: 
        !           222: /*ARGSUSED*/
        !           223: suiword(base, i) caddr_t base; { return (0); }
        !           224: 
        !           225: /*ARGSUSED*/
        !           226: copyseg(udaddr, pf) caddr_t udaddr; unsigned pf; {
        !           227:     CMAP1 = CMAP1; CADDR1[0] = CADDR1[0];
        !           228: }
        !           229: 
        !           230: /*ARGSUSED*/
        !           231: clearseg(pf) unsigned pf; { CMAP2 = CMAP2; CADDR2[0] = CADDR2[0]; }
        !           232: 
        !           233: /*ARGSUSED*/
        !           234: useracc(udaddr, bcnt, rw) caddr_t udaddr; unsigned bcnt; { return (0); }
        !           235: 
        !           236: /*ARGSUSED*/
        !           237: kernacc(addr, bcnt, rw) caddr_t addr; unsigned bcnt; { return (0); }
        !           238: 
        !           239: /*
        !           240:  * Routines handled by asm.sed script.
        !           241:  */
        !           242: 
        !           243: /*VARARGS1*/
        !           244: /*ARGSUSED*/
        !           245: mtpr(reg, value) int reg, value; { }
        !           246: 
        !           247: /*ARGSUSED*/
        !           248: mfpr(reg) int reg; { return (0); }
        !           249: 
        !           250: 
        !           251: spl0() { }
        !           252: spl4() { return (0); }
        !           253: spl5() { return (0); }
        !           254: spl6() { return (0); }
        !           255: spl7() { return (0); }
        !           256: 
        !           257: /*ARGSUSED*/
        !           258: splx(s) int s; { }
        !           259: 
        !           260: /*ARGSUSED*/
        !           261: bcopy(from, to, count) caddr_t from, to; unsigned count; { ; }
        !           262: 
        !           263: /*ARGSUSED*/
        !           264: bzero(base, count) caddr_t base; unsigned count; { ; }
        !           265: 
        !           266: /*ARGSUSED*/
        !           267: bcmp(s1, s2, count) caddr_t s1, s2; unsigned count; { return (0); }
        !           268: 
        !           269: /*ARGSUSED*/
        !           270: scanc(size, cp, table, mask)
        !           271: unsigned size; caddr_t cp, table; int mask; { return (0); }
        !           272: 
        !           273: /*ARGSUSED*/
        !           274: ffs(i) { return (0); }
        !           275: 
        !           276: ntohs(s) u_short s; { return ((int)s); }
        !           277: 
        !           278: htons(s) u_short s; { return ((int)s); }
        !           279: 
        !           280: /*
        !           281:  * Variables declared for savecore, or
        !           282:  * implicitly, such as by config or the loader.
        !           283:  */
        !           284: char   version[] = "4.2 BSD UNIX ....";
        !           285: char   etext;

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