![[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