how did these ever work before?

[unix-history] / usr / src / sys / kern / subr_prf.c

diff --git a/usr/src/sys/kern/subr_prf.c b/usr/src/sys/kern/subr_prf.c
index 3f2c89d..6449cd1 100644 (file)
--- a/usr/src/sys/kern/subr_prf.c
+++ b/usr/src/sys/kern/subr_prf.c
@@ -1,66 +1,77 @@
-/*     subr_prf.c      4.9     %G%     */
+/*     subr_prf.c      4.28    83/07/01        */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 #include "../h/seg.h"
 #include "../h/buf.h"
 #include "../h/conf.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"
 #include "../h/seg.h"
 #include "../h/buf.h"
 #include "../h/conf.h"

-#include "../h/mtpr.h"

 #include "../h/reboot.h"
 #include "../h/vm.h"
 #include "../h/msgbuf.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/reboot.h"
 #include "../h/vm.h"
 #include "../h/msgbuf.h"
 #include "../h/dir.h"
 #include "../h/user.h"

+#include "../h/proc.h"

 #include "../h/tty.h"
 
 #include "../h/tty.h"
 

+#ifdef vax
+#include "../vax/mtpr.h"
+#endif
+

 /*
  * In case console is off,
  * panicstr contains argument to last
  * call to panic.
  */
 /*
  * In case console is off,
  * panicstr contains argument to last
  * call to panic.
  */

-

 char   *panicstr;
 
 /*
  * Scaled down version of C Library printf.
 char   *panicstr;
 
 /*
  * Scaled down version of C Library printf.

- * Only %s %u %d (==%u) %o %x %D are recognized.
- * Used to print diagnostic information
- * directly on console tty.
- * Since it is not interrupt driven,
- * all system activities are pretty much
- * suspended.
- * Printf should not be used for chit-chat.
+ * Used to print diagnostic information directly on console tty.
+ * Since it is not interrupt driven, all system activities are
+ * suspended.  Printf should not be used for chit-chat.
+ *
+ * One additional format: %b is supported to decode error registers.
+ * Usage is:
+ *     printf("reg=%b\n", regval, "<base><arg>*");
+ * Where <base> is the output base expressed as a control character,
+ * e.g. \10 gives octal; \20 gives hex.  Each arg is a sequence of
+ * characters, the first of which gives the bit number to be inspected
+ * (origin 1), and the next characters (up to a control character, i.e.
+ * a character <= 32), give the name of the register.  Thus
+ *     printf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
+ * would produce output:
+ *     reg=2<BITTWO,BITONE>

  */
 /*VARARGS1*/
 printf(fmt, x1)
  */
 /*VARARGS1*/
 printf(fmt, x1)

-register char *fmt;
-unsigned x1;
+       char *fmt;
+       unsigned x1;

 {
 
        prf(fmt, &x1, 0);
 }
 
 /*
 {
 
        prf(fmt, &x1, 0);
 }
 
 /*

- * print to the current users terminal,
- * guarantee not to sleep (so can be called by intr routine)
- * no watermark checking - so no verbose messages
+ * Uprintf prints to the current user's terminal,
+ * guarantees not to sleep (so can be called by interrupt routines)
+ * and does no watermark checking - (so no verbose messages).

  */
 /*VARARGS1*/
 uprintf(fmt, x1)
  */
 /*VARARGS1*/
 uprintf(fmt, x1)

-       char    *fmt;
+       char *fmt;

        unsigned x1;
 {
 
        prf(fmt, &x1, 2);
 }
 
        unsigned x1;
 {
 
        prf(fmt, &x1, 2);
 }
 

-/* THIS CODE IS VAX DEPENDENT */

 prf(fmt, adx, touser)
 prf(fmt, adx, touser)

-register char *fmt;
-register u_int *adx;
+       register char *fmt;
+       register u_int *adx;

 {
        register int b, c, i;
        char *s;
 {
        register int b, c, i;
        char *s;

+       int any;

 
 loop:
        while ((c = *fmt++) != '%') {
 
 loop:
        while ((c = *fmt++) != '%') {


@@ -70,6 +81,7 @@ loop:
        }
 again:
        c = *fmt++;
        }
 again:
        c = *fmt++;

+       /* THIS CODE IS VAX DEPENDENT IN HANDLING %l? AND %c */

        switch (c) {
 
        case 'l':
        switch (c) {
 
        case 'l':


@@ -84,7 +96,7 @@ again:
        case 'o': case 'O':
                b = 8;
 number:
        case 'o': case 'O':
                b = 8;
 number:

-               printn(*adx, b, touser);
+               printn((u_long)*adx, b, touser);

                break;
        case 'c':
                b = *adx;
                break;
        case 'c':
                b = *adx;


@@ -92,19 +104,49 @@ number:
                        if (c = (b >> i) & 0x7f)
                                putchar(c, touser);
                break;
                        if (c = (b >> i) & 0x7f)
                                putchar(c, touser);
                break;

+       case 'b':
+               b = *adx++;
+               s = (char *)*adx;
+               printn((u_long)b, *s++, touser);
+               any = 0;
+               if (b) {
+                       putchar('<', touser);
+                       while (i = *s++) {
+                               if (b & (1 << (i-1))) {
+                                       if (any)
+                                               putchar(',', touser);
+                                       any = 1;
+                                       for (; (c = *s) > 32; s++)
+                                               putchar(c, touser);
+                               } else
+                                       for (; *s > 32; s++)
+                                               ;
+                       }
+                       if (any)
+                               putchar('>', touser);
+               }
+               break;
+

        case 's':
                s = (char *)*adx;
                while (c = *s++)
                        putchar(c, touser);
                break;
        case 's':
                s = (char *)*adx;
                while (c = *s++)
                        putchar(c, touser);
                break;

+
+       case '%':
+               putchar('%', touser);
+               break;

        }
        adx++;
        goto loop;
 }
        }
        adx++;
        goto loop;
 }

