6069 libdisasm: instrlen arch op should have a sane default

[illumos-gate.git] / usr / src / lib / libdevinfo / devfsmap.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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#ifdef  lint
#define _REENTRANT      /* for localtime_r */
#endif

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <sys/types.h>
#include <strings.h>
#include <stdarg.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <stropts.h>
#include <time.h>
#include <sys/param.h>
#include <sys/vfstab.h>
#include <dirent.h>
#ifdef __sparc
#include <sys/scsi/adapters/scsi_vhci.h>
#include <sys/sunmdi.h>
#endif /* __sparc */
#include "libdevinfo.h"
#include "device_info.h"
#include <regex.h>

#define isnewline(ch)   ((ch) == '\n' || (ch) == '\r' || (ch) == '\f')
#define isnamechar(ch)  (isalpha(ch) || isdigit(ch) || (ch) == '_' ||\
        (ch) == '-')
#define MAX_TOKEN_SIZE  1024
#define BUFSIZE         1024
#define STRVAL(s)       ((s) ? (s) : "NULL")

#define SCSI_VHCI_CONF          "/kernel/drv/scsi_vhci.conf"
#define QLC_CONF                "/kernel/drv/qlc.conf"
#define FP_CONF                 "/kernel/drv/fp.conf"
#define DRIVER_CLASSES          "/etc/driver_classes"
#define FP_AT                   "fp@"
#define VHCI_CTL_NODE           "/devices/scsi_vhci:devctl"
#define SLASH_DEVICES           "/devices"
#define SLASH_DEVICES_SLASH     "/devices/"
#define SLASH_FP_AT             "/fp@"
#define SLASH_SCSI_VHCI         "/scsi_vhci"
#define META_DEV                "/dev/md/dsk/"
#define SLASH_DEV_SLASH         "/dev/"

/*
 * Macros to produce a quoted string containing the value of a
 * preprocessor macro. For example, if SIZE is defined to be 256,
 * VAL2STR(SIZE) is "256". This is used to construct format
 * strings for scanf-family functions below.
 */
#define QUOTE(x)        #x
#define VAL2STR(x)      QUOTE(x)

typedef enum {
        CLIENT_TYPE_UNKNOWN,
        CLIENT_TYPE_PHCI,
        CLIENT_TYPE_VHCI
} client_type_t;

typedef enum {
        T_EQUALS,
        T_AMPERSAND,
        T_BIT_OR,
        T_STAR,
        T_POUND,
        T_COLON,
        T_SEMICOLON,
        T_COMMA,
        T_SLASH,
        T_WHITE_SPACE,
        T_NEWLINE,
        T_EOF,
        T_STRING,
        T_HEXVAL,
        T_DECVAL,
        T_NAME
} token_t;

typedef enum {
        begin, parent, drvname, drvclass, prop,
        parent_equals, name_equals, drvclass_equals,
        parent_equals_string, name_equals_string,
        drvclass_equals_string,
        prop_equals, prop_equals_string, prop_equals_integer,
        prop_equals_string_comma, prop_equals_integer_comma
} conf_state_t;

/* structure to hold entries with mpxio-disable property in driver.conf file */
struct conf_entry {
        char *name;
        char *parent;
        char *class;
        char *unit_address;
        int port;
        int mpxio_disable;
        struct conf_entry *next;
};

struct conf_file {
        char *filename;
        FILE *fp;
        int linenum;
};

static char *tok_err = "Unexpected token '%s'\n";


/* #define      DEBUG */

#ifdef DEBUG

int devfsmap_debug = 0;
/* /var/run is not mounted at install time. Therefore use /tmp */
char *devfsmap_logfile = "/tmp/devfsmap.log";
static FILE *logfp;
#define logdmsg(args)   log_debug_msg args
static void vlog_debug_msg(char *, va_list);
static void log_debug_msg(char *, ...);
#ifdef __sparc
static void log_confent_list(char *, struct conf_entry *, int);
static void log_pathlist(char **);
#endif /* __sparc */

#else /* DEBUG */
#define logdmsg(args)   /* nothing */
#endif /* DEBUG */


/*
 * Leave NEWLINE as the next character.
 */
static void
find_eol(FILE *fp)
{
        int ch;

        while ((ch = getc(fp)) != EOF) {
                if (isnewline(ch)) {
                        (void) ungetc(ch, fp);
                        break;
                }
        }
}

/* ignore parsing errors */
/*ARGSUSED*/
static void
file_err(struct conf_file *filep, char *fmt, ...)
{
#ifdef DEBUG
        va_list ap;

        va_start(ap, fmt);
        log_debug_msg("WARNING: %s line # %d: ",
            filep->filename, filep->linenum);
        vlog_debug_msg(fmt, ap);
        va_end(ap);
#endif /* DEBUG */
}

/* return the next token from the given driver.conf file, or -1 on error */
static token_t
lex(struct conf_file *filep, char *val, size_t size)
{
        char    *cp;
        int     ch, oval, badquote;
        size_t  remain;
        token_t token;
        FILE    *fp = filep->fp;

        if (size < 2)
                return (-1);

        cp = val;
        while ((ch = getc(fp)) == ' ' || ch == '\t')
                ;

        remain = size - 1;
        *cp++ = (char)ch;
        switch (ch) {
        case '=':
                token = T_EQUALS;
                break;
        case '&':
                token = T_AMPERSAND;
                break;
        case '|':
                token = T_BIT_OR;
                break;
        case '*':
                token = T_STAR;
                break;
        case '#':
                token = T_POUND;
                break;
        case ':':
                token = T_COLON;
                break;
        case ';':
                token = T_SEMICOLON;
                break;
        case ',':
                token = T_COMMA;
                break;
        case '/':
                token = T_SLASH;
                break;
        case ' ':
        case '\t':
        case '\f':
                while ((ch = getc(fp)) == ' ' ||
                    ch == '\t' || ch == '\f') {
                        if (--remain == 0) {
                                *cp = '\0';
                                return (-1);
                        }
                        *cp++ = (char)ch;
                }
                (void) ungetc(ch, fp);
                token = T_WHITE_SPACE;
                break;
        case '\n':
        case '\r':
                token = T_NEWLINE;
                break;
        case '"':
                remain++;
                cp--;
                badquote = 0;
                while (!badquote && (ch  = getc(fp)) != '"') {
                        switch (ch) {
                        case '\n':
                        case EOF:
                                file_err(filep, "Missing \"\n");
                                remain = size - 1;
                                cp = val;
                                *cp++ = '\n';
                                badquote = 1;
                                /* since we consumed the newline/EOF */
                                (void) ungetc(ch, fp);
                                break;

                        case '\\':
                                if (--remain == 0) {
                                        *cp = '\0';
                                        return (-1);
                                }
                                ch = (char)getc(fp);
                                if (!isdigit(ch)) {
                                        /* escape the character */
                                        *cp++ = (char)ch;
                                        break;
                                }
                                oval = 0;
                                while (ch >= '0' && ch <= '7') {
                                        ch -= '0';
                                        oval = (oval << 3) + ch;
                                        ch = (char)getc(fp);
                                }
                                (void) ungetc(ch, fp);
                                /* check for character overflow? */
                                if (oval > 127) {
                                        file_err(filep,
                                            "Character "
                                            "overflow detected.\n");
                                }
                                *cp++ = (char)oval;
                                break;
                        default:
                                if (--remain == 0) {
                                        *cp = '\0';
                                        return (-1);
                                }
                                *cp++ = (char)ch;
                                break;
                        }
                }
                token = T_STRING;
                break;

        case EOF:
                token = T_EOF;
                break;

        default:
                /*
                 * detect a lone '-' (including at the end of a line), and
                 * identify it as a 'name'
                 */
                if (ch == '-') {
                        if (--remain == 0) {
                                *cp = '\0';
                                return (-1);
                        }
                        *cp++ = (char)(ch = getc(fp));
                        if (ch == ' ' || ch == '\t' || ch == '\n') {
                                (void) ungetc(ch, fp);
                                remain++;
                                cp--;
                                token = T_NAME;
                                break;
                        }
                } else if (ch == '~' || ch == '-') {
                        if (--remain == 0) {
                                *cp = '\0';
                                return (-1);
                        }
                        *cp++ = (char)(ch = getc(fp));
                }


                if (isdigit(ch)) {
                        if (ch == '0') {
                                if ((ch = getc(fp)) == 'x') {
                                        if (--remain == 0) {
                                                *cp = '\0';
                                                return (-1);
                                        }
                                        *cp++ = (char)ch;
                                        ch = getc(fp);
                                        while (isxdigit(ch)) {
                                                if (--remain == 0) {
                                                        *cp = '\0';
                                                        return (-1);
                                                }
                                                *cp++ = (char)ch;
                                                ch = getc(fp);
                                        }
                                        (void) ungetc(ch, fp);
                                        token = T_HEXVAL;
                                } else {
                                        goto digit;
                                }
                        } else {
                                ch = getc(fp);
digit:
                                while (isdigit(ch)) {
                                        if (--remain == 0) {
                                                *cp = '\0';
                                                return (-1);
                                        }
                                        *cp++ = (char)ch;
                                        ch = getc(fp);
                                }
                                (void) ungetc(ch, fp);
                                token = T_DECVAL;
                        }
                } else if (isalpha(ch) || ch == '\\') {
                        if (ch != '\\') {
                                ch = getc(fp);
                        } else {
                                /*
                                 * if the character was a backslash,
                                 * back up so we can overwrite it with
                                 * the next (i.e. escaped) character.
                                 */
                                remain++;
                                cp--;
                        }
                        while (isnamechar(ch) || ch == '\\') {
                                if (ch == '\\')
                                        ch = getc(fp);
                                if (--remain == 0) {
                                        *cp = '\0';
                                        return (-1);
                                }
                                *cp++ = (char)ch;
                                ch = getc(fp);
                        }
                        (void) ungetc(ch, fp);
                        token = T_NAME;
                } else {
                        return (-1);
                }
                break;
        }

        *cp = '\0';

        return (token);
}

