projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
add USL's copyright notice
[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..3b2462e 100644 (file)
--- a/usr/src/sys/kern/subr_prf.c
+++ b/usr/src/sys/kern/subr_prf.c
@@ -1,205 +1,487 @@
-/*     subr_prf.c      4.9     %G%     */
-
-#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/tty.h"
+/*-
+ * Copyright (c) 1986, 1988, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * %sccs.include.redist.c%
+ *
+ *     @(#)subr_prf.c  8.3 (Berkeley) %G%
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/buf.h>
+#include <sys/conf.h>
+#include <sys/reboot.h>
+#include <sys/msgbuf.h>
+#include <sys/proc.h>
+#include <sys/ioctl.h>
+#include <sys/vnode.h>
+#include <sys/file.h>
+#include <sys/tty.h>
+#include <sys/tprintf.h>
+#include <sys/syslog.h>
+#include <sys/malloc.h>
 
 /*
 
 /*
- * In case console is off,
- * panicstr contains argument to last
- * call to panic.
+ * Note that stdarg.h and the ANSI style va_start macro is used for both
+ * ANSI and traditional C compilers.
  */
  */
+#include <machine/stdarg.h>
+
+#ifdef KADB
+#include <machine/kdbparam.h>
+#endif
+
+#define TOCONS 0x01
+#define TOTTY  0x02
+#define TOLOG  0x04
+
+struct tty *constty;                   /* pointer to console "window" tty */
+
+extern cnputc();                       /* standard console putc */
+int    (*v_putc)() = cnputc;           /* routine to putc on virtual console */
+
+void  logpri __P((int level));
+static void  putchar __P((int ch, int flags, struct tty *tp));
+static char *ksprintn __P((u_long num, int base, int *len));
+void kprintf __P((const char *fmt, int flags, struct tty *tp, va_list ap));
 
 
-char   *panicstr;
+int consintr = 1;                      /* Ok to handle console interrupts? */
+
+extern cnputc();                       /* standard console putc */
+extern struct tty cons;                /* standard console tty */
+struct tty *constty;                   /* pointer to console "window" tty */
+int    (*v_console)() = cnputc;        /* routine to putc on virtual console */
+
+/*
+ * Variable panicstr contains argument to first call to panic; used as flag
+ * to indicate that the kernel has already called panic.
+ */
+const 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.
+ * Panic is called on unresolvable fatal errors.  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.
  */
  */
-/*VARARGS1*/
-printf(fmt, x1)
-register char *fmt;
-unsigned x1;
+#ifdef __GNUC__
+volatile void boot(int flags); /* boot() does not return */
+volatile                       /* panic() does not return */
+#endif
+void
+#ifdef __STDC__
+panic(const char *fmt, ...)
+#else
+panic(fmt, va_alist)
+       char *fmt;
+#endif
 {
 {
+       int bootopt;
+       va_list ap;
+
+       bootopt = RB_AUTOBOOT | RB_DUMP;
+       if (panicstr)
+               bootopt |= RB_NOSYNC;
+       else
+               panicstr = fmt;
+
+       va_start(ap, fmt);
+       printf("panic: %r\n", fmt, ap);
+       va_end(ap);
 
 
-       prf(fmt, &x1, 0);
+#ifdef KGDB
+       kgdb_panic();
+#endif
+#ifdef KADB
+       if (boothowto & RB_KDB)
+               kdbpanic();
+#endif
+       boot(bootopt);
 }
 
 /*
 }
 
 /*
- * print to the current users terminal,
- * guarantee not to sleep (so can be called by intr routine)
- * no watermark checking - so no verbose messages
+ * Warn that a system table is full.
  */
  */
-/*VARARGS1*/
-uprintf(fmt, x1)
-       char    *fmt;
-       unsigned x1;
+void
+tablefull(tab)
+       const char *tab;
 {
 
 {
 
-       prf(fmt, &x1, 2);
+       log(LOG_ERR, "%s: table is full\n", tab);
 }
 
 }
 
-/* THIS CODE IS VAX DEPENDENT */
-prf(fmt, adx, touser)
-register char *fmt;
-register u_int *adx;
+/*
+ * Uprintf prints to the controlling terminal for the current process.
+ * It may block if the tty queue is overfull.  No message is printed if
+ * the queue does not clear in a reasonable time.
+ */
+void
+#ifdef __STDC__
+uprintf(const char *fmt, ...)
+#else
+uprintf(fmt, va_alist)
+       char *fmt;
+#endif
 {
 {
-       register int b, c, i;
-       char *s;
-
-loop:
-       while ((c = *fmt++) != '%') {
-               if(c == '\0')
-                       return;
-               putchar(c, touser);
-       }
-again:
-       c = *fmt++;
-       switch (c) {
-
-       case 'l':
-               goto again;
-       case 'x': case 'X':
-               b = 16;
-               goto number;
-       case 'd': case 'D':
-       case 'u':               /* what a joke */
-               b = 10;
-               goto number;
-       case 'o': case 'O':
-               b = 8;
-number:
-               printn(*adx, b, touser);
-               break;
-       case 'c':
-               b = *adx;
-               for (i = 24; i >= 0; i -= 8)
-                       if (c = (b >> i) & 0x7f)
-                               putchar(c, touser);
-               break;
-       case 's':
-               s = (char *)*adx;
-               while (c = *s++)
-                       putchar(c, touser);
-               break;
+       register struct proc *p = curproc;
+       va_list ap;
+
+       if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) {
+               va_start(ap, fmt);
+               kprintf(fmt, TOTTY, p->p_session->s_ttyp, ap);
+               va_end(ap);
        }
        }
-       adx++;
-       goto loop;
 }
 }
-/* END VAX DEPENDENT CODE */
 
 
-printn(n, b, touser)
-       unsigned long n;
+tpr_t
+tprintf_open(p)
+       register struct proc *p;
 {
 {
-       char prbuf[11];
-       register char *cp;
 
 
-       if (b == 10 && (int)n < 0) {
-               putchar('-', touser);
-               n = (unsigned)(-(int)n);
+       if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) {
+               SESSHOLD(p->p_session);
+               return ((tpr_t) p->p_session);
        }
        }
-       cp = prbuf;
-       do {
-               *cp++ = "0123456789abcdef"[n%b];
-               n /= b;
-       } while (n);
-       do
-               putchar(*--cp, touser);
-       while (cp > prbuf);
+       return ((tpr_t) NULL);
+}
+
+void
+tprintf_close(sess)
+       tpr_t sess;
+{
+
+       if (sess)
+               SESSRELE((struct session *) sess);
 }
 
 /*
 }
 
 /*
- * Panic is called on unresolvable fatal errors.
- * It syncs, prints "panic: mesg", and then reboots.
+ * tprintf prints on the controlling terminal associated
+ * with the given session.
  */
  */
-panic(s)
-char *s;
+void
+#ifdef __STDC__
+tprintf(tpr_t tpr, const char *fmt, ...)
+#else
+tprintf(tpr, fmt, va_alist)
+       tpr_t tpr;
+       char *fmt;
+#endif
 {
 {
+       register struct session *sess = (struct session *)tpr;
+       struct tty *tp = NULL;
+       int flags = TOLOG;
+       va_list ap;
 
 
-       panicstr = s;
-       printf("panic: %s\n", s);
-       (void) spl0();
-       for(;;)
-               boot(RB_PANIC, RB_AUTOBOOT);
+       logpri(LOG_INFO);
+       if (sess && sess->s_ttyvp && ttycheckoutq(sess->s_ttyp, 0)) {
+               flags |= TOTTY;
+               tp = sess->s_ttyp;
+       }
+       va_start(ap, fmt);
+       kprintf(fmt, flags, tp, ap);
+       va_end(ap);
+       logwakeup();
 }
 
 /*
 }
 
 /*
- * 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.
+ * Ttyprintf displays a message on a tty; it should be used only by
+ * the tty driver, or anything that knows the underlying tty will not
+ * be revoke(2)'d away.  Other callers should use tprintf.
  */
  */
-prdev(str, dev)
-       char *str;
-       dev_t dev;
+void
+#ifdef __STDC__
+ttyprintf(struct tty *tp, const char *fmt, ...)
+#else
+ttyprintf(tp, fmt, va_alist)
+       struct tty *tp;
+       char *fmt;
+#endif
 {
 {
+       va_list ap;
 
 
-       printf("%s on dev %d/%d\n", str, major(dev), minor(dev));
+       va_start(ap, fmt);
+       kprintf(fmt, TOTTY, tp, ap);
+       va_end(ap);
 }
 
 }
 
+extern int log_open;
+
 /*
 /*
- * 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.
+ * Log writes to the log buffer, and guarantees not to sleep (so can be
+ * called by interrupt routines).  If there is no process reading the
+ * log yet, it writes to the console also.
  */
  */
-deverror(bp, o1, o2)
-       register struct buf *bp;
+void
+#ifdef __STDC__
+log(int level, const char *fmt, ...)
+#else
+log(level, fmt, va_alist)
+       int level;
+       char *fmt;
+#endif
 {
 {
+       register int s;
+       va_list ap;
 
 
-       printf("bn=%d er=%x,%x", bp->b_blkno, o1,o2);
-       prdev("", bp->b_dev);
+       s = splhigh();
+       logpri(level);
+       va_start(ap, fmt);
+       kprintf(fmt, TOLOG, NULL, ap);
+       splx(s);
+       va_end(ap);
+       if (!log_open) {
+               va_start(ap, fmt);
+               kprintf(fmt, TOCONS, NULL, ap);
+               va_end(ap);
+       }
+       logwakeup();
+}
+
+void
+logpri(level)
+       int level;
+{
+       register int ch;
+       register char *p;
+
+       putchar('<', TOLOG, NULL);
+       for (p = ksprintn((u_long)level, 10, NULL); ch = *p--;)
+               putchar(ch, TOLOG, NULL);
+       putchar('>', TOLOG, NULL);
+}
+
+void
+#ifdef __STDC__
+addlog(const char *fmt, ...)
+#else
+addlog(fmt, va_alist)
+       char *fmt;
+#endif
+{
+       register int s;
+       va_list ap;
+
+       s = splhigh();
+       va_start(ap, fmt);
+       kprintf(fmt, TOLOG, NULL, ap);
+       splx(s);
+       va_end(ap);
+       if (!log_open) {
+               va_start(ap, fmt);
+               kprintf(fmt, TOCONS, NULL, ap);
+               va_end(ap);
+       }
+       logwakeup();
+}
+
+void
+#ifdef __STDC__
+printf(const char *fmt, ...)
+#else
+printf(fmt, va_alist)
+       char *fmt;
+#endif
+{
+       va_list ap;
+       register int savintr;
+
+       savintr = consintr;             /* disable interrupts */
+       consintr = 0;
+       va_start(ap, fmt);
+       kprintf(fmt, TOCONS | TOLOG, NULL, ap);
+       va_end(ap);
+       if (!panicstr)
+               logwakeup();
+       consintr = savintr;             /* reenable interrupts */
 }
 
 /*
 }
 
 /*
- * Print a character on console or users terminal.
- * If destination is console then the last MSGBUFS characters
- * are saved in msgbuf for inspection later.
+ * Scaled down version of printf(3).
+ *
+ * Two additional formats:
+ *
+ * The format %b is supported to decode error registers.
+ * Its 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:
+ *
+ *     kprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
+ *
+ * would produce output:
+ *
+ *     reg=3<BITTWO,BITONE>
+ *
+ * The format %r passes an additional format string and argument list
+ * recursively.  Its usage is:
+ *
+ * fn(char *fmt, ...)
+ * {
+ *     va_list ap;
+ *     va_start(ap, fmt);
+ *     printf("prefix: %r: suffix\n", fmt, ap);
+ *     va_end(ap);
+ * }
+ *
+ * Space or zero padding and a field width are supported for the numeric
+ * formats only.
  */
  */
-/*ARGSUSED*/
-putchar(c, touser)
-       register int c;
+void
+kprintf(fmt, flags, tp, ap)
+       register const char *fmt;
+       int flags;
+       struct tty *tp;
+       va_list ap;
 {
 {
+       register char *p, *q;
+       register int ch, n;
+       u_long ul;
+       int base, lflag, tmp, width;
+       char padc;
+
+       for (;;) {
+               padc = ' ';
+               width = 0;
+               while ((ch = *(u_char *)fmt++) != '%') {
+                       if (ch == '\0')
+                               return;
+                       putchar(ch, flags, tp);
+               }
+               lflag = 0;
+reswitch:      switch (ch = *(u_char *)fmt++) {
+               case '0':
+                       padc = '0';
+                       goto reswitch;
+               case '1': case '2': case '3': case '4':
+               case '5': case '6': case '7': case '8': case '9':
+                       for (width = 0;; ++fmt) {
+                               width = width * 10 + ch - '0';
+                               ch = *fmt;
+                               if (ch < '0' || ch > '9')
+                                       break;
+                       }
+                       goto reswitch;
+               case 'l':
+                       lflag = 1;
+                       goto reswitch;
+               case 'b':
+                       ul = va_arg(ap, int);
+                       p = va_arg(ap, char *);
+                       for (q = ksprintn(ul, *p++, NULL); ch = *q--;)
+                               putchar(ch, flags, tp);
 
 
-       if (touser) {
-               register struct tty *tp = u.u_ttyp;
+                       if (!ul)
+                               break;
 
 
-               if (tp && (tp->t_state&CARR_ON)) {
-                       register s = spl6();
-                       if (c == '\n')
-                               ttyoutput('\r', tp);
-                       ttyoutput(c, tp);
-                       ttstart(tp);
-                       splx(s);
+                       for (tmp = 0; n = *p++;) {
+                               if (ul & (1 << (n - 1))) {
+                                       putchar(tmp ? ',' : '<', flags, tp);
+                                       for (; (n = *p) > ' '; ++p)
+                                               putchar(n, flags, tp);
+                                       tmp = 1;
+                               } else
+                                       for (; *p > ' '; ++p)
+                                               continue;
+                       }
+                       if (tmp)
+                               putchar('>', flags, tp);
+                       break;
+               case 'c':
+                       putchar(va_arg(ap, int), flags, tp);
+                       break;
+               case 'r':
+                       p = va_arg(ap, char *);
+                       kprintf(p, flags, tp, va_arg(ap, va_list));
+                       break;
+               case 's':
+                       p = va_arg(ap, char *);
+                       while (ch = *p++)
+                               putchar(ch, flags, tp);
+                       break;
+               case 'd':
+                       ul = lflag ? va_arg(ap, long) : va_arg(ap, int);
+                       if ((long)ul < 0) {
+                               putchar('-', flags, tp);
+                               ul = -(long)ul;
+                       }
+                       base = 10;
+                       goto number;
+               case 'o':
+                       ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
+                       base = 8;
+                       goto number;
+               case 'u':
+                       ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
+                       base = 10;
+                       goto number;
+               case 'x':
+                       ul = lflag ? va_arg(ap, u_long) : va_arg(ap, u_int);
+                       base = 16;
+number:                        p = ksprintn(ul, base, &tmp);
+                       if (width && (width -= tmp) > 0)
+                               while (width--)
+                                       putchar(padc, flags, tp);
+                       while (ch = *p--)
+                               putchar(ch, flags, tp);
+                       break;
+               default:
+                       putchar('%', flags, tp);
+                       if (lflag)
+                               putchar('l', flags, tp);
+                       /* FALLTHROUGH */
+               case '%':
+                       putchar(ch, flags, tp);
                }
                }
-               return;
        }
        }
-       if (c != '\0' && c != '\r' && c != 0177 && mfpr(MAPEN)) {
-               if (msgbuf.msg_magic != MSG_MAGIC) {
-                       msgbuf.msg_bufx = 0;
-                       msgbuf.msg_magic = MSG_MAGIC;
+}
+
+/*
+ * Print a character on console or users terminal.  If destination is
+ * the console then the last MSGBUFS characters are saved in msgbuf for
+ * inspection later.
+ */
+static void
+putchar(c, flags, tp)
+       register int c;
+       int flags;
+       struct tty *tp;
+{
+       extern int msgbufmapped;
+       register struct msgbuf *mbp;
+
+       if (panicstr)
+               constty = NULL;
+       if ((flags & TOCONS) && tp == NULL && constty) {
+               tp = constty;
+               flags |= TOTTY;
+       }
+       if ((flags & TOCONS) && panicstr == 0 && tp == 0 && constty) {
+               tp = constty;
+               flags |= TOTTY;
+       }
+       if ((flags & TOTTY) && tp && tputchar(c, tp) < 0 &&
+           (flags & TOCONS) && tp == constty)
+               constty = NULL;
+       if ((flags & TOLOG) &&
+           c != '\0' && c != '\r' && c != 0177 && msgbufmapped) {
+               mbp = msgbufp;
+               if (mbp->msg_magic != MSG_MAGIC) {
+                       bzero((caddr_t)mbp, sizeof(*mbp));
+                       mbp->msg_magic = MSG_MAGIC;
                }
                }
-               if (msgbuf.msg_bufx < 0 || msgbuf.msg_bufx >= MSG_BSIZE)
-                       msgbuf.msg_bufx = 0;
-               msgbuf.msg_bufc[msgbuf.msg_bufx++] = c;
+               mbp->msg_bufc[mbp->msg_bufx++] = c;
+               if (mbp->msg_bufx < 0 || mbp->msg_bufx >= MSG_BSIZE)
+                       mbp->msg_bufx = 0;
        }
        }
-       if (c == 0)
-               return;
-       cnputc(c);
+               (*v_console)(c);
 }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.