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