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

#include "cfga_scsi.h"
#include <libgen.h>
#include <limits.h>

/*
 * This file contains helper routines for the SCSI plugin
 */

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif

typedef struct strlist {
    const char *str;
    struct strlist *next;
} strlist_t;

typedef struct {
    scfga_ret_t scsi_err;
    cfga_err_t  cfga_err;
} errcvt_t;

typedef struct {
    scfga_cmd_t cmd;
    int type;
    int (*fcn)(const devctl_hdl_t);
} set_state_cmd_t;

typedef struct {
    scfga_cmd_t cmd;
    int type;
    int (*state_fcn)(const devctl_hdl_t, uint_t *);
} get_state_cmd_t;

/* Function prototypes */
static char *pathdup(const char *path, int *l_errnop);
static void msg_common(char **err_msgpp, int append_newline, int l_errno,
    va_list ap);

/*
 * The string table contains most of the strings used by the scsi cfgadm plugin.
 * All strings which are to be internationalized must be in this table.
 * Some strings which are not internationalized are also included here.
 * Arguments to messages are NOT internationalized.
 */
msgcvt_t str_tbl[] = {

/*
 * The first element (ERR_UNKNOWN) MUST always be present in the array.
 */
#define UNKNOWN_ERR_IDX     0   /* Keep the index in sync */


/* msg_code num_args, I18N  msg_string              */

/* ERRORS */
{ERR_UNKNOWN,       0, 1,   "unknown error"},
{ERR_OP_FAILED,     0, 1,   "operation failed"},
{ERR_CMD_INVAL,     0, 1,   "invalid command"},
{ERR_NOT_BUSAPID,   0, 1,   "not a SCSI bus apid"},
{ERR_APID_INVAL,    0, 1,   "invalid SCSI ap_id"},
{ERR_NOT_BUSOP,     0, 1,   "operation not supported for SCSI bus"},
{ERR_NOT_DEVOP,     0, 1,   "operation not supported for SCSI device"},
{ERR_UNAVAILABLE,   0, 1,   "unavailable"},
{ERR_CTRLR_CRIT,    0, 1,   "critical partition controlled by SCSI HBA"},
{ERR_BUS_GETSTATE,  0, 1,   "failed to get state for SCSI bus"},
{ERR_BUS_NOTCONNECTED,  0, 1,   "SCSI bus not connected"},
{ERR_BUS_CONNECTED, 0, 1,   "SCSI bus not disconnected"},
{ERR_BUS_QUIESCE,   0, 1,   "SCSI bus quiesce failed"},
{ERR_BUS_UNQUIESCE, 0, 1,   "SCSI bus unquiesce failed"},
{ERR_BUS_CONFIGURE, 0, 1,   "failed to configure devices on SCSI bus"},
{ERR_BUS_UNCONFIGURE,   0, 1,   "failed to unconfigure SCSI bus"},
{ERR_DEV_CONFIGURE, 0, 1,   "failed to configure SCSI device"},
{ERR_DEV_RECONFIGURE,   1, 1,   "failed to reconfigure device: "},
{ERR_DEV_UNCONFIGURE,   0, 1,   "failed to unconfigure SCSI device"},
{ERR_DEV_REMOVE,    0, 1,   "remove operation failed"},
{ERR_DEV_REPLACE,   0, 1,   "replace operation failed"},
{ERR_DEV_INSERT,    0, 1,   "insert operation failed"},
{ERR_DEV_GETSTATE,  0, 1,   "failed to get state for SCSI device"},
{ERR_RESET,     0, 1,   "reset failed"},
{ERR_LIST,      0, 1,   "list operation failed"},
{ERR_MAYBE_BUSY,    0, 1,   "device may be busy"},
{ERR_BUS_DEV_MISMATCH,  0, 1,   "mismatched SCSI bus and device"},
{ERR_VAR_RUN,       0, 1,   "/var/run is not mounted"},
{ERR_FORK,      0, 1,   "failed to fork cleanup handler"},

/* Errors with arguments */
{ERRARG_OPT_INVAL,  1, 1,   "invalid option: "},
{ERRARG_HWCMD_INVAL,    1, 1,   "invalid command: "},
{ERRARG_DEVINFO,    1, 1,   "libdevinfo failed on path: "},
{ERRARG_OPEN,       1, 1,   "open failed: "},
{ERRARG_LOCK,       1, 1,   "lock failed: "},
{ERRARG_QUIESCE_LOCK,   1, 1,   "cannot acquire quiesce lock: "},

/* RCM Errors */
{ERR_RCM_HANDLE,    0, 1,   "cannot get RCM handle"},
{ERRARG_RCM_SUSPEND,    0, 1,   "failed to suspend: "},
{ERRARG_RCM_RESUME, 0, 1,   "failed to resume: "},
{ERRARG_RCM_OFFLINE,    0, 1,   "failed to offline: "},
{ERRARG_RCM_CLIENT_OFFLINE, 0, 1,   "failed to offline a client device: "},
{ERRARG_RCM_ONLINE, 0, 1,   "failed to online: "},
{ERRARG_RCM_REMOVE, 0, 1,   "failed to remove: "},

/* Commands */
{CMD_INSERT_DEV,    0, 0,   "insert_device"},
{CMD_REMOVE_DEV,    0, 0,   "remove_device"},
{CMD_LED_DEV,       0, 0,   "led"},
{CMD_LOCATOR_DEV,   0, 0,   "locator"},
{CMD_REPLACE_DEV,   0, 0,   "replace_device"},
{CMD_RESET_DEV,     0, 0,   "reset_device"},
{CMD_RESET_BUS,     0, 0,   "reset_bus"},
{CMD_RESET_ALL,     0, 0,   "reset_all"},

/* help messages */
{MSG_HELP_HDR,      0, 1,   "\nSCSI specific commands and options:\n"},
{MSG_HELP_USAGE,    0, 0,   "\t-x insert_device ap_id [ap_id... ]\n"
                "\t-x remove_device ap_id [ap_id... ]\n"
                "\t-x replace_device ap_id [ap_id... ]\n"
                "\t-x locator[=on|off] ap_id [ap_id... ]\n"
                "\t-x led[=LED,mode=on|off|blink] "
                    "ap_id [ap_id... ]\n"
                "\t-x reset_device ap_id [ap_id... ]\n"
                "\t-x reset_bus ap_id [ap_id... ]\n"
                "\t-x reset_all ap_id [ap_id... ]\n"},

/* hotplug messages */
{MSG_INSDEV,        1, 1,   "Adding device to SCSI HBA: "},
{MSG_RMDEV,     1, 1,   "Removing SCSI device: "},
{MSG_REPLDEV,       1, 1,   "Replacing SCSI device: "},
{MSG_WAIT_LOCK,     0, 1,   "Waiting for quiesce lock... "},

/* Hotplugging confirmation prompts */
{CONF_QUIESCE_1,    1, 1,
    "This operation will suspend activity on SCSI bus: "},

{CONF_QUIESCE_2,    0, 1,   "\nContinue"},

{CONF_UNQUIESCE,    0, 1,
    "SCSI bus quiesced successfully.\n"
    "It is now safe to proceed with hotplug operation."
    "\nEnter y if operation is complete or n to abort"},

{CONF_NO_QUIESCE,   0, 1,
    "Proceed with hotplug operation."
    "\nEnter y if operation is complete or n to abort"},

/* Misc. */
{WARN_DISCONNECT,   0, 1,
    "WARNING: Disconnecting critical partitions may cause system hang."
    "\nContinue"},

/* LED messages */
{MSG_LED_HDR,       0, 1,   "Disk                    Led"},
{MSG_MISSING_LED_NAME,  0, 1,   "Missing LED name"},
{MSG_MISSING_LED_MODE,  0, 1,   "Missing LED mode"}
};

