3390d47670
Changes from the original implementation: - Fragmentation is handled by the function m_fragment, which can be called from whereever fragmentation is needed. Note that this function is wrapped in #ifdef MBUF_STRESS_TEST to discourage non-testing use. - m_fragment works slightly differently from the old fragmentation code in that it allocates a seperate mbuf cluster for each fragment. This defeats dma_map_load_mbuf/buffer's feature of coalescing adjacent fragments. While that is a nice feature in practice, it nerfed the usefulness of mbuf_stress_test. - Add two modes of random fragmentation. Chains with fragments all of the same random length and chains with fragments that are each uniquely random in length may now be requested.
970 lines
22 KiB
C
970 lines
22 KiB
C
/*
|
|
* Copyright (c) 1982, 1986, 1988, 1991, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)uipc_mbuf.c 8.2 (Berkeley) 1/4/94
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include "opt_mac.h"
|
|
#include "opt_param.h"
|
|
#include "opt_mbuf_stress_test.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/mac.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/domain.h>
|
|
#include <sys/protosw.h>
|
|
|
|
int max_linkhdr;
|
|
int max_protohdr;
|
|
int max_hdr;
|
|
int max_datalen;
|
|
#ifdef MBUF_STRESS_TEST
|
|
int m_defragpackets;
|
|
int m_defragbytes;
|
|
int m_defraguseless;
|
|
int m_defragfailure;
|
|
int m_defragrandomfailures;
|
|
#endif
|
|
|
|
/*
|
|
* sysctl(8) exported objects
|
|
*/
|
|
SYSCTL_DECL(_kern_ipc);
|
|
SYSCTL_INT(_kern_ipc, KIPC_MAX_LINKHDR, max_linkhdr, CTLFLAG_RW,
|
|
&max_linkhdr, 0, "");
|
|
SYSCTL_INT(_kern_ipc, KIPC_MAX_PROTOHDR, max_protohdr, CTLFLAG_RW,
|
|
&max_protohdr, 0, "");
|
|
SYSCTL_INT(_kern_ipc, KIPC_MAX_HDR, max_hdr, CTLFLAG_RW, &max_hdr, 0, "");
|
|
SYSCTL_INT(_kern_ipc, KIPC_MAX_DATALEN, max_datalen, CTLFLAG_RW,
|
|
&max_datalen, 0, "");
|
|
#ifdef MBUF_STRESS_TEST
|
|
SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragpackets, CTLFLAG_RD,
|
|
&m_defragpackets, 0, "");
|
|
SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragbytes, CTLFLAG_RD,
|
|
&m_defragbytes, 0, "");
|
|
SYSCTL_INT(_kern_ipc, OID_AUTO, m_defraguseless, CTLFLAG_RD,
|
|
&m_defraguseless, 0, "");
|
|
SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragfailure, CTLFLAG_RD,
|
|
&m_defragfailure, 0, "");
|
|
SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragrandomfailures, CTLFLAG_RW,
|
|
&m_defragrandomfailures, 0, "");
|
|
#endif
|
|
|
|
/*
|
|
* "Move" mbuf pkthdr from "from" to "to".
|
|
* "from" must have M_PKTHDR set, and "to" must be empty.
|
|
*/
|
|
void
|
|
m_move_pkthdr(struct mbuf *to, struct mbuf *from)
|
|
{
|
|
|
|
#if 0
|
|
/* see below for why these are not enabled */
|
|
M_ASSERTPKTHDR(to);
|
|
/* Note: with MAC, this may not be a good assertion. */
|
|
KASSERT(SLIST_EMPTY(&to->m_pkthdr.tags),
|
|
("m_move_pkthdr: to has tags"));
|
|
#endif
|
|
KASSERT((to->m_flags & M_EXT) == 0, ("m_move_pkthdr: to has cluster"));
|
|
#ifdef MAC
|
|
/*
|
|
* XXXMAC: It could be this should also occur for non-MAC?
|
|
*/
|
|
if (to->m_flags & M_PKTHDR)
|
|
m_tag_delete_chain(to, NULL);
|
|
#endif
|
|
to->m_flags = from->m_flags & M_COPYFLAGS;
|
|
to->m_data = to->m_pktdat;
|
|
to->m_pkthdr = from->m_pkthdr; /* especially tags */
|
|
SLIST_INIT(&from->m_pkthdr.tags); /* purge tags from src */
|
|
from->m_flags &= ~M_PKTHDR;
|
|
}
|
|
|
|
/*
|
|
* Duplicate "from"'s mbuf pkthdr in "to".
|
|
* "from" must have M_PKTHDR set, and "to" must be empty.
|
|
* In particular, this does a deep copy of the packet tags.
|
|
*/
|
|
int
|
|
m_dup_pkthdr(struct mbuf *to, struct mbuf *from, int how)
|
|
{
|
|
|
|
#if 0
|
|
/*
|
|
* The mbuf allocator only initializes the pkthdr
|
|
* when the mbuf is allocated with MGETHDR. Many users
|
|
* (e.g. m_copy*, m_prepend) use MGET and then
|
|
* smash the pkthdr as needed causing these
|
|
* assertions to trip. For now just disable them.
|
|
*/
|
|
M_ASSERTPKTHDR(to);
|
|
/* Note: with MAC, this may not be a good assertion. */
|
|
KASSERT(SLIST_EMPTY(&to->m_pkthdr.tags), ("m_dup_pkthdr: to has tags"));
|
|
#endif
|
|
#ifdef MAC
|
|
if (to->m_flags & M_PKTHDR)
|
|
m_tag_delete_chain(to, NULL);
|
|
#endif
|
|
to->m_flags = (from->m_flags & M_COPYFLAGS) | (to->m_flags & M_EXT);
|
|
if ((to->m_flags & M_EXT) == 0)
|
|
to->m_data = to->m_pktdat;
|
|
to->m_pkthdr = from->m_pkthdr;
|
|
SLIST_INIT(&to->m_pkthdr.tags);
|
|
return (m_tag_copy_chain(to, from, MBTOM(how)));
|
|
}
|
|
|
|
/*
|
|
* Lesser-used path for M_PREPEND:
|
|
* allocate new mbuf to prepend to chain,
|
|
* copy junk along.
|
|
*/
|
|
struct mbuf *
|
|
m_prepend(struct mbuf *m, int len, int how)
|
|
{
|
|
struct mbuf *mn;
|
|
|
|
if (m->m_flags & M_PKTHDR)
|
|
MGETHDR(mn, how, m->m_type);
|
|
else
|
|
MGET(mn, how, m->m_type);
|
|
if (mn == NULL) {
|
|
m_freem(m);
|
|
return (NULL);
|
|
}
|
|
if (m->m_flags & M_PKTHDR)
|
|
M_MOVE_PKTHDR(mn, m);
|
|
mn->m_next = m;
|
|
m = mn;
|
|
if (len < MHLEN)
|
|
MH_ALIGN(m, len);
|
|
m->m_len = len;
|
|
return (m);
|
|
}
|
|
|
|
/*
|
|
* Make a copy of an mbuf chain starting "off0" bytes from the beginning,
|
|
* continuing for "len" bytes. If len is M_COPYALL, copy to end of mbuf.
|
|
* The wait parameter is a choice of M_TRYWAIT/M_DONTWAIT from caller.
|
|
* Note that the copy is read-only, because clusters are not copied,
|
|
* only their reference counts are incremented.
|
|
*/
|
|
struct mbuf *
|
|
m_copym(struct mbuf *m, int off0, int len, int wait)
|
|
{
|
|
struct mbuf *n, **np;
|
|
int off = off0;
|
|
struct mbuf *top;
|
|
int copyhdr = 0;
|
|
|
|
KASSERT(off >= 0, ("m_copym, negative off %d", off));
|
|
KASSERT(len >= 0, ("m_copym, negative len %d", len));
|
|
if (off == 0 && m->m_flags & M_PKTHDR)
|
|
copyhdr = 1;
|
|
while (off > 0) {
|
|
KASSERT(m != NULL, ("m_copym, offset > size of mbuf chain"));
|
|
if (off < m->m_len)
|
|
break;
|
|
off -= m->m_len;
|
|
m = m->m_next;
|
|
}
|
|
np = ⊤
|
|
top = 0;
|
|
while (len > 0) {
|
|
if (m == NULL) {
|
|
KASSERT(len == M_COPYALL,
|
|
("m_copym, length > size of mbuf chain"));
|
|
break;
|
|
}
|
|
if (copyhdr)
|
|
MGETHDR(n, wait, m->m_type);
|
|
else
|
|
MGET(n, wait, m->m_type);
|
|
*np = n;
|
|
if (n == NULL)
|
|
goto nospace;
|
|
if (copyhdr) {
|
|
if (!m_dup_pkthdr(n, m, wait))
|
|
goto nospace;
|
|
if (len == M_COPYALL)
|
|
n->m_pkthdr.len -= off0;
|
|
else
|
|
n->m_pkthdr.len = len;
|
|
copyhdr = 0;
|
|
}
|
|
n->m_len = min(len, m->m_len - off);
|
|
if (m->m_flags & M_EXT) {
|
|
n->m_data = m->m_data + off;
|
|
n->m_ext = m->m_ext;
|
|
n->m_flags |= M_EXT;
|
|
MEXT_ADD_REF(m);
|
|
} else
|
|
bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
|
|
(u_int)n->m_len);
|
|
if (len != M_COPYALL)
|
|
len -= n->m_len;
|
|
off = 0;
|
|
m = m->m_next;
|
|
np = &n->m_next;
|
|
}
|
|
if (top == NULL)
|
|
mbstat.m_mcfail++; /* XXX: No consistency. */
|
|
|
|
return (top);
|
|
nospace:
|
|
m_freem(top);
|
|
mbstat.m_mcfail++; /* XXX: No consistency. */
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Copy an entire packet, including header (which must be present).
|
|
* An optimization of the common case `m_copym(m, 0, M_COPYALL, how)'.
|
|
* Note that the copy is read-only, because clusters are not copied,
|
|
* only their reference counts are incremented.
|
|
* Preserve alignment of the first mbuf so if the creator has left
|
|
* some room at the beginning (e.g. for inserting protocol headers)
|
|
* the copies still have the room available.
|
|
*/
|
|
struct mbuf *
|
|
m_copypacket(struct mbuf *m, int how)
|
|
{
|
|
struct mbuf *top, *n, *o;
|
|
|
|
MGET(n, how, m->m_type);
|
|
top = n;
|
|
if (n == NULL)
|
|
goto nospace;
|
|
|
|
if (!m_dup_pkthdr(n, m, how))
|
|
goto nospace;
|
|
n->m_len = m->m_len;
|
|
if (m->m_flags & M_EXT) {
|
|
n->m_data = m->m_data;
|
|
n->m_ext = m->m_ext;
|
|
n->m_flags |= M_EXT;
|
|
MEXT_ADD_REF(m);
|
|
} else {
|
|
n->m_data = n->m_pktdat + (m->m_data - m->m_pktdat );
|
|
bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
|
|
}
|
|
|
|
m = m->m_next;
|
|
while (m) {
|
|
MGET(o, how, m->m_type);
|
|
if (o == NULL)
|
|
goto nospace;
|
|
|
|
n->m_next = o;
|
|
n = n->m_next;
|
|
|
|
n->m_len = m->m_len;
|
|
if (m->m_flags & M_EXT) {
|
|
n->m_data = m->m_data;
|
|
n->m_ext = m->m_ext;
|
|
n->m_flags |= M_EXT;
|
|
MEXT_ADD_REF(m);
|
|
} else {
|
|
bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
|
|
}
|
|
|
|
m = m->m_next;
|
|
}
|
|
return top;
|
|
nospace:
|
|
m_freem(top);
|
|
mbstat.m_mcfail++; /* XXX: No consistency. */
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Copy data from an mbuf chain starting "off" bytes from the beginning,
|
|
* continuing for "len" bytes, into the indicated buffer.
|
|
*/
|
|
void
|
|
m_copydata(const struct mbuf *m, int off, int len, caddr_t cp)
|
|
{
|
|
u_int count;
|
|
|
|
KASSERT(off >= 0, ("m_copydata, negative off %d", off));
|
|
KASSERT(len >= 0, ("m_copydata, negative len %d", len));
|
|
while (off > 0) {
|
|
KASSERT(m != NULL, ("m_copydata, offset > size of mbuf chain"));
|
|
if (off < m->m_len)
|
|
break;
|
|
off -= m->m_len;
|
|
m = m->m_next;
|
|
}
|
|
while (len > 0) {
|
|
KASSERT(m != NULL, ("m_copydata, length > size of mbuf chain"));
|
|
count = min(m->m_len - off, len);
|
|
bcopy(mtod(m, caddr_t) + off, cp, count);
|
|
len -= count;
|
|
cp += count;
|
|
off = 0;
|
|
m = m->m_next;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Copy a packet header mbuf chain into a completely new chain, including
|
|
* copying any mbuf clusters. Use this instead of m_copypacket() when
|
|
* you need a writable copy of an mbuf chain.
|
|
*/
|
|
struct mbuf *
|
|
m_dup(struct mbuf *m, int how)
|
|
{
|
|
struct mbuf **p, *top = NULL;
|
|
int remain, moff, nsize;
|
|
|
|
/* Sanity check */
|
|
if (m == NULL)
|
|
return (NULL);
|
|
M_ASSERTPKTHDR(m);
|
|
|
|
/* While there's more data, get a new mbuf, tack it on, and fill it */
|
|
remain = m->m_pkthdr.len;
|
|
moff = 0;
|
|
p = ⊤
|
|
while (remain > 0 || top == NULL) { /* allow m->m_pkthdr.len == 0 */
|
|
struct mbuf *n;
|
|
|
|
/* Get the next new mbuf */
|
|
MGET(n, how, m->m_type);
|
|
if (n == NULL)
|
|
goto nospace;
|
|
if (top == NULL) { /* first one, must be PKTHDR */
|
|
if (!m_dup_pkthdr(n, m, how))
|
|
goto nospace;
|
|
nsize = MHLEN;
|
|
} else /* not the first one */
|
|
nsize = MLEN;
|
|
if (remain >= MINCLSIZE) {
|
|
MCLGET(n, how);
|
|
if ((n->m_flags & M_EXT) == 0) {
|
|
(void)m_free(n);
|
|
goto nospace;
|
|
}
|
|
nsize = MCLBYTES;
|
|
}
|
|
n->m_len = 0;
|
|
|
|
/* Link it into the new chain */
|
|
*p = n;
|
|
p = &n->m_next;
|
|
|
|
/* Copy data from original mbuf(s) into new mbuf */
|
|
while (n->m_len < nsize && m != NULL) {
|
|
int chunk = min(nsize - n->m_len, m->m_len - moff);
|
|
|
|
bcopy(m->m_data + moff, n->m_data + n->m_len, chunk);
|
|
moff += chunk;
|
|
n->m_len += chunk;
|
|
remain -= chunk;
|
|
if (moff == m->m_len) {
|
|
m = m->m_next;
|
|
moff = 0;
|
|
}
|
|
}
|
|
|
|
/* Check correct total mbuf length */
|
|
KASSERT((remain > 0 && m != NULL) || (remain == 0 && m == NULL),
|
|
("%s: bogus m_pkthdr.len", __func__));
|
|
}
|
|
return (top);
|
|
|
|
nospace:
|
|
m_freem(top);
|
|
mbstat.m_mcfail++; /* XXX: No consistency. */
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Concatenate mbuf chain n to m.
|
|
* Both chains must be of the same type (e.g. MT_DATA).
|
|
* Any m_pkthdr is not updated.
|
|
*/
|
|
void
|
|
m_cat(struct mbuf *m, struct mbuf *n)
|
|
{
|
|
while (m->m_next)
|
|
m = m->m_next;
|
|
while (n) {
|
|
if (m->m_flags & M_EXT ||
|
|
m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) {
|
|
/* just join the two chains */
|
|
m->m_next = n;
|
|
return;
|
|
}
|
|
/* splat the data from one into the other */
|
|
bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
|
|
(u_int)n->m_len);
|
|
m->m_len += n->m_len;
|
|
n = m_free(n);
|
|
}
|
|
}
|
|
|
|
void
|
|
m_adj(struct mbuf *mp, int req_len)
|
|
{
|
|
int len = req_len;
|
|
struct mbuf *m;
|
|
int count;
|
|
|
|
if ((m = mp) == NULL)
|
|
return;
|
|
if (len >= 0) {
|
|
/*
|
|
* Trim from head.
|
|
*/
|
|
while (m != NULL && len > 0) {
|
|
if (m->m_len <= len) {
|
|
len -= m->m_len;
|
|
m->m_len = 0;
|
|
m = m->m_next;
|
|
} else {
|
|
m->m_len -= len;
|
|
m->m_data += len;
|
|
len = 0;
|
|
}
|
|
}
|
|
m = mp;
|
|
if (mp->m_flags & M_PKTHDR)
|
|
m->m_pkthdr.len -= (req_len - len);
|
|
} else {
|
|
/*
|
|
* Trim from tail. Scan the mbuf chain,
|
|
* calculating its length and finding the last mbuf.
|
|
* If the adjustment only affects this mbuf, then just
|
|
* adjust and return. Otherwise, rescan and truncate
|
|
* after the remaining size.
|
|
*/
|
|
len = -len;
|
|
count = 0;
|
|
for (;;) {
|
|
count += m->m_len;
|
|
if (m->m_next == (struct mbuf *)0)
|
|
break;
|
|
m = m->m_next;
|
|
}
|
|
if (m->m_len >= len) {
|
|
m->m_len -= len;
|
|
if (mp->m_flags & M_PKTHDR)
|
|
mp->m_pkthdr.len -= len;
|
|
return;
|
|
}
|
|
count -= len;
|
|
if (count < 0)
|
|
count = 0;
|
|
/*
|
|
* Correct length for chain is "count".
|
|
* Find the mbuf with last data, adjust its length,
|
|
* and toss data from remaining mbufs on chain.
|
|
*/
|
|
m = mp;
|
|
if (m->m_flags & M_PKTHDR)
|
|
m->m_pkthdr.len = count;
|
|
for (; m; m = m->m_next) {
|
|
if (m->m_len >= count) {
|
|
m->m_len = count;
|
|
break;
|
|
}
|
|
count -= m->m_len;
|
|
}
|
|
while (m->m_next)
|
|
(m = m->m_next) ->m_len = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Rearange an mbuf chain so that len bytes are contiguous
|
|
* and in the data area of an mbuf (so that mtod and dtom
|
|
* will work for a structure of size len). Returns the resulting
|
|
* mbuf chain on success, frees it and returns null on failure.
|
|
* If there is room, it will add up to max_protohdr-len extra bytes to the
|
|
* contiguous region in an attempt to avoid being called next time.
|
|
*/
|
|
struct mbuf *
|
|
m_pullup(struct mbuf *n, int len)
|
|
{
|
|
struct mbuf *m;
|
|
int count;
|
|
int space;
|
|
|
|
/*
|
|
* If first mbuf has no cluster, and has room for len bytes
|
|
* without shifting current data, pullup into it,
|
|
* otherwise allocate a new mbuf to prepend to the chain.
|
|
*/
|
|
if ((n->m_flags & M_EXT) == 0 &&
|
|
n->m_data + len < &n->m_dat[MLEN] && n->m_next) {
|
|
if (n->m_len >= len)
|
|
return (n);
|
|
m = n;
|
|
n = n->m_next;
|
|
len -= m->m_len;
|
|
} else {
|
|
if (len > MHLEN)
|
|
goto bad;
|
|
MGET(m, M_DONTWAIT, n->m_type);
|
|
if (m == NULL)
|
|
goto bad;
|
|
m->m_len = 0;
|
|
if (n->m_flags & M_PKTHDR)
|
|
M_MOVE_PKTHDR(m, n);
|
|
}
|
|
space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
|
|
do {
|
|
count = min(min(max(len, max_protohdr), space), n->m_len);
|
|
bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
|
|
(u_int)count);
|
|
len -= count;
|
|
m->m_len += count;
|
|
n->m_len -= count;
|
|
space -= count;
|
|
if (n->m_len)
|
|
n->m_data += count;
|
|
else
|
|
n = m_free(n);
|
|
} while (len > 0 && n);
|
|
if (len > 0) {
|
|
(void) m_free(m);
|
|
goto bad;
|
|
}
|
|
m->m_next = n;
|
|
return (m);
|
|
bad:
|
|
m_freem(n);
|
|
mbstat.m_mpfail++; /* XXX: No consistency. */
|
|
return (NULL);
|
|
}
|
|
|
|
/*
|
|
* Partition an mbuf chain in two pieces, returning the tail --
|
|
* all but the first len0 bytes. In case of failure, it returns NULL and
|
|
* attempts to restore the chain to its original state.
|
|
*
|
|
* Note that the resulting mbufs might be read-only, because the new
|
|
* mbuf can end up sharing an mbuf cluster with the original mbuf if
|
|
* the "breaking point" happens to lie within a cluster mbuf. Use the
|
|
* M_WRITABLE() macro to check for this case.
|
|
*/
|
|
struct mbuf *
|
|
m_split(struct mbuf *m0, int len0, int wait)
|
|
{
|
|
struct mbuf *m, *n;
|
|
u_int len = len0, remain;
|
|
|
|
for (m = m0; m && len > m->m_len; m = m->m_next)
|
|
len -= m->m_len;
|
|
if (m == NULL)
|
|
return (NULL);
|
|
remain = m->m_len - len;
|
|
if (m0->m_flags & M_PKTHDR) {
|
|
MGETHDR(n, wait, m0->m_type);
|
|
if (n == NULL)
|
|
return (NULL);
|
|
n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
|
|
n->m_pkthdr.len = m0->m_pkthdr.len - len0;
|
|
m0->m_pkthdr.len = len0;
|
|
if (m->m_flags & M_EXT)
|
|
goto extpacket;
|
|
if (remain > MHLEN) {
|
|
/* m can't be the lead packet */
|
|
MH_ALIGN(n, 0);
|
|
n->m_next = m_split(m, len, wait);
|
|
if (n->m_next == NULL) {
|
|
(void) m_free(n);
|
|
return (NULL);
|
|
} else {
|
|
n->m_len = 0;
|
|
return (n);
|
|
}
|
|
} else
|
|
MH_ALIGN(n, remain);
|
|
} else if (remain == 0) {
|
|
n = m->m_next;
|
|
m->m_next = NULL;
|
|
return (n);
|
|
} else {
|
|
MGET(n, wait, m->m_type);
|
|
if (n == NULL)
|
|
return (NULL);
|
|
M_ALIGN(n, remain);
|
|
}
|
|
extpacket:
|
|
if (m->m_flags & M_EXT) {
|
|
n->m_flags |= M_EXT;
|
|
n->m_ext = m->m_ext;
|
|
MEXT_ADD_REF(m);
|
|
n->m_data = m->m_data + len;
|
|
} else {
|
|
bcopy(mtod(m, caddr_t) + len, mtod(n, caddr_t), remain);
|
|
}
|
|
n->m_len = remain;
|
|
m->m_len = len;
|
|
n->m_next = m->m_next;
|
|
m->m_next = NULL;
|
|
return (n);
|
|
}
|
|
/*
|
|
* Routine to copy from device local memory into mbufs.
|
|
* Note that `off' argument is offset into first mbuf of target chain from
|
|
* which to begin copying the data to.
|
|
*/
|
|
struct mbuf *
|
|
m_devget(char *buf, int totlen, int off, struct ifnet *ifp,
|
|
void (*copy)(char *from, caddr_t to, u_int len))
|
|
{
|
|
struct mbuf *m;
|
|
struct mbuf *top = 0, **mp = ⊤
|
|
int len;
|
|
|
|
if (off < 0 || off > MHLEN)
|
|
return (NULL);
|
|
|
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
|
if (m == NULL)
|
|
return (NULL);
|
|
m->m_pkthdr.rcvif = ifp;
|
|
m->m_pkthdr.len = totlen;
|
|
len = MHLEN;
|
|
|
|
while (totlen > 0) {
|
|
if (top) {
|
|
MGET(m, M_DONTWAIT, MT_DATA);
|
|
if (m == NULL) {
|
|
m_freem(top);
|
|
return (NULL);
|
|
}
|
|
len = MLEN;
|
|
}
|
|
if (totlen + off >= MINCLSIZE) {
|
|
MCLGET(m, M_DONTWAIT);
|
|
if (m->m_flags & M_EXT)
|
|
len = MCLBYTES;
|
|
} else {
|
|
/*
|
|
* Place initial small packet/header at end of mbuf.
|
|
*/
|
|
if (top == NULL && totlen + off + max_linkhdr <= len) {
|
|
m->m_data += max_linkhdr;
|
|
len -= max_linkhdr;
|
|
}
|
|
}
|
|
if (off) {
|
|
m->m_data += off;
|
|
len -= off;
|
|
off = 0;
|
|
}
|
|
m->m_len = len = min(totlen, len);
|
|
if (copy)
|
|
copy(buf, mtod(m, caddr_t), (u_int)len);
|
|
else
|
|
bcopy(buf, mtod(m, caddr_t), (u_int)len);
|
|
buf += len;
|
|
*mp = m;
|
|
mp = &m->m_next;
|
|
totlen -= len;
|
|
}
|
|
return (top);
|
|
}
|
|
|
|
/*
|
|
* Copy data from a buffer back into the indicated mbuf chain,
|
|
* starting "off" bytes from the beginning, extending the mbuf
|
|
* chain if necessary.
|
|
*/
|
|
void
|
|
m_copyback(struct mbuf *m0, int off, int len, caddr_t cp)
|
|
{
|
|
int mlen;
|
|
struct mbuf *m = m0, *n;
|
|
int totlen = 0;
|
|
|
|
if (m0 == NULL)
|
|
return;
|
|
while (off > (mlen = m->m_len)) {
|
|
off -= mlen;
|
|
totlen += mlen;
|
|
if (m->m_next == NULL) {
|
|
n = m_get_clrd(M_DONTWAIT, m->m_type);
|
|
if (n == NULL)
|
|
goto out;
|
|
n->m_len = min(MLEN, len + off);
|
|
m->m_next = n;
|
|
}
|
|
m = m->m_next;
|
|
}
|
|
while (len > 0) {
|
|
mlen = min (m->m_len - off, len);
|
|
bcopy(cp, off + mtod(m, caddr_t), (u_int)mlen);
|
|
cp += mlen;
|
|
len -= mlen;
|
|
mlen += off;
|
|
off = 0;
|
|
totlen += mlen;
|
|
if (len == 0)
|
|
break;
|
|
if (m->m_next == NULL) {
|
|
n = m_get(M_DONTWAIT, m->m_type);
|
|
if (n == NULL)
|
|
break;
|
|
n->m_len = min(MLEN, len);
|
|
m->m_next = n;
|
|
}
|
|
m = m->m_next;
|
|
}
|
|
out: if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
|
|
m->m_pkthdr.len = totlen;
|
|
}
|
|
|
|
void
|
|
m_print(const struct mbuf *m)
|
|
{
|
|
int len;
|
|
const struct mbuf *m2;
|
|
|
|
len = m->m_pkthdr.len;
|
|
m2 = m;
|
|
while (len) {
|
|
printf("%p %*D\n", m2, m2->m_len, (u_char *)m2->m_data, "-");
|
|
len -= m2->m_len;
|
|
m2 = m2->m_next;
|
|
}
|
|
return;
|
|
}
|
|
|
|
u_int
|
|
m_fixhdr(struct mbuf *m0)
|
|
{
|
|
u_int len;
|
|
|
|
len = m_length(m0, NULL);
|
|
m0->m_pkthdr.len = len;
|
|
return (len);
|
|
}
|
|
|
|
u_int
|
|
m_length(struct mbuf *m0, struct mbuf **last)
|
|
{
|
|
struct mbuf *m;
|
|
u_int len;
|
|
|
|
len = 0;
|
|
for (m = m0; m != NULL; m = m->m_next) {
|
|
len += m->m_len;
|
|
if (m->m_next == NULL)
|
|
break;
|
|
}
|
|
if (last != NULL)
|
|
*last = m;
|
|
return (len);
|
|
}
|
|
|
|
/*
|
|
* Defragment a mbuf chain, returning the shortest possible
|
|
* chain of mbufs and clusters. If allocation fails and
|
|
* this cannot be completed, NULL will be returned, but
|
|
* the passed in chain will be unchanged. Upon success,
|
|
* the original chain will be freed, and the new chain
|
|
* will be returned.
|
|
*
|
|
* If a non-packet header is passed in, the original
|
|
* mbuf (chain?) will be returned unharmed.
|
|
*/
|
|
struct mbuf *
|
|
m_defrag(struct mbuf *m0, int how)
|
|
{
|
|
struct mbuf *m_new = NULL, *m_final = NULL;
|
|
int progress = 0, length;
|
|
|
|
if (!(m0->m_flags & M_PKTHDR))
|
|
return (m0);
|
|
|
|
m_fixhdr(m0); /* Needed sanity check */
|
|
|
|
#ifdef MBUF_STRESS_TEST
|
|
if (m_defragrandomfailures) {
|
|
int temp = arc4random() & 0xff;
|
|
if (temp == 0xba)
|
|
goto nospace;
|
|
}
|
|
#endif
|
|
|
|
if (m0->m_pkthdr.len > MHLEN)
|
|
m_final = m_getcl(how, MT_DATA, M_PKTHDR);
|
|
else
|
|
m_final = m_gethdr(how, MT_DATA);
|
|
|
|
if (m_final == NULL)
|
|
goto nospace;
|
|
|
|
if (m_dup_pkthdr(m_final, m0, how) == NULL)
|
|
goto nospace;
|
|
|
|
m_new = m_final;
|
|
|
|
while (progress < m0->m_pkthdr.len) {
|
|
length = m0->m_pkthdr.len - progress;
|
|
if (length > MCLBYTES)
|
|
length = MCLBYTES;
|
|
|
|
if (m_new == NULL) {
|
|
if (length > MLEN)
|
|
m_new = m_getcl(how, MT_DATA, 0);
|
|
else
|
|
m_new = m_get(how, MT_DATA);
|
|
if (m_new == NULL)
|
|
goto nospace;
|
|
}
|
|
|
|
m_copydata(m0, progress, length, mtod(m_new, caddr_t));
|
|
progress += length;
|
|
m_new->m_len = length;
|
|
if (m_new != m_final)
|
|
m_cat(m_final, m_new);
|
|
m_new = NULL;
|
|
}
|
|
#ifdef MBUF_STRESS_TEST
|
|
if (m0->m_next == NULL)
|
|
m_defraguseless++;
|
|
#endif
|
|
m_freem(m0);
|
|
m0 = m_final;
|
|
#ifdef MBUF_STRESS_TEST
|
|
m_defragpackets++;
|
|
m_defragbytes += m0->m_pkthdr.len;
|
|
#endif
|
|
return (m0);
|
|
nospace:
|
|
#ifdef MBUF_STRESS_TEST
|
|
m_defragfailure++;
|
|
#endif
|
|
if (m_new)
|
|
m_free(m_new);
|
|
if (m_final)
|
|
m_freem(m_final);
|
|
return (NULL);
|
|
}
|
|
|
|
#ifdef MBUF_STRESS_TEST
|
|
|
|
/*
|
|
* Fragment an mbuf chain. There's no reason you'd ever want to do
|
|
* this in normal usage, but it's great for stress testing various
|
|
* mbuf consumers.
|
|
*
|
|
* If fragmentation is not possible, the original chain will be
|
|
* returned.
|
|
*
|
|
* Possible length values:
|
|
* 0 no fragmentation will occur
|
|
* > 0 each fragment will be of the specified length
|
|
* -1 each fragment will be the same random value in length
|
|
* -2 each fragment's length will be entirely random
|
|
* (Random values range from 1 to 256)
|
|
*/
|
|
struct mbuf *
|
|
m_fragment(struct mbuf *m0, int how, int length)
|
|
{
|
|
struct mbuf *m_new = NULL, *m_final = NULL;
|
|
int progress = 0;
|
|
|
|
if (!(m0->m_flags & M_PKTHDR))
|
|
return (m0);
|
|
|
|
if ((length == 0) || (length < -2))
|
|
return (m0);
|
|
|
|
m_fixhdr(m0); /* Needed sanity check */
|
|
|
|
m_final = m_getcl(how, MT_DATA, M_PKTHDR);
|
|
|
|
if (m_final == NULL)
|
|
goto nospace;
|
|
|
|
if (m_dup_pkthdr(m_final, m0, how) == NULL)
|
|
goto nospace;
|
|
|
|
m_new = m_final;
|
|
|
|
if (length == -1)
|
|
length = 1 + (arc4random() & 255);
|
|
|
|
while (progress < m0->m_pkthdr.len) {
|
|
int fraglen;
|
|
|
|
if (length > 0)
|
|
fraglen = length;
|
|
else
|
|
fraglen = 1 + (arc4random() & 255);
|
|
if (fraglen > m0->m_pkthdr.len - progress)
|
|
fraglen = m0->m_pkthdr.len - progress;
|
|
|
|
if (fraglen > MCLBYTES)
|
|
fraglen = MCLBYTES;
|
|
|
|
if (m_new == NULL) {
|
|
m_new = m_getcl(how, MT_DATA, 0);
|
|
if (m_new == NULL)
|
|
goto nospace;
|
|
}
|
|
|
|
m_copydata(m0, progress, fraglen, mtod(m_new, caddr_t));
|
|
progress += fraglen;
|
|
m_new->m_len = fraglen;
|
|
if (m_new != m_final)
|
|
m_cat(m_final, m_new);
|
|
m_new = NULL;
|
|
}
|
|
m_freem(m0);
|
|
m0 = m_final;
|
|
return (m0);
|
|
nospace:
|
|
if (m_new)
|
|
m_free(m_new);
|
|
if (m_final)
|
|
m_freem(m_final);
|
|
/* Return the original chain on failure */
|
|
return (m0);
|
|
}
|
|
|
|
#endif
|