The sbuf family of functions allows one to safely allocate, compose and release strings in kernel or user
space.
Instead of arrays of characters, these functions operate on structures called sbufs, defined in
<sys/sbuf.h>.
Any errors encountered during the allocation or composition of the string will be latched in the data
structure, making a single error test at the end of the composition sufficient to determine success or
failure of the entire process.
The sbuf_new() function initializes the sbuf pointed to by its first argument. If that pointer is NULL,
sbuf_new() allocates a structsbuf using malloc(9). The buf argument is a pointer to a buffer in which
to store the actual string; if it is NULL, sbuf_new() will allocate one using malloc(9). The length is
the initial size of the storage buffer. The fourth argument, flags, may be comprised of the following
flags:
SBUF_FIXEDLEN The storage buffer is fixed at its initial size. Attempting to extend the sbuf beyond
this size results in an overflow condition.
SBUF_AUTOEXTEND This indicates that the storage buffer may be extended as necessary, so long as
resources allow, to hold additional data.
SBUF_INCLUDENUL This causes the final nulterm byte to be counted in the length of the data.
SBUF_DRAINTOEOR Treat top-level sections started with sbuf_start_section() as a record boundary marker
that will be used during drain operations to avoid records being split. If a record
grows sufficiently large such that it fills the sbuf and therefore cannot be drained
without being split, an error of EDEADLK is set.
Note that if buf is not NULL, it must point to an array of at least length characters. The result of
accessing that array directly while it is in use by the sbuf is undefined.
The sbuf_new_auto() function is a shortcut for creating a completely dynamic sbuf. It is the equivalent
of calling sbuf_new() with values NULL, NULL, 0, and SBUF_AUTOEXTEND.
The sbuf_new_for_sysctl() function will set up an sbuf with a drain function to use SYSCTL_OUT() when the
internal buffer fills. Note that if the various functions which append to an sbuf are used while a non-
sleepable lock is held, the user buffer should be wired using sysctl_wire_old_buffer().
The sbuf_delete() function clears the sbuf and frees any memory allocated for it. There must be a call
to sbuf_delete() for every call to sbuf_new(). Any attempt to access the sbuf after it has been deleted
will fail.
The sbuf_clear() function invalidates the contents of the sbuf and resets its position to zero.
The sbuf_get_flags() function returns the current user flags. The sbuf_set_flags() and sbuf_get_flags()
functions set or clear one or more user flags, respectively. The user flags are described under the
sbuf_new() function.
The sbuf_setpos() function sets the sbuf's end position to pos, which is a value between zero and the
current position in the buffer. It can only truncate the sbuf to the new position.
The sbuf_bcat() function appends the first len bytes from the buffer buf to the sbuf.
The sbuf_bcopyin() function copies len bytes from the specified userland address into the sbuf.
The sbuf_bcpy() function replaces the contents of the sbuf with the first len bytes from the buffer buf.
The sbuf_cat() function appends the NUL-terminated string str to the sbuf at the current position.
The sbuf_set_drain() function sets a drain function func for the sbuf, and records a pointer arg to be
passed to the drain on callback. The drain function cannot be changed while sbuf_len is non-zero.
The registered drain function sbuf_drain_func will be called with the argument arg provided to
sbuf_set_drain(), a pointer data to a byte string that is the contents of the sbuf, and the length len of
the data. If the drain function exists, it will be called when the sbuf internal buffer is full, or on
behalf of sbuf_finish(). The drain function may drain some or all of the data, but must drain at least 1
byte. The return value from the drain function, if positive, indicates how many bytes were drained. If
negative, the return value indicates the negative error code which will be returned from this or a later
call to sbuf_finish(). The returned drained length cannot be zero. To do unbuffered draining,
initialize the sbuf with a two-byte buffer. The drain will be called for every byte added to the sbuf.
The sbuf_bcopyin(), sbuf_copyin(), sbuf_trim(), and sbuf_data() functions cannot be used on an sbuf with
a drain.
The sbuf_copyin() function copies a NUL-terminated string from the specified userland address into the
sbuf. If the len argument is non-zero, no more than len characters (not counting the terminating NUL)
are copied; otherwise the entire string, or as much of it as can fit in the sbuf, is copied.
The sbuf_cpy() function replaces the contents of the sbuf with those of the NUL-terminated string str.
This is equivalent to calling sbuf_cat() with a fresh sbuf or one which position has been reset to zero
with sbuf_clear() or sbuf_setpos().
The sbuf_printf() function formats its arguments according to the format string pointed to by fmt and
appends the resulting string to the sbuf at the current position.
The sbuf_vprintf() function behaves the same as sbuf_printf() except that the arguments are obtained from
the variable-length argument list ap.
The sbuf_putc() function appends the character c to the sbuf at the current position.
The sbuf_trim() function removes trailing whitespace from the sbuf.
The sbuf_error() function returns any error value that the sbuf may have accumulated, either from the
drain function, or ENOMEM if the sbuf overflowed. This function is generally not needed and instead the
error code from sbuf_finish() is the preferred way to discover whether an sbuf had an error.
The sbuf_finish() function will call the attached drain function if one exists until all the data in the
sbuf is flushed. If there is no attached drain, sbuf_finish() NUL-terminates the sbuf. In either case
it marks the sbuf as finished, which means that it may no longer be modified using sbuf_setpos(),
sbuf_cat(), sbuf_cpy(), sbuf_printf() or sbuf_putc(), until sbuf_clear() is used to reset the sbuf.
The sbuf_data() function returns the actual string; sbuf_data() only works on a finished sbuf. The
sbuf_len() function returns the length of the string. For an sbuf with an attached drain, sbuf_len()
returns the length of the un-drained data. sbuf_done() returns non-zero if the sbuf is finished.
The sbuf_start_section() and sbuf_end_section() functions may be used for automatic section alignment.
The arguments pad and c specify the padding size and a character used for padding. The arguments
old_lenp and old_len are to save and restore the current section length when nested sections are used.
For the top level section NULL and -1 can be specified for old_lenp and old_len respectively.
The sbuf_hexdump() function prints an array of bytes to the supplied sbuf, along with an ASCII
representation of the bytes if possible. See the hexdump(3) man page for more details on the interface.
The sbuf_putbuf() function printfs the sbuf to stdout if in userland, and to the console and log if in
the kernel. It does not drain the buffer or update any pointers.
Install Now
PNG Icons