char *
led_strs[] = {
    "fault",
    "power",
    "attn",
    "active",
    "locator",
    NULL
};

char *
led_mode_strs[] = {
    "off",
    "on",
    "blink",
    "faulted",
    "unknown",
    NULL
};


#define N_STRS  (sizeof (str_tbl) / sizeof (str_tbl[0]))

#define GET_MSG_NARGS(i)    (str_tbl[msg_idx(i)].nargs)
#define GET_MSG_INTL(i)     (str_tbl[msg_idx(i)].intl)

static errcvt_t err_cvt_tbl[] = {
    { SCFGA_OK,     CFGA_OK         },
    { SCFGA_LIB_ERR,    CFGA_LIB_ERROR      },
    { SCFGA_APID_NOEXIST,   CFGA_APID_NOEXIST   },
    { SCFGA_NACK,       CFGA_NACK       },
    { SCFGA_BUSY,       CFGA_BUSY       },
    { SCFGA_SYSTEM_BUSY,    CFGA_SYSTEM_BUSY    },
    { SCFGA_OPNOTSUPP,  CFGA_OPNOTSUPP      },
    { SCFGA_PRIV,       CFGA_PRIV       },
    { SCFGA_UNKNOWN_ERR,    CFGA_ERROR      },
    { SCFGA_ERR,        CFGA_ERROR      }
};

#define N_ERR_CVT_TBL   (sizeof (err_cvt_tbl)/sizeof (err_cvt_tbl[0]))

