mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-22 11:17:19 +00:00
Code Issues Releases Activity
57e3d9cf76
freebsd/sys/kern/subr_mchain.c
Bosko Milekic 9e7225808e Make m_getm() always return the top of the newly allocated chain, as 
opposed to returning the top of the old chain when there was one and
the top of the newly allocated chain if there was no old chain.

Actually, it should be noted that prior to this fix, although the
comment above m_getm() advertised that m_getm() would return the
top of the old chain (if an old chain was being passed in) it
actually [wrongly] was returning the tail mbuf in the old chain
instead.  This is a bug but since the one use of m_getm() in
the tree luckily did not depend on the behavior, it happened
to work out without notice.

Harti Brandt pointed out that the advertised behavior was actually
not the real behavior and so this change makes m_getm() ALWAYS
return the newly allocated chain (and fixes the comment).  This
is less confusing and is the best course of action as then the
caller is always able to have both a reference to the top of
the original chain (because it's passing it in in the call) and
a reference to the newly attached chain.  Although the API is
slightly modified, I don't think that any third-party code uses
m_getm() and if it does, it surely can't be working properly
because the old behavior was bogus.

API bug pointed out by: Harti Brandt <brandt@fokus.fraunhofer.de>
2003-02-14 16:50:13 +00:00

543 lines
11 KiB
C
Raw Blame History

/*
* Copyright (c) 2000, 2001 Boris Popov
* 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 Boris Popov.
* 4. Neither the name of the author nor the names of any co-contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/endian.h>
#include <sys/errno.h>
#include <sys/mbuf.h>
#include <sys/module.h>
#include <sys/uio.h>
#include <sys/mchain.h>
MODULE_VERSION(libmchain, 1);
#define MBERROR(format, ...) printf("%s(%d): "format, __func__ , \
__LINE__ , ## __VA_ARGS__)
#define MBPANIC(format, ...) printf("%s(%d): "format, __func__ , \
__LINE__ , ## __VA_ARGS__)
/*
* Various helper functions
*/
int
mb_init(struct mbchain *mbp)
{
struct mbuf *m;
m = m_gethdr(0, MT_DATA);
if (m == NULL)
return ENOBUFS;
m->m_len = 0;
mb_initm(mbp, m);
return 0;
}
void
mb_initm(struct mbchain *mbp, struct mbuf *m)
{
bzero(mbp, sizeof(*mbp));
mbp->mb_top = mbp->mb_cur = m;
mbp->mb_mleft = M_TRAILINGSPACE(m);
}
void
mb_done(struct mbchain *mbp)
{
if (mbp->mb_top) {
m_freem(mbp->mb_top);
mbp->mb_top = NULL;
}
}
struct mbuf *
mb_detach(struct mbchain *mbp)
{
struct mbuf *m;
m = mbp->mb_top;
mbp->mb_top = NULL;
return m;
}
int
mb_fixhdr(struct mbchain *mbp)
{
return mbp->mb_top->m_pkthdr.len = m_fixhdr(mbp->mb_top);
}
/*
* Check if object of size 'size' fit to the current position and
* allocate new mbuf if not. Advance pointers and increase length of mbuf(s).
* Return pointer to the object placeholder or NULL if any error occured.
* Note: size should be <= MLEN
*/
caddr_t
mb_reserve(struct mbchain *mbp, int size)
{
struct mbuf *m, *mn;
caddr_t bpos;
if (size > MLEN)
panic("mb_reserve: size = %d\n", size);
m = mbp->mb_cur;
if (mbp->mb_mleft < size) {
mn = m_get(0, MT_DATA);
if (mn == NULL)
return NULL;
mbp->mb_cur = m->m_next = mn;
m = mn;
m->m_len = 0;
mbp->mb_mleft = M_TRAILINGSPACE(m);
}
mbp->mb_mleft -= size;
mbp->mb_count += size;
bpos = mtod(m, caddr_t) + m->m_len;
m->m_len += size;
return bpos;
}
int
mb_put_uint8(struct mbchain *mbp, u_int8_t x)
{
return mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM);
}
int
mb_put_uint16be(struct mbchain *mbp, u_int16_t x)
{
x = htobe16(x);
return mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM);
}
int
mb_put_uint16le(struct mbchain *mbp, u_int16_t x)
{
x = htole16(x);
return mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM);
}
int
mb_put_uint32be(struct mbchain *mbp, u_int32_t x)
{
x = htobe32(x);
return mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM);
}
int
mb_put_uint32le(struct mbchain *mbp, u_int32_t x)
{
x = htole32(x);
return mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM);
}
int
mb_put_int64be(struct mbchain *mbp, int64_t x)
{
x = htobe64(x);
return mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM);
}
int
mb_put_int64le(struct mbchain *mbp, int64_t x)
{
x = htole64(x);
return mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM);
}
int
mb_put_mem(struct mbchain *mbp, c_caddr_t source, int size, int type)
{
struct mbuf *m;
caddr_t dst;
c_caddr_t src;
int cplen, error, mleft, count;
m = mbp->mb_cur;
mleft = mbp->mb_mleft;
while (size > 0) {
if (mleft == 0) {
if (m->m_next == NULL) {
m = m_getm(m, size, 0, MT_DATA);
if (m == NULL)
return ENOBUFS;
}
mleft = M_TRAILINGSPACE(m);
continue;
}
cplen = mleft > size ? size : mleft;
dst = mtod(m, caddr_t) + m->m_len;
switch (type) {
case MB_MCUSTOM:
error = mbp->mb_copy(mbp, source, dst, cplen);
if (error)
return error;
break;
case MB_MINLINE:
for (src = source, count = cplen; count; count--)
*dst++ = *src++;
break;
case MB_MSYSTEM:
bcopy(source, dst, cplen);
break;
case MB_MUSER:
error = copyin(source, dst, cplen);
if (error)
return error;
break;
case MB_MZERO:
bzero(dst, cplen);
break;
}
size -= cplen;
source += cplen;
m->m_len += cplen;
mleft -= cplen;
mbp->mb_count += cplen;
}
mbp->mb_cur = m;
mbp->mb_mleft = mleft;
return 0;
}
int
mb_put_mbuf(struct mbchain *mbp, struct mbuf *m)
{
mbp->mb_cur->m_next = m;
while (m) {
mbp->mb_count += m->m_len;
if (m->m_next == NULL)
break;
m = m->m_next;
}
mbp->mb_mleft = M_TRAILINGSPACE(m);
mbp->mb_cur = m;
return 0;
}
/*
* copies a uio scatter/gather list to an mbuf chain.
*/
int
mb_put_uio(struct mbchain *mbp, struct uio *uiop, int size)
{
long left;
int mtype, error;
mtype = (uiop->uio_segflg == UIO_SYSSPACE) ? MB_MSYSTEM : MB_MUSER;
while (size > 0 && uiop->uio_resid) {
if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
return EFBIG;
left = uiop->uio_iov->iov_len;
if (left == 0) {
uiop->uio_iov++;
uiop->uio_iovcnt--;
continue;
}
if (left > size)
left = size;
error = mb_put_mem(mbp, uiop->uio_iov->iov_base, left, mtype);
if (error)
return error;
uiop->uio_offset += left;
uiop->uio_resid -= left;
uiop->uio_iov->iov_base =
(char *)uiop->uio_iov->iov_base + left;
uiop->uio_iov->iov_len -= left;
size -= left;
}
return 0;
}
/*
* Routines for fetching data from an mbuf chain
*/
int
md_init(struct mdchain *mdp)
{
struct mbuf *m;
m = m_gethdr(0, MT_DATA);
if (m == NULL)
return ENOBUFS;
m->m_len = 0;
md_initm(mdp, m);
return 0;
}
void
md_initm(struct mdchain *mdp, struct mbuf *m)
{
bzero(mdp, sizeof(*mdp));
mdp->md_top = mdp->md_cur = m;
mdp->md_pos = mtod(m, u_char*);
}
void
md_done(struct mdchain *mdp)
{
if (mdp->md_top) {
m_freem(mdp->md_top);
mdp->md_top = NULL;
}
}
/*
* Append a separate mbuf chain. It is caller responsibility to prevent
* multiple calls to fetch/record routines.
*/
void
md_append_record(struct mdchain *mdp, struct mbuf *top)
{
struct mbuf *m;
if (mdp->md_top == NULL) {
md_initm(mdp, top);
return;
}
m = mdp->md_top;
while (m->m_nextpkt)
m = m->m_nextpkt;
m->m_nextpkt = top;
top->m_nextpkt = NULL;
return;
}
/*
* Put next record in place of existing
*/
int
md_next_record(struct mdchain *mdp)
{
struct mbuf *m;
if (mdp->md_top == NULL)
return ENOENT;
m = mdp->md_top->m_nextpkt;
md_done(mdp);
if (m == NULL)
return ENOENT;
md_initm(mdp, m);
return 0;
}
int
md_get_uint8(struct mdchain *mdp, u_int8_t *x)
{
return md_get_mem(mdp, x, 1, MB_MINLINE);
}
int
md_get_uint16(struct mdchain *mdp, u_int16_t *x)
{
return md_get_mem(mdp, (caddr_t)x, 2, MB_MINLINE);
}
int
md_get_uint16le(struct mdchain *mdp, u_int16_t *x)
{
u_int16_t v;
int error = md_get_uint16(mdp, &v);
if (x != NULL)
*x = le16toh(v);
return error;
}
int
md_get_uint16be(struct mdchain *mdp, u_int16_t *x) {
u_int16_t v;
int error = md_get_uint16(mdp, &v);
if (x != NULL)
*x = be16toh(v);
return error;
}
int
md_get_uint32(struct mdchain *mdp, u_int32_t *x)
{
return md_get_mem(mdp, (caddr_t)x, 4, MB_MINLINE);
}
int
md_get_uint32be(struct mdchain *mdp, u_int32_t *x)
{
u_int32_t v;
int error;
error = md_get_uint32(mdp, &v);
if (x != NULL)
*x = be32toh(v);
return error;
}
int
md_get_uint32le(struct mdchain *mdp, u_int32_t *x)
{
u_int32_t v;
int error;
error = md_get_uint32(mdp, &v);
if (x != NULL)
*x = le32toh(v);
return error;
}
int
md_get_int64(struct mdchain *mdp, int64_t *x)
{
return md_get_mem(mdp, (caddr_t)x, 8, MB_MINLINE);
}
int
md_get_int64be(struct mdchain *mdp, int64_t *x)
{
int64_t v;
int error;
error = md_get_int64(mdp, &v);
if (x != NULL)
*x = be64toh(v);
return error;
}
int
md_get_int64le(struct mdchain *mdp, int64_t *x)
{
int64_t v;
int error;
error = md_get_int64(mdp, &v);
if (x != NULL)
*x = le64toh(v);
return error;
}
int
md_get_mem(struct mdchain *mdp, caddr_t target, int size, int type)
{
struct mbuf *m = mdp->md_cur;
int error;
u_int count;
u_char *s;
while (size > 0) {
if (m == NULL) {
MBERROR("incomplete copy\n");
return EBADRPC;
}
s = mdp->md_pos;
count = mtod(m, u_char*) + m->m_len - s;
if (count == 0) {
mdp->md_cur = m = m->m_next;
if (m)
s = mdp->md_pos = mtod(m, caddr_t);
continue;
}
if (count > size)
count = size;
size -= count;
mdp->md_pos += count;
if (target == NULL)
continue;
switch (type) {
case MB_MUSER:
error = copyout(s, target, count);
if (error)
return error;
break;
case MB_MSYSTEM:
bcopy(s, target, count);
break;
case MB_MINLINE:
while (count--)
*target++ = *s++;
continue;
}
target += count;
}
return 0;
}
int
md_get_mbuf(struct mdchain *mdp, int size, struct mbuf **ret)
{
struct mbuf *m = mdp->md_cur, *rm;
rm = m_copym(m, mdp->md_pos - mtod(m, u_char*), size, 0);
if (rm == NULL)
return EBADRPC;
md_get_mem(mdp, NULL, size, MB_MZERO);
*ret = rm;
return 0;
}
int
md_get_uio(struct mdchain *mdp, struct uio *uiop, int size)
{
char *uiocp;
long left;
int mtype, error;
mtype = (uiop->uio_segflg == UIO_SYSSPACE) ? MB_MSYSTEM : MB_MUSER;
while (size > 0 && uiop->uio_resid) {
if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
return EFBIG;
left = uiop->uio_iov->iov_len;
if (left == 0) {
uiop->uio_iov++;
uiop->uio_iovcnt--;
continue;
}
uiocp = uiop->uio_iov->iov_base;
if (left > size)
left = size;
error = md_get_mem(mdp, uiocp, left, mtype);
if (error)
return error;
uiop->uio_offset += left;
uiop->uio_resid -= left;
uiop->uio_iov->iov_base =
(char *)uiop->uio_iov->iov_base + left;
uiop->uio_iov->iov_len -= left;
size -= left;
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink