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/kern/uipc_mbuf.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1988, 1991, 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  * 4. Neither the name of the University nor the names of its contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  *      @(#)uipc_mbuf.c 8.2 (Berkeley) 1/4/94
   30  */
   31 
   32 #include <sys/cdefs.h>
   33 __FBSDID("$FreeBSD: releng/5.4/sys/kern/uipc_mbuf.c 145335 2005-04-20 19:11:07Z cvs2svn $");
   34 
   35 #include "opt_mac.h"
   36 #include "opt_param.h"
   37 #include "opt_mbuf_stress_test.h"
   38 
   39 #include <sys/param.h>
   40 #include <sys/systm.h>
   41 #include <sys/kernel.h>
   42 #include <sys/limits.h>
   43 #include <sys/lock.h>
   44 #include <sys/mac.h>
   45 #include <sys/malloc.h>
   46 #include <sys/mbuf.h>
   47 #include <sys/sysctl.h>
   48 #include <sys/domain.h>
   49 #include <sys/protosw.h>
   50 #include <sys/uio.h>
   51 
   52 int     max_linkhdr;
   53 int     max_protohdr;
   54 int     max_hdr;
   55 int     max_datalen;
   56 #ifdef MBUF_STRESS_TEST
   57 int     m_defragpackets;
   58 int     m_defragbytes;
   59 int     m_defraguseless;
   60 int     m_defragfailure;
   61 int     m_defragrandomfailures;
   62 #endif
   63 
   64 /*
   65  * sysctl(8) exported objects
   66  */
   67 SYSCTL_DECL(_kern_ipc);
   68 SYSCTL_INT(_kern_ipc, KIPC_MAX_LINKHDR, max_linkhdr, CTLFLAG_RW,
   69            &max_linkhdr, 0, "");
   70 SYSCTL_INT(_kern_ipc, KIPC_MAX_PROTOHDR, max_protohdr, CTLFLAG_RW,
   71            &max_protohdr, 0, "");
   72 SYSCTL_INT(_kern_ipc, KIPC_MAX_HDR, max_hdr, CTLFLAG_RW, &max_hdr, 0, "");
   73 SYSCTL_INT(_kern_ipc, KIPC_MAX_DATALEN, max_datalen, CTLFLAG_RW,
   74            &max_datalen, 0, "");
   75 #ifdef MBUF_STRESS_TEST
   76 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragpackets, CTLFLAG_RD,
   77            &m_defragpackets, 0, "");
   78 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragbytes, CTLFLAG_RD,
   79            &m_defragbytes, 0, "");
   80 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defraguseless, CTLFLAG_RD,
   81            &m_defraguseless, 0, "");
   82 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragfailure, CTLFLAG_RD,
   83            &m_defragfailure, 0, "");
   84 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragrandomfailures, CTLFLAG_RW,
   85            &m_defragrandomfailures, 0, "");
   86 #endif
   87 
   88 /*
   89  * Malloc-type for external ext_buf ref counts.
   90  */
   91 MALLOC_DEFINE(M_MBUF, "mbextcnt", "mbuf external ref counts");
   92 
   93 /*
   94  * Allocate a given length worth of mbufs and/or clusters (whatever fits
   95  * best) and return a pointer to the top of the allocated chain.  If an
   96  * existing mbuf chain is provided, then we will append the new chain
   97  * to the existing one but still return the top of the newly allocated
   98  * chain.
   99  */
  100 struct mbuf *
  101 m_getm(struct mbuf *m, int len, int how, short type)
  102 {
  103         struct mbuf *mb, *top, *cur, *mtail;
  104         int num, rem;
  105         int i;
  106 
  107         KASSERT(len >= 0, ("m_getm(): len is < 0"));
  108 
  109         /* If m != NULL, we will append to the end of that chain. */
  110         if (m != NULL)
  111                 for (mtail = m; mtail->m_next != NULL; mtail = mtail->m_next);
  112         else
  113                 mtail = NULL;
  114 
  115         /*
  116          * Calculate how many mbufs+clusters ("packets") we need and how much
  117          * leftover there is after that and allocate the first mbuf+cluster
  118          * if required.
  119          */
  120         num = len / MCLBYTES;
  121         rem = len % MCLBYTES;
  122         top = cur = NULL;
  123         if (num > 0) {
  124                 if ((top = cur = m_getcl(how, type, 0)) == NULL)
  125                         goto failed;
  126                 top->m_len = 0;
  127         }
  128         num--;
  129 
  130         for (i = 0; i < num; i++) {
  131                 mb = m_getcl(how, type, 0);
  132                 if (mb == NULL)
  133                         goto failed;
  134                 mb->m_len = 0;
  135                 cur = (cur->m_next = mb);
  136         }
  137         if (rem > 0) {
  138                 mb = (rem > MINCLSIZE) ?
  139                     m_getcl(how, type, 0) : m_get(how, type);
  140                 if (mb == NULL)
  141                         goto failed;
  142                 mb->m_len = 0;
  143                 if (cur == NULL)
  144                         top = mb;
  145                 else
  146                         cur->m_next = mb;
  147         }
  148 
  149         if (mtail != NULL)
  150                 mtail->m_next = top;
  151         return top;
  152 failed:
  153         if (top != NULL)
  154                 m_freem(top);
  155         return NULL;
  156 }
  157 
  158 /*
  159  * Free an entire chain of mbufs and associated external buffers, if
  160  * applicable.
  161  */
  162 void
  163 m_freem(struct mbuf *mb)
  164 {
  165 
  166         while (mb != NULL)
  167                 mb = m_free(mb);
  168 }
  169 
  170 /*-
  171  * Configure a provided mbuf to refer to the provided external storage
  172  * buffer and setup a reference count for said buffer.  If the setting
  173  * up of the reference count fails, the M_EXT bit will not be set.  If
  174  * successfull, the M_EXT bit is set in the mbuf's flags.
  175  *
  176  * Arguments:
  177  *    mb     The existing mbuf to which to attach the provided buffer.
  178  *    buf    The address of the provided external storage buffer.
  179  *    size   The size of the provided buffer.
  180  *    freef  A pointer to a routine that is responsible for freeing the
  181  *           provided external storage buffer.
  182  *    args   A pointer to an argument structure (of any type) to be passed
  183  *           to the provided freef routine (may be NULL).
  184  *    flags  Any other flags to be passed to the provided mbuf.
  185  *    type   The type that the external storage buffer should be
  186  *           labeled with.
  187  *
  188  * Returns:
  189  *    Nothing.
  190  */
  191 void
  192 m_extadd(struct mbuf *mb, caddr_t buf, u_int size,
  193     void (*freef)(void *, void *), void *args, int flags, int type)
  194 {
  195         u_int *ref_cnt = NULL;
  196 
  197         /* XXX Shouldn't be adding EXT_CLUSTER with this API */
  198         if (type == EXT_CLUSTER)
  199                 ref_cnt = (u_int *)uma_find_refcnt(zone_clust,
  200                     mb->m_ext.ext_buf);
  201         else if (type == EXT_EXTREF)
  202                 ref_cnt = __DEVOLATILE(u_int *, mb->m_ext.ref_cnt);
  203         mb->m_ext.ref_cnt = (ref_cnt == NULL) ?
  204             malloc(sizeof(u_int), M_MBUF, M_NOWAIT) : (u_int *)ref_cnt;
  205         if (mb->m_ext.ref_cnt != NULL) {
  206                 *(mb->m_ext.ref_cnt) = 1;
  207                 mb->m_flags |= (M_EXT | flags);
  208                 mb->m_ext.ext_buf = buf;
  209                 mb->m_data = mb->m_ext.ext_buf;
  210                 mb->m_ext.ext_size = size;
  211                 mb->m_ext.ext_free = freef;
  212                 mb->m_ext.ext_args = args;
  213                 mb->m_ext.ext_type = type;
  214         }
  215 }
  216 
  217 /*
  218  * Non-directly-exported function to clean up after mbufs with M_EXT
  219  * storage attached to them if the reference count hits 0.
  220  */
  221 void
  222 mb_free_ext(struct mbuf *m)
  223 {
  224         u_int cnt;
  225         int dofree;
  226 
  227         /* Account for lazy ref count assign. */
  228         if (m->m_ext.ref_cnt == NULL)
  229                 dofree = 1;
  230         else
  231                 dofree = 0;
  232 
  233         /*
  234          * This is tricky.  We need to make sure to decrement the
  235          * refcount in a safe way but to also clean up if we're the
  236          * last reference.  This method seems to do it without race.
  237          */
  238         while (dofree == 0) {
  239                 cnt = *(m->m_ext.ref_cnt);
  240                 if (atomic_cmpset_int(m->m_ext.ref_cnt, cnt, cnt - 1)) {
  241                         if (cnt == 1)
  242                                 dofree = 1;
  243                         break;
  244                 }
  245         }
  246 
  247         if (dofree) {
  248                 /*
  249                  * Do the free, should be safe.
  250                  */
  251                 if (m->m_ext.ext_type == EXT_PACKET) {
  252                         uma_zfree(zone_pack, m);
  253                         return;
  254                 } else if (m->m_ext.ext_type == EXT_CLUSTER) {
  255                         uma_zfree(zone_clust, m->m_ext.ext_buf);
  256                         m->m_ext.ext_buf = NULL;
  257                 } else {
  258                         (*(m->m_ext.ext_free))(m->m_ext.ext_buf,
  259                             m->m_ext.ext_args);
  260                         if (m->m_ext.ext_type != EXT_EXTREF) {
  261                                 if (m->m_ext.ref_cnt != NULL)
  262                                         free(__DEVOLATILE(u_int *,
  263                                             m->m_ext.ref_cnt), M_MBUF);
  264                                 m->m_ext.ref_cnt = NULL;
  265                         }
  266                         m->m_ext.ext_buf = NULL;
  267                 }
  268         }
  269         uma_zfree(zone_mbuf, m);
  270 }
  271 
  272 /*
  273  * "Move" mbuf pkthdr from "from" to "to".
  274  * "from" must have M_PKTHDR set, and "to" must be empty.
  275  */
  276 void
  277 m_move_pkthdr(struct mbuf *to, struct mbuf *from)
  278 {
  279 
  280 #if 0
  281         /* see below for why these are not enabled */
  282         M_ASSERTPKTHDR(to);
  283         /* Note: with MAC, this may not be a good assertion. */
  284         KASSERT(SLIST_EMPTY(&to->m_pkthdr.tags),
  285             ("m_move_pkthdr: to has tags"));
  286 #endif
  287         KASSERT((to->m_flags & M_EXT) == 0, ("m_move_pkthdr: to has cluster"));
  288 #ifdef MAC
  289         /*
  290          * XXXMAC: It could be this should also occur for non-MAC?
  291          */
  292         if (to->m_flags & M_PKTHDR)
  293                 m_tag_delete_chain(to, NULL);
  294 #endif
  295         to->m_flags = from->m_flags & M_COPYFLAGS;
  296         to->m_data = to->m_pktdat;
  297         to->m_pkthdr = from->m_pkthdr;          /* especially tags */
  298         SLIST_INIT(&from->m_pkthdr.tags);       /* purge tags from src */
  299         from->m_flags &= ~M_PKTHDR;
  300 }
  301 
  302 /*
  303  * Duplicate "from"'s mbuf pkthdr in "to".
  304  * "from" must have M_PKTHDR set, and "to" must be empty.
  305  * In particular, this does a deep copy of the packet tags.
  306  */
  307 int
  308 m_dup_pkthdr(struct mbuf *to, struct mbuf *from, int how)
  309 {
  310 
  311 #if 0
  312         /*
  313          * The mbuf allocator only initializes the pkthdr
  314          * when the mbuf is allocated with MGETHDR. Many users
  315          * (e.g. m_copy*, m_prepend) use MGET and then
  316          * smash the pkthdr as needed causing these
  317          * assertions to trip.  For now just disable them.
  318          */
  319         M_ASSERTPKTHDR(to);
  320         /* Note: with MAC, this may not be a good assertion. */
  321         KASSERT(SLIST_EMPTY(&to->m_pkthdr.tags), ("m_dup_pkthdr: to has tags"));
  322 #endif
  323         MBUF_CHECKSLEEP(how);
  324 #ifdef MAC
  325         if (to->m_flags & M_PKTHDR)
  326                 m_tag_delete_chain(to, NULL);
  327 #endif
  328         to->m_flags = (from->m_flags & M_COPYFLAGS) | (to->m_flags & M_EXT);
  329         if ((to->m_flags & M_EXT) == 0)
  330                 to->m_data = to->m_pktdat;
  331         to->m_pkthdr = from->m_pkthdr;
  332         SLIST_INIT(&to->m_pkthdr.tags);
  333         return (m_tag_copy_chain(to, from, MBTOM(how)));
  334 }
  335 
  336 /*
  337  * Lesser-used path for M_PREPEND:
  338  * allocate new mbuf to prepend to chain,
  339  * copy junk along.
  340  */
  341 struct mbuf *
  342 m_prepend(struct mbuf *m, int len, int how)
  343 {
  344         struct mbuf *mn;
  345 
  346         if (m->m_flags & M_PKTHDR)
  347                 MGETHDR(mn, how, m->m_type);
  348         else
  349                 MGET(mn, how, m->m_type);
  350         if (mn == NULL) {
  351                 m_freem(m);
  352                 return (NULL);
  353         }
  354         if (m->m_flags & M_PKTHDR)
  355                 M_MOVE_PKTHDR(mn, m);
  356         mn->m_next = m;
  357         m = mn;
  358         if (len < MHLEN)
  359                 MH_ALIGN(m, len);
  360         m->m_len = len;
  361         return (m);
  362 }
  363 
  364 /*
  365  * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
  366  * continuing for "len" bytes.  If len is M_COPYALL, copy to end of mbuf.
  367  * The wait parameter is a choice of M_TRYWAIT/M_DONTWAIT from caller.
  368  * Note that the copy is read-only, because clusters are not copied,
  369  * only their reference counts are incremented.
  370  */
  371 struct mbuf *
  372 m_copym(struct mbuf *m, int off0, int len, int wait)
  373 {
  374         struct mbuf *n, **np;
  375         int off = off0;
  376         struct mbuf *top;
  377         int copyhdr = 0;
  378 
  379         KASSERT(off >= 0, ("m_copym, negative off %d", off));
  380         KASSERT(len >= 0, ("m_copym, negative len %d", len));
  381         MBUF_CHECKSLEEP(wait);
  382         if (off == 0 && m->m_flags & M_PKTHDR)
  383                 copyhdr = 1;
  384         while (off > 0) {
  385                 KASSERT(m != NULL, ("m_copym, offset > size of mbuf chain"));
  386                 if (off < m->m_len)
  387                         break;
  388                 off -= m->m_len;
  389                 m = m->m_next;
  390         }
  391         np = &top;
  392         top = 0;
  393         while (len > 0) {
  394                 if (m == NULL) {
  395                         KASSERT(len == M_COPYALL, 
  396                             ("m_copym, length > size of mbuf chain"));
  397                         break;
  398                 }
  399                 if (copyhdr)
  400                         MGETHDR(n, wait, m->m_type);
  401                 else
  402                         MGET(n, wait, m->m_type);
  403                 *np = n;
  404                 if (n == NULL)
  405                         goto nospace;
  406                 if (copyhdr) {
  407                         if (!m_dup_pkthdr(n, m, wait))
  408                                 goto nospace;
  409                         if (len == M_COPYALL)
  410                                 n->m_pkthdr.len -= off0;
  411                         else
  412                                 n->m_pkthdr.len = len;
  413                         copyhdr = 0;
  414                 }
  415                 n->m_len = min(len, m->m_len - off);
  416                 if (m->m_flags & M_EXT) {
  417                         n->m_data = m->m_data + off;
  418                         n->m_ext = m->m_ext;
  419                         n->m_flags |= M_EXT;
  420                         MEXT_ADD_REF(m);
  421                         n->m_ext.ref_cnt = m->m_ext.ref_cnt;
  422                 } else
  423                         bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
  424                             (u_int)n->m_len);
  425                 if (len != M_COPYALL)
  426                         len -= n->m_len;
  427                 off = 0;
  428                 m = m->m_next;
  429                 np = &n->m_next;
  430         }
  431         if (top == NULL)
  432                 mbstat.m_mcfail++;      /* XXX: No consistency. */
  433 
  434         return (top);
  435 nospace:
  436         m_freem(top);
  437         mbstat.m_mcfail++;      /* XXX: No consistency. */
  438         return (NULL);
  439 }
  440 
  441 /*
  442  * Copy an entire packet, including header (which must be present).
  443  * An optimization of the common case `m_copym(m, 0, M_COPYALL, how)'.
  444  * Note that the copy is read-only, because clusters are not copied,
  445  * only their reference counts are incremented.
  446  * Preserve alignment of the first mbuf so if the creator has left
  447  * some room at the beginning (e.g. for inserting protocol headers)
  448  * the copies still have the room available.
  449  */
  450 struct mbuf *
  451 m_copypacket(struct mbuf *m, int how)
  452 {
  453         struct mbuf *top, *n, *o;
  454 
  455         MBUF_CHECKSLEEP(how);
  456         MGET(n, how, m->m_type);
  457         top = n;
  458         if (n == NULL)
  459                 goto nospace;
  460 
  461         if (!m_dup_pkthdr(n, m, how))
  462                 goto nospace;
  463         n->m_len = m->m_len;
  464         if (m->m_flags & M_EXT) {
  465                 n->m_data = m->m_data;
  466                 n->m_ext = m->m_ext;
  467                 n->m_flags |= M_EXT;
  468                 MEXT_ADD_REF(m);
  469                 n->m_ext.ref_cnt = m->m_ext.ref_cnt;
  470         } else {
  471                 n->m_data = n->m_pktdat + (m->m_data - m->m_pktdat );
  472                 bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
  473         }
  474 
  475         m = m->m_next;
  476         while (m) {
  477                 MGET(o, how, m->m_type);
  478                 if (o == NULL)
  479                         goto nospace;
  480 
  481                 n->m_next = o;
  482                 n = n->m_next;
  483 
  484                 n->m_len = m->m_len;
  485                 if (m->m_flags & M_EXT) {
  486                         n->m_data = m->m_data;
  487                         n->m_ext = m->m_ext;
  488                         n->m_flags |= M_EXT;
  489                         MEXT_ADD_REF(m);
  490                         n->m_ext.ref_cnt = m->m_ext.ref_cnt;
  491                 } else {
  492                         bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
  493                 }
  494 
  495                 m = m->m_next;
  496         }
  497         return top;
  498 nospace:
  499         m_freem(top);
  500         mbstat.m_mcfail++;      /* XXX: No consistency. */ 
  501         return (NULL);
  502 }
  503 
  504 /*
  505  * Copy data from an mbuf chain starting "off" bytes from the beginning,
  506  * continuing for "len" bytes, into the indicated buffer.
  507  */
  508 void
  509 m_copydata(const struct mbuf *m, int off, int len, caddr_t cp)
  510 {
  511         u_int count;
  512 
  513         KASSERT(off >= 0, ("m_copydata, negative off %d", off));
  514         KASSERT(len >= 0, ("m_copydata, negative len %d", len));
  515         while (off > 0) {
  516                 KASSERT(m != NULL, ("m_copydata, offset > size of mbuf chain"));
  517                 if (off < m->m_len)
  518                         break;
  519                 off -= m->m_len;
  520                 m = m->m_next;
  521         }
  522         while (len > 0) {
  523                 KASSERT(m != NULL, ("m_copydata, length > size of mbuf chain"));
  524                 count = min(m->m_len - off, len);
  525                 bcopy(mtod(m, caddr_t) + off, cp, count);
  526                 len -= count;
  527                 cp += count;
  528                 off = 0;
  529                 m = m->m_next;
  530         }
  531 }
  532 
  533 /*
  534  * Copy a packet header mbuf chain into a completely new chain, including
  535  * copying any mbuf clusters.  Use this instead of m_copypacket() when
  536  * you need a writable copy of an mbuf chain.
  537  */
  538 struct mbuf *
  539 m_dup(struct mbuf *m, int how)
  540 {
  541         struct mbuf **p, *top = NULL;
  542         int remain, moff, nsize;
  543 
  544         MBUF_CHECKSLEEP(how);
  545         /* Sanity check */
  546         if (m == NULL)
  547                 return (NULL);
  548         M_ASSERTPKTHDR(m);
  549 
  550         /* While there's more data, get a new mbuf, tack it on, and fill it */
  551         remain = m->m_pkthdr.len;
  552         moff = 0;
  553         p = &top;
  554         while (remain > 0 || top == NULL) {     /* allow m->m_pkthdr.len == 0 */
  555                 struct mbuf *n;
  556 
  557                 /* Get the next new mbuf */
  558                 if (remain >= MINCLSIZE) {
  559                         n = m_getcl(how, m->m_type, 0);
  560                         nsize = MCLBYTES;
  561                 } else {
  562                         n = m_get(how, m->m_type);
  563                         nsize = MLEN;
  564                 }
  565                 if (n == NULL)
  566                         goto nospace;
  567 
  568                 if (top == NULL) {              /* First one, must be PKTHDR */
  569                         if (!m_dup_pkthdr(n, m, how)) {
  570                                 m_free(n);
  571                                 goto nospace;
  572                         }
  573                         nsize = MHLEN;
  574                 }
  575                 n->m_len = 0;
  576 
  577                 /* Link it into the new chain */
  578                 *p = n;
  579                 p = &n->m_next;
  580 
  581                 /* Copy data from original mbuf(s) into new mbuf */
  582                 while (n->m_len < nsize && m != NULL) {
  583                         int chunk = min(nsize - n->m_len, m->m_len - moff);
  584 
  585                         bcopy(m->m_data + moff, n->m_data + n->m_len, chunk);
  586                         moff += chunk;
  587                         n->m_len += chunk;
  588                         remain -= chunk;
  589                         if (moff == m->m_len) {
  590                                 m = m->m_next;
  591                                 moff = 0;
  592                         }
  593                 }
  594 
  595                 /* Check correct total mbuf length */
  596                 KASSERT((remain > 0 && m != NULL) || (remain == 0 && m == NULL),
  597                         ("%s: bogus m_pkthdr.len", __func__));
  598         }
  599         return (top);
  600 
  601 nospace:
  602         m_freem(top);
  603         mbstat.m_mcfail++;      /* XXX: No consistency. */
  604         return (NULL);
  605 }
  606 
  607 /*
  608  * Concatenate mbuf chain n to m.
  609  * Both chains must be of the same type (e.g. MT_DATA).
  610  * Any m_pkthdr is not updated.
  611  */
  612 void
  613 m_cat(struct mbuf *m, struct mbuf *n)
  614 {
  615         while (m->m_next)
  616                 m = m->m_next;
  617         while (n) {
  618                 if (m->m_flags & M_EXT ||
  619                     m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) {
  620                         /* just join the two chains */
  621                         m->m_next = n;
  622                         return;
  623                 }
  624                 /* splat the data from one into the other */
  625                 bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
  626                     (u_int)n->m_len);
  627                 m->m_len += n->m_len;
  628                 n = m_free(n);
  629         }
  630 }
  631 
  632 void
  633 m_adj(struct mbuf *mp, int req_len)
  634 {
  635         int len = req_len;
  636         struct mbuf *m;
  637         int count;
  638 
  639         if ((m = mp) == NULL)
  640                 return;
  641         if (len >= 0) {
  642                 /*
  643                  * Trim from head.
  644                  */
  645                 while (m != NULL && len > 0) {
  646                         if (m->m_len <= len) {
  647                                 len -= m->m_len;
  648                                 m->m_len = 0;
  649                                 m = m->m_next;
  650                         } else {
  651                                 m->m_len -= len;
  652                                 m->m_data += len;
  653                                 len = 0;
  654                         }
  655                 }
  656                 m = mp;
  657                 if (mp->m_flags & M_PKTHDR)
  658                         m->m_pkthdr.len -= (req_len - len);
  659         } else {
  660                 /*
  661                  * Trim from tail.  Scan the mbuf chain,
  662                  * calculating its length and finding the last mbuf.
  663                  * If the adjustment only affects this mbuf, then just
  664                  * adjust and return.  Otherwise, rescan and truncate
  665                  * after the remaining size.
  666                  */
  667                 len = -len;
  668                 count = 0;
  669                 for (;;) {
  670                         count += m->m_len;
  671                         if (m->m_next == (struct mbuf *)0)
  672                                 break;
  673                         m = m->m_next;
  674                 }
  675                 if (m->m_len >= len) {
  676                         m->m_len -= len;
  677                         if (mp->m_flags & M_PKTHDR)
  678                                 mp->m_pkthdr.len -= len;
  679                         return;
  680                 }
  681                 count -= len;
  682                 if (count < 0)
  683                         count = 0;
  684                 /*
  685                  * Correct length for chain is "count".
  686                  * Find the mbuf with last data, adjust its length,
  687                  * and toss data from remaining mbufs on chain.
  688                  */
  689                 m = mp;
  690                 if (m->m_flags & M_PKTHDR)
  691                         m->m_pkthdr.len = count;
  692                 for (; m; m = m->m_next) {
  693                         if (m->m_len >= count) {
  694                                 m->m_len = count;
  695                                 break;
  696                         }
  697                         count -= m->m_len;
  698                 }
  699                 while (m->m_next)
  700                         (m = m->m_next) ->m_len = 0;
  701         }
  702 }
  703 
  704 /*
  705  * Rearange an mbuf chain so that len bytes are contiguous
  706  * and in the data area of an mbuf (so that mtod and dtom
  707  * will work for a structure of size len).  Returns the resulting
  708  * mbuf chain on success, frees it and returns null on failure.
  709  * If there is room, it will add up to max_protohdr-len extra bytes to the
  710  * contiguous region in an attempt to avoid being called next time.
  711  */
  712 struct mbuf *
  713 m_pullup(struct mbuf *n, int len)
  714 {
  715         struct mbuf *m;
  716         int count;
  717         int space;
  718 
  719         /*
  720          * If first mbuf has no cluster, and has room for len bytes
  721          * without shifting current data, pullup into it,
  722          * otherwise allocate a new mbuf to prepend to the chain.
  723          */
  724         if ((n->m_flags & M_EXT) == 0 &&
  725             n->m_data + len < &n->m_dat[MLEN] && n->m_next) {
  726                 if (n->m_len >= len)
  727                         return (n);
  728                 m = n;
  729                 n = n->m_next;
  730                 len -= m->m_len;
  731         } else {
  732                 if (len > MHLEN)
  733                         goto bad;
  734                 MGET(m, M_DONTWAIT, n->m_type);
  735                 if (m == NULL)
  736                         goto bad;
  737                 m->m_len = 0;
  738                 if (n->m_flags & M_PKTHDR)
  739                         M_MOVE_PKTHDR(m, n);
  740         }
  741         space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
  742         do {
  743                 count = min(min(max(len, max_protohdr), space), n->m_len);
  744                 bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
  745                   (u_int)count);
  746                 len -= count;
  747                 m->m_len += count;
  748                 n->m_len -= count;
  749                 space -= count;
  750                 if (n->m_len)
  751                         n->m_data += count;
  752                 else
  753                         n = m_free(n);
  754         } while (len > 0 && n);
  755         if (len > 0) {
  756                 (void) m_free(m);
  757                 goto bad;
  758         }
  759         m->m_next = n;
  760         return (m);
  761 bad:
  762         m_freem(n);
  763         mbstat.m_mpfail++;      /* XXX: No consistency. */
  764         return (NULL);
  765 }
  766 
  767 /*
  768  * Partition an mbuf chain in two pieces, returning the tail --
  769  * all but the first len0 bytes.  In case of failure, it returns NULL and
  770  * attempts to restore the chain to its original state.
  771  *
  772  * Note that the resulting mbufs might be read-only, because the new
  773  * mbuf can end up sharing an mbuf cluster with the original mbuf if
  774  * the "breaking point" happens to lie within a cluster mbuf. Use the
  775  * M_WRITABLE() macro to check for this case.
  776  */
  777 struct mbuf *
  778 m_split(struct mbuf *m0, int len0, int wait)
  779 {
  780         struct mbuf *m, *n;
  781         u_int len = len0, remain;
  782 
  783         MBUF_CHECKSLEEP(wait);
  784         for (m = m0; m && len > m->m_len; m = m->m_next)
  785                 len -= m->m_len;
  786         if (m == NULL)
  787                 return (NULL);
  788         remain = m->m_len - len;
  789         if (m0->m_flags & M_PKTHDR) {
  790                 MGETHDR(n, wait, m0->m_type);
  791                 if (n == NULL)
  792                         return (NULL);
  793                 n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
  794                 n->m_pkthdr.len = m0->m_pkthdr.len - len0;
  795                 m0->m_pkthdr.len = len0;
  796                 if (m->m_flags & M_EXT)
  797                         goto extpacket;
  798                 if (remain > MHLEN) {
  799                         /* m can't be the lead packet */
  800                         MH_ALIGN(n, 0);
  801                         n->m_next = m_split(m, len, wait);
  802                         if (n->m_next == NULL) {
  803                                 (void) m_free(n);
  804                                 return (NULL);
  805                         } else {
  806                                 n->m_len = 0;
  807                                 return (n);
  808                         }
  809                 } else
  810                         MH_ALIGN(n, remain);
  811         } else if (remain == 0) {
  812                 n = m->m_next;
  813                 m->m_next = NULL;
  814                 return (n);
  815         } else {
  816                 MGET(n, wait, m->m_type);
  817                 if (n == NULL)
  818                         return (NULL);
  819                 M_ALIGN(n, remain);
  820         }
  821 extpacket:
  822         if (m->m_flags & M_EXT) {
  823                 n->m_flags |= M_EXT;
  824                 n->m_ext = m->m_ext;
  825                 MEXT_ADD_REF(m);
  826                 n->m_ext.ref_cnt = m->m_ext.ref_cnt;
  827                 n->m_data = m->m_data + len;
  828         } else {
  829                 bcopy(mtod(m, caddr_t) + len, mtod(n, caddr_t), remain);
  830         }
  831         n->m_len = remain;
  832         m->m_len = len;
  833         n->m_next = m->m_next;
  834         m->m_next = NULL;
  835         return (n);
  836 }
  837 /*
  838  * Routine to copy from device local memory into mbufs.
  839  * Note that `off' argument is offset into first mbuf of target chain from
  840  * which to begin copying the data to.
  841  */
  842 struct mbuf *
  843 m_devget(char *buf, int totlen, int off, struct ifnet *ifp,
  844          void (*copy)(char *from, caddr_t to, u_int len))
  845 {
  846         struct mbuf *m;
  847         struct mbuf *top = NULL, **mp = &top;
  848         int len;
  849 
  850         if (off < 0 || off > MHLEN)
  851                 return (NULL);
  852 
  853         while (totlen > 0) {
  854                 if (top == NULL) {      /* First one, must be PKTHDR */
  855                         if (totlen + off >= MINCLSIZE) {
  856                                 m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
  857                                 len = MCLBYTES;
  858                         } else {
  859                                 m = m_gethdr(M_DONTWAIT, MT_DATA);
  860                                 len = MHLEN;
  861 
  862                                 /* Place initial small packet/header at end of mbuf */
  863                                 if (m && totlen + off + max_linkhdr <= MLEN) {
  864                                         m->m_data += max_linkhdr;
  865                                         len -= max_linkhdr;
  866                                 }
  867                         }
  868                         if (m == NULL)
  869                                 return NULL;
  870                         m->m_pkthdr.rcvif = ifp;
  871                         m->m_pkthdr.len = totlen;
  872                 } else {
  873                         if (totlen + off >= MINCLSIZE) {
  874                                 m = m_getcl(M_DONTWAIT, MT_DATA, 0);
  875                                 len = MCLBYTES;
  876                         } else {
  877                                 m = m_get(M_DONTWAIT, MT_DATA);
  878                                 len = MLEN;
  879                         }
  880                         if (m == NULL) {
  881                                 m_freem(top);
  882                                 return NULL;
  883                         }
  884                 }
  885                 if (off) {
  886                         m->m_data += off;
  887                         len -= off;
  888                         off = 0;
  889                 }
  890                 m->m_len = len = min(totlen, len);
  891                 if (copy)
  892                         copy(buf, mtod(m, caddr_t), (u_int)len);
  893                 else
  894                         bcopy(buf, mtod(m, caddr_t), (u_int)len);
  895                 buf += len;
  896                 *mp = m;
  897                 mp = &m->m_next;
  898                 totlen -= len;
  899         }
  900         return (top);
  901 }
  902 
  903 /*
  904  * Copy data from a buffer back into the indicated mbuf chain,
  905  * starting "off" bytes from the beginning, extending the mbuf
  906  * chain if necessary.
  907  */
  908 void
  909 m_copyback(struct mbuf *m0, int off, int len, c_caddr_t cp)
  910 {
  911         int mlen;
  912         struct mbuf *m = m0, *n;
  913         int totlen = 0;
  914 
  915         if (m0 == NULL)
  916                 return;
  917         while (off > (mlen = m->m_len)) {
  918                 off -= mlen;
  919                 totlen += mlen;
  920                 if (m->m_next == NULL) {
  921                         n = m_get(M_DONTWAIT, m->m_type);
  922                         if (n == NULL)
  923                                 goto out;
  924                         bzero(mtod(n, caddr_t), MLEN);
  925                         n->m_len = min(MLEN, len + off);
  926                         m->m_next = n;
  927                 }
  928                 m = m->m_next;
  929         }
  930         while (len > 0) {
  931                 mlen = min (m->m_len - off, len);
  932                 bcopy(cp, off + mtod(m, caddr_t), (u_int)mlen);
  933                 cp += mlen;
  934                 len -= mlen;
  935                 mlen += off;
  936                 off = 0;
  937                 totlen += mlen;
  938                 if (len == 0)
  939                         break;
  940                 if (m->m_next == NULL) {
  941                         n = m_get(M_DONTWAIT, m->m_type);
  942                         if (n == NULL)
  943                                 break;
  944                         n->m_len = min(MLEN, len);
  945                         m->m_next = n;
  946                 }
  947                 m = m->m_next;
  948         }
  949 out:    if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
  950                 m->m_pkthdr.len = totlen;
  951 }
  952 
  953 /*
  954  * Apply function f to the data in an mbuf chain starting "off" bytes from
  955  * the beginning, continuing for "len" bytes.
  956  */
  957 int
  958 m_apply(struct mbuf *m, int off, int len,
  959     int (*f)(void *, void *, u_int), void *arg)
  960 {
  961         u_int count;
  962         int rval;
  963 
  964         KASSERT(off >= 0, ("m_apply, negative off %d", off));
  965         KASSERT(len >= 0, ("m_apply, negative len %d", len));
  966         while (off > 0) {
  967                 KASSERT(m != NULL, ("m_apply, offset > size of mbuf chain"));
  968                 if (off < m->m_len)
  969                         break;
  970                 off -= m->m_len;
  971                 m = m->m_next;
  972         }
  973         while (len > 0) {
  974                 KASSERT(m != NULL, ("m_apply, offset > size of mbuf chain"));
  975                 count = min(m->m_len - off, len);
  976                 rval = (*f)(arg, mtod(m, caddr_t) + off, count);
  977                 if (rval)
  978                         return (rval);
  979                 len -= count;
  980                 off = 0;
  981                 m = m->m_next;
  982         }
  983         return (0);
  984 }
  985 
  986 /*
  987  * Return a pointer to mbuf/offset of location in mbuf chain.
  988  */
  989 struct mbuf *
  990 m_getptr(struct mbuf *m, int loc, int *off)
  991 {
  992 
  993         while (loc >= 0) {
  994                 /* Normal end of search. */
  995                 if (m->m_len > loc) {
  996                         *off = loc;
  997                         return (m);
  998                 } else {
  999                         loc -= m->m_len;
 1000                         if (m->m_next == NULL) {
 1001                                 if (loc == 0) {
 1002                                         /* Point at the end of valid data. */
 1003                                         *off = m->m_len;
 1004                                         return (m);
 1005                                 }
 1006                                 return (NULL);
 1007                         }
 1008                         m = m->m_next;
 1009                 }
 1010         }
 1011         return (NULL);
 1012 }
 1013 
 1014 void
 1015 m_print(const struct mbuf *m, int maxlen)
 1016 {
 1017         int len;
 1018         int pdata;
 1019         const struct mbuf *m2;
 1020 
 1021         if (m->m_flags & M_PKTHDR)
 1022                 len = m->m_pkthdr.len;
 1023         else
 1024                 len = -1;
 1025         m2 = m;
 1026         while (m2 != NULL && (len == -1 || len)) {
 1027                 pdata = m2->m_len;
 1028                 if (maxlen != -1 && pdata > maxlen)
 1029                         pdata = maxlen;
 1030                 printf("mbuf: %p len: %d, next: %p, %b%s", m2, m2->m_len,
 1031                     m2->m_next, m2->m_flags, "\2\20freelist\17skipfw"
 1032                     "\11proto5\10proto4\7proto3\6proto2\5proto1\4rdonly"
 1033                     "\3eor\2pkthdr\1ext", pdata ? "" : "\n");
 1034                 if (pdata)
 1035                         printf(", %*D\n", m2->m_len, (u_char *)m2->m_data, "-");
 1036                 if (len != -1)
 1037                         len -= m2->m_len;
 1038                 m2 = m2->m_next;
 1039         }
 1040         if (len > 0)
 1041                 printf("%d bytes unaccounted for.\n", len);
 1042         return;
 1043 }
 1044 
 1045 u_int
 1046 m_fixhdr(struct mbuf *m0)
 1047 {
 1048         u_int len;
 1049 
 1050         len = m_length(m0, NULL);
 1051         m0->m_pkthdr.len = len;
 1052         return (len);
 1053 }
 1054 
 1055 u_int
 1056 m_length(struct mbuf *m0, struct mbuf **last)
 1057 {
 1058         struct mbuf *m;
 1059         u_int len;
 1060 
 1061         len = 0;
 1062         for (m = m0; m != NULL; m = m->m_next) {
 1063                 len += m->m_len;
 1064                 if (m->m_next == NULL)
 1065                         break;
 1066         }
 1067         if (last != NULL)
 1068                 *last = m;
 1069         return (len);
 1070 }
 1071 
 1072 /*
 1073  * Defragment a mbuf chain, returning the shortest possible
 1074  * chain of mbufs and clusters.  If allocation fails and
 1075  * this cannot be completed, NULL will be returned, but
 1076  * the passed in chain will be unchanged.  Upon success,
 1077  * the original chain will be freed, and the new chain
 1078  * will be returned.
 1079  *
 1080  * If a non-packet header is passed in, the original
 1081  * mbuf (chain?) will be returned unharmed.
 1082  */
 1083 struct mbuf *
 1084 m_defrag(struct mbuf *m0, int how)
 1085 {
 1086         struct mbuf *m_new = NULL, *m_final = NULL;
 1087         int progress = 0, length;
 1088 
 1089         MBUF_CHECKSLEEP(how);
 1090         if (!(m0->m_flags & M_PKTHDR))
 1091                 return (m0);
 1092 
 1093         m_fixhdr(m0); /* Needed sanity check */
 1094 
 1095 #ifdef MBUF_STRESS_TEST
 1096         if (m_defragrandomfailures) {
 1097                 int temp = arc4random() & 0xff;
 1098                 if (temp == 0xba)
 1099                         goto nospace;
 1100         }
 1101 #endif
 1102         
 1103         if (m0->m_pkthdr.len > MHLEN)
 1104                 m_final = m_getcl(how, MT_DATA, M_PKTHDR);
 1105         else
 1106                 m_final = m_gethdr(how, MT_DATA);
 1107 
 1108         if (m_final == NULL)
 1109                 goto nospace;
 1110 
 1111         if (m_dup_pkthdr(m_final, m0, how) == 0)
 1112                 goto nospace;
 1113 
 1114         m_new = m_final;
 1115 
 1116         while (progress < m0->m_pkthdr.len) {
 1117                 length = m0->m_pkthdr.len - progress;
 1118                 if (length > MCLBYTES)
 1119                         length = MCLBYTES;
 1120 
 1121                 if (m_new == NULL) {
 1122                         if (length > MLEN)
 1123                                 m_new = m_getcl(how, MT_DATA, 0);
 1124                         else
 1125                                 m_new = m_get(how, MT_DATA);
 1126                         if (m_new == NULL)
 1127                                 goto nospace;
 1128                 }
 1129 
 1130                 m_copydata(m0, progress, length, mtod(m_new, caddr_t));
 1131                 progress += length;
 1132                 m_new->m_len = length;
 1133                 if (m_new != m_final)
 1134                         m_cat(m_final, m_new);
 1135                 m_new = NULL;
 1136         }
 1137 #ifdef MBUF_STRESS_TEST
 1138         if (m0->m_next == NULL)
 1139                 m_defraguseless++;
 1140 #endif
 1141         m_freem(m0);
 1142         m0 = m_final;
 1143 #ifdef MBUF_STRESS_TEST
 1144         m_defragpackets++;
 1145         m_defragbytes += m0->m_pkthdr.len;
 1146 #endif
 1147         return (m0);
 1148 nospace:
 1149 #ifdef MBUF_STRESS_TEST
 1150         m_defragfailure++;
 1151 #endif
 1152         if (m_new)
 1153                 m_free(m_new);
 1154         if (m_final)
 1155                 m_freem(m_final);
 1156         return (NULL);
 1157 }
 1158 
 1159 #ifdef MBUF_STRESS_TEST
 1160 
 1161 /*
 1162  * Fragment an mbuf chain.  There's no reason you'd ever want to do
 1163  * this in normal usage, but it's great for stress testing various
 1164  * mbuf consumers.
 1165  *
 1166  * If fragmentation is not possible, the original chain will be
 1167  * returned.
 1168  *
 1169  * Possible length values:
 1170  * 0     no fragmentation will occur
 1171  * > 0  each fragment will be of the specified length
 1172  * -1   each fragment will be the same random value in length
 1173  * -2   each fragment's length will be entirely random
 1174  * (Random values range from 1 to 256)
 1175  */
 1176 struct mbuf *
 1177 m_fragment(struct mbuf *m0, int how, int length)
 1178 {
 1179         struct mbuf *m_new = NULL, *m_final = NULL;
 1180         int progress = 0;
 1181 
 1182         if (!(m0->m_flags & M_PKTHDR))
 1183                 return (m0);
 1184         
 1185         if ((length == 0) || (length < -2))
 1186                 return (m0);
 1187 
 1188         m_fixhdr(m0); /* Needed sanity check */
 1189 
 1190         m_final = m_getcl(how, MT_DATA, M_PKTHDR);
 1191 
 1192         if (m_final == NULL)
 1193                 goto nospace;
 1194 
 1195         if (m_dup_pkthdr(m_final, m0, how) == 0)
 1196                 goto nospace;
 1197 
 1198         m_new = m_final;
 1199 
 1200         if (length == -1)
 1201                 length = 1 + (arc4random() & 255);
 1202 
 1203         while (progress < m0->m_pkthdr.len) {
 1204                 int fraglen;
 1205 
 1206                 if (length > 0)
 1207                         fraglen = length;
 1208                 else
 1209                         fraglen = 1 + (arc4random() & 255);
 1210                 if (fraglen > m0->m_pkthdr.len - progress)
 1211                         fraglen = m0->m_pkthdr.len - progress;
 1212 
 1213                 if (fraglen > MCLBYTES)
 1214                         fraglen = MCLBYTES;
 1215 
 1216                 if (m_new == NULL) {
 1217                         m_new = m_getcl(how, MT_DATA, 0);
 1218                         if (m_new == NULL)
 1219                                 goto nospace;
 1220                 }
 1221 
 1222                 m_copydata(m0, progress, fraglen, mtod(m_new, caddr_t));
 1223                 progress += fraglen;
 1224                 m_new->m_len = fraglen;
 1225                 if (m_new != m_final)
 1226                         m_cat(m_final, m_new);
 1227                 m_new = NULL;
 1228         }
 1229         m_freem(m0);
 1230         m0 = m_final;
 1231         return (m0);
 1232 nospace:
 1233         if (m_new)
 1234                 m_free(m_new);
 1235         if (m_final)
 1236                 m_freem(m_final);
 1237         /* Return the original chain on failure */
 1238         return (m0);
 1239 }
 1240 
 1241 #endif
 1242 
 1243 struct mbuf *
 1244 m_uiotombuf(struct uio *uio, int how, int len)
 1245 {
 1246         struct mbuf *m_new = NULL, *m_final = NULL;
 1247         int progress = 0, error = 0, length, total;
 1248 
 1249         if (len > 0)
 1250                 total = min(uio->uio_resid, len);
 1251         else
 1252                 total = uio->uio_resid;
 1253         if (total > MHLEN)
 1254                 m_final = m_getcl(how, MT_DATA, M_PKTHDR);
 1255         else
 1256                 m_final = m_gethdr(how, MT_DATA);
 1257         if (m_final == NULL)
 1258                 goto nospace;
 1259         m_new = m_final;
 1260         while (progress < total) {
 1261                 length = total - progress;
 1262                 if (length > MCLBYTES)
 1263                         length = MCLBYTES;
 1264                 if (m_new == NULL) {
 1265                         if (length > MLEN)
 1266                                 m_new = m_getcl(how, MT_DATA, 0);
 1267                         else
 1268                                 m_new = m_get(how, MT_DATA);
 1269                         if (m_new == NULL)
 1270                                 goto nospace;
 1271                 }
 1272                 error = uiomove(mtod(m_new, void *), length, uio);
 1273                 if (error)
 1274                         goto nospace;
 1275                 progress += length;
 1276                 m_new->m_len = length;
 1277                 if (m_new != m_final)
 1278                         m_cat(m_final, m_new);
 1279                 m_new = NULL;
 1280         }
 1281         m_fixhdr(m_final);
 1282         return (m_final);
 1283 nospace:
 1284         if (m_new)
 1285                 m_free(m_new);
 1286         if (m_final)
 1287                 m_freem(m_final);
 1288         return (NULL);
 1289 }

Cache object: fa0a25fcc17a1a40626a11f3cc0a34de


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