sys/kern/kern_mbuf.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2004, 2005,
   5  *      Bosko Milekic <bmilekic@FreeBSD.org>.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice unmodified, this list of conditions and the following
  12  *    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  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include "opt_param.h"
  34 #include "opt_kern_tls.h"
  35
  36 #include <sys/param.h>
  37 #include <sys/conf.h>
  38 #include <sys/domainset.h>
  39 #include <sys/malloc.h>
  40 #include <sys/systm.h>
  41 #include <sys/mbuf.h>
  42 #include <sys/domain.h>
  43 #include <sys/eventhandler.h>
  44 #include <sys/kernel.h>
  45 #include <sys/ktls.h>
  46 #include <sys/limits.h>
  47 #include <sys/lock.h>
  48 #include <sys/mutex.h>
  49 #include <sys/protosw.h>
  50 #include <sys/refcount.h>
  51 #include <sys/sf_buf.h>
  52 #include <sys/smp.h>
  53 #include <sys/socket.h>
  54 #include <sys/sysctl.h>
  55
  56 #include <net/if.h>
  57 #include <net/if_var.h>
  58
  59 #include <vm/vm.h>
  60 #include <vm/vm_extern.h>
  61 #include <vm/vm_kern.h>
  62 #include <vm/vm_page.h>
  63 #include <vm/vm_pageout.h>
  64 #include <vm/vm_map.h>
  65 #include <vm/uma.h>
  66 #include <vm/uma_dbg.h>
  67
  68 /*
  69  * In FreeBSD, Mbufs and Mbuf Clusters are allocated from UMA
  70  * Zones.
  71  *
  72  * Mbuf Clusters (2K, contiguous) are allocated from the Cluster
  73  * Zone.  The Zone can be capped at kern.ipc.nmbclusters, if the
  74  * administrator so desires.
  75  *
  76  * Mbufs are allocated from a UMA Primary Zone called the Mbuf
  77  * Zone.
  78  *
  79  * Additionally, FreeBSD provides a Packet Zone, which it
  80  * configures as a Secondary Zone to the Mbuf Primary Zone,
  81  * thus sharing backend Slab kegs with the Mbuf Primary Zone.
  82  *
  83  * Thus common-case allocations and locking are simplified:
  84  *
  85  *  m_clget()                m_getcl()
  86  *    |                         |
  87  *    |   .------------>[(Packet Cache)]    m_get(), m_gethdr()
  88  *    |   |             [     Packet   ]            |
  89  *  [(Cluster Cache)]   [    Secondary ]   [ (Mbuf Cache)     ]
  90  *  [ Cluster Zone  ]   [     Zone     ]   [ Mbuf Primary Zone ]
  91  *        |                       \________         |
  92  *  [ Cluster Keg   ]                      \       /
  93  *        |                              [ Mbuf Keg   ]
  94  *  [ Cluster Slabs ]                         |
  95  *        |                              [ Mbuf Slabs ]
  96  *         \____________(VM)_________________/
  97  *
  98  *
  99  * Whenever an object is allocated with uma_zalloc() out of
 100  * one of the Zones its _ctor_ function is executed.  The same
 101  * for any deallocation through uma_zfree() the _dtor_ function
 102  * is executed.
 103  *
 104  * Caches are per-CPU and are filled from the Primary Zone.
 105  *
 106  * Whenever an object is allocated from the underlying global
 107  * memory pool it gets pre-initialized with the _zinit_ functions.
 108  * When the Keg's are overfull objects get decommissioned with
 109  * _zfini_ functions and free'd back to the global memory pool.
 110  *
 111  */
 112
 113 int nmbufs;                     /* limits number of mbufs */
 114 int nmbclusters;                /* limits number of mbuf clusters */
 115 int nmbjumbop;                  /* limits number of page size jumbo clusters */
 116 int nmbjumbo9;                  /* limits number of 9k jumbo clusters */
 117 int nmbjumbo16;                 /* limits number of 16k jumbo clusters */
 118
 119 bool mb_use_ext_pgs;            /* use M_EXTPG mbufs for sendfile & TLS */
 120 SYSCTL_BOOL(_kern_ipc, OID_AUTO, mb_use_ext_pgs, CTLFLAG_RWTUN,
 121     &mb_use_ext_pgs, 0,
 122     "Use unmapped mbufs for sendfile(2) and TLS offload");
 123
 124 static quad_t maxmbufmem;       /* overall real memory limit for all mbufs */
 125
 126 SYSCTL_QUAD(_kern_ipc, OID_AUTO, maxmbufmem, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &maxmbufmem, 0,
 127     "Maximum real memory allocatable to various mbuf types");
 128
 129 static counter_u64_t snd_tag_count;
 130 SYSCTL_COUNTER_U64(_kern_ipc, OID_AUTO, num_snd_tags, CTLFLAG_RW,
 131     &snd_tag_count, "# of active mbuf send tags");
 132
 133 /*
 134  * tunable_mbinit() has to be run before any mbuf allocations are done.
 135  */
 136 static void
 137 tunable_mbinit(void *dummy)
 138 {
 139         quad_t realmem;
 140
 141         /*
 142          * The default limit for all mbuf related memory is 1/2 of all
 143          * available kernel memory (physical or kmem).
 144          * At most it can be 3/4 of available kernel memory.
 145          */
 146         realmem = qmin((quad_t)physmem * PAGE_SIZE, vm_kmem_size);
 147         maxmbufmem = realmem / 2;
 148         TUNABLE_QUAD_FETCH("kern.ipc.maxmbufmem", &maxmbufmem);
 149         if (maxmbufmem > realmem / 4 * 3)
 150                 maxmbufmem = realmem / 4 * 3;
 151
 152         TUNABLE_INT_FETCH("kern.ipc.nmbclusters", &nmbclusters);
 153         if (nmbclusters == 0)
 154                 nmbclusters = maxmbufmem / MCLBYTES / 4;
 155
 156         TUNABLE_INT_FETCH("kern.ipc.nmbjumbop", &nmbjumbop);
 157         if (nmbjumbop == 0)
 158                 nmbjumbop = maxmbufmem / MJUMPAGESIZE / 4;
 159
 160         TUNABLE_INT_FETCH("kern.ipc.nmbjumbo9", &nmbjumbo9);
 161         if (nmbjumbo9 == 0)
 162                 nmbjumbo9 = maxmbufmem / MJUM9BYTES / 6;
 163
 164         TUNABLE_INT_FETCH("kern.ipc.nmbjumbo16", &nmbjumbo16);
 165         if (nmbjumbo16 == 0)
 166                 nmbjumbo16 = maxmbufmem / MJUM16BYTES / 6;
 167
 168         /*
 169          * We need at least as many mbufs as we have clusters of
 170          * the various types added together.
 171          */
 172         TUNABLE_INT_FETCH("kern.ipc.nmbufs", &nmbufs);
 173         if (nmbufs < nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16)
 174                 nmbufs = lmax(maxmbufmem / MSIZE / 5,
 175                     nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16);
 176 }
 177 SYSINIT(tunable_mbinit, SI_SUB_KMEM, SI_ORDER_MIDDLE, tunable_mbinit, NULL);
 178
 179 static int
 180 sysctl_nmbclusters(SYSCTL_HANDLER_ARGS)
 181 {
 182         int error, newnmbclusters;
 183
 184         newnmbclusters = nmbclusters;
 185         error = sysctl_handle_int(oidp, &newnmbclusters, 0, req);
 186         if (error == 0 && req->newptr && newnmbclusters != nmbclusters) {
 187                 if (newnmbclusters > nmbclusters &&
 188                     nmbufs >= nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16) {
 189                         nmbclusters = newnmbclusters;
 190                         nmbclusters = uma_zone_set_max(zone_clust, nmbclusters);
 191                         EVENTHANDLER_INVOKE(nmbclusters_change);
 192                 } else
 193                         error = EINVAL;
 194         }
 195         return (error);
 196 }
 197 SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbclusters,
 198     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &nmbclusters, 0,
 199     sysctl_nmbclusters, "IU",
 200     "Maximum number of mbuf clusters allowed");
 201
 202 static int
 203 sysctl_nmbjumbop(SYSCTL_HANDLER_ARGS)
 204 {
 205         int error, newnmbjumbop;
 206
 207         newnmbjumbop = nmbjumbop;
 208         error = sysctl_handle_int(oidp, &newnmbjumbop, 0, req);
 209         if (error == 0 && req->newptr && newnmbjumbop != nmbjumbop) {
 210                 if (newnmbjumbop > nmbjumbop &&
 211                     nmbufs >= nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16) {
 212                         nmbjumbop = newnmbjumbop;
 213                         nmbjumbop = uma_zone_set_max(zone_jumbop, nmbjumbop);
 214                 } else
 215                         error = EINVAL;
 216         }
 217         return (error);
 218 }
 219 SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbop,
 220     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &nmbjumbop, 0,
 221     sysctl_nmbjumbop, "IU",
 222     "Maximum number of mbuf page size jumbo clusters allowed");
 223
 224 static int
 225 sysctl_nmbjumbo9(SYSCTL_HANDLER_ARGS)
 226 {
 227         int error, newnmbjumbo9;
 228
 229         newnmbjumbo9 = nmbjumbo9;
 230         error = sysctl_handle_int(oidp, &newnmbjumbo9, 0, req);
 231         if (error == 0 && req->newptr && newnmbjumbo9 != nmbjumbo9) {
 232                 if (newnmbjumbo9 > nmbjumbo9 &&
 233                     nmbufs >= nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16) {
 234                         nmbjumbo9 = newnmbjumbo9;
 235                         nmbjumbo9 = uma_zone_set_max(zone_jumbo9, nmbjumbo9);
 236                 } else
 237                         error = EINVAL;
 238         }
 239         return (error);
 240 }
 241 SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbo9,
 242     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &nmbjumbo9, 0,
 243     sysctl_nmbjumbo9, "IU",
 244     "Maximum number of mbuf 9k jumbo clusters allowed");
 245
 246 static int
 247 sysctl_nmbjumbo16(SYSCTL_HANDLER_ARGS)
 248 {
 249         int error, newnmbjumbo16;
 250
 251         newnmbjumbo16 = nmbjumbo16;
 252         error = sysctl_handle_int(oidp, &newnmbjumbo16, 0, req);
 253         if (error == 0 && req->newptr && newnmbjumbo16 != nmbjumbo16) {
 254                 if (newnmbjumbo16 > nmbjumbo16 &&
 255                     nmbufs >= nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16) {
 256                         nmbjumbo16 = newnmbjumbo16;
 257                         nmbjumbo16 = uma_zone_set_max(zone_jumbo16, nmbjumbo16);
 258                 } else
 259                         error = EINVAL;
 260         }
 261         return (error);
 262 }
 263 SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjumbo16,
 264     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &nmbjumbo16, 0,
 265     sysctl_nmbjumbo16, "IU",
 266     "Maximum number of mbuf 16k jumbo clusters allowed");
 267
 268 static int
 269 sysctl_nmbufs(SYSCTL_HANDLER_ARGS)
 270 {
 271         int error, newnmbufs;
 272
 273         newnmbufs = nmbufs;
 274         error = sysctl_handle_int(oidp, &newnmbufs, 0, req);
 275         if (error == 0 && req->newptr && newnmbufs != nmbufs) {
 276                 if (newnmbufs > nmbufs) {
 277                         nmbufs = newnmbufs;
 278                         nmbufs = uma_zone_set_max(zone_mbuf, nmbufs);
 279                         EVENTHANDLER_INVOKE(nmbufs_change);
 280                 } else
 281                         error = EINVAL;
 282         }
 283         return (error);
 284 }
 285 SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbufs,
 286     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 287     &nmbufs, 0, sysctl_nmbufs, "IU",
 288     "Maximum number of mbufs allowed");
 289
 290 /*
 291  * Zones from which we allocate.
 292  */
 293 uma_zone_t      zone_mbuf;
 294 uma_zone_t      zone_clust;
 295 uma_zone_t      zone_pack;
 296 uma_zone_t      zone_jumbop;
 297 uma_zone_t      zone_jumbo9;
 298 uma_zone_t      zone_jumbo16;
 299
 300 /*
 301  * Local prototypes.
 302  */
 303 static int      mb_ctor_mbuf(void *, int, void *, int);
 304 static int      mb_ctor_clust(void *, int, void *, int);
 305 static int      mb_ctor_pack(void *, int, void *, int);
 306 static void     mb_dtor_mbuf(void *, int, void *);
 307 static void     mb_dtor_pack(void *, int, void *);
 308 static int      mb_zinit_pack(void *, int, int);
 309 static void     mb_zfini_pack(void *, int);
 310 static void     mb_reclaim(uma_zone_t, int);
 311
 312 /* Ensure that MSIZE is a power of 2. */
 313 CTASSERT((((MSIZE - 1) ^ MSIZE) + 1) >> 1 == MSIZE);
 314
 315 _Static_assert(sizeof(struct mbuf) <= MSIZE,
 316     "size of mbuf exceeds MSIZE");
 317 /*
 318  * Initialize FreeBSD Network buffer allocation.
 319  */
 320 static void
 321 mbuf_init(void *dummy)
 322 {
 323
 324         /*
 325          * Configure UMA zones for Mbufs, Clusters, and Packets.
 326          */
 327         zone_mbuf = uma_zcreate(MBUF_MEM_NAME, MSIZE,
 328             mb_ctor_mbuf, mb_dtor_mbuf, NULL, NULL,
 329             MSIZE - 1, UMA_ZONE_CONTIG | UMA_ZONE_MAXBUCKET);
 330         if (nmbufs > 0)
 331                 nmbufs = uma_zone_set_max(zone_mbuf, nmbufs);
 332         uma_zone_set_warning(zone_mbuf, "kern.ipc.nmbufs limit reached");
 333         uma_zone_set_maxaction(zone_mbuf, mb_reclaim);
 334
 335         zone_clust = uma_zcreate(MBUF_CLUSTER_MEM_NAME, MCLBYTES,
 336             mb_ctor_clust, NULL, NULL, NULL,
 337             UMA_ALIGN_PTR, UMA_ZONE_CONTIG);
 338         if (nmbclusters > 0)
 339                 nmbclusters = uma_zone_set_max(zone_clust, nmbclusters);
 340         uma_zone_set_warning(zone_clust, "kern.ipc.nmbclusters limit reached");
 341         uma_zone_set_maxaction(zone_clust, mb_reclaim);
 342
 343         zone_pack = uma_zsecond_create(MBUF_PACKET_MEM_NAME, mb_ctor_pack,
 344             mb_dtor_pack, mb_zinit_pack, mb_zfini_pack, zone_mbuf);
 345
 346         /* Make jumbo frame zone too. Page size, 9k and 16k. */
 347         zone_jumbop = uma_zcreate(MBUF_JUMBOP_MEM_NAME, MJUMPAGESIZE,
 348             mb_ctor_clust, NULL, NULL, NULL,
 349             UMA_ALIGN_PTR, UMA_ZONE_CONTIG);
 350         if (nmbjumbop > 0)
 351                 nmbjumbop = uma_zone_set_max(zone_jumbop, nmbjumbop);
 352         uma_zone_set_warning(zone_jumbop, "kern.ipc.nmbjumbop limit reached");
 353         uma_zone_set_maxaction(zone_jumbop, mb_reclaim);
 354
 355         zone_jumbo9 = uma_zcreate(MBUF_JUMBO9_MEM_NAME, MJUM9BYTES,
 356             mb_ctor_clust, NULL, NULL, NULL,
 357             UMA_ALIGN_PTR, UMA_ZONE_CONTIG);
 358         if (nmbjumbo9 > 0)
 359                 nmbjumbo9 = uma_zone_set_max(zone_jumbo9, nmbjumbo9);
 360         uma_zone_set_warning(zone_jumbo9, "kern.ipc.nmbjumbo9 limit reached");
 361         uma_zone_set_maxaction(zone_jumbo9, mb_reclaim);
 362
 363         zone_jumbo16 = uma_zcreate(MBUF_JUMBO16_MEM_NAME, MJUM16BYTES,
 364             mb_ctor_clust, NULL, NULL, NULL,
 365             UMA_ALIGN_PTR, UMA_ZONE_CONTIG);
 366         if (nmbjumbo16 > 0)
 367                 nmbjumbo16 = uma_zone_set_max(zone_jumbo16, nmbjumbo16);
 368         uma_zone_set_warning(zone_jumbo16, "kern.ipc.nmbjumbo16 limit reached");
 369         uma_zone_set_maxaction(zone_jumbo16, mb_reclaim);
 370
 371         /*
 372          * Hook event handler for low-memory situation, used to
 373          * drain protocols and push data back to the caches (UMA
 374          * later pushes it back to VM).
 375          */
 376         EVENTHANDLER_REGISTER(vm_lowmem, mb_reclaim, NULL,
 377             EVENTHANDLER_PRI_FIRST);
 378
 379         snd_tag_count = counter_u64_alloc(M_WAITOK);
 380 }
 381 SYSINIT(mbuf, SI_SUB_MBUF, SI_ORDER_FIRST, mbuf_init, NULL);
 382
 383 #ifdef DEBUGNET
 384 /*
 385  * debugnet makes use of a pre-allocated pool of mbufs and clusters.  When
 386  * debugnet is configured, we initialize a set of UMA cache zones which return
 387  * items from this pool.  At panic-time, the regular UMA zone pointers are
 388  * overwritten with those of the cache zones so that drivers may allocate and
 389  * free mbufs and clusters without attempting to allocate physical memory.
 390  *
 391  * We keep mbufs and clusters in a pair of mbuf queues.  In particular, for
 392  * the purpose of caching clusters, we treat them as mbufs.
 393  */
 394 static struct mbufq dn_mbufq =
 395     { STAILQ_HEAD_INITIALIZER(dn_mbufq.mq_head), 0, INT_MAX };
 396 static struct mbufq dn_clustq =
 397     { STAILQ_HEAD_INITIALIZER(dn_clustq.mq_head), 0, INT_MAX };
 398
 399 static int dn_clsize;
 400 static uma_zone_t dn_zone_mbuf;
 401 static uma_zone_t dn_zone_clust;
 402 static uma_zone_t dn_zone_pack;
 403
 404 static struct debugnet_saved_zones {
 405         uma_zone_t dsz_mbuf;
 406         uma_zone_t dsz_clust;
 407         uma_zone_t dsz_pack;
 408         uma_zone_t dsz_jumbop;
 409         uma_zone_t dsz_jumbo9;
 410         uma_zone_t dsz_jumbo16;
 411         bool dsz_debugnet_zones_enabled;
 412 } dn_saved_zones;
 413
 414 static int
 415 dn_buf_import(void *arg, void **store, int count, int domain __unused,
 416     int flags)
 417 {
 418         struct mbufq *q;
 419         struct mbuf *m;
 420         int i;
 421
 422         q = arg;
 423
 424         for (i = 0; i < count; i++) {
 425                 m = mbufq_dequeue(q);
 426                 if (m == NULL)
 427                         break;
 428                 trash_init(m, q == &dn_mbufq ? MSIZE : dn_clsize, flags);
 429                 store[i] = m;
 430         }
 431         KASSERT((flags & M_WAITOK) == 0 || i == count,
 432             ("%s: ran out of pre-allocated mbufs", __func__));
 433         return (i);
 434 }
 435
 436 static void
 437 dn_buf_release(void *arg, void **store, int count)
 438 {
 439         struct mbufq *q;
 440         struct mbuf *m;
 441         int i;
 442
 443         q = arg;
 444
 445         for (i = 0; i < count; i++) {
 446                 m = store[i];
 447                 (void)mbufq_enqueue(q, m);
 448         }
 449 }
 450
 451 static int
 452 dn_pack_import(void *arg __unused, void **store, int count, int domain __unused,
 453     int flags __unused)
 454 {
 455         struct mbuf *m;
 456         void *clust;
 457         int i;
 458
 459         for (i = 0; i < count; i++) {
 460                 m = m_get(MT_DATA, M_NOWAIT);
 461                 if (m == NULL)
 462                         break;
 463                 clust = uma_zalloc(dn_zone_clust, M_NOWAIT);
 464                 if (clust == NULL) {
 465                         m_free(m);
 466                         break;
 467                 }
 468                 mb_ctor_clust(clust, dn_clsize, m, 0);
 469                 store[i] = m;
 470         }
 471         KASSERT((flags & M_WAITOK) == 0 || i == count,
 472             ("%s: ran out of pre-allocated mbufs", __func__));
 473         return (i);
 474 }
 475
 476 static void
 477 dn_pack_release(void *arg __unused, void **store, int count)
 478 {
 479         struct mbuf *m;
 480         void *clust;
 481         int i;
 482
 483         for (i = 0; i < count; i++) {
 484                 m = store[i];
 485                 clust = m->m_ext.ext_buf;
 486                 uma_zfree(dn_zone_clust, clust);
 487                 uma_zfree(dn_zone_mbuf, m);
 488         }
 489 }
 490
 491 /*
 492  * Free the pre-allocated mbufs and clusters reserved for debugnet, and destroy
 493  * the corresponding UMA cache zones.
 494  */
 495 void
 496 debugnet_mbuf_drain(void)
 497 {
 498         struct mbuf *m;
 499         void *item;
 500
 501         if (dn_zone_mbuf != NULL) {
 502                 uma_zdestroy(dn_zone_mbuf);
 503                 dn_zone_mbuf = NULL;
 504         }
 505         if (dn_zone_clust != NULL) {
 506                 uma_zdestroy(dn_zone_clust);
 507                 dn_zone_clust = NULL;
 508         }
 509         if (dn_zone_pack != NULL) {
 510                 uma_zdestroy(dn_zone_pack);
 511                 dn_zone_pack = NULL;
 512         }
 513
 514         while ((m = mbufq_dequeue(&dn_mbufq)) != NULL)
 515                 m_free(m);
 516         while ((item = mbufq_dequeue(&dn_clustq)) != NULL)
 517                 uma_zfree(m_getzone(dn_clsize), item);
 518 }
 519
 520 /*
 521  * Callback invoked immediately prior to starting a debugnet connection.
 522  */
 523 void
 524 debugnet_mbuf_start(void)
 525 {
 526
 527         MPASS(!dn_saved_zones.dsz_debugnet_zones_enabled);
 528
 529         /* Save the old zone pointers to restore when debugnet is closed. */
 530         dn_saved_zones = (struct debugnet_saved_zones) {
 531                 .dsz_debugnet_zones_enabled = true,
 532                 .dsz_mbuf = zone_mbuf,
 533                 .dsz_clust = zone_clust,
 534                 .dsz_pack = zone_pack,
 535                 .dsz_jumbop = zone_jumbop,
 536                 .dsz_jumbo9 = zone_jumbo9,
 537                 .dsz_jumbo16 = zone_jumbo16,
 538         };
 539
 540         /*
 541          * All cluster zones return buffers of the size requested by the
 542          * drivers.  It's up to the driver to reinitialize the zones if the
 543          * MTU of a debugnet-enabled interface changes.
 544          */
 545         printf("debugnet: overwriting mbuf zone pointers\n");
 546         zone_mbuf = dn_zone_mbuf;
 547         zone_clust = dn_zone_clust;
 548         zone_pack = dn_zone_pack;
 549         zone_jumbop = dn_zone_clust;
 550         zone_jumbo9 = dn_zone_clust;
 551         zone_jumbo16 = dn_zone_clust;
 552 }
 553
 554 /*
 555  * Callback invoked when a debugnet connection is closed/finished.
 556  */
 557 void
 558 debugnet_mbuf_finish(void)
 559 {
 560
 561         MPASS(dn_saved_zones.dsz_debugnet_zones_enabled);
 562
 563         printf("debugnet: restoring mbuf zone pointers\n");
 564         zone_mbuf = dn_saved_zones.dsz_mbuf;
 565         zone_clust = dn_saved_zones.dsz_clust;
 566         zone_pack = dn_saved_zones.dsz_pack;
 567         zone_jumbop = dn_saved_zones.dsz_jumbop;
 568         zone_jumbo9 = dn_saved_zones.dsz_jumbo9;
 569         zone_jumbo16 = dn_saved_zones.dsz_jumbo16;
 570
 571         memset(&dn_saved_zones, 0, sizeof(dn_saved_zones));
 572 }
 573
 574 /*
 575  * Reinitialize the debugnet mbuf+cluster pool and cache zones.
 576  */
 577 void
 578 debugnet_mbuf_reinit(int nmbuf, int nclust, int clsize)
 579 {
 580         struct mbuf *m;
 581         void *item;
 582
 583         debugnet_mbuf_drain();
 584
 585         dn_clsize = clsize;
 586
 587         dn_zone_mbuf = uma_zcache_create("debugnet_" MBUF_MEM_NAME,
 588             MSIZE, mb_ctor_mbuf, mb_dtor_mbuf, NULL, NULL,
 589             dn_buf_import, dn_buf_release,
 590             &dn_mbufq, UMA_ZONE_NOBUCKET);
 591
 592         dn_zone_clust = uma_zcache_create("debugnet_" MBUF_CLUSTER_MEM_NAME,
 593             clsize, mb_ctor_clust, NULL, NULL, NULL,
 594             dn_buf_import, dn_buf_release,
 595             &dn_clustq, UMA_ZONE_NOBUCKET);
 596
 597         dn_zone_pack = uma_zcache_create("debugnet_" MBUF_PACKET_MEM_NAME,
 598             MCLBYTES, mb_ctor_pack, mb_dtor_pack, NULL, NULL,
 599             dn_pack_import, dn_pack_release,
 600             NULL, UMA_ZONE_NOBUCKET);
 601
 602         while (nmbuf-- > 0) {
 603                 m = m_get(MT_DATA, M_WAITOK);
 604                 uma_zfree(dn_zone_mbuf, m);
 605         }
 606         while (nclust-- > 0) {
 607                 item = uma_zalloc(m_getzone(dn_clsize), M_WAITOK);
 608                 uma_zfree(dn_zone_clust, item);
 609         }
 610 }
 611 #endif /* DEBUGNET */
 612
 613 /*
 614  * Constructor for Mbuf primary zone.
 615  *
 616  * The 'arg' pointer points to a mb_args structure which
 617  * contains call-specific information required to support the
 618  * mbuf allocation API.  See mbuf.h.
 619  */
 620 static int
 621 mb_ctor_mbuf(void *mem, int size, void *arg, int how)
 622 {
 623         struct mbuf *m;
 624         struct mb_args *args;
 625         int error;
 626         int flags;
 627         short type;
 628
 629         args = (struct mb_args *)arg;
 630         type = args->type;
 631
 632         /*
 633          * The mbuf is initialized later.  The caller has the
 634          * responsibility to set up any MAC labels too.
 635          */
 636         if (type == MT_NOINIT)
 637                 return (0);
 638
 639         m = (struct mbuf *)mem;
 640         flags = args->flags;
 641         MPASS((flags & M_NOFREE) == 0);
 642
 643         error = m_init(m, how, type, flags);
 644
 645         return (error);
 646 }
 647
 648 /*
 649  * The Mbuf primary zone destructor.
 650  */
 651 static void
 652 mb_dtor_mbuf(void *mem, int size, void *arg)
 653 {
 654         struct mbuf *m;
 655         unsigned long flags;
 656
 657         m = (struct mbuf *)mem;
 658         flags = (unsigned long)arg;
 659
 660         KASSERT((m->m_flags & M_NOFREE) == 0, ("%s: M_NOFREE set", __func__));
 661         if (!(flags & MB_DTOR_SKIP) && (m->m_flags & M_PKTHDR) && !SLIST_EMPTY(&m->m_pkthdr.tags))
 662                 m_tag_delete_chain(m, NULL);
 663 }
 664
 665 /*
 666  * The Mbuf Packet zone destructor.
 667  */
 668 static void
 669 mb_dtor_pack(void *mem, int size, void *arg)
 670 {
 671         struct mbuf *m;
 672
 673         m = (struct mbuf *)mem;
 674         if ((m->m_flags & M_PKTHDR) != 0)
 675                 m_tag_delete_chain(m, NULL);
 676
 677         /* Make sure we've got a clean cluster back. */
 678         KASSERT((m->m_flags & M_EXT) == M_EXT, ("%s: M_EXT not set", __func__));
 679         KASSERT(m->m_ext.ext_buf != NULL, ("%s: ext_buf == NULL", __func__));
 680         KASSERT(m->m_ext.ext_free == NULL, ("%s: ext_free != NULL", __func__));
 681         KASSERT(m->m_ext.ext_arg1 == NULL, ("%s: ext_arg1 != NULL", __func__));
 682         KASSERT(m->m_ext.ext_arg2 == NULL, ("%s: ext_arg2 != NULL", __func__));
 683         KASSERT(m->m_ext.ext_size == MCLBYTES, ("%s: ext_size != MCLBYTES", __func__));
 684         KASSERT(m->m_ext.ext_type == EXT_PACKET, ("%s: ext_type != EXT_PACKET", __func__));
 685 #ifdef INVARIANTS
 686         trash_dtor(m->m_ext.ext_buf, MCLBYTES, arg);
 687 #endif
 688         /*
 689          * If there are processes blocked on zone_clust, waiting for pages
 690          * to be freed up, cause them to be woken up by draining the
 691          * packet zone.  We are exposed to a race here (in the check for
 692          * the UMA_ZFLAG_FULL) where we might miss the flag set, but that
 693          * is deliberate. We don't want to acquire the zone lock for every
 694          * mbuf free.
 695          */
 696         if (uma_zone_exhausted(zone_clust))
 697                 uma_zone_reclaim(zone_pack, UMA_RECLAIM_DRAIN);
 698 }
 699
 700 /*
 701  * The Cluster and Jumbo[PAGESIZE|9|16] zone constructor.
 702  *
 703  * Here the 'arg' pointer points to the Mbuf which we
 704  * are configuring cluster storage for.  If 'arg' is
 705  * empty we allocate just the cluster without setting
 706  * the mbuf to it.  See mbuf.h.
 707  */
 708 static int
 709 mb_ctor_clust(void *mem, int size, void *arg, int how)
 710 {
 711         struct mbuf *m;
 712
 713         m = (struct mbuf *)arg;
 714         if (m != NULL) {
 715                 m->m_ext.ext_buf = (char *)mem;
 716                 m->m_data = m->m_ext.ext_buf;
 717                 m->m_flags |= M_EXT;
 718                 m->m_ext.ext_free = NULL;
 719                 m->m_ext.ext_arg1 = NULL;
 720                 m->m_ext.ext_arg2 = NULL;
 721                 m->m_ext.ext_size = size;
 722                 m->m_ext.ext_type = m_gettype(size);
 723                 m->m_ext.ext_flags = EXT_FLAG_EMBREF;
 724                 m->m_ext.ext_count = 1;
 725         }
 726
 727         return (0);
 728 }
 729
 730 /*
 731  * The Packet secondary zone's init routine, executed on the
 732  * object's transition from mbuf keg slab to zone cache.
 733  */
 734 static int
 735 mb_zinit_pack(void *mem, int size, int how)
 736 {
 737         struct mbuf *m;
 738
 739         m = (struct mbuf *)mem;         /* m is virgin. */
 740         if (uma_zalloc_arg(zone_clust, m, how) == NULL ||
 741             m->m_ext.ext_buf == NULL)
 742                 return (ENOMEM);
 743         m->m_ext.ext_type = EXT_PACKET; /* Override. */
 744 #ifdef INVARIANTS
 745         trash_init(m->m_ext.ext_buf, MCLBYTES, how);
 746 #endif
 747         return (0);
 748 }
 749
 750 /*
 751  * The Packet secondary zone's fini routine, executed on the
 752  * object's transition from zone cache to keg slab.
 753  */
 754 static void
 755 mb_zfini_pack(void *mem, int size)
 756 {
 757         struct mbuf *m;
 758
 759         m = (struct mbuf *)mem;
 760 #ifdef INVARIANTS
 761         trash_fini(m->m_ext.ext_buf, MCLBYTES);
 762 #endif
 763         uma_zfree_arg(zone_clust, m->m_ext.ext_buf, NULL);
 764 #ifdef INVARIANTS
 765         trash_dtor(mem, size, NULL);
 766 #endif
 767 }
 768
 769 /*
 770  * The "packet" keg constructor.
 771  */
 772 static int
 773 mb_ctor_pack(void *mem, int size, void *arg, int how)
 774 {
 775         struct mbuf *m;
 776         struct mb_args *args;
 777         int error, flags;
 778         short type;
 779
 780         m = (struct mbuf *)mem;
 781         args = (struct mb_args *)arg;
 782         flags = args->flags;
 783         type = args->type;
 784         MPASS((flags & M_NOFREE) == 0);
 785
 786 #ifdef INVARIANTS
 787         trash_ctor(m->m_ext.ext_buf, MCLBYTES, arg, how);
 788 #endif
 789
 790         error = m_init(m, how, type, flags);
 791
 792         /* m_ext is already initialized. */
 793         m->m_data = m->m_ext.ext_buf;
 794         m->m_flags = (flags | M_EXT);
 795
 796         return (error);
 797 }
 798
 799 /*
 800  * This is the protocol drain routine.  Called by UMA whenever any of the
 801  * mbuf zones is closed to its limit.
 802  *
 803  * No locks should be held when this is called.  The drain routines have to
 804  * presently acquire some locks which raises the possibility of lock order
 805  * reversal.
 806  */
 807 static void
 808 mb_reclaim(uma_zone_t zone __unused, int pending __unused)
 809 {
 810         struct epoch_tracker et;
 811         struct domain *dp;
 812         struct protosw *pr;
 813
 814         WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK | WARN_PANIC, NULL, __func__);
 815
 816         NET_EPOCH_ENTER(et);
 817         for (dp = domains; dp != NULL; dp = dp->dom_next)
 818                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
 819                         if (pr->pr_drain != NULL)
 820                                 (*pr->pr_drain)();
 821         NET_EPOCH_EXIT(et);
 822 }
 823
 824 /*
 825  * Free "count" units of I/O from an mbuf chain.  They could be held
 826  * in M_EXTPG or just as a normal mbuf.  This code is intended to be
 827  * called in an error path (I/O error, closed connection, etc).
 828  */
 829 void
 830 mb_free_notready(struct mbuf *m, int count)
 831 {
 832         int i;
 833
 834         for (i = 0; i < count && m != NULL; i++) {
 835                 if ((m->m_flags & M_EXTPG) != 0) {
 836                         m->m_epg_nrdy--;
 837                         if (m->m_epg_nrdy != 0)
 838                                 continue;
 839                 }
 840                 m = m_free(m);
 841         }
 842         KASSERT(i == count, ("Removed only %d items from %p", i, m));
 843 }
 844
 845 /*
 846  * Compress an unmapped mbuf into a simple mbuf when it holds a small
 847  * amount of data.  This is used as a DOS defense to avoid having
 848  * small packets tie up wired pages, an ext_pgs structure, and an
 849  * mbuf.  Since this converts the existing mbuf in place, it can only
 850  * be used if there are no other references to 'm'.
 851  */
 852 int
 853 mb_unmapped_compress(struct mbuf *m)
 854 {
 855         volatile u_int *refcnt;
 856         char buf[MLEN];
 857
 858         /*
 859          * Assert that 'm' does not have a packet header.  If 'm' had
 860          * a packet header, it would only be able to hold MHLEN bytes
 861          * and m_data would have to be initialized differently.
 862          */
 863         KASSERT((m->m_flags & M_PKTHDR) == 0 && (m->m_flags & M_EXTPG),
 864             ("%s: m %p !M_EXTPG or M_PKTHDR", __func__, m));
 865         KASSERT(m->m_len <= MLEN, ("m_len too large %p", m));
 866
 867         if (m->m_ext.ext_flags & EXT_FLAG_EMBREF) {
 868                 refcnt = &m->m_ext.ext_count;
 869         } else {
 870                 KASSERT(m->m_ext.ext_cnt != NULL,
 871                     ("%s: no refcounting pointer on %p", __func__, m));
 872                 refcnt = m->m_ext.ext_cnt;
 873         }
 874
 875         if (*refcnt != 1)
 876                 return (EBUSY);
 877
 878         m_copydata(m, 0, m->m_len, buf);
 879
 880         /* Free the backing pages. */
 881         m->m_ext.ext_free(m);
 882
 883         /* Turn 'm' into a "normal" mbuf. */
 884         m->m_flags &= ~(M_EXT | M_RDONLY | M_EXTPG);
 885         m->m_data = m->m_dat;
 886
 887         /* Copy data back into m. */
 888         bcopy(buf, mtod(m, char *), m->m_len);
 889
 890         return (0);
 891 }
 892
 893 /*
 894  * These next few routines are used to permit downgrading an unmapped
 895  * mbuf to a chain of mapped mbufs.  This is used when an interface
 896  * doesn't supported unmapped mbufs or if checksums need to be
 897  * computed in software.
 898  *
 899  * Each unmapped mbuf is converted to a chain of mbufs.  First, any
 900  * TLS header data is stored in a regular mbuf.  Second, each page of
 901  * unmapped data is stored in an mbuf with an EXT_SFBUF external
 902  * cluster.  These mbufs use an sf_buf to provide a valid KVA for the
 903  * associated physical page.  They also hold a reference on the
 904  * original M_EXTPG mbuf to ensure the physical page doesn't go away.
 905  * Finally, any TLS trailer data is stored in a regular mbuf.
 906  *
 907  * mb_unmapped_free_mext() is the ext_free handler for the EXT_SFBUF
 908  * mbufs.  It frees the associated sf_buf and releases its reference
 909  * on the original M_EXTPG mbuf.
 910  *
 911  * _mb_unmapped_to_ext() is a helper function that converts a single
 912  * unmapped mbuf into a chain of mbufs.
 913  *
 914  * mb_unmapped_to_ext() is the public function that walks an mbuf
 915  * chain converting any unmapped mbufs to mapped mbufs.  It returns
 916  * the new chain of unmapped mbufs on success.  On failure it frees
 917  * the original mbuf chain and returns NULL.
 918  */
 919 static void
 920 mb_unmapped_free_mext(struct mbuf *m)
 921 {
 922         struct sf_buf *sf;
 923         struct mbuf *old_m;
 924
 925         sf = m->m_ext.ext_arg1;
 926         sf_buf_free(sf);
 927
 928         /* Drop the reference on the backing M_EXTPG mbuf. */
 929         old_m = m->m_ext.ext_arg2;
 930         mb_free_extpg(old_m);
 931 }
 932
 933 static struct mbuf *
 934 _mb_unmapped_to_ext(struct mbuf *m)
 935 {
 936         struct mbuf *m_new, *top, *prev, *mref;
 937         struct sf_buf *sf;
 938         vm_page_t pg;
 939         int i, len, off, pglen, pgoff, seglen, segoff;
 940         volatile u_int *refcnt;
 941         u_int ref_inc = 0;
 942
 943         M_ASSERTEXTPG(m);
 944         len = m->m_len;
 945         KASSERT(m->m_epg_tls == NULL, ("%s: can't convert TLS mbuf %p",
 946             __func__, m));
 947
 948         /* See if this is the mbuf that holds the embedded refcount. */
 949         if (m->m_ext.ext_flags & EXT_FLAG_EMBREF) {
 950                 refcnt = &m->m_ext.ext_count;
 951                 mref = m;
 952         } else {
 953                 KASSERT(m->m_ext.ext_cnt != NULL,
 954                     ("%s: no refcounting pointer on %p", __func__, m));
 955                 refcnt = m->m_ext.ext_cnt;
 956                 mref = __containerof(refcnt, struct mbuf, m_ext.ext_count);
 957         }
 958
 959         /* Skip over any data removed from the front. */
 960         off = mtod(m, vm_offset_t);
 961
 962         top = NULL;
 963         if (m->m_epg_hdrlen != 0) {
 964                 if (off >= m->m_epg_hdrlen) {
 965                         off -= m->m_epg_hdrlen;
 966                 } else {
 967                         seglen = m->m_epg_hdrlen - off;
 968                         segoff = off;
 969                         seglen = min(seglen, len);
 970                         off = 0;
 971                         len -= seglen;
 972                         m_new = m_get(M_NOWAIT, MT_DATA);
 973                         if (m_new == NULL)
 974                                 goto fail;
 975                         m_new->m_len = seglen;
 976                         prev = top = m_new;
 977                         memcpy(mtod(m_new, void *), &m->m_epg_hdr[segoff],
 978                             seglen);
 979                 }
 980         }
 981         pgoff = m->m_epg_1st_off;
 982         for (i = 0; i < m->m_epg_npgs && len > 0; i++) {
 983                 pglen = m_epg_pagelen(m, i, pgoff);
 984                 if (off >= pglen) {
 985                         off -= pglen;
 986                         pgoff = 0;
 987                         continue;
 988                 }
 989                 seglen = pglen - off;
 990                 segoff = pgoff + off;
 991                 off = 0;
 992                 seglen = min(seglen, len);
 993                 len -= seglen;
 994
 995                 pg = PHYS_TO_VM_PAGE(m->m_epg_pa[i]);
 996                 m_new = m_get(M_NOWAIT, MT_DATA);
 997                 if (m_new == NULL)
 998                         goto fail;
 999                 if (top == NULL) {
1000                         top = prev = m_new;
1001                 } else {
1002                         prev->m_next = m_new;
1003                         prev = m_new;
1004                 }
1005                 sf = sf_buf_alloc(pg, SFB_NOWAIT);
1006                 if (sf == NULL)
1007                         goto fail;
1008
1009                 ref_inc++;
1010                 m_extadd(m_new, (char *)sf_buf_kva(sf), PAGE_SIZE,
1011                     mb_unmapped_free_mext, sf, mref, M_RDONLY, EXT_SFBUF);
1012                 m_new->m_data += segoff;
1013                 m_new->m_len = seglen;
1014
1015                 pgoff = 0;
1016         };
1017         if (len != 0) {
1018                 KASSERT((off + len) <= m->m_epg_trllen,
1019                     ("off + len > trail (%d + %d > %d)", off, len,
1020                     m->m_epg_trllen));
1021                 m_new = m_get(M_NOWAIT, MT_DATA);
1022                 if (m_new == NULL)
1023                         goto fail;
1024                 if (top == NULL)
1025                         top = m_new;
1026                 else
1027                         prev->m_next = m_new;
1028                 m_new->m_len = len;
1029                 memcpy(mtod(m_new, void *), &m->m_epg_trail[off], len);
1030         }
1031
1032         if (ref_inc != 0) {
1033                 /*
1034                  * Obtain an additional reference on the old mbuf for
1035                  * each created EXT_SFBUF mbuf.  They will be dropped
1036                  * in mb_unmapped_free_mext().
1037                  */
1038                 if (*refcnt == 1)
1039                         *refcnt += ref_inc;
1040                 else
1041                         atomic_add_int(refcnt, ref_inc);
1042         }
1043         m_free(m);
1044         return (top);
1045
1046 fail:
1047         if (ref_inc != 0) {
1048                 /*
1049                  * Obtain an additional reference on the old mbuf for
1050                  * each created EXT_SFBUF mbuf.  They will be
1051                  * immediately dropped when these mbufs are freed
1052                  * below.
1053                  */
1054                 if (*refcnt == 1)
1055                         *refcnt += ref_inc;
1056                 else
1057                         atomic_add_int(refcnt, ref_inc);
1058         }
1059         m_free(m);
1060         m_freem(top);
1061         return (NULL);
1062 }
1063
1064 struct mbuf *
1065 mb_unmapped_to_ext(struct mbuf *top)
1066 {
1067         struct mbuf *m, *next, *prev = NULL;
1068
1069         prev = NULL;
1070         for (m = top; m != NULL; m = next) {
1071                 /* m might be freed, so cache the next pointer. */
1072                 next = m->m_next;
1073                 if (m->m_flags & M_EXTPG) {
1074                         if (prev != NULL) {
1075                                 /*
1076                                  * Remove 'm' from the new chain so
1077                                  * that the 'top' chain terminates
1078                                  * before 'm' in case 'top' is freed
1079                                  * due to an error.
1080                                  */
1081                                 prev->m_next = NULL;
1082                         }
1083                         m = _mb_unmapped_to_ext(m);
1084                         if (m == NULL) {
1085                                 m_freem(top);
1086                                 m_freem(next);
1087                                 return (NULL);
1088                         }
1089                         if (prev == NULL) {
1090                                 top = m;
1091                         } else {
1092                                 prev->m_next = m;
1093                         }
1094
1095                         /*
1096                          * Replaced one mbuf with a chain, so we must
1097                          * find the end of chain.
1098                          */
1099                         prev = m_last(m);
1100                 } else {
1101                         if (prev != NULL) {
1102                                 prev->m_next = m;
1103                         }
1104                         prev = m;
1105                 }
1106         }
1107         return (top);
1108 }
1109
1110 /*
1111  * Allocate an empty M_EXTPG mbuf.  The ext_free routine is
1112  * responsible for freeing any pages backing this mbuf when it is
1113  * freed.
1114  */
1115 struct mbuf *
1116 mb_alloc_ext_pgs(int how, m_ext_free_t ext_free)
1117 {
1118         struct mbuf *m;
1119
1120         m = m_get(how, MT_DATA);
1121         if (m == NULL)
1122                 return (NULL);
1123
1124         m->m_epg_npgs = 0;
1125         m->m_epg_nrdy = 0;
1126         m->m_epg_1st_off = 0;
1127         m->m_epg_last_len = 0;
1128         m->m_epg_flags = 0;
1129         m->m_epg_hdrlen = 0;
1130         m->m_epg_trllen = 0;
1131         m->m_epg_tls = NULL;
1132         m->m_epg_so = NULL;
1133         m->m_data = NULL;
1134         m->m_flags |= (M_EXT | M_RDONLY | M_EXTPG);
1135         m->m_ext.ext_flags = EXT_FLAG_EMBREF;
1136         m->m_ext.ext_count = 1;
1137         m->m_ext.ext_size = 0;
1138         m->m_ext.ext_free = ext_free;
1139         return (m);
1140 }
1141
1142 /*
1143  * Clean up after mbufs with M_EXT storage attached to them if the
1144  * reference count hits 1.
1145  */
1146 void
1147 mb_free_ext(struct mbuf *m)
1148 {
1149         volatile u_int *refcnt;
1150         struct mbuf *mref;
1151         int freembuf;
1152
1153         KASSERT(m->m_flags & M_EXT, ("%s: M_EXT not set on %p", __func__, m));
1154
1155         /* See if this is the mbuf that holds the embedded refcount. */
1156         if (m->m_ext.ext_flags & EXT_FLAG_EMBREF) {
1157                 refcnt = &m->m_ext.ext_count;
1158                 mref = m;
1159         } else {
1160                 KASSERT(m->m_ext.ext_cnt != NULL,
1161                     ("%s: no refcounting pointer on %p", __func__, m));
1162                 refcnt = m->m_ext.ext_cnt;
1163                 mref = __containerof(refcnt, struct mbuf, m_ext.ext_count);
1164         }
1165
1166         /*
1167          * Check if the header is embedded in the cluster.  It is
1168          * important that we can't touch any of the mbuf fields
1169          * after we have freed the external storage, since mbuf
1170          * could have been embedded in it.  For now, the mbufs
1171          * embedded into the cluster are always of type EXT_EXTREF,
1172          * and for this type we won't free the mref.
1173          */
1174         if (m->m_flags & M_NOFREE) {
1175                 freembuf = 0;
1176                 KASSERT(m->m_ext.ext_type == EXT_EXTREF ||
1177                     m->m_ext.ext_type == EXT_RXRING,
1178                     ("%s: no-free mbuf %p has wrong type", __func__, m));
1179         } else
1180                 freembuf = 1;
1181
1182         /* Free attached storage if this mbuf is the only reference to it. */
1183         if (*refcnt == 1 || atomic_fetchadd_int(refcnt, -1) == 1) {
1184                 switch (m->m_ext.ext_type) {
1185                 case EXT_PACKET:
1186                         /* The packet zone is special. */
1187                         if (*refcnt == 0)
1188                                 *refcnt = 1;
1189                         uma_zfree(zone_pack, mref);
1190                         break;
1191                 case EXT_CLUSTER:
1192                         uma_zfree(zone_clust, m->m_ext.ext_buf);
1193                         uma_zfree(zone_mbuf, mref);
1194                         break;
1195                 case EXT_JUMBOP:
1196                         uma_zfree(zone_jumbop, m->m_ext.ext_buf);
1197                         uma_zfree(zone_mbuf, mref);
1198                         break;
1199                 case EXT_JUMBO9:
1200                         uma_zfree(zone_jumbo9, m->m_ext.ext_buf);
1201                         uma_zfree(zone_mbuf, mref);
1202                         break;
1203                 case EXT_JUMBO16:
1204                         uma_zfree(zone_jumbo16, m->m_ext.ext_buf);
1205                         uma_zfree(zone_mbuf, mref);
1206                         break;
1207                 case EXT_SFBUF:
1208                 case EXT_NET_DRV:
1209                 case EXT_MOD_TYPE:
1210                 case EXT_DISPOSABLE:
1211                         KASSERT(mref->m_ext.ext_free != NULL,
1212                             ("%s: ext_free not set", __func__));
1213                         mref->m_ext.ext_free(mref);
1214                         uma_zfree(zone_mbuf, mref);
1215                         break;
1216                 case EXT_EXTREF:
1217                         KASSERT(m->m_ext.ext_free != NULL,
1218                             ("%s: ext_free not set", __func__));
1219                         m->m_ext.ext_free(m);
1220                         break;
1221                 case EXT_RXRING:
1222                         KASSERT(m->m_ext.ext_free == NULL,
1223                             ("%s: ext_free is set", __func__));
1224                         break;
1225                 default:
1226                         KASSERT(m->m_ext.ext_type == 0,
1227                             ("%s: unknown ext_type", __func__));
1228                 }
1229         }
1230
1231         if (freembuf && m != mref)
1232                 uma_zfree(zone_mbuf, m);
1233 }
1234
1235 /*
1236  * Clean up after mbufs with M_EXTPG storage attached to them if the
1237  * reference count hits 1.
1238  */
1239 void
1240 mb_free_extpg(struct mbuf *m)
1241 {
1242         volatile u_int *refcnt;
1243         struct mbuf *mref;
1244
1245         M_ASSERTEXTPG(m);
1246
1247         /* See if this is the mbuf that holds the embedded refcount. */
1248         if (m->m_ext.ext_flags & EXT_FLAG_EMBREF) {
1249                 refcnt = &m->m_ext.ext_count;
1250                 mref = m;
1251         } else {
1252                 KASSERT(m->m_ext.ext_cnt != NULL,
1253                     ("%s: no refcounting pointer on %p", __func__, m));
1254                 refcnt = m->m_ext.ext_cnt;
1255                 mref = __containerof(refcnt, struct mbuf, m_ext.ext_count);
1256         }
1257
1258         /* Free attached storage if this mbuf is the only reference to it. */
1259         if (*refcnt == 1 || atomic_fetchadd_int(refcnt, -1) == 1) {
1260                 KASSERT(mref->m_ext.ext_free != NULL,
1261                     ("%s: ext_free not set", __func__));
1262
1263                 mref->m_ext.ext_free(mref);
1264 #ifdef KERN_TLS
1265                 if (mref->m_epg_tls != NULL &&
1266                     !refcount_release_if_not_last(&mref->m_epg_tls->refcount))
1267                         ktls_enqueue_to_free(mref);
1268                 else
1269 #endif
1270                         uma_zfree(zone_mbuf, mref);
1271         }
1272
1273         if (m != mref)
1274                 uma_zfree(zone_mbuf, m);
1275 }
1276
1277 /*
1278  * Official mbuf(9) allocation KPI for stack and drivers:
1279  *
1280  * m_get()      - a single mbuf without any attachments, sys/mbuf.h.
1281  * m_gethdr()   - a single mbuf initialized as M_PKTHDR, sys/mbuf.h.
1282  * m_getcl()    - an mbuf + 2k cluster, sys/mbuf.h.
1283  * m_clget()    - attach cluster to already allocated mbuf.
1284  * m_cljget()   - attach jumbo cluster to already allocated mbuf.
1285  * m_get2()     - allocate minimum mbuf that would fit size argument.
1286  * m_getm2()    - allocate a chain of mbufs/clusters.
1287  * m_extadd()   - attach external cluster to mbuf.
1288  *
1289  * m_free()     - free single mbuf with its tags and ext, sys/mbuf.h.
1290  * m_freem()    - free chain of mbufs.
1291  */
1292
1293 int
1294 m_clget(struct mbuf *m, int how)
1295 {
1296
1297         KASSERT((m->m_flags & M_EXT) == 0, ("%s: mbuf %p has M_EXT",
1298             __func__, m));
1299         m->m_ext.ext_buf = (char *)NULL;
1300         uma_zalloc_arg(zone_clust, m, how);
1301         /*
1302          * On a cluster allocation failure, drain the packet zone and retry,
1303          * we might be able to loosen a few clusters up on the drain.
1304          */
1305         if ((how & M_NOWAIT) && (m->m_ext.ext_buf == NULL)) {
1306                 uma_zone_reclaim(zone_pack, UMA_RECLAIM_DRAIN);
1307                 uma_zalloc_arg(zone_clust, m, how);
1308         }
1309         MBUF_PROBE2(m__clget, m, how);
1310         return (m->m_flags & M_EXT);
1311 }
1312
1313 /*
1314  * m_cljget() is different from m_clget() as it can allocate clusters without
1315  * attaching them to an mbuf.  In that case the return value is the pointer
1316  * to the cluster of the requested size.  If an mbuf was specified, it gets
1317  * the cluster attached to it and the return value can be safely ignored.
1318  * For size it takes MCLBYTES, MJUMPAGESIZE, MJUM9BYTES, MJUM16BYTES.
1319  */
1320 void *
1321 m_cljget(struct mbuf *m, int how, int size)
1322 {
1323         uma_zone_t zone;
1324         void *retval;
1325
1326         if (m != NULL) {
1327                 KASSERT((m->m_flags & M_EXT) == 0, ("%s: mbuf %p has M_EXT",
1328                     __func__, m));
1329                 m->m_ext.ext_buf = NULL;
1330         }
1331
1332         zone = m_getzone(size);
1333         retval = uma_zalloc_arg(zone, m, how);
1334
1335         MBUF_PROBE4(m__cljget, m, how, size, retval);
1336
1337         return (retval);
1338 }
1339
1340 /*
1341  * m_get2() allocates minimum mbuf that would fit "size" argument.
1342  */
1343 struct mbuf *
1344 m_get2(int size, int how, short type, int flags)
1345 {
1346         struct mb_args args;
1347         struct mbuf *m, *n;
1348
1349         args.flags = flags;
1350         args.type = type;
1351
1352         if (size <= MHLEN || (size <= MLEN && (flags & M_PKTHDR) == 0))
1353                 return (uma_zalloc_arg(zone_mbuf, &args, how));
1354         if (size <= MCLBYTES)
1355                 return (uma_zalloc_arg(zone_pack, &args, how));
1356
1357         if (size > MJUMPAGESIZE)
1358                 return (NULL);
1359
1360         m = uma_zalloc_arg(zone_mbuf, &args, how);
1361         if (m == NULL)
1362                 return (NULL);
1363
1364         n = uma_zalloc_arg(zone_jumbop, m, how);
1365         if (n == NULL) {
1366                 uma_zfree(zone_mbuf, m);
1367                 return (NULL);
1368         }
1369
1370         return (m);
1371 }
1372
1373 /*
1374  * m_getjcl() returns an mbuf with a cluster of the specified size attached.
1375  * For size it takes MCLBYTES, MJUMPAGESIZE, MJUM9BYTES, MJUM16BYTES.
1376  */
1377 struct mbuf *
1378 m_getjcl(int how, short type, int flags, int size)
1379 {
1380         struct mb_args args;
1381         struct mbuf *m, *n;
1382         uma_zone_t zone;
1383
1384         if (size == MCLBYTES)
1385                 return m_getcl(how, type, flags);
1386
1387         args.flags = flags;
1388         args.type = type;
1389
1390         m = uma_zalloc_arg(zone_mbuf, &args, how);
1391         if (m == NULL)
1392                 return (NULL);
1393
1394         zone = m_getzone(size);
1395         n = uma_zalloc_arg(zone, m, how);
1396         if (n == NULL) {
1397                 uma_zfree(zone_mbuf, m);
1398                 return (NULL);
1399         }
1400         MBUF_PROBE5(m__getjcl, how, type, flags, size, m);
1401         return (m);
1402 }
1403
1404 /*
1405  * Allocate a given length worth of mbufs and/or clusters (whatever fits
1406  * best) and return a pointer to the top of the allocated chain.  If an
1407  * existing mbuf chain is provided, then we will append the new chain
1408  * to the existing one and return a pointer to the provided mbuf.
1409  */
1410 struct mbuf *
1411 m_getm2(struct mbuf *m, int len, int how, short type, int flags)
1412 {
1413         struct mbuf *mb, *nm = NULL, *mtail = NULL;
1414
1415         KASSERT(len >= 0, ("%s: len is < 0", __func__));
1416
1417         /* Validate flags. */
1418         flags &= (M_PKTHDR | M_EOR);
1419
1420         /* Packet header mbuf must be first in chain. */
1421         if ((flags & M_PKTHDR) && m != NULL)
1422                 flags &= ~M_PKTHDR;
1423
1424         /* Loop and append maximum sized mbufs to the chain tail. */
1425         while (len > 0) {
1426                 mb = NULL;
1427                 if (len > MCLBYTES) {
1428                         mb = m_getjcl(M_NOWAIT, type, (flags & M_PKTHDR),
1429                             MJUMPAGESIZE);
1430                 }
1431                 if (mb == NULL) {
1432                         if (len >= MINCLSIZE)
1433                                 mb = m_getcl(how, type, (flags & M_PKTHDR));
1434                         else if (flags & M_PKTHDR)
1435                                 mb = m_gethdr(how, type);
1436                         else
1437                                 mb = m_get(how, type);
1438
1439                         /*
1440                          * Fail the whole operation if one mbuf can't be
1441                          * allocated.
1442                          */
1443                         if (mb == NULL) {
1444                                 m_freem(nm);
1445                                 return (NULL);
1446                         }
1447                 }
1448
1449                 /* Book keeping. */
1450                 len -= M_SIZE(mb);
1451                 if (mtail != NULL)
1452                         mtail->m_next = mb;
1453                 else
1454                         nm = mb;
1455                 mtail = mb;
1456                 flags &= ~M_PKTHDR;     /* Only valid on the first mbuf. */
1457         }
1458         if (flags & M_EOR)
1459                 mtail->m_flags |= M_EOR;  /* Only valid on the last mbuf. */
1460
1461         /* If mbuf was supplied, append new chain to the end of it. */
1462         if (m != NULL) {
1463                 for (mtail = m; mtail->m_next != NULL; mtail = mtail->m_next)
1464                         ;
1465                 mtail->m_next = nm;
1466                 mtail->m_flags &= ~M_EOR;
1467         } else
1468                 m = nm;
1469
1470         return (m);
1471 }
1472
1473 /*-
1474  * Configure a provided mbuf to refer to the provided external storage
1475  * buffer and setup a reference count for said buffer.
1476  *
1477  * Arguments:
1478  *    mb     The existing mbuf to which to attach the provided buffer.
1479  *    buf    The address of the provided external storage buffer.
1480  *    size   The size of the provided buffer.
1481  *    freef  A pointer to a routine that is responsible for freeing the
1482  *           provided external storage buffer.
1483  *    args   A pointer to an argument structure (of any type) to be passed
1484  *           to the provided freef routine (may be NULL).
1485  *    flags  Any other flags to be passed to the provided mbuf.
1486  *    type   The type that the external storage buffer should be
1487  *           labeled with.
1488  *
1489  * Returns:
1490  *    Nothing.
1491  */
1492 void
1493 m_extadd(struct mbuf *mb, char *buf, u_int size, m_ext_free_t freef,
1494     void *arg1, void *arg2, int flags, int type)
1495 {
1496
1497         KASSERT(type != EXT_CLUSTER, ("%s: EXT_CLUSTER not allowed", __func__));
1498
1499         mb->m_flags |= (M_EXT | flags);
1500         mb->m_ext.ext_buf = buf;
1501         mb->m_data = mb->m_ext.ext_buf;
1502         mb->m_ext.ext_size = size;
1503         mb->m_ext.ext_free = freef;
1504         mb->m_ext.ext_arg1 = arg1;
1505         mb->m_ext.ext_arg2 = arg2;
1506         mb->m_ext.ext_type = type;
1507
1508         if (type != EXT_EXTREF) {
1509                 mb->m_ext.ext_count = 1;
1510                 mb->m_ext.ext_flags = EXT_FLAG_EMBREF;
1511         } else
1512                 mb->m_ext.ext_flags = 0;
1513 }
1514
1515 /*
1516  * Free an entire chain of mbufs and associated external buffers, if
1517  * applicable.
1518  */
1519 void
1520 m_freem(struct mbuf *mb)
1521 {
1522
1523         MBUF_PROBE1(m__freem, mb);
1524         while (mb != NULL)
1525                 mb = m_free(mb);
1526 }
1527
1528 int
1529 m_snd_tag_alloc(struct ifnet *ifp, union if_snd_tag_alloc_params *params,
1530     struct m_snd_tag **mstp)
1531 {
1532
1533         if (ifp->if_snd_tag_alloc == NULL)
1534                 return (EOPNOTSUPP);
1535         return (ifp->if_snd_tag_alloc(ifp, params, mstp));
1536 }
1537
1538 void
1539 m_snd_tag_init(struct m_snd_tag *mst, struct ifnet *ifp, u_int type)
1540 {
1541
1542         if_ref(ifp);
1543         mst->ifp = ifp;
1544         refcount_init(&mst->refcount, 1);
1545         mst->type = type;
1546         counter_u64_add(snd_tag_count, 1);
1547 }
1548
1549 void
1550 m_snd_tag_destroy(struct m_snd_tag *mst)
1551 {
1552         struct ifnet *ifp;
1553
1554         ifp = mst->ifp;
1555         ifp->if_snd_tag_free(mst);
1556         if_rele(ifp);
1557         counter_u64_add(snd_tag_count, -1);
1558 }
1559
1560 /*
1561  * Allocate an mbuf with anonymous external pages.
1562  */
1563 struct mbuf *
1564 mb_alloc_ext_plus_pages(int len, int how)
1565 {
1566         struct mbuf *m;
1567         vm_page_t pg;
1568         int i, npgs;
1569
1570         m = mb_alloc_ext_pgs(how, mb_free_mext_pgs);
1571         if (m == NULL)
1572                 return (NULL);
1573         m->m_epg_flags |= EPG_FLAG_ANON;
1574         npgs = howmany(len, PAGE_SIZE);
1575         for (i = 0; i < npgs; i++) {
1576                 do {
1577                         pg = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
1578                             VM_ALLOC_NOOBJ | VM_ALLOC_NODUMP | VM_ALLOC_WIRED);
1579                         if (pg == NULL) {
1580                                 if (how == M_NOWAIT) {
1581                                         m->m_epg_npgs = i;
1582                                         m_free(m);
1583                                         return (NULL);
1584                                 }
1585                                 vm_wait(NULL);
1586                         }
1587                 } while (pg == NULL);
1588                 m->m_epg_pa[i] = VM_PAGE_TO_PHYS(pg);
1589         }
1590         m->m_epg_npgs = npgs;
1591         return (m);
1592 }
1593
1594 /*
1595  * Copy the data in the mbuf chain to a chain of mbufs with anonymous external
1596  * unmapped pages.
1597  * len is the length of data in the input mbuf chain.
1598  * mlen is the maximum number of bytes put into each ext_page mbuf.
1599  */
1600 struct mbuf *
1601 mb_mapped_to_unmapped(struct mbuf *mp, int len, int mlen, int how,
1602     struct mbuf **mlast)
1603 {
1604         struct mbuf *m, *mout;
1605         char *pgpos, *mbpos;
1606         int i, mblen, mbufsiz, pglen, xfer;
1607
1608         if (len == 0)
1609                 return (NULL);
1610         mbufsiz = min(mlen, len);
1611         m = mout = mb_alloc_ext_plus_pages(mbufsiz, how);
1612         if (m == NULL)
1613                 return (m);
1614         pgpos = (char *)(void *)PHYS_TO_DMAP(m->m_epg_pa[0]);
1615         pglen = PAGE_SIZE;
1616         mblen = 0;
1617         i = 0;
1618         do {
1619                 if (pglen == 0) {
1620                         if (++i == m->m_epg_npgs) {
1621                                 m->m_epg_last_len = PAGE_SIZE;
1622                                 mbufsiz = min(mlen, len);
1623                                 m->m_next = mb_alloc_ext_plus_pages(mbufsiz,
1624                                     how);
1625                                 m = m->m_next;
1626                                 if (m == NULL) {
1627                                         m_freem(mout);
1628                                         return (m);
1629                                 }
1630                                 i = 0;
1631                         }
1632                         pgpos = (char *)(void *)PHYS_TO_DMAP(m->m_epg_pa[i]);
1633                         pglen = PAGE_SIZE;
1634                 }
1635                 while (mblen == 0) {
1636                         if (mp == NULL) {
1637                                 m_freem(mout);
1638                                 return (NULL);
1639                         }
1640                         KASSERT((mp->m_flags & M_EXTPG) == 0,
1641                             ("mb_copym_ext_pgs: ext_pgs input mbuf"));
1642                         mbpos = mtod(mp, char *);
1643                         mblen = mp->m_len;
1644                         mp = mp->m_next;
1645                 }
1646                 xfer = min(mblen, pglen);
1647                 memcpy(pgpos, mbpos, xfer);
1648                 pgpos += xfer;
1649                 mbpos += xfer;
1650                 pglen -= xfer;
1651                 mblen -= xfer;
1652                 len -= xfer;
1653                 m->m_len += xfer;
1654         } while (len > 0);
1655         m->m_epg_last_len = PAGE_SIZE - pglen;
1656         if (mlast != NULL)
1657                 *mlast = m;
1658         return (mout);
1659 }