dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / sasinfo / sasinfo-list.c

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

#include <unistd.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <printAttrs.h>
#include <smhbaapi.h>

#define TABLEN  2
typedef struct inputArgs {
        int             wwnCount;
        char            **wwn_argv;
        uint64_t        portWWN;
        char            *hbaName;
        int             pflag;
        int             *wwn_flag;
} inputArg_t;

typedef struct tgt_mapping {
        SMHBA_SCSIENTRY tgtentry;
        uchar_t         inq_vid[8];
        uchar_t         inq_pid[16];
        uchar_t         inq_dtype;
        struct tgt_mapping *next;
}tgt_mapping;

/*
 * Remote port tree node structure.
 */
typedef struct smhba_rp_tree {
        SMHBA_PORTATTRIBUTES    portattr;
        SMHBA_SAS_PORT          sasattr;
        tgt_mapping             *first_entry;
        int                     printed;
        struct smhba_rp_tree    *parent;
        struct smhba_rp_tree    *child;
        struct smhba_rp_tree    *sibling;
}rp_tree_t;

/*
 * Report LUN data structure.
 */
struct lun {
        uchar_t val[8];
};

typedef struct rep_luns_rsp {
        uint32_t    length;
        uint32_t    rsrvd;
        struct lun  lun[1];
} rep_luns_rsp_t;

/*
 * The following flag is used for printing HBA header on-demand.
 */
static int g_printHBA = 0;

/*
 * The following structure is for sorted output of HBA and HBA Port.
 */
typedef struct _sas_elem {
        char    name[256];
        int     index;
}sas_elem_t;

/*
 * The following two functions are for generating hierachy of expander
 * subcommand.
 */
static int
sas_rp_tree_insert(rp_tree_t **rproot, rp_tree_t *rpnode);
static int
sas_rp_tree_print(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    rp_tree_t *rpnode, inputArg_t *input, int gident,
    int *printPort);
static int
sas_rp_tree_print_desc(HBA_HANDLE handle, HBA_UINT32 portIndex,
    SMHBA_PORTATTRIBUTES *port, rp_tree_t *desc,
    inputArg_t *input, int lident, int gident);
static int
sas_print_rpnode(inputArg_t *input,
    rp_tree_t *rpnode, int lident, int gident);
static void sas_rp_tree_free(rp_tree_t *rproot);

typedef int (*processPortFunc)(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input);

static int processHBA(inputArg_t *input,
    processPortFunc processPort);

static int isPortWWNInArgv(inputArg_t *input, PHBA_WWN pWWN);
static int isStringInArgv(inputArg_t *input, const char *adapterName);
static boolean_t compareLUName(char *cmdArg, char *osName);
static discoveredDevice *LUList = NULL;
static targetPortList_t *gTargetPortList = NULL;

/* processes for hanlding local HBA info */
static int handleHBA(SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input,
    int numberOfPorts, const char *adapterName);
static int handleHBAPort(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input);
static int processHBAPortPhyInfo(HBA_HANDLE handle, HBA_UINT32 portIndex,
    SMHBA_PORTATTRIBUTES *port, int pflag);
static int processHBAPortPhyStat(HBA_HANDLE handle, HBA_UINT32 portIndex,
    int phyIndex, PSMHBA_SAS_PHY phyattrs, int pflag);

/* process for handling expander info */
static int handleExpander(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input);

/* process for handling target port info */
static int handleTargetPort(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input);

/* process for handling logical unit info */
static int handleLogicalUnit(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input);

/* process for target port SCSI processing */
static int
searchTargetPortMappingData(HBA_HANDLE handle, HBA_UINT32 portIndex,
    SMHBA_PORTATTRIBUTES *port, SMHBA_SAS_PORT *sasattr,
    struct targetPortConfig *configData);

/* process for target port config processing */
static int searchTargetPort(HBA_HANDLE handle, HBA_UINT32 portIndex,
    SMHBA_PORTATTRIBUTES *port, SMHBA_PORTATTRIBUTES *targetattr,
    SMHBA_SAS_PORT *sasattr, int pflag);

/* process for logical-unit config processing */
static int
searchDevice(PSMHBA_SCSIENTRY entryP, HBA_HANDLE handle, HBA_WWN hbaPortWWN,
    HBA_WWN domainPortWWN, char *portName, int pflag);

/* get domain port out of hba-port phy attr. */
HBA_STATUS get_domainPort(HBA_HANDLE handle,
    int portindex, PSMHBA_PORTATTRIBUTES port,
    HBA_WWN *pdomainPort);

static int
sas_name_comp(const char *name1, const char *name2);
static void
sas_elem_sort(sas_elem_t *array, int nelem);

/*
 * function for hba subcommand
 *
 * Arguments:
 *      wwnCount - count of the number of WWNs in wwn_argv
 *          if wwnCount > 0, then we will only print information for
 *              the hba ports listed in wwn_argv
 *          if wwnCount == 0, then we will print information on all hba ports
 *      wwn_argv - argument array of hba port WWNs
 *      options - any options specified by the caller
 *
 * returns:
 *      0       if successful
 *      >0      otherwise
 */
int
sas_util_list_hba(int hbaCount, char **hba_argv, cmdOptions_t *options)
{
        HBA_STATUS              status;
        int                     processHBA_flags = 0;
        inputArg_t              input;
        int                     err_cnt = 0;

        /* process each of the options */
        for (; options->optval; options++) {
                switch (options->optval) {
                case 'v':
                        processHBA_flags |= PRINT_VERBOSE;
                        break;
                default:
                        break;
                }
        }

        if ((status = HBA_LoadLibrary()) != HBA_STATUS_OK) {
                (void *) fprintf(stderr, "%s %s\n",
                    gettext("Failed to load SM-HBA libraries."
                    "Reason:"), getHBAStatus(status));
                err_cnt++;
                return (err_cnt);
        }

        memset(&input, 0, sizeof (input));
        /* utilize wwnCount and wwn_argv for hbaCount and hba_argv */
        input.wwnCount = hbaCount;
        input.wwn_argv = hba_argv;
        input.pflag = processHBA_flags;

        /*
         * Process and filter for every local hba,
         * when the hba is not specificed, print all hba(s).
         */
        err_cnt += processHBA(&input, NULL);

        (void) HBA_FreeLibrary();

        return (err_cnt);
}

/*
 * function for hba-port subcommand
 *
 * Arguments:
 *      wwnCount - count of the number of WWNs in wwn_argv
 *          if wwnCount > 0, then we will only print information for
 *              the hba ports listed in wwn_argv
 *          if wwnCount == 0, then we will print information on all hba ports
 *      wwn_argv - argument array of hba port WWNs
 *      options - any options specified by the caller
 *
 * returns:
 *      0       if successful
 *      >0      otherwise
 */
int
sas_util_list_hbaport(int wwnCount, char **wwn_argv, cmdOptions_t *options)
{
        HBA_STATUS              status;
        int                     processHBA_flags = 0;
        inputArg_t              input;
        int                     err_cnt = 0;
        char                    hbaName[256] = {'\0'};

        /* process each of the options */
        for (; options->optval; options++) {
                switch (options->optval) {
                case 'a':
                        (void *) strlcpy(hbaName,
                            options->optarg, sizeof (hbaName));
                        break;
                case 'y':
                        processHBA_flags |= PRINT_PHY;
                        break;
                case 'l':
                        processHBA_flags |= PRINT_PHY_LINKSTAT;
                        break;
                case 'v':
                        processHBA_flags |= PRINT_VERBOSE;
                        break;
                default:
                        break;
                }
        }

        if ((status = HBA_LoadLibrary()) != HBA_STATUS_OK) {
                (void *) fprintf(stderr, "%s %s\n",
                    gettext("Failed to load SM-HBA libraries."
                    "Reason:"), getHBAStatus(status));
                err_cnt++;
                return (err_cnt);
        }

        memset(&input, 0, sizeof (input));
        input.wwnCount = wwnCount;
        input.wwn_argv = wwn_argv;
        input.hbaName = hbaName;
        input.pflag = processHBA_flags;

        /*
         * Process and filter for every local hba-port,
         * when the hba-port is not specificed, print all hba-port(s).
         */
        err_cnt += processHBA(&input, handleHBAPort);

        (void) HBA_FreeLibrary();

        return (err_cnt);
}

/*
 * function for expander subcommand
 *
 * Arguments:
 *      wwnCount - the number of Remote Port SAS Address in wwn_argv
 *          if wwnCount == 0, then print information on all
 *              expander devices.
 *          if wwnCount > 0, then print information for the exapnders
 *              given in wwn_argv.
 *      wwn_argv - array of WWNs
 *      options - options specified by the caller
 *
 * returns:
 *      0       if successful
 *      >0      otherwise
 */
int
sas_util_list_expander(int wwnCount, char **wwn_argv, cmdOptions_t *options)
{
        HBA_STATUS              status;
        int                     processHBA_flags = 0;
        char                    hbaPort[MAXPATHLEN + 1] = {0};
        inputArg_t              input;
        int                     err_cnt = 0;

        /* process each of the options */
        for (; options->optval; options++) {
                switch (options->optval) {
                case 'p':
                        (void) strlcpy(hbaPort, options->optarg,
                            sizeof (hbaPort));
                        break;
                case 't':
                        processHBA_flags |= PRINT_TARGET_PORT;
                        break;
                case 'v':
                        processHBA_flags |= PRINT_VERBOSE;
                        break;
                default:
                        break;
                }
        }

        if ((status = HBA_LoadLibrary()) != HBA_STATUS_OK) {
                (void *) fprintf(stderr, "%s %s\n",
                    gettext("Failed to load SM-HBA libraries."
                    "Reason:"), getHBAStatus(status));
                err_cnt++;
                return (err_cnt);
        }

        memset(&input, 0, sizeof (input));
        input.wwnCount = wwnCount;
        input.wwn_argv = wwn_argv;
        input.pflag = processHBA_flags;
        input.hbaName = hbaPort;

        /*
         * Process and filter for every hba-port,
         * when the hba-port is not specificed, print all hba-port(s).
         */
        err_cnt += processHBA(&input, handleExpander);

        (void) HBA_FreeLibrary();

        return (err_cnt);
}

/*
 * function for target-port subcommand
 *
 * Arguments:
 *      wwnCount - the number of Remote Port SAS Address in wwn_argv
 *          if wwnCount == 0, then print information on all
 *              target ports.
 *          if wwnCount > 0, then print information for the target ports
 *              given in wwn_argv.
 *      wwn_argv - array of WWNs
 *      options - options specified by the caller
 *
 * returns:
 *      0       if successful
 *      >0      otherwise
 */
