io/ttymux/ttymux_ioctl.c

	ttymux_ioctl.c revision fa9e4066f08beec538e775443c5be79dd423fcab
/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * DESCRIPTION
 *
 * ttymux_ioctl - Handler for ttymux specific ioctl calls.
 *
 */

#include <sys/types.h>
#include <sys/strsubr.h>
#include <sys/strsun.h>
#include <sys/errno.h>
#include <sys/stat.h>
#include <sys/kmem.h>
#include <sys/ddi.h>
#include <sys/termio.h>
#include <sys/mkdev.h>
#include <sys/sunddi.h>
#include <sys/esunddi.h>
#include <sys/consdev.h>
#include <sys/promif.h>

#include <sys/ttymux.h>
#include "ttymux_impl.h"

/*
 * Extern declarations
 */
extern mblk_t *mkiocb(uint_t);
extern int nulldev();
extern uintptr_t space_fetch(char *key);
extern void prom_interpret(char *, uintptr_t, uintptr_t, uintptr_t,
    uintptr_t, uintptr_t);

/*
 * Imported ttymux routines
 */
extern void sm_debug(char *, ...);
extern void sm_log(char *, ...);
extern sm_lqi_t *get_lqi_byid(int);
extern sm_lqi_t *get_lqi_bydevt(dev_t);
extern int sm_associate(int, sm_lqi_t *, ulong_t, uint_t, char *);
extern int sm_disassociate(int, sm_lqi_t *, ulong_t);

/*
 * Exported ttymux routines
 */
int ttymux_abort_ioctl(mblk_t *);
int ttymux_device_init(sm_lqi_t *);
int ttymux_device_fini(sm_lqi_t *);
int sm_ioctl_cmd(sm_uqi_t *, mblk_t *);

/*
 * Imported ttymux variables
 */
extern sm_ss_t  *sm_ssp;

static int
mblk2assoc(mblk_t *mp, ttymux_assoc_t *assoc)
{
    struct iocblk *iobp = (struct iocblk *)mp->b_rptr;

    sm_dbg('M', ("mblk2assoc:\n"));
    if (mp->b_cont == NULL)
        return (EINVAL);

#ifdef _SYSCALL32_IMPL
    if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
        ttymux_assoc32_t *assoc32;

        sm_dbg('I', ("mblk2assoc: b_cont 0x%p count %d (sz %d)\n",
            mp->b_cont, iobp->ioc_count, sizeof (*assoc32)));

        if (iobp->ioc_count < sizeof (ttymux_assoc32_t))
            return (EINVAL);

        assoc32 = (ttymux_assoc32_t *)mp->b_cont->b_rptr;
        assoc->ttymux_udev = expldev(assoc32->ttymux32_udev);
        assoc->ttymux_ldev = expldev(assoc32->ttymux32_ldev);
        assoc->ttymux_linkid = assoc32->ttymux32_linkid;
        assoc->ttymux_tag = assoc32->ttymux32_tag;
        assoc->ttymux_ioflag = assoc32->ttymux32_ioflag;
        (void) strncpy(assoc->ttymux_path, assoc32->ttymux32_path,
                MAXPATHLEN);

    } else
#endif
    if (iobp->ioc_count < sizeof (*assoc)) {
        return (EINVAL);
    } else {
        *assoc = *(ttymux_assoc_t *)mp->b_cont->b_rptr;
    }
    sm_dbg('M', ("mblk2assoc (%d): dev %d:%d not found\n",
        assoc->ttymux_linkid, getmajor(assoc->ttymux_ldev),
            getminor(assoc->ttymux_ldev)));
    return (0);
}

/*
 * Given a device path return an OBP alias for it if it exists.
 */
static char *
val2alias(pnode_t node, char *path)
{
    char *buf1;
    char *buf2;
    char *propname, *propval;
    int proplen;

    if (node == OBP_BADNODE)
        return (NULL);

    sm_dbg('A', ("Looking for an alias for: %s (len %d)\n",
        path, strlen(path)));

    /*
     * Ask for first property by passing a NULL string
     */
    buf1 = kmem_alloc(OBP_MAXPROPNAME, KM_SLEEP);
    buf2 = kmem_zalloc(OBP_MAXPROPNAME, KM_SLEEP);
    buf1[0] = '\0';

    while (propname = (char *)prom_nextprop(node, buf1, buf2)) {
        if (strlen(propname) == 0)
            break;    /* end of prop list */

        (void) strcpy(buf1, propname);

        proplen = prom_getproplen(node, propname);
        if (proplen == 0)
            continue;
        propval = kmem_zalloc(proplen + 1, KM_SLEEP);
        (void) prom_getprop(node, propname, propval);

        if (strcmp(propval, path) == 0) {
            kmem_free(propval, proplen + 1);
            kmem_free(buf1, OBP_MAXPROPNAME);
            sm_dbg('A', ("Alias is : %s\n", buf2));
            return (buf2);
        }

        kmem_free(propval, proplen + 1);
        bzero(buf2, OBP_MAXPROPNAME);
    }

    kmem_free(buf1, OBP_MAXPROPNAME);
    kmem_free(buf2, OBP_MAXPROPNAME);

    return (NULL);
}

/*
 * Tell OBP that this device is now usable
 */
static void
enable_device(sm_mux_state_t *ms, sm_console_t *cn)
{
    char *enb_str = "\" enable-device\" rot $call-method";

    if (!cn->sm_obp_con)
        return;

    sm_dbg('A', ("ttymux: enabling %d:%d\n",
        getmajor(cn->sm_dev), getminor(cn->sm_dev)));

    if (cn->sm_i_ihdl != 0)
        prom_interpret(enb_str, (caddr32_t)ms->sm_cons_stdin.sm_i_ihdl,
            (caddr32_t)cn->sm_i_ihdl, 0, 0, 0);

    if (cn->sm_o_ihdl != 0 && cn->sm_o_ihdl != cn->sm_i_ihdl)
        prom_interpret(enb_str, (caddr32_t)ms->sm_cons_stdout.sm_o_ihdl,
            (caddr32_t)cn->sm_o_ihdl, 0, 0, 0);
}