#define DEV_OP  0
#define BUS_OP  1
static set_state_cmd_t set_state_cmds[] = {

{ SCFGA_BUS_QUIESCE,        BUS_OP,     devctl_bus_quiesce  },
{ SCFGA_BUS_UNQUIESCE,      BUS_OP,     devctl_bus_unquiesce    },
{ SCFGA_BUS_CONFIGURE,      BUS_OP,     devctl_bus_configure    },
{ SCFGA_BUS_UNCONFIGURE,    BUS_OP,     devctl_bus_unconfigure  },
{ SCFGA_RESET_BUS,      BUS_OP,     devctl_bus_reset    },
{ SCFGA_RESET_ALL,      BUS_OP,     devctl_bus_resetall },
{ SCFGA_DEV_CONFIGURE,      DEV_OP,     devctl_device_online    },
{ SCFGA_DEV_UNCONFIGURE,    DEV_OP,     devctl_device_offline   },
{ SCFGA_DEV_REMOVE,     DEV_OP,     devctl_device_remove    },
{ SCFGA_RESET_DEV,      DEV_OP,     devctl_device_reset }

};

#define N_SET_STATE_CMDS (sizeof (set_state_cmds)/sizeof (set_state_cmds[0]))

static get_state_cmd_t get_state_cmds[] = {
{ SCFGA_BUS_GETSTATE,       BUS_OP,     devctl_bus_getstate },
{ SCFGA_DEV_GETSTATE,       DEV_OP,     devctl_device_getstate  }
};

#define N_GET_STATE_CMDS (sizeof (get_state_cmds)/sizeof (get_state_cmds[0]))

/*
 * SCSI hardware specific commands
 */
static hw_cmd_t hw_cmds[] = {
    /* Command string   Command ID      Function    */

    { CMD_INSERT_DEV,   SCFGA_INSERT_DEV,   dev_insert  },
    { CMD_REMOVE_DEV,   SCFGA_REMOVE_DEV,   dev_remove  },
    { CMD_REPLACE_DEV,  SCFGA_REPLACE_DEV,  dev_replace },
    { CMD_LED_DEV,      SCFGA_LED_DEV,      dev_led     },
    { CMD_LOCATOR_DEV,  SCFGA_LOCATOR_DEV,  dev_led     },
    { CMD_RESET_DEV,    SCFGA_RESET_DEV,    reset_common    },
    { CMD_RESET_BUS,    SCFGA_RESET_BUS,    reset_common    },
    { CMD_RESET_ALL,    SCFGA_RESET_ALL,    reset_common    },
};
#define N_HW_CMDS (sizeof (hw_cmds) / sizeof (hw_cmds[0]))


cfga_err_t
err_cvt(scfga_ret_t s_err)
{
    int i;

    for (i = 0; i < N_ERR_CVT_TBL; i++) {
        if (err_cvt_tbl[i].scsi_err == s_err) {
            return (err_cvt_tbl[i].cfga_err);
        }
    }

    return (CFGA_ERROR);
}

/*
 * Removes duplicate slashes from a pathname and any trailing slashes.
 * Returns "/" if input is "/"
 */
static char *
pathdup(const char *path, int *l_errnop)
{
    int prev_was_slash = 0;
    char c, *dp = NULL, *dup = NULL;
    const char *sp = NULL;

    *l_errnop = 0;

    if (path == NULL) {
        return (NULL);
    }

    if ((dup = calloc(1, strlen(path) + 1)) == NULL) {
        *l_errnop = errno;
        return (NULL);
    }

    prev_was_slash = 0;
    for (sp = path, dp = dup; (c = *sp) != '\0'; sp++) {
        if (!prev_was_slash || c != '/') {
            *dp++ = c;
        }
        if (c == '/') {
            prev_was_slash = 1;
        } else {
            prev_was_slash = 0;
        }
    }

    /* Remove trailing slash except if it is the first char */
    if (prev_was_slash && dp != dup && dp - 1 != dup) {
        *(--dp) = '\0';
    } else {
        *dp = '\0';
    }

    return (dup);
}


scfga_ret_t
apidt_create(const char *ap_id, apid_t *apidp, char **errstring)
{
    char *hba_phys = NULL, *dyn = NULL;
    char *dyncomp = NULL, *path = NULL;
    int l_errno = 0;
    size_t len = 0;
    scfga_ret_t ret;

    if ((hba_phys = pathdup(ap_id, &l_errno)) == NULL) {
        cfga_err(errstring, l_errno, ERR_OP_FAILED, 0);
        return (SCFGA_LIB_ERR);
    }

    /* Extract the base(hba) and dynamic(device) component if any */
    dyncomp = NULL;
    if ((dyn = GET_DYN(hba_phys)) != NULL) {
        len = strlen(DYN_TO_DYNCOMP(dyn)) + 1;
        dyncomp = calloc(1, len);
        if (dyncomp == NULL) {
            cfga_err(errstring, errno, ERR_OP_FAILED, 0);
            ret = SCFGA_LIB_ERR;
            goto err;
        }
        (void) strcpy(dyncomp, DYN_TO_DYNCOMP(dyn));

        /* Remove the dynamic component from the base */
        *dyn = '\0';
    } else {
        apidp->dyntype = NODYNCOMP;
    }

    /* get dyn comp type */
    if (dyncomp != NULL) {
        if (strstr(dyncomp, PATH_APID_DYN_SEP) != NULL) {
            apidp->dyntype = PATH_APID;
        } else {
            apidp->dyntype = DEV_APID;
        }
    }

    /* Create the path */
    if ((ret = apid_to_path(hba_phys, dyncomp, &path,
        &l_errno)) != SCFGA_OK) {
        cfga_err(errstring, l_errno, ERR_OP_FAILED, 0);
        goto err;
    }

    assert(path != NULL);
    assert(hba_phys != NULL);

    apidp->hba_phys = hba_phys;
    apidp->dyncomp = dyncomp;
    apidp->path = path;
    apidp->flags = 0;

    return (SCFGA_OK);

err:
    S_FREE(hba_phys);
    S_FREE(dyncomp);
    S_FREE(path);
    return (ret);
}

