common/io/sad.c

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */


/*
 * STREAMS Administrative Driver
 *
 * Currently only handles autopush and module name verification.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/strsubr.h>
#include <sys/strsun.h>
#include <sys/conf.h>
#include <sys/sad.h>
#include <sys/cred.h>
#include <sys/debug.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/stat.h>
#include <sys/cmn_err.h>
#include <sys/systm.h>
#include <sys/modctl.h>
#include <sys/sysmacros.h>
#include <sys/zone.h>
#include <sys/policy.h>

static int sadopen(queue_t *, dev_t *, int, int, cred_t *);
static int sadclose(queue_t *, int, cred_t *);
static int sadwput(queue_t *qp, mblk_t *mp);

static int sad_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int sad_attach(dev_info_t *, ddi_attach_cmd_t);

static void apush_ioctl(), apush_iocdata();
static void vml_ioctl(), vml_iocdata();
static int valid_major(major_t);

static dev_info_t *sad_dip;     /* private copy of devinfo pointer */

static struct module_info sad_minfo = {
    0x7361, "sad", 0, INFPSZ, 0, 0
};

static struct qinit sad_rinit = {
    NULL, NULL, sadopen, sadclose, NULL, &sad_minfo, NULL
};

static struct qinit sad_winit = {
    sadwput, NULL, NULL, NULL, NULL, &sad_minfo, NULL
};

struct streamtab sadinfo = {
    &sad_rinit, &sad_winit, NULL, NULL
};

DDI_DEFINE_STREAM_OPS(sad_ops, nulldev, nulldev, sad_attach,
    nodev, nodev, sad_info,
    D_MP | D_MTPERQ | D_MTOUTPERIM | D_MTOCEXCL, &sadinfo,
    ddi_quiesce_not_supported);

/*
 * Module linkage information for the kernel.
 */

static struct modldrv modldrv = {
    &mod_driverops, /* Type of module.  This one is a pseudo driver */
    "STREAMS Administrative Driver 'sad'",
    &sad_ops,   /* driver ops */
};

static struct modlinkage modlinkage = {
    MODREV_1, &modldrv, NULL
};

int
_init(void)
{
    return (mod_install(&modlinkage));
}

int
_fini(void)
{
    return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
    return (mod_info(&modlinkage, modinfop));
}

static int
sad_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
    int instance = ddi_get_instance(devi);

    if (cmd != DDI_ATTACH)
        return (DDI_FAILURE);

    ASSERT(instance == 0);
    if (instance != 0)
        return (DDI_FAILURE);

    if (ddi_create_minor_node(devi, "user", S_IFCHR,
        0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
        return (DDI_FAILURE);
    }
    if (ddi_create_minor_node(devi, "admin", S_IFCHR,
        1, DDI_PSEUDO, NULL) == DDI_FAILURE) {
        ddi_remove_minor_node(devi, NULL);
        return (DDI_FAILURE);
    }
    sad_dip = devi;
    return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
sad_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
    int error;

    switch (infocmd) {
    case DDI_INFO_DEVT2DEVINFO:
        if (sad_dip == NULL) {
            error = DDI_FAILURE;
        } else {
            *result = sad_dip;
            error = DDI_SUCCESS;
        }
        break;
    case DDI_INFO_DEVT2INSTANCE:
        *result = (void *)0;
        error = DDI_SUCCESS;
        break;
    default:
        error = DDI_FAILURE;
    }
    return (error);
}


/*
 * sadopen() -
 * Allocate a sad device.  Only one
 * open at a time allowed per device.
 */
/* ARGSUSED */
static int
sadopen(
    queue_t *qp,    /* pointer to read queue */
    dev_t *devp,    /* major/minor device of stream */
    int flag,   /* file open flags */
    int sflag,  /* stream open flags */
    cred_t *credp)  /* user credentials */
{
    int i;
    netstack_t *ns;
    str_stack_t *ss;

    if (sflag)      /* no longer called from clone driver */
        return (EINVAL);

    /* Only privileged process can access ADMINDEV */
    if (getminor(*devp) == ADMMIN) {
        int err;

        err = secpolicy_sadopen(credp);

        if (err != 0)
            return (err);
    }

    ns = netstack_find_by_cred(credp);
    ASSERT(ns != NULL);
    ss = ns->netstack_str;
    ASSERT(ss != NULL);

    /*
     * Both USRMIN and ADMMIN are clone interfaces.
     */
    for (i = 0; i < ss->ss_sadcnt; i++)
        if (ss->ss_saddev[i].sa_qp == NULL)
            break;
    if (i >= ss->ss_sadcnt) {       /* no such device */
        netstack_rele(ss->ss_netstack);
        return (ENXIO);
    }
    switch (getminor(*devp)) {
    case USRMIN:            /* mere mortal */
        ss->ss_saddev[i].sa_flags = 0;
        break;

    case ADMMIN:            /* privileged user */
        ss->ss_saddev[i].sa_flags = SADPRIV;
        break;

    default:
        netstack_rele(ss->ss_netstack);
        return (EINVAL);
    }

    ss->ss_saddev[i].sa_qp = qp;
    ss->ss_saddev[i].sa_ss = ss;
    qp->q_ptr = (caddr_t)&ss->ss_saddev[i];
    WR(qp)->q_ptr = (caddr_t)&ss->ss_saddev[i];

    /*
     * NOTE: should the ADMMIN or USRMIN minors change
     * then so should the offset of 2 below
     * Both USRMIN and ADMMIN are clone interfaces and
     * therefore their minor numbers (0 and 1) are reserved.
     */
    *devp = makedevice(getemajor(*devp), i + 2);
    qprocson(qp);
    return (0);
}

/*
 * sadclose() -
 * Clean up the data structures.
 */
/* ARGSUSED */
static int
sadclose(
    queue_t *qp,    /* pointer to read queue */
    int flag,   /* file open flags */
    cred_t *credp)  /* user credentials */
{
    struct saddev *sadp;

    qprocsoff(qp);
    sadp = (struct saddev *)qp->q_ptr;
    sadp->sa_qp = NULL;
    sadp->sa_addr = NULL;
    netstack_rele(sadp->sa_ss->ss_netstack);
    sadp->sa_ss = NULL;
    qp->q_ptr = NULL;
    WR(qp)->q_ptr = NULL;
    return (0);
}

/*
 * sadwput() -
 * Write side put procedure.
 */
static int
sadwput(
    queue_t *qp,    /* pointer to write queue */
    mblk_t *mp) /* message pointer */
{
    struct iocblk *iocp;

    switch (mp->b_datap->db_type) {
    case M_FLUSH:
        if (*mp->b_rptr & FLUSHR) {
            *mp->b_rptr &= ~FLUSHW;
            qreply(qp, mp);
        } else
            freemsg(mp);
        break;

    case M_IOCTL:
        iocp = (struct iocblk *)mp->b_rptr;
        switch (SAD_CMD(iocp->ioc_cmd)) {
        case SAD_CMD(SAD_SAP):
        case SAD_CMD(SAD_GAP):
            apush_ioctl(qp, mp);
            break;

        case SAD_VML:
            vml_ioctl(qp, mp);
            break;

        default:
            miocnak(qp, mp, 0, EINVAL);
            break;
        }
        break;

    case M_IOCDATA:
        iocp = (struct iocblk *)mp->b_rptr;
        switch (SAD_CMD(iocp->ioc_cmd)) {
        case SAD_CMD(SAD_SAP):
        case SAD_CMD(SAD_GAP):
            apush_iocdata(qp, mp);
            break;

        case SAD_VML:
            vml_iocdata(qp, mp);
            break;

        default:
            cmn_err(CE_WARN,
                "sadwput: invalid ioc_cmd in case M_IOCDATA: %d",
                iocp->ioc_cmd);
            freemsg(mp);
            break;
        }
        break;

    default:
        freemsg(mp);
        break;
    } /* switch (db_type) */
    return (0);
}

/*
 * apush_ioctl() -
 * Handle the M_IOCTL messages associated with
 * the autopush feature.
 */