int
sas_util_list_targetport(int tpCount, char **tpArgv, cmdOptions_t *options)
{
        HBA_STATUS              status;
        int                     processHBA_flags = 0;
        int                     tp, tpFound;
        inputArg_t              input;
        targetPortList_t        *tpListWalk;
        int                     err_cnt = 0;
        uint64_t                tmpAddr;

        /* process each of the options */
        for (; options->optval; options++) {
                switch (options->optval) {
                case 's':
                        processHBA_flags |= PRINT_TARGET_SCSI;
                        break;
                case 'v':
                        processHBA_flags |= PRINT_VERBOSE;
                        break;
                default:
                        break;
                }
        }

        if ((status = HBA_LoadLibrary()) != HBA_STATUS_OK) {
                (void *) fprintf(stderr, "%s %s\n",
                    gettext("Failed to load SM-HBA libraries."
                    "Reason:"), getHBAStatus(status));
                err_cnt++;
                return (err_cnt);
        }

        memset(&input, 0, sizeof (input));
        input.wwnCount = tpCount;
        input.wwn_argv = tpArgv;
        input.pflag = processHBA_flags;

        /*
         * Process and filter for every hba-port,
         * when the hba-port is not specificed, print all hba-port(s).
         */
        err_cnt += processHBA(&input, handleTargetPort);

        if (tpCount == 0) {
                /* list all target port */
                for (tpListWalk = gTargetPortList; tpListWalk != NULL;
                    tpListWalk = tpListWalk->next) {
                        err_cnt += printTargetPortInfo(tpListWalk, input.pflag);
                }
        } else {
                /*
                 * When operands provided, we should set the error code
                 * only if there are issues related with the operands.
                 */
                err_cnt = 0;
                /*
                 * list any paths not found first
                 * this gives the user cleaner output
                 */
                for (tp = 0; tp < tpCount; tp++) {
                        errno = 0;
                        tmpAddr = strtoull(tpArgv[tp], NULL, 16);
                        if ((tmpAddr == 0) && (errno != 0)) {
                                err_cnt++;
                                continue;
                        }
                        for (tpListWalk = gTargetPortList, tpFound = B_FALSE;
                            tpListWalk != NULL;
                            tpListWalk = tpListWalk->next) {
                                if (wwnConversion(tpListWalk->sasattr.
                                    LocalSASAddress.wwn) == tmpAddr) {
                                        tpFound = B_TRUE;
                                        break;
                                }
                        }
                        if (tpFound == B_FALSE) {
                                (void *) fprintf(stderr,
                                    "Error: Target Port %s Not Found \n",
                                    tpArgv[tp]);
                                err_cnt++;
                        }
                }
                /* list all paths requested in order requested */
                for (tp = 0; tp < tpCount; tp++) {
                        errno = 0;
                        tmpAddr = strtoull(tpArgv[tp], NULL, 16);
                        if ((tmpAddr == 0) && (errno != 0)) {
                                continue;
                        }
                        for (tpListWalk = gTargetPortList, tpFound = B_FALSE;
                            tpListWalk != NULL;
                            tpListWalk = tpListWalk->next) {
                                if (wwnConversion(tpListWalk->sasattr.
                                    LocalSASAddress.wwn) == tmpAddr) {
                                        err_cnt += printTargetPortInfo(
                                            tpListWalk,
                                            processHBA_flags);
                                }
                        }
                }
        }
        (void) HBA_FreeLibrary();
        return (err_cnt);
}
/*
 * This function will enumerate all the hba and hba ports,
 * call the callback function to proceed with futher process.
 *
 * Arguments:
 *      input - contains all the input parameters.
 *      processPort - a callback function when handling each port.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
static int
processHBA(inputArg_t *input, processPortFunc processPort)
{
        int                     numAdapters = 0;
        int                     matchedHBAs = 0;
        int                     matchedHBAPorts = 0;
        int                     hbaPortExist = 0;
        HBA_STATUS              status;
        HBA_HANDLE              handle;
        HBA_UINT32              numberOfPorts = 0;
        int                     portIndex = 0;
        HBA_PORTTYPE            porttype;
        SMHBA_LIBRARYATTRIBUTES libattrs;
        SMHBA_ADAPTERATTRIBUTES attrs;
        SMHBA_PORTATTRIBUTES    port;
        SMHBA_SAS_PORT          sasattrs;
        int                     i, sum, ret = 0;
        int                     remote_avail = 0;
        int                     local_avail = 0;
        sas_elem_t              *adpt_array = NULL;
        sas_elem_t              *port_array = NULL;

        numAdapters = HBA_GetNumberOfAdapters();
        if (numAdapters == 0) {
                (void *) fprintf(stderr, "%s\n",
                    gettext("Error: No Adapters Found."));
                return (++ret);
        }

        /*
         * To deal with mismatching HBA/HBA Port/Expander Port, we need an
         * array of flags for each operands.
         */
        if (input->wwnCount && (processPort != handleTargetPort) &&
            (processPort != handleLogicalUnit)) {
                input->wwn_flag = calloc(input->wwnCount, sizeof (int));
                if (input->wwn_flag == NULL) {
                        (void *) fprintf(stderr, "%s\n",
                            gettext("No enough memory on heap"));
                        return (++ret);
                }
        }

        adpt_array = calloc(numAdapters, sizeof (sas_elem_t));
        if (adpt_array == NULL) {
                (void *) fprintf(stderr, "%s\n",
                    gettext("No enough memory on heap"));
                if (input->wwn_flag) {
                        free(input->wwn_flag);
                        input->wwn_flag = NULL;
                }
                return (++ret);
        }
        for (i = 0; i < numAdapters; i++) {
                status =
                    SMHBA_GetVendorLibraryAttributes(i, &libattrs);
                /*
                 * If we get SAS incompatible library warning here,
                 * just skip the following steps.
                 */
                if (status != 1) {
                        continue;
                }
                status = HBA_GetAdapterName(i, adpt_array[i].name);
                if (status != HBA_STATUS_OK) {
                        (void *) fprintf(stderr, "%s %d %s %s\n",
                            gettext("Error: Failed to get the name for"
                            " HBA index"),
                            i, gettext("Reason:"),
                            getHBAStatus(status));
                        ret++;
                        continue;
                }
                adpt_array[i].index = i;
        }
        /* Sort the HBA Name in place. */
        sas_elem_sort(adpt_array, numAdapters);

        for (i = 0; i < numAdapters; i++) {
                int times = 0;
                if (adpt_array[i].name[0] != '\0') {
                        if ((handle = HBA_OpenAdapter(adpt_array[i].name))
                            == 0) {
                                (void *) fprintf(stderr, "%s %s.\n",
                                    gettext("Error: Failed to open adapter"),
                                    adpt_array[i].name);
                                ret++;
                                continue;
                        }
                } else {
                        continue;
                }

                /*
                 * We need to support an adapter without hba port.
                 * So get attributes anyway.
                 */
                memset(&attrs, 0, sizeof (attrs));
                status = SMHBA_GetAdapterAttributes(handle, &attrs);
                while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
                    status == HBA_STATUS_ERROR_BUSY) &&
                    times++ < HBA_MAX_RETRIES) {
                        (void) sleep(1);
                        status = SMHBA_GetAdapterAttributes(handle,
                            &attrs);
                }
                if (status != HBA_STATUS_OK) {
                        (void *) fprintf(stderr, "%s %s %s %s\n",
                            gettext("Error: Failed to get attributes"
                            " for HBA "), adpt_array[i].name,
                            gettext("Reason:"),
                            getHBAStatus(status));

                        HBA_CloseAdapter(handle);
                        ret++;
                        continue;
                }

                status = SMHBA_GetNumberOfPorts(handle, &numberOfPorts);
                if (status != HBA_STATUS_OK) {
                        (void *) fprintf(stderr, "%s %s %s %s\n",
                            gettext("Error: Failed to get number of ports "
                            "for HBA"), adpt_array[i].name,
                            gettext("Reason:"),
                            getHBAStatus(status));
                        HBA_CloseAdapter(handle);
                        ret++;
                        continue;
                }

                /*
                 * Deal with each subcommand for hba filter here,
                 * processPort is NULL for hba subcommand.
                 */
                if (processPort == NULL) {
                        matchedHBAs += handleHBA(&attrs, input,
                            numberOfPorts, adpt_array[i].name);
                        HBA_CloseAdapter(handle);
                        continue;
                } else if (processPort == handleHBAPort) {
                        if (input->hbaName[0] != '\0') {
                                if (strcmp(input->hbaName,
                                    adpt_array[i].name) == 0) {
                                        matchedHBAs++;
                                } else {
                                        continue;
                                }
                        } else {
                                matchedHBAs++;
                        }
                } else {
                        matchedHBAs++;
                }

                /*
                 * In order to have a sorted output for HBA Port, we should
                 * do the sorting before moving on.
                 */
                if (numberOfPorts) {
                        port_array = calloc(numberOfPorts, sizeof (sas_elem_t));
                }
                for (portIndex = 0; portIndex < numberOfPorts; portIndex++) {
                        if ((status = SMHBA_GetPortType(handle,
                            portIndex, &porttype)) != HBA_STATUS_OK) {
                                (void *) fprintf(stderr, "%s %s %s %s\n",
                                    gettext("Failed to get adapter port type "
                                    "for HBA"), adpt_array[i].name,
                                    gettext("Reason:"),
                                    getHBAStatus(status));
                                ret++;
                                continue;
                        }
                        if (porttype != HBA_PORTTYPE_SASDEVICE) {
                                /* skip any non-sas hba port */
                                continue;
                        }
                        memset(&port, 0, sizeof (port));
                        memset(&sasattrs, 0, sizeof (sasattrs));
                        port.PortSpecificAttribute.SASPort = &sasattrs;
                        if ((status = SMHBA_GetAdapterPortAttributes(
                            handle, portIndex, &port)) != HBA_STATUS_OK) {
                                /*
                                 * Not able to get port attributes.
                                 * print out error message and
                                 * move on to the next port
                                 */
                                (void *) fprintf(stderr, "%s %s %s %d %s %s\n",
                                    gettext("Error: Failed to get port "
                                    "attributes for HBA"), adpt_array[i].name,
                                    gettext("port index"), portIndex,
                                    gettext("Reason:"),
                                    getHBAStatus(status));
                                ret++;
                                continue;
                        }
                        (void) strlcpy(port_array[portIndex].name,
                            port.OSDeviceName,
                            sizeof (port_array[portIndex].name));
                        port_array[portIndex].index = portIndex;
                }
                /* Sort the HBA Port Name here. */
                if (port_array) {
                        sas_elem_sort(port_array, numberOfPorts);
                }
                /*
                 * Sum up the local hba ports available.
                 */
                local_avail += numberOfPorts;

                /*
                 * Clear g_printHBA flag for expander subcommand.
                 */
                g_printHBA = 0;

                /* process each port on the given adapter */
                for (portIndex = 0;
                    portIndex < numberOfPorts;
                    portIndex++) {
                        /*
                         * We only handle the port which is valid.
                         */
                        if (port_array[portIndex].name[0] == '\0') {
                                continue;
                        }
                        memset(&port, 0, sizeof (port));
                        memset(&sasattrs, 0, sizeof (sasattrs));
                        port.PortSpecificAttribute.SASPort = &sasattrs;

                        (void) SMHBA_GetAdapterPortAttributes(handle,
                            port_array[portIndex].index, &port);

                        /*
                         * We have different things to do for the three
                         * sub-commands here.
                         */
                        if (processPort == handleHBAPort) {
                                /*
                                 * For hba-port, we will check whether the
                                 * specified hba port exist first.
                                 * But if no hba port specified, we should
                                 * by pass this check(just let hbaPortExist
                                 * be 1).
                                 */
                                if (input->wwnCount > 0) {
                                        if (isStringInArgv(input,
                                            port.OSDeviceName)) {
                                                hbaPortExist = 1;
                                                if (g_printHBA == 0) {
                                                        (void *) fprintf(stdout,
                                                            "%s %s\n",
                                                            "HBA Name:",
                                                            adpt_array[i].name);
                                                        g_printHBA = 1;
                                                }
                                        }
                                } else {
                                        hbaPortExist = 1;
                                        if (g_printHBA == 0) {
                                                (void *) fprintf(stdout,
                                                    "%s %s\n",
                                                    "HBA Name:",
                                                    adpt_array[i].name);
                                                g_printHBA = 1;
                                        }
                                }
                        }

                        if (processPort == handleExpander) {
                                /*
                                 * For expander device, input->hbaName is
                                 * the hba port name specified on the
                                 * command line(with -p option).
                                 */
                                if (input->hbaName[0] != '\0') {
                                        if (strcmp(input->hbaName,
                                            port.OSDeviceName) == 0)
                                                hbaPortExist = 1;
                                } else
                                        hbaPortExist = 1;
                        }

                        if (processPort == handleTargetPort) {
                                /*
                                 * For target port, we don't need to check the
                                 * hba port address, so let it go here.
                                 */
                                hbaPortExist = 1;
                        }

                        if (processPort == handleLogicalUnit) {
                                /*
                                 * For lu, we don't need to check the hba
                                 * port address, so let it go here.
                                 */
                                hbaPortExist = 1;
                        }

                        if (hbaPortExist) {
                                if (port.PortSpecificAttribute.SASPort->
                                    NumberofDiscoveredPorts) {
                                        remote_avail++;
                                }
                                ret += (*processPort)(handle,
                                    adpt_array[i].name,
                                    port_array[portIndex].index, &port,
                                    &attrs, input);
                                /*
                                 * We should reset the hbaPortExist flag
                                 * here for next round of check and count
                                 * for the machedHBAPorts.
                                 */
                                hbaPortExist = 0;
                                matchedHBAPorts++;
                        }
                }
                if (port_array) {
                        free(port_array);
                        port_array = NULL;
                }
                HBA_CloseAdapter(handle);
        }
        if (adpt_array) {
                free(adpt_array);
                adpt_array = NULL;
        }

        /*
         * When we are here, we have traversed all the hba and hba ports.
         */
        if (matchedHBAs == 0) {
                (void *) fprintf(stderr, "%s\n",
                    gettext("Error: Matching HBA not found."));
                if (input->wwn_flag) {
                        free(input->wwn_flag);
                        input->wwn_flag = NULL;
                }
                return (++ret);
        } else if (processPort == NULL) {
                /*
                 * processPort == NULL signifies hba subcommand.
                 * If enter here, it means we have at least one matching
                 * hba, we need to check if there are mismatching ones.
                 */
                for (i = 0; i < input->wwnCount; i++) {
                        if (input->wwn_flag[i] == 0) {
                                (void *) fprintf(stderr, "%s %s %s\n",
                                    gettext("Error: HBA"),
                                    input->wwn_argv[i],
                                    gettext("not found."));
                                ret++;
                        }
                }
        } else {
                if (local_avail > 0 && matchedHBAPorts == 0) {
                        (void *) fprintf(stderr, "%s\n",
                            gettext("Error: Matching HBA Port "
                            "not found."));
                        if (input->wwn_flag) {
                                free(input->wwn_flag);
                                input->wwn_flag = NULL;
                        }
                        return (++ret);
                } else if (local_avail == 0) {
                        (void *) fprintf(stderr, "%s\n",
                            gettext("Error: No HBA Port Configured."));
                        if (input->wwn_flag) {
                                free(input->wwn_flag);
                                input->wwn_flag = NULL;
                        }
                        return (++ret);
                } else if (processPort == handleHBAPort) {
                        /*
                         * If enter here, we have at least one HBA port
                         * matched. For hba-port subcommand, we shall check
                         * whether there are operands mismatching.
                         */
                        for (i = 0; i < input->wwnCount; i++) {
                                if (input->wwn_flag[i] == 0) {
                                        (void *) fprintf(stderr, "%s %s %s\n",
                                            gettext("Error: HBA Port"),
                                            input->wwn_argv[i],
                                            gettext("not found."));
                                        ret++;
                                }
                        }
                }
        }

        /*
         * For expander subcommand, we need to check if the
         * specified sas address(ese) exist (none/partial/all).
         */
        if (processPort == handleExpander) {
                if (input->wwnCount > 0) {
                        sum = 0;
                        for (i = 0; i < input->wwnCount; i++) {
                                sum += input->wwn_flag[i];
                        }
                        /*
                         * If sum is zero, it means that for all the given
                         * operands matching count is zero. So none of the
                         * specified SAS address exist actually.
                         */
                        if (sum == 0) {
                                (void *) fprintf(stderr, gettext("Error: "
                                    "Matching SAS Address not found.\n"));
                                free(input->wwn_flag);
                                input->wwn_flag = NULL;
                                return (++ret);
                        }

                        /*
                         * If we get here, it means that some of the specified
                         * sas address exist, we will know through looping the
                         * wwn_flag array.
                         */
                        for (i = 0; i < input->wwnCount; i++) {
                                if (input->wwn_flag[i] == 0) {
                                        (void *) fprintf(stderr, "%s %s %s\n",
                                            gettext("Error: SAS Address"),
                                            input->wwn_argv[i],
                                            gettext("not found."));
                                        ret++;
                                }
                        }
                }
                /* even if no remote port is found it is not an error. */
        }
        if (input->wwn_flag) {
                free(input->wwn_flag);
                input->wwn_flag = NULL;
        }
        return (ret);
}

