/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*LINTLIBRARY*/

/*
 * I18N message number ranges
 *  This file: (not defined yet)
 *  Shared common messages: 1 - 1999
 */

/*
 *      This module is part of the Fibre Channel Interface library.
 */

/* #define              _POSIX_SOURCE 1 */


/*      Includes        */
#include        <stdlib.h>
#include        <stdio.h>
#include        <sys/file.h>
#include        <sys/types.h>
#include        <sys/stat.h>
#include        <sys/mkdev.h>
#include        <sys/param.h>
#include        <fcntl.h>
#include        <unistd.h>
#include        <string.h>
#include        <sys/scsi/scsi.h>
#include        <dirent.h>              /* for DIR */
#include        <sys/vtoc.h>
#include        <nl_types.h>
#include        <strings.h>
#include        <sys/ddi.h>             /* for max */
#include        <fnmatch.h>
#include        <l_common.h>
#include        <stgcom.h>
#include        <l_error.h>
#include        <g_state.h>
#include        <sys/fibre-channel/ulp/fcp_util.h>
#include        <sys/fibre-channel/impl/fc_error.h>
#include        <sys/fibre-channel/impl/fcph.h>
#include        <sys/socalio.h>
#include        <libdevinfo.h>
#include        <libnvpair.h>
#include        <sys/scsi/adapters/scsi_vhci.h>
#include        <errno.h>

/* Some forward declarations of static functions */
static void g_free_pi_list(sv_path_info_t *, uint_t num_paths);
static int get_pathlist(char *, sv_iocdata_t *, int *);
static int stms_path_enable_disable(char *, char *, int);
static int stms_path_enable_disable_all(char *, int);

/*
 * To get lun number of a given device pathname using driver ioctl.
 * This interface is called directly by g_get_lun_number
 *
 * inputs;
 * outputs:
 * returns:
 *    0 - success
 *   !0 - failure
 */
int
g_get_lun_str(char *dev_path, char lunstr[], int path_num)
{
        char            *char_ptr, *charptr1;
        int             fd = 0;
        sv_iocdata_t    ioc;
        char            phci_path[MAXPATHLEN];
        char            client_path[MAXPATHLEN];
        char            paddr[MAXNAMELEN];
        uint_t          num_elem = 0, i;
        sv_path_info_t  *pi = NULL;
        int             retval = 0;
        uint_t          num_paths;

        if (strstr(dev_path, "/devices") == NULL) {
                return (-1);
        }

        num_paths = path_num + 1;
        (void) strcpy(client_path, dev_path + DEV_PREFIX_LEN-1);
        if ((char_ptr = strrchr(client_path, ':')) != NULL) {
                *char_ptr = '\0';
        }

        ioc.client      = client_path;
        ioc.phci        = phci_path;
        ioc.addr        = paddr;
        ioc.buf_elem    = 0;
        ioc.ret_buf     = NULL;
        ioc.ret_elem    = &num_elem;

        if ((fd = g_object_open(VHCI_NODE, O_RDWR)) < 0) {
                return (L_OPEN_PATH_FAIL);
        }

        /* Allocate memory for path info structs */
        pi = (sv_path_info_t *)calloc((size_t)num_paths,
                sizeof (sv_path_info_t));
        ioc.buf_elem = num_paths;
        ioc.ret_buf  = pi;

        /* Allocate memory for getting per path info properties */

        for (i = 0; i < num_paths; i++) {
                pi[i].ret_prop.buf_size = SV_PROP_MAX_BUF_SIZE;
                if (((pi[i].ret_prop.buf =
                        malloc(SV_PROP_MAX_BUF_SIZE)) == NULL) ||
                        ((pi[i].ret_prop.ret_buf_size =
                                malloc(sizeof (*pi[i].ret_prop.ret_buf_size)))
                                    == NULL)) {
                        /* Free memory for per path info properties */
                        g_free_pi_list(pi, num_paths);
                        (void) close(fd);
                        return (-1);
                }
        }

        retval = ioctl(fd, SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO, &ioc);
        if (retval != 0) {
                /* Free memory for per path info properties */
                g_free_pi_list(pi, num_paths);
                (void) close(fd);
                return (retval);
        }

        if (path_num < ioc.buf_elem) {
                charptr1 = strchr(pi[path_num].ret_addr, ',');
                retval = 0;
        } else {
                charptr1 = strchr(pi[0].ret_addr, ',');
                retval = -1;
        }

        if (charptr1 != NULL) {
                charptr1++;
                if (charptr1 != NULL) {
                        (void) strcpy(lunstr, charptr1);
                }
        }

        /* Free memory for per path info properties */
        g_free_pi_list(pi, num_paths);
        (void) close(fd);
        return (retval);
}

