ext/sctp/usrsctp/usrsctplib/user_mbuf.h

   1 /*-
   2  * Copyright (c) 1982, 1986, 1988, 1993
   3  *      The Regents of the University of California.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. Neither the name of the University nor the names of its contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  */
  31
  32 #ifndef _USER_MBUF_H_
  33 #define _USER_MBUF_H_
  34
  35 /* __Userspace__ header file for mbufs */
  36 #include <stdio.h>
  37 #if !defined(SCTP_SIMPLE_ALLOCATOR)
  38 #include "umem.h"
  39 #endif
  40 #include "user_malloc.h"
  41 #include "netinet/sctp_os_userspace.h"
  42
  43 #define USING_MBUF_CONSTRUCTOR 0
  44
  45 /* For Linux */
  46 #ifndef MSIZE
  47 #define MSIZE 256
  48 /* #define MSIZE 1024 */
  49 #endif
  50 #ifndef MCLBYTES
  51 #define MCLBYTES 2048
  52 #endif
  53
  54 struct mbuf * m_gethdr(int how, short type);
  55 struct mbuf * m_get(int how, short type);
  56 struct mbuf * m_free(struct mbuf *m);
  57 void m_clget(struct mbuf *m, int how);
  58 struct mbuf * m_getm2(struct mbuf *m, int len, int how, short type, int flags, int allonebuf);
  59 struct mbuf *m_uiotombuf(struct uio *uio, int how, int len, int align, int flags);
  60 u_int m_length(struct mbuf *m0, struct mbuf **last);
  61 struct mbuf *m_last(struct mbuf *m);
  62
  63 /* mbuf initialization function */
  64 void mbuf_initialize(void *);
  65
  66 #define M_MOVE_PKTHDR(to, from) m_move_pkthdr((to), (from))
  67 #define MGET(m, how, type)      ((m) = m_get((how), (type)))
  68 #define MGETHDR(m, how, type)   ((m) = m_gethdr((how), (type)))
  69 #define MCLGET(m, how)          m_clget((m), (how))
  70
  71
  72 #define M_HDR_PAD ((sizeof(intptr_t)==4) ? 2 : 6) /* modified for __Userspace__ */
  73
  74 /* Length to m_copy to copy all. */
  75 #define M_COPYALL       1000000000
  76
  77 /* umem_cache_t is defined in user_include/umem.h as
  78  * typedef struct umem_cache umem_cache_t;
  79  * Note:umem_zone_t is a pointer.
  80  */
  81 #if defined(SCTP_SIMPLE_ALLOCATOR)
  82 typedef size_t sctp_zone_t;
  83 #else
  84 typedef umem_cache_t *sctp_zone_t;
  85 #endif
  86
  87 extern sctp_zone_t zone_mbuf;
  88 extern sctp_zone_t zone_clust;
  89 extern sctp_zone_t zone_ext_refcnt;
  90
  91 /*-
  92  * Macros for type conversion:
  93  * mtod(m, t)   -- Convert mbuf pointer to data pointer of correct type.
  94  * dtom(x)      -- Convert data pointer within mbuf to mbuf pointer (XXX).
  95  */
  96 #define mtod(m, t)      ((t)((m)->m_data))
  97 #define dtom(x)         ((struct mbuf *)((intptr_t)(x) & ~(MSIZE-1)))
  98
  99 struct mb_args {
 100         int     flags;  /* Flags for mbuf being allocated */
 101         short   type;   /* Type of mbuf being allocated */
 102 };
 103
 104 struct clust_args {
 105         struct mbuf * parent_mbuf;
 106 };
 107
 108 struct mbuf *    m_split(struct mbuf *, int, int);
 109 void             m_cat(struct mbuf *m, struct mbuf *n);
 110 void             m_adj(struct mbuf *, int);
 111 void  mb_free_ext(struct mbuf *);
 112 void  m_freem(struct mbuf *);
 113 struct m_tag    *m_tag_alloc(uint32_t, int, int, int);
 114 struct mbuf     *m_copym(struct mbuf *, int, int, int);
 115 void             m_copyback(struct mbuf *, int, int, caddr_t);
 116 struct mbuf     *m_pullup(struct mbuf *, int);
 117 struct mbuf     *m_pulldown(struct mbuf *, int off, int len, int *offp);
 118 int              m_dup_pkthdr(struct mbuf *, struct mbuf *, int);
 119 struct m_tag    *m_tag_copy(struct m_tag *, int);
 120 int              m_tag_copy_chain(struct mbuf *, struct mbuf *, int);
 121 struct mbuf     *m_prepend(struct mbuf *, int, int);
 122 void             m_copydata(const struct mbuf *, int, int, caddr_t);
 123
 124 #define MBUF_MEM_NAME "mbuf"
 125 #define MBUF_CLUSTER_MEM_NAME "mbuf_cluster"
 126 #define MBUF_EXTREFCNT_MEM_NAME "mbuf_ext_refcnt"
 127
 128 #define MT_NOINIT       255     /* Not a type but a flag to allocate
 129                                    a non-initialized mbuf */
 130
 131 /*
 132  * Mbufs are of a single size, MSIZE (sys/param.h), which includes overhead.
 133  * An mbuf may add a single "mbuf cluster" of size MCLBYTES (also in
 134  * sys/param.h), which has no additional overhead and is used instead of the
 135  * internal data area; this is done when at least MINCLSIZE of data must be
 136  * stored.  Additionally, it is possible to allocate a separate buffer
 137  * externally and attach it to the mbuf in a way similar to that of mbuf
 138  * clusters.
 139  */
 140 #define MLEN            ((int)(MSIZE - sizeof(struct m_hdr)))   /* normal data len */
 141 #define MHLEN           ((int)(MLEN - sizeof(struct pkthdr)))   /* data len w/pkthdr */
 142 #define MINCLSIZE       ((int)(MHLEN + 1))      /* smallest amount to put in cluster */
 143 #define M_MAXCOMPRESS   (MHLEN / 2)     /* max amount to copy for compression */
 144
 145
 146 /*
 147  * Header present at the beginning of every mbuf.
 148  */
 149 struct m_hdr {
 150         struct mbuf     *mh_next;       /* next buffer in chain */
 151         struct mbuf     *mh_nextpkt;    /* next chain in queue/record */
 152         caddr_t          mh_data;       /* location of data */
 153         int              mh_len;        /* amount of data in this mbuf */
 154         int              mh_flags;      /* flags; see below */
 155         short            mh_type;       /* type of data in this mbuf */
 156         uint8_t          pad[M_HDR_PAD];/* word align                  */
 157 };
 158
 159 /*
 160  * Packet tag structure (see below for details).
 161  */
 162 struct m_tag {
 163         SLIST_ENTRY(m_tag)      m_tag_link;     /* List of packet tags */
 164         uint16_t                m_tag_id;       /* Tag ID */
 165         uint16_t                m_tag_len;      /* Length of data */
 166         uint32_t                m_tag_cookie;   /* ABI/Module ID */
 167         void                    (*m_tag_free)(struct m_tag *);
 168 };
 169
 170 /*
 171  * Record/packet header in first mbuf of chain; valid only if M_PKTHDR is set.
 172  */
 173 struct pkthdr {
 174         struct ifnet    *rcvif;         /* rcv interface */
 175         /* variables for ip and tcp reassembly */
 176         void            *header;        /* pointer to packet header */
 177         int              len;           /* total packet length */
 178         /* variables for hardware checksum */
 179         int              csum_flags;    /* flags regarding checksum */
 180         int              csum_data;     /* data field used by csum routines */
 181         uint16_t         tso_segsz;     /* TSO segment size */
 182         uint16_t         ether_vtag;    /* Ethernet 802.1p+q vlan tag */
 183         SLIST_HEAD(packet_tags, m_tag) tags; /* list of packet tags */
 184 };
 185
 186 /*
 187  * Description of external storage mapped into mbuf; valid only if M_EXT is
 188  * set.
 189  */
 190 struct m_ext {
 191         caddr_t          ext_buf;       /* start of buffer */
 192         void            (*ext_free)     /* free routine if not the usual */
 193                             (void *, void *);
 194         void            *ext_args;      /* optional argument pointer */
 195         u_int            ext_size;      /* size of buffer, for ext_free */
 196         volatile u_int  *ref_cnt;       /* pointer to ref count info */
 197         int              ext_type;      /* type of external storage */
 198 };
 199
 200
 201 /*
 202  * The core of the mbuf object along with some shortcut defined for practical
 203  * purposes.
 204  */
 205 struct mbuf {
 206         struct m_hdr    m_hdr;
 207         union {
 208                 struct {
 209                         struct pkthdr   MH_pkthdr;      /* M_PKTHDR set */
 210                         union {
 211                                 struct m_ext    MH_ext; /* M_EXT set */
 212                                 char            MH_databuf[MHLEN];
 213                         } MH_dat;
 214                 } MH;
 215                 char    M_databuf[MLEN];                /* !M_PKTHDR, !M_EXT */
 216         } M_dat;
 217 };
 218
 219 #define m_next          m_hdr.mh_next
 220 #define m_len           m_hdr.mh_len
 221 #define m_data          m_hdr.mh_data
 222 #define m_type          m_hdr.mh_type
 223 #define m_flags         m_hdr.mh_flags
 224 #define m_nextpkt       m_hdr.mh_nextpkt
 225 #define m_act           m_nextpkt
 226 #define m_pkthdr        M_dat.MH.MH_pkthdr
 227 #define m_ext           M_dat.MH.MH_dat.MH_ext
 228 #define m_pktdat        M_dat.MH.MH_dat.MH_databuf
 229 #define m_dat           M_dat.M_databuf
 230
 231
 232 /*
 233  * mbuf flags.
 234  */
 235 #define M_EXT           0x0001  /* has associated external storage */
 236 #define M_PKTHDR        0x0002  /* start of record */
 237 #define M_EOR           0x0004  /* end of record */
 238 #define M_RDONLY        0x0008  /* associated data is marked read-only */
 239 #define M_PROTO1        0x0010  /* protocol-specific */
 240 #define M_PROTO2        0x0020  /* protocol-specific */
 241 #define M_PROTO3        0x0040  /* protocol-specific */
 242 #define M_PROTO4        0x0080  /* protocol-specific */
 243 #define M_PROTO5        0x0100  /* protocol-specific */
 244 #define M_FREELIST      0x8000  /* mbuf is on the free list */
 245
 246
 247 /*
 248  * Flags copied when copying m_pkthdr.
 249  */
 250 #define M_COPYFLAGS     (M_PKTHDR|M_EOR|M_RDONLY|M_PROTO1|M_PROTO1|M_PROTO2|\
 251                             M_PROTO3|M_PROTO4|M_PROTO5|\
 252                             M_BCAST|M_MCAST|M_FRAG|M_FIRSTFRAG|M_LASTFRAG|\
 253                             M_VLANTAG|M_PROMISC)
 254
 255
 256 /*
 257  * mbuf pkthdr flags (also stored in m_flags).
 258  */
 259 #define M_BCAST         0x0200  /* send/received as link-level broadcast */
 260 #define M_MCAST         0x0400  /* send/received as link-level multicast */
 261 #define M_FRAG          0x0800  /* packet is a fragment of a larger packet */
 262 #define M_FIRSTFRAG     0x1000  /* packet is first fragment */
 263 #define M_LASTFRAG      0x2000  /* packet is last fragment */
 264 #define M_VLANTAG       0x10000 /* ether_vtag is valid */
 265 #define M_PROMISC       0x20000 /* packet was not for us */
 266 #define M_NOFREE        0x40000 /* do not free mbuf - it is embedded in the cluster */
 267
 268
 269 /*
 270  * External buffer types: identify ext_buf type.
 271  */
 272 #define EXT_CLUSTER     1       /* mbuf cluster */
 273 #define EXT_SFBUF       2       /* sendfile(2)'s sf_bufs */
 274 #define EXT_JUMBOP      3       /* jumbo cluster 4096 bytes */
 275 #define EXT_JUMBO9      4       /* jumbo cluster 9216 bytes */
 276 #define EXT_JUMBO16     5       /* jumbo cluster 16184 bytes */
 277 #define EXT_PACKET      6       /* mbuf+cluster from packet zone */
 278 #define EXT_MBUF        7       /* external mbuf reference (M_IOVEC) */
 279 #define EXT_NET_DRV     100     /* custom ext_buf provided by net driver(s) */
 280 #define EXT_MOD_TYPE    200     /* custom module's ext_buf type */
 281 #define EXT_DISPOSABLE  300     /* can throw this buffer away w/page flipping */
 282 #define EXT_EXTREF      400     /* has externally maintained ref_cnt ptr */
 283
 284
 285 /*
 286  * mbuf types.
 287  */
 288 #define MT_NOTMBUF      0       /* USED INTERNALLY ONLY! Object is not mbuf */
 289 #define MT_DATA         1       /* dynamic (data) allocation */
 290 #define MT_HEADER       MT_DATA /* packet header, use M_PKTHDR instead */
 291 #define MT_SONAME       8       /* socket name */
 292 #define MT_CONTROL      14      /* extra-data protocol message */
 293 #define MT_OOBDATA      15      /* expedited data  */
 294 #define MT_NTYPES       16      /* number of mbuf types for mbtypes[] */
 295
 296 #define MT_NOINIT       255     /* Not a type but a flag to allocate
 297                                    a non-initialized mbuf */
 298
 299 /*
 300  * __Userspace__ flags like M_NOWAIT are defined in malloc.h
 301  * Flags like these are used in functions like uma_zalloc()
 302  * but don't have an equivalent in userland umem
 303  * Flags specifying how an allocation should be made.
 304  *
 305  * The flag to use is as follows:
 306  * - M_DONTWAIT or M_NOWAIT from an interrupt handler to not block allocation.
 307  * - M_WAIT or M_WAITOK or M_TRYWAIT from wherever it is safe to block.
 308  *
 309  * M_DONTWAIT/M_NOWAIT means that we will not block the thread explicitly and
 310  * if we cannot allocate immediately we may return NULL, whereas
 311  * M_WAIT/M_WAITOK/M_TRYWAIT means that if we cannot allocate resources we
 312  * will block until they are available, and thus never return NULL.
 313  *
 314  * XXX Eventually just phase this out to use M_WAITOK/M_NOWAIT.
 315  */
 316 #define MBTOM(how)      (how)
 317
 318 void             m_tag_delete(struct mbuf *, struct m_tag *);
 319 void             m_tag_delete_chain(struct mbuf *, struct m_tag *);
 320 void             m_move_pkthdr(struct mbuf *, struct mbuf *);
 321 void             m_tag_free_default(struct m_tag *);
 322
 323 extern int max_linkhdr;    /* Largest link-level header */
 324 extern int max_protohdr; /* Size of largest protocol layer header. See user_mbuf.c */
 325
 326 /*
 327  * Evaluate TRUE if it's safe to write to the mbuf m's data region (this can
 328  * be both the local data payload, or an external buffer area, depending on
 329  * whether M_EXT is set).
 330  */
 331 #define M_WRITABLE(m)   (!((m)->m_flags & M_RDONLY) &&                  \
 332                          (!(((m)->m_flags & M_EXT)) ||                  \
 333                          (*((m)->m_ext.ref_cnt) == 1)) )                \
 334
 335
 336 /*
 337  * Compute the amount of space available before the current start of data in
 338  * an mbuf.
 339  *
 340  * The M_WRITABLE() is a temporary, conservative safety measure: the burden
 341  * of checking writability of the mbuf data area rests solely with the caller.
 342  */
 343 #define M_LEADINGSPACE(m)                                               \
 344         (((m)->m_flags & M_EXT) ?                                       \
 345             (M_WRITABLE(m) ? (m)->m_data - (m)->m_ext.ext_buf : 0):     \
 346             ((m)->m_flags & M_PKTHDR)? (m)->m_data - (m)->m_pktdat :    \
 347             (m)->m_data - (m)->m_dat)
 348
 349 /*
 350  * Compute the amount of space available after the end of data in an mbuf.
 351  *
 352  * The M_WRITABLE() is a temporary, conservative safety measure: the burden
 353  * of checking writability of the mbuf data area rests solely with the caller.
 354  */
 355 #define M_TRAILINGSPACE(m)                                              \
 356         (((m)->m_flags & M_EXT) ?                                       \
 357             (M_WRITABLE(m) ? (m)->m_ext.ext_buf + (m)->m_ext.ext_size   \
 358                 - ((m)->m_data + (m)->m_len) : 0) :                     \
 359             &(m)->m_dat[MLEN] - ((m)->m_data + (m)->m_len))
 360
 361
 362
 363 /*
 364  * Arrange to prepend space of size plen to mbuf m.  If a new mbuf must be
 365  * allocated, how specifies whether to wait.  If the allocation fails, the
 366  * original mbuf chain is freed and m is set to NULL.
 367  */
 368 #define M_PREPEND(m, plen, how) do {                                    \
 369         struct mbuf **_mmp = &(m);                                      \
 370         struct mbuf *_mm = *_mmp;                                       \
 371         int _mplen = (plen);                                            \
 372         int __mhow = (how);                                             \
 373                                                                         \
 374         if (M_LEADINGSPACE(_mm) >= _mplen) {                            \
 375                 _mm->m_data -= _mplen;                                  \
 376                 _mm->m_len += _mplen;                                   \
 377         } else                                                          \
 378                 _mm = m_prepend(_mm, _mplen, __mhow);                   \
 379         if (_mm != NULL && _mm->m_flags & M_PKTHDR)                     \
 380                 _mm->m_pkthdr.len += _mplen;                            \
 381         *_mmp = _mm;                                                    \
 382 } while (0)
 383
 384 /*
 385  * Set the m_data pointer of a newly-allocated mbuf (m_get/MGET) to place an
 386  * object of the specified size at the end of the mbuf, longword aligned.
 387  */
 388 #define M_ALIGN(m, len) do {                                            \
 389         KASSERT(!((m)->m_flags & (M_PKTHDR|M_EXT)),                     \
 390                 ("%s: M_ALIGN not normal mbuf", __func__));             \
 391         KASSERT((m)->m_data == (m)->m_dat,                              \
 392                 ("%s: M_ALIGN not a virgin mbuf", __func__));           \
 393         (m)->m_data += (MLEN - (len)) & ~(sizeof(long) - 1);            \
 394 } while (0)
 395
 396 /*
 397  * As above, for mbufs allocated with m_gethdr/MGETHDR or initialized by
 398  * M_DUP/MOVE_PKTHDR.
 399  */
 400 #define MH_ALIGN(m, len) do {                                           \
 401         KASSERT((m)->m_flags & M_PKTHDR && !((m)->m_flags & M_EXT),     \
 402                 ("%s: MH_ALIGN not PKTHDR mbuf", __func__));            \
 403         KASSERT((m)->m_data == (m)->m_pktdat,                           \
 404                 ("%s: MH_ALIGN not a virgin mbuf", __func__));          \
 405         (m)->m_data += (MHLEN - (len)) & ~(sizeof(long) - 1);           \
 406 } while (0)
 407
 408 #define M_SIZE(m)                                               \
 409                 (((m)->m_flags & M_EXT) ? (m)->m_ext.ext_size : \
 410                 ((m)->m_flags & M_PKTHDR) ? MHLEN :             \
 411                 MLEN)
 412
 413 #endif