static void
apush_ioctl(
    queue_t *qp,    /* pointer to write queue */
    mblk_t *mp) /* message pointer */
{
    struct iocblk   *iocp;
    struct saddev   *sadp;
    uint_t      size;

    iocp = (struct iocblk *)mp->b_rptr;
    if (iocp->ioc_count != TRANSPARENT) {
        miocnak(qp, mp, 0, EINVAL);
        return;
    }
    if (SAD_VER(iocp->ioc_cmd) > AP_VERSION) {
        miocnak(qp, mp, 0, EINVAL);
        return;
    }

    sadp = (struct saddev *)qp->q_ptr;
    switch (SAD_CMD(iocp->ioc_cmd)) {
    case SAD_CMD(SAD_SAP):
        if (!(sadp->sa_flags & SADPRIV)) {
            miocnak(qp, mp, 0, EPERM);
            break;
        }
        /* FALLTHRU */

    case SAD_CMD(SAD_GAP):
        sadp->sa_addr = (caddr_t)*(uintptr_t *)mp->b_cont->b_rptr;
        if (SAD_VER(iocp->ioc_cmd) == 1)
            size = STRAPUSH_V1_LEN;
        else
            size = STRAPUSH_V0_LEN;
        mcopyin(mp, (void *)GETSTRUCT, size, NULL);
        qreply(qp, mp);
        break;

    default:
        ASSERT(0);
        miocnak(qp, mp, 0, EINVAL);
        break;
    } /* switch (ioc_cmd) */
}

/*
 * apush_iocdata() -
 * Handle the M_IOCDATA messages associated with
 * the autopush feature.
 */