/*
 * This function will handle the phy stuff for hba-port subcommand.
 *
 * Arguments:
 *      handle - handle to hba port.
 *      portIndex - the index of hba port currently being processed.
 *      port - pointer to hba port attributes.
 *      pflag - options user specified.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
static int
processHBAPortPhyInfo(HBA_HANDLE handle, HBA_UINT32 portIndex,
    SMHBA_PORTATTRIBUTES *port, int pflag)
{
        int             phyIndex = 0, err_cnt = 0;
        HBA_UINT32      numphys = 0;
        HBA_STATUS      status = 0;
        SMHBA_SAS_PHY   phyattrs;

        if (port == NULL)
                return (++err_cnt);

        numphys = port->PortSpecificAttribute.SASPort->NumberofPhys;
        if (numphys == 0)
                return (0);

        if ((pflag & PRINT_PHY) || (pflag & PRINT_PHY_LINKSTAT))
                (void *) fprintf(stdout, "%s\n", "    Phy Information:");
        else
                return (0);


        for (phyIndex = 0; phyIndex < numphys; phyIndex++) {
                memset(&phyattrs, 0, sizeof (phyattrs));
                status = SMHBA_GetSASPhyAttributes(
                    handle, portIndex, phyIndex, &phyattrs);
                if (status != HBA_STATUS_OK) {
                        (void *) fprintf(stderr, "%s %d %s %s\n",
                            gettext("Failed to get SAS Phy attributes"
                            "phyIndex"), phyIndex,
                            gettext("Reason:"),
                            getHBAStatus(status));
                        err_cnt++;
                        continue;
                }
                if (pflag & PRINT_PHY)
                        printHBAPortPhyInfo(&phyattrs);
                if (pflag & PRINT_PHY_LINKSTAT)
                        err_cnt += processHBAPortPhyStat(handle,
                            portIndex, phyIndex, &phyattrs, pflag);
        }
        return (err_cnt);
}

/*
 * This function will handle the phy stuff for hba-port subcommand.
 *
 * Arguments:
 *      handle - handle to hba port.
 *      portIndex - the index of hba port currently being processed.
 *      port - pointer to hba port attributes.
 *      pflag - options user specified.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
static int
processHBAPortPhyStat(HBA_HANDLE handle, HBA_UINT32 portIndex, int phyIndex,
    PSMHBA_SAS_PHY phyattrs, int pflag)
{
        HBA_STATUS              status = 0;
        SMHBA_PHYSTATISTICS     phystat;
        SMHBA_SASPHYSTATISTICS  sasphystat;

        if ((pflag & PRINT_PHY) == 0) {
                (void *) fprintf(stdout, "%s %d\n",
                    "      Identifier:", phyattrs->PhyIdentifier);
        }

        memset(&phystat, 0, sizeof (phystat));
        memset(&sasphystat, 0, sizeof (sasphystat));
        phystat.SASPhyStatistics = &sasphystat;
        status = SMHBA_GetPhyStatistics(handle, portIndex, phyIndex, &phystat);
        if (status != HBA_STATUS_OK) {
                (void *) fprintf(stdout, "%s\n",
                    "        Link Error Statistics:");
                (void *) fprintf(stderr, "%s\n",
                    gettext("            Failed to retrieve Link "
                    "Error Statistics!"));
                return (1);
        }
        printHBAPortPhyStatistics(phystat.SASPhyStatistics);
        return (0);
}

/*
 * Check whether the pWWN exist in the WWNs list which specified by user.
 *
 * Arguments:
 *      input - contains all the input parameters.
 *      pWWN - pointer to the hba port sas address.
 *
 *  Return Value:
 *          1           true, the pWWN exist in the sas address list specified.
 *          0           false.
 */
static int
isPortWWNInArgv(inputArg_t *input, PHBA_WWN pWWN)
{
        int             port_wwn_counter = 0;
        int             portfound = 0;
        uint64_t        hbaWWN;

        /* list only ports given in wwn_argv */
        for (port_wwn_counter = 0;
            port_wwn_counter < input->wwnCount;
            port_wwn_counter++) {
                hbaWWN = strtoull(input->wwn_argv[port_wwn_counter], NULL,
                    16);
                if (hbaWWN == 0 && errno != 0)
                        continue;
                if (wwnConversion(pWWN->wwn) == hbaWWN) {
                        if (input->wwn_flag) {
                                input->wwn_flag[port_wwn_counter]++;
                        }
                        portfound = 1;
                }
        }
        return (portfound);
}

/*
 * Check whether the string value exists in the input list,
 * which specified by user.
 *
 * Arguments:
 *      input - contains all the input parameters.
 *      stringName - could be hba adapter name
 *                            hba-port name.
 *
 *  Return Value:
 *          1           true, the HBA exists in the list specified.
 *          0           false.
 */
static int
isStringInArgv(inputArg_t *input, const char *stringName)
{
        int             counter = 0;
        int             found = 0;

        /* list only hba(s) given in wwn_argv */
        for (counter = 0;
            counter < input->wwnCount;
            counter++) {
                if (strcmp(input->wwn_argv[counter],
                    stringName) == 0) {
                        if (input->wwn_flag)
                                input->wwn_flag[counter]++;
                        found = 1;
                }
        }
        return (found);
}

/*
 * Callback function for hba subcommand.
 *
 * Arguments:
 *      attrs - pointer to adapter attributes currently being processed.
 *      input - contains all the input parameters.
 *      numberOfPorts - number of ports of this HBA.
 *
 *  Return Value:
 *      matching number
 */
static int handleHBA(SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input,
    int numberOfPorts, const char *adapterName)
{
        int matchingHBA = 1;

        if (input->wwnCount == 0) {
                printHBAInfo(attrs, input->pflag, numberOfPorts, adapterName);
        } else {
                if (isStringInArgv(input, adapterName)) {
                        printHBAInfo(attrs,
                            input->pflag, numberOfPorts, adapterName);
                } else {
                        matchingHBA = 0;
                }
        }

        return (matchingHBA);
}