/*
 * Tell OBP that this device is no longer usable
 */
static void
disable_device(sm_mux_state_t *ms, sm_console_t *cn)
{
    char *dis_str = "\" disable-device\" rot $call-method";

    if (!cn->sm_obp_con)
        return;

    sm_dbg('A', ("ttymux: disabling %d:%d\n",
        getmajor(cn->sm_dev), getminor(cn->sm_dev)));

    if (cn->sm_i_ihdl != 0)
        prom_interpret(dis_str, (caddr32_t)ms->sm_cons_stdin.sm_i_ihdl,
            (caddr32_t)cn->sm_i_ihdl, 0, 0, 0);
    if (cn->sm_o_ihdl != 0 && cn->sm_o_ihdl != cn->sm_i_ihdl)
        prom_interpret(dis_str, (caddr32_t)ms->sm_cons_stdout.sm_o_ihdl,
            (caddr32_t)cn->sm_o_ihdl, 0, 0, 0);
}

static void
device_init_impl(sm_mux_state_t *ms, sm_console_t *cn, sm_lqi_t *plqi)
{
    uint_t      flags = 0;
    dev_info_t  *ldip;

    sm_dbg('I', ("device_init_impl:\n"));

    if (plqi == NULL || cn == NULL)
        return;

    flags = (uint_t)cn->sm_mode;
    sm_dbg('I', ("device_init_impl: flgs %d con %d\n", flags,
            cn->sm_obp_con));
    if (ldip = e_ddi_hold_devi_by_dev(cn->sm_dev, 0)) {

        /*
         * Indicate to the linked device that it is
         * providing a multiplexed console.
         */
        if (flags & (uint_t)FORINPUT)
            (void) e_ddi_prop_create(cn->sm_dev, ldip,
                DDI_PROP_CANSLEEP, "obp-input-console", 0, 0);
        if (flags & (uint_t)FOROUTPUT)
            (void) e_ddi_prop_create(cn->sm_dev, ldip,
                DDI_PROP_CANSLEEP, "obp-output-console", 0, 0);

        ddi_release_devi(ldip);
    }

    if (flags) {
        plqi->sm_ioflag = flags;
        if (cn->sm_obp_con)
            plqi->sm_uqflags |= SM_OBPCNDEV;
        plqi->sm_ctrla_abort_on = sm_ssp->sm_ctrla_abort_on;
        plqi->sm_break_abort_on = sm_ssp->sm_break_abort_on;
    }

    /*
     * Tell OBP that its ok to use this console
     */
    enable_device(ms, cn);
}

static void
device_fini_impl(sm_mux_state_t *ms, sm_console_t *cn, sm_lqi_t *plqi)
{
    dev_info_t  *ldip;

    if (plqi == NULL || cn == NULL)
        return;
    /*
     * Indicate to the linked device that it is no longer
     * providing a multiplexed console.
     */
    if (ldip = e_ddi_hold_devi_by_dev(plqi->sm_dev, 0)) {
        if (plqi->sm_ioflag & (uint_t)FORINPUT)
            (void) e_ddi_prop_remove(plqi->sm_dev,
                ldip, "obp-input-console");
        if (plqi->sm_ioflag & (uint_t)FOROUTPUT)
            (void) e_ddi_prop_remove(plqi->sm_dev,
                ldip, "obp-output-console");

        ddi_release_devi(ldip);
    }
    plqi->sm_ioflag = 0;
    plqi->sm_uqflags &= ~SM_OBPCNDEV;
    disable_device(ms, cn);
}

static int
read_prop(pnode_t node, char *propname, char **propval)
{
    int proplen = prom_getproplen(node, propname);

    if (proplen < 0)
        return (proplen);
    *propval = kmem_zalloc(proplen + 1, KM_SLEEP);
    if (proplen > 0)
        (void) prom_getprop(node, propname, *propval);
    else
        *propval = 0;

    return (proplen);
}

/*
 * Parse a list of tokens
 */
static char *
sm_strtok_r(char *p, char *sep, char **lasts)
{
    char    *e, *tok = NULL;

    if (p == 0 || *p == 0)
        return (NULL);

    e = p + strlen(p);

    do {
        if (strchr(sep, *p) != NULL) {
            if (tok != NULL) {
                *p = 0;
                *lasts = p + 1;
                return (tok);
            }
        } else if (tok == NULL) {
            tok = p;
        }
    } while (++p < e);

    *lasts = NULL;
    if (tok != NULL)
        return (tok);
    return (NULL);
}

/*
 * Add or remove an alias from a property list of aliases:
 * path:    an OBP device path
 * pname:   property name containing a space separated list of aliases
 * append:  if true include the alias for path in the property list
 *      otherwise remove the alias from the list.
 */