static void
apush_iocdata(
    queue_t *qp,    /* pointer to write queue */
    mblk_t *mp) /* message pointer */
{
    int i, ret;
    struct copyresp *csp;
    struct strapush *sap = NULL;
    struct autopush *ap, *ap_tmp;
    struct saddev *sadp;
    uint_t size;
    dev_t dev;
    str_stack_t *ss;

    sadp = (struct saddev *)qp->q_ptr;
    ss = sadp->sa_ss;

    csp = (struct copyresp *)mp->b_rptr;
    if (csp->cp_rval) { /* if there was an error */
        freemsg(mp);
        return;
    }
    if (mp->b_cont) {
        /*
         * sap needed only if mp->b_cont is set.  figure out the
         * size of the expected sap structure and make sure
         * enough data was supplied.
         */
        if (SAD_VER(csp->cp_cmd) == 1)
            size = STRAPUSH_V1_LEN;
        else
            size = STRAPUSH_V0_LEN;
        if (MBLKL(mp->b_cont) < size) {
            miocnak(qp, mp, 0, EINVAL);
            return;
        }
        sap = (struct strapush *)mp->b_cont->b_rptr;
        dev = makedevice(sap->sap_major, sap->sap_minor);
    }
    switch (SAD_CMD(csp->cp_cmd)) {
    case SAD_CMD(SAD_SAP):

        /* currently we only support one SAD_SAP command */
        if (((long)csp->cp_private) != GETSTRUCT) {
            cmn_err(CE_WARN,
                "apush_iocdata: cp_private bad in SAD_SAP: %p",
                (void *)csp->cp_private);
            miocnak(qp, mp, 0, EINVAL);
            return;
        }

        switch (sap->sap_cmd) {
        default:
            miocnak(qp, mp, 0, EINVAL);
            return;
        case SAP_ONE:
        case SAP_RANGE:
        case SAP_ALL:
            /* allocate and initialize a new config */
            ap = sad_ap_alloc();
            ap->ap_common = sap->sap_common;
            if (SAD_VER(csp->cp_cmd) > 0)
                ap->ap_anchor = sap->sap_anchor;
            for (i = 0; i < MIN(sap->sap_npush, MAXAPUSH); i++)
                (void) strncpy(ap->ap_list[i],
                    sap->sap_list[i], FMNAMESZ);

            /* sanity check the request */
            if (((ret = sad_ap_verify(ap)) != 0) ||
                ((ret = valid_major(ap->ap_major)) != 0)) {
                sad_ap_rele(ap, ss);
                miocnak(qp, mp, 0, ret);
                return;
            }

            /* check for overlapping configs */
            mutex_enter(&ss->ss_sad_lock);
            ap_tmp = sad_ap_find(&ap->ap_common, ss);
            if (ap_tmp != NULL) {
                /* already configured */
                mutex_exit(&ss->ss_sad_lock);
                sad_ap_rele(ap_tmp, ss);
                sad_ap_rele(ap, ss);
                miocnak(qp, mp, 0, EEXIST);
                return;
            }

            /* add the new config to our hash */
            sad_ap_insert(ap, ss);
            mutex_exit(&ss->ss_sad_lock);
            miocack(qp, mp, 0, 0);
            return;

        case SAP_CLEAR:
            /* sanity check the request */
            if (ret = valid_major(sap->sap_major)) {
                miocnak(qp, mp, 0, ret);
                return;
            }

            /* search for a matching config */
            if ((ap = sad_ap_find_by_dev(dev, ss)) == NULL) {
                /* no config found */
                miocnak(qp, mp, 0, ENODEV);
                return;
            }

            /*
             * If we matched a SAP_RANGE config
             * the minor passed in must match the
             * beginning of the range exactly.
             */
            if ((ap->ap_type == SAP_RANGE) &&
                (ap->ap_minor != sap->sap_minor)) {
                sad_ap_rele(ap, ss);
                miocnak(qp, mp, 0, ERANGE);
                return;
            }

            /*
             * If we matched a SAP_ALL config
             * the minor passed in must be 0.
             */
            if ((ap->ap_type == SAP_ALL) &&
                (sap->sap_minor != 0)) {
                sad_ap_rele(ap, ss);
                miocnak(qp, mp, 0, EINVAL);
                return;
            }

            /*
             * make sure someone else hasn't already
             * removed this config from the hash.
             */
            mutex_enter(&ss->ss_sad_lock);
            ap_tmp = sad_ap_find(&ap->ap_common, ss);
            if (ap_tmp != ap) {
                mutex_exit(&ss->ss_sad_lock);
                sad_ap_rele(ap_tmp, ss);
                sad_ap_rele(ap, ss);
                miocnak(qp, mp, 0, ENODEV);
                return;
            }

            /* remove the config from the hash and return */
            sad_ap_remove(ap, ss);
            mutex_exit(&ss->ss_sad_lock);

            /*
             * Release thrice, once for sad_ap_find_by_dev(),
             * once for sad_ap_find(), and once to free.
             */
            sad_ap_rele(ap, ss);
            sad_ap_rele(ap, ss);
            sad_ap_rele(ap, ss);
            miocack(qp, mp, 0, 0);
            return;
        } /* switch (sap_cmd) */
        /*NOTREACHED*/

    case SAD_CMD(SAD_GAP):
        switch ((long)csp->cp_private) {

        case GETSTRUCT:
            /* sanity check the request */
            if (ret = valid_major(sap->sap_major)) {
                miocnak(qp, mp, 0, ret);
                return;
            }

            /* search for a matching config */
            if ((ap = sad_ap_find_by_dev(dev, ss)) == NULL) {
                /* no config found */
                miocnak(qp, mp, 0, ENODEV);
                return;
            }

            /* copy out the contents of the config */
            sap->sap_common = ap->ap_common;
            if (SAD_VER(csp->cp_cmd) > 0)
                sap->sap_anchor = ap->ap_anchor;
            for (i = 0; i < ap->ap_npush; i++)
                (void) strcpy(sap->sap_list[i], ap->ap_list[i]);
            for (; i < MAXAPUSH; i++)
                bzero(sap->sap_list[i], FMNAMESZ + 1);

            /* release our hold on the config */
            sad_ap_rele(ap, ss);

            /* copyout the results */
            if (SAD_VER(csp->cp_cmd) == 1)
                size = STRAPUSH_V1_LEN;
            else
                size = STRAPUSH_V0_LEN;

            mcopyout(mp, (void *)GETRESULT, size, sadp->sa_addr,
                NULL);
            qreply(qp, mp);
            return;
        case GETRESULT:
            miocack(qp, mp, 0, 0);
            return;

        default:
            cmn_err(CE_WARN,
                "apush_iocdata: cp_private bad case SAD_GAP: %p",
                (void *)csp->cp_private);
            freemsg(mp);
            return;
        } /* switch (cp_private) */
        /*NOTREACHED*/
    default:    /* can't happen */
        ASSERT(0);
        freemsg(mp);
        return;
    } /* switch (cp_cmd) */
}