/*
 * Callback function for hba-port subcommand.
 *
 * Arguments:
 *      handle - handle to hba port.
 *      portIndex - the index of hba port currently being processed.
 *      port - pointer to hba port attributes.
 *      attrs - pointer to adapter attributes currently being processed.
 *      input - contains all the input parameters.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
/*ARGSUSED*/
static int handleHBAPort(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input)
{
        int ret = 0;
        printHBAPortInfo(port, attrs, input->pflag);
        ret = processHBAPortPhyInfo(handle, portIndex, port, input->pflag);
        return (ret);
}

/*
 * Callback function for expander subcommand.
 *
 * Arguments:
 *      handle - handle to hba port.
 *      portIndex - the index of hba port currently being processed.
 *      port - pointer to hba port attributes.
 *      attrs - pointer to adapter attributes currently being processed.
 *      input - contains all the input parameters.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
/*ARGSUSED*/
static int handleExpander(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input)
{
        SMHBA_PORTATTRIBUTES    attr;
        SMHBA_SAS_PORT          sasport;
        HBA_STATUS              status;
        int                     ret = 0;
        int                     i, numberOfRP;
        rp_tree_t               *rpnode;
        rp_tree_t               *rproot = NULL;
        rp_tree_t               *unsolved_head = NULL;
        rp_tree_t               *unsolved_tail = NULL;
        rp_tree_t               *unsolved_sentinel = NULL;
        int                     printPort = 0;
        int                     numberOfEXP = 0;
        int                     unsolved_inserted = 0;
        int                     unsolved_left = 0;
        int                     disco_port_fail = 0;
        boolean_t               firstPrinted = B_FALSE;

        memset(&attr, 0, sizeof (attr));
        memset(&sasport, 0, sizeof (sasport));
        attr.PortSpecificAttribute.SASPort = &sasport;

        /*
         * Retrive all expander device from this hba port first.
         */
        if ((numberOfRP = port->PortSpecificAttribute.SASPort->
            NumberofDiscoveredPorts) == 0) {
                /* no remote port. just return 0. */
                return (ret);
        }

        for (i = 0; i < numberOfRP; i++) {
                rpnode = calloc(1, sizeof (rp_tree_t));
                rpnode->portattr.PortSpecificAttribute.SASPort =
                    &rpnode->sasattr;
                status = SMHBA_GetDiscoveredPortAttributes(handle,
                    portIndex, i, &rpnode->portattr);
                if (status != HBA_STATUS_OK) {
                        disco_port_fail++;
                        free(rpnode);
                        ret++;
                        continue;
                }

                if (rpnode->portattr.PortType == HBA_PORTTYPE_SASEXPANDER) {
                        numberOfEXP++;
                }
                /*
                 * We will try to insert this expander device and target
                 * ports into the topology tree. If we failed, we can chain
                 * them together and try again when we have all the
                 * discovered port information in hands.
                 */
                if (rproot == NULL && memcmp(port->
                    PortSpecificAttribute.SASPort->LocalSASAddress.wwn,
                    rpnode->sasattr.AttachedSASAddress.wwn,
                    sizeof (HBA_WWN)) == 0) {
                        /*
                         * The root node of tree should
                         * be set up first.
                         */
                        rproot = rpnode;
                } else {
                        /*
                         * If we can not set up the root node of
                         * the tree or we failed to insert
                         * the disocvered port node, queue it up then.
                         */
                        if (rproot == NULL ||
                            sas_rp_tree_insert(&rproot, rpnode) != 0) {
                                if (unsolved_head == NULL) {
                                        unsolved_head = rpnode;
                                        unsolved_tail = rpnode;
                                } else {
                                        rpnode->sibling = unsolved_head;
                                        unsolved_head = rpnode;
                                }
                        }
                }
        }

        if (disco_port_fail) {
                (void *) fprintf(stderr, "%s %d %s %s\n",
                    gettext("Error: Failed to get attributes for"),
                    disco_port_fail,
                    gettext("connected ports of HBA port"),
                    port->OSDeviceName);
        }

        /* no expander found.  No need further processing. */
        if (numberOfEXP == 0) {
                while (unsolved_head) {
                        unsolved_tail =
                            unsolved_head->sibling;
                        free(unsolved_head);
                        unsolved_head = unsolved_tail;
                }
                if (rproot) sas_rp_tree_free(rproot);
                return (ret);
        }

        /*
         * When we're here, we should already have all information,
         * now we try again to insert them into the topology tree.
         * unsolved_head is the pointer which point to the head of
         * unsolved rpnode linked list.
         * unsolved_tail is the pointer which point to the tail of
         * unsolved rpnode linked list.
         * unsolved_sentinel is for insertion failure detection.
         * When we're trying to insert the rpnodes from unsolved
         * linked list, it may happen that some of the rpnodes can
         * not be inserted no matter how many times we loop through
         * this linked list. So we use unsolved_sentinel to identify
         * the tail of last round of scanning, and unsolved_inserted
         * which is a counter will be used to count how many rpnodes
         * have been inserted from last round, if it is zero, which
         * means that we can not insert rpnodes into rptree any more,
         * and we should stop and deallocate the memory they occupied.
         */
        unsolved_sentinel = unsolved_tail;
        while (unsolved_head) {
                rpnode = unsolved_head;
                unsolved_head = unsolved_head->sibling;
                if (unsolved_head == NULL)
                        unsolved_tail = NULL;
                rpnode->sibling = NULL;
                if (sas_rp_tree_insert(&rproot, rpnode) != 0) {
                        unsolved_tail->sibling = rpnode;
                        unsolved_tail = rpnode;
                        if (rpnode == unsolved_sentinel) {
                                /*
                                 * We just scanned one round for the
                                 * unsolved list. Check to see whether we
                                 * have nodes inserted, if none, we should
                                 * break in case of an indefinite loop.
                                 */
                                if (unsolved_inserted == 0) {
                                        /*
                                         * Indicate there is unhandled node.
                                         * Chain free the whole unsolved
                                         * list here.
                                         */
                                        unsolved_left++;
                                        break;
                                } else {
                                        unsolved_inserted = 0;
                                        unsolved_sentinel = unsolved_tail;
                                }
                        }
                } else {
                        /*
                         * We just inserted one rpnode, increment the
                         * unsolved_inserted counter. We will utilize this
                         * counter to detect an indefinite insertion loop.
                         */
                        unsolved_inserted++;
                }
        }

        /* check if there is left out discovered ports. */
        if (unsolved_left) {
                ret++;
                (void *) fprintf(stderr, "%s %s\n",
                    gettext("Error: Failed to establish expander topology on"),
                    port->OSDeviceName);
                (void *) fprintf(stderr, "%s\n",
                    gettext("       Folowing port(s) are unresolved."));
                while (unsolved_head) {
                        unsolved_tail =
                            unsolved_head->sibling;
                        (void *) fprintf(stderr, "%s%016llx ",
                            firstPrinted ? "" : "\t",
                            wwnConversion(unsolved_head->sasattr.
                            LocalSASAddress.wwn));
                        if (firstPrinted == B_FALSE) firstPrinted = B_TRUE;
                        free(unsolved_head);
                        unsolved_head = unsolved_tail;
                }
                (void *) fprintf(stderr, "\n");
                /* still print what we have */
                ret += sas_rp_tree_print(handle, adapterName, portIndex,
                    port, rproot, input, 2 * TABLEN, &printPort);
        } else {
                ret += sas_rp_tree_print(handle, adapterName, portIndex,
                    port, rproot, input, 2 * TABLEN, &printPort);
        }

        if (rproot) sas_rp_tree_free(rproot);

        return (ret);
}

/*
 * Callback function for target-port subcommand.
 *
 * Arguments:
 *      handle - handle to hba port.
 *      portIndex - the index of hba port currently being processed.
 *      port - pointer to hba port attributes.
 *      attrs - pointer to adapter attributes currently being processed.
 *      input - contains all the input parameters.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
/*ARGSUSED*/
static int handleTargetPort(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input)
{
        HBA_STATUS              status;
        SMHBA_PORTATTRIBUTES    targetattr;
        SMHBA_SAS_PORT          sasattr;
        int                     i;
        int                     ret = 0;
        int                     disco_port_fail = 0;

        targetattr.PortSpecificAttribute.SASPort = &sasattr;

        for (i = 0; i < port->PortSpecificAttribute.SASPort->
            NumberofDiscoveredPorts; i++) {
                status = SMHBA_GetDiscoveredPortAttributes(handle,
                    portIndex, i, &targetattr);
                if (status != HBA_STATUS_OK) {
                        disco_port_fail++;
                } else {
                        /* skip expander device */
                        if (targetattr.PortType != HBA_PORTTYPE_SASEXPANDER) {
                                ret += searchTargetPort(handle, portIndex, port,
                                    &targetattr, &sasattr, input->pflag);
                        }
                }
        }

        if (disco_port_fail) {
                ret++;
                (void *) fprintf(stderr, "%s %d %s %s\n",
                    gettext("Error: Failed to get attributes for"),
                    disco_port_fail,
                    gettext("connected ports of HBA port"),
                    port->OSDeviceName);
        }
        return (ret);
}

/*
 * ****************************************************************************
 *
 * compareLUName -
 *      compare names directly and also check if disk namees match with
 *      different slice number or /devices path are speicified and matches.
 *
 * cmdArg       - first string to compare
 * osName       - os name from attributes
 *
 * returns      B_TRUE if the strings match either directly or via devid
 *              B_FALSE otherwise
 *
 * ****************************************************************************
 */
static boolean_t
compareLUName(char *cmdArg, char *osName)
{

        boolean_t       isSame = B_FALSE;
        char            dev1[MAXPATHLEN], dev2[MAXPATHLEN];
        char            *ch1, *ch2;

        if (strcmp(cmdArg, osName) == 0) {
                isSame = B_TRUE;
        } else {
                /* user input didn't match, try to  match the core of args. */
                (void) strlcpy(dev1, cmdArg, MAXPATHLEN);
                (void) strlcpy(dev2, osName, MAXPATHLEN);
                /* is this /devices path */
                if (((ch1 = strrchr(dev1, ',')) != NULL) &&
                    ((ch2 = strrchr(dev2, ',')) != NULL)) {
                        *ch1 = *ch2 = '\0';
                        if (strcmp(dev1, dev2) == 0) {
                                isSame = B_TRUE;
                        }
                /* is this a /dev link */
                } else if ((strncmp(dev1, "/dev/", 5) == 0) &&
                    (strncmp(dev2, "/dev/", 5) == 0)) {
                        if ((strstr(dev1, "dsk") != NULL) &&
                            ((strstr(dev2, "dsk") != NULL))) {
                                /* if it is disk link */
                                if (((ch1 = strrchr(dev1, 's')) != NULL) &&
                                    ((ch2 = strrchr(dev2, 's')) != NULL)) {
                                        *ch1 = *ch2 = '\0';
                                        if (strcmp(dev1, dev2) == 0) {
                                                isSame = B_TRUE;
                                        }
                                }
                        } else {
                                /* other dev links */
                                if (strcmp(dev1, dev2) == 0) {
                                        isSame = B_TRUE;
                                }
                        }
                }
        } /* compare */

        return (isSame);
}