static int
upd_config(boolean_t append, char *pname, char *path)
{
    pnode_t     onode, anode;
    size_t      plen;       /* length of property name */
    char        *pval;      /* value of property */
    char        *tok, *lasts;
    char        *aliases[TTYMUX_MAX_LINKS];
    size_t      i, cnt, len;
    boolean_t   found;
    char        *nval, *alias = NULL;

    if ((anode = prom_alias_node()) == OBP_BADNODE ||
        (onode = prom_optionsnode()) == OBP_BADNODE) {
        sm_dbg('I', ("upd_config: no alias or options node.\n"));
        return (1);
    }

    if ((plen = read_prop(onode, pname, &pval)) < 0)
        return (1);

    sm_dbg('I', ("upd_config: %s=%s (%s)\n", pname, pval, path));
    found = B_FALSE;
    for (len = 0, cnt = 0, tok = sm_strtok_r(pval, " \t", &lasts);
        tok != NULL && cnt < TTYMUX_MAX_LINKS;
        tok = sm_strtok_r(lasts, " \t", &lasts)) {
        char    *aval;
        size_t  alen;

        if ((alen = read_prop(anode, tok, &aval)) < 0)
            continue;

        /* does this alias match the requested path */
        if (strcmp(aval, path) == 0 ||
            (strstr(path, aval) != NULL &&
            strchr(aval, ':') == NULL && strchr(path, ':') != NULL &&
            strcmp(strchr(path, ':'), ":a") == 0)) {
            if (!found && append) {
                kmem_free(aval, alen + 1);
                goto out;
            }
            found = B_TRUE;
        } else {
            aliases[cnt++] = tok;
            len += strlen(tok) + 1;
        }
        kmem_free(aval, alen + 1);
    }

    sm_dbg('I', ("%d aliases\n", cnt));
    if (append) {
        if (cnt + 1 == TTYMUX_MAX_LINKS)
            goto out;

        if ((alias = val2alias(anode, path)) == NULL) {
            char *mnode = strstr(path, ":a");

            if (mnode != 0) {
                *mnode = '\0';
                alias = val2alias(anode, path);
                *mnode = ':';
            }
        }
        if (alias == NULL) {
            sm_dbg('I', ("No alias for %s\n", path));
            goto out;
        }
        aliases[cnt++] = alias;
        len += strlen(alias) + 1;
    } else if (!found) {
        goto out;
    }

    sm_dbg('I', ("%d aliases (len %d)\n", cnt, len));
    if (len == 0)
        goto out;
    ASSERT(len > 1 && cnt > 0);

    nval = kmem_zalloc(len, KM_SLEEP);
    for (i = 0; ; ) {
        ASSERT(strlen(nval) + strlen(aliases[i]) + 1 <= len);
        sm_dbg('I', ("alias %s\n", aliases[i]));
        (void) strcat(nval, aliases[i]);
        if (++i == cnt)
            break;
        (void) strcat(nval, " ");
    }

    sm_dbg('I', ("setprop: %s=%s (%d)\n", pname, nval, len));

    (void) prom_setprop(onode, pname, nval, len);

    kmem_free(nval, len);

    if (alias != NULL)
        kmem_free(alias, OBP_MAXPROPNAME);
out:
    sm_dbg('I', ("upd_config: returning.\n"));
    kmem_free(pval, plen + 1);
    return (0);
}

/*
 *
 */
static int
update_config(sm_mux_state_t *ms, char *path, io_mode_t mode, int cmd)
{
    sm_dbg('I', ("update_config: path %s io %d\n", path ? path : "", mode));
    if (path == 0 || *path == 0) {
        sm_dbg('I', ("update_config: EINVAL - no path\n"));
        return (1);
    }
    if (prom_is_openprom() == 0)
        return (0);

    if ((mode & FORINPUT) && ms->sm_ialias != NULL)
        (void) upd_config((cmd == TTYMUX_ASSOC), ms->sm_ialias, path);
    if ((mode & FOROUTPUT) && ms->sm_oalias != NULL)
        (void) upd_config((cmd == TTYMUX_ASSOC), ms->sm_oalias, path);
    return (0);
}

/*
 * Convert a dev_t to a device path
 */
static char *
sm_di_path(dev_t dev)
{
    char *p, *path;

    if (dev == NODEV)
        return (NULL);

    p = kmem_zalloc(MAXPATHLEN + 1, KM_SLEEP);
    if (ddi_dev_pathname(dev, S_IFCHR, p) == DDI_SUCCESS) {
        path = kmem_alloc(strlen(p) + 1, KM_SLEEP);
        (void) strcpy(path, p);
    }
    kmem_free(p, MAXPATHLEN + 1);

    return (path);
}

