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  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  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: src/sys/sys/mbuf.h,v 1.128 2003/11/24 03:57:03 sam Exp $
   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 (sys/param.h), which
   44  * includes overhead.  An mbuf may add a single "mbuf cluster" of size
   45  * MCLBYTES (also in sys/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.  Additionally, it is possible
   48  * to allocate a separate buffer externally and attach it to the mbuf in
   49  * a way similar to that of mbuf clusters.
   50  */
   51 #define MLEN            (MSIZE - sizeof(struct m_hdr))  /* normal data len */
   52 #define MHLEN           (MLEN - sizeof(struct pkthdr))  /* data len w/pkthdr */
   53 #define MINCLSIZE       (MHLEN + 1)     /* smallest amount to put in cluster */
   54 #define M_MAXCOMPRESS   (MHLEN / 2)     /* max amount to copy for compression */
   55 
   56 #ifdef _KERNEL
   57 /*-
   58  * Macros for type conversion:
   59  * mtod(m, t)   -- Convert mbuf pointer to data pointer of correct type.
   60  * dtom(x)      -- Convert data pointer within mbuf to mbuf pointer (XXX).
   61  */
   62 #define mtod(m, t)      ((t)((m)->m_data))
   63 #define dtom(x)         ((struct mbuf *)((intptr_t)(x) & ~(MSIZE-1)))
   64 #endif /* _KERNEL */
   65 
   66 /*
   67  * Header present at the beginning of every mbuf.
   68  */
   69 struct m_hdr {
   70         struct  mbuf *mh_next;          /* next buffer in chain */
   71         struct  mbuf *mh_nextpkt;       /* next chain in queue/record */
   72         caddr_t mh_data;                /* location of data */
   73         int     mh_len;                 /* amount of data in this mbuf */
   74         int     mh_flags;               /* flags; see below */
   75         short   mh_type;                /* type of data in this mbuf */
   76 };
   77 
   78 /*
   79  * Packet tag structure (see below for details).
   80  */
   81 struct m_tag {
   82         SLIST_ENTRY(m_tag)      m_tag_link;     /* List of packet tags */
   83         u_int16_t               m_tag_id;       /* Tag ID */
   84         u_int16_t               m_tag_len;      /* Length of data */
   85         u_int32_t               m_tag_cookie;   /* ABI/Module ID */
   86 };
   87 
   88 /*
   89  * Record/packet header in first mbuf of chain; valid only if M_PKTHDR is set.
   90  */
   91 struct pkthdr {
   92         struct  ifnet *rcvif;           /* rcv interface */
   93         int     len;                    /* total packet length */
   94         /* variables for ip and tcp reassembly */
   95         void    *header;                /* pointer to packet header */
   96         /* variables for hardware checksum */
   97         int     csum_flags;             /* flags regarding checksum */
   98         int     csum_data;              /* data field used by csum routines */
   99         SLIST_HEAD(packet_tags, m_tag) tags; /* list of packet tags */
  100 };
  101 
  102 /*
  103  * Description of external storage mapped into mbuf; valid only if M_EXT is set.
  104  */
  105 struct m_ext {
  106         caddr_t ext_buf;                /* start of buffer */
  107         void    (*ext_free)             /* free routine if not the usual */
  108                     (void *, void *);
  109         void    *ext_args;              /* optional argument pointer */
  110         u_int   ext_size;               /* size of buffer, for ext_free */
  111         u_int   *ref_cnt;               /* pointer to ref count info */
  112         int     ext_type;               /* type of external storage */
  113 };
  114 
  115 /*
  116  * The core of the mbuf object along with some shortcut defines for
  117  * practical purposes.
  118  */
  119 struct mbuf {
  120         struct  m_hdr m_hdr;
  121         union {
  122                 struct {
  123                         struct  pkthdr MH_pkthdr;       /* M_PKTHDR set */
  124                         union {
  125                                 struct  m_ext MH_ext;   /* M_EXT set */
  126                                 char    MH_databuf[MHLEN];
  127                         } MH_dat;
  128                 } MH;
  129                 char    M_databuf[MLEN];                /* !M_PKTHDR, !M_EXT */
  130         } M_dat;
  131 };
  132 #define m_next          m_hdr.mh_next
  133 #define m_len           m_hdr.mh_len
  134 #define m_data          m_hdr.mh_data
  135 #define m_type          m_hdr.mh_type
  136 #define m_flags         m_hdr.mh_flags
  137 #define m_nextpkt       m_hdr.mh_nextpkt
  138 #define m_act           m_nextpkt
  139 #define m_pkthdr        M_dat.MH.MH_pkthdr
  140 #define m_ext           M_dat.MH.MH_dat.MH_ext
  141 #define m_pktdat        M_dat.MH.MH_dat.MH_databuf
  142 #define m_dat           M_dat.M_databuf
  143 
  144 /*
  145  * mbuf flags.
  146  */
  147 #define M_EXT           0x0001  /* has associated external storage */
  148 #define M_PKTHDR        0x0002  /* start of record */
  149 #define M_EOR           0x0004  /* end of record */
  150 #define M_RDONLY        0x0008  /* associated data is marked read-only */
  151 #define M_PROTO1        0x0010  /* protocol-specific */
  152 #define M_PROTO2        0x0020  /* protocol-specific */
  153 #define M_PROTO3        0x0040  /* protocol-specific */
  154 #define M_PROTO4        0x0080  /* protocol-specific */
  155 #define M_PROTO5        0x0100  /* protocol-specific */
  156 #define M_PROTO6        0x4000  /* protocol-specific (avoid M_BCAST conflict) */
  157 #define M_FREELIST      0x8000  /* mbuf is on the free list */
  158 
  159 /*
  160  * mbuf pkthdr flags (also stored in m_flags).
  161  */
  162 #define M_BCAST         0x0200  /* send/received as link-level broadcast */
  163 #define M_MCAST         0x0400  /* send/received as link-level multicast */
  164 #define M_FRAG          0x0800  /* packet is a fragment of a larger packet */
  165 #define M_FIRSTFRAG     0x1000  /* packet is first fragment */
  166 #define M_LASTFRAG      0x2000  /* packet is last fragment */
  167 
  168 /*
  169  * External buffer types: identify ext_buf type.
  170  */
  171 #define EXT_CLUSTER     1       /* mbuf cluster */
  172 #define EXT_SFBUF       2       /* sendfile(2)'s sf_bufs */
  173 #define EXT_NET_DRV     100     /* custom ext_buf provided by net driver(s) */
  174 #define EXT_MOD_TYPE    200     /* custom module's ext_buf type */
  175 #define EXT_DISPOSABLE  300     /* can throw this buffer away w/page flipping */
  176 #define EXT_EXTREF      400     /* has externally maintained ref_cnt ptr*/
  177 
  178 /*
  179  * Flags copied when copying m_pkthdr.
  180  */
  181 #define M_COPYFLAGS     (M_PKTHDR|M_EOR|M_RDONLY|M_PROTO1|M_PROTO1|M_PROTO2|\
  182                             M_PROTO3|M_PROTO4|M_PROTO5|M_PROTO6|\
  183                             M_BCAST|M_MCAST|M_FRAG|M_FIRSTFRAG|M_LASTFRAG)
  184 
  185 /*
  186  * Flags indicating hw checksum support and sw checksum requirements.
  187  */
  188 #define CSUM_IP                 0x0001          /* will csum IP */
  189 #define CSUM_TCP                0x0002          /* will csum TCP */
  190 #define CSUM_UDP                0x0004          /* will csum UDP */
  191 #define CSUM_IP_FRAGS           0x0008          /* will csum IP fragments */
  192 #define CSUM_FRAGMENT           0x0010          /* will do IP fragmentation */
  193 
  194 #define CSUM_IP_CHECKED         0x0100          /* did csum IP */
  195 #define CSUM_IP_VALID           0x0200          /*   ... the csum is valid */
  196 #define CSUM_DATA_VALID         0x0400          /* csum_data field is valid */
  197 #define CSUM_PSEUDO_HDR         0x0800          /* csum_data has pseudo hdr */
  198 
  199 #define CSUM_DELAY_DATA         (CSUM_TCP | CSUM_UDP)
  200 #define CSUM_DELAY_IP           (CSUM_IP)       /* XXX add ipv6 here too? */
  201 
  202 /*
  203  * mbuf types.
  204  */
  205 #define MT_NOTMBUF      0       /* USED INTERNALLY ONLY! Object is not mbuf */
  206 #define MT_DATA         1       /* dynamic (data) allocation */
  207 #define MT_HEADER       2       /* packet header */
  208 #if 0
  209 #define MT_SOCKET       3       /* socket structure */
  210 #define MT_PCB          4       /* protocol control block */
  211 #define MT_RTABLE       5       /* routing tables */
  212 #define MT_HTABLE       6       /* IMP host tables */
  213 #define MT_ATABLE       7       /* address resolution tables */
  214 #endif
  215 #define MT_SONAME       8       /* socket name */
  216 #if 0
  217 #define MT_SOOPTS       10      /* socket options */
  218 #endif
  219 #define MT_FTABLE       11      /* fragment reassembly header */
  220 #if 0
  221 #define MT_RIGHTS       12      /* access rights */
  222 #define MT_IFADDR       13      /* interface address */
  223 #endif
  224 #define MT_TAG          13      /* volatile metadata associated to pkts */
  225 #define MT_CONTROL      14      /* extra-data protocol message */
  226 #define MT_OOBDATA      15      /* expedited data  */
  227 #define MT_NTYPES       16      /* number of mbuf types for mbtypes[] */
  228 
  229 /*
  230  * Mbuf and cluster allocation statistics PCPU structure.
  231  */
  232 struct mbpstat {
  233         u_long  mb_mbfree;
  234         u_long  mb_mbbucks;
  235         u_long  mb_clfree;
  236         u_long  mb_clbucks;
  237         long    mb_mbtypes[MT_NTYPES];
  238         short   mb_active;
  239 };
  240 
  241 /*
  242  * General mbuf allocator statistics structure.
  243  * XXX: Modifications of these are not protected by any mutex locks nor by
  244  * any atomic() manipulations.  As a result, we may occasionally lose
  245  * a count or two.  Luckily, not all of these fields are modified at all
  246  * and remain static, and those that are manipulated are only manipulated
  247  * in failure situations, which do not occur (hopefully) very often.
  248  */
  249 struct mbstat {
  250         u_long  m_drops;        /* times failed to allocate */
  251         u_long  m_wait;         /* times succesfully returned from wait */
  252         u_long  m_drain;        /* times drained protocols for space */
  253         u_long  m_mcfail;       /* XXX: times m_copym failed */
  254         u_long  m_mpfail;       /* XXX: times m_pullup failed */
  255         u_long  m_msize;        /* length of an mbuf */
  256         u_long  m_mclbytes;     /* length of an mbuf cluster */
  257         u_long  m_minclsize;    /* min length of data to allocate a cluster */
  258         u_long  m_mlen;         /* length of data in an mbuf */
  259         u_long  m_mhlen;        /* length of data in a header mbuf */
  260         u_int   m_mbperbuck;    /* number of mbufs per "bucket" */
  261         u_int   m_clperbuck;    /* number of clusters per "bucket" */
  262         /* Number of mbtypes (gives # elems in mbpstat's mb_mbtypes[] array: */
  263         short   m_numtypes;
  264 };
  265 
  266 /*
  267  * Flags specifying how an allocation should be made.
  268  * M_DONTWAIT means "don't block if nothing is available" whereas
  269  * M_TRYWAIT means "block for mbuf_wait ticks at most if nothing is
  270  * available."
  271  */
  272 #define M_DONTWAIT      0x4             /* don't conflict with M_NOWAIT */
  273 #define M_TRYWAIT       0x8             /* or M_WAITOK */
  274 #define M_WAIT          M_TRYWAIT       /* XXX: deprecated */
  275 #define MBTOM(how)      ((how) & M_TRYWAIT ? M_WAITOK : M_NOWAIT)
  276 
  277 #ifdef _KERNEL
  278 /*-
  279  * mbuf external reference count management macros.
  280  *
  281  * MEXT_IS_REF(m): true if (m) is not the only mbuf referencing
  282  *     the external buffer ext_buf.
  283  *
  284  * MEXT_REM_REF(m): remove reference to m_ext object.
  285  *
  286  * MEXT_ADD_REF(m): add reference to m_ext object already
  287  *     referred to by (m).
  288  */
  289 #define MEXT_IS_REF(m)  (*((m)->m_ext.ref_cnt) > 1)
  290 
  291 #define MEXT_REM_REF(m) do {                                            \
  292         KASSERT(*((m)->m_ext.ref_cnt) > 0, ("m_ext refcnt < 0"));       \
  293         atomic_subtract_int((m)->m_ext.ref_cnt, 1);                     \
  294 } while(0)
  295 
  296 #define MEXT_ADD_REF(m) atomic_add_int((m)->m_ext.ref_cnt, 1)
  297 
  298 /*
  299  * mbuf, cluster, and external object allocation macros
  300  * (for compatibility purposes).
  301  */
  302 /* NB: M_COPY_PKTHDR is deprecated.  Use M_MOVE_PKTHDR or m_dup_pktdr. */
  303 #define M_MOVE_PKTHDR(to, from) m_move_pkthdr((to), (from))
  304 #define m_getclr(how, type)     m_get_clrd((how), (type))
  305 #define MGET(m, how, type)      ((m) = m_get((how), (type)))
  306 #define MGETHDR(m, how, type)   ((m) = m_gethdr((how), (type)))
  307 #define MCLGET(m, how)          m_clget((m), (how))
  308 #define MEXTADD(m, buf, size, free, args, flags, type)                  \
  309     m_extadd((m), (caddr_t)(buf), (size), (free), (args), (flags), (type))
  310 
  311 /*
  312  * MEXTFREE(m): disassociate (and possibly free) an external object from (m).
  313  * 
  314  * If the atomic_cmpset_int() returns 0, then we effectively do nothing
  315  * in terms of "cleaning up" (freeing the ext buf and ref. counter) as
  316  * this means that either there are still references, or another thread
  317  * is taking care of the clean-up.
  318  */
  319 #define MEXTFREE(m) do {                                                \
  320         struct mbuf *_mb = (m);                                         \
  321                                                                         \
  322         MEXT_REM_REF(_mb);                                              \
  323         if (atomic_cmpset_int(_mb->m_ext.ref_cnt, 0, 1))                \
  324                 _mext_free(_mb);                                        \
  325         _mb->m_flags &= ~M_EXT;                                         \
  326 } while (0)
  327 
  328 /*
  329  * Evaluate TRUE if it's safe to write to the mbuf m's data region (this
  330  * can be both the local data payload, or an external buffer area,
  331  * depending on whether M_EXT is set).
  332  */
  333 #define M_WRITABLE(m)   (!((m)->m_flags & M_RDONLY) && (!((m)->m_flags  \
  334                             & M_EXT) || !MEXT_IS_REF(m)))
  335 
  336 /*
  337  * Check if the supplied mbuf has a packet header, or else panic.
  338  */
  339 #define M_ASSERTPKTHDR(m)                               \
  340         KASSERT(m != NULL && m->m_flags & M_PKTHDR,     \
  341                 ("%s: no mbuf packet header!", __func__))
  342 
  343 /*
  344  * Ensure that the supplied mbuf is a valid, non-free mbuf.
  345  */
  346 #define M_ASSERTVALID(m)                                        \
  347         KASSERT((((struct mbuf *)m)->m_flags & M_FREELIST) == 0,                        \
  348                 ("%s: attempted use of a free mbuf!", __func__))
  349 
  350 /*
  351  * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place
  352  * an object of the specified size at the end of the mbuf, longword aligned.
  353  */
  354 #define M_ALIGN(m, len) do {                                            \
  355         (m)->m_data += (MLEN - (len)) & ~(sizeof(long) - 1);            \
  356 } while (0)
  357 
  358 /*
  359  * As above, for mbufs allocated with m_gethdr/MGETHDR
  360  * or initialized by M_COPY_PKTHDR.
  361  */
  362 #define MH_ALIGN(m, len) do {                                           \
  363         (m)->m_data += (MHLEN - (len)) & ~(sizeof(long) - 1);           \
  364 } while (0)
  365 
  366 /*
  367  * Compute the amount of space available
  368  * before the current start of data in an mbuf.
  369  *
  370  * The M_WRITABLE() is a temporary, conservative safety measure: the burden
  371  * of checking writability of the mbuf data area rests solely with the caller.
  372  */
  373 #define M_LEADINGSPACE(m)                                               \
  374         ((m)->m_flags & M_EXT ?                                         \
  375             (M_WRITABLE(m) ? (m)->m_data - (m)->m_ext.ext_buf : 0):     \
  376             (m)->m_flags & M_PKTHDR ? (m)->m_data - (m)->m_pktdat :     \
  377             (m)->m_data - (m)->m_dat)
  378 
  379 /*
  380  * Compute the amount of space available
  381  * after the end of data in an mbuf.
  382  *
  383  * The M_WRITABLE() is a temporary, conservative safety measure: the burden
  384  * of checking writability of the mbuf data area rests solely with the caller.
  385  */
  386 #define M_TRAILINGSPACE(m)                                              \
  387         ((m)->m_flags & M_EXT ?                                         \
  388             (M_WRITABLE(m) ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size   \
  389                 - ((m)->m_data + (m)->m_len) : 0) :                     \
  390             &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len))
  391 
  392 /*
  393  * Arrange to prepend space of size plen to mbuf m.
  394  * If a new mbuf must be allocated, how specifies whether to wait.
  395  * If the allocation fails, the original mbuf chain is freed and m is
  396  * set to NULL.
  397  */
  398 #define M_PREPEND(m, plen, how) do {                                    \
  399         struct mbuf **_mmp = &(m);                                      \
  400         struct mbuf *_mm = *_mmp;                                       \
  401         int _mplen = (plen);                                            \
  402         int __mhow = (how);                                             \
  403                                                                         \
  404         if (M_LEADINGSPACE(_mm) >= _mplen) {                            \
  405                 _mm->m_data -= _mplen;                                  \
  406                 _mm->m_len += _mplen;                                   \
  407         } else                                                          \
  408                 _mm = m_prepend(_mm, _mplen, __mhow);                   \
  409         if (_mm != NULL && _mm->m_flags & M_PKTHDR)                     \
  410                 _mm->m_pkthdr.len += _mplen;                            \
  411         *_mmp = _mm;                                                    \
  412 } while (0)
  413 
  414 /*
  415  * Change mbuf to new type.
  416  * This is a relatively expensive operation and should be avoided.
  417  */
  418 #define MCHTYPE(m, t)   m_chtype((m), (t))
  419 
  420 /* Length to m_copy to copy all. */
  421 #define M_COPYALL       1000000000
  422 
  423 /* Compatibility with 4.3. */
  424 #define m_copy(m, o, l) m_copym((m), (o), (l), M_DONTWAIT)
  425 
  426 extern  int max_datalen;                /* MHLEN - max_hdr */
  427 extern  int max_hdr;                    /* Largest link + protocol header */
  428 extern  int max_linkhdr;                /* Largest link-level header */
  429 extern  int max_protohdr;               /* Largest protocol header */
  430 extern  struct mbstat mbstat;           /* General mbuf stats/infos */
  431 extern  int nmbclusters;                /* Maximum number of clusters */
  432 extern  int nmbcnt;                     /* Scale kmem_map for counter space */
  433 extern  int nmbufs;                     /* Maximum number of mbufs */
  434 extern  int nsfbufs;                    /* Number of sendfile(2) bufs */
  435 
  436 void             _mext_free(struct mbuf *);
  437 void             m_adj(struct mbuf *, int);
  438 void             m_cat(struct mbuf *, struct mbuf *);
  439 void             m_chtype(struct mbuf *, short);
  440 void             m_clget(struct mbuf *, int);
  441 void             m_extadd(struct mbuf *, caddr_t, u_int,
  442                     void (*)(void *, void *), void *, int, int);
  443 void             m_copyback(struct mbuf *, int, int, caddr_t);
  444 void             m_copydata(const struct mbuf *, int, int, caddr_t);
  445 struct  mbuf    *m_copym(struct mbuf *, int, int, int);
  446 struct  mbuf    *m_copypacket(struct mbuf *, int);
  447 void             m_copy_pkthdr(struct mbuf *, struct mbuf *);
  448 struct  mbuf    *m_defrag(struct mbuf *, int);
  449 struct  mbuf    *m_devget(char *, int, int, struct ifnet *,
  450                     void (*)(char *, caddr_t, u_int));
  451 struct  mbuf    *m_dup(struct mbuf *, int);
  452 int              m_dup_pkthdr(struct mbuf *, struct mbuf *, int);
  453 u_int            m_fixhdr(struct mbuf *);
  454 struct  mbuf    *m_fragment(struct mbuf *, int, int);
  455 struct  mbuf    *m_free(struct mbuf *);
  456 void             m_freem(struct mbuf *);
  457 struct  mbuf    *m_get(int, short);
  458 struct  mbuf    *m_get_clrd(int, short);
  459 struct  mbuf    *m_getcl(int, short, int);
  460 struct  mbuf    *m_gethdr(int, short);
  461 struct  mbuf    *m_gethdr_clrd(int, short);
  462 struct  mbuf    *m_getm(struct mbuf *, int, int, short);
  463 u_int            m_length(struct mbuf *, struct mbuf **);
  464 void             m_move_pkthdr(struct mbuf *, struct mbuf *);
  465 struct  mbuf    *m_prepend(struct mbuf *, int, int);
  466 void             m_print(const struct mbuf *);
  467 struct  mbuf    *m_pulldown(struct mbuf *, int, int, int *);
  468 struct  mbuf    *m_pullup(struct mbuf *, int);
  469 struct  mbuf    *m_split(struct mbuf *, int, int);
  470 
  471 /*
  472  * Packets may have annotations attached by affixing a list
  473  * of "packet tags" to the pkthdr structure.  Packet tags are
  474  * dynamically allocated semi-opaque data structures that have
  475  * a fixed header (struct m_tag) that specifies the size of the
  476  * memory block and a <cookie,type> pair that identifies it.
  477  * The cookie is a 32-bit unique unsigned value used to identify
  478  * a module or ABI.  By convention this value is chose as the
  479  * date+time that the module is created, expressed as the number of
  480  * seconds since the epoch (e.g., using date -u +'%s').  The type value
  481  * is an ABI/module-specific value that identifies a particular annotation
  482  * and is private to the module.  For compatibility with systems
  483  * like OpenBSD that define packet tags w/o an ABI/module cookie,
  484  * the value PACKET_ABI_COMPAT is used to implement m_tag_get and
  485  * m_tag_find compatibility shim functions and several tag types are
  486  * defined below.  Users that do not require compatibility should use
  487  * a private cookie value so that packet tag-related definitions
  488  * can be maintained privately.
  489  *
  490  * Note that the packet tag returned by m_tag_allocate has the default
  491  * memory alignment implemented by malloc.  To reference private data
  492  * one can use a construct like:
  493  *
  494  *      struct m_tag *mtag = m_tag_allocate(...);
  495  *      struct foo *p = (struct foo *)(mtag+1);
  496  *
  497  * if the alignment of struct m_tag is sufficient for referencing members
  498  * of struct foo.  Otherwise it is necessary to embed struct m_tag within
  499  * the private data structure to insure proper alignment; e.g.,
  500  *
  501  *      struct foo {
  502  *              struct m_tag    tag;
  503  *              ...
  504  *      };
  505  *      struct foo *p = (struct foo *) m_tag_allocate(...);
  506  *      struct m_tag *mtag = &p->tag;
  507  */
  508 
  509 /*
  510  * Persistent tags stay with an mbuf until the mbuf is reclaimed.
  511  * Otherwise tags are expected to ``vanish'' when they pass through
  512  * a network interface.  For most interfaces this happens normally
  513  * as the tags are reclaimed when the mbuf is free'd.  However in
  514  * some special cases reclaiming must be done manually.  An example
  515  * is packets that pass through the loopback interface.  Also, one
  516  * must be careful to do this when ``turning around'' packets (e.g.,
  517  * icmp_reflect).
  518  *
  519  * To mark a tag persistent bit-or this flag in when defining the
  520  * tag id.  The tag will then be treated as described above.
  521  */
  522 #define MTAG_PERSISTENT                         0x800
  523 
  524 #define PACKET_TAG_NONE                         0  /* Nadda */
  525 
  526 /* Packet tag for use with PACKET_ABI_COMPAT. */
  527 #define PACKET_TAG_IPSEC_IN_DONE                1  /* IPsec applied, in */
  528 #define PACKET_TAG_IPSEC_OUT_DONE               2  /* IPsec applied, out */
  529 #define PACKET_TAG_IPSEC_IN_CRYPTO_DONE         3  /* NIC IPsec crypto done */
  530 #define PACKET_TAG_IPSEC_OUT_CRYPTO_NEEDED      4  /* NIC IPsec crypto req'ed */
  531 #define PACKET_TAG_IPSEC_IN_COULD_DO_CRYPTO     5  /* NIC notifies IPsec */
  532 #define PACKET_TAG_IPSEC_PENDING_TDB            6  /* Reminder to do IPsec */
  533 #define PACKET_TAG_BRIDGE                       7  /* Bridge processing done */
  534 #define PACKET_TAG_GIF                          8  /* GIF processing done */
  535 #define PACKET_TAG_GRE                          9  /* GRE processing done */
  536 #define PACKET_TAG_IN_PACKET_CHECKSUM           10 /* NIC checksumming done */
  537 #define PACKET_TAG_ENCAP                        11 /* Encap.  processing */
  538 #define PACKET_TAG_IPSEC_SOCKET                 12 /* IPSEC socket ref */
  539 #define PACKET_TAG_IPSEC_HISTORY                13 /* IPSEC history */
  540 #define PACKET_TAG_IPV6_INPUT                   14 /* IPV6 input processing */
  541 
  542 /*
  543  * As a temporary and low impact solution to replace the even uglier
  544  * approach used so far in some parts of the network stack (which relies
  545  * on global variables), packet tag-like annotations are stored in MT_TAG
  546  * mbufs (or lookalikes) prepended to the actual mbuf chain.
  547  *
  548  *      m_type  = MT_TAG
  549  *      m_flags = m_tag_id
  550  *      m_next  = next buffer in chain.
  551  *
  552  * BE VERY CAREFUL not to pass these blocks to the mbuf handling routines.
  553  */
  554 #define _m_tag_id       m_hdr.mh_flags
  555 
  556 /* Packet tags used in the FreeBSD network stack. */
  557 #define PACKET_TAG_DUMMYNET                     15 /* dummynet info */
  558 #define PACKET_TAG_IPFW                         16 /* ipfw classification */
  559 #define PACKET_TAG_DIVERT                       17 /* divert info */
  560 #define PACKET_TAG_IPFORWARD                    18 /* ipforward info */
  561 #define PACKET_TAG_MACLABEL     (19 | MTAG_PERSISTENT) /* MAC label */
  562 #define PACKET_TAG_IPFASTFWD_OURS               20 /* IP fastforward dropback */
  563 
  564 /* Packet tag routines. */
  565 struct  m_tag   *m_tag_alloc(u_int32_t, int, int, int);
  566 void             m_tag_free(struct m_tag *);
  567 void             m_tag_prepend(struct mbuf *, struct m_tag *);
  568 void             m_tag_unlink(struct mbuf *, struct m_tag *);
  569 void             m_tag_delete(struct mbuf *, struct m_tag *);
  570 void             m_tag_delete_chain(struct mbuf *, struct m_tag *);
  571 struct  m_tag   *m_tag_locate(struct mbuf *, u_int32_t, int, struct m_tag *);
  572 struct  m_tag   *m_tag_copy(struct m_tag *, int);
  573 int              m_tag_copy_chain(struct mbuf *, struct mbuf *, int);
  574 void             m_tag_init(struct mbuf *);
  575 struct  m_tag   *m_tag_first(struct mbuf *);
  576 struct  m_tag   *m_tag_next(struct mbuf *, struct m_tag *);
  577 void             m_tag_delete_nonpersistent(struct mbuf *);
  578 
  579 /* These are for OpenBSD compatibility. */
  580 #define MTAG_ABI_COMPAT         0               /* compatibility ABI */
  581 
  582 static __inline struct m_tag *
  583 m_tag_get(int type, int length, int wait)
  584 {
  585         return m_tag_alloc(MTAG_ABI_COMPAT, type, length, wait);
  586 }
  587 
  588 static __inline struct m_tag *
  589 m_tag_find(struct mbuf *m, int type, struct m_tag *start)
  590 {
  591         return m_tag_locate(m, MTAG_ABI_COMPAT, type, start);
  592 }
  593 #endif /* _KERNEL */
  594 
  595 #endif /* !_SYS_MBUF_H_ */

Cache object: 85aa8954c692178fbd5790a8bca62900


[ 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.