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

#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <libintl.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <libnvpair.h>
#include <pthread.h>
#include <syslog.h>
#include <libstmf.h>
#include <netinet/in.h>
#include <inttypes.h>
#include <store.h>
#include <locale.h>
#include <math.h>
#include <libstmf_impl.h>
#include <sys/stmf_ioctl.h>
#include <sys/stmf_sbd_ioctl.h>
#include <sys/pppt_ioctl.h>
#include <macros.h>

#define STMF_PATH    "/devices/pseudo/stmf@0:admin"
#define SBD_PATH    "/devices/pseudo/stmf_sbd@0:admin"
#define PPPT_PATH    "/devices/pseudo/pppt@0:pppt"

#define EUI "eui."
#define WWN "wwn."
#define IQN "iqn."
#define LU_ASCII_GUID_SIZE 32
#define LU_GUID_SIZE 16
#define OUI_ASCII_SIZE 6
#define HOST_ID_ASCII_SIZE 8
#define OUI_SIZE 3
#define HOST_ID_SIZE 4
#define IDENT_LENGTH_BYTE 3

/* various initial allocation values */
#define ALLOC_LU                8192
#define ALLOC_TARGET_PORT       2048
#define ALLOC_PROVIDER          64
#define ALLOC_GROUP             2048
#define ALLOC_SESSION           2048
#define ALLOC_VE                256
#define ALLOC_PP_DATA_SIZE      128*1024
#define ALLOC_GRP_MEMBER        256

#define MAX_ISCSI_NAME  223
#define MAX_SERIAL_SIZE 252 + 1
#define MAX_LU_ALIAS_SIZE 256
#define MAX_SBD_PROPS   MAXPATHLEN + MAX_SERIAL_SIZE + MAX_LU_ALIAS_SIZE

#define OPEN_STMF 0
#define OPEN_EXCL_STMF O_EXCL

#define OPEN_SBD 0
#define OPEN_EXCL_SBD O_EXCL

#define OPEN_PPPT 0
#define OPEN_EXCL_PPPT O_EXCL

#define LOGICAL_UNIT_TYPE 0
#define TARGET_TYPE 1
#define STMF_SERVICE_TYPE 2

#define HOST_GROUP   1
#define TARGET_GROUP 2

/* set default persistence here */
#define STMF_DEFAULT_PERSIST    STMF_PERSIST_SMF

#define MAX_PROVIDER_RETRY 30

static int openStmf(int, int *fd);
static int openSbd(int, int *fd);
static int openPppt(int, int *fd);
static int groupIoctl(int fd, int cmd, stmfGroupName *);
static int loadStore(int fd);
static int initializeConfig();
static int groupMemberIoctl(int fd, int cmd, stmfGroupName *, stmfDevid *);
static int guidCompare(const void *, const void *);
static int addViewEntryIoctl(int fd, stmfGuid *, stmfViewEntry *);
static int loadHostGroups(int fd, stmfGroupList *);
static int loadTargetGroups(int fd, stmfGroupList *);
static int getStmfState(stmf_state_desc_t *);
static int setStmfState(int fd, stmf_state_desc_t *, int);
static int setProviderData(int fd, char *, nvlist_t *, int, uint64_t *);
static int createDiskResource(luResourceImpl *);
static int createDiskLu(diskResource *, stmfGuid *);
static int deleteDiskLu(stmfGuid *luGuid);
static int getDiskProp(luResourceImpl *, uint32_t, char *, size_t *);
static int getDiskAllProps(stmfGuid *luGuid, luResource *hdl);
static int loadDiskPropsFromDriver(luResourceImpl *, sbd_lu_props_t *);
static int removeGuidFromDiskStore(stmfGuid *);
static int addGuidToDiskStore(stmfGuid *, char *);
static int persistDiskGuid(stmfGuid *, char *, boolean_t);
static int setDiskProp(luResourceImpl *, uint32_t, const char *);
static int getDiskGlobalProp(uint32_t prop, char *propVal, size_t *propLen);
static int checkHexUpper(char *);
static int strToShift(const char *);
static int niceStrToNum(const char *, uint64_t *);
static void diskError(uint32_t, int *);
static int importDiskLu(char *fname, stmfGuid *);
static int modifyDiskLu(diskResource *, stmfGuid *, const char *);
static int modifyDiskLuProp(stmfGuid *, const char *, uint32_t, const char *);
static int validateModifyDiskProp(uint32_t);
static uint8_t iGetPersistMethod();
static int groupListIoctl(stmfGroupList **, int);
static int iLoadGroupFromPs(stmfGroupList **, int);
static int groupMemberListIoctl(stmfGroupName *, stmfGroupProperties **, int);
static int getProviderData(char *, nvlist_t **, int, uint64_t *);
static int setDiskStandby(stmfGuid *luGuid);
static int setDiskGlobalProp(uint32_t, const char *);
static int viewEntryCompare(const void *, const void *);
static void deleteNonActiveLus();
static int loadStmfProp(int fd);

static pthread_mutex_t persistenceTypeLock = PTHREAD_MUTEX_INITIALIZER;
static int iPersistType = 0;
/* when B_TRUE, no need to access SMF anymore. Just use iPersistType */
static boolean_t iLibSetPersist = B_FALSE;

/*
 * Open for stmf module
 *
 * flag - open flag (OPEN_STMF, OPEN_EXCL_STMF)
 * fd - pointer to integer. On success, contains the stmf file descriptor
 */
static int
openStmf(int flag, int *fd)
{
        int ret = STMF_STATUS_ERROR;

        if ((*fd = open(STMF_PATH, O_NDELAY | O_RDONLY | flag)) != -1) {
                ret = STMF_STATUS_SUCCESS;
        } else {
                if (errno == EBUSY) {
                        ret = STMF_ERROR_BUSY;
                } else if (errno == EACCES) {
                        ret = STMF_ERROR_PERM;
                } else {
                        ret = STMF_STATUS_ERROR;
                }
                syslog(LOG_DEBUG, "openStmf:open failure:%s:errno(%d)",
                    STMF_PATH, errno);
        }

        return (ret);
}

/*
 * Open for sbd module
 *
 * flag - open flag (OPEN_SBD, OPEN_EXCL_SBD)
 * fd - pointer to integer. On success, contains the stmf file descriptor
 */
static int
openSbd(int flag, int *fd)
{
        int ret = STMF_STATUS_ERROR;

        if ((*fd = open(SBD_PATH, O_NDELAY | O_RDONLY | flag)) != -1) {
                ret = STMF_STATUS_SUCCESS;
        } else {
                if (errno == EBUSY) {
                        ret = STMF_ERROR_BUSY;
                } else if (errno == EACCES) {
                        ret = STMF_ERROR_PERM;
                } else {
                        ret = STMF_STATUS_ERROR;
                }
                syslog(LOG_DEBUG, "openSbd:open failure:%s:errno(%d)",
                    SBD_PATH, errno);
        }

        return (ret);
}

/*
 * Open for pppt module
 *
 * flag - open flag (OPEN_PPPT, OPEN_EXCL_PPPT)
 * fd - pointer to integer. On success, contains the stmf file descriptor
 */
static int
openPppt(int flag, int *fd)
{
        int ret = STMF_STATUS_ERROR;

        if ((*fd = open(PPPT_PATH, O_RDONLY | flag)) != -1) {
                ret = STMF_STATUS_SUCCESS;
        } else {
                if (errno == EBUSY) {
                        ret = STMF_ERROR_BUSY;
                } else if (errno == EACCES) {
                        ret = STMF_ERROR_PERM;
                } else {
                        ret = STMF_STATUS_ERROR;
                }
                syslog(LOG_DEBUG, "openPppt:open failure:%s:errno(%d)",
                    PPPT_PATH, errno);
        }

        return (ret);
}

/*
 * initializeConfig
 *
 * This routine should be called before any ioctl requiring initialization
 * which is basically everything except stmfGetState(), setStmfState() and
 * stmfLoadConfig().
 */
static int
initializeConfig()
{
        int ret;
        stmfState state;


        ret = stmfGetState(&state);
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /* if we've already initialized or in the process, return success */
        if (state.configState == STMF_CONFIG_STATE_INIT_DONE ||
            state.configState == STMF_CONFIG_STATE_INIT) {
                return (STMF_STATUS_SUCCESS);
        }

        ret = stmfLoadConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                syslog(LOG_DEBUG,
                    "initializeConfig:stmfLoadConfig:error(%d)", ret);
                return (ret);
        }

        ret = stmfGetState(&state);
        if (ret != STMF_STATUS_SUCCESS) {
                syslog(LOG_DEBUG,
                    "initializeConfig:stmfGetState:error(%d)", ret);
                return (ret);
        }

        if (state.configState != STMF_CONFIG_STATE_INIT_DONE) {
                syslog(LOG_DEBUG, "initializeConfig:state.configState(%d)",
                    state.configState);
                ret = STMF_STATUS_ERROR;
        }

        return (ret);
}


/*
 * groupIoctl
 *
 * Purpose: issue ioctl for create/delete on group
 *
 * cmd - valid STMF ioctl group cmd
 * groupName - groupName to create or delete
 */
static int
groupIoctl(int fd, int cmd, stmfGroupName *groupName)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        stmf_iocdata_t stmfIoctl;
        stmf_group_name_t iGroupName;

        bzero(&iGroupName, sizeof (iGroupName));

        bcopy(groupName, &iGroupName.name, strlen((char *)groupName));

        iGroupName.name_size = strlen((char *)groupName);

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to create the host group
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (iGroupName);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&iGroupName;
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                switch (stmfIoctl.stmf_error) {
                                        case STMF_IOCERR_TG_EXISTS:
                                        case STMF_IOCERR_HG_EXISTS:
                                                ret = STMF_ERROR_EXISTS;
                                                break;
                                        case STMF_IOCERR_TG_IN_USE:
                                        case STMF_IOCERR_HG_IN_USE:
                                                ret = STMF_ERROR_GROUP_IN_USE;
                                                break;
                                        case STMF_IOCERR_INVALID_HG:
                                        case STMF_IOCERR_INVALID_TG:
                                                ret = STMF_ERROR_NOT_FOUND;
                                                break;
                                        default:
                                                syslog(LOG_DEBUG,
                                                    "groupIoctl:error(%d)",
                                                    stmfIoctl.stmf_error);
                                                ret = STMF_STATUS_ERROR;
                                                break;
                                }
                                break;
                }
        }
        return (ret);
}

/*
 * groupMemberIoctl
 *
 * Purpose: issue ioctl for add/remove member on group
 *
 * cmd - valid STMF ioctl group member cmd
 * groupName - groupName to add to or remove from
 * devid - group member to add or remove
 */
static int
groupMemberIoctl(int fd, int cmd, stmfGroupName *groupName, stmfDevid *devid)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        stmf_iocdata_t stmfIoctl;
        stmf_group_op_data_t stmfGroupData;

        bzero(&stmfGroupData, sizeof (stmfGroupData));

        bcopy(groupName, &stmfGroupData.group.name, strlen((char *)groupName));

        stmfGroupData.group.name_size = strlen((char *)groupName);
        stmfGroupData.ident[IDENT_LENGTH_BYTE] = devid->identLength;
        bcopy(&(devid->ident), &stmfGroupData.ident[IDENT_LENGTH_BYTE + 1],
            devid->identLength);

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to add to the host group
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (stmfGroupData);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&stmfGroupData;
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                switch (stmfIoctl.stmf_error) {
                                        case STMF_IOCERR_TG_NEED_TG_OFFLINE:
                                                ret = STMF_ERROR_TG_ONLINE;
                                                break;
                                        default:
                                                ret = STMF_ERROR_BUSY;
                                                break;
                                }
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                switch (stmfIoctl.stmf_error) {
                                        case STMF_IOCERR_TG_ENTRY_EXISTS:
                                        case STMF_IOCERR_HG_ENTRY_EXISTS:
                                                ret = STMF_ERROR_EXISTS;
                                                break;
                                        case STMF_IOCERR_INVALID_TG_ENTRY:
                                        case STMF_IOCERR_INVALID_HG_ENTRY:
                                                ret =
                                                    STMF_ERROR_MEMBER_NOT_FOUND;
                                                break;
                                        case STMF_IOCERR_INVALID_TG:
                                        case STMF_IOCERR_INVALID_HG:
                                                ret =
                                                    STMF_ERROR_GROUP_NOT_FOUND;
                                                break;
                                        default:
                                                syslog(LOG_DEBUG,
                                                    "groupMemberIoctl:error"
                                                    "(%d)",
                                                    stmfIoctl.stmf_error);
                                                ret = STMF_STATUS_ERROR;
                                                break;
                                }
                                break;
                }
        }
        return (ret);
}

/*
 * qsort function
 * sort on veIndex
 */
static int
viewEntryCompare(const void *p1, const void *p2)
{

        stmfViewEntry *v1 = (stmfViewEntry *)p1, *v2 = (stmfViewEntry *)p2;
        if (v1->veIndex > v2->veIndex)
                return (1);
        if (v1->veIndex < v2->veIndex)
                return (-1);
        return (0);
}

/*
 * guidCompare
 *
 * qsort function
 * sort on guid
 */
static int
guidCompare(const void *p1, const void *p2)
{

        stmfGuid *g1 = (stmfGuid *)p1, *g2 = (stmfGuid *)p2;
        int i;

        for (i = 0; i < sizeof (stmfGuid); i++) {
                if (g1->guid[i] > g2->guid[i])
                        return (1);
                if (g1->guid[i] < g2->guid[i])
                        return (-1);
        }

        return (0);
}

/*
 * stmfAddToHostGroup
 *
 * Purpose: Adds an initiator to an existing host group
 *
 * hostGroupName - name of an existing host group
 * hostName - name of initiator to add
 */
