URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [ecos-2.0/] [packages/] [net/] [tcpip/] [v2_0/] [src/] [sys/] [kern/] [uipc_mbuf.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

//==========================================================================
//
//      sys/kern/uipc_mbuf.c
//
//     
//
//==========================================================================
//####BSDCOPYRIGHTBEGIN####
//
// -------------------------------------------
//
// Portions of this software may have been derived from OpenBSD or other sources,
// and are covered by the appropriate copyright disclaimers included herein.
//
// -------------------------------------------
//
//####BSDCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):    gthomas
// Contributors: gthomas
// Date:         2000-01-10
// Purpose:      
// Description:  
//              
//
//####DESCRIPTIONEND####
//
//==========================================================================
 
 
/*      $OpenBSD: uipc_mbuf.c,v 1.18 1999/12/05 07:30:31 angelos Exp $  */
/*      $NetBSD: uipc_mbuf.c,v 1.15.4.1 1996/06/13 17:11:44 cgd Exp $   */
 
/*
 * 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
 */
 
/*
%%% portions-copyright-nrl-95
Portions of this software are Copyright 1995-1998 by Randall Atkinson,
Ronald Lee, Daniel McDonald, Bao Phan, and Chris Winters. All Rights
Reserved. All rights under this copyright have been assigned to the US
Naval Research Laboratory (NRL). The NRL Copyright Notice and License
Agreement Version 1.1 (January 17, 1995) applies to these portions of the
software.
You should have received a copy of the license with this software. If you
didn't get a copy, you may request one from <license@ipv6.nrl.navy.mil>.
*/
 
#include <sys/param.h>
#ifndef __ECOS
#include <sys/systm.h>
#include <sys/proc.h>
#endif
#include <sys/malloc.h>
#ifndef __ECOS
#include <sys/map.h>
#endif
#define MBTYPES
#include <sys/mbuf.h>
#include <sys/kernel.h>
#ifndef __ECOS
#include <sys/syslog.h>
#endif
#include <sys/domain.h>
#include <sys/protosw.h>
 
#include <machine/cpu.h>
 
#ifndef __ECOS
#include <vm/vm.h>
#endif
 
#if defined(UVM)
#include <uvm/uvm_extern.h>
#endif
 
#ifndef __ECOS
extern  vm_map_t mb_map;
#endif
struct  mbuf *mbutl;
char    *mclrefcnt;
int     needqueuedrain;
 
#ifdef __ECOS
extern void setsoftnet(void);
extern void *cyg_net_cluster_alloc(void);
#endif
 
/* Declarations of variables move from mbuf.h to keep g++ happy */
#ifdef __ECOS
struct mbstat mbstat;
union  mcluster *mclfree;
int    max_linkhdr;                    /* largest link-level header */
int    max_protohdr;                   /* largest protocol header */
int    max_hdr;                        /* largest link+protocol header */
int    max_datalen;                    /* MHLEN - max_hdr */
#ifdef MBTYPES
int mbtypes[] = {                              /* XXX */
       M_FREE,         /* MT_FREE      0          should be on free list */
       M_MBUF,         /* MT_DATA      1          dynamic (data) allocation */
       M_MBUF,         /* MT_HEADER    2          packet header */
       M_SOCKET,       /* MT_SOCKET    3          socket structure */
       M_PCB,          /* MT_PCB       4          protocol control block */
       M_RTABLE,       /* MT_RTABLE    5          routing tables */
       M_HTABLE,       /* MT_HTABLE    6          IMP host tables */
       0,              /* MT_ATABLE    7          address resolution tables */
       M_MBUF,         /* MT_SONAME    8          socket name */
       0,              /*              9 */
       M_SOOPTS,       /* MT_SOOPTS    10         socket options */
       M_FTABLE,       /* MT_FTABLE    11         fragment reassembly header */
       M_MBUF,         /* MT_RIGHTS    12         access rights */
       M_IFADDR,       /* MT_IFADDR    13         interface address */
       M_MBUF,         /* MT_CONTROL   14         extra-data protocol message */
       M_MBUF,         /* MT_OOBDATA   15         expedited data  */
#ifdef DATAKIT
       25, 26, 27, 28, 29, 30, 31, 32          /* datakit ugliness */
#endif
};
#endif
#endif // __ECOS
 
void
mbinit()
{
        int s;
 
        s = splimp();
#ifdef __ECOS
        if (m_clalloc(1, M_DONTWAIT) == 0)
#else
        if (m_clalloc(max(4096 / CLBYTES, 1), M_DONTWAIT) == 0)
#endif
                goto bad;
        splx(s);
        return;
bad:
        panic("mbinit");
}
 
/*
 * Allocate some number of mbuf clusters
 * and place on cluster free list.
 * Must be called at splimp.
 */
/* ARGSUSED */
int
m_clalloc(ncl, nowait)
        register int ncl;
        int nowait;
{
#ifdef __ECOS
        caddr_t p;
        int i;
 
        if (ncl != 1) {
            panic("Allocate multiple clusters!");
        }
        p = (caddr_t)cyg_net_cluster_alloc();
        if (p == NULL) {
                m_reclaim();
                return (mclfree != NULL);
        }
        for (i = 0; i < ncl; i++) {
                ((union mcluster *)p)->mcl_next = mclfree;
                mclfree = (union mcluster *)p;
                p += MCLBYTES;
                mbstat.m_clfree++;
        }
        mbstat.m_clusters += ncl;
        return (1);
#else // __ECOS
        volatile static struct timeval lastlogged;
        struct timeval curtime, logdiff;
        register caddr_t p;
        register int i;
        int npg, s;
 
        npg = ncl * CLSIZE;
#if defined(UVM)
        p = (caddr_t)uvm_km_kmemalloc(mb_map, uvmexp.mb_object, ctob(npg),
            nowait ? 0 : UVM_KMF_NOWAIT);
#else
        p = (caddr_t)kmem_malloc(mb_map, ctob(npg), !nowait);
#endif
        if (p == NULL) {
                s = splclock();
                curtime = time;
                splx(s);
                timersub(&curtime, &lastlogged, &logdiff);
                if (logdiff.tv_sec >= 60) {
                        lastlogged = curtime;
                        log(LOG_ERR, "mb_map full\n");
                }
                m_reclaim();
                return (mclfree != NULL);
        }
        ncl = ncl * CLBYTES / MCLBYTES;
        for (i = 0; i < ncl; i++) {
                ((union mcluster *)p)->mcl_next = mclfree;
                mclfree = (union mcluster *)p;
                p += MCLBYTES;
                mbstat.m_clfree++;
        }
        mbstat.m_clusters += ncl;
        return (1);
#endif // __ECOS
}
 
/*
 * When MGET failes, ask protocols to free space when short of memory,
 * then re-attempt to allocate an mbuf.
 */
struct mbuf *
m_retry(i, t)
        int i, t;
{
        register struct mbuf *m;
 
        if (i & M_DONTWAIT) {
                needqueuedrain = 1;
                setsoftnet();
                return (NULL);
        }
        m_reclaim();
#define m_retry(i, t)   NULL
        MGET(m, i, t);
#undef m_retry
        return (m);
}
 
/*
 * As above; retry an MGETHDR.
 */
struct mbuf *
m_retryhdr(i, t)
        int i, t;
{
        register struct mbuf *m;
 
        if (i & M_DONTWAIT) {
                needqueuedrain = 1;
                setsoftnet();
                return (NULL);
        }
        m_reclaim();
#define m_retryhdr(i, t) NULL
        MGETHDR(m, i, t);
#undef m_retryhdr
        return (m);
}
 
void
m_reclaim()
{
        register struct domain *dp;
        register struct protosw *pr;
        int s = splimp();
 
        needqueuedrain = 0;
        for (dp = domains; dp; dp = dp->dom_next)
                for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
                        if (pr->pr_drain)
                                (*pr->pr_drain)();
        splx(s);
        mbstat.m_drain++;
}
 
/*
 * Space allocation routines.
 * These are also available as macros
 * for critical paths.
 */
struct mbuf *
m_get(nowait, type)
        int nowait, type;
{
        register struct mbuf *m;
 
        MGET(m, nowait, type);
        return (m);
}
 
struct mbuf *
m_gethdr(nowait, type)
        int nowait, type;
{
        register struct mbuf *m;
 
        MGETHDR(m, nowait, type);
        return (m);
}
 
struct mbuf *
m_getclr(nowait, type)
        int nowait, type;
{
        register struct mbuf *m;
 
        MGET(m, nowait, type);
        if (m == NULL)
                return (NULL);
        bzero(mtod(m, caddr_t), MLEN);
        return (m);
}
 
struct mbuf *
m_free(m)
        struct mbuf *m;
{
        register struct mbuf *n;
 
        MFREE(m, n);
        return (n);
}
 
void
m_freem(m)
        register struct mbuf *m;
{
        register struct mbuf *n;
 
        if (m == NULL)
                return;
        do {
                MFREE(m, n);
        } while ((m = n) != NULL);
}
 
/*
 * Mbuffer utility routines.
 */
 
/*
 * Lesser-used path for M_PREPEND:
 * allocate new mbuf to prepend to chain,
 * copy junk along.
 */
struct mbuf *
m_prepend(m, len, how)
        register struct mbuf *m;
        int len, how;
{
        struct mbuf *mn;
 
        MGET(mn, how, m->m_type);
        if (mn == NULL) {
                m_freem(m);
                return (NULL);
        }
        if (m->m_flags & M_PKTHDR) {
                M_COPY_PKTHDR(mn, m);
                m->m_flags &= ~M_PKTHDR;
        }
        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_WAIT/M_DONTWAIT from caller.
 */
int MCFail;
 
struct mbuf *
m_copym(m, off0, len, wait)
        register struct mbuf *m;
        int off0, wait;
        register int len;
{
        register struct mbuf *n, **np;
        register int off = off0;
        struct mbuf *top;
        int copyhdr = 0;
 
        if (off < 0)
                panic("m_copym: off %d < 0", off);
        if (len < 0)
                panic("m_copym: len %d < 0", len);
        if (off == 0 && m->m_flags & M_PKTHDR)
                copyhdr = 1;
        while (off > 0) {
                if (m == NULL)
                        panic("m_copym: null mbuf");
                if (off < m->m_len)
                        break;
                off -= m->m_len;
                m = m->m_next;
        }
        np = &top;
        top = NULL;
        while (len > 0) {
                if (m == NULL) {
                        if (len != M_COPYALL)
                                panic("m_copym: %d not M_COPYALL", len);
                        break;
                }
                MGET(n, wait, m->m_type);
                *np = n;
                if (n == NULL)
                        goto nospace;
                if (copyhdr) {
                        M_COPY_PKTHDR(n, m);
                        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;
                        if (!m->m_ext.ext_ref)
                                mclrefcnt[mtocl(m->m_ext.ext_buf)]++;
                        else
                                (*(m->m_ext.ext_ref))(m);
                        n->m_ext = m->m_ext;
                        n->m_flags |= M_EXT;
                } else
                        bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
                            (unsigned)n->m_len);
                if (len != M_COPYALL)
                        len -= n->m_len;
                off = 0;
                m = m->m_next;
                np = &n->m_next;
        }
        if (top == NULL)
                MCFail++;
        return (top);
nospace:
        m_freem(top);
        MCFail++;
        return (NULL);
}
 
/*
 * m_copym2() is like m_copym(), except it COPIES cluster mbufs, instead
 * of merely bumping the reference count.
 */
struct mbuf *
m_copym2(m, off0, len, wait)
        register struct mbuf *m;
        int off0, wait;
        register int len;
{
        register struct mbuf *n, **np;
        register int off = off0;
        struct mbuf *top;
        int copyhdr = 0;
 
        if (len < 0)
                panic("m_copym2: len %d < 0", len);
        if (off < 0)
                panic("m_copym2: off %d < 0", off);
        if (off == 0 && m->m_flags & M_PKTHDR)
                copyhdr = 1;
        while (off > 0) {
                if (m == NULL)
                        panic("m_copym2: null mbuf");
                if (off < m->m_len)
                        break;
                off -= m->m_len;
                m = m->m_next;
        }
        np = &top;
        top = NULL;
        while (len > 0) {
                if (m == NULL) {
                        if (len != M_COPYALL)
                                panic("m_copym2: %d != M_COPYALL", len);
                        break;
                }
                MGET(n, wait, m->m_type);
                *np = n;
                if (n == NULL)
                        goto nospace;
                if (copyhdr) {
                        M_COPY_PKTHDR(n, m);
                        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_len > MHLEN)) {
                        /* This is a cheesy hack. */
                        MCLGET(n, wait);
                        if (n->m_flags & M_EXT)
                                bcopy(mtod(m, caddr_t) + off, mtod(n, caddr_t),
                                    (unsigned)n->m_len);
                        else
                                goto nospace;
                } else
                        bcopy(mtod(m, caddr_t) + off, mtod(n, caddr_t),
                            (unsigned)n->m_len);
                if (len != M_COPYALL)
                        len -= n->m_len;
                off = 0;
                m = m->m_next;
                np = &n->m_next;
        }
        if (top == NULL)
                MCFail++;
        return (top);
nospace:
        m_freem(top);
        MCFail++;
        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(m, off, len, cp)
        register struct mbuf *m;
        register int off;
        register int len;
        caddr_t cp;
{
        register unsigned count;
 
        if (off < 0)
                panic("m_copydata: off %d < 0", off);
        if (len < 0)
                panic("m_copydata: len %d < 0", len);
        while (off > 0) {
                if (m == NULL)
                        panic("m_copydata: null mbuf in skip");
                if (off < m->m_len)
                        break;
                off -= m->m_len;
                m = m->m_next;
        }
        while (len > 0) {
                if (m == NULL)
                        panic("m_copydata: null mbuf");
                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;
        }
}
 
/*
 * 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(m, n)
        register struct mbuf *m, *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(mp, req_len)
        struct mbuf *mp;
        int req_len;
{
        register int len = req_len;
        register struct mbuf *m;
        register 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 == NULL)
                                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->m_next) != NULL)
                        m->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.
 */
int MPFail;
 
struct mbuf *
m_pullup(n, len)
        register struct mbuf *n;
        int len;
{
        register struct mbuf *m;
        register 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_COPY_PKTHDR(m, n);
                        n->m_flags &= ~M_PKTHDR;
                }
        }
        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,
                    (unsigned)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);
        MPFail++;
        return (NULL);
}
 
