Merge remote-tracking branch 'origin/master'

[unleashed/lotheac.git] / usr / src / uts / common / io / pckt.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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


/*
 * Description: The pckt module packetizes messages on
 *              its read queue by pre-fixing an M_PROTO
 *              message type to certain incoming messages.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/kmem.h>
#include <sys/errno.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/debug.h>

/*
 * This is the loadable module wrapper.
 */
#include <sys/conf.h>
#include <sys/modctl.h>

static struct streamtab pcktinfo;

/*
 * Per queue instances are single-threaded since the q_ptr
 * field of queues need to be shared among threads.
 */
static struct fmodsw fsw = {
        "pckt",
        &pcktinfo,
        D_NEW | D_MTPERQ | D_MP
};

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

static struct modlstrmod modlstrmod = {
        &mod_strmodops,
        "pckt module",
        &fsw
};

static struct modlinkage modlinkage = {
        MODREV_1, &modlstrmod, 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      pcktopen(queue_t *, dev_t *, int, int, cred_t *);
static int      pcktclose(queue_t *, int, cred_t *);
static void     pcktrput(queue_t *, mblk_t *);
static void     pcktrsrv(queue_t *);
static void     pcktwput(queue_t *, mblk_t *);
static mblk_t   *add_ctl_info(queue_t *, mblk_t *);
static void     add_ctl_wkup(void *);


/*
 * Stream module data structure definitions.
 * Sits over the ptm module generally.
 *
 * Read side flow control strategy: Since we may be putting messages on
 * the read q due to allocb failures, these failures must get
 * reflected fairly quickly to the module below us.
 * No sense in piling on messages in times of memory shortage.
 * Further, for the case of upper level flow control, there is no
 * compelling reason to have more buffering in this module.
 * Thus use a hi-water mark of one.
 * This module imposes no max packet size, there is no inherent reason
 * in the code to do so.
 */
static struct module_info pcktiinfo = {
        0x9898,                                 /* module id number */
        "pckt",                                 /* module name */
        0,                                      /* minimum packet size */
        INFPSZ,                                 /* maximum packet size */
        1,                                      /* hi-water mark */
        0                                       /* lo-water mark */
};

/*
 * Write side flow control strategy: There is no write service procedure.
 * The write put function is pass thru, thus there is no reason to have any
 * limits on the maximum packet size.
 */
static struct module_info pcktoinfo = {
        0x9898,                                 /* module id number */
        "pckt",                                 /* module name */
        0,                                      /* minimum packet size */
        INFPSZ,                                 /* maximum packet size */
        0,                                      /* hi-water mark */
        0                                       /* lo-water mark */
};

static struct qinit pcktrinit = {
        (int (*)())pcktrput,
        (int (*)())pcktrsrv,
        pcktopen,
        pcktclose,
        NULL,
        &pcktiinfo,
        NULL
};

static struct qinit pcktwinit = {
        (int (*)())pcktwput,
        NULL,
        NULL,
        NULL,
        NULL,
        &pcktoinfo,
        NULL
};

static struct streamtab pcktinfo = {
        &pcktrinit,
        &pcktwinit,
        NULL,
        NULL
};


/*
 * Per-instance state struct for the pckt module.
 */
struct pckt_info {
        queue_t         *pi_qptr;               /* back pointer to q */
        bufcall_id_t    pi_bufcall_id;
#ifdef _MULTI_DATAMODEL
        model_t         model;
#endif /* _MULTI_DATAMODEL */
};

/*
 * Dummy qbufcall callback routine used by open and close.
 * The framework will wake up qwait_sig when we return from
 * this routine (as part of leaving the perimeters.)
 * (The framework enters the perimeters before calling the qbufcall() callback
 * and leaves the perimeters after the callback routine has executed. The
 * framework performs an implicit wakeup of any thread in qwait/qwait_sig
 * when it leaves the perimeter. See qwait(9E).)
 */
/* ARGSUSED */
static void
dummy_callback(void *arg)
{}

/*
 * pcktopen - open routine gets called when the
 *          module gets pushed onto the stream.
 */
/*ARGSUSED*/
static int
pcktopen(
        queue_t *q,             /* pointer to the read side queue */
        dev_t   *devp,          /* pointer to stream tail's dev */
        int     oflag,          /* the user open(2) supplied flags */
        int     sflag,          /* open state flag */
        cred_t  *credp)         /* credentials */
{
        struct pckt_info        *pip;
        mblk_t                  *mop; /* ptr to a setopts msg block */
        struct stroptions       *sop;

        if (sflag != MODOPEN)
                return (EINVAL);

        if (q->q_ptr != NULL) {
                /* It's already attached. */
                return (0);
        }

        /*
         * Allocate state structure.
         */
        pip = kmem_zalloc(sizeof (*pip), KM_SLEEP);

#ifdef _MULTI_DATAMODEL
        pip->model = ddi_model_convert_from(get_udatamodel());
#endif /* _MULTI_DATAMODEL */

        /*
         * Cross-link.
         */
        pip->pi_qptr = q;
        q->q_ptr = pip;
        WR(q)->q_ptr = pip;

        qprocson(q);

        /*
         * Initialize an M_SETOPTS message to set up hi/lo water marks on
         * stream head read queue.
         */

        while ((mop = allocb(sizeof (struct stroptions), BPRI_MED)) == NULL) {
                bufcall_id_t id = qbufcall(q, sizeof (struct stroptions),
                    BPRI_MED, dummy_callback, NULL);
                if (!qwait_sig(q)) {
                        qunbufcall(q, id);
                        kmem_free(pip, sizeof (*pip));
                        qprocsoff(q);
                        return (EINTR);
                }
                qunbufcall(q, id);
        }


        /*
         * XXX: Should this module really control the hi/low water marks?
         * Is there any reason in this code to do so?
         */
        mop->b_datap->db_type = M_SETOPTS;
        mop->b_wptr += sizeof (struct stroptions);
        sop = (struct stroptions *)mop->b_rptr;
        sop->so_flags = SO_HIWAT | SO_LOWAT;
        sop->so_hiwat = 512;
        sop->so_lowat = 256;

        /*
         * Commit to the open and send the M_SETOPTS off to the stream head.
         */
        putnext(q, mop);

        return (0);
}


/*
 * pcktclose - This routine gets called when the module
 *      gets popped off of the stream.
 */

/*ARGSUSED*/
static int
pcktclose(
        queue_t *q,     /* Pointer to the read queue */
        int     flag,
        cred_t  *credp)
{
        struct pckt_info        *pip = (struct pckt_info *)q->q_ptr;

        qprocsoff(q);
        /*
         * Cancel outstanding qbufcall
         */
        if (pip->pi_bufcall_id) {
                qunbufcall(q, pip->pi_bufcall_id);
                pip->pi_bufcall_id = 0;
        }
        /*
         * Do not worry about msgs queued on the q, the framework
         * will free them up.
         */
        kmem_free(q->q_ptr, sizeof (struct pckt_info));
        q->q_ptr = WR(q)->q_ptr = NULL;
        return (0);
}

/*
 * pcktrput - Module read queue put procedure.
 *      This is called from the module or
 *      driver downstream.
 */
static void
pcktrput(
        queue_t *q,     /* Pointer to the read queue */
        mblk_t *mp)     /* Pointer to the current message block */
{
        mblk_t          *pckt_msgp;


        switch (mp->b_datap->db_type) {
        case M_FLUSH:
                /*
                 * The PTS driver swaps the FLUSHR and FLUSHW flags
                 * we need to swap them back to reflect the actual
                 * slave side FLUSH mode.
                 */
                if ((*mp->b_rptr & FLUSHRW) != FLUSHRW)
                        if ((*mp->b_rptr & FLUSHRW) == FLUSHR)
                                *mp->b_rptr = FLUSHW;
                        else if ((*mp->b_rptr & FLUSHRW) == FLUSHW)
                                *mp->b_rptr = FLUSHR;

                pckt_msgp = copymsg(mp);
                if (*mp->b_rptr & FLUSHW) {
                        /*
                         * In the packet model we are not allowing
                         * flushes of the master's stream head read
                         * side queue. This is because all packet
                         * state information is stored there and
                         * a flush could destroy this data before
                         * it is read.
                         */
                        *mp->b_rptr = FLUSHW;
                        putnext(q, mp);
                } else {
                        /*
                         * Free messages that only flush the
                         * master's read queue.
                         */
                        freemsg(mp);
                }

                if (pckt_msgp == NULL)
                        break;

                mp = pckt_msgp;
                /*
                 * Prefix M_PROTO and putnext.
                 */
                goto prefix_head;

        case M_DATA:
        case M_IOCTL:
        case M_PROTO:
                /*
                 * For non-priority messages, follow flow-control rules.
                 * Also, if there are messages on the q already, keep
                 * queueing them since they need to be processed in order.
                 */
                if (!canputnext(q) || (qsize(q) > 0)) {
                        (void) putq(q, mp);
                        break;
                }
                /* FALLTHROUGH */

        /*
         * For high priority messages, skip flow control checks.
         */
        case M_PCPROTO:
        case M_READ:
        case M_STOP:
        case M_START:
        case M_STARTI:
        case M_STOPI:
prefix_head:
                /*
                 * Prefix an M_PROTO header to message and pass upstream.
                 */
                if ((mp = add_ctl_info(q, mp)) != NULL)
                        putnext(q, mp);
                break;

        default:
                /*
                 * For data messages, queue them back on the queue if
                 * there are messages on the queue already. This is
                 * done to preserve the order of messages.
                 * For high priority messages or for no messages on the
                 * q, simply putnext() and pass it on.
                 */
                if ((datamsg(mp->b_datap->db_type)) && (qsize(q) > 0))
                        (void) putq(q, mp);
                else
                        putnext(q, mp);
                break;
        }
}

/*
 * pcktrsrv - module read service procedure
 * This function deals with messages left in the queue due to
 *      (a) not enough memory to allocate the header M_PROTO message
 *      (b) flow control reasons
 * The function will attempt to get the messages off the queue and
 * process them.
 */
static void
pcktrsrv(queue_t *q)
{
        mblk_t *mp;

        while ((mp = getq(q)) != NULL) {
                if (!canputnext(q)) {
                        /*
                         * For high priority messages, make sure there is no
                         * infinite loop. Disable the queue for this case.
                         * High priority messages get here only for buffer
                         * allocation failures. Thus the bufcall callout
                         * will reenable the q.
                         * XXX bug alert - nooenable will *not* prevent
                         * putbq of a hipri messages frm enabling the queue.
                         */
                        if (!datamsg(mp->b_datap->db_type))
                                noenable(q);
                        (void) putbq(q, mp);
                        return;
                }

                /*
                 * M_FLUSH msgs may also be here if there was a memory
                 * failure.
                 */
                switch (mp->b_datap->db_type) {
                case M_FLUSH:
                case M_PROTO:
                case M_PCPROTO:
                case M_STOP:
                case M_START:
                case M_IOCTL:
                case M_DATA:
                case M_READ:
                case M_STARTI:
                case M_STOPI:
                        /*
                         * Prefix an M_PROTO header to msg and pass upstream.
                         */
                        if ((mp = add_ctl_info(q, mp)) == NULL) {
                                /*
                                 * Running into memory or flow ctl problems.
                                 */
                                return;
                        }
                        /* FALL THROUGH */

                default:
                        putnext(q, mp);
                        break;
                }
        }
}

/*
 * pcktwput - Module write queue put procedure.
 *      All messages are send downstream unchanged
 */

static void
pcktwput(
        queue_t *q,     /* Pointer to the read queue */
        mblk_t *mp)     /* Pointer to current message block */
{
        putnext(q, mp);
}

#ifdef _MULTI_DATAMODEL
/*
 * reallocb - copy the data block from the given message block into a new block.
 * This function is used in case data block had another message block
 * pointing to it (and hence we just copy this one data block).
 *
 * Returns new message block if successful. On failure it returns NULL.
 * It also tries to do a qbufcall and if that also fails,
 * it frees the message block.
 */
static mblk_t *
pckt_reallocb(
        queue_t *q,     /* Pointer to the read queue */
        mblk_t *mp      /* Pointer to the message block to be changed */
)
{
        mblk_t  *nmp;

        ASSERT(mp->b_datap->db_ref >= 1);

        /*
         * No reallocation is needed if there is only one reference
         * to this data block.
         */
        if (mp->b_datap->db_ref == 1)
                return (mp);

        if ((nmp = copyb(mp)) == NULL) {
                struct pckt_info        *pip = (struct pckt_info *)q->q_ptr;

                noenable(q);
                if (pip->pi_bufcall_id = qbufcall(q, mp->b_wptr - mp->b_rptr,
                    BPRI_MED, add_ctl_wkup, q)) {
                        /*
                         * Put the message back onto the q.
                         */
                        (void) putq(q, mp);
                } else {
                        /*
                         * Things are pretty bad and serious if bufcall fails!
                         * Drop the message in this case.
                         */
                        freemsg(mp);
                }
                return ((mblk_t *)0);
        }

        nmp->b_cont = mp->b_cont;
        freeb(mp);
        return (nmp);
}
#endif /* _MULTI_DATAMODEL */

/*
 * add_ctl_info: add message control information to in coming
 *      message.
 */
static mblk_t *
add_ctl_info(
        queue_t *q,             /* pointer to the read queue */
        mblk_t  *mp)            /* pointer to the raw data input message */
{
        struct pckt_info        *pip = (struct pckt_info *)q->q_ptr;
        mblk_t  *bp;            /* pointer to the unmodified message block */

        /*
         * Waiting on space for previous message?
         */
        if (pip->pi_bufcall_id) {
                /*
                 * Chain this message on to q for later processing.
                 */
                (void) putq(q, mp);
                return (NULL);
        }

        /*
         * Need to add the message block header as
         * an M_PROTO type message.
         */
        if ((bp = allocb(sizeof (char), BPRI_MED)) == NULL) {

                /*
                 * There are two reasons to disable the q:
                 * (1) Flow control reasons should not wake up the q.
                 * (2) High priority messages will wakeup the q
                 *      immediately. Disallow this.
                 */
                noenable(q);
                if (pip->pi_bufcall_id = qbufcall(q, sizeof (char), BPRI_MED,
                    add_ctl_wkup, q)) {
                        /*
                         * Add the message to the q.
                         */
                        (void) putq(q, mp);
                } else {
                        /*
                         * Things are pretty bad and serious if bufcall fails!
                         * Drop the message in this case.
                         */
                        freemsg(mp);
                }

                return (NULL);
        }

        /*
         * Copy the message type information to this message.
         */
        bp->b_datap->db_type = M_PROTO;
        *(unsigned char *)bp->b_rptr = mp->b_datap->db_type;
        bp->b_wptr++;

#ifdef _MULTI_DATAMODEL
        /*
         * Check the datamodel and if the calling program is
         * an ILP32 application then we covert the M_IOCTLs and M_READs
         * into the native ILP32 format before passing them upstream
         * to user mode.
         */
        switch (pip->model) {
        case DDI_MODEL_ILP32:
                switch (mp->b_datap->db_type) {
                        /*
                         * This structure must have the same shape as
                         * the * ILP32 compilation of `struct iocblk'
                         * from <sys/stream.h>.
                         */
                        struct iocblk32 {
                                int32_t         ioc_cmd;
                                caddr32_t       ioc_cr;
                                uint32_t        ioc_id;
                                int32_t         ioc_count;
                                int32_t         ioc_error;
                                int32_t         ioc_rval;
                                int32_t         ioc_fill1;
                                uint32_t        ioc_flag;
                                int32_t         ioc_filler[2];
                        } niocblk_32;
                        struct iocblk           *iocblk_64;

                case M_IOCTL:
                        if ((mp = pckt_reallocb(q, mp)) == (mblk_t *)0)
                                return ((mblk_t *)0);

                        bzero(&niocblk_32, sizeof (niocblk_32));
                        iocblk_64 = (struct iocblk *)mp->b_rptr;

                        /* Leave the pointer to cred_t structure as it is. */
                        niocblk_32.ioc_cmd = iocblk_64->ioc_cmd;
                        niocblk_32.ioc_cr = (caddr32_t)(uintptr_t)
                            iocblk_64->ioc_cr;
                        niocblk_32.ioc_id = iocblk_64->ioc_id;
                        niocblk_32.ioc_count = iocblk_64->ioc_count;
                        niocblk_32.ioc_error = iocblk_64->ioc_error;
                        niocblk_32.ioc_rval = iocblk_64->ioc_rval;
                        niocblk_32.ioc_flag = iocblk_64->ioc_flag;

                        /* Copy the iocblk structure for ILP32 back */
                        *(struct iocblk32 *)mp->b_rptr = niocblk_32;
                        mp->b_wptr = mp->b_rptr + sizeof (struct iocblk32);
                        break;

                case M_READ:
                        if ((mp = pckt_reallocb(q, mp)) == (mblk_t *)0)
                                return ((mblk_t *)0);

                        /* change the size_t to size32_t for ILP32 */
                        *(size32_t *)mp->b_rptr = *(size_t *)mp->b_rptr;
                        mp->b_wptr = mp->b_rptr + sizeof (size32_t);
                        break;
                }
                break;

        case DATAMODEL_NONE:
                break;
        }
#endif /* _MULTI_DATAMODEL */

        /*
         * Now change the orginal message type to M_DATA and tie them up.
         */
        mp->b_datap->db_type = M_DATA;
        bp->b_cont = mp;

        return (bp);
}

static void
add_ctl_wkup(void *arg)
{
        queue_t *q = arg;       /* ptr to the read queue */
        struct pckt_info *pip = (struct pckt_info *)q->q_ptr;

        pip->pi_bufcall_id = 0;
        /*
         * Allow enabling of the q to allow the service
         * function to do its job.
         *
         * Also, qenable() to schedule the q immediately.
         * This is to ensure timely processing of high priority
         * messages if they are on the q.
         */
        enableok(q);
        qenable(q);
}