libmemstat(3)

NAME

libmemstat - library interface to retrieve kernel memory al
locator statistics

LIBRARY

library ``libmemstat''

SYNOPSIS

#include <sys/types.h>
#include <memstat.h>
General Functions
const char *
memstat_strerror(int error);
Memory Type List Management Functions
struct memory_type_list *
memstat_mtl_alloc(void);
struct memory_type *
memstat_mtl_first(struct memory_type_list *list);
struct memory_type *
memstat_mtl_next(struct memory_type *mtp);
struct memory_type *
memstat_mtl_find(struct    memory_type_list    *list,    int
allocator,
        const char *name);
void
memstat_mtl_free(struct memory_type_list *list);
int
memstat_mtl_geterror(struct memory_type_list *list);
Allocator Query Functions
int
memstat_kvm_all(struct    memory_type_list    *list,    void
*kvm_handle);
int
memstat_kvm_malloc(struct   memory_type_list   *list,   void
*kvm_handle);
int
memstat_kvm_uma(struct    memory_type_list    *list,    void
*kvm_handle);
int
memstat_sysctl_all(struct    memory_type_list   *list,   int
flags);
int
memstat_sysctl_malloc(struct  memory_type_list  *list,   int
flags);
int
memstat_sysctl_uma(struct    memory_type_list   *list,   int
flags);
Memory Type Accessor Methods
const char *
memstat_get_name(const struct memory_type *mtp);
int
memstat_get_allocator(const struct memory_type *mtp);
uint64_t
memstat_get_countlimit(const struct memory_type *mtp);
uint64_t
memstat_get_byteslimit(const struct memory_type *mtp);
uint64_t
memstat_get_sizemask(const struct memory_type *mtp);
uint64_t
memstat_get_size(const struct memory_type *mtp);
uint64_t
memstat_get_memalloced(const struct memory_type *mtp);
uint64_t
memstat_get_memfreed(const struct memory_type *mtp);
uint64_t
memstat_get_numallocs(const struct memory_type *mtp);
uint64_t
memstat_get_numfrees(const struct memory_type *mtp);
uint64_t
memstat_get_bytes(const struct memory_type *mtp);
uint64_t
memstat_get_count(const struct memory_type *mtp);
uint64_t
memstat_get_free(const struct memory_type *mtp);
uint64_t
memstat_get_failures(const struct memory_type *mtp);
void *
memstat_get_caller_pointer(const  struct  memory_type  *mtp,
int index);
void
memstat_set_caller_pointer(struct   memory_type   *mtp,  int
index,
        void *value);
uint64_t
memstat_get_caller_uint64(const struct memory_type *mtp, int
index);
void
memstat_set_caller_uint64(struct   memory_type   *mtp,   int
index,
        uint64_t value);
uint64_t
memstat_get_zonefree(const struct memory_type *mtp);
uint64_t
memstat_get_kegfree(const struct memory_type *mtp);
uint64_t
memstat_get_percpu_memalloced(const struct memory_type *mtp,
int cpu);
uint64_t
memstat_get_percpu_memfreed(const  struct  memory_type *mtp,
int cpu);
uint64_t
memstat_get_percpu_numallocs(const struct memory_type  *mtp,
int cpu);
uint64_t
memstat_get_percpu_numfrees(const  struct  memory_type *mtp,
int cpu);
uint64_t
memstat_get_percpu_sizemask(const struct  memory_type  *mtp,
int cpu);
void *
memstat_get_percpu_caller_pointer(const  struct  memory_type
*mtp, int cpu,
        int index);
void
memstat_set_percpu_caller_pointer(struct  memory_type  *mtp,
int cpu,
        int index, void *value);
uint64_t
memstat_get_percpu_caller_uint64(const   struct  memory_type
*mtp, int cpu,
        int index);
void
memstat_set_percpu_caller_uint64(struct  memory_type   *mtp,
int cpu,
        int index, uint64_t value);
uint64_t
memstat_get_percpu_free(const  struct  memory_type *mtp, int
cpu);

DESCRIPTION