/*
 * m_pullup2() works like m_pullup, save that len can be <= MCLBYTES.
 * m_pullup2() only works on values of len such that MHLEN < len <= MCLBYTES,
 * it calls m_pullup() for values <= MHLEN.  It also only coagulates the
 * reqested number of bytes.  (For those of us who expect unwieldly option
 * headers.
 *
 * KEBE SAYS:  Remember that dtom() calls with data in clusters does not work!
 */
struct mbuf *
m_pullup2(n, len)
        register struct mbuf *n;
        int len;
{
        register struct mbuf *m;
        register int count;
        int space;
        if (len <= MHLEN)
                return m_pullup(n, len);
 
        if ((n->m_flags & M_EXT) != 0 &&
            n->m_data + len < &n->m_data[MCLBYTES] && n->m_next) {
                if (n->m_len >= len)
                        return (n);
                m = n;
                n = n->m_next;
                len -= m->m_len;
        } else {
                if (len > MCLBYTES)
                        goto bad;
                MGET(m, M_DONTWAIT, n->m_type);
                if (m == NULL)
                        goto bad;
                MCLGET(m, M_DONTWAIT);
                if ((m->m_flags & M_EXT) == 0)
                        goto bad;
                m->m_len = 0;
                if (n->m_flags & M_PKTHDR) {
                        /* M_COPY_PKTHDR(m, n);*//* Too many adverse side effects. */
                        m->m_pkthdr = n->m_pkthdr;
                        m->m_flags = (n->m_flags & M_COPYFLAGS) | M_EXT;
                        n->m_flags &= ~M_PKTHDR;
                        /* n->m_data is cool. */
                }
        }
 
        do {
                count = min(len, n->m_len);
                bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
                    (unsigned)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);
        MPFail++;
        return (NULL);
}
 
