![[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 [Net/2] / Net2 / kern|
Return to uipc_mbuf.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1988, 1991 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)uipc_mbuf.c 7.19 (Berkeley) 4/20/91 ! 34: */ ! 35: ! 36: #include "param.h" ! 37: #include "proc.h" ! 38: #include "malloc.h" ! 39: #include "map.h" ! 40: #define MBTYPES ! 41: #include "mbuf.h" ! 42: #include "kernel.h" ! 43: #include "syslog.h" ! 44: #include "domain.h" ! 45: #include "protosw.h" ! 46: #include "vm/vm.h" ! 47: ! 48: extern vm_map_t mb_map; ! 49: struct mbuf *mbutl; ! 50: char *mclrefcnt; ! 51: ! 52: mbinit() ! 53: { ! 54: int s; ! 55: ! 56: #if CLBYTES < 4096 ! 57: #define NCL_INIT (4096/CLBYTES) ! 58: #else ! 59: #define NCL_INIT 1 ! 60: #endif ! 61: s = splimp(); ! 62: if (m_clalloc(NCL_INIT, M_DONTWAIT) == 0) ! 63: goto bad; ! 64: splx(s); ! 65: return; ! 66: bad: ! 67: panic("mbinit"); ! 68: } ! 69: ! 70: /* ! 71: * Allocate some number of mbuf clusters ! 72: * and place on cluster free list. ! 73: * Must be called at splimp. ! 74: */ ! 75: /* ARGSUSED */ ! 76: m_clalloc(ncl, canwait) ! 77: register int ncl; ! 78: { ! 79: int npg, mbx; ! 80: register caddr_t p; ! 81: register int i; ! 82: static int logged; ! 83: ! 84: npg = ncl * CLSIZE; ! 85: p = (caddr_t)kmem_malloc(mb_map, ctob(npg), canwait); ! 86: if (p == NULL) { ! 87: if (logged == 0) { ! 88: logged++; ! 89: log(LOG_ERR, "mb_map full\n"); ! 90: } ! 91: return (0); ! 92: } ! 93: ncl = ncl * CLBYTES / MCLBYTES; ! 94: for (i = 0; i < ncl; i++) { ! 95: ((union mcluster *)p)->mcl_next = mclfree; ! 96: mclfree = (union mcluster *)p; ! 97: p += MCLBYTES; ! 98: mbstat.m_clfree++; ! 99: } ! 100: mbstat.m_clusters += ncl; ! 101: return (1); ! 102: } ! 103: ! 104: /* ! 105: * When MGET failes, ask protocols to free space when short of memory, ! 106: * then re-attempt to allocate an mbuf. ! 107: */ ! 108: struct mbuf * ! 109: m_retry(i, t) ! 110: int i, t; ! 111: { ! 112: register struct mbuf *m; ! 113: ! 114: m_reclaim(); ! 115: #define m_retry(i, t) (struct mbuf *)0 ! 116: MGET(m, i, t); ! 117: #undef m_retry ! 118: return (m); ! 119: } ! 120: ! 121: /* ! 122: * As above; retry an MGETHDR. ! 123: */ ! 124: struct mbuf * ! 125: m_retryhdr(i, t) ! 126: int i, t; ! 127: { ! 128: register struct mbuf *m; ! 129: ! 130: m_reclaim(); ! 131: #define m_retryhdr(i, t) (struct mbuf *)0 ! 132: MGETHDR(m, i, t); ! 133: #undef m_retryhdr ! 134: return (m); ! 135: } ! 136: ! 137: m_reclaim() ! 138: { ! 139: register struct domain *dp; ! 140: register struct protosw *pr; ! 141: int s = splimp(); ! 142: ! 143: for (dp = domains; dp; dp = dp->dom_next) ! 144: for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) ! 145: if (pr->pr_drain) ! 146: (*pr->pr_drain)(); ! 147: splx(s); ! 148: mbstat.m_drain++; ! 149: } ! 150: ! 151: /* ! 152: * Space allocation routines. ! 153: * These are also available as macros ! 154: * for critical paths. ! 155: */ ! 156: struct mbuf * ! 157: m_get(canwait, type) ! 158: int canwait, type; ! 159: { ! 160: register struct mbuf *m; ! 161: ! 162: MGET(m, canwait, type); ! 163: return (m); ! 164: } ! 165: ! 166: struct mbuf * ! 167: m_gethdr(canwait, type) ! 168: int canwait, type; ! 169: { ! 170: register struct mbuf *m; ! 171: ! 172: MGETHDR(m, canwait, type); ! 173: return (m); ! 174: } ! 175: ! 176: struct mbuf * ! 177: m_getclr(canwait, type) ! 178: int canwait, type; ! 179: { ! 180: register struct mbuf *m; ! 181: ! 182: MGET(m, canwait, type); ! 183: if (m == 0) ! 184: return (0); ! 185: bzero(mtod(m, caddr_t), MLEN); ! 186: return (m); ! 187: } ! 188: ! 189: struct mbuf * ! 190: m_free(m) ! 191: struct mbuf *m; ! 192: { ! 193: register struct mbuf *n; ! 194: ! 195: MFREE(m, n); ! 196: return (n); ! 197: } ! 198: ! 199: m_freem(m) ! 200: register struct mbuf *m; ! 201: { ! 202: register struct mbuf *n; ! 203: ! 204: if (m == NULL) ! 205: return; ! 206: do { ! 207: MFREE(m, n); ! 208: } while (m = n); ! 209: } ! 210: ! 211: /* ! 212: * Mbuffer utility routines. ! 213: */ ! 214: ! 215: /* ! 216: * Lesser-used path for M_PREPEND: ! 217: * allocate new mbuf to prepend to chain, ! 218: * copy junk along. ! 219: */ ! 220: struct mbuf * ! 221: m_prepend(m, len, how) ! 222: register struct mbuf *m; ! 223: int len, how; ! 224: { ! 225: struct mbuf *mn; ! 226: ! 227: MGET(mn, how, m->m_type); ! 228: if (mn == (struct mbuf *)NULL) { ! 229: m_freem(m); ! 230: return ((struct mbuf *)NULL); ! 231: } ! 232: if (m->m_flags & M_PKTHDR) { ! 233: M_COPY_PKTHDR(mn, m); ! 234: m->m_flags &= ~M_PKTHDR; ! 235: } ! 236: mn->m_next = m; ! 237: m = mn; ! 238: if (len < MHLEN) ! 239: MH_ALIGN(m, len); ! 240: m->m_len = len; ! 241: return (m); ! 242: } ! 243: ! 244: /* ! 245: * Make a copy of an mbuf chain starting "off0" bytes from the beginning, ! 246: * continuing for "len" bytes. If len is M_COPYALL, copy to end of mbuf. ! 247: * The wait parameter is a choice of M_WAIT/M_DONTWAIT from caller. ! 248: */ ! 249: int MCFail; ! 250: ! 251: struct mbuf * ! 252: m_copym(m, off0, len, wait) ! 253: register struct mbuf *m; ! 254: int off0, wait; ! 255: register int len; ! 256: { ! 257: register struct mbuf *n, **np; ! 258: register int off = off0; ! 259: struct mbuf *top; ! 260: int copyhdr = 0; ! 261: ! 262: if (off < 0 || len < 0) ! 263: panic("m_copym"); ! 264: if (off == 0 && m->m_flags & M_PKTHDR) ! 265: copyhdr = 1; ! 266: while (off > 0) { ! 267: if (m == 0) ! 268: panic("m_copym"); ! 269: if (off < m->m_len) ! 270: break; ! 271: off -= m->m_len; ! 272: m = m->m_next; ! 273: } ! 274: np = ⊤ ! 275: top = 0; ! 276: while (len > 0) { ! 277: if (m == 0) { ! 278: if (len != M_COPYALL) ! 279: panic("m_copym"); ! 280: break; ! 281: } ! 282: MGET(n, wait, m->m_type); ! 283: *np = n; ! 284: if (n == 0) ! 285: goto nospace; ! 286: if (copyhdr) { ! 287: M_COPY_PKTHDR(n, m); ! 288: if (len == M_COPYALL) ! 289: n->m_pkthdr.len -= off0; ! 290: else ! 291: n->m_pkthdr.len = len; ! 292: copyhdr = 0; ! 293: } ! 294: n->m_len = MIN(len, m->m_len - off); ! 295: if (m->m_flags & M_EXT) { ! 296: n->m_data = m->m_data + off; ! 297: mclrefcnt[mtocl(m->m_ext.ext_buf)]++; ! 298: n->m_ext = m->m_ext; ! 299: n->m_flags |= M_EXT; ! 300: } else ! 301: bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t), ! 302: (unsigned)n->m_len); ! 303: if (len != M_COPYALL) ! 304: len -= n->m_len; ! 305: off = 0; ! 306: m = m->m_next; ! 307: np = &n->m_next; ! 308: } ! 309: if (top == 0) ! 310: MCFail++; ! 311: return (top); ! 312: nospace: ! 313: m_freem(top); ! 314: MCFail++; ! 315: return (0); ! 316: } ! 317: ! 318: /* ! 319: * Copy data from an mbuf chain starting "off" bytes from the beginning, ! 320: * continuing for "len" bytes, into the indicated buffer. ! 321: */ ! 322: m_copydata(m, off, len, cp) ! 323: register struct mbuf *m; ! 324: register int off; ! 325: register int len; ! 326: caddr_t cp; ! 327: { ! 328: register unsigned count; ! 329: ! 330: if (off < 0 || len < 0) ! 331: panic("m_copydata"); ! 332: while (off > 0) { ! 333: if (m == 0) ! 334: panic("m_copydata"); ! 335: if (off < m->m_len) ! 336: break; ! 337: off -= m->m_len; ! 338: m = m->m_next; ! 339: } ! 340: while (len > 0) { ! 341: if (m == 0) ! 342: panic("m_copydata"); ! 343: count = MIN(m->m_len - off, len); ! 344: bcopy(mtod(m, caddr_t) + off, cp, count); ! 345: len -= count; ! 346: cp += count; ! 347: off = 0; ! 348: m = m->m_next; ! 349: } ! 350: } ! 351: ! 352: /* ! 353: * Concatenate mbuf chain n to m. ! 354: * Both chains must be of the same type (e.g. MT_DATA). ! 355: * Any m_pkthdr is not updated. ! 356: */ ! 357: m_cat(m, n) ! 358: register struct mbuf *m, *n; ! 359: { ! 360: while (m->m_next) ! 361: m = m->m_next; ! 362: while (n) { ! 363: if (m->m_flags & M_EXT || ! 364: m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) { ! 365: /* just join the two chains */ ! 366: m->m_next = n; ! 367: return; ! 368: } ! 369: /* splat the data from one into the other */ ! 370: bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len, ! 371: (u_int)n->m_len); ! 372: m->m_len += n->m_len; ! 373: n = m_free(n); ! 374: } ! 375: } ! 376: ! 377: m_adj(mp, req_len) ! 378: struct mbuf *mp; ! 379: { ! 380: register int len = req_len; ! 381: register struct mbuf *m; ! 382: register count; ! 383: ! 384: if ((m = mp) == NULL) ! 385: return; ! 386: if (len >= 0) { ! 387: /* ! 388: * Trim from head. ! 389: */ ! 390: while (m != NULL && len > 0) { ! 391: if (m->m_len <= len) { ! 392: len -= m->m_len; ! 393: m->m_len = 0; ! 394: m = m->m_next; ! 395: } else { ! 396: m->m_len -= len; ! 397: m->m_data += len; ! 398: len = 0; ! 399: } ! 400: } ! 401: m = mp; ! 402: if (mp->m_flags & M_PKTHDR) ! 403: m->m_pkthdr.len -= (req_len - len); ! 404: } else { ! 405: /* ! 406: * Trim from tail. Scan the mbuf chain, ! 407: * calculating its length and finding the last mbuf. ! 408: * If the adjustment only affects this mbuf, then just ! 409: * adjust and return. Otherwise, rescan and truncate ! 410: * after the remaining size. ! 411: */ ! 412: len = -len; ! 413: count = 0; ! 414: for (;;) { ! 415: count += m->m_len; ! 416: if (m->m_next == (struct mbuf *)0) ! 417: break; ! 418: m = m->m_next; ! 419: } ! 420: if (m->m_len >= len) { ! 421: m->m_len -= len; ! 422: if ((mp = m)->m_flags & M_PKTHDR) ! 423: m->m_pkthdr.len -= len; ! 424: return; ! 425: } ! 426: count -= len; ! 427: if (count < 0) ! 428: count = 0; ! 429: /* ! 430: * Correct length for chain is "count". ! 431: * Find the mbuf with last data, adjust its length, ! 432: * and toss data from remaining mbufs on chain. ! 433: */ ! 434: m = mp; ! 435: if (m->m_flags & M_PKTHDR) ! 436: m->m_pkthdr.len = count; ! 437: for (; m; m = m->m_next) { ! 438: if (m->m_len >= count) { ! 439: m->m_len = count; ! 440: break; ! 441: } ! 442: count -= m->m_len; ! 443: } ! 444: while (m = m->m_next) ! 445: m->m_len = 0; ! 446: } ! 447: } ! 448: ! 449: /* ! 450: * Rearange an mbuf chain so that len bytes are contiguous ! 451: * and in the data area of an mbuf (so that mtod and dtom ! 452: * will work for a structure of size len). Returns the resulting ! 453: * mbuf chain on success, frees it and returns null on failure. ! 454: * If there is room, it will add up to max_protohdr-len extra bytes to the ! 455: * contiguous region in an attempt to avoid being called next time. ! 456: */ ! 457: int MPFail; ! 458: ! 459: struct mbuf * ! 460: m_pullup(n, len) ! 461: register struct mbuf *n; ! 462: int len; ! 463: { ! 464: register struct mbuf *m; ! 465: register int count; ! 466: int space; ! 467: ! 468: /* ! 469: * If first mbuf has no cluster, and has room for len bytes ! 470: * without shifting current data, pullup into it, ! 471: * otherwise allocate a new mbuf to prepend to the chain. ! 472: */ ! 473: if ((n->m_flags & M_EXT) == 0 && ! 474: n->m_data + len < &n->m_dat[MLEN] && n->m_next) { ! 475: if (n->m_len >= len) ! 476: return (n); ! 477: m = n; ! 478: n = n->m_next; ! 479: len -= m->m_len; ! 480: } else { ! 481: if (len > MHLEN) ! 482: goto bad; ! 483: MGET(m, M_DONTWAIT, n->m_type); ! 484: if (m == 0) ! 485: goto bad; ! 486: m->m_len = 0; ! 487: if (n->m_flags & M_PKTHDR) { ! 488: M_COPY_PKTHDR(m, n); ! 489: n->m_flags &= ~M_PKTHDR; ! 490: } ! 491: } ! 492: space = &m->m_dat[MLEN] - (m->m_data + m->m_len); ! 493: do { ! 494: count = min(min(max(len, max_protohdr), space), n->m_len); ! 495: bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len, ! 496: (unsigned)count); ! 497: len -= count; ! 498: m->m_len += count; ! 499: n->m_len -= count; ! 500: space -= count; ! 501: if (n->m_len) ! 502: n->m_data += count; ! 503: else ! 504: n = m_free(n); ! 505: } while (len > 0 && n); ! 506: if (len > 0) { ! 507: (void) m_free(m); ! 508: goto bad; ! 509: } ! 510: m->m_next = n; ! 511: return (m); ! 512: bad: ! 513: m_freem(n); ! 514: MPFail++; ! 515: return (0); ! 516: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.