Return to Locore.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986, 1988 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.2 (Berkeley) 5/27/88
        !             7:  */
        !             8: 
        !             9: #include "param.h"
        !            10: #include "systm.h"
        !            11: #include "dir.h"
        !            12: #include "user.h"
        !            13: #include "vm.h"
        !            14: #include "ioctl.h"
        !            15: #include "tty.h"
        !            16: #include "proc.h"
        !            17: #include "buf.h"
        !            18: #include "msgbuf.h"
        !            19: #include "mbuf.h"
        !            20: #include "protosw.h"
        !            21: #include "domain.h"
        !            22: #include "map.h"
        !            23: 
        !            24: #include "cpu.h"
        !            25: #include "mtpr.h"
        !            26: #include "trap.h"
        !            27: #include "psl.h"
        !            28: #include "pte.h"
        !            29: #include "scb.h"
        !            30: #include "cp.h"
        !            31: #include "mem.h"
        !            32: 
        !            33: #include "../tahoemath/fp.h"
        !            34: 
        !            35: /*
        !            36:  * Pseudo file for lint to show what is used/defined in locore.s.
        !            37:  */
        !            38: 
        !            39: struct scb scb;
        !            40: struct rpb rpb;
        !            41: int    dumpflag;
        !            42: int    intstack[3*NBPG];
        !            43: int    masterpaddr;            /* p_addr of current process on master cpu */
        !            44: struct user u;
        !            45: int    icode[8];
        !            46: int    szicode = sizeof (icode);
        !            47: quad   catcher[SCB_LASTIV];
        !            48: /*
        !            49:  * Variables declared for savecore, or
        !            50:  * implicitly, such as by config or the loader.
        !            51:  */
        !            52: char   version[] = "4.3 BSD UNIX ....";
        !            53: int    etext;
        !            54: 
        !            55: doadump() { dumpsys(); }
        !            56: 
        !            57: lowinit()
        !            58: {
        !            59: #if !defined(GPROF)
        !            60:        caddr_t cp;
        !            61: #endif
        !            62:        extern int dumpmag;
        !            63:        extern int rthashsize;
        !            64:        extern int arptab_size;
        !            65:        extern int dk_ndrive;
        !            66:        extern struct domain unixdomain;
        !            67: #ifdef INET
        !            68:        extern struct domain inetdomain;
        !            69: #endif
        !            70: #include "imp.h"
        !            71: #if NIMP > 0
        !            72:        extern struct domain impdomain;
        !            73: #endif
        !            74: #ifdef NS
        !            75:        extern struct domain nsdomain;
        !            76: #endif
        !            77: 
        !            78:        /* cpp messes these up for lint so put them here */
        !            79:        unixdomain.dom_next = domains;
        !            80:        domains = &unixdomain;
        !            81: #ifdef INET
        !            82:        inetdomain.dom_next = domains;
        !            83:        domains = &inetdomain;
        !            84: #endif
        !            85: #if NIMP > 0
        !            86:        impdomain.dom_next = domains;
        !            87:        domains = &impdomain;
        !            88: #endif
        !            89: #ifdef NS
        !            90:        nsdomain.dom_next = domains;
        !            91:        domains = &nsdomain;
        !            92: #endif
        !            93:        dumpmag = 0;                    /* used only by savecore */
        !            94:        rthashsize = rthashsize;        /* used by netstat, etc. */
        !            95:        arptab_size = arptab_size;      /* used by arp command */
        !            96:        dk_ndrive = dk_ndrive;          /* used by vmstat, iostat, etc. */
        !            97: 
        !            98:        /*
        !            99:         * Pseudo-uses of globals.
        !           100:         */
        !           101:        lowinit();
        !           102:        intstack[0] = intstack[1];
        !           103:        rpb = rpb;
        !           104:        scb = scb;
        !           105:        maxmem = physmem = freemem = 0;
        !           106:        u = u;
        !           107:        fixctlrmask();
        !           108:        main(0);
        !           109: 
        !           110:        /*
        !           111:         * Routines called from interrupt vectors.
        !           112:         */
        !           113:        buserror((caddr_t)0);
        !           114:        panic("Machine check");
        !           115:        printf("Write timeout");
        !           116:        rawintr();
        !           117: #ifdef INET
        !           118:        ipintr();
        !           119: #endif
        !           120: #ifdef NS
        !           121:        nsintr();
        !           122: #endif
        !           123:        cnrint(0);
        !           124:        cnxint(0);
        !           125:        hardclock((caddr_t)0, 0);
        !           126:        softclock((caddr_t)0, 0);
        !           127:        fpemulate(0, 0, 0, 0, 0, 0, 0, 0, 0);
        !           128:        trap(0, 0, 0, 0, 0, 0, (unsigned)0, 0, 0);
        !           129:        syscall(0, 0, 0, 0, 0, 0, (unsigned)0, 0, 0);
        !           130: 
        !           131:        if (vmemall((struct pte *)0, 0, (struct proc *)0, 0))
        !           132:                return;         /* use value */
        !           133:        boothowto = 0;
        !           134:        if (rmget((struct map *)0, 0, 0) == 0)
        !           135:                return;
        !           136:        dumpflag = 0; dumpflag = dumpflag;
        !           137: #ifdef KADB
        !           138:        bootesym = 0; bootesym = bootesym;
        !           139: #endif
        !           140: #if !defined(GPROF)
        !           141:        cp = (caddr_t)&etext;
        !           142:        cp = cp;
        !           143: #endif
        !           144: }
        !           145: 
        !           146: struct pte Sysmap[6*NPTEPG];
        !           147: caddr_t        Sysbase;
        !           148: struct pte VMEMmap[1];
        !           149: caddr_t        vmem, vmembeg, vmemend;
        !           150: struct pte VMEMmap1[1];
        !           151: caddr_t        vmem1;
        !           152: struct pte VBmap[1];
        !           153: caddr_t        vbbase, vbend;
        !           154: struct pte Usrptmap[USRPTSIZE];
        !           155: struct pte usrpt[USRPTSIZE*NPTEPG];
        !           156: struct pte Forkmap[UPAGES];
        !           157: struct user forkutl;
        !           158: struct pte Xswapmap[UPAGES];
        !           159: struct user xswaputl;
        !           160: struct pte Xswap2map[UPAGES];
        !           161: struct user xswap2utl;
        !           162: struct pte Swapmap[UPAGES];
        !           163: struct user swaputl;
        !           164: struct pte Pushmap[UPAGES];
        !           165: struct user pushutl;
        !           166: struct pte Vfmap[UPAGES];
        !           167: struct user vfutl;
        !           168: struct pte CMAP1[1], CMAP2[1];
        !           169: caddr_t        CADDR1, CADDR2;
        !           170: struct pte mmap[1];
        !           171: char   vmmap[1];
        !           172: struct pte msgbufmap[3*NBPG];
        !           173: struct msgbuf msgbuf;
        !           174: struct pte kmempt[100], ekmempt[1];
        !           175: char   kmembase[100*NBPG];
        !           176: struct pte Mbmap[NMBCLUSTERS/CLSIZE];
        !           177: struct mbuf mbutl[NMBCLUSTERS*CLBYTES/sizeof (struct mbuf)];
        !           178: 
        !           179: /*ARGSUSED*/
        !           180: badaddr(addr, len) caddr_t addr; int len; { return (0); }
        !           181: /*ARGSUSED*/
        !           182: ovbcopy(from, to, len) caddr_t from, to; unsigned len; { }
        !           183: copyinstr(udaddr, kaddr, maxlength, lencopied)
        !           184:     caddr_t udaddr, kaddr; u_int maxlength, *lencopied;
        !           185: { *kaddr = *udaddr; *lencopied = maxlength; return (0); }
        !           186: copyoutstr(kaddr, udaddr, maxlength, lencopied)
        !           187:     caddr_t kaddr, udaddr; u_int maxlength, *lencopied;
        !           188: { *kaddr = *udaddr; *lencopied = maxlength; return (0); }
        !           189: copystr(kfaddr, kdaddr, maxlength, lencopied)
        !           190:     caddr_t kfaddr, kdaddr; u_int maxlength, *lencopied;
        !           191: { *kdaddr = *kfaddr; *lencopied = maxlength; return (0); }
        !           192: /*ARGSUSED*/
        !           193: copyin(udaddr, kaddr, n) caddr_t udaddr, kaddr; u_int n; { return (0); }
        !           194: /*ARGSUSED*/
        !           195: copyout(kaddr, udaddr, n) caddr_t kaddr, udaddr; u_int n; { return (0); }
        !           196: 
        !           197: /*ARGSUSED*/
        !           198: longjmp(lp) label_t *lp; { /*NOTREACHED*/ }
        !           199: 
        !           200: /*ARGSUSED*/
        !           201: savectx(lp) label_t *lp; { return (0); }
        !           202: 
        !           203: /*ARGSUSED*/
        !           204: setrq(p) struct proc *p; { }
        !           205: 
        !           206: /*ARGSUSED*/
        !           207: remrq(p) struct proc *p; { }
        !           208: 
        !           209: swtch() { if (whichqs) whichqs = 0; if (masterpaddr) masterpaddr = 0; }
        !           210: 
        !           211: /*ARGSUSED*/
        !           212: resume(pcbpf) unsigned pcbpf; { }
        !           213: 
        !           214: /*ARGSUSED*/
        !           215: fubyte(base) caddr_t base; { return (0); }
        !           216: /*ARGSUSED*/
        !           217: subyte(base, i) caddr_t base; { return (0); }
        !           218: /*ARGSUSED*/
        !           219: fuword(base) caddr_t base; { return (0); }
        !           220: /*ARGSUSED*/
        !           221: suword(base, i) caddr_t base; { return (0); }
        !           222: 
        !           223: /*ARGSUSED*/
        !           224: copyseg(udaddr, pf)
        !           225:     caddr_t udaddr; unsigned pf;
        !           226: { CMAP1[0] = CMAP1[0]; CADDR1[0] = CADDR1[0]; }
        !           227: 
        !           228: /*ARGSUSED*/
        !           229: clearseg(pf) unsigned pf; { CMAP2[0] = CMAP2[0]; CADDR2[0] = CADDR2[0]; }
        !           230: 
        !           231: /*ARGSUSED*/
        !           232: useracc(udaddr, bcnt, rw) caddr_t udaddr; unsigned bcnt; { return (0); }
        !           233: 
        !           234: /*ARGSUSED*/
        !           235: kernacc(addr, bcnt, rw) caddr_t addr; unsigned bcnt; { return (0); }
        !           236: 
        !           237: /*ARGSUSED*/
        !           238: addupc(pc, prof, counts) int pc; struct uprof *prof; int counts; { }
        !           239: 
        !           240: /*ARGSUSED*/
        !           241: scanc(size, cp, table, mask)
        !           242:     unsigned size; u_char *cp, table[]; u_char mask;
        !           243: { return (0); }
        !           244: 
        !           245: /*ARGSUSED*/
        !           246: skpc(mask, size, cp) int mask; int size; char *cp; { return (0); }
        !           247: 
        !           248: #ifdef notdef
        !           249: /*ARGSUSED*/
        !           250: locc(mask, size, cp) int mask; int size; char *cp; { return (0); }
        !           251: #endif
        !           252: 
        !           253: /*
        !           254:  * Routines expanded by inline.
        !           255:  */
        !           256: #ifdef notdef
        !           257: fuibyte(base) caddr_t base; { return (fubyte(base)); }
        !           258: #endif
        !           259: fuiword(base) caddr_t base; { return (fuword(base)); }
        !           260: suibyte(base, i) caddr_t base; { return (subyte(base, i)); }
        !           261: suiword(base, i) caddr_t base; { return (suword(base, i)); }
        !           262: 
        !           263: /*ARGSUSED*/
        !           264: setjmp(lp) label_t *lp; { return (0); }
        !           265: 
        !           266: /*ARGSUSED*/
        !           267: _insque(p, q) caddr_t p, q; { }
        !           268: /*ARGSUSED*/
        !           269: _remque(p) caddr_t p; { }
        !           270: 
        !           271: /*ARGSUSED*/
        !           272: bcopy(from, to, len) caddr_t from, to; unsigned len; { }
        !           273: /*ARGSUSED*/
        !           274: bzero(base, count) caddr_t base; unsigned count; { }
        !           275: /*ARGSUSED*/
        !           276: blkclr(base, count) caddr_t base; unsigned count; { }
        !           277: 
        !           278: /*ARGSUSED*/
        !           279: /*VARARGS1*/
        !           280: mtpr(reg, v) int reg; { }
        !           281: /*ARGSUSED*/
        !           282: mfpr(reg) int reg; { return (0); }
        !           283: 
        !           284: /*ARGSUSED*/
        !           285: _movow(dst, v) u_short *dst, v; { }
        !           286: /*ARGSUSED*/
        !           287: _movob(dst, v) u_char *dst, v; { }
        !           288: 
        !           289: /*ARGSUSED*/
        !           290: ffs(v) long v; { return (0); }
        !           291: 
        !           292: imin(a, b) int a, b; { return (a < b ? a : b); }
        !           293: imax(a, b) int a, b; { return (a > b ? a : b); }
        !           294: #ifdef notdef
        !           295: unsigned min(a, b) u_int a, b; { return (a < b ? a : b); }
        !           296: unsigned max(a, b) u_int a, b; { return (a > b ? a : b); }
        !           297: #endif

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