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.21 2008/07/17 23:56:23 dillon Exp $
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/kernel.h>
48 #include <sys/msgbuf.h>
49 #include <sys/malloc.h>
53 #include <sys/tprintf.h>
54 #include <sys/stdint.h>
55 #include <sys/syslog.h>
58 #include <sys/sysctl.h>
60 #include <sys/ctype.h>
61 #include <sys/eventhandler.h>
62 #include <sys/kthread.h>
64 #include <sys/thread2.h>
65 #include <sys/spinlock2.h>
72 * Note that stdarg.h and the ANSI style va_start macro is used for both
73 * ANSI and traditional C compilers. We use the __ machine version to stay
74 * within the kernel header file set.
76 #include <machine/stdarg.h>
83 /* Max number conversion buffer length: a u_quad_t in base 2, plus NUL byte. */
84 #define MAXNBUF (sizeof(intmax_t) * NBBY + 1)
99 struct tty
*constty
; /* pointer to console "window" tty */
101 static void msglogchar(int c
, int pri
);
102 static void msgaddchar(int c
, void *dummy
);
103 static void kputchar (int ch
, void *arg
);
104 static char *ksprintn (char *nbuf
, uintmax_t num
, int base
, int *lenp
,
106 static void snprintf_func (int ch
, void *arg
);
108 static int consintr
= 1; /* Ok to handle console interrupts? */
109 static int msgbufmapped
; /* Set when safe to use msgbuf */
110 static struct spinlock cons_spin
= SPINLOCK_INITIALIZER(cons_spin
);
111 static thread_t constty_td
= NULL
;
115 static int log_console_output
= 1;
116 TUNABLE_INT("kern.log_console_output", &log_console_output
);
117 SYSCTL_INT(_kern
, OID_AUTO
, log_console_output
, CTLFLAG_RW
,
118 &log_console_output
, 0, "");
120 static int unprivileged_read_msgbuf
= 1;
121 SYSCTL_INT(_security
, OID_AUTO
, unprivileged_read_msgbuf
, CTLFLAG_RW
,
122 &unprivileged_read_msgbuf
, 0,
123 "Unprivileged processes may read the kernel message buffer");
126 * Warn that a system table is full.
129 tablefull(const char *tab
)
132 log(LOG_ERR
, "%s: table is full\n", tab
);
136 * Uprintf prints to the controlling terminal for the current process.
139 uprintf(const char *fmt
, ...)
141 struct proc
*p
= curproc
;
143 struct putchar_arg pca
;
146 if (p
&& p
->p_flag
& P_CONTROLT
&&
147 p
->p_session
->s_ttyvp
) {
149 pca
.tty
= p
->p_session
->s_ttyp
;
152 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
159 tprintf_open(struct proc
*p
)
161 if ((p
->p_flag
& P_CONTROLT
) && p
->p_session
->s_ttyvp
) {
162 sess_hold(p
->p_session
);
163 return ((tpr_t
) p
->p_session
);
165 return ((tpr_t
) NULL
);
169 tprintf_close(tpr_t sess
)
172 sess_rele((struct session
*) sess
);
176 * tprintf prints on the controlling terminal associated
177 * with the given session.
180 tprintf(tpr_t tpr
, const char *fmt
, ...)
182 struct session
*sess
= (struct session
*)tpr
;
183 struct tty
*tp
= NULL
;
186 struct putchar_arg pca
;
189 if (sess
&& sess
->s_ttyvp
&& ttycheckoutq(sess
->s_ttyp
, 0)) {
197 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
204 * Ttyprintf displays a message on a tty; it should be used only by
205 * the tty driver, or anything that knows the underlying tty will not
206 * be revoke(2)'d away. Other callers should use tprintf.
209 ttyprintf(struct tty
*tp
, const char *fmt
, ...)
212 struct putchar_arg pca
;
218 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
224 * Log writes to the log buffer, and guarantees not to sleep (so can be
225 * called by interrupt routines). If there is no process reading the
226 * log yet, it writes to the console also.
229 log(int level
, const char *fmt
, ...)
233 struct putchar_arg pca
;
237 pca
.flags
= log_open
? TOLOG
: TOCONS
;
240 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
247 #define CONSCHUNK 128
250 log_console(struct uio
*uio
)
252 int c
, i
, error
, iovlen
, nl
;
254 struct iovec
*miov
= NULL
;
258 if (!log_console_output
)
261 pri
= LOG_INFO
| LOG_CONSOLE
;
263 iovlen
= uio
->uio_iovcnt
* sizeof (struct iovec
);
264 MALLOC(miov
, struct iovec
*, iovlen
, M_TEMP
, M_WAITOK
);
265 MALLOC(consbuffer
, char *, CONSCHUNK
, M_TEMP
, M_WAITOK
);
266 bcopy((caddr_t
)muio
.uio_iov
, (caddr_t
)miov
, iovlen
);
271 while (uio
->uio_resid
> 0) {
272 c
= (int)szmin(uio
->uio_resid
, CONSCHUNK
);
273 error
= uiomove(consbuffer
, (size_t)c
, uio
);
276 for (i
= 0; i
< c
; i
++) {
277 msglogchar(consbuffer
[i
], pri
);
278 if (consbuffer
[i
] == '\n')
285 msglogchar('\n', pri
);
288 FREE(consbuffer
, M_TEMP
);
293 * Output to the console.
296 kprintf(const char *fmt
, ...)
300 struct putchar_arg pca
;
303 savintr
= consintr
; /* disable interrupts */
307 pca
.flags
= TOCONS
| TOLOG
;
309 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
313 consintr
= savintr
; /* reenable interrupts */
318 kvprintf(const char *fmt
, __va_list ap
)
321 struct putchar_arg pca
;
324 savintr
= consintr
; /* disable interrupts */
327 pca
.flags
= TOCONS
| TOLOG
;
329 retval
= kvcprintf(fmt
, kputchar
, &pca
, 10, ap
);
332 consintr
= savintr
; /* reenable interrupts */
337 * Limited rate kprintf. The passed rate structure must be initialized
338 * with the desired reporting frequency. A frequency of 0 will result in
341 * count may be initialized to a negative number to allow an initial
345 krateprintf(struct krate
*rate
, const char *fmt
, ...)
349 if (rate
->ticks
!= (int)time_second
) {
350 rate
->ticks
= (int)time_second
;
354 if (rate
->count
< rate
->freq
) {
363 * Print a character to the dmesg log, the console, and/or the user's
366 * NOTE: TOTTY does not require nonblocking operation, but TOCONS
367 * and TOLOG do. When we have a constty we still output to
368 * the real console but we have a monitoring thread which
369 * we wakeup which tracks the log.
372 kputchar(int c
, void *arg
)
374 struct putchar_arg
*ap
= (struct putchar_arg
*) arg
;
375 int flags
= ap
->flags
;
376 struct tty
*tp
= ap
->tty
;
380 if ((flags
& TOCONS
) && tp
== NULL
&& constty
)
381 flags
|= TOLOG
| TOWAKEUP
;
382 if ((flags
& TOTTY
) && tputchar(c
, tp
) < 0)
385 msglogchar(c
, ap
->pri
);
386 if ((flags
& TOCONS
) && c
)
388 if (flags
& TOWAKEUP
)
393 * Scaled down version of sprintf(3).
396 ksprintf(char *buf
, const char *cfmt
, ...)
401 __va_start(ap
, cfmt
);
402 retval
= kvcprintf(cfmt
, NULL
, (void *)buf
, 10, ap
);
409 * Scaled down version of vsprintf(3).
412 kvsprintf(char *buf
, const char *cfmt
, __va_list ap
)
416 retval
= kvcprintf(cfmt
, NULL
, (void *)buf
, 10, ap
);
422 * Scaled down version of snprintf(3).
425 ksnprintf(char *str
, size_t size
, const char *format
, ...)
430 __va_start(ap
, format
);
431 retval
= kvsnprintf(str
, size
, format
, ap
);
437 * Scaled down version of vsnprintf(3).
440 kvsnprintf(char *str
, size_t size
, const char *format
, __va_list ap
)
442 struct snprintf_arg info
;
447 retval
= kvcprintf(format
, snprintf_func
, &info
, 10, ap
);
448 if (info
.remain
>= 1)
454 ksnrprintf(char *str
, size_t size
, int radix
, const char *format
, ...)
459 __va_start(ap
, format
);
460 retval
= kvsnrprintf(str
, size
, radix
, format
, ap
);
466 kvsnrprintf(char *str
, size_t size
, int radix
, const char *format
, __va_list ap
)
468 struct snprintf_arg info
;
473 retval
= kvcprintf(format
, snprintf_func
, &info
, radix
, ap
);
474 if (info
.remain
>= 1)
480 kvasnrprintf(char **strp
, size_t size
, int radix
,
481 const char *format
, __va_list ap
)
483 struct snprintf_arg info
;
486 *strp
= kmalloc(size
, M_TEMP
, M_WAITOK
);
489 retval
= kvcprintf(format
, snprintf_func
, &info
, radix
, ap
);
490 if (info
.remain
>= 1)
496 kvasfree(char **strp
)
499 kfree(*strp
, M_TEMP
);
505 snprintf_func(int ch
, void *arg
)
507 struct snprintf_arg
*const info
= arg
;
509 if (info
->remain
>= 2) {
516 * Put a NUL-terminated ASCII number (base <= 36) in a buffer in reverse
517 * order; return an optional length and a pointer to the last character
518 * written in the buffer (i.e., the first character of the string).
519 * The buffer pointed to by `nbuf' must have length >= MAXNBUF.
522 ksprintn(char *nbuf
, uintmax_t num
, int base
, int *lenp
, int upper
)
529 c
= hex2ascii(num
% base
);
530 *++p
= upper
? toupper(c
) : c
;
531 } while (num
/= base
);
538 * Scaled down version of printf(3).
540 * Two additional formats:
542 * The format %b is supported to decode error registers.
545 * kprintf("reg=%b\n", regval, "<base><arg>*");
547 * where <base> is the output base expressed as a control character, e.g.
548 * \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
549 * the first of which gives the bit number to be inspected (origin 1), and
550 * the next characters (up to a control character, i.e. a character <= 32),
551 * give the name of the register. Thus:
553 * kvcprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
555 * would produce output:
557 * reg=3<BITTWO,BITONE>
559 * XXX: %D -- Hexdump, takes pointer and separator string:
560 * ("%6D", ptr, ":") -> XX:XX:XX:XX:XX:XX
561 * ("%*D", len, ptr, " " -> XX XX XX XX ...
564 #define PCHAR(c) {int cc=(c); if(func) (*func)(cc,arg); else *d++=cc; retval++;}
567 kvcprintf(char const *fmt
, void (*func
)(int, void*), void *arg
,
568 int radix
, __va_list ap
)
572 const char *p
, *percent
, *q
;
576 int base
, tmp
, width
, ladjust
, sharpflag
, neg
, sign
, dot
;
577 int cflag
, hflag
, jflag
, lflag
, qflag
, tflag
, zflag
;
580 int retval
= 0, stop
= 0;
584 * Make a supreme effort to avoid reentrant panics or deadlocks.
586 if (func
== kputchar
) {
587 if (mycpu
->gd_flags
& GDF_KPRINTF
)
589 atomic_set_long(&mycpu
->gd_flags
, GDF_KPRINTF
);
599 fmt
= "(fmt null)\n";
601 if (radix
< 2 || radix
> 36)
604 usespin
= (panic_cpu_gd
!= mycpu
&&
606 (((struct putchar_arg
*)arg
)->flags
& TOTTY
) == 0);
609 spin_lock(&cons_spin
);
615 while ((ch
= (u_char
)*fmt
++) != '%' || stop
) {
621 dot
= dwidth
= ladjust
= neg
= sharpflag
= sign
= upper
= 0;
622 cflag
= hflag
= jflag
= lflag
= qflag
= tflag
= zflag
= 0;
625 switch (ch
= (u_char
)*fmt
++) {
643 width
= __va_arg(ap
, int);
649 dwidth
= __va_arg(ap
, int);
657 case '1': case '2': case '3': case '4':
658 case '5': case '6': case '7': case '8': case '9':
659 for (n
= 0;; ++fmt
) {
660 n
= n
* 10 + ch
- '0';
662 if (ch
< '0' || ch
> '9')
671 num
= (u_int
)__va_arg(ap
, int);
672 p
= __va_arg(ap
, char *);
673 for (q
= ksprintn(nbuf
, num
, *p
++, NULL
, 0); *q
;)
681 if (num
& (1 << (n
- 1))) {
682 PCHAR(tmp
? ',' : '<');
683 for (; (n
= *p
) > ' '; ++p
)
687 for (; *p
> ' '; ++p
)
694 PCHAR(__va_arg(ap
, int));
697 up
= __va_arg(ap
, u_char
*);
698 p
= __va_arg(ap
, char *);
702 PCHAR(hex2ascii(*up
>> 4));
703 PCHAR(hex2ascii(*up
& 0x0f));
734 *(__va_arg(ap
, char *)) = retval
;
736 *(__va_arg(ap
, short *)) = retval
;
738 *(__va_arg(ap
, intmax_t *)) = retval
;
740 *(__va_arg(ap
, long *)) = retval
;
742 *(__va_arg(ap
, quad_t
*)) = retval
;
744 *(__va_arg(ap
, int *)) = retval
;
751 sharpflag
= (width
== 0);
753 num
= (uintptr_t)__va_arg(ap
, void *);
764 p
= __va_arg(ap
, char *);
770 for (n
= 0; n
< dwidth
&& p
[n
]; n
++)
775 if (!ladjust
&& width
> 0)
780 if (ladjust
&& width
> 0)
802 num
= (u_char
)__va_arg(ap
, int);
804 num
= (u_short
)__va_arg(ap
, int);
806 num
= __va_arg(ap
, uintmax_t);
808 num
= __va_arg(ap
, u_long
);
810 num
= __va_arg(ap
, u_quad_t
);
812 num
= __va_arg(ap
, ptrdiff_t);
814 num
= __va_arg(ap
, size_t);
816 num
= __va_arg(ap
, u_int
);
820 num
= (char)__va_arg(ap
, int);
822 num
= (short)__va_arg(ap
, int);
824 num
= __va_arg(ap
, intmax_t);
826 num
= __va_arg(ap
, long);
828 num
= __va_arg(ap
, quad_t
);
830 num
= __va_arg(ap
, ptrdiff_t);
832 num
= __va_arg(ap
, ssize_t
);
834 num
= __va_arg(ap
, int);
836 if (sign
&& (intmax_t)num
< 0) {
838 num
= -(intmax_t)num
;
840 p
= ksprintn(nbuf
, num
, base
, &tmp
, upper
);
841 if (sharpflag
&& num
!= 0) {
850 if (!ladjust
&& padc
!= '0' && width
&&
851 (width
-= tmp
) > 0) {
857 if (sharpflag
&& num
!= 0) {
860 } else if (base
== 16) {
865 if (!ladjust
&& width
&& (width
-= tmp
) > 0)
872 if (ladjust
&& width
&& (width
-= tmp
) > 0)
878 while (percent
< fmt
)
881 * Since we ignore an formatting argument it is no
882 * longer safe to obey the remaining formatting
883 * arguments as the arguments will no longer match
892 * Cleanup reentrancy issues.
894 if (func
== kputchar
)
895 atomic_clear_long(&mycpu
->gd_flags
, GDF_KPRINTF
);
897 spin_unlock(&cons_spin
);
906 * Called from the panic code to try to get the console working
907 * again in case we paniced inside a kprintf().
912 spin_init(&cons_spin
);
913 atomic_clear_long(&mycpu
->gd_flags
, GDF_KPRINTF
);
917 * Console support thread for constty intercepts. This is needed because
918 * console tty intercepts can block. Instead of having kputchar() attempt
919 * to directly write to the console intercept we just force it to log
920 * and wakeup this baby to track and dump the log to constty.
930 EVENTHANDLER_REGISTER(shutdown_pre_sync
, shutdown_kproc
,
931 constty_td
, SHUTDOWN_PRI_FIRST
);
932 constty_td
->td_flags
|= TDF_SYSTHREAD
;
935 kproc_suspend_loop();
939 if (mbp
== NULL
|| msgbufmapped
== 0 ||
940 windex
== mbp
->msg_bufx
) {
941 tsleep(constty_td
, 0, "waiting", hz
*60);
945 windex
= mbp
->msg_bufx
;
949 * Get message buf FIFO indices. rindex is tracking.
951 if ((tp
= constty
) == NULL
) {
952 rindex
= mbp
->msg_bufx
;
957 * Don't blow up if the message buffer is broken
959 if (windex
< 0 || windex
>= mbp
->msg_size
)
961 if (rindex
< 0 || rindex
>= mbp
->msg_size
)
965 * And dump it. If constty gets stuck will give up.
967 while (rindex
!= windex
) {
968 if (tputchar((uint8_t)mbp
->msg_ptr
[rindex
], tp
) < 0) {
970 rindex
= mbp
->msg_bufx
;
973 if (++rindex
>= mbp
->msg_size
)
975 if (tp
->t_outq
.c_cc
>= tp
->t_ohiwat
) {
976 tsleep(constty_daemon
, 0, "blocked", hz
/ 10);
977 if (tp
->t_outq
.c_cc
>= tp
->t_ohiwat
) {
986 static struct kproc_desc constty_kp
= {
991 SYSINIT(bufdaemon
, SI_SUB_KTHREAD_UPDATE
, SI_ORDER_ANY
,
992 kproc_start
, &constty_kp
)
995 * Put character in log buffer with a particular priority.
1000 msglogchar(int c
, int pri
)
1002 static int lastpri
= -1;
1003 static int dangling
;
1009 if (c
== '\0' || c
== '\r')
1011 if (pri
!= -1 && pri
!= lastpri
) {
1013 msgaddchar('\n', NULL
);
1016 msgaddchar('<', NULL
);
1017 for (p
= ksprintn(nbuf
, (uintmax_t)pri
, 10, NULL
, 0); *p
;)
1018 msgaddchar(*p
--, NULL
);
1019 msgaddchar('>', NULL
);
1022 msgaddchar(c
, NULL
);
1032 * Put char in log buffer. Make sure nothing blows up beyond repair if
1033 * we have an MP race.
1038 msgaddchar(int c
, void *dummy
)
1047 windex
= mbp
->msg_bufx
;
1048 mbp
->msg_ptr
[windex
] = c
;
1049 if (++windex
>= mbp
->msg_size
)
1051 rindex
= mbp
->msg_bufr
;
1052 if (windex
== rindex
) {
1054 if (rindex
>= mbp
->msg_size
)
1055 rindex
-= mbp
->msg_size
;
1056 mbp
->msg_bufr
= rindex
;
1058 mbp
->msg_bufx
= windex
;
1062 msgbufcopy(struct msgbuf
*oldp
)
1066 pos
= oldp
->msg_bufr
;
1067 while (pos
!= oldp
->msg_bufx
) {
1068 msglogchar(oldp
->msg_ptr
[pos
], -1);
1069 if (++pos
>= oldp
->msg_size
)
1075 msgbufinit(void *ptr
, size_t size
)
1078 static struct msgbuf
*oldp
= NULL
;
1080 size
-= sizeof(*msgbufp
);
1082 msgbufp
= (struct msgbuf
*) (cp
+ size
);
1083 if (msgbufp
->msg_magic
!= MSG_MAGIC
|| msgbufp
->msg_size
!= size
||
1084 msgbufp
->msg_bufx
>= size
|| msgbufp
->msg_bufr
>= size
) {
1086 bzero(msgbufp
, sizeof(*msgbufp
));
1087 msgbufp
->msg_magic
= MSG_MAGIC
;
1088 msgbufp
->msg_size
= (char *)msgbufp
- cp
;
1090 msgbufp
->msg_ptr
= cp
;
1091 if (msgbufmapped
&& oldp
!= msgbufp
)
1097 /* Sysctls for accessing/clearing the msgbuf */
1100 sysctl_kern_msgbuf(SYSCTL_HANDLER_ARGS
)
1106 * Only wheel or root can access the message log.
1108 if (unprivileged_read_msgbuf
== 0) {
1109 KKASSERT(req
->td
->td_proc
);
1110 cred
= req
->td
->td_proc
->p_ucred
;
1112 if ((cred
->cr_prison
|| groupmember(0, cred
) == 0) &&
1113 priv_check(req
->td
, PRIV_ROOT
) != 0
1120 * Unwind the buffer, so that it's linear (possibly starting with
1121 * some initial nulls).
1123 error
= sysctl_handle_opaque(oidp
, msgbufp
->msg_ptr
+ msgbufp
->msg_bufx
,
1124 msgbufp
->msg_size
- msgbufp
->msg_bufx
, req
);
1127 if (msgbufp
->msg_bufx
> 0) {
1128 error
= sysctl_handle_opaque(oidp
, msgbufp
->msg_ptr
,
1129 msgbufp
->msg_bufx
, req
);
1134 SYSCTL_PROC(_kern
, OID_AUTO
, msgbuf
, CTLTYPE_STRING
| CTLFLAG_RD
,
1135 0, 0, sysctl_kern_msgbuf
, "A", "Contents of kernel message buffer");
1137 static int msgbuf_clear
;
1140 sysctl_kern_msgbuf_clear(SYSCTL_HANDLER_ARGS
)
1143 error
= sysctl_handle_int(oidp
, oidp
->oid_arg1
, oidp
->oid_arg2
, req
);
1144 if (!error
&& req
->newptr
) {
1145 /* Clear the buffer and reset write pointer */
1146 bzero(msgbufp
->msg_ptr
, msgbufp
->msg_size
);
1147 msgbufp
->msg_bufr
= msgbufp
->msg_bufx
= 0;
1153 SYSCTL_PROC(_kern
, OID_AUTO
, msgbuf_clear
,
1154 CTLTYPE_INT
| CTLFLAG_RW
| CTLFLAG_SECURE
, &msgbuf_clear
, 0,
1155 sysctl_kern_msgbuf_clear
, "I", "Clear kernel message buffer");
1159 DB_SHOW_COMMAND(msgbuf
, db_show_msgbuf
)
1163 if (!msgbufmapped
) {
1164 db_printf("msgbuf not mapped yet\n");
1167 db_printf("msgbufp = %p\n", msgbufp
);
1168 db_printf("magic = %x, size = %d, r= %d, w = %d, ptr = %p\n",
1169 msgbufp
->msg_magic
, msgbufp
->msg_size
, msgbufp
->msg_bufr
,
1170 msgbufp
->msg_bufx
, msgbufp
->msg_ptr
);
1171 for (i
= 0; i
< msgbufp
->msg_size
; i
++) {
1172 j
= (i
+ msgbufp
->msg_bufr
) % msgbufp
->msg_size
;
1173 db_printf("%c", msgbufp
->msg_ptr
[j
]);