![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uipc_mbuf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / kern|
Return to uipc_mbuf.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1982, 1986, 1988, 1991, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)uipc_mbuf.c 8.4 (Berkeley) 2/14/95
59: */
60:
61: #include <sys/param.h>
62: #include <sys/systm.h>
63: #include <sys/malloc.h>
64: #include <sys/mbuf.h>
65: #include <sys/kernel.h>
66: #include <sys/syslog.h>
67: #include <sys/protosw.h>
68: #include <sys/domain.h>
69: #include <net/netisr.h>
70:
71: struct mbuf *mfree; /* mbuf free list */
72: struct mbuf *mfreelater; /* mbuf deallocation list */
73: extern vm_map_t mb_map; /* special map */
74: int m_want; /* sleepers on mbufs */
75: extern int nmbclusters; /* max number of mapped clusters */
76: short *mclrefcnt; /* mapped cluster reference counts */
77: union mcluster *mclfree; /* mapped cluster free list */
78: int max_linkhdr; /* largest link-level header */
79: int max_protohdr; /* largest protocol header */
80: int max_hdr; /* largest link+protocol header */
81: int max_datalen; /* MHLEN - max_hdr */
82: struct mbstat mbstat; /* statistics */
83: union mcluster *mbutl; /* first mapped cluster address */
84: union mcluster embutl; /* virtual address of mclusters */
85:
86: static int nclpp; /* # clusters per physical page */
87: static char mbfail[] = "mbuf not mapped";
88:
89: static int m_howmany();
90:
91: /* The number of cluster mbufs that are allocated, to start. */
92: #define MINCL max(16, 2)
93:
94: void
95: mbinit()
96: {
97: int s,m;
98:
99: if (nclpp)
100: return;
101: s = splimp();
102: nclpp = round_page(MCLBYTES) / MCLBYTES; /* see mbufgc() */
103: if (nclpp < 1) nclpp = 1;
104: MBUF_LOCKINIT();
105: // NETISR_LOCKINIT();
106: if (nmbclusters == 0)
107: nmbclusters = NMBCLUSTERS;
108: MALLOC(mclrefcnt, short *, nmbclusters * sizeof (short),
109: M_TEMP, M_WAITOK);
110: if (mclrefcnt == 0)
111: panic("mbinit");
112: for (m = 0; m < nmbclusters; m++)
113: mclrefcnt[m] = -1;
114: MBUF_LOCK();
115: if (m_clalloc(max(4096/CLBYTES, 1) * 10, M_DONTWAIT) == 0)
116: goto bad;
117: MBUF_UNLOCK();
118: splx(s);
119: return;
120: bad:
121: panic("mbinit");
122: }
123:
124: /*
125: * Allocate some number of mbuf clusters
126: * and place on cluster free list.
127: * Must be called at splimp.
128: */
129: /* ARGSUSED */
130: m_clalloc(ncl, nowait)
131: register int ncl;
132: int nowait;
133: {
134: register union mcluster *mcl;
135: register int i;
136: vm_size_t size;
137: static char doing_alloc;
138:
139: if (doing_alloc || (i = m_howmany()) <= 0)
140: goto out;
141: doing_alloc = 1;
142: MBUF_UNLOCK();
143:
144: if (ncl < i) ncl = i;
145: size = round_page(ncl * MCLBYTES);
146: mcl = (union mcluster *)kmem_mb_alloc(mb_map, size);
147: if (mcl == 0 && ncl > 1) {
148: size = round_page(MCLBYTES); /* Try for 1 if failed */
149: mcl = (union mcluster *)kmem_mb_alloc(mb_map, size);
150: }
151: MBUF_LOCK();
152: doing_alloc = 0;
153: if (mcl) {
154: ncl = size / MCLBYTES;
155: for (i = 0; i < ncl; i++) {
156: if (++mclrefcnt[mtocl(mcl)] != 0)
157: panic("m_clalloc already there");
158: mcl->mcl_next = mclfree;
159: mclfree = mcl++;
160: }
161: mbstat.m_clfree += ncl;
162: mbstat.m_clusters += ncl;
163: return (ncl);
164: } /* else ... */
165: out:
166: if (mclfree)
167: return 1;
168: mbstat.m_drops++;
169: return 0;
170: }
171:
172: /*
173: * Add more free mbufs by cutting up a cluster.
174: */
175: m_expand(canwait)
176: int canwait;
177: {
178: register caddr_t mcl;
179:
180: if (mbstat.m_clfree < (mbstat.m_clusters >> 4))
181: /* 1/16th of the total number of cluster mbufs allocated is
182: reserved for large packets. The number reserved must
183: always be < 1/2, or future allocation will be prevented.
184: */
185: return 0;
186:
187: MCLALLOC(mcl, canwait);
188: if (mcl) {
189: register struct mbuf *m = (struct mbuf *)mcl;
190: register int i = NMBPCL;
191: int s = splimp();
192: MBUF_LOCK();
193: mbstat.m_mtypes[MT_FREE] += i;
194: mbstat.m_mbufs += i;
195: while (i--) {
196: m->m_type = MT_FREE;
197: m->m_next = mfree;
198: mfree = m++;
199: }
200: i = m_want;
201: m_want = 0;
202: MBUF_UNLOCK();
203: splx(s);
204: if (i) wakeup((caddr_t)&mfree);
205: return 1;
206: }
207: return 0;
208: }
209:
210: /*
211: * When MGET failes, ask protocols to free space when short of memory,
212: * then re-attempt to allocate an mbuf.
213: */
214: struct mbuf *
215: m_retry(canwait, type)
216: int canwait, type;
217: {
218: #define m_retry(h, t) 0
219: register struct mbuf *m;
220: int wait, s;
221:
222: for (;;) {
223: (void) m_expand(canwait);
224: MGET(m, XXX, type);
225: if (m || canwait == M_DONTWAIT)
226: break;
227: s = splimp();
228: MBUF_LOCK();
229: wait = m_want++;
230: if (wait == 0)
231: mbstat.m_drain++;
232: else {
233: assert_wait((caddr_t)&mfree, FALSE);
234: mbstat.m_wait++;
235: }
236: MBUF_UNLOCK();
237: if (wait == 0) {
238: splx(s);
239: m_reclaim();
240: } else {
241: /* Sleep with a small timeout as insurance */
242: (void) tsleep((caddr_t)0, PZERO-1, "m_retry", hz);
243: splx(s);
244: }
245: }
246: return (m);
247: #undef m_retry
248: }
249:
250: /*
251: * As above; retry an MGETHDR.
252: */
253: struct mbuf *
254: m_retryhdr(canwait, type)
255: int canwait, type;
256: {
257: register struct mbuf *m;
258:
259: if (m = m_retry(canwait, type)) {
260: m->m_flags |= M_PKTHDR;
261: m->m_data = m->m_pktdat;
262: }
263: return (m);
264: }
265:
266: m_reclaim()
267: {
268: register struct domain *dp;
269: register struct protosw *pr;
270: int s = splimp();
271:
272: for (dp = domains; dp; dp = dp->dom_next)
273: for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
274: if (pr->pr_drain)
275: (*pr->pr_drain)();
276: splx(s);
277: mbstat.m_drain++;
278: }
279:
280: /*
281: * Space allocation routines.
282: * These are also available as macros
283: * for critical paths.
284: */
285: struct mbuf *
286: m_get(nowait, type)
287: int nowait, type;
288: {
289: register struct mbuf *m;
290:
291: MGET(m, nowait, type);
292: return (m);
293: }
294:
295: struct mbuf *
296: m_gethdr(nowait, type)
297: int nowait, type;
298: {
299: register struct mbuf *m;
300:
301: MGETHDR(m, nowait, type);
302: return (m);
303: }
304:
305: struct mbuf *
306: m_getclr(nowait, type)
307: int nowait, type;
308: {
309: register struct mbuf *m;
310:
311: MGET(m, nowait, type);
312: if (m == 0)
313: return (0);
314: bzero(mtod(m, caddr_t), MLEN);
315: return (m);
316: }
317:
318: struct mbuf *
319: m_free(m)
320: struct mbuf *m;
321: {
322: struct mbuf *n = m->m_next;
323: int i, s;
324:
325: if (m->m_type == MT_FREE)
326: panic("freeing free mbuf");
327: s = splimp();
328: MBUF_LOCK();
329: if (m->m_flags & M_EXT) {
330: if (MCLHASREFERENCE(m)) {
331: remque((queue_t)&m->m_ext.ext_refs);
332: } else if (m->m_ext.ext_free == NULL) {
333: union mcluster *mcl= (union mcluster *)m->m_ext.ext_buf;
334: if (MCLUNREF(mcl)) {
335: mcl->mcl_next = mclfree;
336: mclfree = mcl;
337: ++mbstat.m_clfree;
338: } else /* sanity check - not referenced this way */
339: panic("m_free m_ext cluster not free");
340: } else {
341: (*(m->m_ext.ext_free))(m->m_ext.ext_buf,
342: m->m_ext.ext_size, m->m_ext.ext_arg);
343: }
344: }
345: mbstat.m_mtypes[m->m_type]--;
346: (void) MCLUNREF(m);
347: m->m_type = MT_FREE;
348: mbstat.m_mtypes[m->m_type]++;
349: m->m_flags = 0;
350: m->m_next = mfree;
351: m->m_len = 0;
352: mfree = m;
353: i = m_want;
354: m_want = 0;
355: MBUF_UNLOCK();
356: splx(s);
357: if (i) wakeup((caddr_t)&mfree);
358: return (n);
359: }
360:
361: void
362: m_freem(m)
363: register struct mbuf *m;
364: {
365: while (m)
366: m = m_free(m);
367: }
368:
369: /*
370: * Mbuffer utility routines.
371: */
372: /*
373: * Compute the amount of space available
374: * before the current start of data in an mbuf.
375: */
376: m_leadingspace(m)
377: register struct mbuf *m;
378: {
379: if (m->m_flags & M_EXT) {
380: if (MCLHASREFERENCE(m))
381: return(0);
382: return (m->m_data - m->m_ext.ext_buf);
383: }
384: if (m->m_flags & M_PKTHDR)
385: return (m->m_data - m->m_pktdat);
386: return (m->m_data - m->m_dat);
387: }
388:
389: /*
390: * Compute the amount of space available
391: * after the end of data in an mbuf.
392: */
393: m_trailingspace(m)
394: register struct mbuf *m;
395: {
396: if (m->m_flags & M_EXT) {
397: if (MCLHASREFERENCE(m))
398: return(0);
399: return (m->m_ext.ext_buf + m->m_ext.ext_size -
400: (m->m_data + m->m_len));
401: }
402: return (&m->m_dat[MLEN] - (m->m_data + m->m_len));
403: }
404:
405: /*
406: * Lesser-used path for M_PREPEND:
407: * allocate new mbuf to prepend to chain,
408: * copy junk along.
409: */
410: struct mbuf *
411: m_prepend(m, len, how)
412: register struct mbuf *m;
413: int len, how;
414: {
415: struct mbuf *mn;
416:
417: MGET(mn, how, m->m_type);
418: if (mn == (struct mbuf *)NULL) {
419: m_freem(m);
420: return ((struct mbuf *)NULL);
421: }
422: if (m->m_flags & M_PKTHDR) {
423: M_COPY_PKTHDR(mn, m);
424: m->m_flags &= ~M_PKTHDR;
425: }
426: mn->m_next = m;
427: m = mn;
428: if (len < MHLEN)
429: MH_ALIGN(m, len);
430: m->m_len = len;
431: return (m);
432: }
433:
434: /*
435: * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
436: * continuing for "len" bytes. If len is M_COPYALL, copy to end of mbuf.
437: * The wait parameter is a choice of M_WAIT/M_DONTWAIT from caller.
438: */
439: int MCFail;
440:
441: struct mbuf *
442: m_copym(m, off0, len, wait)
443: register struct mbuf *m;
444: int off0, wait;
445: register int len;
446: {
447: register struct mbuf *n, **np;
448: register int off = off0;
449: struct mbuf *top;
450: int copyhdr = 0;
451:
452: if (off < 0 || len < 0)
453: panic("m_copym");
454: if (off == 0 && m->m_flags & M_PKTHDR)
455: copyhdr = 1;
456: while (off > 0) {
457: if (m == 0)
458: panic("m_copym");
459: if (off < m->m_len)
460: break;
461: off -= m->m_len;
462: m = m->m_next;
463: }
464: np = ⊤
465: top = 0;
466: while (len > 0) {
467: if (m == 0) {
468: if (len != M_COPYALL)
469: panic("m_copym");
470: break;
471: }
472: MGET(n, wait, m->m_type);
473: *np = n;
474: if (n == 0)
475: goto nospace;
476: if (copyhdr) {
477: M_COPY_PKTHDR(n, m);
478: if (len == M_COPYALL)
479: n->m_pkthdr.len -= off0;
480: else
481: n->m_pkthdr.len = len;
482: copyhdr = 0;
483: }
484: if (len == M_COPYALL) {
485: if (min(len, (m->m_len - off)) == len) {
486: printf("m->m_len %d - off %d = %d, %d\n",
487: m->m_len, off, m->m_len - off,
488: min(len, (m->m_len - off)));
489: }
490: }
491: n->m_len = min(len, (m->m_len - off));
492: if (n->m_len == M_COPYALL) {
493: printf("n->m_len == M_COPYALL, fixing\n");
494: n->m_len = MHLEN;
495: }
496: if (m->m_flags & M_EXT) {
497: int s = splimp();
498: MBUF_LOCK();
499: n->m_ext = m->m_ext;
500: insque((queue_t)&n->m_ext.ext_refs, (queue_t)&m->m_ext.ext_refs);
501: MBUF_UNLOCK();
502: splx(s);
503: n->m_data = m->m_data + off;
504: n->m_flags |= M_EXT;
505: } else
506: bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
507: (unsigned)n->m_len);
508: if (len != M_COPYALL)
509: len -= n->m_len;
510: off = 0;
511: m = m->m_next;
512: np = &n->m_next;
513: }
514: if (top == 0)
515: MCFail++;
516: return (top);
517: nospace:
518: m_freem(top);
519: MCFail++;
520: return (0);
521: }
522:
523: /*
524: * Copy data from an mbuf chain starting "off" bytes from the beginning,
525: * continuing for "len" bytes, into the indicated buffer.
526: */
527: m_copydata(m, off, len, cp)
528: register struct mbuf *m;
529: register int off;
530: register int len;
531: caddr_t cp;
532: {
533: register unsigned count;
534:
535: if (off < 0 || len < 0)
536: panic("m_copydata");
537: while (off > 0) {
538: if (m == 0)
539: panic("m_copydata");
540: if (off < m->m_len)
541: break;
542: off -= m->m_len;
543: m = m->m_next;
544: }
545: while (len > 0) {
546: if (m == 0)
547: panic("m_copydata");
548: count = min(m->m_len - off, len);
549: bcopy(mtod(m, caddr_t) + off, cp, count);
550: len -= count;
551: cp += count;
552: off = 0;
553: m = m->m_next;
554: }
555: }
556:
557: /*
558: * Concatenate mbuf chain n to m.
559: * Both chains must be of the same type (e.g. MT_DATA).
560: * Any m_pkthdr is not updated.
561: */
562: m_cat(m, n)
563: register struct mbuf *m, *n;
564: {
565: while (m->m_next)
566: m = m->m_next;
567: while (n) {
568: if (m->m_flags & M_EXT ||
569: m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) {
570: /* just join the two chains */
571: m->m_next = n;
572: return;
573: }
574: /* splat the data from one into the other */
575: bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
576: (u_int)n->m_len);
577: m->m_len += n->m_len;
578: n = m_free(n);
579: }
580: }
581:
582: void
583: m_adj(mp, req_len)
584: struct mbuf *mp;
585: int req_len;
586: {
587: register int len = req_len;
588: register struct mbuf *m;
589: register count;
590:
591: if ((m = mp) == NULL)
592: return;
593: if (len >= 0) {
594: /*
595: * Trim from head.
596: */
597: while (m != NULL && len > 0) {
598: if (m->m_len <= len) {
599: len -= m->m_len;
600: m->m_len = 0;
601: m = m->m_next;
602: } else {
603: m->m_len -= len;
604: m->m_data += len;
605: len = 0;
606: }
607: }
608: m = mp;
609: if (m->m_flags & M_PKTHDR)
610: m->m_pkthdr.len -= (req_len - len);
611: } else {
612: /*
613: * Trim from tail. Scan the mbuf chain,
614: * calculating its length and finding the last mbuf.
615: * If the adjustment only affects this mbuf, then just
616: * adjust and return. Otherwise, rescan and truncate
617: * after the remaining size.
618: */
619: len = -len;
620: count = 0;
621: for (;;) {
622: count += m->m_len;
623: if (m->m_next == (struct mbuf *)0)
624: break;
625: m = m->m_next;
626: }
627: if (m->m_len >= len) {
628: m->m_len -= len;
629: m = mp;
630: if (m->m_flags & M_PKTHDR)
631: m->m_pkthdr.len -= len;
632: return;
633: }
634: count -= len;
635: if (count < 0)
636: count = 0;
637: /*
638: * Correct length for chain is "count".
639: * Find the mbuf with last data, adjust its length,
640: * and toss data from remaining mbufs on chain.
641: */
642: m = mp;
643: if (m->m_flags & M_PKTHDR)
644: m->m_pkthdr.len = count;
645: for (; m; m = m->m_next) {
646: if (m->m_len >= count) {
647: m->m_len = count;
648: break;
649: }
650: count -= m->m_len;
651: }
652: while (m = m->m_next)
653: m->m_len = 0;
654: }
655: }
656:
657: /*
658: * Rearange an mbuf chain so that len bytes are contiguous
659: * and in the data area of an mbuf (so that mtod and dtom
660: * will work for a structure of size len). Returns the resulting
661: * mbuf chain on success, frees it and returns null on failure.
662: * If there is room, it will add up to max_protohdr-len extra bytes to the
663: * contiguous region in an attempt to avoid being called next time.
664: */
665: int MPFail;
666:
667: struct mbuf *
668: m_pullup(n, len)
669: register struct mbuf *n;
670: int len;
671: {
672: register struct mbuf *m;
673: register int count;
674: int space;
675:
676: /*
677: * If first mbuf has no cluster, and has room for len bytes
678: * without shifting current data, pullup into it,
679: * otherwise allocate a new mbuf to prepend to the chain.
680: */
681: if ((n->m_flags & M_EXT) == 0 &&
682: n->m_data + len < &n->m_dat[MLEN] && n->m_next) {
683: if (n->m_len >= len)
684: return (n);
685: m = n;
686: n = n->m_next;
687: len -= m->m_len;
688: } else {
689: if (len > MHLEN)
690: goto bad;
691: MGET(m, M_DONTWAIT, n->m_type);
692: if (m == 0)
693: goto bad;
694: m->m_len = 0;
695: if (n->m_flags & M_PKTHDR) {
696: M_COPY_PKTHDR(m, n);
697: n->m_flags &= ~M_PKTHDR;
698: }
699: }
700: space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
701: do {
702: count = min(min(max(len, max_protohdr), space), n->m_len);
703: bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
704: (unsigned)count);
705: len -= count;
706: m->m_len += count;
707: n->m_len -= count;
708: space -= count;
709: if (n->m_len)
710: n->m_data += count;
711: else
712: n = m_free(n);
713: } while (len > 0 && n);
714: if (len > 0) {
715: (void) m_free(m);
716: goto bad;
717: }
718: m->m_next = n;
719: return (m);
720: bad:
721: m_freem(n);
722: MPFail++;
723: return (0);
724: }
725:
726: /*
727: * Partition an mbuf chain in two pieces, returning the tail --
728: * all but the first len0 bytes. In case of failure, it returns NULL and
729: * attempts to restore the chain to its original state.
730: */
731: struct mbuf *
732: m_split(m0, len0, wait)
733: register struct mbuf *m0;
734: int len0, wait;
735: {
736: register struct mbuf *m, *n;
737: unsigned len = len0, remain;
738:
739: for (m = m0; m && len > m->m_len; m = m->m_next)
740: len -= m->m_len;
741: if (m == 0)
742: return (0);
743: remain = m->m_len - len;
744: if (m0->m_flags & M_PKTHDR) {
745: MGETHDR(n, wait, m0->m_type);
746: if (n == 0)
747: return (0);
748: n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
749: n->m_pkthdr.len = m0->m_pkthdr.len - len0;
750: m0->m_pkthdr.len = len0;
751: if (m->m_flags & M_EXT)
752: goto extpacket;
753: if (remain > MHLEN) {
754: /* m can't be the lead packet */
755: MH_ALIGN(n, 0);
756: n->m_next = m_split(m, len, wait);
757: if (n->m_next == 0) {
758: (void) m_free(n);
759: return (0);
760: } else
761: return (n);
762: } else
763: MH_ALIGN(n, remain);
764: } else if (remain == 0) {
765: n = m->m_next;
766: m->m_next = 0;
767: return (n);
768: } else {
769: MGET(n, wait, m->m_type);
770: if (n == 0)
771: return (0);
772: M_ALIGN(n, remain);
773: }
774: extpacket:
775: if (m->m_flags & M_EXT) {
776: n->m_flags |= M_EXT;
777: n->m_ext = m->m_ext;
778: mclrefcnt[mtocl(m->m_ext.ext_buf)]++;
779: m->m_ext.ext_size = 0; /* For Accounting XXXXXX danger */
780: n->m_data = m->m_data + len;
781: } else {
782: bcopy(mtod(m, caddr_t) + len, mtod(n, caddr_t), remain);
783: }
784: n->m_len = remain;
785: m->m_len = len;
786: n->m_next = m->m_next;
787: m->m_next = 0;
788: return (n);
789: }
790: /*
791: * Routine to copy from device local memory into mbufs.
792: */
793: struct mbuf *
794: m_devget(buf, totlen, off0, ifp, copy)
795: char *buf;
796: int totlen, off0;
797: struct ifnet *ifp;
798: void (*copy)();
799: {
800: register struct mbuf *m;
801: struct mbuf *top = 0, **mp = ⊤
802: register int off = off0, len;
803: register char *cp;
804: char *epkt;
805:
806: cp = buf;
807: epkt = cp + totlen;
808: if (off) {
809: /*
810: * If 'off' is non-zero, packet is trailer-encapsulated,
811: * so we have to skip the type and length fields.
812: */
813: cp += off + 2 * sizeof(u_int16_t);
814: totlen -= 2 * sizeof(u_int16_t);
815: }
816: MGETHDR(m, M_DONTWAIT, MT_DATA);
817: if (m == 0)
818: return (0);
819: m->m_pkthdr.rcvif = ifp;
820: m->m_pkthdr.len = totlen;
821: m->m_len = MHLEN;
822:
823: while (totlen > 0) {
824: if (top) {
825: MGET(m, M_DONTWAIT, MT_DATA);
826: if (m == 0) {
827: m_freem(top);
828: return (0);
829: }
830: m->m_len = MLEN;
831: }
832: len = min(totlen, epkt - cp);
833: if (len >= MINCLSIZE) {
834: MCLGET(m, M_DONTWAIT);
835: if (m->m_flags & M_EXT)
836: m->m_len = len = min(len, MCLBYTES);
837: else {
838: /* give up when it's out of cluster mbufs */
839: if (top)
840: m_freem(top);
841: m_freem(m);
842: return (0);
843: }
844: } else {
845: /*
846: * Place initial small packet/header at end of mbuf.
847: */
848: if (len < m->m_len) {
849: if (top == 0 && len + max_linkhdr <= m->m_len)
850: m->m_data += max_linkhdr;
851: m->m_len = len;
852: } else
853: len = m->m_len;
854: }
855: if (copy)
856: copy(cp, mtod(m, caddr_t), (unsigned)len);
857: else
858: bcopy(cp, mtod(m, caddr_t), (unsigned)len);
859: cp += len;
860: *mp = m;
861: mp = &m->m_next;
862: totlen -= len;
863: if (cp == epkt)
864: cp = buf;
865: }
866: return (top);
867: }
868:
869: /*
870: * Cluster freelist allocation check. Mbuf lock/splimp must be held.
871: * Ensure hysteresis between hi/lo.
872: */
873: static int
874: m_howmany()
875: {
876: register int i;
877:
878: /* Under minimum */
879: if (mbstat.m_clusters < MINCL)
880: return (MINCL - mbstat.m_clusters);
881: /* Too few (free < 1/2 total) and not over maximum */
882: if (mbstat.m_clusters < nmbclusters &&
883: (i = ((mbstat.m_clusters >> 1) - mbstat.m_clfree)) > 0)
884: return i;
885: return 0;
886: }
887:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.