-/* END VAX DEPENDENT CODE */

 
 

+/*
+ * Printn prints a number n in base b.
+ * We don't use recursion to avoid deep kernel stacks.
+ */

 printn(n, b, touser)
 printn(n, b, touser)

-       unsigned long n;
+       u_long n;

 {
        char prbuf[11];
        register char *cp;
 {
        char prbuf[11];
        register char *cp;


@@ -125,46 +167,45 @@ printn(n, b, touser)
 
 /*
  * Panic is called on unresolvable fatal errors.
 
 /*
  * Panic is called on unresolvable fatal errors.

- * It syncs, prints "panic: mesg", and then reboots.
+ * It prints "panic: mesg", and then reboots.
+ * If we are called twice, then we avoid trying to
+ * sync the disks as this often leads to recursive panics.

  */
 panic(s)
  */
 panic(s)

-char *s;
+       char *s;

 {
 {

+       int bootopt = RB_AUTOBOOT;

 
 

-       panicstr = s;
+       if (panicstr)
+               bootopt |= RB_NOSYNC;
+       else {
+               panicstr = s;
+       }

        printf("panic: %s\n", s);
        printf("panic: %s\n", s);

-       (void) spl0();
-       for(;;)
-               boot(RB_PANIC, RB_AUTOBOOT);
+       boot(RB_PANIC, bootopt);

 }
 
 /*
 }
 
 /*

- * prdev prints a warning message of the
- * form "mesg on dev x/y".
- * x and y are the major and minor parts of
- * the device argument.
+ * Warn that a system table is full.

  */
  */

-prdev(str, dev)
-       char *str;
-       dev_t dev;
+tablefull(tab)
+       char *tab;

 {
 
 {
 

-       printf("%s on dev %d/%d\n", str, major(dev), minor(dev));
+       printf("%s: table is full\n", tab);

 }
 
 /*
 }
 
 /*

- * deverr prints a diagnostic from
- * a device driver.
- * It prints the device, block number,
- * and an octal word (usually some error
- * status register) passed as argument.
+ * Hard error is the preface to plaintive error messages
+ * about failing disk transfers.

  */
  */

-deverror(bp, o1, o2)
-       register struct buf *bp;
+harderr(bp, cp)
+       struct buf *bp;
+       char *cp;

 {
 
 {
 

-       printf("bn=%d er=%x,%x", bp->b_blkno, o1,o2);
-       prdev("", bp->b_dev);
+       printf("%s%d%c: hard error sn%d ", cp,
+           dkunit(bp), 'a'+(minor(bp->b_dev)&07), bp->b_blkno);

 }
 
 /*
 }
 
 /*


@@ -180,20 +221,28 @@ putchar(c, touser)
        if (touser) {
                register struct tty *tp = u.u_ttyp;
 
        if (touser) {
                register struct tty *tp = u.u_ttyp;
 

-               if (tp && (tp->t_state&CARR_ON)) {
+               if (tp && (tp->t_state&TS_CARR_ON)) {

                        register s = spl6();
                        if (c == '\n')
                        register s = spl6();
                        if (c == '\n')

-                               ttyoutput('\r', tp);
-                       ttyoutput(c, tp);
+                               (void) ttyoutput('\r', tp);
+                       (void) ttyoutput(c, tp);

                        ttstart(tp);
                        splx(s);
                }
                return;
        }
                        ttstart(tp);
                        splx(s);
                }
                return;
        }

-       if (c != '\0' && c != '\r' && c != 0177 && mfpr(MAPEN)) {
+       if (c != '\0' && c != '\r' && c != 0177
+#ifdef vax
+           && mfpr(MAPEN)
+#endif
+           ) {

                if (msgbuf.msg_magic != MSG_MAGIC) {
                if (msgbuf.msg_magic != MSG_MAGIC) {

+                       register int i;
+

                        msgbuf.msg_bufx = 0;
                        msgbuf.msg_magic = MSG_MAGIC;
                        msgbuf.msg_bufx = 0;
                        msgbuf.msg_magic = MSG_MAGIC;

+                       for (i=0; i < MSG_BSIZE; i++)
+                               msgbuf.msg_bufc[i] = 0;

                }
                if (msgbuf.msg_bufx < 0 || msgbuf.msg_bufx >= MSG_BSIZE)
                        msgbuf.msg_bufx = 0;
                }
                if (msgbuf.msg_bufx < 0 || msgbuf.msg_bufx >= MSG_BSIZE)
                        msgbuf.msg_bufx = 0;