static int
console_cmd(int cmd, ttymux_assoc_t *assoc)
{
    sm_mux_state_t  *ms;
    sm_console_t    *cn;
    uint_t      j;

    sm_dbg('I', ("console_cmd ENTER: %s\n", cmd == TTYMUX_DISASSOC ?
        "TTYMUX_DISASSOC" : "TTYMUX_ASSOC"));

    if (assoc->ttymux_ldev == NODEV && *assoc->ttymux_path != '/') {
        sm_lqi_t *lqi = get_lqi_byid(assoc->ttymux_linkid);
        if (lqi == 0 || lqi->sm_dev == NODEV) {
            sm_dbg('I', ("console_cmd: no id link %d cmd %d\n",
                assoc->ttymux_linkid, cmd));
            return (EINVAL);
        }
        assoc->ttymux_ldev = lqi->sm_dev;
    }

    sm_dbg('I', ("console_cmd: path %s\n", assoc->ttymux_path));

    if ((ms = (sm_mux_state_t *)space_fetch(TTYMUXPTR)) == 0) {
        sm_dbg('I', ("console_cmd: No muxstate\n"));
        return (0);
    }

    mutex_enter(&ms->sm_cons_mutex);

    for (cn = ms->sm_cons_links, j = 0;
        j < ms->sm_cons_cnt; cn++, j++) {
        if (assoc->ttymux_ldev != NODEV && assoc->ttymux_ldev ==
                cn->sm_dev) {
            break;
        } else if (cn->sm_path != NULL &&
            strncmp(cn->sm_path, assoc->ttymux_path, MAXPATHLEN) == 0) {
            break;
        }
    }

    assoc->ttymux_path[MAXPATHLEN - 1] = 0;
    if (cmd == TTYMUX_DISASSOC) {
        if (j == ms->sm_cons_cnt) {
            mutex_exit(&ms->sm_cons_mutex);
            return (0);
        }

        /*
         * Disable the console in OBP and then delete this console
         * this console - note that this also deletes OBP
         * information - i.e. once it is disassociated it cannot
         * be reused as an OBP console - roll on polled I/O!
         */
        sm_dbg('I', ("console_cmd: cleaning up\n"));
        device_fini_impl(ms, cn, get_lqi_bydevt(assoc->ttymux_ldev));

        if (cn->sm_path == NULL) {
            if (assoc->ttymux_ldev != NODEV)
                cn->sm_path = sm_di_path(assoc->ttymux_ldev);
            else
                (void) update_config(ms, assoc->ttymux_path,
                    assoc->ttymux_ioflag, cmd);
        }
        if (cn->sm_path) {
            (void) update_config(ms, cn->sm_path, cn->sm_mode, cmd);
            kmem_free(cn->sm_path, strlen(cn->sm_path) + 1);
            cn->sm_path = NULL;
        }
        ms->sm_cons_cnt -= 1;
        if (ms->sm_cons_cnt > 0)
            *cn = ms->sm_cons_links[ms->sm_cons_cnt];

        sm_dbg('I', ("console_cmd: console %d removed (cnt %d)\n",
            j, ms->sm_cons_cnt));

    } else if (cmd == TTYMUX_ASSOC) {

        if (j == ms->sm_cons_cnt) {

            if (j == TTYMUX_MAX_LINKS) {
                mutex_exit(&ms->sm_cons_mutex);
                return (ENOMEM);
            }

            ms->sm_cons_cnt += 1;

            bzero((caddr_t)cn, sizeof (*cn));
            cn->sm_dev = assoc->ttymux_ldev;
            cn->sm_muxid = assoc->ttymux_linkid;
            cn->sm_mode = assoc->ttymux_ioflag;
            device_init_impl(ms, cn,
                get_lqi_bydevt(assoc->ttymux_ldev));
        } else {
            cn->sm_dev = assoc->ttymux_ldev;
            cn->sm_muxid = assoc->ttymux_linkid;
            cn->sm_mode = assoc->ttymux_ioflag;
        }

        if (assoc->ttymux_ldev != NODEV) {
            cn->sm_path = sm_di_path(assoc->ttymux_ldev);
        } else {
            cn->sm_path = kmem_alloc(strlen(assoc->ttymux_path) + 1,
                KM_SLEEP);
            (void) strcpy(cn->sm_path, assoc->ttymux_path);
        }
        if (cn->sm_path != NULL)
            (void) update_config(ms, cn->sm_path, cn->sm_mode, cmd);
        else
            sm_dbg('I', ("console_cmd: ASSOC No path info"));
    }
    mutex_exit(&ms->sm_cons_mutex);
    sm_dbg('I', ("console_cmd EXIT: %s\n", cmd == TTYMUX_DISASSOC ?
        "TTYMUX_DISASSOC" : "TTYMUX_ASSOC"));
    return (0);
}

static int
get_unconfigured_consoles(sm_mux_state_t *ms, ttymux_assoc_t *a)
{
    sm_console_t    *cn;
    int     j, cnt;

    if (ms == 0)
        return (0);

    mutex_enter(&ms->sm_cons_mutex);
    for (cn = ms->sm_cons_links, cnt = j = 0; j < ms->sm_cons_cnt;
                            cn++, j++) {
        if (cn->sm_path && get_lqi_bydevt(cn->sm_dev) == NULL) {
            a->ttymux_linkid = cn->sm_muxid;
            a->ttymux_tag = (uint_t)0;
            a->ttymux_ioflag = cn->sm_mode;
            a->ttymux_udev = cn->sm_mode & FORINPUT ?
                        ms->sm_cons_stdin.sm_dev :
                        ms->sm_cons_stdout.sm_dev;
            a->ttymux_ldev = NODEV;
            (void) strncpy(a->ttymux_path, cn->sm_path, MAXPATHLEN);
            cnt++;
            a++;
        }
    }
    mutex_exit(&ms->sm_cons_mutex);
    return (cnt);
}

#ifdef _SYSCALL32_IMPL
/*
 * Look for any consoles that are not currently plumbed under the multiplexer.
 */
static int
get_unconfigured_consoles32(sm_mux_state_t *ms, ttymux_assoc32_t *a)
{
    sm_console_t    *cn;
    int     j, cnt;

    if (ms == 0)
        return (0);

    mutex_enter(&ms->sm_cons_mutex);
    for (cn = ms->sm_cons_links, cnt = j = 0; j < ms->sm_cons_cnt;
                            cn++, j++) {
        sm_dbg('I', ("get_unconfigured_consoles: check %s (%d:%d)",
            cn->sm_path ? cn->sm_path : "NULL",
            getmajor(cn->sm_dev), getminor(cn->sm_dev)));
        if (cn->sm_path && get_lqi_bydevt(cn->sm_dev) == NULL) {
            a->ttymux32_linkid = 0;
            a->ttymux32_tag = (uint32_t)0;
            a->ttymux32_ioflag = (uint32_t)cn->sm_mode;
            a->ttymux32_ldev = NODEV32;
            (void) cmpldev(&a->ttymux32_udev, cn->sm_mode &
                    FORINPUT ? ms->sm_cons_stdin.sm_dev :
                    ms->sm_cons_stdout.sm_dev);

            (void) strncpy(a->ttymux32_path, cn->sm_path,
                    MAXPATHLEN);
            cnt++;
            a++;
        }
    }
    mutex_exit(&ms->sm_cons_mutex);
    return (cnt);
}
#endif

static int
count_unconfigured_consoles(sm_mux_state_t *ms)
{
    sm_console_t    *cn;
    int     j, cnt;

    if (ms == 0)
        return (0);

    mutex_enter(&ms->sm_cons_mutex);
    for (cn = ms->sm_cons_links, cnt = j = 0; j < ms->sm_cons_cnt;
                            cn++, j++) {
        sm_dbg('I', ("cnt_unconfigured_consoles: check %s (%d:%d)",
            cn->sm_path ? cn->sm_path : "NULL",
            getmajor(cn->sm_dev), getminor(cn->sm_dev)));
        if (cn->sm_path && get_lqi_bydevt(cn->sm_dev) == NULL)
            cnt++;
    }
    mutex_exit(&ms->sm_cons_mutex);
    return (cnt);
}

