2 * Copyright (c) 1986, 1988, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the University of
21 * California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * @(#)subr_prf.c 8.3 (Berkeley) 1/21/94
39 * $FreeBSD: src/sys/kern/subr_prf.c,v 1.61.2.5 2002/08/31 18:22:08 dwmalone Exp $
40 * $DragonFly: src/sys/kern/subr_prf.c,v 1.16 2006/12/24 00:47:54 swildner Exp $
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/kernel.h>
46 #include <sys/msgbuf.h>
47 #include <sys/malloc.h>
50 #include <sys/tprintf.h>
51 #include <sys/syslog.h>
54 #include <sys/sysctl.h>
58 * Note that stdarg.h and the ANSI style va_start macro is used for both
59 * ANSI and traditional C compilers. We use the __ machine version to stay
60 * within the kernel header file set.
62 #include <machine/stdarg.h>
68 /* Max number conversion buffer length: a u_quad_t in base 2, plus NUL byte. */
69 #define MAXNBUF (sizeof(quad_t) * NBBY + 1)
84 struct tty
*constty
; /* pointer to console "window" tty */
86 static void (*v_putc
)(int) = cnputc
; /* routine to putc on virtual console */
87 static void msglogchar(int c
, int pri
);
88 static void msgaddchar(int c
, void *dummy
);
89 static void kputchar (int ch
, void *arg
);
90 static char *ksprintn (char *nbuf
, u_long num
, int base
, int *len
);
91 static char *ksprintqn (char *nbuf
, u_quad_t num
, int base
, int *len
);
92 static void snprintf_func (int ch
, void *arg
);
94 static int consintr
= 1; /* Ok to handle console interrupts? */
95 static int msgbufmapped
; /* Set when safe to use msgbuf */
98 static int log_console_output
= 1;
99 TUNABLE_INT("kern.log_console_output", &log_console_output
);
100 SYSCTL_INT(_kern
, OID_AUTO
, log_console_output
, CTLFLAG_RW
,
101 &log_console_output
, 0, "");
103 static int unprivileged_read_msgbuf
= 1;
104 SYSCTL_INT(_kern
, OID_AUTO
, unprivileged_read_msgbuf
, CTLFLAG_RW
,
105 &unprivileged_read_msgbuf
, 0,
106 "Unprivileged processes may read the kernel message buffer");
109 * Warn that a system table is full.
112 tablefull(const char *tab
)
115 log(LOG_ERR
, "%s: table is full\n", tab
);
119 * Uprintf prints to the controlling terminal for the current process.
120 * It may block if the tty queue is overfull. No message is printed if
121 * the queue does not clear in a reasonable time.
124 uprintf(const char *fmt
, ...)
126 struct proc
*p
= curproc
;
128 struct putchar_arg pca
;
131 if (p
&& p
->p_flag
& P_CONTROLT
&&
132 p
->p_session
->s_ttyvp
) {
134 pca
.tty
= p
->p_session
->s_ttyp
;
137 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
144 tprintf_open(struct proc
*p
)
147 if ((p
->p_flag
& P_CONTROLT
) && p
->p_session
->s_ttyvp
) {
148 sess_hold(p
->p_session
);
149 return ((tpr_t
) p
->p_session
);
151 return ((tpr_t
) NULL
);
155 tprintf_close(tpr_t sess
)
158 sess_rele((struct session
*) sess
);
162 * tprintf prints on the controlling terminal associated
163 * with the given session.
166 tprintf(tpr_t tpr
, const char *fmt
, ...)
168 struct session
*sess
= (struct session
*)tpr
;
169 struct tty
*tp
= NULL
;
172 struct putchar_arg pca
;
175 if (sess
&& sess
->s_ttyvp
&& ttycheckoutq(sess
->s_ttyp
, 0)) {
183 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
190 * Ttyprintf displays a message on a tty; it should be used only by
191 * the tty driver, or anything that knows the underlying tty will not
192 * be revoke(2)'d away. Other callers should use tprintf.
195 ttyprintf(struct tty
*tp
, const char *fmt
, ...)
198 struct putchar_arg pca
;
204 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
210 * Log writes to the log buffer, and guarantees not to sleep (so can be
211 * called by interrupt routines). If there is no process reading the
212 * log yet, it writes to the console also.
215 log(int level
, const char *fmt
, ...)
219 struct putchar_arg pca
;
223 pca
.flags
= log_open
? TOLOG
: TOCONS
;
226 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
234 addlog(const char *fmt
, ...)
238 struct putchar_arg pca
;
242 pca
.flags
= log_open
? TOLOG
: TOCONS
;
245 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
252 #define CONSCHUNK 128
255 log_console(struct uio
*uio
)
257 int c
, i
, error
, iovlen
, nl
;
259 struct iovec
*miov
= NULL
;
263 if (!log_console_output
)
266 pri
= LOG_INFO
| LOG_CONSOLE
;
268 iovlen
= uio
->uio_iovcnt
* sizeof (struct iovec
);
269 MALLOC(miov
, struct iovec
*, iovlen
, M_TEMP
, M_WAITOK
);
270 MALLOC(consbuffer
, char *, CONSCHUNK
, M_TEMP
, M_WAITOK
);
271 bcopy((caddr_t
)muio
.uio_iov
, (caddr_t
)miov
, iovlen
);
276 while (uio
->uio_resid
> 0) {
277 c
= imin(uio
->uio_resid
, CONSCHUNK
);
278 error
= uiomove(consbuffer
, c
, uio
);
281 for (i
= 0; i
< c
; i
++) {
282 msglogchar(consbuffer
[i
], pri
);
283 if (consbuffer
[i
] == '\n')
290 msglogchar('\n', pri
);
293 FREE(consbuffer
, M_TEMP
);
298 * Output to the console.
300 * NOT YET ENTIRELY MPSAFE
303 kprintf(const char *fmt
, ...)
307 struct putchar_arg pca
;
310 savintr
= consintr
; /* disable interrupts */
314 pca
.flags
= TOCONS
| TOLOG
;
317 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
322 consintr
= savintr
; /* reenable interrupts */
327 kvprintf(const char *fmt
, __va_list ap
)
330 struct putchar_arg pca
;
333 savintr
= consintr
; /* disable interrupts */
336 pca
.flags
= TOCONS
| TOLOG
;
339 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
343 consintr
= savintr
; /* reenable interrupts */
348 * Print a character on console or users terminal. If destination is
349 * the console then the last bunch of characters are saved in msgbuf for
352 * NOT YET ENTIRELY MPSAFE, EVEN WHEN LOGGING JUST TO THE SYSCONSOLE.
355 kputchar(int c
, void *arg
)
357 struct putchar_arg
*ap
= (struct putchar_arg
*) arg
;
358 int flags
= ap
->flags
;
359 struct tty
*tp
= ap
->tty
;
362 if ((flags
& TOCONS
) && tp
== NULL
&& constty
) {
366 if ((flags
& TOTTY
) && tp
&& tputchar(c
, tp
) < 0 &&
367 (flags
& TOCONS
) && tp
== constty
)
370 msglogchar(c
, ap
->pri
);
371 if ((flags
& TOCONS
) && constty
== NULL
&& c
!= '\0')
376 * Scaled down version of sprintf(3).
379 ksprintf(char *buf
, const char *cfmt
, ...)
384 __va_start(ap
, cfmt
);
385 retval
= kvcprintf(cfmt
, NULL
, (void *)buf
, 10, ap
);
392 * Scaled down version of vsprintf(3).
395 kvsprintf(char *buf
, const char *cfmt
, __va_list ap
)
399 retval
= kvcprintf(cfmt
, NULL
, (void *)buf
, 10, ap
);
405 * Scaled down version of snprintf(3).
408 ksnprintf(char *str
, size_t size
, const char *format
, ...)
413 __va_start(ap
, format
);
414 retval
= kvsnprintf(str
, size
, format
, ap
);
420 * Scaled down version of vsnprintf(3).
423 kvsnprintf(char *str
, size_t size
, const char *format
, __va_list ap
)
425 struct snprintf_arg info
;
430 retval
= kvcprintf(format
, snprintf_func
, &info
, 10, ap
);
431 if (info
.remain
>= 1)
437 snprintf_func(int ch
, void *arg
)
439 struct snprintf_arg
*const info
= arg
;
441 if (info
->remain
>= 2) {
448 * Put a NUL-terminated ASCII number (base <= 36) in a buffer in reverse
449 * order; return an optional length and a pointer to the last character
450 * written in the buffer (i.e., the first character of the string).
451 * The buffer pointed to by `nbuf' must have length >= MAXNBUF.
454 ksprintn(char *nbuf
, u_long ul
, int base
, int *lenp
)
461 *++p
= hex2ascii(ul
% base
);
462 } while (ul
/= base
);
467 /* ksprintn, but for a quad_t. */
469 ksprintqn(char *nbuf
, u_quad_t uq
, int base
, int *lenp
)
476 *++p
= hex2ascii(uq
% base
);
477 } while (uq
/= base
);
484 * Scaled down version of printf(3).
486 * Two additional formats:
488 * The format %b is supported to decode error registers.
491 * kprintf("reg=%b\n", regval, "<base><arg>*");
493 * where <base> is the output base expressed as a control character, e.g.
494 * \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
495 * the first of which gives the bit number to be inspected (origin 1), and
496 * the next characters (up to a control character, i.e. a character <= 32),
497 * give the name of the register. Thus:
499 * kvcprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
501 * would produce output:
503 * reg=3<BITTWO,BITONE>
505 * XXX: %D -- Hexdump, takes pointer and separator string:
506 * ("%6D", ptr, ":") -> XX:XX:XX:XX:XX:XX
507 * ("%*D", len, ptr, " " -> XX XX XX XX ...
510 kvcprintf(char const *fmt
, void (*func
)(int, void*), void *arg
, int radix
, __va_list ap
)
512 #define PCHAR(c) {int cc=(c); if (func) (*func)(cc,arg); else *d++ = cc; retval++; }
519 int base
, lflag
, qflag
, tmp
, width
, ladjust
, sharpflag
, neg
, sign
, dot
;
532 fmt
= "(fmt null)\n";
534 if (radix
< 2 || radix
> 36)
540 while ((ch
= (u_char
)*fmt
++) != '%') {
545 qflag
= 0; lflag
= 0; ladjust
= 0; sharpflag
= 0; neg
= 0;
546 sign
= 0; dot
= 0; dwidth
= 0;
547 reswitch
: switch (ch
= (u_char
)*fmt
++) {
565 width
= __va_arg(ap
, int);
571 dwidth
= __va_arg(ap
, int);
579 case '1': case '2': case '3': case '4':
580 case '5': case '6': case '7': case '8': case '9':
581 for (n
= 0;; ++fmt
) {
582 n
= n
* 10 + ch
- '0';
584 if (ch
< '0' || ch
> '9')
593 ul
= __va_arg(ap
, int);
594 p
= __va_arg(ap
, char *);
595 for (q
= ksprintn(nbuf
, ul
, *p
++, NULL
); *q
;)
603 if (ul
& (1 << (n
- 1))) {
604 PCHAR(tmp
? ',' : '<');
605 for (; (n
= *p
) > ' '; ++p
)
609 for (; *p
> ' '; ++p
)
616 PCHAR(__va_arg(ap
, int));
619 up
= __va_arg(ap
, u_char
*);
620 p
= __va_arg(ap
, char *);
624 PCHAR(hex2ascii(*up
>> 4));
625 PCHAR(hex2ascii(*up
& 0x0f));
634 uq
= __va_arg(ap
, quad_t
);
636 ul
= __va_arg(ap
, long);
638 ul
= __va_arg(ap
, int);
651 uq
= __va_arg(ap
, u_quad_t
);
653 ul
= __va_arg(ap
, u_long
);
655 ul
= __va_arg(ap
, u_int
);
659 ul
= (uintptr_t)__va_arg(ap
, void *);
661 sharpflag
= (width
== 0);
669 uq
= __va_arg(ap
, u_quad_t
);
671 ul
= __va_arg(ap
, u_long
);
674 (u_long
)__va_arg(ap
, int) : __va_arg(ap
, u_int
);
678 p
= __va_arg(ap
, char *);
684 for (n
= 0; n
< dwidth
&& p
[n
]; n
++)
689 if (!ladjust
&& width
> 0)
694 if (ladjust
&& width
> 0)
700 uq
= __va_arg(ap
, u_quad_t
);
702 ul
= __va_arg(ap
, u_long
);
704 ul
= __va_arg(ap
, u_int
);
710 uq
= __va_arg(ap
, u_quad_t
);
712 ul
= __va_arg(ap
, u_long
);
714 ul
= __va_arg(ap
, u_int
);
719 uq
= __va_arg(ap
, u_quad_t
);
721 ul
= __va_arg(ap
, u_long
);
724 (u_long
)__va_arg(ap
, int) : __va_arg(ap
, u_int
);
730 if (sign
&& (quad_t
)uq
< 0) {
734 p
= ksprintqn(nbuf
, uq
, base
, &tmp
);
736 if (sign
&& (long)ul
< 0) {
740 p
= ksprintn(nbuf
, ul
, base
, &tmp
);
742 if (sharpflag
&& (qflag
? uq
!= 0 : ul
!= 0)) {
751 if (!ladjust
&& width
&& (width
-= tmp
) > 0)
756 if (sharpflag
&& (qflag
? uq
!= 0 : ul
!= 0)) {
759 } else if (base
== 16) {
768 if (ladjust
&& width
&& (width
-= tmp
) > 0)
785 * Put character in log buffer with a particular priority.
790 msglogchar(int c
, int pri
)
792 static int lastpri
= -1;
799 if (c
== '\0' || c
== '\r')
801 if (pri
!= -1 && pri
!= lastpri
) {
803 msgaddchar('\n', NULL
);
806 msgaddchar('<', NULL
);
807 for (p
= ksprintn(nbuf
, (u_long
)pri
, 10, NULL
); *p
;)
808 msgaddchar(*p
--, NULL
);
809 msgaddchar('>', NULL
);
822 * Put char in log buffer. Make sure nothing blows up beyond repair if
823 * we have an MP race.
828 msgaddchar(int c
, void *dummy
)
837 windex
= mbp
->msg_bufx
;
838 mbp
->msg_ptr
[windex
] = c
;
839 if (++windex
>= mbp
->msg_size
)
841 rindex
= mbp
->msg_bufr
;
842 if (windex
== rindex
) {
844 if (rindex
>= mbp
->msg_size
)
845 rindex
-= mbp
->msg_size
;
846 mbp
->msg_bufr
= rindex
;
848 mbp
->msg_bufx
= windex
;
852 msgbufcopy(struct msgbuf
*oldp
)
856 pos
= oldp
->msg_bufr
;
857 while (pos
!= oldp
->msg_bufx
) {
858 msglogchar(oldp
->msg_ptr
[pos
], -1);
859 if (++pos
>= oldp
->msg_size
)
865 msgbufinit(void *ptr
, size_t size
)
868 static struct msgbuf
*oldp
= NULL
;
870 size
-= sizeof(*msgbufp
);
872 msgbufp
= (struct msgbuf
*) (cp
+ size
);
873 if (msgbufp
->msg_magic
!= MSG_MAGIC
|| msgbufp
->msg_size
!= size
||
874 msgbufp
->msg_bufx
>= size
|| msgbufp
->msg_bufr
>= size
) {
876 bzero(msgbufp
, sizeof(*msgbufp
));
877 msgbufp
->msg_magic
= MSG_MAGIC
;
878 msgbufp
->msg_size
= (char *)msgbufp
- cp
;
880 msgbufp
->msg_ptr
= cp
;
881 if (msgbufmapped
&& oldp
!= msgbufp
)
887 /* Sysctls for accessing/clearing the msgbuf */
890 sysctl_kern_msgbuf(SYSCTL_HANDLER_ARGS
)
896 * Only wheel or root can access the message log.
898 if (unprivileged_read_msgbuf
== 0) {
899 KKASSERT(req
->td
->td_proc
);
900 cred
= req
->td
->td_proc
->p_ucred
;
902 if ((cred
->cr_prison
|| groupmember(0, cred
) == 0) &&
910 * Unwind the buffer, so that it's linear (possibly starting with
911 * some initial nulls).
913 error
= sysctl_handle_opaque(oidp
, msgbufp
->msg_ptr
+ msgbufp
->msg_bufx
,
914 msgbufp
->msg_size
- msgbufp
->msg_bufx
, req
);
917 if (msgbufp
->msg_bufx
> 0) {
918 error
= sysctl_handle_opaque(oidp
, msgbufp
->msg_ptr
,
919 msgbufp
->msg_bufx
, req
);
924 SYSCTL_PROC(_kern
, OID_AUTO
, msgbuf
, CTLTYPE_STRING
| CTLFLAG_RD
,
925 0, 0, sysctl_kern_msgbuf
, "A", "Contents of kernel message buffer");
927 static int msgbuf_clear
;
930 sysctl_kern_msgbuf_clear(SYSCTL_HANDLER_ARGS
)
933 error
= sysctl_handle_int(oidp
, oidp
->oid_arg1
, oidp
->oid_arg2
, req
);
934 if (!error
&& req
->newptr
) {
935 /* Clear the buffer and reset write pointer */
936 bzero(msgbufp
->msg_ptr
, msgbufp
->msg_size
);
937 msgbufp
->msg_bufr
= msgbufp
->msg_bufx
= 0;
943 SYSCTL_PROC(_kern
, OID_AUTO
, msgbuf_clear
,
944 CTLTYPE_INT
| CTLFLAG_RW
| CTLFLAG_SECURE
, &msgbuf_clear
, 0,
945 sysctl_kern_msgbuf_clear
, "I", "Clear kernel message buffer");
951 DB_SHOW_COMMAND(msgbuf
, db_show_msgbuf
)
956 db_printf("msgbuf not mapped yet\n");
959 db_printf("msgbufp = %p\n", msgbufp
);
960 db_printf("magic = %x, size = %d, r= %d, w = %d, ptr = %p\n",
961 msgbufp
->msg_magic
, msgbufp
->msg_size
, msgbufp
->msg_bufr
,
962 msgbufp
->msg_bufx
, msgbufp
->msg_ptr
);
963 for (i
= 0; i
< msgbufp
->msg_size
; i
++) {
964 j
= (i
+ msgbufp
->msg_bufr
) % msgbufp
->msg_size
;
965 db_printf("%c", msgbufp
->msg_ptr
[j
]);