/*
 * 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_fp.h"

/* define */
#define ALL_APID_LUNS_UNUSABLE  0x10

#define DEFAULT_LUN_COUNT       1024
#define LUN_SIZE                8
#define LUN_HEADER_SIZE         8
#define DEFAULT_LUN_LENGTH      DEFAULT_LUN_COUNT   *   \
                                LUN_SIZE            +   \
                                LUN_HEADER_SIZE

/* Some forward declarations */
static fpcfga_ret_t do_devctl_dev_create(apid_t *, char *, int,
                                                        uchar_t, char **);
static fpcfga_ret_t dev_rcm_online(apid_t *, int, cfga_flags_t, char **);
static void dev_rcm_online_nonoperationalpath(apid_t *, cfga_flags_t, char **);
static fpcfga_ret_t dev_rcm_offline(apid_t *, cfga_flags_t, char **);
static fpcfga_ret_t dev_rcm_remove(apid_t *, cfga_flags_t, char **);
static fpcfga_ret_t lun_unconf(char *, int, char *, char *, char **);
static fpcfga_ret_t dev_unconf(apid_t *, char **, uchar_t *);
static fpcfga_ret_t is_xport_phys_in_pathlist(apid_t *, char **);
static void copy_pwwn_data_to_str(char *, const uchar_t *);
static fpcfga_ret_t unconf_vhci_nodes(di_path_t, di_node_t, char *,
                        char *, int, int *, int *, char **, cfga_flags_t);
static fpcfga_ret_t unconf_non_vhci_nodes(di_node_t, char *, char *,
                        int, int *, int *, char **, cfga_flags_t);
static fpcfga_ret_t unconf_any_devinfo_nodes(apid_t *, cfga_flags_t, char **,
                        int *, int *);
static fpcfga_ret_t handle_devs(cfga_cmd_t, apid_t *, cfga_flags_t,
                        char **, HBA_HANDLE, int, HBA_PORTATTRIBUTES);


/*
 * This function initiates the creation of the new device node for a given
 * port WWN.
 * So, apidt->dyncomp CANNOT be NULL
 */
static fpcfga_ret_t
do_devctl_dev_create(apid_t *apidt, char *dev_path, int pathlen,
                                        uchar_t dev_dtype, char **errstring)
{
        devctl_ddef_t   ddef_hdl;
        devctl_hdl_t    bus_hdl, dev_hdl;
        char            *drvr_name = "dummy";
        la_wwn_t        pwwn;

        *dev_path = '\0';
        if ((ddef_hdl = devctl_ddef_alloc(drvr_name, 0)) == NULL) {
                cfga_err(errstring, errno, ERRARG_DC_DDEF_ALLOC, drvr_name, 0);
                return (FPCFGA_LIB_ERR);
        }

        if (cvt_dyncomp_to_lawwn(apidt->dyncomp, &pwwn)) {
                devctl_ddef_free(ddef_hdl);
                cfga_err(errstring, 0, ERR_APID_INVAL, 0);
                return (FPCFGA_LIB_ERR);
        }

        if (devctl_ddef_byte_array(ddef_hdl, PORT_WWN_PROP, FC_WWN_SIZE,
                                                        pwwn.raw_wwn) == -1) {
                devctl_ddef_free(ddef_hdl);
                cfga_err(errstring, errno, ERRARG_DC_BYTE_ARRAY,
                                                        PORT_WWN_PROP, 0);
                return (FPCFGA_LIB_ERR);
        }

        if ((bus_hdl = devctl_bus_acquire(apidt->xport_phys, 0)) == NULL) {
                devctl_ddef_free(ddef_hdl);
                cfga_err(errstring, errno, ERRARG_DC_BUS_ACQUIRE,
                                                        apidt->xport_phys, 0);
                return (FPCFGA_LIB_ERR);
        }

        /* Let driver handle creation of the new path */
        if (devctl_bus_dev_create(bus_hdl, ddef_hdl, 0, &dev_hdl)) {
                devctl_ddef_free(ddef_hdl);
                devctl_release(bus_hdl);
                if (dev_dtype == DTYPE_UNKNOWN) {
                        /*
                         * Unknown DTYPES are devices such as another system's
                         * FC HBA port. We have tried to configure it but
                         * have failed. Since devices with no device type
                         * or an unknown dtype cannot be configured, we will
                         * return an appropriate error message.
                         */
                        cfga_err(errstring, errno,
                            ERRARG_BUS_DEV_CREATE_UNKNOWN, apidt->dyncomp, 0);
                } else {
                        cfga_err(errstring, errno, ERRARG_BUS_DEV_CREATE,
                            apidt->dyncomp, 0);
                }
                return (FPCFGA_LIB_ERR);
        }
        devctl_release(bus_hdl);
        devctl_ddef_free(ddef_hdl);

        devctl_get_pathname(dev_hdl, dev_path, pathlen);
        devctl_release(dev_hdl);

        return (FPCFGA_OK);
}

/*
 * Online, in RCM, all the LUNs for a particular device.
 * Caller can specify the # of luns in the lunlist that have to be onlined
 * by passing a count that is not -ve.
 *
 * INPUT :
 * apidt - this is expected to have the list of luns for the device and so
 *         is assumed to be filled in prior to this call
 * count - # of LUNs in the list that have to be onlined.
 * errstring - If non-NULL, it will hold any error messages
 *
 * RETURNS :
 * 0 on success
 * non-zero otherwise
 */
static fpcfga_ret_t
dev_rcm_online(apid_t *apidt, int count, cfga_flags_t flags, char **errstring)
{
        luninfo_list_t  *lunlistp;
        int             i = 0, ret = 0;
        fpcfga_ret_t    retval = FPCFGA_OK;

        /* This check may be redundant, but safer this way */
        if ((apidt->flags & FLAG_DISABLE_RCM) != 0) {
                /* User has requested not to notify RCM framework */
                return (FPCFGA_OK);
        }

        lunlistp = apidt->lunlist;

        for (lunlistp = apidt->lunlist; lunlistp != NULL;
                                        i++, lunlistp = lunlistp->next) {
                if ((count >= 0) && (i >= count))
                        break;
                if (fp_rcm_online(lunlistp->path, errstring, flags) !=
                                                                FPCFGA_OK) {
                        ret++;
                }
        }

        if (ret > 0)
                retval = FPCFGA_LIB_ERR;

        return (retval);
}

/*
 * Online in RCM for devices which only have paths
 * not in ONLINE/STANDBY state
 */
void
dev_rcm_online_nonoperationalpath(apid_t *apidt, cfga_flags_t flags,
    char **errstring)
{
        luninfo_list_t  *lunlistp;

        if ((apidt->flags & FLAG_DISABLE_RCM) != 0) {
                return;
        }

        lunlistp = apidt->lunlist;

        for (lunlistp = apidt->lunlist; lunlistp != NULL;
            lunlistp = lunlistp->next) {
                if ((lunlistp->lun_flag & FLAG_SKIP_ONLINEOTHERS) != 0) {
                        continue;
                }
                (void) fp_rcm_online(lunlistp->path, errstring, flags);
        }
}

/*
 * Offline, in RCM, all the LUNs for a particular device.
 * This function should not be called for the MPXIO case.
 *
 * INPUT :
 * apidt - this is expected to have the list of luns for the device and so
 *         is assumed to be filled in prior to this call
 * errstring - If non-NULL, it will hold any error messages
 *
 * RETURNS :
 * FPCFGA_OK on success
 * error code otherwise
 */
