![[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] / 43BSDTahoe / sys / vax|
Return to Locore.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vax |
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.