/*
 * vml_ioctl() -
 * Handle the M_IOCTL message associated with a request
 * to validate a module list.
 */
static void
vml_ioctl(
    queue_t *qp,    /* pointer to write queue */
    mblk_t *mp) /* message pointer */
{
    struct iocblk *iocp;

    iocp = (struct iocblk *)mp->b_rptr;
    if (iocp->ioc_count != TRANSPARENT) {
        miocnak(qp, mp, 0, EINVAL);
        return;
    }
    ASSERT(SAD_CMD(iocp->ioc_cmd) == SAD_VML);
    mcopyin(mp, (void *)GETSTRUCT,
        SIZEOF_STRUCT(str_list, iocp->ioc_flag), NULL);
    qreply(qp, mp);
}

/*
 * vml_iocdata() -
 * Handle the M_IOCDATA messages associated with
 * a request to validate a module list.
 */
static void
vml_iocdata(
    queue_t *qp,    /* pointer to write queue */
    mblk_t *mp) /* message pointer */
{
    long i;
    int nmods;
    struct copyresp *csp;
    struct str_mlist *lp;
    STRUCT_HANDLE(str_list, slp);
    struct saddev *sadp;

    csp = (struct copyresp *)mp->b_rptr;
    if (csp->cp_rval) { /* if there was an error */
        freemsg(mp);
        return;
    }

    ASSERT(SAD_CMD(csp->cp_cmd) == SAD_VML);
    sadp = (struct saddev *)qp->q_ptr;
    switch ((long)csp->cp_private) {
    case GETSTRUCT:
        STRUCT_SET_HANDLE(slp, csp->cp_flag,
            (struct str_list *)mp->b_cont->b_rptr);
        nmods = STRUCT_FGET(slp, sl_nmods);
        if (nmods <= 0) {
            miocnak(qp, mp, 0, EINVAL);
            break;
        }
        sadp->sa_addr = (caddr_t)(uintptr_t)nmods;

        mcopyin(mp, (void *)GETLIST, nmods * sizeof (struct str_mlist),
            STRUCT_FGETP(slp, sl_modlist));
        qreply(qp, mp);
        break;

    case GETLIST:
        lp = (struct str_mlist *)mp->b_cont->b_rptr;
        for (i = 0; i < (long)sadp->sa_addr; i++, lp++) {
            lp->l_name[FMNAMESZ] = '\0';
            if (fmodsw_find(lp->l_name, FMODSW_LOAD) == NULL) {
                miocack(qp, mp, 0, 1);
                return;
            }
        }
        miocack(qp, mp, 0, 0);
        break;

    default:
        cmn_err(CE_WARN, "vml_iocdata: invalid cp_private value: %p",
            (void *)csp->cp_private);
        freemsg(mp);
        break;
    } /* switch (cp_private) */
}

/*
 * Validate a major number and also verify if
 * it is a STREAMS device.
 * Return values: 0 if a valid STREAMS dev
 *        error code otherwise
 */
static int
valid_major(major_t major)
{
    int ret = 0;

    if (etoimajor(major) == -1)
        return (EINVAL);

    /*
     * attempt to load the driver 'major' and verify that
     * it is a STREAMS driver.
     */
    if (ddi_hold_driver(major) == NULL)
        return (EINVAL);

    if (!STREAMSTAB(major))
        ret = ENOSTR;

    ddi_rele_driver(major);

    return (ret);
}