static fpcfga_ret_t
dev_rcm_offline(apid_t *apidt, cfga_flags_t flags, char **errstring)
{
        int             count = 0;
        luninfo_list_t  *lunlistp;

        if ((apidt->flags & FLAG_DISABLE_RCM) != 0) {
                /* User has requested not to notify RCM framework */
                return (FPCFGA_OK);
        }

        for (lunlistp = apidt->lunlist; lunlistp != NULL;
                                                lunlistp = lunlistp->next) {
                if ((lunlistp->lun_flag & FLAG_SKIP_RCMOFFLINE) != 0) {
                        continue;
                }
                if ((apidt->flags & FLAG_REMOVE_UNUSABLE_FCP_DEV) ==
                    FLAG_REMOVE_UNUSABLE_FCP_DEV) {
                        int ret = strncmp(lunlistp->path, SCSI_VHCI_ROOT,
                                strlen(SCSI_VHCI_ROOT));

                        if (((ret == 0) &&
                            (lunlistp->node_state == DI_PATH_STATE_OFFLINE)) ||
                            ((ret != 0) &&
                            ((lunlistp->node_state & DI_DEVICE_OFFLINE) ==
                            DI_DEVICE_OFFLINE))) {
                                /* Offline the device through RCM */
                                if (fp_rcm_offline(lunlistp->path, errstring,
                                            flags) != 0) {
                                        /*
                                         * Bring everything back online in
                                         * rcm and return
                                         */
                                        (void) dev_rcm_online(apidt, count,
                                                                flags, NULL);
                                        return (FPCFGA_LIB_ERR);
                                }
                                count++;
                        }
                } else {
                        /* Offline the device through RCM */
                        if (fp_rcm_offline(lunlistp->path, errstring,
                                    flags) != 0) {
                                /*
                                 * Bring everything back online in
                                 * rcm and return
                                 */
                                (void) dev_rcm_online(apidt, count, flags,
                                                                        NULL);
                                return (FPCFGA_LIB_ERR);
                        }
                        count++;
                }
        }
        return (FPCFGA_OK);
}

/*
 * Remove, in RCM, all the LUNs for a particular device.
 * This function should not be called for the MPXIO case.
 *
 * INPUT :
 * apidt - this is expected to have the list of luns for the device and so
 *         is assumed to be filled in prior to this call
 * errstring - If non-NULL, it will hold any error messages
 *
 * RETURNS :
 * FPCFGA_OK on success
 * error code otherwise
 */
static fpcfga_ret_t
dev_rcm_remove(apid_t *apidt, cfga_flags_t flags, char **errstring)
{
        int             count = 0;
        luninfo_list_t  *lunlistp;

        if ((apidt->flags & FLAG_DISABLE_RCM) != 0) {
                /* User has requested not to notify RCM framework */
                return (FPCFGA_OK);
        }

        for (lunlistp = apidt->lunlist; lunlistp != NULL;
                                                lunlistp = lunlistp->next) {
                if ((lunlistp->lun_flag & FLAG_SKIP_RCMREMOVE) != 0)
                        continue;
                if ((apidt->flags & FLAG_REMOVE_UNUSABLE_FCP_DEV) ==
                    FLAG_REMOVE_UNUSABLE_FCP_DEV) {
                        int ret = strncmp(lunlistp->path, SCSI_VHCI_ROOT,
                                strlen(SCSI_VHCI_ROOT));

                        if (((ret == 0) &&
                            (lunlistp->node_state == DI_PATH_STATE_OFFLINE)) ||
                            ((ret != 0) &&
                            ((lunlistp->node_state & DI_DEVICE_OFFLINE) ==
                            DI_DEVICE_OFFLINE))) {
                                /* remove the device through RCM */
                                if (fp_rcm_remove(lunlistp->path, errstring,
                                            flags) != 0) {
                                        /*
                                         * Bring everything back online in
                                         * rcm and return
                                         */
                                        (void) dev_rcm_online(apidt, count,
                                                                flags, NULL);
                                        return (FPCFGA_LIB_ERR);
                                }
                                count++;
                        }
                } else {
                        /* remove the device through RCM */
                        if (fp_rcm_remove(lunlistp->path, errstring,
                                flags) != 0) {
                                /*
                                 * Bring everything back online in rcm and
                                 * return
                                 */
                                (void) dev_rcm_online(apidt, count, flags,
                                                                        NULL);
                                return (FPCFGA_LIB_ERR);
                        }
                        count++;
                }
        }
        return (FPCFGA_OK);
}

static fpcfga_ret_t
lun_unconf(char *path, int lunnum, char *xport_phys, char *dyncomp,
                                                char **errstring)
{
        devctl_hdl_t    hdl;
        char            *ptr;           /* To use as scratch/temp pointer */
        char            pathname[MAXPATHLEN];

        if (path == NULL)
                return (FPCFGA_OK);

        if (strncmp(path, SCSI_VHCI_ROOT, strlen(SCSI_VHCI_ROOT)) == 0) {
                /*
                 * We have an MPXIO managed device here.
                 * So, we have to concoct a path for the device.
                 *
                 * xport_phys looks like :
                 * /devices/pci@b,2000/pci@1/SUNW,qlc@5/fp@0,0:fc
                 */
                (void) strlcpy(pathname, xport_phys, MAXPATHLEN);
                if ((ptr = strrchr(pathname, ':')) != NULL) {
                        *ptr = '\0';
                }

                /*
                 * Get pointer to driver name from VHCI path
                 * So, if lunlistp->path is
                 * /devices/scsi_vhci/ssd@g220000203707a417,
                 * we need a pointer to the last '/'
                 *
                 * Assumption:
                 * With MPXIO there will be only one entry per lun
                 * So, there will only be one entry in the linked list
                 * apidt->lunlist
                 */
                if ((ptr = strrchr(path, '/')) == NULL) {
                        /* This shouldn't happen, but anyways ... */
                        cfga_err(errstring, 0, ERRARG_INVALID_PATH, path, 0);
                        return (FPCFGA_LIB_ERR);
                }

                /*
                 * Make pathname to look something like :
                 * /devices/pci@x,xxxx/pci@x/SUNW,qlc@x/fp@x,x/ssd@w...
                 */
                strcat(pathname, ptr);

                /*
                 * apidt_create() will make sure that lunlist->path
                 * has a "@<something>" at the end even if the driver
                 * state is "detached"
                 */
                if ((ptr = strrchr(pathname, '@')) == NULL) {
                        /* This shouldn't happen, but anyways ... */
                        cfga_err(errstring, 0, ERRARG_INVALID_PATH,
                                                pathname, 0);
                        return (FPCFGA_LIB_ERR);
                }
                *ptr = '\0';

                /* Now, concoct the path */
                sprintf(&pathname[strlen(pathname)], "@w%s,%x",
                                                        dyncomp, lunnum);
                ptr = pathname;
        } else {
                /*
                 * non-MPXIO path, use the path that is passed in
                 */
                ptr = path;
        }

        if ((hdl = devctl_device_acquire(ptr,  0)) == NULL) {
                cfga_err(errstring, errno, ERRARG_DEV_ACQUIRE, ptr, 0);
                return (FPCFGA_LIB_ERR);
        }

        if (devctl_device_remove(hdl) != 0) {
                devctl_release(hdl);
                cfga_err(errstring, errno, ERRARG_DEV_REMOVE, ptr, 0);
                return (FPCFGA_LIB_ERR);
        }
        devctl_release(hdl);

        return (FPCFGA_OK);
}

