![[BACK]](/icons/back.gif){kind=icon}
Return to subr_prf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to subr_prf.c CVS log | Up to [local] / sys / kern |
1.1 ! nbrk 1: /* $OpenBSD: subr_prf.c,v 1.70 2007/04/26 20:28:25 deraadt Exp $ */
! 2: /* $NetBSD: subr_prf.c,v 1.45 1997/10/24 18:14:25 chuck Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1986, 1988, 1991, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: * (c) UNIX System Laboratories, Inc.
! 8: * All or some portions of this file are derived from material licensed
! 9: * to the University of California by American Telephone and Telegraph
! 10: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
! 11: * the permission of UNIX System Laboratories, Inc.
! 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: * @(#)subr_prf.c 8.3 (Berkeley) 1/21/94
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/buf.h>
! 43: #include <sys/conf.h>
! 44: #include <sys/reboot.h>
! 45: #include <sys/msgbuf.h>
! 46: #include <sys/proc.h>
! 47: #include <sys/ioctl.h>
! 48: #include <sys/vnode.h>
! 49: #include <sys/file.h>
! 50: #include <sys/tty.h>
! 51: #include <sys/tprintf.h>
! 52: #include <sys/syslog.h>
! 53: #include <sys/malloc.h>
! 54: #include <sys/pool.h>
! 55: #include <sys/mutex.h>
! 56:
! 57: #include <dev/cons.h>
! 58:
! 59: /*
! 60: * note that stdarg.h and the ansi style va_start macro is used for both
! 61: * ansi and traditional c compilers.
! 62: */
! 63: #include <sys/stdarg.h>
! 64:
! 65: #ifdef KGDB
! 66: #include <sys/kgdb.h>
! 67: #include <machine/cpu.h>
! 68: #endif
! 69: #ifdef DDB
! 70: #include <ddb/db_output.h> /* db_printf, db_putchar prototypes */
! 71: #include <ddb/db_var.h> /* db_log, db_radix */
! 72: #endif
! 73: #if defined(UVM_SWAP_ENCRYPT)
! 74: extern int uvm_doswapencrypt;
! 75: #endif
! 76:
! 77:
! 78: /*
! 79: * defines
! 80: */
! 81:
! 82: /* flags for kprintf */
! 83: #define TOCONS 0x01 /* to the console */
! 84: #define TOTTY 0x02 /* to the process' tty */
! 85: #define TOLOG 0x04 /* to the kernel message buffer */
! 86: #define TOBUFONLY 0x08 /* to the buffer (only) [for snprintf] */
! 87: #define TODDB 0x10 /* to ddb console */
! 88: #define TOCOUNT 0x20 /* act like [v]snprintf */
! 89:
! 90: /* max size buffer kprintf needs to print quad_t [size in base 8 + \0] */
! 91: #define KPRINTF_BUFSIZE (sizeof(quad_t) * NBBY / 3 + 2)
! 92:
! 93:
! 94: /*
! 95: * local prototypes
! 96: */
! 97:
! 98: int kprintf(const char *, int, void *, char *, va_list);
! 99: void kputchar(int, int, struct tty *);
! 100:
! 101: struct mutex kprintf_mutex = MUTEX_INITIALIZER(IPL_HIGH);
! 102:
! 103: /*
! 104: * globals
! 105: */
! 106:
! 107: extern struct tty *constty; /* pointer to console "window" tty */
! 108: int consintr = 1; /* ok to handle console interrupts? */
! 109: extern int log_open; /* subr_log: is /dev/klog open? */
! 110: const char *panicstr; /* arg to first call to panic (used as a flag
! 111: to indicate that panic has already been called). */
! 112: #ifdef DDB
! 113: /*
! 114: * Enter ddb on panic.
! 115: */
! 116: int db_panic = 1;
! 117:
! 118: /*
! 119: * db_console controls if we can be able to enter ddb by a special key
! 120: * combination (machine dependent).
! 121: * If DDB_SAFE_CONSOLE is defined in the kernel configuration it allows
! 122: * to break into console during boot. It's _really_ useful when debugging
! 123: * some things in the kernel that can cause init(8) to crash.
! 124: */
! 125: #ifdef DDB_SAFE_CONSOLE
! 126: int db_console = 1;
! 127: #else
! 128: int db_console = 0;
! 129: #endif
! 130: #endif
! 131:
! 132: /*
! 133: * panic on spl assertion failure?
! 134: */
! 135: int splassert_ctl = 1;
! 136:
! 137: /*
! 138: * v_putc: routine to putc on virtual console
! 139: *
! 140: * the v_putc pointer can be used to redirect the console cnputc elsewhere
! 141: * [e.g. to a "virtual console"].
! 142: */
! 143:
! 144: void (*v_putc)(int) = cnputc; /* start with cnputc (normal cons) */
! 145:
! 146:
! 147: /*
! 148: * functions
! 149: */
! 150:
! 151: /*
! 152: * Partial support (the failure case) of the assertion facility
! 153: * commonly found in userland.
! 154: */
! 155: void
! 156: __assert(const char *t, const char *f, int l, const char *e)
! 157: {
! 158:
! 159: panic("kernel %sassertion \"%s\" failed: file \"%s\", line %d",
! 160: t, e, f, l);
! 161: }
! 162:
! 163: /*
! 164: * tablefull: warn that a system table is full
! 165: */
! 166:
! 167: void
! 168: tablefull(const char *tab)
! 169: {
! 170: log(LOG_ERR, "%s: table is full\n", tab);
! 171: }
! 172:
! 173: /*
! 174: * panic: handle an unresolvable fatal error
! 175: *
! 176: * prints "panic: <message>" and reboots. if called twice (i.e. recursive
! 177: * call) we avoid trying to sync the disk and just reboot (to avoid
! 178: * recursive panics).
! 179: */
! 180:
! 181: void
! 182: panic(const char *fmt, ...)
! 183: {
! 184: static char panicbuf[512];
! 185: int bootopt;
! 186: va_list ap;
! 187:
! 188: bootopt = RB_AUTOBOOT | RB_DUMP;
! 189: #if defined(UVM_SWAP_ENCRYPT)
! 190: if (uvm_doswapencrypt)
! 191: bootopt &= ~RB_DUMP;
! 192: #endif
! 193: va_start(ap, fmt);
! 194: if (panicstr)
! 195: bootopt |= RB_NOSYNC;
! 196: else {
! 197: vsnprintf(panicbuf, sizeof panicbuf, fmt, ap);
! 198: panicstr = panicbuf;
! 199: }
! 200: va_end(ap);
! 201:
! 202: printf("panic: ");
! 203: va_start(ap, fmt);
! 204: vprintf(fmt, ap);
! 205: printf("\n");
! 206: va_end(ap);
! 207:
! 208: #ifdef KGDB
! 209: kgdb_panic();
! 210: #endif
! 211: #ifdef KADB
! 212: if (boothowto & RB_KDB)
! 213: kdbpanic();
! 214: #endif
! 215: #ifdef DDB
! 216: if (db_panic)
! 217: Debugger();
! 218: else
! 219: db_stack_dump();
! 220: #endif
! 221: boot(bootopt);
! 222: }
! 223:
! 224: /*
! 225: * We print only the function name. The file name is usually very long and
! 226: * would eat tons of space in the kernel.
! 227: */
! 228: void
! 229: splassert_fail(int wantipl, int haveipl, const char *func)
! 230: {
! 231:
! 232: printf("splassert: %s: want %d have %d\n", func, wantipl, haveipl);
! 233: switch (splassert_ctl) {
! 234: case 1:
! 235: break;
! 236: case 2:
! 237: #ifdef DDB
! 238: db_stack_dump();
! 239: #endif
! 240: break;
! 241: case 3:
! 242: #ifdef DDB
! 243: db_stack_dump();
! 244: Debugger();
! 245: #endif
! 246: break;
! 247: default:
! 248: panic("spl assertion failure in %s", func);
! 249: }
! 250: }
! 251:
! 252: /*
! 253: * kernel logging functions: log, logpri, addlog
! 254: */
! 255:
! 256: /*
! 257: * log: write to the log buffer
! 258: *
! 259: * => will not sleep [so safe to call from interrupt]
! 260: * => will log to console if /dev/klog isn't open
! 261: */
! 262:
! 263: void
! 264: log(int level, const char *fmt, ...)
! 265: {
! 266: int s;
! 267: va_list ap;
! 268:
! 269: s = splhigh();
! 270: logpri(level); /* log the level first */
! 271: va_start(ap, fmt);
! 272: kprintf(fmt, TOLOG, NULL, NULL, ap);
! 273: va_end(ap);
! 274: splx(s);
! 275: if (!log_open) {
! 276: va_start(ap, fmt);
! 277: kprintf(fmt, TOCONS, NULL, NULL, ap);
! 278: va_end(ap);
! 279: }
! 280: logwakeup(); /* wake up anyone waiting for log msgs */
! 281: }
! 282:
! 283: /*
! 284: * logpri: log the priority level to the klog
! 285: */
! 286:
! 287: void
! 288: logpri(int level)
! 289: {
! 290: char *p;
! 291: char snbuf[KPRINTF_BUFSIZE];
! 292:
! 293: kputchar('<', TOLOG, NULL);
! 294: snprintf(snbuf, sizeof snbuf, "%d", level);
! 295: for (p = snbuf ; *p ; p++)
! 296: kputchar(*p, TOLOG, NULL);
! 297: kputchar('>', TOLOG, NULL);
! 298: }
! 299:
! 300: /*
! 301: * addlog: add info to previous log message
! 302: */
! 303:
! 304: int
! 305: addlog(const char *fmt, ...)
! 306: {
! 307: int s;
! 308: va_list ap;
! 309:
! 310: s = splhigh();
! 311: va_start(ap, fmt);
! 312: kprintf(fmt, TOLOG, NULL, NULL, ap);
! 313: va_end(ap);
! 314: splx(s);
! 315: if (!log_open) {
! 316: va_start(ap, fmt);
! 317: kprintf(fmt, TOCONS, NULL, NULL, ap);
! 318: va_end(ap);
! 319: }
! 320: logwakeup();
! 321: return(0);
! 322: }
! 323:
! 324:
! 325: /*
! 326: * kputchar: print a single character on console or user terminal.
! 327: *
! 328: * => if console, then the last MSGBUFS chars are saved in msgbuf
! 329: * for inspection later (e.g. dmesg/syslog)
! 330: */
! 331: void
! 332: kputchar(int c, int flags, struct tty *tp)
! 333: {
! 334: extern int msgbufmapped;
! 335:
! 336: if (panicstr)
! 337: constty = NULL;
! 338: if ((flags & TOCONS) && tp == NULL && constty) {
! 339: tp = constty;
! 340: flags |= TOTTY;
! 341: }
! 342: if ((flags & TOTTY) && tp && tputchar(c, tp) < 0 &&
! 343: (flags & TOCONS) && tp == constty)
! 344: constty = NULL;
! 345: if ((flags & TOLOG) &&
! 346: c != '\0' && c != '\r' && c != 0177 && msgbufmapped)
! 347: msgbuf_putchar(c);
! 348: if ((flags & TOCONS) && constty == NULL && c != '\0')
! 349: (*v_putc)(c);
! 350: #ifdef DDB
! 351: if (flags & TODDB)
! 352: db_putchar(c);
! 353: #endif
! 354: }
! 355:
! 356:
! 357: /*
! 358: * uprintf: print to the controlling tty of the current process
! 359: *
! 360: * => we may block if the tty queue is full
! 361: * => no message is printed if the queue doesn't clear in a reasonable
! 362: * time
! 363: */
! 364:
! 365: void
! 366: uprintf(const char *fmt, ...)
! 367: {
! 368: struct proc *p = curproc;
! 369: va_list ap;
! 370:
! 371: if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) {
! 372: va_start(ap, fmt);
! 373: kprintf(fmt, TOTTY, p->p_session->s_ttyp, NULL, ap);
! 374: va_end(ap);
! 375: }
! 376: }
! 377:
! 378: #if defined(NFSSERVER) || defined(NFSCLIENT)
! 379:
! 380: /*
! 381: * tprintf functions: used to send messages to a specific process
! 382: *
! 383: * usage:
! 384: * get a tpr_t handle on a process "p" by using "tprintf_open(p)"
! 385: * use the handle when calling "tprintf"
! 386: * when done, do a "tprintf_close" to drop the handle
! 387: */
! 388:
! 389: /*
! 390: * tprintf_open: get a tprintf handle on a process "p"
! 391: *
! 392: * => returns NULL if process can't be printed to
! 393: */
! 394:
! 395: tpr_t
! 396: tprintf_open(struct proc *p)
! 397: {
! 398:
! 399: if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) {
! 400: SESSHOLD(p->p_session);
! 401: return ((tpr_t) p->p_session);
! 402: }
! 403: return ((tpr_t) NULL);
! 404: }
! 405:
! 406: /*
! 407: * tprintf_close: dispose of a tprintf handle obtained with tprintf_open
! 408: */
! 409:
! 410: void
! 411: tprintf_close(tpr_t sess)
! 412: {
! 413:
! 414: if (sess)
! 415: SESSRELE((struct session *) sess);
! 416: }
! 417:
! 418: /*
! 419: * tprintf: given tprintf handle to a process [obtained with tprintf_open],
! 420: * send a message to the controlling tty for that process.
! 421: *
! 422: * => also sends message to /dev/klog
! 423: */
! 424: void
! 425: tprintf(tpr_t tpr, const char *fmt, ...)
! 426: {
! 427: struct session *sess = (struct session *)tpr;
! 428: struct tty *tp = NULL;
! 429: int flags = TOLOG;
! 430: va_list ap;
! 431:
! 432: logpri(LOG_INFO);
! 433: if (sess && sess->s_ttyvp && ttycheckoutq(sess->s_ttyp, 0)) {
! 434: flags |= TOTTY;
! 435: tp = sess->s_ttyp;
! 436: }
! 437: va_start(ap, fmt);
! 438: kprintf(fmt, flags, tp, NULL, ap);
! 439: va_end(ap);
! 440: logwakeup();
! 441: }
! 442:
! 443: #endif /* NFSSERVER || NFSCLIENT */
! 444:
! 445:
! 446: /*
! 447: * ttyprintf: send a message to a specific tty
! 448: *
! 449: * => should be used only by tty driver or anything that knows the
! 450: * underlying tty will not be revoked(2)'d away. [otherwise,
! 451: * use tprintf]
! 452: */
! 453: void
! 454: ttyprintf(struct tty *tp, const char *fmt, ...)
! 455: {
! 456: va_list ap;
! 457:
! 458: va_start(ap, fmt);
! 459: kprintf(fmt, TOTTY, tp, NULL, ap);
! 460: va_end(ap);
! 461: }
! 462:
! 463: #ifdef DDB
! 464:
! 465: /*
! 466: * db_printf: printf for DDB (via db_putchar)
! 467: */
! 468:
! 469: int
! 470: db_printf(const char *fmt, ...)
! 471: {
! 472: va_list ap;
! 473: int flags, retval;
! 474:
! 475: flags = TODDB;
! 476: if (db_log)
! 477: flags |= TOLOG;
! 478: va_start(ap, fmt);
! 479: retval = kprintf(fmt, flags, NULL, NULL, ap);
! 480: va_end(ap);
! 481: return(retval);
! 482: }
! 483:
! 484: #endif /* DDB */
! 485:
! 486:
! 487: /*
! 488: * normal kernel printf functions: printf, vprintf, snprintf
! 489: */
! 490:
! 491: /*
! 492: * printf: print a message to the console and the log
! 493: */
! 494: int
! 495: printf(const char *fmt, ...)
! 496: {
! 497: va_list ap;
! 498: int savintr, retval;
! 499:
! 500: mtx_enter(&kprintf_mutex);
! 501:
! 502: savintr = consintr; /* disable interrupts */
! 503: consintr = 0;
! 504: va_start(ap, fmt);
! 505: retval = kprintf(fmt, TOCONS | TOLOG, NULL, NULL, ap);
! 506: va_end(ap);
! 507: if (!panicstr)
! 508: logwakeup();
! 509: consintr = savintr; /* reenable interrupts */
! 510:
! 511: mtx_leave(&kprintf_mutex);
! 512:
! 513: return(retval);
! 514: }
! 515:
! 516: /*
! 517: * vprintf: print a message to the console and the log [already have a
! 518: * va_list]
! 519: */
! 520:
! 521: int
! 522: vprintf(const char *fmt, va_list ap)
! 523: {
! 524: int savintr, retval;
! 525:
! 526: mtx_enter(&kprintf_mutex);
! 527:
! 528: savintr = consintr; /* disable interrupts */
! 529: consintr = 0;
! 530: retval = kprintf(fmt, TOCONS | TOLOG, NULL, NULL, ap);
! 531: if (!panicstr)
! 532: logwakeup();
! 533: consintr = savintr; /* reenable interrupts */
! 534:
! 535: mtx_leave(&kprintf_mutex);
! 536:
! 537: return (retval);
! 538: }
! 539:
! 540: /*
! 541: * snprintf: print a message to a buffer
! 542: */
! 543: int
! 544: snprintf(char *buf, size_t size, const char *fmt, ...)
! 545: {
! 546: int retval;
! 547: va_list ap;
! 548: char *p;
! 549:
! 550: p = buf + size - 1;
! 551: if (size < 1)
! 552: p = buf;
! 553: va_start(ap, fmt);
! 554: retval = kprintf(fmt, TOBUFONLY | TOCOUNT, &p, buf, ap);
! 555: va_end(ap);
! 556: if (size > 0)
! 557: *(p) = 0; /* null terminate */
! 558: return(retval);
! 559: }
! 560:
! 561: /*
! 562: * vsnprintf: print a message to a buffer [already have va_alist]
! 563: */
! 564: int
! 565: vsnprintf(char *buf, size_t size, const char *fmt, va_list ap)
! 566: {
! 567: int retval;
! 568: char *p;
! 569:
! 570: p = buf + size - 1;
! 571: if (size < 1)
! 572: p = buf;
! 573: retval = kprintf(fmt, TOBUFONLY | TOCOUNT, &p, buf, ap);
! 574: if (size > 0)
! 575: *(p) = 0; /* null terminate */
! 576: return(retval);
! 577: }
! 578:
! 579: /*
! 580: * kprintf: scaled down version of printf(3).
! 581: *
! 582: * this version based on vfprintf() from libc which was derived from
! 583: * software contributed to Berkeley by Chris Torek.
! 584: *
! 585: * Two additional formats:
! 586: *
! 587: * The format %b is supported to decode error registers.
! 588: * Its usage is:
! 589: *
! 590: * printf("reg=%b\n", regval, "<base><arg>*");
! 591: *
! 592: * where <base> is the output base expressed as a control character, e.g.
! 593: * \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
! 594: * the first of which gives the bit number to be inspected (origin 1), and
! 595: * the next characters (up to a control character, i.e. a character <= 32),
! 596: * give the name of the register. Thus:
! 597: *
! 598: * kprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
! 599: *
! 600: * would produce output:
! 601: *
! 602: * reg=3<BITTWO,BITONE>
! 603: *
! 604: * To support larger integers (> 32 bits), %b formatting will also accept
! 605: * control characters in the region 0x80 - 0xff. 0x80 refers to bit 0,
! 606: * 0x81 refers to bit 1, and so on. The equivalent string to the above is:
! 607: *
! 608: * kprintf("reg=%b\n", 3, "\10\201BITTWO\200BITONE\n");
! 609: *
! 610: * and would produce the same output.
! 611: *
! 612: * Like the rest of printf, %b can be prefixed to handle various size
! 613: * modifiers, eg. %b is for "int", %lb is for "long", and %llb supports
! 614: * "long long".
! 615: *
! 616: * This code is large and complicated...
! 617: */
! 618:
! 619: /*
! 620: * macros for converting digits to letters and vice versa
! 621: */
! 622: #define to_digit(c) ((c) - '0')
! 623: #define is_digit(c) ((unsigned)to_digit(c) <= 9)
! 624: #define to_char(n) ((n) + '0')
! 625:
! 626: /*
! 627: * flags used during conversion.
! 628: */
! 629: #define ALT 0x001 /* alternate form */
! 630: #define HEXPREFIX 0x002 /* add 0x or 0X prefix */
! 631: #define LADJUST 0x004 /* left adjustment */
! 632: #define LONGDBL 0x008 /* long double; unimplemented */
! 633: #define LONGINT 0x010 /* long integer */
! 634: #define QUADINT 0x020 /* quad integer */
! 635: #define SHORTINT 0x040 /* short integer */
! 636: #define ZEROPAD 0x080 /* zero (as opposed to blank) pad */
! 637: #define FPT 0x100 /* Floating point number */
! 638:
! 639: /*
! 640: * To extend shorts properly, we need both signed and unsigned
! 641: * argument extraction methods.
! 642: */
! 643: #define SARG() \
! 644: (flags&QUADINT ? va_arg(ap, quad_t) : \
! 645: flags&LONGINT ? va_arg(ap, long) : \
! 646: flags&SHORTINT ? (long)(short)va_arg(ap, int) : \
! 647: (long)va_arg(ap, int))
! 648: #define UARG() \
! 649: (flags&QUADINT ? va_arg(ap, u_quad_t) : \
! 650: flags&LONGINT ? va_arg(ap, u_long) : \
! 651: flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \
! 652: (u_long)va_arg(ap, u_int))
! 653:
! 654: #define KPRINTF_PUTCHAR(C) do { \
! 655: int chr = (C); \
! 656: ret += 1; \
! 657: if (oflags & TOBUFONLY) { \
! 658: if ((vp != NULL) && (sbuf == tailp)) { \
! 659: if (!(oflags & TOCOUNT)) \
! 660: goto overflow; \
! 661: } else \
! 662: *sbuf++ = chr; \
! 663: } else { \
! 664: kputchar(chr, oflags, (struct tty *)vp); \
! 665: } \
! 666: } while(0)
! 667:
! 668: int
! 669: kprintf(const char *fmt0, int oflags, void *vp, char *sbuf, va_list ap)
! 670: {
! 671: char *fmt; /* format string */
! 672: int ch; /* character from fmt */
! 673: int n; /* handy integer (short term usage) */
! 674: char *cp = NULL; /* handy char pointer (short term usage) */
! 675: int flags; /* flags as above */
! 676: int ret; /* return value accumulator */
! 677: int width; /* width from format (%8d), or 0 */
! 678: int prec; /* precision from format (%.3d), or -1 */
! 679: char sign; /* sign prefix (' ', '+', '-', or \0) */
! 680:
! 681: u_quad_t _uquad; /* integer arguments %[diouxX] */
! 682: enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
! 683: int dprec; /* a copy of prec if [diouxX], 0 otherwise */
! 684: int realsz; /* field size expanded by dprec */
! 685: int size = 0; /* size of converted field or string */
! 686: char *xdigs = NULL; /* digits for [xX] conversion */
! 687: char buf[KPRINTF_BUFSIZE]; /* space for %c, %[diouxX] */
! 688: char *tailp = NULL; /* tail pointer for snprintf */
! 689:
! 690: if ((oflags & TOBUFONLY) && (vp != NULL))
! 691: tailp = *(char **)vp;
! 692:
! 693: fmt = (char *)fmt0;
! 694: ret = 0;
! 695:
! 696: /*
! 697: * Scan the format for conversions (`%' character).
! 698: */
! 699: for (;;) {
! 700: while (*fmt != '%' && *fmt) {
! 701: KPRINTF_PUTCHAR(*fmt++);
! 702: }
! 703: if (*fmt == 0)
! 704: goto done;
! 705:
! 706: fmt++; /* skip over '%' */
! 707:
! 708: flags = 0;
! 709: dprec = 0;
! 710: width = 0;
! 711: prec = -1;
! 712: sign = '\0';
! 713:
! 714: rflag: ch = *fmt++;
! 715: reswitch: switch (ch) {
! 716: /* XXX: non-standard '%b' format */
! 717: case 'b': {
! 718: char *b, *z;
! 719: int tmp;
! 720: _uquad = UARG();
! 721: b = va_arg(ap, char *);
! 722: if (*b == 8)
! 723: snprintf(buf, sizeof buf, "%llo", _uquad);
! 724: else if (*b == 10)
! 725: snprintf(buf, sizeof buf, "%lld", _uquad);
! 726: else if (*b == 16)
! 727: snprintf(buf, sizeof buf, "%llx", _uquad);
! 728: else
! 729: break;
! 730: b++;
! 731:
! 732: z = buf;
! 733: while (*z) {
! 734: KPRINTF_PUTCHAR(*z++);
! 735: }
! 736:
! 737: if (_uquad) {
! 738: tmp = 0;
! 739: while ((n = *b++) != 0) {
! 740: if (n & 0x80)
! 741: n &= 0x7f;
! 742: else if (n <= ' ')
! 743: n = n - 1;
! 744: if (_uquad & (1LL << n)) {
! 745: KPRINTF_PUTCHAR(tmp ? ',':'<');
! 746: while (*b > ' ' &&
! 747: (*b & 0x80) == 0) {
! 748: KPRINTF_PUTCHAR(*b);
! 749: b++;
! 750: }
! 751: tmp = 1;
! 752: } else {
! 753: while (*b > ' ' &&
! 754: (*b & 0x80) == 0)
! 755: b++;
! 756: }
! 757: }
! 758: if (tmp) {
! 759: KPRINTF_PUTCHAR('>');
! 760: }
! 761: }
! 762: continue; /* no output */
! 763: }
! 764:
! 765: #ifdef DDB
! 766: /* XXX: non-standard '%r' format (print int in db_radix) */
! 767: case 'r':
! 768: if ((oflags & TODDB) == 0)
! 769: goto default_case;
! 770:
! 771: if (db_radix == 16)
! 772: goto case_z; /* signed hex */
! 773: _uquad = SARG();
! 774: if ((quad_t)_uquad < 0) {
! 775: _uquad = -_uquad;
! 776: sign = '-';
! 777: }
! 778: base = (db_radix == 8) ? OCT : DEC;
! 779: goto number;
! 780:
! 781:
! 782: /* XXX: non-standard '%z' format ("signed hex", a "hex %i")*/
! 783: case 'z':
! 784: case_z:
! 785: if ((oflags & TODDB) == 0)
! 786: goto default_case;
! 787:
! 788: xdigs = "0123456789abcdef";
! 789: ch = 'x'; /* the 'x' in '0x' (below) */
! 790: _uquad = SARG();
! 791: base = HEX;
! 792: /* leading 0x/X only if non-zero */
! 793: if (flags & ALT && _uquad != 0)
! 794: flags |= HEXPREFIX;
! 795: if ((quad_t)_uquad < 0) {
! 796: _uquad = -_uquad;
! 797: sign = '-';
! 798: }
! 799: goto number;
! 800: #endif
! 801:
! 802: case ' ':
! 803: /*
! 804: * ``If the space and + flags both appear, the space
! 805: * flag will be ignored.''
! 806: * -- ANSI X3J11
! 807: */
! 808: if (!sign)
! 809: sign = ' ';
! 810: goto rflag;
! 811: case '#':
! 812: flags |= ALT;
! 813: goto rflag;
! 814: case '*':
! 815: /*
! 816: * ``A negative field width argument is taken as a
! 817: * - flag followed by a positive field width.''
! 818: * -- ANSI X3J11
! 819: * They don't exclude field widths read from args.
! 820: */
! 821: if ((width = va_arg(ap, int)) >= 0)
! 822: goto rflag;
! 823: width = -width;
! 824: /* FALLTHROUGH */
! 825: case '-':
! 826: flags |= LADJUST;
! 827: goto rflag;
! 828: case '+':
! 829: sign = '+';
! 830: goto rflag;
! 831: case '.':
! 832: if ((ch = *fmt++) == '*') {
! 833: n = va_arg(ap, int);
! 834: prec = n < 0 ? -1 : n;
! 835: goto rflag;
! 836: }
! 837: n = 0;
! 838: while (is_digit(ch)) {
! 839: n = 10 * n + to_digit(ch);
! 840: ch = *fmt++;
! 841: }
! 842: prec = n < 0 ? -1 : n;
! 843: goto reswitch;
! 844: case '0':
! 845: /*
! 846: * ``Note that 0 is taken as a flag, not as the
! 847: * beginning of a field width.''
! 848: * -- ANSI X3J11
! 849: */
! 850: flags |= ZEROPAD;
! 851: goto rflag;
! 852: case '1': case '2': case '3': case '4':
! 853: case '5': case '6': case '7': case '8': case '9':
! 854: n = 0;
! 855: do {
! 856: n = 10 * n + to_digit(ch);
! 857: ch = *fmt++;
! 858: } while (is_digit(ch));
! 859: width = n;
! 860: goto reswitch;
! 861: case 'h':
! 862: flags |= SHORTINT;
! 863: goto rflag;
! 864: case 'l':
! 865: if (*fmt == 'l') {
! 866: fmt++;
! 867: flags |= QUADINT;
! 868: } else {
! 869: flags |= LONGINT;
! 870: }
! 871: goto rflag;
! 872: case 'q':
! 873: flags |= QUADINT;
! 874: goto rflag;
! 875: case 'c':
! 876: *(cp = buf) = va_arg(ap, int);
! 877: size = 1;
! 878: sign = '\0';
! 879: break;
! 880: case 'D':
! 881: flags |= LONGINT;
! 882: /*FALLTHROUGH*/
! 883: case 'd':
! 884: case 'i':
! 885: _uquad = SARG();
! 886: if ((quad_t)_uquad < 0) {
! 887: _uquad = -_uquad;
! 888: sign = '-';
! 889: }
! 890: base = DEC;
! 891: goto number;
! 892: case 'n':
! 893: #ifdef DDB
! 894: /* XXX: non-standard '%n' format */
! 895: /*
! 896: * XXX: HACK! DDB wants '%n' to be a '%u' printed
! 897: * in db_radix format. this should die since '%n'
! 898: * is already defined in standard printf to write
! 899: * the number of chars printed so far to the arg (which
! 900: * should be a pointer.
! 901: */
! 902: if (oflags & TODDB) {
! 903: if (db_radix == 16)
! 904: ch = 'x'; /* convert to %x */
! 905: else if (db_radix == 8)
! 906: ch = 'o'; /* convert to %o */
! 907: else
! 908: ch = 'u'; /* convert to %u */
! 909:
! 910: /* ... and start again */
! 911: goto reswitch;
! 912: }
! 913:
! 914: #endif
! 915: if (flags & QUADINT)
! 916: *va_arg(ap, quad_t *) = ret;
! 917: else if (flags & LONGINT)
! 918: *va_arg(ap, long *) = ret;
! 919: else if (flags & SHORTINT)
! 920: *va_arg(ap, short *) = ret;
! 921: else
! 922: *va_arg(ap, int *) = ret;
! 923: continue; /* no output */
! 924: case 'O':
! 925: flags |= LONGINT;
! 926: /*FALLTHROUGH*/
! 927: case 'o':
! 928: _uquad = UARG();
! 929: base = OCT;
! 930: goto nosign;
! 931: case 'p':
! 932: /*
! 933: * ``The argument shall be a pointer to void. The
! 934: * value of the pointer is converted to a sequence
! 935: * of printable characters, in an implementation-
! 936: * defined manner.''
! 937: * -- ANSI X3J11
! 938: */
! 939: /* NOSTRICT */
! 940: _uquad = (u_long)va_arg(ap, void *);
! 941: base = HEX;
! 942: xdigs = "0123456789abcdef";
! 943: flags |= HEXPREFIX;
! 944: ch = 'x';
! 945: goto nosign;
! 946: case 's':
! 947: if ((cp = va_arg(ap, char *)) == NULL)
! 948: cp = "(null)";
! 949: if (prec >= 0) {
! 950: /*
! 951: * can't use strlen; can only look for the
! 952: * NUL in the first `prec' characters, and
! 953: * strlen() will go further.
! 954: */
! 955: char *p = memchr(cp, 0, prec);
! 956:
! 957: if (p != NULL) {
! 958: size = p - cp;
! 959: if (size > prec)
! 960: size = prec;
! 961: } else
! 962: size = prec;
! 963: } else
! 964: size = strlen(cp);
! 965: sign = '\0';
! 966: break;
! 967: case 'U':
! 968: flags |= LONGINT;
! 969: /*FALLTHROUGH*/
! 970: case 'u':
! 971: _uquad = UARG();
! 972: base = DEC;
! 973: goto nosign;
! 974: case 'X':
! 975: xdigs = "0123456789ABCDEF";
! 976: goto hex;
! 977: case 'x':
! 978: xdigs = "0123456789abcdef";
! 979: hex: _uquad = UARG();
! 980: base = HEX;
! 981: /* leading 0x/X only if non-zero */
! 982: if (flags & ALT && _uquad != 0)
! 983: flags |= HEXPREFIX;
! 984:
! 985: /* unsigned conversions */
! 986: nosign: sign = '\0';
! 987: /*
! 988: * ``... diouXx conversions ... if a precision is
! 989: * specified, the 0 flag will be ignored.''
! 990: * -- ANSI X3J11
! 991: */
! 992: number: if ((dprec = prec) >= 0)
! 993: flags &= ~ZEROPAD;
! 994:
! 995: /*
! 996: * ``The result of converting a zero value with an
! 997: * explicit precision of zero is no characters.''
! 998: * -- ANSI X3J11
! 999: */
! 1000: cp = buf + KPRINTF_BUFSIZE;
! 1001: if (_uquad != 0 || prec != 0) {
! 1002: /*
! 1003: * Unsigned mod is hard, and unsigned mod
! 1004: * by a constant is easier than that by
! 1005: * a variable; hence this switch.
! 1006: */
! 1007: switch (base) {
! 1008: case OCT:
! 1009: do {
! 1010: *--cp = to_char(_uquad & 7);
! 1011: _uquad >>= 3;
! 1012: } while (_uquad);
! 1013: /* handle octal leading 0 */
! 1014: if (flags & ALT && *cp != '0')
! 1015: *--cp = '0';
! 1016: break;
! 1017:
! 1018: case DEC:
! 1019: /* many numbers are 1 digit */
! 1020: while (_uquad >= 10) {
! 1021: *--cp = to_char(_uquad % 10);
! 1022: _uquad /= 10;
! 1023: }
! 1024: *--cp = to_char(_uquad);
! 1025: break;
! 1026:
! 1027: case HEX:
! 1028: do {
! 1029: *--cp = xdigs[_uquad & 15];
! 1030: _uquad >>= 4;
! 1031: } while (_uquad);
! 1032: break;
! 1033:
! 1034: default:
! 1035: cp = "bug in kprintf: bad base";
! 1036: size = strlen(cp);
! 1037: goto skipsize;
! 1038: }
! 1039: }
! 1040: size = buf + KPRINTF_BUFSIZE - cp;
! 1041: skipsize:
! 1042: break;
! 1043: default: /* "%?" prints ?, unless ? is NUL */
! 1044: #ifdef DDB
! 1045: default_case: /* DDB */
! 1046: #endif
! 1047: if (ch == '\0')
! 1048: goto done;
! 1049: /* pretend it was %c with argument ch */
! 1050: cp = buf;
! 1051: *cp = ch;
! 1052: size = 1;
! 1053: sign = '\0';
! 1054: break;
! 1055: }
! 1056:
! 1057: /*
! 1058: * All reasonable formats wind up here. At this point, `cp'
! 1059: * points to a string which (if not flags&LADJUST) should be
! 1060: * padded out to `width' places. If flags&ZEROPAD, it should
! 1061: * first be prefixed by any sign or other prefix; otherwise,
! 1062: * it should be blank padded before the prefix is emitted.
! 1063: * After any left-hand padding and prefixing, emit zeroes
! 1064: * required by a decimal [diouxX] precision, then print the
! 1065: * string proper, then emit zeroes required by any leftover
! 1066: * floating precision; finally, if LADJUST, pad with blanks.
! 1067: *
! 1068: * Compute actual size, so we know how much to pad.
! 1069: * size excludes decimal prec; realsz includes it.
! 1070: */
! 1071: realsz = dprec > size ? dprec : size;
! 1072: if (sign)
! 1073: realsz++;
! 1074: else if (flags & HEXPREFIX)
! 1075: realsz+= 2;
! 1076:
! 1077: /* right-adjusting blank padding */
! 1078: if ((flags & (LADJUST|ZEROPAD)) == 0) {
! 1079: n = width - realsz;
! 1080: while (n-- > 0)
! 1081: KPRINTF_PUTCHAR(' ');
! 1082: }
! 1083:
! 1084: /* prefix */
! 1085: if (sign) {
! 1086: KPRINTF_PUTCHAR(sign);
! 1087: } else if (flags & HEXPREFIX) {
! 1088: KPRINTF_PUTCHAR('0');
! 1089: KPRINTF_PUTCHAR(ch);
! 1090: }
! 1091:
! 1092: /* right-adjusting zero padding */
! 1093: if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) {
! 1094: n = width - realsz;
! 1095: while (n-- > 0)
! 1096: KPRINTF_PUTCHAR('0');
! 1097: }
! 1098:
! 1099: /* leading zeroes from decimal precision */
! 1100: n = dprec - size;
! 1101: while (n-- > 0)
! 1102: KPRINTF_PUTCHAR('0');
! 1103:
! 1104: /* the string or number proper */
! 1105: while (size--)
! 1106: KPRINTF_PUTCHAR(*cp++);
! 1107: /* left-adjusting padding (always blank) */
! 1108: if (flags & LADJUST) {
! 1109: n = width - realsz;
! 1110: while (n-- > 0)
! 1111: KPRINTF_PUTCHAR(' ');
! 1112: }
! 1113: }
! 1114:
! 1115: done:
! 1116: if ((oflags & TOBUFONLY) && (vp != NULL))
! 1117: *(char **)vp = sbuf;
! 1118: overflow:
! 1119: return (ret);
! 1120: /* NOTREACHED */
! 1121: }
! 1122:
! 1123: #if __GNUC_PREREQ__(2,96)
! 1124: /*
! 1125: * XXX - these functions shouldn't be in the kernel, but gcc 3.X feels like
! 1126: * translating some printf calls to puts and since it doesn't seem
! 1127: * possible to just turn off parts of those optimizations (some of
! 1128: * them are really useful), we have to provide a dummy puts and putchar
! 1129: * that are wrappers around printf.
! 1130: */
! 1131: int puts(const char *);
! 1132: int putchar(int c);
! 1133:
! 1134: int
! 1135: puts(const char *str)
! 1136: {
! 1137: printf("%s\n", str);
! 1138:
! 1139: return (0);
! 1140: }
! 1141:
! 1142: int
! 1143: putchar(int c)
! 1144: {
! 1145: printf("%c", c);
! 1146:
! 1147: return (c);
! 1148: }
! 1149:
! 1150:
! 1151: #endif