/*
 * Exported interfaces
 */

/*
 * A console device is no longer associated.
 */
int
ttymux_device_fini(sm_lqi_t *plqi)
{
    int     j;
    sm_mux_state_t  *ms;

    ms = (sm_mux_state_t *)space_fetch(TTYMUXPTR);

    if (plqi == NULL || ms == NULL)
        return (0);

    mutex_enter(&ms->sm_cons_mutex);

    for (j = 0; j < ms->sm_cons_cnt; j++) {

        if (ms->sm_cons_links[j].sm_dev == plqi->sm_dev) {

            device_fini_impl(ms, &ms->sm_cons_links[j], plqi);

            mutex_exit(&ms->sm_cons_mutex);
            return (0);
        }
    }
    mutex_exit(&ms->sm_cons_mutex);

    return (1);
}

/*
 * A console device is being introduced.
 */
int
ttymux_device_init(sm_lqi_t *plqi)
{
    int j;
    sm_mux_state_t *ms;

    ms = (sm_mux_state_t *)space_fetch(TTYMUXPTR);

    if (ms == NULL)
        return (0);

    mutex_enter(&ms->sm_cons_mutex);

    for (j = 0; j < ms->sm_cons_cnt; j++) {

        if (ms->sm_cons_links[j].sm_dev == plqi->sm_dev) {

            device_init_impl(ms, &ms->sm_cons_links[j], plqi);

            mutex_exit(&ms->sm_cons_mutex);
            return (0);
        }
    }
    mutex_exit(&ms->sm_cons_mutex);
    return (1);
}

/*
 * Process a TTYMUX_ASSOCIATE or TTYMUX_DISASSOCIATE ioctl.
 */
static int
ttymux_link_ioctl(mblk_t *mp)
{
    ttymux_assoc_t  assoc;
    int     err;
    sm_lqi_t        *lqi;
    struct iocblk   *iobp = (struct iocblk *)mp->b_rptr;
    dev_t       cidev, codev;

    sm_dbg('I', ("ttymux_link_ioctl:\n"));
    if ((err = mblk2assoc(mp, &assoc)) != 0)
        return (err);

    sm_dbg('I', ("uminor is %d\n", getminor(assoc.ttymux_udev)));

    if (assoc.ttymux_udev == NODEV)
        return (EINVAL);

    err = 0;

    if ((lqi = get_lqi_bydevt(assoc.ttymux_ldev)) == NULL) {
        if (assoc.ttymux_linkid < 0)
            err = EINVAL;
        else if ((lqi = get_lqi_byid(assoc.ttymux_linkid)) == 0)
            err = ENOLINK;
    }

    if (sm_ssp->sm_ms) {
        mutex_enter(&sm_ssp->sm_ms->sm_cons_mutex);
        cidev = sm_ssp->sm_ms->sm_cons_stdin.sm_dev;
        codev = sm_ssp->sm_ms->sm_cons_stdout.sm_dev;
        mutex_exit(&sm_ssp->sm_ms->sm_cons_mutex);
    } else {
        cidev = codev = NODEV;
    }

    if (err != 0) {
        if (assoc.ttymux_udev != cidev && assoc.ttymux_udev != codev)
            return (err);
        (void) console_cmd(iobp->ioc_cmd, &assoc);
        return (0);
    } else if (assoc.ttymux_udev == cidev || assoc.ttymux_udev == codev) {
        (void) console_cmd(iobp->ioc_cmd, &assoc);
    }

    if (iobp->ioc_cmd == TTYMUX_ASSOC)
        return (sm_associate(sm_dev2unit(assoc.ttymux_udev),
            lqi, assoc.ttymux_tag, assoc.ttymux_ioflag,
            assoc.ttymux_path));
    else if (iobp->ioc_cmd == TTYMUX_DISASSOC)
        return (sm_disassociate(sm_dev2unit(assoc.ttymux_udev),
            lqi, assoc.ttymux_tag));

    return (0);
}

/*
 * Process a TTYMUX_GETLINK ioctl.
 */
int
ttymux_query_link_ioctl(mblk_t *mp)
{
    sm_lqi_t        *lqi;

    struct iocblk *iobp = (struct iocblk *)mp->b_rptr;

    sm_dbg('I', ("ttymux_query_link_ioctl:\n"));

    if (mp->b_cont == NULL)
        return (EINVAL);

#ifdef _SYSCALL32_IMPL
    if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
        ttymux_assoc32_t    *assoc32;
        ttymux_assoc_t  assoc;

        if (mblk2assoc(mp, &assoc) != 0)
            return (EINVAL);

        if ((lqi = get_lqi_bydevt(assoc.ttymux_ldev)) == NULL &&
            (lqi = get_lqi_byid(assoc.ttymux_linkid)) == NULL) {
            sm_dbg('M', ("Query Link (%d): dev %d:%d not found\n",
                assoc.ttymux_linkid,
                getmajor(assoc.ttymux_ldev),
                getminor(assoc.ttymux_ldev)));
            return (ENOLINK);
        }
        assoc32 = (ttymux_assoc32_t *)mp->b_cont->b_rptr;
        LQI2ASSOC32(assoc32, lqi);
    } else
#endif
    {
        ttymux_assoc_t  *assoc;

        if (iobp->ioc_count < sizeof (ttymux_assoc_t))
            return (EINVAL);

        assoc = (ttymux_assoc_t *)mp->b_cont->b_rptr;
        if ((lqi = get_lqi_bydevt(assoc->ttymux_ldev)) == NULL &&
            (lqi = get_lqi_byid(assoc->ttymux_linkid)) == NULL) {
            return (ENOLINK);
        }
        LQI2ASSOC(assoc, lqi);
    }
    return (0);
}

/*
 * Response to receiving an M_IOCDATA message for the TTYMUX_LIST ioctl.
 */