static fpcfga_ret_t
dev_unconf(apid_t *apidt, char **errstring, uchar_t *flag)
{
        luninfo_list_t  *lunlistp;
        fpcfga_ret_t    ret = FPCFGA_OK;
        int lun_cnt = 0, unusable_lun_cnt = 0;

        for (lunlistp = apidt->lunlist; lunlistp != NULL;
            lunlistp = lunlistp->next) {
                lun_cnt++;
                /*
                 * Unconfigure each LUN.
                 * Note that for MPXIO devices, lunlistp->path will be a
                 * vHCI path
                 */
                if ((apidt->flags & FLAG_REMOVE_UNUSABLE_FCP_DEV) ==
                        FLAG_REMOVE_UNUSABLE_FCP_DEV) {
                    if (strncmp(lunlistp->path, SCSI_VHCI_ROOT,
                        strlen(SCSI_VHCI_ROOT)) == 0) {
                        if (lunlistp->node_state ==
                                DI_PATH_STATE_OFFLINE) {
                            unusable_lun_cnt++;
                            if ((ret = lun_unconf(lunlistp->path,
                                lunlistp->lunnum, apidt->xport_phys,
                                apidt->dyncomp, errstring)) != FPCFGA_OK) {
                                return (ret);
                            }
                        }
                    } else {
                        if ((lunlistp->node_state & DI_DEVICE_OFFLINE) ==
                                DI_DEVICE_OFFLINE) {
                            unusable_lun_cnt++;
                            if ((ret = lun_unconf(lunlistp->path,
                                lunlistp->lunnum, apidt->xport_phys,
                                apidt->dyncomp, errstring)) != FPCFGA_OK) {
                                return (ret);
                            }
                        }
                    }
                } else {
                /*
                 * Unconfigure each LUN.
                 * Note that for MPXIO devices, lunlistp->path will be a
                 * vHCI path
                 */
                    if ((ret = lun_unconf(lunlistp->path, lunlistp->lunnum,
                                apidt->xport_phys, apidt->dyncomp,
                                errstring)) != FPCFGA_OK) {
                        return (ret);
                    }
                }
        }

        if ((apidt->flags & FLAG_REMOVE_UNUSABLE_FCP_DEV) ==
                        FLAG_REMOVE_UNUSABLE_FCP_DEV) {
                /*
                 * when all luns are unconfigured
                 * indicate to remove repository entry.
                 */
                if (lun_cnt == unusable_lun_cnt) {
                        *flag = ALL_APID_LUNS_UNUSABLE;
                }
        }

        return (ret);
}

/*
 * Check if the given physical path (the xport_phys) is part of the
 * pHCI list and if the RCM should be done for a particular pHCI.
 * Skip non-MPxIO dev node if any.
 */
static fpcfga_ret_t
is_xport_phys_in_pathlist(apid_t *apidt, char **errstring)
{
        di_node_t       root, vhci, node, phci;
        di_path_t       path = DI_PATH_NIL;
        int             num_active_paths, found = 0;
        char            *vhci_path_ptr, *pathname_ptr, pathname[MAXPATHLEN];
        char            *phci_path, *node_path;
        char            phci_addr[MAXPATHLEN];
        char            *xport_phys, *vhci_path, *dyncomp;
        luninfo_list_t  *lunlistp, *temp;
        int             non_operational_path_count;

        /* a safety check */
        if ((apidt->dyncomp == NULL) || (*apidt->dyncomp == '\0')) {
                return (FPCFGA_LIB_ERR);
        }

        xport_phys = apidt->xport_phys;
        dyncomp = apidt->dyncomp;

        lunlistp = apidt->lunlist;
        for (lunlistp = apidt->lunlist; lunlistp != NULL;
            lunlistp = lunlistp->next) {

                if (strncmp(lunlistp->path, SCSI_VHCI_ROOT,
                    strlen(SCSI_VHCI_ROOT)) != 0) {
                        lunlistp->lun_flag |= FLAG_SKIP_ONLINEOTHERS;
                        continue;
                }

                vhci_path = lunlistp->path;

                num_active_paths = 0;   /* # of paths in ONLINE/STANDBY */
                non_operational_path_count = 0;

                if (xport_phys == NULL || vhci_path == NULL) {
                    cfga_err(errstring, 0, ERRARG_XPORT_NOT_IN_PHCI_LIST,
                    xport_phys, 0);
                        return (FPCFGA_LIB_ERR);
                }

                (void) strlcpy(pathname, xport_phys, MAXPATHLEN);
                if ((pathname_ptr = strrchr(pathname, ':')) != NULL) {
                        *pathname_ptr = '\0';
                }
                /* strip off the /devices/from the path */
                pathname_ptr = pathname + strlen(DEVICES_DIR);

                root = di_init("/", DINFOCPYALL|DINFOPATH);

                if (root == DI_NODE_NIL) {
                        return (FPCFGA_LIB_ERR);
                }

                vhci_path_ptr = vhci_path + strlen(DEVICES_DIR);
                if ((vhci = di_drv_first_node(SCSI_VHCI_DRVR, root)) ==
                    DI_NODE_NIL) {
                        return (FPCFGA_LIB_ERR);
                }
                found = 0;
                for (node = di_child_node(vhci); node != DI_NODE_NIL;
                    node = di_sibling_node(node)) {
                        if ((node_path = di_devfs_path(node)) != NULL) {
                                if (strncmp(vhci_path_ptr, node_path,
                                    strlen(node_path)) != 0) {
                                        di_devfs_path_free(node_path);
                                } else {
                                        found = 1;
                                        break;
                                }
                        }
                }
                if (found == 0) {
                        cfga_err(errstring, 0, ERRARG_XPORT_NOT_IN_PHCI_LIST,
                            xport_phys, 0);
                        di_fini(root);
                        return (FPCFGA_LIB_ERR);
                }
                /* found vhci_path we are looking for */
                di_devfs_path_free(node_path);
                found = 0;
                for (path = di_path_next_phci(node, DI_PATH_NIL);
                    path != DI_PATH_NIL;
                    path = di_path_next_phci(node, path)) {
                        if ((phci = di_path_phci_node(path)) == DI_NODE_NIL) {
                                cfga_err(errstring, 0,
                                    ERRARG_XPORT_NOT_IN_PHCI_LIST,
                                    xport_phys, 0);
                                di_fini(root);
                                return (FPCFGA_LIB_ERR);
                        }
                        if ((phci_path = di_devfs_path(phci)) == NULL) {
                                cfga_err(errstring, 0,
                                    ERRARG_XPORT_NOT_IN_PHCI_LIST,
                                    xport_phys, 0);
                                di_fini(root);
                                return (FPCFGA_LIB_ERR);
                        }
                        (void) di_path_addr(path, (char *)phci_addr);
                        if ((phci_addr == NULL) || (*phci_addr == '\0')) {
                                cfga_err(errstring, 0,
                                    ERRARG_XPORT_NOT_IN_PHCI_LIST,
                                    xport_phys, 0);
                                di_devfs_path_free(phci_path);
                                di_fini(root);
                                return (FPCFGA_LIB_ERR);
                        }
                        /*
                         * Check if the phci path has the same
                         * xport addr and the target addr with current lun
                         */
                        if ((strncmp(phci_path, pathname_ptr,
                            strlen(pathname_ptr)) == 0) &&
                            (strstr(phci_addr, dyncomp) != NULL)) {
                                /* SUCCESS Found xport_phys */
                                found = 1;
                        } else if ((di_path_state(path) ==
                            DI_PATH_STATE_ONLINE) ||
                            (di_path_state(path) == DI_PATH_STATE_STANDBY)) {
                                num_active_paths++;
                        } else {
                                /*
                                 * We have another path not in ONLINE/STANDBY
                                 * state now, so should do a RCM online after
                                 * the unconfiguration of current path.
                                 */
                                non_operational_path_count++;
                        }
                        di_devfs_path_free(phci_path);
                }
                di_fini(root);
                if (found == 1) {
                        if (num_active_paths != 0) {
                                /*
                                 * There are other ONLINE/STANDBY paths,
                                 * so no need to do the RCM
                                 */
                                lunlistp->lun_flag |= FLAG_SKIP_RCMREMOVE;
                                lunlistp->lun_flag |= FLAG_SKIP_RCMOFFLINE;
                        }
                        if (non_operational_path_count == 0) {
                                lunlistp->lun_flag |= FLAG_SKIP_ONLINEOTHERS;
                        }
                } else {
                        /*
                         * Fail all operations here
                         */
                        cfga_err(errstring, 0, ERRARG_XPORT_NOT_IN_PHCI_LIST,
                            xport_phys, 0);
                        return (FPCFGA_APID_NOEXIST);
                }
        }

        /* Mark duplicated paths for same vhci in the list */
        for (lunlistp = apidt->lunlist; lunlistp != NULL;
            lunlistp = lunlistp->next) {
                if (strncmp(lunlistp->path, SCSI_VHCI_ROOT,
                    strlen(SCSI_VHCI_ROOT)) != 0) {
                        continue;
                }
                for (temp = lunlistp->next; temp != NULL;
                    temp = temp->next) {
                        if (strcmp(lunlistp->path, temp->path) == 0) {
                                /*
                                 * don't do RCM for dup
                                 */
                                lunlistp->lun_flag |= FLAG_SKIP_RCMREMOVE;
                                lunlistp->lun_flag |= FLAG_SKIP_RCMOFFLINE;
                                lunlistp->lun_flag |= FLAG_SKIP_ONLINEOTHERS;
                        }
                }
        }
        return (FPCFGA_OK);
}
/*
 * apidt->dyncomp has to be non-NULL by the time this routine is called
 */
