fs/smbsrv/smb_mbuf_util.c

	smb_mbuf_util.c revision a90cf9f29973990687fa61de9f1f6ea22e924e40
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * 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.
 *
 */

#include <smbsrv/smb_kproto.h>
#include <smbsrv/smb_kstat.h>

static kmem_cache_t *smb_mbc_cache = NULL;
static kmem_cache_t *smb_mbuf_cache = NULL;
static kmem_cache_t *smb_mbufcl_cache = NULL;

void
smb_mbc_init(void)
{
    if (smb_mbc_cache != NULL)
        return;
    smb_mbc_cache = kmem_cache_create(SMBSRV_KSTAT_MBC_CACHE,
        sizeof (mbuf_chain_t), 8, NULL, NULL, NULL, NULL, NULL, 0);

    smb_mbuf_cache = kmem_cache_create("smb_mbuf_cache",
        sizeof (mbuf_t), 8, NULL, NULL, NULL, NULL, NULL, 0);

    smb_mbufcl_cache = kmem_cache_create("smb_mbufcl_cache",
        MCLBYTES, 8, NULL, NULL, NULL, NULL, NULL, 0);
}

void
smb_mbc_fini(void)
{
    if (smb_mbc_cache != NULL) {
        kmem_cache_destroy(smb_mbc_cache);
        smb_mbc_cache = NULL;
    }
    if (smb_mbuf_cache != NULL) {
        kmem_cache_destroy(smb_mbuf_cache);
        smb_mbuf_cache = NULL;
    }
    if (smb_mbufcl_cache != NULL) {
        kmem_cache_destroy(smb_mbufcl_cache);
        smb_mbufcl_cache = NULL;
    }
}

mbuf_chain_t *
smb_mbc_alloc(uint32_t max_bytes)
{
    mbuf_chain_t    *mbc;
    mbuf_t      *m;

    mbc = kmem_cache_alloc(smb_mbc_cache, KM_SLEEP);
    bzero(mbc, sizeof (*mbc));
    mbc->mbc_magic = SMB_MBC_MAGIC;

    if (max_bytes != 0) {
        MGET(m, M_WAIT, MT_DATA);
        m->m_len = 0;
        mbc->chain = m;
        if (max_bytes > MINCLSIZE)
            MCLGET(m, M_WAIT);
    }
    mbc->max_bytes = max_bytes;
    return (mbc);
}

void
smb_mbc_free(mbuf_chain_t *mbc)
{
    SMB_MBC_VALID(mbc);

    m_freem(mbc->chain);
    mbc->chain = NULL;
    mbc->mbc_magic = 0;
    kmem_cache_free(smb_mbc_cache, mbc);
}

/*
 * smb_mbuf_get
 *
 * Allocate mbufs to hold the amount of data specified.
 * A pointer to the head of the mbuf list is returned.
 */
struct mbuf *
smb_mbuf_get(uchar_t *buf, int nbytes)
{
    struct mbuf *mhead = 0;
    struct mbuf *m = 0;
    int count;
    int offset = 0;

    while (nbytes) {
        count = (nbytes > MCLBYTES) ? MCLBYTES : nbytes;
        nbytes -= count;

        if (mhead == 0) {
            MGET(mhead, M_WAIT, MT_DATA);
            m = mhead;
        } else {
            MGET(m->m_next, M_WAIT, MT_DATA);
            m = m->m_next;
        }

        if (count > MLEN) {
            MCLGET(m, M_WAIT);
        }

        m->m_len = count;
        bcopy(buf + offset, m->m_data, count);
        offset += count;
    }
    return (mhead);
}

static int
smb_mbuf_kmem_ref(void *p, uint_t sz, int incr)
{
    if (incr < 0)
        kmem_free(p, sz);
    return (0);
}

/*
 * Allocate enough mbufs to accommodate the residual count in uio,
 * and setup the uio_iov to point to them.
 *
 * This is used by the various SMB read code paths.  That code is
 * going to do a disk read into this buffer, so we'd like it to be
 * large and contiguous.  Use an external (M_EXT) buffer.
 */
struct mbuf *
smb_mbuf_allocate(struct uio *uio)
{
    mbuf_t  *m = 0;
    int len = uio->uio_resid;

    MGET(m, M_WAIT, MT_DATA);
    if (len > MCLBYTES) {
        /* Like MCLGET(), but bigger buf. */
        m->m_ext.ext_buf = kmem_zalloc(len, KM_SLEEP);
        m->m_data = m->m_ext.ext_buf;
        m->m_flags |= M_EXT;
        m->m_ext.ext_size = len;
        m->m_ext.ext_ref = smb_mbuf_kmem_ref;
    } else if (len > MLEN) {
        /* Use the kmem cache. */
        MCLGET(m, M_WAIT);
    }
    m->m_len = len;

    uio->uio_iov->iov_base = m->m_data;
    uio->uio_iov->iov_len = m->m_len;
    uio->uio_iovcnt = 1;

    return (m);
}

/*
 * Trim an mbuf chain to nbytes.
 */
void
smb_mbuf_trim(struct mbuf *mhead, int nbytes)
{
    struct mbuf *m = mhead;

    while (m != 0) {
        if (nbytes <= m->m_len) {
            m->m_len = nbytes;
            if (m->m_next != 0) {
                m_freem(m->m_next);
                m->m_next = 0;
            }
            break;
        }
        nbytes -= m->m_len;
        m = m->m_next;
    }
}

