Home | History | Annotate | Line # | Download | only in kern
uipc_mbuf.c revision 1.28
      1  1.28   thorpej /*	$NetBSD: uipc_mbuf.c,v 1.28 1998/08/01 01:35:20 thorpej Exp $	*/
      2  1.10       cgd 
      3   1.1       cgd /*
      4   1.9   mycroft  * Copyright (c) 1982, 1986, 1988, 1991, 1993
      5   1.9   mycroft  *	The Regents of the University of California.  All rights reserved.
      6   1.1       cgd  *
      7   1.1       cgd  * Redistribution and use in source and binary forms, with or without
      8   1.1       cgd  * modification, are permitted provided that the following conditions
      9   1.1       cgd  * are met:
     10   1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     11   1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     12   1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     13   1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     14   1.1       cgd  *    documentation and/or other materials provided with the distribution.
     15   1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     16   1.1       cgd  *    must display the following acknowledgement:
     17   1.1       cgd  *	This product includes software developed by the University of
     18   1.1       cgd  *	California, Berkeley and its contributors.
     19   1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     20   1.1       cgd  *    may be used to endorse or promote products derived from this software
     21   1.1       cgd  *    without specific prior written permission.
     22   1.1       cgd  *
     23   1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24   1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25   1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26   1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27   1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28   1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29   1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30   1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31   1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32   1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33   1.1       cgd  * SUCH DAMAGE.
     34   1.1       cgd  *
     35  1.26      fvdl  *	@(#)uipc_mbuf.c	8.4 (Berkeley) 2/14/95
     36   1.1       cgd  */
     37  1.24       mrg 
     38  1.24       mrg #include "opt_uvm.h"
     39   1.1       cgd 
     40   1.6   mycroft #include <sys/param.h>
     41   1.6   mycroft #include <sys/systm.h>
     42   1.6   mycroft #include <sys/proc.h>
     43   1.6   mycroft #include <sys/malloc.h>
     44   1.9   mycroft #include <sys/map.h>
     45   1.1       cgd #define MBTYPES
     46   1.6   mycroft #include <sys/mbuf.h>
     47   1.6   mycroft #include <sys/kernel.h>
     48   1.6   mycroft #include <sys/syslog.h>
     49   1.6   mycroft #include <sys/domain.h>
     50   1.6   mycroft #include <sys/protosw.h>
     51  1.28   thorpej #include <sys/pool.h>
     52  1.27      matt #include <sys/socket.h>
     53  1.27      matt #include <net/if.h>
     54   1.6   mycroft 
     55   1.6   mycroft #include <vm/vm.h>
     56  1.14  christos 
     57  1.23       mrg #if defined(UVM)
     58  1.23       mrg #include <uvm/uvm_extern.h>
     59  1.23       mrg #endif
     60  1.23       mrg 
     61  1.28   thorpej struct	pool mbpool;		/* mbuf pool */
     62  1.28   thorpej struct	pool mclpool;		/* mbuf cluster pool */
     63  1.28   thorpej 
     64  1.18   thorpej struct mbuf *mbutl;
     65  1.18   thorpej struct mbstat mbstat;
     66  1.18   thorpej union mcluster *mclfree;
     67  1.18   thorpej int	max_linkhdr;
     68  1.18   thorpej int	max_protohdr;
     69  1.18   thorpej int	max_hdr;
     70  1.18   thorpej int	max_datalen;
     71  1.18   thorpej 
     72   1.1       cgd extern	vm_map_t mb_map;
     73   1.1       cgd 
     74  1.28   thorpej void	*mclpool_alloc __P((unsigned long, int, int));
     75  1.28   thorpej void	mclpool_release __P((void *, unsigned long, int));
     76  1.28   thorpej 
     77  1.28   thorpej /*
     78  1.28   thorpej  * Initialize the mbuf allcator.  Note, this cannot allocate any
     79  1.28   thorpej  * memory itself; we are called before mb_map has been allocated.
     80  1.28   thorpej  */
     81   1.4       jtc void
     82   1.1       cgd mbinit()
     83   1.1       cgd {
     84   1.1       cgd 
     85  1.28   thorpej 	/* XXX malloc types! */
     86  1.28   thorpej 	pool_init(&mbpool, MSIZE, 0, 0, 0, "mbpl", 0, NULL, NULL, 0);
     87  1.28   thorpej 	pool_init(&mclpool, MCLBYTES, 0, 0, 0, "mclpl", 0, mclpool_alloc,
     88  1.28   thorpej 	    mclpool_release, 0);
     89  1.28   thorpej }
     90  1.28   thorpej 
     91  1.28   thorpej void *
     92  1.28   thorpej mclpool_alloc(sz, flags, mtype)
     93  1.28   thorpej 	unsigned long sz;
     94  1.28   thorpej 	int flags;
     95  1.28   thorpej 	int mtype;
     96  1.28   thorpej {
     97  1.28   thorpej 
     98  1.28   thorpej #if defined(UVM)
     99  1.28   thorpej 	return ((void *)uvm_km_alloc_poolpage1(mb_map, uvmexp.mb_object));
    100  1.28   thorpej #else
    101  1.28   thorpej 	return ((void *)kmem_alloc_poolpage1(mb_map));
    102  1.28   thorpej #endif
    103   1.1       cgd }
    104   1.1       cgd 
    105  1.28   thorpej void
    106  1.28   thorpej mclpool_release(v, sz, mtype)
    107  1.28   thorpej 	void *v;
    108  1.28   thorpej 	unsigned long sz;
    109  1.28   thorpej 	int mtype;
    110   1.1       cgd {
    111   1.1       cgd 
    112  1.23       mrg #if defined(UVM)
    113  1.28   thorpej 	uvm_km_free_poolpage1(mb_map, (vm_offset_t)v);
    114  1.23       mrg #else
    115  1.28   thorpej 	kmem_free_poolpage1(mb_map, (vm_offset_t)v);
    116  1.23       mrg #endif
    117   1.1       cgd }
    118   1.1       cgd 
    119   1.1       cgd /*
    120   1.1       cgd  * When MGET failes, ask protocols to free space when short of memory,
    121   1.1       cgd  * then re-attempt to allocate an mbuf.
    122   1.1       cgd  */
    123   1.1       cgd struct mbuf *
    124   1.1       cgd m_retry(i, t)
    125   1.1       cgd 	int i, t;
    126   1.1       cgd {
    127  1.27      matt 	struct mbuf *m;
    128   1.1       cgd 
    129   1.1       cgd 	m_reclaim();
    130   1.1       cgd #define m_retry(i, t)	(struct mbuf *)0
    131   1.1       cgd 	MGET(m, i, t);
    132   1.1       cgd #undef m_retry
    133  1.18   thorpej 	if (m != NULL)
    134  1.18   thorpej 		mbstat.m_wait++;
    135  1.18   thorpej 	else
    136  1.18   thorpej 		mbstat.m_drops++;
    137   1.1       cgd 	return (m);
    138   1.1       cgd }
    139   1.1       cgd 
    140   1.1       cgd /*
    141   1.1       cgd  * As above; retry an MGETHDR.
    142   1.1       cgd  */
    143   1.1       cgd struct mbuf *
    144   1.1       cgd m_retryhdr(i, t)
    145   1.1       cgd 	int i, t;
    146   1.1       cgd {
    147  1.27      matt 	struct mbuf *m;
    148   1.1       cgd 
    149   1.1       cgd 	m_reclaim();
    150   1.1       cgd #define m_retryhdr(i, t) (struct mbuf *)0
    151   1.1       cgd 	MGETHDR(m, i, t);
    152   1.1       cgd #undef m_retryhdr
    153  1.18   thorpej 	if (m != NULL)
    154  1.18   thorpej 		mbstat.m_wait++;
    155  1.18   thorpej 	else
    156  1.18   thorpej 		mbstat.m_drops++;
    157   1.1       cgd 	return (m);
    158   1.1       cgd }
    159   1.1       cgd 
    160  1.14  christos void
    161   1.1       cgd m_reclaim()
    162   1.1       cgd {
    163  1.27      matt 	struct domain *dp;
    164  1.27      matt 	struct protosw *pr;
    165  1.27      matt 	struct ifnet *ifp;
    166   1.1       cgd 	int s = splimp();
    167   1.1       cgd 
    168   1.1       cgd 	for (dp = domains; dp; dp = dp->dom_next)
    169   1.1       cgd 		for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
    170   1.1       cgd 			if (pr->pr_drain)
    171   1.1       cgd 				(*pr->pr_drain)();
    172  1.27      matt 	for (ifp = TAILQ_FIRST(&ifnet); ifp; ifp = TAILQ_NEXT(ifp, if_list))
    173  1.27      matt 		if (ifp->if_drain)
    174  1.27      matt 			(*ifp->if_drain)(ifp);
    175   1.1       cgd 	splx(s);
    176   1.1       cgd 	mbstat.m_drain++;
    177   1.1       cgd }
    178   1.1       cgd 
    179   1.1       cgd /*
    180   1.1       cgd  * Space allocation routines.
    181   1.1       cgd  * These are also available as macros
    182   1.1       cgd  * for critical paths.
    183   1.1       cgd  */
    184   1.1       cgd struct mbuf *
    185   1.5       cgd m_get(nowait, type)
    186   1.5       cgd 	int nowait, type;
    187   1.1       cgd {
    188  1.27      matt 	struct mbuf *m;
    189   1.1       cgd 
    190   1.5       cgd 	MGET(m, nowait, type);
    191   1.1       cgd 	return (m);
    192   1.1       cgd }
    193   1.1       cgd 
    194   1.1       cgd struct mbuf *
    195   1.5       cgd m_gethdr(nowait, type)
    196   1.5       cgd 	int nowait, type;
    197   1.1       cgd {
    198  1.27      matt 	struct mbuf *m;
    199   1.1       cgd 
    200   1.5       cgd 	MGETHDR(m, nowait, type);
    201   1.1       cgd 	return (m);
    202   1.1       cgd }
    203   1.1       cgd 
    204   1.1       cgd struct mbuf *
    205   1.5       cgd m_getclr(nowait, type)
    206   1.5       cgd 	int nowait, type;
    207   1.1       cgd {
    208  1.27      matt 	struct mbuf *m;
    209   1.1       cgd 
    210   1.5       cgd 	MGET(m, nowait, type);
    211   1.1       cgd 	if (m == 0)
    212   1.1       cgd 		return (0);
    213   1.1       cgd 	bzero(mtod(m, caddr_t), MLEN);
    214   1.1       cgd 	return (m);
    215   1.1       cgd }
    216   1.1       cgd 
    217   1.1       cgd struct mbuf *
    218   1.1       cgd m_free(m)
    219   1.1       cgd 	struct mbuf *m;
    220   1.1       cgd {
    221  1.27      matt 	struct mbuf *n;
    222   1.1       cgd 
    223   1.1       cgd 	MFREE(m, n);
    224   1.1       cgd 	return (n);
    225   1.1       cgd }
    226   1.1       cgd 
    227   1.9   mycroft void
    228   1.1       cgd m_freem(m)
    229  1.27      matt 	struct mbuf *m;
    230   1.1       cgd {
    231  1.27      matt 	struct mbuf *n;
    232   1.1       cgd 
    233   1.1       cgd 	if (m == NULL)
    234   1.1       cgd 		return;
    235   1.1       cgd 	do {
    236   1.1       cgd 		MFREE(m, n);
    237  1.18   thorpej 		m = n;
    238  1.18   thorpej 	} while (m);
    239   1.1       cgd }
    240   1.1       cgd 
    241   1.1       cgd /*
    242   1.1       cgd  * Mbuffer utility routines.
    243   1.1       cgd  */
    244   1.1       cgd 
    245   1.1       cgd /*
    246   1.1       cgd  * Lesser-used path for M_PREPEND:
    247   1.1       cgd  * allocate new mbuf to prepend to chain,
    248   1.1       cgd  * copy junk along.
    249   1.1       cgd  */
    250   1.1       cgd struct mbuf *
    251   1.9   mycroft m_prepend(m, len, how)
    252  1.27      matt 	struct mbuf *m;
    253   1.9   mycroft 	int len, how;
    254   1.1       cgd {
    255   1.1       cgd 	struct mbuf *mn;
    256   1.1       cgd 
    257   1.9   mycroft 	MGET(mn, how, m->m_type);
    258   1.1       cgd 	if (mn == (struct mbuf *)NULL) {
    259   1.1       cgd 		m_freem(m);
    260   1.1       cgd 		return ((struct mbuf *)NULL);
    261   1.1       cgd 	}
    262   1.1       cgd 	if (m->m_flags & M_PKTHDR) {
    263   1.1       cgd 		M_COPY_PKTHDR(mn, m);
    264   1.1       cgd 		m->m_flags &= ~M_PKTHDR;
    265   1.1       cgd 	}
    266   1.1       cgd 	mn->m_next = m;
    267   1.1       cgd 	m = mn;
    268   1.1       cgd 	if (len < MHLEN)
    269   1.1       cgd 		MH_ALIGN(m, len);
    270   1.1       cgd 	m->m_len = len;
    271   1.1       cgd 	return (m);
    272   1.1       cgd }
    273   1.1       cgd 
    274   1.1       cgd /*
    275   1.1       cgd  * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
    276   1.1       cgd  * continuing for "len" bytes.  If len is M_COPYALL, copy to end of mbuf.
    277   1.1       cgd  * The wait parameter is a choice of M_WAIT/M_DONTWAIT from caller.
    278   1.1       cgd  */
    279   1.1       cgd int MCFail;
    280   1.1       cgd 
    281   1.1       cgd struct mbuf *
    282   1.1       cgd m_copym(m, off0, len, wait)
    283  1.27      matt 	struct mbuf *m;
    284   1.1       cgd 	int off0, wait;
    285  1.27      matt 	int len;
    286   1.1       cgd {
    287  1.27      matt 	struct mbuf *n, **np;
    288  1.27      matt 	int off = off0;
    289   1.1       cgd 	struct mbuf *top;
    290   1.1       cgd 	int copyhdr = 0;
    291   1.1       cgd 
    292   1.1       cgd 	if (off < 0 || len < 0)
    293   1.1       cgd 		panic("m_copym");
    294   1.1       cgd 	if (off == 0 && m->m_flags & M_PKTHDR)
    295   1.1       cgd 		copyhdr = 1;
    296   1.1       cgd 	while (off > 0) {
    297   1.1       cgd 		if (m == 0)
    298   1.1       cgd 			panic("m_copym");
    299   1.1       cgd 		if (off < m->m_len)
    300   1.1       cgd 			break;
    301   1.1       cgd 		off -= m->m_len;
    302   1.1       cgd 		m = m->m_next;
    303   1.1       cgd 	}
    304   1.1       cgd 	np = &top;
    305   1.1       cgd 	top = 0;
    306   1.1       cgd 	while (len > 0) {
    307   1.1       cgd 		if (m == 0) {
    308   1.1       cgd 			if (len != M_COPYALL)
    309   1.1       cgd 				panic("m_copym");
    310   1.1       cgd 			break;
    311   1.1       cgd 		}
    312   1.1       cgd 		MGET(n, wait, m->m_type);
    313   1.1       cgd 		*np = n;
    314   1.1       cgd 		if (n == 0)
    315   1.1       cgd 			goto nospace;
    316   1.1       cgd 		if (copyhdr) {
    317   1.1       cgd 			M_COPY_PKTHDR(n, m);
    318   1.1       cgd 			if (len == M_COPYALL)
    319   1.1       cgd 				n->m_pkthdr.len -= off0;
    320   1.1       cgd 			else
    321   1.1       cgd 				n->m_pkthdr.len = len;
    322   1.1       cgd 			copyhdr = 0;
    323   1.1       cgd 		}
    324   1.9   mycroft 		n->m_len = min(len, m->m_len - off);
    325   1.1       cgd 		if (m->m_flags & M_EXT) {
    326   1.1       cgd 			n->m_data = m->m_data + off;
    327   1.1       cgd 			n->m_ext = m->m_ext;
    328  1.18   thorpej 			MCLADDREFERENCE(m, n);
    329   1.1       cgd 		} else
    330   1.1       cgd 			bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
    331   1.1       cgd 			    (unsigned)n->m_len);
    332   1.1       cgd 		if (len != M_COPYALL)
    333   1.1       cgd 			len -= n->m_len;
    334   1.1       cgd 		off = 0;
    335   1.1       cgd 		m = m->m_next;
    336   1.1       cgd 		np = &n->m_next;
    337   1.1       cgd 	}
    338   1.1       cgd 	if (top == 0)
    339   1.1       cgd 		MCFail++;
    340   1.1       cgd 	return (top);
    341   1.1       cgd nospace:
    342   1.1       cgd 	m_freem(top);
    343   1.1       cgd 	MCFail++;
    344   1.1       cgd 	return (0);
    345   1.1       cgd }
    346   1.1       cgd 
    347   1.1       cgd /*
    348  1.18   thorpej  * Copy an entire packet, including header (which must be present).
    349  1.18   thorpej  * An optimization of the common case `m_copym(m, 0, M_COPYALL, how)'.
    350  1.18   thorpej  */
    351  1.18   thorpej struct mbuf *
    352  1.18   thorpej m_copypacket(m, how)
    353  1.18   thorpej 	struct mbuf *m;
    354  1.18   thorpej 	int how;
    355  1.18   thorpej {
    356  1.18   thorpej 	struct mbuf *top, *n, *o;
    357  1.18   thorpej 
    358  1.18   thorpej 	MGET(n, how, m->m_type);
    359  1.18   thorpej 	top = n;
    360  1.18   thorpej 	if (!n)
    361  1.18   thorpej 		goto nospace;
    362  1.18   thorpej 
    363  1.18   thorpej 	M_COPY_PKTHDR(n, m);
    364  1.18   thorpej 	n->m_len = m->m_len;
    365  1.18   thorpej 	if (m->m_flags & M_EXT) {
    366  1.18   thorpej 		n->m_data = m->m_data;
    367  1.18   thorpej 		n->m_ext = m->m_ext;
    368  1.18   thorpej 		MCLADDREFERENCE(m, n);
    369  1.18   thorpej 	} else {
    370  1.18   thorpej 		bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
    371  1.18   thorpej 	}
    372  1.18   thorpej 
    373  1.18   thorpej 	m = m->m_next;
    374  1.18   thorpej 	while (m) {
    375  1.18   thorpej 		MGET(o, how, m->m_type);
    376  1.18   thorpej 		if (!o)
    377  1.18   thorpej 			goto nospace;
    378  1.18   thorpej 
    379  1.18   thorpej 		n->m_next = o;
    380  1.18   thorpej 		n = n->m_next;
    381  1.18   thorpej 
    382  1.18   thorpej 		n->m_len = m->m_len;
    383  1.18   thorpej 		if (m->m_flags & M_EXT) {
    384  1.18   thorpej 			n->m_data = m->m_data;
    385  1.18   thorpej 			n->m_ext = m->m_ext;
    386  1.18   thorpej 			MCLADDREFERENCE(m, n);
    387  1.18   thorpej 		} else {
    388  1.18   thorpej 			bcopy(mtod(m, char *), mtod(n, char *), n->m_len);
    389  1.18   thorpej 		}
    390  1.18   thorpej 
    391  1.18   thorpej 		m = m->m_next;
    392  1.18   thorpej 	}
    393  1.18   thorpej 	return top;
    394  1.18   thorpej nospace:
    395  1.18   thorpej 	m_freem(top);
    396  1.18   thorpej 	MCFail++;
    397  1.18   thorpej 	return 0;
    398  1.18   thorpej }
    399  1.18   thorpej 
    400  1.18   thorpej /*
    401   1.1       cgd  * Copy data from an mbuf chain starting "off" bytes from the beginning,
    402   1.1       cgd  * continuing for "len" bytes, into the indicated buffer.
    403   1.1       cgd  */
    404  1.14  christos void
    405   1.1       cgd m_copydata(m, off, len, cp)
    406  1.27      matt 	struct mbuf *m;
    407  1.27      matt 	int off;
    408  1.27      matt 	int len;
    409   1.1       cgd 	caddr_t cp;
    410   1.1       cgd {
    411  1.27      matt 	unsigned count;
    412   1.1       cgd 
    413   1.1       cgd 	if (off < 0 || len < 0)
    414   1.1       cgd 		panic("m_copydata");
    415   1.1       cgd 	while (off > 0) {
    416   1.1       cgd 		if (m == 0)
    417   1.1       cgd 			panic("m_copydata");
    418   1.1       cgd 		if (off < m->m_len)
    419   1.1       cgd 			break;
    420   1.1       cgd 		off -= m->m_len;
    421   1.1       cgd 		m = m->m_next;
    422   1.1       cgd 	}
    423   1.1       cgd 	while (len > 0) {
    424   1.1       cgd 		if (m == 0)
    425   1.1       cgd 			panic("m_copydata");
    426   1.9   mycroft 		count = min(m->m_len - off, len);
    427   1.1       cgd 		bcopy(mtod(m, caddr_t) + off, cp, count);
    428   1.1       cgd 		len -= count;
    429   1.1       cgd 		cp += count;
    430   1.1       cgd 		off = 0;
    431   1.1       cgd 		m = m->m_next;
    432   1.1       cgd 	}
    433   1.1       cgd }
    434   1.1       cgd 
    435   1.1       cgd /*
    436   1.1       cgd  * Concatenate mbuf chain n to m.
    437   1.1       cgd  * Both chains must be of the same type (e.g. MT_DATA).
    438   1.1       cgd  * Any m_pkthdr is not updated.
    439   1.1       cgd  */
    440  1.14  christos void
    441   1.1       cgd m_cat(m, n)
    442  1.27      matt 	struct mbuf *m, *n;
    443   1.1       cgd {
    444   1.1       cgd 	while (m->m_next)
    445   1.1       cgd 		m = m->m_next;
    446   1.1       cgd 	while (n) {
    447   1.1       cgd 		if (m->m_flags & M_EXT ||
    448   1.1       cgd 		    m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) {
    449   1.1       cgd 			/* just join the two chains */
    450   1.1       cgd 			m->m_next = n;
    451   1.1       cgd 			return;
    452   1.1       cgd 		}
    453   1.1       cgd 		/* splat the data from one into the other */
    454   1.1       cgd 		bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
    455   1.1       cgd 		    (u_int)n->m_len);
    456   1.1       cgd 		m->m_len += n->m_len;
    457   1.1       cgd 		n = m_free(n);
    458   1.1       cgd 	}
    459   1.1       cgd }
    460   1.1       cgd 
    461  1.11   mycroft void
    462   1.1       cgd m_adj(mp, req_len)
    463   1.1       cgd 	struct mbuf *mp;
    464   1.8   deraadt 	int req_len;
    465   1.1       cgd {
    466  1.27      matt 	int len = req_len;
    467  1.27      matt 	struct mbuf *m;
    468  1.27      matt 	int count;
    469   1.1       cgd 
    470   1.1       cgd 	if ((m = mp) == NULL)
    471   1.1       cgd 		return;
    472   1.1       cgd 	if (len >= 0) {
    473   1.1       cgd 		/*
    474   1.1       cgd 		 * Trim from head.
    475   1.1       cgd 		 */
    476   1.1       cgd 		while (m != NULL && len > 0) {
    477   1.1       cgd 			if (m->m_len <= len) {
    478   1.1       cgd 				len -= m->m_len;
    479   1.1       cgd 				m->m_len = 0;
    480   1.1       cgd 				m = m->m_next;
    481   1.1       cgd 			} else {
    482   1.1       cgd 				m->m_len -= len;
    483   1.1       cgd 				m->m_data += len;
    484   1.1       cgd 				len = 0;
    485   1.1       cgd 			}
    486   1.1       cgd 		}
    487   1.1       cgd 		m = mp;
    488   1.1       cgd 		if (mp->m_flags & M_PKTHDR)
    489   1.1       cgd 			m->m_pkthdr.len -= (req_len - len);
    490   1.1       cgd 	} else {
    491   1.1       cgd 		/*
    492   1.1       cgd 		 * Trim from tail.  Scan the mbuf chain,
    493   1.1       cgd 		 * calculating its length and finding the last mbuf.
    494   1.1       cgd 		 * If the adjustment only affects this mbuf, then just
    495   1.1       cgd 		 * adjust and return.  Otherwise, rescan and truncate
    496   1.1       cgd 		 * after the remaining size.
    497   1.1       cgd 		 */
    498   1.1       cgd 		len = -len;
    499   1.1       cgd 		count = 0;
    500   1.1       cgd 		for (;;) {
    501   1.1       cgd 			count += m->m_len;
    502   1.1       cgd 			if (m->m_next == (struct mbuf *)0)
    503   1.1       cgd 				break;
    504   1.1       cgd 			m = m->m_next;
    505   1.1       cgd 		}
    506   1.1       cgd 		if (m->m_len >= len) {
    507   1.1       cgd 			m->m_len -= len;
    508   1.8   deraadt 			if (mp->m_flags & M_PKTHDR)
    509   1.8   deraadt 				mp->m_pkthdr.len -= len;
    510   1.1       cgd 			return;
    511   1.1       cgd 		}
    512   1.1       cgd 		count -= len;
    513   1.1       cgd 		if (count < 0)
    514   1.1       cgd 			count = 0;
    515   1.1       cgd 		/*
    516   1.1       cgd 		 * Correct length for chain is "count".
    517   1.1       cgd 		 * Find the mbuf with last data, adjust its length,
    518   1.1       cgd 		 * and toss data from remaining mbufs on chain.
    519   1.1       cgd 		 */
    520   1.1       cgd 		m = mp;
    521   1.1       cgd 		if (m->m_flags & M_PKTHDR)
    522   1.1       cgd 			m->m_pkthdr.len = count;
    523   1.1       cgd 		for (; m; m = m->m_next) {
    524   1.1       cgd 			if (m->m_len >= count) {
    525   1.1       cgd 				m->m_len = count;
    526   1.1       cgd 				break;
    527   1.1       cgd 			}
    528   1.1       cgd 			count -= m->m_len;
    529   1.1       cgd 		}
    530  1.18   thorpej 		while (m->m_next)
    531  1.18   thorpej 			(m = m->m_next) ->m_len = 0;
    532   1.1       cgd 	}
    533   1.1       cgd }
    534   1.1       cgd 
    535   1.1       cgd /*
    536   1.1       cgd  * Rearange an mbuf chain so that len bytes are contiguous
    537   1.1       cgd  * and in the data area of an mbuf (so that mtod and dtom
    538   1.1       cgd  * will work for a structure of size len).  Returns the resulting
    539   1.1       cgd  * mbuf chain on success, frees it and returns null on failure.
    540   1.1       cgd  * If there is room, it will add up to max_protohdr-len extra bytes to the
    541   1.1       cgd  * contiguous region in an attempt to avoid being called next time.
    542   1.1       cgd  */
    543   1.1       cgd int MPFail;
    544   1.1       cgd 
    545   1.1       cgd struct mbuf *
    546   1.1       cgd m_pullup(n, len)
    547  1.27      matt 	struct mbuf *n;
    548   1.1       cgd 	int len;
    549   1.1       cgd {
    550  1.27      matt 	struct mbuf *m;
    551  1.27      matt 	int count;
    552   1.1       cgd 	int space;
    553   1.1       cgd 
    554   1.1       cgd 	/*
    555   1.1       cgd 	 * If first mbuf has no cluster, and has room for len bytes
    556   1.1       cgd 	 * without shifting current data, pullup into it,
    557   1.1       cgd 	 * otherwise allocate a new mbuf to prepend to the chain.
    558   1.1       cgd 	 */
    559   1.1       cgd 	if ((n->m_flags & M_EXT) == 0 &&
    560   1.1       cgd 	    n->m_data + len < &n->m_dat[MLEN] && n->m_next) {
    561   1.1       cgd 		if (n->m_len >= len)
    562   1.1       cgd 			return (n);
    563   1.1       cgd 		m = n;
    564   1.1       cgd 		n = n->m_next;
    565   1.1       cgd 		len -= m->m_len;
    566   1.1       cgd 	} else {
    567   1.1       cgd 		if (len > MHLEN)
    568   1.1       cgd 			goto bad;
    569   1.1       cgd 		MGET(m, M_DONTWAIT, n->m_type);
    570   1.1       cgd 		if (m == 0)
    571   1.1       cgd 			goto bad;
    572   1.1       cgd 		m->m_len = 0;
    573   1.1       cgd 		if (n->m_flags & M_PKTHDR) {
    574   1.1       cgd 			M_COPY_PKTHDR(m, n);
    575   1.1       cgd 			n->m_flags &= ~M_PKTHDR;
    576   1.1       cgd 		}
    577   1.1       cgd 	}
    578   1.1       cgd 	space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
    579   1.1       cgd 	do {
    580   1.1       cgd 		count = min(min(max(len, max_protohdr), space), n->m_len);
    581   1.1       cgd 		bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
    582   1.1       cgd 		  (unsigned)count);
    583   1.1       cgd 		len -= count;
    584   1.1       cgd 		m->m_len += count;
    585   1.1       cgd 		n->m_len -= count;
    586   1.1       cgd 		space -= count;
    587   1.1       cgd 		if (n->m_len)
    588   1.1       cgd 			n->m_data += count;
    589   1.1       cgd 		else
    590   1.1       cgd 			n = m_free(n);
    591   1.1       cgd 	} while (len > 0 && n);
    592   1.1       cgd 	if (len > 0) {
    593   1.1       cgd 		(void) m_free(m);
    594   1.1       cgd 		goto bad;
    595   1.1       cgd 	}
    596   1.1       cgd 	m->m_next = n;
    597   1.1       cgd 	return (m);
    598   1.1       cgd bad:
    599   1.1       cgd 	m_freem(n);
    600   1.1       cgd 	MPFail++;
    601   1.1       cgd 	return (0);
    602   1.9   mycroft }
    603   1.9   mycroft 
    604   1.9   mycroft /*
    605   1.9   mycroft  * Partition an mbuf chain in two pieces, returning the tail --
    606   1.9   mycroft  * all but the first len0 bytes.  In case of failure, it returns NULL and
    607   1.9   mycroft  * attempts to restore the chain to its original state.
    608   1.9   mycroft  */
    609   1.9   mycroft struct mbuf *
    610   1.9   mycroft m_split(m0, len0, wait)
    611  1.27      matt 	struct mbuf *m0;
    612   1.9   mycroft 	int len0, wait;
    613   1.9   mycroft {
    614  1.27      matt 	struct mbuf *m, *n;
    615  1.22   thorpej 	unsigned len = len0, remain, len_save;
    616   1.9   mycroft 
    617   1.9   mycroft 	for (m = m0; m && len > m->m_len; m = m->m_next)
    618   1.9   mycroft 		len -= m->m_len;
    619   1.9   mycroft 	if (m == 0)
    620   1.9   mycroft 		return (0);
    621   1.9   mycroft 	remain = m->m_len - len;
    622   1.9   mycroft 	if (m0->m_flags & M_PKTHDR) {
    623   1.9   mycroft 		MGETHDR(n, wait, m0->m_type);
    624   1.9   mycroft 		if (n == 0)
    625   1.9   mycroft 			return (0);
    626   1.9   mycroft 		n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
    627   1.9   mycroft 		n->m_pkthdr.len = m0->m_pkthdr.len - len0;
    628  1.22   thorpej 		len_save = m0->m_pkthdr.len;
    629   1.9   mycroft 		m0->m_pkthdr.len = len0;
    630   1.9   mycroft 		if (m->m_flags & M_EXT)
    631   1.9   mycroft 			goto extpacket;
    632   1.9   mycroft 		if (remain > MHLEN) {
    633   1.9   mycroft 			/* m can't be the lead packet */
    634   1.9   mycroft 			MH_ALIGN(n, 0);
    635   1.9   mycroft 			n->m_next = m_split(m, len, wait);
    636   1.9   mycroft 			if (n->m_next == 0) {
    637   1.9   mycroft 				(void) m_free(n);
    638  1.22   thorpej 				m0->m_pkthdr.len = len_save;
    639   1.9   mycroft 				return (0);
    640   1.9   mycroft 			} else
    641   1.9   mycroft 				return (n);
    642   1.9   mycroft 		} else
    643   1.9   mycroft 			MH_ALIGN(n, remain);
    644   1.9   mycroft 	} else if (remain == 0) {
    645   1.9   mycroft 		n = m->m_next;
    646   1.9   mycroft 		m->m_next = 0;
    647   1.9   mycroft 		return (n);
    648   1.9   mycroft 	} else {
    649   1.9   mycroft 		MGET(n, wait, m->m_type);
    650   1.9   mycroft 		if (n == 0)
    651   1.9   mycroft 			return (0);
    652   1.9   mycroft 		M_ALIGN(n, remain);
    653   1.9   mycroft 	}
    654   1.9   mycroft extpacket:
    655   1.9   mycroft 	if (m->m_flags & M_EXT) {
    656   1.9   mycroft 		n->m_ext = m->m_ext;
    657  1.18   thorpej 		MCLADDREFERENCE(m, n);
    658   1.9   mycroft 		n->m_data = m->m_data + len;
    659   1.9   mycroft 	} else {
    660   1.9   mycroft 		bcopy(mtod(m, caddr_t) + len, mtod(n, caddr_t), remain);
    661   1.9   mycroft 	}
    662   1.9   mycroft 	n->m_len = remain;
    663   1.9   mycroft 	m->m_len = len;
    664   1.9   mycroft 	n->m_next = m->m_next;
    665   1.9   mycroft 	m->m_next = 0;
    666   1.9   mycroft 	return (n);
    667   1.9   mycroft }
    668   1.9   mycroft /*
    669   1.9   mycroft  * Routine to copy from device local memory into mbufs.
    670   1.9   mycroft  */
    671   1.9   mycroft struct mbuf *
    672   1.9   mycroft m_devget(buf, totlen, off0, ifp, copy)
    673   1.9   mycroft 	char *buf;
    674   1.9   mycroft 	int totlen, off0;
    675   1.9   mycroft 	struct ifnet *ifp;
    676  1.18   thorpej 	void (*copy) __P((const void *from, void *to, size_t len));
    677   1.9   mycroft {
    678  1.27      matt 	struct mbuf *m;
    679   1.9   mycroft 	struct mbuf *top = 0, **mp = &top;
    680  1.27      matt 	int off = off0, len;
    681  1.27      matt 	char *cp;
    682   1.9   mycroft 	char *epkt;
    683   1.9   mycroft 
    684   1.9   mycroft 	cp = buf;
    685   1.9   mycroft 	epkt = cp + totlen;
    686   1.9   mycroft 	if (off) {
    687  1.13       cgd 		/*
    688  1.13       cgd 		 * If 'off' is non-zero, packet is trailer-encapsulated,
    689  1.13       cgd 		 * so we have to skip the type and length fields.
    690  1.13       cgd 		 */
    691  1.13       cgd 		cp += off + 2 * sizeof(u_int16_t);
    692  1.13       cgd 		totlen -= 2 * sizeof(u_int16_t);
    693   1.9   mycroft 	}
    694   1.9   mycroft 	MGETHDR(m, M_DONTWAIT, MT_DATA);
    695   1.9   mycroft 	if (m == 0)
    696   1.9   mycroft 		return (0);
    697   1.9   mycroft 	m->m_pkthdr.rcvif = ifp;
    698   1.9   mycroft 	m->m_pkthdr.len = totlen;
    699   1.9   mycroft 	m->m_len = MHLEN;
    700   1.9   mycroft 
    701   1.9   mycroft 	while (totlen > 0) {
    702   1.9   mycroft 		if (top) {
    703   1.9   mycroft 			MGET(m, M_DONTWAIT, MT_DATA);
    704   1.9   mycroft 			if (m == 0) {
    705   1.9   mycroft 				m_freem(top);
    706   1.9   mycroft 				return (0);
    707   1.9   mycroft 			}
    708   1.9   mycroft 			m->m_len = MLEN;
    709   1.9   mycroft 		}
    710   1.9   mycroft 		len = min(totlen, epkt - cp);
    711   1.9   mycroft 		if (len >= MINCLSIZE) {
    712   1.9   mycroft 			MCLGET(m, M_DONTWAIT);
    713  1.19   mycroft 			if ((m->m_flags & M_EXT) == 0) {
    714  1.20   mycroft 				m_free(m);
    715  1.19   mycroft 				m_freem(top);
    716  1.19   mycroft 				return (0);
    717  1.19   mycroft 			}
    718  1.19   mycroft 			m->m_len = len = min(len, MCLBYTES);
    719   1.9   mycroft 		} else {
    720   1.9   mycroft 			/*
    721   1.9   mycroft 			 * Place initial small packet/header at end of mbuf.
    722   1.9   mycroft 			 */
    723   1.9   mycroft 			if (len < m->m_len) {
    724   1.9   mycroft 				if (top == 0 && len + max_linkhdr <= m->m_len)
    725   1.9   mycroft 					m->m_data += max_linkhdr;
    726   1.9   mycroft 				m->m_len = len;
    727   1.9   mycroft 			} else
    728   1.9   mycroft 				len = m->m_len;
    729   1.9   mycroft 		}
    730   1.9   mycroft 		if (copy)
    731  1.14  christos 			copy(cp, mtod(m, caddr_t), (size_t)len);
    732   1.9   mycroft 		else
    733  1.14  christos 			bcopy(cp, mtod(m, caddr_t), (size_t)len);
    734   1.9   mycroft 		cp += len;
    735   1.9   mycroft 		*mp = m;
    736   1.9   mycroft 		mp = &m->m_next;
    737   1.9   mycroft 		totlen -= len;
    738   1.9   mycroft 		if (cp == epkt)
    739   1.9   mycroft 			cp = buf;
    740   1.9   mycroft 	}
    741   1.9   mycroft 	return (top);
    742  1.18   thorpej }
    743  1.18   thorpej 
    744  1.18   thorpej /*
    745  1.18   thorpej  * Copy data from a buffer back into the indicated mbuf chain,
    746  1.18   thorpej  * starting "off" bytes from the beginning, extending the mbuf
    747  1.18   thorpej  * chain if necessary.
    748  1.18   thorpej  */
    749  1.18   thorpej void
    750  1.18   thorpej m_copyback(m0, off, len, cp)
    751  1.18   thorpej 	struct	mbuf *m0;
    752  1.27      matt 	int off;
    753  1.27      matt 	int len;
    754  1.18   thorpej 	caddr_t cp;
    755  1.18   thorpej {
    756  1.27      matt 	int mlen;
    757  1.27      matt 	struct mbuf *m = m0, *n;
    758  1.18   thorpej 	int totlen = 0;
    759  1.18   thorpej 
    760  1.18   thorpej 	if (m0 == 0)
    761  1.18   thorpej 		return;
    762  1.18   thorpej 	while (off > (mlen = m->m_len)) {
    763  1.18   thorpej 		off -= mlen;
    764  1.18   thorpej 		totlen += mlen;
    765  1.18   thorpej 		if (m->m_next == 0) {
    766  1.18   thorpej 			n = m_getclr(M_DONTWAIT, m->m_type);
    767  1.18   thorpej 			if (n == 0)
    768  1.18   thorpej 				goto out;
    769  1.18   thorpej 			n->m_len = min(MLEN, len + off);
    770  1.18   thorpej 			m->m_next = n;
    771  1.18   thorpej 		}
    772  1.18   thorpej 		m = m->m_next;
    773  1.18   thorpej 	}
    774  1.18   thorpej 	while (len > 0) {
    775  1.18   thorpej 		mlen = min (m->m_len - off, len);
    776  1.18   thorpej 		bcopy(cp, mtod(m, caddr_t) + off, (unsigned)mlen);
    777  1.18   thorpej 		cp += mlen;
    778  1.18   thorpej 		len -= mlen;
    779  1.18   thorpej 		mlen += off;
    780  1.18   thorpej 		off = 0;
    781  1.18   thorpej 		totlen += mlen;
    782  1.18   thorpej 		if (len == 0)
    783  1.18   thorpej 			break;
    784  1.18   thorpej 		if (m->m_next == 0) {
    785  1.18   thorpej 			n = m_get(M_DONTWAIT, m->m_type);
    786  1.18   thorpej 			if (n == 0)
    787  1.18   thorpej 				break;
    788  1.18   thorpej 			n->m_len = min(MLEN, len);
    789  1.18   thorpej 			m->m_next = n;
    790  1.18   thorpej 		}
    791  1.18   thorpej 		m = m->m_next;
    792  1.18   thorpej 	}
    793  1.18   thorpej out:	if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
    794  1.18   thorpej 		m->m_pkthdr.len = totlen;
    795   1.1       cgd }
    796