/*
 * Process logical-unit(lu) subcommand.
 *
 * Arguments:
 *      luCount - number of OS device name(s) specified by user.
 *      luArgv - array of OS device name(s) specified by user.
 *      options - all the options specified by user.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
int
sas_util_list_logicalunit(int luCount, char **luArgv, cmdOptions_t *options)
{
        HBA_STATUS              status;
        int                     processHBA_flags = 0;
        int                     lu;
        boolean_t               pathFound;
        boolean_t               verbose;
        inputArg_t              input;
        discoveredDevice        *LUListWalk = NULL;
        int                     err_cnt = 0;

        for (; options->optval; options++) {
                if (options->optval == 'v') {
                        processHBA_flags |= PRINT_VERBOSE;
                }
        }

        /* HBA_LoadLibrary() */
        if ((status = HBA_LoadLibrary()) != HBA_STATUS_OK) {
                (void *) fprintf(stderr, "%s %s\n",
                    gettext("Failed to load SM-HBA libraries."
                    "Reason:"), getHBAStatus(status));
                err_cnt++;
                return (err_cnt);
        }

        memset(&input, 0, sizeof (input));
        input.pflag = processHBA_flags;
        input.wwnCount = luCount;
        input.wwn_argv = luArgv;

        err_cnt += processHBA(&input, handleLogicalUnit);
        verbose = (input.pflag & PRINT_VERBOSE) ? B_TRUE : B_FALSE;

        if (luCount == 0) {
                /* list all paths */
                for (LUListWalk = LUList; LUListWalk != NULL;
                    LUListWalk = LUListWalk->next) {
                        err_cnt += printOSDeviceNameInfo(LUListWalk, verbose);
                }
        } else {
                /*
                 * When operands provided, we should set the error code
                 * only if there are issues related with the operands.
                 */
                err_cnt = 0;
                /*
                 * list any paths not found first
                 * this gives the user cleaner output
                 */
                for (lu = 0; lu < luCount; lu++) {
                        for (LUListWalk = LUList, pathFound = B_FALSE;
                            LUListWalk != NULL;
                            LUListWalk = LUListWalk->next) {
                                if (compareLUName(luArgv[lu],
                                    LUListWalk->OSDeviceName)) {
                                        pathFound = B_TRUE;
                                        break;
                                }
                        }
                        if (pathFound == B_FALSE) {
                                (void *) fprintf(stderr,
                                    "Error: Logical Unit %s Not Found \n",
                                    luArgv[lu]);
                                err_cnt++;
                        }
                }
                /* list all paths requested in order requested */
                for (lu = 0; lu < luCount; lu++) {
                        for (LUListWalk = LUList; LUListWalk != NULL;
                            LUListWalk = LUListWalk->next) {
                                if (compareLUName(luArgv[lu],
                                    LUListWalk->OSDeviceName)) {
                                        err_cnt += printOSDeviceNameInfo(
                                            LUListWalk,
                                            verbose);
                                }
                        }
                }
        }
        (void) HBA_FreeLibrary();
        return (err_cnt);
}

/*
 * Callback function for logical-unit(lu) subcommand.
 *
 * Arguments:
 *      handle - handle to hba port.
 *      portIndex - the index of hba port currently being processed.
 *      port - pointer to hba port attributes.
 *      attrs - pointer to adapter attributes currently being processed.
 *      input - contains all the input parameters.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
/*ARGSUSED*/
static int handleLogicalUnit(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    SMHBA_ADAPTERATTRIBUTES *attrs, inputArg_t *input)
{
        HBA_STATUS              status;
        SMHBA_TARGETMAPPING     *map;
        HBA_WWN                 hbaPortWWN, domainPortWWN;
        char                    *portName = NULL;
        int                     numentries;
        int                     count = 0;
        int                     ret = 0;

        hbaPortWWN = port->PortSpecificAttribute.SASPort->LocalSASAddress;
        portName = port->OSDeviceName;

        status = get_domainPort(handle, portIndex, port, &domainPortWWN);
        switch (status) {
                case HBA_STATUS_OK:
                        break;
                case HBA_STATUS_ERROR_NOT_SUPPORTED:
                        /* don't increase error flag for no phy configuration */
                        return (ret);
                case HBA_STATUS_ERROR:
                default:
                        return (++ret);
        }

        if ((map = calloc(1, sizeof (*map))) == NULL) {
                (void *) fprintf(stderr, "%s\n",
                    gettext("No enough memory on heap."));
                return (++ret);
        }
        map->NumberOfEntries = 1;

        /*
         * First, we need to get the target mapping data from this hba
         * port.
         */
        status = SMHBA_GetTargetMapping(handle,
            hbaPortWWN, domainPortWWN, map);

        if (status == HBA_STATUS_ERROR_MORE_DATA) {
                numentries = map->NumberOfEntries;
                free(map);
                map = calloc(1, sizeof (HBA_UINT32) +
                    (numentries * sizeof (SMHBA_SCSIENTRY)));
                if (map == NULL) {
                        (void *) fprintf(stderr, "%s\n",
                            gettext("No enough memory on heap."));
                        return (++ret);
                }
                map->NumberOfEntries = numentries;
                status = SMHBA_GetTargetMapping(handle,
                    hbaPortWWN, domainPortWWN, map);
        }

        if (status != HBA_STATUS_OK) {
                (void *) fprintf(stderr, "%s %016llx %s %s\n",
                    gettext("Error: Failed to get SCSI mapping data for "
                    "the HBA port"), wwnConversion(hbaPortWWN.wwn),
                    gettext("Reason:"),
                    getHBAStatus(status));
                free(map);
                return (++ret);
        }

        /*
         * By iterating each entry of the targetmapping data, we will
         * construct a global list of logical unit.
         */
        for (count = 0; count < map->NumberOfEntries; count++) {
                ret += searchDevice(
                    &(map->entry[count]), handle, hbaPortWWN, domainPortWWN,
                    portName, input->pflag);
        }
        free(map);
        return (ret);
}

/*
 * Search the matching targetmapping data for given target port and SAM LUN
 *      and return target mapping data if found.
 *
 * Arguments:
 *      handle - handle to hba port.
 *      portIndex - hba port index
 *      port - hba port attributes.
 *      targetportWWN - target port SAS address.
 *      domainportWWN - domain port SAS address.
 *      domainportttr - target port SAS attributes.
 *      samLUN - samLUN from report LUNs data.
 *      data - matching target mapping data.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
static int
searchTargetPortMappingData(HBA_HANDLE handle, HBA_UINT32 portIndex,
    SMHBA_PORTATTRIBUTES *port, SMHBA_SAS_PORT *sasattr,
    struct targetPortConfig *configData)
{
        int                     ret = 0;
        HBA_STATUS              status;
        SMHBA_TARGETMAPPING     *map = NULL;
        HBA_WWN                 hbaPortWWN, domainPortWWN;
        int                     numentries, count;
        targetPortMappingData_t *TPMapData;
        struct scsi_inquiry     inq;
        struct scsi_extended_sense  sense;
        HBA_UINT32              responseSize, senseSize = 0;
        uchar_t                 rawLUNs[DEFAULT_LUN_LENGTH], *lun_string;
        HBA_UINT8               scsiStatus;
        rep_luns_rsp_t          *lun_resp;
        int                     lunNum, numberOfLun, lunCount;
        uint32_t                lunlength, tmp_lunlength;
        uint64_t                sasLUN;
        SMHBA_SCSILUN           smhbaLUN;

        hbaPortWWN = port->PortSpecificAttribute.SASPort->
            LocalSASAddress;

        status = get_domainPort(handle, portIndex, port, &domainPortWWN);
        if (status == HBA_STATUS_OK) {
                if ((map = calloc(1, sizeof (*map))) == NULL) {
                        (void *) fprintf(stderr, "%s\n",
                        gettext("No enough memory on heap."));
                        return (++ret);
                }
                map->NumberOfEntries = 1;

                status = SMHBA_GetTargetMapping(handle, hbaPortWWN,
                    domainPortWWN, map);

                if (status == HBA_STATUS_ERROR_MORE_DATA) {
                        numentries = map->NumberOfEntries;
                        free(map);
                        map = calloc(1, sizeof (HBA_UINT32) +
                            (numentries * sizeof (SMHBA_SCSIENTRY)));
                        if (map == NULL) {
                                (void *) fprintf(stderr, "%s\n",
                                    gettext("No enough memory on heap."));
                                return (++ret);
                        }
                        map->NumberOfEntries = numentries;
                        status = SMHBA_GetTargetMapping(handle,
                            hbaPortWWN, domainPortWWN, map);
                }

                if (status != HBA_STATUS_OK) {
                        /* continue to build mapping data based SCSI info */
                        ret++;
                        free(map);
                        map = NULL;
                }
        }

        /*
         * Get report lun data.
         */
        responseSize = DEFAULT_LUN_LENGTH;
        senseSize = sizeof (struct scsi_extended_sense);
        (void) memset(&sense, 0, sizeof (sense));
        status = SMHBA_ScsiReportLUNs(
            handle,
            hbaPortWWN,
            sasattr->LocalSASAddress,
            domainPortWWN,
            (void *)rawLUNs,
            &responseSize,
            &scsiStatus,
            (void *) &sense, &senseSize);

        /*
         * if HBA_STATUS_ERROR_NOT_A_TARGET is return, we can assume this is
         * a remote HBA and move on
         */
        if (status != HBA_STATUS_OK) {
                configData->reportLUNsFailed = B_TRUE;
                if (map != NULL) {
                        /*
                         * Let's search mapping data and indicate that Report
                         * LUNs failed.
                         */
                        for (count = 0; count < map->NumberOfEntries; count++) {
                                if (memcmp(map->entry[count].PortLun.
                                    PortWWN.wwn, sasattr->LocalSASAddress.wwn,
                                    sizeof (HBA_WWN)) == 0) {
                                        /* allocate mapping data for each LUN */
                                        TPMapData = calloc(1,
                                            sizeof (targetPortMappingData_t));
                                        if (TPMapData == NULL) {
                                                (void *) fprintf(stderr, "%s\n",
                                                    gettext("No enough "
                                                    "memory."));
                                                free(map);
                                                return (++ret);
                                        }
                                        TPMapData->mappingExist = B_TRUE;
                                        TPMapData->osLUN =
                                            map->entry[count].ScsiId.ScsiOSLun;
                                        (void) strlcpy(TPMapData->osDeviceName,
                                            map->entry[count].ScsiId.
                                            OSDeviceName,
                                            sizeof (TPMapData->osDeviceName));
                                        TPMapData->inq_vid[0] = '\0';
                                        TPMapData->inq_pid[0] = '\0';
                                        TPMapData->inq_dtype = DTYPE_UNKNOWN;
                                        if (configData->map == NULL) {
                                                configData->map = TPMapData;
                                        } else {
                                                TPMapData->next =
                                                    configData->map->next;
                                                configData->map = TPMapData;
                                        }
                                }
                        }
                }
                (void) free(map);
                return (++ret);
        }
        lun_resp = (rep_luns_rsp_t *)((void *)rawLUNs);
        (void) memcpy(&tmp_lunlength, &(lun_resp->length),
            sizeof (tmp_lunlength));
        lunlength = ntohl(tmp_lunlength);
        (void) memcpy(&numberOfLun, &lunlength, sizeof (numberOfLun));
        for (lunCount = 0; lunCount < (numberOfLun / 8); lunCount++) {
                /* allocate mapping data for each LUN */
                TPMapData = calloc(1,
                    sizeof (targetPortMappingData_t));
                if (TPMapData == NULL) {
                        (void *) fprintf(stderr, "%s\n",
                            gettext("No enough memory."));
                        free(map);
                        return (++ret);
                }

                (void) memcpy(&TPMapData->reportLUN, lun_resp->
                    lun[lunCount].val, sizeof (SMHBA_SCSILUN));

                /*
                 * now issue standard inquiry to get Vendor
                 * and product information
                 */
                responseSize = sizeof (struct scsi_inquiry);
                senseSize = sizeof (struct scsi_extended_sense);
                (void) memset(&inq, 0, sizeof (struct scsi_inquiry));
                (void) memset(&sense, 0, sizeof (sense));
                sasLUN = ntohll(wwnConversion(lun_resp->lun[lunCount].val));
                (void) memcpy(&smhbaLUN, &sasLUN, sizeof (SMHBA_SCSILUN));
                status = SMHBA_ScsiInquiry(
                    handle,
                    hbaPortWWN,
                    sasattr->LocalSASAddress,
                    domainPortWWN,
                    smhbaLUN,
                    0,
                    0,
                    (void *) &inq, &responseSize,
                    &scsiStatus,
                    (void *) &sense, &senseSize);
                if (status != HBA_STATUS_OK) {
                        TPMapData->inq_vid[0] = '\0';
                        TPMapData->inq_pid[0] = '\0';
                        TPMapData->inq_dtype = DTYPE_UNKNOWN;
                        /* indicate that inquiry for this lun is failed */
                        TPMapData->inquiryFailed = B_TRUE;
                } else {
                        (void *) memcpy(TPMapData->inq_vid, inq.inq_vid,
                            sizeof (TPMapData->inq_vid));
                        (void *) memcpy(TPMapData->inq_pid, inq.inq_pid,
                            sizeof (TPMapData->inq_pid));
                        TPMapData->inq_dtype = inq.inq_dtype;
                }

                if (map != NULL) {
                        for (count = 0; count < map->NumberOfEntries; count++) {
                                if ((memcmp(map->entry[count].PortLun.
                                    PortWWN.wwn, sasattr->LocalSASAddress.wwn,
                                    sizeof (HBA_WWN)) == 0) &&
                                    (memcmp(&(map->entry[count].PortLun.
                                    TargetLun), &smhbaLUN,
                                    sizeof (SMHBA_SCSILUN))
                                    == 0)) {
                                        TPMapData->mappingExist = B_TRUE;
                                        TPMapData->osLUN =
                                            map->entry[count].ScsiId.ScsiOSLun;
                                        (void) strlcpy(TPMapData->osDeviceName,
                                            map->entry[count].ScsiId.
                                            OSDeviceName,
                                            sizeof (TPMapData->osDeviceName));
                                        break;
                                }
                        }
                        if (count == map->NumberOfEntries) {
                                TPMapData->osDeviceName[0] = '\0';
                                lun_string = lun_resp->lun[lunCount].val;
                                lunNum = ((lun_string[0] & 0x3F) << 8) |
                                    lun_string[1];
                                TPMapData->osLUN = lunNum;
                        }
                } else {
                /* Not able to get any target mapping information */
                        TPMapData->osDeviceName[0] = '\0';
                        lun_string = lun_resp->lun[lunCount].val;
                        lunNum = ((lun_string[0] & 0x3F) << 8) |
                            lun_string[1];
                        TPMapData->osLUN = lunNum;
                }

                if (configData->map == NULL) {
                        configData->map = TPMapData;
                } else {
                        TPMapData->next = configData->map->next;
                        configData->map = TPMapData;
                }
        }
        free(map);
        return (ret);
}