fpcfga_ret_t
dev_change_state(cfga_cmd_t state_change_cmd, apid_t *apidt, la_wwn_t *pwwn,
                cfga_flags_t flags, char **errstring, HBA_HANDLE handle,
                HBA_PORTATTRIBUTES portAttrs)
{
        char                    dev_path[MAXPATHLEN];
        char                    *update_str, *t_apid;
        int                     optflag = apidt->flags;
        int                     no_config_attempt = 0;
        fpcfga_ret_t            ret;
        apid_t                  my_apidt;
        uchar_t                 unconf_flag = 0, peri_qual;
        HBA_STATUS              status;
        HBA_PORTATTRIBUTES      discPortAttrs;
        uint64_t                lun = 0;
        struct scsi_inquiry     inq;
        struct scsi_extended_sense sense;
        HBA_UINT8               scsiStatus;
        uint32_t                inquirySize = sizeof (inq),
                                senseSize = sizeof (sense);
        report_lun_resp_t       *resp_buf;
        int                     i, l_errno, num_luns = 0;
        uchar_t                 *lun_string;

        if ((apidt->dyncomp == NULL) || (*apidt->dyncomp == '\0')) {
                /*
                 * No dynamic component specified. Just return success.
                 * Should not see this case. Just a safety check.
                 */
                return (FPCFGA_OK);
        }

        /* Now construct the string we are going to put in the repository */
        if ((update_str = calloc(1, (strlen(apidt->xport_phys) +
                strlen(DYN_SEP) + strlen(apidt->dyncomp) + 1))) == NULL) {
                cfga_err(errstring, errno, ERR_MEM_ALLOC, 0);
                return (FPCFGA_LIB_ERR);
        }
        strcpy(update_str, apidt->xport_phys);
        strcat(update_str, DYN_SEP);
        strcat(update_str, apidt->dyncomp);

        /* If force update of repository is sought, do it first */
        if (optflag & FLAG_FORCE_UPDATE_REP) {
                /* Ignore any failure in rep update */
                (void) update_fabric_wwn_list(
                        ((state_change_cmd == CFGA_CMD_CONFIGURE) ?
                        ADD_ENTRY : REMOVE_ENTRY),
                        update_str, errstring);
        }

        memset(&sense, 0, sizeof (sense));
        if ((ret = get_report_lun_data(apidt->xport_phys, apidt->dyncomp,
                &num_luns, &resp_buf, &sense, &l_errno)) != FPCFGA_OK) {
                /*
                 * Checking the sense key data as well as the additional
                 * sense key.  The SES Node is not required to repond
                 * to Report LUN.  In the case of Minnow, the SES node
                 * returns with KEY_ILLEGAL_REQUEST and the additional
                 * sense key of 0x20.  In this case we will blindly
                 * send the SCSI Inquiry call to lun 0
                 *
                 * if we get any other error we will set the inq_type
                 * appropriately
                 */
                if ((sense.es_key == KEY_ILLEGAL_REQUEST) &&
                    (sense.es_add_code == 0x20)) {
                        lun = 0;
                } else {
                        if (ret == FPCFGA_FCP_SEND_SCSI_DEV_NOT_TGT) {
                                inq.inq_dtype = DTYPE_UNKNOWN;
                        } else {
                                /*
                                 * Failed to get the LUN data for the device
                                 * If we find that there is a lunlist for this
                                 * device it could mean that there are dangling
                                 * devinfo nodes. So, we will go ahead and try
                                 * to unconfigure them.
                                 */
                                if ((apidt->lunlist == NULL) ||
                                    (state_change_cmd == CFGA_CMD_CONFIGURE)) {
                                        S_FREE(update_str);
                                        status = getPortAttrsByWWN(handle,
                                            *((HBA_WWN *)(pwwn)),
                                            &discPortAttrs);
                                        if (status ==
                                            HBA_STATUS_ERROR_ILLEGAL_WWN) {
                                                return (FPCFGA_APID_NOEXIST);
                                        } else {
                                                cfga_err(errstring, 0,
                                                    ERRARG_FC_REP_LUNS,
                                                    apidt->dyncomp, 0);
                                                return (FPCFGA_LIB_ERR);
                                        }
                                } else {
                                        /* unconfig with lunlist not empty */
                                        no_config_attempt++;
                                }
                        }
                }
        }
        for (i = 0; i < num_luns; i++) {
                /*
                 * issue the inquiry to the first valid lun found
                 * in the lun_string
                 */
                lun_string = (uchar_t *)&(resp_buf->lun_string[i]);
                memcpy(&lun, lun_string, sizeof (lun));

                memset(&sense, 0, sizeof (sense));
                status = HBA_ScsiInquiryV2(handle, portAttrs.PortWWN,
                    *(HBA_WWN *)(pwwn), lun, 0, 0, &inq, &inquirySize,
                    &scsiStatus, &sense, &senseSize);
                /*
                 * if Inquiry is returned correctly, check the
                 * peripheral qualifier for the lun.  if it is non-zero
                 * then try the SCSI Inquiry on the next lun
                 */
                if (status == HBA_STATUS_OK) {
                        peri_qual = inq.inq_dtype & FP_PERI_QUAL_MASK;
                        if (peri_qual == DPQ_POSSIBLE) {
                                break;
                        }
                }
        }

        if (ret == FPCFGA_OK)
                S_FREE(resp_buf);

        /*
         * If there are no luns on this target, we will attempt to send
         * the SCSI Inquiry to lun 0
         */
        if (num_luns == 0) {
                lun = 0;
                status = HBA_ScsiInquiryV2(handle, portAttrs.PortWWN,
                    *(HBA_WWN *)(pwwn), lun, 0, 0, &inq, &inquirySize,
                    &scsiStatus, &sense, &senseSize);
        }

        if (status != HBA_STATUS_OK) {
                if (status ==  HBA_STATUS_ERROR_NOT_A_TARGET) {
                        inq.inq_dtype = DTYPE_UNKNOWN;
                } else if (status ==  HBA_STATUS_ERROR_ILLEGAL_WWN) {
                        free(update_str);
                        return (FPCFGA_APID_NOEXIST);
                } else {
                        /*
                         * Failed to get the inq_dtype of device
                         * If we find that there is a lunlist for this
                         * device it could mean that there dangling
                         * devinfo nodes. So, we will go ahead and try
                         * to unconfigure them.  We'll just set the
                         * inq_dtype to some invalid value (0xFF)
                         */
                        if ((apidt->lunlist == NULL) ||
                            (state_change_cmd == CFGA_CMD_CONFIGURE)) {
                                cfga_err(errstring, 0,
                                    ERRARG_FC_INQUIRY,
                                    apidt->dyncomp, 0);
                                free(update_str);
                                return (FPCFGA_LIB_ERR);
                        } else {
                                /* unconfig with lunlist not empty */
                                no_config_attempt++;
                        }
                }
        }
        switch (state_change_cmd) {
        case CFGA_CMD_CONFIGURE:
            if (portAttrs.PortType != HBA_PORTTYPE_NLPORT &&
                portAttrs.PortType != HBA_PORTTYPE_NPORT) {
                free(update_str);
                return (FPCFGA_OK);
            }

            if (((inq.inq_dtype & DTYPE_MASK) == DTYPE_UNKNOWN) &&
                ((flags & CFGA_FLAG_FORCE) == 0)) {
                /*
                 * We assume all DTYPE_UNKNOWNs are HBAs and we wont
                 * waste time trying to config them. If they are not
                 * HBAs, then there is something wrong since they should
                 * have had a valid dtype.
                 *
                 * However, if the force flag is set (cfgadm -f), we
                 * go ahead and try to configure.
                 *
                 * In this path, however, the force flag is not set.
                 */
                free(update_str);
                return (FPCFGA_OK);
            }

            errno = 0;
                /*
                 * We'll issue the devctl_bus_dev_create() call even if the
                 * path exists in the devinfo tree. This is to take care of
                 * the situation where the device may be in a state other
                 * than the online and attached state.
                 */
            if ((ret = do_devctl_dev_create(apidt, dev_path, MAXPATHLEN,
                        inq.inq_dtype, errstring)) != FPCFGA_OK) {
                /*
                 * Could not configure device. To provide a more
                 * meaningful error message, first see if the supplied port
                 * WWN is there on the fabric. Otherwise print the error
                 * message using the information received from the driver
                 */
                status = getPortAttrsByWWN(handle, *((HBA_WWN *)(pwwn)),
                    &discPortAttrs);
                S_FREE(update_str);
                if (status == HBA_STATUS_ERROR_ILLEGAL_WWN) {
                        return (FPCFGA_APID_NOEXIST);
                } else {
                        return (FPCFGA_LIB_ERR);
                }
            }

            if (((optflag & (FLAG_FORCE_UPDATE_REP|FLAG_NO_UPDATE_REP)) == 0) &&
                update_fabric_wwn_list(ADD_ENTRY, update_str, errstring)) {
                    cfga_err(errstring, 0, ERR_CONF_OK_UPD_REP, 0);
            }

            S_FREE(update_str);

            if ((apidt->flags & FLAG_DISABLE_RCM) == 0) {
                /*
                 * There may be multiple LUNs associated with the
                 * WWN we created nodes for. So, we'll call
                 * apidt_create() again and let it build a list of
                 * all the LUNs for this WWN using the devinfo tree.
                 * We will then online all those devices in RCM
                 */
                    if ((t_apid = calloc(1, strlen(apidt->xport_phys) +
                                        strlen(DYN_SEP) +
                                        strlen(apidt->dyncomp) + 1)) == NULL) {
                            cfga_err(errstring, errno, ERR_MEM_ALLOC, 0);
                            return (FPCFGA_LIB_ERR);
                    }
                    sprintf(t_apid, "%s%s%s", apidt->xport_phys, DYN_SEP,
                        apidt->dyncomp);
                    if ((ret = apidt_create(t_apid, &my_apidt,
                                        errstring)) != FPCFGA_OK) {
                            free(t_apid);
                            return (ret);
                    }

                    my_apidt.flags = apidt->flags;
                    if ((ret = dev_rcm_online(&my_apidt, -1, flags,
                                        NULL)) != FPCFGA_OK) {
                            cfga_err(errstring, 0, ERRARG_RCM_ONLINE,
                                apidt->lunlist->path, 0);
                            apidt_free(&my_apidt);
                            free(t_apid);
                            return (ret);
                    }
                    S_FREE(t_apid);
                    apidt_free(&my_apidt);
            }
            return (FPCFGA_OK);

        case CFGA_CMD_UNCONFIGURE:
                if (portAttrs.PortType != HBA_PORTTYPE_NLPORT &&
                    portAttrs.PortType != HBA_PORTTYPE_NPORT) {
                        free(update_str);
                        return (FPCFGA_OPNOTSUPP);
                }

                status = getPortAttrsByWWN(handle, *((HBA_WWN *)(pwwn)),
                    &discPortAttrs);
                if (apidt->lunlist == NULL) {
                        /*
                         * But first, remove entry from the repository if it is
                         * there ... provided the force update flag is not set
                         * (in which case the update is already done) or if
                         * the no-update flag is not set.
                         */
                        if ((optflag &
                        (FLAG_FORCE_UPDATE_REP|FLAG_NO_UPDATE_REP)) == 0) {
                                if (update_fabric_wwn_list(REMOVE_ENTRY,
                                                update_str, errstring)) {
                                        free(update_str);
                                        cfga_err(errstring, 0,
                                                ERR_UNCONF_OK_UPD_REP, 0);
                                        return
                                        (FPCFGA_UNCONF_OK_UPD_REP_FAILED);
                                }
                        }
                        S_FREE(update_str);
                        if (status == HBA_STATUS_ERROR_ILLEGAL_WWN) {
                                return (FPCFGA_APID_NOEXIST);
                        }
                        return (FPCFGA_OK);
                }
                /*
                 * If there are multiple paths to the mpxio
                 * device, we will not check in RCM ONLY when there
                 * is atleast one other ONLINE/STANDBY path
                 */
                if (is_xport_phys_in_pathlist(apidt, errstring) !=
                    FPCFGA_OK) {
                        free(update_str);
                        return (FPCFGA_XPORT_NOT_IN_PHCI_LIST);
                }

                /*
                 * dev_rcm_offline() updates errstring
                 */
                if ((ret = dev_rcm_offline(apidt, flags, errstring)) !=
                    FPCFGA_OK) {
                        free(update_str);
                        return (ret);
                }
                if ((ret = dev_unconf(apidt, errstring, &unconf_flag)) !=
                    FPCFGA_OK) {
                        /* when inq failed don't attempt to reconfigure */
                    if (!no_config_attempt) {
                        (void) do_devctl_dev_create(apidt, dev_path, MAXPATHLEN,
                                inq.inq_dtype, NULL);
                        (void) dev_rcm_online(apidt, -1, flags, NULL);
                    }
                    free(update_str);
                    return (ret);
                }
                if ((ret = dev_rcm_remove(apidt, flags, errstring)) !=
                    FPCFGA_OK) {
                        (void) do_devctl_dev_create(apidt, dev_path, MAXPATHLEN,
                                inq.inq_dtype, NULL);
                        (void) dev_rcm_online(apidt, -1, flags, NULL);
                        free(update_str);
                        return (ret);
                }
                /*
                 * If we offlined a lun in RCM when there are multiple paths but
                 * none of them are ONLINE/STANDBY, we have to online it back
                 * in RCM now. This is a try best, will not fail for it.
                 */
                dev_rcm_online_nonoperationalpath(apidt, flags, NULL);

                /* Update the repository if we havent already done it */
                if ((optflag &
                        (FLAG_FORCE_UPDATE_REP|FLAG_NO_UPDATE_REP)) == 0) {
                        if (((optflag & FLAG_REMOVE_UNUSABLE_FCP_DEV) !=
                                    FLAG_REMOVE_UNUSABLE_FCP_DEV) ||
                            (((optflag & FLAG_REMOVE_UNUSABLE_FCP_DEV) ==
                                FLAG_REMOVE_UNUSABLE_FCP_DEV) &&
                            (unconf_flag == ALL_APID_LUNS_UNUSABLE))) {
                                if (update_fabric_wwn_list(REMOVE_ENTRY,
                                            update_str, errstring)) {
                                    free(update_str);
                                    cfga_err(errstring, errno,
                                        ERR_UNCONF_OK_UPD_REP, 0);
                                    return (FPCFGA_UNCONF_OK_UPD_REP_FAILED);
                                }
                        }
                }
                free(update_str);
                return (FPCFGA_OK);

        default:
                free(update_str);
                return (FPCFGA_OPNOTSUPP);
        }
}

