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