#ifdef __sparc

static void
free_confent(struct conf_entry *confent)
{
        if (confent->name)
                free(confent->name);
        if (confent->parent)
                free(confent->parent);
        if (confent->class)
                free(confent->class);
        if (confent->unit_address)
                free(confent->unit_address);
        free(confent);
}

static void
free_confent_list(struct conf_entry *confent_list)
{
        struct conf_entry *confent, *next;

        for (confent = confent_list; confent != NULL; confent = next) {
                next = confent->next;
                free_confent(confent);
        }
}

/*
 * Parse the next entry from the driver.conf file and return in the form of
 * a pointer to the conf_entry.
 */
static struct conf_entry *
parse_conf_entry(struct conf_file *filep, char *tokbuf, size_t linesize)
{
        char *prop_name, *string;
        token_t token;
        struct conf_entry *confent;
        conf_state_t state;
        int failed = 1;

        if ((confent = calloc(1, sizeof (*confent))) == NULL)
                return (NULL);

        confent->port = -1;
        confent->mpxio_disable = -1;

        state = begin;
        token = T_NAME;
        prop_name = NULL;
        string = NULL;
        do {
                switch (token) {
                case T_NAME:
                        switch (state) {
                        case prop_equals_string:
                        case prop_equals_integer:
                        case begin:
                                state = prop;
                                if ((prop_name = strdup(tokbuf)) == NULL)
                                        goto bad;
                                break;
                        default:
                                file_err(filep, tok_err, tokbuf);
                        }
                        break;
                case T_EQUALS:
                        switch (state) {
                        case prop:
                                state = prop_equals;
                                break;
                        default:
                                file_err(filep, tok_err, tokbuf);
                        }
                        break;
                case T_STRING:
                        switch (state) {
                        case prop_equals:
                                if ((string = strdup(tokbuf)) == NULL)
                                        goto bad;

                                state = begin;
                                if (strcmp(prop_name, "PARENT") == 0 ||
                                    strcmp(prop_name, "parent") == 0) {
                                        if (confent->parent) {
                                                file_err(filep,
                                "'parent' property already specified\n");
                                                goto bad;
                                        }
                                        confent->parent = string;
                                } else if (strcmp(prop_name, "NAME") == 0 ||
                                    strcmp(prop_name, "name") == 0) {
                                        if (confent->name) {
                                                file_err(filep,
                                "'name' property already specified\n");
                                                goto bad;
                                        }
                                        confent->name = string;
                                } else if (strcmp(prop_name, "CLASS") == 0 ||
                                    strcmp(prop_name, "class") == 0) {
                                        if (confent->class) {
                                                file_err(filep,
                                "'class' property already specified\n");
                                                goto bad;
                                        }
                                        confent->class = string;
                                } else if (strcmp(prop_name, "unit-address")
                                    == 0) {
                                        if (confent->unit_address) {
                                                file_err(filep,
                                "'unit-address' property already specified\n");
                                                goto bad;
                                        }
                                        confent->unit_address = string;
                                } else if (strcmp(prop_name, "mpxio-disable")
                                    == 0) {
                                        if (confent->mpxio_disable != -1) {
                                                file_err(filep,
                                "'mpxio-disable' property already specified\n");
                                                goto bad;
                                        }
                                        if (strcmp(string, "yes") == 0)
                                                confent->mpxio_disable = 1;
                                        else if (strcmp(string, "no") == 0)
                                                confent->mpxio_disable = 0;
                                        else {
                                                file_err(filep,
                                "'mpxio-disable' property setting is invalid. "
                                "The value must be either \"yes\" or \"no\"\n");
                                                goto bad;
                                        }
                                        free(string);
                                } else {
                                        free(string);
                                        state = prop_equals_string;
                                }
                                string = NULL;
                                free(prop_name);
                                prop_name = NULL;
                                break;

                        case prop_equals_string_comma:
                                state = prop_equals_string;
                                break;
                        default:
                                file_err(filep, tok_err, tokbuf);
                        }
                        break;
                case T_HEXVAL:
                case T_DECVAL:
                        switch (state) {
                        case prop_equals:
                                if (strcmp(prop_name, "port") == 0) {
                                        if (confent->port != -1) {
                                                file_err(filep,
                                        "'port' property already specified\n");
                                                goto bad;
                                        }
                                        confent->port =
                                            (int)strtol(tokbuf, NULL, 0);
                                        state = begin;
                                } else
                                        state = prop_equals_integer;
                                free(prop_name);
                                prop_name = NULL;
                                break;

                        case prop_equals_integer_comma:
                                state = prop_equals_integer;
                                break;
                        default:
                                file_err(filep, tok_err, tokbuf);
                        }
                        break;
                case T_COMMA:
                        switch (state) {
                        case prop_equals_string:
                                state = prop_equals_string_comma;
                                break;
                        case prop_equals_integer:
                                state = prop_equals_integer_comma;
                                break;
                        default:
                                file_err(filep, tok_err, tokbuf);
                        }
                        break;
                case T_NEWLINE:
                        filep->linenum++;
                        break;
                case T_POUND:
                        find_eol(filep->fp);
                        break;
                case T_EOF:
                        file_err(filep, "Unexpected EOF\n");
                        goto bad;
                default:
                        file_err(filep, tok_err, tokbuf);
                        goto bad;
                }
        } while ((token = lex(filep, tokbuf, linesize)) != T_SEMICOLON);

        failed = 0;

bad:
        if (prop_name)
                free(prop_name);
        if (string)
                free(string);
        if (failed == 1) {
                free_confent(confent);
                return (NULL);
        }
        return (confent);
}

/*
 * Parse all entries with mpxio-disable property in the given driver.conf
 * file.
 *
 * fname                driver.conf file name
 * confent_list         on return *confent_list will contain the list of
 *                      driver.conf file entries with mpxio-disable property.
 * mpxio_disable        on return *mpxio_disable is set to the setting of the
 *                      driver global mpxio-dissable property as follows.
 *                      0  if driver mpxio-disable="no"
 *                      1  if driver mpxio-disable="yes"
 *                      -1 if driver mpxio-disable property isn't specified.
 */
