![[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 [Research Unix] / researchv9 / sys / sun3|
Return to machdep.c CVS log | Up to [Research Unix] / researchv9 / sys / sun3 |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)machdep.c 1.1 86/02/03 Copyr 1986 Sun Micro"; ! 3: #endif lint ! 4: ! 5: /* ! 6: * Copyright (c) 1986 by Sun Microsystems, Inc. ! 7: */ ! 8: ! 9: #include "../h/param.h" ! 10: #include "../h/systm.h" ! 11: #include "../h/dir.h" ! 12: #include "../h/user.h" ! 13: #include "../h/map.h" ! 14: #include "../h/vm.h" ! 15: #include "../h/lnode.h" ! 16: #include "../h/proc.h" ! 17: #include "../h/msgbuf.h" ! 18: #include "../h/buf.h" ! 19: #include "../h/inode.h" ! 20: #include "../h/file.h" ! 21: #include "../h/text.h" ! 22: #include "../h/callout.h" ! 23: #include "../h/cmap.h" ! 24: #include "../h/reboot.h" ! 25: ! 26: #include "../machine/mbvar.h" ! 27: #include "../machine/psl.h" ! 28: #include "../machine/reg.h" ! 29: #include "../machine/clock.h" ! 30: #include "../machine/pte.h" ! 31: #include "../machine/scb.h" ! 32: #include "../machine/mmu.h" ! 33: #include "../machine/cpu.h" ! 34: #include "../machine/eeprom.h" ! 35: #include "../machine/interreg.h" ! 36: #include "../machine/memerr.h" ! 37: #include "../machine/eccreg.h" ! 38: #include "../machine/frame.h" ! 39: ! 40: /* ! 41: * Declare these as initialized data so we can patch them. ! 42: */ ! 43: int nbuf = 0; ! 44: int nswbuf = 0; ! 45: int bufpages = 0; ! 46: int physmem = 0; /* memory size in pages, patch if you want less */ ! 47: int kernprot = 1; /* write protect kernel text */ ! 48: int msgbufinit = 0; /* message buffer has been initialized, ok to printf */ ! 49: dev_t consdev = 0; ! 50: ! 51: int (*exit_vector)() = (int (*)())0; /* Where to go when halting UNIX */ ! 52: ! 53: #define TESTVAL 0xA55A /* memory test value */ ! 54: ! 55: u_char getsegmap(), pmegallocres(); ! 56: long getpgmap(); ! 57: ! 58: #ifdef SUN3_260 ! 59: /* ! 60: * Since there is no implied ordering of the memory cards, we store ! 61: * a zero terminated list of pointers to eccreg's that are active so ! 62: * that we only look at existent memory cards during softecc() handling. ! 63: */ ! 64: struct eccreg *ecc_alive[MAX_ECC+1]; ! 65: #endif SUN3_260 ! 66: ! 67: /* ! 68: * We make use of CMAPn (the pte address) ! 69: * and CADDRn (the virtual address) ! 70: * which are both temporaries defined in locore.s, ! 71: * not preserved across context switches, ! 72: * and not to be used in interrupt routines ! 73: */ ! 74: ! 75: /* ! 76: * Machine-dependent startup code ! 77: */ ! 78: startup() ! 79: { ! 80: register int unixsize, dvmapage; ! 81: register unsigned i; ! 82: register int c; ! 83: register struct pte *pte; ! 84: register caddr_t v; ! 85: u_int firstaddr; /* next free physical page number */ ! 86: extern char start[], etext[], end[], CADDR1[], Syslimit[]; ! 87: u_char oc, u_pmeg; ! 88: u_int mapaddr; ! 89: caddr_t zmemall(); ! 90: void v_handler(); ! 91: int mon_mem; ! 92: ! 93: initscb(); /* set trap vectors */ ! 94: *INTERREG |= IR_ENA_INT; /* make sure interrupts can occur */ ! 95: firstaddr = btoc((int)end - KERNELBASE) + UPAGES; ! 96: ! 97: /* ! 98: * Initialize map of allocated page map groups. ! 99: * Must be done before mapin of unallocated segments. ! 100: */ ! 101: pmeginit(); /* init list of pmeg data structures */ ! 102: ctxinit(); /* init context data structures */ ! 103: ! 104: /* ! 105: * Reserve necessary pmegs and set segment mapping. ! 106: * It is assumed here that the pmegs for low ! 107: * memory have already been duplicated for the ! 108: * segments up in the kernel virtual address space. ! 109: */ ! 110: ! 111: /* ! 112: * invalidate to start of high mapping ! 113: */ ! 114: for (i = 0; i < KERNELBASE >> SGSHIFT; i++) ! 115: setsegmap(i, (u_char)SEGINV); ! 116: ! 117: /* reserve kernel pmegs */ ! 118: for (; i < ptos(NPAGSEG - 1 + btoc(end)); i++) ! 119: pmegreserve(getsegmap(i)); ! 120: ! 121: for (; i < (MONSTART >> SGSHIFT); i++) /* invalidate to mon start */ ! 122: setsegmap(i, (u_char)SEGINV); ! 123: ! 124: for (; i < (MONEND >> SGSHIFT); i++) /* reserve monitor pmegs */ ! 125: if ((oc = getsegmap(i)) != (u_char)SEGINV) ! 126: pmegreserve(oc); ! 127: ! 128: for (; i < NSEGMAP - 1; i++) /* invalid until last seg */ ! 129: setsegmap(i, (u_char)SEGINV); ! 130: ! 131: /* ! 132: * Last segment contains the u area itself, ! 133: * the pmeg here is reserved for all contexts. ! 134: * We also reserve the invalid pmeg itself. ! 135: */ ! 136: u_pmeg = getsegmap(NSEGMAP - 1); ! 137: pmegreserve(u_pmeg); ! 138: pmegreserve((u_char)SEGINV); ! 139: ! 140: setcputype(); /* sets cpu and dvmasize variables */ ! 141: ! 142: /* ! 143: * Make sure the memory error register is ! 144: * set up to generate interrupts on error. ! 145: */ ! 146: #if defined(SUN3_160) || defined(SUN3_50) ! 147: if (cpu == CPU_SUN3_160 || cpu == CPU_SUN3_50) ! 148: MEMREG->mr_per = PER_INTENA | PER_CHECK; ! 149: #endif defined(SUN3_160) || defined(SUN3_50) ! 150: ! 151: #ifdef SUN3_260 ! 152: if (cpu == CPU_SUN3_260) { ! 153: register struct eccreg **ecc_nxt = ecc_alive; ! 154: register struct eccreg *ecc; ! 155: ! 156: /* ! 157: * Go probe for all memory cards and perform initialization. ! 158: * The address of the cards found is stashed in ecc_alive[]. ! 159: * We assume that the cards are already enabled and the ! 160: * base addresses have been set correctly by the monitor. ! 161: */ ! 162: for (ecc = ECCREG; ecc < &ECCREG[MAX_ECC]; ecc++) { ! 163: if (peekc((char *)ecc) == -1) ! 164: continue; ! 165: ecc->eccena.ena_scrub = 1; ! 166: ecc->eccena.ena_busena = 1; ! 167: *ecc_nxt++ = ecc; ! 168: } ! 169: *ecc_nxt = (struct eccreg *)0; /* terminate list */ ! 170: ! 171: MEMREG->mr_eer = EER_INTENA | EER_CE_ENA; ! 172: } ! 173: #endif SUN3_260 ! 174: ! 175: /* ! 176: * Allocate pmegs for DVMA space ! 177: */ ! 178: for (i = ptos(btop(DVMA)); i < ptos(btop(DVMA) + dvmasize); i++) { ! 179: u_char pm = pmegallocres(); ! 180: ! 181: setsegmap(i, pm); ! 182: for (v = (caddr_t)ctob(NPAGSEG * i); ! 183: v < (caddr_t)ctob(NPAGSEG * (i+1)); ! 184: v += NBPG) ! 185: setpgmap(v, (long)0); ! 186: } ! 187: ! 188: /* ! 189: * Now go through all the other contexts and set up the segment ! 190: * maps so that all segments are mapped the same. ! 191: * We have to use a PROM routine to do this since we don't want ! 192: * to switch to a new (unmapped) context to call setsegmap()! ! 193: */ ! 194: for (c = 0; c < NCONTEXT; c++) { ! 195: if (c == KCONTEXT) ! 196: continue; ! 197: ! 198: for (v = (caddr_t)0, i = 0; ! 199: v < (caddr_t)ctob(NPAGSEG * NSEGMAP); v += NBSG, i++) ! 200: (*romp->v_setcxsegmap)(c, v, getsegmap(i)); ! 201: } ! 202: ! 203: /* ! 204: * Initialize kernel page table entries. ! 205: */ ! 206: pte = &Sysmap[0]; ! 207: ! 208: /* invalid until start except scb page which is kernel writable */ ! 209: for (v = (caddr_t)KERNELBASE; v < (caddr_t)start; v += NBPG) { ! 210: if (v == (caddr_t)&scb) ! 211: *(int *)pte = PG_V | PG_KW | getpgmap(v) & PG_PFNUM; ! 212: else ! 213: *(int *)pte = 0; ! 214: setpgmap(v, *(long *)pte++); ! 215: } ! 216: ! 217: /* set up kernel text pages */ ! 218: for (; v < (caddr_t)etext; v += NBPG) { ! 219: if (kernprot) /* is kernel to be protected? */ ! 220: *(int *)pte = PG_V | PG_KR | getpgmap(v) & PG_PFNUM; ! 221: else ! 222: *(int *)pte = PG_V | PG_KW | getpgmap(v) & PG_PFNUM; ! 223: setpgmap(v, *(long *)pte++); ! 224: } ! 225: ! 226: /* set up kernel data/bss pages to be writeable */ ! 227: for (; v < (caddr_t)end; v += NBPG) { ! 228: *(int *)pte = PG_V | PG_KW | getpgmap(v) & PG_PFNUM; ! 229: setpgmap(v, *(long *)pte++); ! 230: } ! 231: ! 232: /* invalid until end of this segment */ ! 233: i = ((u_int)end + SGOFSET) & ~SGOFSET; ! 234: for (; v < (caddr_t)i; v += NBPG) ! 235: setpgmap(v, (long)0); ! 236: ! 237: /* ! 238: * Remove user access to monitor-set-up maps. ! 239: */ ! 240: for (i = MONSTART>>SGSHIFT; i < MONEND>>SGSHIFT; i++) { ! 241: if (getsegmap(i) == SEGINV) ! 242: continue; ! 243: for (v = (caddr_t)ctob(NPAGSEG * i); ! 244: v < (caddr_t)ctob(NPAGSEG * (i+1)); ! 245: v += NBPG) ! 246: setpgmap(v, (long)(((getpgmap(v) & ~PG_PROT) | PG_KW))); ! 247: } ! 248: ! 249: /* ! 250: * Invalidate any other pages in last segment ! 251: * besides the u area, EEPROM_ADDR, CLKADDR, ! 252: * MEMREG, INTERREG and MONSHORTPAGE. This sets ! 253: * up the kernel redzone below the u area. We ! 254: * get interrupt redzone for free when the kernel ! 255: * is write protected as the interrupt stack is ! 256: * the first thing in the data area. Since u ! 257: * and MONSHORTPAGE are defined as 32 bit virtual ! 258: * addresses (to get short references to work), ! 259: * we must mask to get only the 28 bits we really ! 260: * want to look at. ! 261: */ ! 262: for (v = (caddr_t)ctob(NPAGSEG * (NSEGMAP - 1)); ! 263: v < (caddr_t)ctob(NPAGSEG * NSEGMAP); v += NBPG) { ! 264: if (((u_int)v < ((u_int)&u & 0x0FFFFFFF) || ! 265: (u_int)v >= (((u_int)&u & 0x0FFFFFFF) + UPAGES*NBPG)) && ! 266: (u_int)v != ((u_int)MONSHORTPAGE & 0x0FFFFFFF) && ! 267: (u_int)v != (u_int)EEPROM_ADDR && ! 268: (u_int)v != (u_int)CLKADDR && ! 269: (u_int)v != (u_int)MEMREG && ! 270: (u_int)v != (u_int)INTERREG) ! 271: setpgmap(v, (long)0); ! 272: } ! 273: ! 274: /* ! 275: * v_memorysize is the amount of physical memory while ! 276: * v_memoryavail is the amount of usable memory in versions ! 277: * equal or greater to 1. Mon_mem is the difference which ! 278: * is the number of pages hidden by the monitor. ! 279: */ ! 280: if (romp->v_romvec_version >= 1) ! 281: mon_mem = btop(*romp->v_memorysize - *romp->v_memoryavail); ! 282: else ! 283: mon_mem = 0; ! 284: /* ! 285: * If physmem is patched to be non-zero, use it instead of ! 286: * the monitor value unless physmem is larger than the total ! 287: * amount of memory on hand. ! 288: */ ! 289: if (physmem == 0 || physmem > btop(*romp->v_memorysize)) ! 290: physmem = btop(*romp->v_memorysize); ! 291: /* ! 292: * Adjust physmem down for the pages stolen by the monitor. ! 293: */ ! 294: physmem -= mon_mem; ! 295: maxmem = physmem; ! 296: ! 297: /* ! 298: * v_vector_cmd is the handler for new monitor vector ! 299: * command in versions equal or greater to 2. ! 300: * We install v_handler() there for Unix. ! 301: */ ! 302: if (romp->v_romvec_version >= 2) ! 303: *romp->v_vector_cmd = v_handler; ! 304: ! 305: #include "bwtwo.h" ! 306: #if NBWTWO > 0 ! 307: if (physmem > btop(OBFBADDR + FBSIZE)) ! 308: fbobmemavail = 1; ! 309: else ! 310: fbobmemavail = 0; ! 311: #else ! 312: fbobmemavail = 0; ! 313: #endif ! 314: ! 315: /* ! 316: * Determine if anything lives in DVMA bus space. ! 317: * We're paranoid and go through both the 16 bit ! 318: * and 32 bit device types. ! 319: */ ! 320: disable_dvma(); ! 321: for (dvmapage = 0; dvmapage < btoc(dvmasize); dvmapage++) { ! 322: mapin(CMAP1, btop(CADDR1), (u_int)(dvmapage | PGT_VME_D16), ! 323: 1, PG_V | PG_KW); ! 324: if (poke((short *)CADDR1, TESTVAL) == 0) ! 325: break; ! 326: mapin(CMAP1, btop(CADDR1), (u_int)(dvmapage | PGT_VME_D32), ! 327: 1, PG_V | PG_KW); ! 328: if (poke((short *)CADDR1, TESTVAL) == 0) ! 329: break; ! 330: } ! 331: enable_dvma(); ! 332: ! 333: /* ! 334: * Initialize error message buffer (in low real memory before start). ! 335: * Printf's which occur prior to this will not be captured. ! 336: */ ! 337: mapin(msgbufmap, (u_int)btop(&msgbuf), ! 338: (u_int)btop((int)start - sizeof (struct msgbuf) - KERNELBASE), ! 339: (int)btoc(sizeof (struct msgbuf)), PG_V | PG_KW); ! 340: msgbufinit = 1; ! 341: ! 342: /* ! 343: * Allocate IOPB memory space just below the message ! 344: * buffer and map it to the first pages of DVMA space. ! 345: */ ! 346: maxmem -= IOPBMEM; ! 347: for (v = (caddr_t)DVMA, i = maxmem; i < maxmem + IOPBMEM; ! 348: v += NBPG, i++) { ! 349: struct pte tmp; /* scratch pte */ ! 350: ! 351: mapin(&tmp, btop(v), i, 1, PG_V | PG_KW); ! 352: } ! 353: ! 354: /* ! 355: * Good {morning,afternoon,evening,night}. ! 356: * When printing memory, use the total including ! 357: * those hidden by the monitor (mon_mem). ! 358: */ ! 359: printf(version); ! 360: ! 361: if (dvmapage < btoc(dvmasize)) { ! 362: printf("CAN'T HAVE PERIPHERALS IN RANGE 0 - %dKB\n", ! 363: ctob(dvmasize) / 1024); ! 364: panic("dvma collision"); ! 365: } ! 366: ! 367: #ifndef lint ! 368: if ((int)start - (int)ctob(btoc(sizeof (struct msgbuf))) <= (int)&scb) ! 369: panic("msgbuf too large"); ! 370: ! 371: if (sizeof (struct user) > UPAGES * NBPG) ! 372: panic("user area too large"); ! 373: #endif lint ! 374: ! 375: if ((int)Syslimit > (CSEG << SGSHIFT)) ! 376: panic("system map tables too large"); ! 377: ! 378: /* ! 379: * Determine how many buffers to allocate. ! 380: * Use 10% of memory (not counting 512K for kernel), with min of 16. ! 381: * We allocate 1/4 as many swap buffer headers as file i/o buffers. ! 382: */ ! 383: if (bufpages == 0) ! 384: bufpages = (physmem * NBPG - 512 * 1024) / 10 / CLBYTES; ! 385: if (nbuf == 0) { ! 386: nbuf = bufpages; ! 387: if (nbuf < 16) ! 388: nbuf = 16; ! 389: } ! 390: if (bufpages > nbuf * (BUFSIZE / CLBYTES)) ! 391: bufpages = nbuf * (BUFSIZE / CLBYTES); ! 392: if (nswbuf == 0) { ! 393: nswbuf = (nbuf / 4) &~ 1; /* force even */ ! 394: if (nswbuf > 32) ! 395: nswbuf = 32; /* sanity */ ! 396: } ! 397: printf("real mem = %d nbuf = %d nswbuf = %d\n", ! 398: ctob(physmem + mon_mem), nbuf, nswbuf); ! 399: ! 400: /* ! 401: * Allocate space for system data structures. ! 402: * The first available real memory address is in "firstaddr". ! 403: * The first available kernel virtual address is in "v". ! 404: * As pages of kernel virtual memory are allocated, "v" is incremented. ! 405: * "mapaddr" is the real memory address where the tables start. ! 406: * It is used when remapping the tables later. ! 407: * In order to support the frame buffer which might appear in ! 408: * the middle of contiguous memory we adjust the map address to ! 409: * start after the end of the frame buffer. Later we will adjust ! 410: * the core map to take this hole into account. The reason for ! 411: * this is to keep all the kernel tables contiguous in virtual space. ! 412: */ ! 413: if (fbobmemavail) ! 414: mapaddr = btoc(OBFBADDR + FBSIZE); ! 415: else ! 416: mapaddr = firstaddr; ! 417: v = (caddr_t)(ctob(firstaddr) + KERNELBASE); ! 418: #define valloc(name, type, num) \ ! 419: (name) = (type *)(v); (v) = (caddr_t)((name)+(num)) ! 420: #define valloclim(name, type, num, lim) \ ! 421: (name) = (type *)(v); (v) = (caddr_t)((lim) = ((name)+(num))) ! 422: valloc(swbuf, struct buf, nswbuf); ! 423: valloclim(inode, struct inode, ninode, inodeNINODE); ! 424: valloclim(file, struct file, nfile, fileNFILE); ! 425: valloclim(proc, struct proc, nproc, procNPROC); ! 426: valloclim(text, struct text, ntext, textNTEXT); ! 427: valloclim(lnodes, struct kern_lnode, maxusers, lnodesMAXUSERS); ! 428: valloc(callout, struct callout, ncallout); ! 429: valloc(swapmap, struct map, nswapmap = nproc * 2); ! 430: valloc(argmap, struct map, ARGMAPSIZE); ! 431: valloc(kernelmap, struct map, nproc); ! 432: valloc(iopbmap, struct map, IOPBMAPSIZE); ! 433: valloc(mb_hd.mh_map, struct map, DVMAMAPSIZE); ! 434: ! 435: /* ! 436: * Now allocate space for core map ! 437: * Allow space for all of physical memory minus the amount ! 438: * dedicated to the system. The amount of physical memory ! 439: * dedicated to the system is the total virtual memory of ! 440: * the system minus the space in the buffers which is not ! 441: * allocated real memory. ! 442: */ ! 443: ncmap = physmem - firstaddr; ! 444: valloclim(cmap, struct cmap, ncmap, ecmap); ! 445: unixsize = btoc((int)(ecmap+1) - KERNELBASE); ! 446: ! 447: if ((int)unixsize > SYSPTSIZE) ! 448: panic("sys pt too small"); ! 449: ! 450: /* ! 451: * Clear allocated space, and make r/w entries ! 452: * for the space in the kernel map. ! 453: */ ! 454: if (unixsize >= physmem - 8*UPAGES) ! 455: panic("no memory"); ! 456: ! 457: pte = &Sysmap[firstaddr]; ! 458: for (i = firstaddr + btop(KERNELBASE); i < btoc(v); i++) { ! 459: mapin(pte++, i, mapaddr, 1, PG_V | PG_KW); ! 460: clearseg(mapaddr++); ! 461: } ! 462: ! 463: /* ! 464: * Initialize callouts. ! 465: */ ! 466: callfree = callout; ! 467: for (i = 1; i < ncallout; i++) ! 468: callout[i-1].c_next = &callout[i]; ! 469: ! 470: /* ! 471: * Initialize memory allocator and swap ! 472: * and user page table maps. ! 473: */ ! 474: if (fbobmemavail) { ! 475: meminit((int)firstaddr, maxmem); ! 476: memialloc((int)firstaddr, (int)btop(OBFBADDR)); ! 477: memialloc((int)(1 + mapaddr), maxmem); ! 478: } else { ! 479: meminit((int)mapaddr, maxmem); ! 480: memialloc((int)mapaddr, maxmem); ! 481: } ! 482: maxmem = freemem; ! 483: printf("avail mem = %d\n", ctob(maxmem)); ! 484: rminit(kernelmap, (long)(USRPTSIZE - CLSIZE), (long)CLSIZE, ! 485: "usrpt", nproc); ! 486: rminit(iopbmap, (long)ctob(IOPBMEM), (long)DVMA, ! 487: "IOPB space", IOPBMAPSIZE); ! 488: rminit(mb_hd.mh_map, (long)(dvmasize - IOPBMEM), (long)IOPBMEM, ! 489: "DVMA map space", DVMAMAPSIZE); ! 490: ! 491: /* ! 492: * Configure the system. ! 493: */ ! 494: bootflags(); /* get the boot options */ ! 495: configure(); /* set up devices */ ! 496: if (fbobmemavail) { ! 497: /* ! 498: * Onboard frame buffer memory still ! 499: * available, put back onto the free list. ! 500: */ ! 501: memialloc((int)btop(OBFBADDR), (int)btop(OBFBADDR + FBSIZE)); ! 502: fbobmemavail = 0; ! 503: } ! 504: bufmemall(); ! 505: uinit(); /* initialize the u area */ ! 506: (void) spl0(); /* drop priority */ ! 507: } ! 508: ! 509: /* ! 510: * set up a physical address ! 511: * into users virtual address space. ! 512: */ ! 513: sysphys() ! 514: { ! 515: ! 516: if(!suser()) ! 517: return; ! 518: u.u_error = EINVAL; ! 519: } ! 520: ! 521: /* ! 522: * This system call sets the time of year clock without touching ! 523: * the software clock. It returns the previous clock value. If ! 524: * the argument is zero or the caller is not the super-user, it ! 525: * does not change the clock. ! 526: * Since the clocks are the same on the SUN, it just calls stime. ! 527: */ ! 528: settod() ! 529: { ! 530: register struct a { ! 531: long unsigned tod; ! 532: } *uap; ! 533: ! 534: u.u_r.r_time = time; ! 535: if (uap->tod != 0 && suser()) ! 536: stime(); ! 537: } ! 538: ! 539: /* ! 540: * Allocate physical memory for system buffers ! 541: * In Ethernet memory if the right board exists & ! 542: * the root device is ND & there are no block I/O DMA devices ! 543: */ ! 544: bufmemall() ! 545: { ! 546: struct pte *pte; ! 547: long a, va; ! 548: int npages; ! 549: int i, j, base, residual; ! 550: ! 551: a = rmalloc(kernelmap, (long)(nbuf*BUFSIZE/NBPG)); ! 552: if (a == 0) ! 553: panic("no vmem for buffers"); ! 554: buffers = (caddr_t)kmxtob(a); ! 555: pte = &Usrptmap[a]; ! 556: base = bufpages / nbuf; ! 557: residual = bufpages % nbuf; ! 558: for (i = 0; i < nbuf; i++) { ! 559: if (i < residual) ! 560: npages = base+1; ! 561: else ! 562: npages = base; ! 563: /* XXX - this loop only works if CLSIZE == 1 */ ! 564: for (j = 0; j < npages; j += CLSIZE) { ! 565: if (memall(pte+j, CLSIZE, &proc[0], CSYS) == 0) ! 566: panic("no mem for buffers"); ! 567: *(int *)(pte+j) |= PG_V|PG_KW; ! 568: va = (int)kmxtob(a+j); ! 569: vmaccess(pte+j, (caddr_t)va, 1); ! 570: bzero((caddr_t)va, CLBYTES); ! 571: } ! 572: pte += BUFSIZE/CLBYTES; ! 573: a += BUFSIZE/CLBYTES; ! 574: } ! 575: /* ! 576: * Double map and then unmap the last page of the last ! 577: * buffer to insure the presence of a pmeg. ! 578: * AARRRGGGHHH. Kludge away. ! 579: */ ! 580: if (base < BUFSIZE/CLBYTES) { ! 581: pte -= BUFSIZE/CLBYTES; ! 582: va = (int)kmxtob(a-1); ! 583: pte[BUFSIZE/CLBYTES - 1] = pte[0]; ! 584: vmaccess(&pte[BUFSIZE/CLBYTES - 1], (caddr_t)va, 1); ! 585: /* now unmap without disturbing the pmeg */ ! 586: *(int *)&pte[BUFSIZE/CLBYTES - 1] = 0; ! 587: setpgmap((caddr_t)va, (long)0); ! 588: } ! 589: buf = (struct buf *)zmemall(memall, nbuf * sizeof(struct buf)); ! 590: if (buf == 0) ! 591: panic("no mem for buf headers"); ! 592: } ! 593: ! 594: struct bootf { ! 595: char let; ! 596: short bit; ! 597: } bootf[] = { ! 598: 'a', RB_ASKNAME, ! 599: 's', RB_SINGLE, ! 600: 'i', RB_INITNAME, ! 601: 'h', RB_HALT, ! 602: 0, 0, ! 603: }; ! 604: char *initname = "/etc/init"; ! 605: ! 606: /* ! 607: * Parse the boot line to determine boot flags . ! 608: */ ! 609: bootflags() ! 610: { ! 611: register struct bootparam *bp = (*romp->v_bootparam); ! 612: register char *cp; ! 613: register int i; ! 614: ! 615: cp = bp->bp_argv[1]; ! 616: if (cp && *cp++ == '-') ! 617: do { ! 618: for (i = 0; bootf[i].let; i++) { ! 619: if (*cp == bootf[i].let) { ! 620: boothowto |= bootf[i].bit; ! 621: break; ! 622: } ! 623: } ! 624: cp++; ! 625: } while (bootf[i].let && *cp); ! 626: if (boothowto & RB_INITNAME) ! 627: initname = bp->bp_argv[2]; ! 628: if (boothowto & RB_HALT) ! 629: halt("bootflags"); ! 630: } ! 631: ! 632: /* ! 633: * Start the initial user process. ! 634: * The program [initname] is invoked with one argument ! 635: * containing the boot flags. ! 636: */ ! 637: icode() ! 638: { ! 639: struct execa { ! 640: char *fname; ! 641: char **argp; ! 642: char **envp; ! 643: } *ap; ! 644: char *ucp, **uap, *arg0, *arg1; ! 645: int i; ! 646: ! 647: u.u_error = 0; /* paranoid */ ! 648: /* Make a user stack (1 page) */ ! 649: expand(1, 1); ! 650: (void) swpexpand(0, 1, &u.u_dmap, &u.u_smap); ! 651: ! 652: /* Move out the boot flag argument */ ! 653: ucp = (char *)USRSTACK; ! 654: (void) subyte(--ucp, 0); /* trailing zero */ ! 655: for (i = 0; bootf[i].let; i++) { ! 656: if (boothowto & bootf[i].bit) ! 657: (void) subyte(--ucp, bootf[i].let); ! 658: } ! 659: (void) subyte(--ucp, '-'); /* leading hyphen */ ! 660: arg1 = ucp; ! 661: ! 662: /* Move out the file name (also arg 0) */ ! 663: for (i = 0; initname[i]; i++) ! 664: ; /* size the name */ ! 665: for (; i >= 0; i--) ! 666: (void) subyte(--ucp, initname[i]); ! 667: arg0 = ucp; ! 668: ! 669: /* Move out the arg pointers */ ! 670: uap = (char **) ((int)ucp & ~(NBPW-1)); ! 671: (void) suword((caddr_t)--uap, 0); /* terminator */ ! 672: (void) suword((caddr_t)--uap, (int)arg1); ! 673: (void) suword((caddr_t)--uap, (int)arg0); ! 674: ! 675: /* Point at the arguments */ ! 676: u.u_ap = u.u_arg; ! 677: ap = (struct execa *)u.u_ap; ! 678: ap->fname = arg0; ! 679: ap->argp = uap; ! 680: ap->envp = 0; ! 681: u.u_dirp = (caddr_t)u.u_arg[0]; ! 682: ! 683: /* Now let exec do the hard work */ ! 684: exece(); ! 685: if (u.u_error) { ! 686: printf("Can't invoke %s, error %d\n", initname, u.u_error); ! 687: panic("icode"); ! 688: } ! 689: } ! 690: ! 691: /* ! 692: * Set up page tables for process 0 U pages. ! 693: * This is closely related to way the code ! 694: * in locore.s sets things up. ! 695: */ ! 696: uinit() ! 697: { ! 698: register struct pte *pte; ! 699: u_int page; ! 700: register int i; ! 701: extern char end[]; ! 702: ! 703: /* ! 704: * main() will initialize proc[0].p_p0br to u.u_pcb.pcb_p0br ! 705: * and proc[0].p_szpt to 1. All we have to do is set up ! 706: * the pcb_p{0,1}{b,l}r registers in the pcb for now. ! 707: */ ! 708: ! 709: /* initialize base and length of P0 region */ ! 710: u.u_pcb.pcb_p0br = usrpt; ! 711: u.u_pcb.pcb_p0lr = 0; /* no user text/data (P0) for proc 0 */ ! 712: ! 713: /* ! 714: * initialize base and length of P1 region, ! 715: * where the length here is for invalid pages ! 716: */ ! 717: u.u_pcb.pcb_p1br = initp1br(usrpt + 1 * NPTEPG); ! 718: u.u_pcb.pcb_p1lr = P1PAGES; /* no user stack (P1) for proc 0 */ ! 719: ! 720: /* ! 721: * Doublely map the page containing the scb to contain the ! 722: * ptes whose virtual address is usrpt. Got that? ! 723: */ ! 724: page = (u_int)(getpgmap((caddr_t)&scb) & PG_PFNUM); ! 725: mapin(&Usrptmap[0], btop(usrpt), page, 1, PG_V | PG_KW); ! 726: ! 727: /* ! 728: * Now build the software page maps to map virtual U to physical U. ! 729: * These pages have already been set up using the real pages beyond ! 730: * end by locore.s. ! 731: */ ! 732: pte = usrpt + 1 * NPTEPG - UPAGES; ! 733: page = btop((int)end + (NBPG - 1) - KERNELBASE); ! 734: for (i = 0; i < UPAGES; i++) ! 735: *(int *)pte++ = PG_V | PG_KW | page++; ! 736: } ! 737: ! 738: struct sigcontext { ! 739: int sc_sp; /* sp to restore */ ! 740: int sc_pc; /* pc to retore */ ! 741: int sc_ps; /* psl to restore */ ! 742: }; ! 743: /* ! 744: * Send an interrupt to process. ! 745: * ! 746: * When using new signals user code must do a ! 747: * sys #139 to return from the signal, which ! 748: * calls sigcleanup below, which resets the ! 749: * signal mask and the notion of onsigstack, ! 750: * and returns from the signal handler. ! 751: */ ! 752: sendsig(p, sig) ! 753: int (*p)(), sig; ! 754: { ! 755: register int usp, *regs, scp; ! 756: struct nframe { ! 757: int sig; ! 758: int code; ! 759: int scp; ! 760: } frame; ! 761: struct sigcontext sc; ! 762: ! 763: #define mask(s) (1<<((s)-1)) ! 764: regs = u.u_ar0; ! 765: ! 766: usp = regs[SP]; ! 767: usp -= sizeof (struct sigcontext); ! 768: scp = usp; ! 769: usp -= sizeof (frame); ! 770: if (usp <= USRSTACK - ctob(u.u_ssize)) ! 771: (void) grow((unsigned)usp); ! 772: if (useracc((caddr_t)usp, sizeof(frame) + sizeof(sc), B_WRITE) == 0) { ! 773: /* ! 774: * Process has trashed its stack; give it an illegal ! 775: * instruction to halt it in its tracks. ! 776: */ ! 777: u.u_signal[SIGILL] = SIG_DFL; ! 778: u.u_procp->p_siga0 &= ~(1<<(SIGILL-1)); ! 779: u.u_procp->p_siga1 &= ~(1<<(SIGILL-1)); ! 780: psignal(u.u_procp, SIGILL); ! 781: } ! 782: /* ! 783: * push sigcontext structure. ! 784: */ ! 785: sc.sc_sp = regs[SP]; ! 786: sc.sc_pc = regs[PC]; ! 787: sc.sc_ps = regs[PS]; ! 788: /* ! 789: * If trace mode was on for the user process ! 790: * when we came in here, it may have been because ! 791: * of an ast-induced trace on a trap instruction, ! 792: * in which case we do not want to restore the ! 793: * trace bit in the status register later on ! 794: * in sigcleanup(). If we were to restore it ! 795: * and another ast trap had been posted, we would ! 796: * end up marking the trace trap as a user-requested ! 797: * real trace trap and send a bogus "Trace/BPT" signal. ! 798: */ ! 799: if ((sc.sc_ps & PSL_T) && (u.u_pcb.pcb_p0lr & TRACE_AST)) ! 800: sc.sc_ps &= ~PSL_T; ! 801: (void) copyout((caddr_t)&sc, (caddr_t)scp, sizeof (sc)); ! 802: /* ! 803: * push call frame. ! 804: */ ! 805: frame.sig = sig; ! 806: if (sig == SIGILL || sig == SIGFPE || sig == SIGEMT) { ! 807: frame.code = u.u_code; ! 808: u.u_code = 0; ! 809: } else ! 810: frame.code = 0; ! 811: frame.scp = scp; ! 812: (void) copyout((caddr_t)&frame, (caddr_t)usp, sizeof (frame)); ! 813: regs[SP] = usp; ! 814: regs[PC] = (int)p; ! 815: } ! 816: ! 817: /* ! 818: * Routine to cleanup state after a signal ! 819: * has been taken. Reset signal mask and ! 820: * notion of on signal stack from context ! 821: * left there by sendsig (above). Pop these ! 822: * values and perform rti. ! 823: */ ! 824: sigcleanup() ! 825: { ! 826: struct sigcontext *scp, sc; ! 827: ! 828: scp = (struct sigcontext *)fuword((caddr_t)u.u_ar0[SP] + sizeof(int)); ! 829: if ((int)scp == -1) ! 830: return; ! 831: if (copyin((caddr_t)scp, (caddr_t)&sc, sizeof (sc))) ! 832: return; ! 833: u.u_ar0[SP] = sc.sc_sp; ! 834: u.u_ar0[PC] = sc.sc_pc; ! 835: u.u_ar0[PS] = sc.sc_ps; ! 836: u.u_ar0[PS] &= ~PSL_USERCLR; ! 837: u.u_ar0[PS] |= PSL_USERSET; ! 838: u.u_eosys = REALLYRETURN; ! 839: } ! 840: #undef mask ! 841: ! 842: int waittime = -1; ! 843: ! 844: boot(arghowto) ! 845: int arghowto; ! 846: { ! 847: register int howto; ! 848: static int prevflag = 0; ! 849: register struct buf *bp; ! 850: int iter, nbusy; ! 851: int s; ! 852: ! 853: consdev = 0; ! 854: startnmi(); ! 855: howto = arghowto; ! 856: if ((howto&RB_NOSYNC)==0 && waittime < 0 && bfreelist[0].b_forw) { ! 857: waittime = 0; ! 858: update(); ! 859: printf("syncing disks... "); ! 860: while (++waittime <= 5) ! 861: sleep((caddr_t)&lbolt, PZERO); ! 862: printf("done\n"); ! 863: } ! 864: s = spl7(); /* extreme priority */ ! 865: if (howto & RB_HALT) { ! 866: halt((char *)NULL); ! 867: /* MAYBE REACHED */ ! 868: } else { ! 869: if ((howto & RB_PANIC) && prevflag == 0) { ! 870: prevflag = 1; ! 871: dumpsys(); ! 872: ! 873: } ! 874: printf("Rebooting Unix...\n"); ! 875: (*romp->v_boot_me)(howto & RB_SINGLE ? "-s" : ""); ! 876: /*NOTREACHED*/ ! 877: } ! 878: (void) splx(s); ! 879: } ! 880: ! 881: /* ! 882: * Initialize UNIX's vector table: ! 883: * Vectors are copied from protoscb unless ! 884: * they are zero; zero means preserve whatever the ! 885: * monitor put there. If the protoscb is zero, ! 886: * then the original contents are copied into ! 887: * the scb we are setting up. ! 888: */ ! 889: initscb() ! 890: { ! 891: register int *s, *p, *f; ! 892: register int n; ! 893: struct scb *orig, *getvbr(); ! 894: ! 895: orig = getvbr(); ! 896: exit_vector = orig->scb_trap[14]; ! 897: s = (int *)&scb; ! 898: p = (int *)&protoscb; ! 899: f = (int *)orig; ! 900: for (n = sizeof (struct scb)/sizeof (int); n--; s++, p++, f++) { ! 901: if (*p) ! 902: *s = *p; ! 903: else ! 904: *s = *f; ! 905: } ! 906: setvbr(&scb); ! 907: } ! 908: ! 909: /* ! 910: * Clear a segment (page (click)). ! 911: */ ! 912: clearseg(pgno) ! 913: u_int pgno; ! 914: { ! 915: extern char CADDR1[]; ! 916: ! 917: mapin(CMAP1, btop(CADDR1), pgno, 1, PG_V | PG_KW); ! 918: bzero(CADDR1, NBPG); ! 919: } ! 920: ! 921: /* ! 922: * Copy a segment (page) from a user virtual address ! 923: * to a physical page number. ! 924: */ ! 925: copyseg(vaddr, pgno) ! 926: caddr_t vaddr; ! 927: int pgno; ! 928: { ! 929: register struct pte *pte; ! 930: register int lock; ! 931: extern char CADDR1[]; ! 932: ! 933: /* ! 934: * Make sure the user's page is valid and locked. ! 935: */ ! 936: pte = vtopte(u.u_procp, btop(vaddr)); ! 937: if (lock = !pte->pg_v) { ! 938: pagein((u_int)vaddr, &u, 1); /* return it locked */ ! 939: pte = vtopte(u.u_procp, btop(vaddr)); /* pte may move */ ! 940: } ! 941: /* ! 942: * Map the destination page into kernel address space. ! 943: */ ! 944: mapin(CMAP1, btop(CADDR1), (u_int)pgno, 1, PG_V | PG_KW); ! 945: (void) copyin(vaddr, CADDR1, CLBYTES); ! 946: if (lock) ! 947: munlock(pte->pg_pfnum); ! 948: } ! 949: ! 950: /* ! 951: * Handle "physical" block transfers. ! 952: */ ! 953: physstrat(bp, strat, pri) ! 954: register struct buf *bp; ! 955: int (*strat)(); ! 956: int pri; ! 957: { ! 958: register int npte, n; ! 959: register long a; ! 960: unsigned v; ! 961: register struct pte *pte, *kpte; ! 962: struct proc *rp; ! 963: int va, s, o; ! 964: ! 965: v = btop(bp->b_un.b_addr); ! 966: o = (int)bp->b_un.b_addr & PGOFSET; ! 967: npte = btoc(bp->b_bcount + o) + 1; ! 968: while ((a = rmalloc(kernelmap, (long)npte)) == NULL) { ! 969: kmapwnt++; ! 970: sleep((caddr_t)kernelmap, PSWP+4); ! 971: } ! 972: kpte = &Usrptmap[a]; ! 973: rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc; ! 974: if ((bp->b_flags & B_PHYS) == 0) ! 975: pte = &Sysmap[btop((int)bp->b_un.b_addr - KERNELBASE)]; ! 976: else if (bp->b_flags & B_UAREA) ! 977: pte = &rp->p_addr[v]; ! 978: else if (bp->b_flags & B_PAGET) ! 979: pte = &Usrptmap[btokmx((struct pte *)bp->b_un.b_addr)]; ! 980: else ! 981: pte = vtopte(rp, v); ! 982: for (n = npte; --n != 0; kpte++, pte++) ! 983: *(int *)kpte = PG_V | PG_KW | (*(int *)pte & PG_PFNUM); ! 984: *(int *)kpte = 0; ! 985: va = (int)kmxtob(a); ! 986: vmaccess(&Usrptmap[a], (caddr_t)va, npte); ! 987: bp->b_saddr = bp->b_un.b_addr; ! 988: bp->b_un.b_addr = (caddr_t)(va | o); ! 989: bp->b_kmx = a; ! 990: bp->b_npte = npte; ! 991: (*strat)(bp); ! 992: if (bp->b_flags & B_DIRTY) ! 993: return; ! 994: s = spl6(); ! 995: while ((bp->b_flags & B_DONE) == 0) ! 996: sleep((caddr_t)bp, pri); ! 997: (void) splx(s); ! 998: bp->b_un.b_addr = bp->b_saddr; ! 999: bp->b_kmx = 0; ! 1000: bp->b_npte = 0; ! 1001: mapout(&Usrptmap[a], npte); ! 1002: rmfree(kernelmap, (long)npte, a); ! 1003: } ! 1004: ! 1005: /* ! 1006: * Halt the machine and return to the monitor ! 1007: */ ! 1008: halt(s) ! 1009: char *s; ! 1010: { ! 1011: extern struct scb *getvbr(); ! 1012: ! 1013: if (s) ! 1014: (*romp->v_printf)("(%s) ", s); ! 1015: (*romp->v_printf)("Unix Halted\n\n"); ! 1016: startnmi(); ! 1017: if (exit_vector) ! 1018: getvbr()->scb_trap[14] = exit_vector; ! 1019: asm("trap #14"); ! 1020: if (exit_vector) ! 1021: getvbr()->scb_trap[14] = protoscb.scb_trap[14]; ! 1022: stopnmi(); ! 1023: } ! 1024: ! 1025: /* ! 1026: * Print out a traceback for the caller - can be called anywhere ! 1027: * within the kernel or from the monitor by typing "g4" (for sun-2 ! 1028: * compatibility) or "w trace". This causes the monitor to call ! 1029: * the v_handler() routine which will call tracedump() for these cases. ! 1030: */ ! 1031: /*VARARGS0*/ ! 1032: tracedump(x1) ! 1033: caddr_t x1; ! 1034: { ! 1035: struct frame *fp = (struct frame *)(&x1 - 2); ! 1036: u_int tospage = btoc(fp); ! 1037: ! 1038: (*romp->v_printf)("Begin traceback...fp = %x\n", fp); ! 1039: while (btoc(fp) == tospage) { ! 1040: if (fp == fp->fr_savfp) { ! 1041: (*romp->v_printf)("FP loop at %x", fp); ! 1042: break; ! 1043: } ! 1044: (*romp->v_printf)("Called from %x, fp=%x, args=%x %x %x %x\n", ! 1045: fp->fr_savpc, fp->fr_savfp, ! 1046: fp->fr_arg[0], fp->fr_arg[1], fp->fr_arg[2], fp->fr_arg[3]); ! 1047: fp = fp->fr_savfp; ! 1048: } ! 1049: (*romp->v_printf)("End traceback...\n"); ! 1050: } ! 1051: ! 1052: /* ! 1053: * Buscheck is called by mbsetup to check to see it the requested ! 1054: * setup is a valid busmem type (i.e. VMEbus). Returns 1 if ok ! 1055: * busmem type, returns 0 if not busmem type. This routine ! 1056: * make checks and panic's if an illegal busmem type request is detected. ! 1057: */ ! 1058: buscheck(pte, npf) ! 1059: register struct pte *pte; ! 1060: register int npf; ! 1061: { ! 1062: register int i, pf; ! 1063: register int pt = *(int *)pte & PGT_MASK; ! 1064: ! 1065: if (pt == PGT_VME_D16 || pt == PGT_VME_D32) { ! 1066: pf = pte->pg_pfnum; ! 1067: if (pf < btoc(DVMASIZE)) ! 1068: panic("buscheck: busmem in DVMA range"); ! 1069: for (i = 0; i < npf; i++, pte++, pf++) { ! 1070: if ((*(int *)pte & PGT_MASK) != pt || ! 1071: pte->pg_pfnum != pf) ! 1072: panic("buscheck: request not contiguous"); ! 1073: } ! 1074: return (1); ! 1075: } ! 1076: return (0); ! 1077: } ! 1078: ! 1079: /* ! 1080: * Compute the address of an I/O device within standard address ! 1081: * ranges and return the result. This is used by DKIOCINFO ! 1082: * ioctl to get the best guess possible for the actual address ! 1083: * set on the card. ! 1084: */ ! 1085: getdevaddr(addr) ! 1086: caddr_t addr; ! 1087: { ! 1088: int off = (int)addr & PGOFSET; ! 1089: int pte = getkpgmap(addr); ! 1090: int physaddr = ((pte & PG_PFNUM) & ~PGT_MASK) * NBPG; ! 1091: ! 1092: switch (pte & PGT_MASK) { ! 1093: case PGT_VME_D16: ! 1094: case PGT_VME_D32: ! 1095: if (physaddr > VME16_BASE) { ! 1096: /* 16 bit VMEbus address */ ! 1097: physaddr -= VME16_BASE; ! 1098: } else if (physaddr > VME24_BASE) { ! 1099: /* 24 bit VMEbus address */ ! 1100: physaddr -= VME24_BASE; ! 1101: } ! 1102: /* ! 1103: * else 32 bit VMEbus address, ! 1104: * physaddr doesn't require adjustments ! 1105: */ ! 1106: break; ! 1107: ! 1108: case PGT_OBMEM: ! 1109: case PGT_OBIO: ! 1110: /* physaddr doesn't require adjustments */ ! 1111: break; ! 1112: } ! 1113: ! 1114: return (physaddr + off); ! 1115: } ! 1116: ! 1117: static int (*mon_nmi)(); /* monitor's level 7 nmi routine */ ! 1118: extern int level7(); /* Unix's level 7 nmi routine */ ! 1119: ! 1120: stopnmi() ! 1121: { ! 1122: struct scb *vbr, *getvbr(); ! 1123: ! 1124: vbr = getvbr(); ! 1125: if (vbr->scb_autovec[7 - 1] != level7) { ! 1126: #ifndef GPROF ! 1127: set_clk_mode(0, IR_ENA_CLK7); /* disable level 7 clk intr */ ! 1128: #endif !GPROF ! 1129: mon_nmi = vbr->scb_autovec[7 - 1]; /* save mon vec */ ! 1130: vbr->scb_autovec[7 - 1] = level7; /* install Unix vec */ ! 1131: } ! 1132: } ! 1133: ! 1134: startnmi() ! 1135: { ! 1136: struct scb *getvbr(); ! 1137: ! 1138: if (mon_nmi) { ! 1139: getvbr()->scb_autovec[7 - 1] = mon_nmi; /* install mon vec */ ! 1140: #ifndef GPROF ! 1141: set_clk_mode(IR_ENA_CLK7, 0); /* enable level 7 clk intr */ ! 1142: #endif !GPROF ! 1143: } ! 1144: } ! 1145: ! 1146: /* ! 1147: * Handler for monitor vector cmd - ! 1148: * For now we just implement the old "g0" and "g4" ! 1149: * commands and a printf hack. ! 1150: */ ! 1151: void ! 1152: v_handler(addr, str) ! 1153: int addr; ! 1154: char *str; ! 1155: { ! 1156: ! 1157: switch (*str) { ! 1158: case '\0': ! 1159: /* ! 1160: * No (non-hex) letter was specified on ! 1161: * command line, use only the number given ! 1162: */ ! 1163: switch (addr) { ! 1164: case 0: /* old g0 */ ! 1165: case 0xd: /* 'd'ump short hand */ ! 1166: panic("zero"); ! 1167: /*NOTREACHED*/ ! 1168: ! 1169: case 4: /* old g4 */ ! 1170: tracedump(); ! 1171: break; ! 1172: ! 1173: default: ! 1174: goto err; ! 1175: } ! 1176: break; ! 1177: ! 1178: case 'p': /* 'p'rint string command */ ! 1179: case 'P': ! 1180: (*romp->v_printf)("%s\n", (char *)addr); ! 1181: break; ! 1182: ! 1183: case '%': /* p'%'int anything a la printf */ ! 1184: (*romp->v_printf)(str, addr); ! 1185: (*romp->v_printf)("\n"); ! 1186: break; ! 1187: ! 1188: case 't': /* 't'race kernel stack */ ! 1189: case 'T': ! 1190: tracedump(); ! 1191: break; ! 1192: ! 1193: case 'u': /* d'u'mp hack ('d' look like hex) */ ! 1194: case 'U': ! 1195: if (addr == 0xd) { ! 1196: panic("zero"); ! 1197: } else ! 1198: goto err; ! 1199: break; ! 1200: ! 1201: default: ! 1202: err: ! 1203: (*romp->v_printf)("Don't understand 0x%x '%s'\n", addr, str); ! 1204: } ! 1205: } ! 1206: ! 1207: /* ! 1208: * Handle parity/ECC memory errors. XXX - use something like ! 1209: * vax to only look for soft ecc errors periodically? ! 1210: */ ! 1211: memerr() ! 1212: { ! 1213: u_char per, eer; ! 1214: char *mess = 0; ! 1215: int c; ! 1216: long pme; ! 1217: ! 1218: eer = per = MEMREG->mr_er; ! 1219: #ifdef SUN3_260 ! 1220: if (cpu == CPU_SUN3_260 && (eer & EER_ERR) == EER_CE) { ! 1221: softecc(); ! 1222: MEMREG->mr_dvma = 1; /* clear latching */ ! 1223: return; ! 1224: } ! 1225: #endif SUN3_260 ! 1226: ! 1227: /* ! 1228: * Since we are going down in flames, disable further ! 1229: * memory error interrupts to prevent confusion. ! 1230: */ ! 1231: MEMREG->mr_er &= ~ER_INTENA; ! 1232: ! 1233: #if defined(SUN3_160) || defined(SUN3_50) ! 1234: if ((cpu == CPU_SUN3_160 || cpu == CPU_SUN3_50) && ! 1235: (per & PER_ERR) != 0) { ! 1236: printf("Parity Error Register %b\n", per, PARERR_BITS); ! 1237: mess = "parity error"; ! 1238: } ! 1239: #endif defined(SUN3_160) || defined(SUN3_50) ! 1240: ! 1241: #ifdef SUN3_260 ! 1242: if ((cpu == CPU_SUN3_260) && (eer & EER_ERR) != 0) { ! 1243: printf("ECC Error Register %b\n", eer, ECCERR_BITS); ! 1244: mess = "uncorrectable ECC error"; ! 1245: } ! 1246: #endif SUN3_260 ! 1247: ! 1248: if (!mess) { ! 1249: printf("Memory Error Register %b %b\n", ! 1250: per, PARERR_BITS, eer, ECCERR_BITS); ! 1251: mess = "unknown memory error"; ! 1252: } ! 1253: ! 1254: printf("DVMA = %x, context = %x, virtual address = %x\n", ! 1255: MEMREG->mr_dvma, MEMREG->mr_ctx, MEMREG->mr_vaddr); ! 1256: ! 1257: c = getcontext(); ! 1258: setcontext((int)MEMREG->mr_ctx); ! 1259: pme = getpgmap((caddr_t)MEMREG->mr_vaddr); ! 1260: printf("pme = %x, physical address = %x\n", pme, ! 1261: ptob(((struct pte *)&pme)->pg_pfnum) + (MEMREG->mr_vaddr&PGOFSET)); ! 1262: setcontext(c); ! 1263: ! 1264: /* ! 1265: * Clear the latching by writing to the top ! 1266: * nibble of the memory address register ! 1267: */ ! 1268: MEMREG->mr_dvma = 1; ! 1269: ! 1270: panic(mess); ! 1271: /*NOTREACHED*/ ! 1272: } ! 1273: ! 1274: #ifdef SUN3_260 ! 1275: int prtsoftecc = 1; ! 1276: ! 1277: /* ! 1278: * Probe memory cards to find which one(s) had ecc error(s). ! 1279: * If prtsoftecc is non-zero, log messages regarding the failing ! 1280: * syndrome. Then clear the latching on the memory card. ! 1281: */ ! 1282: softecc() ! 1283: { ! 1284: register struct eccreg **ecc_nxt, *ecc; ! 1285: ! 1286: for (ecc_nxt = ecc_alive; *ecc_nxt != (struct eccreg *)0; ecc_nxt++) { ! 1287: ecc = *ecc_nxt; ! 1288: if (ecc->syndrome.sy_ce) { ! 1289: if (prtsoftecc) { ! 1290: printf("mem%d: soft ecc addr %x+%x=%x syn %b\n", ! 1291: ecc - ECCREG, ! 1292: (ecc->eccena.ena_addr << 22), ! 1293: (ecc->syndrome.sy_addr << 3), ! 1294: (ecc->eccena.ena_addr << 22) + ! 1295: (ecc->syndrome.sy_addr << 3), ! 1296: ecc->syndrome.sy_synd, SYNDERR_BITS); ! 1297: } ! 1298: ecc->syndrome.sy_ce = 1; /* clear latching */ ! 1299: } ! 1300: } ! 1301: } ! 1302: #endif SUN3_260
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.