/*
 * Inject a new mbuf chain of length siz in mbuf chain m0 at
 * position len0. Returns a pointer to the first injected mbuf, or
 * NULL on failure (m0 is left undisturbed). Note that if there is
 * enough space for an object of size siz in the appropriate position,
 * no memory will be allocated. Also, there will be no data movement in
 * the first len0 bytes (pointers to that will remain valid).
 *
 * XXX It is assumed that siz is less than the size of an mbuf at the moment.
 */
struct mbuf *
m_inject(m0, len0, siz, wait)
        register struct mbuf *m0;
        int len0, siz, wait;
{
        register struct mbuf *m, *n, *n2 = NULL, *n3;
        unsigned len = len0, remain;
 
        if ((siz >= MHLEN) || (len0 <= 0))
                return (NULL);
        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 (remain == 0) {
                if ((m->m_next) &&  (M_LEADINGSPACE(m->m_next) >= siz)) {
                        m->m_next->m_len += siz;
                        m0->m_pkthdr.len += siz;
                        m->m_next->m_data -= siz;
                        return m->m_next;
                }
        } else {
                n2 = m_copym2(m, len, remain, wait);
                if (n2 == NULL)
                        return (NULL);
        }
 
        MGET(n, wait, MT_DATA);
        if (n == NULL) {
                if (n2)
                        m_freem(n2);
                return (NULL);
        }
 
        n->m_len = siz;
        m0->m_pkthdr.len += siz;
        m->m_len -= remain; /* Trim */
        if (n2) {
                for (n3 = n; n3->m_next != NULL; n3 = n3->m_next)
                        ;
                n3->m_next = n2;
        } else
                n3 = n;
        for (; n3->m_next != NULL; n3 = n3->m_next)
                ;
        n3->m_next = m->m_next;
        m->m_next = n;
        return n;
}
 