/*
 * Search the discovered LUs and construct the global LU list.
 *
 * Arguments:
 *      handle - handle to hba port.
 *      portIndex - hba port index
 *      port - hba port attributes.
 *      targetattr - target port attributes.
 *      sasattr - target port SAS attributes.
 *      pflag - options the user specified.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
static int
searchTargetPort(HBA_HANDLE handle, HBA_UINT32 portIndex,
    SMHBA_PORTATTRIBUTES *port, SMHBA_PORTATTRIBUTES *targetattr,
    SMHBA_SAS_PORT *sasattr, int pflag)
{
        int                     ret = 0;
        HBA_WWN                 expander;
        HBA_WWN                 domainPortWWN;
        targetPortList_t        *discoveredTP, *newTP;
        targetPortConfig_t      *TPConfig, *newConfig, *prevConfig;
        boolean_t               foundTP = B_FALSE;
        boolean_t               foundConfig = B_FALSE;
        int                     status;
        SMHBA_PORTATTRIBUTES    tgtattr;
        SMHBA_SAS_PORT          tgtsasport;
        int                     expanderValid = 0;

        status = get_domainPort(handle, portIndex, port, &domainPortWWN);
        switch (status) {
                case HBA_STATUS_OK:
                        break;
                case HBA_STATUS_ERROR_NOT_SUPPORTED:
                        /* don't increase error flag for no phy configuration */
                        return (ret);
                case HBA_STATUS_ERROR:
                default:
                        return (++ret);
        }

        /*
         * First, we will iterate the already constructed target port
         * list to see whether there is a target port already exist with
         * matching target port SAS address.
         */
        for (discoveredTP = gTargetPortList; discoveredTP != NULL;
            discoveredTP = discoveredTP->next) {
                if (memcmp((void *)sasattr->LocalSASAddress.wwn,
                    (void *)discoveredTP->sasattr.LocalSASAddress.wwn,
                    sizeof (HBA_WWN)) == 0) {
                        /*
                         * if the target port exist and
                         * verbose is not set, just return
                         */
                        if (((pflag & PRINT_VERBOSE) == 0) &&
                            ((pflag & PRINT_TARGET_SCSI) == 0)) {
                                return (ret);
                        }
                        foundTP = B_TRUE;
                        break;
                }
        }

        if (foundTP == B_TRUE) {
                /*
                 * If there is a target port already exist, we should
                 * add more information on the target port to construct the
                 * whole topology.
                 * Here we will check whether the current hba port name
                 * has already been added.
                 */
                /* first get the expander SAS address compare */
                if (memcmp((void *)port->PortSpecificAttribute.SASPort->
                    LocalSASAddress.wwn, (void *)sasattr->
                    AttachedSASAddress.wwn, sizeof (HBA_WWN)) == 0) {
                        /* NO expander */
                        (void) memset(expander.wwn, 0,
                            sizeof (HBA_WWN));
                        expanderValid = 1;
                } else {
                        if (wwnConversion(sasattr->AttachedSASAddress.wwn)
                            != 0) {
                                /* expander exist.  We should verify it.  */
                                (void) memcpy((void *)expander.wwn,
                                    (void *)sasattr->AttachedSASAddress.wwn,
                                    sizeof (HBA_WWN));

                                memset(&tgtattr, 0, sizeof (tgtattr));
                                memset(&tgtsasport, 0,
                                    sizeof (tgtsasport));
                                tgtattr.PortSpecificAttribute.SASPort
                                    = &tgtsasport;
                                status = SMHBA_GetPortAttributesByWWN(handle,
                                    sasattr->AttachedSASAddress, domainPortWWN,
                                    &tgtattr);
                                if (status == HBA_STATUS_OK && tgtattr.PortType
                                    == HBA_PORTTYPE_SASEXPANDER) {
                                        expanderValid = 1;
                                }
                        }
                }

                for (TPConfig = discoveredTP->configEntry,
                    foundConfig = B_FALSE; TPConfig != NULL;
                    TPConfig = TPConfig->next) {
                        if ((strcmp(TPConfig->hbaPortName,
                            port->OSDeviceName) == 0) &&
                            (memcmp((void *)expander.wwn, (void *)TPConfig->
                            expanderSASAddr.wwn,
                            sizeof (HBA_WWN)) == 0)) {
                                foundConfig = B_TRUE;
                                break;
                        }
                }

                /*
                 * If we get here, it means that it is a new hba port/exapnder
                 * sas address for this discovered target port.
                 */
                if (foundConfig == B_FALSE) {
                        newConfig = (targetPortConfig_t *)calloc(1,
                            sizeof (targetPortConfig_t));
                        if (newConfig == NULL) {
                                (void *) fprintf(stderr,
                                    "%s\n", strerror(errno));
                                return (++ret);
                        }

                        (void) strlcpy(newConfig->hbaPortName, port->
                            OSDeviceName, sizeof (newConfig->hbaPortName));
                        (void) memcpy((void *)newConfig->expanderSASAddr.wwn,
                            (void *)expander.wwn, sizeof (HBA_WWN));
                        newConfig->expanderValid = expanderValid;
                        if (discoveredTP->configEntry == NULL) {
                                discoveredTP->configEntry = newConfig;
                        } else {
                                TPConfig = discoveredTP->configEntry;
                                prevConfig = TPConfig;
                                while (TPConfig != NULL &&
                                    sas_name_comp(newConfig->hbaPortName,
                                    TPConfig->hbaPortName) > 0) {
                                        prevConfig = TPConfig;
                                        TPConfig = TPConfig->next;
                                }
                                if (TPConfig == prevConfig) {
                                        /* Should be inserted in the head. */
                                        newConfig->next = TPConfig;
                                        discoveredTP->configEntry = newConfig;
                                } else {
                                        newConfig->next = TPConfig;
                                        prevConfig->next = newConfig;
                                }
                        }
                        /* if scsi option is not set return */
                        if ((pflag & PRINT_TARGET_SCSI) == 0) {
                                return (0);
                        } else {
                                return (searchTargetPortMappingData(
                                    handle, portIndex, port,
                                    sasattr, newConfig));
                        }
                }
        } else {
                /*
                 * Here we got a new target port which has not ever exist
                 * in our global target port list. So add it to the list.
                 * list.
                 */
                newTP = (targetPortList_t *)calloc(1,
                    sizeof (targetPortList_t));

                if (newTP == NULL) {
                        (void *) fprintf(stderr, "%s\n", strerror(errno));
                        return (++ret);
                }

                (void) memcpy((void *)&newTP->targetattr, (void *)targetattr,
                    sizeof (SMHBA_PORTATTRIBUTES));
                (void) memcpy((void *)&newTP->sasattr, (void *)sasattr,
                    sizeof (SMHBA_SAS_PORT));

                newConfig = (targetPortConfig_t *)calloc(1,
                    sizeof (targetPortConfig_t));

                if (newConfig == NULL) {
                        (void *) fprintf(stderr, "%s\n", strerror(errno));
                        free(newTP);
                        return (++ret);
                }

                (void) strlcpy(newConfig->hbaPortName, port->OSDeviceName,
                    sizeof (newConfig->hbaPortName));
                if (memcmp((void *)port->PortSpecificAttribute.SASPort->
                    LocalSASAddress.wwn, (void *)sasattr->
                    AttachedSASAddress.wwn, sizeof (HBA_WWN)) == 0) {
                        /* NO expander */
                        (void) memset(newConfig->expanderSASAddr.wwn,
                            0, sizeof (HBA_WWN));
                } else {
                        /* expander exist.  We should verify it. */
                        (void) memcpy((void *)newConfig->expanderSASAddr.wwn,
                            (void *)sasattr->AttachedSASAddress.wwn,
                            sizeof (HBA_WWN));

                        memset(&tgtattr, 0, sizeof (tgtattr));
                        memset(&tgtsasport, 0, sizeof (tgtsasport));
                        tgtattr.PortSpecificAttribute.SASPort = &tgtsasport;
                        status = SMHBA_GetPortAttributesByWWN(handle,
                            sasattr->AttachedSASAddress, domainPortWWN,
                            &tgtattr);
                        if (status == HBA_STATUS_OK && tgtattr.PortType ==
                            HBA_PORTTYPE_SASEXPANDER) {
                                expanderValid = 1;
                        }
                        newConfig->expanderValid = expanderValid;
                }

                newTP->configEntry = newConfig;

                newTP->next = gTargetPortList; /* insert at head */
                gTargetPortList = newTP; /* set new head */

                /* if scsi option is not set return */
                if ((pflag & PRINT_TARGET_SCSI) == 0) {
                        return (0);
                } else {
                        return (searchTargetPortMappingData(
                            handle, portIndex, port, sasattr, newConfig));
                }
        }
        return (ret);
}