void
apidt_free(apid_t *apidp)
{
    if (apidp == NULL)
        return;

    S_FREE(apidp->hba_phys);
    S_FREE(apidp->dyncomp);
    S_FREE(apidp->path);
}

scfga_ret_t
walk_tree(
    const char  *physpath,
    void        *arg,
    uint_t      init_flags,
    walkarg_t   *up,
    scfga_cmd_t cmd,
    int     *l_errnop)
{
    int rv;
    di_node_t root, walk_root;
    char *root_path, *cp = NULL, *init_path;
    size_t len;
    scfga_ret_t ret;

    *l_errnop = 0;

    if ((root_path = strdup(physpath)) == NULL) {
        *l_errnop = errno;
        return (SCFGA_LIB_ERR);
    }

    /* Fix up path for di_init() */
    len = strlen(DEVICES_DIR);
    if (strncmp(root_path, DEVICES_DIR SLASH,
        len + strlen(SLASH)) == 0) {
        cp = root_path + len;
        (void) memmove(root_path, cp, strlen(cp) + 1);
    } else if (*root_path != '/') {
        *l_errnop = 0;
        ret = SCFGA_ERR;
        goto out;
    }

    /* Remove dynamic component if any */
    if ((cp = GET_DYN(root_path)) != NULL) {
        *cp = '\0';
    }

    /* Remove minor name if any */
    if ((cp = strrchr(root_path, ':')) != NULL) {
        *cp = '\0';
    }

    /*
     * Cached snapshots are always rooted at "/"
     */
    init_path = root_path;
    if ((init_flags & DINFOCACHE) == DINFOCACHE) {
        init_path = "/";
    }

    /* Get a snapshot */
    if ((root = di_init(init_path, init_flags)) == DI_NODE_NIL) {
        *l_errnop = errno;
        ret = SCFGA_LIB_ERR;
        goto out;
    }

    /*
     * Lookup the subtree of interest
     */
    walk_root = root;
    if ((init_flags & DINFOCACHE) == DINFOCACHE) {
        walk_root = di_lookup_node(root, root_path);
    }

    if (walk_root == DI_NODE_NIL) {
        *l_errnop = errno;
        di_fini(root);
        ret = SCFGA_LIB_ERR;
        goto out;
    }

    /* Walk the tree */
    errno = 0;
    if (cmd == SCFGA_WALK_NODE) {
        rv = di_walk_node(walk_root, up->node_args.flags, arg,
            up->node_args.fcn);
    } else if (cmd == SCFGA_WALK_PATH) {
        rv = stat_path_info(walk_root, arg, l_errnop);
    } else {
        assert(cmd == SCFGA_WALK_MINOR);
        rv = di_walk_minor(walk_root, up->minor_args.nodetype, 0, arg,
            up->minor_args.fcn);
    }

    if (rv != 0) {
        *l_errnop = errno;
        ret = SCFGA_LIB_ERR;
    } else {
        *l_errnop = 0;
        ret = SCFGA_OK;
    }

    di_fini(root);

    /*FALLTHRU*/
out:
    S_FREE(root_path);
    return (ret);
}

scfga_ret_t
invoke_cmd(
    const char *func,
    apid_t *apidtp,
    prompt_t *prp,
    cfga_flags_t flags,
    char **errstring)
{
    int i;
    int len;


    /*
     * Determine if the func has an equal sign; only compare up to
     * the equals
     */
    for (len = 0; func[len] != 0 && func[len] != '='; len++) {
    };

    for (i = 0; i < N_HW_CMDS; i++) {
        const char *s = GET_MSG_STR(hw_cmds[i].str_id);
        if (strncmp(func, s, len) == 0 && s[len] == 0) {
            return (hw_cmds[i].fcn(func, hw_cmds[i].cmd, apidtp,
                prp, flags, errstring));
        }
    }

    cfga_err(errstring, 0, ERRARG_HWCMD_INVAL, func, 0);
    return (SCFGA_ERR);
}

