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