static void
parse_conf_file(char *fname, struct conf_entry **confent_list,
    int *mpxio_disable)
{
        struct conf_entry *confent, *tail = NULL;
        token_t token;
        struct conf_file file;
        char tokval[MAX_TOKEN_SIZE];

        *confent_list = NULL;
        *mpxio_disable = -1;
        if ((file.fp = fopen(fname, "r")) == NULL)
                return;

        file.filename = fname;
        file.linenum = 1;

        while ((token = lex(&file, tokval, MAX_TOKEN_SIZE)) != T_EOF) {
                switch (token) {
                case T_POUND:
                        /*
                         * Skip comments.
                         */
                        find_eol(file.fp);
                        break;
                case T_NAME:
                        if ((confent = parse_conf_entry(&file, tokval,
                            MAX_TOKEN_SIZE)) == NULL)
                                break;
                        /*
                         * No name indicates global property.
                         * Make sure parent and class not NULL.
                         */
                        if (confent->name == NULL) {
                                if (confent->parent ||
                                    confent->class) {
                                        file_err(&file,
                                            "missing name attribute\n");
                                } else if (confent->mpxio_disable != -1) {
                                        if (*mpxio_disable == -1)
                                                *mpxio_disable =
                                                    confent->mpxio_disable;
                                        else
                                                file_err(&file,
                                "'mpxio-disable' property already specified\n");
                                }
                                free_confent(confent);
                                break;
                        }

                        /*
                         * This is a node spec, either parent or class
                         * must be specified.
                         */
                        if (confent->parent == NULL && confent->class == NULL) {
                                file_err(&file,
                                    "missing parent or class attribute\n");
                                free_confent(confent);
                                break;
                        }

                        /* only need entries with mpxio_disable property */
                        if (confent->mpxio_disable == -1) {
                                free_confent(confent);
                                break;
                        }

                        if (tail)
                                tail->next = confent;
                        else
                                *confent_list = confent;
                        tail = confent;
                        break;

                case T_NEWLINE:
                        file.linenum++;
                        break;
                default:
                        break;
                }
        }

        (void) fclose(file.fp);
}

/*
 * Return the driver class of the given driver_name.
 * The memory for the driver class is allocated by this function and the
 * caller must free it.
 */
static char *
get_driver_class(char *rootdir, char *driver_name)
{
        FILE *fp;
        char buf[BUFSIZE];
        char driver[BUFSIZE];
        char class_name[BUFSIZE];

        logdmsg(("get_driver_class: rootdir = %s, driver name = %s\n",
            rootdir, driver_name));

        (void) snprintf(buf, sizeof (buf), "%s%s", rootdir, DRIVER_CLASSES);

        if ((fp = fopen(buf, "r")) == NULL) {
                logdmsg(("get_driver_class: failed to open %s: %s\n",
                    buf, strerror(errno)));
                return (NULL);
        }

        while (fgets(buf, sizeof (buf), fp) != NULL) {
                /* LINTED - unbounded string specifier */
                if ((sscanf(buf, "%s %s", driver, class_name) == 2) &&
                    driver[0] != '#' && strcmp(driver, driver_name) == 0) {
                        logdmsg(("get_driver_class: driver class = %s\n",
                            class_name));
                        (void) fclose(fp);
                        return (strdup(class_name));
                }
        }

        (void) fclose(fp);
        return (NULL);
}

static int
lookup_in_confent_list(struct conf_entry *confent_list,
    int match_class, char *parent, char *unit_addr, int port)
{
        struct conf_entry *confent;
        char *par;

        logdmsg(("lookup_in_confent_list: %s = \"%s\", unit_addr = \"%s\", "
            "port = %d\n", (match_class) ? "class" : "parent", parent,
            STRVAL(unit_addr), port));

        for (confent = confent_list; confent != NULL; confent = confent->next) {
                par = (match_class) ? confent->class : confent->parent;
                if (unit_addr) {
                        if (confent->unit_address != NULL &&
                            strcmp(confent->unit_address, unit_addr) == 0 &&
                            par != NULL && strcmp(par, parent) == 0)
                                return (confent->mpxio_disable);
                } else {
                        if (confent->port == port &&
                            par != NULL && strcmp(par, parent) == 0)
                                return (confent->mpxio_disable);
                }
        }
        return (-1);
}

/*
 * lookup mpxio-disabled property setting for the given path in the given
 * driver.conf file. Match the entries from most specific to least specific.
 *
 * conf_file    the path name of either fp.conf, qlc.conf or scsi_vhci.conf
 * path         /devices node path without the /devices prefix.
 *              If the conf_file is fp.conf, path must be a fp node path
 *              if the conf_file is qlc.conf, path must be a qlc node path.
 *              if the conf_file is scsi_vhci.conf, path must be NULL.
 *              ex:     /pci@8,600000/SUNW,qlc@4/fp@0,0
 *                      /pci@8,600000/SUNW,qlc@4
 *
 * returns:
 *      0       if mpxio-disable="no"
 *      1       if mpxio-disable="yes"
 *      -1      if mpxio-disable property isn't specified.
 */
static int
lookup_in_conf_file(char *rootdir, char *conf_file, char *path)
{
        struct conf_entry *confent_list = NULL;
        int mpxio_disable;
        di_node_t par_node = DI_NODE_NIL;
        char *node_name = NULL, *node_addr = NULL;
        char *unit_addr = NULL;
        int port = -1;
        char *par_node_name = NULL, *par_node_addr = NULL;
        char *par_binding_name = NULL, *par_driver_name = NULL;
        char *par_driver_class = NULL, *par_node_name_addr;
        int rv = -1;
        char buf[MAXPATHLEN];

        logdmsg(("lookup_in_conf_file: rootdir = \"%s\", conf_file = \"%s\", "
            "path = \"%s\"\n", rootdir, conf_file, STRVAL(path)));

        (void) snprintf(buf, MAXPATHLEN, "%s%s", rootdir, conf_file);
        parse_conf_file(buf, &confent_list, &mpxio_disable);
#ifdef DEBUG
        log_confent_list(buf, confent_list, mpxio_disable);
#endif

        /* if path is NULL, return driver global mpxio-disable setting */
        if (path == NULL) {
                rv = mpxio_disable;
                goto done;
        }

        if ((node_name = strrchr(path, '/')) == NULL)
                goto done;

        *node_name = '\0';
        node_name++;

        if ((node_addr = strchr(node_name, '@')) == NULL)
                goto done;

        *node_addr = '\0';
        node_addr++;

        if (strcmp(node_name, "fp") == 0) {
                /* get port number; encoded in the node addr as a hex number */
                port = (int)strtol(node_addr, NULL, 16);
        } else
                unit_addr = node_addr;

        /*
         * Match from most specific to least specific;
         * first, start the lookup based on full path.
         */
        if ((rv = lookup_in_confent_list(confent_list, 0, path,
            unit_addr, port)) != -1)
                goto done;

        /* lookup nodename@address */
        if ((par_node_name_addr = strrchr(path, '/')) != NULL) {
                par_node_name_addr++;
                if ((rv = lookup_in_confent_list(confent_list, 0,
                    par_node_name_addr, unit_addr, port)) != -1)
                        goto done;
        }

        /* di_init() doesn't work when 0 is passed in flags */
        par_node = di_init(path, DINFOMINOR);
        if (par_node != DI_NODE_NIL) {
                par_node_name = di_node_name(par_node);
                par_node_addr = di_bus_addr(par_node);
                par_binding_name = di_binding_name(par_node);
                par_driver_name = di_driver_name(par_node);
        }

        logdmsg(("par_node_name = %s\n", STRVAL(par_node_name)));
        logdmsg(("par_node_addr = %s\n", STRVAL(par_node_addr)));
        logdmsg(("par_binding_name = %s\n", STRVAL(par_binding_name)));
        logdmsg(("par_driver_name = %s\n", STRVAL(par_driver_name)));

        /* lookup bindingname@address */
        if (par_binding_name != NULL && par_binding_name != par_node_name &&
            par_node_addr != NULL) {
                (void) snprintf(buf, sizeof (buf), "%s@%s", par_binding_name,
                    par_node_addr);
                if ((rv = lookup_in_confent_list(confent_list, 0,
                    buf, unit_addr, port)) != -1)
                        goto done;
        }

        /* lookup binding name */
        if (par_binding_name != NULL) {
                if ((rv = lookup_in_confent_list(confent_list, 0,
                    par_binding_name, unit_addr, port)) != -1)
                        goto done;
        }

        if (par_driver_name != NULL) {
                /* lookup driver name */
                if ((rv = lookup_in_confent_list(confent_list, 0,
                    par_driver_name, unit_addr, port)) != -1)
                        goto done;

                /* finally, lookup class name */
                par_driver_class = get_driver_class(rootdir, par_driver_name);
                if (par_driver_class != NULL) {
                        if ((rv = lookup_in_confent_list(confent_list, 1,
                            par_driver_class, unit_addr, port)) != -1)
                                goto done;
                }
        }

        /*
         * no match so far;
         * use the driver global mpxio-disable setting if exists.
         */
        rv = mpxio_disable;

done:
        if (node_name != NULL)
                *(node_name - 1) = '/';
        if (node_addr != NULL)
                *(node_addr - 1) = '@';
        if (par_driver_class != NULL)
                free(par_driver_class);
        if (confent_list != NULL)
                free_confent_list(confent_list);
        if (par_node != DI_NODE_NIL)
                di_fini(par_node);

        return (rv);
}

