The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/sys/mbuf.h

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*
    2  * Copyright (c) 1982, 1986, 1988, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *      This product includes software developed by the University of
   16  *      California, Berkeley and its contributors.
   17  * 4. Neither the name of the University nor the names of its contributors
   18  *    may be used to endorse or promote products derived from this software
   19  *    without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31  * SUCH DAMAGE.
   32  *
   33  *      @(#)mbuf.h      8.5 (Berkeley) 2/19/95
   34  * $FreeBSD: stable/4/sys/sys/mbuf.h 130618 2004-06-17 00:08:23Z fjoe $
   35  */
   36 
   37 #ifndef _SYS_MBUF_H_
   38 #define _SYS_MBUF_H_
   39 
   40 #include <sys/queue.h>
   41 
   42 /*
   43  * Mbufs are of a single size, MSIZE (machine/param.h), which
   44  * includes overhead.  An mbuf may add a single "mbuf cluster" of size
   45  * MCLBYTES (also in machine/param.h), which has no additional overhead
   46  * and is used instead of the internal data area; this is done when
   47  * at least MINCLSIZE of data must be stored.
   48  */
   49 #define MLEN            (MSIZE - sizeof(struct m_hdr))  /* normal data len */
   50 #define MHLEN           (MLEN - sizeof(struct pkthdr))  /* data len w/pkthdr */
   51 #define MINCLSIZE       (MHLEN + 1)     /* smallest amount to put in cluster */
   52 #define M_MAXCOMPRESS   (MHLEN / 2)     /* max amount to copy for compression */
   53 
   54 /*
   55  * Macros for type conversion:
   56  * mtod(m, t)   -- Convert mbuf pointer to data pointer of correct type.
   57  * dtom(x)      -- Convert data pointer within mbuf to mbuf pointer (XXX).
   58  * mtocl(x) -   convert pointer within cluster to cluster index #
   59  * cltom(x) -   convert cluster # to ptr to beginning of cluster
   60  */
   61 #define mtod(m, t)      ((t)((m)->m_data))
   62 #define dtom(x)         ((struct mbuf *)((intptr_t)(x) & ~(MSIZE-1)))
   63 #define mtocl(x)        (((uintptr_t)(x) - (uintptr_t)mbutl) >> MCLSHIFT)
   64 #define cltom(x)        ((caddr_t)((uintptr_t)mbutl + \
   65                             ((uintptr_t)(x) << MCLSHIFT)))
   66 #define mcl_valid(x)    ((uintptr_t)(x) >= (uintptr_t)mbutl &&          \
   67                          (uintptr_t)(x) < (uintptr_t)mbutltop)
   68 
   69 /*
   70  * Header present at the beginning of every mbuf.
   71  */
   72 struct m_hdr {
   73         struct  mbuf *mh_next;          /* next buffer in chain */
   74         struct  mbuf *mh_nextpkt;       /* next chain in queue/record */
   75         caddr_t mh_data;                /* location of data */
   76         int     mh_len;                 /* amount of data in this mbuf */
   77         short   mh_type;                /* type of data in this mbuf */
   78         short   mh_flags;               /* flags; see below */
   79 };
   80 
   81 /*
   82  * Packet tag structure (see below for details).
   83  */
   84 struct m_tag {
   85         SLIST_ENTRY(m_tag)      m_tag_link;     /* List of packet tags */
   86         u_int16_t               m_tag_id;       /* Tag ID */
   87         u_int16_t               m_tag_len;      /* Length of data */
   88         u_int32_t               m_tag_cookie;   /* ABI/Module ID */
   89 };
   90 
   91 /*
   92  * Record/packet header in first mbuf of chain; valid only if M_PKTHDR is set.
   93  */
   94 struct pkthdr {
   95         struct  ifnet *rcvif;           /* rcv interface */
   96         int     len;                    /* total packet length */
   97         /* variables for ip and tcp reassembly */
   98         void    *header;                /* pointer to packet header */
   99         /* variables for hardware checksum */
  100         int     csum_flags;             /* flags regarding checksum */
  101         int     csum_data;              /* data field used by csum routines */
  102         SLIST_HEAD(packet_tags, m_tag) tags; /* list of packet tags */
  103 };
  104 
  105 /*
  106  * Description of external storage mapped into mbuf; valid only if M_EXT is set.
  107  */
  108 struct m_ext {
  109         caddr_t ext_buf;                /* start of buffer */
  110         void    (*ext_free)             /* free routine if not the usual */
  111                     (caddr_t, u_int);
  112         u_int   ext_size;               /* size of buffer, for ext_free */
  113         void    (*ext_ref)              /* add a reference to the ext object */
  114                 (caddr_t, u_int);
  115 };
  116 
  117 /*
  118  * The core of the mbuf object along with some shortcut defines for
  119  * practical purposes.
  120  */
  121 struct mbuf {
  122         struct  m_hdr m_hdr;
  123         union {
  124                 struct {
  125                         struct  pkthdr MH_pkthdr;       /* M_PKTHDR set */
  126                         union {
  127                                 struct  m_ext MH_ext;   /* M_EXT set */
  128                                 char    MH_databuf[MHLEN];
  129                         } MH_dat;
  130                 } MH;
  131                 char    M_databuf[MLEN];                /* !M_PKTHDR, !M_EXT */
  132         } M_dat;
  133 };
  134 #define m_next          m_hdr.mh_next
  135 #define m_len           m_hdr.mh_len
  136 #define m_data          m_hdr.mh_data
  137 #define m_type          m_hdr.mh_type
  138 #define m_flags         m_hdr.mh_flags
  139 #define m_nextpkt       m_hdr.mh_nextpkt
  140 #define m_act           m_nextpkt
  141 #define m_pkthdr        M_dat.MH.MH_pkthdr
  142 #define m_ext           M_dat.MH.MH_dat.MH_ext
  143 #define m_pktdat        M_dat.MH.MH_dat.MH_databuf
  144 #define m_dat           M_dat.M_databuf
  145 
  146 /*
  147  * mbuf flags.
  148  */
  149 #define M_EXT           0x0001  /* has associated external storage */
  150 #define M_PKTHDR        0x0002  /* start of record */
  151 #define M_EOR           0x0004  /* end of record */
  152 #define M_PROTO1        0x0008  /* protocol-specific */
  153 #define M_PROTO2        0x0010  /* protocol-specific */
  154 #define M_PROTO3        0x0020  /* protocol-specific */
  155 #define M_PROTO4        0x0040  /* protocol-specific */
  156 #define M_PROTO5        0x0080  /* protocol-specific */
  157 
  158 /*
  159  * mbuf pkthdr flags (also stored in m_flags).
  160  */
  161 #define M_BCAST         0x0100  /* send/received as link-level broadcast */
  162 #define M_MCAST         0x0200  /* send/received as link-level multicast */
  163 #define M_FRAG          0x0400  /* packet is a fragment of a larger packet */
  164 #define M_FIRSTFRAG     0x0800  /* packet is first fragment */
  165 #define M_LASTFRAG      0x1000  /* packet is last fragment */
  166 
  167 /*
  168  * Flags copied when copying m_pkthdr.
  169  */
  170 #define M_COPYFLAGS     (M_PKTHDR|M_EOR|M_PROTO1|M_PROTO1|M_PROTO2|M_PROTO3 | \
  171                             M_PROTO4|M_PROTO5|M_BCAST|M_MCAST|M_FRAG | \
  172                             M_FIRSTFRAG|M_LASTFRAG)
  173 
  174 /*
  175  * Flags indicating hw checksum support and sw checksum requirements.
  176  */
  177 #define CSUM_IP                 0x0001          /* will csum IP */
  178 #define CSUM_TCP                0x0002          /* will csum TCP */
  179 #define CSUM_UDP                0x0004          /* will csum UDP */
  180 #define CSUM_IP_FRAGS           0x0008          /* will csum IP fragments */
  181 #define CSUM_FRAGMENT           0x0010          /* will do IP fragmentation */
  182 
  183 #define CSUM_IP_CHECKED         0x0100          /* did csum IP */
  184 #define CSUM_IP_VALID           0x0200          /*   ... the csum is valid */
  185 #define CSUM_DATA_VALID         0x0400          /* csum_data field is valid */
  186 #define CSUM_PSEUDO_HDR         0x0800          /* csum_data has pseudo hdr */
  187 
  188 #define CSUM_DELAY_DATA         (CSUM_TCP | CSUM_UDP)
  189 #define CSUM_DELAY_IP           (CSUM_IP)       /* XXX add ipv6 here too? */
  190 
  191 /*
  192  * mbuf types.
  193  */
  194 #define MT_FREE         0       /* should be on free list */
  195 #define MT_DATA         1       /* dynamic (data) allocation */
  196 #define MT_HEADER       2       /* packet header */
  197 #if 0
  198 #define MT_SOCKET       3       /* socket structure */
  199 #define MT_PCB          4       /* protocol control block */
  200 #define MT_RTABLE       5       /* routing tables */
  201 #define MT_HTABLE       6       /* IMP host tables */
  202 #define MT_ATABLE       7       /* address resolution tables */
  203 #endif
  204 #define MT_SONAME       8       /* socket name */
  205 #if 0
  206 #define MT_SOOPTS       10      /* socket options */
  207 #endif
  208 #define MT_FTABLE       11      /* fragment reassembly header */
  209 #if 0
  210 #define MT_RIGHTS       12      /* access rights */
  211 #define MT_IFADDR       13      /* interface address */
  212 #endif
  213 #define MT_TAG          13      /* volatile metadata associated to pkts */
  214 #define MT_CONTROL      14      /* extra-data protocol message */
  215 #define MT_OOBDATA      15      /* expedited data  */
  216 #define MT_NTYPES       16      /* number of mbuf types for mbtypes[] */
  217 
  218 /*
  219  * General mbuf allocator statistics structure.
  220  */
  221 struct mbstat {
  222         u_long  m_mbufs;        /* mbufs obtained from page pool */
  223         u_long  m_clusters;     /* clusters obtained from page pool */
  224         u_long  m_spare;        /* spare field */
  225         u_long  m_clfree;       /* free clusters */
  226         u_long  m_drops;        /* times failed to find space */
  227         u_long  m_wait;         /* times waited for space */
  228         u_long  m_drain;        /* times drained protocols for space */
  229         u_long  m_mcfail;       /* times m_copym failed */
  230         u_long  m_mpfail;       /* times m_pullup failed */
  231         u_long  m_msize;        /* length of an mbuf */
  232         u_long  m_mclbytes;     /* length of an mbuf cluster */
  233         u_long  m_minclsize;    /* min length of data to allocate a cluster */
  234         u_long  m_mlen;         /* length of data in an mbuf */
  235         u_long  m_mhlen;        /* length of data in a header mbuf */
  236         u_long  sf_iocnt;       /* times sendfile had to do disk I/O */
  237         u_long  sf_allocfail;   /* times sfbuf allocation failed */
  238         u_long  sf_allocwait;   /* times sfbuf allocation had to wait */
  239 };
  240 
  241 /*
  242  * Flags specifying how an allocation should be made.
  243  */
  244 
  245 #define M_DONTWAIT      1
  246 #define M_WAIT          0
  247 
  248 /* Freelists:
  249  *
  250  * Normal mbuf clusters are normally treated as character arrays
  251  * after allocation, but use the first word of the buffer as a free list
  252  * pointer while on the free list.
  253  */
  254 union mcluster {
  255         union   mcluster *mcl_next;
  256         char    mcl_buf[MCLBYTES];
  257 };
  258 
  259 
  260 /*
  261  * These are identifying numbers passed to the m_mballoc_wait function,
  262  * allowing us to determine whether the call came from an MGETHDR or
  263  * an MGET.
  264  */
  265 #define MGETHDR_C      1
  266 #define MGET_C         2
  267 
  268 /*
  269  * Wake up the next instance (if any) of m_mballoc_wait() which is
  270  * waiting for an mbuf to be freed.  This should be called at splimp().
  271  *
  272  * XXX: If there is another free mbuf, this routine will be called [again]
  273  * from the m_mballoc_wait routine in order to wake another sleep instance.
  274  */
  275 #define MMBWAKEUP() do {                                                \
  276         if (m_mballoc_wid) {                                            \
  277                 m_mballoc_wid--;                                        \
  278                 wakeup_one(&m_mballoc_wid);                             \
  279         }                                                               \
  280 } while (0)
  281 
  282 /*
  283  * Same as above, but for mbuf cluster(s).
  284  */
  285 #define MCLWAKEUP() do {                                                \
  286         if (m_clalloc_wid) {                                            \
  287                 m_clalloc_wid--;                                        \
  288                 wakeup_one(&m_clalloc_wid);                             \
  289         }                                                               \
  290 } while (0)
  291 
  292 /*
  293  * mbuf utility macros:
  294  *
  295  *      MBUFLOCK(code)
  296  * prevents a section of code from from being interrupted by network
  297  * drivers.
  298  */
  299 #define MBUFLOCK(code) do {                                             \
  300         int _ms = splimp();                                             \
  301                                                                         \
  302         { code }                                                        \
  303         splx(_ms);                                                      \
  304 } while (0)
  305 
  306 /*
  307  * mbuf allocation/deallocation macros:
  308  *
  309  *      MGET(struct mbuf *m, int how, int type)
  310  * allocates an mbuf and initializes it to contain internal data.
  311  *
  312  *      MGETHDR(struct mbuf *m, int how, int type)
  313  * allocates an mbuf and initializes it to contain a packet header
  314  * and internal data.
  315  */
  316 #define MGET(m, how, type) do {                                         \
  317         struct mbuf *_mm;                                               \
  318         int _mhow = (how);                                              \
  319         int _mtype = (type);                                            \
  320         int _ms = splimp();                                             \
  321                                                                         \
  322         if (mmbfree == NULL)                                            \
  323                 (void)m_mballoc(1, _mhow);                              \
  324         _mm = mmbfree;                                                  \
  325         if (_mm != NULL) {                                              \
  326                 mmbfree = _mm->m_next;                                  \
  327                 mbtypes[MT_FREE]--;                                     \
  328                 _mm->m_type = _mtype;                                   \
  329                 mbtypes[_mtype]++;                                      \
  330                 _mm->m_next = NULL;                                     \
  331                 _mm->m_nextpkt = NULL;                                  \
  332                 _mm->m_data = _mm->m_dat;                               \
  333                 _mm->m_flags = 0;                                       \
  334                 (m) = _mm;                                              \
  335                 splx(_ms);                                              \
  336         } else {                                                        \
  337                 splx(_ms);                                              \
  338                 _mm = m_retry(_mhow, _mtype);                           \
  339                 if (_mm == NULL && _mhow == M_WAIT)                     \
  340                         (m) = m_mballoc_wait(MGET_C, _mtype);           \
  341                 else                                                    \
  342                         (m) = _mm;                                      \
  343         }                                                               \
  344 } while (0)
  345 
  346 #define MGETHDR(m, how, type) do {                                      \
  347         struct mbuf *_mm;                                               \
  348         int _mhow = (how);                                              \
  349         int _mtype = (type);                                            \
  350         int _ms = splimp();                                             \
  351                                                                         \
  352         if (mmbfree == NULL)                                            \
  353                 (void)m_mballoc(1, _mhow);                              \
  354         _mm = mmbfree;                                                  \
  355         if (_mm != NULL) {                                              \
  356                 mmbfree = _mm->m_next;                                  \
  357                 mbtypes[MT_FREE]--;                                     \
  358                 _mm->m_type = _mtype;                                   \
  359                 mbtypes[_mtype]++;                                      \
  360                 _mm->m_next = NULL;                                     \
  361                 _mm->m_nextpkt = NULL;                                  \
  362                 _mm->m_data = _mm->m_pktdat;                            \
  363                 _mm->m_flags = M_PKTHDR;                                \
  364                 _mm->m_pkthdr.rcvif = NULL;                             \
  365                 SLIST_INIT(&_mm->m_pkthdr.tags);                        \
  366                 _mm->m_pkthdr.csum_flags = 0;                           \
  367                 (m) = _mm;                                              \
  368                 splx(_ms);                                              \
  369         } else {                                                        \
  370                 splx(_ms);                                              \
  371                 _mm = m_retryhdr(_mhow, _mtype);                        \
  372                 if (_mm == NULL && _mhow == M_WAIT)                     \
  373                         (m) = m_mballoc_wait(MGETHDR_C, _mtype);        \
  374                 else                                                    \
  375                         (m) = _mm;                                      \
  376         }                                                               \
  377 } while (0)
  378 
  379 /*
  380  * Mbuf cluster macros.
  381  * MCLALLOC(caddr_t p, int how) allocates an mbuf cluster.
  382  * MCLGET adds such clusters to a normal mbuf;
  383  * the flag M_EXT is set upon success.
  384  * MCLFREE releases a reference to a cluster allocated by MCLALLOC,
  385  * freeing the cluster if the reference count has reached 0.
  386  */
  387 #define MCLALLOC(p, how) do {                                           \
  388         caddr_t _mp;                                                    \
  389         int _mhow = (how);                                              \
  390         int _ms = splimp();                                             \
  391                                                                         \
  392         if (mclfree == NULL)                                            \
  393                 (void)m_clalloc(1, _mhow);                              \
  394         _mp = (caddr_t)mclfree;                                         \
  395         if (_mp != NULL) {                                              \
  396                 KASSERT(mcl_valid(_mp),                                 \
  397                         ("MCLALLOC junk pointer: %x < %x < %x.",        \
  398                         (uintptr_t)mbutl, (uintptr_t)_mp,               \
  399                         (uintptr_t)mbutltop));                          \
  400                 KASSERT(mclrefcnt[mtocl(_mp)] == 0,                     \
  401                         ("free cluster with refcount %d.",              \
  402                         mclrefcnt[mtocl(_mp)]));                        \
  403                 mclrefcnt[mtocl(_mp)]++;                                \
  404                 mbstat.m_clfree--;                                      \
  405                 mclfree = ((union mcluster *)_mp)->mcl_next;            \
  406                 (p) = _mp;                                              \
  407                 splx(_ms);                                              \
  408         } else {                                                        \
  409                 splx(_ms);                                              \
  410                 if (_mhow == M_WAIT)                                    \
  411                         (p) = m_clalloc_wait();                         \
  412                 else                                                    \
  413                         (p) = NULL;                                     \
  414         }                                                               \
  415 } while (0)     
  416 
  417 #define MCLGET(m, how) do {                                             \
  418         struct mbuf *_mm = (m);                                         \
  419                                                                         \
  420         MCLALLOC(_mm->m_ext.ext_buf, (how));                            \
  421         if (_mm->m_ext.ext_buf != NULL) {                               \
  422                 _mm->m_data = _mm->m_ext.ext_buf;                       \
  423                 _mm->m_flags |= M_EXT;                                  \
  424                 _mm->m_ext.ext_free = NULL;                             \
  425                 _mm->m_ext.ext_ref = NULL;                              \
  426                 _mm->m_ext.ext_size = MCLBYTES;                         \
  427         }                                                               \
  428 } while (0)
  429 
  430 #define MCLFREE1(p) do {                                                \
  431         union mcluster *_mp = (union mcluster *)(p);                    \
  432                                                                         \
  433         KASSERT(mcl_valid(_mp),                                         \
  434                 ("MCLFREE1 junk pointer: %x < %x < %x.",                \
  435                 (uintptr_t)mbutl, (uintptr_t)_mp,                       \
  436                 (uintptr_t)mbutltop));                                  \
  437         KASSERT(mclrefcnt[mtocl(_mp)] > 0,                              \
  438                 ("freeing free cluster, refcount: %d.",                 \
  439                 mclrefcnt[mtocl(_mp)]));                                \
  440         if (--mclrefcnt[mtocl(_mp)] == 0) {                             \
  441                 _mp->mcl_next = mclfree;                                \
  442                 mclfree = _mp;                                          \
  443                 mbstat.m_clfree++;                                      \
  444                 MCLWAKEUP();                                            \
  445         }                                                               \
  446 } while (0)
  447 
  448 #define MCLFREE(p) MBUFLOCK(                                            \
  449         MCLFREE1(p);                                                    \
  450 )
  451 
  452 #define MEXTFREE1(m) do {                                               \
  453                 struct mbuf *_mm = (m);                                 \
  454                                                                         \
  455                 if (_mm->m_ext.ext_free != NULL)                        \
  456                         (*_mm->m_ext.ext_free)(_mm->m_ext.ext_buf,      \
  457                             _mm->m_ext.ext_size);                       \
  458                 else                                                    \
  459                         MCLFREE1(_mm->m_ext.ext_buf);                   \
  460 } while (0)
  461 
  462 #define MEXTFREE(m) MBUFLOCK(                                           \
  463         MEXTFREE1(m);                                                   \
  464 )
  465 
  466 /*
  467  * NB: M_COPY_PKTHDR is deprecated; use either M_MOVE_PKTHDR
  468  *     or m_dup_pkthdr.
  469  */
  470 /*
  471  * Move mbuf pkthdr from "from" to "to".
  472  * from should have M_PKTHDR set, and to must be empty.
  473  * from no longer has a pkthdr after this operation.
  474  */
  475 #define M_MOVE_PKTHDR(_to, _from)       m_move_pkthdr((_to), (_from))
  476 
  477 /*
  478  * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place
  479  * an object of the specified size at the end of the mbuf, longword aligned.
  480  */
  481 #define M_ALIGN(m, len) do {                                            \
  482         (m)->m_data += (MLEN - (len)) & ~(sizeof(long) - 1);            \
  483 } while (0)
  484 
  485 /*
  486  * As above, for mbufs allocated with m_gethdr/MGETHDR
  487  * or initialized by M_COPY_PKTHDR.
  488  */
  489 #define MH_ALIGN(m, len) do {                                           \
  490         (m)->m_data += (MHLEN - (len)) & ~(sizeof(long) - 1);           \
  491 } while (0)
  492 
  493 /*
  494  * Check if we can write to an mbuf.
  495  */
  496 #define M_EXT_WRITABLE(m)       \
  497     ((m)->m_ext.ext_free == NULL && mclrefcnt[mtocl((m)->m_ext.ext_buf)] == 1)
  498 
  499 #define M_WRITABLE(m) (!((m)->m_flags & M_EXT) || \
  500     M_EXT_WRITABLE(m) )
  501 
  502 /*
  503  * Compute the amount of space available
  504  * before the current start of data in an mbuf.
  505  *
  506  * The M_WRITABLE() is a temporary, conservative safety measure: the burden
  507  * of checking writability of the mbuf data area rests solely with the caller.
  508  */
  509 #define M_LEADINGSPACE(m)                                               \
  510         ((m)->m_flags & M_EXT ?                                         \
  511             (M_EXT_WRITABLE(m) ? (m)->m_data - (m)->m_ext.ext_buf : 0): \
  512             (m)->m_flags & M_PKTHDR ? (m)->m_data - (m)->m_pktdat :     \
  513             (m)->m_data - (m)->m_dat)
  514 
  515 /*
  516  * Compute the amount of space available
  517  * after the end of data in an mbuf.
  518  *
  519  * The M_WRITABLE() is a temporary, conservative safety measure: the burden
  520  * of checking writability of the mbuf data area rests solely with the caller.
  521  */
  522 #define M_TRAILINGSPACE(m)                                              \
  523         ((m)->m_flags & M_EXT ?                                         \
  524             (M_WRITABLE(m) ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size   \
  525                 - ((m)->m_data + (m)->m_len) : 0) :                     \
  526             &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len))
  527 
  528 /*
  529  * Arrange to prepend space of size plen to mbuf m.
  530  * If a new mbuf must be allocated, how specifies whether to wait.
  531  * If how is M_DONTWAIT and allocation fails, the original mbuf chain
  532  * is freed and m is set to NULL.
  533  */
  534 #define M_PREPEND(m, plen, how) do {                                    \
  535         struct mbuf **_mmp = &(m);                                      \
  536         struct mbuf *_mm = *_mmp;                                       \
  537         int _mplen = (plen);                                            \
  538         int __mhow = (how);                                             \
  539                                                                         \
  540         if (M_LEADINGSPACE(_mm) >= _mplen) {                            \
  541                 _mm->m_data -= _mplen;                                  \
  542                 _mm->m_len += _mplen;                                   \
  543         } else                                                          \
  544                 _mm = m_prepend(_mm, _mplen, __mhow);                   \
  545         if (_mm != NULL && _mm->m_flags & M_PKTHDR)                     \
  546                 _mm->m_pkthdr.len += _mplen;                            \
  547         *_mmp = _mm;                                                    \
  548 } while (0)
  549 
  550 /* change mbuf to new type */
  551 #define MCHTYPE(m, t) do {                                              \
  552         struct mbuf *_mm = (m);                                         \
  553         int _mt = (t);                                                  \
  554         int _ms = splimp();                                             \
  555                                                                         \
  556         mbtypes[_mm->m_type]--;                                         \
  557         mbtypes[_mt]++;                                                 \
  558         splx(_ms);                                                      \
  559         _mm->m_type = (_mt);                                            \
  560 } while (0)
  561 
  562 /* Length to m_copy to copy all. */
  563 #define M_COPYALL       1000000000
  564 
  565 /* Compatibility with 4.3 */
  566 #define m_copy(m, o, l) m_copym((m), (o), (l), M_DONTWAIT)
  567 
  568 #ifdef _KERNEL
  569 extern  u_int            m_clalloc_wid; /* mbuf cluster wait count */
  570 extern  u_int            m_mballoc_wid; /* mbuf wait count */
  571 extern  int              max_linkhdr;   /* largest link-level header */
  572 extern  int              max_protohdr;  /* largest protocol header */
  573 extern  int              max_hdr;       /* largest link+protocol header */
  574 extern  int              max_datalen;   /* MHLEN - max_hdr */
  575 extern  struct mbstat    mbstat;
  576 extern  u_long           mbtypes[MT_NTYPES]; /* per-type mbuf allocations */
  577 extern  int              mbuf_wait;     /* mbuf sleep time */
  578 extern  struct mbuf     *mbutl;         /* virtual address of mclusters */
  579 extern  struct mbuf     *mbutltop;      /* highest address of mclusters */
  580 extern  char            *mclrefcnt;     /* cluster reference counts */
  581 extern  union mcluster  *mclfree;
  582 extern  struct mbuf     *mmbfree;
  583 extern  int              nmbclusters;
  584 extern  int              nmbufs;
  585 extern  int              nsfbufs;       /* Number of sendfile(2) bufs alloced */
  586 extern  int              nsfbufspeak;   /* Peak of nsfbufsused */
  587 extern  int              nsfbufsused;   /* Number of sendfile(2) bufs in use */
  588 
  589 void             m_adj(struct mbuf *, int);
  590 int              m_apply(struct mbuf *, int, int,
  591                     int (*)(void *, void *, unsigned int), void *);
  592 void             m_cat(struct mbuf *, struct mbuf *);
  593 int              m_clalloc(int, int);
  594 caddr_t          m_clalloc_wait(void);
  595 void             m_copyback(struct mbuf *, int, int, caddr_t);
  596 void             m_copydata(struct mbuf *, int, int, caddr_t);
  597 struct  mbuf    *m_copym(struct mbuf *, int, int, int);
  598 struct  mbuf    *m_copypacket(struct mbuf *, int);
  599 struct  mbuf    *m_defrag(struct mbuf *, int);
  600 struct  mbuf    *m_devget(char *, int, int, struct ifnet *,
  601                     void (*copy)(char *, caddr_t, u_int));
  602 struct  mbuf    *m_dup(struct mbuf *, int);
  603 int              m_dup_pkthdr(struct mbuf *, struct mbuf *, int);
  604 u_int            m_fixhdr(struct mbuf *);
  605 struct  mbuf    *m_fragment(struct mbuf *, int, int);
  606 struct  mbuf    *m_free(struct mbuf *);
  607 void             m_freem(struct mbuf *);
  608 struct  mbuf    *m_get(int, int);
  609 struct  mbuf    *m_getcl(int how, short type, int flags);
  610 struct  mbuf    *m_getclr(int, int);
  611 struct  mbuf    *m_gethdr(int, int);
  612 struct  mbuf    *m_getm(struct mbuf *, int, int, int);
  613 struct  mbuf    *m_getptr(struct mbuf *, int, int *);
  614 u_int           m_length(struct mbuf *, struct mbuf **);
  615 int              m_mballoc(int, int);
  616 struct  mbuf    *m_mballoc_wait(int, int);
  617 void             m_move_pkthdr(struct mbuf *, struct mbuf *);
  618 struct  mbuf    *m_prepend(struct mbuf *, int, int);
  619 void             m_print(const struct mbuf *m);
  620 struct  mbuf    *m_pulldown(struct mbuf *, int, int, int *);
  621 struct  mbuf    *m_pullup(struct mbuf *, int);
  622 struct  mbuf    *m_retry(int, int);
  623 struct  mbuf    *m_retryhdr(int, int);
  624 struct  mbuf    *m_split(struct mbuf *, int, int);
  625 
  626 /*
  627  * Packets may have annotations attached by affixing a list
  628  * of "packet tags" to the pkthdr structure.  Packet tags are
  629  * dynamically allocated semi-opaque data structures that have
  630  * a fixed header (struct m_tag) that specifies the size of the
  631  * memory block and a <cookie,type> pair that identifies it.
  632  * The cookie is a 32-bit unique unsigned value used to identify
  633  * a module or ABI.  By convention this value is chose as the
  634  * date+time that the module is created, expressed as the number of
  635  * seconds since the epoch (e.g. using date -u +'%s').  The type value
  636  * is an ABI/module-specific value that identifies a particular annotation
  637  * and is private to the module.  For compatibility with systems
  638  * like openbsd that define packet tags w/o an ABI/module cookie,
  639  * the value PACKET_ABI_COMPAT is used to implement m_tag_get and
  640  * m_tag_find compatibility shim functions and several tag types are
  641  * defined below.  Users that do not require compatibility should use
  642  * a private cookie value so that packet tag-related definitions
  643  * can be maintained privately.
  644  *
  645  * Note that the packet tag returned by m_tag_alloc has the default
  646  * memory alignment implemented by malloc.  To reference private data
  647  * one can use a construct like:
  648  *
  649  *      struct m_tag *mtag = m_tag_alloc(...);
  650  *      struct foo *p = (struct foo *)(mtag+1);
  651  *
  652  * if the alignment of struct m_tag is sufficient for referencing members
  653  * of struct foo.  Otherwise it is necessary to embed struct m_tag within
  654  * the private data structure to insure proper alignment; e.g.
  655  *
  656  *      struct foo {
  657  *              struct m_tag    tag;
  658  *              ...
  659  *      };
  660  *      struct foo *p = (struct foo *) m_tag_alloc(...);
  661  *      struct m_tag *mtag = &p->tag;
  662  */
  663 
  664 #define PACKET_TAG_NONE                         0  /* Nadda */
  665 
  666 /* Packet tag for use with PACKET_ABI_COMPAT */
  667 #define PACKET_TAG_IPSEC_IN_DONE                1  /* IPsec applied, in */
  668 #define PACKET_TAG_IPSEC_OUT_DONE               2  /* IPsec applied, out */
  669 #define PACKET_TAG_IPSEC_IN_CRYPTO_DONE         3  /* NIC IPsec crypto done */
  670 #define PACKET_TAG_IPSEC_OUT_CRYPTO_NEEDED      4  /* NIC IPsec crypto req'ed */
  671 #define PACKET_TAG_IPSEC_IN_COULD_DO_CRYPTO     5  /* NIC notifies IPsec */
  672 #define PACKET_TAG_IPSEC_PENDING_TDB            6  /* Reminder to do IPsec */
  673 #define PACKET_TAG_BRIDGE                       7  /* Bridge processing done */
  674 #define PACKET_TAG_GIF                          8  /* GIF processing done */
  675 #define PACKET_TAG_GRE                          9  /* GRE processing done */
  676 #define PACKET_TAG_IN_PACKET_CHECKSUM           10 /* NIC checksumming done */
  677 #define PACKET_TAG_ENCAP                        11 /* Encap.  processing */
  678 #define PACKET_TAG_IPSEC_SOCKET                 12 /* IPSEC socket ref */
  679 #define PACKET_TAG_IPSEC_HISTORY                13 /* IPSEC history */
  680 #define PACKET_TAG_IPV6_INPUT                   14 /* IPV6 input processing */
  681 
  682 /*
  683  * As a temporary and low impact solution to replace the even uglier
  684  * approach used so far in some parts of the network stack (which relies
  685  * on global variables), packet tag-like annotations are stored in MT_TAG
  686  * mbufs (or lookalikes) prepended to the actual mbuf chain.
  687  *
  688  *      m_type  = MT_TAG
  689  *      m_flags = m_tag_id
  690  *      m_next  = next buffer in chain.
  691  *
  692  * BE VERY CAREFUL not to pass these blocks to the mbuf handling routines.
  693  */
  694 #define _m_tag_id       m_hdr.mh_flags
  695 
  696 /* Packet tags used in the FreeBSD network stack */
  697 #define PACKET_TAG_DUMMYNET                     15 /* dummynet info */
  698 #define PACKET_TAG_IPFW                         16 /* ipfw classification */
  699 #define PACKET_TAG_DIVERT                       17 /* divert info */
  700 #define PACKET_TAG_IPFORWARD                    18 /* ipforward info */
  701 
  702 /* Packet tag routines */
  703 struct  m_tag   *m_tag_alloc(u_int32_t, int, int, int);
  704 void             m_tag_free(struct m_tag *);
  705 void             m_tag_prepend(struct mbuf *, struct m_tag *);
  706 void             m_tag_unlink(struct mbuf *, struct m_tag *);
  707 void             m_tag_delete(struct mbuf *, struct m_tag *);
  708 void             m_tag_delete_chain(struct mbuf *, struct m_tag *);
  709 struct  m_tag   *m_tag_locate(struct mbuf *, u_int32_t, int, struct m_tag *);
  710 struct  m_tag   *m_tag_copy(struct m_tag *, int);
  711 int              m_tag_copy_chain(struct mbuf *, struct mbuf *, int);
  712 void             m_tag_init(struct mbuf *);
  713 struct  m_tag   *m_tag_first(struct mbuf *);
  714 struct  m_tag   *m_tag_next(struct mbuf *, struct m_tag *);
  715 
  716 /* these are for openbsd compatibility */
  717 #define MTAG_ABI_COMPAT         0               /* compatibility ABI */
  718 
  719 static __inline struct m_tag *
  720 m_tag_get(int type, int length, int wait)
  721 {
  722         return m_tag_alloc(MTAG_ABI_COMPAT, type, length, wait);
  723 }
  724 
  725 static __inline struct m_tag *
  726 m_tag_find(struct mbuf *m, int type, struct m_tag *start)
  727 {
  728         return m_tag_locate(m, MTAG_ABI_COMPAT, type, start);
  729 }
  730 #endif /* _KERNEL */
  731 
  732 #endif /* !_SYS_MBUF_H_ */

Cache object: 4271d09d20dc8efc1e04a140d655791c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.