/*
 * 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.
 */
struct mbuf *
m_split(m0, len0, wait)
        register struct mbuf *m0;
        int len0, wait;
{
        register struct mbuf *m, *n;
        unsigned len = len0, remain, olen;
 
        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;
                olen = m0->m_pkthdr.len;
                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);
                                m0->m_pkthdr.len = olen;
                                return (NULL);
                        } else
                                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;
                if(!m->m_ext.ext_ref)
                        mclrefcnt[mtocl(m->m_ext.ext_buf)]++;
                else
                        (*(m->m_ext.ext_ref))(m);
                m->m_ext.ext_size = 0; /* For Accounting XXXXXX danger */
                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.
 */
struct mbuf *
m_devget(buf, totlen, off0, ifp, copy)
        char *buf;
        int totlen, off0;
        struct ifnet *ifp;
        void (*copy) __P((const void *, void *, size_t));
{
        register struct mbuf *m;
        struct mbuf *top = NULL, **mp = &top;
        register int off = off0, len;
        register char *cp;
        char *epkt;
 
        cp = buf;
        epkt = cp + totlen;
        if (off) {
                /*
                 * If 'off' is non-zero, packet is trailer-encapsulated,
                 * so we have to skip the type and length fields.
                 */
                cp += off + 2 * sizeof(u_int16_t);
                totlen -= 2 * sizeof(u_int16_t);
        }
        MGETHDR(m, M_DONTWAIT, MT_DATA);
        if (m == NULL)
                return (NULL);
        m->m_pkthdr.rcvif = ifp;
        m->m_pkthdr.len = totlen;
        m->m_len = MHLEN;
 
        while (totlen > 0) {
                if (top != NULL) {
                        MGET(m, M_DONTWAIT, MT_DATA);
                        if (m == NULL) {
                                m_freem(top);
                                return (NULL);
                        }
                        m->m_len = MLEN;
                }
                len = min(totlen, epkt - cp);
                if (len >= MINCLSIZE) {
                        MCLGET(m, M_DONTWAIT);
                        if (m->m_flags & M_EXT)
                                m->m_len = len = min(len, MCLBYTES);
                        else
                                len = m->m_len;
                } else {
                        /*
                         * Place initial small packet/header at end of mbuf.
                         */
                        if (len < m->m_len) {
                                if (top == NULL &&
                                    len + max_linkhdr <= m->m_len)
                                        m->m_data += max_linkhdr;
                                m->m_len = len;
                        } else
                                len = m->m_len;
                }
                if (copy)
                        copy(cp, mtod(m, caddr_t), (size_t)len);
                else
                        bcopy(cp, mtod(m, caddr_t), (size_t)len);
                cp += len;
                *mp = m;
                mp = &m->m_next;
                totlen -= len;
                if (cp == epkt)
                        cp = buf;
        }
        return (top);
}
 