int
msg_idx(msgid_t msgid)
{
    int idx = 0;

    /* The string table index and the error id may or may not be same */
    if (msgid >= 0 && msgid <= N_STRS - 1 &&
        str_tbl[msgid].msgid == msgid) {
        idx = msgid;
    } else {
        for (idx = 0; idx < N_STRS; idx++) {
            if (str_tbl[idx].msgid == msgid)
                break;
        }
        if (idx >= N_STRS) {
            idx =  UNKNOWN_ERR_IDX;
        }
    }

    return (idx);
}

/*
 * cfga_err() accepts a variable number of message IDs and constructs
 * a corresponding error string which is returned via the errstring argument.
 * cfga_err() calls dgettext() to internationalize proper messages.
 * May be called with a NULL argument.
 */
void
cfga_err(char **errstring, int l_errno, ...)
{
    va_list ap;
    int append_newline = 0;

    if (errstring == NULL || *errstring != NULL) {
        return;
    }

    /*
     * Don't append a newline, the application (for example cfgadm)
     * should do that.
     */
    append_newline = 0;

    va_start(ap, l_errno);
    msg_common(errstring, append_newline, l_errno, ap);
    va_end(ap);
}

/*
 * This routine accepts a variable number of message IDs and constructs
 * a corresponding message string which is printed via the message print
 * routine argument.
 */
void
cfga_msg(struct cfga_msg *msgp, ...)
{
    char *p = NULL;
    int append_newline = 0, l_errno = 0;
    va_list ap;

    if (msgp == NULL || msgp->message_routine == NULL) {
        return;
    }

    /* Append a newline after message */
    append_newline = 1;
    l_errno = 0;

    va_start(ap, msgp);
    msg_common(&p, append_newline, l_errno, ap);
    va_end(ap);

    (void) (*msgp->message_routine)(msgp->appdata_ptr, p);

    S_FREE(p);
}


/*
 * This routine prints the value of an led for a disk.
 */
void
cfga_led_msg(struct cfga_msg *msgp, apid_t *apidp, led_strid_t led,
    led_modeid_t mode)
{
    char led_msg[MAX_INPUT];    /* 512 bytes */

    if ((msgp == NULL) || (msgp->message_routine == NULL)) {
        return;
    }
    if ((apidp == NULL) || (apidp->dyncomp == NULL)) {
        return;
    }
    (void) snprintf(led_msg, sizeof (led_msg), "%-23s\t%s=%s\n",
        basename(apidp->dyncomp),
        dgettext(TEXT_DOMAIN, led_strs[led]),
        dgettext(TEXT_DOMAIN, led_mode_strs[mode]));
    (void) (*msgp->message_routine)(msgp->appdata_ptr, led_msg);
}

/*
 * Get internationalized string corresponding to message id
 * Caller must free the memory allocated.
 */
char *
cfga_str(int append_newline, ...)
{
    char *p = NULL;
    int l_errno = 0;
    va_list ap;

    va_start(ap, append_newline);
    msg_common(&p, append_newline, l_errno, ap);
    va_end(ap);

    return (p);
}

static void
msg_common(char **msgpp, int append_newline, int l_errno, va_list ap)
{
    int a = 0;
    size_t len = 0;
    int i = 0, n = 0;
    char *s = NULL, *t = NULL;
    strlist_t dummy;
    strlist_t *savep = NULL, *sp = NULL, *tailp = NULL;

    if (*msgpp != NULL) {
        return;
    }

    dummy.next = NULL;
    tailp = &dummy;
    for (len = 0; (a = va_arg(ap, int)) != 0; ) {
        n = GET_MSG_NARGS(a); /* 0 implies no additional args */
        for (i = 0; i <= n; i++) {
            sp = calloc(1, sizeof (*sp));
            if (sp == NULL) {
                goto out;
            }
            if (i == 0 && GET_MSG_INTL(a)) {
                sp->str = dgettext(TEXT_DOMAIN, GET_MSG_STR(a));
            } else if (i == 0) {
                sp->str = GET_MSG_STR(a);
            } else {
                sp->str = va_arg(ap, char *);
            }
            len += (strlen(sp->str));
            sp->next = NULL;
            tailp->next = sp;
            tailp = sp;
        }
    }

    len += 1;   /* terminating NULL */

    s = t = NULL;
    if (l_errno) {
        s = dgettext(TEXT_DOMAIN, ": ");
        t = S_STR(strerror(l_errno));
        if (s != NULL && t != NULL) {
            len += strlen(s) + strlen(t);
        }
    }

    if (append_newline) {
        len++;
    }

    if ((*msgpp = calloc(1, len)) == NULL) {
        goto out;
    }

    **msgpp = '\0';
    for (sp = dummy.next; sp != NULL; sp = sp->next) {
        (void) strcat(*msgpp, sp->str);
    }

    if (s != NULL && t != NULL) {
        (void) strcat(*msgpp, s);
        (void) strcat(*msgpp, t);
    }

    if (append_newline) {
        (void) strcat(*msgpp, dgettext(TEXT_DOMAIN, "\n"));
    }

    /* FALLTHROUGH */
out:
    sp = dummy.next;
    while (sp != NULL) {
        savep = sp->next;
        S_FREE(sp);
        sp = savep;
    }
}