static int
sm_iocresp(mblk_t *mp)
{
    struct copyresp *csp = (struct copyresp *)mp->b_rptr;
    struct iocblk   *iobp = (struct iocblk *)mp->b_rptr;
    mblk_t      *pmp;

    sm_dbg('M', ("(M_IOCDATA: cmd %d)\n", csp->cp_cmd));

    if (csp->cp_cmd != TTYMUX_LIST) {
        sm_dbg('M', ("(M_IOCDATA: unknown cmd)\n"));
        DB_TYPE(mp) = M_IOCNAK;
        return (EINVAL);
    }
    if (csp->cp_rval) {
        if (csp->cp_private)
            freemsg((mblk_t *)csp->cp_private);

        sm_dbg('M', ("M_IOCDATA: result is %d\n", csp->cp_rval));
        DB_TYPE(mp) = M_IOCNAK;
        iobp->ioc_error = (int)(uintptr_t)csp->cp_rval;
        iobp->ioc_rval = 0;
        return (iobp->ioc_error);
    }

    pmp = (mblk_t *)csp->cp_private;

#ifdef _SYSCALL32_IMPL
    if ((csp->cp_flag & IOC_MODELS) != IOC_NATIVE) {
        iobp->ioc_count = sizeof (ttymux_assocs32_t);
        iobp->ioc_rval = pmp == NULL ? 0 :
            ((ttymux_assocs32_t *)pmp->b_rptr)->ttymux32_nlinks;
    } else
#endif
    {
        iobp->ioc_count = sizeof (ttymux_assocs_t);
        iobp->ioc_rval = pmp == NULL ? 0 :
            ((ttymux_assocs_t *)pmp->b_rptr)->ttymux_nlinks;

    }

    DB_TYPE(mp) = (pmp) ? M_IOCACK : M_IOCNAK;
    mp->b_wptr = mp->b_rptr + sizeof (struct iocblk);

    if (mp->b_cont)
        freemsg(unlinkb(mp));
    if (pmp)
        linkb(mp, pmp);
    else
        iobp->ioc_count = 0;

    iobp->ioc_error = 0;

    sm_dbg('M', ("(M_IOCDATA: rval %d cnt %d private 0x%p)\n",
        iobp->ioc_rval, iobp->ioc_count, pmp));
    return (0);
}

/*
 * Process a TTYMUX_LIST ioctl.
 */
int
ttymux_query_links_ioctl(mblk_t *mp)
{
    struct iocblk   *iobp = (struct iocblk *)mp->b_rptr;
    struct copyreq  *cqp;
    int     unit;
    sm_lqi_t        *lqi;
    mblk_t      *nmp;
    int     cnt;
    void        *asl;
    void        *uaddr;
    size_t      sz;

    if (DB_TYPE(mp) == M_IOCDATA) {
        return (sm_iocresp(mp));
    }
    /*
     * Is this a query for the number of linked devices?
     */
    if (iobp->ioc_count == 0) {

        for (unit = 0, iobp->ioc_rval = 0;
            unit < MAX_LQS && (lqi = get_lqi(sm_ssp, unit));
            unit++)
            if (lqi->sm_linkid != 0)
                iobp->ioc_rval += 1;

        iobp->ioc_rval += count_unconfigured_consoles(sm_ssp->sm_ms);
        DB_TYPE(mp) = M_IOCACK;
        iobp->ioc_error = 0;

        return (0);
    }

    if (mp->b_cont == NULL) {
        sm_dbg('Y', ("TTYMUX_LIST: b_cont is NULL\n"));
        DB_TYPE(mp) = M_IOCNAK;
        iobp->ioc_error = EINVAL;
        return (EINVAL);
    }

    asl = mp->b_cont->b_rptr;

#ifdef _SYSCALL32_IMPL
    if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
        cnt = ((ttymux_assocs32_t *)asl)->ttymux32_nlinks;
        sz = cnt * sizeof (ttymux_assoc32_t);
        uaddr = (void *)(uintptr_t)
            ((ttymux_assocs32_t *)asl)->ttymux32_assocs;
    } else
#endif
    {
        cnt = ((ttymux_assocs_t *)asl)->ttymux_nlinks;
        sz = cnt * sizeof (ttymux_assoc_t);
        uaddr = (void *)((ttymux_assocs_t *)asl)->ttymux_assocs;
    }
    if ((nmp = sm_allocb(sz, BPRI_MED)) == NULL) {
        DB_TYPE(mp) = M_IOCNAK;
        iobp->ioc_error = EINVAL;
        return (EAGAIN);
    }

    sm_dbg('Y', ("TTYMUX_LIST: cnt %d sz %d uaddr 0x%p\n", cnt, sz, uaddr));

    iobp->ioc_rval = 0;

#ifdef _SYSCALL32_IMPL
    if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
        ttymux_assoc32_t    *assoc;

        sm_dbg('Y', ("!Native: %d structures\n", cnt));
        assoc = (ttymux_assoc32_t *)nmp->b_rptr;

        for (unit = 0;
            unit < MAX_LQS && (lqi = get_lqi(sm_ssp, unit));
            unit++) {
            if (lqi->sm_linkid != 0) {
                if (cnt-- == 0)
                    break;
                LQI2ASSOC32(assoc, lqi);
                assoc++;
                iobp->ioc_rval += 1;
            }
        }
        if (cnt > 0) {
            /* see if there are unconfigured consoles */
            iobp->ioc_rval +=
                get_unconfigured_consoles32(sm_ssp->sm_ms, assoc);
            sm_dbg('I', ("%d unconfigured consoles\n",
                iobp->ioc_rval));
        } else {
            sm_dbg('I', ("no more space in user addr\n"));
        }
        ((ttymux_assocs32_t *)asl)->ttymux32_nlinks = iobp->ioc_rval;
    } else