/*
 * This function copies a port_wwn got by reading the property on a device
 * node (from_ptr in the function below) on to an array (to_ptr) so that it is
 * readable.
 *
 * Caller responsible to allocate enough memory in "to_ptr"
 */
static void
copy_pwwn_data_to_str(char *to_ptr, const uchar_t *from_ptr)
{
        if ((to_ptr == NULL) || (from_ptr == NULL))
                return;

        (void) sprintf(to_ptr, "%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x%1.2x",
        from_ptr[0], from_ptr[1], from_ptr[2], from_ptr[3],
        from_ptr[4], from_ptr[5], from_ptr[6], from_ptr[7]);
}

static fpcfga_ret_t
unconf_vhci_nodes(di_path_t pnode, di_node_t fp_node, char *xport_phys,
        char *dyncomp, int unusable_flag,
        int *num_devs, int *failure_count, char **errstring,
        cfga_flags_t flags)
{
        int             iret1, iret2, *lunnump;
        char            *ptr;           /* scratch pad */
        char            *node_path, *vhci_path, *update_str;
        char            port_wwn[WWN_SIZE*2+1], pathname[MAXPATHLEN];
        uchar_t         *port_wwn_data = NULL;
        di_node_t       client_node;

        while (pnode != DI_PATH_NIL) {

                (*num_devs)++;


                if ((node_path = di_devfs_path(fp_node)) == NULL) {
                        cfga_err(errstring, 0, ERRARG_DEVINFO,
                                                        xport_phys, 0);
                        (*failure_count)++;
                        pnode = di_path_next_client(fp_node, pnode);
                        continue;
                }

                iret1 = di_path_prop_lookup_bytes(pnode, PORT_WWN_PROP,
                        &port_wwn_data);

                iret2 = di_path_prop_lookup_ints(pnode, LUN_PROP, &lunnump);

                if ((iret1 == -1) || (iret2 == -1)) {
                        cfga_err(errstring, 0, ERRARG_DI_GET_PROP,
                                                                node_path, 0);
                        di_devfs_path_free(node_path);
                        node_path = NULL;
                        (*failure_count)++;
                        pnode = di_path_next_client(fp_node, pnode);
                        continue;
                }

                copy_pwwn_data_to_str(port_wwn, port_wwn_data);

                if ((client_node = di_path_client_node(pnode)) ==
                                                                DI_NODE_NIL) {
                        (*failure_count)++;
                        di_devfs_path_free(node_path);
                        node_path = NULL;
                        pnode = di_path_next_client(fp_node, pnode);
                        continue;
                }

                if ((vhci_path = di_devfs_path(client_node)) == NULL) {
                        (*failure_count)++;
                        di_devfs_path_free(node_path);
                        node_path = NULL;
                        pnode = di_path_next_client(fp_node, pnode);
                        continue;
                }

                if ((ptr = strrchr(vhci_path, '@')) != NULL) {
                        *ptr = '\0';
                }

                if ((ptr = strrchr(vhci_path, '/')) == NULL) {
                        (*failure_count)++;
                        di_devfs_path_free(node_path);
                        node_path = NULL;
                        pnode = di_path_next_client(fp_node, pnode);
                        continue;
                }

                sprintf(pathname, "%s%s/%s@w%s,%x", DEVICES_DIR, node_path,
                                        ++ptr, port_wwn, *lunnump);

                di_devfs_path_free(node_path);
                di_devfs_path_free(vhci_path);
                node_path = vhci_path = NULL;

                /*
                 * Try to offline in RCM first and if that is successful,
                 * unconfigure the LUN. If offlining in RCM fails, then
                 * update the failure_count which gets passed back to caller
                 *
                 * Here we got to check if unusable_flag is set or not.
                 * If set, then unconfigure only those luns which are in
                 * node_state DI_PATH_STATE_OFFLINE. If not set, unconfigure
                 * all luns.
                 */
                if ((unusable_flag & FLAG_REMOVE_UNUSABLE_FCP_DEV) ==
                    FLAG_REMOVE_UNUSABLE_FCP_DEV) {
                        if (pnode->path_state == DI_PATH_STATE_OFFLINE) {
                                if (fp_rcm_offline(pathname, errstring,
                                    flags) != 0) {
                                        (*failure_count)++;
                                        pnode = di_path_next_client(fp_node,
                                            pnode);
                                        continue;
                                } else if (lun_unconf(pathname, *lunnump,
                                    xport_phys,dyncomp, errstring)
                                    != FPCFGA_OK) {
                                        (void) fp_rcm_online(pathname,
                                            NULL, flags);
                                        (*failure_count)++;
                                        pnode = di_path_next_client(fp_node,
                                            pnode);
                                        continue;
                                } else if (fp_rcm_remove(pathname, errstring,
                                    flags) != 0) {
                                        /*
                                         * Bring everything back online
                                         * in rcm and continue
                                         */
                                        (void) fp_rcm_online(pathname,
                                            NULL, flags);
                                        (*failure_count)++;
                                        pnode = di_path_next_client(fp_node,
                                            pnode);
                                        continue;
                                }
                        } else {
                                pnode = di_path_next(fp_node, pnode);
                                continue;
                        }
                } else {
                        if (fp_rcm_offline(pathname, errstring, flags) != 0) {
                                (*failure_count)++;
                                pnode = di_path_next_client(fp_node, pnode);
                                continue;
                        } else if (lun_unconf(pathname, *lunnump, xport_phys,
                            dyncomp, errstring) != FPCFGA_OK) {
                                (void) fp_rcm_online(pathname, NULL, flags);
                                (*failure_count)++;
                                pnode = di_path_next_client(fp_node, pnode);
                                continue;
                        } else if (fp_rcm_remove(pathname, errstring,
                            flags) != 0) {
                                /*
                                 * Bring everything back online
                                 * in rcm and continue
                                 */
                                (void) fp_rcm_online(pathname, NULL, flags);
                                (*failure_count)++;
                                pnode = di_path_next_client(fp_node, pnode);
                                continue;
                        }
                }

                /* Update the repository only on a successful unconfigure */
                if ((update_str = calloc(1, strlen(xport_phys) +
                                        strlen(DYN_SEP) +
                                        strlen(port_wwn) + 1)) == NULL) {
                        cfga_err(errstring, errno, ERR_UNCONF_OK_UPD_REP, 0);
                        (*failure_count)++;
                        pnode = di_path_next_client(fp_node, pnode);
                        continue;
                }

                /* Init the string to be removed from repository */
                sprintf(update_str, "%s%s%s", xport_phys, DYN_SEP, port_wwn);

                if (update_fabric_wwn_list(REMOVE_ENTRY, update_str,
                                                                errstring)) {
                        S_FREE(update_str);
                        cfga_err(errstring, errno,
                                        ERR_UNCONF_OK_UPD_REP, 0);
                        (*failure_count)++;
                        /* Cleanup and continue from here just for clarity */
                        pnode = di_path_next_client(fp_node, pnode);
                        continue;
                }

                S_FREE(update_str);
                pnode = di_path_next_client(fp_node, pnode);
        }

        return (FPCFGA_OK);
}