/*
 * Check to see if the given pi_node is the last path to the client device.
 *
 * Return:
 *  0: if there is another path avialable.
 *  -1: if no other paths available.
 */
static int
check_available_path(
    di_node_t client_node,
    di_path_t pi_node)
{
    di_path_state_t pi_state;
    di_path_t   next_pi = DI_PATH_NIL;

    if (((pi_state = di_path_state(pi_node)) != DI_PATH_STATE_ONLINE) &&
        (pi_state != DI_PATH_STATE_STANDBY)) {
        /* it is not last available path */
        return (0);
    }

    while (next_pi = di_path_client_next_path(client_node, next_pi)) {
        /* if anohter pi node is avaialble, return 0 */
        if ((next_pi != pi_node) &&
            (((pi_state = di_path_state(next_pi)) ==
            DI_PATH_STATE_ONLINE) ||
            pi_state == DI_PATH_STATE_STANDBY)) {
            return (0);
        }
    }
    return (-1);
}

scfga_ret_t
path_apid_state_change(
    apid_t      *apidp,
    scfga_cmd_t cmd,
    cfga_flags_t    flags,
    char        **errstring,
    int     *l_errnop,
    msgid_t     errid)
{
    di_node_t   root, walk_root, client_node;
    di_path_t   pi_node = DI_PATH_NIL;
    char        *root_path, *cp, *client_path, devpath[MAXPATHLEN];
    int     len, found = 0;
    scfga_ret_t ret;
    char *dev_list[2] = {NULL};

    *l_errnop = 0;

    /* Make sure apid is pathinfo associated apid. */
    if ((apidp->dyntype != PATH_APID) || (apidp->dyncomp == NULL)) {
        return (SCFGA_LIB_ERR);
    }

    if ((cmd != SCFGA_DEV_CONFIGURE) && (cmd != SCFGA_DEV_UNCONFIGURE)) {
        return (SCFGA_LIB_ERR);
    }

    if ((root_path = strdup(apidp->hba_phys)) == NULL) {
        *l_errnop = errno;
        return (SCFGA_LIB_ERR);
    }

    /* Fix up path for di_init() */
    len = strlen(DEVICES_DIR);
    if (strncmp(root_path, DEVICES_DIR SLASH,
        len + strlen(SLASH)) == 0) {
        cp = root_path + len;
        (void) memmove(root_path, cp, strlen(cp) + 1);
    } else if (*root_path != '/') {
        *l_errnop = 0;
        S_FREE(root_path);
        return (SCFGA_ERR);
    }

    /* Remove dynamic component if any */
    if ((cp = GET_DYN(root_path)) != NULL) {
        *cp = '\0';
    }

    /* Remove minor name if any */
    if ((cp = strrchr(root_path, ':')) != NULL) {
        *cp = '\0';
    }

    /*
     * Cached snapshots are always rooted at "/"
     */

    /* Get a snapshot */
    if ((root = di_init("/", DINFOCACHE)) == DI_NODE_NIL) {
        *l_errnop = errno;
        S_FREE(root_path);
        return (SCFGA_ERR);
    }

    /*
     * Lookup the subtree of interest
     */
    walk_root = di_lookup_node(root, root_path);

    if (walk_root == DI_NODE_NIL) {
        *l_errnop = errno;
        di_fini(root);
        S_FREE(root_path);
        return (SCFGA_LIB_ERR);
    }


    if ((pi_node = di_path_next_client(walk_root, pi_node)) ==
        DI_PATH_NIL) {
        /* the path apid not found */
        di_fini(root);
        S_FREE(root_path);
        return (SCFGA_APID_NOEXIST);
    }

    do {
        /* check the length first. */
        if (strlen(di_path_bus_addr(pi_node)) !=
            strlen(apidp->dyncomp)) {
            continue;
        }

        /* compare bus addr. */
        if (strcmp(di_path_bus_addr(pi_node), apidp->dyncomp) == 0) {
            found = 1;
            break;
        }
        pi_node = di_path_next_client(root, pi_node);
    } while (pi_node != DI_PATH_NIL);

    if (!found) {
        di_fini(root);
        S_FREE(root_path);
        return (SCFGA_APID_NOEXIST);
    }

    /* Get client node path. */
    client_node = di_path_client_node(pi_node);
    if (client_node == DI_NODE_NIL) {
        di_fini(root);
        S_FREE(root_path);
        return (SCFGA_ERR);
    } else {
        client_path = di_devfs_path(client_node);
        if (client_path == NULL) {
            di_fini(root);
            S_FREE(root_path);
            return (SCFGA_ERR);
        }

        if ((apidp->flags & FLAG_DISABLE_RCM) == 0) {
            if (cmd == SCFGA_DEV_UNCONFIGURE) {
                if (check_available_path(client_node,
                    pi_node) != 0) {
                    /*
                     * last path. check if unconfiguring
                     * is okay.
                     */
                    (void) snprintf(devpath,
                        strlen(DEVICES_DIR) +
                        strlen(client_path) + 1, "%s%s",
                        DEVICES_DIR, client_path);
                    dev_list[0] = devpath;
                    flags |= FLAG_CLIENT_DEV;
                    ret = scsi_rcm_offline(dev_list,
                        errstring, flags);
                    if (ret != SCFGA_OK) {
                        di_fini(root);
                        di_devfs_path_free(client_path);
                        S_FREE(root_path);
                        return (ret);
                    }
                }
            }
        }
    }

    ret = devctl_cmd(apidp->path, cmd, NULL, l_errnop);
    if (ret != SCFGA_OK) {
        cfga_err(errstring, *l_errnop, errid, 0);

        /*
         * If an unconfigure fails, cancel the RCM offline.
         * Discard any RCM failures so that the devctl
         * failure will still be reported.
         */
        if ((apidp->flags & FLAG_DISABLE_RCM) == 0) {
            if (cmd == SCFGA_DEV_UNCONFIGURE)
                (void) scsi_rcm_online(dev_list,
                    errstring, flags);
        }
    }

    di_devfs_path_free(client_path);
    di_fini(root);
    S_FREE(root_path);

    return (ret);
}


