![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to machdep.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 machdep.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoe |
1.1 root 1: /*
2: * Copyright (c) 1982,1987,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: * @(#)machdep.c 7.13 (Berkeley) 6/28/90
7: */
8:
9: #include "param.h"
10: #include "systm.h"
11: #include "user.h"
12: #include "kernel.h"
13: #include "map.h"
14: #include "vm.h"
15: #include "proc.h"
16: #include "buf.h"
17: #include "reboot.h"
18: #include "conf.h"
19: #include "file.h"
20: #include "text.h"
21: #include "clist.h"
22: #include "callout.h"
23: #include "cmap.h"
24: #include "malloc.h"
25: #include "mbuf.h"
26: #include "msgbuf.h"
27: #ifdef SYSVSHM
28: #include "shm.h"
29: #endif
30:
31: #include "cpu.h"
32: #include "reg.h"
33: #include "pte.h"
34: #include "psl.h"
35: #include "mem.h"
36: #include "mtpr.h"
37: #include "cp.h"
38:
39: #include "../tahoevba/vbavar.h"
40:
41: /*
42: * Declare these as initialized data so we can patch them.
43: */
44: int nswbuf = 0;
45: #ifdef NBUF
46: int nbuf = NBUF;
47: #else
48: int nbuf = 0;
49: #endif
50: #ifdef BUFPAGES
51: int bufpages = BUFPAGES;
52: #else
53: int bufpages = 0;
54: #endif
55: #include "yc.h"
56: #if NCY > 0
57: #include "../tahoevba/cyreg.h"
58: #endif
59: int msgbufmapped; /* set when safe to use msgbuf */
60: int physmem = MAXMEM; /* max supported memory, changes to actual */
61:
62: /*
63: * Machine-dependent startup code
64: */
65: startup(firstaddr)
66: int firstaddr;
67: {
68: register int unixsize;
69: register unsigned i;
70: register struct pte *pte;
71: int mapaddr, j;
72: register caddr_t v;
73: int maxbufs, base, residual;
74:
75: /*
76: * Initialize error message buffer (at end of core).
77: */
78: maxmem = physmem - btoc(sizeof (struct msgbuf));
79: pte = msgbufmap;
80: for (i = 1; i < btoc(sizeof (struct msgbuf)) + 1; i++)
81: *(int *)pte++ = PG_V | PG_KW | (physmem - i);
82: mtpr(TBIA, 1);
83: msgbufmapped = 1;
84: #ifdef KADB
85: kdb_init(); /* startup kernel debugger */
86: (void) cnopen(makedev(0, 1), 0); /* open console XXX */
87: #endif
88: /*
89: * Good {morning,afternoon,evening,night}.
90: */
91: printf(version);
92: printf("real mem = %d\n", ctob(physmem));
93:
94: /*
95: * Allocate space for system data structures.
96: * The first available real memory address is in "firstaddr".
97: * The first available kernel virtual address is in "v".
98: * As pages of kernel virtual memory are allocated, "v" is incremented.
99: * As pages of memory are allocated and cleared,
100: * "firstaddr" is incremented.
101: * An index into the kernel page table corresponding to the
102: * virtual memory address maintained in "v" is kept in "mapaddr".
103: */
104: v = (caddr_t)(0xc0000000 | (firstaddr * NBPG));
105: #define valloc(name, type, num) \
106: (name) = (type *)v; v = (caddr_t)((name)+(num))
107: #define valloclim(name, type, num, lim) \
108: (name) = (type *)v; v = (caddr_t)((lim) = ((name)+(num)))
109: #if NCY > 0
110: /*
111: * Allocate raw buffers for tapemaster controllers
112: * first, as they need buffers in the first megabyte.
113: */
114: valloc(cybuf, char, NCY * CYMAXIO);
115: #endif
116: valloclim(file, struct file, nfile, fileNFILE);
117: valloclim(proc, struct proc, nproc, procNPROC);
118: valloclim(text, struct text, ntext, textNTEXT);
119: valloc(cfree, struct cblock, nclist);
120: valloc(callout, struct callout, ncallout);
121: valloc(swapmap, struct map, nswapmap = nproc * 2);
122: valloc(argmap, struct map, ARGMAPSIZE);
123: valloc(kernelmap, struct map, nproc);
124: valloc(mbmap, struct map, nmbclusters/4);
125: valloc(kmemmap, struct map, ekmempt - kmempt);
126: valloc(kmemusage, struct kmemusage, ekmempt - kmempt);
127: #ifdef SYSVSHM
128: valloc(shmsegs, struct shmid_ds, shminfo.shmmni);
129: #endif
130:
131: /*
132: * Determine how many buffers to allocate.
133: * Use 10% of memory for the first 2 Meg, 5% of the remaining
134: * memory. Insure a minimum of 16 buffers.
135: * We allocate 1/2 as many swap buffer headers as file i/o buffers.
136: */
137: if (bufpages == 0)
138: if (physmem < (2 * 1024 * 1024))
139: bufpages = physmem / 10 / CLSIZE;
140: else
141: bufpages = ((2 * 1024 * 1024 + physmem) / 20) / CLSIZE;
142: if (nbuf == 0) {
143: nbuf = bufpages / 2;
144: if (nbuf < 16)
145: nbuf = 16;
146: }
147: if (nswbuf == 0) {
148: nswbuf = (nbuf / 2) &~ 1; /* force even */
149: if (nswbuf > 256)
150: nswbuf = 256; /* sanity */
151: }
152: valloc(swbuf, struct buf, nswbuf);
153:
154: /*
155: * Now the amount of virtual memory remaining for buffers
156: * can be calculated, estimating needs for the cmap.
157: */
158: ncmap = (maxmem*NBPG - ((int)v &~ 0xc0000000)) /
159: (CLBYTES + sizeof(struct cmap)) + 2;
160: maxbufs = ((SYSPTSIZE * NBPG) -
161: ((int)(v + ncmap * sizeof(struct cmap)) - 0xc0000000)) /
162: (MAXBSIZE + sizeof(struct buf));
163: if (maxbufs < 16)
164: panic("sys pt too small");
165: if (nbuf > maxbufs) {
166: printf("SYSPTSIZE limits number of buffers to %d\n", maxbufs);
167: nbuf = maxbufs;
168: }
169: if (bufpages > nbuf * (MAXBSIZE / CLBYTES))
170: bufpages = nbuf * (MAXBSIZE / CLBYTES);
171: valloc(buf, struct buf, nbuf);
172:
173: /*
174: * Allocate space for core map.
175: * Allow space for all of phsical memory minus the amount
176: * dedicated to the system. The amount of physical memory
177: * dedicated to the system is the total virtual memory of
178: * the system thus far, plus core map, buffer pages,
179: * and buffer headers not yet allocated.
180: * Add 2: 1 because the 0th entry is unused, 1 for rounding.
181: */
182: ncmap = (maxmem*NBPG - ((int)(v + bufpages*CLBYTES) &~ 0xc0000000)) /
183: (CLBYTES + sizeof(struct cmap)) + 2;
184: valloclim(cmap, struct cmap, ncmap, ecmap);
185:
186: /*
187: * Clear space allocated thus far, and make r/w entries
188: * for the space in the kernel map.
189: */
190: unixsize = btoc((int)v &~ 0xc0000000);
191: while (firstaddr < unixsize) {
192: *(int *)(&Sysmap[firstaddr]) = PG_V | PG_KW | firstaddr;
193: clearseg((unsigned)firstaddr);
194: firstaddr++;
195: }
196:
197: /*
198: * Now allocate buffers proper. They are different than the above
199: * in that they usually occupy more virtual memory than physical.
200: */
201: v = (caddr_t) ((int)(v + PGOFSET) &~ PGOFSET);
202: valloc(buffers, char, MAXBSIZE * nbuf);
203: base = bufpages / nbuf;
204: residual = bufpages % nbuf;
205: mapaddr = firstaddr;
206: for (i = 0; i < residual; i++) {
207: for (j = 0; j < (base + 1) * CLSIZE; j++) {
208: *(int *)(&Sysmap[mapaddr+j]) = PG_V | PG_KW | firstaddr;
209: clearseg((unsigned)firstaddr);
210: firstaddr++;
211: }
212: mapaddr += MAXBSIZE / NBPG;
213: }
214: for (i = residual; i < nbuf; i++) {
215: for (j = 0; j < base * CLSIZE; j++) {
216: *(int *)(&Sysmap[mapaddr+j]) = PG_V | PG_KW | firstaddr;
217: clearseg((unsigned)firstaddr);
218: firstaddr++;
219: }
220: mapaddr += MAXBSIZE / NBPG;
221: }
222:
223: unixsize = btoc((int)v &~ 0xc0000000);
224: if (firstaddr >= physmem - 8*UPAGES)
225: panic("no memory");
226: mtpr(TBIA, 1); /* After we just cleared it all! */
227:
228: /*
229: * Initialize callouts
230: */
231: callfree = callout;
232: for (i = 1; i < ncallout; i++)
233: callout[i-1].c_next = &callout[i];
234:
235: /*
236: * Initialize memory allocator and swap
237: * and user page table maps.
238: *
239: * THE USER PAGE TABLE MAP IS CALLED ``kernelmap''
240: * WHICH IS A VERY UNDESCRIPTIVE AND INCONSISTENT NAME.
241: */
242: meminit(firstaddr, maxmem);
243: maxmem = freemem;
244: printf("avail mem = %d\n", ctob(maxmem));
245: printf("using %d buffers containing %d bytes of memory\n",
246: nbuf, bufpages * CLBYTES);
247: rminit(kernelmap, (long)USRPTSIZE, (long)1,
248: "usrpt", nproc);
249: rminit(mbmap, (long)(nmbclusters * CLSIZE), (long)CLSIZE,
250: "mbclusters", nmbclusters/4);
251: kmeminit(); /* now safe to do malloc/free */
252: intenable = 1; /* Enable interrupts from now on */
253:
254: /*
255: * Set up CPU-specific registers, cache, etc.
256: */
257: initcpu();
258:
259: /*
260: * Set up buffers, so they can be used to read disk labels.
261: */
262: bhinit();
263: binit();
264:
265: /*
266: * Configure the system.
267: */
268: configure();
269: }
270:
271: #ifdef PGINPROF
272: /*
273: * Return the difference (in microseconds)
274: * between the current time and a previous
275: * time as represented by the arguments.
276: * If there is a pending clock interrupt
277: * which has not been serviced due to high
278: * ipl, return error code.
279: */
280: /*ARGSUSED*/
281: vmtime(otime, olbolt, oicr)
282: register int otime, olbolt, oicr;
283: {
284:
285: return (((time.tv_sec-otime)*60 + lbolt-olbolt)*16667);
286: }
287: #endif
288:
289: /*
290: * Send an interrupt to process.
291: *
292: * Stack is set up to allow sigcode stored
293: * in u. to call routine, followed by kcall
294: * to sigreturn routine below. After sigreturn
295: * resets the signal mask, the stack, and the
296: * frame pointer, it returns to the user
297: * specified pc, psl.
298: */
299: sendsig(catcher, sig, mask, code)
300: sig_t catcher;
301: int sig, mask;
302: unsigned code;
303: {
304: register struct sigcontext *scp;
305: register struct proc *p = u.u_procp;
306: register int *regs;
307: register struct sigframe {
308: int sf_signum;
309: int sf_code;
310: struct sigcontext *sf_scp;
311: sig_t sf_handler;
312: int sf_regs[6]; /* r0-r5 */
313: struct sigcontext *sf_scpcopy;
314: } *fp;
315: int oonstack;
316:
317: regs = u.u_ar0;
318: oonstack = u.u_onstack;
319: /*
320: * Allocate and validate space for the signal handler
321: * context. Note that if the stack is in P0 space, the
322: * call to grow() is a nop, and the useracc() check
323: * will fail if the process has not already allocated
324: * the space with a `brk'.
325: */
326: if (!u.u_onstack && (u.u_sigonstack & sigmask(sig))) {
327: scp = (struct sigcontext *)u.u_sigsp - 1;
328: u.u_onstack = 1;
329: } else
330: scp = (struct sigcontext *)regs[SP] - 1;
331: fp = (struct sigframe *)scp - 1;
332: if ((int)fp <= USRSTACK - ctob(u.u_ssize))
333: (void) grow((unsigned)fp);
334: if (useracc((caddr_t)fp, sizeof (*fp) + sizeof (*scp), B_WRITE) == 0) {
335: /*
336: * Process has trashed its stack; give it an illegal
337: * instruction to halt it in its tracks.
338: */
339: SIGACTION(p, SIGILL) = SIG_DFL;
340: sig = sigmask(SIGILL);
341: p->p_sigignore &= ~sig;
342: p->p_sigcatch &= ~sig;
343: p->p_sigmask &= ~sig;
344: psignal(p, SIGILL);
345: return;
346: }
347: /*
348: * Build the argument list for the signal handler.
349: */
350: fp->sf_signum = sig;
351: fp->sf_code = code;
352: fp->sf_scp = scp;
353: fp->sf_handler = catcher;
354: /*
355: * Build the callf argument frame to be used to call sigreturn.
356: */
357: fp->sf_scpcopy = scp;
358: /*
359: * Build the signal context to be used by sigreturn.
360: */
361: scp->sc_onstack = oonstack;
362: scp->sc_mask = mask;
363: scp->sc_sp = regs[SP];
364: scp->sc_fp = regs[FP];
365: scp->sc_pc = regs[PC];
366: scp->sc_ps = regs[PS];
367: regs[SP] = (int)fp;
368: regs[PC] = (int)u.u_pcb.pcb_sigc;
369: }
370:
371: /*
372: * System call to cleanup state after a signal
373: * has been taken. Reset signal mask and
374: * stack state from context left by sendsig (above).
375: * Return to previous pc and psl as specified by
376: * context left by sendsig. Check carefully to
377: * make sure that the user has not modified the
378: * psl to gain improper priviledges or to cause
379: * a machine fault.
380: */
381: /* ARGSUSED */
382: sigreturn(p, uap, retval)
383: struct proc *p;
384: struct args {
385: struct sigcontext *sigcntxp;
386: } *uap;
387: int *retval;
388: {
389: register struct sigcontext *scp;
390: register int *regs = u.u_ar0;
391:
392: scp = uap->sigcntxp;
393: if (useracc((caddr_t)scp, sizeof (*scp), 0) == 0)
394: return (EINVAL);
395: if ((scp->sc_ps & (PSL_MBZ|PSL_IPL|PSL_IS)) != 0 ||
396: (scp->sc_ps & (PSL_PRVMOD|PSL_CURMOD)) != (PSL_PRVMOD|PSL_CURMOD))
397: return (EINVAL);
398: u.u_onstack = scp->sc_onstack & 01;
399: p->p_sigmask = scp->sc_mask &~ sigcantmask;
400: regs[FP] = scp->sc_fp;
401: regs[SP] = scp->sc_sp;
402: regs[PC] = scp->sc_pc;
403: regs[PS] = scp->sc_ps;
404: return (EJUSTRETURN);
405: }
406:
407: int waittime = -1;
408:
409: boot(arghowto)
410: int arghowto;
411: {
412: register long dummy; /* r12 is reserved */
413: register int howto; /* r11 == how to boot */
414: register int devtype; /* r10 == major of root dev */
415: extern char *panicstr;
416:
417: howto = arghowto;
418: if ((howto&RB_NOSYNC) == 0 && waittime < 0 && bfreelist[0].b_forw) {
419: register struct buf *bp;
420: int iter, nbusy;
421:
422: waittime = 0;
423: (void) splnet();
424: printf("syncing disks... ");
425: /*
426: * Release vnodes held by texts before update.
427: */
428: if (panicstr == 0)
429: xumount(NULL);
430: sync();
431:
432: for (iter = 0; iter < 20; iter++) {
433: nbusy = 0;
434: for (bp = &buf[nbuf]; --bp >= buf; )
435: if ((bp->b_flags & (B_BUSY|B_INVAL)) == B_BUSY)
436: nbusy++;
437: if (nbusy == 0)
438: break;
439: printf("%d ", nbusy);
440: DELAY(40000 * iter);
441: }
442: if (nbusy)
443: printf("giving up\n");
444: else
445: printf("done\n");
446: DELAY(10000); /* wait for printf to finish */
447: }
448: mtpr(IPL, 0x1f); /* extreme priority */
449: devtype = major(rootdev);
450: *(int *)CPBFLG = howto;
451: if (howto&RB_HALT) {
452: printf("halting (in tight loop); hit ~h\n\n");
453: mtpr(IPL, 0x1f);
454: for (;;)
455: ;
456: } else {
457: if (howto & RB_DUMP) {
458: doadump(); /* CPBOOT's itsself */
459: /*NOTREACHED*/
460: }
461: tocons(CPBOOT);
462: }
463: #ifdef lint
464: dummy = 0; dummy = dummy;
465: printf("howto %d, devtype %d\n", arghowto, devtype);
466: #endif
467: for (;;)
468: asm("halt");
469: /*NOTREACHED*/
470: }
471:
472: struct cpdcb_o cpcontrol;
473:
474: /*
475: * Send the given comand ('c') to the console processor.
476: * Assumed to be one of the last things the OS does before
477: * halting or rebooting.
478: */
479: tocons(c)
480: {
481: register timeout;
482:
483: cpcontrol.cp_hdr.cp_unit = CPUNIT;
484: cpcontrol.cp_hdr.cp_comm = (char)c;
485: if (c != CPBOOT)
486: cpcontrol.cp_hdr.cp_count = 1; /* Just for sanity */
487: else {
488: cpcontrol.cp_hdr.cp_count = 4;
489: *(int *)cpcontrol.cp_buf = 0; /* r11 value for reboot */
490: }
491: timeout = 100000; /* Delay loop */
492: while (timeout-- && (cnlast->cp_unit&CPDONE) == 0)
493: uncache(&cnlast->cp_unit);
494: /* give up, force it to listen */
495: mtpr(CPMDCB, vtoph((struct proc *)0, (unsigned)&cpcontrol));
496: }
497:
498: #if CLSIZE != 1
499: /*
500: * Invalidate single all pte's in a cluster
501: */
502: tbiscl(v)
503: unsigned v;
504: {
505: register caddr_t addr; /* must be first reg var */
506: register int i;
507:
508: addr = ptob(v);
509: for (i = 0; i < CLSIZE; i++) {
510: mtpr(TBIS, addr);
511: addr += NBPG;
512: }
513: }
514: #endif
515:
516: int dumpmag = 0x8fca0101; /* magic number for savecore */
517: int dumpsize = 0; /* also for savecore */
518:
519: dumpconf()
520: {
521: int nblks;
522:
523: dumpsize = physmem;
524: if (dumpdev != NODEV && bdevsw[major(dumpdev)].d_psize) {
525: nblks = (*bdevsw[major(dumpdev)].d_psize)(dumpdev);
526: if (dumpsize > btoc(dbtob(nblks - dumplo)))
527: dumpsize = btoc(dbtob(nblks - dumplo));
528: else if (dumplo == 0)
529: dumplo = nblks - btodb(ctob(physmem));
530: }
531: /*
532: * Don't dump on the first CLSIZE pages,
533: * in case the dump device includes a disk label.
534: */
535: if (dumplo < CLSIZE)
536: dumplo = CLSIZE;
537: }
538:
539: /*
540: * Doadump comes here after turning off memory management and
541: * getting on the dump stack, either when called above, or by
542: * the auto-restart code.
543: */
544: dumpsys()
545: {
546:
547: if (dumpdev == NODEV)
548: return;
549: /*
550: * For dumps during autoconfiguration,
551: * if dump device has already configured...
552: */
553: if (dumpsize == 0)
554: dumpconf();
555: if (dumplo < 0)
556: return;
557: printf("\ndumping to dev %x, offset %d\n", dumpdev, dumplo);
558: printf("dump ");
559: switch ((*bdevsw[major(dumpdev)].d_dump)(dumpdev)) {
560:
561: case ENXIO:
562: printf("device bad\n");
563: break;
564:
565: case EFAULT:
566: printf("device not ready\n");
567: break;
568:
569: case EINVAL:
570: printf("area improper\n");
571: break;
572:
573: case EIO:
574: printf("i/o error\n");
575: break;
576:
577: default:
578: printf("succeeded\n");
579: break;
580: }
581: printf("\n\n");
582: DELAY(1000);
583: tocons(CPBOOT);
584: }
585:
586: /*
587: * Bus error 'recovery' code.
588: * Print out the buss frame and then give up.
589: * (More information from special registers can be printed here.)
590: */
591:
592: /*
593: * Frame for bus error
594: */
595: struct buserframe {
596: int which_bus; /* primary or secondary */
597: int memerreg; /* memory error register */
598: int trp_pc; /* trapped pc */
599: int trp_psl; /* trapped psl */
600: };
601:
602: char *mem_errcd[8] = {
603: "Unknown error code 0",
604: "Address parity error", /* APE */
605: "Data parity error", /* DPE */
606: "Data check error", /* DCE */
607: "Versabus timeout", /* VTO */
608: "Versabus error", /* VBE */
609: "Non-existent memory", /* NEM */
610: "Unknown error code 7",
611: };
612:
613: buserror(v)
614: caddr_t v;
615: {
616: register struct buserframe *busef = (struct buserframe *)v;
617: register long reg;
618:
619: printf("bus error, address %x, psl %x\n",
620: busef->trp_pc, busef->trp_psl);
621: reg = busef->memerreg;
622: printf("mear %x %s\n",
623: ((reg&MEAR)>>16)&0xffff, mem_errcd[reg & ERRCD]);
624: if (reg&AXE)
625: printf("adapter external error\n");
626: printf("error master: %s\n", reg&ERM ? "versabus" : "tahoe");
627: if (reg&IVV)
628: printf("illegal interrupt vector from ipl %d\n", (reg>>2)&7);
629: reg = busef->which_bus;
630: printf("mcbr %x versabus type %x\n",
631: ((reg&MCBR)>>16)&0xffff, reg & 0xffc3);
632: if ((busef->memerreg&IVV) == 0)
633: panic("buserror");
634: }
635:
636: microtime(tvp)
637: register struct timeval *tvp;
638: {
639: int s = splhigh();
640:
641: *tvp = time;
642: tvp->tv_usec += tick;
643: while (tvp->tv_usec > 1000000) {
644: tvp->tv_sec++;
645: tvp->tv_usec -= 1000000;
646: }
647: splx(s);
648: }
649:
650: initcpu()
651: {
652: register struct proc *p;
653:
654: p = &proc[0];
655: #define initkey(which, p, index) \
656: which/**/_cache[index] = 1, which/**/_cnt[index] = 1; \
657: p->p_/**/which = index;
658: initkey(ckey, p, MAXCKEY);
659: initkey(dkey, p, MAXDKEY);
660: }
661:
662: /*
663: * Clear registers on exec
664: */
665: /* ARGSUSED */
666: setregs(entry, retval)
667: u_long entry;
668: int *retval;
669: {
670:
671: #ifdef notdef
672: /* should pass args to init on the stack */
673: for (rp = &u.u_ar0[0]; rp < &u.u_ar0[16];)
674: *rp++ = 0;
675: #endif
676: u.u_ar0[FP] = 0; /* bottom of the fp chain */
677: u.u_ar0[PC] = entry + 2;
678: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.