static fpcfga_ret_t
unconf_non_vhci_nodes(di_node_t dnode, char *xport_phys, char *dyncomp,
        int unusable_flag, int *num_devs, int *failure_count,
        char **errstring, cfga_flags_t flags)
{
        int     ret1, ret2, *lunnump;
        char    pathname[MAXPATHLEN];
        char    *node_path, *update_str;
        char    port_wwn[WWN_SIZE*2+1];
        uchar_t *port_wwn_data = NULL;

        while (dnode != DI_NODE_NIL) {

                (*num_devs)++;

                /* Get the physical path for this node */
                if ((node_path = di_devfs_path(dnode)) == NULL) {
                        /*
                         * We don't try to offline in RCM here because we
                         * don't know the path to offline. Just continue to
                         * the next node.
                         */
                        cfga_err(errstring, 0, ERRARG_DEVINFO, xport_phys, 0);
                        (*failure_count)++;
                        dnode = di_sibling_node(dnode);
                        continue;
                }

                /* Now get the LUN # of this device thru the property */
                ret1 = di_prop_lookup_ints(DDI_DEV_T_ANY, dnode,
                                                        LUN_PROP, &lunnump);

                /* Next get the port WWN of the device */
                ret2 = di_prop_lookup_bytes(DDI_DEV_T_ANY, dnode,
                                                PORT_WWN_PROP, &port_wwn_data);

                /* A failure in any of the above is not good */
                if ((ret1 == -1) || (ret2 == -1)) {
                        /*
                         * We don't try to offline in RCM here because we
                         * don't know the path to offline. Just continue to
                         * the next node.
                         */
                        cfga_err(errstring, 0,
                                        ERRARG_DI_GET_PROP, node_path, 0);
                        di_devfs_path_free(node_path);
                        node_path = NULL;
                        (*failure_count)++;
                        dnode = di_sibling_node(dnode);
                        continue;
                }

                /* Prepend the "/devices" prefix to the path and copy it */
                sprintf(pathname, "%s%s", DEVICES_DIR, node_path);
                di_devfs_path_free(node_path);
                node_path = NULL;

                copy_pwwn_data_to_str(port_wwn, port_wwn_data);

                if (strstr(pathname, "@w") == NULL) {
                        /*
                         * If the driver is detached, some part of the path
                         * may be missing and so we'll manually construct it
                         */
                        sprintf(&pathname[strlen(pathname)], "@w%s,%x",
                                                        port_wwn, *lunnump);
                }

                /*
                 * Try to offline in RCM first and if that is successful,
                 * unconfigure the LUN. If offlining in RCM fails, then
                 * update the failure count
                 *
                 * Here we got to check if unusable_flag is set or not.
                 * If set, then unconfigure only those luns which are in
                 * node_state DI_DEVICE_OFFLINE or DI_DEVICE_DOWN.
                 * If not set, unconfigure all luns.
                 */
                if ((unusable_flag & FLAG_REMOVE_UNUSABLE_FCP_DEV) ==
                    FLAG_REMOVE_UNUSABLE_FCP_DEV) {
                        if ((dnode->node_state == DI_DEVICE_OFFLINE) ||
                            (dnode->node_state == DI_DEVICE_DOWN)) {
                                if (fp_rcm_offline(pathname, errstring,
                                    flags) != 0) {
                                        (*failure_count)++;
                                        dnode = di_sibling_node(dnode);
                                        continue;
                                } else if (lun_unconf(pathname, *lunnump,
                                    xport_phys,dyncomp, errstring)
                                    != FPCFGA_OK) {
                                        (void) fp_rcm_online(pathname,
                                            NULL, flags);
                                        (*failure_count)++;
                                        dnode = di_sibling_node(dnode);
                                        continue;
                                } else if (fp_rcm_remove(pathname, errstring,
                                    flags) != 0) {
                                        /*
                                         * Bring everything back online
                                         * in rcm and continue
                                         */
                                        (void) fp_rcm_online(pathname,
                                            NULL, flags);
                                        (*failure_count)++;
                                        dnode = di_sibling_node(dnode);
                                        continue;
                                }
                        } else {
                                dnode = di_sibling_node(dnode);
                                continue;
                        }
                } else {
                        if (fp_rcm_offline(pathname, errstring, flags) != 0) {
                                (*failure_count)++;
                                dnode = di_sibling_node(dnode);
                                continue;
                        } else if (lun_unconf(pathname, *lunnump, xport_phys,
                            dyncomp, errstring) != FPCFGA_OK) {
                                (void) fp_rcm_online(pathname, NULL, flags);
                                (*failure_count)++;
                                dnode = di_sibling_node(dnode);
                                continue;
                        } else if (fp_rcm_remove(pathname, errstring,
                            flags) != 0) {
                                /*
                                 * Bring everything back online
                                 * in rcm and continue
                                 */
                                (void) fp_rcm_online(pathname, NULL, flags);
                                (*failure_count)++;
                                dnode = di_sibling_node(dnode);
                                continue;
                        }
                }

                /* Update the repository only on a successful unconfigure */
                if ((update_str = calloc(1, strlen(xport_phys) +
                                        strlen(DYN_SEP) +
                                        strlen(port_wwn) + 1)) == NULL) {
                        cfga_err(errstring, errno, ERR_UNCONF_OK_UPD_REP, 0);
                        (*failure_count)++;
                        dnode = di_sibling_node(dnode);
                        continue;
                }

                /* Init the string to be removed from repository */
                sprintf(update_str, "%s%s%s", xport_phys, DYN_SEP, port_wwn);

                if (update_fabric_wwn_list(REMOVE_ENTRY, update_str,
                                                                errstring)) {
                        S_FREE(update_str);
                        cfga_err(errstring, errno, ERR_UNCONF_OK_UPD_REP, 0);
                        (*failure_count)++;
                        dnode = di_sibling_node(dnode);
                        continue;
                }

                S_FREE(update_str);
                dnode = di_sibling_node(dnode);
        }

        return (FPCFGA_OK);
}