scfga_ret_t
devctl_cmd(
    const char  *physpath,
    scfga_cmd_t cmd,
    uint_t      *statep,
    int     *l_errnop)
{
    int rv = -1, i, type;
    devctl_hdl_t hdl = NULL;
    char *cp = NULL, *path = NULL;
    int (*func)(const devctl_hdl_t);
    int (*state_func)(const devctl_hdl_t, uint_t *);

    *l_errnop = 0;

    if (statep != NULL) *statep = 0;

    func = NULL;
    state_func = NULL;
    type = 0;

    for (i = 0; i < N_GET_STATE_CMDS; i++) {
        if (get_state_cmds[i].cmd == cmd) {
            state_func = get_state_cmds[i].state_fcn;
            type = get_state_cmds[i].type;
            assert(statep != NULL);
            break;
        }
    }

    if (state_func == NULL) {
        for (i = 0; i < N_SET_STATE_CMDS; i++) {
            if (set_state_cmds[i].cmd == cmd) {
                func = set_state_cmds[i].fcn;
                type = set_state_cmds[i].type;
                assert(statep == NULL);
                break;
            }
        }
    }

    assert(type == BUS_OP || type == DEV_OP);

    if (func == NULL && state_func == NULL) {
        return (SCFGA_ERR);
    }

    /*
     * Fix up path for calling devctl.
     */
    if ((path = strdup(physpath)) == NULL) {
        *l_errnop = errno;
        return (SCFGA_LIB_ERR);
    }

    /* Remove dynamic component if any */
    if ((cp = GET_DYN(path)) != NULL) {
        *cp = '\0';
    }

    /* Remove minor name */
    if ((cp = strrchr(path, ':')) != NULL) {
        *cp = '\0';
    }

    errno = 0;

    if (type == BUS_OP) {
        hdl = devctl_bus_acquire(path, 0);
    } else {
        hdl = devctl_device_acquire(path, 0);
    }
    *l_errnop = errno;

    S_FREE(path);

    if (hdl == NULL) {
        return (SCFGA_ERR);
    }

    errno = 0;
    /* Only getstate functions require a second argument */
    if (func != NULL && statep == NULL) {
        rv = func(hdl);
        *l_errnop = errno;
    } else if (state_func != NULL && statep != NULL) {
        rv = state_func(hdl, statep);
        *l_errnop = errno;
    } else {
        rv = -1;
        *l_errnop = 0;
    }

    devctl_release(hdl);

    return ((rv == -1) ? SCFGA_ERR : SCFGA_OK);
}

/*
 * Is device in a known state ? (One of BUSY, ONLINE, OFFLINE)
 *  BUSY --> One or more device special files are open. Implies online
 *  ONLINE --> driver attached
 *  OFFLINE --> CF1 with offline flag set.
 *  UNKNOWN --> None of the above
 */
int
known_state(di_node_t node)
{
    uint_t state;

    state = di_state(node);

    /*
     * CF1 without offline flag set is considered unknown state.
     * We are in a known state if either CF2 (driver attached) or
     * offline.
     */
    if ((state & DI_DEVICE_OFFLINE) == DI_DEVICE_OFFLINE ||
        (state & DI_DRIVER_DETACHED) != DI_DRIVER_DETACHED) {
        return (1);
    }

    return (0);
}