/*
 * Given client_name return whether it is a phci or vhci based name.
 * client_name is /devices name of a client without the /devices prefix.
 *
 * client_name                  Return value
 * .../fp@xxx/ssd@yyy           CLIENT_TYPE_PHCI
 * .../scsi_vhci/ssd@yyy        CLIENT_TYPE_VHCI
 * other                        CLIENT_TYPE_UNKNOWN
 */
static client_type_t
client_name_type(char *client_name)
{
        client_type_t client_type;
        char *p1, *p2;

        logdmsg(("client_name_type: client_name = %s\n", client_name));

        if (strncmp(client_name, SLASH_SCSI_VHCI,
            sizeof (SLASH_SCSI_VHCI) - 1) == 0)
                return (CLIENT_TYPE_VHCI);

        if (*client_name != '/')
                return (CLIENT_TYPE_UNKNOWN);

        if ((p1 = strrchr(client_name, '/')) == NULL)
                return (CLIENT_TYPE_UNKNOWN);

        *p1 = '\0';

        if ((p2 = strrchr(client_name, '/')) != NULL &&
            strncmp(p2, SLASH_FP_AT, sizeof (SLASH_FP_AT) - 1) == 0)
                client_type = CLIENT_TYPE_PHCI;
        else
                client_type = CLIENT_TYPE_UNKNOWN;

        *p1 = '/';
        return (client_type);
}

/*
 * Compare controller name portion of dev1 and dev2.
 *
 * rootdir      root directory of the target environment
 * dev1         can be either a /dev link or /devices name in the target
 *              environemnt
 * dev2         /devices name of a device without the /devices prefix
 *
 * Returns:
 *      0       if controller names match
 *      1       if controller names don't match
 *      -1      an error occurred.
 */
static int
compare_controller(char *rootdir, char *dev1, char *dev2)
{
        int linksize;
        char *p1, *p;
        char physdev1[MAXPATHLEN];
        char buf[MAXPATHLEN];

        logdmsg(("compare_controller: rootdir = %s, dev1 = %s, dev2 = %s\n",
            rootdir, dev1, dev2));

        if (strncmp(dev1, SLASH_DEV_SLASH, sizeof (SLASH_DEV_SLASH) - 1)
            == 0) {
                (void) snprintf(buf, MAXPATHLEN, "%s%s", rootdir, dev1);
                if ((linksize = readlink(buf, physdev1, MAXPATHLEN)) > 0 &&
                    linksize < (MAXPATHLEN - 1)) {
                        physdev1[linksize] = '\0';
                        logdmsg(("compare_controller: physdev1 = %s\n",
                            physdev1));
                } else
                        return (-1);
        } else
                (void) strlcpy(physdev1, dev1, MAXPATHLEN);

        if ((p1 = strstr(physdev1, SLASH_DEVICES)) == NULL)
                return (-1);

        p1 += sizeof (SLASH_DEVICES) - 1;
        /* strip the device portion */
        if ((p = strrchr(p1, '/')) == NULL)
                return (-1);
        *p = '\0';

        if ((p = strrchr(dev2, '/')) == NULL)
                return (-1);
        *p = '\0';

        logdmsg(("compare_controller: path1 = %s, path2 = %s\n",
            p1, dev2));
        if (strcmp(p1, dev2) == 0) {
                *p = '/';
                return (0);
        } else {
                *p = '/';
                return (1);
        }
}

/*
 * Check if the specified device path is on the root controller.
 *
 * rootdir      root directory of the target environment
 * path         /devices name of a device without the /devices prefix
 *
 * Returns
 *      1       if the path is on the root controller
 *      0       if the path is not on the root controller
 *      -1      if an error occurs
 */
static int
is_root_controller(char *rootdir, char *path)
{
        FILE *fp;
        char *tmpfile;
        int rv = -1;
        struct vfstab vfsent;
        char buf[MAXPATHLEN];
        char ctd[MAXNAMELEN + 1];

        logdmsg(("is_root_controller: rootdir = %s, path = %s\n", rootdir,
            path));

        (void) snprintf(buf, MAXPATHLEN, "%s%s", rootdir, VFSTAB);

        if ((fp = fopen(buf, "r")) == NULL) {
                logdmsg(("is_root_controller: failed to open %s: %s\n",
                    buf, strerror(errno)));
                return (-1);
        }

        if (getvfsfile(fp, &vfsent, "/") != 0) {
                logdmsg(("is_root_controller: getvfsfile: failed to read "
                    "vfstab entry for mount point \"/\": %s\n",
                    strerror(errno)));
                (void) fclose(fp);
                return (-1);
        }
        (void) fclose(fp);

        /* check if the root is an svm metadisk */
        if (strncmp(vfsent.vfs_special, META_DEV, sizeof (META_DEV) - 1) != 0) {
                if (compare_controller(rootdir, vfsent.vfs_special, path) == 0)
                        return (1);
                else
                        return (0);
        }

        /* Don't use /var/run as it is not mounted in miniroot */
        if ((tmpfile = tempnam("/tmp", "diirc")) == NULL) {
                logdmsg(("is_root_controller: tempnam: failed: %s\n",
                    strerror(errno)));
                return (-1);
        }

        /* get metadisk components using metastat command */
        (void) snprintf(buf, MAXPATHLEN,
            "/usr/sbin/metastat -p %s 2>/dev/null | "
            "/usr/bin/grep ' 1 1 ' | "
            "/usr/bin/sed -e 's/^.* 1 1 //' | "
            "/usr/bin/cut -f1 -d ' ' > %s",
            vfsent.vfs_special + sizeof (META_DEV) - 1, tmpfile);

        logdmsg(("is_root_controller: command = %s\n", buf));
        fp = NULL;
        if (system(buf) == 0 && (fp = fopen(tmpfile, "r")) != NULL) {
                while (fscanf(fp, "%" VAL2STR(MAXNAMELEN) "s", ctd) == 1) {
                        (void) snprintf(buf, MAXPATHLEN, "/dev/dsk/%s", ctd);
                        if (compare_controller(rootdir, buf, path) == 0) {
                                rv = 1;
                                goto out;
                        }
                }
                rv = 0;
        }

out:
        if (fp)
                (void) fclose(fp);
        (void) unlink(tmpfile);
        free(tmpfile);
        return (rv);
}

static int
file_exists(char *rootdir, char *path)
{
        struct stat stbuf;
        char fullpath[MAXPATHLEN];
        int x;

        (void) snprintf(fullpath, MAXPATHLEN, "%s%s", rootdir, path);

        x = stat(fullpath, &stbuf);
        logdmsg(("file_exists: %s: %s\n", fullpath, (x == 0) ? "yes" : "no"));
        if (x == 0)
                return (1);
        else
                return (0);
}

/*
 * Check if mpxio is enabled or disabled on the specified device path.
 * Looks through the .conf files to determine the mpxio setting.
 *
 * rootdir      root directory of the target environment
 * path         /devices name of a device without the /devices prefix and
 *              minor name component.
 *
 * Returns
 *      1       if mpxio is disabled
 *      0       if mpxio is enabled
 *      -1      if an error occurs
 */