/*
 * Search the discovered LUs and construct the global LU list.
 *
 * Arguments:
 *      entryP - one of the target mapping data.
 *      handle - handle to hba port.
 *      hbaPortWWN - hba port sas address.
 *      domainPortWWN - domain port WWN for this sas domain.
 *      portName - HBA port OS Device Name.
 *      pflag - options the user specified.
 *
 *  Return Value:
 *          0           sucessfully processed handle
 *          >0          error has occured
 */
static int
searchDevice(PSMHBA_SCSIENTRY entryP,
    HBA_HANDLE handle, HBA_WWN hbaPortWWN, HBA_WWN domainPortWWN,
    char *portName, int pflag)
{
        HBA_STATUS              status;
        int                     ret = 0;
        discoveredDevice        *discoveredLU, *newDevice;
        portList                *portElem, *newPort, *prevElem;
        tgtPortWWNList          *newTgtWWN, *TgtWWNList;
        boolean_t               foundDevice = B_FALSE;
        boolean_t               foundPort = B_FALSE;
        struct scsi_inquiry     inq;
        HBA_UINT32              responseSize, senseSize = 0;
        HBA_UINT8               inq_status;
        SMHBA_SCSILUN           smhbaLUN;
        struct scsi_extended_sense sense;

        /* if OSDeviceName is not set, we don't need to search */
        if (entryP->ScsiId.OSDeviceName[0] == '\0') {
                return (ret);
        }

        /*
         * First, we will iterate the already constructed discovered LU
         * list to see whether there is a LU already exist with the same OS
         * device name as current target mapping data entry.
         */
        for (discoveredLU = LUList; discoveredLU != NULL;
            discoveredLU = discoveredLU->next) {
                if (strcmp(entryP->ScsiId.OSDeviceName,
                    discoveredLU->OSDeviceName) == 0) {
                        /*
                         * if there is existing OS Device Name and
                         * verbose is not set, just return
                         */
                        if ((pflag & PRINT_VERBOSE) == 0) {
                                return (ret);
                        }
                        foundDevice = B_TRUE;
                        break;
                }
        }

        if (foundDevice == B_TRUE) {
                /*
                 * If there is a discovered LU already exist, we should
                 * add more information on this LU to construct the whole
                 * topology.
                 * Here we will check whether the current hba port has
                 * already been added.
                 */
                for (portElem = discoveredLU->HBAPortList,
                    foundPort = B_FALSE;  portElem != NULL;
                    portElem = portElem->next) {
                        if (strcmp(portElem->portName,
                            portName) == 0) {
                                foundPort = B_TRUE;
                                break;
                        }
                }

                /*
                 * If we get here, it means that it is a new hba port name
                 * for this discovered LU.
                 */
                if (foundPort == B_FALSE) {
                        newPort = (portList *)calloc(1, sizeof (portList));
                        if (newPort == NULL) {
                                (void *) fprintf(stderr,
                                    "%s\n", strerror(errno));
                                return (++ret);
                        }
                        (void) strlcpy(newPort->portName, portName,
                            sizeof (newPort->portName));

                        portElem = discoveredLU->HBAPortList;
                        prevElem = portElem;
                        while (portElem != NULL &&
                            sas_name_comp(newPort->portName, portElem->portName)
                            > 0) {
                                prevElem = portElem;
                                portElem = portElem->next;
                        }
                        if (portElem == prevElem) {
                                /* Insert in the head of list. */
                                newPort->next = portElem;
                                discoveredLU->HBAPortList = newPort;
                        } else {
                                newPort->next = portElem;
                                prevElem->next = newPort;
                        }
                        /* add Target Port */
                        newPort->tgtPortWWN = (tgtPortWWNList *)calloc(1,
                            sizeof (tgtPortWWNList));
                        if (newPort->tgtPortWWN == NULL) {
                                (void *) fprintf(stderr,
                                    "%s\n", strerror(errno));
                                return (++ret);
                        }
                        (void *) memcpy((void *)&(newPort->tgtPortWWN->portWWN),
                            (void *)&(entryP->PortLun.PortWWN),
                            sizeof (HBA_WWN));
                        /* Set LUN data */
                        newPort->tgtPortWWN->scsiOSLun =
                            entryP->ScsiId.ScsiOSLun;
                } else {
                        /*
                         * Otherwise, we just need to add the target port
                         * sas address information.
                         */
                        for (TgtWWNList = portElem->tgtPortWWN;
                            TgtWWNList != NULL;
                            TgtWWNList = TgtWWNList->next) {
                                if (memcmp(&TgtWWNList->portWWN,
                                    &entryP->PortLun.PortWWN,
                                    sizeof (HBA_WWN)) == 0)
                                        return (0);
                        }
                        /* add it to existing */
                        newTgtWWN = (tgtPortWWNList *)calloc(1,
                            sizeof (tgtPortWWNList));
                        if (newTgtWWN == NULL) {
                                (void *) fprintf(stderr,
                                    "%s\n", strerror(errno));
                                return (++ret);
                        }
                        /* insert at head */
                        newTgtWWN->next = portElem->tgtPortWWN;
                        portElem->tgtPortWWN = newTgtWWN;
                        (void *) memcpy((void *)&(newTgtWWN->portWWN),
                            (void *)&(entryP->PortLun.PortWWN),
                            sizeof (HBA_WWN));
                        /* Set LUN data */
                        newTgtWWN->scsiOSLun =
                            entryP->ScsiId.ScsiOSLun;
                }
        } else {
                /*
                 * Here we got a new discovered LU which has not ever exist
                 * in our global LU list. So add it into our global LU
                 * list.
                 */
                newDevice = (discoveredDevice *)calloc(1,
                    sizeof (discoveredDevice));

                if (newDevice == NULL) {
                        (void *) fprintf(stderr, "%s\n", strerror(errno));
                        return (++ret);
                }
                newDevice->next = LUList; /* insert at head */
                LUList = newDevice; /* set new head */

                /* copy device name */
                (void *) strlcpy(newDevice->OSDeviceName,
                    entryP->ScsiId.OSDeviceName,
                    sizeof (newDevice->OSDeviceName));

                /* if verbose is not set return */
                if ((pflag & PRINT_VERBOSE) == 0) {
                        return (0);
                }

                /* copy WWN data */
                newDevice->HBAPortList = (portList *)calloc(1,
                    sizeof (portList));
                if (newDevice->HBAPortList == NULL) {
                        (void *) fprintf(stderr, "%s\n", strerror(errno));
                        return (++ret);
                }
                (void) strlcpy(newDevice->HBAPortList->portName,
                    portName, sizeof (newDevice->HBAPortList->portName));

                newDevice->HBAPortList->tgtPortWWN =
                    (tgtPortWWNList *)calloc(1, sizeof (tgtPortWWNList));
                if (newDevice->HBAPortList->tgtPortWWN == NULL) {
                        (void *) fprintf(stderr, "%s\n", strerror(errno));
                        return (++ret);
                }

                (void *) memcpy((void *)&(newDevice->HBAPortList->\
                    tgtPortWWN->portWWN),
                    (void *)&(entryP->PortLun.PortWWN),
                    sizeof (HBA_WWN));
                newDevice->HBAPortList->tgtPortWWN->scsiOSLun =
                    entryP->ScsiId.ScsiOSLun;

                responseSize = sizeof (struct scsi_inquiry);
                senseSize = sizeof (struct scsi_extended_sense);
                memset(&inq, 0, sizeof (struct scsi_inquiry));
                memset(&sense, 0, sizeof (sense));
                (void *) memcpy(&smhbaLUN, &entryP->PortLun.TargetLun,
                    sizeof (smhbaLUN));

                /*
                 * Retrieve the VPD data for the newly found discovered LU.
                 */
                status = SMHBA_ScsiInquiry(
                    handle,
                    hbaPortWWN,
                    entryP->PortLun.PortWWN,
                    domainPortWWN,
                    smhbaLUN,
                    0,
                    0,
                    (void *) &inq, &responseSize,
                    &inq_status,
                    (void *) &sense, &senseSize);

                if (status != HBA_STATUS_OK) {
                        /* init VID/PID/dType as '\0' */
                        newDevice->VID[0] = '\0';
                        newDevice->PID[0] = '\0';
                        newDevice->dType = DTYPE_UNKNOWN;
                        /* initialize inq status */
                        newDevice->inquiryFailed = B_TRUE;
                        ret++;
                } else {
                        (void *) memcpy(newDevice->VID, inq.inq_vid,
                            sizeof (newDevice->VID));
                        (void *) memcpy(newDevice->PID, inq.inq_pid,
                            sizeof (newDevice->PID));
                        newDevice->dType = inq.inq_dtype;
                        /* initialize inq status */
                        newDevice->inquiryFailed = B_FALSE;
                }
        }
        return (ret);
}

/*
 * Function we use to insert a newly discovered port.
 * Return:
 *      0 - success
 *      >0 - failed
 */
static int
sas_rp_tree_insert(rp_tree_t **rproot,
    rp_tree_t *rpnode)
{
        HBA_UINT8 *wwn1, *wwn2, *wwn3;
        rp_tree_t *node_ptr;
        int ret = 0;

        if (rproot == NULL) {
                (void *) fprintf(stderr, "%s\n",
                    gettext("Error: NULL rproot"));
                return (1);
        }

        if (rpnode == NULL) {
                (void *) fprintf(stderr, "%s\n",
                    gettext("Error: NULL rpnode"));
                return (1);
        }

        if (*rproot == NULL) {
                *rproot = rpnode;
                return (0);
        }

        wwn1 = (*rproot)->sasattr.LocalSASAddress.wwn;
        wwn2 = (*rproot)->sasattr.AttachedSASAddress.wwn;
        wwn3 = rpnode->sasattr.AttachedSASAddress.wwn;

        /*
         * If the attched sas address is equal to the local sas address,
         * then this should be a child node of current root node.
         */
        if (memcmp(wwn1, wwn3, sizeof (HBA_WWN)) == 0) {
                (void) sas_rp_tree_insert(&(*rproot)->child, rpnode);
                rpnode->parent = *rproot;
        } else if (memcmp(wwn2, wwn3, sizeof (HBA_WWN)) == 0) {
                /*
                 * If the attached sas address is equal to the attached sas
                 * address of current root node, then this should be a
                 * sibling node.
                 * Insert the SAS/SATA Device at the head of sibling list.
                 */
                if (rpnode->portattr.PortType != HBA_PORTTYPE_SASEXPANDER) {
                        rpnode->sibling = *rproot;
                        *rproot = rpnode;
                } else {
                        /*
                         * Insert the SAS Expander at the tail of sibling
                         * list.
                         */
                        node_ptr = *rproot;
                        while (node_ptr->sibling != NULL)
                                node_ptr = node_ptr->sibling;
                        node_ptr->sibling = rpnode;
                }
                rpnode->parent = (*rproot)->parent;
        } else {
                /*
                 * If enter here, we should first try to insert the discovered
                 * port node into the child sub-tree, then try to insert to the
                 * sibling sub-trees. If we failed to insert the discovered
                 * port node, return 1. The caller will queue this node
                 * up and retry insertion later.
                 */
                if ((*rproot)->child) {
                        ret = sas_rp_tree_insert(&(*rproot)->child, rpnode);
                }
                if ((*rproot)->child == NULL || ret != 0) {
                        if ((*rproot)->sibling) {
                                ret = sas_rp_tree_insert(&(*rproot)->sibling,
                                    rpnode);
                        } else
                                ret = 1;
                }
                return (ret);
        }
        return (0);
}