int
stmfAddToHostGroup(stmfGroupName *hostGroupName, stmfDevid *hostName)
{
        int ret;
        int fd;

        if (hostGroupName == NULL ||
            (strnlen((char *)hostGroupName, sizeof (stmfGroupName))
            == sizeof (stmfGroupName)) || hostName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        if ((ret = groupMemberIoctl(fd, STMF_IOCTL_ADD_HG_ENTRY, hostGroupName,
            hostName)) != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        ret = psAddHostGroupMember((char *)hostGroupName,
            (char *)hostName->ident);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_EXISTS:
                        ret = STMF_ERROR_EXISTS;
                        break;
                case STMF_PS_ERROR_GROUP_NOT_FOUND:
                        ret = STMF_ERROR_GROUP_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfAddToHostGroup:psAddHostGroupMember:error(%d)",
                            ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfAddToTargetGroup
 *
 * Purpose: Adds a local port to an existing target group
 *
 * targetGroupName - name of an existing target group
 * targetName - name of target to add
 */
int
stmfAddToTargetGroup(stmfGroupName *targetGroupName, stmfDevid *targetName)
{
        int ret;
        int fd;

        if (targetGroupName == NULL ||
            (strnlen((char *)targetGroupName, sizeof (stmfGroupName))
            == sizeof (stmfGroupName)) || targetName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        if ((ret = groupMemberIoctl(fd, STMF_IOCTL_ADD_TG_ENTRY,
            targetGroupName, targetName)) != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        ret = psAddTargetGroupMember((char *)targetGroupName,
            (char *)targetName->ident);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_EXISTS:
                        ret = STMF_ERROR_EXISTS;
                        break;
                case STMF_PS_ERROR_GROUP_NOT_FOUND:
                        ret = STMF_ERROR_GROUP_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfAddToTargetGroup:psAddTargetGroupMember:"
                            "error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * addViewEntryIoctl
 *
 * Purpose: Issues ioctl to add a view entry
 *
 * lu - Logical Unit identifier to which the view entry is added
 * viewEntry - view entry to add
 * init - When set to B_TRUE, we are in the init state, i.e. don't call open
 */
static int
addViewEntryIoctl(int fd, stmfGuid *lu, stmfViewEntry *viewEntry)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        stmf_iocdata_t stmfIoctl;
        stmf_view_op_entry_t ioctlViewEntry;

        bzero(&ioctlViewEntry, sizeof (ioctlViewEntry));
        /*
         * don't set ve_ndx or ve_ndx_valid as ve_ndx_valid should be
         * false on input
         */
        ioctlViewEntry.ve_lu_number_valid = viewEntry->luNbrValid;
        ioctlViewEntry.ve_all_hosts = viewEntry->allHosts;
        ioctlViewEntry.ve_all_targets = viewEntry->allTargets;

        if (viewEntry->allHosts == B_FALSE) {
                bcopy(viewEntry->hostGroup, &ioctlViewEntry.ve_host_group.name,
                    sizeof (stmfGroupName));
                ioctlViewEntry.ve_host_group.name_size =
                    strlen((char *)viewEntry->hostGroup);
        }
        if (viewEntry->allTargets == B_FALSE) {
                bcopy(viewEntry->targetGroup,
                    &ioctlViewEntry.ve_target_group.name,
                    sizeof (stmfGroupName));
                ioctlViewEntry.ve_target_group.name_size =
                    strlen((char *)viewEntry->targetGroup);
        }
        if (viewEntry->luNbrValid) {
                bcopy(viewEntry->luNbr, &ioctlViewEntry.ve_lu_nbr,
                    sizeof (ioctlViewEntry.ve_lu_nbr));
        }
        bcopy(lu, &ioctlViewEntry.ve_guid, sizeof (stmfGuid));

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to add to the view entry
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (ioctlViewEntry);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&ioctlViewEntry;
        stmfIoctl.stmf_obuf_size = sizeof (ioctlViewEntry);
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)&ioctlViewEntry;
        ioctlRet = ioctl(fd, STMF_IOCTL_ADD_VIEW_ENTRY, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                                ret = STMF_ERROR_PERM;
                                break;
                        case EACCES:
                                switch (stmfIoctl.stmf_error) {
                                        case STMF_IOCERR_UPDATE_NEED_CFG_INIT:
                                                ret = STMF_ERROR_CONFIG_NONE;
                                                break;
                                        default:
                                                ret = STMF_ERROR_PERM;
                                                break;
                                }
                                break;
                        default:
                                switch (stmfIoctl.stmf_error) {
                                        case STMF_IOCERR_LU_NUMBER_IN_USE:
                                                ret = STMF_ERROR_LUN_IN_USE;
                                                break;
                                        case STMF_IOCERR_VIEW_ENTRY_CONFLICT:
                                                ret = STMF_ERROR_VE_CONFLICT;
                                                break;
                                        case STMF_IOCERR_UPDATE_NEED_CFG_INIT:
                                                ret = STMF_ERROR_CONFIG_NONE;
                                                break;
                                        case STMF_IOCERR_INVALID_HG:
                                                ret = STMF_ERROR_INVALID_HG;
                                                break;
                                        case STMF_IOCERR_INVALID_TG:
                                                ret = STMF_ERROR_INVALID_TG;
                                                break;
                                        default:
                                                syslog(LOG_DEBUG,
                                                    "addViewEntryIoctl"
                                                    ":error(%d)",
                                                    stmfIoctl.stmf_error);
                                                ret = STMF_STATUS_ERROR;
                                                break;
                                }
                                break;
                }
                goto done;
        }

        /* copy lu nbr back to caller's view entry on success */
        viewEntry->veIndex = ioctlViewEntry.ve_ndx;
        if (ioctlViewEntry.ve_lu_number_valid) {
                bcopy(&ioctlViewEntry.ve_lu_nbr, viewEntry->luNbr,
                    sizeof (ioctlViewEntry.ve_lu_nbr));
        }
        viewEntry->luNbrValid = B_TRUE;

done:
        return (ret);
}

/*
 * stmfAddViewEntry
 *
 * Purpose: Adds a view entry to a logical unit
 *
 * lu - guid of the logical unit to which the view entry is added
 * viewEntry - view entry structure to add
 */
int
stmfAddViewEntry(stmfGuid *lu, stmfViewEntry *viewEntry)
{
        int ret;
        int fd;
        stmfViewEntry iViewEntry;

        if (lu == NULL || viewEntry == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* initialize and set internal view entry */
        bzero(&iViewEntry, sizeof (iViewEntry));

        if (!viewEntry->allHosts) {
                bcopy(viewEntry->hostGroup, iViewEntry.hostGroup,
                    sizeof (iViewEntry.hostGroup));
        } else {
                iViewEntry.allHosts = B_TRUE;
        }

        if (!viewEntry->allTargets) {
                bcopy(viewEntry->targetGroup, iViewEntry.targetGroup,
                    sizeof (iViewEntry.targetGroup));
        } else {
                iViewEntry.allTargets = B_TRUE;
        }

        if (viewEntry->luNbrValid) {
                iViewEntry.luNbrValid = B_TRUE;
                bcopy(viewEntry->luNbr, iViewEntry.luNbr,
                    sizeof (iViewEntry.luNbr));
        }

        /*
         * set users return view entry index valid flag to false
         * in case of failure
         */
        viewEntry->veIndexValid = B_FALSE;

        /* Check to ensure service exists */
        if (psCheckService() != STMF_STATUS_SUCCESS) {
                return (STMF_ERROR_SERVICE_NOT_FOUND);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * First add the view entry to the driver
         */
        ret = addViewEntryIoctl(fd, lu, &iViewEntry);
        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        /*
         * If the add to driver was successful, add it to the persistent
         * store.
         */
        ret = psAddViewEntry(lu, &iViewEntry);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfAddViewEntry:psAddViewEntry:error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);

        if (ret == STMF_STATUS_SUCCESS) {
                /* set caller's view entry on success */
                viewEntry->veIndexValid = iViewEntry.veIndexValid;
                viewEntry->veIndex = iViewEntry.veIndex;
                viewEntry->luNbrValid = B_TRUE;
                bcopy(iViewEntry.luNbr, viewEntry->luNbr,
                    sizeof (iViewEntry.luNbr));
        }
        return (ret);
}

/*
 * stmfClearProviderData
 *
 * Purpose: delete all provider data for specified provider
 *
 * providerName - name of provider for which data should be deleted
 */
int
stmfClearProviderData(char *providerName, int providerType)
{
        int ret;
        int fd;
        int ioctlRet;
        int savedErrno;
        stmf_iocdata_t stmfIoctl;
        stmf_ppioctl_data_t ppi;

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        if (providerName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (providerType != STMF_LU_PROVIDER_TYPE &&
            providerType != STMF_PORT_PROVIDER_TYPE) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        bzero(&ppi, sizeof (ppi));

        (void) strncpy(ppi.ppi_name, providerName, sizeof (ppi.ppi_name));

        switch (providerType) {
                case STMF_LU_PROVIDER_TYPE:
                        ppi.ppi_lu_provider = 1;
                        break;
                case STMF_PORT_PROVIDER_TYPE:
                        ppi.ppi_port_provider = 1;
                        break;
                default:
                        ret = STMF_ERROR_INVALID_ARG;
                        goto done;
        }

        bzero(&stmfIoctl, sizeof (stmfIoctl));

        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (stmf_ppioctl_data_t);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&ppi;

        ioctlRet = ioctl(fd, STMF_IOCTL_CLEAR_PP_DATA, &stmfIoctl);
        if (ioctlRet != 0) {
                savedErrno = errno;
                switch (savedErrno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "stmfClearProviderData:ioctl error(%d)",
                                    ioctlRet);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                if (savedErrno != ENOENT) {
                        goto done;
                }
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        ret = psClearProviderData(providerName, providerType);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfClearProviderData:psClearProviderData"
                            ":error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfCreateHostGroup
 *
 * Purpose: Create a new initiator group
 *
 * hostGroupName - name of host group to create
 */
int
stmfCreateHostGroup(stmfGroupName *hostGroupName)
{
        int ret;
        int fd;

        if (hostGroupName == NULL ||
            (strnlen((char *)hostGroupName, sizeof (stmfGroupName))
            == sizeof (stmfGroupName))) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* Check to ensure service exists */
        if (psCheckService() != STMF_STATUS_SUCCESS) {
                return (STMF_ERROR_SERVICE_NOT_FOUND);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        if ((ret = groupIoctl(fd, STMF_IOCTL_CREATE_HOST_GROUP,
            hostGroupName)) != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        ret = psCreateHostGroup((char *)hostGroupName);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_EXISTS:
                        ret = STMF_ERROR_EXISTS;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfCreateHostGroup:psCreateHostGroup:error(%d)",
                            ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfCreateLu
 *
 * Purpose: Create a logical unit
 *
 * hdl - handle to logical unit resource created via stmfCreateLuResource
 *
 * luGuid - If non-NULL, on success, contains the guid of the created logical
 *          unit
 */
int
stmfCreateLu(luResource hdl, stmfGuid *luGuid)
{
        int ret = STMF_STATUS_SUCCESS;
        luResourceImpl *luPropsHdl = hdl;

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

        if (luPropsHdl->type == STMF_DISK) {
                ret = createDiskLu((diskResource *)luPropsHdl->resource,
                    luGuid);
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }

        return (ret);
}

/*
 * stmfCreateLuResource
 *
 * Purpose: Create resource handle for a logical unit
 *
 * dType - Type of logical unit resource to create
 *         Can be: STMF_DISK
 *
 * hdl - pointer to luResource
 */
int
stmfCreateLuResource(uint16_t dType, luResource *hdl)
{
        int ret = STMF_STATUS_SUCCESS;

        if (dType != STMF_DISK || hdl == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        *hdl = calloc(1, sizeof (luResourceImpl));
        if (*hdl == NULL) {
                return (STMF_ERROR_NOMEM);
        }

        ret = createDiskResource((luResourceImpl *)*hdl);
        if (ret != STMF_STATUS_SUCCESS) {
                free(*hdl);
                return (ret);
        }

        return (STMF_STATUS_SUCCESS);
}

/*
 * Creates a disk logical unit
 *
 * disk - pointer to diskResource structure that represents the properties
 *        for the disk logical unit to be created.
 */
static int
createDiskLu(diskResource *disk, stmfGuid *createdGuid)
{
        int ret = STMF_STATUS_SUCCESS;
        int dataFileNameLen = 0;
        int metaFileNameLen = 0;
        int serialNumLen = 0;
        int luAliasLen = 0;
        int luMgmtUrlLen = 0;
        int sluBufSize = 0;
        int bufOffset = 0;
        int fd = 0;
        int ioctlRet;
        int savedErrno;
        stmfGuid guid;
        stmf_iocdata_t sbdIoctl = {0};

        sbd_create_and_reg_lu_t *sbdLu = NULL;

        /*
         * Open control node for sbd
         */
        if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /* data file name must be specified */
        if (disk->luDataFileNameValid) {
                dataFileNameLen = strlen(disk->luDataFileName);
        } else {
                (void) close(fd);
                return (STMF_ERROR_MISSING_PROP_VAL);
        }

        sluBufSize += dataFileNameLen + 1;

        if (disk->luMetaFileNameValid) {
                metaFileNameLen = strlen(disk->luMetaFileName);
                sluBufSize += metaFileNameLen + 1;
        }

        serialNumLen = strlen(disk->serialNum);
        sluBufSize += serialNumLen;

        if (disk->luAliasValid) {
                luAliasLen = strlen(disk->luAlias);
                sluBufSize += luAliasLen + 1;
        }

        if (disk->luMgmtUrlValid) {
                luMgmtUrlLen = strlen(disk->luMgmtUrl);
                sluBufSize += luMgmtUrlLen + 1;
        }

        /*
         * 8 is the size of the buffer set aside for
         * concatenation of variable length fields
         */
        sbdLu = (sbd_create_and_reg_lu_t *)calloc(1,
            sizeof (sbd_create_and_reg_lu_t) + sluBufSize - 8);
        if (sbdLu == NULL) {
                return (STMF_ERROR_NOMEM);
        }

        sbdLu->slu_struct_size = sizeof (sbd_create_and_reg_lu_t) +
            sluBufSize - 8;

        if (metaFileNameLen) {
                sbdLu->slu_meta_fname_valid = 1;
                sbdLu->slu_meta_fname_off = bufOffset;
                bcopy(disk->luMetaFileName, &(sbdLu->slu_buf[bufOffset]),
                    metaFileNameLen + 1);
                bufOffset += metaFileNameLen + 1;
        }

        bcopy(disk->luDataFileName, &(sbdLu->slu_buf[bufOffset]),
            dataFileNameLen + 1);
        sbdLu->slu_data_fname_off = bufOffset;
        bufOffset += dataFileNameLen + 1;

        /* currently, serial # is not passed null terminated to the driver */
        if (disk->serialNumValid) {
                sbdLu->slu_serial_valid = 1;
                sbdLu->slu_serial_off = bufOffset;
                sbdLu->slu_serial_size = serialNumLen;
                bcopy(disk->serialNum, &(sbdLu->slu_buf[bufOffset]),
                    serialNumLen);
                bufOffset += serialNumLen;
        }

        if (disk->luAliasValid) {
                sbdLu->slu_alias_valid = 1;
                sbdLu->slu_alias_off = bufOffset;
                bcopy(disk->luAlias, &(sbdLu->slu_buf[bufOffset]),
                    luAliasLen + 1);
                bufOffset += luAliasLen + 1;
        }

        if (disk->luMgmtUrlValid) {
                sbdLu->slu_mgmt_url_valid = 1;
                sbdLu->slu_mgmt_url_off = bufOffset;
                bcopy(disk->luMgmtUrl, &(sbdLu->slu_buf[bufOffset]),
                    luMgmtUrlLen + 1);
                bufOffset += luMgmtUrlLen + 1;
        }

        if (disk->luSizeValid) {
                sbdLu->slu_lu_size_valid = 1;
                sbdLu->slu_lu_size = disk->luSize;
        }

        if (disk->luGuidValid) {
                sbdLu->slu_guid_valid = 1;
                bcopy(disk->luGuid, sbdLu->slu_guid, sizeof (disk->luGuid));
        }

        if (disk->vidValid) {
                sbdLu->slu_vid_valid = 1;
                bcopy(disk->vid, sbdLu->slu_vid, sizeof (disk->vid));
        }

        if (disk->pidValid) {
                sbdLu->slu_pid_valid = 1;
                bcopy(disk->pid, sbdLu->slu_pid, sizeof (disk->pid));
        }

        if (disk->revValid) {
                sbdLu->slu_rev_valid = 1;
                bcopy(disk->rev, sbdLu->slu_rev, sizeof (disk->rev));
        }

        if (disk->companyIdValid) {
                sbdLu->slu_company_id_valid = 1;
                sbdLu->slu_company_id = disk->companyId;
        }

        if (disk->hostIdValid) {
                sbdLu->slu_host_id_valid = 1;
                sbdLu->slu_host_id = disk->hostId;
        }

        if (disk->blkSizeValid) {
                sbdLu->slu_blksize_valid = 1;
                sbdLu->slu_blksize = disk->blkSize;
        }

        if (disk->writeProtectEnableValid) {
                if (disk->writeProtectEnable) {
                        sbdLu->slu_write_protected = 1;
                }
        }

        if (disk->writebackCacheDisableValid) {
                sbdLu->slu_writeback_cache_disable_valid = 1;
                if (disk->writebackCacheDisable) {
                        sbdLu->slu_writeback_cache_disable = 1;
                }
        }

        sbdIoctl.stmf_version = STMF_VERSION_1;
        sbdIoctl.stmf_ibuf_size = sbdLu->slu_struct_size;
        sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)sbdLu;
        sbdIoctl.stmf_obuf_size = sbdLu->slu_struct_size;
        sbdIoctl.stmf_obuf = (uint64_t)(unsigned long)sbdLu;

        ioctlRet = ioctl(fd, SBD_IOCTL_CREATE_AND_REGISTER_LU, &sbdIoctl);
        if (ioctlRet != 0) {
                savedErrno = errno;
                switch (savedErrno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                diskError(sbdIoctl.stmf_error, &ret);
                                if (ret == STMF_STATUS_ERROR) {
                                        syslog(LOG_DEBUG,
                                        "createDiskLu:ioctl "
                                        "error(%d) (%d) (%d)", ioctlRet,
                                            sbdIoctl.stmf_error, savedErrno);
                                }
                                break;
                }
        }

        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        /*
         * on success, copy the resulting guid into the caller's guid if not
         * NULL
         */
        if (createdGuid) {
                bcopy(sbdLu->slu_guid, createdGuid->guid,
                    sizeof (sbdLu->slu_guid));
        }

        bcopy(sbdLu->slu_guid, guid.guid, sizeof (sbdLu->slu_guid));
        if (disk->luMetaFileNameValid) {
                ret = addGuidToDiskStore(&guid, disk->luMetaFileName);
        } else {
                ret = addGuidToDiskStore(&guid, disk->luDataFileName);
        }
done:
        free(sbdLu);
        (void) close(fd);
        return (ret);
}


/*
 * stmfImportLu
 *
 * Purpose: Import a previously created logical unit
 *
 * dType - Type of logical unit
 *         Can be: STMF_DISK
 *
 * luGuid - If non-NULL, on success, contains the guid of the imported logical
 *          unit
 *
 * fname - A file name where the metadata resides
 *
 */
int
stmfImportLu(uint16_t dType, char *fname, stmfGuid *luGuid)
{
        int ret = STMF_STATUS_SUCCESS;

        if (dType == STMF_DISK) {
                ret = importDiskLu(fname, luGuid);
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }

        return (ret);
}

/*
 * importDiskLu
 *
 * filename - filename to import
 * createdGuid - if not NULL, on success contains the imported guid
 *
 */
static int
importDiskLu(char *fname, stmfGuid *createdGuid)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd = 0;
        int ioctlRet;
        int savedErrno;
        int metaFileNameLen;
        stmfGuid iGuid;
        int iluBufSize = 0;
        sbd_import_lu_t *sbdLu = NULL;
        stmf_iocdata_t sbdIoctl = {0};

        if (fname == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /*
         * Open control node for sbd
         */
        if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        metaFileNameLen = strlen(fname);
        iluBufSize += metaFileNameLen + 1;

        /*
         * 8 is the size of the buffer set aside for
         * concatenation of variable length fields
         */
        sbdLu = (sbd_import_lu_t *)calloc(1,
            sizeof (sbd_import_lu_t) + iluBufSize - 8);
        if (sbdLu == NULL) {
                (void) close(fd);
                return (STMF_ERROR_NOMEM);
        }

        /*
         * Accept either a data file or meta data file.
         * sbd will do the right thing here either way.
         * i.e. if it's a data file, it assumes that the
         * meta data is shared with the data.
         */
        (void) strncpy(sbdLu->ilu_meta_fname, fname, metaFileNameLen);

        sbdLu->ilu_struct_size = sizeof (sbd_import_lu_t) + iluBufSize - 8;

        sbdIoctl.stmf_version = STMF_VERSION_1;
        sbdIoctl.stmf_ibuf_size = sbdLu->ilu_struct_size;
        sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)sbdLu;
        sbdIoctl.stmf_obuf_size = sbdLu->ilu_struct_size;
        sbdIoctl.stmf_obuf = (uint64_t)(unsigned long)sbdLu;

        ioctlRet = ioctl(fd, SBD_IOCTL_IMPORT_LU, &sbdIoctl);
        if (ioctlRet != 0) {

                if (createdGuid && sbdIoctl.stmf_error ==
                    SBD_RET_FILE_ALREADY_REGISTERED) {
                        bcopy(sbdLu->ilu_ret_guid, createdGuid->guid,
                            sizeof (sbdLu->ilu_ret_guid));
                }

                savedErrno = errno;
                switch (savedErrno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                diskError(sbdIoctl.stmf_error, &ret);
                                if (ret == STMF_STATUS_ERROR) {
                                        syslog(LOG_DEBUG,
                                        "importDiskLu:ioctl "
                                        "error(%d) (%d) (%d)", ioctlRet,
                                            sbdIoctl.stmf_error, savedErrno);
                                }
                                break;
                }
        }


        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        /*
         * on success, copy the resulting guid into the caller's guid if not
         * NULL and add it to the persistent store for sbd
         */
        if (createdGuid) {
                bcopy(sbdLu->ilu_ret_guid, createdGuid->guid,
                    sizeof (sbdLu->ilu_ret_guid));
                ret = addGuidToDiskStore(createdGuid, fname);
        } else {
                bcopy(sbdLu->ilu_ret_guid, iGuid.guid,
                    sizeof (sbdLu->ilu_ret_guid));
                ret = addGuidToDiskStore(&iGuid, fname);
        }
done:
        free(sbdLu);
        (void) close(fd);
        return (ret);
}

/*
 * diskError
 *
 * Purpose: Translate sbd driver error
 */
static void
diskError(uint32_t stmfError, int *ret)
{
        switch (stmfError) {
                case SBD_RET_META_CREATION_FAILED:
                case SBD_RET_ZFS_META_CREATE_FAILED:
                        *ret = STMF_ERROR_META_CREATION;
                        break;
                case SBD_RET_INVALID_BLKSIZE:
                        *ret = STMF_ERROR_INVALID_BLKSIZE;
                        break;
                case SBD_RET_FILE_ALREADY_REGISTERED:
                        *ret = STMF_ERROR_FILE_IN_USE;
                        break;
                case SBD_RET_GUID_ALREADY_REGISTERED:
                        *ret = STMF_ERROR_GUID_IN_USE;
                        break;
                case SBD_RET_META_PATH_NOT_ABSOLUTE:
                case SBD_RET_META_FILE_LOOKUP_FAILED:
                case SBD_RET_META_FILE_OPEN_FAILED:
                case SBD_RET_META_FILE_GETATTR_FAILED:
                case SBD_RET_NO_META:
                        *ret = STMF_ERROR_META_FILE_NAME;
                        break;
                case SBD_RET_DATA_PATH_NOT_ABSOLUTE:
                case SBD_RET_DATA_FILE_LOOKUP_FAILED:
                case SBD_RET_DATA_FILE_OPEN_FAILED:
                case SBD_RET_DATA_FILE_GETATTR_FAILED:
                        *ret = STMF_ERROR_DATA_FILE_NAME;
                        break;
                case SBD_RET_FILE_SIZE_ERROR:
                        *ret = STMF_ERROR_FILE_SIZE_INVALID;
                        break;
                case SBD_RET_SIZE_OUT_OF_RANGE:
                        *ret = STMF_ERROR_SIZE_OUT_OF_RANGE;
                        break;
                case SBD_RET_LU_BUSY:
                        *ret = STMF_ERROR_LU_BUSY;
                        break;
                case SBD_RET_WRITE_CACHE_SET_FAILED:
                        *ret = STMF_ERROR_WRITE_CACHE_SET;
                        break;
                case SBD_RET_ACCESS_STATE_FAILED:
                        *ret = STMF_ERROR_ACCESS_STATE_SET;
                        break;
                default:
                        *ret = STMF_STATUS_ERROR;
                        break;
        }
}

/*
 * Creates a logical unit resource of type STMF_DISK.
 *
 * No defaults should be set here as all defaults are derived from the
 * driver's default settings.
 */
static int
createDiskResource(luResourceImpl *hdl)
{
        hdl->type = STMF_DISK;

        hdl->resource = calloc(1, sizeof (diskResource));
        if (hdl->resource == NULL) {
                return (STMF_ERROR_NOMEM);
        }

        return (STMF_STATUS_SUCCESS);
}

/*
 * stmfDeleteLu
 *
 * Purpose: Delete a logical unit
 *
 * hdl - handle to logical unit resource created via stmfCreateLuResource
 *
 * luGuid - If non-NULL, on success, contains the guid of the created logical
 *          unit
 */
int
stmfDeleteLu(stmfGuid *luGuid)
{
        int ret = STMF_STATUS_SUCCESS;
        stmfLogicalUnitProperties luProps;

        if (luGuid == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* Check logical unit provider name to call correct dtype function */
        if ((ret = stmfGetLogicalUnitProperties(luGuid, &luProps))
            != STMF_STATUS_SUCCESS) {
                return (ret);
        } else {
                if (strcmp(luProps.providerName, "sbd") == 0) {
                        ret = deleteDiskLu(luGuid);
                } else if (luProps.status == STMF_LOGICAL_UNIT_UNREGISTERED) {
                        return (STMF_ERROR_NOT_FOUND);
                } else {
                        return (STMF_ERROR_INVALID_ARG);
                }
        }

        return (ret);
}

static int
deleteDiskLu(stmfGuid *luGuid)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        int savedErrno;
        int ioctlRet;
        sbd_delete_lu_t deleteLu = {0};

        stmf_iocdata_t sbdIoctl = {0};

        /*
         * Open control node for sbd
         */
        if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        ret = removeGuidFromDiskStore(luGuid);
        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        bcopy(luGuid, deleteLu.dlu_guid, sizeof (deleteLu.dlu_guid));
        deleteLu.dlu_by_guid = 1;

        sbdIoctl.stmf_version = STMF_VERSION_1;
        sbdIoctl.stmf_ibuf_size = sizeof (deleteLu);
        sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)&deleteLu;
        ioctlRet = ioctl(fd, SBD_IOCTL_DELETE_LU, &sbdIoctl);
        if (ioctlRet != 0) {
                savedErrno = errno;
                switch (savedErrno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        case ENOENT:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "deleteDiskLu:ioctl error(%d) (%d) (%d)",
                                    ioctlRet, sbdIoctl.stmf_error, savedErrno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfLuStandby
 *
 * Purpose: Sets access state to standby
 *
 * luGuid - guid of registered logical unit
 *
 */
int
stmfLuStandby(stmfGuid *luGuid)
{
        int ret = STMF_STATUS_SUCCESS;
        stmfLogicalUnitProperties luProps;

        if (luGuid == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* Check logical unit provider name to call correct dtype function */
        if ((ret = stmfGetLogicalUnitProperties(luGuid, &luProps))
            != STMF_STATUS_SUCCESS) {
                return (ret);
        } else {
                if (strcmp(luProps.providerName, "sbd") == 0) {
                        ret = setDiskStandby(luGuid);
                } else if (luProps.status == STMF_LOGICAL_UNIT_UNREGISTERED) {
                        return (STMF_ERROR_NOT_FOUND);
                } else {
                        return (STMF_ERROR_INVALID_ARG);
                }
        }

        return (ret);
}

static int
setDiskStandby(stmfGuid *luGuid)
{
        int ret = STMF_STATUS_SUCCESS;
        stmf_iocdata_t sbdIoctl = {0};
        sbd_set_lu_standby_t sbdLu = {0};
        int ioctlRet;
        int savedErrno;
        int fd = 0;

        /*
         * Open control node for sbd
         */
        if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        bcopy(luGuid, &sbdLu.stlu_guid, sizeof (stmfGuid));

        sbdIoctl.stmf_version = STMF_VERSION_1;
        sbdIoctl.stmf_ibuf_size = sizeof (sbd_set_lu_standby_t);
        sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)&sbdLu;

        ioctlRet = ioctl(fd, SBD_IOCTL_SET_LU_STANDBY, &sbdIoctl);
        if (ioctlRet != 0) {
                savedErrno = errno;
                switch (savedErrno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                diskError(sbdIoctl.stmf_error, &ret);
                                if (ret == STMF_STATUS_ERROR) {
                                        syslog(LOG_DEBUG,
                                        "setDiskStandby:ioctl "
                                        "error(%d) (%d) (%d)", ioctlRet,
                                            sbdIoctl.stmf_error, savedErrno);
                                }
                                break;
                }
        }
        (void) close(fd);
        return (ret);
}

/*
 * stmfModifyLu
 *
 * Purpose: Modify properties of a logical unit
 *
 * luGuid - guid of registered logical unit
 * prop - property to modify
 * propVal - property value to set
 *
 */
int
stmfModifyLu(stmfGuid *luGuid, uint32_t prop, const char *propVal)
{
        int ret = STMF_STATUS_SUCCESS;
        stmfLogicalUnitProperties luProps;

        if (luGuid == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* Check logical unit provider name to call correct dtype function */
        if ((ret = stmfGetLogicalUnitProperties(luGuid, &luProps))
            != STMF_STATUS_SUCCESS) {
                return (ret);
        } else {
                if (strcmp(luProps.providerName, "sbd") == 0) {
                        ret = modifyDiskLuProp(luGuid, NULL, prop, propVal);
                } else if (luProps.status == STMF_LOGICAL_UNIT_UNREGISTERED) {
                        return (STMF_ERROR_NOT_FOUND);
                } else {
                        return (STMF_ERROR_INVALID_ARG);
                }
        }

        return (ret);
}

/*
 * stmfModifyLuByFname
 *
 * Purpose: Modify a device by filename. Device does not need to be registered.
 *
 * dType - type of device to modify
 *         STMF_DISK
 *
 * fname - filename or meta filename
 * prop - valid property identifier
 * propVal - property value
 *
 */
int
stmfModifyLuByFname(uint16_t dType, const char *fname, uint32_t prop,
    const char *propVal)
{
        int ret = STMF_STATUS_SUCCESS;
        if (fname == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (dType == STMF_DISK) {
                ret = modifyDiskLuProp(NULL, fname, prop, propVal);
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }

        return (ret);
}

static int
modifyDiskLuProp(stmfGuid *luGuid, const char *fname, uint32_t prop,
    const char *propVal)
{
        int ret = STMF_STATUS_SUCCESS;
        luResource hdl = NULL;
        luResourceImpl *luPropsHdl;

        ret = stmfCreateLuResource(STMF_DISK, &hdl);
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }
        ret = validateModifyDiskProp(prop);
        if (ret != STMF_STATUS_SUCCESS) {
                (void) stmfFreeLuResource(hdl);
                return (STMF_ERROR_INVALID_PROP);
        }
        ret = stmfSetLuProp(hdl, prop, propVal);
        if (ret != STMF_STATUS_SUCCESS) {
                (void) stmfFreeLuResource(hdl);
                return (ret);
        }
        luPropsHdl = hdl;
        ret = modifyDiskLu((diskResource *)luPropsHdl->resource, luGuid, fname);
        (void) stmfFreeLuResource(hdl);
        return (ret);
}

static int
validateModifyDiskProp(uint32_t prop)
{
        switch (prop) {
                case STMF_LU_PROP_ALIAS:
                case STMF_LU_PROP_SIZE:
                case STMF_LU_PROP_MGMT_URL:
                case STMF_LU_PROP_WRITE_PROTECT:
                case STMF_LU_PROP_WRITE_CACHE_DISABLE:
                        return (STMF_STATUS_SUCCESS);
                default:
                        return (STMF_STATUS_ERROR);
        }
}

static int
modifyDiskLu(diskResource *disk, stmfGuid *luGuid, const char *fname)
{
        int ret = STMF_STATUS_SUCCESS;
        int luAliasLen = 0;
        int luMgmtUrlLen = 0;
        int mluBufSize = 0;
        int bufOffset = 0;
        int fd = 0;
        int ioctlRet;
        int savedErrno;
        int fnameSize = 0;
        stmf_iocdata_t sbdIoctl = {0};

        sbd_modify_lu_t *sbdLu = NULL;

        if (luGuid == NULL && fname == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (fname) {
                fnameSize = strlen(fname) + 1;
                mluBufSize += fnameSize;
        }

        /*
         * Open control node for sbd
         */
        if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        if (disk->luAliasValid) {
                luAliasLen = strlen(disk->luAlias);
                mluBufSize += luAliasLen + 1;
        }

        if (disk->luMgmtUrlValid) {
                luMgmtUrlLen = strlen(disk->luMgmtUrl);
                mluBufSize += luMgmtUrlLen + 1;
        }

        /*
         * 8 is the size of the buffer set aside for
         * concatenation of variable length fields
         */
        sbdLu = (sbd_modify_lu_t *)calloc(1,
            sizeof (sbd_modify_lu_t) + mluBufSize - 8 + fnameSize);
        if (sbdLu == NULL) {
                (void) close(fd);
                return (STMF_ERROR_NOMEM);
        }

        sbdLu->mlu_struct_size = sizeof (sbd_modify_lu_t) +
            mluBufSize - 8 + fnameSize;

        if (disk->luAliasValid) {
                sbdLu->mlu_alias_valid = 1;
                sbdLu->mlu_alias_off = bufOffset;
                bcopy(disk->luAlias, &(sbdLu->mlu_buf[bufOffset]),
                    luAliasLen + 1);
                bufOffset += luAliasLen + 1;
        }

        if (disk->luMgmtUrlValid) {
                sbdLu->mlu_mgmt_url_valid = 1;
                sbdLu->mlu_mgmt_url_off = bufOffset;
                bcopy(disk->luMgmtUrl, &(sbdLu->mlu_buf[bufOffset]),
                    luMgmtUrlLen + 1);
                bufOffset += luMgmtUrlLen + 1;
        }

        if (disk->luSizeValid) {
                sbdLu->mlu_lu_size_valid = 1;
                sbdLu->mlu_lu_size = disk->luSize;
        }

        if (disk->writeProtectEnableValid) {
                sbdLu->mlu_write_protected_valid = 1;
                if (disk->writeProtectEnable) {
                        sbdLu->mlu_write_protected = 1;
                }
        }

        if (disk->writebackCacheDisableValid) {
                sbdLu->mlu_writeback_cache_disable_valid = 1;
                if (disk->writebackCacheDisable) {
                        sbdLu->mlu_writeback_cache_disable = 1;
                }
        }

        if (luGuid) {
                bcopy(luGuid, sbdLu->mlu_input_guid, sizeof (stmfGuid));
                sbdLu->mlu_by_guid = 1;
        } else {
                sbdLu->mlu_fname_off = bufOffset;
                bcopy(fname, &(sbdLu->mlu_buf[bufOffset]), fnameSize + 1);
                sbdLu->mlu_by_fname = 1;
        }

        sbdIoctl.stmf_version = STMF_VERSION_1;
        sbdIoctl.stmf_ibuf_size = sbdLu->mlu_struct_size;
        sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)sbdLu;

        ioctlRet = ioctl(fd, SBD_IOCTL_MODIFY_LU, &sbdIoctl);
        if (ioctlRet != 0) {
                savedErrno = errno;
                switch (savedErrno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                diskError(sbdIoctl.stmf_error, &ret);
                                if (ret == STMF_STATUS_ERROR) {
                                        syslog(LOG_DEBUG,
                                        "modifyDiskLu:ioctl "
                                        "error(%d) (%d) (%d)", ioctlRet,
                                            sbdIoctl.stmf_error, savedErrno);
                                }
                                break;
                }
        }

        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

done:
        free(sbdLu);
        (void) close(fd);
        return (ret);
}

/*
 * removeGuidFromDiskStore
 *
 * Purpose: delete a logical unit from the sbd provider data
 */
static int
removeGuidFromDiskStore(stmfGuid *guid)
{
        return (persistDiskGuid(guid, NULL, B_FALSE));
}


/*
 * addGuidToDiskStore
 *
 * Purpose: add a logical unit to the sbd provider data
 */
static int
addGuidToDiskStore(stmfGuid *guid, char *filename)
{
        return (persistDiskGuid(guid, filename, B_TRUE));
}


/*
 * persistDiskGuid
 *
 * Purpose: Persist or unpersist a guid for the sbd provider data
 *
 */
static int
persistDiskGuid(stmfGuid *guid, char *filename, boolean_t persist)
{
        char        guidAsciiBuf[LU_ASCII_GUID_SIZE + 1] = {0};
        nvlist_t    *nvl = NULL;

        uint64_t    setToken;
        boolean_t   retryGetProviderData = B_FALSE;
        boolean_t   newData = B_FALSE;
        int         ret = STMF_STATUS_SUCCESS;
        int         retryCnt = 0;
        int         stmfRet;

        /* if we're persisting a guid, there must be a filename */
        if (persist && !filename) {
                return (1);
        }

        /* guid is stored in lowercase ascii hex */
        (void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf),
            "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
            "%02x%02x%02x%02x%02x%02x",
            guid->guid[0], guid->guid[1], guid->guid[2], guid->guid[3],
            guid->guid[4], guid->guid[5], guid->guid[6], guid->guid[7],
            guid->guid[8], guid->guid[9], guid->guid[10], guid->guid[11],
            guid->guid[12], guid->guid[13], guid->guid[14], guid->guid[15]);


        do {
                retryGetProviderData = B_FALSE;
                stmfRet = stmfGetProviderDataProt("sbd", &nvl,
                    STMF_LU_PROVIDER_TYPE, &setToken);
                if (stmfRet != STMF_STATUS_SUCCESS) {
                        if (persist && stmfRet == STMF_ERROR_NOT_FOUND) {
                                ret = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0);
                                if (ret != 0) {
                                        syslog(LOG_DEBUG,
                                            "unpersistGuid:nvlist_alloc(%d)",
                                            ret);
                                        ret = STMF_STATUS_ERROR;
                                        goto done;
                                }
                                newData = B_TRUE;
                        } else {
                                /*
                                 * if we're persisting the data, it's
                                 * an error. Otherwise, just return
                                 */
                                if (persist) {
                                        ret = stmfRet;
                                }
                                goto done;
                        }
                }
                if (persist) {
                        ret = nvlist_add_string(nvl, guidAsciiBuf, filename);
                } else {
                        ret = nvlist_remove(nvl, guidAsciiBuf,
                            DATA_TYPE_STRING);
                        if (ret == ENOENT) {
                                ret = 0;
                        }
                }
                if (ret == 0) {
                        if (newData) {
                                stmfRet = stmfSetProviderDataProt("sbd", nvl,
                                    STMF_LU_PROVIDER_TYPE, NULL);
                        } else {
                                stmfRet = stmfSetProviderDataProt("sbd", nvl,
                                    STMF_LU_PROVIDER_TYPE, &setToken);
                        }
                        if (stmfRet != STMF_STATUS_SUCCESS) {
                                if (stmfRet == STMF_ERROR_BUSY) {
                                        /* get/set failed, try again */
                                        retryGetProviderData = B_TRUE;
                                        if (retryCnt++ > MAX_PROVIDER_RETRY) {
                                                ret = stmfRet;
                                                break;
                                        }
                                        continue;
                                } else if (stmfRet ==
                                    STMF_ERROR_PROV_DATA_STALE) {
                                        /* update failed, try again */
                                        nvlist_free(nvl);
                                        nvl = NULL;
                                        retryGetProviderData = B_TRUE;
                                        if (retryCnt++ > MAX_PROVIDER_RETRY) {
                                                ret = stmfRet;
                                                break;
                                        }
                                        continue;
                                } else {
                                        syslog(LOG_DEBUG,
                                            "unpersistGuid:error(%x)", stmfRet);
                                        ret = stmfRet;
                                }
                                break;
                        }
                } else {
                        syslog(LOG_DEBUG,
                            "unpersistGuid:error nvlist_add/remove(%d)",
                            ret);
                        ret = STMF_STATUS_ERROR;
                }
        } while (retryGetProviderData);

done:
        nvlist_free(nvl);
        return (ret);
}


/*
 * stmfGetLuProp
 *
 * Purpose: Get current value for a resource property
 *
 * hdl - luResource from a previous call to stmfCreateLuResource
 *
 * resourceProp - a valid resource property type
 *
 * propVal - void pointer to a pointer of the value to be retrieved
 */
int
stmfGetLuProp(luResource hdl, uint32_t prop, char *propVal, size_t *propLen)
{
        int ret = STMF_STATUS_SUCCESS;
        luResourceImpl *luPropsHdl = hdl;
        if (hdl == NULL || propLen == NULL || propVal == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (luPropsHdl->type == STMF_DISK) {
                ret = getDiskProp(luPropsHdl, prop, propVal, propLen);
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }

        return (ret);
}

/*
 * stmfGetLuResource
 *
 * Purpose: Get a logical unit resource handle for a given logical unit.
 *
 * hdl - pointer to luResource
 */
int
stmfGetLuResource(stmfGuid *luGuid, luResource *hdl)
{
        int ret = STMF_STATUS_SUCCESS;
        stmfLogicalUnitProperties luProps;

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

        /* Check logical unit provider name to call correct dtype function */
        if ((ret = stmfGetLogicalUnitProperties(luGuid, &luProps))
            != STMF_STATUS_SUCCESS) {
                return (ret);
        } else {
                if (strcmp(luProps.providerName, "sbd") == 0) {
                        ret = getDiskAllProps(luGuid, hdl);
                } else if (luProps.status == STMF_LOGICAL_UNIT_UNREGISTERED) {
                        return (STMF_ERROR_NOT_FOUND);
                } else {
                        return (STMF_ERROR_INVALID_ARG);
                }
        }

        return (ret);
}

/*
 * getDiskAllProps
 *
 * Purpose: load all disk properties from sbd driver
 *
 * luGuid - guid of disk device for which properties are to be retrieved
 * hdl - allocated luResource into which properties are to be copied
 *
 */
static int
getDiskAllProps(stmfGuid *luGuid, luResource *hdl)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        sbd_lu_props_t *sbdProps;
        int ioctlRet;
        int savedErrno;
        int sbdPropsSize = sizeof (*sbdProps) + MAX_SBD_PROPS;
        stmf_iocdata_t sbdIoctl = {0};

        /*
         * Open control node for sbd
         */
        if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);


        *hdl = calloc(1, sizeof (luResourceImpl));
        if (*hdl == NULL) {
                (void) close(fd);
                return (STMF_ERROR_NOMEM);
        }

        sbdProps = calloc(1, sbdPropsSize);
        if (sbdProps == NULL) {
                free(*hdl);
                (void) close(fd);
                return (STMF_ERROR_NOMEM);
        }

        ret = createDiskResource((luResourceImpl *)*hdl);
        if (ret != STMF_STATUS_SUCCESS) {
                free(*hdl);
                free(sbdProps);
                (void) close(fd);
                return (ret);
        }

        sbdProps->slp_input_guid = 1;
        bcopy(luGuid, sbdProps->slp_guid, sizeof (sbdProps->slp_guid));

        sbdIoctl.stmf_version = STMF_VERSION_1;
        sbdIoctl.stmf_ibuf_size = sbdPropsSize;
        sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)sbdProps;
        sbdIoctl.stmf_obuf_size = sbdPropsSize;
        sbdIoctl.stmf_obuf = (uint64_t)(unsigned long)sbdProps;
        ioctlRet = ioctl(fd, SBD_IOCTL_GET_LU_PROPS, &sbdIoctl);
        if (ioctlRet != 0) {
                savedErrno = errno;
                switch (savedErrno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        case ENOENT:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "getDiskAllProps:ioctl error(%d) (%d) (%d)",
                                    ioctlRet, sbdIoctl.stmf_error, savedErrno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
        }

        if (ret == STMF_STATUS_SUCCESS) {
                ret = loadDiskPropsFromDriver((luResourceImpl *)*hdl, sbdProps);
        }

        free(sbdProps);
        (void) close(fd);
        return (ret);
}

/*
 * loadDiskPropsFromDriver
 *
 * Purpose: Retrieve all disk type properties from sbd driver
 *
 * hdl - Allocated luResourceImpl
 * sbdProps - sbd_lu_props_t structure returned from sbd driver
 *
 */
static int
loadDiskPropsFromDriver(luResourceImpl *hdl, sbd_lu_props_t *sbdProps)
{
        int ret = STMF_STATUS_SUCCESS;
        diskResource *diskLu = hdl->resource;
        /* copy guid */
        diskLu->luGuidValid = B_TRUE;
        bcopy(sbdProps->slp_guid, diskLu->luGuid, sizeof (sbdProps->slp_guid));

        if (sbdProps->slp_separate_meta && sbdProps->slp_meta_fname_valid) {
                diskLu->luMetaFileNameValid = B_TRUE;
                if (strlcpy(diskLu->luMetaFileName,
                    (char *)&(sbdProps->slp_buf[sbdProps->slp_meta_fname_off]),
                    sizeof (diskLu->luMetaFileName)) >=
                    sizeof (diskLu->luMetaFileName)) {
                        return (STMF_STATUS_ERROR);
                }
        }

        if (sbdProps->slp_data_fname_valid) {
                diskLu->luDataFileNameValid = B_TRUE;
                if (strlcpy(diskLu->luDataFileName,
                    (char *)&(sbdProps->slp_buf[sbdProps->slp_data_fname_off]),
                    sizeof (diskLu->luDataFileName)) >=
                    sizeof (diskLu->luDataFileName)) {
                        return (STMF_STATUS_ERROR);
                }
        }

        if (sbdProps->slp_serial_valid) {
                diskLu->serialNumValid = B_TRUE;
                bcopy(&(sbdProps->slp_buf[sbdProps->slp_serial_off]),
                    diskLu->serialNum, sbdProps->slp_serial_size);
        }

        if (sbdProps->slp_mgmt_url_valid) {
                diskLu->luMgmtUrlValid = B_TRUE;
                if (strlcpy(diskLu->luMgmtUrl,
                    (char *)&(sbdProps->slp_buf[sbdProps->slp_mgmt_url_off]),
                    sizeof (diskLu->luMgmtUrl)) >=
                    sizeof (diskLu->luMgmtUrl)) {
                        return (STMF_STATUS_ERROR);
                }
        }

        if (sbdProps->slp_alias_valid) {
                diskLu->luAliasValid = B_TRUE;
                if (strlcpy(diskLu->luAlias,
                    (char *)&(sbdProps->slp_buf[sbdProps->slp_alias_off]),
                    sizeof (diskLu->luAlias)) >=
                    sizeof (diskLu->luAlias)) {
                        return (STMF_STATUS_ERROR);
                }
        } else { /* set alias to data filename if not set */
                if (sbdProps->slp_data_fname_valid) {
                        diskLu->luAliasValid = B_TRUE;
                        if (strlcpy(diskLu->luAlias,
                            (char *)&(sbdProps->slp_buf[
                            sbdProps->slp_data_fname_off]),
                            sizeof (diskLu->luAlias)) >=
                            sizeof (diskLu->luAlias)) {
                                return (STMF_STATUS_ERROR);
                        }
                }
        }

        diskLu->vidValid = B_TRUE;
        bcopy(sbdProps->slp_vid, diskLu->vid, sizeof (diskLu->vid));

        diskLu->pidValid = B_TRUE;
        bcopy(sbdProps->slp_pid, diskLu->pid, sizeof (diskLu->pid));

        diskLu->revValid = B_TRUE;
        bcopy(sbdProps->slp_rev, diskLu->rev, sizeof (diskLu->rev));

        diskLu->writeProtectEnableValid = B_TRUE;
        if (sbdProps->slp_write_protected) {
                diskLu->writeProtectEnable = B_TRUE;
        }

        diskLu->writebackCacheDisableValid = B_TRUE;
        if (sbdProps->slp_writeback_cache_disable_cur) {
                diskLu->writebackCacheDisable = B_TRUE;
        }

        diskLu->blkSizeValid = B_TRUE;
        diskLu->blkSize = sbdProps->slp_blksize;

        diskLu->luSizeValid = B_TRUE;
        diskLu->luSize = sbdProps->slp_lu_size;

        diskLu->accessState = sbdProps->slp_access_state;

        return (ret);
}

/*
 * stmfGetGlobalLuProp
 *
 * Purpose: get a global property for a device type
 *
 */
int
stmfGetGlobalLuProp(uint16_t dType, uint32_t prop, char *propVal,
    size_t *propLen)
{
        int ret = STMF_STATUS_SUCCESS;
        if (dType != STMF_DISK || propVal == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        ret = getDiskGlobalProp(prop, propVal, propLen);

        return (ret);
}

/*
 * getDiskGlobalProp
 *
 * Purpose: get global property from sbd driver
 *
 */
static int
getDiskGlobalProp(uint32_t prop, char *propVal, size_t *propLen)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        sbd_global_props_t *sbdProps;
        void *sbd_realloc;
        int retryCnt = 0;
        boolean_t retry;
        int ioctlRet;
        int savedErrno;
        int sbdPropsSize = sizeof (*sbdProps) + MAX_SBD_PROPS;
        stmf_iocdata_t sbdIoctl = {0};
        size_t reqLen;

        switch (prop) {
                case STMF_LU_PROP_MGMT_URL:
                        break;
                default:
                        return (STMF_ERROR_INVALID_PROP);
        }

        /*
         * Open control node for sbd
         */
        if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        sbdProps = calloc(1, sbdPropsSize);
        if (sbdProps == NULL) {
                (void) close(fd);
                return (STMF_ERROR_NOMEM);
        }

        do {
                retry = B_FALSE;
                sbdIoctl.stmf_version = STMF_VERSION_1;
                sbdIoctl.stmf_obuf_size = sbdPropsSize;
                sbdIoctl.stmf_obuf = (uint64_t)(unsigned long)sbdProps;
                ioctlRet = ioctl(fd, SBD_IOCTL_GET_GLOBAL_LU, &sbdIoctl);
                if (ioctlRet != 0) {
                        savedErrno = errno;
                        switch (savedErrno) {
                                case EBUSY:
                                        ret = STMF_ERROR_BUSY;
                                        break;
                                case EPERM:
                                case EACCES:
                                        ret = STMF_ERROR_PERM;
                                        break;
                                case ENOMEM:
                                        if (sbdIoctl.stmf_error ==
                                            SBD_RET_INSUFFICIENT_BUF_SPACE &&
                                            retryCnt++ < 3) {
                                                sbdPropsSize =
                                                    sizeof (*sbdProps) +
                                                    sbdProps->
                                                    mlu_buf_size_needed;

                                                sbd_realloc = sbdProps;
                                                sbdProps = realloc(sbdProps,
                                                    sbdPropsSize);
                                                if (sbdProps == NULL) {
                                                        free(sbd_realloc);
                                                        ret = STMF_ERROR_NOMEM;
                                                        break;
                                                }
                                                retry = B_TRUE;
                                        } else {
                                                ret = STMF_ERROR_NOMEM;
                                        }
                                        break;
                                default:
                                        syslog(LOG_DEBUG,
                                            "getDiskGlobalProp:ioctl error(%d)"
                                            "(%d)(%d)", ioctlRet,
                                            sbdIoctl.stmf_error, savedErrno);
                                        ret = STMF_STATUS_ERROR;
                                        break;
                        }

                }
        } while (retry);

        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        switch (prop) {
                case STMF_LU_PROP_MGMT_URL:
                        if (sbdProps->mlu_mgmt_url_valid == 0) {
                                ret = STMF_ERROR_NO_PROP;
                                goto done;
                        }
                        if ((reqLen = strlcpy(propVal, (char *)&(
                            sbdProps->mlu_buf[sbdProps->mlu_mgmt_url_off]),
                            *propLen)) >= *propLen) {
                                *propLen = reqLen + 1;
                                ret = STMF_ERROR_INVALID_ARG;
                                goto done;
                        }
                        break;
        }

done:
        free(sbdProps);
        (void) close(fd);
        return (ret);
}

/*
 * stmfSetGlobalLuProp
 *
 * Purpose: set a global property for a device type
 *
 */
int
stmfSetGlobalLuProp(uint16_t dType, uint32_t prop, const char *propVal)
{
        int ret = STMF_STATUS_SUCCESS;
        if (dType != STMF_DISK || propVal == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        ret = setDiskGlobalProp(prop, propVal);

        return (ret);
}

/*
 * setDiskGlobalProp
 *
 * Purpose: set properties for resource of type disk
 *
 * resourceProp - valid resource identifier
 * propVal - valid resource value
 */
static int
setDiskGlobalProp(uint32_t resourceProp, const char *propVal)
{
        int ret = STMF_STATUS_SUCCESS;
        sbd_global_props_t *sbdGlobalProps = NULL;
        int sbdGlobalPropsSize = 0;
        int propLen;
        int mluBufSize = 0;
        int fd;
        int savedErrno;
        int ioctlRet;
        stmf_iocdata_t sbdIoctl = {0};

        switch (resourceProp) {
                case STMF_LU_PROP_MGMT_URL:
                        break;
                default:
                        return (STMF_ERROR_INVALID_PROP);
        }

        /*
         * Open control node for sbd
         */
        if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        propLen = strlen(propVal);
        mluBufSize += propLen + 1;
        sbdGlobalPropsSize += sizeof (sbd_global_props_t) - 8 +
            max(8, mluBufSize);
        /*
         * 8 is the size of the buffer set aside for
         * concatenation of variable length fields
         */
        sbdGlobalProps = (sbd_global_props_t *)calloc(1, sbdGlobalPropsSize);
        if (sbdGlobalProps == NULL) {
                (void) close(fd);
                return (STMF_ERROR_NOMEM);
        }

        sbdGlobalProps->mlu_struct_size = sbdGlobalPropsSize;

        switch (resourceProp) {
                case STMF_LU_PROP_MGMT_URL:
                        sbdGlobalProps->mlu_mgmt_url_valid = 1;
                        bcopy(propVal, &(sbdGlobalProps->mlu_buf),
                            propLen + 1);
                        break;
                default:
                        ret = STMF_ERROR_NO_PROP;
                        goto done;
        }

        sbdIoctl.stmf_version = STMF_VERSION_1;
        sbdIoctl.stmf_ibuf_size = sbdGlobalProps->mlu_struct_size;
        sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)sbdGlobalProps;

        ioctlRet = ioctl(fd, SBD_IOCTL_SET_GLOBAL_LU, &sbdIoctl);
        if (ioctlRet != 0) {
                savedErrno = errno;
                switch (savedErrno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                diskError(sbdIoctl.stmf_error, &ret);
                                if (ret == STMF_STATUS_ERROR) {
                                        syslog(LOG_DEBUG,
                                        "modifyDiskLu:ioctl "
                                        "error(%d) (%d) (%d)", ioctlRet,
                                            sbdIoctl.stmf_error, savedErrno);
                                }
                                break;
                }
        }

done:
        free(sbdGlobalProps);
        (void) close(fd);
        return (ret);
}


/*
 * stmfSetLuProp
 *
 * Purpose: set a property on an luResource
 *
 * hdl - allocated luResource
 * prop - property identifier
 * propVal - property value to be set
 */
int
stmfSetLuProp(luResource hdl, uint32_t prop, const char *propVal)
{
        int ret = STMF_STATUS_SUCCESS;
        luResourceImpl *luPropsHdl = hdl;
        if (hdl == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (luPropsHdl->type == STMF_DISK) {
                ret = setDiskProp(luPropsHdl, prop, propVal);
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }

        return (ret);
}

/*
 * getDiskProp
 *
 * Purpose: retrieve a given property from a logical unit resource of type disk
 *
 * hdl - allocated luResourceImpl
 * prop - property identifier
 * propVal - pointer to character to contain the retrieved property value
 * propLen - On input this is the length of propVal. On failure, it contains the
 *           number of bytes required for propVal
 */
static int
getDiskProp(luResourceImpl *hdl, uint32_t prop, char *propVal, size_t *propLen)
{
        int ret = STMF_STATUS_SUCCESS;
        diskResource *diskLu = hdl->resource;
        char accessState[20];
        size_t reqLen;

        if (prop == STMF_LU_PROP_ACCESS_STATE) {
                if (diskLu->accessState == SBD_LU_ACTIVE) {
                        (void) strlcpy(accessState, STMF_ACCESS_ACTIVE,
                            sizeof (accessState));
                } else if (diskLu->accessState == SBD_LU_TRANSITION_TO_ACTIVE) {
                        (void) strlcpy(accessState,
                            STMF_ACCESS_STANDBY_TO_ACTIVE,
                            sizeof (accessState));
                } else if (diskLu->accessState == SBD_LU_STANDBY) {
                        (void) strlcpy(accessState, STMF_ACCESS_STANDBY,
                            sizeof (accessState));
                } else if (diskLu->accessState ==
                    SBD_LU_TRANSITION_TO_STANDBY) {
                        (void) strlcpy(accessState,
                            STMF_ACCESS_ACTIVE_TO_STANDBY,
                            sizeof (accessState));
                }
                if ((reqLen = strlcpy(propVal, accessState,
                    *propLen)) >= *propLen) {
                        *propLen = reqLen + 1;
                        return (STMF_ERROR_INVALID_ARG);
                }
                return (0);
        }

        if (diskLu->accessState != SBD_LU_ACTIVE) {
                return (STMF_ERROR_NO_PROP_STANDBY);
        }

        switch (prop) {
                case STMF_LU_PROP_BLOCK_SIZE:
                        if (diskLu->blkSizeValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        reqLen = snprintf(propVal, *propLen, "%llu",
                            (u_longlong_t)diskLu->blkSize);
                        if (reqLen >= *propLen) {
                                *propLen = reqLen + 1;
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        break;
                case STMF_LU_PROP_FILENAME:
                        if (diskLu->luDataFileNameValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if ((reqLen = strlcpy(propVal, diskLu->luDataFileName,
                            *propLen)) >= *propLen) {
                                *propLen = reqLen + 1;
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        break;
                case STMF_LU_PROP_META_FILENAME:
                        if (diskLu->luMetaFileNameValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if ((reqLen = strlcpy(propVal, diskLu->luMetaFileName,
                            *propLen)) >= *propLen) {
                                *propLen = reqLen + 1;
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        break;
                case STMF_LU_PROP_MGMT_URL:
                        if (diskLu->luMgmtUrlValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if ((reqLen = strlcpy(propVal, diskLu->luMgmtUrl,
                            *propLen)) >= *propLen) {
                                *propLen = reqLen + 1;
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        break;
                case STMF_LU_PROP_GUID:
                        if (diskLu->luGuidValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        reqLen = snprintf(propVal, *propLen,
                            "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"
                            "%02X%02X%02X%02X",
                            diskLu->luGuid[0], diskLu->luGuid[1],
                            diskLu->luGuid[2], diskLu->luGuid[3],
                            diskLu->luGuid[4], diskLu->luGuid[5],
                            diskLu->luGuid[6], diskLu->luGuid[7],
                            diskLu->luGuid[8], diskLu->luGuid[9],
                            diskLu->luGuid[10], diskLu->luGuid[11],
                            diskLu->luGuid[12], diskLu->luGuid[13],
                            diskLu->luGuid[14], diskLu->luGuid[15]);
                        if (reqLen >= *propLen) {
                                *propLen = reqLen + 1;
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        break;
                case STMF_LU_PROP_SERIAL_NUM:
                        if (diskLu->serialNumValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if ((reqLen = strlcpy(propVal, diskLu->serialNum,
                            *propLen)) >= *propLen) {
                                *propLen = reqLen + 1;
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        break;
                case STMF_LU_PROP_SIZE:
                        if (diskLu->luSizeValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        (void) snprintf(propVal, *propLen, "%llu",
                            (u_longlong_t)diskLu->luSize);
                        break;
                case STMF_LU_PROP_ALIAS:
                        if (diskLu->luAliasValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if ((reqLen = strlcpy(propVal, diskLu->luAlias,
                            *propLen)) >= *propLen) {
                                *propLen = reqLen + 1;
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        break;
                case STMF_LU_PROP_VID:
                        if (diskLu->vidValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if (*propLen <= sizeof (diskLu->vid)) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        bcopy(diskLu->vid, propVal, sizeof (diskLu->vid));
                        propVal[sizeof (diskLu->vid)] = 0;
                        break;
                case STMF_LU_PROP_PID:
                        if (diskLu->pidValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if (*propLen <= sizeof (diskLu->pid)) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        bcopy(diskLu->pid, propVal, sizeof (diskLu->pid));
                        propVal[sizeof (diskLu->pid)] = 0;
                        break;
                case STMF_LU_PROP_WRITE_PROTECT:
                        if (diskLu->writeProtectEnableValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if (diskLu->writeProtectEnable) {
                                if ((reqLen = strlcpy(propVal, "true",
                                    *propLen)) >= *propLen) {
                                        *propLen = reqLen + 1;
                                        return (STMF_ERROR_INVALID_ARG);
                                }
                        } else {
                                if ((reqLen = strlcpy(propVal, "false",
                                    *propLen)) >= *propLen) {
                                        *propLen = reqLen + 1;
                                        return (STMF_ERROR_INVALID_ARG);
                                }
                        }
                        break;
                case STMF_LU_PROP_WRITE_CACHE_DISABLE:
                        if (diskLu->writebackCacheDisableValid == B_FALSE) {
                                return (STMF_ERROR_NO_PROP);
                        }
                        if (diskLu->writebackCacheDisable) {
                                if ((reqLen = strlcpy(propVal, "true",
                                    *propLen)) >= *propLen) {
                                        *propLen = reqLen + 1;
                                        return (STMF_ERROR_INVALID_ARG);
                                }
                        } else {
                                if ((reqLen = strlcpy(propVal, "false",
                                    *propLen)) >= *propLen) {
                                        *propLen = reqLen + 1;
                                        return (STMF_ERROR_INVALID_ARG);
                                }
                        }
                        break;
                default:
                        ret = STMF_ERROR_INVALID_PROP;
                        break;
        }

        return (ret);
}

/*
 * setDiskProp
 *
 * Purpose: set properties for resource of type disk
 *
 * hdl - allocated luResourceImpl
 * resourceProp - valid resource identifier
 * propVal - valid resource value
 */
static int
setDiskProp(luResourceImpl *hdl, uint32_t resourceProp, const char *propVal)
{
        int ret = STMF_STATUS_SUCCESS;
        int i;
        diskResource *diskLu = hdl->resource;
        unsigned long long numericProp = 0;
        char guidProp[LU_ASCII_GUID_SIZE + 1];
        char ouiProp[OUI_ASCII_SIZE + 1];
        char hostIdProp[HOST_ID_ASCII_SIZE + 1];
        unsigned int oui[OUI_SIZE];
        unsigned int hostId[HOST_ID_SIZE];
        unsigned int guid[LU_GUID_SIZE];
        int propSize;


        if (propVal == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        switch (resourceProp) {
                case STMF_LU_PROP_ALIAS:
                        if (strlcpy(diskLu->luAlias, propVal,
                            sizeof (diskLu->luAlias)) >=
                            sizeof (diskLu->luAlias)) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }
                        diskLu->luAliasValid = B_TRUE;
                        break;
                case STMF_LU_PROP_BLOCK_SIZE: {
                        const char *tmp = propVal;
                        while (*tmp) {
                                if (!isdigit(*tmp++)) {
                                        return (STMF_ERROR_INVALID_ARG);
                                }
                        }
                        (void) sscanf(propVal, "%llu", &numericProp);
                        if (numericProp > UINT16_MAX) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }
                        diskLu->blkSize = numericProp;
                        diskLu->blkSizeValid = B_TRUE;
                        break;
                }
                case STMF_LU_PROP_COMPANY_ID:
                        if ((strlcpy(ouiProp, propVal, sizeof (ouiProp))) >=
                            sizeof (ouiProp)) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        if (checkHexUpper(ouiProp) != 0) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        (void) sscanf(ouiProp, "%2X%2X%2X",
                            &oui[0], &oui[1], &oui[2]);

                        diskLu->companyId = 0;
                        diskLu->companyId += oui[0] << 16;
                        diskLu->companyId += oui[1] << 8;
                        diskLu->companyId += oui[2];
                        if (diskLu->companyId == 0) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        diskLu->companyIdValid = B_TRUE;
                        break;
                case STMF_LU_PROP_HOST_ID:
                        if ((strlcpy(hostIdProp, propVal,
                            sizeof (hostIdProp))) >= sizeof (hostIdProp)) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        if (checkHexUpper(hostIdProp) != 0) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        (void) sscanf(hostIdProp, "%2X%2X%2X%2X",
                            &hostId[0], &hostId[1], &hostId[2], &hostId[3]);

                        diskLu->hostId = 0;
                        diskLu->hostId += hostId[0] << 24;
                        diskLu->hostId += hostId[1] << 16;
                        diskLu->hostId += hostId[2] << 8;
                        diskLu->hostId += hostId[3];
                        if (diskLu->hostId == 0) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        diskLu->hostIdValid = B_TRUE;
                        break;
                case STMF_LU_PROP_GUID:
                        if (strlen(propVal) != LU_ASCII_GUID_SIZE) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }

                        if ((strlcpy(guidProp, propVal, sizeof (guidProp))) >=
                            sizeof (guidProp)) {
                                return (STMF_ERROR_INVALID_ARG);
                        }

                        if (checkHexUpper(guidProp) != 0) {
                                return (STMF_ERROR_INVALID_ARG);
                        }

                        (void) sscanf(guidProp,
                            "%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X",
                            &guid[0], &guid[1], &guid[2], &guid[3], &guid[4],
                            &guid[5], &guid[6], &guid[7], &guid[8], &guid[9],
                            &guid[10], &guid[11], &guid[12], &guid[13],
                            &guid[14], &guid[15]);
                        for (i = 0; i < sizeof (diskLu->luGuid); i++) {
                                diskLu->luGuid[i] = guid[i];
                        }
                        diskLu->luGuidValid = B_TRUE;
                        break;
                case STMF_LU_PROP_FILENAME:
                        if ((strlcpy(diskLu->luDataFileName, propVal,
                            sizeof (diskLu->luDataFileName))) >=
                            sizeof (diskLu->luDataFileName)) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }
                        diskLu->luDataFileNameValid = B_TRUE;
                        break;
                case STMF_LU_PROP_META_FILENAME:
                        if ((strlcpy(diskLu->luMetaFileName, propVal,
                            sizeof (diskLu->luMetaFileName))) >=
                            sizeof (diskLu->luMetaFileName)) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }
                        diskLu->luMetaFileNameValid = B_TRUE;
                        break;
                case STMF_LU_PROP_MGMT_URL:
                        if ((strlcpy(diskLu->luMgmtUrl, propVal,
                            sizeof (diskLu->luMgmtUrl))) >=
                            sizeof (diskLu->luMgmtUrl)) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }
                        diskLu->luMgmtUrlValid = B_TRUE;
                        break;
                case STMF_LU_PROP_PID:
                        if ((propSize = strlen(propVal)) >
                            sizeof (diskLu->pid)) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }
                        (void) strncpy(diskLu->pid, propVal, propSize);
                        diskLu->pidValid = B_TRUE;
                        break;
                case STMF_LU_PROP_SERIAL_NUM:
                        if ((propSize = strlen(propVal)) >
                            (sizeof (diskLu->serialNum) - 1)) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }
                        (void) strncpy(diskLu->serialNum, propVal, propSize);
                        diskLu->serialNumValid = B_TRUE;
                        break;
                case STMF_LU_PROP_SIZE:
                        if ((niceStrToNum(propVal, &diskLu->luSize) != 0)) {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        diskLu->luSizeValid = B_TRUE;
                        break;
                case STMF_LU_PROP_VID:
                        if ((propSize = strlen(propVal)) >
                            sizeof (diskLu->vid)) {
                                return (STMF_ERROR_INVALID_PROPSIZE);
                        }
                        (void) strncpy(diskLu->vid, propVal, propSize);
                        diskLu->vidValid = B_TRUE;
                        break;
                case STMF_LU_PROP_WRITE_PROTECT:
                        if (strcasecmp(propVal, "TRUE") == 0) {
                                diskLu->writeProtectEnable = B_TRUE;
                        } else if (strcasecmp(propVal, "FALSE") == 0) {
                                diskLu->writeProtectEnable = B_FALSE;
                        } else {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        diskLu->writeProtectEnableValid = B_TRUE;
                        break;
                case STMF_LU_PROP_WRITE_CACHE_DISABLE:
                        if (strcasecmp(propVal, "TRUE") == 0) {
                                diskLu->writebackCacheDisable = B_TRUE;
                        } else if (strcasecmp(propVal, "FALSE") == 0) {
                                diskLu->writebackCacheDisable = B_FALSE;
                        } else {
                                return (STMF_ERROR_INVALID_ARG);
                        }
                        diskLu->writebackCacheDisableValid = B_TRUE;
                        break;
                case STMF_LU_PROP_ACCESS_STATE:
                        ret = STMF_ERROR_INVALID_PROP;
                        break;
                default:
                        ret = STMF_ERROR_INVALID_PROP;
                        break;
        }
        return (ret);
}

static int
checkHexUpper(char *buf)
{
        int i;

        for (i = 0; i < strlen(buf); i++) {
                if (isxdigit(buf[i])) {
                        buf[i] = toupper(buf[i]);
                        continue;
                }
                return (-1);
        }

        return (0);
}

/*
 * Given a numeric suffix, convert the value into a number of bits that the
 * resulting value must be shifted.
 * Code lifted from libzfs_util.c
 */
static int
strToShift(const char *buf)
{
        const char *ends = "BKMGTPE";
        int i;

        if (buf[0] == '\0')
                return (0);

        for (i = 0; i < strlen(ends); i++) {
                if (toupper(buf[0]) == ends[i])
                        return (10*i);
        }

        return (-1);
}

int
stmfFreeLuResource(luResource hdl)
{
        int ret = STMF_STATUS_SUCCESS;
        if (hdl == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        luResourceImpl *hdlImpl = hdl;
        free(hdlImpl->resource);
        free(hdlImpl);
        return (ret);
}

/*
 * Convert a string of the form '100G' into a real number. Used when setting
 * the size of a logical unit.
 * Code lifted from libzfs_util.c
 */
static int
niceStrToNum(const char *value, uint64_t *num)
{
        char *end;
        int shift;

        *num = 0;

        /* Check to see if this looks like a number.  */
        if ((value[0] < '0' || value[0] > '9') && value[0] != '.') {
                return (-1);
        }

        /* Rely on stroull() to process the numeric portion.  */
        errno = 0;
        *num = strtoull(value, &end, 10);

        /*
         * Check for ERANGE, which indicates that the value is too large to fit
         * in a 64-bit value.
         */
        if (errno == ERANGE) {
                return (-1);
        }

        /*
         * If we have a decimal value, then do the computation with floating
         * point arithmetic.  Otherwise, use standard arithmetic.
         */
        if (*end == '.') {
                double fval = strtod(value, &end);

                if ((shift = strToShift(end)) == -1) {
                        return (-1);
                }

                fval *= pow(2, shift);

                if (fval > UINT64_MAX) {
                        return (-1);
                }

                *num = (uint64_t)fval;
        } else {
                if ((shift = strToShift(end)) == -1) {
                        return (-1);
                }

                /* Check for overflow */
                if (shift >= 64 || (*num << shift) >> shift != *num) {
                        return (-1);
                }

                *num <<= shift;
        }

        return (0);
}

/*
 * stmfCreateTargetGroup
 *
 * Purpose: Create a local port group
 *
 * targetGroupName - name of local port group to create
 */
int
stmfCreateTargetGroup(stmfGroupName *targetGroupName)
{
        int ret;
        int fd;

        if (targetGroupName == NULL ||
            (strnlen((char *)targetGroupName, sizeof (stmfGroupName))
            == sizeof (stmfGroupName))) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* Check to ensure service exists */
        if (psCheckService() != STMF_STATUS_SUCCESS) {
                return (STMF_ERROR_SERVICE_NOT_FOUND);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Add the group to the driver
         */
        if ((ret = groupIoctl(fd, STMF_IOCTL_CREATE_TARGET_GROUP,
            targetGroupName)) != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        /*
         * If the add to the driver was successful, add it to the persistent
         * store.
         */
        ret = psCreateTargetGroup((char *)targetGroupName);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_EXISTS:
                        ret = STMF_ERROR_EXISTS;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfCreateTargetGroup:psCreateTargetGroup"
                            ":error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfDeleteHostGroup
 *
 * Purpose: Delete an initiator or local port group
 *
 * hostGroupName - group to delete
 */
int
stmfDeleteHostGroup(stmfGroupName *hostGroupName)
{
        int ret;
        int fd;

        if (hostGroupName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* Check to ensure service exists */
        if (psCheckService() != STMF_STATUS_SUCCESS) {
                return (STMF_ERROR_SERVICE_NOT_FOUND);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Remove the group from the driver
         */
        if ((ret = groupIoctl(fd, STMF_IOCTL_REMOVE_HOST_GROUP,
            hostGroupName)) != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        /*
         * If the remove from the driver was successful, remove it from the
         * persistent store.
         */
        ret = psDeleteHostGroup((char *)hostGroupName);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfDeleteHostGroup:psDeleteHostGroup:error(%d)",
                            ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfDeleteTargetGroup
 *
 * Purpose: Delete an initiator or local port group
 *
 * targetGroupName - group to delete
 */
int
stmfDeleteTargetGroup(stmfGroupName *targetGroupName)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;

        if (targetGroupName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* Check to ensure service exists */
        if (psCheckService() != STMF_STATUS_SUCCESS) {
                return (STMF_ERROR_SERVICE_NOT_FOUND);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Remove the group from the driver
         */
        if ((ret = groupIoctl(fd, STMF_IOCTL_REMOVE_TARGET_GROUP,
            targetGroupName)) != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        /*
         * If the remove from the driver was successful, remove it from the
         * persistent store.
         */
        ret = psDeleteTargetGroup((char *)targetGroupName);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfDeleteTargetGroup:psDeleteTargetGroup"
                            ":error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfDevidFromIscsiName
 *
 * Purpose: convert an iSCSI name to an stmf devid
 *
 * iscsiName - unicode nul terminated utf-8 encoded iSCSI name
 * devid - on success, contains the converted iscsi name
 */
int
stmfDevidFromIscsiName(char *iscsiName, stmfDevid *devid)
{
        if (devid == NULL || iscsiName == NULL)
                return (STMF_ERROR_INVALID_ARG);

        bzero(devid, sizeof (stmfDevid));

        /* Validate size of target */
        if ((devid->identLength = strlen(iscsiName)) > MAX_ISCSI_NAME ||
            devid->identLength < strlen(EUI) ||
            devid->identLength < strlen(IQN)) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if ((strncmp(iscsiName, EUI, strlen(EUI)) != 0) &&
            strncmp(iscsiName, IQN, strlen(IQN)) != 0) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* copy UTF-8 bytes to ident */
        bcopy(iscsiName, devid->ident, devid->identLength);

        return (STMF_STATUS_SUCCESS);
}

/*
 * stmfDevidFromWwn
 *
 * Purpose: convert a WWN to an stmf devid
 *
 * wwn - 8-byte wwn identifier
 * devid - on success, contains the converted wwn
 */
int
stmfDevidFromWwn(uchar_t wwn[8], stmfDevid *devid)
{
        if (wwn == NULL || devid == NULL)
                return (STMF_ERROR_INVALID_ARG);

        bzero(devid, sizeof (stmfDevid));

        /* Copy eui prefix */
        (void) bcopy(WWN, devid->ident, strlen(WWN));

        /* Convert to ASCII uppercase hexadecimal string */
        (void) snprintf((char *)&devid->ident[strlen(WWN)],
            sizeof (devid->ident), "%02X%02X%02X%02X%02X%02X%02X%02X",
            wwn[0], wwn[1], wwn[2], wwn[3], wwn[4], wwn[5], wwn[6], wwn[7]);

        devid->identLength = strlen((char *)devid->ident);

        return (STMF_STATUS_SUCCESS);
}

/*
 * stmfFreeMemory
 *
 * Purpose: Free memory allocated by this library
 *
 * memory - previously allocated pointer of memory managed by library
 */
void
stmfFreeMemory(void *memory)
{
        free(memory);
}

/*
 * get host group, target group list from stmf
 *
 * groupType - HOST_GROUP, TARGET_GROUP
 */
static int
groupListIoctl(stmfGroupList **groupList, int groupType)
{
        int ret;
        int fd;
        int ioctlRet;
        int i;
        int cmd;
        stmf_iocdata_t stmfIoctl;
        /* framework group list */
        stmf_group_name_t *iGroupList = NULL;
        uint32_t groupListSize;

        if (groupList == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (groupType == HOST_GROUP) {
                cmd = STMF_IOCTL_GET_HG_LIST;
        } else if (groupType == TARGET_GROUP) {
                cmd = STMF_IOCTL_GET_TG_LIST;
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Allocate ioctl input buffer
         */
        groupListSize = ALLOC_GROUP;
        groupListSize = groupListSize * (sizeof (stmf_group_name_t));
        iGroupList = (stmf_group_name_t *)calloc(1, groupListSize);
        if (iGroupList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to get the group list
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_obuf_size = groupListSize;
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)iGroupList;
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "groupListIoctl:ioctl errno(%d)",
                                    errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }
        /*
         * Check whether input buffer was large enough
         */
        if (stmfIoctl.stmf_obuf_max_nentries > ALLOC_GROUP) {
                groupListSize = stmfIoctl.stmf_obuf_max_nentries *
                    sizeof (stmf_group_name_t);
                iGroupList = realloc(iGroupList, groupListSize);
                if (iGroupList == NULL) {
                        ret = STMF_ERROR_NOMEM;
                        goto done;
                }
                stmfIoctl.stmf_obuf_size = groupListSize;
                stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)iGroupList;
                ioctlRet = ioctl(fd, cmd, &stmfIoctl);
                if (ioctlRet != 0) {
                        switch (errno) {
                                case EBUSY:
                                        ret = STMF_ERROR_BUSY;
                                        break;
                                case EPERM:
                                case EACCES:
                                        ret = STMF_ERROR_PERM;
                                        break;
                                default:
                                        syslog(LOG_DEBUG,
                                            "groupListIoctl:ioctl errno(%d)",
                                            errno);
                                        ret = STMF_STATUS_ERROR;
                                        break;
                        }
                        goto done;
                }
        }

        /* allocate and copy to caller's buffer */
        *groupList = (stmfGroupList *)calloc(1, sizeof (stmfGroupList) +
            sizeof (stmfGroupName) * stmfIoctl.stmf_obuf_nentries);
        if (*groupList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }
        (*groupList)->cnt = stmfIoctl.stmf_obuf_nentries;
        for (i = 0; i < stmfIoctl.stmf_obuf_nentries; i++) {
                bcopy(iGroupList[i].name, (*groupList)->name[i],
                    sizeof (stmfGroupName));
        }

done:
        free(iGroupList);
        (void) close(fd);
        return (ret);
}

/*
 * get host group members, target group members from stmf
 *
 * groupProps - allocated on success
 *
 * groupType - HOST_GROUP, TARGET_GROUP
 */
static int
groupMemberListIoctl(stmfGroupName *groupName, stmfGroupProperties **groupProps,
    int groupType)
{
        int ret;
        int fd;
        int ioctlRet;
        int i;
        int cmd;
        stmf_iocdata_t stmfIoctl;
        /* framework group list */
        stmf_group_name_t iGroupName;
        stmf_ge_ident_t *iGroupMembers;
        uint32_t groupListSize;

        if (groupName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (groupType == HOST_GROUP) {
                cmd = STMF_IOCTL_GET_HG_ENTRIES;
        } else if (groupType == TARGET_GROUP) {
                cmd = STMF_IOCTL_GET_TG_ENTRIES;
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        bzero(&iGroupName, sizeof (iGroupName));

        bcopy(groupName, &iGroupName.name, strlen((char *)groupName));

        iGroupName.name_size = strlen((char *)groupName);

        /*
         * Allocate ioctl input buffer
         */
        groupListSize = ALLOC_GRP_MEMBER;
        groupListSize = groupListSize * (sizeof (stmf_ge_ident_t));
        iGroupMembers = (stmf_ge_ident_t *)calloc(1, groupListSize);
        if (iGroupMembers == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to get the group list
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&iGroupName;
        stmfIoctl.stmf_ibuf_size = sizeof (stmf_group_name_t);
        stmfIoctl.stmf_obuf_size = groupListSize;
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)iGroupMembers;
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "groupListIoctl:ioctl errno(%d)",
                                    errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }
        /*
         * Check whether input buffer was large enough
         */
        if (stmfIoctl.stmf_obuf_max_nentries > ALLOC_GRP_MEMBER) {
                groupListSize = stmfIoctl.stmf_obuf_max_nentries *
                    sizeof (stmf_ge_ident_t);
                iGroupMembers = realloc(iGroupMembers, groupListSize);
                if (iGroupMembers == NULL) {
                        ret = STMF_ERROR_NOMEM;
                        goto done;
                }
                stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&iGroupName;
                stmfIoctl.stmf_ibuf_size = sizeof (stmf_group_name_t);
                stmfIoctl.stmf_obuf_size = groupListSize;
                stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)iGroupMembers;
                ioctlRet = ioctl(fd, cmd, &stmfIoctl);
                if (ioctlRet != 0) {
                        switch (errno) {
                                case EBUSY:
                                        ret = STMF_ERROR_BUSY;
                                        break;
                                case EPERM:
                                case EACCES:
                                        ret = STMF_ERROR_PERM;
                                        break;
                                default:
                                        syslog(LOG_DEBUG,
                                            "groupListIoctl:ioctl errno(%d)",
                                            errno);
                                        ret = STMF_STATUS_ERROR;
                                        break;
                        }
                        goto done;
                }
        }

        /* allocate and copy to caller's buffer */
        *groupProps = (stmfGroupProperties *)calloc(1,
            sizeof (stmfGroupProperties) +
            sizeof (stmfDevid) * stmfIoctl.stmf_obuf_nentries);
        if (*groupProps == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }
        (*groupProps)->cnt = stmfIoctl.stmf_obuf_nentries;
        for (i = 0; i < stmfIoctl.stmf_obuf_nentries; i++) {
                (*groupProps)->name[i].identLength =
                    iGroupMembers[i].ident_size;
                bcopy(iGroupMembers[i].ident, (*groupProps)->name[i].ident,
                    iGroupMembers[i].ident_size);
        }

done:
        free(iGroupMembers);
        (void) close(fd);
        return (ret);
}

/*
 * Purpose: access persistent config data for host groups and target groups
 */
static int
iLoadGroupFromPs(stmfGroupList **groupList, int type)
{
        int ret;

        if (groupList == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (type == HOST_GROUP) {
                ret = psGetHostGroupList(groupList);
        } else if (type == TARGET_GROUP) {
                ret = psGetTargetGroupList(groupList);
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfGetHostGroupList:psGetHostGroupList:error(%d)",
                            ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

        return (ret);
}

/*
 * stmfGetHostGroupList
 *
 * Purpose: Retrieves the list of initiator group oids
 *
 * hostGroupList - pointer to pointer to hostGroupList structure
 *                 on success, this contains the host group list.
 */
int
stmfGetHostGroupList(stmfGroupList **hostGroupList)
{
        int ret = STMF_STATUS_ERROR;

        if (hostGroupList == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        ret = groupListIoctl(hostGroupList, HOST_GROUP);
        return (ret);
}


/*
 * Purpose: access persistent config data for host groups and target groups
 */
static int
iLoadGroupMembersFromPs(stmfGroupName *groupName,
    stmfGroupProperties **groupProp, int type)
{
        int ret;

        if (groupName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (type == HOST_GROUP) {
                ret = psGetHostGroupMemberList((char *)groupName, groupProp);
        } else if (type == TARGET_GROUP) {
                ret = psGetTargetGroupMemberList((char *)groupName, groupProp);
        } else {
                return (STMF_ERROR_INVALID_ARG);
        }
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "iLoadGroupMembersFromPs:psGetHostGroupList:"
                            "error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

        return (ret);
}

/*
 * stmfGetHostGroupMembers
 *
 * Purpose: Retrieves the group properties for a host group
 *
 * groupName - name of group for which to retrieve host group members.
 * groupProp - pointer to pointer to stmfGroupProperties structure
 *             on success, this contains the list of group members.
 */
int
stmfGetHostGroupMembers(stmfGroupName *groupName,
    stmfGroupProperties **groupProp)
{
        int ret;

        if (groupName == NULL || groupProp == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        ret = groupMemberListIoctl(groupName, groupProp, HOST_GROUP);

        return (ret);
}

/*
 * stmfGetProviderData
 *
 * Purpose: Get provider data list
 *
 * providerName - name of provider for which to retrieve the data
 * nvl - pointer to nvlist_t pointer which will contain the nvlist data
 *       retrieved.
 * providerType - type of provider for which to retrieve data.
 *                  STMF_LU_PROVIDER_TYPE
 *                  STMF_PORT_PROVIDER_TYPE
 */
int
stmfGetProviderData(char *providerName, nvlist_t **nvl, int providerType)
{
        return (stmfGetProviderDataProt(providerName, nvl, providerType,
            NULL));
}

/*
 * stmfGetProviderDataProt
 *
 * Purpose: Get provider data list with token
 *
 * providerName - name of provider for which to retrieve the data
 * nvl - pointer to nvlist_t pointer which will contain the nvlist data
 *       retrieved.
 * providerType - type of provider for which to retrieve data.
 *                  STMF_LU_PROVIDER_TYPE
 *                  STMF_PORT_PROVIDER_TYPE
 * setToken - Returns the stale data token
 */
int
stmfGetProviderDataProt(char *providerName, nvlist_t **nvl, int providerType,
    uint64_t *setToken)
{
        int ret;

        if (providerName == NULL || nvl == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }
        if (providerType != STMF_LU_PROVIDER_TYPE &&
            providerType != STMF_PORT_PROVIDER_TYPE) {
                return (STMF_ERROR_INVALID_ARG);
        }
        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }
        return (getProviderData(providerName, nvl, providerType, setToken));
}

/*
 * stmfGetProviderDataList
 *
 * Purpose: Get the list of providers currently persisting data
 *
 * providerList - pointer to pointer to an stmfProviderList structure allocated
 *                by the caller. Will contain the list of providers on success.
 */
int
stmfGetProviderDataList(stmfProviderList **providerList)
{
        int ret;

        ret = psGetProviderDataList(providerList);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfGetProviderDataList:psGetProviderDataList"
                            ":error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

        return (ret);
}


/*
 * stmfGetSessionList
 *
 * Purpose: Retrieves the session list for a target (devid)
 *
 * devid - devid of target for which to retrieve session information.
 * sessionList - pointer to pointer to stmfSessionList structure
 *             on success, this contains the list of initiator sessions.
 */
int
stmfGetSessionList(stmfDevid *devid, stmfSessionList **sessionList)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        int ioctlRet;
        int cmd = STMF_IOCTL_SESSION_LIST;
        int i;
        stmf_iocdata_t stmfIoctl;
        slist_scsi_session_t *fSessionList, *fSessionListP = NULL;
        uint8_t ident[260];
        uint32_t fSessionListSize;

        if (sessionList == NULL || devid == NULL) {
                ret = STMF_ERROR_INVALID_ARG;
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Allocate ioctl input buffer
         */
        fSessionListSize = ALLOC_SESSION;
        fSessionListSize = fSessionListSize * (sizeof (slist_scsi_session_t));
        fSessionList = (slist_scsi_session_t *)calloc(1, fSessionListSize);
        fSessionListP = fSessionList;
        if (fSessionList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        ident[IDENT_LENGTH_BYTE] = devid->identLength;
        bcopy(&(devid->ident), &ident[IDENT_LENGTH_BYTE + 1],
            devid->identLength);

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to get the session list
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&ident;
        stmfIoctl.stmf_ibuf_size = sizeof (ident);
        stmfIoctl.stmf_obuf_size = fSessionListSize;
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)fSessionList;
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "stmfGetSessionList:ioctl errno(%d)",
                                    errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }
        /*
         * Check whether input buffer was large enough
         */
        if (stmfIoctl.stmf_obuf_max_nentries > ALLOC_SESSION) {
                fSessionListSize = stmfIoctl.stmf_obuf_max_nentries *
                    sizeof (slist_scsi_session_t);
                fSessionList = realloc(fSessionList, fSessionListSize);
                if (fSessionList == NULL) {
                        ret = STMF_ERROR_NOMEM;
                        goto done;
                }
                fSessionListP = fSessionList;
                stmfIoctl.stmf_obuf_size = fSessionListSize;
                stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)fSessionList;
                ioctlRet = ioctl(fd, cmd, &stmfIoctl);
                if (ioctlRet != 0) {
                        switch (errno) {
                                case EBUSY:
                                        ret = STMF_ERROR_BUSY;
                                        break;
                                case EPERM:
                                case EACCES:
                                        ret = STMF_ERROR_PERM;
                                        break;
                                default:
                                        syslog(LOG_DEBUG,
                                            "stmfGetSessionList:ioctl "
                                            "errno(%d)", errno);
                                        ret = STMF_STATUS_ERROR;
                                        break;
                        }
                        goto done;
                }
        }

        /*
         * allocate caller's buffer with the final size
         */
        *sessionList = (stmfSessionList *)calloc(1, sizeof (stmfSessionList) +
            stmfIoctl.stmf_obuf_max_nentries * sizeof (stmfSession));
        if (*sessionList == NULL) {
                ret = STMF_ERROR_NOMEM;
                free(sessionList);
                goto done;
        }

        (*sessionList)->cnt = stmfIoctl.stmf_obuf_max_nentries;

        /*
         * copy session info to caller's buffer
         */
        for (i = 0; i < (*sessionList)->cnt; i++) {
                (*sessionList)->session[i].initiator.identLength =
                    fSessionList->initiator[IDENT_LENGTH_BYTE];
                bcopy(&(fSessionList->initiator[IDENT_LENGTH_BYTE + 1]),
                    (*sessionList)->session[i].initiator.ident,
                    STMF_IDENT_LENGTH);
                bcopy(&(fSessionList->alias),
                    &((*sessionList)->session[i].alias),
                    sizeof ((*sessionList)->session[i].alias));
                bcopy(&(fSessionList++->creation_time),
                    &((*sessionList)->session[i].creationTime),
                    sizeof (time_t));
        }
done:
        (void) close(fd);
        free(fSessionListP);
        return (ret);
}

/*
 * stmfGetTargetGroupList
 *
 * Purpose: Retrieves the list of target groups
 *
 * targetGroupList - pointer to a pointer to an stmfGroupList structure. On
 *                   success, it contains the list of target groups.
 */
int
stmfGetTargetGroupList(stmfGroupList **targetGroupList)
{
        int ret;

        if (targetGroupList == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        ret = groupListIoctl(targetGroupList, TARGET_GROUP);
        return (ret);
}

/*
 * stmfGetTargetGroupMembers
 *
 * Purpose: Retrieves the group members for a target group
 *
 * groupName - name of target group for which to retrieve members.
 * groupProp - pointer to pointer to stmfGroupProperties structure
 *             on success, this contains the list of group members.
 */
int
stmfGetTargetGroupMembers(stmfGroupName *groupName,
    stmfGroupProperties **groupProp)
{
        int ret;

        if (groupName == NULL || groupProp == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        ret = groupMemberListIoctl(groupName, groupProp, TARGET_GROUP);

        return (ret);
}

/*
 * stmfGetTargetList
 *
 * Purpose: Retrieves the list of target ports
 *
 * targetList - pointer to a pointer to an stmfDevidList structure.
 *                  On success, it contains the list of local ports (target).
 */
int
stmfGetTargetList(stmfDevidList **targetList)
{
        int ret;
        int fd;
        int ioctlRet;
        int i;
        stmf_iocdata_t stmfIoctl;
        /* framework target port list */
        slist_target_port_t *fTargetList, *fTargetListP = NULL;
        uint32_t fTargetListSize;

        if (targetList == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Allocate ioctl input buffer
         */
        fTargetListSize = ALLOC_TARGET_PORT * sizeof (slist_target_port_t);
        fTargetListP = fTargetList =
            (slist_target_port_t *)calloc(1, fTargetListSize);
        if (fTargetList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to retrieve target list
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_obuf_size = fTargetListSize;
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)fTargetList;
        ioctlRet = ioctl(fd, STMF_IOCTL_TARGET_PORT_LIST, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "stmfGetTargetList:ioctl errno(%d)", errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }
        /*
         * Check whether input buffer was large enough
         */
        if (stmfIoctl.stmf_obuf_max_nentries > ALLOC_TARGET_PORT) {
                fTargetListSize = stmfIoctl.stmf_obuf_max_nentries *
                    sizeof (slist_target_port_t);
                fTargetListP = fTargetList =
                    realloc(fTargetList, fTargetListSize);
                if (fTargetList == NULL) {
                        ret = STMF_ERROR_NOMEM;
                        goto done;
                }
                stmfIoctl.stmf_obuf_size = fTargetListSize;
                stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)fTargetList;
                ioctlRet = ioctl(fd, STMF_IOCTL_TARGET_PORT_LIST,
                    &stmfIoctl);
                if (ioctlRet != 0) {
                        switch (errno) {
                                case EBUSY:
                                        ret = STMF_ERROR_BUSY;
                                        break;
                                case EPERM:
                                case EACCES:
                                        ret = STMF_ERROR_PERM;
                                        break;
                                default:
                                        syslog(LOG_DEBUG,
                                            "stmfGetTargetList:ioctl errno(%d)",
                                            errno);
                                        ret = STMF_STATUS_ERROR;
                                        break;
                        }
                        goto done;
                }
        }

        *targetList = (stmfDevidList *)calloc(1,
            stmfIoctl.stmf_obuf_max_nentries * sizeof (stmfDevid) +
            sizeof (stmfDevidList));
        if (*targetList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        (*targetList)->cnt = stmfIoctl.stmf_obuf_max_nentries;
        for (i = 0; i < stmfIoctl.stmf_obuf_max_nentries; i++, fTargetList++) {
                (*targetList)->devid[i].identLength =
                    fTargetList->target[IDENT_LENGTH_BYTE];
                bcopy(&fTargetList->target[IDENT_LENGTH_BYTE + 1],
                    &(*targetList)->devid[i].ident,
                    fTargetList->target[IDENT_LENGTH_BYTE]);
        }

done:
        (void) close(fd);
        free(fTargetListP);
        return (ret);
}

/*
 * stmfGetTargetProperties
 *
 * Purpose:  Retrieves the properties for a logical unit
 *
 * devid - devid of the target for which to retrieve properties
 * targetProps - pointer to an stmfTargetProperties structure.
 *              On success, it contains the target properties for
 *              the specified devid.
 */
int
stmfGetTargetProperties(stmfDevid *devid, stmfTargetProperties *targetProps)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        int ioctlRet;
        stmf_iocdata_t stmfIoctl;
        sioc_target_port_props_t targetProperties;
        scsi_devid_desc_t *scsiDevid;

        if (devid == NULL || targetProps == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        targetProperties.tgt_id[IDENT_LENGTH_BYTE] = devid->identLength;
        bcopy(&(devid->ident), &targetProperties.tgt_id[IDENT_LENGTH_BYTE + 1],
            devid->identLength);

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to add to the host group
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (targetProperties.tgt_id);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&targetProperties.tgt_id;
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)&targetProperties;
        stmfIoctl.stmf_obuf_size = sizeof (targetProperties);
        ioctlRet = ioctl(fd, STMF_IOCTL_GET_TARGET_PORT_PROPERTIES,
            &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        case ENOENT:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "stmfGetTargetProperties:ioctl errno(%d)",
                                    errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }

        bcopy(targetProperties.tgt_provider_name, targetProps->providerName,
            sizeof (targetProperties.tgt_provider_name));
        if (targetProperties.tgt_state == STMF_STATE_ONLINE) {
                targetProps->status = STMF_TARGET_PORT_ONLINE;
        } else if (targetProperties.tgt_state == STMF_STATE_OFFLINE) {
                targetProps->status = STMF_TARGET_PORT_OFFLINE;
        } else if (targetProperties.tgt_state == STMF_STATE_ONLINING) {
                targetProps->status = STMF_TARGET_PORT_ONLINING;
        } else if (targetProperties.tgt_state == STMF_STATE_OFFLINING) {
                targetProps->status = STMF_TARGET_PORT_OFFLINING;
        }
        bcopy(targetProperties.tgt_alias, targetProps->alias,
            sizeof (targetProps->alias));

        scsiDevid = (scsi_devid_desc_t *)&targetProperties.tgt_id;
        targetProps->protocol = scsiDevid->protocol_id;

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfGetLogicalUnitList
 *
 * Purpose: Retrieves list of logical unit Object IDs
 *
 * luList - pointer to a pointer to a stmfGuidList structure. On success,
 *          it contains the list of logical unit guids.
 *
 */
int
stmfGetLogicalUnitList(stmfGuidList **luList)
{
        int ret;
        int fd;
        int ioctlRet;
        int cmd = STMF_IOCTL_LU_LIST;
        int i;
        stmf_iocdata_t stmfIoctl;
        slist_lu_t *fLuList;
        uint32_t fLuListSize;
        uint32_t listCnt;

        if (luList == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Allocate ioctl input buffer
         */
        fLuListSize = ALLOC_LU;
        fLuListSize = fLuListSize * (sizeof (slist_lu_t));
        fLuList = (slist_lu_t *)calloc(1, fLuListSize);
        if (fLuList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to get the LU list
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_obuf_size = fLuListSize;
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)fLuList;
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "stmfGetLogicalUnitList:ioctl errno(%d)",
                                    errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }
        /*
         * Check whether input buffer was large enough
         */
        if (stmfIoctl.stmf_obuf_max_nentries > ALLOC_LU) {
                fLuListSize = stmfIoctl.stmf_obuf_max_nentries *
                    sizeof (slist_lu_t);
                free(fLuList);
                fLuList = (slist_lu_t *)calloc(1, fLuListSize);
                if (fLuList == NULL) {
                        ret = STMF_ERROR_NOMEM;
                        goto done;
                }
                stmfIoctl.stmf_obuf_size = fLuListSize;
                stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)fLuList;
                ioctlRet = ioctl(fd, cmd, &stmfIoctl);
                if (ioctlRet != 0) {
                        switch (errno) {
                                case EBUSY:
                                        ret = STMF_ERROR_BUSY;
                                        break;
                                case EPERM:
                                case EACCES:
                                        ret = STMF_ERROR_PERM;
                                        break;
                                default:
                                        syslog(LOG_DEBUG,
                                            "stmfGetLogicalUnitList:"
                                            "ioctl errno(%d)", errno);
                                        ret = STMF_STATUS_ERROR;
                                        break;
                        }
                        goto done;
                }
        }

        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        listCnt = stmfIoctl.stmf_obuf_nentries;

        /*
         * allocate caller's buffer with the final size
         */
        *luList = (stmfGuidList *)calloc(1, sizeof (stmfGuidList) +
            listCnt * sizeof (stmfGuid));
        if (*luList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        (*luList)->cnt = listCnt;

        /* copy to caller's buffer */
        for (i = 0; i < listCnt; i++) {
                bcopy(&fLuList[i].lu_guid, (*luList)->guid[i].guid,
                    sizeof (stmfGuid));
        }

        /*
         * sort the list. This gives a consistent view across gets
         */
        qsort((void *)&((*luList)->guid[0]), (*luList)->cnt,
            sizeof (stmfGuid), guidCompare);

done:
        (void) close(fd);
        /*
         * free internal buffers
         */
        free(fLuList);
        return (ret);
}

/*
 * stmfGetLogicalUnitProperties
 *
 * Purpose:  Retrieves the properties for a logical unit
 *
 * lu - guid of the logical unit for which to retrieve properties
 * stmfLuProps - pointer to an stmfLogicalUnitProperties structure. On success,
 *               it contains the logical unit properties for the specified guid.
 */
int
stmfGetLogicalUnitProperties(stmfGuid *lu, stmfLogicalUnitProperties *luProps)
{
        int ret = STMF_STATUS_SUCCESS;
        int stmfRet;
        int fd;
        int ioctlRet;
        int cmd = STMF_IOCTL_GET_LU_PROPERTIES;
        stmfViewEntryList *viewEntryList = NULL;
        stmf_iocdata_t stmfIoctl;
        sioc_lu_props_t fLuProps;

        if (lu == NULL || luProps == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        bzero(luProps, sizeof (stmfLogicalUnitProperties));

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to add to the host group
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (stmfGuid);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)lu;
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)&fLuProps;
        stmfIoctl.stmf_obuf_size = sizeof (fLuProps);
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        case ENOENT:
                                stmfRet = stmfGetViewEntryList(lu,
                                    &viewEntryList);
                                if (stmfRet == STMF_STATUS_SUCCESS) {
                                        luProps->status =
                                            STMF_LOGICAL_UNIT_UNREGISTERED;
                                        if (viewEntryList->cnt > 0) {
                                                ret = STMF_STATUS_SUCCESS;
                                        } else {
                                                ret = STMF_ERROR_NOT_FOUND;
                                        }
                                } else {
                                        ret = STMF_ERROR_NOT_FOUND;
                                }
                                stmfFreeMemory(viewEntryList);
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "stmfGetLogicalUnit:ioctl errno(%d)",
                                    errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }

        bcopy(fLuProps.lu_provider_name, luProps->providerName,
            sizeof (fLuProps.lu_provider_name));
        if (fLuProps.lu_state == STMF_STATE_ONLINE) {
                luProps->status = STMF_LOGICAL_UNIT_ONLINE;
        } else if (fLuProps.lu_state == STMF_STATE_OFFLINE) {
                luProps->status = STMF_LOGICAL_UNIT_OFFLINE;
        } else if (fLuProps.lu_state == STMF_STATE_ONLINING) {
                luProps->status = STMF_LOGICAL_UNIT_ONLINING;
        } else if (fLuProps.lu_state == STMF_STATE_OFFLINING) {
                luProps->status = STMF_LOGICAL_UNIT_OFFLINING;
        }
        bcopy(fLuProps.lu_alias, luProps->alias, sizeof (luProps->alias));
done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfGetState
 *
 * Purpose: retrieve the current state of the stmf module
 *
 * state - pointer to stmfState structure allocated by the caller
 *         On success, contains the state of stmf
 */
int
stmfGetState(stmfState *state)
{
        int ret;
        stmf_state_desc_t iState;

        if (state == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        ret = getStmfState(&iState);
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }
        switch (iState.state) {
                case STMF_STATE_ONLINE:
                        state->operationalState =
                            STMF_SERVICE_STATE_ONLINE;
                        break;
                case STMF_STATE_OFFLINE:
                        state->operationalState =
                            STMF_SERVICE_STATE_OFFLINE;
                        break;
                case STMF_STATE_ONLINING:
                        state->operationalState =
                            STMF_SERVICE_STATE_ONLINING;
                        break;
                case STMF_STATE_OFFLINING:
                        state->operationalState =
                            STMF_SERVICE_STATE_OFFLINING;
                        break;
                default:
                        state->operationalState =
                            STMF_SERVICE_STATE_UNKNOWN;
                        break;
        }
        switch (iState.config_state) {
                case STMF_CONFIG_NONE:
                        state->configState = STMF_CONFIG_STATE_NONE;
                        break;
                case STMF_CONFIG_INIT:
                        state->configState = STMF_CONFIG_STATE_INIT;
                        break;
                case STMF_CONFIG_INIT_DONE:
                        state->configState =
                            STMF_CONFIG_STATE_INIT_DONE;
                        break;
                default:
                        state->configState =
                            STMF_CONFIG_STATE_UNKNOWN;
                        break;
        }
        return (STMF_STATUS_SUCCESS);
}

/*
 * stmfGetViewEntryList
 *
 * Purpose: Retrieves the list of view entries for the specified
 *          logical unit.
 *
 * lu - the guid of the logical unit for which to retrieve the view entry list
 * viewEntryList - a pointer to a pointer to a stmfViewEntryList structure. On
 *                 success, contains the list of view entries.
 */
int
stmfGetViewEntryList(stmfGuid *lu, stmfViewEntryList **viewEntryList)
{
        int ret;
        int fd;
        int ioctlRet;
        int cmd = STMF_IOCTL_LU_VE_LIST;
        int i;
        stmf_iocdata_t stmfIoctl;
        stmf_view_op_entry_t *fVeList;
        uint32_t fVeListSize;
        uint32_t listCnt;

        if (lu == NULL || viewEntryList == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Allocate ioctl input buffer
         */
        fVeListSize = ALLOC_VE;
        fVeListSize = fVeListSize * (sizeof (stmf_view_op_entry_t));
        fVeList = (stmf_view_op_entry_t *)calloc(1, fVeListSize);
        if (fVeList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to get the LU list
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)lu;
        stmfIoctl.stmf_ibuf_size = sizeof (stmfGuid);
        stmfIoctl.stmf_obuf_size = fVeListSize;
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)fVeList;
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "stmfGetViewEntryList:ioctl errno(%d)",
                                    errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }
        /*
         * Check whether input buffer was large enough
         */
        if (stmfIoctl.stmf_obuf_max_nentries > ALLOC_VE) {
                bzero(&stmfIoctl, sizeof (stmfIoctl));
                fVeListSize = stmfIoctl.stmf_obuf_max_nentries *
                    sizeof (stmf_view_op_entry_t);
                free(fVeList);
                fVeList = (stmf_view_op_entry_t *)calloc(1, fVeListSize);
                if (fVeList == NULL) {
                        return (STMF_ERROR_NOMEM);
                }
                stmfIoctl.stmf_obuf_size = fVeListSize;
                stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)fVeList;
                ioctlRet = ioctl(fd, cmd, &stmfIoctl);
                if (ioctlRet != 0) {
                        switch (errno) {
                                case EBUSY:
                                        ret = STMF_ERROR_BUSY;
                                        break;
                                case EPERM:
                                case EACCES:
                                        ret = STMF_ERROR_PERM;
                                        break;
                                default:
                                        syslog(LOG_DEBUG,
                                            "stmfGetLogicalUnitList:"
                                            "ioctl errno(%d)", errno);
                                        ret = STMF_STATUS_ERROR;
                                        break;
                        }
                        goto done;
                }
        }

        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        listCnt = stmfIoctl.stmf_obuf_nentries;

        /*
         * allocate caller's buffer with the final size
         */
        *viewEntryList = (stmfViewEntryList *)calloc(1,
            sizeof (stmfViewEntryList) + listCnt * sizeof (stmfViewEntry));
        if (*viewEntryList == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        (*viewEntryList)->cnt = listCnt;

        /* copy to caller's buffer */
        for (i = 0; i < listCnt; i++) {
                (*viewEntryList)->ve[i].veIndexValid = B_TRUE;
                (*viewEntryList)->ve[i].veIndex = fVeList[i].ve_ndx;
                if (fVeList[i].ve_all_hosts == 1) {
                        (*viewEntryList)->ve[i].allHosts = B_TRUE;
                } else {
                        bcopy(fVeList[i].ve_host_group.name,
                            (*viewEntryList)->ve[i].hostGroup,
                            fVeList[i].ve_host_group.name_size);
                }
                if (fVeList[i].ve_all_targets == 1) {
                        (*viewEntryList)->ve[i].allTargets = B_TRUE;
                } else {
                        bcopy(fVeList[i].ve_target_group.name,
                            (*viewEntryList)->ve[i].targetGroup,
                            fVeList[i].ve_target_group.name_size);
                }
                bcopy(fVeList[i].ve_lu_nbr, (*viewEntryList)->ve[i].luNbr,
                    sizeof ((*viewEntryList)->ve[i].luNbr));
                (*viewEntryList)->ve[i].luNbrValid = B_TRUE;
        }

        /*
         * sort the list. This gives a consistent view across gets
         */
        qsort((void *)&((*viewEntryList)->ve[0]), (*viewEntryList)->cnt,
            sizeof (stmfViewEntry), viewEntryCompare);

done:
        (void) close(fd);
        /*
         * free internal buffers
         */
        free(fVeList);
        return (ret);
}


/*
 * loadHostGroups
 *
 * Purpose - issues the ioctl to load the host groups into stmf
 *
 * fd - file descriptor for the control node of stmf.
 * groupList - populated host group list
 */
static int
loadHostGroups(int fd, stmfGroupList *groupList)
{
        int i, j;
        int ret = STMF_STATUS_SUCCESS;
        stmfGroupProperties *groupProps = NULL;

        for (i = 0; i < groupList->cnt; i++) {
                if ((ret = groupIoctl(fd, STMF_IOCTL_CREATE_HOST_GROUP,
                    &(groupList->name[i]))) != STMF_STATUS_SUCCESS) {
                        goto out;
                }
                ret = iLoadGroupMembersFromPs(&(groupList->name[i]),
                    &groupProps, HOST_GROUP);
                for (j = 0; j < groupProps->cnt; j++) {
                        if ((ret = groupMemberIoctl(fd, STMF_IOCTL_ADD_HG_ENTRY,
                            &(groupList->name[i]), &(groupProps->name[j])))
                            != STMF_STATUS_SUCCESS) {
                                goto out;
                        }
                }
        }


out:
        stmfFreeMemory(groupProps);
        return (ret);
}

/*
 * loadTargetGroups
 *
 * Purpose - issues the ioctl to load the target groups into stmf
 *
 * fd - file descriptor for the control node of stmf.
 * groupList - populated target group list.
 */
static int
loadTargetGroups(int fd, stmfGroupList *groupList)
{
        int i, j;
        int ret = STMF_STATUS_SUCCESS;
        stmfGroupProperties *groupProps = NULL;

        for (i = 0; i < groupList->cnt; i++) {
                if ((ret = groupIoctl(fd, STMF_IOCTL_CREATE_TARGET_GROUP,
                    &(groupList->name[i]))) != STMF_STATUS_SUCCESS) {
                        goto out;
                }
                ret = iLoadGroupMembersFromPs(&(groupList->name[i]),
                    &groupProps, TARGET_GROUP);
                for (j = 0; j < groupProps->cnt; j++) {
                        if ((ret = groupMemberIoctl(fd, STMF_IOCTL_ADD_TG_ENTRY,
                            &(groupList->name[i]), &(groupProps->name[j])))
                            != STMF_STATUS_SUCCESS) {
                                goto out;
                        }
                }
        }


out:
        stmfFreeMemory(groupProps);
        return (ret);
}


/*
 * loadStore
 *
 * Purpose: Load the configuration data from the store
 *
 * First load the host groups and target groups, then the view entries
 * and finally the provider data
 *
 * fd - file descriptor of control node for stmf.
 */
static int
loadStore(int fd)
{
        int ret;
        int i, j;
        stmfGroupList *groupList = NULL;
        stmfGuidList *guidList = NULL;
        stmfViewEntryList *viewEntryList = NULL;
        stmfProviderList *providerList = NULL;
        int providerType;
        nvlist_t *nvl = NULL;



        /* load host groups */
        ret = iLoadGroupFromPs(&groupList, HOST_GROUP);
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }
        ret = loadHostGroups(fd, groupList);
        if (ret != STMF_STATUS_SUCCESS) {
                goto out;
        }

        stmfFreeMemory(groupList);
        groupList = NULL;

        /* load target groups */
        ret = iLoadGroupFromPs(&groupList, TARGET_GROUP);
        if (ret != STMF_STATUS_SUCCESS) {
                goto out;
        }
        ret = loadTargetGroups(fd, groupList);
        if (ret != STMF_STATUS_SUCCESS) {
                goto out;
        }

        stmfFreeMemory(groupList);
        groupList = NULL;

        /* Get the guid list */
        ret = psGetLogicalUnitList(&guidList);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        ret = STMF_STATUS_ERROR;
                        break;
        }

        if (ret != STMF_STATUS_SUCCESS) {
                goto out;
        }

        /*
         * We have the guid list, now get the corresponding
         * view entries for each guid
         */
        for (i = 0; i < guidList->cnt; i++) {
                ret = psGetViewEntryList(&guidList->guid[i], &viewEntryList);
                switch (ret) {
                        case STMF_PS_SUCCESS:
                                ret = STMF_STATUS_SUCCESS;
                                break;
                        case STMF_PS_ERROR_NOT_FOUND:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        case STMF_PS_ERROR_BUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                                ret = STMF_ERROR_SERVICE_NOT_FOUND;
                                break;
                        case STMF_PS_ERROR_VERSION_MISMATCH:
                                ret = STMF_ERROR_SERVICE_DATA_VERSION;
                                break;
                        default:
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                if (ret != STMF_STATUS_SUCCESS) {
                        goto out;
                }
                for (j = 0; j < viewEntryList->cnt; j++) {
                        ret = addViewEntryIoctl(fd, &guidList->guid[i],
                            &viewEntryList->ve[j]);
                        if (ret != STMF_STATUS_SUCCESS) {
                                goto out;
                        }
                }
        }

        /* get the list of providers that have data */
        ret = psGetProviderDataList(&providerList);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        ret = STMF_STATUS_ERROR;
                        break;
        }
        if (ret != STMF_STATUS_SUCCESS) {
                goto out;
        }

        for (i = 0; i < providerList->cnt; i++) {
                providerType = providerList->provider[i].providerType;
                ret = psGetProviderData(providerList->provider[i].name,
                    &nvl, providerType, NULL);
                switch (ret) {
                        case STMF_PS_SUCCESS:
                                ret = STMF_STATUS_SUCCESS;
                                break;
                        case STMF_PS_ERROR_NOT_FOUND:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        case STMF_PS_ERROR_BUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                                ret = STMF_ERROR_SERVICE_NOT_FOUND;
                                break;
                        case STMF_PS_ERROR_VERSION_MISMATCH:
                                ret = STMF_ERROR_SERVICE_DATA_VERSION;
                                break;
                        default:
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                if (ret != STMF_STATUS_SUCCESS) {
                        goto out;
                }

                /* call setProviderData */
                ret = setProviderData(fd, providerList->provider[i].name, nvl,
                    providerType, NULL);
                switch (ret) {
                        case STMF_PS_SUCCESS:
                                ret = STMF_STATUS_SUCCESS;
                                break;
                        case STMF_PS_ERROR_NOT_FOUND:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        case STMF_PS_ERROR_BUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                                ret = STMF_ERROR_SERVICE_NOT_FOUND;
                                break;
                        case STMF_PS_ERROR_VERSION_MISMATCH:
                                ret = STMF_ERROR_SERVICE_DATA_VERSION;
                                break;
                        default:
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                if (ret != STMF_STATUS_SUCCESS) {
                        goto out;
                }

                nvlist_free(nvl);
                nvl = NULL;
        }
out:
        if (groupList != NULL) {
                free(groupList);
        }
        if (guidList != NULL) {
                free(guidList);
        }
        if (viewEntryList != NULL) {
                free(viewEntryList);
        }
        if (nvl != NULL) {
                nvlist_free(nvl);
        }
        return (ret);
}

/*
 * stmfGetAluaState
 *
 * Purpose - Get the alua state
 *
 */
int
stmfGetAluaState(boolean_t *enabled, uint32_t *node)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        stmf_iocdata_t stmfIoctl = {0};
        stmf_alua_state_desc_t alua_state = {0};
        int ioctlRet;

        if (enabled == NULL || node == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Issue ioctl to get the stmf state
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_obuf_size = sizeof (alua_state);
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)&alua_state;
        ioctlRet = ioctl(fd, STMF_IOCTL_GET_ALUA_STATE, &stmfIoctl);

        (void) close(fd);

        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "getStmfState:ioctl errno(%d)", errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
        } else {
                if (alua_state.alua_state == 1) {
                        *enabled = B_TRUE;
                } else {
                        *enabled = B_FALSE;
                }
                *node = alua_state.alua_node;
        }

        return (ret);
}

/*
 * stmfSetAluaState
 *
 * Purpose - set the alua state to enabled/disabled
 *
 */
int
stmfSetAluaState(boolean_t enabled, uint32_t node)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        stmf_iocdata_t stmfIoctl = {0};
        stmf_alua_state_desc_t alua_state = {0};
        int ioctlRet;

        if ((enabled != B_TRUE && enabled != B_FALSE) || (node > 1)) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (enabled) {
                alua_state.alua_state = 1;
        }

        alua_state.alua_node = node;

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Issue ioctl to get the stmf state
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (alua_state);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&alua_state;
        ioctlRet = ioctl(fd, STMF_IOCTL_SET_ALUA_STATE, &stmfIoctl);

        (void) close(fd);

        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "getStmfState:ioctl errno(%d)", errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
        }
        if (!enabled && ret == STMF_STATUS_SUCCESS) {
                deleteNonActiveLus();
        }

        return (ret);
}

static void
deleteNonActiveLus()
{
        int stmfRet;
        int i;
        stmfGuidList *luList;
        luResource hdl = NULL;
        char propVal[10];
        size_t propValSize = sizeof (propVal);

        stmfRet = stmfGetLogicalUnitList(&luList);
        if (stmfRet != STMF_STATUS_SUCCESS) {
                return;
        }

        for (i = 0; i < luList->cnt; i++) {
                stmfRet = stmfGetLuResource(&luList->guid[i], &hdl);
                if (stmfRet != STMF_STATUS_SUCCESS) {
                        goto err;
                }
                stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_ACCESS_STATE, propVal,
                    &propValSize);
                if (stmfRet != STMF_STATUS_SUCCESS) {
                        goto err;
                }
                if (propVal[0] == '0') {
                        (void) stmfFreeLuResource(hdl);
                        hdl = NULL;
                        continue;
                }
                (void) stmfDeleteLu(&luList->guid[i]);
                (void) stmfFreeLuResource(hdl);
                hdl = NULL;
        }

err:
        stmfFreeMemory(luList);
        (void) stmfFreeLuResource(hdl);
}

/*
 * stmfLoadConfig
 *
 * Purpose - load the configuration data from smf into stmf
 *
 */
int
stmfLoadConfig(void)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        stmf_state_desc_t stmfStateSet;
        stmfState state;

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                stmfStateSet.state = STMF_STATE_OFFLINE;

                if ((ret = openStmf(OPEN_EXCL_STMF, &fd))
                    != STMF_STATUS_SUCCESS) {
                        return (ret);
                }
                /*
                 * Configuration not stored persistently; nothing to
                 * initialize so do not set to STMF_CONFIG_INIT.
                 */
                stmfStateSet.config_state = STMF_CONFIG_INIT_DONE;
                goto done;
        }

        /* Check to ensure service exists */
        if (psCheckService() != STMF_STATUS_SUCCESS) {
                return (STMF_ERROR_SERVICE_NOT_FOUND);
        }

        ret = stmfGetState(&state);
        if (ret == STMF_STATUS_SUCCESS) {
                if (state.operationalState != STMF_SERVICE_STATE_OFFLINE) {
                        return (STMF_ERROR_SERVICE_ONLINE);
                }
        } else {
                return (STMF_STATUS_ERROR);
        }


        stmfStateSet.state = STMF_STATE_OFFLINE;
        stmfStateSet.config_state = STMF_CONFIG_INIT;

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        ret = setStmfState(fd, &stmfStateSet, STMF_SERVICE_TYPE);
        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        /* Load the persistent configuration data */
        ret = loadStore(fd);
        if (ret != 0) {
                goto done;
        }

        stmfStateSet.state = STMF_STATE_OFFLINE;
        stmfStateSet.config_state = STMF_CONFIG_INIT_DONE;

done:
        if (ret == STMF_STATUS_SUCCESS) {
                ret = setStmfState(fd, &stmfStateSet, STMF_SERVICE_TYPE);
        }
        (void) close(fd);
        return (ret);
}


/*
 * getStmfState
 *
 * stmfState - pointer to stmf_state_desc_t structure. Will contain the state
 *             information of the stmf service on success.
 */
static int
getStmfState(stmf_state_desc_t *stmfState)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        int ioctlRet;
        stmf_iocdata_t stmfIoctl;

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to get the stmf state
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (stmf_state_desc_t);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)stmfState;
        stmfIoctl.stmf_obuf_size = sizeof (stmf_state_desc_t);
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)stmfState;
        ioctlRet = ioctl(fd, STMF_IOCTL_GET_STMF_STATE, &stmfIoctl);

        (void) close(fd);

        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "getStmfState:ioctl errno(%d)", errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
        }
        return (ret);
}


/*
 * setStmfState
 *
 * stmfState - pointer to caller set state structure
 * objectType - one of:
 *              LOGICAL_UNIT_TYPE
 *              TARGET_TYPE
 *              STMF_SERVICE_TYPE
 */
static int
setStmfState(int fd, stmf_state_desc_t *stmfState, int objectType)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        int cmd;
        stmf_iocdata_t stmfIoctl;

        switch (objectType) {
                case LOGICAL_UNIT_TYPE:
                        cmd = STMF_IOCTL_SET_LU_STATE;
                        break;
                case TARGET_TYPE:
                        cmd = STMF_IOCTL_SET_TARGET_PORT_STATE;
                        break;
                case STMF_SERVICE_TYPE:
                        cmd = STMF_IOCTL_SET_STMF_STATE;
                        break;
                default:
                        ret = STMF_STATUS_ERROR;
                        goto done;
        }

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to set the stmf state
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (stmf_state_desc_t);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)stmfState;
        ioctlRet = ioctl(fd, cmd, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        case ENOENT:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "setStmfState:ioctl errno(%d)", errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
        }
done:
        return (ret);
}
int
stmfSetStmfProp(uint8_t propType, char *propVal)
{
        int ret = STMF_STATUS_SUCCESS;
        switch (propType) {
                case STMF_DEFAULT_LU_STATE:
                        break;
                case STMF_DEFAULT_TARGET_PORT_STATE:
                        break;
                default:
                        return (STMF_ERROR_INVALID_ARG);
        }
        ret = psSetStmfProp(propType, propVal);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfSetStmfProp:psSetStmfProp:error(%d)",
                            ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }
        return (ret);
}


int
stmfGetStmfProp(uint8_t propType, char *propVal, size_t *propLen)
{
        int ret = STMF_STATUS_SUCCESS;
        char prop[MAXNAMELEN] = {0};
        size_t reqLen;

        if (propVal == NULL || propLen == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }
        switch (propType) {
                case STMF_DEFAULT_LU_STATE:
                        break;
                case STMF_DEFAULT_TARGET_PORT_STATE:
                        break;
                default:
                        return (STMF_ERROR_INVALID_ARG);
        }
        ret = psGetStmfProp(propType, prop);
        if ((reqLen = strlcpy(propVal, prop, *propLen)) >= *propLen) {
                *propLen = reqLen + 1;
                return (STMF_ERROR_INVALID_ARG);
        }

        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfGetStmfProp:psGetStmfProp:error(%d)",
                            ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }
        return (ret);
}

static int
setStmfProp(stmf_set_props_t *stmf_set_props)
{
        char propVal[MAXNAMELEN] = {0};
        int ret;
        if ((ret = psGetStmfProp(STMF_DEFAULT_LU_STATE, propVal)) ==
            STMF_PS_SUCCESS) {
                if (strncmp(propVal, "offline", strlen(propVal)) == 0) {
                        stmf_set_props->default_lu_state_value =
                            STMF_STATE_OFFLINE;
                } else {
                        stmf_set_props->default_lu_state_value =
                            STMF_STATE_ONLINE;
                }
        } else {
                syslog(LOG_DEBUG,
                    "DefaultLuState:psSetStmfProp:error(%d)", ret);
                goto done;
        }

        if ((ret = psGetStmfProp(STMF_DEFAULT_TARGET_PORT_STATE, propVal)) ==
            STMF_PS_SUCCESS) {
                if (strncmp(propVal, "offline", strlen(propVal)) == 0) {
                        stmf_set_props->default_target_state_value =
                            STMF_STATE_OFFLINE;
                } else {
                        stmf_set_props->default_target_state_value =
                            STMF_STATE_ONLINE;
                }
        } else {
                syslog(LOG_DEBUG,
                    "DefaultTargetPortState:psSetStmfProp:error(%d)", ret);
                goto done;
        }
done:
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                default:
                        ret = STMF_STATUS_ERROR;
                        break;
        }
        return (ret);
}

static int
loadStmfProp(int fd)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        stmf_iocdata_t stmfIoctl = {0};
        stmf_set_props_t *stmf_set_props = NULL;

        stmf_set_props = (stmf_set_props_t *)
            calloc(1, (sizeof (stmf_set_props_t)));
        if (stmf_set_props == NULL) {
                ret = STMF_ERROR_NOMEM;
                goto done;
        }

        /* Loading the default property values from smf */

        if ((ret = setStmfProp(stmf_set_props)) != STMF_STATUS_SUCCESS)
                goto done;

        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (stmf_set_props_t);
        stmfIoctl.stmf_ibuf =
            (uint64_t)(unsigned long)stmf_set_props;

        ioctlRet = ioctl(fd, STMF_IOCTL_SET_STMF_PROPS,
            &stmfIoctl);

        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        case ENOENT:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "setDefaultStmfState:"
                                    "ioctl errno(%d)", errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
        }
done:
        if (stmf_set_props != NULL) {
                free(stmf_set_props);
        }
        return (ret);
}

int
stmfLoadStmfProps(void)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        /* open control node for stmf */
        if ((ret = openStmf(OPEN_EXCL_STMF, &fd))
            != STMF_STATUS_SUCCESS) {
                goto done;
        }
        ret = loadStmfProp(fd);

        (void) close(fd);
done:
        if (ret != STMF_STATUS_SUCCESS) {
                syslog(LOG_DEBUG,
                    "stmfLoadStmfProps:Failed");
        }
        return (ret);
}

/*
 * stmfOnline
 *
 * Purpose: Online stmf service
 *
 */
int
stmfOnline(void)
{
        int ret;
        int fd;
        stmfState state;
        stmf_state_desc_t iState;

        ret = stmfGetState(&state);
        if (ret == STMF_STATUS_SUCCESS) {
                if (state.operationalState == STMF_SERVICE_STATE_ONLINE) {
                        return (STMF_ERROR_SERVICE_ONLINE);
                }
        } else {
                return (STMF_STATUS_ERROR);
        }
        iState.state = STMF_STATE_ONLINE;
        iState.config_state = STMF_CONFIG_NONE;
        /*
         * Open control node for stmf
         * to make call to setStmfState()
         */
        if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);
        ret = setStmfState(fd, &iState, STMF_SERVICE_TYPE);
        (void) close(fd);
        return (ret);
}

/*
 * stmfOffline
 *
 * Purpose: Offline stmf service
 *
 */
int
stmfOffline(void)
{
        int ret;
        int fd;
        stmfState state;
        stmf_state_desc_t iState;

        ret = stmfGetState(&state);
        if (ret == STMF_STATUS_SUCCESS) {
                if (state.operationalState == STMF_SERVICE_STATE_OFFLINE) {
                        return (STMF_ERROR_SERVICE_OFFLINE);
                }
        } else {
                return (STMF_STATUS_ERROR);
        }
        iState.state = STMF_STATE_OFFLINE;
        iState.config_state = STMF_CONFIG_NONE;

        /*
         * Open control node for stmf
         * to make call to setStmfState()
         */
        if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);
        ret = setStmfState(fd, &iState, STMF_SERVICE_TYPE);
        (void) close(fd);
        return (ret);
}


/*
 * stmfOfflineTarget
 *
 * Purpose: Change state of target to offline
 *
 * devid - devid of the target to offline
 */
int
stmfOfflineTarget(stmfDevid *devid)
{
        stmf_state_desc_t targetState;
        int ret = STMF_STATUS_SUCCESS;
        int fd;

        if (devid == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }
        bzero(&targetState, sizeof (targetState));

        targetState.state = STMF_STATE_OFFLINE;
        targetState.ident[IDENT_LENGTH_BYTE] = devid->identLength;
        bcopy(&(devid->ident), &targetState.ident[IDENT_LENGTH_BYTE + 1],
            devid->identLength);
        /*
         * Open control node for stmf
         * to make call to setStmfState()
         */
        if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);
        ret = setStmfState(fd, &targetState, TARGET_TYPE);
        (void) close(fd);
        return (ret);
}

/*
 * stmfOfflineLogicalUnit
 *
 * Purpose: Change state of logical unit to offline
 *
 * lu - guid of the logical unit to offline
 */
int
stmfOfflineLogicalUnit(stmfGuid *lu)
{
        stmf_state_desc_t luState;
        int ret = STMF_STATUS_SUCCESS;
        int fd;

        if (lu == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        bzero(&luState, sizeof (luState));

        luState.state = STMF_STATE_OFFLINE;
        bcopy(lu, &luState.ident, sizeof (stmfGuid));
        /*
         * Open control node for stmf
         * to make call to setStmfState()
         */
        if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);
        ret = setStmfState(fd, &luState, LOGICAL_UNIT_TYPE);
        (void) close(fd);
        return (ret);
}

/*
 * stmfOnlineTarget
 *
 * Purpose: Change state of target to online
 *
 * devid - devid of the target to online
 */
int
stmfOnlineTarget(stmfDevid *devid)
{
        stmf_state_desc_t targetState;
        int ret = STMF_STATUS_SUCCESS;
        int fd;

        if (devid == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }
        bzero(&targetState, sizeof (targetState));

        targetState.state = STMF_STATE_ONLINE;
        targetState.ident[IDENT_LENGTH_BYTE] = devid->identLength;
        bcopy(&(devid->ident), &targetState.ident[IDENT_LENGTH_BYTE + 1],
            devid->identLength);
        /*
         * Open control node for stmf
         * to make call to setStmfState()
         */
        if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);
        ret = setStmfState(fd, &targetState, TARGET_TYPE);
        (void) close(fd);
        return (ret);
}

/*
 * stmfOnlineLogicalUnit
 *
 * Purpose: Change state of logical unit to online
 *
 * lu - guid of the logical unit to online
 */
int
stmfOnlineLogicalUnit(stmfGuid *lu)
{
        stmf_state_desc_t luState;
        int ret = STMF_STATUS_SUCCESS;
        int fd;

        if (lu == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        bzero(&luState, sizeof (luState));

        luState.state = STMF_STATE_ONLINE;
        bcopy(lu, &luState.ident, sizeof (stmfGuid));
        /*
         * Open control node for stmf
         * to make call to setStmfState()
         */
        if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);
        ret = setStmfState(fd, &luState, LOGICAL_UNIT_TYPE);
        (void) close(fd);
        return (ret);
}

/*
 * stmfRemoveFromHostGroup
 *
 * Purpose: Removes an initiator from an initiator group
 *
 * hostGroupName - name of an initiator group
 * hostName - name of host group member to remove
 */
int
stmfRemoveFromHostGroup(stmfGroupName *hostGroupName, stmfDevid *hostName)
{
        int ret;
        int fd;

        if (hostGroupName == NULL ||
            (strnlen((char *)hostGroupName, sizeof (stmfGroupName))
            == sizeof (stmfGroupName)) || hostName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        if ((ret = groupMemberIoctl(fd, STMF_IOCTL_REMOVE_HG_ENTRY,
            hostGroupName, hostName)) != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        ret = psRemoveHostGroupMember((char *)hostGroupName,
            (char *)hostName->ident);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_MEMBER_NOT_FOUND:
                        ret = STMF_ERROR_MEMBER_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_GROUP_NOT_FOUND:
                        ret = STMF_ERROR_GROUP_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfRemoveFromHostGroup"
                            "psRemoveHostGroupMember:error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfRemoveFromTargetGroup
 *
 * Purpose: Removes a local port from a local port group
 *
 * targetGroupName - name of a target group
 * targetName - name of target to remove
 */
int
stmfRemoveFromTargetGroup(stmfGroupName *targetGroupName, stmfDevid *targetName)
{
        int ret;
        int fd;

        if (targetGroupName == NULL ||
            (strnlen((char *)targetGroupName, sizeof (stmfGroupName))
            == sizeof (stmfGroupName)) || targetName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        if ((ret = groupMemberIoctl(fd, STMF_IOCTL_REMOVE_TG_ENTRY,
            targetGroupName, targetName)) != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        ret = psRemoveTargetGroupMember((char *)targetGroupName,
            (char *)targetName->ident);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_MEMBER_NOT_FOUND:
                        ret = STMF_ERROR_MEMBER_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_GROUP_NOT_FOUND:
                        ret = STMF_ERROR_GROUP_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfRemoveFromTargetGroup"
                            "psRemoveTargetGroupMember:error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfRemoveViewEntry
 *
 * Purpose: Removes a view entry from a logical unit
 *
 * lu - guid of lu for which view entry is being removed
 * viewEntryIndex - index of view entry to remove
 *
 */
int
stmfRemoveViewEntry(stmfGuid *lu, uint32_t viewEntryIndex)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        int ioctlRet;
        stmf_iocdata_t stmfIoctl;
        stmf_view_op_entry_t ioctlViewEntry;

        if (lu == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        bzero(&ioctlViewEntry, sizeof (ioctlViewEntry));
        ioctlViewEntry.ve_ndx_valid = B_TRUE;
        ioctlViewEntry.ve_ndx = viewEntryIndex;
        bcopy(lu, &ioctlViewEntry.ve_guid, sizeof (stmfGuid));

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to add to the view entry
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (ioctlViewEntry);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&ioctlViewEntry;
        ioctlRet = ioctl(fd, STMF_IOCTL_REMOVE_VIEW_ENTRY, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                                ret = STMF_ERROR_PERM;
                                break;
                        case EACCES:
                                switch (stmfIoctl.stmf_error) {
                                        case STMF_IOCERR_UPDATE_NEED_CFG_INIT:
                                                ret = STMF_ERROR_CONFIG_NONE;
                                                break;
                                        default:
                                                ret = STMF_ERROR_PERM;
                                                break;
                                }
                                break;
                        case ENODEV:
                        case ENOENT:
                                ret = STMF_ERROR_NOT_FOUND;
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "stmfRemoveViewEntry:ioctl errno(%d)",
                                    errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        ret = psRemoveViewEntry(lu, viewEntryIndex);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_NOT_FOUND:
                        ret = STMF_ERROR_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfRemoveViewEntry" "psRemoveViewEntry:error(%d)",
                            ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        (void) close(fd);
        return (ret);
}

/*
 * stmfSetProviderData
 *
 * Purpose: set the provider data
 *
 * providerName - unique name of provider
 * nvl - nvlist to set
 * providerType - type of provider for which to set data
 *              STMF_LU_PROVIDER_TYPE
 *              STMF_PORT_PROVIDER_TYPE
 */
int
stmfSetProviderData(char *providerName, nvlist_t *nvl, int providerType)
{
        return (stmfSetProviderDataProt(providerName, nvl, providerType,
            NULL));
}

/*
 * stmfSetProviderDataProt
 *
 * Purpose: set the provider data
 *
 * providerName - unique name of provider
 * nvl - nvlist to set
 * providerType - type of provider for which to set data
 *              STMF_LU_PROVIDER_TYPE
 *              STMF_PORT_PROVIDER_TYPE
 * setToken - Stale data token returned in the stmfGetProviderDataProt()
 *            call or NULL.
 */
int
stmfSetProviderDataProt(char *providerName, nvlist_t *nvl, int providerType,
    uint64_t *setToken)
{
        int ret;
        int fd;

        if (providerName == NULL || nvl == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        if (providerType != STMF_LU_PROVIDER_TYPE &&
            providerType != STMF_PORT_PROVIDER_TYPE) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        ret = setProviderData(fd, providerName, nvl, providerType, setToken);

        (void) close(fd);

        if (ret != STMF_STATUS_SUCCESS) {
                goto done;
        }

        if (iGetPersistMethod() == STMF_PERSIST_NONE) {
                goto done;
        }

        /* setting driver provider data successful. Now persist it */
        ret = psSetProviderData(providerName, nvl, providerType, NULL);
        switch (ret) {
                case STMF_PS_SUCCESS:
                        ret = STMF_STATUS_SUCCESS;
                        break;
                case STMF_PS_ERROR_EXISTS:
                        ret = STMF_ERROR_EXISTS;
                        break;
                case STMF_PS_ERROR_BUSY:
                        ret = STMF_ERROR_BUSY;
                        break;
                case STMF_PS_ERROR_SERVICE_NOT_FOUND:
                        ret = STMF_ERROR_SERVICE_NOT_FOUND;
                        break;
                case STMF_PS_ERROR_VERSION_MISMATCH:
                        ret = STMF_ERROR_SERVICE_DATA_VERSION;
                        break;
                case STMF_PS_ERROR_PROV_DATA_STALE:
                        ret = STMF_ERROR_PROV_DATA_STALE;
                        break;
                default:
                        syslog(LOG_DEBUG,
                            "stmfSetProviderData"
                            "psSetProviderData:error(%d)", ret);
                        ret = STMF_STATUS_ERROR;
                        break;
        }

done:
        return (ret);
}

/*
 * getProviderData
 *
 * Purpose: set the provider data from stmf
 *
 * providerName - unique name of provider
 * nvl - nvlist to load/retrieve
 * providerType - logical unit or port provider
 * setToken - returned stale data token
 */
int
getProviderData(char *providerName, nvlist_t **nvl, int providerType,
    uint64_t *setToken)
{
        int ret = STMF_STATUS_SUCCESS;
        int fd;
        int ioctlRet;
        size_t nvlistSize = ALLOC_PP_DATA_SIZE;
        int retryCnt = 0;
        int retryCntMax = MAX_PROVIDER_RETRY;
        stmf_ppioctl_data_t ppi = {0}, *ppi_out = NULL;
        boolean_t retry = B_TRUE;
        stmf_iocdata_t stmfIoctl;

        if (providerName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /* set provider name and provider type */
        if (strlcpy(ppi.ppi_name, providerName,
            sizeof (ppi.ppi_name)) >=
            sizeof (ppi.ppi_name)) {
                ret = STMF_ERROR_INVALID_ARG;
                goto done;
        }
        switch (providerType) {
                case STMF_LU_PROVIDER_TYPE:
                        ppi.ppi_lu_provider = 1;
                        break;
                case STMF_PORT_PROVIDER_TYPE:
                        ppi.ppi_port_provider = 1;
                        break;
                default:
                        ret = STMF_ERROR_INVALID_ARG;
                        goto done;
        }

        do {
                /* allocate memory for ioctl */
                ppi_out = (stmf_ppioctl_data_t *)calloc(1, nvlistSize +
                    sizeof (stmf_ppioctl_data_t));
                if (ppi_out == NULL) {
                        ret = STMF_ERROR_NOMEM;
                        goto done;

                }

                /* set the size of the ioctl data to allocated buffer */
                ppi.ppi_data_size = nvlistSize;

                bzero(&stmfIoctl, sizeof (stmfIoctl));

                stmfIoctl.stmf_version = STMF_VERSION_1;
                stmfIoctl.stmf_ibuf_size = sizeof (stmf_ppioctl_data_t);
                stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&ppi;
                stmfIoctl.stmf_obuf_size = sizeof (stmf_ppioctl_data_t) +
                    nvlistSize;
                stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)ppi_out;
                ioctlRet = ioctl(fd, STMF_IOCTL_GET_PP_DATA, &stmfIoctl);
                if (ioctlRet != 0) {
                        switch (errno) {
                                case EBUSY:
                                        ret = STMF_ERROR_BUSY;
                                        break;
                                case EPERM:
                                case EACCES:
                                        ret = STMF_ERROR_PERM;
                                        break;
                                case EINVAL:
                                        if (stmfIoctl.stmf_error ==
                                            STMF_IOCERR_INSUFFICIENT_BUF) {
                                                nvlistSize =
                                                    ppi_out->ppi_data_size;
                                                free(ppi_out);
                                                ppi_out = NULL;
                                                if (retryCnt++ > retryCntMax) {
                                                        retry = B_FALSE;
                                                        ret = STMF_ERROR_BUSY;
                                                } else {
                                                        ret =
                                                            STMF_STATUS_SUCCESS;
                                                }
                                        } else {
                                                syslog(LOG_DEBUG,
                                                    "getProviderData:ioctl"
                                                    "unable to retrieve "
                                                    "nvlist");
                                                ret = STMF_STATUS_ERROR;
                                        }
                                        break;
                                case ENOENT:
                                        ret = STMF_ERROR_NOT_FOUND;
                                        break;
                                default:
                                        syslog(LOG_DEBUG,
                                            "getProviderData:ioctl errno(%d)",
                                            errno);
                                        ret = STMF_STATUS_ERROR;
                                        break;
                        }
                        if (ret != STMF_STATUS_SUCCESS)
                                goto done;
                }
        } while (retry && stmfIoctl.stmf_error == STMF_IOCERR_INSUFFICIENT_BUF);

        if ((ret = nvlist_unpack((char *)ppi_out->ppi_data,
            ppi_out->ppi_data_size, nvl, 0)) != 0) {
                ret = STMF_STATUS_ERROR;
                goto done;
        }

        /* caller has asked for new token */
        if (setToken) {
                *setToken = ppi_out->ppi_token;
        }
done:
        free(ppi_out);
        (void) close(fd);
        return (ret);
}

/*
 * setProviderData
 *
 * Purpose: set the provider data in stmf
 *
 * providerName - unique name of provider
 * nvl - nvlist to set
 * providerType - logical unit or port provider
 * setToken - stale data token to check if not NULL
 */
static int
setProviderData(int fd, char *providerName, nvlist_t *nvl, int providerType,
    uint64_t *setToken)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        size_t nvlistEncodedSize;
        stmf_ppioctl_data_t *ppi = NULL;
        uint64_t outToken;
        char *allocatedNvBuffer;
        stmf_iocdata_t stmfIoctl;

        if (providerName == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* get size of encoded nvlist */
        if (nvlist_size(nvl, &nvlistEncodedSize, NV_ENCODE_XDR) != 0) {
                return (STMF_STATUS_ERROR);
        }

        /* allocate memory for ioctl */
        ppi = (stmf_ppioctl_data_t *)calloc(1, nvlistEncodedSize +
            sizeof (stmf_ppioctl_data_t));
        if (ppi == NULL) {
                return (STMF_ERROR_NOMEM);
        }

        if (setToken) {
                ppi->ppi_token_valid = 1;
                ppi->ppi_token = *setToken;
        }

        allocatedNvBuffer = (char *)&ppi->ppi_data;
        if (nvlist_pack(nvl, &allocatedNvBuffer, &nvlistEncodedSize,
            NV_ENCODE_XDR, 0) != 0) {
                return (STMF_STATUS_ERROR);
        }

        /* set provider name and provider type */
        (void) strncpy(ppi->ppi_name, providerName, sizeof (ppi->ppi_name));
        switch (providerType) {
                case STMF_LU_PROVIDER_TYPE:
                        ppi->ppi_lu_provider = 1;
                        break;
                case STMF_PORT_PROVIDER_TYPE:
                        ppi->ppi_port_provider = 1;
                        break;
                default:
                        return (STMF_ERROR_INVALID_ARG);
        }

        /* set the size of the ioctl data to packed data size */
        ppi->ppi_data_size = nvlistEncodedSize;

        bzero(&stmfIoctl, sizeof (stmfIoctl));

        stmfIoctl.stmf_version = STMF_VERSION_1;
        /*
         * Subtracting 8 from the size as that is the size of the last member
         * of the structure where the packed data resides
         */
        stmfIoctl.stmf_ibuf_size = nvlistEncodedSize +
            sizeof (stmf_ppioctl_data_t) - 8;
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)ppi;
        stmfIoctl.stmf_obuf_size = sizeof (uint64_t);
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)&outToken;
        ioctlRet = ioctl(fd, STMF_IOCTL_LOAD_PP_DATA, &stmfIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        case EINVAL:
                                if (stmfIoctl.stmf_error ==
                                    STMF_IOCERR_PPD_UPDATED) {
                                        ret = STMF_ERROR_PROV_DATA_STALE;
                                } else {
                                        ret = STMF_STATUS_ERROR;
                                }
                                break;
                        default:
                                syslog(LOG_DEBUG,
                                    "setProviderData:ioctl errno(%d)", errno);
                                ret = STMF_STATUS_ERROR;
                                break;
                }
                if (ret != STMF_STATUS_SUCCESS)
                        goto done;
        }

        /* caller has asked for new token */
        if (setToken) {
                *setToken = outToken;
        }
done:
        free(ppi);
        return (ret);
}

/*
 * set the persistence method in the library only or library and service
 */
int
stmfSetPersistMethod(uint8_t persistType, boolean_t serviceSet)
{
        int ret = STMF_STATUS_SUCCESS;
        int oldPersist;

        (void) pthread_mutex_lock(&persistenceTypeLock);
        oldPersist = iPersistType;
        if (persistType == STMF_PERSIST_NONE ||
            persistType == STMF_PERSIST_SMF) {
                iLibSetPersist = B_TRUE;
                iPersistType = persistType;
        } else {
                (void) pthread_mutex_unlock(&persistenceTypeLock);
                return (STMF_ERROR_INVALID_ARG);
        }
        /* Is this for this library open or in SMF */
        if (serviceSet == B_TRUE) {
                ret = psSetServicePersist(persistType);
                if (ret != STMF_PS_SUCCESS) {
                        ret = STMF_ERROR_PERSIST_TYPE;
                        /* Set to old value */
                        iPersistType = oldPersist;
                }
        }
        (void) pthread_mutex_unlock(&persistenceTypeLock);

        return (ret);
}

/*
 * Only returns internal state for persist. If unset, goes to ps. If that
 * fails, returns default setting
 */
static uint8_t
iGetPersistMethod()
{

        uint8_t persistType = 0;

        (void) pthread_mutex_lock(&persistenceTypeLock);
        if (iLibSetPersist) {
                persistType = iPersistType;
        } else {
                int ret;
                ret = psGetServicePersist(&persistType);
                if (ret != STMF_PS_SUCCESS) {
                        /* set to default */
                        persistType = STMF_DEFAULT_PERSIST;
                }
        }
        (void) pthread_mutex_unlock(&persistenceTypeLock);
        return (persistType);
}

/*
 * Returns either library state or persistent config state depending on
 * serviceState
 */
int
stmfGetPersistMethod(uint8_t *persistType, boolean_t serviceState)
{
        int ret = STMF_STATUS_SUCCESS;

        if (persistType == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }
        if (serviceState) {
                ret = psGetServicePersist(persistType);
                if (ret != STMF_PS_SUCCESS) {
                        ret = STMF_ERROR_PERSIST_TYPE;
                }
        } else {
                (void) pthread_mutex_lock(&persistenceTypeLock);
                if (iLibSetPersist) {
                        *persistType = iPersistType;
                } else {
                        *persistType = STMF_DEFAULT_PERSIST;
                }
                (void) pthread_mutex_unlock(&persistenceTypeLock);
        }

        return (ret);
}

/*
 * stmfPostProxyMsg
 *
 * Purpose: Post a message to the proxy port provider
 *
 * buf - buffer containing message to post
 * buflen - buffer length
 */
int
stmfPostProxyMsg(int hdl, void *buf, uint32_t buflen)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        pppt_iocdata_t ppptIoctl = {0};

        if (buf == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /*
         * Issue ioctl to post the message
         */
        ppptIoctl.pppt_version = PPPT_VERSION_1;
        ppptIoctl.pppt_buf_size = buflen;
        ppptIoctl.pppt_buf = (uint64_t)(unsigned long)buf;
        ioctlRet = ioctl(hdl, PPPT_MESSAGE, &ppptIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        default:
                                ret = STMF_ERROR_POST_MSG_FAILED;
                                break;
                }
        }

        return (ret);
}

/*
 * stmfInitProxyDoor
 *
 * Purpose: Install door in proxy
 *
 * hdl - pointer to returned handle
 * fd - door from door_create()
 */
int
stmfInitProxyDoor(int *hdl, int door)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        int fd;
        pppt_iocdata_t ppptIoctl = {0};

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

        /*
         * Open control node for pppt
         */
        if ((ret = openPppt(OPEN_PPPT, &fd)) != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Issue ioctl to install the door
         */
        ppptIoctl.pppt_version = PPPT_VERSION_1;
        ppptIoctl.pppt_door_fd = (uint32_t)door;
        ioctlRet = ioctl(fd, PPPT_INSTALL_DOOR, &ppptIoctl);
        if (ioctlRet != 0) {
                switch (errno) {
                        case EPERM:
                        case EACCES:
                                ret = STMF_ERROR_PERM;
                                break;
                        case EINVAL:
                                ret = STMF_ERROR_INVALID_ARG;
                                break;
                        case EBUSY:
                                ret = STMF_ERROR_DOOR_INSTALLED;
                                break;
                        default:
                                ret = STMF_STATUS_ERROR;
                                break;
                }
        }

        /* return driver fd to caller */
        *hdl = fd;
        return (ret);
}

void
stmfDestroyProxyDoor(int hdl)
{
        (void) close(hdl);
}

/*
 * validateLunNumIoctl
 *
 * Purpose: Issues ioctl to check and get available lun# in view entry
 *
 * viewEntry - view entry to use
 */
static int
validateLunNumIoctl(int fd, stmfViewEntry *viewEntry)
{
        int ret = STMF_STATUS_SUCCESS;
        int ioctlRet;
        stmf_iocdata_t stmfIoctl;
        stmf_view_op_entry_t ioctlViewEntry;

        bzero(&ioctlViewEntry, sizeof (ioctlViewEntry));
        /*
         * don't set ve_ndx or ve_ndx_valid as ve_ndx_valid should be
         * false on input
         */
        ioctlViewEntry.ve_lu_number_valid = viewEntry->luNbrValid;
        ioctlViewEntry.ve_all_hosts = viewEntry->allHosts;
        ioctlViewEntry.ve_all_targets = viewEntry->allTargets;

        if (viewEntry->allHosts == B_FALSE) {
                bcopy(viewEntry->hostGroup, &ioctlViewEntry.ve_host_group.name,
                    sizeof (stmfGroupName));
                ioctlViewEntry.ve_host_group.name_size =
                    strlen((char *)viewEntry->hostGroup);
        }
        if (viewEntry->allTargets == B_FALSE) {
                bcopy(viewEntry->targetGroup,
                    &ioctlViewEntry.ve_target_group.name,
                    sizeof (stmfGroupName));
                ioctlViewEntry.ve_target_group.name_size =
                    strlen((char *)viewEntry->targetGroup);
        }
        /* Validating the lun number */
        if (viewEntry->luNbrValid) {
                bcopy(viewEntry->luNbr, &ioctlViewEntry.ve_lu_nbr,
                    sizeof (ioctlViewEntry.ve_lu_nbr));
        }

        bzero(&stmfIoctl, sizeof (stmfIoctl));
        /*
         * Issue ioctl to validate lun# in the view entry
         */
        stmfIoctl.stmf_version = STMF_VERSION_1;
        stmfIoctl.stmf_ibuf_size = sizeof (ioctlViewEntry);
        stmfIoctl.stmf_ibuf = (uint64_t)(unsigned long)&ioctlViewEntry;
        stmfIoctl.stmf_obuf_size = sizeof (ioctlViewEntry);
        stmfIoctl.stmf_obuf = (uint64_t)(unsigned long)&ioctlViewEntry;
        ioctlRet = ioctl(fd, STMF_IOCTL_VALIDATE_VIEW, &stmfIoctl);

        /* save available lun number */
        if (!viewEntry->luNbrValid) {
                bcopy(ioctlViewEntry.ve_lu_nbr, viewEntry->luNbr,
                    sizeof (ioctlViewEntry.ve_lu_nbr));
        }
        if (ioctlRet != 0) {
                switch (errno) {
                        case EBUSY:
                                ret = STMF_ERROR_BUSY;
                                break;
                        case EPERM:
                                ret = STMF_ERROR_PERM;
                                break;
                        case EACCES:
                                switch (stmfIoctl.stmf_error) {
                                        case STMF_IOCERR_UPDATE_NEED_CFG_INIT:
                                                ret = STMF_ERROR_CONFIG_NONE;
                                                break;
                                        default:
                                                ret = STMF_ERROR_PERM;
                                                break;
                                }
                                break;
                        default:
                                switch (stmfIoctl.stmf_error) {
                                        case STMF_IOCERR_LU_NUMBER_IN_USE:
                                                ret = STMF_ERROR_LUN_IN_USE;
                                                break;
                                        case STMF_IOCERR_VIEW_ENTRY_CONFLICT:
                                                ret = STMF_ERROR_VE_CONFLICT;
                                                break;
                                        case STMF_IOCERR_UPDATE_NEED_CFG_INIT:
                                                ret = STMF_ERROR_CONFIG_NONE;
                                                break;
                                        case STMF_IOCERR_INVALID_HG:
                                                ret = STMF_ERROR_INVALID_HG;
                                                break;
                                        case STMF_IOCERR_INVALID_TG:
                                                ret = STMF_ERROR_INVALID_TG;
                                                break;
                                        default:
                                                syslog(LOG_DEBUG,
                                                    "addViewEntryIoctl"
                                                    ":error(%d)",
                                                    stmfIoctl.stmf_error);
                                                ret = STMF_STATUS_ERROR;
                                                break;
                                }
                                break;
                }
        }
        return (ret);
}

/*
 * stmfValidateView
 *
 * Purpose: Validate or get lun # base on TG, HG of view entry
 *
 * viewEntry - view entry structure to use
 */
int
stmfValidateView(stmfViewEntry *viewEntry)
{
        int ret;
        int fd;
        stmfViewEntry iViewEntry;

        if (viewEntry == NULL) {
                return (STMF_ERROR_INVALID_ARG);
        }

        /* initialize and set internal view entry */
        bzero(&iViewEntry, sizeof (iViewEntry));

        if (!viewEntry->allHosts) {
                bcopy(viewEntry->hostGroup, iViewEntry.hostGroup,
                    sizeof (iViewEntry.hostGroup));
        } else {
                iViewEntry.allHosts = B_TRUE;
        }

        if (!viewEntry->allTargets) {
                bcopy(viewEntry->targetGroup, iViewEntry.targetGroup,
                    sizeof (iViewEntry.targetGroup));
        } else {
                iViewEntry.allTargets = B_TRUE;
        }

        if (viewEntry->luNbrValid) {
                iViewEntry.luNbrValid = B_TRUE;
                bcopy(viewEntry->luNbr, iViewEntry.luNbr,
                    sizeof (iViewEntry.luNbr));
        }

        /*
         * set users return view entry index valid flag to false
         * in case of failure
         */
        viewEntry->veIndexValid = B_FALSE;

        /* Check to ensure service exists */
        if (psCheckService() != STMF_STATUS_SUCCESS) {
                return (STMF_ERROR_SERVICE_NOT_FOUND);
        }

        /* call init */
        ret = initializeConfig();
        if (ret != STMF_STATUS_SUCCESS) {
                return (ret);
        }

        /*
         * Open control node for stmf
         */
        if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
                return (ret);

        /*
         * Validate lun# in the view entry from the driver
         */
        ret = validateLunNumIoctl(fd, &iViewEntry);
        (void) close(fd);

        /* save available lun number */
        if (!viewEntry->luNbrValid) {
                bcopy(iViewEntry.luNbr, viewEntry->luNbr,
                    sizeof (iViewEntry.luNbr));
        }

        return (ret);
}