/*
 * INPUT:
 * apidt - Pointer to apid_t structure with data filled in
 * flags - Flags for special handling
 *
 * OUTPUT:
 * errstring - Applicable only on a failure from plugin
 * num_devs  - Incremented per lun
 * failure_count - Incremented on any failed operation on lun
 *
 * RETURNS:
 * non-FPCFGA_OK on any validation check error. If this value is returned, no
 *             devices were handled.  Consequently num_devs and failure_count
 *             will not be incremented.
 * FPCFGA_OK This return value doesn't mean that all devices were successfully
 *             unconfigured, you have to check failure_count.
 */
static fpcfga_ret_t
unconf_any_devinfo_nodes(apid_t *apidt, cfga_flags_t flags, char **errstring,
                                int *num_devs, int *failure_count)
{
        char            *node_path = NULL;
        char            pathname[MAXPATHLEN], *ptr;     /* scratch pad */
        di_node_t       root_node, direct_node, fp_node;
        di_path_t       path_node = DI_PATH_NIL;

        /*
         * apidt->xport_phys is something like :
         * /devices/pci@.../SUNW,qlc@../fp@0,0:fc
         * Make sure we copy both the devinfo and pathinfo nodes
         */
        (void) strlcpy(pathname, apidt->xport_phys, MAXPATHLEN);

        /* Now get rid of the ':' at the end */
        if ((ptr = strstr(pathname, MINOR_SEP)) != NULL)
                *ptr = '\0';

        if (strncmp(pathname, DEVICES_DIR, strlen(DEVICES_DIR))) {
                cfga_err(errstring, 0, ERRARG_INVALID_PATH, pathname, 0);
                return (FPCFGA_INVALID_PATH);
        }

        if ((root_node = di_init("/", DINFOCPYALL | DINFOPATH)) ==
                                                                DI_NODE_NIL) {
                cfga_err(errstring, errno, ERRARG_DEVINFO,
                                                        apidt->xport_phys, 0);
                return (FPCFGA_LIB_ERR);
        }

        if ((fp_node = di_drv_first_node("fp", root_node)) == DI_NODE_NIL) {
                cfga_err(errstring, errno, ERRARG_DEVINFO,
                                                        apidt->xport_phys, 0);
                di_fini(root_node);
                return (FPCFGA_LIB_ERR);
        }

        /*
         * Search all the fp nodes to see if any match the one we are trying
         * to unconfigure
         */

        /* Skip the "/devices" prefix */
        ptr = pathname + strlen(DEVICES_DIR);

        while (fp_node != DI_NODE_NIL) {
                node_path = di_devfs_path(fp_node);
                if (strcmp(node_path, ptr) == 0) {
                        /* Found the fp node. 'pathname' has the full path */
                        di_devfs_path_free(node_path);
                        node_path = NULL;
                        break;
                }
                fp_node = di_drv_next_node(fp_node);
                di_devfs_path_free(node_path);
        }

        if (fp_node == DI_NODE_NIL) {
                cfga_err(errstring, 0, ERRARG_NOT_IN_DEVINFO,
                                                        apidt->xport_phys, 0);
                di_fini(root_node);
                return (FPCFGA_LIB_ERR);
        }

        direct_node = di_child_node(fp_node);
        path_node = di_path_next_client(fp_node, path_node);

        if ((direct_node == DI_NODE_NIL) && (path_node == DI_PATH_NIL)) {
                /* No devinfo or pathinfo nodes. Great ! Just return success */
                di_fini(root_node);
                return (FPCFGA_OK);
        }

        /* First unconfigure any non-MPXIO nodes */
        unconf_non_vhci_nodes(direct_node, apidt->xport_phys, apidt->dyncomp,
            apidt->flags, num_devs, failure_count, errstring, flags);

        /*
         * Now we will traverse any path info nodes that are there
         *
         * Only MPXIO devices have pathinfo nodes
         */
        unconf_vhci_nodes(path_node, fp_node, apidt->xport_phys, apidt->dyncomp,
            apidt->flags, num_devs, failure_count, errstring, flags);

        di_fini(root_node);

        /*
         * We don't want to check the return value of unconf_non_vhci_nodes()
         * and unconf_vhci_nodes().  But instead, we are interested only in
         * consistently incrementing num_devs and failure_count so that we can
         * compare them.
         */
        return (FPCFGA_OK);
}