/*
 * Function which will print out the whole disocvered port topology.
 * Here we use the Preorder Traversal algorithm.
 * The indentation rules are:
 *      1 * TABLEN - for attributes
 *      2 * TABLEN - for next tier target port/expander
 */
static int
sas_rp_tree_print(HBA_HANDLE handle, char *adapterName,
    HBA_UINT32 portIndex, SMHBA_PORTATTRIBUTES *port,
    rp_tree_t *rpnode, inputArg_t *input,
    int gident, int *printPort)
{
        int ret = 0, lident;

        if (rpnode == NULL)
                return (ret);
        lident = gident;

        /*
         * We assume that all the nodes are disocvered ports(sas device or
         * expander).
         */
        if (input->wwnCount > 0) {
                /* Adjust local indentation if a discovered port specified. */
                lident = 2 * TABLEN;
                /*
                 * Check whether current node match one of the specified
                 * SAS addresses.
                 */
                if ((rpnode->portattr.PortType != HBA_PORTTYPE_SASEXPANDER) ||
                    !isPortWWNInArgv(input,
                    &rpnode->sasattr.LocalSASAddress)) {
                        /*
                         * Step down to child tree first.
                         */
                        ret += sas_rp_tree_print(handle, adapterName,
                            portIndex, port, rpnode->child, input,
                            gident + 2 * TABLEN, printPort);
                        /*
                         * Then check the sibling tree.
                         */
                        ret += sas_rp_tree_print(handle, adapterName,
                            portIndex, port, rpnode->sibling, input,
                            gident, printPort);
                        return (ret);
                }
        }

        if ((rpnode->portattr.PortType == HBA_PORTTYPE_SASEXPANDER) ||
            (input->pflag & PRINT_TARGET_PORT)) {
                /*
                 * We should print the header(HBA Name + HBA Port Name)
                 * on-demand. It means that, if we have expander device
                 * address specified on the command line, we should print
                 * the header once we find a matching one. Or we will
                 * print the header from the beginning of the output.
                 */
                if (g_printHBA == 0) {
                        (void *) fprintf(stdout, "%s %s\n",
                            "HBA Name:", adapterName);
                        g_printHBA = 1;
                }

                if (*printPort == 0) {
                        (void *) fprintf(stdout, "%s%s %s\n",
                            getIndentSpaces(TABLEN),
                            "HBA Port Name:", port->OSDeviceName);
                        *printPort = 1;
                }
                ret += sas_print_rpnode(input, rpnode, lident, gident);
        }

        /*
         * If operands provided with "-t" option specified, we will print
         * the immediate child nodes information under the expander.
         */
        if (input->pflag & PRINT_TARGET_PORT) {
                /* no operand. ignore the option. */
                if (input->wwnCount > 0) {
                        if (rpnode->portattr.PortType ==
                            HBA_PORTTYPE_SASEXPANDER) {
                                ret += sas_rp_tree_print_desc(handle,
                                    portIndex, port, rpnode->child,
                                    input,
                                    lident + 2 * TABLEN,
                                    gident + 2 * TABLEN);
                        }
                }
        }

        /*
         * Here we use DFS(Depth First Search) algorithm to traverse the
         * whole tree.
         */
        ret += sas_rp_tree_print(handle, adapterName,
            portIndex, port, rpnode->child, input,
            gident + 2 * TABLEN, printPort);
        ret += sas_rp_tree_print(handle, adapterName,
            portIndex, port, rpnode->sibling, input,
            gident, printPort);
        return (ret);
}

/*
 * Function which will destroy the whole discovered port tree.
 * Here we use the Postorder Traversal algorithm.
 */
static void sas_rp_tree_free(rp_tree_t *rproot)
{
        tgt_mapping *cur, *next;

        if (rproot == NULL)
                return;

        /*
         * Free child tree first.
         */
        if (rproot->child) {
                sas_rp_tree_free(rproot->child);
        }

        /*
         * Free sibling trees then.
         */
        if (rproot->sibling) {
                sas_rp_tree_free(rproot->sibling);
        }

        /*
         * Free root node at last.
         */
        cur = rproot->first_entry;
        while (cur != NULL) {
                next = cur->next;
                free(cur);
                cur = next;
        }
        free(rproot);
}

/*
 * Function used to print out all the descendant nodes.
 * handle - handle to HBA.
 * port - port attributes of current HBA port.
 * desc - the root node of a subtree which will be processed.
 * input - input argument.
 * lident - local indentation for shifting indentation.
 * gident - global indentation, can also be used to obtain Tier number.
 */
/*ARGSUSED*/
static int
sas_rp_tree_print_desc(HBA_HANDLE handle, HBA_UINT32 portIndex,
    SMHBA_PORTATTRIBUTES *port, rp_tree_t *desc,
    inputArg_t *input, int lident, int gident)
{
        int ret = 0;
        rp_tree_t   *rp_node;

        if (desc == NULL)
                return (ret);
        /*
         * Walk through the subtree of desc by Pre-Order Traversal Algo.
         */
        for (rp_node = desc; rp_node != NULL; rp_node = rp_node->sibling) {
                ret += sas_print_rpnode(input, rp_node, lident, gident);
        }

        return (ret);
}

/*
 * Function used to print the information of specified SAS address.
 * handle - handle to a HBA.
 * port - port attributes of a HBA port.
 * rpnode - discovered port which will be processed.
 * lident - local indentation used for shifting indentation.
 * gident - global indentation used for calculating "Tier" number.
 */
static int
sas_print_rpnode(inputArg_t *input,
    rp_tree_t *rpnode, int lident, int gident)
{
        int ret = 0;

        if (rpnode->portattr.PortType == HBA_PORTTYPE_SASEXPANDER) {
                (void *) fprintf(stdout, "%s%s(Tier %d): %016llx\n",
                    getIndentSpaces(lident),
                    "Expander SAS Address",
                    gident / (2 * TABLEN),
                    wwnConversion(rpnode->sasattr.LocalSASAddress.wwn));
        } else {
                (void *) fprintf(stdout, "%s%s %016llx\n",
                    getIndentSpaces(lident),
                    "Target Port SAS Address:",
                    wwnConversion(rpnode->sasattr.LocalSASAddress.wwn));
        }
        if (input->pflag & PRINT_VERBOSE) {
                if (rpnode->portattr.PortType != HBA_PORTTYPE_SASEXPANDER) {
                        (void *) fprintf(stdout, "%s%s %s\n",
                            getIndentSpaces(TABLEN + lident),
                            "Type:",
                            getStateString(rpnode->portattr.PortType,
                            porttype_string));
                } else {
                        (void *) fprintf(stdout, "%s%s %s\n",
                            getIndentSpaces(TABLEN + lident),
                            "OS Device Name:",
                            rpnode->portattr.OSDeviceName);
                        (void *) fprintf(stdout, "%s%s %s\n",
                            getIndentSpaces(TABLEN + lident),
                            "State: ",
                            getStateString(rpnode->portattr.PortState,
                            portstate_string));
                }
        }
        rpnode->printed = 1;
        return (ret);
}

/*
 * Function used to get the correct domainPortWWN as needed by some of the
 * SMHBA APIs.
 * handle - handle to a HBA.
 * portIndex - index to locate the port.
 * port - pointer to the structure holding port attributes.
 * pdomainPort - pointer to the buffer holding domainPortWWN.
 */
HBA_STATUS
get_domainPort(HBA_HANDLE handle,
    int portIndex, PSMHBA_PORTATTRIBUTES port,
    HBA_WWN *pdomainPort)
{
        HBA_STATUS status;
        PSMHBA_SAS_PORT sasport;
        SMHBA_SAS_PHY phyattr;

        sasport = port->PortSpecificAttribute.SASPort;
        memset(pdomainPort, 0, sizeof (HBA_WWN));
        /*
         * Since iport can exist without any phys,
         * sasinfo hba-port -v has indicated numberOfPhys;
         * if there is no phys within the hba, just return OK.
         */
        if (sasport->NumberofPhys > 0) {
                status = SMHBA_GetSASPhyAttributes(handle, portIndex,
                    0, &phyattr);
                if (status != HBA_STATUS_OK)
                        return (status);
                (void *) memcpy(pdomainPort, &phyattr.domainPortWWN,
                    sizeof (HBA_WWN));
        } else {
                /* return not supported for no phy configured */
                return (HBA_STATUS_ERROR_NOT_SUPPORTED);
        }
        return (HBA_STATUS_OK);
}

/*
 * Comparison function for comparing names possibly ending with digits.
 * Return:
 *      <0 - name1 is less than name2.
 *      0 - name1 is equal with name2.
 *      >0 - name1 is more than name2.
 */
static int
sas_name_comp(const char *name1, const char *name2)
{
        int i = 0;

        if (name1 == name2)
                return (0);

        while ((name1[i] == name2[i]) && (name1[i] != '\0'))
                i++;

        /* If neither of name1[i] and name2[i] is '\0'. */
        if (isdigit(name1[i]) && isdigit(name2[i]))
                return (atoi(&name1[i]) - atoi(&name2[i]));

        /* One of name1[i] and name2[i] is not digit. */
        return (name1[i] - name2[i]);
}
/*
 * Comparison function for sorting HBA/HBA Port.
 * arg1 - first argument of type sas_elem_t.
 * arg2 - second argument of type sas_elem_t.
 * Return:
 *      <0 - arg1 is less than arg2.
 *      0 - arg1 is equal with arg2.
 *      >0 - arg1 is more than arg2.
 */
static int
sas_elem_compare(const void *arg1, const void *arg2)
{
        sas_elem_t *p1, *p2;
        p1 = (sas_elem_t *)arg1;
        p2 = (sas_elem_t *)arg2;
        return (sas_name_comp(p1->name, p2->name));
}

/*
 * Sorting function for HBA/HBA Port output.
 * array - elements array of type sas_elem_t.
 * nelem - number of elements in array of type sas_elem_t.
 */
static void
sas_elem_sort(sas_elem_t *array, int nelem)
{
        qsort((void *)array, nelem, sizeof (sas_elem_t), sas_elem_compare);
}