libmemstat provides an interface to retrieve kernel memory
allocator statistics, for the purposes of debugging and system moni
toring, insulating applications from implementation details of the alloca
tors, and allowing a tool to transparently support multiple alloca
tors. libmemstat
supports both retrieving a single statistics snapshot, as
well as incrementally updating statistics for long-term monitoring.
libmemstat describes each memory type using a struct
memory_type, an
opaque memory type accessed by the application using acces
sor functions
in the library. libmemstat returns and updates chains of
struct
memory_type via a struct memory_type_list, which will be al
located by
calling memstat_mtl_alloc(), and freed on completion using memstat_mtl_free(). Lists of memory types are populated via
calls that
query the kernel for statistics information; currently:
memstat_kvm_all(), memstat_kvm_malloc(), memstat_kvm_uma(), memstat_sysctl_all(), memstat_sysctl_uma(), and
memstat_sysctl_malloc().
Repeated calls will incrementally update the list of memory
types, permitting tracking over time without recreating all list
state. If an error is detected during a query call, error condition in
formation may be
retrieved using memstat_mtl_geterror(), and converted to a
user-readable
string using memstat_strerror().
Freeing the list will free all memory type data in the list,
and so invalidates any outstanding pointers to entries in the list.
struct
memory_type entries in the list may be iterated over using memstat_mtl_first() and memstat_mtl_next(), which respec
tively return the first entry in a list, and the next entry in a list.
memstat_mtl_find(),
which will return a pointer to the first entry matching the
passed parameters.
A series of accessor methods is provided to access fields of
the structure, including retrieving statistics and properties, as
well as setting of caller owned fields. Direct application access to the
data structure fields is not supported.
Library memory_type Fields: Each struct memory_type holds a description of the memory; type, including
its name and the allocator it is managed by, as well as cur; rent statistics on use. Some statistics are directly measured, others; are derived
from directly measured statistics. Certain high level; statistics are
present across all available allocators, such as the number; of allocation
and free operations; other measurements, such as the quanti; ty of free
items in per-CPU caches, or administrative limit on the num; ber of allocations, is available only for specific allocators.
Caller memory_type Fields: struct memory_type includes fields to allow the application; to store
data, in the form of pointers and 64-bit integers, with mem; ory types.
For example, the application author might make use of one of; the caller
pointers to reference a more complex data structure tracking; long-term
behavior of the memory type, or a window system object that; is used to
render the state of the memory type. General and per-CPU; storage is provided with each struct memory_type in the form of an array; of pointers
and integers. The array entries are accessed via the index; argument to
the get and set accessor methods. Possible values of index; range between
0 and MEMSTAT_MAXCALLER.; Caller-owned fields are initialized to 0 or NULL when a new; struct
memory_type is allocated and attached to a memory type list;; these fields
retain their values across queries that update library-owned; fields.
Allocator Types: Currently, libmemstat supports two kernel allocators: ALLO; CATOR_UMA for
uma(9), and ALLOCATOR_MALLOC for malloc(9). These values; may be passed
to memstat_mtl_find(), and will be returned by; memstat_get_allocator().
Two additional constants in the allocator name space are de; fined:
ALLOCATOR_UNKNOWN, which will only be returned as a result; of a library
error, and ALLOCATOR_ANY, which can be used to specify that; returning
types matching any allocator is permittible from; memstat_mtl_find().
Access Method List: The following accessor methods are defined, of which some; will be valid
for a given memory type:; memstat_get_name()
Return a pointer to the name of the memory type.

Memory for the
name is owned by libmemstat and will be valid

through a call to
memstat_mtl_free(). Note that names will be unique

with respect
to a single allocator, but that the same name might

be used by
different memory types owned by different memory al

locators.
memstat_get_allocator(): Return an integer identifier for the memory alloca; tor that owns
the memory type.
memstat_get_countlimit(): If the memory type has an administrative limit on; the number of
simultaneous allocations, return it.
memstat_get_byteslimit(): If the memory type has an administrative limit on; the number of
bytes of memory that may be simultaenously allocated; for the memory type, return it.
memstat_get_sizemask(): If the memory type supports variable allocation; sizes, return a
bitmask of sizes allocated for the memory type.
memstat_get_size(): If the memory type supports a fixed allocation size,; return that
size.
memstat_get_memalloced(): Return the total number of bytes allocated for the; memory type
over its lifetime.
memstat_get_memfreed(): Return the total number of bytes freed for the memo; ry type over
its lifetime.
memstat_get_numallocs(): Return the total number of allocations for the memo; ry type over
its lifetime.
memstat_get_numfrees(): Return the total number of frees for the memory type; over its
lifetime.
memstat_get_bytes(): Return the current number of bytes allocated to the; memory type.
memstat_get_count(): Return the current number of allocations for the; memory type.
memstat_get_free(): If the memory allocator supports a cache, return the; number of
items in the cache.
memstat_get_failures(): If the memory allocator and type permit allocation; failures,
return the number of allocation failures measured.
memstat_get_caller_pointer(): Return a caller-owned pointer for the memory type.
memstat_set_caller_pointer(): Set a caller-owned pointer for the memory type.
memstat_get_caller_uint64(): Return a caller-owned integer for the memory type.
memstat_set_caller_uint64(): Set a caller-owned integer for the memory type.
memstat_get_zonefree(): If the memory allocator supports a multi-level allo; cation structure, return the number of cached items in the zone.; These items
will be in a fully constructed state available for; immediate use.
memstat_get_kegfree(): If the memory allocator supports a multi-level allo; cation structure, return the number of cached items in the keg.; These items
may be in a partially constructed state, and may re; quire further
processing before they can be made available for; use.
memstat_get_percpu_memalloced(): If the memory allocator supports per-CPU statistics,; return the
number of bytes of memory allocated for the memory; type on the
CPU over its lifetime.
memstat_get_percpu_memfreed(): If the memory allocator supports per-CPU statistics,; return the
number of bytes of memory freed from the memory type; on the CPU
over its lifetime.
memstat_get_percpu_numallocs(): If the memory allocator supports per-CPU statistics,; return the
number of allocations for the memory type on the CPU; over its
lifetime.
memstat_get_percpu_numfrees(): If the memory allocator supports per-CPU statistics,; return the
number of frees for the memory type on the CPU over; its lifetime.
memstat_get_percpu_sizemask(): If the memory allocator supports variable size memo; ry allocation
and per-CPU statistics, return the size bitmask for; the memory
type on the CPU.
memstat_get_percpu_caller_pointer(): Return a caller-owned per-CPU pointer for the memory; type.
memstat_set_percpu_caller_pointer(): Set a caller-owned per-CPU pointer for the memory; type.
memstat_get_percpu_caller_uint64(): Return a caller-owned per-CPU integer for the memory; type.
memsttat_set_percpu_caller_uint64(): Set a caller-owned per-CPU integer for the memory; type.
memstat_get_percpu_free(): If the memory allocator supports a per-CPU cache,; return the number of free items in the per-CPU cache of the desig; nated CPU.

