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. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * @(#)subr_prf.c 8.3 (Berkeley) 1/21/94
35 * $FreeBSD: src/sys/kern/subr_prf.c,v 1.61.2.5 2002/08/31 18:22:08 dwmalone Exp $
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/kernel.h>
43 #include <sys/msgbuf.h>
44 #include <sys/malloc.h>
48 #include <sys/tprintf.h>
49 #include <sys/stdint.h>
50 #include <sys/syslog.h>
53 #include <sys/sysctl.h>
55 #include <sys/ctype.h>
56 #include <sys/eventhandler.h>
57 #include <sys/kthread.h>
58 #include <sys/cpu_topology.h>
60 #include <sys/thread2.h>
61 #include <sys/spinlock2.h>
68 * Note that stdarg.h and the ANSI style va_start macro is used for both
69 * ANSI and traditional C compilers. We use the __ machine version to stay
70 * within the kernel header file set.
72 #include <machine/stdarg.h>
78 #define TONOSPIN 0x10 /* avoid serialization */
80 /* Max number conversion buffer length: a u_quad_t in base 2, plus NUL byte. */
81 #define MAXNBUF (sizeof(intmax_t) * NBBY + 1)
96 struct tty
*constty
; /* pointer to console "window" tty */
98 static void msglogchar(int c
, int pri
);
99 static void msgaddchar(int c
, void *dummy
);
100 static void kputchar (int ch
, void *arg
);
101 static char *ksprintn (char *nbuf
, uintmax_t num
, int base
, int *lenp
,
103 static void snprintf_func (int ch
, void *arg
);
105 static int consintr
= 1; /* Ok to handle console interrupts? */
106 static int msgbufmapped
; /* Set when safe to use msgbuf */
107 static struct spinlock cons_spin
= SPINLOCK_INITIALIZER(cons_spin
, "cons_spin");
108 static thread_t constty_td
= NULL
;
112 static int log_console_output
= 1;
113 TUNABLE_INT("kern.log_console_output", &log_console_output
);
114 SYSCTL_INT(_kern
, OID_AUTO
, log_console_output
, CTLFLAG_RW
,
115 &log_console_output
, 0, "");
116 static int kprintf_logging
= TOLOG
| TOCONS
;
117 SYSCTL_INT(_kern
, OID_AUTO
, kprintf_logging
, CTLFLAG_RW
,
118 &kprintf_logging
, 0, "");
120 static int ptr_restrict
= 0;
121 TUNABLE_INT("security.ptr_restrict", &ptr_restrict
);
122 SYSCTL_INT(_security
, OID_AUTO
, ptr_restrict
, CTLFLAG_RW
, &ptr_restrict
, 0,
123 "Prevent leaking the kernel pointers back to userland");
125 static int unprivileged_read_msgbuf
= 1;
126 SYSCTL_INT(_security
, OID_AUTO
, unprivileged_read_msgbuf
, CTLFLAG_RW
,
127 &unprivileged_read_msgbuf
, 0,
128 "Unprivileged processes may read the kernel message buffer");
131 * Warn that a system table is full.
134 tablefull(const char *tab
)
137 log(LOG_ERR
, "%s: table is full\n", tab
);
141 * Uprintf prints to the controlling terminal for the current process.
144 uprintf(const char *fmt
, ...)
146 struct proc
*p
= curproc
;
148 struct putchar_arg pca
;
151 if (p
&& (p
->p_flags
& P_CONTROLT
) && p
->p_session
->s_ttyvp
) {
153 pca
.tty
= p
->p_session
->s_ttyp
;
156 retval
= kvcprintf(fmt
, kputchar
, &pca
, ap
);
163 tprintf_open(struct proc
*p
)
165 if ((p
->p_flags
& P_CONTROLT
) && p
->p_session
->s_ttyvp
) {
166 sess_hold(p
->p_session
);
167 return ((tpr_t
) p
->p_session
);
173 tprintf_close(tpr_t sess
)
176 sess_rele((struct session
*) sess
);
180 * tprintf prints on the controlling terminal associated
181 * with the given session.
184 tprintf(tpr_t tpr
, const char *fmt
, ...)
186 struct session
*sess
= (struct session
*)tpr
;
187 struct tty
*tp
= NULL
;
190 struct putchar_arg pca
;
193 if (sess
&& sess
->s_ttyvp
&& ttycheckoutq(sess
->s_ttyp
, 0)) {
201 retval
= kvcprintf(fmt
, kputchar
, &pca
, ap
);
208 * Ttyprintf displays a message on a tty; it should be used only by
209 * the tty driver, or anything that knows the underlying tty will not
210 * be revoke(2)'d away. Other callers should use tprintf.
213 ttyprintf(struct tty
*tp
, const char *fmt
, ...)
216 struct putchar_arg pca
;
222 retval
= kvcprintf(fmt
, kputchar
, &pca
, ap
);
228 * Log writes to the log buffer, and guarantees not to sleep (so can be
229 * called by interrupt routines). If there is no process reading the
230 * log yet, it writes to the console also.
233 log(int level
, const char *fmt
, ...)
237 struct putchar_arg pca
;
241 if ((kprintf_logging
& TOCONS
) == 0 || log_open
)
247 retval
= kvcprintf(fmt
, kputchar
, &pca
, ap
);
254 #define CONSCHUNK 128
257 log_console(struct uio
*uio
)
259 int c
, i
, error
, iovlen
, nl
;
261 struct iovec
*miov
= NULL
;
265 if (!log_console_output
)
268 pri
= LOG_INFO
| LOG_CONSOLE
;
270 iovlen
= uio
->uio_iovcnt
* sizeof (struct iovec
);
271 miov
= kmalloc(iovlen
, M_TEMP
, M_WAITOK
);
272 consbuffer
= kmalloc(CONSCHUNK
, M_TEMP
, M_WAITOK
);
273 bcopy((caddr_t
)muio
.uio_iov
, (caddr_t
)miov
, iovlen
);
278 while (uio
->uio_resid
> 0) {
279 c
= (int)szmin(uio
->uio_resid
, CONSCHUNK
);
280 error
= uiomove(consbuffer
, (size_t)c
, uio
);
283 for (i
= 0; i
< c
; i
++) {
284 msglogchar(consbuffer
[i
], pri
);
285 if (consbuffer
[i
] == '\n')
292 msglogchar('\n', pri
);
295 kfree(consbuffer
, M_TEMP
);
300 * Output to the console.
303 kprintf(const char *fmt
, ...)
307 struct putchar_arg pca
;
310 savintr
= consintr
; /* disable interrupts */
314 pca
.flags
= kprintf_logging
& ~TOTTY
;
316 retval
= kvcprintf(fmt
, kputchar
, &pca
, ap
);
320 consintr
= savintr
; /* reenable interrupts */
325 kvprintf(const char *fmt
, __va_list ap
)
328 struct putchar_arg pca
;
331 savintr
= consintr
; /* disable interrupts */
334 pca
.flags
= kprintf_logging
& ~TOTTY
;
336 retval
= kvcprintf(fmt
, kputchar
, &pca
, ap
);
339 consintr
= savintr
; /* reenable interrupts */
344 * Limited rate kprintf. The passed rate structure must be initialized
345 * with the desired reporting frequency. A frequency of 0 will result in
348 * count may be initialized to a negative number to allow an initial
352 krateprintf(struct krate
*rate
, const char *fmt
, ...)
356 if (rate
->ticks
!= (int)time_uptime
) {
357 rate
->ticks
= (int)time_uptime
;
361 if (rate
->count
< rate
->freq
) {
370 * Print a character to the dmesg log, the console, and/or the user's
373 * NOTE: TOTTY does not require nonblocking operation, but TOCONS
374 * and TOLOG do. When we have a constty we still output to
375 * the real console but we have a monitoring thread which
376 * we wakeup which tracks the log.
379 kputchar(int c
, void *arg
)
381 struct putchar_arg
*ap
= (struct putchar_arg
*) arg
;
382 int flags
= ap
->flags
;
383 struct tty
*tp
= ap
->tty
;
387 if ((flags
& TOCONS
) && tp
== NULL
&& constty
)
388 flags
|= TOLOG
| TOWAKEUP
;
389 if ((flags
& TOTTY
) && tputchar(c
, tp
) < 0)
392 msglogchar(c
, ap
->pri
);
393 if ((flags
& TOCONS
) && c
)
395 if (flags
& TOWAKEUP
)
400 * Scaled down version of sprintf(3).
403 ksprintf(char *buf
, const char *cfmt
, ...)
408 __va_start(ap
, cfmt
);
409 retval
= kvcprintf(cfmt
, NULL
, buf
, ap
);
416 * Scaled down version of vsprintf(3).
419 kvsprintf(char *buf
, const char *cfmt
, __va_list ap
)
423 retval
= kvcprintf(cfmt
, NULL
, buf
, ap
);
429 * Scaled down version of snprintf(3).
432 ksnprintf(char *str
, size_t size
, const char *format
, ...)
437 __va_start(ap
, format
);
438 retval
= kvsnprintf(str
, size
, format
, ap
);
444 * Scaled down version of vsnprintf(3).
447 kvsnprintf(char *str
, size_t size
, const char *format
, __va_list ap
)
449 struct snprintf_arg info
;
454 retval
= kvcprintf(format
, snprintf_func
, &info
, ap
);
455 if (info
.remain
>= 1)
461 kvasnprintf(char **strp
, size_t size
, const char *format
, __va_list ap
)
463 struct snprintf_arg info
;
466 *strp
= kmalloc(size
, M_TEMP
, M_WAITOK
);
469 retval
= kvcprintf(format
, snprintf_func
, &info
, ap
);
470 if (info
.remain
>= 1)
476 kvasfree(char **strp
)
479 kfree(*strp
, M_TEMP
);
485 snprintf_func(int ch
, void *arg
)
487 struct snprintf_arg
*const info
= arg
;
489 if (info
->remain
>= 2) {
496 * Put a NUL-terminated ASCII number (base <= 36) in a buffer in reverse
497 * order; return an optional length and a pointer to the last character
498 * written in the buffer (i.e., the first character of the string).
499 * The buffer pointed to by `nbuf' must have length >= MAXNBUF.
502 ksprintn(char *nbuf
, uintmax_t num
, int base
, int *lenp
, int upper
)
509 c
= hex2ascii(num
% base
);
510 *++p
= upper
? toupper(c
) : c
;
511 } while (num
/= base
);
518 * Scaled down version of printf(3).
520 * Two additional formats:
522 * The format %pb%i is supported to decode error registers.
525 * kprintf("reg=%pb%i\n", "<base><arg>*", regval);
527 * where <base> is the output base expressed as a control character, e.g.
528 * \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
529 * the first of which gives the bit number to be inspected (origin 1), and
530 * the next characters (up to a control character, i.e. a character <= 32),
531 * give the name of the register. Thus:
533 * kvcprintf("reg=%pb%i\n", "\10\2BITTWO\1BITONE\n", 3);
535 * would produce output:
537 * reg=3<BITTWO,BITONE>
540 #define PCHAR(c) {int cc=(c); if(func) (*func)(cc,arg); else *d++=cc; retval++;}
543 kvcprintf(char const *fmt
, void (*func
)(int, void*), void *arg
, __va_list ap
)
547 const char *p
, *percent
, *q
;
550 int base
, tmp
, width
, ladjust
, sharpflag
, spaceflag
, neg
, sign
, dot
;
551 int cflag
, hflag
, jflag
, lflag
, qflag
, tflag
, zflag
;
554 int retval
= 0, stop
= 0;
559 * Make a supreme effort to avoid reentrant panics or deadlocks.
561 * NOTE! Do nothing that would access mycpu/gd/fs unless the
562 * function is the normal kputchar(), which allows us to
563 * use this function for very early debugging with a special
566 if (func
== kputchar
) {
567 if (mycpu
->gd_flags
& GDF_KPRINTF
)
569 atomic_set_long(&mycpu
->gd_flags
, GDF_KPRINTF
);
573 ddb_active
= db_active
;
585 fmt
= "(fmt null)\n";
587 usespin
= (func
== kputchar
&&
588 (kprintf_logging
& TONOSPIN
) == 0 &&
589 panic_cpu_gd
!= mycpu
&&
590 (((struct putchar_arg
*)arg
)->flags
& TOTTY
) == 0);
593 spin_lock(&cons_spin
);
599 while ((ch
= (u_char
)*fmt
++) != '%' || stop
) {
605 dot
= dwidth
= ladjust
= neg
= sharpflag
= sign
= upper
= 0;
607 cflag
= hflag
= jflag
= lflag
= qflag
= tflag
= zflag
= 0;
610 switch (ch
= (u_char
)*fmt
++) {
631 width
= __va_arg(ap
, int);
637 dwidth
= __va_arg(ap
, int);
645 case '1': case '2': case '3': case '4':
646 case '5': case '6': case '7': case '8': case '9':
647 for (n
= 0;; ++fmt
) {
648 n
= n
* 10 + ch
- '0';
650 if (ch
< '0' || ch
> '9')
659 PCHAR(__va_arg(ap
, int));
685 *(__va_arg(ap
, char *)) = retval
;
687 *(__va_arg(ap
, short *)) = retval
;
689 *(__va_arg(ap
, intmax_t *)) = retval
;
691 *(__va_arg(ap
, long *)) = retval
;
693 *(__va_arg(ap
, quad_t
*)) = retval
;
695 *(__va_arg(ap
, int *)) = retval
;
701 /* peek if this is a /b/ hiding as /p/ or not */
702 if (fmt
[0] == 'b' && fmt
[1] == '%' && fmt
[2] == 'i') {
703 fmt
+= 3; /* consume "b%i" */
704 p
= __va_arg(ap
, char *);
705 num
= (u_int
)__va_arg(ap
, int);
706 for (q
= ksprintn(nbuf
, num
, *p
++, NULL
, 0);*q
;)
714 if (num
& (1 << (n
- 1))) {
715 PCHAR(tmp
? ',' : '<');
716 for (; (n
= *p
) > ' '; ++p
)
720 for (; *p
> ' '; ++p
)
729 sharpflag
= (width
== 0);
731 num
= (uintptr_t)__va_arg(ap
, void *);
732 if (ptr_restrict
&& fmt
[0] != 'x' &&
733 !(panicstr
|| dumping
|| ddb_active
)) {
734 if (ptr_restrict
== 1) {
735 /* zero out upper bits */
746 p
= __va_arg(ap
, char *);
752 for (n
= 0; n
< dwidth
&& p
[n
]; n
++)
757 if (!ladjust
&& width
> 0)
762 if (ladjust
&& width
> 0)
784 num
= (u_char
)__va_arg(ap
, int);
786 num
= (u_short
)__va_arg(ap
, int);
788 num
= __va_arg(ap
, uintmax_t);
790 num
= __va_arg(ap
, u_long
);
792 num
= __va_arg(ap
, u_quad_t
);
794 num
= __va_arg(ap
, ptrdiff_t);
796 num
= __va_arg(ap
, size_t);
798 num
= __va_arg(ap
, u_int
);
802 num
= (char)__va_arg(ap
, int);
804 num
= (short)__va_arg(ap
, int);
806 num
= __va_arg(ap
, intmax_t);
808 num
= __va_arg(ap
, long);
810 num
= __va_arg(ap
, quad_t
);
812 num
= __va_arg(ap
, ptrdiff_t);
814 num
= __va_arg(ap
, ssize_t
);
816 num
= __va_arg(ap
, int);
818 if (sign
&& (intmax_t)num
< 0) {
820 num
= -(intmax_t)num
;
822 p
= ksprintn(nbuf
, num
, base
, &n
, upper
);
824 if (sharpflag
&& num
!= 0) {
830 if (neg
|| (sign
&& spaceflag
))
833 if (!ladjust
&& padc
== '0')
834 dwidth
= width
- tmp
;
835 width
-= tmp
+ imax(dwidth
, n
);
842 } else if (sign
&& spaceflag
) {
845 if (sharpflag
&& num
!= 0) {
848 } else if (base
== 16) {
865 while (percent
< fmt
)
868 * Since we ignore an formatting argument it is no
869 * longer safe to obey the remaining formatting
870 * arguments as the arguments will no longer match
879 * Cleanup reentrancy issues.
881 if (func
== kputchar
)
882 atomic_clear_long(&mycpu
->gd_flags
, GDF_KPRINTF
);
884 spin_unlock(&cons_spin
);
893 * Called from the panic code to try to get the console working
894 * again in case we paniced inside a kprintf().
899 spin_init(&cons_spin
, "kvcre");
900 atomic_clear_long(&mycpu
->gd_flags
, GDF_KPRINTF
);
904 * Console support thread for constty intercepts. This is needed because
905 * console tty intercepts can block. Instead of having kputchar() attempt
906 * to directly write to the console intercept we just force it to log
907 * and wakeup this baby to track and dump the log to constty.
918 EVENTHANDLER_REGISTER(shutdown_pre_sync
, shutdown_kproc
,
919 constty_td
, SHUTDOWN_PRI_FIRST
);
920 constty_td
->td_flags
|= TDF_SYSTHREAD
;
923 rindex
= mbp
->msg_bufr
; /* persistent loop variable */
924 xindex
= mbp
->msg_bufx
- 1; /* anything different than bufx */
928 kproc_suspend_loop();
933 if (xindex
== mbp
->msg_bufx
||
936 tsleep(constty_td
, 0, "waiting", hz
*60);
943 * Get message buf FIFO indices. rindex is tracking.
945 xindex
= mbp
->msg_bufx
;
947 if ((tp
= constty
) == NULL
) {
953 * Check if the calculated bytes has rolled the whole
957 if (n
> mbp
->msg_size
- 1024) {
958 rindex
= xindex
- mbp
->msg_size
+ 2048;
963 * And dump it. If constty gets stuck will give up.
965 while (rindex
!= xindex
) {
966 u_int ri
= rindex
% mbp
->msg_size
;
967 if (tputchar((uint8_t)mbp
->msg_ptr
[ri
], tp
) < 0) {
972 if (tp
->t_outq
.c_cc
>= tp
->t_ohiwat
) {
973 tsleep(constty_daemon
, 0, "blocked", hz
/ 10);
974 if (tp
->t_outq
.c_cc
>= tp
->t_ohiwat
) {
984 static struct kproc_desc constty_kp
= {
989 SYSINIT(bufdaemon
, SI_SUB_KTHREAD_UPDATE
, SI_ORDER_ANY
,
990 kproc_start
, &constty_kp
);
993 * Put character in log buffer with a particular priority.
998 msglogchar(int c
, int pri
)
1000 static int lastpri
= -1;
1001 static int dangling
;
1007 if (c
== '\0' || c
== '\r')
1009 if (pri
!= -1 && pri
!= lastpri
) {
1011 msgaddchar('\n', NULL
);
1014 msgaddchar('<', NULL
);
1015 for (p
= ksprintn(nbuf
, (uintmax_t)pri
, 10, NULL
, 0); *p
;)
1016 msgaddchar(*p
--, NULL
);
1017 msgaddchar('>', NULL
);
1020 msgaddchar(c
, NULL
);
1030 * Put char in log buffer. Make sure nothing blows up beyond repair if
1031 * we have an MP race.
1036 msgaddchar(int c
, void *dummy
)
1047 lindex
= mbp
->msg_bufl
;
1048 rindex
= mbp
->msg_bufr
;
1049 xindex
= mbp
->msg_bufx
++; /* Allow SMP race */
1052 mbp
->msg_ptr
[xindex
% mbp
->msg_size
] = c
;
1053 n
= xindex
- lindex
;
1054 if (n
> mbp
->msg_size
- 1024) {
1055 lindex
= xindex
- mbp
->msg_size
+ 2048;
1057 mbp
->msg_bufl
= lindex
;
1059 n
= xindex
- rindex
;
1060 if (n
> mbp
->msg_size
- 1024) {
1061 rindex
= xindex
- mbp
->msg_size
+ 2048;
1063 mbp
->msg_bufr
= rindex
;
1068 msgbufcopy(struct msgbuf
*oldp
)
1074 rindex
= oldp
->msg_bufr
;
1075 xindex
= oldp
->msg_bufx
;
1078 n
= xindex
- rindex
;
1079 if (n
> oldp
->msg_size
- 1024)
1080 rindex
= xindex
- oldp
->msg_size
+ 2048;
1081 while (rindex
!= xindex
) {
1082 msglogchar(oldp
->msg_ptr
[rindex
% oldp
->msg_size
], -1);
1088 msgbufinit(void *ptr
, size_t size
)
1091 static struct msgbuf
*oldp
= NULL
;
1093 size
-= sizeof(*msgbufp
);
1095 msgbufp
= (struct msgbuf
*) (cp
+ size
);
1096 if (msgbufp
->msg_magic
!= MSG_MAGIC
|| msgbufp
->msg_size
!= size
) {
1098 bzero(msgbufp
, sizeof(*msgbufp
));
1099 msgbufp
->msg_magic
= MSG_MAGIC
;
1100 msgbufp
->msg_size
= (char *)msgbufp
- cp
;
1102 msgbufp
->msg_ptr
= cp
;
1103 if (msgbufmapped
&& oldp
!= msgbufp
)
1110 /* Sysctls for accessing/clearing the msgbuf */
1113 sysctl_kern_msgbuf(SYSCTL_HANDLER_ARGS
)
1118 u_int rindex_modulo
;
1119 u_int xindex_modulo
;
1125 * Only wheel or root can access the message log.
1127 if (unprivileged_read_msgbuf
== 0) {
1128 KKASSERT(req
->td
->td_proc
);
1129 cred
= req
->td
->td_proc
->p_ucred
;
1131 if ((cred
->cr_prison
|| groupmember(0, cred
) == 0) &&
1132 priv_check(req
->td
, PRIV_ROOT
) != 0
1139 * Unwind the buffer, so that it's linear (possibly starting with
1140 * some initial nulls).
1142 * We don't push the entire buffer like we did before because
1143 * bufr (and bufl) now advance in chunks when the fifo is full,
1144 * rather than one character.
1147 rindex
= mbp
->msg_bufr
;
1148 xindex
= mbp
->msg_bufx
;
1149 n
= xindex
- rindex
;
1150 if (n
> mbp
->msg_size
- 1024) {
1151 rindex
= xindex
- mbp
->msg_size
+ 2048;
1152 n
= xindex
- rindex
;
1154 rindex_modulo
= rindex
% mbp
->msg_size
;
1155 xindex_modulo
= xindex
% mbp
->msg_size
;
1157 if (rindex_modulo
< xindex_modulo
) {
1159 * Can handle in one linear section.
1161 error
= sysctl_handle_opaque(oidp
,
1162 mbp
->msg_ptr
+ rindex_modulo
,
1163 xindex_modulo
- rindex_modulo
,
1165 } else if (rindex_modulo
== xindex_modulo
) {
1167 * Empty buffer, just return a single newline
1169 error
= sysctl_handle_opaque(oidp
, "\n", 1, req
);
1170 } else if (n
<= mbp
->msg_size
- rindex_modulo
) {
1172 * Can handle in one linear section.
1174 error
= sysctl_handle_opaque(oidp
,
1175 mbp
->msg_ptr
+ rindex_modulo
,
1180 * Glue together two linear sections into one contiguous
1183 error
= sysctl_handle_opaque(oidp
,
1184 mbp
->msg_ptr
+ rindex_modulo
,
1185 mbp
->msg_size
- rindex_modulo
,
1187 n
-= mbp
->msg_size
- rindex_modulo
;
1189 error
= sysctl_handle_opaque(oidp
, mbp
->msg_ptr
,
1195 SYSCTL_PROC(_kern
, OID_AUTO
, msgbuf
, CTLTYPE_STRING
| CTLFLAG_RD
,
1196 0, 0, sysctl_kern_msgbuf
, "A", "Contents of kernel message buffer");
1198 static int msgbuf_clear
;
1201 sysctl_kern_msgbuf_clear(SYSCTL_HANDLER_ARGS
)
1204 error
= sysctl_handle_int(oidp
, oidp
->oid_arg1
, oidp
->oid_arg2
, req
);
1205 if (!error
&& req
->newptr
) {
1206 /* Clear the buffer and reset write pointer */
1207 msgbufp
->msg_bufr
= msgbufp
->msg_bufx
;
1208 msgbufp
->msg_bufl
= msgbufp
->msg_bufx
;
1209 bzero(msgbufp
->msg_ptr
, msgbufp
->msg_size
);
1215 SYSCTL_PROC(_kern
, OID_AUTO
, msgbuf_clear
,
1216 CTLTYPE_INT
| CTLFLAG_RW
| CTLFLAG_SECURE
, &msgbuf_clear
, 0,
1217 sysctl_kern_msgbuf_clear
, "I", "Clear kernel message buffer");
1221 DB_SHOW_COMMAND(msgbuf
, db_show_msgbuf
)
1227 if (!msgbufmapped
) {
1228 db_printf("msgbuf not mapped yet\n");
1231 db_printf("msgbufp = %p\n", msgbufp
);
1232 db_printf("magic = %x, size = %d, r= %d, w = %d, ptr = %p\n",
1233 msgbufp
->msg_magic
, msgbufp
->msg_size
,
1234 msgbufp
->msg_bufr
% msgbufp
->msg_size
,
1235 msgbufp
->msg_bufx
% msgbufp
->msg_size
,
1238 rindex
= msgbufp
->msg_bufr
;
1239 for (i
= 0; i
< msgbufp
->msg_size
; i
++) {
1240 j
= (i
+ rindex
) % msgbufp
->msg_size
;
1241 db_printf("%c", msgbufp
->msg_ptr
[j
]);
1250 hexdump(const void *ptr
, int length
, const char *hdr
, int flags
)
1254 const unsigned char *cp
;
1257 if ((flags
& HD_DELIM_MASK
) != 0)
1258 delim
= (flags
& HD_DELIM_MASK
) >> 8;
1262 if ((flags
& HD_COLUMN_MASK
) != 0)
1263 cols
= flags
& HD_COLUMN_MASK
;
1268 for (i
= 0; i
< length
; i
+= cols
) {
1272 if ((flags
& HD_OMIT_COUNT
) == 0)
1273 kprintf("%04x ", i
);
1275 if ((flags
& HD_OMIT_HEX
) == 0) {
1276 for (j
= 0; j
< cols
; j
++) {
1279 kprintf("%c%02x", delim
, cp
[k
]);
1285 if ((flags
& HD_OMIT_CHARS
) == 0) {
1287 for (j
= 0; j
< cols
; j
++) {
1291 else if (cp
[k
] >= ' ' && cp
[k
] <= '~')
1292 kprintf("%c", cp
[k
]);
1303 kprint_cpuset(cpumask_t
*mask
)
1311 CPUSET_FOREACH(i
, *mask
) {
1326 kprintf("%d-%d", b
, e
- 1);
1338 kprintf("%d-%d", b
, e
- 1);