3dbf163b3cee9dd0fa313f43567ddd364df2ae51
[dragonfly.git] / sys / kern / uipc_mbuf.c
1 /*
2  * (MPSAFE)
3  *
4  * Copyright (c) 2004 Jeffrey M. Hsu.  All rights reserved.
5  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
6  * 
7  * This code is derived from software contributed to The DragonFly Project
8  * by Jeffrey M. Hsu.
9  * 
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of The DragonFly Project nor the names of its
19  *    contributors may be used to endorse or promote products derived
20  *    from this software without specific, prior written permission.
21  * 
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35
36 /*
37  * Copyright (c) 1982, 1986, 1988, 1991, 1993
38  *      The Regents of the University of California.  All rights reserved.
39  *
40  * Redistribution and use in source and binary forms, with or without
41  * modification, are permitted provided that the following conditions
42  * are met:
43  * 1. Redistributions of source code must retain the above copyright
44  *    notice, this list of conditions and the following disclaimer.
45  * 2. Redistributions in binary form must reproduce the above copyright
46  *    notice, this list of conditions and the following disclaimer in the
47  *    documentation and/or other materials provided with the distribution.
48  * 3. Neither the name of the University nor the names of its contributors
49  *    may be used to endorse or promote products derived from this software
50  *    without specific prior written permission.
51  *
52  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62  * SUCH DAMAGE.
63  *
64  * @(#)uipc_mbuf.c      8.2 (Berkeley) 1/4/94
65  * $FreeBSD: src/sys/kern/uipc_mbuf.c,v 1.51.2.24 2003/04/15 06:59:29 silby Exp $
66  */
67
68 #include "opt_param.h"
69 #include "opt_mbuf_stress_test.h"
70 #include <sys/param.h>
71 #include <sys/systm.h>
72 #include <sys/file.h>
73 #include <sys/malloc.h>
74 #include <sys/mbuf.h>
75 #include <sys/kernel.h>
76 #include <sys/sysctl.h>
77 #include <sys/domain.h>
78 #include <sys/objcache.h>
79 #include <sys/tree.h>
80 #include <sys/protosw.h>
81 #include <sys/uio.h>
82 #include <sys/thread.h>
83 #include <sys/globaldata.h>
84
85 #include <sys/thread2.h>
86 #include <sys/spinlock2.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 static struct spinlock  mbuf_track_spin = SPINLOCK_INITIALIZER(mbuf_track_spin, "mbuf_track_spin");
138
139 static void
140 mbuftrack(struct mbuf *m)
141 {
142         struct mbtrack *mbt;
143
144         mbt = kmalloc(sizeof(*mbt), M_MTRACK, M_INTWAIT|M_ZERO);
145         spin_lock(&mbuf_track_spin);
146         mbt->m = m;
147         if (mbuf_rb_tree_RB_INSERT(&mbuf_track_root, mbt)) {
148                 spin_unlock(&mbuf_track_spin);
149                 panic("mbuftrack: mbuf %p already being tracked", m);
150         }
151         spin_unlock(&mbuf_track_spin);
152 }
153
154 static void
155 mbufuntrack(struct mbuf *m)
156 {
157         struct mbtrack *mbt;
158
159         spin_lock(&mbuf_track_spin);
160         mbt = mbuf_rb_tree_RB_LOOKUP(&mbuf_track_root, m);
161         if (mbt == NULL) {
162                 spin_unlock(&mbuf_track_spin);
163                 panic("mbufuntrack: mbuf %p was not tracked", m);
164         } else {
165                 mbuf_rb_tree_RB_REMOVE(&mbuf_track_root, mbt);
166                 spin_unlock(&mbuf_track_spin);
167                 kfree(mbt, M_MTRACK);
168         }
169 }
170
171 void
172 mbuftrackid(struct mbuf *m, int trackid)
173 {
174         struct mbtrack *mbt;
175         struct mbuf *n;
176
177         spin_lock(&mbuf_track_spin);
178         while (m) { 
179                 n = m->m_nextpkt;
180                 while (m) {
181                         mbt = mbuf_rb_tree_RB_LOOKUP(&mbuf_track_root, m);
182                         if (mbt == NULL) {
183                                 spin_unlock(&mbuf_track_spin);
184                                 panic("mbuftrackid: mbuf %p not tracked", m);
185                         }
186                         mbt->trackid = trackid;
187                         m = m->m_next;
188                 }
189                 m = n;
190         }
191         spin_unlock(&mbuf_track_spin);
192 }
193
194 static int
195 mbuftrack_callback(struct mbtrack *mbt, void *arg)
196 {
197         struct sysctl_req *req = arg;
198         char buf[64];
199         int error;
200
201         ksnprintf(buf, sizeof(buf), "mbuf %p track %d\n", mbt->m, mbt->trackid);
202
203         spin_unlock(&mbuf_track_spin);
204         error = SYSCTL_OUT(req, buf, strlen(buf));
205         spin_lock(&mbuf_track_spin);
206         if (error)      
207                 return(-error);
208         return(0);
209 }
210
211 static int
212 mbuftrack_show(SYSCTL_HANDLER_ARGS)
213 {
214         int error;
215
216         spin_lock(&mbuf_track_spin);
217         error = mbuf_rb_tree_RB_SCAN(&mbuf_track_root, NULL,
218                                      mbuftrack_callback, req);
219         spin_unlock(&mbuf_track_spin);
220         return (-error);
221 }
222 SYSCTL_PROC(_kern_ipc, OID_AUTO, showmbufs, CTLFLAG_RD|CTLTYPE_STRING,
223             0, 0, mbuftrack_show, "A", "Show all in-use mbufs");
224
225 #else
226
227 #define mbuftrack(m)
228 #define mbufuntrack(m)
229
230 #endif
231
232 static void mbinit(void *);
233 SYSINIT(mbuf, SI_BOOT2_MACHDEP, SI_ORDER_FIRST, mbinit, NULL);
234
235 struct mbtypes_stat {
236         u_long  stats[MT_NTYPES];
237 } __cachealign;
238
239 static struct mbtypes_stat      mbtypes[SMP_MAXCPU];
240
241 static struct mbstat mbstat[SMP_MAXCPU] __cachealign;
242 int     max_linkhdr;
243 int     max_protohdr;
244 int     max_hdr;
245 int     max_datalen;
246 int     m_defragpackets;
247 int     m_defragbytes;
248 int     m_defraguseless;
249 int     m_defragfailure;
250 #ifdef MBUF_STRESS_TEST
251 int     m_defragrandomfailures;
252 #endif
253
254 struct objcache *mbuf_cache, *mbufphdr_cache;
255 struct objcache *mclmeta_cache, *mjclmeta_cache;
256 struct objcache *mbufcluster_cache, *mbufphdrcluster_cache;
257 struct objcache *mbufjcluster_cache, *mbufphdrjcluster_cache;
258
259 struct lock     mbupdate_lk = LOCK_INITIALIZER("mbupdate", 0, 0);
260
261 int             nmbclusters;
262 static int      nmbjclusters;
263 int             nmbufs;
264
265 static int      mjclph_cachefrac;
266 static int      mjcl_cachefrac;
267 static int      mclph_cachefrac;
268 static int      mcl_cachefrac;
269
270 SYSCTL_INT(_kern_ipc, KIPC_MAX_LINKHDR, max_linkhdr, CTLFLAG_RW,
271         &max_linkhdr, 0, "Max size of a link-level header");
272 SYSCTL_INT(_kern_ipc, KIPC_MAX_PROTOHDR, max_protohdr, CTLFLAG_RW,
273         &max_protohdr, 0, "Max size of a protocol header");
274 SYSCTL_INT(_kern_ipc, KIPC_MAX_HDR, max_hdr, CTLFLAG_RW, &max_hdr, 0,
275         "Max size of link+protocol headers");
276 SYSCTL_INT(_kern_ipc, KIPC_MAX_DATALEN, max_datalen, CTLFLAG_RW,
277         &max_datalen, 0, "Max data payload size without headers");
278 SYSCTL_INT(_kern_ipc, OID_AUTO, mbuf_wait, CTLFLAG_RW,
279         &mbuf_wait, 0, "Time in ticks to sleep after failed mbuf allocations");
280 static int do_mbstat(SYSCTL_HANDLER_ARGS);
281
282 SYSCTL_PROC(_kern_ipc, KIPC_MBSTAT, mbstat, CTLTYPE_STRUCT|CTLFLAG_RD,
283         0, 0, do_mbstat, "S,mbstat", "mbuf usage statistics");
284
285 static int do_mbtypes(SYSCTL_HANDLER_ARGS);
286
287 SYSCTL_PROC(_kern_ipc, OID_AUTO, mbtypes, CTLTYPE_ULONG|CTLFLAG_RD,
288         0, 0, do_mbtypes, "LU", "");
289
290 static int
291 do_mbstat(SYSCTL_HANDLER_ARGS)
292 {
293         struct mbstat mbstat_total;
294         struct mbstat *mbstat_totalp;
295         int i;
296
297         bzero(&mbstat_total, sizeof(mbstat_total));
298         mbstat_totalp = &mbstat_total;
299
300         for (i = 0; i < ncpus; i++)
301         {
302                 mbstat_total.m_mbufs += mbstat[i].m_mbufs;      
303                 mbstat_total.m_clusters += mbstat[i].m_clusters;        
304                 mbstat_total.m_jclusters += mbstat[i].m_jclusters;      
305                 mbstat_total.m_clfree += mbstat[i].m_clfree;    
306                 mbstat_total.m_drops += mbstat[i].m_drops;      
307                 mbstat_total.m_wait += mbstat[i].m_wait;        
308                 mbstat_total.m_drain += mbstat[i].m_drain;      
309                 mbstat_total.m_mcfail += mbstat[i].m_mcfail;    
310                 mbstat_total.m_mpfail += mbstat[i].m_mpfail;    
311
312         }
313         /*
314          * The following fields are not cumulative fields so just
315          * get their values once.
316          */
317         mbstat_total.m_msize = mbstat[0].m_msize;       
318         mbstat_total.m_mclbytes = mbstat[0].m_mclbytes; 
319         mbstat_total.m_minclsize = mbstat[0].m_minclsize;       
320         mbstat_total.m_mlen = mbstat[0].m_mlen; 
321         mbstat_total.m_mhlen = mbstat[0].m_mhlen;       
322
323         return(sysctl_handle_opaque(oidp, mbstat_totalp, sizeof(mbstat_total), req));
324 }
325
326 static int
327 do_mbtypes(SYSCTL_HANDLER_ARGS)
328 {
329         u_long totals[MT_NTYPES];
330         int i, j;
331
332         for (i = 0; i < MT_NTYPES; i++)
333                 totals[i] = 0;
334
335         for (i = 0; i < ncpus; i++)
336         {
337                 for (j = 0; j < MT_NTYPES; j++)
338                         totals[j] += mbtypes[i].stats[j];
339         }
340
341         return(sysctl_handle_opaque(oidp, totals, sizeof(totals), req));
342 }
343
344 /*
345  * The variables may be set as boot-time tunables or live.  Setting these
346  * values too low can deadlock your network.  Network interfaces may also
347  * adjust nmbclusters and/or nmbjclusters to account for preloading the
348  * hardware rings.
349  */
350 static int sysctl_nmbclusters(SYSCTL_HANDLER_ARGS);
351 static int sysctl_nmbjclusters(SYSCTL_HANDLER_ARGS);
352 static int sysctl_nmbufs(SYSCTL_HANDLER_ARGS);
353 SYSCTL_PROC(_kern_ipc, KIPC_NMBCLUSTERS, nmbclusters, CTLTYPE_INT | CTLFLAG_RW,
354            0, 0, sysctl_nmbclusters, "I",
355            "Maximum number of mbuf clusters available");
356 SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbjclusters, CTLTYPE_INT | CTLFLAG_RW,
357            0, 0, sysctl_nmbjclusters, "I",
358            "Maximum number of mbuf jclusters available");
359 SYSCTL_PROC(_kern_ipc, OID_AUTO, nmbufs, CTLTYPE_INT | CTLFLAG_RW,
360            0, 0, sysctl_nmbufs, "I",
361            "Maximum number of mbufs available");
362
363 SYSCTL_INT(_kern_ipc, OID_AUTO, mjclph_cachefrac, CTLFLAG_RD,
364            &mjclph_cachefrac, 0,
365            "Fraction of cacheable mbuf jclusters w/ pkthdr");
366 SYSCTL_INT(_kern_ipc, OID_AUTO, mjcl_cachefrac, CTLFLAG_RD,
367            &mjcl_cachefrac, 0,
368            "Fraction of cacheable mbuf jclusters");
369 SYSCTL_INT(_kern_ipc, OID_AUTO, mclph_cachefrac, CTLFLAG_RD,
370            &mclph_cachefrac, 0,
371            "Fraction of cacheable mbuf clusters w/ pkthdr");
372 SYSCTL_INT(_kern_ipc, OID_AUTO, mcl_cachefrac, CTLFLAG_RD,
373            &mcl_cachefrac, 0, "Fraction of cacheable mbuf clusters");
374
375 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragpackets, CTLFLAG_RD,
376            &m_defragpackets, 0, "Number of defragment packets");
377 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragbytes, CTLFLAG_RD,
378            &m_defragbytes, 0, "Number of defragment bytes");
379 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defraguseless, CTLFLAG_RD,
380            &m_defraguseless, 0, "Number of useless defragment mbuf chain operations");
381 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragfailure, CTLFLAG_RD,
382            &m_defragfailure, 0, "Number of failed defragment mbuf chain operations");
383 #ifdef MBUF_STRESS_TEST
384 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragrandomfailures, CTLFLAG_RW,
385            &m_defragrandomfailures, 0, "");
386 #endif
387
388 static MALLOC_DEFINE(M_MBUF, "mbuf", "mbuf");
389 static MALLOC_DEFINE(M_MBUFCL, "mbufcl", "mbufcl");
390 static MALLOC_DEFINE(M_MCLMETA, "mclmeta", "mclmeta");
391
392 static void m_reclaim (void);
393 static void m_mclref(void *arg);
394 static void m_mclfree(void *arg);
395 static void m_mjclfree(void *arg);
396
397 /*
398  * NOTE: Default NMBUFS must take into account a possible DOS attack
399  *       using fd passing on unix domain sockets.
400  */
401 #ifndef NMBCLUSTERS
402 #define NMBCLUSTERS     (512 + maxusers * 16)
403 #endif
404 #ifndef MJCLPH_CACHEFRAC
405 #define MJCLPH_CACHEFRAC 16
406 #endif
407 #ifndef MJCL_CACHEFRAC
408 #define MJCL_CACHEFRAC  4
409 #endif
410 #ifndef MCLPH_CACHEFRAC
411 #define MCLPH_CACHEFRAC 16
412 #endif
413 #ifndef MCL_CACHEFRAC
414 #define MCL_CACHEFRAC   4
415 #endif
416 #ifndef NMBJCLUSTERS
417 #define NMBJCLUSTERS    (NMBCLUSTERS / 2)
418 #endif
419 #ifndef NMBUFS
420 #define NMBUFS          (nmbclusters * 2 + maxfiles)
421 #endif
422
423 /*
424  * Perform sanity checks of tunables declared above.
425  */
426 static void
427 tunable_mbinit(void *dummy)
428 {
429         /*
430          * This has to be done before VM init.
431          */
432         nmbclusters = NMBCLUSTERS;
433         TUNABLE_INT_FETCH("kern.ipc.nmbclusters", &nmbclusters);
434         mjclph_cachefrac = MJCLPH_CACHEFRAC;
435         TUNABLE_INT_FETCH("kern.ipc.mjclph_cachefrac", &mjclph_cachefrac);
436         mjcl_cachefrac = MJCL_CACHEFRAC;
437         TUNABLE_INT_FETCH("kern.ipc.mjcl_cachefrac", &mjcl_cachefrac);
438         mclph_cachefrac = MCLPH_CACHEFRAC;
439         TUNABLE_INT_FETCH("kern.ipc.mclph_cachefrac", &mclph_cachefrac);
440         mcl_cachefrac = MCL_CACHEFRAC;
441         TUNABLE_INT_FETCH("kern.ipc.mcl_cachefrac", &mcl_cachefrac);
442
443         /*
444          * WARNING! each mcl cache feeds two mbuf caches, so the minimum
445          *          cachefrac is 2.  For safety, use 3.
446          */
447         if (mjclph_cachefrac < 3)
448                 mjclph_cachefrac = 3;
449         if (mjcl_cachefrac < 3)
450                 mjcl_cachefrac = 3;
451         if (mclph_cachefrac < 3)
452                 mclph_cachefrac = 3;
453         if (mcl_cachefrac < 3)
454                 mcl_cachefrac = 3;
455
456         nmbjclusters = NMBJCLUSTERS;
457         TUNABLE_INT_FETCH("kern.ipc.nmbjclusters", &nmbjclusters);
458
459         nmbufs = NMBUFS;
460         TUNABLE_INT_FETCH("kern.ipc.nmbufs", &nmbufs);
461
462         /* Sanity checks */
463         if (nmbufs < nmbclusters * 2)
464                 nmbufs = nmbclusters * 2;
465 }
466 SYSINIT(tunable_mbinit, SI_BOOT1_TUNABLES, SI_ORDER_ANY,
467         tunable_mbinit, NULL);
468
469 /*
470  * Sysctl support to update nmbclusters, nmbjclusters, and nmbufs.
471  */
472 static int
473 sysctl_nmbclusters(SYSCTL_HANDLER_ARGS)
474 {
475         int error;
476         int value;
477
478         value = nmbclusters;
479         error = sysctl_handle_int(oidp, &value, 0, req);
480         if (error || req->newptr == NULL)
481                 return error;
482
483         lockmgr(&mbupdate_lk, LK_EXCLUSIVE);
484         if (nmbclusters != value) {
485                 nmbclusters = value;
486                 mbupdatelimits();
487         }
488         lockmgr(&mbupdate_lk, LK_RELEASE);
489         return 0;
490 }
491
492 static int
493 sysctl_nmbjclusters(SYSCTL_HANDLER_ARGS)
494 {
495         int error;
496         int value;
497
498         value = nmbjclusters;
499         error = sysctl_handle_int(oidp, &value, 0, req);
500         if (error || req->newptr == NULL)
501                 return error;
502
503         lockmgr(&mbupdate_lk, LK_EXCLUSIVE);
504         if (nmbjclusters != value) {
505                 nmbjclusters = value;
506                 mbupdatelimits();
507         }
508         lockmgr(&mbupdate_lk, LK_RELEASE);
509         return 0;
510 }
511
512 static int
513 sysctl_nmbufs(SYSCTL_HANDLER_ARGS)
514 {
515         int error;
516         int value;
517
518         value = nmbufs;
519         error = sysctl_handle_int(oidp, &value, 0, req);
520         if (error || req->newptr == NULL)
521                 return error;
522
523         lockmgr(&mbupdate_lk, LK_EXCLUSIVE);
524         if (nmbufs != value) {
525                 nmbufs = value;
526                 mbupdatelimits();
527         }
528         lockmgr(&mbupdate_lk, LK_RELEASE);
529         return 0;
530 }
531
532 /* "number of clusters of pages" */
533 #define NCL_INIT        1
534
535 #define NMB_INIT        16
536
537 /*
538  * The mbuf object cache only guarantees that m_next and m_nextpkt are
539  * NULL and that m_data points to the beginning of the data area.  In
540  * particular, m_len and m_pkthdr.len are uninitialized.  It is the
541  * responsibility of the caller to initialize those fields before use.
542  */
543 static __inline boolean_t
544 mbuf_ctor(void *obj, void *private, int ocflags)
545 {
546         struct mbuf *m = obj;
547
548         m->m_next = NULL;
549         m->m_nextpkt = NULL;
550         m->m_data = m->m_dat;
551         m->m_flags = 0;
552
553         return (TRUE);
554 }
555
556 /*
557  * Initialize the mbuf and the packet header fields.
558  */
559 static boolean_t
560 mbufphdr_ctor(void *obj, void *private, int ocflags)
561 {
562         struct mbuf *m = obj;
563
564         m->m_next = NULL;
565         m->m_nextpkt = NULL;
566         m->m_data = m->m_pktdat;
567         m->m_flags = M_PKTHDR | M_PHCACHE;
568
569         m->m_pkthdr.rcvif = NULL;       /* eliminate XXX JH */
570         SLIST_INIT(&m->m_pkthdr.tags);
571         m->m_pkthdr.csum_flags = 0;     /* eliminate XXX JH */
572         m->m_pkthdr.fw_flags = 0;       /* eliminate XXX JH */
573
574         return (TRUE);
575 }
576
577 /*
578  * A mbcluster object consists of 2K (MCLBYTES) cluster and a refcount.
579  */
580 static boolean_t
581 mclmeta_ctor(void *obj, void *private, int ocflags)
582 {
583         struct mbcluster *cl = obj;
584         void *buf;
585
586         if (ocflags & M_NOWAIT)
587                 buf = kmalloc(MCLBYTES, M_MBUFCL, M_NOWAIT | M_ZERO);
588         else
589                 buf = kmalloc(MCLBYTES, M_MBUFCL, M_INTWAIT | M_ZERO);
590         if (buf == NULL)
591                 return (FALSE);
592         cl->mcl_refs = 0;
593         cl->mcl_data = buf;
594         return (TRUE);
595 }
596
597 static boolean_t
598 mjclmeta_ctor(void *obj, void *private, int ocflags)
599 {
600         struct mbcluster *cl = obj;
601         void *buf;
602
603         if (ocflags & M_NOWAIT)
604                 buf = kmalloc(MJUMPAGESIZE, M_MBUFCL, M_NOWAIT | M_ZERO);
605         else
606                 buf = kmalloc(MJUMPAGESIZE, M_MBUFCL, M_INTWAIT | M_ZERO);
607         if (buf == NULL)
608                 return (FALSE);
609         cl->mcl_refs = 0;
610         cl->mcl_data = buf;
611         return (TRUE);
612 }
613
614 static void
615 mclmeta_dtor(void *obj, void *private)
616 {
617         struct mbcluster *mcl = obj;
618
619         KKASSERT(mcl->mcl_refs == 0);
620         kfree(mcl->mcl_data, M_MBUFCL);
621 }
622
623 static void
624 linkjcluster(struct mbuf *m, struct mbcluster *cl, uint size)
625 {
626         /*
627          * Add the cluster to the mbuf.  The caller will detect that the
628          * mbuf now has an attached cluster.
629          */
630         m->m_ext.ext_arg = cl;
631         m->m_ext.ext_buf = cl->mcl_data;
632         m->m_ext.ext_ref = m_mclref;
633         if (size != MCLBYTES)
634                 m->m_ext.ext_free = m_mjclfree;
635         else
636                 m->m_ext.ext_free = m_mclfree;
637         m->m_ext.ext_size = size;
638         atomic_add_int(&cl->mcl_refs, 1);
639
640         m->m_data = m->m_ext.ext_buf;
641         m->m_flags |= M_EXT | M_EXT_CLUSTER;
642 }
643
644 static void
645 linkcluster(struct mbuf *m, struct mbcluster *cl)
646 {
647         linkjcluster(m, cl, MCLBYTES);
648 }
649
650 static boolean_t
651 mbufphdrcluster_ctor(void *obj, void *private, int ocflags)
652 {
653         struct mbuf *m = obj;
654         struct mbcluster *cl;
655
656         mbufphdr_ctor(obj, private, ocflags);
657         cl = objcache_get(mclmeta_cache, ocflags);
658         if (cl == NULL) {
659                 ++mbstat[mycpu->gd_cpuid].m_drops;
660                 return (FALSE);
661         }
662         m->m_flags |= M_CLCACHE;
663         linkcluster(m, cl);
664         return (TRUE);
665 }
666
667 static boolean_t
668 mbufphdrjcluster_ctor(void *obj, void *private, int ocflags)
669 {
670         struct mbuf *m = obj;
671         struct mbcluster *cl;
672
673         mbufphdr_ctor(obj, private, ocflags);
674         cl = objcache_get(mjclmeta_cache, ocflags);
675         if (cl == NULL) {
676                 ++mbstat[mycpu->gd_cpuid].m_drops;
677                 return (FALSE);
678         }
679         m->m_flags |= M_CLCACHE;
680         linkjcluster(m, cl, MJUMPAGESIZE);
681         return (TRUE);
682 }
683
684 static boolean_t
685 mbufcluster_ctor(void *obj, void *private, int ocflags)
686 {
687         struct mbuf *m = obj;
688         struct mbcluster *cl;
689
690         mbuf_ctor(obj, private, ocflags);
691         cl = objcache_get(mclmeta_cache, ocflags);
692         if (cl == NULL) {
693                 ++mbstat[mycpu->gd_cpuid].m_drops;
694                 return (FALSE);
695         }
696         m->m_flags |= M_CLCACHE;
697         linkcluster(m, cl);
698         return (TRUE);
699 }
700
701 static boolean_t
702 mbufjcluster_ctor(void *obj, void *private, int ocflags)
703 {
704         struct mbuf *m = obj;
705         struct mbcluster *cl;
706
707         mbuf_ctor(obj, private, ocflags);
708         cl = objcache_get(mjclmeta_cache, ocflags);
709         if (cl == NULL) {
710                 ++mbstat[mycpu->gd_cpuid].m_drops;
711                 return (FALSE);
712         }
713         m->m_flags |= M_CLCACHE;
714         linkjcluster(m, cl, MJUMPAGESIZE);
715         return (TRUE);
716 }
717
718 /*
719  * Used for both the cluster and cluster PHDR caches.
720  *
721  * The mbuf may have lost its cluster due to sharing, deal
722  * with the situation by checking M_EXT.
723  */
724 static void
725 mbufcluster_dtor(void *obj, void *private)
726 {
727         struct mbuf *m = obj;
728         struct mbcluster *mcl;
729
730         if (m->m_flags & M_EXT) {
731                 KKASSERT((m->m_flags & M_EXT_CLUSTER) != 0);
732                 mcl = m->m_ext.ext_arg;
733                 KKASSERT(mcl->mcl_refs == 1);
734                 mcl->mcl_refs = 0;
735                 if (m->m_flags & M_EXT && m->m_ext.ext_size != MCLBYTES)
736                         objcache_put(mjclmeta_cache, mcl);
737                 else
738                         objcache_put(mclmeta_cache, mcl);
739         }
740 }
741
742 struct objcache_malloc_args mbuf_malloc_args = { MSIZE, M_MBUF };
743 struct objcache_malloc_args mclmeta_malloc_args =
744         { sizeof(struct mbcluster), M_MCLMETA };
745
746 /* ARGSUSED*/
747 static void
748 mbinit(void *dummy)
749 {
750         int mb_limit, cl_limit, ncl_limit, jcl_limit;
751         int limit;
752         int i;
753
754         /*
755          * Initialize statistics
756          */
757         for (i = 0; i < ncpus; i++) {
758                 mbstat[i].m_msize = MSIZE;
759                 mbstat[i].m_mclbytes = MCLBYTES;
760                 mbstat[i].m_mjumpagesize = MJUMPAGESIZE;
761                 mbstat[i].m_minclsize = MINCLSIZE;
762                 mbstat[i].m_mlen = MLEN;
763                 mbstat[i].m_mhlen = MHLEN;
764         }
765
766         /*
767          * Create object caches and save cluster limits, which will
768          * be used to adjust backing kmalloc pools' limit later.
769          */
770
771         mb_limit = cl_limit = 0;
772
773         limit = nmbufs;
774         mbuf_cache = objcache_create("mbuf",
775             limit, nmbufs / 4,
776             mbuf_ctor, NULL, NULL,
777             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
778         mb_limit += limit;
779
780         limit = nmbufs;
781         mbufphdr_cache = objcache_create("mbuf pkt hdr",
782             limit, nmbufs / 4,
783             mbufphdr_ctor, NULL, NULL,
784             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
785         mb_limit += limit;
786
787         ncl_limit = nmbclusters;
788         mclmeta_cache = objcache_create("cluster mbuf",
789             ncl_limit, nmbclusters / 4,
790             mclmeta_ctor, mclmeta_dtor, NULL,
791             objcache_malloc_alloc, objcache_malloc_free, &mclmeta_malloc_args);
792         cl_limit += ncl_limit;
793
794         jcl_limit = nmbjclusters;
795         mjclmeta_cache = objcache_create("jcluster mbuf",
796             jcl_limit, nmbjclusters / 4,
797             mjclmeta_ctor, mclmeta_dtor, NULL,
798             objcache_malloc_alloc, objcache_malloc_free, &mclmeta_malloc_args);
799         cl_limit += jcl_limit;
800
801         limit = nmbclusters;
802         mbufcluster_cache = objcache_create("mbuf + cluster",
803             limit, nmbclusters / mcl_cachefrac,
804             mbufcluster_ctor, mbufcluster_dtor, NULL,
805             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
806         mb_limit += limit;
807
808         limit = nmbclusters;
809         mbufphdrcluster_cache = objcache_create("mbuf pkt hdr + cluster",
810             limit, nmbclusters / mclph_cachefrac,
811             mbufphdrcluster_ctor, mbufcluster_dtor, NULL,
812             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
813         mb_limit += limit;
814
815         limit = nmbjclusters;
816         mbufjcluster_cache = objcache_create("mbuf + jcluster",
817             limit, nmbjclusters / mjcl_cachefrac,
818             mbufjcluster_ctor, mbufcluster_dtor, NULL,
819             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
820         mb_limit += limit;
821
822         limit = nmbjclusters;
823         mbufphdrjcluster_cache = objcache_create("mbuf pkt hdr + jcluster",
824             limit, nmbjclusters / mjclph_cachefrac,
825             mbufphdrjcluster_ctor, mbufcluster_dtor, NULL,
826             objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
827         mb_limit += limit;
828
829         /*
830          * Adjust backing kmalloc pools' limit
831          *
832          * NOTE: We raise the limit by another 1/8 to take the effect
833          * of loosememuse into account.
834          */
835         cl_limit += cl_limit / 8;
836         kmalloc_raise_limit(mclmeta_malloc_args.mtype,
837                             mclmeta_malloc_args.objsize * (size_t)cl_limit);
838         kmalloc_raise_limit(M_MBUFCL,
839                             (MCLBYTES * (size_t)ncl_limit) +
840                             (MJUMPAGESIZE * (size_t)jcl_limit));
841
842         mb_limit += mb_limit / 8;
843         kmalloc_raise_limit(mbuf_malloc_args.mtype,
844                             mbuf_malloc_args.objsize * (size_t)mb_limit);
845 }
846
847 /*
848  * Adjust mbuf limits after changes have been made
849  *
850  * Caller must hold mbupdate_lk
851  */
852 void
853 mbupdatelimits(void)
854 {
855         int mb_limit, cl_limit, ncl_limit, jcl_limit;
856         int limit;
857
858         KASSERT(lockstatus(&mbupdate_lk, curthread) != 0,
859             ("mbupdate_lk is not held"));
860
861         /*
862          * Figure out adjustments to object caches after nmbufs, nmbclusters,
863          * or nmbjclusters has been modified.
864          */
865         mb_limit = cl_limit = 0;
866
867         limit = nmbufs;
868         objcache_set_cluster_limit(mbuf_cache, limit);
869         mb_limit += limit;
870
871         limit = nmbufs;
872         objcache_set_cluster_limit(mbufphdr_cache, limit);
873         mb_limit += limit;
874
875         ncl_limit = nmbclusters;
876         objcache_set_cluster_limit(mclmeta_cache, ncl_limit);
877         cl_limit += ncl_limit;
878
879         jcl_limit = nmbjclusters;
880         objcache_set_cluster_limit(mjclmeta_cache, jcl_limit);
881         cl_limit += jcl_limit;
882
883         limit = nmbclusters;
884         objcache_set_cluster_limit(mbufcluster_cache, limit);
885         mb_limit += limit;
886
887         limit = nmbclusters;
888         objcache_set_cluster_limit(mbufphdrcluster_cache, limit);
889         mb_limit += limit;
890
891         limit = nmbjclusters;
892         objcache_set_cluster_limit(mbufjcluster_cache, limit);
893         mb_limit += limit;
894
895         limit = nmbjclusters;
896         objcache_set_cluster_limit(mbufphdrjcluster_cache, limit);
897         mb_limit += limit;
898
899         /*
900          * Adjust backing kmalloc pools' limit
901          *
902          * NOTE: We raise the limit by another 1/8 to take the effect
903          * of loosememuse into account.
904          */
905         cl_limit += cl_limit / 8;
906         kmalloc_raise_limit(mclmeta_malloc_args.mtype,
907                             mclmeta_malloc_args.objsize * (size_t)cl_limit);
908         kmalloc_raise_limit(M_MBUFCL,
909                             (MCLBYTES * (size_t)ncl_limit) +
910                             (MJUMPAGESIZE * (size_t)jcl_limit));
911         mb_limit += mb_limit / 8;
912         kmalloc_raise_limit(mbuf_malloc_args.mtype,
913                             mbuf_malloc_args.objsize * (size_t)mb_limit);
914 }
915
916 /*
917  * Return the number of references to this mbuf's data.  0 is returned
918  * if the mbuf is not M_EXT, a reference count is returned if it is
919  * M_EXT | M_EXT_CLUSTER, and 99 is returned if it is a special M_EXT.
920  */
921 int
922 m_sharecount(struct mbuf *m)
923 {
924         switch (m->m_flags & (M_EXT | M_EXT_CLUSTER)) {
925         case 0:
926                 return (0);
927         case M_EXT:
928                 return (99);
929         case M_EXT | M_EXT_CLUSTER:
930                 return (((struct mbcluster *)m->m_ext.ext_arg)->mcl_refs);
931         }
932         /* NOTREACHED */
933         return (0);             /* to shut up compiler */
934 }
935
936 /*
937  * change mbuf to new type
938  */
939 void
940 m_chtype(struct mbuf *m, int type)
941 {
942         struct globaldata *gd = mycpu;
943
944         ++mbtypes[gd->gd_cpuid].stats[type];
945         --mbtypes[gd->gd_cpuid].stats[m->m_type];
946         m->m_type = type;
947 }
948
949 static void
950 m_reclaim(void)
951 {
952         struct domain *dp;
953         struct protosw *pr;
954
955         kprintf("Debug: m_reclaim() called\n");
956
957         SLIST_FOREACH(dp, &domains, dom_next) {
958                 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
959                         if (pr->pr_drain)
960                                 (*pr->pr_drain)();
961                 }
962         }
963         ++mbstat[mycpu->gd_cpuid].m_drain;
964 }
965
966 static __inline void
967 updatestats(struct mbuf *m, int type)
968 {
969         struct globaldata *gd = mycpu;
970
971         m->m_type = type;
972         mbuftrack(m);
973 #ifdef MBUF_DEBUG
974         KASSERT(m->m_next == NULL, ("mbuf %p: bad m_next in get", m));
975         KASSERT(m->m_nextpkt == NULL, ("mbuf %p: bad m_nextpkt in get", m));
976 #endif
977
978         ++mbtypes[gd->gd_cpuid].stats[type];
979         ++mbstat[gd->gd_cpuid].m_mbufs;
980
981 }
982
983 /*
984  * Allocate an mbuf.
985  */
986 struct mbuf *
987 m_get(int how, int type)
988 {
989         struct mbuf *m;
990         int ntries = 0;
991         int ocf = MB_OCFLAG(how);
992
993 retryonce:
994
995         m = objcache_get(mbuf_cache, ocf);
996
997         if (m == NULL) {
998                 if ((ocf & M_WAITOK) && ntries++ == 0) {
999                         struct objcache *reclaimlist[] = {
1000                                 mbufphdr_cache,
1001                                 mbufcluster_cache,
1002                                 mbufphdrcluster_cache,
1003                                 mbufjcluster_cache,
1004                                 mbufphdrjcluster_cache
1005                         };
1006                         const int nreclaims = NELEM(reclaimlist);
1007
1008                         if (!objcache_reclaimlist(reclaimlist, nreclaims, ocf))
1009                                 m_reclaim();
1010                         goto retryonce;
1011                 }
1012                 ++mbstat[mycpu->gd_cpuid].m_drops;
1013                 return (NULL);
1014         }
1015 #ifdef MBUF_DEBUG
1016         KASSERT(m->m_data == m->m_dat, ("mbuf %p: bad m_data in get", m));
1017 #endif
1018         m->m_len = 0;
1019
1020         updatestats(m, type);
1021         return (m);
1022 }
1023
1024 struct mbuf *
1025 m_gethdr(int how, int type)
1026 {
1027         struct mbuf *m;
1028         int ocf = MB_OCFLAG(how);
1029         int ntries = 0;
1030
1031 retryonce:
1032
1033         m = objcache_get(mbufphdr_cache, ocf);
1034
1035         if (m == NULL) {
1036                 if ((ocf & M_WAITOK) && ntries++ == 0) {
1037                         struct objcache *reclaimlist[] = {
1038                                 mbuf_cache,
1039                                 mbufcluster_cache, mbufphdrcluster_cache,
1040                                 mbufjcluster_cache, mbufphdrjcluster_cache
1041                         };
1042                         const int nreclaims = NELEM(reclaimlist);
1043
1044                         if (!objcache_reclaimlist(reclaimlist, nreclaims, ocf))
1045                                 m_reclaim();
1046                         goto retryonce;
1047                 }
1048                 ++mbstat[mycpu->gd_cpuid].m_drops;
1049                 return (NULL);
1050         }
1051 #ifdef MBUF_DEBUG
1052         KASSERT(m->m_data == m->m_pktdat, ("mbuf %p: bad m_data in get", m));
1053 #endif
1054         m->m_len = 0;
1055         m->m_pkthdr.len = 0;
1056
1057         updatestats(m, type);
1058         return (m);
1059 }
1060
1061 /*
1062  * Get a mbuf (not a mbuf cluster!) and zero it.
1063  * Deprecated.
1064  */
1065 struct mbuf *
1066 m_getclr(int how, int type)
1067 {
1068         struct mbuf *m;
1069
1070         m = m_get(how, type);
1071         if (m != NULL)
1072                 bzero(m->m_data, MLEN);
1073         return (m);
1074 }
1075
1076 static struct mbuf *
1077 m_getcl_cache(int how, short type, int flags, struct objcache *mbclc,
1078     struct objcache *mbphclc, u_long *cl_stats)
1079 {
1080         struct mbuf *m = NULL;
1081         int ocflags = MB_OCFLAG(how);
1082         int ntries = 0;
1083
1084 retryonce:
1085
1086         if (flags & M_PKTHDR)
1087                 m = objcache_get(mbphclc, ocflags);
1088         else
1089                 m = objcache_get(mbclc, ocflags);
1090
1091         if (m == NULL) {
1092                 if ((ocflags & M_WAITOK) && ntries++ == 0) {
1093                         struct objcache *reclaimlist[1];
1094
1095                         if (flags & M_PKTHDR)
1096                                 reclaimlist[0] = mbclc;
1097                         else
1098                                 reclaimlist[0] = mbphclc;
1099                         if (!objcache_reclaimlist(reclaimlist, 1, ocflags))
1100                                 m_reclaim();
1101                         goto retryonce;
1102                 }
1103                 ++mbstat[mycpu->gd_cpuid].m_drops;
1104                 return (NULL);
1105         }
1106
1107 #ifdef MBUF_DEBUG
1108         KASSERT(m->m_data == m->m_ext.ext_buf,
1109                 ("mbuf %p: bad m_data in get", m));
1110 #endif
1111         m->m_type = type;
1112         m->m_len = 0;
1113         m->m_pkthdr.len = 0;    /* just do it unconditonally */
1114
1115         mbuftrack(m);
1116
1117         ++mbtypes[mycpu->gd_cpuid].stats[type];
1118         ++(*cl_stats);
1119         return (m);
1120 }
1121
1122 struct mbuf *
1123 m_getjcl(int how, short type, int flags, size_t size)
1124 {
1125         struct objcache *mbclc, *mbphclc;
1126         u_long *cl_stats;
1127
1128         switch (size) {
1129         case MCLBYTES:
1130                 mbclc = mbufcluster_cache;
1131                 mbphclc = mbufphdrcluster_cache;
1132                 cl_stats = &mbstat[mycpu->gd_cpuid].m_clusters;
1133                 break;
1134
1135         default:
1136                 mbclc = mbufjcluster_cache;
1137                 mbphclc = mbufphdrjcluster_cache;
1138                 cl_stats = &mbstat[mycpu->gd_cpuid].m_jclusters;
1139                 break;
1140         }
1141         return m_getcl_cache(how, type, flags, mbclc, mbphclc, cl_stats);
1142 }
1143
1144 /*
1145  * Returns an mbuf with an attached cluster.
1146  * Because many network drivers use this kind of buffers a lot, it is
1147  * convenient to keep a small pool of free buffers of this kind.
1148  * Even a small size such as 10 gives about 10% improvement in the
1149  * forwarding rate in a bridge or router.
1150  */
1151 struct mbuf *
1152 m_getcl(int how, short type, int flags)
1153 {
1154         return m_getcl_cache(how, type, flags,
1155             mbufcluster_cache, mbufphdrcluster_cache,
1156             &mbstat[mycpu->gd_cpuid].m_clusters);
1157 }
1158
1159 /*
1160  * Allocate chain of requested length.
1161  */
1162 struct mbuf *
1163 m_getc(int len, int how, int type)
1164 {
1165         struct mbuf *n, *nfirst = NULL, **ntail = &nfirst;
1166         int nsize;
1167
1168         while (len > 0) {
1169                 n = m_getl(len, how, type, 0, &nsize);
1170                 if (n == NULL)
1171                         goto failed;
1172                 n->m_len = 0;
1173                 *ntail = n;
1174                 ntail = &n->m_next;
1175                 len -= nsize;
1176         }
1177         return (nfirst);
1178
1179 failed:
1180         m_freem(nfirst);
1181         return (NULL);
1182 }
1183
1184 /*
1185  * Allocate len-worth of mbufs and/or mbuf clusters (whatever fits best)
1186  * and return a pointer to the head of the allocated chain. If m0 is
1187  * non-null, then we assume that it is a single mbuf or an mbuf chain to
1188  * which we want len bytes worth of mbufs and/or clusters attached, and so
1189  * if we succeed in allocating it, we will just return a pointer to m0.
1190  *
1191  * If we happen to fail at any point during the allocation, we will free
1192  * up everything we have already allocated and return NULL.
1193  *
1194  * Deprecated.  Use m_getc() and m_cat() instead.
1195  */
1196 struct mbuf *
1197 m_getm(struct mbuf *m0, int len, int type, int how)
1198 {
1199         struct mbuf *nfirst;
1200
1201         nfirst = m_getc(len, how, type);
1202
1203         if (m0 != NULL) {
1204                 m_last(m0)->m_next = nfirst;
1205                 return (m0);
1206         }
1207
1208         return (nfirst);
1209 }
1210
1211 /*
1212  * Adds a cluster to a normal mbuf, M_EXT is set on success.
1213  * Deprecated.  Use m_getcl() instead.
1214  */
1215 void
1216 m_mclget(struct mbuf *m, int how)
1217 {
1218         struct mbcluster *mcl;
1219
1220         KKASSERT((m->m_flags & M_EXT) == 0);
1221         mcl = objcache_get(mclmeta_cache, MB_OCFLAG(how));
1222         if (mcl != NULL) {
1223                 linkcluster(m, mcl);
1224                 ++mbstat[mycpu->gd_cpuid].m_clusters;
1225         } else {
1226                 ++mbstat[mycpu->gd_cpuid].m_drops;
1227         }
1228 }
1229
1230 /*
1231  * Updates to mbcluster must be MPSAFE.  Only an entity which already has
1232  * a reference to the cluster can ref it, so we are in no danger of 
1233  * racing an add with a subtract.  But the operation must still be atomic
1234  * since multiple entities may have a reference on the cluster.
1235  *
1236  * m_mclfree() is almost the same but it must contend with two entities
1237  * freeing the cluster at the same time.
1238  */
1239 static void
1240 m_mclref(void *arg)
1241 {
1242         struct mbcluster *mcl = arg;
1243
1244         atomic_add_int(&mcl->mcl_refs, 1);
1245 }
1246
1247 /*
1248  * When dereferencing a cluster we have to deal with a N->0 race, where
1249  * N entities free their references simultaniously.  To do this we use
1250  * atomic_fetchadd_int().
1251  */
1252 static void
1253 m_mclfree(void *arg)
1254 {
1255         struct mbcluster *mcl = arg;
1256
1257         if (atomic_fetchadd_int(&mcl->mcl_refs, -1) == 1) {
1258                 --mbstat[mycpu->gd_cpuid].m_clusters;
1259                 objcache_put(mclmeta_cache, mcl);
1260         }
1261 }
1262
1263 static void
1264 m_mjclfree(void *arg)
1265 {
1266         struct mbcluster *mcl = arg;
1267
1268         if (atomic_fetchadd_int(&mcl->mcl_refs, -1) == 1) {
1269                 --mbstat[mycpu->gd_cpuid].m_jclusters;
1270                 objcache_put(mjclmeta_cache, mcl);
1271         }
1272 }
1273
1274 /*
1275  * Free a single mbuf and any associated external storage.  The successor,
1276  * if any, is returned.
1277  *
1278  * We do need to check non-first mbuf for m_aux, since some of existing
1279  * code does not call M_PREPEND properly.
1280  * (example: call to bpf_mtap from drivers)
1281  */
1282
1283 #ifdef MBUF_DEBUG
1284
1285 struct mbuf  *
1286 _m_free(struct mbuf *m, const char *func)
1287
1288 #else
1289
1290 struct mbuf *
1291 m_free(struct mbuf *m)
1292
1293 #endif
1294 {
1295         struct mbuf *n;
1296         struct globaldata *gd = mycpu;
1297
1298         KASSERT(m->m_type != MT_FREE, ("freeing free mbuf %p", m));
1299         KASSERT(M_TRAILINGSPACE(m) >= 0, ("overflowed mbuf %p", m));
1300         --mbtypes[gd->gd_cpuid].stats[m->m_type];
1301
1302         n = m->m_next;
1303
1304         /*
1305          * Make sure the mbuf is in constructed state before returning it
1306          * to the objcache.
1307          */
1308         m->m_next = NULL;
1309         mbufuntrack(m);
1310 #ifdef MBUF_DEBUG
1311         m->m_hdr.mh_lastfunc = func;
1312 #endif
1313 #ifdef notyet
1314         KKASSERT(m->m_nextpkt == NULL);
1315 #else
1316         if (m->m_nextpkt != NULL) {
1317                 static int afewtimes = 10;
1318
1319                 if (afewtimes-- > 0) {
1320                         kprintf("mfree: m->m_nextpkt != NULL\n");
1321                         print_backtrace(-1);
1322                 }
1323                 m->m_nextpkt = NULL;
1324         }
1325 #endif
1326         if (m->m_flags & M_PKTHDR) {
1327                 m_tag_delete_chain(m);          /* eliminate XXX JH */
1328         }
1329
1330         m->m_flags &= (M_EXT | M_EXT_CLUSTER | M_CLCACHE | M_PHCACHE);
1331
1332         /*
1333          * Clean the M_PKTHDR state so we can return the mbuf to its original
1334          * cache.  This is based on the PHCACHE flag which tells us whether
1335          * the mbuf was originally allocated out of a packet-header cache
1336          * or a non-packet-header cache.
1337          */
1338         if (m->m_flags & M_PHCACHE) {
1339                 m->m_flags |= M_PKTHDR;
1340                 m->m_pkthdr.rcvif = NULL;       /* eliminate XXX JH */
1341                 m->m_pkthdr.csum_flags = 0;     /* eliminate XXX JH */
1342                 m->m_pkthdr.fw_flags = 0;       /* eliminate XXX JH */
1343                 SLIST_INIT(&m->m_pkthdr.tags);
1344         }
1345
1346         /*
1347          * Handle remaining flags combinations.  M_CLCACHE tells us whether
1348          * the mbuf was originally allocated from a cluster cache or not,
1349          * and is totally separate from whether the mbuf is currently
1350          * associated with a cluster.
1351          */
1352         switch(m->m_flags & (M_CLCACHE | M_EXT | M_EXT_CLUSTER)) {
1353         case M_CLCACHE | M_EXT | M_EXT_CLUSTER:
1354                 /*
1355                  * mbuf+cluster cache case.  The mbuf was allocated from the
1356                  * combined mbuf_cluster cache and can be returned to the
1357                  * cache if the cluster hasn't been shared.
1358                  */
1359                 if (m_sharecount(m) == 1) {
1360                         /*
1361                          * The cluster has not been shared, we can just
1362                          * reset the data pointer and return the mbuf
1363                          * to the cluster cache.  Note that the reference
1364                          * count is left intact (it is still associated with
1365                          * an mbuf).
1366                          */
1367                         m->m_data = m->m_ext.ext_buf;
1368                         if (m->m_flags & M_EXT && m->m_ext.ext_size != MCLBYTES) {
1369                                 if (m->m_flags & M_PHCACHE)
1370                                         objcache_put(mbufphdrjcluster_cache, m);
1371                                 else
1372                                         objcache_put(mbufjcluster_cache, m);
1373                                 --mbstat[mycpu->gd_cpuid].m_jclusters;
1374                         } else {
1375                                 if (m->m_flags & M_PHCACHE)
1376                                         objcache_put(mbufphdrcluster_cache, m);
1377                                 else
1378                                         objcache_put(mbufcluster_cache, m);
1379                                 --mbstat[mycpu->gd_cpuid].m_clusters;
1380                         }
1381                 } else {
1382                         /*
1383                          * Hell.  Someone else has a ref on this cluster,
1384                          * we have to disconnect it which means we can't
1385                          * put it back into the mbufcluster_cache, we
1386                          * have to destroy the mbuf.
1387                          *
1388                          * Other mbuf references to the cluster will typically
1389                          * be M_EXT | M_EXT_CLUSTER but without M_CLCACHE.
1390                          *
1391                          * XXX we could try to connect another cluster to
1392                          * it.
1393                          */
1394                         m->m_ext.ext_free(m->m_ext.ext_arg); 
1395                         m->m_flags &= ~(M_EXT | M_EXT_CLUSTER);
1396                         if (m->m_ext.ext_size == MCLBYTES) {
1397                                 if (m->m_flags & M_PHCACHE)
1398                                         objcache_dtor(mbufphdrcluster_cache, m);
1399                                 else
1400                                         objcache_dtor(mbufcluster_cache, m);
1401                         } else {
1402                                 if (m->m_flags & M_PHCACHE)
1403                                         objcache_dtor(mbufphdrjcluster_cache, m);
1404                                 else
1405                                         objcache_dtor(mbufjcluster_cache, m);
1406                         }
1407                 }
1408                 break;
1409         case M_EXT | M_EXT_CLUSTER:
1410         case M_EXT:
1411                 /*
1412                  * Normal cluster association case, disconnect the cluster from
1413                  * the mbuf.  The cluster may or may not be custom.
1414                  */
1415                 m->m_ext.ext_free(m->m_ext.ext_arg); 
1416                 m->m_flags &= ~(M_EXT | M_EXT_CLUSTER);
1417                 /* fall through */
1418         case 0:
1419                 /*
1420                  * return the mbuf to the mbuf cache.
1421                  */
1422                 if (m->m_flags & M_PHCACHE) {
1423                         m->m_data = m->m_pktdat;
1424                         objcache_put(mbufphdr_cache, m);
1425                 } else {
1426                         m->m_data = m->m_dat;
1427                         objcache_put(mbuf_cache, m);
1428                 }
1429                 --mbstat[mycpu->gd_cpuid].m_mbufs;
1430                 break;
1431         default:
1432                 if (!panicstr)
1433                         panic("bad mbuf flags %p %08x", m, m->m_flags);
1434                 break;
1435         }
1436         return (n);
1437 }
1438
1439 #ifdef MBUF_DEBUG
1440
1441 void
1442 _m_freem(struct mbuf *m, const char *func)
1443 {
1444         while (m)
1445                 m = _m_free(m, func);
1446 }
1447
1448 #else
1449
1450 void
1451 m_freem(struct mbuf *m)
1452 {
1453         while (m)
1454                 m = m_free(m);
1455 }
1456
1457 #endif
1458
1459 void
1460 m_extadd(struct mbuf *m, caddr_t buf, u_int size,  void (*reff)(void *),
1461     void (*freef)(void *), void *arg)
1462 {
1463         m->m_ext.ext_arg = arg;
1464         m->m_ext.ext_buf = buf;
1465         m->m_ext.ext_ref = reff;
1466         m->m_ext.ext_free = freef;
1467         m->m_ext.ext_size = size;
1468         reff(arg);
1469         m->m_data = buf;
1470         m->m_flags |= M_EXT;
1471 }
1472
1473 /*
1474  * mbuf utility routines
1475  */
1476
1477 /*
1478  * Lesser-used path for M_PREPEND: allocate new mbuf to prepend to chain and
1479  * copy junk along.
1480  */
1481 struct mbuf *
1482 m_prepend(struct mbuf *m, int len, int how)
1483 {
1484         struct mbuf *mn;
1485
1486         if (m->m_flags & M_PKTHDR)
1487             mn = m_gethdr(how, m->m_type);
1488         else
1489             mn = m_get(how, m->m_type);
1490         if (mn == NULL) {
1491                 m_freem(m);
1492                 return (NULL);
1493         }
1494         if (m->m_flags & M_PKTHDR)
1495                 M_MOVE_PKTHDR(mn, m);
1496         mn->m_next = m;
1497         m = mn;
1498         if (len < MHLEN)
1499                 MH_ALIGN(m, len);
1500         m->m_len = len;
1501         return (m);
1502 }
1503
1504 /*
1505  * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
1506  * continuing for "len" bytes.  If len is M_COPYALL, copy to end of mbuf.
1507  * The wait parameter is a choice of M_WAITOK/M_NOWAIT from caller.
1508  * Note that the copy is read-only, because clusters are not copied,
1509  * only their reference counts are incremented.
1510  */
1511 struct mbuf *
1512 m_copym(const struct mbuf *m, int off0, int len, int wait)
1513 {
1514         struct mbuf *n, **np;
1515         int off = off0;
1516         struct mbuf *top;
1517         int copyhdr = 0;
1518
1519         KASSERT(off >= 0, ("m_copym, negative off %d", off));
1520         KASSERT(len >= 0, ("m_copym, negative len %d", len));
1521         if (off == 0 && (m->m_flags & M_PKTHDR))
1522                 copyhdr = 1;
1523         while (off > 0) {
1524                 KASSERT(m != NULL, ("m_copym, offset > size of mbuf chain"));
1525                 if (off < m->m_len)
1526                         break;
1527                 off -= m->m_len;
1528                 m = m->m_next;
1529         }
1530         np = &top;
1531         top = NULL;
1532         while (len > 0) {
1533                 if (m == NULL) {
1534                         KASSERT(len == M_COPYALL, 
1535                             ("m_copym, length > size of mbuf chain"));
1536                         break;
1537                 }
1538                 /*
1539                  * Because we are sharing any cluster attachment below,
1540                  * be sure to get an mbuf that does not have a cluster
1541                  * associated with it.
1542                  */
1543                 if (copyhdr)
1544                         n = m_gethdr(wait, m->m_type);
1545                 else
1546                         n = m_get(wait, m->m_type);
1547                 *np = n;
1548                 if (n == NULL)
1549                         goto nospace;
1550                 if (copyhdr) {
1551                         if (!m_dup_pkthdr(n, m, wait))
1552                                 goto nospace;
1553                         if (len == M_COPYALL)
1554                                 n->m_pkthdr.len -= off0;
1555                         else
1556                                 n->m_pkthdr.len = len;
1557                         copyhdr = 0;
1558                 }
1559                 n->m_len = min(len, m->m_len - off);
1560                 if (m->m_flags & M_EXT) {
1561                         KKASSERT((n->m_flags & M_EXT) == 0);
1562                         n->m_data = m->m_data + off;
1563                         m->m_ext.ext_ref(m->m_ext.ext_arg); 
1564                         n->m_ext = m->m_ext;
1565                         n->m_flags |= m->m_flags & (M_EXT | M_EXT_CLUSTER);
1566                 } else {
1567                         bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
1568                             (unsigned)n->m_len);
1569                 }
1570                 if (len != M_COPYALL)
1571                         len -= n->m_len;
1572                 off = 0;
1573                 m = m->m_next;
1574                 np = &n->m_next;
1575         }
1576         if (top == NULL)
1577                 ++mbstat[mycpu->gd_cpuid].m_mcfail;
1578         return (top);
1579 nospace:
1580         m_freem(top);
1581         ++mbstat[mycpu->gd_cpuid].m_mcfail;
1582         return (NULL);
1583 }
1584
1585 /*
1586  * Copy an entire packet, including header (which must be present).
1587  * An optimization of the common case `m_copym(m, 0, M_COPYALL, how)'.
1588  * Note that the copy is read-only, because clusters are not copied,
1589  * only their reference counts are incremented.
1590  * Preserve alignment of the first mbuf so if the creator has left
1591  * some room at the beginning (e.g. for inserting protocol headers)
1592  * the copies also have the room available.
1593  */
1594 struct mbuf *
1595 m_copypacket(struct mbuf *m, int how)
1596 {
1597         struct mbuf *top, *n, *o;
1598
1599         n = m_gethdr(how, m->m_type);
1600         top = n;
1601         if (!n)
1602                 goto nospace;
1603
1604         if (!m_dup_pkthdr(n, m, how))
1605                 goto nospace;
1606         n->m_len = m->m_len;
1607         if (m->m_flags & M_EXT) {
1608                 KKASSERT((n->m_flags & M_EXT) == 0);
1609                 n->m_data = m->m_data;
1610                 m->m_ext.ext_ref(m->m_ext.ext_arg); 
1611                 n->m_ext = m->m_ext;
1612                 n->m_flags |= m->m_flags & (M_EXT | M_EXT_CLUSTER);
1613         } else {
1614                 n->m_data = n->m_pktdat + (m->m_data - m->m_pktdat );
1615                 bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
1616         }
1617
1618         m = m->m_next;
1619         while (m) {
1620                 o = m_get(how, m->m_type);
1621                 if (!o)
1622                         goto nospace;
1623
1624                 n->m_next = o;
1625                 n = n->m_next;
1626
1627                 n->m_len = m->m_len;
1628                 if (m->m_flags & M_EXT) {
1629                         KKASSERT((n->m_flags & M_EXT) == 0);
1630                         n->m_data = m->m_data;
1631                         m->m_ext.ext_ref(m->m_ext.ext_arg); 
1632                         n->m_ext = m->m_ext;
1633                         n->m_flags |= m->m_flags & (M_EXT | M_EXT_CLUSTER);
1634                 } else {
1635                         bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
1636                 }
1637
1638                 m = m->m_next;
1639         }
1640         return top;
1641 nospace:
1642         m_freem(top);
1643         ++mbstat[mycpu->gd_cpuid].m_mcfail;
1644         return (NULL);
1645 }
1646
1647 /*
1648  * Copy data from an mbuf chain starting "off" bytes from the beginning,
1649  * continuing for "len" bytes, into the indicated buffer.
1650  */
1651 void
1652 m_copydata(const struct mbuf *m, int off, int len, caddr_t cp)
1653 {
1654         unsigned count;
1655
1656         KASSERT(off >= 0, ("m_copydata, negative off %d", off));
1657         KASSERT(len >= 0, ("m_copydata, negative len %d", len));
1658         while (off > 0) {
1659                 KASSERT(m != NULL, ("m_copydata, offset > size of mbuf chain"));
1660                 if (off < m->m_len)
1661                         break;
1662                 off -= m->m_len;
1663                 m = m->m_next;
1664         }
1665         while (len > 0) {
1666                 KASSERT(m != NULL, ("m_copydata, length > size of mbuf chain"));
1667                 count = min(m->m_len - off, len);
1668                 bcopy(mtod(m, caddr_t) + off, cp, count);
1669                 len -= count;
1670                 cp += count;
1671                 off = 0;
1672                 m = m->m_next;
1673         }
1674 }
1675
1676 /*
1677  * Copy a packet header mbuf chain into a completely new chain, including
1678  * copying any mbuf clusters.  Use this instead of m_copypacket() when
1679  * you need a writable copy of an mbuf chain.
1680  */
1681 struct mbuf *
1682 m_dup(struct mbuf *m, int how)
1683 {
1684         struct mbuf **p, *top = NULL;
1685         int remain, moff, nsize;
1686
1687         /* Sanity check */
1688         if (m == NULL)
1689                 return (NULL);
1690         KASSERT((m->m_flags & M_PKTHDR) != 0, ("%s: !PKTHDR", __func__));
1691
1692         /* While there's more data, get a new mbuf, tack it on, and fill it */
1693         remain = m->m_pkthdr.len;
1694         moff = 0;
1695         p = &top;
1696         while (remain > 0 || top == NULL) {     /* allow m->m_pkthdr.len == 0 */
1697                 struct mbuf *n;
1698
1699                 /* Get the next new mbuf */
1700                 n = m_getl(remain, how, m->m_type, top == NULL ? M_PKTHDR : 0,
1701                            &nsize);
1702                 if (n == NULL)
1703                         goto nospace;
1704                 if (top == NULL)
1705                         if (!m_dup_pkthdr(n, m, how))
1706                                 goto nospace0;
1707
1708                 /* Link it into the new chain */
1709                 *p = n;
1710                 p = &n->m_next;
1711
1712                 /* Copy data from original mbuf(s) into new mbuf */
1713                 n->m_len = 0;
1714                 while (n->m_len < nsize && m != NULL) {
1715                         int chunk = min(nsize - n->m_len, m->m_len - moff);
1716
1717                         bcopy(m->m_data + moff, n->m_data + n->m_len, chunk);
1718                         moff += chunk;
1719                         n->m_len += chunk;
1720                         remain -= chunk;
1721                         if (moff == m->m_len) {
1722                                 m = m->m_next;
1723                                 moff = 0;
1724                         }
1725                 }
1726
1727                 /* Check correct total mbuf length */
1728                 KASSERT((remain > 0 && m != NULL) || (remain == 0 && m == NULL),
1729                         ("%s: bogus m_pkthdr.len", __func__));
1730         }
1731         return (top);
1732
1733 nospace:
1734         m_freem(top);
1735 nospace0:
1736         ++mbstat[mycpu->gd_cpuid].m_mcfail;
1737         return (NULL);
1738 }
1739
1740 /*
1741  * Copy the non-packet mbuf data chain into a new set of mbufs, including
1742  * copying any mbuf clusters.  This is typically used to realign a data
1743  * chain by nfs_realign().
1744  *
1745  * The original chain is left intact.  how should be M_WAITOK or M_NOWAIT
1746  * and NULL can be returned if M_NOWAIT is passed.
1747  *
1748  * Be careful to use cluster mbufs, a large mbuf chain converted to non
1749  * cluster mbufs can exhaust our supply of mbufs.
1750  */
1751 struct mbuf *
1752 m_dup_data(struct mbuf *m, int how)
1753 {
1754         struct mbuf **p, *n, *top = NULL;
1755         int mlen, moff, chunk, gsize, nsize;
1756
1757         /*
1758          * Degenerate case
1759          */
1760         if (m == NULL)
1761                 return (NULL);
1762
1763         /*
1764          * Optimize the mbuf allocation but do not get too carried away.
1765          */
1766         if (m->m_next || m->m_len > MLEN)
1767                 if (m->m_flags & M_EXT && m->m_ext.ext_size == MCLBYTES)
1768                         gsize = MCLBYTES;
1769                 else
1770                         gsize = MJUMPAGESIZE;
1771         else
1772                 gsize = MLEN;
1773
1774         /* Chain control */
1775         p = &top;
1776         n = NULL;
1777         nsize = 0;
1778
1779         /*
1780          * Scan the mbuf chain until nothing is left, the new mbuf chain
1781          * will be allocated on the fly as needed.
1782          */
1783         while (m) {
1784                 mlen = m->m_len;
1785                 moff = 0;
1786
1787                 while (mlen) {
1788                         KKASSERT(m->m_type == MT_DATA);
1789                         if (n == NULL) {
1790                                 n = m_getl(gsize, how, MT_DATA, 0, &nsize);
1791                                 n->m_len = 0;
1792                                 if (n == NULL)
1793                                         goto nospace;
1794                                 *p = n;
1795                                 p = &n->m_next;
1796                         }
1797                         chunk = imin(mlen, nsize);
1798                         bcopy(m->m_data + moff, n->m_data + n->m_len, chunk);
1799                         mlen -= chunk;
1800                         moff += chunk;
1801                         n->m_len += chunk;
1802                         nsize -= chunk;
1803                         if (nsize == 0)
1804                                 n = NULL;
1805                 }
1806                 m = m->m_next;
1807         }
1808         *p = NULL;
1809         return(top);
1810 nospace:
1811         *p = NULL;
1812         m_freem(top);
1813         ++mbstat[mycpu->gd_cpuid].m_mcfail;
1814         return (NULL);
1815 }
1816
1817 /*
1818  * Concatenate mbuf chain n to m.
1819  * Both chains must be of the same type (e.g. MT_DATA).
1820  * Any m_pkthdr is not updated.
1821  */
1822 void
1823 m_cat(struct mbuf *m, struct mbuf *n)
1824 {
1825         m = m_last(m);
1826         while (n) {
1827                 if (m->m_flags & M_EXT ||
1828                     m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) {
1829                         /* just join the two chains */
1830                         m->m_next = n;
1831                         return;
1832                 }
1833                 /* splat the data from one into the other */
1834                 bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
1835                     (u_int)n->m_len);
1836                 m->m_len += n->m_len;
1837                 n = m_free(n);
1838         }
1839 }
1840
1841 void
1842 m_adj(struct mbuf *mp, int req_len)
1843 {
1844         int len = req_len;
1845         struct mbuf *m;
1846         int count;
1847
1848         if ((m = mp) == NULL)
1849                 return;
1850         if (len >= 0) {
1851                 /*
1852                  * Trim from head.
1853                  */
1854                 while (m != NULL && len > 0) {
1855                         if (m->m_len <= len) {
1856                                 len -= m->m_len;
1857                                 m->m_len = 0;
1858                                 m = m->m_next;
1859                         } else {
1860                                 m->m_len -= len;
1861                                 m->m_data += len;
1862                                 len = 0;
1863                         }
1864                 }
1865                 m = mp;
1866                 if (mp->m_flags & M_PKTHDR)
1867                         m->m_pkthdr.len -= (req_len - len);
1868         } else {
1869                 /*
1870                  * Trim from tail.  Scan the mbuf chain,
1871                  * calculating its length and finding the last mbuf.
1872                  * If the adjustment only affects this mbuf, then just
1873                  * adjust and return.  Otherwise, rescan and truncate
1874                  * after the remaining size.
1875                  */
1876                 len = -len;
1877                 count = 0;
1878                 for (;;) {
1879                         count += m->m_len;
1880                         if (m->m_next == NULL)
1881                                 break;
1882                         m = m->m_next;
1883                 }
1884                 if (m->m_len >= len) {
1885                         m->m_len -= len;
1886                         if (mp->m_flags & M_PKTHDR)
1887                                 mp->m_pkthdr.len -= len;
1888                         return;
1889                 }
1890                 count -= len;
1891                 if (count < 0)
1892                         count = 0;
1893                 /*
1894                  * Correct length for chain is "count".
1895                  * Find the mbuf with last data, adjust its length,
1896                  * and toss data from remaining mbufs on chain.
1897                  */
1898                 m = mp;
1899                 if (m->m_flags & M_PKTHDR)
1900                         m->m_pkthdr.len = count;
1901                 for (; m; m = m->m_next) {
1902                         if (m->m_len >= count) {
1903                                 m->m_len = count;
1904                                 break;
1905                         }
1906                         count -= m->m_len;
1907                 }
1908                 while (m->m_next)
1909                         (m = m->m_next) ->m_len = 0;
1910         }
1911 }
1912
1913 /*
1914  * Set the m_data pointer of a newly-allocated mbuf
1915  * to place an object of the specified size at the
1916  * end of the mbuf, longword aligned.
1917  */
1918 void
1919 m_align(struct mbuf *m, int len)
1920 {
1921         int adjust;
1922
1923         if (m->m_flags & M_EXT)
1924                 adjust = m->m_ext.ext_size - len;
1925         else if (m->m_flags & M_PKTHDR)
1926                 adjust = MHLEN - len;
1927         else
1928                 adjust = MLEN - len;
1929         m->m_data += adjust &~ (sizeof(long)-1);
1930 }
1931
1932 /*
1933  * Create a writable copy of the mbuf chain.  While doing this
1934  * we compact the chain with a goal of producing a chain with
1935  * at most two mbufs.  The second mbuf in this chain is likely
1936  * to be a cluster.  The primary purpose of this work is to create
1937  * a writable packet for encryption, compression, etc.  The
1938  * secondary goal is to linearize the data so the data can be
1939  * passed to crypto hardware in the most efficient manner possible.
1940  */
1941 struct mbuf *
1942 m_unshare(struct mbuf *m0, int how)
1943 {
1944         struct mbuf *m, *mprev;
1945         struct mbuf *n, *mfirst, *mlast;
1946         int len, off;
1947
1948         mprev = NULL;
1949         for (m = m0; m != NULL; m = mprev->m_next) {
1950                 /*
1951                  * Regular mbufs are ignored unless there's a cluster
1952                  * in front of it that we can use to coalesce.  We do
1953                  * the latter mainly so later clusters can be coalesced
1954                  * also w/o having to handle them specially (i.e. convert
1955                  * mbuf+cluster -> cluster).  This optimization is heavily
1956                  * influenced by the assumption that we're running over
1957                  * Ethernet where MCLBYTES is large enough that the max
1958                  * packet size will permit lots of coalescing into a
1959                  * single cluster.  This in turn permits efficient
1960                  * crypto operations, especially when using hardware.
1961                  */
1962                 if ((m->m_flags & M_EXT) == 0) {
1963                         if (mprev && (mprev->m_flags & M_EXT) &&
1964                             m->m_len <= M_TRAILINGSPACE(mprev)) {
1965                                 /* XXX: this ignores mbuf types */
1966                                 memcpy(mtod(mprev, caddr_t) + mprev->m_len,
1967                                        mtod(m, caddr_t), m->m_len);
1968                                 mprev->m_len += m->m_len;
1969                                 mprev->m_next = m->m_next;      /* unlink from chain */
1970                                 m_free(m);                      /* reclaim mbuf */
1971                         } else {
1972                                 mprev = m;
1973                         }
1974                         continue;
1975                 }
1976                 /*
1977                  * Writable mbufs are left alone (for now).
1978                  */
1979                 if (M_WRITABLE(m)) {
1980                         mprev = m;
1981                         continue;
1982                 }
1983
1984                 /*
1985                  * Not writable, replace with a copy or coalesce with
1986                  * the previous mbuf if possible (since we have to copy
1987                  * it anyway, we try to reduce the number of mbufs and
1988                  * clusters so that future work is easier).
1989                  */
1990                 KASSERT(m->m_flags & M_EXT, ("m_flags 0x%x", m->m_flags));
1991                 /* NB: we only coalesce into a cluster or larger */
1992                 if (mprev != NULL && (mprev->m_flags & M_EXT) &&
1993                     m->m_len <= M_TRAILINGSPACE(mprev)) {
1994                         /* XXX: this ignores mbuf types */
1995                         memcpy(mtod(mprev, caddr_t) + mprev->m_len,
1996                                mtod(m, caddr_t), m->m_len);
1997                         mprev->m_len += m->m_len;
1998                         mprev->m_next = m->m_next;      /* unlink from chain */
1999                         m_free(m);                      /* reclaim mbuf */
2000                         continue;
2001                 }
2002
2003                 /*
2004                  * Allocate new space to hold the copy...
2005                  */
2006                 /* XXX why can M_PKTHDR be set past the first mbuf? */
2007                 if (mprev == NULL && (m->m_flags & M_PKTHDR)) {
2008                         /*
2009                          * NB: if a packet header is present we must
2010                          * allocate the mbuf separately from any cluster
2011                          * because M_MOVE_PKTHDR will smash the data
2012                          * pointer and drop the M_EXT marker.
2013                          */
2014                         MGETHDR(n, how, m->m_type);
2015                         if (n == NULL) {
2016                                 m_freem(m0);
2017                                 return (NULL);
2018                         }
2019                         M_MOVE_PKTHDR(n, m);
2020                         MCLGET(n, how);
2021                         if ((n->m_flags & M_EXT) == 0) {
2022                                 m_free(n);
2023                                 m_freem(m0);
2024                                 return (NULL);
2025                         }
2026                 } else {
2027                         n = m_getcl(how, m->m_type, m->m_flags);
2028                         if (n == NULL) {
2029                                 m_freem(m0);
2030                                 return (NULL);
2031                         }
2032                 }
2033                 /*
2034                  * ... and copy the data.  We deal with jumbo mbufs
2035                  * (i.e. m_len > MCLBYTES) by splitting them into
2036                  * clusters.  We could just malloc a buffer and make
2037                  * it external but too many device drivers don't know
2038                  * how to break up the non-contiguous memory when
2039                  * doing DMA.
2040                  */
2041                 len = m->m_len;
2042                 off = 0;
2043                 mfirst = n;
2044                 mlast = NULL;
2045                 for (;;) {
2046                         int cc = min(len, MCLBYTES);
2047                         memcpy(mtod(n, caddr_t), mtod(m, caddr_t) + off, cc);
2048                         n->m_len = cc;
2049                         if (mlast != NULL)
2050                                 mlast->m_next = n;
2051                         mlast = n;      
2052
2053                         len -= cc;
2054                         if (len <= 0)
2055                                 break;
2056                         off += cc;
2057
2058                         n = m_getcl(how, m->m_type, m->m_flags);
2059                         if (n == NULL) {
2060                                 m_freem(mfirst);
2061                                 m_freem(m0);
2062                                 return (NULL);
2063                         }
2064                 }
2065                 n->m_next = m->m_next; 
2066                 if (mprev == NULL)
2067                         m0 = mfirst;            /* new head of chain */
2068                 else
2069                         mprev->m_next = mfirst; /* replace old mbuf */
2070                 m_free(m);                      /* release old mbuf */
2071                 mprev = mfirst;
2072         }
2073         return (m0);
2074 }
2075
2076 /*
2077  * Rearrange an mbuf chain so that len bytes are contiguous
2078  * and in the data area of an mbuf (so that mtod will work for a structure
2079  * of size len).  Returns the resulting mbuf chain on success, frees it and
2080  * returns null on failure.  If there is room, it will add up to
2081  * max_protohdr-len extra bytes to the contiguous region in an attempt to
2082  * avoid being called next time.
2083  */
2084 struct mbuf *
2085 m_pullup(struct mbuf *n, int len)
2086 {
2087         struct mbuf *m;
2088         int count;
2089         int space;
2090
2091         /*
2092          * If first mbuf has no cluster, and has room for len bytes
2093          * without shifting current data, pullup into it,
2094          * otherwise allocate a new mbuf to prepend to the chain.
2095          */
2096         if (!(n->m_flags & M_EXT) &&
2097             n->m_data + len < &n->m_dat[MLEN] &&
2098             n->m_next) {
2099                 if (n->m_len >= len)
2100                         return (n);
2101                 m = n;
2102                 n = n->m_next;
2103                 len -= m->m_len;
2104         } else {
2105                 if (len > MHLEN)
2106                         goto bad;
2107                 if (n->m_flags & M_PKTHDR)
2108                         m = m_gethdr(M_NOWAIT, n->m_type);
2109                 else
2110                         m = m_get(M_NOWAIT, n->m_type);
2111                 if (m == NULL)
2112                         goto bad;
2113                 m->m_len = 0;
2114                 if (n->m_flags & M_PKTHDR)
2115                         M_MOVE_PKTHDR(m, n);
2116         }
2117         space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
2118         do {
2119                 count = min(min(max(len, max_protohdr), space), n->m_len);
2120                 bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
2121                   (unsigned)count);
2122                 len -= count;
2123                 m->m_len += count;
2124                 n->m_len -= count;
2125                 space -= count;
2126                 if (n->m_len)
2127                         n->m_data += count;
2128                 else
2129                         n = m_free(n);
2130         } while (len > 0 && n);
2131         if (len > 0) {
2132                 m_free(m);
2133                 goto bad;
2134         }
2135         m->m_next = n;
2136         return (m);
2137 bad:
2138         m_freem(n);
2139         ++mbstat[mycpu->gd_cpuid].m_mcfail;
2140         return (NULL);
2141 }
2142
2143 /*
2144  * Partition an mbuf chain in two pieces, returning the tail --
2145  * all but the first len0 bytes.  In case of failure, it returns NULL and
2146  * attempts to restore the chain to its original state.
2147  *
2148  * Note that the resulting mbufs might be read-only, because the new
2149  * mbuf can end up sharing an mbuf cluster with the original mbuf if
2150  * the "breaking point" happens to lie within a cluster mbuf. Use the
2151  * M_WRITABLE() macro to check for this case.
2152  */
2153 struct mbuf *
2154 m_split(struct mbuf *m0, int len0, int wait)
2155 {
2156         struct mbuf *m, *n;
2157         unsigned len = len0, remain;
2158
2159         for (m = m0; m && len > m->m_len; m = m->m_next)
2160                 len -= m->m_len;
2161         if (m == NULL)
2162                 return (NULL);
2163         remain = m->m_len - len;
2164         if (m0->m_flags & M_PKTHDR) {
2165                 n = m_gethdr(wait, m0->m_type);
2166                 if (n == NULL)
2167                         return (NULL);
2168                 n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
2169                 n->m_pkthdr.len = m0->m_pkthdr.len - len0;
2170                 m0->m_pkthdr.len = len0;
2171                 if (m->m_flags & M_EXT)
2172                         goto extpacket;
2173                 if (remain > MHLEN) {
2174                         /* m can't be the lead packet */
2175                         MH_ALIGN(n, 0);
2176                         n->m_next = m_split(m, len, wait);
2177                         if (n->m_next == NULL) {
2178                                 m_free(n);
2179                                 return (NULL);
2180                         } else {
2181                                 n->m_len = 0;
2182                                 return (n);
2183                         }
2184                 } else
2185                         MH_ALIGN(n, remain);
2186         } else if (remain == 0) {
2187                 n = m->m_next;
2188                 m->m_next = NULL;
2189                 return (n);
2190         } else {
2191                 n = m_get(wait, m->m_type);
2192                 if (n == NULL)
2193                         return (NULL);
2194                 M_ALIGN(n, remain);
2195         }
2196 extpacket:
2197         if (m->m_flags & M_EXT) {
2198                 KKASSERT((n->m_flags & M_EXT) == 0);
2199                 n->m_data = m->m_data + len;
2200                 m->m_ext.ext_ref(m->m_ext.ext_arg); 
2201                 n->m_ext = m->m_ext;
2202                 n->m_flags |= m->m_flags & (M_EXT | M_EXT_CLUSTER);
2203         } else {
2204                 bcopy(mtod(m, caddr_t) + len, mtod(n, caddr_t), remain);
2205         }
2206         n->m_len = remain;
2207         m->m_len = len;
2208         n->m_next = m->m_next;
2209         m->m_next = NULL;
2210         return (n);
2211 }
2212
2213 /*
2214  * Routine to copy from device local memory into mbufs.
2215  * Note: "offset" is ill-defined and always called as 0, so ignore it.
2216  */
2217 struct mbuf *
2218 m_devget(char *buf, int len, int offset, struct ifnet *ifp,
2219     void (*copy)(volatile const void *from, volatile void *to, size_t length))
2220 {
2221         struct mbuf *m, *mfirst = NULL, **mtail;
2222         int nsize, flags;
2223
2224         if (copy == NULL)
2225                 copy = bcopy;
2226         mtail = &mfirst;
2227         flags = M_PKTHDR;
2228
2229         while (len > 0) {
2230                 m = m_getl(len, M_NOWAIT, MT_DATA, flags, &nsize);
2231                 if (m == NULL) {
2232                         m_freem(mfirst);
2233                         return (NULL);
2234                 }
2235                 m->m_len = min(len, nsize);
2236
2237                 if (flags & M_PKTHDR) {
2238                         if (len + max_linkhdr <= nsize)
2239                                 m->m_data += max_linkhdr;
2240                         m->m_pkthdr.rcvif = ifp;
2241                         m->m_pkthdr.len = len;
2242                         flags = 0;
2243                 }
2244
2245                 copy(buf, m->m_data, (unsigned)m->m_len);
2246                 buf += m->m_len;
2247                 len -= m->m_len;
2248                 *mtail = m;
2249                 mtail = &m->m_next;
2250         }
2251
2252         return (mfirst);
2253 }
2254
2255 /*
2256  * Routine to pad mbuf to the specified length 'padto'.
2257  */
2258 int
2259 m_devpad(struct mbuf *m, int padto)
2260 {
2261         struct mbuf *last = NULL;
2262         int padlen;
2263
2264         if (padto <= m->m_pkthdr.len)
2265                 return 0;
2266
2267         padlen = padto - m->m_pkthdr.len;
2268
2269         /* if there's only the packet-header and we can pad there, use it. */
2270         if (m->m_pkthdr.len == m->m_len && M_TRAILINGSPACE(m) >= padlen) {
2271                 last = m;
2272         } else {
2273                 /*
2274                  * Walk packet chain to find last mbuf. We will either
2275                  * pad there, or append a new mbuf and pad it
2276                  */
2277                 for (last = m; last->m_next != NULL; last = last->m_next)
2278                         ; /* EMPTY */
2279
2280                 /* `last' now points to last in chain. */
2281                 if (M_TRAILINGSPACE(last) < padlen) {
2282                         struct mbuf *n;
2283
2284                         /* Allocate new empty mbuf, pad it.  Compact later. */
2285                         MGET(n, M_NOWAIT, MT_DATA);
2286                         if (n == NULL)
2287                                 return ENOBUFS;
2288                         n->m_len = 0;
2289                         last->m_next = n;
2290                         last = n;
2291                 }
2292         }
2293         KKASSERT(M_TRAILINGSPACE(last) >= padlen);
2294         KKASSERT(M_WRITABLE(last));
2295
2296         /* Now zero the pad area */
2297         bzero(mtod(last, char *) + last->m_len, padlen);
2298         last->m_len += padlen;
2299         m->m_pkthdr.len += padlen;
2300         return 0;
2301 }
2302
2303 /*
2304  * Copy data from a buffer back into the indicated mbuf chain,
2305  * starting "off" bytes from the beginning, extending the mbuf
2306  * chain if necessary.
2307  */
2308 void
2309 m_copyback(struct mbuf *m0, int off, int len, caddr_t cp)
2310 {
2311         int mlen;
2312         struct mbuf *m = m0, *n;
2313         int totlen = 0;
2314
2315         if (m0 == NULL)
2316                 return;
2317         while (off > (mlen = m->m_len)) {
2318                 off -= mlen;
2319                 totlen += mlen;
2320                 if (m->m_next == NULL) {
2321                         n = m_getclr(M_NOWAIT, m->m_type);
2322                         if (n == NULL)
2323                                 goto out;
2324                         n->m_len = min(MLEN, len + off);
2325                         m->m_next = n;
2326                 }
2327                 m = m->m_next;
2328         }
2329         while (len > 0) {
2330                 mlen = min (m->m_len - off, len);
2331                 bcopy(cp, off + mtod(m, caddr_t), (unsigned)mlen);
2332                 cp += mlen;
2333                 len -= mlen;
2334                 mlen += off;
2335                 off = 0;
2336                 totlen += mlen;
2337                 if (len == 0)
2338                         break;
2339                 if (m->m_next == NULL) {
2340                         n = m_get(M_NOWAIT, m->m_type);
2341                         if (n == NULL)
2342                                 break;
2343                         n->m_len = min(MLEN, len);
2344                         m->m_next = n;
2345                 }
2346                 m = m->m_next;
2347         }
2348 out:    if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
2349                 m->m_pkthdr.len = totlen;
2350 }
2351
2352 /*
2353  * Append the specified data to the indicated mbuf chain,
2354  * Extend the mbuf chain if the new data does not fit in
2355  * existing space.
2356  *
2357  * Return 1 if able to complete the job; otherwise 0.
2358  */
2359 int
2360 m_append(struct mbuf *m0, int len, c_caddr_t cp)
2361 {
2362         struct mbuf *m, *n;
2363         int remainder, space;
2364
2365         for (m = m0; m->m_next != NULL; m = m->m_next)
2366                 ;
2367         remainder = len;
2368         space = M_TRAILINGSPACE(m);
2369         if (space > 0) {
2370                 /*
2371                  * Copy into available space.
2372                  */
2373                 if (space > remainder)
2374                         space = remainder;
2375                 bcopy(cp, mtod(m, caddr_t) + m->m_len, space);
2376                 m->m_len += space;
2377                 cp += space, remainder -= space;
2378         }
2379         while (remainder > 0) {
2380                 /*
2381                  * Allocate a new mbuf; could check space
2382                  * and allocate a cluster instead.
2383                  */
2384                 n = m_get(M_NOWAIT, m->m_type);
2385                 if (n == NULL)
2386                         break;
2387                 n->m_len = min(MLEN, remainder);
2388                 bcopy(cp, mtod(n, caddr_t), n->m_len);
2389                 cp += n->m_len, remainder -= n->m_len;
2390                 m->m_next = n;
2391                 m = n;
2392         }
2393         if (m0->m_flags & M_PKTHDR)
2394                 m0->m_pkthdr.len += len - remainder;
2395         return (remainder == 0);
2396 }
2397
2398 /*
2399  * Apply function f to the data in an mbuf chain starting "off" bytes from
2400  * the beginning, continuing for "len" bytes.
2401  */
2402 int
2403 m_apply(struct mbuf *m, int off, int len,
2404     int (*f)(void *, void *, u_int), void *arg)
2405 {
2406         u_int count;
2407         int rval;
2408
2409         KASSERT(off >= 0, ("m_apply, negative off %d", off));
2410         KASSERT(len >= 0, ("m_apply, negative len %d", len));
2411         while (off > 0) {
2412                 KASSERT(m != NULL, ("m_apply, offset > size of mbuf chain"));
2413                 if (off < m->m_len)
2414                         break;
2415                 off -= m->m_len;
2416                 m = m->m_next;
2417         }
2418         while (len > 0) {
2419                 KASSERT(m != NULL, ("m_apply, offset > size of mbuf chain"));
2420                 count = min(m->m_len - off, len);
2421                 rval = (*f)(arg, mtod(m, caddr_t) + off, count);
2422                 if (rval)
2423                         return (rval);
2424                 len -= count;
2425                 off = 0;
2426                 m = m->m_next;
2427         }
2428         return (0);
2429 }
2430
2431 /*
2432  * Return a pointer to mbuf/offset of location in mbuf chain.
2433  */
2434 struct mbuf *
2435 m_getptr(struct mbuf *m, int loc, int *off)
2436 {
2437
2438         while (loc >= 0) {
2439                 /* Normal end of search. */
2440                 if (m->m_len > loc) {
2441                         *off = loc;
2442                         return (m);
2443                 } else {
2444                         loc -= m->m_len;
2445                         if (m->m_next == NULL) {
2446                                 if (loc == 0) {
2447                                         /* Point at the end of valid data. */
2448                                         *off = m->m_len;
2449                                         return (m);
2450                                 }
2451                                 return (NULL);
2452                         }
2453                         m = m->m_next;
2454                 }
2455         }
2456         return (NULL);
2457 }
2458
2459 void
2460 m_print(const struct mbuf *m)
2461 {
2462         int len;
2463         const struct mbuf *m2;
2464         char *hexstr;
2465
2466         len = m->m_pkthdr.len;
2467         m2 = m;
2468         hexstr = kmalloc(HEX_NCPYLEN(len), M_TEMP, M_ZERO | M_WAITOK);
2469         while (len) {
2470                 kprintf("%p %s\n", m2, hexncpy(m2->m_data, m2->m_len, hexstr,
2471                         HEX_NCPYLEN(m2->m_len), "-"));
2472                 len -= m2->m_len;
2473                 m2 = m2->m_next;
2474         }
2475         kfree(hexstr, M_TEMP);
2476         return;
2477 }
2478
2479 /*
2480  * "Move" mbuf pkthdr from "from" to "to".
2481  * "from" must have M_PKTHDR set, and "to" must be empty.
2482  */
2483 void
2484 m_move_pkthdr(struct mbuf *to, struct mbuf *from)
2485 {
2486         KASSERT((to->m_flags & M_PKTHDR), ("m_move_pkthdr: not packet header"));
2487
2488         to->m_flags |= from->m_flags & M_COPYFLAGS;
2489         to->m_pkthdr = from->m_pkthdr;          /* especially tags */
2490         SLIST_INIT(&from->m_pkthdr.tags);       /* purge tags from src */
2491 }
2492
2493 /*
2494  * Duplicate "from"'s mbuf pkthdr in "to".
2495  * "from" must have M_PKTHDR set, and "to" must be empty.
2496  * In particular, this does a deep copy of the packet tags.
2497  */
2498 int
2499 m_dup_pkthdr(struct mbuf *to, const struct mbuf *from, int how)
2500 {
2501         KASSERT((to->m_flags & M_PKTHDR), ("m_dup_pkthdr: not packet header"));
2502
2503         to->m_flags = (from->m_flags & M_COPYFLAGS) |
2504                       (to->m_flags & ~M_COPYFLAGS);
2505         to->m_pkthdr = from->m_pkthdr;
2506         SLIST_INIT(&to->m_pkthdr.tags);
2507         return (m_tag_copy_chain(to, from, how));
2508 }
2509
2510 /*
2511  * Defragment a mbuf chain, returning the shortest possible
2512  * chain of mbufs and clusters.  If allocation fails and
2513  * this cannot be completed, NULL will be returned, but
2514  * the passed in chain will be unchanged.  Upon success,
2515  * the original chain will be freed, and the new chain
2516  * will be returned.
2517  *
2518  * If a non-packet header is passed in, the original
2519  * mbuf (chain?) will be returned unharmed.
2520  *
2521  * m_defrag_nofree doesn't free the passed in mbuf.
2522  */
2523 struct mbuf *
2524 m_defrag(struct mbuf *m0, int how)
2525 {
2526         struct mbuf *m_new;
2527
2528         if ((m_new = m_defrag_nofree(m0, how)) == NULL)
2529                 return (NULL);
2530         if (m_new != m0)
2531                 m_freem(m0);
2532         return (m_new);
2533 }
2534
2535 struct mbuf *
2536 m_defrag_nofree(struct mbuf *m0, int how)
2537 {
2538         struct mbuf     *m_new = NULL, *m_final = NULL;
2539         int             progress = 0, length, nsize;
2540
2541         if (!(m0->m_flags & M_PKTHDR))
2542                 return (m0);
2543
2544 #ifdef MBUF_STRESS_TEST
2545         if (m_defragrandomfailures) {
2546                 int temp = karc4random() & 0xff;
2547                 if (temp == 0xba)
2548                         goto nospace;
2549         }
2550 #endif
2551         
2552         m_final = m_getl(m0->m_pkthdr.len, how, MT_DATA, M_PKTHDR, &nsize);
2553         if (m_final == NULL)
2554                 goto nospace;
2555         m_final->m_len = 0;     /* in case m0->m_pkthdr.len is zero */
2556
2557         if (m_dup_pkthdr(m_final, m0, how) == 0)
2558                 goto nospace;
2559
2560         m_new = m_final;
2561
2562         while (progress < m0->m_pkthdr.len) {
2563                 length = m0->m_pkthdr.len - progress;
2564                 if (length > MCLBYTES)
2565                         length = MCLBYTES;
2566
2567                 if (m_new == NULL) {
2568                         m_new = m_getl(length, how, MT_DATA, 0, &nsize);
2569                         if (m_new == NULL)
2570                                 goto nospace;
2571                 }
2572
2573                 m_copydata(m0, progress, length, mtod(m_new, caddr_t));
2574                 progress += length;
2575                 m_new->m_len = length;
2576                 if (m_new != m_final)
2577                         m_cat(m_final, m_new);
2578                 m_new = NULL;
2579         }
2580         if (m0->m_next == NULL)
2581                 m_defraguseless++;
2582         m_defragpackets++;
2583         m_defragbytes += m_final->m_pkthdr.len;
2584         return (m_final);
2585 nospace:
2586         m_defragfailure++;
2587         if (m_new)
2588                 m_free(m_new);
2589         m_freem(m_final);
2590         return (NULL);
2591 }
2592
2593 /*
2594  * Move data from uio into mbufs.
2595  */
2596 struct mbuf *
2597 m_uiomove(struct uio *uio)
2598 {
2599         struct mbuf *m;                 /* current working mbuf */
2600         struct mbuf *head = NULL;       /* result mbuf chain */
2601         struct mbuf **mp = &head;
2602         int flags = M_PKTHDR;
2603         int nsize;
2604         int error;
2605         int resid;
2606
2607         do {
2608                 if (uio->uio_resid > INT_MAX)
2609                         resid = INT_MAX;
2610                 else
2611                         resid = (int)uio->uio_resid;
2612                 m = m_getl(resid, M_WAITOK, MT_DATA, flags, &nsize);
2613                 if (flags) {
2614                         m->m_pkthdr.len = 0;
2615                         /* Leave room for protocol headers. */
2616                         if (resid < MHLEN)
2617                                 MH_ALIGN(m, resid);
2618                         flags = 0;
2619                 }
2620                 m->m_len = imin(nsize, resid);
2621                 error = uiomove(mtod(m, caddr_t), m->m_len, uio);
2622                 if (error) {
2623                         m_free(m);
2624                         goto failed;
2625                 }
2626                 *mp = m;
2627                 mp = &m->m_next;
2628                 head->m_pkthdr.len += m->m_len;
2629         } while (uio->uio_resid > 0);
2630
2631         return (head);
2632
2633 failed:
2634         m_freem(head);
2635         return (NULL);
2636 }
2637
2638 struct mbuf *
2639 m_last(struct mbuf *m)
2640 {
2641         while (m->m_next)
2642                 m = m->m_next;
2643         return (m);
2644 }
2645
2646 /*
2647  * Return the number of bytes in an mbuf chain.
2648  * If lastm is not NULL, also return the last mbuf.
2649  */
2650 u_int
2651 m_lengthm(struct mbuf *m, struct mbuf **lastm)
2652 {
2653         u_int len = 0;
2654         struct mbuf *prev = m;
2655
2656         while (m) {
2657                 len += m->m_len;
2658                 prev = m;
2659                 m = m->m_next;
2660         }
2661         if (lastm != NULL)
2662                 *lastm = prev;
2663         return (len);
2664 }
2665
2666 /*
2667  * Like m_lengthm(), except also keep track of mbuf usage.
2668  */
2669 u_int
2670 m_countm(struct mbuf *m, struct mbuf **lastm, u_int *pmbcnt)
2671 {
2672         u_int len = 0, mbcnt = 0;
2673         struct mbuf *prev = m;
2674
2675         while (m) {
2676                 len += m->m_len;
2677                 mbcnt += MSIZE;
2678                 if (m->m_flags & M_EXT)
2679                         mbcnt += m->m_ext.ext_size;
2680                 prev = m;
2681                 m = m->m_next;
2682         }
2683         if (lastm != NULL)
2684                 *lastm = prev;
2685         *pmbcnt = mbcnt;
2686         return (len);
2687 }