04ac848d6f
between protocol handlers. ipsec socket pointers, ipsec decryption/auth information, tunnel decapsulation information are in my mind - there can be several other usage. at this moment, we use this for ipsec socket pointer passing. this will avoid reuse of m->m_pkthdr.rcvif in ipsec code. due to the change, MHLEN will be decreased by sizeof(void *) - for example, for i386, MHLEN was 100 bytes, but is now 96 bytes. we may want to increase MSIZE from 128 to 256 for some of our architectures. take caution if you use it for keeping some data item for long period of time - use extra caution on M_PREPEND() or m_adj(), as they may result in loss of m->m_pkthdr.aux pointer (and mbuf leak). this will bump kernel version. (as discussed in tech-net, tested in kame tree)
429 lines
11 KiB
C
429 lines
11 KiB
C
/* $NetBSD: uipc_mbuf2.c,v 1.4 2000/03/01 12:49:29 itojun Exp $ */
|
|
/* $KAME: uipc_mbuf2.c,v 1.15 2000/02/22 14:01:37 itojun Exp $ */
|
|
|
|
/*
|
|
* Copyright (C) 1999 WIDE Project.
|
|
* 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. Neither the name of the project 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 PROJECT 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 PROJECT 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.
|
|
*/
|
|
|
|
/*
|
|
* 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.4 (Berkeley) 2/14/95
|
|
*/
|
|
|
|
#define PULLDOWN_STAT
|
|
/*#define PULLDOWN_DEBUG*/
|
|
|
|
#ifdef PULLDOWN_STAT
|
|
#if defined(__NetBSD__) || (defined(__FreeBSD__) && __FreeBSD__ >= 3)
|
|
#include "opt_inet.h"
|
|
#endif
|
|
#endif
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/mbuf.h>
|
|
#if defined(PULLDOWN_STAT) && defined(INET6)
|
|
#include <netinet/in.h>
|
|
#include <netinet/ip6.h>
|
|
#include <netinet6/ip6_var.h>
|
|
#endif
|
|
|
|
/*
|
|
* ensure that [off, off + len) is contiguous on the mbuf chain "m".
|
|
* packet chain before "off" is kept untouched.
|
|
* if offp == NULL, the target will start at <retval, 0> on resulting chain.
|
|
* if offp != NULL, the target will start at <retval, *offp> on resulting chain.
|
|
*
|
|
* on error return (NULL return value), original "m" will be freed.
|
|
*
|
|
* XXX M_TRAILINGSPACE/M_LEADINGSPACE on shared cluster (sharedcluster)
|
|
*/
|
|
struct mbuf *
|
|
m_pulldown(m, off, len, offp)
|
|
struct mbuf *m;
|
|
int off, len;
|
|
int *offp;
|
|
{
|
|
struct mbuf *n, *o;
|
|
int hlen, tlen, olen;
|
|
int sharedcluster;
|
|
#if defined(PULLDOWN_STAT) && defined(INET6)
|
|
static struct mbuf *prev = NULL;
|
|
int prevlen = 0, prevmlen = 0;
|
|
#endif
|
|
|
|
/* check invalid arguments. */
|
|
if (m == NULL)
|
|
panic("m == NULL in m_pulldown()");
|
|
if (len > MCLBYTES) {
|
|
m_freem(m);
|
|
return NULL; /* impossible */
|
|
}
|
|
|
|
#if defined(PULLDOWN_STAT) && defined(INET6)
|
|
ip6stat.ip6s_pulldown++;
|
|
#endif
|
|
|
|
#if defined(PULLDOWN_STAT) && defined(INET6)
|
|
/* statistics for m_pullup */
|
|
ip6stat.ip6s_pullup++;
|
|
if (off + len > MHLEN)
|
|
ip6stat.ip6s_pullup_fail++;
|
|
else {
|
|
int dlen, mlen;
|
|
|
|
dlen = (prev == m) ? prevlen : m->m_len;
|
|
mlen = (prev == m) ? prevmlen : m->m_len + M_TRAILINGSPACE(m);
|
|
|
|
if (dlen >= off + len)
|
|
ip6stat.ip6s_pullup--; /* call will not be made! */
|
|
else if ((m->m_flags & M_EXT) != 0) {
|
|
ip6stat.ip6s_pullup_alloc++;
|
|
ip6stat.ip6s_pullup_copy++;
|
|
} else {
|
|
if (mlen >= off + len)
|
|
ip6stat.ip6s_pullup_copy++;
|
|
else {
|
|
ip6stat.ip6s_pullup_alloc++;
|
|
ip6stat.ip6s_pullup_copy++;
|
|
}
|
|
}
|
|
|
|
prevlen = off + len;
|
|
prevmlen = MHLEN;
|
|
}
|
|
|
|
/* statistics for m_pullup2 */
|
|
ip6stat.ip6s_pullup2++;
|
|
if (off + len > MCLBYTES)
|
|
ip6stat.ip6s_pullup2_fail++;
|
|
else {
|
|
int dlen, mlen;
|
|
|
|
dlen = (prev == m) ? prevlen : m->m_len;
|
|
mlen = (prev == m) ? prevmlen : m->m_len + M_TRAILINGSPACE(m);
|
|
prevlen = off + len;
|
|
prevmlen = mlen;
|
|
|
|
if (dlen >= off + len)
|
|
ip6stat.ip6s_pullup2--; /* call will not be made! */
|
|
else if ((m->m_flags & M_EXT) != 0) {
|
|
ip6stat.ip6s_pullup2_alloc++;
|
|
ip6stat.ip6s_pullup2_copy++;
|
|
prevmlen = (off + len > MHLEN) ? MCLBYTES : MHLEN;
|
|
} else {
|
|
if (mlen >= off + len)
|
|
ip6stat.ip6s_pullup2_copy++;
|
|
else {
|
|
ip6stat.ip6s_pullup2_alloc++;
|
|
ip6stat.ip6s_pullup2_copy++;
|
|
prevmlen = (off + len > MHLEN) ? MCLBYTES
|
|
: MHLEN;
|
|
}
|
|
}
|
|
}
|
|
|
|
prev = m;
|
|
#endif
|
|
|
|
#ifdef PULLDOWN_DEBUG
|
|
{
|
|
struct mbuf *t;
|
|
printf("before:");
|
|
for (t = m; t; t = t->m_next)
|
|
printf(" %d", t->m_len);
|
|
printf("\n");
|
|
}
|
|
#endif
|
|
n = m;
|
|
while (n != NULL && off > 0) {
|
|
if (n->m_len > off)
|
|
break;
|
|
off -= n->m_len;
|
|
n = n->m_next;
|
|
}
|
|
/* be sure to point non-empty mbuf */
|
|
while (n != NULL && n->m_len == 0)
|
|
n = n->m_next;
|
|
if (!n) {
|
|
m_freem(m);
|
|
return NULL; /* mbuf chain too short */
|
|
}
|
|
|
|
/*
|
|
* the target data is on <n, off>.
|
|
* if we got enough data on the mbuf "n", we're done.
|
|
*/
|
|
if ((off == 0 || offp) && len <= n->m_len - off)
|
|
goto ok;
|
|
|
|
#if defined(PULLDOWN_STAT) && defined(INET6)
|
|
ip6stat.ip6s_pulldown_copy++;
|
|
#endif
|
|
|
|
/*
|
|
* when len < n->m_len - off and off != 0, it is a special case.
|
|
* len bytes from <n, off> sits in single mbuf, but the caller does
|
|
* not like the starting position (off).
|
|
* chop the current mbuf into two pieces, set off to 0.
|
|
*/
|
|
if (len < n->m_len - off) {
|
|
o = m_copym(n, off, n->m_len - off, M_DONTWAIT);
|
|
if (o == NULL) {
|
|
m_freem(m);
|
|
return NULL; /* ENOBUFS */
|
|
}
|
|
n->m_len = off;
|
|
o->m_next = n->m_next;
|
|
n->m_next = o;
|
|
n = n->m_next;
|
|
off = 0;
|
|
goto ok;
|
|
}
|
|
|
|
/*
|
|
* we need to take hlen from <n, off> and tlen from <n->m_next, 0>,
|
|
* and construct contiguous mbuf with m_len == len.
|
|
* note that hlen + tlen == len, and tlen > 0.
|
|
*/
|
|
hlen = n->m_len - off;
|
|
tlen = len - hlen;
|
|
|
|
/*
|
|
* ensure that we have enough trailing data on mbuf chain.
|
|
* if not, we can do nothing about the chain.
|
|
*/
|
|
olen = 0;
|
|
for (o = n->m_next; o != NULL; o = o->m_next)
|
|
olen += o->m_len;
|
|
if (hlen + olen < len) {
|
|
m_freem(m);
|
|
return NULL; /* mbuf chain too short */
|
|
}
|
|
|
|
/*
|
|
* easy cases first.
|
|
* we need to use m_copydata() to get data from <n->m_next, 0>.
|
|
*/
|
|
if ((n->m_flags & M_EXT) == 0)
|
|
sharedcluster = 0;
|
|
else {
|
|
#ifdef __bsdi__
|
|
if (n->m_ext.ext_func)
|
|
#else
|
|
if (n->m_ext.ext_free)
|
|
#endif
|
|
sharedcluster = 1;
|
|
#ifdef __NetBSD__
|
|
else if (MCLISREFERENCED(n))
|
|
#else
|
|
else if (mclrefcnt[mtocl(n->m_ext.ext_buf)] > 1)
|
|
#endif
|
|
sharedcluster = 1;
|
|
else
|
|
sharedcluster = 0;
|
|
}
|
|
if ((off == 0 || offp) && M_TRAILINGSPACE(n) >= tlen
|
|
&& !sharedcluster) {
|
|
m_copydata(n->m_next, 0, tlen, mtod(n, caddr_t) + n->m_len);
|
|
n->m_len += tlen;
|
|
m_adj(n->m_next, tlen);
|
|
goto ok;
|
|
}
|
|
if ((off == 0 || offp) && M_LEADINGSPACE(n->m_next) >= hlen
|
|
&& !sharedcluster) {
|
|
n->m_next->m_data -= hlen;
|
|
n->m_next->m_len += hlen;
|
|
bcopy(mtod(n, caddr_t) + off, mtod(n->m_next, caddr_t), hlen);
|
|
n->m_len -= hlen;
|
|
n = n->m_next;
|
|
off = 0;
|
|
goto ok;
|
|
}
|
|
|
|
/*
|
|
* now, we need to do the hard way. don't m_copy as there's no room
|
|
* on both end.
|
|
*/
|
|
#if defined(PULLDOWN_STAT) && defined(INET6)
|
|
ip6stat.ip6s_pulldown_alloc++;
|
|
#endif
|
|
MGET(o, M_DONTWAIT, m->m_type);
|
|
if (o == NULL) {
|
|
m_freem(m);
|
|
return NULL; /* ENOBUFS */
|
|
}
|
|
if (len > MHLEN) { /* use MHLEN just for safety */
|
|
MCLGET(o, M_DONTWAIT);
|
|
if ((o->m_flags & M_EXT) == 0) {
|
|
m_freem(m);
|
|
m_free(o);
|
|
return NULL; /* ENOBUFS */
|
|
}
|
|
}
|
|
/* get hlen from <n, off> into <o, 0> */
|
|
o->m_len = hlen;
|
|
bcopy(mtod(n, caddr_t) + off, mtod(o, caddr_t), hlen);
|
|
n->m_len -= hlen;
|
|
/* get tlen from <n->m_next, 0> into <o, hlen> */
|
|
m_copydata(n->m_next, 0, tlen, mtod(o, caddr_t) + o->m_len);
|
|
o->m_len += tlen;
|
|
m_adj(n->m_next, tlen);
|
|
o->m_next = n->m_next;
|
|
n->m_next = o;
|
|
n = o;
|
|
off = 0;
|
|
|
|
ok:
|
|
#ifdef PULLDOWN_DEBUG
|
|
{
|
|
struct mbuf *t;
|
|
printf("after:");
|
|
for (t = m; t; t = t->m_next)
|
|
printf("%c%d", t == n ? '*' : ' ', t->m_len);
|
|
printf(" (off=%d)\n", off);
|
|
}
|
|
#endif
|
|
if (offp)
|
|
*offp = off;
|
|
return n;
|
|
}
|
|
|
|
/*
|
|
* pkthdr.aux chain manipulation.
|
|
* we don't allow clusters at this moment.
|
|
*/
|
|
struct mbuf *
|
|
m_aux_add(m, af, type)
|
|
struct mbuf *m;
|
|
int af, type;
|
|
{
|
|
struct mbuf *n;
|
|
struct mauxtag *t;
|
|
|
|
if ((m->m_flags & M_PKTHDR) == 0)
|
|
return NULL;
|
|
|
|
n = m_aux_find(m, af, type);
|
|
if (n)
|
|
return n;
|
|
|
|
MGET(n, M_DONTWAIT, m->m_type);
|
|
if (n == NULL)
|
|
return NULL;
|
|
|
|
t = mtod(n, struct mauxtag *);
|
|
t->af = af;
|
|
t->type = type;
|
|
n->m_data += sizeof(struct mauxtag);
|
|
n->m_len = 0;
|
|
n->m_next = m->m_pkthdr.aux;
|
|
m->m_pkthdr.aux = n;
|
|
return n;
|
|
}
|
|
|
|
struct mbuf *
|
|
m_aux_find(m, af, type)
|
|
struct mbuf *m;
|
|
int af, type;
|
|
{
|
|
struct mbuf *n;
|
|
struct mauxtag *t;
|
|
|
|
if ((m->m_flags & M_PKTHDR) == 0)
|
|
return NULL;
|
|
|
|
for (n = m->m_pkthdr.aux; n; n = n->m_next) {
|
|
t = (struct mauxtag *)n->m_dat;
|
|
if (t->af == af && t->type == type)
|
|
return n;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
m_aux_delete(m, victim)
|
|
struct mbuf *m;
|
|
struct mbuf *victim;
|
|
{
|
|
struct mbuf *n, *prev, *next;
|
|
struct mauxtag *t;
|
|
|
|
if ((m->m_flags & M_PKTHDR) == 0)
|
|
return;
|
|
|
|
prev = NULL;
|
|
n = m->m_pkthdr.aux;
|
|
while (n) {
|
|
t = (struct mauxtag *)n->m_dat;
|
|
next = n->m_next;
|
|
if (n == victim) {
|
|
if (prev)
|
|
prev->m_next = n->m_next;
|
|
else
|
|
m->m_pkthdr.aux = n->m_next;
|
|
n->m_next = NULL;
|
|
m_free(n);
|
|
} else
|
|
prev = n;
|
|
n = next;
|
|
}
|
|
}
|