RETURN VALUES

libmemstat functions fall into three categories: functions
returning a pointer to an object, functions returning an integer return
value, and functions implementing accessor methods returning data from
a struct
memory_type.
Functions returning a pointer to an object will generally
return NULL on
failure. memstat_mtl_alloc() will return an error value via
errno, which will consist of the value ENOMEM. Functions
memstat_mtl_first(),
memstat_mtl_next(), and memstat_mtl_find() will return NULL
when there is no entry or match in the list; however, this is not consid
ered a failure mode and no error value is available.
Functions returning an integer success value will return 0
on success, or -1 on failure. If a failure is returned, the list error ac
cess method,
memstat_mtl_geterror(), may be used to retrieve the error
state. The
string representation of the error may be retrieved using
memstat_strerror(). Possible error values are:
MEMSTAT_ERROR_UNDEFINED Undefined error. Occurs if: memstat_mtl_geterror() is; called on a
list before an error asso; ciated with the
list has occurred.
MEMSTAT_ERROR_NOMEMORY Insufficient memory. Oc
curs if library: calls to malloc(3) fail, or; if a system
call to retrieve kernel; statistics fails
with ENOMEM.
MEMSTAT_ERROR_VERSION Returned if the current
version of: libmemstat is unable to in; terpret the
statistics data returned by; the kernel
due to an explicit version; mismatch, or
to differences in data; structures that
cannot be reconciled.
MEMSTAT_ERROR_PERMISSION Returned if a statistics
source returns: errno values of EACCES or; EPERM.
MEMSTAT_ERROR_TOOMANYCPUS Returned if the compile
time limit on: the number of CPUs in; libmemstat is
lower than the number of; CPUs returned
by a statistics data; source.
MEMSTAT_ERROR_DATAERROR Returned if libmemstat is
unable to: interpret statistics data; returned by
the data source, even; though there does
not appear to be a version; problem.
MEMSTAT_ERROR_KVM Returned if libmemstat ex
periences an: error while using kvm(3); interfaces to
query statistics data. Use
kvm_geterr(3) to retrieve; the error.
MEMSTAT_ERROR_KVM_NOSYMBOL Returned if libmemstat is
unable to read: a required symbol from the; kernel being
operated on.
MEMSTAT_ERROR_KVM_SHORTREAD Returned if libmemstat at
tempts to read: data from a live memory im; age or kernel
core dump and insufficient; data is
returned.
Finally, functions returning data from a struct memory_type
pointer are not permitted to fail, and directly return either a statis
tic or pointer to a string.

EXAMPLES

Create a memory type list, query the uma(9) memory allocator
for available statistics, and print out the number of allocations
performed by the mbuf zone.: struct memory_type_list *mtlp;
struct memory_type *mtp;
uint64_t mbuf_count;; mtlp = memstat_mtl_alloc();
if (mtlp == NULL)
err(-1, "memstat_mtl_alloc");; if (memstat_sysctl_uma(mtlp, 0) < 0)
err(-1, "memstat_sysctl_uma");; mtp = memstat_mtl_find(mtlp, ALLOCATOR_UMA, "mbuf");
if (mtp == NULL)
errx(-1, "memstat_mtl_find: mbuf not found");; mbuf_count = memstat_get_count(mtp);
memstat_mtl_free(mtlp);; printf("mbufs: %llu0, (unsigned long long)mbuf_count);

HISTORY

The libmemstat library appeared in FreeBSD 6.0.

AUTHORS

The kernel memory allocator changes necessary to support a
general purpose monitoring library, along with the library, were writ
ten by Robert Watson <rwatson@FreeBSD.org>.

BUGS

There are memory allocators in the kernel, such as the VM
page allocator
and sf_buf allocator, which are not currently supported by
libmemstat.
Once a memory type is present on a memory type list, it will
not be removed even if the kernel no longer presents information on
the type via its monitoring interfaces. In order to flush removed memory
types, it is necessary to free the entire list and allocate a new one.
BSD June 27, 2005

docs.sk

comprehensive documentation repository

See also

libmemstat(3)

NAME

LIBRARY

SYNOPSIS

DESCRIPTION

RETURN VALUES

EXAMPLES

SEE ALSO

HISTORY

AUTHORS

BUGS