static int
is_mpxio_disabled(char *rootdir, char *path)
{
        int mpxio_disable;
        char *p;
        int check_root_controller;

        logdmsg(("is_mpxio_disabled: rootdir = %s, path = %s\n",
            rootdir, path));

        if (file_exists(rootdir, SCSI_VHCI_CONF) == 0) {
                /*
                 * scsi_vhci.conf doesn't exist:
                 *  if upgrading from a pre solaris 9 release. or
                 *  if this function is called during fresh or flash install
                 *  prior to installing scsi_vhci.conf file.
                 */
                if (file_exists(rootdir, "/kernel/drv"))
                        /* upgrading from pre solaris 9 */
                        return (1);
                else
                        /* fresh or flash install */
                        return (0);
        }

        mpxio_disable = lookup_in_conf_file(rootdir, SCSI_VHCI_CONF, NULL);

        /*
         * scsi_vhci.conf contains mpxio-disable property only in s9 and
         * s8+sfkpatch. This property is no longer present from s10 onwards.
         */
        if (mpxio_disable == 1) {
                /* upgrading from s8 or s9 with mpxio globally disabled */
                return (1);
        } else if (mpxio_disable == 0) {
                /* upgrading from s8 or s9 with mpxio globally enabled */
                check_root_controller = 1;
        } else {
                /*
                 * We are looking at the s10 version of the file. This is
                 * the case if this function is called after installing the
                 * new scsi_vhci.conf file.
                 */
                check_root_controller = 0;
        }

        if ((mpxio_disable = lookup_in_conf_file(rootdir, FP_CONF, path))
            != -1)
                return (mpxio_disable);

        if ((p = strrchr(path, '/')) == NULL)
                return (-1);

        *p = '\0';
        if ((mpxio_disable = lookup_in_conf_file(rootdir, QLC_CONF, path))
            != -1) {
                *p = '/';
                return (mpxio_disable);
        }
        *p = '/';

        /*
         * mpxio-disable setting is not found in the .conf files.
         * The default is to enable mpxio, except if the path is on the root
         * controller.
         *
         * In s8 and s9 mpxio is not supported on the root controller.
         * NWS supplies a patch to enable root controller support in s8 and s9.
         * If the system had the patch installed, the fp.conf file would have
         * explicit "mpxio-disable=no" for the root controller. So we would
         * have found the mpxio-disable setting when we looked up this property
         * in the fp.conf file.
         */
        if (check_root_controller) {
                mpxio_disable = is_root_controller(rootdir, path);
                logdmsg(("is_mpxio_disabled: is_root_controller returned %d\n",
                    mpxio_disable));
        } else
                mpxio_disable = 0;

        return (mpxio_disable);
}

static int
vhci_ctl(sv_iocdata_t *iocp, int cmd)
{
        int fd, rv;

        if ((fd = open(VHCI_CTL_NODE, O_RDWR)) < 0)
                return (-1);
        rv = ioctl(fd, cmd, iocp);
        (void) close(fd);
        return (rv);
}

/*
 * Convert a phci client name to vhci client name.
 *
 * phci_name    phci client /devices name without the /devices prefix and
 *              minor name component.
 *              ex: /pci@8,600000/SUNW,qlc@4/fp@0,0/ssd@w2100002037cd9f72,0
 *
 * Returns      on success, vhci client name is returned. The memory for
 *              the vhci name is allocated by this function and the caller
 *              must free it.
 *              on failure, NULL is returned.
 */
static char *
phci_to_vhci(char *phci_name)
{
        sv_iocdata_t ioc;
        char *slash, *addr, *retp;
        char vhci_name_buf[MAXPATHLEN];
        char phci_name_buf[MAXPATHLEN];
        char addr_buf[MAXNAMELEN];

        logdmsg(("phci_to_vhci: pchi_name =  %s\n", phci_name));
        (void) strlcpy(phci_name_buf, phci_name, MAXPATHLEN);

        if ((slash = strrchr(phci_name_buf, '/')) == NULL ||
            (addr = strchr(slash, '@')) == NULL)
                return (NULL);

        *slash = '\0';
        addr++;
        (void) strlcpy(addr_buf, addr, MAXNAMELEN);

        bzero(&ioc, sizeof (sv_iocdata_t));
        ioc.client = vhci_name_buf;
        ioc.phci = phci_name_buf;
        ioc.addr = addr_buf;
        if (vhci_ctl(&ioc, SCSI_VHCI_GET_CLIENT_NAME) != 0) {
                logdmsg(("phci_to_vhci: vhci_ctl failed: %s\n",
                    strerror(errno)));
                return (NULL);
        }

        retp = strdup(vhci_name_buf);
        logdmsg(("phci_to_vhci: vhci name = %s\n", STRVAL(retp)));
        return (retp);
}

static int
add_to_phci_list(char **phci_list, sv_path_info_t *pi, int npaths, int state,
    char *node_name)
{
        int rv = 0;
        char name[MAXPATHLEN];

        while (npaths--) {
                if (state == pi->ret_state) {
                        (void) snprintf(name, MAXPATHLEN, "%s/%s@%s",
                            pi->device.ret_phci, node_name, pi->ret_addr);
                        if ((*phci_list = strdup(name)) == NULL)
                                return (-1);
                        phci_list++;
                        rv++;
                }
                pi++;
        }

        return (rv);
}

static void
free_pathlist(char **pathlist)
{
        char **p;

        if (pathlist != NULL) {
                for (p = pathlist; *p != NULL; p++)
                        free(*p);
                free(pathlist);
        }
}


/*
 * Convert a vhci client name to phci client names.
 *
 * vhci_name    vhci client /devices name without the /devices prefix and
 *              minor name component.
 * num_paths    On return, *num_paths is set to the number paths in the
 *              returned path list.
 *
 * Returns      NULL terminated path list containing phci client paths is
 *              returned on success. The memory for the path list is
 *              allocated by this function and the caller must free it by
 *              calling free_pathlist().
 *              NULL is returned on failure.
 */
static char **
vhci_to_phci(char *vhci_name, int *num_paths)
{
        sv_iocdata_t ioc;
        uint_t npaths;
        int n;
        char **phci_list = NULL;
        char *node_name, *at;
        char vhci_name_buf[MAXPATHLEN];

        logdmsg(("vhci_to_phci: vchi_name =  %s\n", vhci_name));

        *num_paths = 0;
        (void) strlcpy(vhci_name_buf, vhci_name, MAXPATHLEN);

        /* first get the number paths */
        bzero(&ioc, sizeof (sv_iocdata_t));
        ioc.client = vhci_name_buf;
        ioc.ret_elem = &npaths;
        if (vhci_ctl(&ioc, SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO) != 0 ||
            npaths == 0) {
                logdmsg(("vhci_to_phci: vhci_ctl failed to get npaths: %s\n",
                    strerror(errno)));
                return (NULL);
        }

        /* now allocate memory for the path information and get all paths */
        bzero(&ioc, sizeof (sv_iocdata_t));
        ioc.client = vhci_name_buf;
        ioc.buf_elem = npaths;
        ioc.ret_elem = &npaths;
        if ((ioc.ret_buf = (sv_path_info_t *)calloc(npaths,
            sizeof (sv_path_info_t))) == NULL)
                return (NULL);
        if (vhci_ctl(&ioc, SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO) != 0 ||
            npaths == 0) {
                logdmsg(("vhci_to_phci: vhci_ctl failed: %s\n",
                    strerror(errno)));
                goto out;
        }

        if (ioc.buf_elem < npaths)
                npaths = ioc.buf_elem;

        if ((node_name = strrchr(vhci_name_buf, '/')) == NULL ||
            (at = strchr(node_name, '@')) == NULL)
                goto out;

        node_name++;
        *at = '\0';

        /* allocate one more (than npaths) for the terminating NULL pointer */
        if ((phci_list = calloc(npaths + 1, sizeof (char *))) == NULL)
                goto out;

        /*
         * add only online paths as non-online paths may not be accessible
         * in the target environment.
         */
        if ((n = add_to_phci_list(phci_list, ioc.ret_buf, npaths,
            MDI_PATHINFO_STATE_ONLINE, node_name)) <= 0)
                goto out;

        free(ioc.ret_buf);
        *num_paths = n;

#ifdef DEBUG
        logdmsg(("vhci_to_phci: phci list:\n"));
        log_pathlist(phci_list);
#endif
        return (phci_list);

out:
        free(ioc.ret_buf);
        if (phci_list)
                free_pathlist(phci_list);
        return (NULL);
}

/*
 * build list of paths accessible from the target environment
 */
