mbuf.c revision 348ab4dfd43983ccefcd45aa3dd53ab577aaa382
/*
* Copyright (c) 1995 Danny Gasparovski
*
* Please read the file COPYRIGHT for the
* terms and conditions of the copyright.
*/
/*
* mbuf's in SLiRP are much simpler than the real mbufs in
* FreeBSD. They are fixed size, determined by the MTU,
* so that one whole packet can fit. Mbuf's cannot be
* chained together. If there's more data than the mbuf
* could hold, an external malloced buffer is pointed to
* by m_ext (and the data pointers) and M_EXT is set in
* the flags
*/
#include <slirp.h>
#define MBUF_ZONE_SIZE 100
{
int i;
struct mbuf *m;
{
LogRel(("NAT: can't allocate new zone\n"));
return -1;
}
{
LogRel(("NAT: can't allocate zone descriptor\n"));
return -1;
}
for (i = 0; i < MBUF_ZONE_SIZE; ++i)
{
#ifdef M_BUF_DEBUG
#endif
}
pData->mbuf_zone_count++;
return 0;
}
{
struct mbuf *m;
int i;
void *zone;
{
for (i = 0; i < MBUF_ZONE_SIZE; ++i)
{
}
}
}
void
{
int rc = 0;
mbuf_alloced = 0;
#if 1
#endif
}
void
{
/*
* Find a nice value for msize
*/
+ sizeof(struct m_hdr) + sizeof(void *) /*pointer to the backstore*/
+ if_maxlinkhdr ;
}
#ifdef m_get
#endif
#ifdef m_free
#endif
/*
* Get an mbuf from the free list, if there are none
* malloc one
*
* Because fragmentation can occur if we alloc new mbufs and
* free old mbufs, we mark all mbufs above mbuf_thresh as M_DOFREE,
* which tells m_free to actually free() it
*/
struct mbuf *
{
register struct mbuf *m;
int flags = 0;
int rc = 0;
DEBUG_CALL("m_get");
{
#if 1
if (rc == 0)
goto recheck_zone;
AssertMsgFailed(("No mbufs on free list\n"));
return NULL;
#else
if (m == NULL)
goto end_error;
mbuf_alloced++;
if (mbuf_alloced > mbuf_thresh)
if (mbuf_alloced > mbuf_max)
#endif
}
else
{
m = m_freelist.m_next;
}
/* Insert it in the used list */
mbuf_alloced++;
#if 0
{
}
#endif
/* Initialise it */
m->m_len = 0;
m->m_nextpkt = 0;
m->m_prevpkt = 0;
DEBUG_ARG("m = %lx", (long )m);
return m;
}
void
{
int rc;
DEBUG_CALL("m_free");
DEBUG_ARG("m = %lx", (long )m);
mbuf_alloced--;
if(m)
{
/* Remove from m_usedlist */
if (m->m_flags & M_USEDLIST)
/* If it's M_EXT, free() it */
/*
* Either free() it or put it on the free list
*/
{
#if 1
#else
RTMemFree(m);
#endif
mbuf_alloced--;
}
else if ((m->m_flags & M_FREELIST) == 0)
{
}
} /* if(m) */
}
#include "mbuf.h"
/*
* Copy data from one mbuf to the end of
* the other.. if result is too big for one mbuf, malloc()
* an M_EXT data segment
*/
void
{
/*
* If there's no room, realloc
*/
if (M_FREEROOM(m) < n->m_len)
}
/* make m size bytes large */
void
{
int datasize;
/* some compiles throw up on gotos. This one we can fake. */
return;
{
void *pvNew;
if (pvNew)
return; /** @todo better error reporting. */
}
else
{
char *dat;
if (!dat)
return; /** @todo better error reporting. */
}
}
void
{
if (m == NULL)
return;
if (len >= 0)
{
/* Trim from head */
}
else
{
/* Trim from tail */
}
}
/*
* Copy len bytes from m, starting off bytes into n
*/
int
{
if (len > M_FREEROOM(n))
return -1;
return 0;
}
/*
* Given a pointer into an mbuf, return the mbuf
* XXX This is a kludge, I should eliminate the need for it
* Fortunately, it's not used often
*/
struct mbuf *
{
struct mbuf *m;
DEBUG_CALL("dtom");
/* bug corrected for M_EXT buffers */
{
{
return m;
}
else
{
return m;
}
}
return (struct mbuf *)0;
}
#ifndef VBOX_WITH_SLIRP_BSD_MBUF
/**
* Interface that DrvNAT.cpp uses for allocating a buffer.
*
* @returns Opaque m_buf pointer.
*
* @param pData The NAT state.
* @param cbMin The minimum buffer size.
* @param ppvBuf Where to return the pointer to the start of the data
* buffer.
* @param pcbBuf Where to return the actual buffer size.
*/
{
if (!m)
return NULL;
if (cbMin > M_FREEROOM(m))
{
{
return NULL;
}
}
*pcbBuf = M_FREEROOM(m);
return m;
}
{
}
{
char *c;
if (cbBuf > M_FREEROOM(m))
{
cbBuf = M_FREEROOM(m);
}
c = mtod(m, char *);
}
#endif /* VBOX_WITH_SLIRP_BSD_MBUF */