int
MBC_LENGTH(struct mbuf_chain *MBC)
{
    struct mbuf *m = (MBC)->chain;
    int     used = 0;

    while (m != 0) {
        used += m->m_len;
        m = m->m_next;
    }
    return (used);
}

int
MBC_MAXBYTES(struct mbuf_chain *MBC)
{
    return (MBC->max_bytes);
}

void
MBC_SETUP(struct mbuf_chain *MBC, uint32_t max_bytes)
{
    bzero((MBC), sizeof (struct mbuf_chain));
    (MBC)->max_bytes = max_bytes;
}

void
MBC_INIT(struct mbuf_chain *MBC, uint32_t max_bytes)
{
    struct mbuf *m;

    bzero((MBC), sizeof (struct mbuf_chain));

    if (max_bytes != 0) {
        MGET(m, M_WAIT, MT_DATA);
        m->m_len = 0;
        (MBC)->chain = m;
        if (max_bytes > MINCLSIZE)
            MCLGET(m, M_WAIT);
    }
    (MBC)->max_bytes = max_bytes;
}

void
MBC_FLUSH(struct mbuf_chain *MBC)
{
    extern void m_freem(struct mbuf *);
    struct mbuf *m;

    while ((m = (MBC)->chain) != 0) {
        (MBC)->chain = m->m_nextpkt;
        m->m_nextpkt = 0;
        m_freem(m);
    }
    MBC_SETUP(MBC, (MBC)->max_bytes);
}

void
MBC_ATTACH_MBUF(struct mbuf_chain *MBC, struct mbuf *MBUF)
{
    if (MBC->chain != 0)
        MBC_FLUSH(MBC);

    (MBC)->chain_offset = 0;
    (MBC)->chain = (MBUF);
}

void
MBC_APPEND_MBUF(struct mbuf_chain *MBC, struct mbuf *MBUF)
{
    struct mbuf *m;

    if ((MBC)->chain == 0) {
        (MBC)->chain = (MBUF);
    } else {
        m = (MBC)->chain;
        while (m->m_next != 0)
            m = m->m_next;
        m->m_next = (MBUF);
    }
}

static int /*ARGSUSED*/
mclrefnoop(caddr_t p, int size, int adj)
{
    return (0);
}

void
MBC_ATTACH_BUF(struct mbuf_chain *MBC, unsigned char *BUF, int LEN)
{
    MGET((MBC)->chain, M_WAIT, MT_DATA);
    (MBC)->chain_offset = 0;
    (MBC)->chain->m_flags |= M_EXT;
    (MBC)->chain->m_data = (caddr_t)(BUF);
    (MBC)->chain->m_ext.ext_buf = (caddr_t)(BUF);
    (MBC)->chain->m_len = (LEN);
    (MBC)->chain->m_ext.ext_size = (LEN);
    (MBC)->chain->m_ext.ext_ref = mclrefnoop;
    (MBC)->max_bytes = (LEN);
}


int
MBC_SHADOW_CHAIN(struct mbuf_chain *submbc, struct mbuf_chain *mbc,
    int off, int len)
{
    int x = off + len;

    if (off < 0 || len < 0 || x < 0 ||
        off > mbc->max_bytes || x > mbc->max_bytes)
        return (EMSGSIZE);

    *submbc = *mbc;
    submbc->chain_offset = off;
    submbc->max_bytes = x;
    submbc->shadow_of = mbc;
    return (0);
}

/*
 * Free a single mbuf structure.  Calls m->m_ext.ext_ref() to free any
 * associated external buffers if present (indicated by m->m_flags & M_EXT)
 */
struct mbuf *
m_free(struct mbuf *m)
{
    struct mbuf *n;

    MFREE(m, n);
    return (n);
}

/*
 * Free a list of mbufs.  Each mbuf in the list is freed similarly to m_free.
 */
void
m_freem(struct mbuf *m)
{
    struct mbuf *n;

    if (m == NULL)
        return;
    /*
     * Lint doesn't like the m = n assignment at the close of the loop
     * but it is correct.  MFREE assigns n = (m)->m_next so the loop
     * is effectively assigning m = (m)->m_next then exiting when
     * m == NULL
     */
    do {
        MFREE(m, n);
    } while ((m = n) != 0);
}

/*
 * Mbuffer utility routines.
 */

mbuf_t *
smb_mbuf_alloc(void)
{
    mbuf_t *m;

    m = kmem_cache_alloc(smb_mbuf_cache, KM_SLEEP);
    bzero(m, sizeof (*m));
    return (m);
}

void
smb_mbuf_free(mbuf_t *m)
{
    kmem_cache_free(smb_mbuf_cache, m);
}

void *
smb_mbufcl_alloc(void)
{
    void *p;

    p = kmem_cache_alloc(smb_mbufcl_cache, KM_SLEEP);
    bzero(p, MCLBYTES);
    return (p);
}

void
smb_mbufcl_free(void *p)
{
    kmem_cache_free(smb_mbufcl_cache, p);
}

int
smb_mbufcl_ref(void *p, uint_t sz, int incr)
{
    ASSERT3S(sz, ==, MCLBYTES);
    if (incr < 0)
        kmem_cache_free(smb_mbufcl_cache, p);
    return (0);
}