static int
build_pathlist(char *rootdir, char *vhcipath, char **pathlist, int npaths)
{
        int mpxio_disabled;
        int i, j;
        char *vpath = NULL;

        for (i = 0; i < npaths; i++) {
                mpxio_disabled = is_mpxio_disabled(rootdir, pathlist[i]);
                logdmsg(("build_pathlist: mpxio_disabled = %d "
                    "on path %s\n", mpxio_disabled, pathlist[i]));
                if (mpxio_disabled == -1)
                        return (-1);
                if (mpxio_disabled == 0) {
                        /*
                         * mpxio is enabled on this phci path.
                         * So use vhci path instead of phci path.
                         */
                        if (vpath == NULL) {
                                if ((vpath = strdup(vhcipath)) == NULL)
                                        return (-1);
                                free(pathlist[i]);
                                /* keep vhci path at beginning of the list */
                                for (j = i; j > 0; j--)
                                        pathlist[j] = pathlist[j - 1];
                                pathlist[0] = vpath;
                        } else {
                                free(pathlist[i]);
                                npaths--;
                                for (j = i; j < npaths; j++)
                                        pathlist[j] = pathlist[j + 1];
                                pathlist[npaths] = NULL;
                                /* compensate for i++ in the for loop */
                                i--;
                        }
                }
        }

#ifdef DEBUG
        logdmsg(("build_pathlist: returning npaths = %d, pathlist:\n", npaths));
        log_pathlist(pathlist);
#endif
        return (npaths);
}

/*
 * Check if the specified device is refenced in the vfstab file.
 * Return 1 if referenced, 0 if not.
 *
 * rootdir      root directory of the target environment
 * nodepath     /devices path of a device in the target environment without
 *              the /devices prefix and minor component.
 */
static int
is_dev_in_vfstab(char *rootdir, char *nodepath)
{
        FILE *fp;
        int linksize;
        struct vfstab vfsent;
        char *abspath, *minor;
        char physpath[MAXPATHLEN];
        char buf[MAXPATHLEN];

        logdmsg(("is_dev_in_vfstab: rootdir = %s, nodepath = %s\n",
            rootdir, nodepath));

        (void) snprintf(buf, sizeof (buf), "%s%s", rootdir, VFSTAB);

        if ((fp = fopen(buf, "r")) == NULL)
                return (0);

        /*
         * read device specials from vfstab and compare names at physical
         * node path level.
         */
        while (getvfsent(fp, &vfsent) == 0) {
                if (strncmp(vfsent.vfs_special, SLASH_DEV_SLASH,
                    sizeof (SLASH_DEV_SLASH) - 1) == 0) {
                        (void) snprintf(buf, MAXPATHLEN, "%s%s",
                            rootdir, vfsent.vfs_special);
                        if ((linksize = readlink(buf, physpath,
                            MAXPATHLEN)) > 0 && linksize < (MAXPATHLEN - 1)) {
                                physpath[linksize] = '\0';
                                if ((abspath = strstr(physpath,
                                    SLASH_DEVICES_SLASH)) == NULL)
                                        continue;
                        } else
                                continue;
                } else if (strncmp(vfsent.vfs_special, SLASH_DEVICES_SLASH,
                    sizeof (SLASH_DEVICES_SLASH) - 1) == 0) {
                        (void) strlcpy(physpath, vfsent.vfs_special,
                            MAXPATHLEN);
                        abspath = physpath;
                } else
                        continue;

                /* point to / after /devices */
                abspath += sizeof (SLASH_DEVICES_SLASH) - 2;
                /* strip minor component */
                if ((minor = strrchr(abspath, ':')) != NULL)
                        *minor = '\0';

                if (strcmp(nodepath, abspath) == 0) {
                        (void) fclose(fp);
                        logdmsg(("is_dev_in_vfstab: returning 1\n"));
                        return (1);
                }
        }

        (void) fclose(fp);
        return (0);
}

#endif /* __sparc */

static int
devlink_callback(di_devlink_t devlink, void *argp)
{
        const char *link;

        if ((link = di_devlink_path(devlink)) != NULL)
                (void) strlcpy((char *)argp, link, MAXPATHLEN);

        return (DI_WALK_CONTINUE);
}

/*
 * Get the /dev name in the install environment corresponding to physpath.
 *
 * physpath     /devices path in the install environment without the /devices
 *              prefix.
 * buf          caller supplied buffer where the /dev name is placed on return
 * bufsz        length of the buffer
 *
 * Returns      strlen of the /dev name on success, -1 on failure.
 */
static int
get_install_devlink(char *physpath, char *buf, size_t bufsz)
{
        di_devlink_handle_t devlink_hdl;
        char devname[MAXPATHLEN];
        int tries = 0;
        int sleeptime = 2; /* number of seconds to sleep between retries */
        int maxtries = 10; /* maximum number of tries */

        logdmsg(("get_install_devlink: physpath = %s\n", physpath));

        /*
         * devlink_db sync happens after MINOR_FINI_TIMEOUT_DEFAULT secs
         * after dev link creation. So wait for minimum that amout of time.
         */

retry:
        (void) sleep(sleeptime);

        if ((devlink_hdl = di_devlink_init(NULL, 0)) == NULL) {
                logdmsg(("get_install_devlink: di_devlink_init() failed: %s\n",
                    strerror(errno)));
                return (-1);
        }

        devname[0] = '\0';
        if (di_devlink_walk(devlink_hdl, NULL, physpath, DI_PRIMARY_LINK,
            devname, devlink_callback) == 0) {
                if (devname[0] == '\0' && tries < maxtries) {
                        tries++;
                        (void) di_devlink_fini(&devlink_hdl);
                        goto retry;
                } else if (devname[0] == '\0') {
                        logdmsg(("get_install_devlink: di_devlink_walk"
                            " failed: %s\n", strerror(errno)));
                        (void) di_devlink_fini(&devlink_hdl);
                        return (-1);
                }
        } else {
                logdmsg(("get_install_devlink: di_devlink_walk failed: %s\n",
                    strerror(errno)));
                (void) di_devlink_fini(&devlink_hdl);
                return (-1);
        }

        (void) di_devlink_fini(&devlink_hdl);

        logdmsg(("get_install_devlink: devlink = %s\n", devname));
        return (strlcpy(buf, devname, bufsz));
}

/*
 * Get the /dev name in the target environment corresponding to physpath.
 *
 * rootdir      root directory of the target environment
 * physpath     /devices path in the target environment without the /devices
 *              prefix.
 * buf          caller supplied buffer where the /dev name is placed on return
 * bufsz        length of the buffer
 *
 * Returns      strlen of the /dev name on success, -1 on failure.
 */
static int
get_target_devlink(char *rootdir, char *physpath, char *buf, size_t bufsz)
{
        char *p;
        int linksize;
        DIR *dirp;
        struct dirent *direntry;
        char dirpath[MAXPATHLEN];
        char devname[MAXPATHLEN];
        char physdev[MAXPATHLEN];

        logdmsg(("get_target_devlink: rootdir = %s, physpath = %s\n",
            rootdir, physpath));

        if ((p = strrchr(physpath, '/')) == NULL)
                return (-1);

        if (strstr(p, ",raw") != NULL) {
                (void) snprintf(dirpath, MAXPATHLEN, "%s/dev/rdsk", rootdir);
        } else {
                (void) snprintf(dirpath, MAXPATHLEN, "%s/dev/dsk", rootdir);
        }

        if ((dirp = opendir(dirpath)) == NULL)
                return (-1);

        while ((direntry = readdir(dirp)) != NULL) {
                if (strcmp(direntry->d_name, ".") == 0 ||
                    strcmp(direntry->d_name, "..") == 0)
                        continue;

                (void) snprintf(devname, MAXPATHLEN, "%s/%s",
                    dirpath, direntry->d_name);

                if ((linksize = readlink(devname, physdev, MAXPATHLEN)) > 0 &&
                    linksize < (MAXPATHLEN - 1)) {
                        physdev[linksize] = '\0';
                        if ((p = strstr(physdev, SLASH_DEVICES_SLASH)) !=
                            NULL && strcmp(p + sizeof (SLASH_DEVICES) - 1,
                            physpath) == 0) {
                                (void) closedir(dirp);
                                logdmsg(("get_target_devlink: devlink = %s\n",
                                    devname + strlen(rootdir)));
                                return (strlcpy(buf, devname + strlen(rootdir),
                                    bufsz));
                        }
                }
        }

        (void) closedir(dirp);
        return (-1);
}

