![[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 / hp300|
Return to machdep.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hp300 |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
9: *
10: * Redistribution is only permitted until one year after the first shipment
11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
12: * binary forms are permitted provided that: (1) source distributions retain
13: * this entire copyright notice and comment, and (2) distributions including
14: * binaries display the following acknowledgement: This product includes
15: * software developed by the University of California, Berkeley and its
16: * contributors'' in the documentation or other materials provided with the
17: * distribution and in all advertising materials mentioning features or use
18: * of this software. Neither the name of the University nor the names of
19: * its contributors may be used to endorse or promote products derived from
20: * this software without specific prior written permission.
21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24: *
25: * from: Utah $Hdr: machdep.c 1.51 89/11/28$
26: *
27: * @(#)machdep.c 7.7 (Berkeley) 6/28/90
28: */
29:
30: #include "param.h"
31: #include "systm.h"
32: #include "user.h"
33: #include "kernel.h"
34: #include "map.h"
35: #include "vm.h"
36: #include "proc.h"
37: #include "buf.h"
38: #include "reboot.h"
39: #include "conf.h"
40: #include "file.h"
41: #include "text.h"
42: #include "clist.h"
43: #include "callout.h"
44: #include "cmap.h"
45: #include "malloc.h"
46: #include "mbuf.h"
47: #include "msgbuf.h"
48: #ifdef SYSVSHM
49: #include "shm.h"
50: #endif
51: #ifdef HPUXCOMPAT
52: #include "../hpux/hpux.h"
53: #endif
54:
55: #include "cpu.h"
56: #include "reg.h"
57: #include "pte.h"
58: #include "psl.h"
59: #include "isr.h"
60: #include "../net/netisr.h"
61:
62: /*
63: * Declare these as initialized data so we can patch them.
64: */
65: int nswbuf = 0;
66: #ifdef NBUF
67: int nbuf = NBUF;
68: #else
69: int nbuf = 0;
70: #endif
71: #ifdef BUFPAGES
72: int bufpages = BUFPAGES;
73: #else
74: int bufpages = 0;
75: #endif
76: int msgbufmapped; /* set when safe to use msgbuf */
77: int physmem = MAXMEM; /* max supported memory, changes to actual */
78:
79: extern u_int lowram;
80:
81: /*
82: * Machine-dependent startup code
83: */
84: startup(firstaddr)
85: int firstaddr;
86: {
87: register int unixsize;
88: register unsigned i;
89: register struct pte *pte;
90: int mapaddr, j, n;
91: register caddr_t v;
92: int maxbufs, base, residual;
93: extern long Usrptsize;
94: extern struct map *useriomap;
95:
96: /*
97: * Set cpuspeed immediately since cninit() called routines
98: * might use delay.
99: */
100: switch (machineid) {
101: case HP_320:
102: case HP_330:
103: case HP_340:
104: cpuspeed = MHZ_16;
105: break;
106: case HP_350:
107: case HP_360:
108: cpuspeed = MHZ_25;
109: break;
110: case HP_370:
111: cpuspeed = MHZ_33;
112: break;
113: case HP_375:
114: cpuspeed = MHZ_50;
115: break;
116: }
117: /*
118: * Find what hardware is attached to this machine.
119: */
120: find_devs();
121: /*
122: * Initialize the console before we print anything out.
123: */
124: cninit();
125: /*
126: * Initialize error message buffer (at end of core).
127: */
128: maxmem -= btoc(sizeof (struct msgbuf));
129: pte = msgbufmap;
130: for (i = 0; i < btoc(sizeof (struct msgbuf)); i++)
131: *(int *)pte++ = PG_CI | PG_V | PG_KW | (ctob(maxmem + i));
132: TBIAS();
133: msgbufmapped = 1;
134:
135: /*
136: * Good {morning,afternoon,evening,night}.
137: */
138: printf(version);
139: identifycpu();
140: printf("real mem = %d\n", ctob(physmem));
141:
142: /*
143: * Allocate space for system data structures.
144: * The first available real memory address is in "firstaddr".
145: * The first available kernel virtual address is in "v".
146: * As pages of kernel virtual memory are allocated, "v" is incremented.
147: * As pages of memory are allocated and cleared,
148: * "firstaddr" is incremented.
149: * An index into the kernel page table corresponding to the
150: * virtual memory address maintained in "v" is kept in "mapaddr".
151: */
152: v = (caddr_t)((firstaddr * NBPG) - lowram);
153: mapaddr = (int)v;
154: #define valloc(name, type, num) \
155: (name) = (type *)v; v = (caddr_t)((name)+(num))
156: #define valloclim(name, type, num, lim) \
157: (name) = (type *)v; v = (caddr_t)((lim) = ((name)+(num)))
158: valloclim(file, struct file, nfile, fileNFILE);
159: valloclim(proc, struct proc, nproc, procNPROC);
160: valloclim(text, struct text, ntext, textNTEXT);
161: valloc(cfree, struct cblock, nclist);
162: valloc(callout, struct callout, ncallout);
163: valloc(swapmap, struct map, nswapmap = nproc * 2);
164: valloc(argmap, struct map, ARGMAPSIZE);
165: valloc(kernelmap, struct map, nproc);
166: valloc(mbmap, struct map, nmbclusters/4);
167: valloc(kmemmap, struct map, ekmempt - kmempt);
168: valloc(kmemusage, struct kmemusage, ekmempt - kmempt);
169: valloc(useriomap, struct map, nproc);
170: #ifdef SYSVSHM
171: valloc(shmsegs, struct shmid_ds, shminfo.shmmni);
172: #endif
173:
174: /*
175: * Determine how many buffers to allocate.
176: * Since HPs tend to be long on memory and short on disk speed,
177: * we allocate more buffer space than the BSD standard of
178: * use 10% of memory for the first 2 Meg, 5% of remaining.
179: * We just allocate a flat 10%. Insure a minimum of 16 buffers.
180: * We allocate 1/2 as many swap buffer headers as file i/o buffers.
181: */
182: if (bufpages == 0)
183: bufpages = physmem / 10 / CLSIZE;
184: if (nbuf == 0) {
185: nbuf = bufpages;
186: if (nbuf < 16)
187: nbuf = 16;
188: }
189: if (nswbuf == 0) {
190: nswbuf = (nbuf / 2) &~ 1; /* force even */
191: if (nswbuf > 256)
192: nswbuf = 256; /* sanity */
193: }
194: valloc(swbuf, struct buf, nswbuf);
195:
196: /*
197: * Now the amount of virtual memory remaining for buffers
198: * can be calculated, estimating needs for the cmap.
199: */
200: ncmap = (maxmem*NBPG - (firstaddr*NBPG + ((int)v - mapaddr))) /
201: (CLBYTES + sizeof(struct cmap)) + 2;
202: maxbufs = ((SYSPTSIZE * NBPG) -
203: (int)(v + ncmap * sizeof(struct cmap))) /
204: (MAXBSIZE + sizeof(struct buf));
205: if (maxbufs < 16)
206: panic("sys pt too small");
207: if (nbuf > maxbufs) {
208: printf("SYSPTSIZE limits number of buffers to %d\n", maxbufs);
209: nbuf = maxbufs;
210: }
211: if (bufpages > nbuf * (MAXBSIZE / CLBYTES))
212: bufpages = nbuf * (MAXBSIZE / CLBYTES);
213: valloc(buf, struct buf, nbuf);
214:
215: /*
216: * Allocate space for core map.
217: * Allow space for all of physical memory minus the amount
218: * dedicated to the system. The amount of physical memory
219: * dedicated to the system is the total virtual memory of
220: * the system thus far, plus core map, buffer pages,
221: * and buffer headers not yet allocated.
222: * Add 2: 1 because the 0th entry is unused, 1 for rounding.
223: */
224: ncmap = (maxmem*NBPG - (firstaddr * NBPG +
225: ((int)(v + bufpages*CLBYTES) - mapaddr))) /
226: (CLBYTES + sizeof(struct cmap)) + 2;
227: valloclim(cmap, struct cmap, ncmap, ecmap);
228:
229: /*
230: * Clear space allocated thus far, and make r/w entries
231: * for the space in the kernel map.
232: */
233: unixsize = btoc(v);
234: mapaddr = btoc(mapaddr);
235: while (mapaddr < unixsize) {
236: *(int *)(&Sysmap[mapaddr]) = PG_V | PG_KW | ctob(firstaddr);
237: clearseg((unsigned)firstaddr);
238: firstaddr++;
239: mapaddr++;
240: }
241:
242: /*
243: * Now allocate buffers proper. They are different than the above
244: * in that they usually occupy more virtual memory than physical.
245: */
246: v = (caddr_t) ((int)(v + PGOFSET) &~ PGOFSET);
247: valloc(buffers, char, MAXBSIZE * nbuf);
248: base = bufpages / nbuf;
249: residual = bufpages % nbuf;
250: for (i = 0; i < nbuf; i++) {
251: n = (i < residual ? base + 1 : base) * CLSIZE;
252: for (j = 0; j < n; j++) {
253: *(int *)(&Sysmap[mapaddr+j]) =
254: PG_CI | PG_V | PG_KW | ctob(firstaddr);
255: clearseg((unsigned)firstaddr);
256: firstaddr++;
257: }
258: mapaddr += MAXBSIZE / NBPG;
259: }
260:
261: unixsize = btoc(v);
262: if (firstaddr - Sysmap[0].pg_pfnum >= physmem - 8*UPAGES)
263: panic("no memory");
264: TBIA(); /* After we just cleared it all! */
265:
266: /*
267: * Initialize callouts
268: */
269: callfree = callout;
270: for (i = 1; i < ncallout; i++)
271: callout[i-1].c_next = &callout[i];
272:
273: /*
274: * Initialize memory allocator and swap
275: * and user page table maps.
276: *
277: * THE USER PAGE TABLE MAP IS CALLED ``kernelmap''
278: * WHICH IS A VERY UNDESCRIPTIVE AND INCONSISTENT NAME.
279: */
280: meminit(firstaddr, maxmem);
281: maxmem = freemem;
282: printf("avail mem = %d\n", ctob(maxmem));
283: printf("using %d buffers containing %d bytes of memory\n",
284: nbuf, bufpages * CLBYTES);
285: rminit(kernelmap, (long)&Usrptsize-CLSIZE, (long)1, "usrpt", nproc);
286: rminit(useriomap, (long)USRIOSIZE, (long)1, "usrio", nproc);
287: rminit(mbmap, (long)(nmbclusters * MCLBYTES / NBPG), (long)CLSIZE,
288: "mbclusters", nmbclusters/4);
289: kmeminit(); /* now safe to do malloc/free */
290:
291: /*
292: * Set up CPU-specific registers, cache, etc.
293: */
294: initcpu();
295:
296: /*
297: * Set up buffers, so they can be used to read disk labels.
298: */
299: bhinit();
300: binit();
301:
302: /*
303: * Configure the system.
304: */
305: configure();
306: }
307:
308: #ifdef PGINPROF
309: /*
310: * Return the difference (in microseconds)
311: * between the current time and a previous
312: * time as represented by the arguments.
313: */
314: /*ARGSUSED*/
315: vmtime(otime, olbolt, oicr)
316: register int otime, olbolt, oicr;
317: {
318:
319: return (((time.tv_sec-otime)*100 + lbolt-olbolt)*10000);
320: }
321: #endif
322:
323: /*
324: * Clear registers on exec
325: */
326: setregs(entry, retval)
327: u_long entry;
328: int retval[2];
329: {
330: u.u_ar0[PC] = entry & ~1;
331: #ifdef FPCOPROC
332: /* restore a null state frame */
333: u.u_pcb.pcb_fpregs.fpf_null = 0;
334: m68881_restore(&u.u_pcb.pcb_fpregs);
335: #endif
336: #ifdef HPUXCOMPAT
337: if (u.u_procp->p_flag & SHPUX) {
338:
339: u.u_ar0[A0] = 0; /* not 68010 (bit 31), no FPA (30) */
340: retval[0] = 0; /* no float card */
341: #ifdef FPCOPROC
342: retval[1] = 1; /* yes 68881 */
343: #else
344: retval[1] = 0; /* no 68881 */
345: #endif
346: }
347: /*
348: * Ensure we perform the right action on traps type 1 and 2:
349: * If our parent is an HPUX process and we are being traced, turn
350: * on HPUX style interpretation. Else if we were using the HPUX
351: * style interpretation, revert to the BSD interpretation.
352: *
353: * XXX This doesn't have much to do with setting registers but
354: * I didn't want to muck up kern_exec.c with this code, so I
355: * stuck it here.
356: */
357: if ((u.u_procp->p_pptr->p_flag & SHPUX) &&
358: (u.u_procp->p_flag & STRC)) {
359: tweaksigcode(1);
360: u.u_pcb.pcb_flags |= PCB_HPUXTRACE;
361: } else if (u.u_pcb.pcb_flags & PCB_HPUXTRACE) {
362: tweaksigcode(0);
363: u.u_pcb.pcb_flags &= ~PCB_HPUXTRACE;
364: }
365: #endif
366: }
367:
368: identifycpu()
369: {
370: printf("HP9000/");
371: switch (machineid) {
372: case HP_320:
373: printf("320 (16.67Mhz");
374: break;
375: case HP_330:
376: printf("318/319/330 (16.67Mhz");
377: break;
378: case HP_340:
379: printf("340 (16.67Mhz");
380: break;
381: case HP_350:
382: printf("350 (25Mhz");
383: break;
384: case HP_360:
385: printf("360 (25Mhz");
386: break;
387: case HP_370:
388: printf("370 (33.33Mhz");
389: break;
390: case HP_375:
391: printf("345/375 (50Mhz");
392: break;
393: default:
394: printf("\nunknown machine type %d\n", machineid);
395: panic("startup");
396: }
397: printf(" MC680%s CPU", mmutype == MMU_68030 ? "30" : "20");
398: switch (mmutype) {
399: case MMU_68030:
400: printf("+MMU");
401: break;
402: case MMU_68851:
403: printf(", MC68851 MMU");
404: break;
405: case MMU_HP:
406: printf(", HP MMU");
407: break;
408: default:
409: printf("\nunknown MMU type %d\n", mmutype);
410: panic("startup");
411: }
412: if (mmutype == MMU_68030)
413: printf(", %sMhz MC68882 FPU",
414: machineid == HP_340 ? "16.67" :
415: (machineid == HP_360 ? "25" :
416: (machineid == HP_370 ? "33.33" : "50")));
417: else
418: printf(", %sMhz MC68881 FPU",
419: machineid == HP_350 ? "20" : "16.67");
420: switch (ectype) {
421: case EC_VIRT:
422: printf(", %dK virtual-address cache",
423: machineid == HP_320 ? 16 : 32);
424: break;
425: case EC_PHYS:
426: printf(", %dK physical-address cache",
427: machineid == HP_370 ? 64 : 32);
428: break;
429: }
430: printf(")\n");
431: /*
432: * Now that we have told the user what they have,
433: * let them know if that machine type isn't configured.
434: */
435: switch (machineid) {
436: case -1: /* keep compilers happy */
437: #if !defined(HP320) && !defined(HP350)
438: case HP_320:
439: case HP_350:
440: #endif
441: #ifndef HP330
442: case HP_330:
443: #endif
444: #if !defined(HP360) && !defined(HP370)
445: case HP_340:
446: case HP_360:
447: case HP_370:
448: #endif
449: panic("CPU type not configured");
450: default:
451: break;
452: }
453: }
454:
455: #ifdef HPUXCOMPAT
456: tweaksigcode(ishpux)
457: {
458: static short *sigtrap = NULL;
459:
460: /* locate trap instruction in pcb_sigc */
461: if (sigtrap == NULL) {
462: register struct pcb *pcp = &u.u_pcb;
463:
464: sigtrap = &pcp->pcb_sigc[sizeof(pcp->pcb_sigc)/sizeof(short)];
465: while (--sigtrap >= pcp->pcb_sigc)
466: if ((*sigtrap & 0xFFF0) == 0x4E40)
467: break;
468: if (sigtrap < pcp->pcb_sigc)
469: panic("bogus sigcode\n");
470: }
471: *sigtrap = ishpux ? 0x4E42 : 0x4E41;
472: }
473: #endif
474:
475: #define SS_RTEFRAME 1
476: #define SS_FPSTATE 2
477: #define SS_USERREGS 4
478:
479: struct sigstate {
480: int ss_flags; /* which of the following are valid */
481: struct frame ss_frame; /* original exception frame */
482: struct fpframe ss_fpstate; /* 68881/68882 state info */
483: };
484:
485: /*
486: * WARNING: code in locore.s assumes the layout shown for sf_signum
487: * thru sf_handler so... don't screw with them!
488: */
489: struct sigframe {
490: int sf_signum; /* signo for handler */
491: int sf_code; /* additional info for handler */
492: struct sigcontext *sf_scp; /* context ptr for handler */
493: sig_t sf_handler; /* handler addr for u_sigc */
494: struct sigstate sf_state; /* state of the hardware */
495: struct sigcontext sf_sc; /* actual context */
496: };
497:
498: #ifdef HPUXCOMPAT
499: struct hpuxsigcontext {
500: int hsc_syscall;
501: char hsc_action;
502: char hsc_pad1;
503: char hsc_pad2;
504: char hsc_onstack;
505: int hsc_mask;
506: int hsc_sp;
507: short hsc_ps;
508: int hsc_pc;
509: /* the rest aren't part of the context but are included for our convenience */
510: short hsc_pad;
511: u_int hsc_magic; /* XXX sigreturn: cookie */
512: struct sigcontext *hsc_realsc; /* XXX sigreturn: ptr to BSD context */
513: };
514:
515: /*
516: * For an HP-UX process, a partial hpuxsigframe follows the normal sigframe.
517: * Tremendous waste of space, but some HP-UX applications (e.g. LCL) need it.
518: */
519: struct hpuxsigframe {
520: int hsf_signum;
521: int hsf_code;
522: struct sigcontext *hsf_scp;
523: struct hpuxsigcontext hsf_sc;
524: int hsf_regs[15];
525: };
526: #endif
527:
528: #ifdef DEBUG
529: int sigdebug = 0;
530: int sigpid = 0;
531: #define SDB_FOLLOW 0x01
532: #define SDB_KSTACK 0x02
533: #define SDB_FPSTATE 0x04
534: #endif
535:
536: /*
537: * Send an interrupt to process.
538: */
539: sendsig(catcher, sig, mask, code)
540: sig_t catcher;
541: int sig, mask;
542: unsigned code;
543: {
544: register struct proc *p = u.u_procp;
545: register struct sigframe *fp, *kfp;
546: register struct frame *frame;
547: register short ft;
548: int oonstack, fsize;
549:
550: frame = (struct frame *)u.u_ar0;
551: ft = frame->f_format;
552: oonstack = u.u_onstack;
553: /*
554: * Allocate and validate space for the signal handler
555: * context. Note that if the stack is in P0 space, the
556: * call to grow() is a nop, and the useracc() check
557: * will fail if the process has not already allocated
558: * the space with a `brk'.
559: */
560: #ifdef HPUXCOMPAT
561: if (p->p_flag & SHPUX)
562: fsize = sizeof(struct sigframe) + sizeof(struct hpuxsigframe);
563: else
564: #endif
565: fsize = sizeof(struct sigframe);
566: if (!u.u_onstack && (u.u_sigonstack & sigmask(sig))) {
567: fp = (struct sigframe *)(u.u_sigsp - fsize);
568: u.u_onstack = 1;
569: } else
570: fp = (struct sigframe *)(frame->f_regs[SP] - fsize);
571: if ((unsigned)fp <= USRSTACK - ctob(u.u_ssize))
572: (void)grow((unsigned)fp);
573: #ifdef DEBUG
574: if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
575: printf("sendsig(%d): sig %d ssp %x usp %x scp %x ft %d\n",
576: p->p_pid, sig, &oonstack, fp, &fp->sf_sc, ft);
577: #endif
578: if (useracc((caddr_t)fp, fsize, B_WRITE) == 0) {
579: #ifdef DEBUG
580: if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
581: printf("sendsig(%d): useracc failed on sig %d\n",
582: p->p_pid, sig);
583: #endif
584: /*
585: * Process has trashed its stack; give it an illegal
586: * instruction to halt it in its tracks.
587: */
588: SIGACTION(p, SIGILL) = SIG_DFL;
589: sig = sigmask(SIGILL);
590: p->p_sigignore &= ~sig;
591: p->p_sigcatch &= ~sig;
592: p->p_sigmask &= ~sig;
593: psignal(p, SIGILL);
594: return;
595: }
596: kfp = (struct sigframe *)malloc((u_long)fsize, M_TEMP, M_WAITOK);
597: /*
598: * Build the argument list for the signal handler.
599: */
600: kfp->sf_signum = sig;
601: kfp->sf_code = code;
602: kfp->sf_scp = &fp->sf_sc;
603: kfp->sf_handler = catcher;
604: /*
605: * Save necessary hardware state. Currently this includes:
606: * - general registers
607: * - original exception frame (if not a "normal" frame)
608: * - FP coprocessor state
609: */
610: kfp->sf_state.ss_flags = SS_USERREGS;
611: bcopy((caddr_t)frame->f_regs,
612: (caddr_t)kfp->sf_state.ss_frame.f_regs, sizeof frame->f_regs);
613: if (ft >= FMT9) {
614: #ifdef DEBUG
615: if (ft != FMT9 && ft != FMTA && ft != FMTB)
616: panic("sendsig: bogus frame type");
617: #endif
618: kfp->sf_state.ss_flags |= SS_RTEFRAME;
619: kfp->sf_state.ss_frame.f_format = frame->f_format;
620: kfp->sf_state.ss_frame.f_vector = frame->f_vector;
621: bcopy((caddr_t)&frame->F_u,
622: (caddr_t)&kfp->sf_state.ss_frame.F_u,
623: (ft == FMT9) ? FMT9SIZE :
624: (ft == FMTA) ? FMTASIZE : FMTBSIZE);
625: /*
626: * Gag! Leave an indicator that we need to clean up the
627: * kernel stack. We do this by setting the "pad word"
628: * above the hardware stack frame. "bexit" in locore
629: * will then know that it must compress the kernel stack
630: * and create a normal four word stack frame.
631: */
632: frame->f_stackadj = -1;
633: #ifdef DEBUG
634: if (sigdebug & SDB_FOLLOW)
635: printf("sendsig(%d): copy out %d of frame %d\n",
636: p->p_pid,
637: (ft == FMT9) ? FMT9SIZE :
638: (ft == FMTA) ? FMTASIZE : FMTBSIZE, ft);
639: #endif
640: }
641: #ifdef FPCOPROC
642: kfp->sf_state.ss_flags |= SS_FPSTATE;
643: m68881_save(&kfp->sf_state.ss_fpstate);
644: #ifdef DEBUG
645: if ((sigdebug & SDB_FPSTATE) && *(char *)&kfp->sf_state.ss_fpstate)
646: printf("sendsig(%d): copy out FP state (%x) to %x\n",
647: p->p_pid, *(u_int *)&kfp->sf_state.ss_fpstate,
648: &kfp->sf_state.ss_fpstate);
649: #endif
650: #endif
651: /*
652: * Build the signal context to be used by sigreturn.
653: */
654: kfp->sf_sc.sc_onstack = oonstack;
655: kfp->sf_sc.sc_mask = mask;
656: kfp->sf_sc.sc_sp = frame->f_regs[SP];
657: kfp->sf_sc.sc_fp = frame->f_regs[A6];
658: kfp->sf_sc.sc_ap = (int)&fp->sf_state;
659: kfp->sf_sc.sc_pc = frame->f_pc;
660: kfp->sf_sc.sc_ps = frame->f_sr;
661: #ifdef HPUXCOMPAT
662: /*
663: * Create an HP-UX style sigcontext structure and associated goo
664: */
665: if (p->p_flag & SHPUX) {
666: register struct hpuxsigframe *hkfp;
667:
668: hkfp = (struct hpuxsigframe *)&kfp[1];
669: hkfp->hsf_signum = bsdtohpuxsig(kfp->sf_signum);
670: hkfp->hsf_code = kfp->sf_code;
671: hkfp->hsf_scp = (struct sigcontext *)
672: &((struct hpuxsigframe *)(&fp[1]))->hsf_sc;
673: hkfp->hsf_sc.hsc_syscall = 0; /* XXX */
674: hkfp->hsf_sc.hsc_action = 0; /* XXX */
675: hkfp->hsf_sc.hsc_pad1 = hkfp->hsf_sc.hsc_pad2 = 0;
676: hkfp->hsf_sc.hsc_onstack = kfp->sf_sc.sc_onstack;
677: hkfp->hsf_sc.hsc_mask = kfp->sf_sc.sc_mask;
678: hkfp->hsf_sc.hsc_sp = kfp->sf_sc.sc_sp;
679: hkfp->hsf_sc.hsc_ps = kfp->sf_sc.sc_ps;
680: hkfp->hsf_sc.hsc_pc = kfp->sf_sc.sc_pc;
681: hkfp->hsf_sc.hsc_pad = 0;
682: hkfp->hsf_sc.hsc_magic = 0xdeadbeef;
683: hkfp->hsf_sc.hsc_realsc = kfp->sf_scp;
684: bcopy((caddr_t)frame->f_regs, (caddr_t)hkfp->hsf_regs,
685: sizeof (hkfp->hsf_regs));
686:
687: kfp->sf_signum = hkfp->hsf_signum;
688: kfp->sf_scp = hkfp->hsf_scp;
689: }
690: #endif
691: (void) copyout((caddr_t)kfp, (caddr_t)fp, fsize);
692: frame->f_regs[SP] = (int)fp;
693: #ifdef DEBUG
694: if (sigdebug & SDB_FOLLOW)
695: printf("sendsig(%d): sig %d scp %x fp %x sc_sp %x sc_ap %x\n",
696: p->p_pid, sig, kfp->sf_scp, fp,
697: kfp->sf_sc.sc_sp, kfp->sf_sc.sc_ap);
698: #endif
699: /*
700: * User PC is set to signal trampoline code. The catch is that
701: * it must be set to reference the pcb via the user space address
702: * NOT via u. Assumption: u-area is at USRSTACK.
703: */
704: frame->f_pc = (int)((struct user *)USRSTACK)->u_pcb.pcb_sigc;
705: #ifdef DEBUG
706: if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
707: printf("sendsig(%d): sig %d returns\n",
708: p->p_pid, sig);
709: #endif
710: free((caddr_t)kfp, M_TEMP);
711: }
712:
713: /*
714: * System call to cleanup state after a signal
715: * has been taken. Reset signal mask and
716: * stack state from context left by sendsig (above).
717: * Return to previous pc and psl as specified by
718: * context left by sendsig. Check carefully to
719: * make sure that the user has not modified the
720: * psl to gain improper priviledges or to cause
721: * a machine fault.
722: */
723: /* ARGSUSED */
724: sigreturn(p, uap, retval)
725: struct proc *p;
726: struct args {
727: struct sigcontext *sigcntxp;
728: } *uap;
729: int *retval;
730: {
731: register struct sigcontext *scp;
732: register struct frame *frame;
733: register int rf;
734: struct sigcontext tsigc;
735: struct sigstate tstate;
736: int flags;
737:
738: scp = uap->sigcntxp;
739: #ifdef DEBUG
740: if (sigdebug & SDB_FOLLOW)
741: printf("sigreturn: pid %d, scp %x\n", p->p_pid, scp);
742: #endif
743: if ((int)scp & 1)
744: return (EINVAL);
745: #ifdef HPUXCOMPAT
746: /*
747: * Grab context as an HP-UX style context and determine if it
748: * was one that we contructed in sendsig.
749: */
750: if (p->p_flag & SHPUX) {
751: struct hpuxsigcontext *hscp = (struct hpuxsigcontext *)scp;
752: struct hpuxsigcontext htsigc;
753:
754: if (useracc((caddr_t)hscp, sizeof (*hscp), B_WRITE) == 0 ||
755: copyin((caddr_t)hscp, (caddr_t)&htsigc, sizeof htsigc))
756: return (EINVAL);
757: /*
758: * If not generated by sendsig or we cannot restore the
759: * BSD-style sigcontext, just restore what we can -- state
760: * will be lost, but them's the breaks.
761: */
762: hscp = &htsigc;
763: if (hscp->hsc_magic != 0xdeadbeef ||
764: (scp = hscp->hsc_realsc) == 0 ||
765: useracc((caddr_t)scp, sizeof (*scp), B_WRITE) == 0 ||
766: copyin((caddr_t)scp, (caddr_t)&tsigc, sizeof tsigc)) {
767: u.u_onstack = hscp->hsc_onstack & 01;
768: p->p_sigmask = hscp->hsc_mask &~ sigcantmask;
769: frame = (struct frame *) u.u_ar0;
770: frame->f_regs[SP] = hscp->hsc_sp;
771: frame->f_pc = hscp->hsc_pc;
772: frame->f_sr = hscp->hsc_ps &~ PSL_USERCLR;
773: return (EJUSTRETURN);
774: }
775: /*
776: * Otherwise, overlay BSD context with possibly modified
777: * HP-UX values.
778: */
779: tsigc.sc_onstack = hscp->hsc_onstack;
780: tsigc.sc_mask = hscp->hsc_mask;
781: tsigc.sc_sp = hscp->hsc_sp;
782: tsigc.sc_ps = hscp->hsc_ps;
783: tsigc.sc_pc = hscp->hsc_pc;
784: } else
785: #endif
786: /*
787: * Test and fetch the context structure.
788: * We grab it all at once for speed.
789: */
790: if (useracc((caddr_t)scp, sizeof (*scp), B_WRITE) == 0 ||
791: copyin((caddr_t)scp, (caddr_t)&tsigc, sizeof tsigc))
792: return (EINVAL);
793: scp = &tsigc;
794: if ((scp->sc_ps & (PSL_MBZ|PSL_IPL|PSL_S)) != 0)
795: return (EINVAL);
796: /*
797: * Restore the user supplied information
798: */
799: u.u_onstack = scp->sc_onstack & 01;
800: p->p_sigmask = scp->sc_mask &~ sigcantmask;
801: frame = (struct frame *) u.u_ar0;
802: frame->f_regs[SP] = scp->sc_sp;
803: frame->f_regs[A6] = scp->sc_fp;
804: frame->f_pc = scp->sc_pc;
805: frame->f_sr = scp->sc_ps;
806: /*
807: * Grab pointer to hardware state information.
808: * If zero, the user is probably doing a longjmp.
809: */
810: if ((rf = scp->sc_ap) == 0)
811: return (EJUSTRETURN);
812: /*
813: * See if there is anything to do before we go to the
814: * expense of copying in close to 1/2K of data
815: */
816: flags = fuword((caddr_t)rf);
817: #ifdef DEBUG
818: if (sigdebug & SDB_FOLLOW)
819: printf("sigreturn(%d): sc_ap %x flags %x\n",
820: p->p_pid, rf, flags);
821: #endif
822: if (flags == 0 || copyin((caddr_t)rf, (caddr_t)&tstate, sizeof tstate))
823: return (EJUSTRETURN);
824: #ifdef DEBUG
825: if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
826: printf("sigreturn(%d): ssp %x usp %x scp %x ft %d\n",
827: p->p_pid, &flags, scp->sc_sp, uap->sigcntxp,
828: (flags&SS_RTEFRAME) ? tstate.ss_frame.f_format : -1);
829: #endif
830: /*
831: * Restore most of the users registers except for A6 and SP
832: * which were handled above.
833: */
834: if (flags & SS_USERREGS)
835: bcopy((caddr_t)tstate.ss_frame.f_regs,
836: (caddr_t)frame->f_regs, sizeof(frame->f_regs)-2*NBPW);
837: /*
838: * Restore long stack frames. Note that we do not copy
839: * back the saved SR or PC, they were picked up above from
840: * the sigcontext structure.
841: */
842: if (flags & SS_RTEFRAME) {
843: register int sz;
844:
845: /* grab frame type and validate */
846: sz = tstate.ss_frame.f_format;
847: if (sz == FMT9)
848: sz = FMT9SIZE;
849: else if (sz == FMTA)
850: sz = FMTASIZE;
851: else if (sz == FMTB) {
852: sz = FMTBSIZE;
853: /* no k-stack adjustment necessary */
854: frame->f_stackadj = 0;
855: } else
856: return (EINVAL);
857: frame->f_format = tstate.ss_frame.f_format;
858: frame->f_vector = tstate.ss_frame.f_vector;
859: bcopy((caddr_t)&tstate.ss_frame.F_u, (caddr_t)&frame->F_u, sz);
860: #ifdef DEBUG
861: if (sigdebug & SDB_FOLLOW)
862: printf("sigreturn(%d): copy in %d of frame type %d\n",
863: p->p_pid, sz, tstate.ss_frame.f_format);
864: #endif
865: }
866: #ifdef FPCOPROC
867: /*
868: * Finally we restore the original FP context
869: */
870: if (flags & SS_FPSTATE)
871: m68881_restore(&tstate.ss_fpstate);
872: #ifdef DEBUG
873: if ((sigdebug & SDB_FPSTATE) && *(char *)&tstate.ss_fpstate)
874: printf("sigreturn(%d): copied in FP state (%x) at %x\n",
875: p->p_pid, *(u_int *)&tstate.ss_fpstate,
876: &tstate.ss_fpstate);
877: #endif
878: #endif
879: #ifdef DEBUG
880: if ((sigdebug & SDB_FOLLOW) ||
881: ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid))
882: printf("sigreturn(%d): returns\n", p->p_pid);
883: #endif
884: return (EJUSTRETURN);
885: }
886:
887: int waittime = -1;
888:
889: boot(howto)
890: register int howto;
891: {
892: /* take a snap shot before clobbering any registers */
893: resume((u_int)pcbb(u.u_procp));
894:
895: boothowto = howto;
896: if ((howto&RB_NOSYNC) == 0 && waittime < 0 && bfreelist[0].b_forw) {
897: register struct buf *bp;
898: int iter, nbusy;
899:
900: waittime = 0;
901: (void) spl0();
902: printf("syncing disks... ");
903: /*
904: * Release vnodes held by texts before sync.
905: */
906: if (panicstr == 0)
907: xumount(NULL);
908: #include "fd.h"
909: #if NFD > 0
910: fdshutdown();
911: #endif
912: sync((struct sigcontext *)0);
913:
914: for (iter = 0; iter < 20; iter++) {
915: nbusy = 0;
916: for (bp = &buf[nbuf]; --bp >= buf; )
917: if ((bp->b_flags & (B_BUSY|B_INVAL)) == B_BUSY)
918: nbusy++;
919: if (nbusy == 0)
920: break;
921: printf("%d ", nbusy);
922: DELAY(40000 * iter);
923: }
924: if (nbusy)
925: printf("giving up\n");
926: else
927: printf("done\n");
928: /*
929: * If we've been adjusting the clock, the todr
930: * will be out of synch; adjust it now.
931: */
932: resettodr();
933: }
934: splhigh(); /* extreme priority */
935: if (howto&RB_HALT) {
936: printf("halted\n\n");
937: asm(" stop #0x2700");
938: } else {
939: if (howto & RB_DUMP)
940: dumpsys();
941: doboot();
942: /*NOTREACHED*/
943: }
944: /*NOTREACHED*/
945: }
946:
947: int dumpmag = 0x8fca0101; /* magic number for savecore */
948: int dumpsize = 0; /* also for savecore */
949:
950: dumpconf()
951: {
952: int nblks;
953:
954: dumpsize = physmem;
955: if (dumpdev != NODEV && bdevsw[major(dumpdev)].d_psize) {
956: nblks = (*bdevsw[major(dumpdev)].d_psize)(dumpdev);
957: if (dumpsize > btoc(dbtob(nblks - dumplo)))
958: dumpsize = btoc(dbtob(nblks - dumplo));
959: else if (dumplo == 0)
960: dumplo = nblks - btodb(ctob(physmem));
961: }
962: /*
963: * Don't dump on the first CLBYTES (why CLBYTES?)
964: * in case the dump device includes a disk label.
965: */
966: if (dumplo < btodb(CLBYTES))
967: dumplo = btodb(CLBYTES);
968: }
969:
970: /*
971: * Doadump comes here after turning off memory management and
972: * getting on the dump stack, either when called above, or by
973: * the auto-restart code.
974: */
975: dumpsys()
976: {
977:
978: msgbufmapped = 0;
979: if (dumpdev == NODEV)
980: return;
981: /*
982: * For dumps during autoconfiguration,
983: * if dump device has already configured...
984: */
985: if (dumpsize == 0)
986: dumpconf();
987: if (dumplo < 0)
988: return;
989: printf("\ndumping to dev %x, offset %d\n", dumpdev, dumplo);
990: printf("dump ");
991: switch ((*bdevsw[major(dumpdev)].d_dump)(dumpdev)) {
992:
993: case ENXIO:
994: printf("device bad\n");
995: break;
996:
997: case EFAULT:
998: printf("device not ready\n");
999: break;
1000:
1001: case EINVAL:
1002: printf("area improper\n");
1003: break;
1004:
1005: case EIO:
1006: printf("i/o error\n");
1007: break;
1008:
1009: default:
1010: printf("succeeded\n");
1011: break;
1012: }
1013: }
1014:
1015: /*
1016: * Return the best possible estimate of the time in the timeval
1017: * to which tvp points. We do this by returning the current time
1018: * plus the amount of time since the last clock interrupt (clock.c:clkread).
1019: *
1020: * Check that this time is no less than any previously-reported time,
1021: * which could happen around the time of a clock adjustment. Just for fun,
1022: * we guarantee that the time will be greater than the value obtained by a
1023: * previous call.
1024: */
1025: microtime(tvp)
1026: register struct timeval *tvp;
1027: {
1028: int s = splhigh();
1029: static struct timeval lasttime;
1030:
1031: *tvp = time;
1032: tvp->tv_usec += clkread();
1033: while (tvp->tv_usec > 1000000) {
1034: tvp->tv_sec++;
1035: tvp->tv_usec -= 1000000;
1036: }
1037: if (tvp->tv_sec == lasttime.tv_sec &&
1038: tvp->tv_usec <= lasttime.tv_usec &&
1039: (tvp->tv_usec = lasttime.tv_usec + 1) > 1000000) {
1040: tvp->tv_sec++;
1041: tvp->tv_usec -= 1000000;
1042: }
1043: lasttime = *tvp;
1044: splx(s);
1045: }
1046:
1047: initcpu()
1048: {
1049: parityenable();
1050: }
1051:
1052: straytrap(addr)
1053: register int addr;
1054: {
1055: printf("stray trap, addr 0x%x\n", addr);
1056: }
1057:
1058: int *nofault;
1059:
1060: badaddr(addr)
1061: register caddr_t addr;
1062: {
1063: register int i;
1064: label_t faultbuf;
1065:
1066: #ifdef lint
1067: i = *addr; if (i) return(0);
1068: #endif
1069: nofault = (int *) &faultbuf;
1070: if (setjmp((label_t *)nofault)) {
1071: nofault = (int *) 0;
1072: return(1);
1073: }
1074: i = *(volatile short *)addr;
1075: nofault = (int *) 0;
1076: return(0);
1077: }
1078:
1079: badbaddr(addr)
1080: register caddr_t addr;
1081: {
1082: register int i;
1083: label_t faultbuf;
1084:
1085: #ifdef lint
1086: i = *addr; if (i) return(0);
1087: #endif
1088: nofault = (int *) &faultbuf;
1089: if (setjmp((label_t *)nofault)) {
1090: nofault = (int *) 0;
1091: return(1);
1092: }
1093: i = *(volatile char *)addr;
1094: nofault = (int *) 0;
1095: return(0);
1096: }
1097:
1098: netintr()
1099: {
1100: #ifdef INET
1101: if (netisr & (1 << NETISR_IP)) {
1102: netisr &= ~(1 << NETISR_IP);
1103: ipintr();
1104: }
1105: #endif
1106: #ifdef NS
1107: if (netisr & (1 << NETISR_NS)) {
1108: netisr &= ~(1 << NETISR_NS);
1109: nsintr();
1110: }
1111: #endif
1112: #ifdef ISO
1113: if (netisr & (1 << NETISR_ISO)) {
1114: netisr &= ~(1 << NETISR_ISO);
1115: clnlintr();
1116: }
1117: #endif
1118: }
1119:
1120: intrhand(sr)
1121: int sr;
1122: {
1123: register struct isr *isr;
1124: register int found = 0;
1125: register int ipl;
1126: extern struct isr isrqueue[];
1127:
1128: ipl = (sr >> 8) & 7;
1129: switch (ipl) {
1130:
1131: case 3:
1132: case 4:
1133: case 5:
1134: ipl = ISRIPL(ipl);
1135: isr = isrqueue[ipl].isr_forw;
1136: for (; isr != &isrqueue[ipl]; isr = isr->isr_forw) {
1137: if ((isr->isr_intr)(isr->isr_arg)) {
1138: found++;
1139: break;
1140: }
1141: }
1142: if (found == 0)
1143: printf("stray interrupt, sr 0x%x\n", sr);
1144: break;
1145:
1146: case 0:
1147: case 1:
1148: case 2:
1149: case 6:
1150: case 7:
1151: printf("intrhand: unexpected sr 0x%x\n", sr);
1152: break;
1153: }
1154: }
1155:
1156: #if defined(DEBUG) && !defined(PANICBUTTON)
1157: #define PANICBUTTON
1158: #endif
1159:
1160: #ifdef PANICBUTTON
1161: int panicbutton = 1; /* non-zero if panic buttons are enabled */
1162: int crashandburn = 0;
1163: int candbdelay = 50; /* give em half a second */
1164:
1165: candbtimer()
1166: {
1167: crashandburn = 0;
1168: }
1169: #endif
1170:
1171: /*
1172: * Level 7 interrupts can be caused by the keyboard or parity errors.
1173: */
1174: nmihand(frame)
1175: struct frame frame;
1176: {
1177: if (kbdnmi()) {
1178: #ifdef PANICBUTTON
1179: printf("Got a keyboard NMI\n");
1180: if (panicbutton) {
1181: if (crashandburn) {
1182: crashandburn = 0;
1183: panic(panicstr ?
1184: "forced crash, nosync" : "forced crash");
1185: }
1186: crashandburn++;
1187: timeout(candbtimer, (caddr_t)0, candbdelay);
1188: }
1189: #endif
1190: return;
1191: }
1192: if (parityerror(&frame))
1193: return;
1194: /* panic?? */
1195: printf("unexpected level 7 interrupt ignored\n");
1196: }
1197:
1198: /*
1199: * Parity error section. Contains magic.
1200: */
1201: #define PARREG ((volatile short *)IOV(0x5B0000))
1202: static int gotparmem = 0;
1203: #ifdef DEBUG
1204: int ignorekperr = 0; /* ignore kernel parity errors */
1205: #endif
1206:
1207: /*
1208: * Enable parity detection
1209: */
1210: parityenable()
1211: {
1212: label_t faultbuf;
1213:
1214: nofault = (int *) &faultbuf;
1215: if (setjmp((label_t *)nofault)) {
1216: nofault = (int *) 0;
1217: #ifdef DEBUG
1218: printf("No parity memory\n");
1219: #endif
1220: return;
1221: }
1222: *PARREG = 1;
1223: nofault = (int *) 0;
1224: gotparmem = 1;
1225: #ifdef DEBUG
1226: printf("Parity detection enabled\n");
1227: #endif
1228: }
1229:
1230: /*
1231: * Determine if level 7 interrupt was caused by a parity error
1232: * and deal with it if it was. Returns 1 if it was a parity error.
1233: */
1234: parityerror(fp)
1235: struct frame *fp;
1236: {
1237: if (!gotparmem)
1238: return(0);
1239: *PARREG = 0;
1240: DELAY(10);
1241: *PARREG = 1;
1242: if (panicstr) {
1243: printf("parity error after panic ignored\n");
1244: return(1);
1245: }
1246: if (!findparerror())
1247: printf("WARNING: transient parity error ignored\n");
1248: else if (USERMODE(fp->f_sr)) {
1249: printf("pid %d: parity error\n", u.u_procp->p_pid);
1250: uprintf("sorry, pid %d killed due to memory parity error\n",
1251: u.u_procp->p_pid);
1252: psignal(u.u_procp, SIGKILL);
1253: #ifdef DEBUG
1254: } else if (ignorekperr) {
1255: printf("WARNING: kernel parity error ignored\n");
1256: #endif
1257: } else {
1258: regdump(fp->f_regs, 128);
1259: panic("kernel parity error");
1260: }
1261: return(1);
1262: }
1263:
1264: /*
1265: * Yuk! There has got to be a better way to do this!
1266: * Searching all of memory with interrupts blocked can lead to disaster.
1267: */
1268: findparerror()
1269: {
1270: static label_t parcatch;
1271: static int looking = 0;
1272: volatile struct pte opte;
1273: volatile int pg, o, s;
1274: register volatile int *ip;
1275: register int i;
1276: int found;
1277:
1278: #ifdef lint
1279: ip = &found;
1280: i = o = pg = 0; if (i) return(0);
1281: #endif
1282: /*
1283: * If looking is true we are searching for a known parity error
1284: * and it has just occured. All we do is return to the higher
1285: * level invocation.
1286: */
1287: if (looking)
1288: longjmp(&parcatch);
1289: s = splhigh();
1290: /*
1291: * If setjmp returns true, the parity error we were searching
1292: * for has just occured (longjmp above) at the current pg+o
1293: */
1294: if (setjmp(&parcatch)) {
1295: printf("Parity error at 0x%x\n", ctob(pg)|o);
1296: found = 1;
1297: goto done;
1298: }
1299: /*
1300: * If we get here, a parity error has occured for the first time
1301: * and we need to find it. We turn off any external caches and
1302: * loop thru memory, testing every longword til a fault occurs and
1303: * we regain control at setjmp above. Note that because of the
1304: * setjmp, pg and o need to be volatile or their values will be lost.
1305: */
1306: looking = 1;
1307: ecacheoff();
1308: opte = mmap[0];
1309: for (pg = btoc(lowram); pg < btoc(lowram)+physmem; pg++) {
1310: *(u_int *)mmap = PG_RO|PG_CI|PG_V;
1311: mmap[0].pg_pfnum = pg;
1312: TBIS(vmmap);
1313: ip = (int *)vmmap;
1314: for (o = 0; o < NBPG; o += sizeof(int))
1315: i = *ip++;
1316: }
1317: /*
1318: * Getting here implies no fault was found. Should never happen.
1319: */
1320: printf("Couldn't locate parity error\n");
1321: found = 0;
1322: done:
1323: looking = 0;
1324: mmap[0] = opte;
1325: TBIS(vmmap);
1326: ecacheon();
1327: splx(s);
1328: return(found);
1329: }
1330:
1331: regdump(rp, sbytes)
1332: int *rp; /* must not be register */
1333: int sbytes;
1334: {
1335: static int doingdump = 0;
1336: register int i;
1337: int s;
1338: extern char *hexstr();
1339:
1340: if (doingdump)
1341: return;
1342: s = splhigh();
1343: doingdump = 1;
1344: printf("pid = %d, pc = %s, ", u.u_procp->p_pid, hexstr(rp[PC], 8));
1345: printf("ps = %s, ", hexstr(rp[PS], 4));
1346: printf("sfc = %s, ", hexstr(getsfc(), 4));
1347: printf("dfc = %s\n", hexstr(getdfc(), 4));
1348: printf("p0 = %x@%s, ",
1349: u.u_pcb.pcb_p0lr, hexstr((int)u.u_pcb.pcb_p0br, 8));
1350: printf("p1 = %x@%s\n\n",
1351: u.u_pcb.pcb_p1lr, hexstr((int)u.u_pcb.pcb_p1br, 8));
1352: printf("Registers:\n ");
1353: for (i = 0; i < 8; i++)
1354: printf(" %d", i);
1355: printf("\ndreg:");
1356: for (i = 0; i < 8; i++)
1357: printf(" %s", hexstr(rp[i], 8));
1358: printf("\nareg:");
1359: for (i = 0; i < 8; i++)
1360: printf(" %s", hexstr(rp[i+8], 8));
1361: if (sbytes > 0) {
1362: if (rp[PS] & PSL_S) {
1363: printf("\n\nKernel stack (%s):",
1364: hexstr((int)(((int *)&rp)-1), 8));
1365: dumpmem(((int *)&rp)-1, sbytes, 0);
1366: } else {
1367: printf("\n\nUser stack (%s):", hexstr(rp[SP], 8));
1368: dumpmem((int *)rp[SP], sbytes, 1);
1369: }
1370: }
1371: doingdump = 0;
1372: splx(s);
1373: }
1374:
1375: #define KSADDR ((int *)&(((char *)&u)[(UPAGES-1)*NBPG]))
1376:
1377: dumpmem(ptr, sz, ustack)
1378: register int *ptr;
1379: int sz;
1380: {
1381: register int i, val;
1382: extern char *hexstr();
1383:
1384: for (i = 0; i < sz; i++) {
1385: if ((i & 7) == 0)
1386: printf("\n%s: ", hexstr((int)ptr, 6));
1387: else
1388: printf(" ");
1389: if (ustack == 1) {
1390: if ((val = fuword(ptr++)) == -1)
1391: break;
1392: } else {
1393: if (ustack == 0 && (ptr < KSADDR || ptr > KSADDR+(NBPG/4-1)))
1394: break;
1395: val = *ptr++;
1396: }
1397: printf("%s", hexstr(val, 8));
1398: }
1399: printf("\n");
1400: }
1401:
1402: char *
1403: hexstr(val, len)
1404: register int val;
1405: {
1406: static char nbuf[9];
1407: register int x, i;
1408:
1409: if (len > 8)
1410: return("");
1411: nbuf[len] = '\0';
1412: for (i = len-1; i >= 0; --i) {
1413: x = val & 0xF;
1414: if (x > 9)
1415: nbuf[i] = x - 10 + 'A';
1416: else
1417: nbuf[i] = x + '0';
1418: val >>= 4;
1419: }
1420: return(nbuf);
1421: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.