void
list_free(ldata_list_t **llpp)
{
    ldata_list_t *lp, *olp;

    lp = *llpp;
    while (lp != NULL) {
        olp = lp;
        lp = olp->next;
        S_FREE(olp);
    }

    *llpp = NULL;
}

/*
 * Obtain the devlink from a /devices path
 */
typedef struct walk_link {
    char *path;
    char len;
    char **linkpp;
} walk_link_t;

static int
get_link(di_devlink_t devlink, void *arg)
{
    walk_link_t *larg = (walk_link_t *)arg;

    /*
     * When path is specified, it's the node path without minor
     * name. Therefore, the ../.. prefixes needs to be stripped.
     */
    if (larg->path) {
        char *content = (char *)di_devlink_content(devlink);
        char *start = strstr(content, "/devices/");

        /* line content must have minor node */
        if (start == NULL ||
            strncmp(start, larg->path, larg->len) != 0 ||
            start[larg->len] != ':')
            return (DI_WALK_CONTINUE);
    }

    *(larg->linkpp) = strdup(di_devlink_path(devlink));
    return (DI_WALK_TERMINATE);
}

scfga_ret_t
physpath_to_devlink(
    char *node_path,
    char **logpp,
    int *l_errnop,
    int match_minor)
{
    walk_link_t larg;
    di_devlink_handle_t hdl;
    char *minor_path;

    if ((hdl = di_devlink_init(NULL, 0)) == NULL) {
        *l_errnop = errno;
        return (SCFGA_LIB_ERR);
    }

    *logpp = NULL;
    larg.linkpp = logpp;
    if (match_minor) {
        minor_path = node_path + strlen(DEVICES_DIR);
        larg.path = NULL;
    } else {
        minor_path = NULL;
        larg.len = strlen(node_path);
        larg.path = node_path;
    }

    (void) di_devlink_walk(hdl, NULL, minor_path, DI_PRIMARY_LINK,
        (void *)&larg, get_link);

    (void) di_devlink_fini(&hdl);

    if (*logpp == NULL)
        return (SCFGA_LIB_ERR);

    return (SCFGA_OK);
}

int
hba_dev_cmp(const char *hba, const char *devpath)
{
    char *cp = NULL;
    int rv;
    size_t hba_len, dev_len;
    char l_hba[MAXPATHLEN], l_dev[MAXPATHLEN];

    (void) snprintf(l_hba, sizeof (l_hba), "%s", hba);
    (void) snprintf(l_dev, sizeof (l_dev), "%s", devpath);

    /* Remove dynamic component if any */
    if ((cp = GET_DYN(l_hba)) != NULL) {
        *cp = '\0';
    }

    if ((cp = GET_DYN(l_dev)) != NULL) {
        *cp = '\0';
    }


    /* Remove minor names */
    if ((cp = strrchr(l_hba, ':')) != NULL) {
        *cp = '\0';
    }

    if ((cp = strrchr(l_dev, ':')) != NULL) {
        *cp = '\0';
    }

    hba_len = strlen(l_hba);
    dev_len = strlen(l_dev);

    /* Check if HBA path is component of device path */
    if (rv = strncmp(l_hba, l_dev, hba_len)) {
        return (rv);
    }

    /* devpath must have '/' and 1 char in addition to hba path */
    if (dev_len >= hba_len + 2 && l_dev[hba_len] == '/') {
        return (0);
    } else {
        return (-1);
    }
}

int
dev_cmp(const char *dev1, const char *dev2, int match_minor)
{
    char l_dev1[MAXPATHLEN], l_dev2[MAXPATHLEN];
    char *mn1, *mn2;
    int rv;

    (void) snprintf(l_dev1, sizeof (l_dev1), "%s", dev1);
    (void) snprintf(l_dev2, sizeof (l_dev2), "%s", dev2);

    if ((mn1 = GET_DYN(l_dev1)) != NULL) {
        *mn1 = '\0';
    }

    if ((mn2 = GET_DYN(l_dev2)) != NULL) {
        *mn2 = '\0';
    }

    /* Separate out the minor names */
    if ((mn1 = strrchr(l_dev1, ':')) != NULL) {
        *mn1++ = '\0';
    }

    if ((mn2 = strrchr(l_dev2, ':')) != NULL) {
        *mn2++ = '\0';
    }

    if ((rv = strcmp(l_dev1, l_dev2)) != 0 || !match_minor) {
        return (rv);
    }

    /*
     * Compare minor names
     */
    if (mn1 == NULL && mn2 == NULL) {
        return (0);
    } else if (mn1 == NULL) {
        return (-1);
    } else if (mn2 == NULL) {
        return (1);
    } else {
        return (strcmp(mn1, mn2));
    }
}