/*
 * This function handles configuring/unconfiguring all the devices w.r.t
 * the FCA port specified by apidt.
 *
 * In the unconfigure case, it first unconfigures all the devices that are
 * seen through the given port at that moment and then unconfigures all the
 * devices that still (somehow) have devinfo nodes on the system for that FCA
 * port.
 *
 * INPUT:
 * cmd - CFGA_CMD_CONFIGURE or CFGA_CMD_UNCONFIGURE
 * apidt - Pointer to apid_t structure with data filled in
 * flags - Flags for special handling
 *
 * OUTPUT:
 * errstring - Applicable only on a failure from plugin
 *
 * RETURNS:
 * FPCFGA_OK on success
 * non-FPCFGA_OK otherwise
 */
static fpcfga_ret_t
handle_devs(cfga_cmd_t cmd, apid_t *apidt, cfga_flags_t flags,
        char **errstring, HBA_HANDLE handle, int portIndex,
        HBA_PORTATTRIBUTES portAttrs)
{
        int             num_devs = 0, dev_cs_failed = 0;
        char            port_wwn[WWN_S_LEN];
        la_wwn_t        pwwn;
        apid_t          my_apidt = {NULL};
        char            *my_apid;
        HBA_PORTATTRIBUTES      discPortAttrs;
        int                     discIndex;
        fpcfga_ret_t            rval = FPCFGA_OK;

        if ((my_apid = calloc(
                1, strlen(apidt->xport_phys) + strlen(DYN_SEP) +
                (2 * FC_WWN_SIZE) + 1)) == NULL) {
                cfga_err(errstring, errno, ERR_MEM_ALLOC, 0);
                return (FPCFGA_LIB_ERR);
        }

        num_devs = portAttrs.NumberofDiscoveredPorts;
        for (discIndex = 0; discIndex < portAttrs.NumberofDiscoveredPorts;
                discIndex++) {
            if (getDiscPortAttrs(handle, portIndex,
                discIndex, &discPortAttrs)) {
                dev_cs_failed++;
                /* Move on to the next target */
                continue;
            }
            (void) sprintf(port_wwn, "%016llx",
                wwnConversion(discPortAttrs.PortWWN.wwn));
                /*
                 * Construct a fake apid string similar to the one the
                 * plugin gets from the framework and have apidt_create()
                 * fill in the apid_t structure.
                 */
            strcpy(my_apid, apidt->xport_phys);
            strcat(my_apid, DYN_SEP);
            strcat(my_apid, port_wwn);
            if (apidt_create(my_apid, &my_apidt, errstring) != FPCFGA_OK) {
                dev_cs_failed++;
                continue;
            }
            my_apidt.flags = apidt->flags;

            memcpy(&pwwn, &(discPortAttrs.PortWWN), sizeof (la_wwn_t));
            if (dev_change_state(cmd, &my_apidt, &pwwn,
                flags, errstring, handle, portAttrs) != FPCFGA_OK) {
                dev_cs_failed++;
            }
            apidt_free(&my_apidt);
        }

        S_FREE(my_apid);

        /*
         * We have now handled all the devices that are currently visible
         * through the given FCA port. But, it is possible that there are
         * some devinfo nodes hanging around. For the unconfigure operation,
         * this has to be looked into too.
         */
        if (cmd == CFGA_CMD_UNCONFIGURE) {
                /* dev_cs_failed will be updated to indicate any failures */
                rval = unconf_any_devinfo_nodes(apidt, flags, errstring,
                    &num_devs, &dev_cs_failed);
        }

        if (rval == FPCFGA_OK) {
                if (dev_cs_failed == 0)
                        return (FPCFGA_OK);

                /*
                 * For the discovered ports, num_devs is counted on target
                 * basis, but for invisible targets, num_devs is counted on
                 * lun basis.
                 *
                 * But if dev_cs_failed and num_devs are incremented
                 * consistently, comparation of these two counters is still
                 * meaningful.
                 */
                if (dev_cs_failed == num_devs) {
                        /* Failed on all devices seen through this FCA port */
                        cfga_err(errstring, 0,
                        ((cmd == CFGA_CMD_CONFIGURE) ?
                                ERR_FCA_CONFIGURE : ERR_FCA_UNCONFIGURE), 0);
                        return (FPCFGA_LIB_ERR);
                } else {
                        /* Failed only on some of the devices */
                        cfga_err(errstring, 0, ERR_PARTIAL_SUCCESS, 0);
                        return (FPCFGA_LIB_ERR);
                }
        } else {
                if (dev_cs_failed == num_devs) {
                        /* Failed on all devices seen through this FCA port */
                        cfga_err(errstring, 0,
                        ((cmd == CFGA_CMD_CONFIGURE) ?
                                ERR_FCA_CONFIGURE : ERR_FCA_UNCONFIGURE), 0);
                        return (FPCFGA_LIB_ERR);
                } else {
                        /* Failed only on some of the devices */
                        cfga_err(errstring, 0, ERR_PARTIAL_SUCCESS, 0);
                        return (FPCFGA_LIB_ERR);
                }
        }

        /*
         * Should never get here
         */
}

fpcfga_ret_t
fca_change_state(cfga_cmd_t state_change_cmd, apid_t *apidt,
                cfga_flags_t flags, char **errstring)
{
        fpcfga_ret_t    ret;
        HBA_HANDLE      handle;
        HBA_PORTATTRIBUTES      portAttrs;
        int                     portIndex;

        if ((ret = findMatchingAdapterPort(apidt->xport_phys, &handle,
            &portIndex, &portAttrs, errstring)) != FPCFGA_OK) {
                return (ret);
        }

        /*
         * Bail out if not fabric/public loop
         */
        switch (state_change_cmd) {
        case CFGA_CMD_CONFIGURE:
            if (portAttrs.PortType != HBA_PORTTYPE_NLPORT &&
                portAttrs.PortType != HBA_PORTTYPE_NPORT) {
                        HBA_CloseAdapter(handle);
                        HBA_FreeLibrary();
                        return (FPCFGA_OK);
            }
            break;

        case CFGA_CMD_UNCONFIGURE:
            if (portAttrs.PortType != HBA_PORTTYPE_NLPORT &&
                portAttrs.PortType != HBA_PORTTYPE_NPORT) {
                HBA_CloseAdapter(handle);
                HBA_FreeLibrary();
                return (FPCFGA_OPNOTSUPP);
            }
            break;
        default:
                HBA_CloseAdapter(handle);
                HBA_FreeLibrary();
                return (FPCFGA_LIB_ERR);
        }
        ret = (handle_devs(state_change_cmd, apidt, flags, errstring,
            handle, portIndex, portAttrs));
        HBA_CloseAdapter(handle);
        HBA_FreeLibrary();
        return (ret);
}