mbuf - Kernel memory management for networking protocols
#include <sys/mbuf.h>
struct mbuf *
m_copym2(struct mbuf *m, int off0, int len, int wait);
struct mbuf *
m_copym(struct mbuf *m, int off0, int len, int wait);
struct mbuf *
m_free(struct mbuf *m);
MFREE(struct mbuf *m, struct mbuf *n);
struct mbuf *
m_get(int how, int type);
MGET(struct mbuf *m, int how, int type);
struct mbuf *
m_getclr(int how, int type);
struct mbuf *
m_gethdr(int how, int type);
MGETHDR(struct mbuf *m, int how, int type);
struct mbuf *
m_prepend(struct mbuf *m, int len, int how);
M_PREPEND(struct mbuf *m, int plen, int how);
struct mbuf *
m_pulldown(struct mbuf *m, int off, int len, int *offp);
struct mbuf *
m_pullup(struct mbuf *n, int len);
struct mbuf *
m_pullup2(struct mbuf *n, int len);
struct mbuf *
m_split(struct mbuf *m0, int len0, int wait);
struct mbuf *
m_inject(struct mbuf *m0, int len0, int siz, int wait);
struct mbuf *
m_getptr(struct mbuf *m, int loc, int *off);
void
m_adj(struct mbuf *mp, int req_len);
void
m_copyback(struct mbuf *m0, int off, int len, caddr_t cp);
void
m_freem(struct mbuf *m);
void
m_reclaim(void);
void
m_copydata(struct mbuf *m, int off, int len, caddr_t cp);
void
m_cat(struct mbuf *m, struct mbuf *n);
struct mbuf *
m_devget(char *buf, int totlen, int off0, struct ifnet *ifp,
void (*func)(const void *, void *, size_t));
void
m_zero(struct mbuf *m);
int
m_apply(struct mbuf *m, int off, int len,
int (*func)(caddr_t, caddr_t, unsigned int), caddr_t
fstate);
MEXTMALLOC(struct mbuf *m, int size, int how);
MCLGET(struct mbuf *m, int how);
MEXTADD(struct mbuf *m, caddr_t buf, int type,
void (*free)(caddr_t, u_int, void *), void *arg);
M_ALIGN(struct mbuf *m, int len);
MH_ALIGN(struct mbuf *m, int len);
M_READONLY(struct mbuf *m);
M_LEADINGSPACE(struct mbuf *m);
M_TRAILINGSPACE(struct mbuf *m);
MCHTYPE(struct mbuf *m, int type);
#define MLEN (MSIZE - sizeof(struct m_hdr))
#define MHLEN (MLEN - sizeof(struct pkthdr))
#define MINCLSIZE (MHLEN + 1)
#define M_MAXCOMPRESS (MHLEN / 2)
#define mtod(m,t) ((t)((m)->m_data))
struct m_hdr {
struct mbuf *mh_next;
struct mbuf *mh_nextpkt;
caddr_t mh_data;
u_int mh_len;
short mh_type;
short mh_flags;
};
struct pkthdr {
struct ifnet *rcvif;
SLIST_HEAD(packet_tags, m_tag) tags;
int len;
int csum;
};
struct m_ext {
caddr_t ext_buf;
void (*ext_free)(caddr_t, u_int, void *);
void *ext_arg;
u_int ext_size;
int ext_type;
struct mbuf *ext_nextref;
struct mbuf *ext_prevref;
};
struct mbuf {
struct m_hdr m_hdr;
union {
struct {
struct pkthdr MH_pkthdr;
union {
struct m_ext MH_ext;
char MH_databuf[MHLEN];
} MH_dat;
} MH;
char M_databuf[MLEN];
} M_dat;
};
#define m_next m_hdr.mh_next
#define m_len m_hdr.mh_len
#define m_data m_hdr.mh_data
#define m_type m_hdr.mh_type
#define m_flags m_hdr.mh_flags
#define m_nextpkt m_hdr.mh_nextpkt
#define m_act m_nextpkt
#define m_pkthdr M_dat.MH.MH_pkthdr
#define m_ext M_dat.MH.MH_dat.MH_ext
#define m_pktdat M_dat.MH.MH_dat.MH_databuf
#define m_dat M_dat.M_databuf
The mbuf functions provide a way to manage the memory
buffers used by the
kernel's networking subsystem. Several functions and macros
are used to
allocate and deallocate mbufs, but also to get, inject, remove, copy,
modify, prepend or append data inside these mbufs. The size
of an mbuf
is MSIZE (defined in <machine/param.h>).
An mbuf structure is defined as an m_hdr structure followed
by a union.
The header contains the following elements:
mh_next A pointer to the next mbuf in the mbuf chain.
mh_nextpkt A pointer to the next mbuf chain (i.e., packet) in the
queue.
mh_data Indicates the address of the beginning of data
in the mbuf.
mh_len Indicates the amount of data in the mbuf.
mh_type Indicates the type of data contained in the
mbuf (see below).
mh_flags Flags (see below).
The mh_type variable can take the following values:
MT_FREE the mbuf should be on the free
list.
MT_DATA the data in the mbuf was dynamically allocated.
MT_HEADER the data contains a packet header.
MT_SONAME the data is a socket name.
MT_SOOPTS the data are socket options.
MT_FTABLE the data is a fragment reassembly
header.
MT_CONTROL the mbuf contains extra-data protocol message.
MT_OOBDATA the data consists of out-of-banddata.
The mh_flags variable can take the following values:
M_EXT mbuf has associated external storage.
M_PKTHDR the mbuf is the first that forms a
packet.
M_EOR end of record.
M_CLUSTER the external storage is a cluster.
M_PROTO1 protocol-specific.
M_BCAST packet send/received as link-level
broadcast.
M_MCAST packet send/received as link-level
multicast.
M_CONF packet was encrypted (ESP-transport).
M_AUTH packet was authenticated (AH).
M_COMP packet was compressed (IPCOMP).
M_AUTH_AH header was authenticated (AH).
M_TUNNEL IP-in-IP added by tunnel mode
IPsec.
M_IPV4_CSUM_OUT IPv4 checksum needed.
M_TCPV4_CSUM_OUT TCP checksum needed.
M_UDPV4_CSUM_OUT UDP checksum needed.
M_IPV4_CSUM_IN_OK IPv4 checksum verified.
M_IPV4_CSUM_IN_BAD IPv4 checksum bad.
M_TCP_CSUM_IN_OK TCP/IPv4 checksum verified.
M_TCP_CSUM_IN_BAD TCP/IPv4 checksum bad.
M_UDP_CSUM_IN_OK UDP/IPv4 checksum verified.
M_UDP_CSUM_IN_BAD UDP/IPv4 checksum bad.
M_ANYCAST6 received as IPv6 anycast.
M_LOOP for mbuf statistics.
An external cluster is used when the data to hold in the
mbuf is large.
The size of an external cluster is MCLBYTES (also defined in
<machine/param.h>). A cluster should be used when the size
of the data
reach MINCLSIZE (the minimum size to be held by an external
cluster).
The combination of the M_EXT and M_PKTHDR flags give four
types of mbuf.
When none of these constants are in use, the mbuf is a "normal" one,
where the data part of the mbuf has the following elements:
m_dat buffer holding the data (size MLEN).
When only M_PKTHDR is set, the data contained in the mbuf is
a packet
header. The data itself is contained in the mbuf (just like
the previous
case), but part of the mbuf is used to store a packet header. The data
part has then the following elements:
m_pkthdr packet header, containing the length of the
data, a pointer
to the interface on which the data was received and a
generic pointer to a structure containing information for
IPsec processing.
m_pktdat buffer holding the data (size MHLEN).
When only M_EXT flag is set, an external storage buffer is
being used to
hold the data, which is no longer stored in the mbuf. The
data part of
the mbuf has now the following elements:
m_pkthdr a packet header, just like the previous case,
but it is
empty. No information is stored here
m_ext a structure containing information about the
external storage
buffer. The information consists of the
address of the
external buffer, a pointer to the function
used to free the
buffer, a pointer to the arguments of the
function, the
size of the buffer, the type of the buffer,
and pointers to
the previous and next mbufs using this cluster.
When both the M_EXT and M_PKTHDR flags are set, an external
storage
buffer is being used to store the data and this data contains a packet
header. The structure used is the same as the previous one
except that
the m_pkthdr element is not empty, it contains the same information as
when M_PKTHDR is used alone.
m_copym(struct mbuf *m, int off0, int len, int wait)
Copy an mbuf chain starting at off0 bytes from the
beginning and
continuing for len bytes. If off0 is zero and m has
the M_PKTHDR
flag set, the header is copied. If len is M_COPYALL
the whole
mbuf is copied. The wait parameter can be M_WAIT or
M_DONTWAIT.
It does not copy clusters, it just increases their
reference
count.
m_copym2(struct mbuf *m, int off0, int len, int wait)
The same as m_copym() except that it copies cluster
mbufs, whereas
m_copym() just increases the reference count of
the clusters.
m_free(struct mbuf *m)
Free the mbuf pointed to by m. A pointer to the
successor of the
mbuf, if it exists, is returned by the function.
MFREE(m, n)
Free the mbuf pointed to by m and use n to point to
the next mbuf
in the chain if it exists. See m_free().
m_get(int how, int type)
Return a pointer to an mbuf of the type specified.
If the how
argument is M_WAITOK, the function may call sleep(9)
to await resources.
If how is M_DONTWAIT and resources are not
available,
m_get() returns NULL.
MGET(m, how, type)
Return a pointer to an mbuf in m of the type specified. See
m_get() for a description of how.
m_getclr(int how, int type)
Return a pointer to an mbuf of the type specified,
and clear the
data area of the mbuf. See m_get() for a description of how.
m_gethdr(int how, int type)
Return a pointer to an mbuf of the type specified
after initializing
it to contain a packet header. See m_get()
for a description
of how.
MGETHDR(m, int how, int type)
Return a pointer to an mbuf of the type specified
after initializing
it to contain a packet header. See m_get()
for a description
of how.
m_prepend(struct mbuf *m, int len, int how)
Allocate a new mbuf and prepend it to the mbuf chain
pointed to
by m. If m points to an mbuf with a packet header,
it is moved
to the new mbuf that has been prepended. The return
value is a
pointer on the new mbuf chain. If this function
fails to allocate
a new mbuf, m is freed. See m_get() for a description of
how.
M_PREPEND(m, plen, how)
Prepend space of size plen to the mbuf pointed to by
m. If a new
mbuf must be allocated, how specifies whether to
wait or not. If
this function fails to allocate a new mbuf, m is
freed.
m_pulldown(struct mbuf *m, int off, int len, int *offp)
Ensure that the data in the mbuf chain starting at
off and ending
at off+len will be put in a continuous memory region. len must
be smaller or equal than MCLBYTES. The pointer returned points
to an mbuf in the chain and the new offset for data
in this mbuf
is *offp. If this function fails, m is freed.
m_pullup(struct mbuf *n, int len)
Ensure that the data in the mbuf chain starting at
the beginning
of the chain and ending at len will be put in continuous memory
region. To avoid being called again, m_pullup()
will attempt to
copy max_protohdr - len bytes into the first mbuf.
The len argument
must be smaller or equal than MHLEN. If this
function
fails, m is freed.
m_pullup2(struct mbuf *n, int len)
Just like m_pullup(), ensure that the data starting
at the beginning
of the mbuf chain and ending at len will be put
in continuous
memory region. The len argument can be up to
MCLBYTES.
m_pullup2() will simply call m_pullup() if len is
smaller or
equal to MHLEN.
m_split(struct mbuf *m0, int len0, int wait)
Split an mbuf chain in two pieces, returning a
pointer to the
tail (which is made of the previous mbuf chain except the first
len0 bytes).
m_inject(struct mbuf *m0, int len0, int siz, int wait)
Inject a new mbuf chain of length siz into the mbuf
chain pointed
to by m0 at position len0. If there is enough space
for an object
of size siz in the appropriate location, no
memory will be
allocated. On failure, the function returns NULL
(the mbuf is
left untouched) and on success, a pointer to the
first injected
mbuf is returned.
m_getptr(struct mbuf *m, int loc, int *off)
Returns a pointer to the mbuf containing the data
located at loc
bytes of the beginning. The offset in the new mbuf
is pointed to
by off.
m_adj(struct mbuf *mp, int req_len)
Trims req_len bytes of data from the mbuf chain
pointed to by mp.
If req_len is positive, the data will be trimmed
from the head of
the mbuf chain and if it is negative, it will be
trimmed from the
tail of the mbuf chain.
m_copyback(struct mbuf *m0, int off, int len, caddr_t cp)
Copy data from a buffer back into the mbuf chain
pointed to by m0
starting at off bytes from the beginning, extending
the mbuf
chain if necessary. The mbuf chain must be initialized properly,
including setting m_len.
m_freem(struct mbuf *m)
Free the mbuf chain pointed to by m.
m_reclaim(void)
Ask protocols to free unused memory space.
m_copydata(struct mbuf *m, int off, int len, caddr_t cp)
Copy data from the mbuf chain pointed to by m starting at off
bytes from the beginning and continuing for len
bytes into the
buffer pointed to by cp.
m_cat(struct mbuf *m, struct mbuf *n)
Concatenate the mbuf chain pointed to by n to the
mbuf chain
pointed to by m. The mbuf chains must be of the
same type.
m_devget(char *buf, int totlen, int off0, struct ifnet *ifp,
void
(*func)(const void *, void *, size_t))
Copy totlen bytes of data from device local memory
pointed to by
buf using the function func. The data is copied into an mbuf
chain and a pointer to the head of it is returned.
If off0 is
non-zero, it means the packet is trailer-encapsulated and off0
bytes plus the type and length fields will be
skipped before doing
the copy. Returns NULL on failure.
m_zero(struct mbuf *m)
Zeroize the data part of the mbufs in the mbuf chain
pointed to
by m.
m_apply(struct mbuf *m, int off, int len, int
(*func)(caddr_t, caddr_t,
unsigned int), caddr_t fstate)
Apply the function func to the data in the mbuf
chain pointed to
by m starting at off bytes from the beginning and
continuing for
len bytes.
mtod(struct mbuf *m, datatype)
Return a pointer to the data contained in the specified mbuf m
cast to datatype.
MCLGET(struct mbuf *m, int how)
Allocate and add an mbuf cluster to the mbuf pointed
to by m. On
success, the flag M_EXT is set in the mbuf. See
m_get() for a
description of how.
MEXTMALLOC(struct mbuf *m, int size, int how)
Allocate external storage of size size and add it to
the mbuf
pointed to by m. On success, the flag M_EXT is set
in the mbuf.
See m_get() for a description of how.
MEXTADD(struct mbuf *m, caddr_t buf, int type, void
(*free)(caddr_t,
u_int, void *), void *arg)
Add pre-allocated storage to the mbuf pointed to by
m. On success,
the flag M_EXT is set in the mbuf.
M_ALIGN(m, len)
Set the m_data pointer of the newly allocated mbuf
with m_get()
or MGET() pointed to by m to an object of the specified size len
at the end of the mbuf, longword aligned.
MH_ALIGN(m, len)
Same as M_ALIGN() except it is for an mbuf allocated
with
m_gethdr() or MGETHDR().
M_READONLY(m)
Check if the data of the mbuf pointed to by m is
read-only. This
is true for non-cluster external storage and for
clusters that
are being referenced by more than one mbuf.
M_LEADINGSPACE(m)
Compute the amount of space available before the
current start of
data in the mbuf pointed to by m.
M_TRAILINGSPACE(m)
Compute the amount of space available after the end
of data in
the mbuf pointed to by m.
MCHTYPE(m, type)
Change the type of the mbuf pointed to by m to type.
netstat(1), mbuf_tags(9), /usr/share/doc/smm/18.net.
Jun-Ichiro Hagino, "Mbuf issues in 4.4BSD IPv6/IPsec support
(experiences
from KAME Mbuf0 0Mbuf1", Proceedings of the Freenix Track:
2000 USENIX
Annual Technical Proceedings0, June 2000.
The mbuf management functions are implemented in the files
sys/kern/uipc_mbuf.c and sys/kern/uipc_mbuf2.c. The function prototypes
and the macros are located in sys/sys/mbuf.h.
OpenBSD 3.6 December 4, 2001
[ Back ] |
