Return to Locore.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vax

Annotation of 43BSDTahoe/sys/vax/Locore.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)Locore.c    7.4 (Berkeley) 5/26/88
        !             7:  */
        !             8: 
        !             9: #include "dz.h"
        !            10: #include "mba.h"
        !            11: #include "uba.h"
        !            12: 
        !            13: #include "pte.h"
        !            14: 
        !            15: #include "param.h"
        !            16: #include "systm.h"
        !            17: #include "dir.h"
        !            18: #include "user.h"
        !            19: #include "vm.h"
        !            20: #include "ioctl.h"
        !            21: #include "tty.h"
        !            22: #include "proc.h"
        !            23: #include "buf.h"
        !            24: #include "msgbuf.h"
        !            25: #include "mbuf.h"
        !            26: #include "protosw.h"
        !            27: #include "domain.h"
        !            28: #include "map.h"
        !            29: #include "dkbad.h"
        !            30: 
        !            31: #include "scb.h"
        !            32: #include "nexus.h"
        !            33: #include "ioa.h"
        !            34: #include "../vaxuba/ubavar.h"
        !            35: #include "../vaxuba/ubareg.h"
        !            36: 
        !            37: /*
        !            38:  * Pseudo file for lint to show what is used/defined in locore.s.
        !            39:  */
        !            40: 
        !            41: struct scb scb[1];
        !            42: int    (*UNIvec[NUBA][128])();         /* unibus vec for ubas */
        !            43: int    (*eUNIvec)();                   /* end of unibus vec */
        !            44: struct rpb rpb;
        !            45: int    dumpflag;
        !            46: int    intstack[3*NBPG];
        !            47: int    masterpaddr;            /* p_addr of current process on master cpu */
        !            48: struct user u;
        !            49: int    icode[8];
        !            50: int    szicode = sizeof (icode);
        !            51: /*
        !            52:  * Variables declared for savecore, or
        !            53:  * implicitly, such as by config or the loader.
        !            54:  */
        !            55: char   version[] = "4.3 BSD UNIX ....";
        !            56: int    etext;
        !            57: 
        !            58: doadump() { dumpsys(); }
        !            59: 
        !            60: #if NMBA > 0
        !            61: Xmba3int() { }
        !            62: Xmba2int() { }
        !            63: Xmba1int() { }
        !            64: Xmba0int() { }
        !            65: #endif
        !            66: 
        !            67: lowinit()
        !            68: {
        !            69: #if !defined(GPROF)
        !            70:        caddr_t cp;
        !            71: #endif
        !            72:        extern int dumpmag;
        !            73:        extern int rthashsize;
        !            74:        extern int arptab_size;
        !            75:        extern int dk_ndrive;
        !            76:        extern struct domain unixdomain;
        !            77: #ifdef INET
        !            78:        extern struct domain inetdomain;
        !            79: #endif
        !            80: #include "imp.h"
        !            81: #if NIMP > 0
        !            82:        extern struct domain impdomain;
        !            83: #endif
        !            84: #ifdef NS
        !            85:        extern struct domain nsdomain;
        !            86: #endif
        !            87: 
        !            88:        /* cpp messes these up for lint so put them here */
        !            89:        unixdomain.dom_next = domains;
        !            90:        domains = &unixdomain;
        !            91: #ifdef INET
        !            92:        inetdomain.dom_next = domains;
        !            93:        domains = &inetdomain;
        !            94: #endif
        !            95: #if NIMP > 0
        !            96:        impdomain.dom_next = domains;
        !            97:        domains = &impdomain;
        !            98: #endif
        !            99: #ifdef NS
        !           100:        nsdomain.dom_next = domains;
        !           101:        domains = &nsdomain;
        !           102: #endif
        !           103:        dumpmag = 0;                    /* used only by savecore */
        !           104:        rthashsize = rthashsize;        /* used by netstat, etc. */
        !           105:        arptab_size = arptab_size;      /* used by arp command */
        !           106:        dk_ndrive = dk_ndrive;          /* used by vmstat, iostat, etc. */
        !           107: 
        !           108:        /*
        !           109:         * Pseudo-uses of globals.
        !           110:         */
        !           111:        lowinit();
        !           112:        intstack[0] = intstack[1];
        !           113:        rpb = rpb;
        !           114:        scb[0] = scb[0];
        !           115:        maxmem = physmem = freemem = 0;
        !           116:        u = u;
        !           117:        fixctlrmask();
        !           118:        main(0);
        !           119:        Xustray();
        !           120: 
        !           121:        /*
        !           122:         * Routines called from interrupt vectors.
        !           123:         */
        !           124:        panic("Machine check");
        !           125:        printf("Write timeout");
        !           126:        (*UNIvec[0][0])();
        !           127:        ubaerror(0, (struct uba_hd *)0, 0, 0, (struct uba_regs *)0);
        !           128:        cnrint(0);
        !           129:        cnxint(0);
        !           130:        consdin();
        !           131:        consdout();
        !           132: #if NDZ > 0
        !           133:        dzdma();
        !           134: #endif
        !           135: #if NMBA > 0
        !           136:        mbintr(0);
        !           137: #endif
        !           138: #if VAX8200                    /* XXX wrong conditional */
        !           139:        bi_buserr(0);
        !           140: #endif
        !           141: #if VAX8200
        !           142:        rxcdintr();
        !           143:        rx50intr();
        !           144: #endif
        !           145:        hardclock((caddr_t)0, 0);
        !           146:        softclock((caddr_t)0, 0);
        !           147:        trap(0, 0, (unsigned)0, 0, 0);
        !           148:        syscall(0, 0, (unsigned)0, 0, 0);
        !           149:        rawintr();
        !           150: #ifdef INET
        !           151:        ipintr();
        !           152: #endif
        !           153: #ifdef NS
        !           154:        nsintr();
        !           155: #endif
        !           156:        machinecheck((caddr_t)0);
        !           157:        memerr();
        !           158: 
        !           159:        /*
        !           160:         * Miscellaneous routines called from configurable
        !           161:         * drivers.
        !           162:         */
        !           163:        ubapurge((struct uba_ctlr *)0);
        !           164:        ubattydma(0);
        !           165:        (void) ubamem(0, 0, 16, 1);
        !           166:        (void) isbad((struct dkbad *)0, 0, 0, 0);
        !           167:        disksort((struct buf *)0, (struct buf *)0);
        !           168:        (void) uwritec((struct uio *)0);
        !           169:        (void) todr();
        !           170:        if (vmemall((struct pte *)0, 0, (struct proc *)0, 0))
        !           171:                return;         /* use value */
        !           172:        boothowto = 0;
        !           173:        dumpflag = 0; dumpflag = dumpflag;
        !           174: #ifdef KADB
        !           175:        bootesym = 0; bootesym = bootesym;
        !           176: #endif
        !           177: #if !defined(GPROF)
        !           178:        cp = (caddr_t)&etext;
        !           179:        cp = cp;
        !           180: #endif
        !           181: }
        !           182: 
        !           183: consdin() { }
        !           184: consdout() { }
        !           185: #if NDZ > 0
        !           186: dzdma() { dzxint((struct tty *)0); }
        !           187: #endif
        !           188: 
        !           189: quad   catcher[128];
        !           190: int    cold = 1;
        !           191: 
        !           192: Xustray() { }
        !           193: 
        !           194: struct pte Sysmap[6*NPTEPG];
        !           195: #ifdef KADB
        !           196: char   Sysbase[6*NPTEPG*NBPG];
        !           197: #endif
        !           198: int    umbabeg;
        !           199: struct pte Nexmap[16][16];
        !           200: struct nexus nexus[MAXNNEXUS];
        !           201: #if VAX8600
        !           202: struct pte Ioamap[MAXNIOA][IOAMAPSIZ/NBPG];
        !           203: #endif
        !           204: struct pte UMEMmap[NUBA][512];
        !           205: char   umem[NUBA][512*NBPG];
        !           206: int    umbaend;
        !           207: struct pte Usrptmap[USRPTSIZE];
        !           208: struct pte usrpt[USRPTSIZE*NPTEPG];
        !           209: struct pte Forkmap[UPAGES];
        !           210: struct user forkutl;
        !           211: struct pte Xswapmap[UPAGES];
        !           212: struct user xswaputl;
        !           213: struct pte Xswap2map[UPAGES];
        !           214: struct user xswap2utl;
        !           215: struct pte Swapmap[UPAGES];
        !           216: struct user swaputl;
        !           217: struct pte Pushmap[UPAGES];
        !           218: struct user pushutl;
        !           219: struct pte Vfmap[UPAGES];
        !           220: struct user vfutl;
        !           221: struct pte CMAP1;
        !           222: char   CADDR1[NBPG];
        !           223: struct pte CMAP2;
        !           224: char   CADDR2[NBPG];
        !           225: struct pte mmap[1];
        !           226: char   vmmap[NBPG];
        !           227: struct pte Mbmap[NMBCLUSTERS/CLSIZE];
        !           228: struct mbuf mbutl[NMBCLUSTERS*CLBYTES/sizeof (struct mbuf)];
        !           229: struct pte msgbufmap[CLSIZE];
        !           230: struct msgbuf msgbuf;
        !           231: struct pte kmempt[200], ekmempt[1];
        !           232: #if VAX8200
        !           233: struct pte RX50map[1];
        !           234: struct pte Ka820map[1];
        !           235: #endif
        !           236: #if VAX630
        !           237: struct pte Ka630map[1];
        !           238: #endif
        !           239: char   kmembase[100*NBPG];
        !           240: #if VAX8200 || VAX630
        !           241: struct pte Clockmap[1];
        !           242: #endif
        !           243: 
        !           244: /*ARGSUSED*/
        !           245: badaddr(addr, len) caddr_t addr; int len; { return (0); }
        !           246: 
        !           247: /*ARGSUSED*/
        !           248: ovbcopy(from, to, len) caddr_t from, to; unsigned len; { }
        !           249: copyinstr(udaddr, kaddr, maxlength, lencopied)
        !           250:     caddr_t udaddr, kaddr; u_int maxlength, *lencopied;
        !           251: { *kaddr = *udaddr; *lencopied = maxlength; return (0); }
        !           252: copyoutstr(kaddr, udaddr, maxlength, lencopied)
        !           253:     caddr_t kaddr, udaddr; u_int maxlength, *lencopied;
        !           254: { *udaddr = *kaddr; *lencopied = maxlength; return (0); }
        !           255: copystr(kfaddr, kdaddr, maxlength, lencopied)
        !           256:     caddr_t kfaddr, kdaddr; u_int maxlength, *lencopied;
        !           257: { *kdaddr = *kfaddr; *lencopied = maxlength; return (0); }
        !           258: 
        !           259: /*ARGSUSED*/
        !           260: copyin(udaddr, kaddr, n) caddr_t udaddr, kaddr; u_int n; { return (0); }
        !           261: /*ARGSUSED*/
        !           262: copyout(kaddr, udaddr, n) caddr_t kaddr, udaddr; u_int n; { return (0); }
        !           263: 
        !           264: /*ARGSUSED*/
        !           265: longjmp(lp) label_t *lp; { /*NOTREACHED*/ }
        !           266: 
        !           267: /*ARGSUSED*/
        !           268: savectx(lp) label_t *lp; { return (0); }
        !           269: 
        !           270: /*ARGSUSED*/
        !           271: setrq(p) struct proc *p; { }
        !           272: 
        !           273: /*ARGSUSED*/
        !           274: remrq(p) struct proc *p; { }
        !           275: 
        !           276: swtch() { if (whichqs) whichqs = 0; if (masterpaddr) masterpaddr = 0; }
        !           277: 
        !           278: /*ARGSUSED*/
        !           279: resume(pcbpf) unsigned pcbpf; { }
        !           280: 
        !           281: /*ARGSUSED*/
        !           282: fubyte(base) caddr_t base; { return (0); }
        !           283: #ifdef notdef
        !           284: /*ARGSUSED*/
        !           285: fuibyte(base) caddr_t base; { return (0); }
        !           286: #endif
        !           287: /*ARGSUSED*/
        !           288: subyte(base, i) caddr_t base; { return (0); }
        !           289: /*ARGSUSED*/
        !           290: suibyte(base, i) caddr_t base; { return (0); }
        !           291: /*ARGSUSED*/
        !           292: fuword(base) caddr_t base; { return (0); }
        !           293: /*ARGSUSED*/
        !           294: fuiword(base) caddr_t base; { return (0); }
        !           295: /*ARGSUSED*/
        !           296: suword(base, i) caddr_t base; { return (0); }
        !           297: /*ARGSUSED*/
        !           298: suiword(base, i) caddr_t base; { return (0); }
        !           299: 
        !           300: /*ARGSUSED*/
        !           301: copyseg(udaddr, pf)
        !           302:     caddr_t udaddr; unsigned pf;
        !           303: { CMAP1 = CMAP1; CADDR1[0] = CADDR1[0]; }
        !           304: 
        !           305: /*ARGSUSED*/
        !           306: clearseg(pf) unsigned pf; { CMAP2 = CMAP2; CADDR2[0] = CADDR2[0]; }
        !           307: 
        !           308: /*ARGSUSED*/
        !           309: useracc(udaddr, bcnt, rw) caddr_t udaddr; unsigned bcnt; { return (0); }
        !           310: 
        !           311: /*ARGSUSED*/
        !           312: kernacc(addr, bcnt, rw) caddr_t addr; unsigned bcnt; { return (0); }
        !           313: 
        !           314: /*ARGSUSED*/
        !           315: addupc(pc, prof, counts) int pc; struct uprof *prof; int counts; { }
        !           316: 
        !           317: /*
        !           318:  * Routines expanded by inline.
        !           319:  */
        !           320: spl0() { }
        !           321: splsoftclock() { return (0); }
        !           322: splnet() { return (0); }
        !           323: spl4() { return (0); }
        !           324: spl5() { return (0); }
        !           325: splbio() { return (0); }
        !           326: spltty() { return (0); }
        !           327: #ifdef notdef
        !           328: spl6() { return (0); }         /* not currently used */
        !           329: #endif
        !           330: splclock() { return (0); }
        !           331: spl7() { return (0); }
        !           332: splhigh() { return (0); }
        !           333: 
        !           334: /*ARGSUSED*/
        !           335: splx(s) int s; { }
        !           336: 
        !           337: /*ARGSUSED*/
        !           338: bcopy(from, to, len) caddr_t from, to; unsigned len; { }
        !           339: /*ARGSUSED*/
        !           340: bzero(base, count) caddr_t base; unsigned count; { }
        !           341: /*ARGSUSED*/
        !           342: blkclr(base, count) caddr_t base; unsigned count; { }
        !           343: 
        !           344: /*ARGSUSED*/
        !           345: /*VARARGS1*/
        !           346: mtpr(reg, v) int reg; { }
        !           347: /*ARGSUSED*/
        !           348: mfpr(reg) int reg; { return (0); }
        !           349: 
        !           350: /*ARGSUSED*/
        !           351: setjmp(lp) label_t *lp; { return (0); }
        !           352: 
        !           353: #ifndef VAX630
        !           354: /*ARGSUSED*/
        !           355: scanc(size, cp, table, mask)
        !           356:     unsigned size; char *cp, table[]; int mask;
        !           357: { return (0); }
        !           358: #endif
        !           359: 
        !           360: /*ARGSUSED*/
        !           361: skpc(mask, size, cp) int mask; int size; char *cp; { return (0); }
        !           362: 
        !           363: #ifdef notdef
        !           364: /*ARGSUSED*/
        !           365: locc(mask, size, cp) int mask; char *cp; unsigned size; { return (0); }
        !           366: #endif
        !           367: 
        !           368: /*ARGSUSED*/
        !           369: _insque(p, q) caddr_t p, q; { }
        !           370: /*ARGSUSED*/
        !           371: _remque(p) caddr_t p; { }
        !           372: 
        !           373: /*ARGSUSED*/
        !           374: ffs(v) long v; { return (0); }
        !           375: 
        !           376: #ifdef notdef
        !           377: imin(a, b) int a, b; { return (a < b ? a : b); }
        !           378: imax(a, b) int a, b; { return (a > b ? a : b); }
        !           379: unsigned min(a, b) u_int a, b; { return (a < b ? a : b); }
        !           380: unsigned max(a, b) u_int a, b; { return (a > b ? a : b); }
        !           381: #endif
        !           382: u_short ntohs(s) u_short s; { return ((u_short)s); }
        !           383: u_short htons(s) u_short s; { return ((u_short)s); }
        !           384: u_long ntohl(l) u_long l; { return ((u_long)l); }
        !           385: u_long htonl(l) u_long l; { return ((u_long)l); }

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