#endif
    {
        ttymux_assoc_t  *assoc;

        sm_dbg('Y', ("!Native: %d structures\n", cnt));
        assoc = (ttymux_assoc_t *)nmp->b_wptr;

        for (unit = 0;
            unit < MAX_LQS && (lqi = get_lqi(sm_ssp, unit));
            unit++) {
            if (lqi->sm_linkid != 0) {
                if (cnt-- == 0)
                    break;
                LQI2ASSOC(assoc, lqi);
                assoc++;
                iobp->ioc_rval += 1;
            }
        }
        if (cnt > 0) {
            /* see if there are unconfigured consoles */
            iobp->ioc_rval +=
                get_unconfigured_consoles(sm_ssp->sm_ms, assoc);
            sm_dbg('I', ("%d unconfigured consoles\n",
                iobp->ioc_rval));
        } else {
            sm_dbg('I', ("no more space in user addr\n"));
        }
        ((ttymux_assocs_t *)asl)->ttymux_nlinks = iobp->ioc_rval;
    }

    cqp = (struct copyreq *)mp->b_rptr;
    cqp->cq_addr = uaddr;
    cqp->cq_size = sz;
    cqp->cq_flag = 0;
    cqp->cq_private = mp->b_cont;
    mp->b_cont = nmp;
    nmp->b_wptr = nmp->b_rptr + sz;

    DB_TYPE(mp) = M_COPYOUT;
    mp->b_wptr = mp->b_rptr + sizeof (struct copyreq);

    return (0);
}

/*
 * Process a TTYMUX_CONSDEV ioctl.
 */
static int
ttymux_console_ioctl(mblk_t *mp)
{
    struct iocblk *iobp = (struct iocblk *)mp->b_rptr;
    int err = EINVAL;

    sm_dbg('I', ("ttymux_console_ioctl:\n"));
#ifdef _SYSCALL32_IMPL
    if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
        if (mp->b_cont && iobp->ioc_count >= sizeof (dev32_t)) {
            dev32_t dev;

            (void) cmpldev(&dev, rconsdev);

            *(dev32_t *)mp->b_cont->b_rptr = dev;
            mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof (dev);
            iobp->ioc_count = sizeof (dev);
            err = 0;
        } else {
            sm_dbg('I', ("TTYMUX_CONSDEV: b_cont 0x%p count %d\n",
                mp->b_cont, iobp->ioc_count));
        }
    } else
#endif
    if (mp->b_cont && iobp->ioc_count >= sizeof (dev_t)) {
        *(dev_t *)mp->b_cont->b_rptr = rconsdev;
        mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof (rconsdev);
        iobp->ioc_count = sizeof (rconsdev);
        err = 0;
    }
    return (err);
}

/*
 * Process a ioctl relating to aborting on the console.
 */