void
m_zero(m)
        struct mbuf *m;
{
    while (m) {
        if (m->m_flags & M_PKTHDR)
            bzero((unsigned char *)m + sizeof(struct m_hdr) +
                  sizeof(struct pkthdr), MHLEN);
        else
            bzero((unsigned char *)m + sizeof(struct m_hdr), MLEN);
        if ((m->m_flags & M_EXT) &&
            (m->m_ext.ext_free == NULL) &&
            !mclrefcnt[mtocl((m)->m_ext.ext_buf)])
            bzero(m->m_ext.ext_buf, m->m_ext.ext_size);
        m = m->m_next;
    }
}
 
/*
 * Apply function f to the data in an mbuf chain starting "off" bytes from the
 * beginning, continuing for "len" bytes.
 */
int
m_apply(m, off, len, f, fstate)
        struct mbuf *m;
        int off;
        int len;
        /* fstate, data, len */
        int (*f)(caddr_t, caddr_t, unsigned int);
        caddr_t fstate;
{
        int rval;
        unsigned int count;
 
        if (len < 0)
                panic("m_apply: len %d < 0", len);
        if (off < 0)
                panic("m_apply: off %d < 0", off);
        while (off > 0) {
                if (m == NULL)
                        panic("m_apply: null mbuf in skip");
                if (off < m->m_len)
                        break;
                off -= m->m_len;
                m = m->m_next;
        }
        while (len > 0) {
                if (m == NULL)
                        panic("m_apply: null mbuf");
                count = min(m->m_len - off, len);
 
                rval = f(fstate, mtod(m, caddr_t) + off, count);
                if (rval)
                        return (rval);
 
                len -= count;
                off = 0;
                m = m->m_next;
        }
 
        return (0);
}
 
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [ecos-2.0/] [packages/] [net/] [tcpip/] [v2_0/] [src/] [sys/] [kern/] [uipc_mbuf.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1254	phoenix	`//==========================================================================`
2			`//`
3			`// sys/kern/uipc_mbuf.c`
4			`//`
5			`//`
6			`//`
7			`//==========================================================================`
8			`//####BSDCOPYRIGHTBEGIN####`
9			`//`
10			`// -------------------------------------------`
11			`//`
12			`// Portions of this software may have been derived from OpenBSD or other sources,`
13			`// and are covered by the appropriate copyright disclaimers included herein.`
14			`//`
15			`// -------------------------------------------`
16			`//`
17			`//####BSDCOPYRIGHTEND####`
18			`//==========================================================================`
19			`//#####DESCRIPTIONBEGIN####`
20			`//`
21			`// Author(s): gthomas`
22			`// Contributors: gthomas`
23			`// Date: 2000-01-10`
24			`// Purpose:`
25			`// Description:`
26			`//`
27			`//`
28			`//####DESCRIPTIONEND####`
29			`//`
30			`//==========================================================================`
31
32
33			`/* $OpenBSD: uipc_mbuf.c,v 1.18 1999/12/05 07:30:31 angelos Exp $ */`
34			`/* $NetBSD: uipc_mbuf.c,v 1.15.4.1 1996/06/13 17:11:44 cgd Exp $ */`
35
36			`/*`
37			`* Copyright (c) 1982, 1986, 1988, 1991, 1993`
38			`* The Regents of the University of California. All rights reserved.`
39			`*`
40			`* Redistribution and use in source and binary forms, with or without`