/*
 * To give the lun number of a given device pathname
 *
 * inputs: physical pathname beginning with /devices
 * outputs: none
 * returns: lun number (if available) or -1 (if not available or
 *          failure)
 */
int
g_get_lun_number(char *path_phys)
{
        char            path0[MAXPATHLEN], lunarr[MAXPATHLEN];
        char            *charptr1, *charptr2, *charptr3;
        int             lunval = 0;

        if ((strstr(path_phys, "/devices")) == NULL) {
                return (-1);
        }

        if (((charptr3 = strstr(path_phys, SLSH_DRV_NAME_SSD)) == NULL) &&
                ((charptr3 = strstr(path_phys, SLSH_DRV_NAME_ST)) == NULL)) {
                return (-1);
        }

        (void) strcpy(path0, charptr3);

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

        if ((charptr1 = strchr(path0, ',')) != NULL) {
                charptr1++;
                if (*charptr1 != '0') {
                        (void) strcpy(lunarr, charptr1);
                } else {
                        return (0);
                }
        } else if (strstr(path_phys, SCSI_VHCI) != NULL) {
                /* for the time being */
                if (g_get_lun_str(path_phys, lunarr, 0) != 0) {
                        return (-1);
                }
        } else {
                return (-1);
        }

        lunval = (int)strtol(lunarr, NULL, 16);

        return (lunval);
}

/*
 * Input - Space for client_path, phci_path and paddr fields of ioc structure
 * need to be allocated by the caller of this routine.
 */
