Annotation of sys/arch/hp300/hp300/machdep.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: machdep.c,v 1.115 2007/06/06 17:15:11 deraadt Exp $ */
2: /* $NetBSD: machdep.c,v 1.121 1999/03/26 23:41:29 mycroft Exp $ */
3:
4: /*
5: * Copyright (c) 1988 University of Utah.
6: * Copyright (c) 1982, 1986, 1990, 1993
7: * The Regents of the University of California. All rights reserved.
8: *
9: * This code is derived from software contributed to Berkeley by
10: * the Systems Programming Group of the University of Utah Computer
11: * Science Department.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. Neither the name of the University nor the names of its contributors
22: * may be used to endorse or promote products derived from this software
23: * without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35: * SUCH DAMAGE.
36: *
37: * from: Utah $Hdr: machdep.c 1.74 92/12/20$
38: *
39: * @(#)machdep.c 8.10 (Berkeley) 4/20/94
40: */
41:
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/buf.h>
45: #include <sys/timeout.h>
46: #include <sys/conf.h>
47: #include <sys/exec.h>
48: #include <sys/file.h>
49: #include <sys/ioctl.h>
50: #include <sys/kernel.h>
51: #include <sys/device.h>
52: #include <sys/malloc.h>
53: #include <sys/extent.h>
54: #include <sys/mbuf.h>
55: #include <sys/mount.h>
56: #include <sys/msgbuf.h>
57: #include <sys/proc.h>
58: #include <sys/reboot.h>
59: #include <sys/signalvar.h>
60: #include <sys/tty.h>
61: #include <sys/user.h>
62: #include <sys/exec.h>
63: #include <sys/core.h>
64: #include <sys/kcore.h>
65: #include <sys/vnode.h>
66: #include <sys/sysctl.h>
67: #include <sys/syscallargs.h>
68: #include <sys/syslog.h>
69: #ifdef SYSVMSG
70: #include <sys/msg.h>
71: #endif
72:
73: #include <machine/db_machdep.h>
74: #ifdef DDB
75: #include <ddb/db_var.h>
76: #endif
77: #include <ddb/db_sym.h>
78: #include <ddb/db_extern.h>
79:
80: #include <machine/autoconf.h>
81: #include <machine/cpu.h>
82: #include <machine/hp300spu.h>
83: #include <machine/kcore.h>
84: #include <machine/reg.h>
85: #include <machine/psl.h>
86: #include <machine/pte.h>
87:
88: #include <dev/cons.h>
89:
90: #include <uvm/uvm_extern.h>
91:
92: #ifdef USELEDS
93: #include <hp300/hp300/leds.h>
94: #endif
95:
96: /* the following is used externally (sysctl_hw) */
97: char machine[] = MACHINE; /* from <machine/param.h> */
98:
99: struct vm_map *exec_map = NULL;
100: struct vm_map *phys_map = NULL;
101:
102: extern paddr_t avail_start, avail_end;
103:
104: /*
105: * Declare these as initialized data so we can patch them.
106: */
107: #ifndef BUFCACHEPERCENT
108: #define BUFCACHEPERCENT 5
109: #endif
110:
111: #ifdef BUFPAGES
112: int bufpages = BUFPAGES;
113: #else
114: int bufpages = 0;
115: #endif
116: int bufcachepercent = BUFCACHEPERCENT;
117:
118: int physmem; /* size of physical memory, in pages */
119: /*
120: * safepri is a safe priority for sleep to set for a spin-wait
121: * during autoconfiguration or after a panic.
122: */
123: int safepri = PSL_LOWIPL;
124:
125: extern u_int lowram;
126: extern short exframesize[];
127:
128: #ifdef COMPAT_HPUX
129: extern struct emul emul_hpux;
130: #endif
131: #ifdef COMPAT_SUNOS
132: extern struct emul emul_sunos;
133: #endif
134:
135: /*
136: * Some storage space must be allocated statically because of the
137: * early console initialization.
138: */
139: char extiospace[EXTENT_FIXED_STORAGE_SIZE(8)];
140: extern int eiomapsize;
141:
142: /* prototypes for local functions */
143: caddr_t allocsys(caddr_t);
144: void parityenable(void);
145: int parityerror(struct frame *);
146: int parityerrorfind(void);
147: void identifycpu(void);
148: void initcpu(void);
149: void dumpmem(int *, int, int);
150: char *hexstr(int, int);
151:
152: /* functions called from locore.s */
153: void dumpsys(void);
154: void hp300_init(void);
155: void straytrap(int, u_short);
156: void nmihand(struct frame);
157:
158: /*
159: * Select code of console. Set to CONSCODE_INTERNAL if console is on
160: * "internal" framebuffer.
161: */
162: int conscode;
163: caddr_t conaddr; /* for drivers in cn_init() */
164: int convasize; /* size of mapped console device */
165:
166: /*
167: * Note that the value of delay_divisor is roughly
168: * 2048 / cpuspeed (where cpuspeed is in MHz) on 68020
169: * and 68030 systems. See clock.c for the delay
170: * calibration algorithm.
171: */
172: int cpuspeed; /* relative cpu speed */
173: int delay_divisor; /* delay constant */
174:
175: /*
176: * Early initialization, before main() is called.
177: */
178: void
179: hp300_init()
180: {
181: /*
182: * Tell the VM system about available physical memory. The
183: * hp300 only has one segment.
184: */
185: uvm_page_physload(atop(avail_start), atop(avail_end),
186: atop(avail_start), atop(avail_end), VM_FREELIST_DEFAULT);
187:
188: /* Initialize the interrupt handlers. */
189: intr_init();
190:
191: /* Calibrate the delay loop. */
192: hp300_calibrate_delay();
193: }
194:
195: /*
196: * Console initialization: called early on from main,
197: * before vm init or startup. Do enough configuration
198: * to choose and initialize a console.
199: */
200: void
201: consinit()
202: {
203: extern struct extent *extio;
204: extern char *extiobase;
205:
206: /*
207: * Initialize some variables for sanity.
208: */
209: convasize = 0;
210: conscode = CONSCODE_INVALID;
211:
212: /*
213: * Initialize the bus resource map.
214: */
215: extio = extent_create("extio",
216: (u_long)extiobase, (u_long)extiobase + ctob(eiomapsize),
217: M_DEVBUF, extiospace, sizeof(extiospace), EX_NOWAIT);
218:
219: /*
220: * Initialize the console before we print anything out.
221: */
222: hp300_cninit();
223:
224: #ifdef DDB
225: ddb_init();
226: if (boothowto & RB_KDB)
227: Debugger();
228: #endif
229: }
230:
231: /*
232: * cpu_startup: allocate memory for variable-sized tables,
233: * initialize cpu, and do autoconfiguration.
234: */
235: void
236: cpu_startup()
237: {
238: extern char *etext;
239: unsigned i;
240: caddr_t v;
241: vaddr_t minaddr, maxaddr;
242: vsize_t size;
243: #ifdef DEBUG
244: extern int pmapdebug;
245: int opmapdebug = pmapdebug;
246:
247: pmapdebug = 0;
248: #endif
249:
250: /*
251: * Now that VM services are available, give another chance at
252: * console devices to initialize, if they could not before.
253: */
254: hp300_cninit();
255:
256: /*
257: * Initialize error message buffer (at end of core).
258: * avail_end was pre-decremented in pmap_bootstrap to compensate.
259: */
260: for (i = 0; i < btoc(MSGBUFSIZE); i++)
261: pmap_enter(pmap_kernel(), (vaddr_t)msgbufp + i * NBPG,
262: avail_end + i * NBPG, VM_PROT_READ|VM_PROT_WRITE,
263: VM_PROT_READ|VM_PROT_WRITE|PMAP_WIRED);
264: pmap_update(pmap_kernel());
265: initmsgbuf((caddr_t)msgbufp, round_page(MSGBUFSIZE));
266:
267: /*
268: * Good {morning,afternoon,evening,night}.
269: */
270: printf(version);
271: identifycpu();
272: printf("real mem = %u (%uMB)\n", ctob(physmem),
273: ctob(physmem)/1024/1024);
274:
275: /*
276: * Find out how much space we need, allocate it,
277: * and then give everything true virtual addresses.
278: */
279: size = (vsize_t)allocsys((caddr_t)0);
280: if ((v = (caddr_t)uvm_km_zalloc(kernel_map, round_page(size))) == 0)
281: panic("startup: no room for tables");
282: if ((allocsys(v) - v) != size)
283: panic("startup: table size inconsistency");
284:
285: /*
286: * Determine how many buffers to allocate.
287: * We allocate bufcachepercent% of memory for buffer space.
288: */
289: if (bufpages == 0)
290: bufpages = physmem * bufcachepercent / 100;
291:
292: /* Restrict to at most 25% filled kvm */
293: if (bufpages >
294: (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
295: bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
296: PAGE_SIZE / 4;
297:
298: /*
299: * Allocate a submap for exec arguments. This map effectively
300: * limits the number of processes exec'ing at any time.
301: */
302: minaddr = vm_map_min(kernel_map);
303: exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
304: 16*NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
305:
306: /*
307: * Allocate a submap for physio
308: */
309: phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
310: VM_PHYS_SIZE, 0, FALSE, NULL);
311:
312: #ifdef DEBUG
313: pmapdebug = opmapdebug;
314: #endif
315: printf("avail mem = %lu (%luMB)\n", ptoa(uvmexp.free),
316: ptoa(uvmexp.free)/1024/1024);
317:
318: /*
319: * Tell the VM system that page 0 isn't mapped.
320: *
321: * XXX This is bogus; should just fix KERNBASE and
322: * XXX VM_MIN_KERNEL_ADDRESS, but not right now.
323: */
324: if (uvm_map_protect(kernel_map, 0, NBPG, UVM_PROT_NONE, TRUE))
325: panic("can't mark page 0 off-limits");
326:
327: /*
328: * Tell the VM system that writing to kernel text isn't allowed.
329: * If we don't, we might end up COW'ing the text segment!
330: *
331: * XXX Should be trunc_page(&kernel_text) instead
332: * XXX of NBPG.
333: */
334: if (uvm_map_protect(kernel_map, NBPG, round_page((vaddr_t)&etext),
335: UVM_PROT_READ|UVM_PROT_EXEC, TRUE))
336: panic("can't protect kernel text");
337:
338: /*
339: * Set up CPU-specific registers, cache, etc.
340: */
341: initcpu();
342:
343: /*
344: * Set up buffers, so they can be used to read disk labels.
345: */
346: bufinit();
347:
348: /*
349: * Configure the system.
350: */
351: if (boothowto & RB_CONFIG) {
352: #ifdef BOOT_CONFIG
353: user_config();
354: #else
355: printf("kernel does not support -c; continuing..\n");
356: #endif
357: }
358: }
359:
360: /*
361: * Allocate space for system data structures. We are given
362: * a starting virtual address and we return a final virtual
363: * address; along the way we set each data structure pointer.
364: *
365: * We call allocsys() with 0 to find out how much space we want,
366: * allocate that much and fill it with zeroes, and then call
367: * allocsys() again with the correct base virtual address.
368: */
369: caddr_t
370: allocsys(v)
371: caddr_t v;
372: {
373:
374: #define valloc(name, type, num) \
375: (name) = (type *)v; v = (caddr_t)((name)+(num))
376: #define valloclim(name, type, num, lim) \
377: (name) = (type *)v; v = (caddr_t)((lim) = ((name)+(num)))
378:
379: #ifdef SYSVMSG
380: valloc(msgpool, char, msginfo.msgmax);
381: valloc(msgmaps, struct msgmap, msginfo.msgseg);
382: valloc(msghdrs, struct msg, msginfo.msgtql);
383: valloc(msqids, struct msqid_ds, msginfo.msgmni);
384: #endif
385:
386: return (v);
387: }
388:
389: /*
390: * Info for CTL_HW
391: */
392: char cpu_model[120];
393:
394: /*
395: * Text description of models we support, indexed by machineid.
396: */
397: const char *hp300_models[] = {
398: "320", /* HP_320 */
399: "318/319/330", /* HP_330 */
400: "350", /* HP_350 */
401: "360", /* HP_360 */
402: "370", /* HP_370 */
403: "340", /* HP_340 */
404: "345", /* HP_345 */
405: "375", /* HP_375 */
406: "400", /* HP_400 */
407: "380", /* HP_380 */
408: "425", /* HP_425 */
409: "433", /* HP_433 */
410: "385", /* HP_385 */
411: "362", /* HP_362 */
412: "382", /* HP_382 */
413: };
414:
415: /* Map mmuid to single letter designation in 4xx models (e.g. 425s, 425t) */
416: char hp300_designations[] = " ttss e";
417:
418: void
419: identifycpu()
420: {
421: const char *t;
422: char mc, *td;
423: int len;
424: #ifdef FPSP
425: extern u_long fpvect_tab, fpvect_end, fpsp_tab;
426: #endif
427:
428: /*
429: * Map machineid to model name.
430: */
431: if (machineid >= sizeof(hp300_models) / sizeof(char *)) {
432: printf("\nunknown machineid %d\n", machineid);
433: goto lose;
434: }
435: t = hp300_models[machineid];
436:
437: /*
438: * Look up special designation (425s, 425t, etc) by mmuid.
439: */
440: if (mmuid < strlen(hp300_designations) &&
441: hp300_designations[mmuid] != ' ') {
442: td = &hp300_designations[mmuid];
443: td[1] = '\0';
444: } else
445: td = "";
446:
447: /*
448: * ...and the CPU type
449: */
450: switch (cputype) {
451: case CPU_68040:
452: mc = '4';
453: /* adjust cpuspeed by 3/8 on '040 boxes */
454: cpuspeed *= 3;
455: cpuspeed /= 8;
456: break;
457: case CPU_68030:
458: mc = '3';
459: break;
460: case CPU_68020:
461: mc = '2';
462: break;
463: default:
464: printf("\nunknown cputype %d\n", cputype);
465: goto lose;
466: }
467: snprintf(cpu_model, sizeof cpu_model,
468: "HP 9000/%s%s (%dMHz MC680%c0 CPU", t, td, cpuspeed, mc);
469:
470: /*
471: * ...and the MMU type.
472: */
473: switch (mmutype) {
474: case MMU_68040:
475: case MMU_68030:
476: strlcat(cpu_model, "+MMU", sizeof cpu_model);
477: break;
478: case MMU_68851:
479: strlcat(cpu_model, ", MC68851 MMU", sizeof cpu_model);
480: break;
481: case MMU_HP:
482: strlcat(cpu_model, ", HP MMU", sizeof cpu_model);
483: break;
484: default:
485: printf("%s\nunknown MMU type %d\n", cpu_model, mmutype);
486: panic("startup");
487: }
488:
489: /*
490: * ...and the FPU type.
491: */
492: switch (fputype) {
493: case FPU_68040:
494: strlcat(cpu_model, "+FPU", sizeof cpu_model);
495: break;
496: case FPU_68882:
497: len = strlen(cpu_model);
498: snprintf(cpu_model + len, sizeof cpu_model - len,
499: ", %dMHz MC68882 FPU", cpuspeed);
500: break;
501: case FPU_68881:
502: len = strlen(cpu_model);
503: snprintf(cpu_model + len, sizeof cpu_model - len,
504: ", %dMHz MC68881 FPU", machineid == HP_350 ? 20 : 16);
505: break;
506: default:
507: strlcat(cpu_model, ", unknown FPU", sizeof cpu_model);
508: }
509:
510: /*
511: * ...and finally, the cache type.
512: */
513: if (cputype == CPU_68040)
514: strlcat(cpu_model, ", 4k on-chip physical I/D caches",
515: sizeof cpu_model);
516: else {
517: len = strlen(cpu_model);
518: switch (ectype) {
519: case EC_VIRT:
520: snprintf(cpu_model + len, sizeof cpu_model - len,
521: ", %dK virtual-address cache",
522: machineid == HP_320 ? 16 : 32);
523: break;
524: case EC_PHYS:
525: snprintf(cpu_model + len, sizeof cpu_model - len,
526: ", %dK physical-address cache",
527: machineid == HP_370 ? 64 : 32);
528: break;
529: }
530: }
531:
532: printf("%s)\n", cpu_model);
533: #ifdef DEBUG
534: printf("cpu: delay divisor %d", delay_divisor);
535: if (mmuid)
536: printf(", mmuid %d", mmuid);
537: printf("\n");
538: #endif
539:
540: /*
541: * Now that we have told the user what they have,
542: * let them know if that machine type isn't configured.
543: */
544: switch (machineid) {
545: case -1: /* keep compilers happy */
546: #if !defined(HP320)
547: case HP_320:
548: #endif
549: #if !defined(HP330)
550: case HP_330:
551: #endif
552: #if !defined(HP340)
553: case HP_340:
554: #endif
555: #if !defined(HP345)
556: case HP_345:
557: #endif
558: #if !defined(HP350)
559: case HP_350:
560: #endif
561: #if !defined(HP360)
562: case HP_360:
563: #endif
564: #if !defined(HP362)
565: case HP_362:
566: #endif
567: #if !defined(HP370)
568: case HP_370:
569: #endif
570: #if !defined(HP375)
571: case HP_375:
572: #endif
573: #if !defined(HP380)
574: case HP_380:
575: #endif
576: #if !defined(HP382)
577: case HP_382:
578: #endif
579: #if !defined(HP385)
580: case HP_385:
581: #endif
582: #if !defined(HP400)
583: case HP_400:
584: #endif
585: #if !defined(HP425)
586: case HP_425:
587: #endif
588: #if !defined(HP433)
589: case HP_433:
590: #endif
591: panic("SPU type not configured for machineid %d", machineid);
592: default:
593: break;
594: }
595:
596: #ifdef FPSP
597: if (cputype == CPU_68040) {
598: bcopy(&fpsp_tab, &fpvect_tab,
599: (&fpvect_end - &fpvect_tab) * sizeof (fpvect_tab));
600: }
601: #endif
602:
603: return;
604: lose:
605: panic("startup");
606: }
607:
608: /*
609: * machine dependent system variables.
610: */
611: int
612: cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
613: int *name;
614: u_int namelen;
615: void *oldp;
616: size_t *oldlenp;
617: void *newp;
618: size_t newlen;
619: struct proc *p;
620: {
621: dev_t consdev;
622:
623: /* all sysctl names at this level are terminal */
624: if (namelen != 1)
625: return (ENOTDIR); /* overloaded */
626:
627: switch (name[0]) {
628: case CPU_CONSDEV:
629: if (cn_tab != NULL)
630: consdev = cn_tab->cn_dev;
631: else
632: consdev = NODEV;
633: return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
634: sizeof consdev));
635: case CPU_CPUSPEED:
636: return (sysctl_rdint(oldp, oldlenp, newp, cpuspeed));
637: case CPU_MACHINEID:
638: return (sysctl_rdint(oldp, oldlenp, newp, machineid));
639: case CPU_MMUID:
640: return (sysctl_rdint(oldp, oldlenp, newp, mmuid));
641: default:
642: return (EOPNOTSUPP);
643: }
644: /* NOTREACHED */
645: }
646:
647: int waittime = -1;
648:
649: void
650: boot(howto)
651: int howto;
652: {
653: /* take a snap shot before clobbering any registers */
654: if (curproc && curproc->p_addr)
655: savectx(&curproc->p_addr->u_pcb);
656:
657: /* If system is cold, just halt. */
658: if (cold) {
659: /* (Unless the user explicitly asked for reboot.) */
660: if ((howto & RB_USERREQ) == 0)
661: howto |= RB_HALT;
662: goto haltsys;
663: }
664:
665: boothowto = howto;
666: if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
667: waittime = 0;
668: vfs_shutdown();
669: /*
670: * If we've been adjusting the clock, the todr
671: * will be out of synch; adjust it now unless
672: * the system was sitting in ddb.
673: */
674: if ((howto & RB_TIMEBAD) == 0) {
675: resettodr();
676: } else {
677: printf("WARNING: not updating battery clock\n");
678: }
679: }
680:
681: /* Disable interrupts. */
682: splhigh();
683:
684: /* If rebooting and a dump is requested do it. */
685: if (howto & RB_DUMP)
686: dumpsys();
687:
688: haltsys:
689: /* Run any shutdown hooks. */
690: doshutdownhooks();
691:
692: /* Finally, halt/reboot the system. */
693: if (howto & RB_HALT) {
694: printf("System halted. Hit any key to reboot.\n\n");
695: while (cngetc() == 0);
696: }
697:
698: printf("rebooting...\n");
699: DELAY(1000000);
700: doboot();
701: /*NOTREACHED*/
702: }
703:
704: /*
705: * These variables are needed by /sbin/savecore
706: */
707: u_long dumpmag = 0x8fca0101; /* magic number */
708: int dumpsize = 0; /* pages */
709: long dumplo = 0; /* blocks */
710: cpu_kcore_hdr_t cpu_kcore_hdr;
711:
712: /*
713: * This is called by configure to set dumplo and dumpsize.
714: * Dumps always skip the first PAGE_SIZE of disk space
715: * in case there might be a disk label stored there.
716: * If there is extra space, put dump at the end to
717: * reduce the chance that swapping trashes it.
718: */
719: void
720: dumpconf(void)
721: {
722: int nblks; /* size of dump area */
723:
724: if (dumpdev == NODEV ||
725: (nblks = (bdevsw[major(dumpdev)].d_psize)(dumpdev)) == 0)
726: return;
727: if (nblks <= ctod(1))
728: return;
729:
730: /*
731: * XXX include the final RAM page which is not included in physmem.
732: */
733: dumpsize = physmem;
734:
735: /* hp300 only uses a single segment. */
736: cpu_kcore_hdr.ram_segs[0].start = lowram;
737: cpu_kcore_hdr.ram_segs[0].size = ctob(dumpsize);
738: cpu_kcore_hdr.mmutype = mmutype;
739: cpu_kcore_hdr.kernel_pa = lowram;
740: cpu_kcore_hdr.sysseg_pa = pmap_kernel()->pm_stpa;
741:
742: /* Always skip the first block, in case there is a label there. */
743: if (dumplo < ctod(1))
744: dumplo = ctod(1);
745:
746: /* Put dump at end of partition, and make it fit. */
747: if (dumpsize > dtoc(nblks - dumplo))
748: dumpsize = dtoc(nblks - dumplo);
749: if (dumplo < nblks - ctod(dumpsize))
750: dumplo = nblks - ctod(dumpsize);
751: }
752:
753: /*
754: * Dump physical memory onto the dump device. Called by doadump()
755: * in locore.s or by boot() here in machdep.c
756: */
757: void
758: dumpsys()
759: {
760: daddr64_t blkno; /* current block to write */
761: /* dump routine */
762: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
763: int pg; /* page being dumped */
764: paddr_t maddr; /* PA being dumped */
765: int error; /* error code from (*dump)() */
766: kcore_seg_t *kseg_p;
767: cpu_kcore_hdr_t *chdr_p;
768: char dump_hdr[dbtob(1)]; /* XXX assume hdr fits in 1 block */
769: extern int msgbufmapped;
770:
771: /* XXX initialized here because of gcc lossage */
772: maddr = lowram;
773: pg = 0;
774:
775: /* Don't put dump messages in msgbuf. */
776: msgbufmapped = 0;
777:
778: /* Make sure dump device is valid. */
779: if (dumpdev == NODEV)
780: return;
781: if (dumpsize == 0) {
782: dumpconf();
783: if (dumpsize == 0)
784: return;
785: }
786: if (dumplo <= 0) {
787: printf("\ndump to dev %u,%u not possible\n", major(dumpdev),
788: minor(dumpdev));
789: return;
790: }
791: dump = bdevsw[major(dumpdev)].d_dump;
792: blkno = dumplo;
793:
794: printf("\ndumping to dev %u,%u offset %ld\n", major(dumpdev),
795: minor(dumpdev), dumplo);
796:
797: kseg_p = (kcore_seg_t *)dump_hdr;
798: chdr_p = (cpu_kcore_hdr_t *)&dump_hdr[ALIGN(sizeof(*kseg_p))];
799: bzero(dump_hdr, sizeof(dump_hdr));
800:
801: /*
802: * Generate a segment header
803: */
804: CORE_SETMAGIC(*kseg_p, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
805: kseg_p->c_size = dbtob(1) - ALIGN(sizeof(*kseg_p));
806:
807: /*
808: * Add the md header
809: */
810:
811: *chdr_p = cpu_kcore_hdr;
812:
813: printf("dump ");
814: maddr = cpu_kcore_hdr.ram_segs[0].start;
815: /* Dump the header. */
816: error = (*dump) (dumpdev, blkno++, (caddr_t)dump_hdr, dbtob(1));
817: switch (error) {
818: case 0:
819: break;
820:
821: case ENXIO:
822: printf("device bad\n");
823: return;
824:
825: case EFAULT:
826: printf("device not ready\n");
827: return;
828:
829: case EINVAL:
830: printf("area improper\n");
831: return;
832:
833: case EIO:
834: printf("i/o error\n");
835: return;
836:
837: case EINTR:
838: printf("aborted from console\n");
839: return;
840:
841: default:
842: printf("error %d\n", error);
843: return;
844: }
845: for (pg = 0; pg < dumpsize; pg++) {
846: #define NPGMB (1024*1024/NBPG)
847: /* print out how many MBs we have dumped */
848: if (pg && (pg % NPGMB) == 0)
849: printf("%d ", pg / NPGMB);
850: #undef NPGMB
851: pmap_enter(pmap_kernel(), (vaddr_t)vmmap, maddr,
852: VM_PROT_READ, VM_PROT_READ|PMAP_WIRED);
853:
854: pmap_update(pmap_kernel());
855: error = (*dump)(dumpdev, blkno, vmmap, NBPG);
856: switch (error) {
857: case 0:
858: maddr += NBPG;
859: blkno += btodb(NBPG);
860: break;
861:
862: case ENXIO:
863: printf("device bad\n");
864: return;
865:
866: case EFAULT:
867: printf("device not ready\n");
868: return;
869:
870: case EINVAL:
871: printf("area improper\n");
872: return;
873:
874: case EIO:
875: printf("i/o error\n");
876: return;
877:
878: case EINTR:
879: printf("aborted from console\n");
880: return;
881:
882: default:
883: printf("error %d\n", error);
884: return;
885: }
886: }
887: printf("succeeded\n");
888: }
889:
890: void
891: initcpu()
892: {
893:
894: parityenable();
895: #ifdef USELEDS
896: ledinit();
897: #endif
898: }
899:
900: void
901: straytrap(pc, evec)
902: int pc;
903: u_short evec;
904: {
905: printf("unexpected trap (vector offset %x) from %x\n",
906: evec & 0xFFF, pc);
907: }
908:
909: /* XXX should change the interface, and make one badaddr() function */
910:
911: int *nofault;
912:
913: int
914: badaddr(addr)
915: caddr_t addr;
916: {
917: int i;
918: label_t faultbuf;
919:
920: nofault = (int *) &faultbuf;
921: if (setjmp((label_t *)nofault)) {
922: nofault = (int *) 0;
923: return(1);
924: }
925: i = *(volatile short *)addr;
926: nofault = (int *) 0;
927: return(0);
928: }
929:
930: int
931: badbaddr(addr)
932: caddr_t addr;
933: {
934: int i;
935: label_t faultbuf;
936:
937: nofault = (int *) &faultbuf;
938: if (setjmp((label_t *)nofault)) {
939: nofault = (int *) 0;
940: return(1);
941: }
942: i = *(volatile char *)addr;
943: nofault = (int *) 0;
944: return(0);
945: }
946:
947: static int innmihand; /* simple mutex */
948:
949: /*
950: * Level 7 interrupts can be caused by HIL keyboards (in cooked mode only,
951: * but we run them in raw mode) or parity errors.
952: */
953: void
954: nmihand(frame)
955: struct frame frame;
956: {
957:
958: /* Prevent unwanted recursion. */
959: if (innmihand)
960: return;
961: innmihand = 1;
962:
963: if (parityerror(&frame)) {
964: innmihand = 0;
965: return;
966: }
967:
968: /* panic?? */
969: printf("unexpected level 7 interrupt ignored\n");
970:
971: innmihand = 0;
972: }
973:
974: /*
975: * Parity error section. Contains magic.
976: */
977: #define PARREG ((volatile short *)IIOV(0x5B0000))
978: static int gotparmem = 0;
979: #ifdef DEBUG
980: int ignorekperr = 0; /* ignore kernel parity errors */
981: #endif
982:
983: /*
984: * Enable parity detection
985: */
986: void
987: parityenable()
988: {
989: label_t faultbuf;
990:
991: nofault = (int *) &faultbuf;
992: if (setjmp((label_t *)nofault)) {
993: nofault = (int *) 0;
994: printf("No parity memory\n");
995: return;
996: }
997: *PARREG = 1;
998: nofault = (int *) 0;
999: gotparmem = 1;
1000: printf("Parity detection enabled\n");
1001: }
1002:
1003: /*
1004: * Determine if level 7 interrupt was caused by a parity error
1005: * and deal with it if it was. Returns 1 if it was a parity error.
1006: */
1007: int
1008: parityerror(fp)
1009: struct frame *fp;
1010: {
1011: if (!gotparmem)
1012: return(0);
1013: *PARREG = 0;
1014: DELAY(10);
1015: *PARREG = 1;
1016: if (panicstr) {
1017: printf("parity error after panic ignored\n");
1018: return (1);
1019: }
1020: if (!parityerrorfind())
1021: printf("WARNING: transient parity error ignored\n");
1022: else if (USERMODE(fp->f_sr)) {
1023: log(LOG_ERR, "pid %d was killed: memory parity error\n",
1024: curproc->p_pid);
1025: uprintf("sorry, pid %d killed: memory parity error\n",
1026: curproc->p_pid);
1027: psignal(curproc, SIGKILL);
1028: #ifdef DEBUG
1029: } else if (ignorekperr) {
1030: printf("WARNING: kernel parity error ignored\n");
1031: #endif
1032: } else {
1033: regdump(&(fp->F_t), 128);
1034: panic("kernel parity error");
1035: }
1036: return (1);
1037: }
1038:
1039: /*
1040: * Yuck! There has got to be a better way to do this!
1041: * Searching all of memory with interrupts blocked can lead to disaster.
1042: */
1043: int
1044: parityerrorfind()
1045: {
1046: static label_t parcatch;
1047: static int looking = 0;
1048: volatile int pg, o, s;
1049: volatile int *ip;
1050: int i;
1051: int found;
1052:
1053: #ifdef lint
1054: i = o = pg = 0; if (i) return(0);
1055: #endif
1056: /*
1057: * If looking is true we are searching for a known parity error
1058: * and it has just occurred. All we do is return to the higher
1059: * level invocation.
1060: */
1061: if (looking)
1062: longjmp(&parcatch);
1063: s = splhigh();
1064: /*
1065: * If setjmp returns true, the parity error we were searching
1066: * for has just occurred (longjmp above) at the current pg+o
1067: */
1068: if (setjmp(&parcatch)) {
1069: printf("Parity error at 0x%x\n", ctob(pg)|o);
1070: found = 1;
1071: goto done;
1072: }
1073: /*
1074: * If we get here, a parity error has occurred for the first time
1075: * and we need to find it. We turn off any external caches and
1076: * loop thru memory, testing every longword til a fault occurs and
1077: * we regain control at setjmp above. Note that because of the
1078: * setjmp, pg and o need to be volatile or their values will be lost.
1079: */
1080: looking = 1;
1081: ecacheoff();
1082: for (pg = btoc(lowram); pg < btoc(lowram)+physmem; pg++) {
1083: pmap_kenter_pa((vaddr_t)vmmap, ptoa(pg), VM_PROT_READ);
1084: pmap_update(pmap_kernel());
1085: ip = (int *)vmmap;
1086: for (o = 0; o < PAGE_SIZE; o += sizeof(int))
1087: i = *ip++;
1088: }
1089: /*
1090: * Getting here implies no fault was found. Should never happen.
1091: */
1092: printf("Couldn't locate parity error\n");
1093: found = 0;
1094: done:
1095: looking = 0;
1096: ecacheon(); /* pmap_kremove() may cause a cache flush */
1097: pmap_kremove((vaddr_t)vmmap, PAGE_SIZE);
1098: pmap_update(pmap_kernel());
1099: splx(s);
1100: return(found);
1101: }
1102:
1103: /*
1104: * cpu_exec_aout_makecmds():
1105: * cpu-dependent a.out format hook for execve().
1106: *
1107: * Determine of the given exec package refers to something which we
1108: * understand and, if so, set up the vmcmds for it.
1109: */
1110: int
1111: cpu_exec_aout_makecmds(p, epp)
1112: struct proc *p;
1113: struct exec_package *epp;
1114: {
1115: #if defined(COMPAT_44) || defined(COMPAT_SUNOS)
1116: u_long midmag, magic;
1117: u_short mid;
1118: int error;
1119: struct exec *execp = epp->ep_hdr;
1120: #ifdef COMPAT_SUNOS
1121: extern int sunos_exec_aout_makecmds(struct proc *, struct exec_package *);
1122: #endif
1123:
1124: midmag = ntohl(execp->a_midmag);
1125: mid = (midmag >> 16) & 0xffff;
1126: magic = midmag & 0xffff;
1127:
1128: midmag = mid << 16 | magic;
1129:
1130: switch (midmag) {
1131: #ifdef COMPAT_44
1132: case (MID_HP300 << 16) | ZMAGIC:
1133: error = exec_aout_prep_oldzmagic(p, epp);
1134: break;
1135: #endif
1136: default:
1137: #ifdef COMPAT_SUNOS
1138: /* Hand it over to the SunOS emulation package. */
1139: error = sunos_exec_aout_makecmds(p, epp);
1140: #else
1141: error = ENOEXEC;
1142: #endif
1143: }
1144:
1145: return error;
1146: #else /* !(defined(COMPAT_44) || defined(COMPAT_SUNOS)) */
1147: return ENOEXEC;
1148: #endif
1149: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to machdep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / hp300