![[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.vax / sys|
Return to machdep.c CVS log | Up to [Research Unix] / researchv9 / sys.vax / sys |
1.1 root 1: /* machdep.c 4.36 81/05/09 */
2:
3: #include "../h/param.h"
4: #include "../h/systm.h"
5: #include "../h/dir.h"
6: #include "../h/user.h"
7: #include "../h/map.h"
8: #include "../h/reg.h"
9: #include "../h/mtpr.h"
10: #include "../h/clock.h"
11: #include "../h/pte.h"
12: #include "../h/vm.h"
13: #include "../h/lnode.h"
14: #include "../h/proc.h"
15: #include "../h/psl.h"
16: #include "../h/buf.h"
17: #include "../h/nexus.h"
18: #include "../h/ubavar.h"
19: #include "../h/ubareg.h"
20: #include "../h/cons.h"
21: #include "../h/reboot.h"
22: #include "../h/conf.h"
23: #include "../h/mem.h"
24: #include "../h/cpu.h"
25: #include "../h/inode.h"
26: #include "../h/file.h"
27: #include "../h/text.h"
28: #include "../h/callout.h"
29: #include "../h/cmap.h"
30: #include <frame.h>
31: #include "../h/rpb.h"
32: #include <time.h>
33:
34: int icode[] =
35: {
36: 0x9f19af9f, /* pushab [&"init",0]; pushab */
37: 0x02dd09af, /* "/etc/init"; pushl $2 */
38: 0xbc5c5ed0, /* movl sp,ap; chmk */
39: 0x2ffe110b, /* $exec; brb .; "/ */
40: 0x2f637465, /* etc/ */
41: 0x74696e69, /* init" */
42: 0x00000000, /* \0\0\0"; 0 */
43: 0x00000014, /* [&"init", */
44: 0x00000000, /* 0] */
45: };
46: int szicode = sizeof(icode);
47:
48: /*
49: * Declare these as initialized data so we can patch them.
50: */
51: int nbuf = 0;
52: int nswbuf = 0;
53:
54: /*
55: * Machine-dependent startup code
56: */
57: startup(firstaddr)
58: int firstaddr;
59: {
60: register int unixsize;
61: register unsigned i;
62: register struct pte *pte;
63: register caddr_t v;
64:
65: /*
66: * Initialize error message buffer (at end of core).
67: */
68: maxmem -= CLSIZE;
69: pte = msgbufmap;
70: for (i = 0; i < CLSIZE; i++)
71: *(int *)pte++ = PG_V | PG_KW | (maxmem + i);
72: mtpr(TBIA, 1);
73:
74: /*
75: * Good {morning,afternoon,evening,night}.
76: */
77: printf(version);
78:
79: /*
80: * First determine how many buffers are reasonable.
81: * Current alg is 32 per megabyte, with min of 32.
82: * We allocate 1/2 as many swap buffer headers as file i/o buffers.
83: */
84: if (nbuf == 0) {
85: nbuf = (32 * physmem) / btoc(1024*1024);
86: if (nbuf < 32)
87: nbuf = 32;
88: }
89: if (nswbuf == 0) {
90: nswbuf = (nbuf / 2) &~ 1; /* force even */
91: if (nswbuf > 256)
92: nswbuf = 256; /* sanity */
93: }
94: printf("real mem = %d nbuf = %d nswbuf = %d\n", ctob(maxmem),
95: nbuf, nswbuf);
96:
97: /*
98: * Allocate space for system data structures.
99: */
100: v = (caddr_t)(0x80000000 | (firstaddr * NBPG));
101: #define valloc(name, type, num) \
102: (name) = (type *)(v); (v) = (caddr_t)((name)+(num))
103: #define valloclim(name, type, num, lim) \
104: (name) = (type *)(v); (v) = (caddr_t)((lim) = ((name)+(num)))
105: valloc(buffers, char, BUFSIZE*nbuf);
106: valloc(buf, struct buf, nbuf);
107: valloc(swbuf, struct buf, nswbuf);
108: valloc(swsize, short, nswbuf); /* note: nswbuf is even */
109: valloc(swpf, int, nswbuf);
110: valloclim(inode, struct inode, ninode, inodeNINODE);
111: valloclim(file, struct file, nfile, fileNFILE);
112: valloclim(proc, struct proc, nproc, procNPROC);
113: valloclim(text, struct text, ntext, textNTEXT);
114: valloclim(lnodes, struct kern_lnode, maxusers, lnodesMAXUSERS);
115: valloc(callout, struct callout, ncallout);
116: valloc(swapmap, struct map, nswapmap = nproc * 2);
117: valloc(argmap, struct map, ARGMAPSIZE);
118: valloc(kernelmap, struct map, nproc);
119:
120: /*
121: * Now allocate space for core map
122: */
123: ncmap = (physmem*NBPG - ((int)v &~ 0x80000000)) /
124: (NBPG*CLSIZE + sizeof (struct cmap));
125: valloclim(cmap, struct cmap, ncmap, ecmap);
126: if ((((int)(ecmap+1))&~0x80000000) > SYSPTSIZE*NBPG)
127: panic("sys pt too small");
128:
129: /*
130: * Clear allocated space, and make r/w entries
131: * for the space in the kernel map.
132: */
133: unixsize = btoc((int)(ecmap+1) &~ 0x80000000);
134: if (unixsize >= physmem - 8*UPAGES)
135: panic("no memory");
136: for (i = firstaddr; i < unixsize; i++) {
137: *(int *)(&Sysmap[i]) = PG_V | PG_KW | i;
138: clearseg(i);
139: }
140: mtpr(TBIA, 1);
141:
142: /*
143: * Initialize callouts
144: */
145: callfree = callout;
146: for (i = 1; i < ncallout; i++)
147: callout[i-1].c_next = &callout[i];
148:
149: /*
150: * Initialize memory allocator and swap
151: * and user page table maps.
152: *
153: * THE USER PAGE TABLE MAP IS CALLED ``kernelmap''
154: * WHICH IS A VERY UNDESCRIPTIVE AND INCONSISTENT NAME.
155: */
156: meminit(unixsize, maxmem);
157: maxmem = freemem;
158: printf("avail mem = %d\n", ctob(maxmem));
159: rminit(kernelmap, USRPTSIZE, 1, "usrpt", nproc);
160:
161: /*
162: * Configure the system.
163: */
164: configure();
165:
166: /*
167: * Clear restart inhibit flags.
168: */
169: tocons(TXDB_CWSI);
170: tocons(TXDB_CCSI);
171: }
172:
173: /*
174: * set up a physical address
175: * into users virtual address space.
176: */
177: sysphys()
178: {
179:
180: if(!suser())
181: return;
182: u.u_error = EINVAL;
183: }
184:
185: /*
186: * Initialze the clock, based on the time base which is, e.g.
187: * from a filesystem. Base provides the time to within six months,
188: * and the time of year clock provides the rest.
189: */
190: clkinit(base)
191: time_t base;
192: {
193: register unsigned todr = mfpr(TODR);
194: long deltat;
195: int year = YRREF;
196: unsigned secyr;
197:
198: #ifdef MVAX
199: /*
200: * Get the MicroVAX-II's toy register.
201: * Convert it to the time format that the todr is
202: * normally kept in.
203: */
204: if( cpu == M_VAX ) {
205: todr = gettoy();
206: for (;;) {
207: secyr = SECYR;
208: if (LEAPYEAR(year))
209: secyr += SECDAY;
210: if (todr < secyr)
211: break;
212: todr -= secyr;
213: year++;
214: }
215: year = YRREF;
216: todr = TODRZERO + todr*100;
217: }
218: #endif MVAX
219: if (base < 5*SECYR) {
220: printf("WARNING: preposterous time in file system");
221: time = 6*SECYR + 186*SECDAY + SECDAY/2;
222: clkset();
223: goto check;
224: }
225: /*
226: * Have been told that VMS keeps time internally with base TODRZERO.
227: * If this is correct, then this routine and VMS should maintain
228: * the same date, and switching shouldn't be painful.
229: * (Unfortunately, VMS keeps local time, so when you run UNIX
230: * and VMS, VMS runs on GMT...).
231: */
232: if (todr < TODRZERO) {
233: printf("WARNING: todr too small");
234: time = base;
235: /*
236: * Believe the time in the file system for lack of
237: * anything better, resetting the TODR.
238: */
239: clkset();
240: goto check;
241: }
242: /*
243: * Sneak to within 6 month of the time in the filesystem,
244: * by starting with the time of the year suggested by the TODR,
245: * and advancing through succesive years. Adding the number of
246: * seconds in the current year takes us to the end of the current year
247: * and then around into the next year to the same position.
248: */
249: for (time = (todr-TODRZERO)/100; time < base-SECYR/2; time += SECYR) {
250: if (LEAPYEAR(year))
251: time += SECDAY;
252: year++;
253: }
254:
255: /*
256: * The hardware and software clocks are now in sync, so it is
257: * safe to call clkset() to get its side effect, which is to
258: * initialize yearbase.
259: */
260: clkset();
261:
262: /*
263: * See if we gained/lost two or more days;
264: * if so, assume something is amiss.
265: */
266: deltat = time - base;
267: if (deltat < 0)
268: deltat = -deltat;
269: if (deltat < 2*SECDAY)
270: return;
271: printf("WARNING: clock %s %d days",
272: time < base ? "lost" : "gained", deltat / SECDAY);
273: check:
274: printf(" -- CHECK AND RESET THE DATE!\n");
275: }
276:
277: /* Time in seconds from the epoch to the start of the current year */
278: time_t yearbase;
279:
280: /*
281: * Reset the TODR based on the time value; used when the TODR
282: * has a preposterous value and also when the time is reset
283: * by the stime system call. Also called when the TODR goes past
284: * TODRZERO + 100*(SECYEAR+2*SECDAY) (e.g. on Jan 2 just after midnight)
285: * to wrap the TODR around.
286: *
287: * Side effect: yearbase is set appropriately.
288: */
289:
290: clkset()
291: {
292: int year = YRREF;
293: unsigned secyr;
294: unsigned yrtime = time;
295:
296: yearbase = 0;
297:
298: /*
299: * Whittle the time down to an offset in the current year,
300: * by subtracting off whole years as long as possible.
301: */
302: #ifdef MVAX
303: if( cpu == M_VAX ) {
304: settoy( yrtime );
305: return;
306: }
307: #endif MVAX
308: for (;;) {
309: secyr = SECYR;
310: if (LEAPYEAR(year))
311: secyr += SECDAY;
312: if (yrtime < secyr)
313: break;
314: yrtime -= secyr;
315: yearbase += secyr;
316: year++;
317: }
318: mtpr(TODR, TODRZERO + yrtime*100);
319: }
320:
321: #ifdef MVAX
322: /*
323: * This routine sets the time of year clock on the MicroVAX-II.
324: */
325: static int dmsize[12] =
326: { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
327:
328: #define dysize(A) (((A)%4)? 365: 366)
329:
330: gettoy()
331: {
332: int i, sec=0;
333: struct tm tm;
334: int s;
335: register struct qb_regs *qb_regs = (struct qb_regs *)nexus;
336:
337: /*
338: * Copy the toy register contents into tm so that we can
339: * work with. The toy must be completely read in 2.5 millisecs.
340: *
341: *
342: * Wait for update in progress to be done.
343: */
344: while( qb_regs->qb_toycsra & QBT_UIP )
345: ;
346: s = spl7();
347: tm.tm_sec = qb_regs->qb_toysecs;
348: tm.tm_min = qb_regs->qb_toymins;
349: tm.tm_hour = qb_regs->qb_toyhours;
350: tm.tm_mday = qb_regs->qb_toyday;
351: tm.tm_mon = qb_regs->qb_toymonth;
352: tm.tm_year = qb_regs->qb_toyyear;
353: splx( s );
354: /*
355: * sanity check the clock
356: */
357: if( tm.tm_sec < 0 || tm.tm_sec >59 ||
358: tm.tm_min < 0 || tm.tm_min > 59 ||
359: tm.tm_hour < 0 || tm.tm_hour > 23 ||
360: tm.tm_mday < 1 || tm.tm_mday > 31 ||
361: tm.tm_mon < 1 || tm.tm_mon >12 ||
362: tm.tm_year < 70 || tm.tm_year > 99 )
363: return 0;
364: /*
365: * Added up the seconds since the epoch
366: */
367: tm.tm_year += 1900;
368: for (i = 1970; i < tm.tm_year; i++)
369: sec += dysize(i);
370: /*
371: * Leap tm.tm_year
372: */
373: if (dysize(tm.tm_year) == 366 && tm.tm_mon >= 3)
374: sec++;
375: /*
376: * Do the current tm.tm_year
377: */
378: for( i=0 ; i < tm.tm_mon-1 ; i++ )
379: sec += dmsize[i];
380: sec += tm.tm_mday-1;
381: sec = 24*sec + tm.tm_hour;
382: sec = 60*sec + tm.tm_min;
383: sec = 60*sec + tm.tm_sec;
384: return (sec);
385: }
386:
387: /*
388: * This routine is used to set the MicroVAX-II toy register.
389: */
390: settoy( tim )
391: {
392: register int d0, d1;
393: long hms, day;
394: register int *tp;
395: struct tm xtime;
396: int s;
397: register struct qb_regs *qb_regs = (struct qb_regs *)nexus;
398:
399: /*
400: * break initial number into days
401: */
402: hms = tim % 86400;
403: day = tim / 86400;
404: if (hms<0) {
405: hms += 86400;
406: day -= 1;
407: }
408: tp = (int *)&xtime;
409:
410: /*
411: * generate hours:minutes:seconds
412: */
413: *tp++ = hms%60;
414: d1 = hms/60;
415: *tp++ = d1%60;
416: d1 /= 60;
417: *tp++ = d1;
418:
419: /*
420: * year number
421: */
422: if (day>=0) for(d1=70; day >= dysize(d1); d1++)
423: day -= dysize(d1);
424: else for (d1=70; day<0; d1--)
425: day += dysize(d1-1);
426: xtime.tm_year = d1;
427: xtime.tm_yday = d0 = day;
428:
429: /*
430: * generate month
431: */
432:
433: if (dysize(d1)==366)
434: dmsize[1] = 29;
435: for(d1=0; d0 >= dmsize[d1]; d1++)
436: d0 -= dmsize[d1];
437: dmsize[1] = 28;
438: *tp++ = d0+1;
439: *tp++ = d1+1;
440: xtime.tm_isdst = 0;
441: /*
442: * Copy the time into the toy.
443: */
444: qb_regs->qb_toycsrb = QBT_SETUP;
445: s = spl7();
446: qb_regs->qb_toysecs = xtime.tm_sec;
447: qb_regs->qb_toymins = xtime.tm_min;
448: qb_regs->qb_toyhours = xtime.tm_hour;
449: qb_regs->qb_toyday = xtime.tm_mday;
450: qb_regs->qb_toymonth = xtime.tm_mon;
451: qb_regs->qb_toyyear = xtime.tm_year;
452: splx( s );
453: /*
454: * Start the clock again.
455: */
456: qb_regs->qb_toycsra = QBT_SETA;
457: qb_regs->qb_toycsrb = QBT_SETB;
458: }
459: #endif MVAX
460:
461:
462: unsigned trimprof[3];
463:
464: /*
465: * Tweak the rate of the software clock
466: * to track the hardware clock accurately.
467: * This routine is called once a second,
468: * immediately after 'time' has been incremented.
469: */
470: clktrim()
471: {
472: register long delta;
473: register long incr;
474: register unsigned todr = mfpr(TODR);
475:
476: #ifdef MVAX
477: /*
478: * Get the MicroVAX-II's toy register.
479: * Convert it to the time format that the todr is
480: * normally kept in.
481: */
482: if( cpu == M_VAX ) {
483: int year = YRREF;
484: unsigned secyr;
485:
486: todr = gettoy();
487: for (;;) {
488: secyr = SECYR;
489: if (LEAPYEAR(year))
490: secyr += SECDAY;
491: if (todr < secyr)
492: break;
493: todr -= secyr;
494: year++;
495: }
496: todr = TODRZERO + todr*100;
497: }
498: #endif MVAX
499:
500: delta = 100 * (time - yearbase) - todr + TODRZERO;
501:
502: /*
503: * If delta > 0, the software clock is running fast.
504: * It is measured in centiseconds, the units of the
505: * hardware clock. If delta is non-zero, we will
506: * stretch or shrink each tick by 111 microseconds
507: * from the nominal, for a drift of about 2/3 of a
508: * percent. This should result by changing delta by
509: * about 2/3 each second, thus making it very unlikely
510: * that we will overshoot delta == 0. On the other
511: * hand, we will be able to absorb 16 minutes of drift
512: * each day. We also count each kind of tweak.
513: */
514:
515: incr = -16667; /* -1/60 of a second, in microseconds */
516: if (delta > 0) {
517: incr -= 111;
518: trimprof[2]++;
519: } else if (delta < 0) {
520: incr += 111;
521: trimprof[0]++;
522: } else {
523: trimprof[1]++;
524: }
525:
526: /* tell the hardware about it */
527: /* unfortunately this does nothing on the MVAX */
528: mtpr (NICR, incr);
529: }
530:
531: /*
532: * This system call sets the time of year clock without touching
533: * the software clock. It returns the previous clock value. If
534: * the argument is zero or the caller is not the super-user, it
535: * does not change the clock.
536: */
537: settod()
538: {
539: register struct a {
540: long unsigned tod;
541: } *uap;
542: register unsigned todr = mfpr(TODR);
543:
544: #ifdef MVAX
545: /*
546: * Get the MicroVAX-II's toy register.
547: * Convert it to the time format that the todr is
548: * normally kept in.
549: */
550: if( cpu == M_VAX ) {
551: int year = YRREF;
552: unsigned secyr;
553:
554: todr = gettoy();
555: for (;;) {
556: secyr = SECYR;
557: if (LEAPYEAR(year))
558: secyr += SECDAY;
559: if (todr < secyr)
560: break;
561: todr -= secyr;
562: year++;
563: }
564: todr = TODRZERO + todr*100;
565: }
566: #endif MVAX
567:
568: uap = (struct a *) u.u_ap;
569: u.u_r.r_val1 = todr;
570: #ifdef MVAX
571: if (uap->tod != 0 && suser() && cpu == M_VAX) {
572: settoy(uap->tod);
573: return;
574: }
575: #endif MVAX
576: if (uap->tod != 0 && suser())
577: mtpr (TODR, uap->tod);
578: }
579:
580: /*
581: * Return the difference (in microseconds)
582: * between the current time and a previous
583: * time as represented by the arguments.
584: * If there is a pending clock interrupt
585: * which has not been serviced due to high
586: * ipl, return error code.
587: */
588: vmtime(otime, olbolt, oicr)
589: register int otime, olbolt, oicr;
590: {
591:
592: if (mfpr(ICCS)&ICCS_INT)
593: return(-1);
594: else
595: return(((time-otime)*60 + lbolt-olbolt)*16667 + mfpr(ICR)-oicr);
596: }
597:
598: /*
599: * Send an interrupt to process
600: *
601: * SHOULD CHANGE THIS TO PASS ONE MORE WORK SO THAT ALL INFORMATION
602: * PROVIDED BY HARDWARE IS AVAILABLE TO THE USER PROCESS.
603: */
604: sendsig(p, n)
605: int (*p)();
606: {
607: register int *usp, *regs;
608:
609: regs = u.u_ar0;
610: usp = (int *)regs[SP];
611: usp -= 5;
612: if ((int)usp <= USRSTACK - ctob(u.u_ssize))
613: (void) grow((unsigned)usp);
614: ; /* Avoid asm() label botch */
615: #ifndef lint
616: asm("probew $3,$20,(r11)");
617: asm("beql bad");
618: #else
619: if (useracc((caddr_t)usp, 0x20, 1))
620: goto bad;
621: #endif
622: *usp++ = n;
623: if (n == SIGILL || n == SIGFPE) {
624: *usp++ = u.u_code;
625: u.u_code = 0;
626: } else
627: *usp++ = 0;
628: *usp++ = (int)p;
629: *usp++ = regs[PC];
630: *usp++ = regs[PS];
631: regs[SP] = (int)(usp - 5);
632: regs[PS] &= ~(PSL_CM|PSL_FPD);
633: regs[PC] = (int)u.u_pcb.pcb_sigc;
634: return;
635:
636: asm("bad:");
637: bad:
638: /*
639: * Process has trashed its stack; give it an illegal
640: * instruction to halt it in its tracks.
641: */
642: u.u_signal[SIGILL] = SIG_DFL;
643: u.u_procp->p_siga0 &= ~(1<<(SIGILL-1));
644: u.u_procp->p_siga1 &= ~(1<<(SIGILL-1));
645: psignal(u.u_procp, SIGILL);
646: }
647:
648: int userreg[] = {R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, AP, FP, SP, PC};
649:
650: dorti()
651: {
652: struct frame frame;
653: register int sp;
654: register int reg, mask;
655:
656: (void) copyin((caddr_t)u.u_ar0[FP], (caddr_t)&frame, sizeof (frame));
657: sp = u.u_ar0[FP] + sizeof (frame);
658: u.u_ar0[PC] = frame.fr_savpc;
659: u.u_ar0[FP] = frame.fr_savfp;
660: u.u_ar0[AP] = frame.fr_savap;
661: mask = frame.fr_mask;
662: for (reg = 0; reg <= 11; reg++) {
663: if (mask&1) {
664: u.u_ar0[userreg[reg]] = fuword((caddr_t)sp);
665: sp += 4;
666: }
667: mask >>= 1;
668: }
669: sp += frame.fr_spa;
670: u.u_ar0[PS] = (u.u_ar0[PS] & 0xffff0000) | frame.fr_psw;
671: if (frame.fr_s)
672: sp += 4 + 4 * (fuword((caddr_t)sp) & 0xff);
673: /* phew, now the rei */
674: u.u_ar0[PC] = fuword((caddr_t)sp);
675: sp += 4;
676: u.u_ar0[PS] = fuword((caddr_t)sp);
677: sp += 4;
678: u.u_ar0[PS] |= PSL_USERSET;
679: u.u_ar0[PS] &= ~PSL_USERCLR;
680: u.u_ar0[SP] = (int)sp;
681: }
682:
683: /*
684: * Invalidate single all pte's in a cluster
685: */
686: tbiscl(v)
687: unsigned v;
688: {
689: register caddr_t addr; /* must be first reg var */
690: register int i;
691:
692: asm(".set TBIS,58");
693: addr = ptob(v);
694: for (i = 0; i < CLSIZE; i++) {
695: #ifdef lint
696: mtpr(TBIS, addr);
697: #else
698: asm("mtpr r11,$TBIS");
699: #endif
700: addr += NBPG;
701: }
702: }
703:
704: int waittime = -1;
705:
706: boot(arghowto)
707: int arghowto;
708: {
709: register int howto; /* r11 == how to boot */
710: register int devtype; /* r10 == major of root dev */
711:
712: howto = arghowto;
713: if ((howto&RB_NOSYNC)==0 && waittime < 0 && bfreelist[0].b_forw) {
714: waittime = 0;
715: update();
716: printf("syncing disks... ");
717: while (++waittime <= 5)
718: sleep((caddr_t)&lbolt, PZERO);
719: printf("done\n");
720: }
721: splx(0x1f); /* extreme priority */
722: devtype = major(rootdev);
723: if (howto&RB_HALT) {
724: #ifdef MVAX
725: if( cpu == M_VAX ) {
726: ((struct qb_regs *)nexus)->qb_cpmbx = RB_HALTMD;
727: for (;;)
728: asm ("halt");
729: }
730: #endif MVAX
731: printf("halting (in tight loop); hit\n\t^P\n\tHALT\n\n");
732: mtpr(IPL, 0x1f);
733: for (;;)
734: ;
735: } else {
736: if ((howto & RB_PANIC) != 0)
737: doadump();
738: tocons(TXDB_BOOT);
739: }
740: #if defined(VAX750) || defined(VAX7ZZ) || defined(MVAX)
741: if (cpu != VAX_780)
742: { asm("movl r11,r5"); } /* boot flags go in r5 */
743: #endif
744: #ifdef MVAX
745: if( cpu == M_VAX )
746: ((struct qb_regs *)nexus)->qb_cpmbx = RB_REBOOT;
747: #endif
748: for (;;)
749: asm("halt");
750: /*NOTREACHED*/
751: }
752:
753: tocons(c)
754: {
755:
756: while ((mfpr(TXCS)&TXCS_RDY) == 0)
757: continue;
758: mtpr(TXDB, c);
759: }
760:
761: /*
762: * Doadump comes here after turning off memory management and
763: * getting on the dump stack, either when called above, or by
764: * the auto-restart code.
765: */
766: dumpsys()
767: {
768: int dstat;
769: rpb.rp_flag = 1;
770: if ((minor(dumpdev)&07) != 1)
771: return;
772: printf("\ndumping to dev %x, offset %d\n", dumpdev, dumplo);
773: printf("dump ");
774: switch (dstat = (*bdevsw[major(dumpdev)].d_dump)(dumpdev)) {
775:
776: case ENXIO:
777: printf("device bad\n");
778: break;
779:
780: case EFAULT:
781: printf("device not ready\n");
782: break;
783:
784: case EINVAL:
785: printf("area improper\n");
786: break;
787:
788: case EIO:
789: printf("i/o error\n");
790: break;
791:
792: default:
793: printf("unexpected error %d\n", dstat);
794: break;
795:
796: case 0:
797: printf("succeeded\n");
798: break;
799: }
800: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.