/*
 * Convert device name to physpath.
 *
 * rootdir      root directory
 * devname      a /dev name or /devices name under rootdir
 * physpath     caller supplied buffer where the /devices path will be placed
 *              on return (without the /devices prefix).
 * physpathlen  length of the physpath buffer
 *
 * Returns 0 on success, -1 on failure.
 */
static int
devname2physpath(char *rootdir, char *devname, char *physpath, int physpathlen)
{
        int linksize;
        char *p;
        char devlink[MAXPATHLEN];
        char tmpphyspath[MAXPATHLEN];

        logdmsg(("devname2physpath: rootdir = %s, devname = %s\n",
            rootdir, devname));

        if (strncmp(devname, SLASH_DEVICES_SLASH,
            sizeof (SLASH_DEVICES_SLASH) - 1) != 0) {
                if (*rootdir == '\0')
                        linksize = readlink(devname, tmpphyspath, MAXPATHLEN);
                else {
                        (void) snprintf(devlink, MAXPATHLEN, "%s%s",
                            rootdir, devname);
                        linksize = readlink(devlink, tmpphyspath, MAXPATHLEN);
                }
                if (linksize > 0 && linksize < (MAXPATHLEN - 1)) {
                        tmpphyspath[linksize] = '\0';
                        if ((p = strstr(tmpphyspath, SLASH_DEVICES_SLASH))
                            == NULL)
                                return (-1);
                } else
                        return (-1);
        } else
                p = devname;

        (void) strlcpy(physpath, p + sizeof (SLASH_DEVICES) - 1, physpathlen);
        logdmsg(("devname2physpath: physpath = %s\n", physpath));
        return (0);
}

/*
 * Map a device name (devname) from the target environment to the
 * install environment.
 *
 * rootdir      root directory of the target environment
 * devname      /dev or /devices name under the target environment
 * buf          caller supplied buffer where the mapped /dev name is placed
 *              on return
 * bufsz        length of the buffer
 *
 * Returns      strlen of the mapped /dev name on success, -1 on failure.
 */
int
devfs_target2install(const char *rootdir, const char *devname, char *buf,
    size_t bufsz)
{
        char physpath[MAXPATHLEN];

        logdmsg(("devfs_target2install: rootdir = %s, devname = %s\n",
            STRVAL(rootdir), STRVAL(devname)));

        if (rootdir == NULL || devname == NULL || buf == NULL || bufsz == 0)
                return (-1);

        if (strcmp(rootdir, "/") == 0)
                rootdir = "";

        if (devname2physpath((char *)rootdir, (char *)devname, physpath,
            MAXPATHLEN) != 0)
                return (-1);

#ifdef __sparc
        if (client_name_type(physpath) == CLIENT_TYPE_PHCI) {
                char *mapped_node_path, *minor;
                char minorbuf[MAXNAMELEN];

                /* strip minor component if present */
                if ((minor = strrchr(physpath, ':')) != NULL) {
                        *minor = '\0';
                        minor++;
                        (void) strlcpy(minorbuf, minor, MAXNAMELEN);
                }
                if ((mapped_node_path = phci_to_vhci(physpath)) != NULL) {
                        if (minor)
                                (void) snprintf(physpath, MAXPATHLEN,
                                    "%s:%s", mapped_node_path, minorbuf);
                        else
                                (void) strlcpy(physpath, mapped_node_path,
                                    MAXPATHLEN);
                        free(mapped_node_path);
                        logdmsg(("devfs_target2install: mapped physpath: %s\n",
                            physpath));

                } else if (minor)
                        *(minor - 1) = ':';
        }
#endif /* __sparc */

        return (get_install_devlink(physpath, buf, bufsz));
}

/*
 * Map a device name (devname) from the install environment to the target
 * environment.
 *
 * rootdir      root directory of the target environment
 * devname      /dev or /devices name under the install environment
 * buf          caller supplied buffer where the mapped /dev name is placed
 *              on return
 * bufsz        length of the buffer
 *
 * Returns      strlen of the mapped /dev name on success, -1 on failure.
 */
int
devfs_install2target(const char *rootdir, const char *devname, char *buf,
    size_t bufsz)
{
        char physpath[MAXPATHLEN];

        logdmsg(("devfs_install2target: rootdir = %s, devname = %s\n",
            STRVAL(rootdir), STRVAL(devname)));

        if (rootdir == NULL || devname == NULL || buf == NULL || bufsz == 0)
                return (-1);

        if (strcmp(rootdir, "/") == 0)
                rootdir = "";

        if (devname2physpath("", (char *)devname, physpath, MAXPATHLEN) != 0)
                return (-1);

#ifdef __sparc
        if (client_name_type(physpath) == CLIENT_TYPE_VHCI) {
                char **pathlist;
                int npaths, i, j;
                char *minor;
                char minorbuf[MAXNAMELEN];

                /* strip minor component if present */
                if ((minor = strrchr(physpath, ':')) != NULL) {
                        *minor = '\0';
                        minor++;
                        (void) strlcpy(minorbuf, minor, MAXNAMELEN);
                }

                if ((pathlist = vhci_to_phci(physpath, &npaths)) == NULL)
                        return (-1);

                if ((npaths = build_pathlist((char *)rootdir, physpath,
                    pathlist, npaths)) <= 0) {
                        free_pathlist(pathlist);
                        return (-1);
                }

                /*
                 * in case of more than one path, try to use the path
                 * referenced in the vfstab file, otherwise use the first path.
                 */
                j = 0;
                if (npaths > 1) {
                        for (i = 0; i < npaths; i++) {
                                if (is_dev_in_vfstab((char *)rootdir,
                                    pathlist[i])) {
                                        j = i;
                                        break;
                                }
                        }
                }

                if (minor)
                        (void) snprintf(physpath, MAXPATHLEN,
                            "%s:%s", pathlist[j], minorbuf);
                else
                        (void) strlcpy(physpath, pathlist[j], MAXPATHLEN);
                free_pathlist(pathlist);
        }
#endif /* __sparc */

        return (get_target_devlink((char *)rootdir, physpath, buf, bufsz));
}

/*
 * A parser for /etc/path_to_inst.
 * The user-supplied callback is called once for each entry in the file.
 * Returns 0 on success, ENOMEM/ENOENT/EINVAL on error.
 * Callback may return DI_WALK_TERMINATE to terminate the walk,
 * otherwise DI_WALK_CONTINUE.
 */
int
devfs_parse_binding_file(const char *binding_file,
        int (*callback)(void *, const char *, int,
            const char *), void *cb_arg)
{
        token_t token;
        struct conf_file file;
        char tokval[MAX_TOKEN_SIZE];
        enum { STATE_RESET, STATE_DEVPATH, STATE_INSTVAL } state;
        char *devpath;
        char *bindname;
        int instval = 0;
        int rv;

        if ((devpath = calloc(1, MAXPATHLEN)) == NULL)
                return (ENOMEM);
        if ((bindname = calloc(1, MAX_TOKEN_SIZE)) == NULL) {
                free(devpath);
                return (ENOMEM);
        }

        if ((file.fp = fopen(binding_file, "r")) == NULL) {
                free(devpath);
                free(bindname);
                return (errno);
        }

        file.filename = (char *)binding_file;
        file.linenum = 1;

        state = STATE_RESET;
        while ((token = lex(&file, tokval, MAX_TOKEN_SIZE)) != T_EOF) {
                switch (token) {
                case T_POUND:
                        /*
                         * Skip comments.
                         */
                        find_eol(file.fp);
                        break;
                case T_NAME:
                case T_STRING:
                        switch (state) {
                        case STATE_RESET:
                                if (strlcpy(devpath, tokval,
                                    MAXPATHLEN) >= MAXPATHLEN)
                                        goto err;
                                state = STATE_DEVPATH;
                                break;
                        case STATE_INSTVAL:
                                if (strlcpy(bindname, tokval,
                                    MAX_TOKEN_SIZE) >= MAX_TOKEN_SIZE)
                                        goto err;
                                rv = callback(cb_arg,
                                    devpath, instval, bindname);
                                if (rv == DI_WALK_TERMINATE)
                                        goto done;
                                if (rv != DI_WALK_CONTINUE)
                                        goto err;
                                state = STATE_RESET;
                                break;
                        default:
                                file_err(&file, tok_err, tokval);
                                state = STATE_RESET;
                                break;
                        }
                        break;
                case T_DECVAL:
                case T_HEXVAL:
                        switch (state) {
                        case STATE_DEVPATH:
                                instval = (int)strtol(tokval, NULL, 0);
                                state = STATE_INSTVAL;
                                break;
                        default:
                                file_err(&file, tok_err, tokval);
                                state = STATE_RESET;
                                break;
                        }
                        break;
                case T_NEWLINE:
                        file.linenum++;
                        state = STATE_RESET;
                        break;
                default:
                        file_err(&file, tok_err, tokval);
                        state = STATE_RESET;
                        break;
                }
        }

done:
        (void) fclose(file.fp);
        free(devpath);
        free(bindname);
        return (0);

err:
        (void) fclose(file.fp);
        free(devpath);
        free(bindname);
        return (EINVAL);
}