static int
get_pathlist(char *dev_path, sv_iocdata_t *ioc, int *num_paths_to_copy)
{
        char    *physical_path, *physical_path_s;
        int     retval;
        int     fd;
        int     initial_path_count;
        int     current_path_count;
        int     i;
        char    *delimiter;
        int     malloc_error = 0;
        int     prop_buf_size;
        int     pathlist_retry_count = 0;

        if (strncmp(dev_path, SCSI_VHCI, strlen(SCSI_VHCI)) != 0) {
                if ((physical_path = g_get_physical_name(dev_path)) == NULL) {
                        return (L_INVALID_PATH);
                }
                if (strncmp(physical_path, SCSI_VHCI, strlen(SCSI_VHCI)) != 0) {
                        free(physical_path);
                        return (L_INVALID_PATH);
                }
        } else {
                if ((physical_path = calloc(1, MAXPATHLEN)) == NULL) {
                        return (L_MALLOC_FAILED);
                }
                (void) strcpy(physical_path, dev_path);
        }
        physical_path_s = physical_path;

        /* move beyond "/devices" prefix */
        physical_path += DEV_PREFIX_LEN-1;
        /* remove  :c,raw suffix */
        delimiter = strrchr(physical_path, ':');
        /* if we didn't find the ':' fine, else truncate */
        if (delimiter != NULL) {
                *delimiter = '\0';
        }

        /*
         * We'll call ioctl SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO
         * at least twice.  The first time will get the path count
         * and the size of the ioctl propoerty buffer.  The second
         * time will get the path_info for each path.
         *
         * It's possible that additional paths are added while this
         * code is running.  If the path count increases between the
         * 2 ioctl's above, then we'll retry (and assume all is well).
         */
        (void) strcpy(ioc->client, physical_path);
        ioc->buf_elem = 1;
        ioc->ret_elem = (uint_t *)&(initial_path_count);
        ioc->ret_buf = NULL;

        /* free physical path */
        free(physical_path_s);

        /* 0 buf_size asks driver to return actual size needed */
        /* open the ioctl file descriptor */
        if ((fd = g_object_open(VHCI_NODE, O_RDWR)) < 0) {
                return (L_OPEN_PATH_FAIL);
        }

        retval = ioctl(fd, SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO, ioc);
        if (retval != 0) {
                close(fd);
                return (L_SCSI_VHCI_ERROR);
        }
        prop_buf_size = SV_PROP_MAX_BUF_SIZE;


        while (pathlist_retry_count <= RETRY_PATHLIST) {
                ioc->buf_elem = initial_path_count;
                /* Make driver put actual # paths in variable */
                ioc->ret_elem = (uint_t *)&(current_path_count);

                /*
                 * Allocate space for array of path_info structures.
                 * Allocate enough space for # paths from get_pathcount
                 */
                ioc->ret_buf = (sv_path_info_t *)
                                calloc(initial_path_count,
                                        sizeof (sv_path_info_t));
                if (ioc->ret_buf == NULL) {
                        close(fd);
                        return (L_MALLOC_FAILED);
                }

                /*
                 * Allocate space for path properties returned by driver
                 */
                malloc_error = 0;
                for (i = 0; i < initial_path_count; i++) {
                        ioc->ret_buf[i].ret_prop.buf_size = prop_buf_size;
                        if ((ioc->ret_buf[i].ret_prop.buf =
                            (caddr_t)malloc(prop_buf_size)) == NULL) {
                                malloc_error = 1;
                                break;
                        }
                        if ((ioc->ret_buf[i].ret_prop.ret_buf_size =
                                (uint_t *)malloc(sizeof (uint_t))) == NULL) {
                                malloc_error = 1;
                                break;
                        }
                }
                if (malloc_error == 1) {
                        for (i = 0; i < initial_path_count; i++) {
                                free(ioc->ret_buf[i].ret_prop.buf);
                                free(ioc->ret_buf[i].ret_prop.ret_buf_size);
                        }
                        free(ioc->ret_buf);
                        close(fd);
                        return (L_MALLOC_FAILED);
                }

                retval = ioctl(fd, SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO, ioc);
                if (retval != 0) {
                        for (i = 0; i < initial_path_count; i++) {
                                free(ioc->ret_buf[i].ret_prop.buf);
                                free(ioc->ret_buf[i].ret_prop.ret_buf_size);
                        }
                        free(ioc->ret_buf);
                        close(fd);
                        return (L_SCSI_VHCI_ERROR);
                }
                if (initial_path_count < current_path_count) {
                        /* then a new path was added */
                        pathlist_retry_count++;
                        initial_path_count = current_path_count;
                } else {
                        break;
                }
        }
        /* we are done with ioctl's, lose the fd */
        close(fd);

        /*
         * Compare the length num elements from the ioctl response
         *   and the caller's request - use smaller value.
         *
         * pathlist_p->path_count now has count returned from ioctl.
         * ioc.buf_elem has the value the caller provided.
         */
        if (initial_path_count < current_path_count) {
                /* More paths exist than we allocated space for */
                *num_paths_to_copy = initial_path_count;
        } else {
                *num_paths_to_copy = current_path_count;
        }
return (0);
}

/*
 * To obtain pathlist of a given target device
 *
 * inputs:
 *      dev_path client device path
 *      example: /devices/scsi_vhci/ssd@g280000602200416d6257333030303261:c,raw
 * outputs:
 *      pathlist_p pathlist structure containing pathinfo node data
 * returns:
 *   0 - success
 *  !0 - failure
 */
