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