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