int
g_get_pathlist(char *dev_path, struct mp_pathlist *pathlist_p)
{

        sv_iocdata_t    ioc;
        int     retval, caller_ret = 0;
        int     num_paths_to_copy;
        int     i;
        int     prop_buf_size;
        char    *path_class_val = NULL;
        char    *temp_addr;
        char    phci_path[MAXPATHLEN];
        char    client_path[MAXPATHLEN];
        char    paddr[MAXNAMELEN];


        ioc.client = client_path;
        ioc.phci = phci_path;
        ioc.addr = paddr;

        if ((caller_ret = get_pathlist(dev_path, &ioc, &num_paths_to_copy))
                != 0) {
                return (caller_ret);
        }

        pathlist_p->path_count = num_paths_to_copy;
        pathlist_p->path_info = calloc(num_paths_to_copy,
                                        sizeof (mp_pathinfo_t));

        prop_buf_size = SV_PROP_MAX_BUF_SIZE;

        if (pathlist_p->path_info == NULL) {
                caller_ret = L_MALLOC_FAILED;
                /* force the loop to not run so we free buffers and exit */
                num_paths_to_copy = 0;
        }

        /* get ioctl reponse fields and copy them to caller's buffer */
        for (i = 0; i < num_paths_to_copy; i++) {
                nvlist_t *nvl;

                pathlist_p->path_info[i].path_state =
                        ioc.ret_buf[i].ret_state;
                (void) strncpy(pathlist_p->path_info[i].path_hba, DEV_PREFIX,
                        DEV_PREFIX_LEN - 1);
                (void) strcat(pathlist_p->path_info[i].path_hba,
                        ioc.ret_buf[i].device.ret_phci);
                (void) strcpy(pathlist_p->path_info[i].path_dev,
                        ioc.client);

                /*
                 * Check for leading 'w'. The mpxio framework was
                 * incorrectly implemented to skip 'w' in mdi_pi_get_addr().
                 * Since the leading 'w' is fibre-channel specific, we
                 * do it here to remove fibre-channel specific behavior
                 * from the mpxio framework.
                 */
                temp_addr = ioc.ret_buf[i].ret_addr;
                if (*temp_addr == 'w') {
                        temp_addr++;
                }
                (void) strcpy(pathlist_p->path_info[i].path_addr, temp_addr);

                /* use nvlist_ calls to extract properties from retbuf */
                retval = nvlist_unpack(ioc.ret_buf[i].ret_prop.buf,
                                        prop_buf_size, &nvl, 0);
                if (retval != 0) { /* ??? same retcode */
                        (void) strcpy(pathlist_p->path_info[i].path_class,
                                "UNKNOWN PROB");
                } else {
                        retval = nvlist_lookup_string(nvl, "path-class",
                                &path_class_val);
                        if (retval != 0) {
                        (void) strcpy(pathlist_p->path_info[i].path_class,
                                "UNKNOWN");
                        } else {
                                (void) strcpy(pathlist_p->path_info[i].
                                        path_class,
                                        path_class_val);
                        }
                        nvlist_free(nvl);
                }
        }

        /* free everything we alloced */
        for (i = 0; i < ioc.buf_elem; i++) {
                free(ioc.ret_buf[i].ret_prop.buf);
                free(ioc.ret_buf[i].ret_prop.ret_buf_size);
        }
        free(ioc.ret_buf);
return (caller_ret);
}

/*
 * To get the number of paths to a given device pathname using
 * driver ioctl.
 *
 * inputs:
 *   dev path you would like to recieve mp count on
 * outputs:
 * returns:
 *   0  - success
 *   -1 - bad device path
 *   -2 - open failure
 *   -3 - ioctl failure
 */
int
g_get_pathcount(char *dev_path)
{
        char            *char_ptr;
        int             fd = -1;
        sv_iocdata_t    ioc;
        char            phci_path[MAXPATHLEN];
        char            client_path[MAXPATHLEN];
        char            paddr[MAXNAMELEN];
        uint_t          num_elem = 0;
        int             retval = 0;
        char            *physical_path;

        /* translate device path to physical path */
        physical_path = g_get_physical_name(dev_path);
        /* ensure physical path is not NULL, or strcpy will core */
        if (physical_path == NULL) {
                return (-1);
        }
        /* copy physical path without /devices/ prefix */
        (void) strcpy(client_path, physical_path + DEV_PREFIX_LEN-1);
        free(physical_path);

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

        /* prepare sv_iocdata_t structure */
        ioc.client      = client_path;
        ioc.phci        = phci_path;
        ioc.addr        = paddr;
        ioc.buf_elem    = 0;
        ioc.ret_buf     = NULL;
        ioc.ret_elem    = &num_elem;

        strcpy(ioc.phci, client_path);

        /* Get file descr. for "/devices/scsi_vhci:devctl" */
        if ((fd = g_object_open(VHCI_NODE, O_RDWR)) < 0) {
                return (-2);
        }

        /* Issue open to device to get multipath_info (ie. count) */
        retval = ioctl(fd, SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO, &ioc);
        close(fd);

        /* Check icotl status */
        if (retval == 0) {
                /* success */
                return (*ioc.ret_elem);
        } else {
                /* failure */
                return (-3);
        }

}


/*
 * Call driver to effect failover for a given pathclass
 *
 * inputs:
 * outputs:
 * returns:
 *   0  - success
 *   !0 - failure
 */
