1994-05-24 10:09:53 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 1986, 1988, 1991, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
* (c) UNIX System Laboratories, Inc.
|
|
|
|
* All or some portions of this file are derived from material licensed
|
|
|
|
* to the University of California by American Telephone and Telegraph
|
|
|
|
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
|
|
|
* the permission of UNIX System Laboratories, Inc.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)subr_prf.c 8.3 (Berkeley) 1/21/94
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
Add support for reading MAM attributes to camcontrol(8) and libcam(3).
MAM is Medium Auxiliary Memory and is most commonly found as flash
chips on tapes.
This includes support for reading attributes and decoding most
known attributes, but does not yet include support for writing
attributes or reporting attributes in XML format.
libsbuf/Makefile:
Add subr_prf.c for the new sbuf_hexdump() function. This
function is essentially the same function.
libsbuf/Symbol.map:
Add a new shared library minor version, and include the
sbuf_hexdump() function.
libsbuf/Version.def:
Add version 1.4 of the libsbuf library.
libutil/hexdump.3:
Document sbuf_hexdump() alongside hexdump(3), since it is
essentially the same function.
camcontrol/Makefile:
Add attrib.c.
camcontrol/attrib.c:
Implementation of READ ATTRIBUTE support for camcontrol(8).
camcontrol/camcontrol.8:
Document the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.c:
Add the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.h:
Add a function prototype for scsiattrib().
share/man/man9/sbuf.9:
Document the existence of sbuf_hexdump() and point users to
the hexdump(3) man page for more details.
sys/cam/scsi/scsi_all.c:
Add a table of known attributes, text descriptions and
handler functions.
Add a new scsi_attrib_sbuf() function along with a number
of other related functions that help decode attributes.
scsi_attrib_ascii_sbuf() decodes ASCII format attributes.
scsi_attrib_int_sbuf() decodes binary format attributes, and
will pass them off to scsi_attrib_hexdump_sbuf() if they're
bigger than 8 bytes.
scsi_attrib_vendser_sbuf() decodes the vendor and drive
serial number attribute.
scsi_attrib_volcoh_sbuf() decodes the Volume Coherency
Information attribute that LTFS writes out.
sys/cam/scsi/scsi_all.h:
Add a number of attribute-related structure definitions and
other defines.
Add function prototypes for all of the functions added in
scsi_all.c.
sys/kern/subr_prf.c:
Add a new function, sbuf_hexdump(). This is the same as
the existing hexdump(9) function, except that it puts the
result in an sbuf.
This also changes subr_prf.c so that it can be compiled in
userland for includsion in libsbuf.
We should work to change this so that the kernel hexdump
implementation is a wrapper around sbuf_hexdump() with a
statically allocated sbuf with a drain. That will require
a drain function that goes to the kernel printf() buffer
that can take a non-NUL terminated string as input.
That is because an sbuf isn't NUL-terminated until it is
finished, and we don't want to finish it while we're still
using it.
We should also work to consolidate the userland hexdump and
kernel hexdump implemenatations, which are currently
separate. This would also mean making applications that
currently link in libutil link in libsbuf.
sys/sys/sbuf.h:
Add the prototype for sbuf_hexdump(), and add another copy
of the hexdump flag values if they aren't already defined.
Ideally the flags should be defined in one place but the
implemenation makes it difficult to do properly. (See
above.)
Sponsored by: Spectra Logic Corporation
MFC after: 1 week
2015-06-09 21:39:38 +00:00
|
|
|
#ifdef _KERNEL
|
2003-01-04 20:15:32 +00:00
|
|
|
#include "opt_ddb.h"
|
2006-11-30 04:17:05 +00:00
|
|
|
#include "opt_printf.h"
|
Add support for reading MAM attributes to camcontrol(8) and libcam(3).
MAM is Medium Auxiliary Memory and is most commonly found as flash
chips on tapes.
This includes support for reading attributes and decoding most
known attributes, but does not yet include support for writing
attributes or reporting attributes in XML format.
libsbuf/Makefile:
Add subr_prf.c for the new sbuf_hexdump() function. This
function is essentially the same function.
libsbuf/Symbol.map:
Add a new shared library minor version, and include the
sbuf_hexdump() function.
libsbuf/Version.def:
Add version 1.4 of the libsbuf library.
libutil/hexdump.3:
Document sbuf_hexdump() alongside hexdump(3), since it is
essentially the same function.
camcontrol/Makefile:
Add attrib.c.
camcontrol/attrib.c:
Implementation of READ ATTRIBUTE support for camcontrol(8).
camcontrol/camcontrol.8:
Document the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.c:
Add the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.h:
Add a function prototype for scsiattrib().
share/man/man9/sbuf.9:
Document the existence of sbuf_hexdump() and point users to
the hexdump(3) man page for more details.
sys/cam/scsi/scsi_all.c:
Add a table of known attributes, text descriptions and
handler functions.
Add a new scsi_attrib_sbuf() function along with a number
of other related functions that help decode attributes.
scsi_attrib_ascii_sbuf() decodes ASCII format attributes.
scsi_attrib_int_sbuf() decodes binary format attributes, and
will pass them off to scsi_attrib_hexdump_sbuf() if they're
bigger than 8 bytes.
scsi_attrib_vendser_sbuf() decodes the vendor and drive
serial number attribute.
scsi_attrib_volcoh_sbuf() decodes the Volume Coherency
Information attribute that LTFS writes out.
sys/cam/scsi/scsi_all.h:
Add a number of attribute-related structure definitions and
other defines.
Add function prototypes for all of the functions added in
scsi_all.c.
sys/kern/subr_prf.c:
Add a new function, sbuf_hexdump(). This is the same as
the existing hexdump(9) function, except that it puts the
result in an sbuf.
This also changes subr_prf.c so that it can be compiled in
userland for includsion in libsbuf.
We should work to change this so that the kernel hexdump
implementation is a wrapper around sbuf_hexdump() with a
statically allocated sbuf with a drain. That will require
a drain function that goes to the kernel printf() buffer
that can take a non-NUL terminated string as input.
That is because an sbuf isn't NUL-terminated until it is
finished, and we don't want to finish it while we're still
using it.
We should also work to consolidate the userland hexdump and
kernel hexdump implemenatations, which are currently
separate. This would also mean making applications that
currently link in libutil link in libsbuf.
sys/sys/sbuf.h:
Add the prototype for sbuf_hexdump(), and add another copy
of the hexdump flag values if they aren't already defined.
Ideally the flags should be defined in one place but the
implemenation makes it difficult to do properly. (See
above.)
Sponsored by: Spectra Logic Corporation
MFC after: 1 week
2015-06-09 21:39:38 +00:00
|
|
|
#endif /* _KERNEL */
|
2003-01-04 20:15:32 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
Add support for reading MAM attributes to camcontrol(8) and libcam(3).
MAM is Medium Auxiliary Memory and is most commonly found as flash
chips on tapes.
This includes support for reading attributes and decoding most
known attributes, but does not yet include support for writing
attributes or reporting attributes in XML format.
libsbuf/Makefile:
Add subr_prf.c for the new sbuf_hexdump() function. This
function is essentially the same function.
libsbuf/Symbol.map:
Add a new shared library minor version, and include the
sbuf_hexdump() function.
libsbuf/Version.def:
Add version 1.4 of the libsbuf library.
libutil/hexdump.3:
Document sbuf_hexdump() alongside hexdump(3), since it is
essentially the same function.
camcontrol/Makefile:
Add attrib.c.
camcontrol/attrib.c:
Implementation of READ ATTRIBUTE support for camcontrol(8).
camcontrol/camcontrol.8:
Document the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.c:
Add the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.h:
Add a function prototype for scsiattrib().
share/man/man9/sbuf.9:
Document the existence of sbuf_hexdump() and point users to
the hexdump(3) man page for more details.
sys/cam/scsi/scsi_all.c:
Add a table of known attributes, text descriptions and
handler functions.
Add a new scsi_attrib_sbuf() function along with a number
of other related functions that help decode attributes.
scsi_attrib_ascii_sbuf() decodes ASCII format attributes.
scsi_attrib_int_sbuf() decodes binary format attributes, and
will pass them off to scsi_attrib_hexdump_sbuf() if they're
bigger than 8 bytes.
scsi_attrib_vendser_sbuf() decodes the vendor and drive
serial number attribute.
scsi_attrib_volcoh_sbuf() decodes the Volume Coherency
Information attribute that LTFS writes out.
sys/cam/scsi/scsi_all.h:
Add a number of attribute-related structure definitions and
other defines.
Add function prototypes for all of the functions added in
scsi_all.c.
sys/kern/subr_prf.c:
Add a new function, sbuf_hexdump(). This is the same as
the existing hexdump(9) function, except that it puts the
result in an sbuf.
This also changes subr_prf.c so that it can be compiled in
userland for includsion in libsbuf.
We should work to change this so that the kernel hexdump
implementation is a wrapper around sbuf_hexdump() with a
statically allocated sbuf with a drain. That will require
a drain function that goes to the kernel printf() buffer
that can take a non-NUL terminated string as input.
That is because an sbuf isn't NUL-terminated until it is
finished, and we don't want to finish it while we're still
using it.
We should also work to consolidate the userland hexdump and
kernel hexdump implemenatations, which are currently
separate. This would also mean making applications that
currently link in libutil link in libsbuf.
sys/sys/sbuf.h:
Add the prototype for sbuf_hexdump(), and add another copy
of the hexdump flag values if they aren't already defined.
Ideally the flags should be defined in one place but the
implemenation makes it difficult to do properly. (See
above.)
Sponsored by: Spectra Logic Corporation
MFC after: 1 week
2015-06-09 21:39:38 +00:00
|
|
|
#ifdef _KERNEL
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/systm.h>
|
2002-02-23 11:12:57 +00:00
|
|
|
#include <sys/lock.h>
|
2004-07-10 21:43:23 +00:00
|
|
|
#include <sys/kdb.h>
|
2002-02-23 11:12:57 +00:00
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/sx.h>
|
1998-05-28 09:30:28 +00:00
|
|
|
#include <sys/kernel.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/msgbuf.h>
|
1997-10-12 20:26:33 +00:00
|
|
|
#include <sys/malloc.h>
|
2006-11-06 13:42:10 +00:00
|
|
|
#include <sys/priv.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/proc.h>
|
2002-11-13 15:15:59 +00:00
|
|
|
#include <sys/stddef.h>
|
2002-02-10 22:04:44 +00:00
|
|
|
#include <sys/sysctl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/tty.h>
|
|
|
|
#include <sys/syslog.h>
|
1999-08-09 10:35:05 +00:00
|
|
|
#include <sys/cons.h>
|
2000-12-20 21:50:37 +00:00
|
|
|
#include <sys/uio.h>
|
Add support for reading MAM attributes to camcontrol(8) and libcam(3).
MAM is Medium Auxiliary Memory and is most commonly found as flash
chips on tapes.
This includes support for reading attributes and decoding most
known attributes, but does not yet include support for writing
attributes or reporting attributes in XML format.
libsbuf/Makefile:
Add subr_prf.c for the new sbuf_hexdump() function. This
function is essentially the same function.
libsbuf/Symbol.map:
Add a new shared library minor version, and include the
sbuf_hexdump() function.
libsbuf/Version.def:
Add version 1.4 of the libsbuf library.
libutil/hexdump.3:
Document sbuf_hexdump() alongside hexdump(3), since it is
essentially the same function.
camcontrol/Makefile:
Add attrib.c.
camcontrol/attrib.c:
Implementation of READ ATTRIBUTE support for camcontrol(8).
camcontrol/camcontrol.8:
Document the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.c:
Add the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.h:
Add a function prototype for scsiattrib().
share/man/man9/sbuf.9:
Document the existence of sbuf_hexdump() and point users to
the hexdump(3) man page for more details.
sys/cam/scsi/scsi_all.c:
Add a table of known attributes, text descriptions and
handler functions.
Add a new scsi_attrib_sbuf() function along with a number
of other related functions that help decode attributes.
scsi_attrib_ascii_sbuf() decodes ASCII format attributes.
scsi_attrib_int_sbuf() decodes binary format attributes, and
will pass them off to scsi_attrib_hexdump_sbuf() if they're
bigger than 8 bytes.
scsi_attrib_vendser_sbuf() decodes the vendor and drive
serial number attribute.
scsi_attrib_volcoh_sbuf() decodes the Volume Coherency
Information attribute that LTFS writes out.
sys/cam/scsi/scsi_all.h:
Add a number of attribute-related structure definitions and
other defines.
Add function prototypes for all of the functions added in
scsi_all.c.
sys/kern/subr_prf.c:
Add a new function, sbuf_hexdump(). This is the same as
the existing hexdump(9) function, except that it puts the
result in an sbuf.
This also changes subr_prf.c so that it can be compiled in
userland for includsion in libsbuf.
We should work to change this so that the kernel hexdump
implementation is a wrapper around sbuf_hexdump() with a
statically allocated sbuf with a drain. That will require
a drain function that goes to the kernel printf() buffer
that can take a non-NUL terminated string as input.
That is because an sbuf isn't NUL-terminated until it is
finished, and we don't want to finish it while we're still
using it.
We should also work to consolidate the userland hexdump and
kernel hexdump implemenatations, which are currently
separate. This would also mean making applications that
currently link in libutil link in libsbuf.
sys/sys/sbuf.h:
Add the prototype for sbuf_hexdump(), and add another copy
of the hexdump flag values if they aren't already defined.
Ideally the flags should be defined in one place but the
implemenation makes it difficult to do properly. (See
above.)
Sponsored by: Spectra Logic Corporation
MFC after: 1 week
2015-06-09 21:39:38 +00:00
|
|
|
#endif
|
2006-03-09 22:37:34 +00:00
|
|
|
#include <sys/ctype.h>
|
Add support for reading MAM attributes to camcontrol(8) and libcam(3).
MAM is Medium Auxiliary Memory and is most commonly found as flash
chips on tapes.
This includes support for reading attributes and decoding most
known attributes, but does not yet include support for writing
attributes or reporting attributes in XML format.
libsbuf/Makefile:
Add subr_prf.c for the new sbuf_hexdump() function. This
function is essentially the same function.
libsbuf/Symbol.map:
Add a new shared library minor version, and include the
sbuf_hexdump() function.
libsbuf/Version.def:
Add version 1.4 of the libsbuf library.
libutil/hexdump.3:
Document sbuf_hexdump() alongside hexdump(3), since it is
essentially the same function.
camcontrol/Makefile:
Add attrib.c.
camcontrol/attrib.c:
Implementation of READ ATTRIBUTE support for camcontrol(8).
camcontrol/camcontrol.8:
Document the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.c:
Add the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.h:
Add a function prototype for scsiattrib().
share/man/man9/sbuf.9:
Document the existence of sbuf_hexdump() and point users to
the hexdump(3) man page for more details.
sys/cam/scsi/scsi_all.c:
Add a table of known attributes, text descriptions and
handler functions.
Add a new scsi_attrib_sbuf() function along with a number
of other related functions that help decode attributes.
scsi_attrib_ascii_sbuf() decodes ASCII format attributes.
scsi_attrib_int_sbuf() decodes binary format attributes, and
will pass them off to scsi_attrib_hexdump_sbuf() if they're
bigger than 8 bytes.
scsi_attrib_vendser_sbuf() decodes the vendor and drive
serial number attribute.
scsi_attrib_volcoh_sbuf() decodes the Volume Coherency
Information attribute that LTFS writes out.
sys/cam/scsi/scsi_all.h:
Add a number of attribute-related structure definitions and
other defines.
Add function prototypes for all of the functions added in
scsi_all.c.
sys/kern/subr_prf.c:
Add a new function, sbuf_hexdump(). This is the same as
the existing hexdump(9) function, except that it puts the
result in an sbuf.
This also changes subr_prf.c so that it can be compiled in
userland for includsion in libsbuf.
We should work to change this so that the kernel hexdump
implementation is a wrapper around sbuf_hexdump() with a
statically allocated sbuf with a drain. That will require
a drain function that goes to the kernel printf() buffer
that can take a non-NUL terminated string as input.
That is because an sbuf isn't NUL-terminated until it is
finished, and we don't want to finish it while we're still
using it.
We should also work to consolidate the userland hexdump and
kernel hexdump implemenatations, which are currently
separate. This would also mean making applications that
currently link in libutil link in libsbuf.
sys/sys/sbuf.h:
Add the prototype for sbuf_hexdump(), and add another copy
of the hexdump flag values if they aren't already defined.
Ideally the flags should be defined in one place but the
implemenation makes it difficult to do properly. (See
above.)
Sponsored by: Spectra Logic Corporation
MFC after: 1 week
2015-06-09 21:39:38 +00:00
|
|
|
#include <sys/sbuf.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-01-04 20:15:32 +00:00
|
|
|
#ifdef DDB
|
|
|
|
#include <ddb/ddb.h>
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Note that stdarg.h and the ANSI style va_start macro is used for both
|
|
|
|
* ANSI and traditional C compilers.
|
|
|
|
*/
|
|
|
|
#include <machine/stdarg.h>
|
|
|
|
|
Add support for reading MAM attributes to camcontrol(8) and libcam(3).
MAM is Medium Auxiliary Memory and is most commonly found as flash
chips on tapes.
This includes support for reading attributes and decoding most
known attributes, but does not yet include support for writing
attributes or reporting attributes in XML format.
libsbuf/Makefile:
Add subr_prf.c for the new sbuf_hexdump() function. This
function is essentially the same function.
libsbuf/Symbol.map:
Add a new shared library minor version, and include the
sbuf_hexdump() function.
libsbuf/Version.def:
Add version 1.4 of the libsbuf library.
libutil/hexdump.3:
Document sbuf_hexdump() alongside hexdump(3), since it is
essentially the same function.
camcontrol/Makefile:
Add attrib.c.
camcontrol/attrib.c:
Implementation of READ ATTRIBUTE support for camcontrol(8).
camcontrol/camcontrol.8:
Document the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.c:
Add the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.h:
Add a function prototype for scsiattrib().
share/man/man9/sbuf.9:
Document the existence of sbuf_hexdump() and point users to
the hexdump(3) man page for more details.
sys/cam/scsi/scsi_all.c:
Add a table of known attributes, text descriptions and
handler functions.
Add a new scsi_attrib_sbuf() function along with a number
of other related functions that help decode attributes.
scsi_attrib_ascii_sbuf() decodes ASCII format attributes.
scsi_attrib_int_sbuf() decodes binary format attributes, and
will pass them off to scsi_attrib_hexdump_sbuf() if they're
bigger than 8 bytes.
scsi_attrib_vendser_sbuf() decodes the vendor and drive
serial number attribute.
scsi_attrib_volcoh_sbuf() decodes the Volume Coherency
Information attribute that LTFS writes out.
sys/cam/scsi/scsi_all.h:
Add a number of attribute-related structure definitions and
other defines.
Add function prototypes for all of the functions added in
scsi_all.c.
sys/kern/subr_prf.c:
Add a new function, sbuf_hexdump(). This is the same as
the existing hexdump(9) function, except that it puts the
result in an sbuf.
This also changes subr_prf.c so that it can be compiled in
userland for includsion in libsbuf.
We should work to change this so that the kernel hexdump
implementation is a wrapper around sbuf_hexdump() with a
statically allocated sbuf with a drain. That will require
a drain function that goes to the kernel printf() buffer
that can take a non-NUL terminated string as input.
That is because an sbuf isn't NUL-terminated until it is
finished, and we don't want to finish it while we're still
using it.
We should also work to consolidate the userland hexdump and
kernel hexdump implemenatations, which are currently
separate. This would also mean making applications that
currently link in libutil link in libsbuf.
sys/sys/sbuf.h:
Add the prototype for sbuf_hexdump(), and add another copy
of the hexdump flag values if they aren't already defined.
Ideally the flags should be defined in one place but the
implemenation makes it difficult to do properly. (See
above.)
Sponsored by: Spectra Logic Corporation
MFC after: 1 week
2015-06-09 21:39:38 +00:00
|
|
|
#ifdef _KERNEL
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#define TOCONS 0x01
|
|
|
|
#define TOTTY 0x02
|
|
|
|
#define TOLOG 0x04
|
|
|
|
|
1999-07-10 15:27:05 +00:00
|
|
|
/* Max number conversion buffer length: a u_quad_t in base 2, plus NUL byte. */
|
2002-06-02 21:54:55 +00:00
|
|
|
#define MAXNBUF (sizeof(intmax_t) * NBBY + 1)
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-12-03 04:45:57 +00:00
|
|
|
struct putchar_arg {
|
1999-06-07 18:26:26 +00:00
|
|
|
int flags;
|
2000-12-20 21:50:37 +00:00
|
|
|
int pri;
|
1999-06-07 18:26:26 +00:00
|
|
|
struct tty *tty;
|
2006-11-01 04:54:51 +00:00
|
|
|
char *p_bufr;
|
|
|
|
size_t n_bufr;
|
|
|
|
char *p_next;
|
|
|
|
size_t remain;
|
1998-12-03 04:45:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct snprintf_arg {
|
1999-06-07 18:26:26 +00:00
|
|
|
char *str;
|
|
|
|
size_t remain;
|
1998-12-03 04:45:57 +00:00
|
|
|
};
|
|
|
|
|
2000-12-20 21:50:37 +00:00
|
|
|
extern int log_open;
|
|
|
|
|
|
|
|
static void msglogchar(int c, int pri);
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
static void msglogstr(char *str, int pri, int filter_cr);
|
2002-03-19 21:25:46 +00:00
|
|
|
static void putchar(int ch, void *arg);
|
2006-03-09 22:37:34 +00:00
|
|
|
static char *ksprintn(char *nbuf, uintmax_t num, int base, int *len, int upper);
|
2002-03-19 21:25:46 +00:00
|
|
|
static void snprintf_func(int ch, void *arg);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-05-28 09:30:28 +00:00
|
|
|
static int msgbufmapped; /* Set when safe to use msgbuf */
|
2000-12-20 21:50:37 +00:00
|
|
|
int msgbuftrigger;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2014-06-28 03:56:17 +00:00
|
|
|
static int log_console_output = 1;
|
|
|
|
SYSCTL_INT(_kern, OID_AUTO, log_console_output, CTLFLAG_RWTUN,
|
|
|
|
&log_console_output, 0, "Duplicate console output to the syslog");
|
2004-06-18 20:12:42 +00:00
|
|
|
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
/*
|
|
|
|
* See the comment in log_console() below for more explanation of this.
|
|
|
|
*/
|
2014-06-28 03:56:17 +00:00
|
|
|
static int log_console_add_linefeed;
|
|
|
|
SYSCTL_INT(_kern, OID_AUTO, log_console_add_linefeed, CTLFLAG_RWTUN,
|
|
|
|
&log_console_add_linefeed, 0, "log_console() adds extra newlines");
|
|
|
|
|
|
|
|
static int always_console_output;
|
|
|
|
SYSCTL_INT(_kern, OID_AUTO, always_console_output, CTLFLAG_RWTUN,
|
|
|
|
&always_console_output, 0, "Always output to console despite TIOCCONS");
|
2002-04-29 09:15:38 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Warn that a system table is full.
|
|
|
|
*/
|
|
|
|
void
|
2000-12-20 21:50:37 +00:00
|
|
|
tablefull(const char *tab)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
log(LOG_ERR, "%s: table is full\n", tab);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Uprintf prints to the controlling terminal for the current process.
|
|
|
|
*/
|
1999-07-24 09:34:12 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
uprintf(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
1996-01-15 22:41:03 +00:00
|
|
|
struct putchar_arg pca;
|
2009-02-27 12:50:25 +00:00
|
|
|
struct proc *p;
|
|
|
|
struct thread *td;
|
2002-02-23 11:12:57 +00:00
|
|
|
int retval;
|
|
|
|
|
2009-02-27 12:50:25 +00:00
|
|
|
td = curthread;
|
|
|
|
if (TD_IS_IDLETHREAD(td))
|
2002-02-23 11:12:57 +00:00
|
|
|
return (0);
|
|
|
|
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
sx_slock(&proctree_lock);
|
2009-02-27 12:50:25 +00:00
|
|
|
p = td->td_proc;
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
if ((p->p_flag & P_CONTROLT) == 0) {
|
|
|
|
PROC_UNLOCK(p);
|
2013-09-13 06:39:10 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
SESS_LOCK(p->p_session);
|
|
|
|
pca.tty = p->p_session->s_ttyp;
|
|
|
|
SESS_UNLOCK(p->p_session);
|
|
|
|
PROC_UNLOCK(p);
|
2005-09-26 08:02:24 +00:00
|
|
|
if (pca.tty == NULL) {
|
2013-09-13 06:39:10 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
|
|
|
return (0);
|
2005-09-26 08:02:24 +00:00
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
pca.flags = TOTTY;
|
2011-06-07 05:04:37 +00:00
|
|
|
pca.p_bufr = NULL;
|
2002-02-23 11:12:57 +00:00
|
|
|
va_start(ap, fmt);
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
tty_lock(pca.tty);
|
2013-09-13 06:39:10 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
retval = kvprintf(fmt, putchar, &pca, 10, ap);
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
tty_unlock(pca.tty);
|
2002-02-23 11:12:57 +00:00
|
|
|
va_end(ap);
|
2002-02-10 22:04:44 +00:00
|
|
|
return (retval);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2013-09-07 07:53:21 +00:00
|
|
|
* tprintf and vtprintf print on the controlling terminal associated with the
|
|
|
|
* given session, possibly to the log as well.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-11-26 20:35:21 +00:00
|
|
|
void
|
|
|
|
tprintf(struct proc *p, int pri, const char *fmt, ...)
|
2013-09-07 07:53:21 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vtprintf(p, pri, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
vtprintf(struct proc *p, int pri, const char *fmt, va_list ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct tty *tp = NULL;
|
2003-04-17 22:30:43 +00:00
|
|
|
int flags = 0;
|
1996-01-15 22:41:03 +00:00
|
|
|
struct putchar_arg pca;
|
2003-04-17 22:30:43 +00:00
|
|
|
struct session *sess = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
sx_slock(&proctree_lock);
|
2000-12-20 21:50:37 +00:00
|
|
|
if (pri != -1)
|
2000-11-26 20:35:21 +00:00
|
|
|
flags |= TOLOG;
|
2002-02-23 11:12:57 +00:00
|
|
|
if (p != NULL) {
|
|
|
|
PROC_LOCK(p);
|
|
|
|
if (p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) {
|
2003-04-17 22:30:43 +00:00
|
|
|
sess = p->p_session;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
sess_hold(sess);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
2003-04-17 22:30:43 +00:00
|
|
|
tp = sess->s_ttyp;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
if (tp != NULL && tty_checkoutq(tp))
|
2002-02-23 11:12:57 +00:00
|
|
|
flags |= TOTTY;
|
|
|
|
else
|
|
|
|
tp = NULL;
|
|
|
|
} else
|
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-12-20 21:50:37 +00:00
|
|
|
pca.pri = pri;
|
1996-01-15 22:41:03 +00:00
|
|
|
pca.tty = tp;
|
|
|
|
pca.flags = flags;
|
2011-06-07 05:04:37 +00:00
|
|
|
pca.p_bufr = NULL;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
if (pca.tty != NULL)
|
|
|
|
tty_lock(pca.tty);
|
2013-09-13 06:39:10 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
2003-05-31 20:11:33 +00:00
|
|
|
kvprintf(fmt, putchar, &pca, 10, ap);
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
if (pca.tty != NULL)
|
|
|
|
tty_unlock(pca.tty);
|
2005-03-17 08:44:41 +00:00
|
|
|
if (sess != NULL)
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
sess_release(sess);
|
2000-12-20 21:50:37 +00:00
|
|
|
msgbuftrigger = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ttyprintf displays a message on a tty; it should be used only by
|
|
|
|
* the tty driver, or anything that knows the underlying tty will not
|
|
|
|
* be revoke(2)'d away. Other callers should use tprintf.
|
|
|
|
*/
|
1999-07-24 09:34:12 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyprintf(struct tty *tp, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
1996-01-15 22:41:03 +00:00
|
|
|
struct putchar_arg pca;
|
1999-07-24 09:34:12 +00:00
|
|
|
int retval;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
va_start(ap, fmt);
|
1996-01-15 22:41:03 +00:00
|
|
|
pca.tty = tp;
|
|
|
|
pca.flags = TOTTY;
|
2011-06-07 05:04:37 +00:00
|
|
|
pca.p_bufr = NULL;
|
1999-07-24 09:34:12 +00:00
|
|
|
retval = kvprintf(fmt, putchar, &pca, 10, ap);
|
1994-05-24 10:09:53 +00:00
|
|
|
va_end(ap);
|
2002-02-10 22:04:44 +00:00
|
|
|
return (retval);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2014-03-14 01:17:11 +00:00
|
|
|
static int
|
|
|
|
_vprintf(int level, int flags, const char *fmt, va_list ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-12-20 21:50:37 +00:00
|
|
|
struct putchar_arg pca;
|
2014-03-14 01:17:11 +00:00
|
|
|
int retval;
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
#ifdef PRINTF_BUFR_SIZE
|
|
|
|
char bufr[PRINTF_BUFR_SIZE];
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-12-20 21:50:37 +00:00
|
|
|
pca.tty = NULL;
|
|
|
|
pca.pri = level;
|
2014-03-14 01:17:11 +00:00
|
|
|
pca.flags = flags;
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
#ifdef PRINTF_BUFR_SIZE
|
|
|
|
pca.p_bufr = bufr;
|
|
|
|
pca.p_next = pca.p_bufr;
|
|
|
|
pca.n_bufr = sizeof(bufr);
|
|
|
|
pca.remain = sizeof(bufr);
|
|
|
|
*pca.p_next = '\0';
|
|
|
|
#else
|
2014-03-14 01:17:11 +00:00
|
|
|
/* Don't buffer console output. */
|
2006-11-01 04:54:51 +00:00
|
|
|
pca.p_bufr = NULL;
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
#endif
|
1996-01-15 22:41:03 +00:00
|
|
|
|
2014-03-14 01:17:11 +00:00
|
|
|
retval = kvprintf(fmt, putchar, &pca, 10, ap);
|
1996-01-15 22:41:03 +00:00
|
|
|
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
#ifdef PRINTF_BUFR_SIZE
|
|
|
|
/* Write any buffered console/log output: */
|
|
|
|
if (*pca.p_bufr != '\0') {
|
|
|
|
if (pca.flags & TOLOG)
|
|
|
|
msglogstr(pca.p_bufr, level, /*filter_cr*/1);
|
|
|
|
|
|
|
|
if (pca.flags & TOCONS)
|
|
|
|
cnputs(pca.p_bufr);
|
|
|
|
}
|
|
|
|
#endif
|
2014-03-14 01:17:11 +00:00
|
|
|
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Log writes to the log buffer, and guarantees not to sleep (so can be
|
|
|
|
* called by interrupt routines). If there is no process reading the
|
|
|
|
* log yet, it writes to the console also.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
log(int level, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2015-04-20 20:03:26 +00:00
|
|
|
(void)_vprintf(level, log_open ? TOLOG : TOCONS | TOLOG, fmt, ap);
|
2014-03-14 01:17:11 +00:00
|
|
|
va_end(ap);
|
|
|
|
|
2000-12-20 22:07:59 +00:00
|
|
|
msgbuftrigger = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2000-12-20 21:50:37 +00:00
|
|
|
#define CONSCHUNK 128
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-12-20 21:50:37 +00:00
|
|
|
void
|
|
|
|
log_console(struct uio *uio)
|
|
|
|
{
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
int c, error, nl;
|
2000-12-20 21:50:37 +00:00
|
|
|
char *consbuffer;
|
|
|
|
int pri;
|
|
|
|
|
2002-04-29 09:15:38 +00:00
|
|
|
if (!log_console_output)
|
|
|
|
return;
|
|
|
|
|
2000-12-20 21:50:37 +00:00
|
|
|
pri = LOG_INFO | LOG_CONSOLE;
|
2004-07-10 15:42:16 +00:00
|
|
|
uio = cloneuio(uio);
|
|
|
|
consbuffer = malloc(CONSCHUNK, M_TEMP, M_WAITOK);
|
2000-12-20 21:50:37 +00:00
|
|
|
|
2008-12-21 21:54:01 +00:00
|
|
|
nl = 0;
|
2000-12-20 21:50:37 +00:00
|
|
|
while (uio->uio_resid > 0) {
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
c = imin(uio->uio_resid, CONSCHUNK - 1);
|
2000-12-20 21:50:37 +00:00
|
|
|
error = uiomove(consbuffer, c, uio);
|
|
|
|
if (error != 0)
|
2002-09-28 21:34:31 +00:00
|
|
|
break;
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
/* Make sure we're NUL-terminated */
|
|
|
|
consbuffer[c] = '\0';
|
|
|
|
if (consbuffer[c - 1] == '\n')
|
|
|
|
nl = 1;
|
|
|
|
else
|
|
|
|
nl = 0;
|
|
|
|
msglogstr(consbuffer, pri, /*filter_cr*/ 1);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* The previous behavior in log_console() is preserved when
|
|
|
|
* log_console_add_linefeed is non-zero. For that behavior, if an
|
|
|
|
* individual console write came in that was not terminated with a
|
|
|
|
* line feed, it would add a line feed.
|
|
|
|
*
|
|
|
|
* This results in different data in the message buffer than
|
|
|
|
* appears on the system console (which doesn't add extra line feed
|
|
|
|
* characters).
|
|
|
|
*
|
|
|
|
* A number of programs and rc scripts write a line feed, or a period
|
|
|
|
* and a line feed when they have completed their operation. On
|
|
|
|
* the console, this looks seamless, but when displayed with
|
|
|
|
* 'dmesg -a', you wind up with output that looks like this:
|
|
|
|
*
|
|
|
|
* Updating motd:
|
|
|
|
* .
|
|
|
|
*
|
|
|
|
* On the console, it looks like this:
|
|
|
|
* Updating motd:.
|
|
|
|
*
|
|
|
|
* We could add logic to detect that situation, or just not insert
|
|
|
|
* the extra newlines. Set the kern.log_console_add_linefeed
|
|
|
|
* sysctl/tunable variable to get the old behavior.
|
|
|
|
*/
|
|
|
|
if (!nl && log_console_add_linefeed) {
|
|
|
|
consbuffer[0] = '\n';
|
|
|
|
consbuffer[1] = '\0';
|
|
|
|
msglogstr(consbuffer, pri, /*filter_cr*/ 1);
|
2000-12-20 21:50:37 +00:00
|
|
|
}
|
2000-12-20 22:07:59 +00:00
|
|
|
msgbuftrigger = 1;
|
2004-07-10 15:42:16 +00:00
|
|
|
free(uio, M_IOV);
|
|
|
|
free(consbuffer, M_TEMP);
|
2000-12-20 21:50:37 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1996-01-29 03:18:05 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
printf(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
1996-01-29 03:18:05 +00:00
|
|
|
int retval;
|
2006-11-01 04:54:51 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
va_start(ap, fmt);
|
2009-02-27 13:28:54 +00:00
|
|
|
retval = vprintf(fmt, ap);
|
1994-05-24 10:09:53 +00:00
|
|
|
va_end(ap);
|
2006-11-01 04:54:51 +00:00
|
|
|
|
2002-02-10 22:04:44 +00:00
|
|
|
return (retval);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1999-07-24 09:34:12 +00:00
|
|
|
int
|
1996-01-15 22:41:03 +00:00
|
|
|
vprintf(const char *fmt, va_list ap)
|
|
|
|
{
|
1999-07-24 09:34:12 +00:00
|
|
|
int retval;
|
2006-11-01 04:54:51 +00:00
|
|
|
|
2014-03-14 01:17:11 +00:00
|
|
|
retval = _vprintf(-1, TOCONS | TOLOG, fmt, ap);
|
2006-11-01 04:54:51 +00:00
|
|
|
|
1996-01-15 22:41:03 +00:00
|
|
|
if (!panicstr)
|
2000-12-20 22:07:59 +00:00
|
|
|
msgbuftrigger = 1;
|
2006-11-01 04:54:51 +00:00
|
|
|
|
2002-02-10 22:04:44 +00:00
|
|
|
return (retval);
|
1996-01-15 22:41:03 +00:00
|
|
|
}
|
|
|
|
|
2006-11-01 04:54:51 +00:00
|
|
|
static void
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
putbuf(int c, struct putchar_arg *ap)
|
2006-11-01 04:54:51 +00:00
|
|
|
{
|
|
|
|
/* Check if no console output buffer was provided. */
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
if (ap->p_bufr == NULL) {
|
2006-11-01 04:54:51 +00:00
|
|
|
/* Output direct to the console. */
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
if (ap->flags & TOCONS)
|
|
|
|
cnputc(c);
|
|
|
|
|
|
|
|
if (ap->flags & TOLOG)
|
|
|
|
msglogchar(c, ap->pri);
|
|
|
|
} else {
|
2006-11-01 04:54:51 +00:00
|
|
|
/* Buffer the character: */
|
|
|
|
*ap->p_next++ = c;
|
|
|
|
ap->remain--;
|
|
|
|
|
|
|
|
/* Always leave the buffer zero terminated. */
|
|
|
|
*ap->p_next = '\0';
|
|
|
|
|
|
|
|
/* Check if the buffer needs to be flushed. */
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
if (ap->remain == 2 || c == '\n') {
|
|
|
|
|
|
|
|
if (ap->flags & TOLOG)
|
|
|
|
msglogstr(ap->p_bufr, ap->pri, /*filter_cr*/1);
|
|
|
|
|
|
|
|
if (ap->flags & TOCONS) {
|
|
|
|
if ((panicstr == NULL) && (constty != NULL))
|
|
|
|
msgbuf_addstr(&consmsgbuf, -1,
|
|
|
|
ap->p_bufr, /*filter_cr*/ 0);
|
|
|
|
|
|
|
|
if ((constty == NULL) ||(always_console_output))
|
|
|
|
cnputs(ap->p_bufr);
|
|
|
|
}
|
|
|
|
|
2006-11-01 04:54:51 +00:00
|
|
|
ap->p_next = ap->p_bufr;
|
|
|
|
ap->remain = ap->n_bufr;
|
|
|
|
*ap->p_next = '\0';
|
|
|
|
}
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we fill the buffer up one character at a time,
|
|
|
|
* this should not happen. We should always catch it when
|
|
|
|
* ap->remain == 2 (if not sooner due to a newline), flush
|
|
|
|
* the buffer and move on. One way this could happen is
|
|
|
|
* if someone sets PRINTF_BUFR_SIZE to 1 or something
|
|
|
|
* similarly silly.
|
|
|
|
*/
|
|
|
|
KASSERT(ap->remain > 2, ("Bad buffer logic, remain = %zd",
|
|
|
|
ap->remain));
|
2006-11-01 04:54:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1996-01-15 22:41:03 +00:00
|
|
|
/*
|
|
|
|
* Print a character on console or users terminal. If destination is
|
1998-05-28 09:30:28 +00:00
|
|
|
* the console then the last bunch of characters are saved in msgbuf for
|
1996-01-15 22:41:03 +00:00
|
|
|
* inspection later.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
putchar(int c, void *arg)
|
|
|
|
{
|
|
|
|
struct putchar_arg *ap = (struct putchar_arg*) arg;
|
|
|
|
struct tty *tp = ap->tty;
|
2006-11-01 04:54:51 +00:00
|
|
|
int flags = ap->flags;
|
2003-06-22 02:54:33 +00:00
|
|
|
|
2003-06-22 03:20:24 +00:00
|
|
|
/* Don't use the tty code after a panic or while in ddb. */
|
2006-11-01 04:54:51 +00:00
|
|
|
if (kdb_active) {
|
2003-06-22 02:54:33 +00:00
|
|
|
if (c != '\0')
|
|
|
|
cnputc(c);
|
2011-10-16 14:16:46 +00:00
|
|
|
return;
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
}
|
2011-10-16 14:16:46 +00:00
|
|
|
|
|
|
|
if ((flags & TOTTY) && tp != NULL && panicstr == NULL)
|
|
|
|
tty_putchar(tp, c);
|
|
|
|
|
|
|
|
if ((flags & (TOCONS | TOLOG)) && c != '\0')
|
|
|
|
putbuf(c, ap);
|
1996-01-15 22:41:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scaled down version of sprintf(3).
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
sprintf(char *buf, const char *cfmt, ...)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, cfmt);
|
|
|
|
retval = kvprintf(cfmt, NULL, (void *)buf, 10, ap);
|
1996-01-19 11:38:18 +00:00
|
|
|
buf[retval] = '\0';
|
1996-01-15 22:41:03 +00:00
|
|
|
va_end(ap);
|
2002-02-10 22:04:44 +00:00
|
|
|
return (retval);
|
1996-01-15 22:41:03 +00:00
|
|
|
}
|
|
|
|
|
1998-09-06 06:25:18 +00:00
|
|
|
/*
|
|
|
|
* Scaled down version of vsprintf(3).
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vsprintf(char *buf, const char *cfmt, va_list ap)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = kvprintf(cfmt, NULL, (void *)buf, 10, ap);
|
|
|
|
buf[retval] = '\0';
|
2002-02-10 22:04:44 +00:00
|
|
|
return (retval);
|
1998-09-06 06:25:18 +00:00
|
|
|
}
|
|
|
|
|
1998-12-03 04:45:57 +00:00
|
|
|
/*
|
|
|
|
* Scaled down version of snprintf(3).
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
snprintf(char *str, size_t size, const char *format, ...)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, format);
|
|
|
|
retval = vsnprintf(str, size, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scaled down version of vsnprintf(3).
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vsnprintf(char *str, size_t size, const char *format, va_list ap)
|
|
|
|
{
|
|
|
|
struct snprintf_arg info;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
info.str = str;
|
|
|
|
info.remain = size;
|
|
|
|
retval = kvprintf(format, snprintf_func, &info, 10, ap);
|
|
|
|
if (info.remain >= 1)
|
|
|
|
*info.str++ = '\0';
|
2002-02-10 22:04:44 +00:00
|
|
|
return (retval);
|
1998-12-03 04:45:57 +00:00
|
|
|
}
|
|
|
|
|
2003-02-04 10:00:34 +00:00
|
|
|
/*
|
|
|
|
* Kernel version which takes radix argument vsnprintf(3).
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vsnrprintf(char *str, size_t size, int radix, const char *format, va_list ap)
|
|
|
|
{
|
|
|
|
struct snprintf_arg info;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
info.str = str;
|
|
|
|
info.remain = size;
|
|
|
|
retval = kvprintf(format, snprintf_func, &info, radix, ap);
|
|
|
|
if (info.remain >= 1)
|
|
|
|
*info.str++ = '\0';
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
1998-12-03 04:45:57 +00:00
|
|
|
static void
|
|
|
|
snprintf_func(int ch, void *arg)
|
|
|
|
{
|
|
|
|
struct snprintf_arg *const info = arg;
|
|
|
|
|
|
|
|
if (info->remain >= 2) {
|
|
|
|
*info->str++ = ch;
|
|
|
|
info->remain--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1996-01-15 22:41:03 +00:00
|
|
|
/*
|
1999-07-10 15:27:05 +00:00
|
|
|
* Put a NUL-terminated ASCII number (base <= 36) in a buffer in reverse
|
1999-06-07 18:26:26 +00:00
|
|
|
* order; return an optional length and a pointer to the last character
|
|
|
|
* written in the buffer (i.e., the first character of the string).
|
|
|
|
* The buffer pointed to by `nbuf' must have length >= MAXNBUF.
|
1996-01-15 22:41:03 +00:00
|
|
|
*/
|
|
|
|
static char *
|
2006-03-09 22:37:34 +00:00
|
|
|
ksprintn(char *nbuf, uintmax_t num, int base, int *lenp, int upper)
|
1999-06-07 18:26:26 +00:00
|
|
|
{
|
2006-03-09 22:37:34 +00:00
|
|
|
char *p, c;
|
1996-01-15 22:41:03 +00:00
|
|
|
|
1999-06-07 18:26:26 +00:00
|
|
|
p = nbuf;
|
1999-06-06 02:41:55 +00:00
|
|
|
*p = '\0';
|
1996-01-15 22:41:03 +00:00
|
|
|
do {
|
2006-03-09 22:37:34 +00:00
|
|
|
c = hex2ascii(num % base);
|
|
|
|
*++p = upper ? toupper(c) : c;
|
2002-06-02 21:54:55 +00:00
|
|
|
} while (num /= base);
|
1999-07-09 17:54:39 +00:00
|
|
|
if (lenp)
|
|
|
|
*lenp = p - nbuf;
|
|
|
|
return (p);
|
|
|
|
}
|
1996-01-15 22:41:03 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Scaled down version of printf(3).
|
|
|
|
*
|
|
|
|
* Two additional formats:
|
|
|
|
*
|
|
|
|
* The format %b is supported to decode error registers.
|
|
|
|
* Its usage is:
|
|
|
|
*
|
|
|
|
* printf("reg=%b\n", regval, "<base><arg>*");
|
|
|
|
*
|
|
|
|
* where <base> is the output base expressed as a control character, e.g.
|
|
|
|
* \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
|
|
|
|
* the first of which gives the bit number to be inspected (origin 1), and
|
|
|
|
* the next characters (up to a control character, i.e. a character <= 32),
|
|
|
|
* give the name of the register. Thus:
|
|
|
|
*
|
2015-01-23 07:30:57 +00:00
|
|
|
* kvprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE");
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
|
|
|
* would produce output:
|
|
|
|
*
|
|
|
|
* reg=3<BITTWO,BITONE>
|
|
|
|
*
|
1996-01-24 20:56:20 +00:00
|
|
|
* XXX: %D -- Hexdump, takes pointer and separator string:
|
|
|
|
* ("%6D", ptr, ":") -> XX:XX:XX:XX:XX:XX
|
|
|
|
* ("%*D", len, ptr, " " -> XX XX XX XX ...
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1996-01-15 22:41:03 +00:00
|
|
|
int
|
|
|
|
kvprintf(char const *fmt, void (*func)(int, void*), void *arg, int radix, va_list ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1996-01-15 22:41:03 +00:00
|
|
|
#define PCHAR(c) {int cc=(c); if (func) (*func)(cc,arg); else *d++ = cc; retval++; }
|
1999-06-06 02:41:55 +00:00
|
|
|
char nbuf[MAXNBUF];
|
2002-06-02 21:54:55 +00:00
|
|
|
char *d;
|
|
|
|
const char *p, *percent, *q;
|
1996-01-24 20:56:20 +00:00
|
|
|
u_char *up;
|
1996-01-15 22:41:03 +00:00
|
|
|
int ch, n;
|
2002-06-02 21:54:55 +00:00
|
|
|
uintmax_t num;
|
1999-07-09 17:54:39 +00:00
|
|
|
int base, lflag, qflag, tmp, width, ladjust, sharpflag, neg, sign, dot;
|
2004-02-19 05:29:39 +00:00
|
|
|
int cflag, hflag, jflag, tflag, zflag;
|
2006-03-09 22:37:34 +00:00
|
|
|
int dwidth, upper;
|
1994-05-24 10:09:53 +00:00
|
|
|
char padc;
|
2005-09-03 10:28:08 +00:00
|
|
|
int stop = 0, retval = 0;
|
1996-01-15 22:41:03 +00:00
|
|
|
|
2002-06-02 21:54:55 +00:00
|
|
|
num = 0;
|
1996-01-19 11:38:18 +00:00
|
|
|
if (!func)
|
1996-01-15 22:41:03 +00:00
|
|
|
d = (char *) arg;
|
|
|
|
else
|
1996-01-19 11:38:18 +00:00
|
|
|
d = NULL;
|
1994-12-28 06:28:34 +00:00
|
|
|
|
|
|
|
if (fmt == NULL)
|
1994-12-30 12:17:42 +00:00
|
|
|
fmt = "(fmt null)\n";
|
1996-01-22 13:21:33 +00:00
|
|
|
|
1996-01-24 20:56:20 +00:00
|
|
|
if (radix < 2 || radix > 36)
|
1996-01-22 13:21:33 +00:00
|
|
|
radix = 10;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
for (;;) {
|
|
|
|
padc = ' ';
|
|
|
|
width = 0;
|
2005-09-03 10:28:08 +00:00
|
|
|
while ((ch = (u_char)*fmt++) != '%' || stop) {
|
2002-06-02 21:55:58 +00:00
|
|
|
if (ch == '\0')
|
2002-02-10 22:04:44 +00:00
|
|
|
return (retval);
|
1996-01-15 22:41:03 +00:00
|
|
|
PCHAR(ch);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-06-02 21:54:55 +00:00
|
|
|
percent = fmt - 1;
|
1999-07-09 17:54:39 +00:00
|
|
|
qflag = 0; lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
|
2006-03-09 22:37:34 +00:00
|
|
|
sign = 0; dot = 0; dwidth = 0; upper = 0;
|
2004-02-19 05:29:39 +00:00
|
|
|
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
|
1996-08-31 16:52:44 +00:00
|
|
|
reswitch: switch (ch = (u_char)*fmt++) {
|
1996-01-16 18:08:57 +00:00
|
|
|
case '.':
|
|
|
|
dot = 1;
|
|
|
|
goto reswitch;
|
1996-01-15 22:41:03 +00:00
|
|
|
case '#':
|
|
|
|
sharpflag = 1;
|
|
|
|
goto reswitch;
|
|
|
|
case '+':
|
|
|
|
sign = 1;
|
|
|
|
goto reswitch;
|
|
|
|
case '-':
|
|
|
|
ladjust = 1;
|
|
|
|
goto reswitch;
|
|
|
|
case '%':
|
|
|
|
PCHAR(ch);
|
|
|
|
break;
|
|
|
|
case '*':
|
1996-01-19 21:05:52 +00:00
|
|
|
if (!dot) {
|
|
|
|
width = va_arg(ap, int);
|
|
|
|
if (width < 0) {
|
|
|
|
ladjust = !ladjust;
|
|
|
|
width = -width;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
dwidth = va_arg(ap, int);
|
1996-01-15 22:41:03 +00:00
|
|
|
}
|
|
|
|
goto reswitch;
|
1994-05-24 10:09:53 +00:00
|
|
|
case '0':
|
1996-01-18 10:23:02 +00:00
|
|
|
if (!dot) {
|
|
|
|
padc = '0';
|
|
|
|
goto reswitch;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
case '1': case '2': case '3': case '4':
|
|
|
|
case '5': case '6': case '7': case '8': case '9':
|
1996-01-18 10:23:02 +00:00
|
|
|
for (n = 0;; ++fmt) {
|
|
|
|
n = n * 10 + ch - '0';
|
|
|
|
ch = *fmt;
|
|
|
|
if (ch < '0' || ch > '9')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (dot)
|
|
|
|
dwidth = n;
|
|
|
|
else
|
|
|
|
width = n;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto reswitch;
|
|
|
|
case 'b':
|
2003-01-07 18:17:18 +00:00
|
|
|
num = (u_int)va_arg(ap, int);
|
1994-05-24 10:09:53 +00:00
|
|
|
p = va_arg(ap, char *);
|
2006-03-09 22:37:34 +00:00
|
|
|
for (q = ksprintn(nbuf, num, *p++, NULL, 0); *q;)
|
1996-01-15 22:41:03 +00:00
|
|
|
PCHAR(*q--);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-06-02 21:54:55 +00:00
|
|
|
if (num == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
1994-10-02 17:35:40 +00:00
|
|
|
for (tmp = 0; *p;) {
|
|
|
|
n = *p++;
|
2002-06-02 21:54:55 +00:00
|
|
|
if (num & (1 << (n - 1))) {
|
1996-01-15 22:41:03 +00:00
|
|
|
PCHAR(tmp ? ',' : '<');
|
1994-05-24 10:09:53 +00:00
|
|
|
for (; (n = *p) > ' '; ++p)
|
1996-01-15 22:41:03 +00:00
|
|
|
PCHAR(n);
|
1994-05-24 10:09:53 +00:00
|
|
|
tmp = 1;
|
|
|
|
} else
|
|
|
|
for (; *p > ' '; ++p)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (tmp)
|
1996-01-15 22:41:03 +00:00
|
|
|
PCHAR('>');
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
case 'c':
|
1996-01-15 22:41:03 +00:00
|
|
|
PCHAR(va_arg(ap, int));
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1996-01-24 20:56:20 +00:00
|
|
|
case 'D':
|
|
|
|
up = va_arg(ap, u_char *);
|
|
|
|
p = va_arg(ap, char *);
|
|
|
|
if (!width)
|
|
|
|
width = 16;
|
|
|
|
while(width--) {
|
|
|
|
PCHAR(hex2ascii(*up >> 4));
|
|
|
|
PCHAR(hex2ascii(*up & 0x0f));
|
|
|
|
up++;
|
|
|
|
if (width)
|
|
|
|
for (q=p;*q;q++)
|
|
|
|
PCHAR(*q);
|
|
|
|
}
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
case 'd':
|
2002-07-05 18:36:49 +00:00
|
|
|
case 'i':
|
1994-05-24 10:09:53 +00:00
|
|
|
base = 10;
|
2002-06-02 21:54:55 +00:00
|
|
|
sign = 1;
|
|
|
|
goto handle_sign;
|
2004-02-19 05:29:39 +00:00
|
|
|
case 'h':
|
|
|
|
if (hflag) {
|
|
|
|
hflag = 0;
|
|
|
|
cflag = 1;
|
|
|
|
} else
|
|
|
|
hflag = 1;
|
|
|
|
goto reswitch;
|
2002-06-02 21:54:55 +00:00
|
|
|
case 'j':
|
|
|
|
jflag = 1;
|
|
|
|
goto reswitch;
|
1996-01-15 22:41:03 +00:00
|
|
|
case 'l':
|
1999-08-07 20:13:32 +00:00
|
|
|
if (lflag) {
|
|
|
|
lflag = 0;
|
|
|
|
qflag = 1;
|
|
|
|
} else
|
|
|
|
lflag = 1;
|
1996-01-15 22:41:03 +00:00
|
|
|
goto reswitch;
|
2002-06-02 21:54:55 +00:00
|
|
|
case 'n':
|
|
|
|
if (jflag)
|
|
|
|
*(va_arg(ap, intmax_t *)) = retval;
|
|
|
|
else if (qflag)
|
|
|
|
*(va_arg(ap, quad_t *)) = retval;
|
1999-07-09 17:54:39 +00:00
|
|
|
else if (lflag)
|
2002-06-02 21:54:55 +00:00
|
|
|
*(va_arg(ap, long *)) = retval;
|
2002-10-25 19:41:32 +00:00
|
|
|
else if (zflag)
|
|
|
|
*(va_arg(ap, size_t *)) = retval;
|
2004-02-19 05:29:39 +00:00
|
|
|
else if (hflag)
|
|
|
|
*(va_arg(ap, short *)) = retval;
|
|
|
|
else if (cflag)
|
|
|
|
*(va_arg(ap, char *)) = retval;
|
1999-07-09 17:54:39 +00:00
|
|
|
else
|
2002-06-02 21:54:55 +00:00
|
|
|
*(va_arg(ap, int *)) = retval;
|
|
|
|
break;
|
|
|
|
case 'o':
|
1994-05-24 10:09:53 +00:00
|
|
|
base = 8;
|
2002-06-02 21:54:55 +00:00
|
|
|
goto handle_nosign;
|
1995-06-14 07:55:07 +00:00
|
|
|
case 'p':
|
|
|
|
base = 16;
|
1998-08-10 14:27:34 +00:00
|
|
|
sharpflag = (width == 0);
|
2002-06-02 21:54:55 +00:00
|
|
|
sign = 0;
|
|
|
|
num = (uintptr_t)va_arg(ap, void *);
|
|
|
|
goto number;
|
1999-07-09 17:54:39 +00:00
|
|
|
case 'q':
|
|
|
|
qflag = 1;
|
|
|
|
goto reswitch;
|
1998-07-08 10:41:32 +00:00
|
|
|
case 'r':
|
|
|
|
base = radix;
|
2002-06-02 21:54:55 +00:00
|
|
|
if (sign)
|
|
|
|
goto handle_sign;
|
|
|
|
goto handle_nosign;
|
1996-01-15 22:41:03 +00:00
|
|
|
case 's':
|
|
|
|
p = va_arg(ap, char *);
|
|
|
|
if (p == NULL)
|
|
|
|
p = "(null)";
|
1996-01-16 18:08:57 +00:00
|
|
|
if (!dot)
|
|
|
|
n = strlen (p);
|
|
|
|
else
|
1996-01-18 10:23:02 +00:00
|
|
|
for (n = 0; n < dwidth && p[n]; n++)
|
1996-01-16 18:08:57 +00:00
|
|
|
continue;
|
1996-01-18 10:23:02 +00:00
|
|
|
|
1996-01-16 18:08:57 +00:00
|
|
|
width -= n;
|
1996-01-18 10:23:02 +00:00
|
|
|
|
1996-01-15 22:41:03 +00:00
|
|
|
if (!ladjust && width > 0)
|
|
|
|
while (width--)
|
|
|
|
PCHAR(padc);
|
1996-01-16 18:08:57 +00:00
|
|
|
while (n--)
|
1996-01-15 22:41:03 +00:00
|
|
|
PCHAR(*p++);
|
|
|
|
if (ladjust && width > 0)
|
|
|
|
while (width--)
|
|
|
|
PCHAR(padc);
|
|
|
|
break;
|
2002-11-13 15:15:59 +00:00
|
|
|
case 't':
|
|
|
|
tflag = 1;
|
|
|
|
goto reswitch;
|
1994-05-24 10:09:53 +00:00
|
|
|
case 'u':
|
|
|
|
base = 10;
|
2002-06-02 21:54:55 +00:00
|
|
|
goto handle_nosign;
|
2000-10-02 07:13:10 +00:00
|
|
|
case 'X':
|
2006-03-09 22:37:34 +00:00
|
|
|
upper = 1;
|
|
|
|
case 'x':
|
1994-05-24 10:09:53 +00:00
|
|
|
base = 16;
|
2002-06-02 21:54:55 +00:00
|
|
|
goto handle_nosign;
|
2002-10-25 19:41:32 +00:00
|
|
|
case 'y':
|
2002-06-02 21:54:55 +00:00
|
|
|
base = 16;
|
2002-10-11 17:54:55 +00:00
|
|
|
sign = 1;
|
|
|
|
goto handle_sign;
|
2002-10-25 19:41:32 +00:00
|
|
|
case 'z':
|
|
|
|
zflag = 1;
|
|
|
|
goto reswitch;
|
2002-06-02 21:54:55 +00:00
|
|
|
handle_nosign:
|
|
|
|
sign = 0;
|
|
|
|
if (jflag)
|
|
|
|
num = va_arg(ap, uintmax_t);
|
|
|
|
else if (qflag)
|
|
|
|
num = va_arg(ap, u_quad_t);
|
2002-11-13 15:15:59 +00:00
|
|
|
else if (tflag)
|
|
|
|
num = va_arg(ap, ptrdiff_t);
|
1999-07-09 17:54:39 +00:00
|
|
|
else if (lflag)
|
2002-06-02 21:54:55 +00:00
|
|
|
num = va_arg(ap, u_long);
|
2002-10-25 19:41:32 +00:00
|
|
|
else if (zflag)
|
|
|
|
num = va_arg(ap, size_t);
|
2004-02-19 05:29:39 +00:00
|
|
|
else if (hflag)
|
|
|
|
num = (u_short)va_arg(ap, int);
|
|
|
|
else if (cflag)
|
|
|
|
num = (u_char)va_arg(ap, int);
|
1999-07-09 17:54:39 +00:00
|
|
|
else
|
2002-06-02 21:54:55 +00:00
|
|
|
num = va_arg(ap, u_int);
|
1998-07-08 10:41:32 +00:00
|
|
|
goto number;
|
2002-06-02 21:54:55 +00:00
|
|
|
handle_sign:
|
|
|
|
if (jflag)
|
|
|
|
num = va_arg(ap, intmax_t);
|
|
|
|
else if (qflag)
|
|
|
|
num = va_arg(ap, quad_t);
|
2002-11-13 15:15:59 +00:00
|
|
|
else if (tflag)
|
|
|
|
num = va_arg(ap, ptrdiff_t);
|
2002-06-02 21:54:55 +00:00
|
|
|
else if (lflag)
|
|
|
|
num = va_arg(ap, long);
|
2002-10-25 19:41:32 +00:00
|
|
|
else if (zflag)
|
2008-11-17 23:57:40 +00:00
|
|
|
num = va_arg(ap, ssize_t);
|
2004-02-19 05:29:39 +00:00
|
|
|
else if (hflag)
|
|
|
|
num = (short)va_arg(ap, int);
|
|
|
|
else if (cflag)
|
|
|
|
num = (char)va_arg(ap, int);
|
2002-06-02 21:54:55 +00:00
|
|
|
else
|
|
|
|
num = va_arg(ap, int);
|
|
|
|
number:
|
|
|
|
if (sign && (intmax_t)num < 0) {
|
|
|
|
neg = 1;
|
|
|
|
num = -(intmax_t)num;
|
1996-01-15 22:41:03 +00:00
|
|
|
}
|
2010-07-08 22:13:23 +00:00
|
|
|
p = ksprintn(nbuf, num, base, &n, upper);
|
|
|
|
tmp = 0;
|
2002-06-02 21:54:55 +00:00
|
|
|
if (sharpflag && num != 0) {
|
1996-01-15 22:41:03 +00:00
|
|
|
if (base == 8)
|
|
|
|
tmp++;
|
|
|
|
else if (base == 16)
|
|
|
|
tmp += 2;
|
|
|
|
}
|
|
|
|
if (neg)
|
|
|
|
tmp++;
|
|
|
|
|
2010-07-08 22:13:23 +00:00
|
|
|
if (!ladjust && padc == '0')
|
|
|
|
dwidth = width - tmp;
|
2010-07-12 15:32:45 +00:00
|
|
|
width -= tmp + imax(dwidth, n);
|
2010-07-08 22:13:23 +00:00
|
|
|
dwidth -= n;
|
|
|
|
if (!ladjust)
|
|
|
|
while (width-- > 0)
|
|
|
|
PCHAR(' ');
|
1996-01-15 22:41:03 +00:00
|
|
|
if (neg)
|
|
|
|
PCHAR('-');
|
2002-06-02 21:54:55 +00:00
|
|
|
if (sharpflag && num != 0) {
|
1996-01-15 22:41:03 +00:00
|
|
|
if (base == 8) {
|
|
|
|
PCHAR('0');
|
|
|
|
} else if (base == 16) {
|
|
|
|
PCHAR('0');
|
|
|
|
PCHAR('x');
|
|
|
|
}
|
|
|
|
}
|
2010-07-08 22:13:23 +00:00
|
|
|
while (dwidth-- > 0)
|
|
|
|
PCHAR('0');
|
1996-01-15 22:41:03 +00:00
|
|
|
|
1994-10-02 17:35:40 +00:00
|
|
|
while (*p)
|
1996-01-15 22:41:03 +00:00
|
|
|
PCHAR(*p--);
|
|
|
|
|
2010-07-08 22:13:23 +00:00
|
|
|
if (ladjust)
|
|
|
|
while (width-- > 0)
|
|
|
|
PCHAR(' ');
|
1996-01-15 22:41:03 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
default:
|
2002-06-02 21:54:55 +00:00
|
|
|
while (percent < fmt)
|
|
|
|
PCHAR(*percent++);
|
2005-09-03 10:28:08 +00:00
|
|
|
/*
|
2015-01-23 07:30:57 +00:00
|
|
|
* Since we ignore a formatting argument it is no
|
2005-09-03 10:28:08 +00:00
|
|
|
* longer safe to obey the remaining formatting
|
|
|
|
* arguments as the arguments will no longer match
|
|
|
|
* the format specs.
|
|
|
|
*/
|
|
|
|
stop = 1;
|
1996-01-15 22:41:03 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
1996-01-15 22:41:03 +00:00
|
|
|
#undef PCHAR
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-12-20 21:50:37 +00:00
|
|
|
* Put character in log buffer with a particular priority.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
static void
|
2000-12-20 21:50:37 +00:00
|
|
|
msglogchar(int c, int pri)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2000-12-20 21:50:37 +00:00
|
|
|
static int lastpri = -1;
|
|
|
|
static int dangling;
|
|
|
|
char nbuf[MAXNBUF];
|
|
|
|
char *p;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-12-20 21:50:37 +00:00
|
|
|
if (!msgbufmapped)
|
|
|
|
return;
|
|
|
|
if (c == '\0' || c == '\r')
|
|
|
|
return;
|
|
|
|
if (pri != -1 && pri != lastpri) {
|
|
|
|
if (dangling) {
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbuf_addchar(msgbufp, '\n');
|
2000-12-20 21:50:37 +00:00
|
|
|
dangling = 0;
|
1995-02-19 15:02:26 +00:00
|
|
|
}
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbuf_addchar(msgbufp, '<');
|
2006-03-09 22:37:34 +00:00
|
|
|
for (p = ksprintn(nbuf, (uintmax_t)pri, 10, NULL, 0); *p;)
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbuf_addchar(msgbufp, *p--);
|
|
|
|
msgbuf_addchar(msgbufp, '>');
|
2000-12-20 21:50:37 +00:00
|
|
|
lastpri = pri;
|
|
|
|
}
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbuf_addchar(msgbufp, c);
|
2000-12-20 21:50:37 +00:00
|
|
|
if (c == '\n') {
|
|
|
|
dangling = 0;
|
|
|
|
lastpri = -1;
|
|
|
|
} else {
|
|
|
|
dangling = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Fix apparent garbage in the message buffer.
While we have had a fix in place (options PRINTF_BUFR_SIZE=128) to fix
scrambled console output, the message buffer and syslog were still getting
log messages one character at a time. While all of the characters still
made it into the log (courtesy of atomic operations), they were often
interleaved when there were multiple threads writing to the buffer at the
same time.
This fixes message buffer accesses to use buffering logic as well, so that
strings that are less than PRINTF_BUFR_SIZE will be put into the message
buffer atomically. So now dmesg output should look the same as console
output.
subr_msgbuf.c: Convert most message buffer calls to use a new spin
lock instead of atomic variables in some places.
Add a new routine, msgbuf_addstr(), that adds a
NUL-terminated string to a message buffer. This
takes a priority argument, which allows us to
eliminate some races (at least in the the string
at a time case) that are present in the
implementation of msglogchar(). (dangling and
lastpri are static variables, and are subject to
races when multiple callers are present.)
msgbuf_addstr() also allows the caller to request
that carriage returns be stripped out of the
string. This matches the behavior of msglogchar(),
but in testing so far it doesn't appear that any
newlines are being stripped out. So the carriage
return removal functionality may be a candidate
for removal later on if further analysis shows
that it isn't necessary.
subr_prf.c: Add a new msglogstr() routine that calls
msgbuf_logstr().
Rename putcons() to putbuf(). This now handles
buffered output to the message log as well as
the console. Also, remove the logic in putcons()
(now putbuf()) that added a carriage return before
a newline. The console path was the only path that
needed it, and cnputc() (called by cnputs())
already adds a carriage return. So this
duplication resulted in kernel-generated console
output lines ending in '\r''\r''\n'.
Refactor putchar() to handle the new buffering
scheme.
Add buffering to log().
Change log_console() to use msglogstr() instead of
msglogchar(). Don't add extra newlines by default
in log_console(). Hide that behavior behind a
tunable/sysctl (kern.log_console_add_linefeed) for
those who would like the old behavior. The old
behavior led to the insertion of extra newlines
for log output for programs that print out a
string, and then a trailing newline on a separate
write. (This is visible with dmesg -a.)
msgbuf.h: Add a prototype for msgbuf_addstr().
Add three new fields to struct msgbuf, msg_needsnl,
msg_lastpri and msg_lock. The first two are needed
for log message functionality previously handled
by msglogchar(). (Which is still active if
buffering isn't enabled.)
Include sys/lock.h and sys/mutex.h for the new
mutex.
Reviewed by: gibbs
2011-05-31 17:29:58 +00:00
|
|
|
static void
|
|
|
|
msglogstr(char *str, int pri, int filter_cr)
|
|
|
|
{
|
|
|
|
if (!msgbufmapped)
|
|
|
|
return;
|
|
|
|
|
|
|
|
msgbuf_addstr(msgbufp, pri, str, filter_cr);
|
|
|
|
}
|
|
|
|
|
1998-05-28 09:30:28 +00:00
|
|
|
void
|
2002-11-14 16:11:12 +00:00
|
|
|
msgbufinit(void *ptr, int size)
|
1998-05-28 09:30:28 +00:00
|
|
|
{
|
|
|
|
char *cp;
|
1999-06-01 18:20:36 +00:00
|
|
|
static struct msgbuf *oldp = NULL;
|
1998-05-28 09:30:28 +00:00
|
|
|
|
2001-11-09 23:58:07 +00:00
|
|
|
size -= sizeof(*msgbufp);
|
1998-05-28 09:30:28 +00:00
|
|
|
cp = (char *)ptr;
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbufp = (struct msgbuf *)(cp + size);
|
|
|
|
msgbuf_reinit(msgbufp, cp, size);
|
1999-06-01 18:20:36 +00:00
|
|
|
if (msgbufmapped && oldp != msgbufp)
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbuf_copy(oldp, msgbufp);
|
1998-05-28 09:30:28 +00:00
|
|
|
msgbufmapped = 1;
|
1999-06-01 18:20:36 +00:00
|
|
|
oldp = msgbufp;
|
1998-05-28 09:30:28 +00:00
|
|
|
}
|
|
|
|
|
2001-11-30 21:40:52 +00:00
|
|
|
static int unprivileged_read_msgbuf = 1;
|
2002-01-16 06:55:30 +00:00
|
|
|
SYSCTL_INT(_security_bsd, OID_AUTO, unprivileged_read_msgbuf,
|
2001-11-30 21:40:52 +00:00
|
|
|
CTLFLAG_RW, &unprivileged_read_msgbuf, 0,
|
|
|
|
"Unprivileged processes may read the kernel message buffer");
|
|
|
|
|
2001-07-03 19:44:07 +00:00
|
|
|
/* Sysctls for accessing/clearing the msgbuf */
|
|
|
|
static int
|
|
|
|
sysctl_kern_msgbuf(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
2003-06-22 02:18:31 +00:00
|
|
|
char buf[128];
|
|
|
|
u_int seq;
|
|
|
|
int error, len;
|
2001-07-03 19:44:07 +00:00
|
|
|
|
2001-11-30 21:40:52 +00:00
|
|
|
if (!unprivileged_read_msgbuf) {
|
2006-11-06 13:42:10 +00:00
|
|
|
error = priv_check(req->td, PRIV_MSGBUF);
|
2001-11-30 21:40:52 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2003-06-22 02:18:31 +00:00
|
|
|
/* Read the whole buffer, one chunk at a time. */
|
2009-11-03 21:06:19 +00:00
|
|
|
mtx_lock(&msgbuf_lock);
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbuf_peekbytes(msgbufp, NULL, 0, &seq);
|
2009-11-03 21:06:19 +00:00
|
|
|
for (;;) {
|
|
|
|
len = msgbuf_peekbytes(msgbufp, buf, sizeof(buf), &seq);
|
|
|
|
mtx_unlock(&msgbuf_lock);
|
|
|
|
if (len == 0)
|
2015-03-15 00:39:18 +00:00
|
|
|
return (SYSCTL_OUT(req, "", 1)); /* add nulterm */
|
2009-11-03 21:06:19 +00:00
|
|
|
|
2003-06-22 02:18:31 +00:00
|
|
|
error = sysctl_handle_opaque(oidp, buf, len, req);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
2009-11-03 21:06:19 +00:00
|
|
|
|
|
|
|
mtx_lock(&msgbuf_lock);
|
2001-07-03 19:44:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-03 21:06:19 +00:00
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, msgbuf,
|
|
|
|
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
|
2009-02-03 07:51:11 +00:00
|
|
|
NULL, 0, sysctl_kern_msgbuf, "A", "Contents of kernel message buffer");
|
2001-07-03 19:44:07 +00:00
|
|
|
|
2003-06-22 02:18:31 +00:00
|
|
|
static int msgbuf_clearflag;
|
2001-07-03 19:44:07 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
sysctl_kern_msgbuf_clear(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
error = sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, req);
|
|
|
|
if (!error && req->newptr) {
|
2009-11-03 21:06:19 +00:00
|
|
|
mtx_lock(&msgbuf_lock);
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbuf_clear(msgbufp);
|
2009-11-03 21:06:19 +00:00
|
|
|
mtx_unlock(&msgbuf_lock);
|
2003-06-22 02:18:31 +00:00
|
|
|
msgbuf_clearflag = 0;
|
2001-07-03 19:44:07 +00:00
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, msgbuf_clear,
|
2009-11-03 21:06:19 +00:00
|
|
|
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_SECURE | CTLFLAG_MPSAFE,
|
|
|
|
&msgbuf_clearflag, 0, sysctl_kern_msgbuf_clear, "I",
|
|
|
|
"Clear kernel message buffer");
|
2001-07-03 19:44:07 +00:00
|
|
|
|
1998-05-28 09:30:28 +00:00
|
|
|
#ifdef DDB
|
|
|
|
|
|
|
|
DB_SHOW_COMMAND(msgbuf, db_show_msgbuf)
|
|
|
|
{
|
2006-07-12 21:22:44 +00:00
|
|
|
int i, j;
|
1998-05-28 09:30:28 +00:00
|
|
|
|
|
|
|
if (!msgbufmapped) {
|
|
|
|
db_printf("msgbuf not mapped yet\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
db_printf("msgbufp = %p\n", msgbufp);
|
2003-06-22 02:18:31 +00:00
|
|
|
db_printf("magic = %x, size = %d, r= %u, w = %u, ptr = %p, cksum= %u\n",
|
|
|
|
msgbufp->msg_magic, msgbufp->msg_size, msgbufp->msg_rseq,
|
|
|
|
msgbufp->msg_wseq, msgbufp->msg_ptr, msgbufp->msg_cksum);
|
2006-07-12 21:22:44 +00:00
|
|
|
for (i = 0; i < msgbufp->msg_size && !db_pager_quit; i++) {
|
2003-06-22 02:18:31 +00:00
|
|
|
j = MSGBUF_SEQ_TO_POS(msgbufp, i + msgbufp->msg_rseq);
|
1998-05-28 09:30:28 +00:00
|
|
|
db_printf("%c", msgbufp->msg_ptr[j]);
|
|
|
|
}
|
|
|
|
db_printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* DDB */
|
2003-12-07 05:04:49 +00:00
|
|
|
|
|
|
|
void
|
2005-04-06 10:14:13 +00:00
|
|
|
hexdump(const void *ptr, int length, const char *hdr, int flags)
|
2003-12-07 05:04:49 +00:00
|
|
|
{
|
|
|
|
int i, j, k;
|
|
|
|
int cols;
|
2005-04-06 10:14:13 +00:00
|
|
|
const unsigned char *cp;
|
2003-12-07 05:04:49 +00:00
|
|
|
char delim;
|
|
|
|
|
|
|
|
if ((flags & HD_DELIM_MASK) != 0)
|
|
|
|
delim = (flags & HD_DELIM_MASK) >> 8;
|
|
|
|
else
|
|
|
|
delim = ' ';
|
|
|
|
|
|
|
|
if ((flags & HD_COLUMN_MASK) != 0)
|
|
|
|
cols = flags & HD_COLUMN_MASK;
|
|
|
|
else
|
|
|
|
cols = 16;
|
|
|
|
|
|
|
|
cp = ptr;
|
|
|
|
for (i = 0; i < length; i+= cols) {
|
|
|
|
if (hdr != NULL)
|
|
|
|
printf("%s", hdr);
|
|
|
|
|
|
|
|
if ((flags & HD_OMIT_COUNT) == 0)
|
|
|
|
printf("%04x ", i);
|
|
|
|
|
|
|
|
if ((flags & HD_OMIT_HEX) == 0) {
|
|
|
|
for (j = 0; j < cols; j++) {
|
|
|
|
k = i + j;
|
|
|
|
if (k < length)
|
|
|
|
printf("%c%02x", delim, cp[k]);
|
|
|
|
else
|
|
|
|
printf(" ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((flags & HD_OMIT_CHARS) == 0) {
|
|
|
|
printf(" |");
|
|
|
|
for (j = 0; j < cols; j++) {
|
|
|
|
k = i + j;
|
|
|
|
if (k >= length)
|
|
|
|
printf(" ");
|
|
|
|
else if (cp[k] >= ' ' && cp[k] <= '~')
|
|
|
|
printf("%c", cp[k]);
|
|
|
|
else
|
|
|
|
printf(".");
|
|
|
|
}
|
2006-02-25 16:20:22 +00:00
|
|
|
printf("|");
|
2003-12-07 05:04:49 +00:00
|
|
|
}
|
2006-02-25 16:20:22 +00:00
|
|
|
printf("\n");
|
2003-12-07 05:04:49 +00:00
|
|
|
}
|
|
|
|
}
|
Add support for reading MAM attributes to camcontrol(8) and libcam(3).
MAM is Medium Auxiliary Memory and is most commonly found as flash
chips on tapes.
This includes support for reading attributes and decoding most
known attributes, but does not yet include support for writing
attributes or reporting attributes in XML format.
libsbuf/Makefile:
Add subr_prf.c for the new sbuf_hexdump() function. This
function is essentially the same function.
libsbuf/Symbol.map:
Add a new shared library minor version, and include the
sbuf_hexdump() function.
libsbuf/Version.def:
Add version 1.4 of the libsbuf library.
libutil/hexdump.3:
Document sbuf_hexdump() alongside hexdump(3), since it is
essentially the same function.
camcontrol/Makefile:
Add attrib.c.
camcontrol/attrib.c:
Implementation of READ ATTRIBUTE support for camcontrol(8).
camcontrol/camcontrol.8:
Document the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.c:
Add the new 'camcontrol attrib' subcommand.
camcontrol/camcontrol.h:
Add a function prototype for scsiattrib().
share/man/man9/sbuf.9:
Document the existence of sbuf_hexdump() and point users to
the hexdump(3) man page for more details.
sys/cam/scsi/scsi_all.c:
Add a table of known attributes, text descriptions and
handler functions.
Add a new scsi_attrib_sbuf() function along with a number
of other related functions that help decode attributes.
scsi_attrib_ascii_sbuf() decodes ASCII format attributes.
scsi_attrib_int_sbuf() decodes binary format attributes, and
will pass them off to scsi_attrib_hexdump_sbuf() if they're
bigger than 8 bytes.
scsi_attrib_vendser_sbuf() decodes the vendor and drive
serial number attribute.
scsi_attrib_volcoh_sbuf() decodes the Volume Coherency
Information attribute that LTFS writes out.
sys/cam/scsi/scsi_all.h:
Add a number of attribute-related structure definitions and
other defines.
Add function prototypes for all of the functions added in
scsi_all.c.
sys/kern/subr_prf.c:
Add a new function, sbuf_hexdump(). This is the same as
the existing hexdump(9) function, except that it puts the
result in an sbuf.
This also changes subr_prf.c so that it can be compiled in
userland for includsion in libsbuf.
We should work to change this so that the kernel hexdump
implementation is a wrapper around sbuf_hexdump() with a
statically allocated sbuf with a drain. That will require
a drain function that goes to the kernel printf() buffer
that can take a non-NUL terminated string as input.
That is because an sbuf isn't NUL-terminated until it is
finished, and we don't want to finish it while we're still
using it.
We should also work to consolidate the userland hexdump and
kernel hexdump implemenatations, which are currently
separate. This would also mean making applications that
currently link in libutil link in libsbuf.
sys/sys/sbuf.h:
Add the prototype for sbuf_hexdump(), and add another copy
of the hexdump flag values if they aren't already defined.
Ideally the flags should be defined in one place but the
implemenation makes it difficult to do properly. (See
above.)
Sponsored by: Spectra Logic Corporation
MFC after: 1 week
2015-06-09 21:39:38 +00:00
|
|
|
#endif /* _KERNEL */
|
|
|
|
|
|
|
|
void
|
|
|
|
sbuf_hexdump(struct sbuf *sb, const void *ptr, int length, const char *hdr,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
int i, j, k;
|
|
|
|
int cols;
|
|
|
|
const unsigned char *cp;
|
|
|
|
char delim;
|
|
|
|
|
|
|
|
if ((flags & HD_DELIM_MASK) != 0)
|
|
|
|
delim = (flags & HD_DELIM_MASK) >> 8;
|
|
|
|
else
|
|
|
|
delim = ' ';
|
|
|
|
|
|
|
|
if ((flags & HD_COLUMN_MASK) != 0)
|
|
|
|
cols = flags & HD_COLUMN_MASK;
|
|
|
|
else
|
|
|
|
cols = 16;
|
|
|
|
|
|
|
|
cp = ptr;
|
|
|
|
for (i = 0; i < length; i+= cols) {
|
|
|
|
if (hdr != NULL)
|
|
|
|
sbuf_printf(sb, "%s", hdr);
|
|
|
|
|
|
|
|
if ((flags & HD_OMIT_COUNT) == 0)
|
|
|
|
sbuf_printf(sb, "%04x ", i);
|
|
|
|
|
|
|
|
if ((flags & HD_OMIT_HEX) == 0) {
|
|
|
|
for (j = 0; j < cols; j++) {
|
|
|
|
k = i + j;
|
|
|
|
if (k < length)
|
|
|
|
sbuf_printf(sb, "%c%02x", delim, cp[k]);
|
|
|
|
else
|
|
|
|
sbuf_printf(sb, " ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((flags & HD_OMIT_CHARS) == 0) {
|
|
|
|
sbuf_printf(sb, " |");
|
|
|
|
for (j = 0; j < cols; j++) {
|
|
|
|
k = i + j;
|
|
|
|
if (k >= length)
|
|
|
|
sbuf_printf(sb, " ");
|
|
|
|
else if (cp[k] >= ' ' && cp[k] <= '~')
|
|
|
|
sbuf_printf(sb, "%c", cp[k]);
|
|
|
|
else
|
|
|
|
sbuf_printf(sb, ".");
|
|
|
|
}
|
|
|
|
sbuf_printf(sb, "|");
|
|
|
|
}
|
|
|
|
sbuf_printf(sb, "\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|