MirOS Manual: mbuf(9), MCHTYPE(9), MCLGET(9), MEXTADD(9), MEXTALLOC(9), MFREE(9), MGET(9), MGETHDR(9), MH_ALIGN(9), m_adj(9), M_ALIGN(9), m_apply(9), m_cat(9), m_copyback(9), m_copydata(9), m_copym(9), m_copym2(9), m_devget(9), m_free(9), m_freem(9), m_get(9), m_getclr(9), m_gethdr(9), m_getptr(9), m_inject(9), M_LEADINGSPACE(9), M_PREPEND(9), m_prepend(9), m_pulldown(9), m_pullup(9), m_pullup2(9), M_READONLY(9), m_reclaim(9), m_retry(9), m_retryhdr(9), m_split(9), M_TRAILINGSPACE(9), m_zero(9)

MBUF(9)                       BSD Kernel Manual                        MBUF(9)

NAME

     mbuf - Kernel memory management for networking protocols

SYNOPSIS

     #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

DESCRIPTION

     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 gen-
                   eric pointer to a structure containing information for IP-
                   sec 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 clus-
             ters.

     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 ar-
             gument 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 initial-
             izing it to contain a packet header. See m_get() for a descrip-
             tion of how.

     MGETHDR(m, int how, int type)
             Return a pointer to an mbuf of the type specified after initial-
             izing it to contain a packet header. See m_get() for a descrip-
             tion 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 argu-
             ment 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 begin-
             ning of the mbuf chain and ending at len will be put in continu-
             ous 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 allo-
             cated. 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 do-
             ing 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 suc-
             cess, 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.

SEE ALSO

     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", Proceedings of the Freenix Track: 2000 USENIX Annual
     Technical, June 2000.

CODE REFERENCES

     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.

MirOS BSD #10-current          December 4, 2001                              7

Generated on 2014-04-02 20:57:59 by $MirOS: src/scripts/roff2htm,v 1.79 2014/02/10 00:36:11 tg Exp $

These manual pages and other documentation are copyrighted by their respective writers; their source is available at our CVSweb, AnonCVS, and other mirrors. The rest is Copyright © 2002‒2014 The MirOS Project, Germany.
This product includes material provided by Thorsten Glaser.

This manual page’s HTML representation is supposed to be valid XHTML/1.1; if not, please send a bug report – diffs preferred.