int
g_failover(char *dev_path, char *path_class)
{
int             fd = 0, ret = 0;
char            client_path[MAXPATHLEN];
char            class[MAXNAMELEN];
sv_switch_to_cntlr_iocdata_t    iocsc;

char            *char_ptr_start, *char_ptr_end;


        if (strstr(dev_path, SCSI_VHCI) == NULL) {
                return (L_INVALID_PATH);
        }

        char_ptr_start = dev_path + strlen("/devices");
        if ((char_ptr_end = strrchr(char_ptr_start, ':')) != NULL) {
                *char_ptr_end = '\0';
        }

        if ((fd = g_object_open(VHCI_NODE, O_RDWR)) < 0) {
                return (L_OPEN_PATH_FAIL);
        }

        iocsc.client = client_path;
        iocsc.class = class;

        strcpy(iocsc.client, char_ptr_start);
        strcpy(iocsc.class, path_class);

        if (ioctl(fd, SCSI_VHCI_SWITCH_TO_CNTLR, &iocsc) != 0) {
                switch (errno) {
                        case EALREADY:
                                ret = L_SCSI_VHCI_ALREADY_ACTIVE;
                                break;
                        case ENXIO:
                                ret = L_INVALID_PATH;
                                break;
                        case EIO:
                                ret = L_SCSI_VHCI_NO_STANDBY;
                                break;
                        case ENOTSUP:
                                ret = L_SCSI_VHCI_FAILOVER_NOTSUP;
                                break;
                        case EBUSY:
                                ret = L_SCSI_VHCI_FAILOVER_BUSY;
                                break;
                        case EFAULT:
                        default:
                                ret = L_SCSI_VHCI_ERROR;
                }
        }

        close(fd);
        return (ret);
}

static void
g_free_pi_list(sv_path_info_t *pi, uint_t num_paths)
{
sv_path_info_t *pi_h = pi;
int i = 0;

        while (i++ < num_paths && pi != NULL) {
                free(pi->ret_prop.buf);
                free(pi->ret_prop.ret_buf_size);
                pi++;
        }
        free(pi_h);
}


/*
 * Name: stms_path_enable_disable
 *
 * inputs:
 *
 * client_path  client device path
 *      example: /devices/scsi_vhci/ssd@g280000602200416d6257333030303261:c,raw
 *
 * phci         Controller device path
 *      example: /devices/pci@4,4000/SUNW,qlc@4/fp@0,0
 *
 * request should be set to one of the following:
 *      SCSI_VHCI_PATH_DISABLE
 *      SCSI_VHCI_PATH_ENABLE
 *
 * returns:
 *      0 for success
 *      non-zero otherwise
 */
static int
stms_path_enable_disable(char *client_path, char *phci, int request)
{
        char *ioc_phci;
        char *char_ptr_end;
        char *client_physical_path, *client_path_ptr;
        int fd;
        sv_iocdata_t    ioc;

        if (!client_path || !phci) {
                return (EINVAL);
        }

        if ((fd = g_object_open(VHCI_NODE, O_RDWR)) < 0) {
                return (L_OPEN_PATH_FAIL);
        }

        /*
         * translate device path to physical path
         * Save off the ptr for use by free
         */
        client_path_ptr = client_physical_path =
                g_get_physical_name(client_path);

        /* ensure physical path is not NULL, or strcpy will core */
        if (client_physical_path == NULL) {
                return (EINVAL);
        }

        /*
         * Must be a scsi_vhci path
         */
        if (strstr(client_physical_path, SCSI_VHCI) == NULL) {
                free(client_path_ptr);
                return (L_INVALID_PATH);
        }

        /* physical path without /devices/ prefix */
        client_physical_path += DEV_PREFIX_LEN - 1;

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

        /*
         * If there is a '/devices', strip it, if not
         * assume it is complete and correct
         */
        if (strncmp(phci, DEV_PREFIX, DEV_PREFIX_LEN) == 0) {
                ioc_phci = phci + DEV_PREFIX_LEN - 1;
        } else {
                ioc_phci = phci;
        }

        memset(&ioc, 0, sizeof (ioc));

        ioc.client = client_physical_path;
        ioc.phci = ioc_phci;

        /*
         * Issue requested operation
         */
        if (ioctl(fd, request, &ioc) != 0) {
                free(client_path_ptr);
                return (errno);
        }
        free(client_path_ptr);
        return (0);
}

int
g_stms_path_disable(char *client_path, char *phci)
{
        return (stms_path_enable_disable(client_path, phci,
                SCSI_VHCI_PATH_DISABLE));
}

int
g_stms_path_enable(char *client_path, char *phci)
{
        return (stms_path_enable_disable(client_path, phci,
                SCSI_VHCI_PATH_ENABLE));
}