/*
 * Walk the minor nodes of all children below the specified device
 * by calling the provided callback with the path to each minor.
 */
static int
devfs_walk_children_minors(const char *device_path, struct stat *st,
    int (*callback)(void *, const char *), void *cb_arg, int *terminate)
{
        DIR *dir;
        struct dirent *dp;
        char *minor_path = NULL;
        int need_close = 0;
        int rv;

        if ((minor_path = calloc(1, MAXPATHLEN)) == NULL)
                return (ENOMEM);

        if ((dir = opendir(device_path)) == NULL) {
                rv = ENOENT;
                goto err;
        }
        need_close = 1;

        while ((dp = readdir(dir)) != NULL) {
                if ((strcmp(dp->d_name, ".") == 0) ||
                    (strcmp(dp->d_name, "..") == 0))
                        continue;
                (void) snprintf(minor_path, MAXPATHLEN,
                    "%s/%s", device_path, dp->d_name);
                if (stat(minor_path, st) == -1)
                        continue;
                if (S_ISDIR(st->st_mode)) {
                        rv = devfs_walk_children_minors(
                            (const char *)minor_path, st,
                            callback, cb_arg, terminate);
                        if (rv != 0)
                                goto err;
                        if (*terminate)
                                break;
                } else {
                        rv = callback(cb_arg, minor_path);
                        if (rv == DI_WALK_TERMINATE) {
                                *terminate = 1;
                                break;
                        }
                        if (rv != DI_WALK_CONTINUE) {
                                rv = EINVAL;
                                goto err;
                        }
                }
        }

        rv = 0;
err:
        if (need_close)
                (void) closedir(dir);
        if (minor_path)
                free(minor_path);
        return (rv);
}

/*
 * Return the path to each minor node for a device by
 * calling the provided callback.
 */
static int
devfs_walk_device_minors(const char *device_path, struct stat *st,
    int (*callback)(void *, const char *), void *cb_arg, int *terminate)
{
        char *minor_path;
        char *devpath;
        char *expr;
        regex_t regex;
        int need_regfree = 0;
        int need_close = 0;
        DIR *dir;
        struct dirent *dp;
        int rv;
        char *p;

        minor_path = calloc(1, MAXPATHLEN);
        devpath = calloc(1, MAXPATHLEN);
        expr = calloc(1, MAXNAMELEN);
        if (devpath == NULL || expr == NULL || minor_path == NULL) {
                rv = ENOMEM;
                goto err;
        }

        rv = EINVAL;
        if (strlcpy(devpath, device_path, MAXPATHLEN) >= MAXPATHLEN)
                goto err;
        if ((p = strrchr(devpath, '/')) == NULL)
                goto err;
        *p++ = 0;
        if (strlen(p) == 0)
                goto err;
        if (snprintf(expr, MAXNAMELEN, "%s:.*", p) >= MAXNAMELEN)
                goto err;
        if (regcomp(&regex, expr, REG_EXTENDED) != 0)
                goto err;
        need_regfree = 1;

        if ((dir = opendir(devpath)) == NULL) {
                rv = ENOENT;
                goto err;
        }
        need_close = 1;

        while ((dp = readdir(dir)) != NULL) {
                if ((strcmp(dp->d_name, ".") == 0) ||
                    (strcmp(dp->d_name, "..") == 0))
                        continue;
                (void) snprintf(minor_path, MAXPATHLEN,
                    "%s/%s", devpath, dp->d_name);
                if (stat(minor_path, st) == -1)
                        continue;
                if ((S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode)) &&
                    regexec(&regex, dp->d_name, 0, NULL, 0) == 0) {
                        rv = callback(cb_arg, minor_path);
                        if (rv == DI_WALK_TERMINATE) {
                                *terminate = 1;
                                break;
                        }
                        if (rv != DI_WALK_CONTINUE) {
                                rv = EINVAL;
                                goto err;
                        }
                }
        }

        rv = 0;
err:
        if (need_close)
                (void) closedir(dir);
        if (need_regfree)
                regfree(&regex);
        if (devpath)
                free(devpath);
        if (minor_path)
                free(minor_path);
        if (expr)
                free(expr);
        return (rv);
}

/*
 * Perform a walk of all minor nodes for the specified device,
 * and minor nodes below the device.
 */
int
devfs_walk_minor_nodes(const char *device_path,
        int (*callback)(void *, const char *), void *cb_arg)
{
        struct stat stbuf;
        int rv;
        int terminate = 0;

        rv = devfs_walk_device_minors(device_path,
            &stbuf, callback, cb_arg, &terminate);
        if (rv == 0 && terminate == 0) {
                rv = devfs_walk_children_minors(device_path,
                    &stbuf, callback, cb_arg, &terminate);
        }
        return (rv);
}

#ifdef DEBUG

static void
vlog_debug_msg(char *fmt, va_list ap)
{
        time_t clock;
        struct tm t;

        if (!devfsmap_debug)
                return;

        if (logfp == NULL) {
                if (*devfsmap_logfile != '\0') {
                        logfp = fopen(devfsmap_logfile, "a");
                        if (logfp)
                                (void) fprintf(logfp, "\nNew Log:\n");
                }

                if (logfp == NULL)
                        logfp = stdout;
        }

        clock = time(NULL);
        (void) localtime_r(&clock, &t);
        (void) fprintf(logfp, "%02d:%02d:%02d ", t.tm_hour, t.tm_min,
            t.tm_sec);
        (void) vfprintf(logfp, fmt, ap);
        (void) fflush(logfp);
}

static void
log_debug_msg(char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        vlog_debug_msg(fmt, ap);
        va_end(ap);
}

#ifdef __sparc

static char *
mpxio_disable_string(int mpxio_disable)
{
        if (mpxio_disable == 0)
                return ("no");
        else if (mpxio_disable == 1)
                return ("yes");
        else
                return ("not specified");
}

static void
log_confent_list(char *filename, struct conf_entry *confent_list,
    int global_mpxio_disable)
{
        struct conf_entry *confent;

        log_debug_msg("log_confent_list: filename = %s:\n", filename);
        if (global_mpxio_disable != -1)
                log_debug_msg("\tdriver global mpxio_disable = \"%s\"\n\n",
                    mpxio_disable_string(global_mpxio_disable));

        for (confent = confent_list; confent != NULL; confent = confent->next) {
                if (confent->name)
                        log_debug_msg("\tname = %s\n", confent->name);
                if (confent->parent)
                        log_debug_msg("\tparent = %s\n", confent->parent);
                if (confent->class)
                        log_debug_msg("\tclass = %s\n", confent->class);
                if (confent->unit_address)
                        log_debug_msg("\tunit_address = %s\n",
                            confent->unit_address);
                if (confent->port != -1)
                        log_debug_msg("\tport = %d\n", confent->port);
                log_debug_msg("\tmpxio_disable = \"%s\"\n\n",
                    mpxio_disable_string(confent->mpxio_disable));
        }
}

static void
log_pathlist(char **pathlist)
{
        char **p;

        for (p = pathlist; *p != NULL; p++)
                log_debug_msg("\t%s\n", *p);
}

#endif /* __sparc */

#endif /* DEBUG */