sys/kern/uipc_mbuf.c

   1 /*
   2  * Copyright (c) 2004 Jeffrey M. Hsu.  All rights reserved.
   3  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to The DragonFly Project
   6  * by Jeffrey M. Hsu.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of The DragonFly Project nor the names of its
  17  *    contributors may be used to endorse or promote products derived
  18  *    from this software without specific, prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  24  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  30  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * Copyright (c) 1982, 1986, 1988, 1991, 1993
  36  *      The Regents of the University of California.  All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  * 3. All advertising materials mentioning features or use of this software
  47  *    must display the following acknowledgement:
  48  *      This product includes software developed by the University of
  49  *      California, Berkeley and its contributors.
  50  * 4. Neither the name of the University nor the names of its contributors
  51  *    may be used to endorse or promote products derived from this software
  52  *    without specific prior written permission.
  53  *
  54  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  64  * SUCH DAMAGE.
  65  *
  66  * @(#)uipc_mbuf.c      8.2 (Berkeley) 1/4/94
  67  * $FreeBSD: src/sys/kern/uipc_mbuf.c,v 1.51.2.24 2003/04/15 06:59:29 silby Exp $
  68  * $DragonFly: src/sys/kern/uipc_mbuf.c,v 1.70 2008/11/20 14:21:01 sephe Exp $
  69  */
  70
  71 #include "opt_param.h"
  72 #include "opt_mbuf_stress_test.h"
  73 #include <sys/param.h>
  74 #include <sys/systm.h>
  75 #include <sys/malloc.h>
  76 #include <sys/mbuf.h>
  77 #include <sys/kernel.h>
  78 #include <sys/sysctl.h>
  79 #include <sys/domain.h>
  80 #include <sys/objcache.h>
  81 #include <sys/tree.h>
  82 #include <sys/protosw.h>
  83 #include <sys/uio.h>
  84 #include <sys/thread.h>
  85 #include <sys/globaldata.h>
  86 #include <sys/thread2.h>
  87
  88 #include <machine/atomic.h>
  89 #include <machine/limits.h>
  90
  91 #include <vm/vm.h>
  92 #include <vm/vm_kern.h>
  93 #include <vm/vm_extern.h>
  94
  95 #ifdef INVARIANTS
  96 #include <machine/cpu.h>
  97 #endif
  98
  99 /*
 100  * mbuf cluster meta-data
 101  */
 102 struct mbcluster {
 103         int32_t mcl_refs;
 104         void    *mcl_data;
 105 };
 106
 107 /*
 108  * mbuf tracking for debugging purposes
 109  */
 110 #ifdef MBUF_DEBUG
 111
 112 static MALLOC_DEFINE(M_MTRACK, "mtrack", "mtrack");
 113
 114 struct mbctrack;
 115 RB_HEAD(mbuf_rb_tree, mbtrack);
 116 RB_PROTOTYPE2(mbuf_rb_tree, mbtrack, rb_node, mbtrack_cmp, struct mbuf *);
 117
 118 struct mbtrack {
 119         RB_ENTRY(mbtrack) rb_node;
 120         int trackid;
 121         struct mbuf *m;
 122 };
 123
 124 static int
 125 mbtrack_cmp(struct mbtrack *mb1, struct mbtrack *mb2)
 126 {
 127         if (mb1->m < mb2->m)
 128                 return(-1);
 129         if (mb1->m > mb2->m)
 130                 return(1);
 131         return(0);
 132 }
 133
 134 RB_GENERATE2(mbuf_rb_tree, mbtrack, rb_node, mbtrack_cmp, struct mbuf *, m);
 135
 136 struct mbuf_rb_tree     mbuf_track_root;
 137
 138 static void
 139 mbuftrack(struct mbuf *m)
 140 {
 141         struct mbtrack *mbt;
 142
 143         crit_enter();
 144         mbt = kmalloc(sizeof(*mbt), M_MTRACK, M_INTWAIT|M_ZERO);
 145         mbt->m = m;
 146         if (mbuf_rb_tree_RB_INSERT(&mbuf_track_root, mbt))
 147                 panic("mbuftrack: mbuf %p already being tracked\n", m);
 148         crit_exit();
 149 }
 150
 151 static void
 152 mbufuntrack(struct mbuf *m)
 153 {
 154         struct mbtrack *mbt;
 155
 156         crit_enter();
 157         mbt = mbuf_rb_tree_RB_LOOKUP(&mbuf_track_root, m);
 158         if (mbt == NULL) {
 159                 kprintf("mbufuntrack: mbuf %p was not tracked\n", m);
 160         } else {
 161                 mbuf_rb_tree_RB_REMOVE(&mbuf_track_root, mbt);
 162                 kfree(mbt, M_MTRACK);
 163         }
 164         crit_exit();
 165 }
 166
 167 void
 168 mbuftrackid(struct mbuf *m, int trackid)
 169 {
 170         struct mbtrack *mbt;
 171         struct mbuf *n;
 172
 173         crit_enter();
 174         while (m) {
 175                 n = m->m_nextpkt;
 176                 while (m) {
 177                         mbt = mbuf_rb_tree_RB_LOOKUP(&mbuf_track_root, m);
 178                         if (mbt)
 179                                 mbt->trackid = trackid;
 180                         m = m->m_next;
 181                 }
 182                 m = n;
 183         }
 184         crit_exit();
 185 }
 186
 187 static int
 188 mbuftrack_callback(struct mbtrack *mbt, void *arg)
 189 {
 190         struct sysctl_req *req = arg;
 191         char buf[64];
 192         int error;
 193
 194         ksnprintf(buf, sizeof(buf), "mbuf %p track %d\n", mbt->m, mbt->trackid);
 195
 196         error = SYSCTL_OUT(req, buf, strlen(buf));
 197         if (error)
 198                 return(-error);
 199         return(0);
 200 }
 201
 202 static int
 203 mbuftrack_show(SYSCTL_HANDLER_ARGS)
 204 {
 205         int error;
 206
 207         crit_enter();
 208         error = mbuf_rb_tree_RB_SCAN(&mbuf_track_root, NULL,
 209                                      mbuftrack_callback, req);
 210         crit_exit();
 211         return (-error);
 212 }
 213 SYSCTL_PROC(_kern_ipc, OID_AUTO, showmbufs, CTLFLAG_RD|CTLTYPE_STRING,
 214             0, 0, mbuftrack_show, "A", "Show all in-use mbufs");
 215
 216 #else
 217
 218 #define mbuftrack(m)
 219 #define mbufuntrack(m)
 220
 221 #endif
 222
 223 static void mbinit(void *);
 224 SYSINIT(mbuf, SI_BOOT2_MACHDEP, SI_ORDER_FIRST, mbinit, NULL)
 225
 226 static u_long   mbtypes[SMP_MAXCPU][MT_NTYPES];
 227
 228 static struct mbstat mbstat[SMP_MAXCPU];
 229 int     max_linkhdr;
 230 int     max_protohdr;
 231 int     max_hdr;
 232 int     max_datalen;
 233 int     m_defragpackets;
 234 int     m_defragbytes;
 235 int     m_defraguseless;
 236 int     m_defragfailure;
 237 #ifdef MBUF_STRESS_TEST
 238 int     m_defragrandomfailures;
 239 #endif
 240
 241 struct objcache *mbuf_cache, *mbufphdr_cache;
 242 struct objcache *mclmeta_cache;
 243 struct objcache *mbufcluster_cache, *mbufphdrcluster_cache;
 244
 245 int     nmbclusters;
 246 int     nmbufs;
 247
 248 SYSCTL_INT(_kern_ipc, KIPC_MAX_LINKHDR, max_linkhdr, CTLFLAG_RW,
 249            &max_linkhdr, 0, "");
 250 SYSCTL_INT(_kern_ipc, KIPC_MAX_PROTOHDR, max_protohdr, CTLFLAG_RW,
 251            &max_protohdr, 0, "");
 252 SYSCTL_INT(_kern_ipc, KIPC_MAX_HDR, max_hdr, CTLFLAG_RW, &max_hdr, 0, "");
 253 SYSCTL_INT(_kern_ipc, KIPC_MAX_DATALEN, max_datalen, CTLFLAG_RW,
 254            &max_datalen, 0, "");
 255 SYSCTL_INT(_kern_ipc, OID_AUTO, mbuf_wait, CTLFLAG_RW,
 256            &mbuf_wait, 0, "");
 257 static int do_mbstat(SYSCTL_HANDLER_ARGS);
 258
 259 SYSCTL_PROC(_kern_ipc, KIPC_MBSTAT, mbstat, CTLTYPE_STRUCT|CTLFLAG_RD,
 260         0, 0, do_mbstat, "S,mbstat", "");
 261
 262 static int do_mbtypes(SYSCTL_HANDLER_ARGS);
 263
 264 SYSCTL_PROC(_kern_ipc, OID_AUTO, mbtypes, CTLTYPE_ULONG|CTLFLAG_RD,
 265         0, 0, do_mbtypes, "LU", "");
 266
 267 static int
 268 do_mbstat(SYSCTL_HANDLER_ARGS)
 269 {
 270         struct mbstat mbstat_total;
 271         struct mbstat *mbstat_totalp;
 272         int i;
 273
 274         bzero(&mbstat_total, sizeof(mbstat_total));
 275         mbstat_totalp = &mbstat_total;
 276
 277         for (i = 0; i < ncpus; i++)
 278         {
 279                 mbstat_total.m_mbufs += mbstat[i].m_mbufs;
 280                 mbstat_total.m_clusters += mbstat[i].m_clusters;
 281                 mbstat_total.m_spare += mbstat[i].m_spare;
 282                 mbstat_total.m_clfree += mbstat[i].m_clfree;
 283                 mbstat_total.m_drops += mbstat[i].m_drops;
 284                 mbstat_total.m_wait += mbstat[i].m_wait;
 285                 mbstat_total.m_drain += mbstat[i].m_drain;
 286                 mbstat_total.m_mcfail += mbstat[i].m_mcfail;
 287                 mbstat_total.m_mpfail += mbstat[i].m_mpfail;
 288
 289         }
 290         /*
 291          * The following fields are not cumulative fields so just
 292          * get their values once.
 293          */
 294         mbstat_total.m_msize = mbstat[0].m_msize;
 295         mbstat_total.m_mclbytes = mbstat[0].m_mclbytes;
 296         mbstat_total.m_minclsize = mbstat[0].m_minclsize;
 297         mbstat_total.m_mlen = mbstat[0].m_mlen;
 298         mbstat_total.m_mhlen = mbstat[0].m_mhlen;
 299
 300         return(sysctl_handle_opaque(oidp, mbstat_totalp, sizeof(mbstat_total), req));
 301 }
 302
 303 static int
 304 do_mbtypes(SYSCTL_HANDLER_ARGS)
 305 {
 306         u_long totals[MT_NTYPES];
 307         int i, j;
 308
 309         for (i = 0; i < MT_NTYPES; i++)
 310                 totals[i] = 0;
 311
 312         for (i = 0; i < ncpus; i++)
 313         {
 314                 for (j = 0; j < MT_NTYPES; j++)
 315                         totals[j] += mbtypes[i][j];
 316         }
 317
 318         return(sysctl_handle_opaque(oidp, totals, sizeof(totals), req));
 319 }
 320
 321 /*
 322  * These are read-only because we do not currently have any code
 323  * to adjust the objcache limits after the fact.  The variables
 324  * may only be set as boot-time tunables.
 325  */
 326 SYSCTL_INT(_kern_ipc, KIPC_NMBCLUSTERS, nmbclusters, CTLFLAG_RD,
 327            &nmbclusters, 0, "Maximum number of mbuf clusters available");
 328 SYSCTL_INT(_kern_ipc, OID_AUTO, nmbufs, CTLFLAG_RD, &nmbufs, 0,
 329            "Maximum number of mbufs available");
 330
 331 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragpackets, CTLFLAG_RD,
 332            &m_defragpackets, 0, "");
 333 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragbytes, CTLFLAG_RD,
 334            &m_defragbytes, 0, "");
 335 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defraguseless, CTLFLAG_RD,
 336            &m_defraguseless, 0, "");
 337 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragfailure, CTLFLAG_RD,
 338            &m_defragfailure, 0, "");
 339 #ifdef MBUF_STRESS_TEST
 340 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragrandomfailures, CTLFLAG_RW,
 341            &m_defragrandomfailures, 0, "");
 342 #endif
 343
 344 static MALLOC_DEFINE(M_MBUF, "mbuf", "mbuf");
 345 static MALLOC_DEFINE(M_MBUFCL, "mbufcl", "mbufcl");
 346 static MALLOC_DEFINE(M_MCLMETA, "mclmeta", "mclmeta");
 347
 348 static void m_reclaim (void);
 349 static void m_mclref(void *arg);
 350 static void m_mclfree(void *arg);
 351
 352 #ifndef NMBCLUSTERS
 353 #define NMBCLUSTERS     (512 + maxusers * 16)
 354 #endif
 355 #ifndef NMBUFS
 356 #define NMBUFS          (nmbclusters * 2)
 357 #endif
 358
 359 /*
 360  * Perform sanity checks of tunables declared above.
 361  */
 362 static void
 363 tunable_mbinit(void *dummy)
 364 {
 365         /*
 366          * This has to be done before VM init.
 367          */
 368         nmbclusters = NMBCLUSTERS;
 369         TUNABLE_INT_FETCH("kern.ipc.nmbclusters", &nmbclusters);
 370         nmbufs = NMBUFS;
 371         TUNABLE_INT_FETCH("kern.ipc.nmbufs", &nmbufs);
 372         /* Sanity checks */
 373         if (nmbufs < nmbclusters * 2)
 374                 nmbufs = nmbclusters * 2;
 375 }
 376 SYSINIT(tunable_mbinit, SI_BOOT1_TUNABLES, SI_ORDER_ANY,
 377         tunable_mbinit, NULL);
 378
 379 /* "number of clusters of pages" */
 380 #define NCL_INIT        1
 381
 382 #define NMB_INIT        16
 383
 384 /*
 385  * The mbuf object cache only guarantees that m_next and m_nextpkt are
 386  * NULL and that m_data points to the beginning of the data area.  In
 387  * particular, m_len and m_pkthdr.len are uninitialized.  It is the
 388  * responsibility of the caller to initialize those fields before use.
 389  */
 390
 391 static boolean_t __inline
 392 mbuf_ctor(void *obj, void *private, int ocflags)
 393 {
 394         struct mbuf *m = obj;
 395
 396         m->m_next = NULL;
 397         m->m_nextpkt = NULL;
 398         m->m_data = m->m_dat;
 399         m->m_flags = 0;
 400
 401         return (TRUE);
 402 }
 403
 404 /*
 405  * Initialize the mbuf and the packet header fields.
 406  */
 407 static boolean_t
 408 mbufphdr_ctor(void *obj, void *private, int ocflags)
 409 {
 410         struct mbuf *m = obj;
 411
 412         m->m_next = NULL;
 413         m->m_nextpkt = NULL;
 414         m->m_data = m->m_pktdat;
 415         m->m_flags = M_PKTHDR | M_PHCACHE;
 416
 417         m->m_pkthdr.rcvif = NULL;       /* eliminate XXX JH */
 418         SLIST_INIT(&m->m_pkthdr.tags);
 419         m->m_pkthdr.csum_flags = 0;     /* eliminate XXX JH */
 420         m->m_pkthdr.fw_flags = 0;       /* eliminate XXX JH */
 421
 422         return (TRUE);
 423 }
 424
 425 /*
 426  * A mbcluster object consists of 2K (MCLBYTES) cluster and a refcount.
 427  */
 428 static boolean_t
 429 mclmeta_ctor(void *obj, void *private, int ocflags)
 430 {
 431         struct mbcluster *cl = obj;
 432         void *buf;
 433
 434         if (ocflags & M_NOWAIT)
 435                 buf = kmalloc(MCLBYTES, M_MBUFCL, M_NOWAIT | M_ZERO);
 436         else
 437                 buf = kmalloc(MCLBYTES, M_MBUFCL, M_INTWAIT | M_ZERO);
 438         if (buf == NULL)
 439                 return (FALSE);
 440         cl->mcl_refs = 0;
 441         cl->mcl_data = buf;
 442         return (TRUE);
 443 }
 444
 445 static void
 446 mclmeta_dtor(void *obj, void *private)
 447 {
 448         struct mbcluster *mcl = obj;
 449
 450         KKASSERT(mcl->mcl_refs == 0);
 451         kfree(mcl->mcl_data, M_MBUFCL);
 452 }
 453
 454 static void
 455 linkcluster(struct mbuf *m, struct mbcluster *cl)
 456 {
 457         /*
 458          * Add the cluster to the mbuf.  The caller will detect that the
 459          * mbuf now has an attached cluster.
 460          */
 461         m->m_ext.ext_arg = cl;
 462         m->m_ext.ext_buf = cl->mcl_data;
 463         m->m_ext.ext_ref = m_mclref;
 464         m->m_ext.ext_free = m_mclfree;
 465         m->m_ext.ext_size = MCLBYTES;
 466         atomic_add_int(&cl->mcl_refs, 1);
 467
 468         m->m_data = m->m_ext.ext_buf;
 469         m->m_flags |= M_EXT | M_EXT_CLUSTER;
 470 }
 471
 472 static boolean_t
 473 mbufphdrcluster_ctor(void *obj, void *private, int ocflags)
 474 {
 475         struct mbuf *m = obj;
 476         struct mbcluster *cl;
 477
 478         mbufphdr_ctor(obj, private, ocflags);
 479         cl = objcache_get(mclmeta_cache, ocflags);
 480         if (cl == NULL) {
 481                 ++mbstat[mycpu->gd_cpuid].m_drops;
 482                 return (FALSE);
 483         }
 484         m->m_flags |= M_CLCACHE;
 485         linkcluster(m, cl);
 486         return (TRUE);
 487 }
 488
 489 static boolean_t
 490 mbufcluster_ctor(void *obj, void *private, int ocflags)
 491 {
 492         struct mbuf *m = obj;
 493         struct mbcluster *cl;
 494
 495         mbuf_ctor(obj, private, ocflags);
 496         cl = objcache_get(mclmeta_cache, ocflags);
 497         if (cl == NULL) {
 498                 ++mbstat[mycpu->gd_cpuid].m_drops;
 499                 return (FALSE);
 500         }
 501         m->m_flags |= M_CLCACHE;
 502         linkcluster(m, cl);
 503         return (TRUE);
 504 }
 505
 506 /*
 507  * Used for both the cluster and cluster PHDR caches.
 508  *
 509  * The mbuf may have lost its cluster due to sharing, deal
 510  * with the situation by checking M_EXT.
 511  */
 512 static void
 513 mbufcluster_dtor(void *obj, void *private)
 514 {
 515         struct mbuf *m = obj;
 516         struct mbcluster *mcl;
 517
 518         if (m->m_flags & M_EXT) {
 519                 KKASSERT((m->m_flags & M_EXT_CLUSTER) != 0);
 520                 mcl = m->m_ext.ext_arg;
 521                 KKASSERT(mcl->mcl_refs == 1);
 522                 mcl->mcl_refs = 0;
 523                 objcache_put(mclmeta_cache, mcl);
 524         }
 525 }
 526
 527 struct objcache_malloc_args mbuf_malloc_args = { MSIZE, M_MBUF };
 528 struct objcache_malloc_args mclmeta_malloc_args =
 529         { sizeof(struct mbcluster), M_MCLMETA };
 530
 531 /* ARGSUSED*/
 532 static void
 533 mbinit(void *dummy)
 534 {
 535         int mb_limit, cl_limit;
 536         int limit;
 537         int i;
 538
 539         /*
 540          * Initialize statistics
 541          */
 542         for (i = 0; i < ncpus; i++) {
 543                 atomic_set_long_nonlocked(&mbstat[i].m_msize, MSIZE);
 544                 atomic_set_long_nonlocked(&mbstat[i].m_mclbytes, MCLBYTES);
 545                 atomic_set_long_nonlocked(&mbstat[i].m_minclsize, MINCLSIZE);
 546                 atomic_set_long_nonlocked(&mbstat[i].m_mlen, MLEN);
 547                 atomic_set_long_nonlocked(&mbstat[i].m_mhlen, MHLEN);
 548         }
 549
 550         /*
 551          * Create objtect caches and save cluster limits, which will
 552          * be used to adjust backing kmalloc pools' limit later.
 553          */
 554
 555         mb_limit = cl_limit = 0;
 556
 557         limit = nmbufs;
 558         mbuf_cache = objcache_create("mbuf", &limit, 0,
 559             mbuf_ctor, NULL, NULL,
 560             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
 561         mb_limit += limit;
 562
 563         limit = nmbufs;
 564         mbufphdr_cache = objcache_create("mbuf pkt hdr", &limit, 64,
 565             mbufphdr_ctor, NULL, NULL,
 566             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
 567         mb_limit += limit;
 568
 569         cl_limit = nmbclusters;
 570         mclmeta_cache = objcache_create("cluster mbuf", &cl_limit, 0,
 571             mclmeta_ctor, mclmeta_dtor, NULL,
 572             objcache_malloc_alloc, objcache_malloc_free, &mclmeta_malloc_args);
 573
 574         limit = nmbclusters;
 575         mbufcluster_cache = objcache_create("mbuf + cluster", &limit, 0,
 576             mbufcluster_ctor, mbufcluster_dtor, NULL,
 577             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
 578         mb_limit += limit;
 579
 580         limit = nmbclusters;
 581         mbufphdrcluster_cache = objcache_create("mbuf pkt hdr + cluster",
 582             &limit, 64, mbufphdrcluster_ctor, mbufcluster_dtor, NULL,
 583             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
 584         mb_limit += limit;
 585
 586         /*
 587          * Adjust backing kmalloc pools' limit
 588          *
 589          * NOTE: We raise the limit by another 1/8 to take the effect
 590          * of loosememuse into account.
 591          */
 592         cl_limit += cl_limit / 8;
 593         kmalloc_raise_limit(mclmeta_malloc_args.mtype,
 594                             mclmeta_malloc_args.objsize * cl_limit);
 595         kmalloc_raise_limit(M_MBUFCL, MCLBYTES * cl_limit);
 596
 597         mb_limit += mb_limit / 8;
 598         kmalloc_raise_limit(mbuf_malloc_args.mtype,
 599                             mbuf_malloc_args.objsize * mb_limit);
 600 }
 601
 602 /*
 603  * Return the number of references to this mbuf's data.  0 is returned
 604  * if the mbuf is not M_EXT, a reference count is returned if it is
 605  * M_EXT | M_EXT_CLUSTER, and 99 is returned if it is a special M_EXT.
 606  */
 607 int
 608 m_sharecount(struct mbuf *m)
 609 {
 610         switch (m->m_flags & (M_EXT | M_EXT_CLUSTER)) {
 611         case 0:
 612                 return (0);
 613         case M_EXT:
 614                 return (99);
 615         case M_EXT | M_EXT_CLUSTER:
 616                 return (((struct mbcluster *)m->m_ext.ext_arg)->mcl_refs);
 617         }
 618         /* NOTREACHED */
 619         return (0);             /* to shut up compiler */
 620 }
 621
 622 /*
 623  * change mbuf to new type
 624  */
 625 void
 626 m_chtype(struct mbuf *m, int type)
 627 {
 628         struct globaldata *gd = mycpu;
 629
 630         atomic_add_long_nonlocked(&mbtypes[gd->gd_cpuid][type], 1);
 631         atomic_subtract_long_nonlocked(&mbtypes[gd->gd_cpuid][m->m_type], 1);
 632         atomic_set_short_nonlocked(&m->m_type, type);
 633 }
 634
 635 static void
 636 m_reclaim(void)
 637 {
 638         struct domain *dp;
 639         struct protosw *pr;
 640
 641         crit_enter();
 642         SLIST_FOREACH(dp, &domains, dom_next) {
 643                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
 644                         if (pr->pr_drain)
 645                                 (*pr->pr_drain)();
 646                 }
 647         }
 648         crit_exit();
 649         atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_drain, 1);
 650 }
 651
 652 static void __inline
 653 updatestats(struct mbuf *m, int type)
 654 {
 655         struct globaldata *gd = mycpu;
 656         m->m_type = type;
 657
 658         mbuftrack(m);
 659
 660         atomic_add_long_nonlocked(&mbtypes[gd->gd_cpuid][type], 1);
 661         atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_mbufs, 1);
 662
 663 }
 664
 665 /*
 666  * Allocate an mbuf.
 667  */
 668 struct mbuf *
 669 m_get(int how, int type)
 670 {
 671         struct mbuf *m;
 672         int ntries = 0;
 673         int ocf = MBTOM(how);
 674
 675 retryonce:
 676
 677         m = objcache_get(mbuf_cache, ocf);
 678
 679         if (m == NULL) {
 680                 if ((how & MB_TRYWAIT) && ntries++ == 0) {
 681                         struct objcache *reclaimlist[] = {
 682                                 mbufphdr_cache,
 683                                 mbufcluster_cache, mbufphdrcluster_cache
 684                         };
 685                         const int nreclaims = __arysize(reclaimlist);
 686
 687                         if (!objcache_reclaimlist(reclaimlist, nreclaims, ocf))
 688                                 m_reclaim();
 689                         goto retryonce;
 690                 }
 691                 ++mbstat[mycpu->gd_cpuid].m_drops;
 692                 return (NULL);
 693         }
 694
 695         updatestats(m, type);
 696         return (m);
 697 }
 698
 699 struct mbuf *
 700 m_gethdr(int how, int type)
 701 {
 702         struct mbuf *m;
 703         int ocf = MBTOM(how);
 704         int ntries = 0;
 705
 706 retryonce:
 707
 708         m = objcache_get(mbufphdr_cache, ocf);
 709
 710         if (m == NULL) {
 711                 if ((how & MB_TRYWAIT) && ntries++ == 0) {
 712                         struct objcache *reclaimlist[] = {
 713                                 mbuf_cache,
 714                                 mbufcluster_cache, mbufphdrcluster_cache
 715                         };
 716                         const int nreclaims = __arysize(reclaimlist);
 717
 718                         if (!objcache_reclaimlist(reclaimlist, nreclaims, ocf))
 719                                 m_reclaim();
 720                         goto retryonce;
 721                 }
 722                 ++mbstat[mycpu->gd_cpuid].m_drops;
 723                 return (NULL);
 724         }
 725
 726         updatestats(m, type);
 727         return (m);
 728 }
 729
 730 /*
 731  * Get a mbuf (not a mbuf cluster!) and zero it.
 732  * Deprecated.
 733  */
 734 struct mbuf *
 735 m_getclr(int how, int type)
 736 {
 737         struct mbuf *m;
 738
 739         m = m_get(how, type);
 740         if (m != NULL)
 741                 bzero(m->m_data, MLEN);
 742         return (m);
 743 }
 744
 745 /*
 746  * Returns an mbuf with an attached cluster.
 747  * Because many network drivers use this kind of buffers a lot, it is
 748  * convenient to keep a small pool of free buffers of this kind.
 749  * Even a small size such as 10 gives about 10% improvement in the
 750  * forwarding rate in a bridge or router.
 751  */
 752 struct mbuf *
 753 m_getcl(int how, short type, int flags)
 754 {
 755         struct mbuf *m;
 756         int ocflags = MBTOM(how);
 757         int ntries = 0;
 758
 759 retryonce:
 760
 761         if (flags & M_PKTHDR)
 762                 m = objcache_get(mbufphdrcluster_cache, ocflags);
 763         else
 764                 m = objcache_get(mbufcluster_cache, ocflags);
 765
 766         if (m == NULL) {
 767                 if ((how & MB_TRYWAIT) && ntries++ == 0) {
 768                         struct objcache *reclaimlist[1];
 769
 770                         if (flags & M_PKTHDR)
 771                                 reclaimlist[0] = mbufcluster_cache;
 772                         else
 773                                 reclaimlist[0] = mbufphdrcluster_cache;
 774                         if (!objcache_reclaimlist(reclaimlist, 1, ocflags))
 775                                 m_reclaim();
 776                         goto retryonce;
 777                 }
 778                 ++mbstat[mycpu->gd_cpuid].m_drops;
 779                 return (NULL);
 780         }
 781
 782         m->m_type = type;
 783
 784         mbuftrack(m);
 785
 786         atomic_add_long_nonlocked(&mbtypes[mycpu->gd_cpuid][type], 1);
 787         atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_clusters, 1);
 788         return (m);
 789 }
 790
 791 /*
 792  * Allocate chain of requested length.
 793  */
 794 struct mbuf *
 795 m_getc(int len, int how, int type)
 796 {
 797         struct mbuf *n, *nfirst = NULL, **ntail = &nfirst;
 798         int nsize;
 799
 800         while (len > 0) {
 801                 n = m_getl(len, how, type, 0, &nsize);
 802                 if (n == NULL)
 803                         goto failed;
 804                 n->m_len = 0;
 805                 *ntail = n;
 806                 ntail = &n->m_next;
 807                 len -= nsize;
 808         }
 809         return (nfirst);
 810
 811 failed:
 812         m_freem(nfirst);
 813         return (NULL);
 814 }
 815
 816 /*
 817  * Allocate len-worth of mbufs and/or mbuf clusters (whatever fits best)
 818  * and return a pointer to the head of the allocated chain. If m0 is
 819  * non-null, then we assume that it is a single mbuf or an mbuf chain to
 820  * which we want len bytes worth of mbufs and/or clusters attached, and so
 821  * if we succeed in allocating it, we will just return a pointer to m0.
 822  *
 823  * If we happen to fail at any point during the allocation, we will free
 824  * up everything we have already allocated and return NULL.
 825  *
 826  * Deprecated.  Use m_getc() and m_cat() instead.
 827  */
 828 struct mbuf *
 829 m_getm(struct mbuf *m0, int len, int type, int how)
 830 {
 831         struct mbuf *nfirst;
 832
 833         nfirst = m_getc(len, how, type);
 834
 835         if (m0 != NULL) {
 836                 m_last(m0)->m_next = nfirst;
 837                 return (m0);
 838         }
 839
 840         return (nfirst);
 841 }
 842
 843 /*
 844  * Adds a cluster to a normal mbuf, M_EXT is set on success.
 845  * Deprecated.  Use m_getcl() instead.
 846  */
 847 void
 848 m_mclget(struct mbuf *m, int how)
 849 {
 850         struct mbcluster *mcl;
 851
 852         KKASSERT((m->m_flags & M_EXT) == 0);
 853         mcl = objcache_get(mclmeta_cache, MBTOM(how));
 854         if (mcl != NULL) {
 855                 linkcluster(m, mcl);
 856                 atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_clusters, 1);
 857         } else {
 858                 ++mbstat[mycpu->gd_cpuid].m_drops;
 859         }
 860 }
 861
 862 /*
 863  * Updates to mbcluster must be MPSAFE.  Only an entity which already has
 864  * a reference to the cluster can ref it, so we are in no danger of
 865  * racing an add with a subtract.  But the operation must still be atomic
 866  * since multiple entities may have a reference on the cluster.
 867  *
 868  * m_mclfree() is almost the same but it must contend with two entities
 869  * freeing the cluster at the same time.  If there is only one reference
 870  * count we are the only entity referencing the cluster and no further
 871  * locking is required.  Otherwise we must protect against a race to 0
 872  * with the serializer.
 873  */
 874 static void
 875 m_mclref(void *arg)
 876 {
 877         struct mbcluster *mcl = arg;
 878
 879         atomic_add_int(&mcl->mcl_refs, 1);
 880 }
 881
 882 /*
 883  * When dereferencing a cluster we have to deal with a N->0 race, where
 884  * N entities free their references simultaniously.  To do this we use
 885  * atomic_fetchadd_int().
 886  */
 887 static void
 888 m_mclfree(void *arg)
 889 {
 890         struct mbcluster *mcl = arg;
 891
 892         if (atomic_fetchadd_int(&mcl->mcl_refs, -1) == 1)
 893                 objcache_put(mclmeta_cache, mcl);
 894 }
 895
 896 /*
 897  * Free a single mbuf and any associated external storage.  The successor,
 898  * if any, is returned.
 899  *
 900  * We do need to check non-first mbuf for m_aux, since some of existing
 901  * code does not call M_PREPEND properly.
 902  * (example: call to bpf_mtap from drivers)
 903  */
 904 struct mbuf *
 905 m_free(struct mbuf *m)
 906 {
 907         struct mbuf *n;
 908         struct globaldata *gd = mycpu;
 909
 910         KASSERT(m->m_type != MT_FREE, ("freeing free mbuf %p", m));
 911         atomic_subtract_long_nonlocked(&mbtypes[gd->gd_cpuid][m->m_type], 1);
 912
 913         n = m->m_next;
 914
 915         /*
 916          * Make sure the mbuf is in constructed state before returning it
 917          * to the objcache.
 918          */
 919         m->m_next = NULL;
 920         mbufuntrack(m);
 921 #ifdef notyet
 922         KKASSERT(m->m_nextpkt == NULL);
 923 #else
 924         if (m->m_nextpkt != NULL) {
 925                 static int afewtimes = 10;
 926
 927                 if (afewtimes-- > 0) {
 928                         kprintf("mfree: m->m_nextpkt != NULL\n");
 929                         print_backtrace();
 930                 }
 931                 m->m_nextpkt = NULL;
 932         }
 933 #endif
 934         if (m->m_flags & M_PKTHDR) {
 935                 m_tag_delete_chain(m);          /* eliminate XXX JH */
 936         }
 937
 938         m->m_flags &= (M_EXT | M_EXT_CLUSTER | M_CLCACHE | M_PHCACHE);
 939
 940         /*
 941          * Clean the M_PKTHDR state so we can return the mbuf to its original
 942          * cache.  This is based on the PHCACHE flag which tells us whether
 943          * the mbuf was originally allocated out of a packet-header cache
 944          * or a non-packet-header cache.
 945          */
 946         if (m->m_flags & M_PHCACHE) {
 947                 m->m_flags |= M_PKTHDR;
 948                 m->m_pkthdr.rcvif = NULL;       /* eliminate XXX JH */
 949                 m->m_pkthdr.csum_flags = 0;     /* eliminate XXX JH */
 950                 m->m_pkthdr.fw_flags = 0;       /* eliminate XXX JH */
 951                 SLIST_INIT(&m->m_pkthdr.tags);
 952         }
 953
 954         /*
 955          * Handle remaining flags combinations.  M_CLCACHE tells us whether
 956          * the mbuf was originally allocated from a cluster cache or not,
 957          * and is totally separate from whether the mbuf is currently
 958          * associated with a cluster.
 959          */
 960         crit_enter();
 961         switch(m->m_flags & (M_CLCACHE | M_EXT | M_EXT_CLUSTER)) {
 962         case M_CLCACHE | M_EXT | M_EXT_CLUSTER:
 963                 /*
 964                  * mbuf+cluster cache case.  The mbuf was allocated from the
 965                  * combined mbuf_cluster cache and can be returned to the
 966                  * cache if the cluster hasn't been shared.
 967                  */
 968                 if (m_sharecount(m) == 1) {
 969                         /*
 970                          * The cluster has not been shared, we can just
 971                          * reset the data pointer and return the mbuf
 972                          * to the cluster cache.  Note that the reference
 973                          * count is left intact (it is still associated with
 974                          * an mbuf).
 975                          */
 976                         m->m_data = m->m_ext.ext_buf;
 977                         if (m->m_flags & M_PHCACHE)
 978                                 objcache_put(mbufphdrcluster_cache, m);
 979                         else
 980                                 objcache_put(mbufcluster_cache, m);
 981                         atomic_subtract_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_clusters, 1);
 982                 } else {
 983                         /*
 984                          * Hell.  Someone else has a ref on this cluster,
 985                          * we have to disconnect it which means we can't
 986                          * put it back into the mbufcluster_cache, we
 987                          * have to destroy the mbuf.
 988                          *
 989                          * Other mbuf references to the cluster will typically
 990                          * be M_EXT | M_EXT_CLUSTER but without M_CLCACHE.
 991                          *
 992                          * XXX we could try to connect another cluster to
 993                          * it.
 994                          */
 995                         m->m_ext.ext_free(m->m_ext.ext_arg);
 996                         m->m_flags &= ~(M_EXT | M_EXT_CLUSTER);
 997                         if (m->m_flags & M_PHCACHE)
 998                                 objcache_dtor(mbufphdrcluster_cache, m);
 999                         else
1000                                 objcache_dtor(mbufcluster_cache, m);
1001                 }
1002                 break;
1003         case M_EXT | M_EXT_CLUSTER:
1004                 /*
1005                  * Normal cluster associated with an mbuf that was allocated
1006                  * from the normal mbuf pool rather then the cluster pool.
1007                  * The cluster has to be independantly disassociated from the
1008                  * mbuf.
1009                  */
1010                 if (m_sharecount(m) == 1)
1011                         atomic_subtract_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_clusters, 1);
1012                 /* fall through */
1013         case M_EXT:
1014                 /*
1015                  * Normal cluster association case, disconnect the cluster from
1016                  * the mbuf.  The cluster may or may not be custom.
1017                  */
1018                 m->m_ext.ext_free(m->m_ext.ext_arg);
1019                 m->m_flags &= ~(M_EXT | M_EXT_CLUSTER);
1020                 /* fall through */
1021         case 0:
1022                 /*
1023                  * return the mbuf to the mbuf cache.
1024                  */
1025                 if (m->m_flags & M_PHCACHE) {
1026                         m->m_data = m->m_pktdat;
1027                         objcache_put(mbufphdr_cache, m);
1028                 } else {
1029                         m->m_data = m->m_dat;
1030                         objcache_put(mbuf_cache, m);
1031                 }
1032                 atomic_subtract_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_mbufs, 1);
1033                 break;
1034         default:
1035                 if (!panicstr)
1036                         panic("bad mbuf flags %p %08x\n", m, m->m_flags);
1037                 break;
1038         }
1039         crit_exit();
1040         return (n);
1041 }
1042
1043 void
1044 m_freem(struct mbuf *m)
1045 {
1046         crit_enter();
1047         while (m)
1048                 m = m_free(m);
1049         crit_exit();
1050 }
1051
1052 /*
1053  * mbuf utility routines
1054  */
1055
1056 /*
1057  * Lesser-used path for M_PREPEND: allocate new mbuf to prepend to chain and
1058  * copy junk along.
1059  */
1060 struct mbuf *
1061 m_prepend(struct mbuf *m, int len, int how)
1062 {
1063         struct mbuf *mn;
1064
1065         if (m->m_flags & M_PKTHDR)
1066             mn = m_gethdr(how, m->m_type);
1067         else
1068             mn = m_get(how, m->m_type);
1069         if (mn == NULL) {
1070                 m_freem(m);
1071                 return (NULL);
1072         }
1073         if (m->m_flags & M_PKTHDR)
1074                 M_MOVE_PKTHDR(mn, m);
1075         mn->m_next = m;
1076         m = mn;
1077         if (len < MHLEN)
1078                 MH_ALIGN(m, len);
1079         m->m_len = len;
1080         return (m);
1081 }
1082
1083 /*
1084  * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
1085  * continuing for "len" bytes.  If len is M_COPYALL, copy to end of mbuf.
1086  * The wait parameter is a choice of MB_WAIT/MB_DONTWAIT from caller.
1087  * Note that the copy is read-only, because clusters are not copied,
1088  * only their reference counts are incremented.
1089  */
1090 struct mbuf *
1091 m_copym(const struct mbuf *m, int off0, int len, int wait)
1092 {
1093         struct mbuf *n, **np;
1094         int off = off0;
1095         struct mbuf *top;
1096         int copyhdr = 0;
1097
1098         KASSERT(off >= 0, ("m_copym, negative off %d", off));
1099         KASSERT(len >= 0, ("m_copym, negative len %d", len));
1100         if (off == 0 && m->m_flags & M_PKTHDR)
1101                 copyhdr = 1;
1102         while (off > 0) {
1103                 KASSERT(m != NULL, ("m_copym, offset > size of mbuf chain"));
1104                 if (off < m->m_len)
1105                         break;
1106                 off -= m->m_len;
1107                 m = m->m_next;
1108         }
1109         np = &top;
1110         top = 0;
1111         while (len > 0) {
1112                 if (m == NULL) {
1113                         KASSERT(len == M_COPYALL,
1114                             ("m_copym, length > size of mbuf chain"));
1115                         break;
1116                 }
1117                 /*
1118                  * Because we are sharing any cluster attachment below,
1119                  * be sure to get an mbuf that does not have a cluster
1120                  * associated with it.
1121                  */
1122                 if (copyhdr)
1123                         n = m_gethdr(wait, m->m_type);
1124                 else
1125                         n = m_get(wait, m->m_type);
1126                 *np = n;
1127                 if (n == NULL)
1128                         goto nospace;
1129                 if (copyhdr) {
1130                         if (!m_dup_pkthdr(n, m, wait))
1131                                 goto nospace;
1132                         if (len == M_COPYALL)
1133                                 n->m_pkthdr.len -= off0;
1134                         else
1135                                 n->m_pkthdr.len = len;
1136                         copyhdr = 0;
1137                 }
1138                 n->m_len = min(len, m->m_len - off);
1139                 if (m->m_flags & M_EXT) {
1140                         KKASSERT((n->m_flags & M_EXT) == 0);
1141                         n->m_data = m->m_data + off;
1142                         m->m_ext.ext_ref(m->m_ext.ext_arg);
1143                         n->m_ext = m->m_ext;
1144                         n->m_flags |= m->m_flags & (M_EXT | M_EXT_CLUSTER);
1145                 } else {
1146                         bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
1147                             (unsigned)n->m_len);
1148                 }
1149                 if (len != M_COPYALL)
1150                         len -= n->m_len;
1151                 off = 0;
1152                 m = m->m_next;
1153                 np = &n->m_next;
1154         }
1155         if (top == NULL)
1156                 atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_mcfail, 1);
1157         return (top);
1158 nospace:
1159         m_freem(top);
1160         atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_mcfail, 1);
1161         return (NULL);
1162 }
1163
1164 /*
1165  * Copy an entire packet, including header (which must be present).
1166  * An optimization of the common case `m_copym(m, 0, M_COPYALL, how)'.
1167  * Note that the copy is read-only, because clusters are not copied,
1168  * only their reference counts are incremented.
1169  * Preserve alignment of the first mbuf so if the creator has left
1170  * some room at the beginning (e.g. for inserting protocol headers)
1171  * the copies also have the room available.
1172  */
1173 struct mbuf *
1174 m_copypacket(struct mbuf *m, int how)
1175 {
1176         struct mbuf *top, *n, *o;
1177
1178         n = m_gethdr(how, m->m_type);
1179         top = n;
1180         if (!n)
1181                 goto nospace;
1182
1183         if (!m_dup_pkthdr(n, m, how))
1184                 goto nospace;
1185         n->m_len = m->m_len;
1186         if (m->m_flags & M_EXT) {
1187                 KKASSERT((n->m_flags & M_EXT) == 0);
1188                 n->m_data = m->m_data;
1189                 m->m_ext.ext_ref(m->m_ext.ext_arg);
1190                 n->m_ext = m->m_ext;
1191                 n->m_flags |= m->m_flags & (M_EXT | M_EXT_CLUSTER);
1192         } else {
1193                 n->m_data = n->m_pktdat + (m->m_data - m->m_pktdat );
1194                 bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
1195         }
1196
1197         m = m->m_next;
1198         while (m) {
1199                 o = m_get(how, m->m_type);
1200                 if (!o)
1201                         goto nospace;
1202
1203                 n->m_next = o;
1204                 n = n->m_next;
1205
1206                 n->m_len = m->m_len;
1207                 if (m->m_flags & M_EXT) {
1208                         KKASSERT((n->m_flags & M_EXT) == 0);
1209                         n->m_data = m->m_data;
1210                         m->m_ext.ext_ref(m->m_ext.ext_arg);
1211                         n->m_ext = m->m_ext;
1212                         n->m_flags |= m->m_flags & (M_EXT | M_EXT_CLUSTER);
1213                 } else {
1214                         bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
1215                 }
1216
1217                 m = m->m_next;
1218         }
1219         return top;
1220 nospace:
1221         m_freem(top);
1222         atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_mcfail, 1);
1223         return (NULL);
1224 }
1225
1226 /*
1227  * Copy data from an mbuf chain starting "off" bytes from the beginning,
1228  * continuing for "len" bytes, into the indicated buffer.
1229  */
1230 void
1231 m_copydata(const struct mbuf *m, int off, int len, caddr_t cp)
1232 {
1233         unsigned count;
1234
1235         KASSERT(off >= 0, ("m_copydata, negative off %d", off));
1236         KASSERT(len >= 0, ("m_copydata, negative len %d", len));
1237         while (off > 0) {
1238                 KASSERT(m != NULL, ("m_copydata, offset > size of mbuf chain"));
1239                 if (off < m->m_len)
1240                         break;
1241                 off -= m->m_len;
1242                 m = m->m_next;
1243         }
1244         while (len > 0) {
1245                 KASSERT(m != NULL, ("m_copydata, length > size of mbuf chain"));
1246                 count = min(m->m_len - off, len);
1247                 bcopy(mtod(m, caddr_t) + off, cp, count);
1248                 len -= count;
1249                 cp += count;
1250                 off = 0;
1251                 m = m->m_next;
1252         }
1253 }
1254
1255 /*
1256  * Copy a packet header mbuf chain into a completely new chain, including
1257  * copying any mbuf clusters.  Use this instead of m_copypacket() when
1258  * you need a writable copy of an mbuf chain.
1259  */
1260 struct mbuf *
1261 m_dup(struct mbuf *m, int how)
1262 {
1263         struct mbuf **p, *top = NULL;
1264         int remain, moff, nsize;
1265
1266         /* Sanity check */
1267         if (m == NULL)
1268                 return (NULL);
1269         KASSERT((m->m_flags & M_PKTHDR) != 0, ("%s: !PKTHDR", __func__));
1270
1271         /* While there's more data, get a new mbuf, tack it on, and fill it */
1272         remain = m->m_pkthdr.len;
1273         moff = 0;
1274         p = &top;
1275         while (remain > 0 || top == NULL) {     /* allow m->m_pkthdr.len == 0 */
1276                 struct mbuf *n;
1277
1278                 /* Get the next new mbuf */
1279                 n = m_getl(remain, how, m->m_type, top == NULL ? M_PKTHDR : 0,
1280                            &nsize);
1281                 if (n == NULL)
1282                         goto nospace;
1283                 if (top == NULL)
1284                         if (!m_dup_pkthdr(n, m, how))
1285                                 goto nospace0;
1286
1287                 /* Link it into the new chain */
1288                 *p = n;
1289                 p = &n->m_next;
1290
1291                 /* Copy data from original mbuf(s) into new mbuf */
1292                 n->m_len = 0;
1293                 while (n->m_len < nsize && m != NULL) {
1294                         int chunk = min(nsize - n->m_len, m->m_len - moff);
1295
1296                         bcopy(m->m_data + moff, n->m_data + n->m_len, chunk);
1297                         moff += chunk;
1298                         n->m_len += chunk;
1299                         remain -= chunk;
1300                         if (moff == m->m_len) {
1301                                 m = m->m_next;
1302                                 moff = 0;
1303                         }
1304                 }
1305
1306                 /* Check correct total mbuf length */
1307                 KASSERT((remain > 0 && m != NULL) || (remain == 0 && m == NULL),
1308                         ("%s: bogus m_pkthdr.len", __func__));
1309         }
1310         return (top);
1311
1312 nospace:
1313         m_freem(top);
1314 nospace0:
1315         atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_mcfail, 1);
1316         return (NULL);
1317 }
1318
1319 /*
1320  * Concatenate mbuf chain n to m.
1321  * Both chains must be of the same type (e.g. MT_DATA).
1322  * Any m_pkthdr is not updated.
1323  */
1324 void
1325 m_cat(struct mbuf *m, struct mbuf *n)
1326 {
1327         m = m_last(m);
1328         while (n) {
1329                 if (m->m_flags & M_EXT ||
1330                     m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) {
1331                         /* just join the two chains */
1332                         m->m_next = n;
1333                         return;
1334                 }
1335                 /* splat the data from one into the other */
1336                 bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
1337                     (u_int)n->m_len);
1338                 m->m_len += n->m_len;
1339                 n = m_free(n);
1340         }
1341 }
1342
1343 void
1344 m_adj(struct mbuf *mp, int req_len)
1345 {
1346         int len = req_len;
1347         struct mbuf *m;
1348         int count;
1349
1350         if ((m = mp) == NULL)
1351                 return;
1352         if (len >= 0) {
1353                 /*
1354                  * Trim from head.
1355                  */
1356                 while (m != NULL && len > 0) {
1357                         if (m->m_len <= len) {
1358                                 len -= m->m_len;
1359                                 m->m_len = 0;
1360                                 m = m->m_next;
1361                         } else {
1362                                 m->m_len -= len;
1363                                 m->m_data += len;
1364                                 len = 0;
1365                         }
1366                 }
1367                 m = mp;
1368                 if (mp->m_flags & M_PKTHDR)
1369                         m->m_pkthdr.len -= (req_len - len);
1370         } else {
1371                 /*
1372                  * Trim from tail.  Scan the mbuf chain,
1373                  * calculating its length and finding the last mbuf.
1374                  * If the adjustment only affects this mbuf, then just
1375                  * adjust and return.  Otherwise, rescan and truncate
1376                  * after the remaining size.
1377                  */
1378                 len = -len;
1379                 count = 0;
1380                 for (;;) {
1381                         count += m->m_len;
1382                         if (m->m_next == NULL)
1383                                 break;
1384                         m = m->m_next;
1385                 }
1386                 if (m->m_len >= len) {
1387                         m->m_len -= len;
1388                         if (mp->m_flags & M_PKTHDR)
1389                                 mp->m_pkthdr.len -= len;
1390                         return;
1391                 }
1392                 count -= len;
1393                 if (count < 0)
1394                         count = 0;
1395                 /*
1396                  * Correct length for chain is "count".
1397                  * Find the mbuf with last data, adjust its length,
1398                  * and toss data from remaining mbufs on chain.
1399                  */
1400                 m = mp;
1401                 if (m->m_flags & M_PKTHDR)
1402                         m->m_pkthdr.len = count;
1403                 for (; m; m = m->m_next) {
1404                         if (m->m_len >= count) {
1405                                 m->m_len = count;
1406                                 break;
1407                         }
1408                         count -= m->m_len;
1409                 }
1410                 while (m->m_next)
1411                         (m = m->m_next) ->m_len = 0;
1412         }
1413 }
1414
1415 /*
1416  * Set the m_data pointer of a newly-allocated mbuf
1417  * to place an object of the specified size at the
1418  * end of the mbuf, longword aligned.
1419  */
1420 void
1421 m_align(struct mbuf *m, int len)
1422 {
1423         int adjust;
1424
1425         if (m->m_flags & M_EXT)
1426                 adjust = m->m_ext.ext_size - len;
1427         else if (m->m_flags & M_PKTHDR)
1428                 adjust = MHLEN - len;
1429         else
1430                 adjust = MLEN - len;
1431         m->m_data += adjust &~ (sizeof(long)-1);
1432 }
1433
1434 /*
1435  * Rearrange an mbuf chain so that len bytes are contiguous
1436  * and in the data area of an mbuf (so that mtod will work for a structure
1437  * of size len).  Returns the resulting mbuf chain on success, frees it and
1438  * returns null on failure.  If there is room, it will add up to
1439  * max_protohdr-len extra bytes to the contiguous region in an attempt to
1440  * avoid being called next time.
1441  */
1442 struct mbuf *
1443 m_pullup(struct mbuf *n, int len)
1444 {
1445         struct mbuf *m;
1446         int count;
1447         int space;
1448
1449         /*
1450          * If first mbuf has no cluster, and has room for len bytes
1451          * without shifting current data, pullup into it,
1452          * otherwise allocate a new mbuf to prepend to the chain.
1453          */
1454         if (!(n->m_flags & M_EXT) &&
1455             n->m_data + len < &n->m_dat[MLEN] &&
1456             n->m_next) {
1457                 if (n->m_len >= len)
1458                         return (n);
1459                 m = n;
1460                 n = n->m_next;
1461                 len -= m->m_len;
1462         } else {
1463                 if (len > MHLEN)
1464                         goto bad;
1465                 if (n->m_flags & M_PKTHDR)
1466                         m = m_gethdr(MB_DONTWAIT, n->m_type);
1467                 else
1468                         m = m_get(MB_DONTWAIT, n->m_type);
1469                 if (m == NULL)
1470                         goto bad;
1471                 m->m_len = 0;
1472                 if (n->m_flags & M_PKTHDR)
1473                         M_MOVE_PKTHDR(m, n);
1474         }
1475         space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
1476         do {
1477                 count = min(min(max(len, max_protohdr), space), n->m_len);
1478                 bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
1479                   (unsigned)count);
1480                 len -= count;
1481                 m->m_len += count;
1482                 n->m_len -= count;
1483                 space -= count;
1484                 if (n->m_len)
1485                         n->m_data += count;
1486                 else
1487                         n = m_free(n);
1488         } while (len > 0 && n);
1489         if (len > 0) {
1490                 m_free(m);
1491                 goto bad;
1492         }
1493         m->m_next = n;
1494         return (m);
1495 bad:
1496         m_freem(n);
1497         atomic_add_long_nonlocked(&mbstat[mycpu->gd_cpuid].m_mcfail, 1);
1498         return (NULL);
1499 }
1500
1501 /*
1502  * Partition an mbuf chain in two pieces, returning the tail --
1503  * all but the first len0 bytes.  In case of failure, it returns NULL and
1504  * attempts to restore the chain to its original state.
1505  *
1506  * Note that the resulting mbufs might be read-only, because the new
1507  * mbuf can end up sharing an mbuf cluster with the original mbuf if
1508  * the "breaking point" happens to lie within a cluster mbuf. Use the
1509  * M_WRITABLE() macro to check for this case.
1510  */
1511 struct mbuf *
1512 m_split(struct mbuf *m0, int len0, int wait)
1513 {
1514         struct mbuf *m, *n;
1515         unsigned len = len0, remain;
1516
1517         for (m = m0; m && len > m->m_len; m = m->m_next)
1518                 len -= m->m_len;
1519         if (m == NULL)
1520                 return (NULL);
1521         remain = m->m_len - len;
1522         if (m0->m_flags & M_PKTHDR) {
1523                 n = m_gethdr(wait, m0->m_type);
1524                 if (n == NULL)
1525                         return (NULL);
1526                 n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
1527                 n->m_pkthdr.len = m0->m_pkthdr.len - len0;
1528                 m0->m_pkthdr.len = len0;
1529                 if (m->m_flags & M_EXT)
1530                         goto extpacket;
1531                 if (remain > MHLEN) {
1532                         /* m can't be the lead packet */
1533                         MH_ALIGN(n, 0);
1534                         n->m_next = m_split(m, len, wait);
1535                         if (n->m_next == NULL) {
1536                                 m_free(n);
1537                                 return (NULL);
1538                         } else {
1539                                 n->m_len = 0;
1540                                 return (n);
1541                         }
1542                 } else
1543                         MH_ALIGN(n, remain);
1544         } else if (remain == 0) {
1545                 n = m->m_next;
1546                 m->m_next = 0;
1547                 return (n);
1548         } else {
1549                 n = m_get(wait, m->m_type);
1550                 if (n == NULL)
1551                         return (NULL);
1552                 M_ALIGN(n, remain);
1553         }
1554 extpacket:
1555         if (m->m_flags & M_EXT) {
1556                 KKASSERT((n->m_flags & M_EXT) == 0);
1557                 n->m_data = m->m_data + len;
1558                 m->m_ext.ext_ref(m->m_ext.ext_arg);
1559                 n->m_ext = m->m_ext;
1560                 n->m_flags |= m->m_flags & (M_EXT | M_EXT_CLUSTER);
1561         } else {
1562                 bcopy(mtod(m, caddr_t) + len, mtod(n, caddr_t), remain);
1563         }
1564         n->m_len = remain;
1565         m->m_len = len;
1566         n->m_next = m->m_next;
1567         m->m_next = 0;
1568         return (n);
1569 }
1570
1571 /*
1572  * Routine to copy from device local memory into mbufs.
1573  * Note: "offset" is ill-defined and always called as 0, so ignore it.
1574  */
1575 struct mbuf *
1576 m_devget(char *buf, int len, int offset, struct ifnet *ifp,
1577     void (*copy)(volatile const void *from, volatile void *to, size_t length))
1578 {
1579         struct mbuf *m, *mfirst = NULL, **mtail;
1580         int nsize, flags;
1581
1582         if (copy == NULL)
1583                 copy = bcopy;
1584         mtail = &mfirst;
1585         flags = M_PKTHDR;
1586
1587         while (len > 0) {
1588                 m = m_getl(len, MB_DONTWAIT, MT_DATA, flags, &nsize);
1589                 if (m == NULL) {
1590                         m_freem(mfirst);
1591                         return (NULL);
1592                 }
1593                 m->m_len = min(len, nsize);
1594
1595                 if (flags & M_PKTHDR) {
1596                         if (len + max_linkhdr <= nsize)
1597                                 m->m_data += max_linkhdr;
1598                         m->m_pkthdr.rcvif = ifp;
1599                         m->m_pkthdr.len = len;
1600                         flags = 0;
1601                 }
1602
1603                 copy(buf, m->m_data, (unsigned)m->m_len);
1604                 buf += m->m_len;
1605                 len -= m->m_len;
1606                 *mtail = m;
1607                 mtail = &m->m_next;
1608         }
1609
1610         return (mfirst);
1611 }
1612
1613 /*
1614  * Routine to pad mbuf to the specified length 'padto'.
1615  */
1616 int
1617 m_devpad(struct mbuf *m, int padto)
1618 {
1619         struct mbuf *last = NULL;
1620         int padlen;
1621
1622         if (padto <= m->m_pkthdr.len)
1623                 return 0;
1624
1625         padlen = padto - m->m_pkthdr.len;
1626
1627         /* if there's only the packet-header and we can pad there, use it. */
1628         if (m->m_pkthdr.len == m->m_len && M_TRAILINGSPACE(m) >= padlen) {
1629                 last = m;
1630         } else {
1631                 /*
1632                  * Walk packet chain to find last mbuf. We will either
1633                  * pad there, or append a new mbuf and pad it
1634                  */
1635                 for (last = m; last->m_next != NULL; last = last->m_next)
1636                         ; /* EMPTY */
1637
1638                 /* `last' now points to last in chain. */
1639                 if (M_TRAILINGSPACE(last) < padlen) {
1640                         struct mbuf *n;
1641
1642                         /* Allocate new empty mbuf, pad it.  Compact later. */
1643                         MGET(n, MB_DONTWAIT, MT_DATA);
1644                         if (n == NULL)
1645                                 return ENOBUFS;
1646                         n->m_len = 0;
1647                         last->m_next = n;
1648                         last = n;
1649                 }
1650         }
1651         KKASSERT(M_TRAILINGSPACE(last) >= padlen);
1652         KKASSERT(M_WRITABLE(last));
1653
1654         /* Now zero the pad area */
1655         bzero(mtod(last, char *) + last->m_len, padlen);
1656         last->m_len += padlen;
1657         m->m_pkthdr.len += padlen;
1658         return 0;
1659 }
1660
1661 /*
1662  * Copy data from a buffer back into the indicated mbuf chain,
1663  * starting "off" bytes from the beginning, extending the mbuf
1664  * chain if necessary.
1665  */
1666 void
1667 m_copyback(struct mbuf *m0, int off, int len, caddr_t cp)
1668 {
1669         int mlen;
1670         struct mbuf *m = m0, *n;
1671         int totlen = 0;
1672
1673         if (m0 == NULL)
1674                 return;
1675         while (off > (mlen = m->m_len)) {
1676                 off -= mlen;
1677                 totlen += mlen;
1678                 if (m->m_next == NULL) {
1679                         n = m_getclr(MB_DONTWAIT, m->m_type);
1680                         if (n == NULL)
1681                                 goto out;
1682                         n->m_len = min(MLEN, len + off);
1683                         m->m_next = n;
1684                 }
1685                 m = m->m_next;
1686         }
1687         while (len > 0) {
1688                 mlen = min (m->m_len - off, len);
1689                 bcopy(cp, off + mtod(m, caddr_t), (unsigned)mlen);
1690                 cp += mlen;
1691                 len -= mlen;
1692                 mlen += off;
1693                 off = 0;
1694                 totlen += mlen;
1695                 if (len == 0)
1696                         break;
1697                 if (m->m_next == NULL) {
1698                         n = m_get(MB_DONTWAIT, m->m_type);
1699                         if (n == NULL)
1700                                 break;
1701                         n->m_len = min(MLEN, len);
1702                         m->m_next = n;
1703                 }
1704                 m = m->m_next;
1705         }
1706 out:    if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
1707                 m->m_pkthdr.len = totlen;
1708 }
1709
1710 /*
1711  * Append the specified data to the indicated mbuf chain,
1712  * Extend the mbuf chain if the new data does not fit in
1713  * existing space.
1714  *
1715  * Return 1 if able to complete the job; otherwise 0.
1716  */
1717 int
1718 m_append(struct mbuf *m0, int len, c_caddr_t cp)
1719 {
1720         struct mbuf *m, *n;
1721         int remainder, space;
1722
1723         for (m = m0; m->m_next != NULL; m = m->m_next)
1724                 ;
1725         remainder = len;
1726         space = M_TRAILINGSPACE(m);
1727         if (space > 0) {
1728                 /*
1729                  * Copy into available space.
1730                  */
1731                 if (space > remainder)
1732                         space = remainder;
1733                 bcopy(cp, mtod(m, caddr_t) + m->m_len, space);
1734                 m->m_len += space;
1735                 cp += space, remainder -= space;
1736         }
1737         while (remainder > 0) {
1738                 /*
1739                  * Allocate a new mbuf; could check space
1740                  * and allocate a cluster instead.
1741                  */
1742                 n = m_get(MB_DONTWAIT, m->m_type);
1743                 if (n == NULL)
1744                         break;
1745                 n->m_len = min(MLEN, remainder);
1746                 bcopy(cp, mtod(n, caddr_t), n->m_len);
1747                 cp += n->m_len, remainder -= n->m_len;
1748                 m->m_next = n;
1749                 m = n;
1750         }
1751         if (m0->m_flags & M_PKTHDR)
1752                 m0->m_pkthdr.len += len - remainder;
1753         return (remainder == 0);
1754 }
1755
1756 /*
1757  * Apply function f to the data in an mbuf chain starting "off" bytes from
1758  * the beginning, continuing for "len" bytes.
1759  */
1760 int
1761 m_apply(struct mbuf *m, int off, int len,
1762     int (*f)(void *, void *, u_int), void *arg)
1763 {
1764         u_int count;
1765         int rval;
1766
1767         KASSERT(off >= 0, ("m_apply, negative off %d", off));
1768         KASSERT(len >= 0, ("m_apply, negative len %d", len));
1769         while (off > 0) {
1770                 KASSERT(m != NULL, ("m_apply, offset > size of mbuf chain"));
1771                 if (off < m->m_len)
1772                         break;
1773                 off -= m->m_len;
1774                 m = m->m_next;
1775         }
1776         while (len > 0) {
1777                 KASSERT(m != NULL, ("m_apply, offset > size of mbuf chain"));
1778                 count = min(m->m_len - off, len);
1779                 rval = (*f)(arg, mtod(m, caddr_t) + off, count);
1780                 if (rval)
1781                         return (rval);
1782                 len -= count;
1783                 off = 0;
1784                 m = m->m_next;
1785         }
1786         return (0);
1787 }
1788
1789 /*
1790  * Return a pointer to mbuf/offset of location in mbuf chain.
1791  */
1792 struct mbuf *
1793 m_getptr(struct mbuf *m, int loc, int *off)
1794 {
1795
1796         while (loc >= 0) {
1797                 /* Normal end of search. */
1798                 if (m->m_len > loc) {
1799                         *off = loc;
1800                         return (m);
1801                 } else {
1802                         loc -= m->m_len;
1803                         if (m->m_next == NULL) {
1804                                 if (loc == 0) {
1805                                         /* Point at the end of valid data. */
1806                                         *off = m->m_len;
1807                                         return (m);
1808                                 }
1809                                 return (NULL);
1810                         }
1811                         m = m->m_next;
1812                 }
1813         }
1814         return (NULL);
1815 }
1816
1817 void
1818 m_print(const struct mbuf *m)
1819 {
1820         int len;
1821         const struct mbuf *m2;
1822
1823         len = m->m_pkthdr.len;
1824         m2 = m;
1825         while (len) {
1826                 kprintf("%p %*D\n", m2, m2->m_len, (u_char *)m2->m_data, "-");
1827                 len -= m2->m_len;
1828                 m2 = m2->m_next;
1829         }
1830         return;
1831 }
1832
1833 /*
1834  * "Move" mbuf pkthdr from "from" to "to".
1835  * "from" must have M_PKTHDR set, and "to" must be empty.
1836  */
1837 void
1838 m_move_pkthdr(struct mbuf *to, struct mbuf *from)
1839 {
1840         KASSERT((to->m_flags & M_PKTHDR), ("m_move_pkthdr: not packet header"));
1841
1842         to->m_flags |= from->m_flags & M_COPYFLAGS;
1843         to->m_pkthdr = from->m_pkthdr;          /* especially tags */
1844         SLIST_INIT(&from->m_pkthdr.tags);       /* purge tags from src */
1845 }
1846
1847 /*
1848  * Duplicate "from"'s mbuf pkthdr in "to".
1849  * "from" must have M_PKTHDR set, and "to" must be empty.
1850  * In particular, this does a deep copy of the packet tags.
1851  */
1852 int
1853 m_dup_pkthdr(struct mbuf *to, const struct mbuf *from, int how)
1854 {
1855         KASSERT((to->m_flags & M_PKTHDR), ("m_dup_pkthdr: not packet header"));
1856
1857         to->m_flags = (from->m_flags & M_COPYFLAGS) |
1858                       (to->m_flags & ~M_COPYFLAGS);
1859         to->m_pkthdr = from->m_pkthdr;
1860         SLIST_INIT(&to->m_pkthdr.tags);
1861         return (m_tag_copy_chain(to, from, how));
1862 }
1863
1864 /*
1865  * Defragment a mbuf chain, returning the shortest possible
1866  * chain of mbufs and clusters.  If allocation fails and
1867  * this cannot be completed, NULL will be returned, but
1868  * the passed in chain will be unchanged.  Upon success,
1869  * the original chain will be freed, and the new chain
1870  * will be returned.
1871  *
1872  * If a non-packet header is passed in, the original
1873  * mbuf (chain?) will be returned unharmed.
1874  *
1875  * m_defrag_nofree doesn't free the passed in mbuf.
1876  */
1877 struct mbuf *
1878 m_defrag(struct mbuf *m0, int how)
1879 {
1880         struct mbuf *m_new;
1881
1882         if ((m_new = m_defrag_nofree(m0, how)) == NULL)
1883                 return (NULL);
1884         if (m_new != m0)
1885                 m_freem(m0);
1886         return (m_new);
1887 }
1888
1889 struct mbuf *
1890 m_defrag_nofree(struct mbuf *m0, int how)
1891 {
1892         struct mbuf     *m_new = NULL, *m_final = NULL;
1893         int             progress = 0, length, nsize;
1894
1895         if (!(m0->m_flags & M_PKTHDR))
1896                 return (m0);
1897
1898 #ifdef MBUF_STRESS_TEST
1899         if (m_defragrandomfailures) {
1900                 int temp = karc4random() & 0xff;
1901                 if (temp == 0xba)
1902                         goto nospace;
1903         }
1904 #endif
1905
1906         m_final = m_getl(m0->m_pkthdr.len, how, MT_DATA, M_PKTHDR, &nsize);
1907         if (m_final == NULL)
1908                 goto nospace;
1909         m_final->m_len = 0;     /* in case m0->m_pkthdr.len is zero */
1910
1911         if (m_dup_pkthdr(m_final, m0, how) == 0)
1912                 goto nospace;
1913
1914         m_new = m_final;
1915
1916         while (progress < m0->m_pkthdr.len) {
1917                 length = m0->m_pkthdr.len - progress;
1918                 if (length > MCLBYTES)
1919                         length = MCLBYTES;
1920
1921                 if (m_new == NULL) {
1922                         m_new = m_getl(length, how, MT_DATA, 0, &nsize);
1923                         if (m_new == NULL)
1924                                 goto nospace;
1925                 }
1926
1927                 m_copydata(m0, progress, length, mtod(m_new, caddr_t));
1928                 progress += length;
1929                 m_new->m_len = length;
1930                 if (m_new != m_final)
1931                         m_cat(m_final, m_new);
1932                 m_new = NULL;
1933         }
1934         if (m0->m_next == NULL)
1935                 m_defraguseless++;
1936         m_defragpackets++;
1937         m_defragbytes += m_final->m_pkthdr.len;
1938         return (m_final);
1939 nospace:
1940         m_defragfailure++;
1941         if (m_new)
1942                 m_free(m_new);
1943         m_freem(m_final);
1944         return (NULL);
1945 }
1946
1947 /*
1948  * Move data from uio into mbufs.
1949  */
1950 struct mbuf *
1951 m_uiomove(struct uio *uio)
1952 {
1953         struct mbuf *m;                 /* current working mbuf */
1954         struct mbuf *head = NULL;       /* result mbuf chain */
1955         struct mbuf **mp = &head;
1956         int flags = M_PKTHDR;
1957         int nsize;
1958         int error;
1959         int resid;
1960
1961         do {
1962                 if (uio->uio_resid > INT_MAX)
1963                         resid = INT_MAX;
1964                 else
1965                         resid = (int)uio->uio_resid;
1966                 m = m_getl(resid, MB_WAIT, MT_DATA, flags, &nsize);
1967                 if (flags) {
1968                         m->m_pkthdr.len = 0;
1969                         /* Leave room for protocol headers. */
1970                         if (resid < MHLEN)
1971                                 MH_ALIGN(m, resid);
1972                         flags = 0;
1973                 }
1974                 m->m_len = imin(nsize, resid);
1975                 error = uiomove(mtod(m, caddr_t), m->m_len, uio);
1976                 if (error) {
1977                         m_free(m);
1978                         goto failed;
1979                 }
1980                 *mp = m;
1981                 mp = &m->m_next;
1982                 head->m_pkthdr.len += m->m_len;
1983         } while (uio->uio_resid > 0);
1984
1985         return (head);
1986
1987 failed:
1988         m_freem(head);
1989         return (NULL);
1990 }
1991
1992 struct mbuf *
1993 m_last(struct mbuf *m)
1994 {
1995         while (m->m_next)
1996                 m = m->m_next;
1997         return (m);
1998 }
1999
2000 /*
2001  * Return the number of bytes in an mbuf chain.
2002  * If lastm is not NULL, also return the last mbuf.
2003  */
2004 u_int
2005 m_lengthm(struct mbuf *m, struct mbuf **lastm)
2006 {
2007         u_int len = 0;
2008         struct mbuf *prev = m;
2009
2010         while (m) {
2011                 len += m->m_len;
2012                 prev = m;
2013                 m = m->m_next;
2014         }
2015         if (lastm != NULL)
2016                 *lastm = prev;
2017         return (len);
2018 }
2019
2020 /*
2021  * Like m_lengthm(), except also keep track of mbuf usage.
2022  */
2023 u_int
2024 m_countm(struct mbuf *m, struct mbuf **lastm, u_int *pmbcnt)
2025 {
2026         u_int len = 0, mbcnt = 0;
2027         struct mbuf *prev = m;
2028
2029         while (m) {
2030                 len += m->m_len;
2031                 mbcnt += MSIZE;
2032                 if (m->m_flags & M_EXT)
2033                         mbcnt += m->m_ext.ext_size;
2034                 prev = m;
2035                 m = m->m_next;
2036         }
2037         if (lastm != NULL)
2038                 *lastm = prev;
2039         *pmbcnt = mbcnt;
2040         return (len);
2041 }