/*
 * Name: stms_path_enable_disable_all
 *
 * inputs:
 *
 * phci         Controller device path
 *      example: /devices/pci@4,4000/SUNW,qlc@4/fp@0,0
 *
 * request should be set to one of the following:
 *      SCSI_VHCI_PATH_DISABLE
 *      SCSI_VHCI_PATH_ENABLE
 *
 * returns:
 *      0 for success
 *      non-zero otherwise
 */

static int
stms_path_enable_disable_all(char *phci, int request)
{
        int fd;
        char *ioc_phci;
        sv_iocdata_t ioc;

        if (!phci) {
                return (EINVAL);
        }

        if ((fd = g_object_open(VHCI_NODE, O_RDWR)) < 0) {
                return (L_OPEN_PATH_FAIL);
        }

        memset(&ioc, 0, sizeof (ioc));

        /*
         * If there is a '/devices', strip it, if not
         * assume it is complete and correct
         */
        if (strncmp(phci, DEV_PREFIX, DEV_PREFIX_LEN) == 0) {
                ioc_phci = phci + DEV_PREFIX_LEN - 1;
        } else {
                ioc_phci = phci;
        }

        ioc.client = "/scsi_vhci";
        ioc.phci = ioc_phci;

        /*
         * Issue requested operation
         */
        if (ioctl(fd, request, &ioc) != 0) {
                return (errno);
        }
        return (0);
}

int
g_stms_path_disable_all(char *phci)
{
        /*
         * issue disable on all clients for a phci
         */
        return (stms_path_enable_disable_all(phci, SCSI_VHCI_PATH_DISABLE));
}

int
g_stms_path_enable_all(char *phci)
{
        /*
         * issue enable on all clients for a phci
         */
        return (stms_path_enable_disable_all(phci, SCSI_VHCI_PATH_ENABLE));
}

/*
 * Name: stms_get_path_state
 *
 * inputs:
 *
 * client_path  client device path
 *      example: /devices/scsi_vhci/ssd@g280000602200416d6257333030303261:c,raw
 *
 * phci         Controller device path
 *      example: /devices/pci@4,4000/SUNW,qlc@4/fp@0,0
 *
 * outputs:
 * state set to one of enum mdi_pathinfo_state_t in sunmdi.h
 *      MDI_PATHINFO_STATE_*
 *
 * ext_state set to one or more of the bits defined in mdi_impldefs.h
 *      MDI_PATHINFO_STATE_*
 *
 *
 * returns:
 *      0 for success
 *      non-zero otherwise
 */
int
g_stms_get_path_state(char *client_path, char *phci, int *state, int *ext_state)
{
        sv_iocdata_t ioc;
        int num_paths;
        char *ioc_phci;
        int i;
        int found = 0;
        int err;
        char    phci_path[MAXPATHLEN];
        char    cpath[MAXPATHLEN];
        char    paddr[MAXNAMELEN];


        if (!client_path || !phci) {
                return (EINVAL);
        }

        ioc.client = cpath;
        ioc.phci = phci_path;
        ioc.addr = paddr;

        /*
         * Get all the paths for this client
         */
        if ((err = get_pathlist(client_path, &ioc, &num_paths))
                != 0) {
                return (err);
        }

        /*
         * If there is a '/devices', strip it, if not
         * assume it is complete and correct
         */
        if (strncmp(phci, DEV_PREFIX, DEV_PREFIX_LEN) == 0) {
                ioc_phci = phci + DEV_PREFIX_LEN - 1;
        } else {
                ioc_phci = phci;
        }

        /*
         * get ioctl response states
         * for the requested client and phci
         * and copy them to caller's buffers
         */
        for (i = 0; i < num_paths; i++) {
                if (strncmp(ioc_phci, ioc.ret_buf[i].device.ret_phci,
                        strlen(ioc_phci)) == 0) {
                        found++;
                        *state = ioc.ret_buf[i].ret_state;
                        *ext_state = ioc.ret_buf[i].ret_ext_state;
                        break;
                }
        }

        /* free everything we alloced */
        for (i = 0; i < ioc.buf_elem; i++) {
                free(ioc.ret_buf[i].ret_prop.buf);
                free(ioc.ret_buf[i].ret_prop.ret_buf_size);
        }
        free(ioc.ret_buf);

        if (found) {
                return (0);
        } else {
                /* Requested path not found */
                return (ENXIO);
        }
}