int
ttymux_abort_ioctl(mblk_t *mp)
{
    struct iocblk   *iobp;
    int     cmd, err = 0;
    sm_lqi_t        *lqi;
    ttymux_abort_t  *abreq;
#ifdef _SYSCALL32_IMPL
    struct ttymux_abort32 {
        dev32_t         ldev;
        enum ttymux_break_type  method;
        uint32_t        enable;
    } *abreq32;
#endif
    dev_t           ldev;
    enum ttymux_break_type  method;
    uint_t          enable;

    iobp = (struct iocblk *)mp->b_rptr;
    cmd = iobp->ioc_cmd;

    iobp->ioc_error = 0;
    iobp->ioc_rval = 0;
    sm_dbg('I', ("ttymux_abort_ioctl:\n"));
    switch (cmd) {
    case CONSSETABORTENABLE:
        lqi = (sm_ssp->sm_lconsole) ? sm_ssp->sm_lconsole->sm_lqs : 0;
        enable = (*(intptr_t *)mp->b_cont->b_rptr) ? 1 : 0;
        sm_ssp->sm_ctrla_abort_on = sm_ssp->sm_break_abort_on = enable;
        for (; lqi != 0; lqi = lqi->sm_nlqi) {
            lqi->sm_ctrla_abort_on = enable;
            lqi->sm_break_abort_on = enable;
        }
        break;
    case CONSGETABORTENABLE:
        if (mp->b_cont == 0 || iobp->ioc_count < sizeof (intptr_t)) {
            iobp->ioc_error = EINVAL;
            iobp->ioc_rval = -1;
        } else {
            *(intptr_t *)mp->b_cont->b_rptr =
                (sm_ssp->sm_ctrla_abort_on ||
                sm_ssp->sm_break_abort_on);
            mp->b_cont->b_wptr =
                mp->b_cont->b_rptr + sizeof (intptr_t);
            iobp->ioc_count = sizeof (intptr_t);
        }
        break;
    case TTYMUX_GETABORTSTR:

        if (iobp->ioc_count < strlen(sm_ssp->sm_abs) + 1 ||
            mp->b_cont == 0 ||
            mp->b_cont->b_cont) {
            iobp->ioc_error = EINVAL;
            iobp->ioc_rval = -1;
        } else {
            (void) strcpy((char *)mp->b_cont->b_rptr,
                    sm_ssp->sm_abs);
            iobp->ioc_count = strlen(sm_ssp->sm_abs) + 1;
            mp->b_cont->b_wptr =
                mp->b_cont->b_rptr + iobp->ioc_count;
        }
        break;
    case TTYMUX_GETABORT:
    case TTYMUX_SETABORT:

        lqi = 0;
#ifdef _SYSCALL32_IMPL
        if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
            if (iobp->ioc_count < sizeof (*abreq32) ||
                mp->b_cont == 0) {
                err = EINVAL;
            } else {
                abreq32 = (struct ttymux_abort32 *)
                    mp->b_cont->b_rptr;
                ldev = expldev(abreq32->ldev);
                method = abreq32->method;
                enable = (uint_t)abreq32->enable;
                iobp->ioc_count = sizeof (*abreq32);
            }
        } else
#endif
        if (iobp->ioc_count < sizeof (*abreq) ||
            mp->b_cont == 0) {
            err = EINVAL;
        } else {
            abreq = (ttymux_abort_t *)mp->b_cont->b_rptr;
            ldev = abreq->ttymux_ldev;
            method = abreq->ttymux_method;
            enable = abreq->ttymux_enable;
            iobp->ioc_count = sizeof (*abreq);
        }

        if (err != 0) {
            iobp->ioc_rval = -1;
            return ((iobp->ioc_error = err));
        }

        sm_dbg('Y', ("ttymux_abort_ioctl: type %d how %d ldev %d:%d\n",
            method, enable, getmajor(ldev), getminor(ldev)));

        lqi = get_lqi_bydevt(ldev);
        if (ldev != NODEV && lqi == 0) {
            err = ENOLINK;
        } else if (cmd == TTYMUX_GETABORT && lqi == 0) {
            err = ENODEV;
        } else if (cmd == TTYMUX_GETABORT) {
            if (lqi->sm_break_abort_on == 0 &&
                lqi->sm_ctrla_abort_on == 0) {
                method = SOFTHARD_BREAK;
                enable = 0;
            } else {
                enable = 1;
                if (lqi->sm_break_abort_on == 0)
                    method = SOFTWARE_BREAK;
                else if (lqi->sm_ctrla_abort_on == 0)
                    method = HARDWARE_BREAK;
                else
                    method = SOFTHARD_BREAK;
            }

#ifdef _SYSCALL32_IMPL
            if ((iobp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
                abreq32->method = method;
                abreq32->enable = (uint32_t)enable;
            } else
#endif
            {
                abreq->ttymux_method = method;
                abreq->ttymux_enable = enable;
            }
        } else {
            iobp->ioc_count = 0;
            sm_dbg('I', ("lqi is 0x%p\n", lqi));
            if (lqi == 0) {
                if (method == HARDWARE_BREAK)
                    sm_ssp->sm_break_abort_on = enable;
                else if (method == SOFTWARE_BREAK)
                    sm_ssp->sm_ctrla_abort_on = enable;
                else if (method == SOFTHARD_BREAK) {
                    sm_ssp->sm_break_abort_on = enable;
                    sm_ssp->sm_ctrla_abort_on = enable;
                } else {
                    sm_dbg('I', ("%d - invalid\n", method));
                    iobp->ioc_rval = -1;
                    return ((iobp->ioc_error = EINVAL));
                }

                if (sm_ssp->sm_lconsole) {
                    sm_dbg('I', ("lconsole 0x%p (0x%p)\n",
                        sm_ssp->sm_lconsole,
                        sm_ssp->sm_lconsole->sm_lqs));
                } else {
                    sm_dbg('I', ("lconsole is null\n"));
                }

                lqi = (sm_ssp->sm_lconsole) ?
                    sm_ssp->sm_lconsole->sm_lqs : 0;
            }
            while (lqi) {
                if (method == HARDWARE_BREAK)
                    lqi->sm_break_abort_on = enable;
                else if (method == SOFTWARE_BREAK)
                    lqi->sm_ctrla_abort_on = enable;
                else if (method == SOFTHARD_BREAK) {
                    lqi->sm_break_abort_on = enable;
                    lqi->sm_ctrla_abort_on = enable;
                } else {
                    sm_dbg('I', ("%d: invalid\n", method));
                    iobp->ioc_rval = -1;
                    return ((iobp->ioc_error = EINVAL));
                }

                lqi = (ldev == NODEV) ? lqi->sm_nlqi : 0;
            }
        }
        iobp->ioc_rval = err ? -1 : 0;
        iobp->ioc_error = err;
        break;
    default:
        iobp->ioc_rval = -1;
        iobp->ioc_error = EINVAL;
    }
    return (iobp->ioc_error);
}

/*
 * Process ioctls specific to the ttymux driver.
 */
/*ARGSUSED*/
int
sm_ioctl_cmd(sm_uqi_t *uqi, mblk_t *mp)
{
    struct iocblk *iobp = (struct iocblk *)mp->b_rptr;

    iobp->ioc_rval = 0;

    /*
     * This routine does not support transparent ioctls
     */
    if (iobp->ioc_count == TRANSPARENT) {
        sm_dbg('Y', ("sm_ioctl_cmd: unsupported ioctl\n"));
        iobp->ioc_error = ENOTSUP;
        DB_TYPE(mp) = M_IOCNAK;
        if (mp->b_cont)
            freemsg(unlinkb(mp));
        return (ENOTSUP);
    }

    switch (iobp->ioc_cmd) {
    case TTYMUX_CONSDEV:
        iobp->ioc_error = ttymux_console_ioctl(mp);
        break;
    case TTYMUX_ASSOC:
    case TTYMUX_DISASSOC:
        iobp->ioc_error = ttymux_link_ioctl(mp);
        break;
    case TTYMUX_GETLINK:
        iobp->ioc_error = ttymux_query_link_ioctl(mp);
        break;
    case TTYMUX_LIST:
        return (ttymux_query_links_ioctl(mp));
    case TTYMUX_SETCTL:
    case TTYMUX_GETCTL:
        iobp->ioc_error = ENOTSUP;
        break;
    case TTYMUX_GETABORTSTR:
    case TTYMUX_SETABORT:
    case TTYMUX_GETABORT:
        iobp->ioc_error = ttymux_abort_ioctl(mp);
        break;
    default:
        iobp->ioc_error = EINVAL;
        break;
    }

    DB_TYPE(mp) = iobp->ioc_error ? M_IOCNAK : M_IOCACK;

    if ((iobp->ioc_error || iobp->ioc_count == 0) && mp->b_cont)
        freemsg(unlinkb(mp));

    sm_dbg('I', ("TTYMUX IOCTL: err %d rval %d count %d\n",
        iobp->ioc_error, iobp->ioc_rval, iobp->ioc_count));

    return (iobp->ioc_error);
}