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

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stddef.h>
#include <stdlib.h>
#include <dirent.h>
#include <dlfcn.h>
#include <link.h>
#include <strings.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/mnttab.h>
#include <config_admin.h>
#include <sys/param.h>
#include <libintl.h>
#include <libdevinfo.h>
#include <raidcfg.h>
#include <thread.h>
#include <synch.h>

#ifndef TEXT_DOMAIN
#define TEXT_DOMAIN     "SYS_TEST"
#endif

#define HASH_SLOTS      16
#define HANDLER_SLOTS   256

/*
 * Raid object status;
 */
#define OBJ_STATUS_CMD_CLEAN    -1
#define OBJ_STATUS_OPENED       1
#define OBJ_STATUS_SCANCOMP     1 << 1

#if defined(__sparcv9)
#define SUPP_PLUGIN_DIR "/usr/lib/raidcfg/sparcv9"
#elif defined(__amd64)
#define SUPP_PLUGIN_DIR "/usr/lib/raidcfg/amd64"
#else
#define SUPP_PLUGIN_DIR "/usr/lib/raidcfg"
#endif

/*
 * Basic types
 */
typedef int raid_obj_id_t;
typedef int raid_obj_status_t;

/*
 * Data structures used for object maintennance
 */
typedef struct {
        void *head;
        void *tail;
        size_t offset;  /* offset of double-linked element (raid_list_el_t) */
                        /* in the linked data structures (objects) */
} raid_list_t;

typedef struct {
        void *prev;
        void *next;
} raid_list_el_t;

typedef struct {
        raid_obj_id_t obj_id_cnt;       /* id 0 is reserved */
        size_t slots;                   /* How many lists linked by *table */
        raid_list_t *table;
} raid_obj_tab_t;

/*
 * Object type structure containing function pointers;
 */
typedef struct {
        int (*compnum)(raid_obj_tab_t *, raid_obj_id_t, raid_obj_type_id_t);
        int (*complist)(raid_obj_tab_t *, raid_obj_id_t, int, raid_obj_id_t *,
                raid_obj_type_id_t);
        int (*get_attr)(raid_obj_tab_t *, raid_obj_id_t);
        int (*set_attr)(raid_obj_tab_t *, raid_obj_id_t, uint32_t, uint32_t *,
                char **);
        int (*act)(raid_obj_tab_t *, raid_obj_id_t, uint32_t, void *, char **);
        int (*create_obj)(raid_obj_tab_t *, raid_obj_id_t, int,
                raid_obj_id_t *, char **);
        int (*delete_obj)(raid_obj_tab_t *, raid_obj_id_t, char **);
        int (*bind_obj)(raid_obj_tab_t *, raid_obj_id_t *, char **);
        int (*unbind_obj)(raid_obj_tab_t *, raid_obj_id_t *, char **);
} raid_obj_op_t;

/*
 * Common object data structure
 */
typedef struct {
        raid_list_el_t          el;     /* double-links */

        raid_obj_type_id_t      obj_type_id;
        raid_obj_id_t           obj_id;
        raid_obj_status_t       status;

        raid_obj_id_t           container;
        raid_obj_id_t           sibling;
        raid_obj_id_t           component;

        void                    *data;  /* Pointer to attribute structure */
        raid_obj_handle_t       handle;
} raid_obj_t;

/*
 * Definition about handle
 */
typedef struct {
        uint32_t        next;
        uint32_t        type;
        uint32_t        controller_id;
        uint32_t        array_id;
        uint32_t        disk_id;
        uint64_t        seq_id;
        uint32_t        task_id;
        uint32_t        prop_id;
        uint32_t        fd;             /* Only for controller */
        raid_lib_t      *raid_lib;      /* Only for controller */
} handle_attr_t;

#define LIST_OBJ_TO_EL(list, obj)       \
        ((void *)((char *)(obj) + (list)->offset))
#define OBJ_TAB_SLOT(tab, id)   \
        ((tab)->table + ((id)%(tab)->slots))

#pragma init(raidcfg_init)
#pragma fini(raidcfg_fini)

/*
 * Function prototypes
 */
static int intcompare(const void *p1, const void *p2);
static uint64_t raid_space_noalign(raid_obj_tab_t *, uint32_t, int,
        raid_obj_id_t *, arraypart_attr_t *);
static int raid_handle_init();
static void raid_handle_fini();
static raid_obj_handle_t raid_handle_new(raid_obj_type_id_t);
static void raid_handle_delete(raid_obj_handle_t);
static void raid_handle_delete_controller_comp(uint32_t);
static raid_obj_id_t raid_handle_to_obj(raid_obj_tab_t *,
        raid_obj_handle_t);
static raid_obj_handle_t raid_obj_to_handle(raid_obj_tab_t *,
        raid_obj_id_t);
static raid_lib_t *raid_obj_get_lib(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_set_lib(raid_obj_tab_t *, raid_obj_id_t, raid_lib_t *);
static int raid_obj_get_fd(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_set_fd(raid_obj_tab_t *, raid_obj_id_t, int);
static int obj_scan_comp(raid_obj_tab_t *, raid_obj_id_t);
static int obj_rescan(raid_obj_tab_t *);
static raid_obj_id_t obj_get_comp(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_type_id_t);
static raid_obj_id_t obj_get_sibling(raid_obj_tab_t *, raid_obj_id_t);
static int obj_get_attr(raid_obj_tab_t *, raid_obj_id_t, void **);
static raid_obj_id_t obj_locate_controller(raid_obj_tab_t *, uint32_t);
static raid_obj_id_t obj_locate_array(raid_obj_tab_t *, uint32_t, uint32_t);
static raid_obj_id_t obj_locate_array_recur(raid_obj_tab_t *, raid_obj_id_t,
        uint32_t);
static raid_obj_id_t obj_locate_hsp(raid_obj_tab_t *, uint32_t,
        uint32_t, uint32_t);
static raid_obj_id_t obj_locate_disk(raid_obj_tab_t *, uint32_t, uint32_t);
static raid_obj_id_t obj_locate_arraypart(raid_obj_tab_t *, uint32_t,
        uint32_t, uint32_t);
static raid_obj_id_t obj_locate_diskseg(raid_obj_tab_t *, uint32_t,
        uint32_t, uint32_t);
static raid_obj_id_t obj_locate_task(raid_obj_tab_t *, uint32_t, uint32_t);
static raid_obj_id_t obj_locate_prop(raid_obj_tab_t *, uint32_t, uint32_t,
        uint32_t);
static raid_obj_id_t obj_get_controller(raid_obj_tab_t *, raid_obj_id_t);

static int obj_sys_compnum(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_type_id_t);
static int obj_sys_complist(raid_obj_tab_t *, raid_obj_id_t, int,
        raid_obj_id_t *, raid_obj_type_id_t);
static int obj_controller_compnum(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_type_id_t);
static int obj_controller_complist(raid_obj_tab_t *, raid_obj_id_t, int,
        raid_obj_id_t *, raid_obj_type_id_t);
static int obj_controller_get_attr(raid_obj_tab_t *, raid_obj_id_t);
static int obj_controller_act(raid_obj_tab_t *, raid_obj_id_t,
        uint32_t, void *, char **);
static int obj_array_compnum(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_type_id_t);
static int obj_array_complist(raid_obj_tab_t *, raid_obj_id_t, int,
        raid_obj_id_t *, raid_obj_type_id_t);
static int obj_array_get_attr(raid_obj_tab_t *, raid_obj_id_t);
static int obj_array_set_attr(raid_obj_tab_t *, raid_obj_id_t,
        uint32_t, uint32_t *, char **);
static int obj_disk_compnum(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_type_id_t);
static int obj_disk_complist(raid_obj_tab_t *, raid_obj_id_t, int,
        raid_obj_id_t *, raid_obj_type_id_t);
static int obj_disk_get_attr(raid_obj_tab_t *, raid_obj_id_t);
static int obj_hsp_get_attr(raid_obj_tab_t *, raid_obj_id_t);
static int obj_arraypart_get_attr(raid_obj_tab_t *, raid_obj_id_t);
static int obj_diskseg_get_attr(raid_obj_tab_t *, raid_obj_id_t);
static int obj_task_get_attr(raid_obj_tab_t *, raid_obj_id_t);
static int obj_prop_get_attr(raid_obj_tab_t *, raid_obj_id_t);
static int obj_array_create(raid_obj_tab_t *, raid_obj_id_t, int,
        raid_obj_id_t *, char **);
static int obj_array_delete(raid_obj_tab_t *, raid_obj_id_t, char **);
static int obj_hsp_bind(raid_obj_tab_t *, raid_obj_id_t *, char **);
static int obj_hsp_unbind(raid_obj_tab_t *, raid_obj_id_t *, char **);

static int raid_obj_create_system_obj(raid_obj_tab_t *);
static raid_obj_id_t raid_obj_id_new(raid_obj_tab_t *);
static void *raid_obj_attr_new(raid_obj_type_id_t);
static raid_obj_id_t raid_obj_create(raid_obj_tab_t *, raid_obj_type_id_t);
static int raid_obj_delete(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_add_org(raid_obj_tab_t *, raid_obj_id_t, raid_obj_id_t);
static raid_obj_type_id_t raid_obj_get_type(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_set_type(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_type_id_t);
static raid_obj_status_t raid_obj_get_status(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_set_status(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_status_t);
static int raid_obj_clear_status(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_status_t);
static raid_obj_id_t raid_obj_get_container(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_set_container(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_id_t);
static raid_obj_id_t raid_obj_get_comp(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_set_comp(raid_obj_tab_t *, raid_obj_id_t, raid_obj_id_t);
static raid_obj_id_t raid_obj_get_sibling(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_set_sibling(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_id_t);
static void *raid_obj_get_data_ptr(raid_obj_tab_t *, raid_obj_id_t);
static int raid_obj_set_data_ptr(raid_obj_tab_t *, raid_obj_id_t, void *);
static raid_obj_handle_t raid_obj_get_handle(raid_obj_tab_t *,
        raid_obj_id_t);
static int raid_obj_set_handle(raid_obj_tab_t *, raid_obj_id_t,
        raid_obj_handle_t);

static void raid_list_create(raid_list_t *, size_t);
static void *raid_list_head(raid_list_t *);
static void *raid_list_next(raid_list_t *, void *);
static void raid_list_insert_tail(raid_list_t *, void *);
static void raid_list_remove(raid_list_t *, void *);
static void *raid_list_remove_head(raid_list_t *);
static void *raid_list_find(raid_list_t *, raid_obj_id_t);
static int raid_obj_tab_create(raid_obj_tab_t *, size_t);
static void raid_obj_tab_destroy(raid_obj_tab_t *);
static int raid_obj_tab_insert(raid_obj_tab_t *, raid_obj_id_t, void *);
static void *raid_obj_tab_remove(raid_obj_tab_t *, raid_obj_id_t);
static void *raid_obj_tab_find(raid_obj_tab_t *, raid_obj_id_t);
static void raid_list_destroy(raid_list_t *);

static int controller_id_to_path(uint32_t, char *);
static char *controller_id_to_driver_name(uint32_t);
static void raid_plugin_init();
static raid_lib_t *raid_plugin_load(char *);
static raid_lib_t *raid_find_lib(raid_obj_tab_t *, raid_obj_id_t);

/* Global object table */
static raid_obj_tab_t raid_tab_sys = {0, 0, NULL};

/* Plug-in modules maintenance data structures */
static raid_lib_t *raid_lib_sys = NULL;

/* Handle table definition */
static struct {
        int             handle_num;
        int             used;
        int             unused;
        handle_attr_t   *handles;
} raid_handle_sys = {0, 0, 0, NULL};

/*
 * RAID object method table definition
 */
static raid_obj_op_t raid_obj_op_sys[OBJ_TYPE_ALL] = {
        {obj_sys_compnum, obj_sys_complist, NULL, NULL, NULL,
                NULL, NULL, NULL, NULL},        /* system object methods */
        {obj_controller_compnum, obj_controller_complist,
                obj_controller_get_attr, NULL, obj_controller_act,
                NULL, NULL, NULL, NULL},        /* controller object methods */
        {obj_array_compnum, obj_array_complist, obj_array_get_attr,
                obj_array_set_attr, NULL, obj_array_create,
                obj_array_delete, NULL, NULL},  /* array object methods */
        {obj_disk_compnum, obj_disk_complist, obj_disk_get_attr, NULL,
                NULL, NULL, NULL, NULL, NULL},  /* disk object methods */
        {NULL, NULL, obj_hsp_get_attr, NULL, NULL, NULL, NULL, obj_hsp_bind,
                obj_hsp_unbind},                /* hsp object methods */
        {NULL, NULL, obj_arraypart_get_attr, NULL, NULL, NULL, NULL,
                NULL, NULL},                    /* array part object methods */
        {NULL, NULL, obj_diskseg_get_attr, NULL, NULL, NULL, NULL, NULL, NULL},
        {NULL, NULL, obj_task_get_attr, NULL, NULL, NULL, NULL,
                NULL, NULL},                    /* disk seg object methods */
        {NULL, NULL, obj_prop_get_attr, NULL, NULL, NULL, NULL,
                NULL, NULL}                     /* property object methods */
};

/*
 * Mutex for multithread safe
 */
static mutex_t raidcfg_mp;

/*
 * RaidCfg library APIs
 */
const char *
raidcfg_errstr(int err_code)
{
        char *ret_val;

        (void) mutex_lock(&raidcfg_mp);
        switch (err_code) {
        case    SUCCESS:
                ret_val = dgettext(TEXT_DOMAIN, "Operation succeeded.\n");
                break;
        case    STD_IOCTL:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Request standard IOCTL service.\n");
                break;
        case    ERR_DRIVER_NOT_FOUND:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Controller device can not be found.\n");
                break;
        case    ERR_DRIVER_OPEN:
                ret_val = dgettext(TEXT_DOMAIN, "Can not open controller.\n");
                break;
        case    ERR_DRIVER_LOCK:
                ret_val = dgettext(TEXT_DOMAIN, "Controller is locked.\n");
                break;
        case    ERR_DRIVER_CLOSED:
                ret_val = dgettext(TEXT_DOMAIN, "Controller is not opened.\n");
                break;
        case    ERR_DRIVER_ACROSS:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Operation across multiple controllers.\n");
                break;
        case    ERR_ARRAY_LEVEL:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Operation not support with volume of this level.\n");
                break;
        case    ERR_ARRAY_SIZE:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Capacity of array out of range.\n");
                break;
        case    ERR_ARRAY_STRIPE_SIZE:
                ret_val = dgettext(TEXT_DOMAIN, "Illegal stripe size.\n");
                break;
        case    ERR_ARRAY_CACHE_POLICY:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Illegal cache-write policy.\n");
                break;
        case    ERR_ARRAY_IN_USE:
                ret_val = dgettext(TEXT_DOMAIN, "Array or disk in use.\n");
                break;
        case    ERR_ARRAY_TASK:
                ret_val = dgettext(TEXT_DOMAIN, "Array has background task.\n");
                break;
        case    ERR_ARRAY_CONFIG:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Configuration over device node failed.\n");
                break;
        case    ERR_ARRAY_DISKNUM:
                ret_val = dgettext(TEXT_DOMAIN, "Incorrect number of disks.\n");
                break;
        case    ERR_ARRAY_LAYOUT:
                ret_val = dgettext(TEXT_DOMAIN, "Illegal array layout.\n");
                break;
        case    ERR_ARRAY_AMOUNT:
                ret_val = dgettext(TEXT_DOMAIN, "Too many arrays.\n");
                break;
        case    ERR_DISK_STATE:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Incorrect disk status for current operation.\n");
                break;
        case    ERR_DISK_SPACE:
                ret_val = dgettext(TEXT_DOMAIN, "No enough disk space.\n");
                break;
        case    ERR_DISK_SEG_AMOUNT:
                ret_val = dgettext(TEXT_DOMAIN, "Too many disk segments.\n");
                break;
        case    ERR_DISK_NOT_EMPTY:
                ret_val = dgettext(TEXT_DOMAIN, "Disk has occupied space.\n");
                break;
        case    ERR_DISK_TASK:
                ret_val = dgettext(TEXT_DOMAIN, "Disk has background task.\n");
                break;
        case    ERR_TASK_STATE:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Incorrect task state for current operation.\n");
                break;
        case    ERR_OP_ILLEGAL:
                ret_val = dgettext(TEXT_DOMAIN, "Illegal operation.\n");
                break;
        case    ERR_OP_NO_IMPL:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Operation is not implemented.\n");
                break;
        case    ERR_OP_FAILED:
                ret_val = dgettext(TEXT_DOMAIN, "Operation failed.\n");
                break;
        case    ERR_DEVICE_NOENT:
                ret_val = dgettext(TEXT_DOMAIN, "Device not found.\n");
                break;
        case    ERR_DEVICE_TYPE:
                ret_val = dgettext(TEXT_DOMAIN, "Illegal type of device.\n");
                break;
        case    ERR_DEVICE_DUP:
                ret_val = dgettext(TEXT_DOMAIN, "Device record duplicated.\n");
                break;
        case    ERR_DEVICE_OVERFLOW:
                ret_val = dgettext(TEXT_DOMAIN, "Too many devices.\n");
                break;
        case    ERR_DEVICE_UNCLEAN:
                ret_val = dgettext(TEXT_DOMAIN, "Device pool is not clean.\n");
                break;
        case    ERR_DEVICE_INVALID:
                ret_val = dgettext(TEXT_DOMAIN, "Device record is invalid.\n");
                break;
        case    ERR_NOMEM:
                ret_val = dgettext(TEXT_DOMAIN,
                    "Can not allocate more memory space.\n");
                break;
        case    ERR_PRIV:
                ret_val = dgettext(TEXT_DOMAIN, "No privilege.\n");
                break;
        default:
                ret_val = dgettext(TEXT_DOMAIN, "Undefined error.\n");
        }
        (void) mutex_unlock(&raidcfg_mp);

        return (ret_val);
}

int
raidcfg_get_controller(uint32_t controller_id)
{
        raid_obj_id_t obj_id;
        int ret_val;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = obj_locate_controller(&raid_tab_sys, controller_id);
        if (obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }

        if (obj_id == OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }
        ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret_val);
}

int
raidcfg_get_array(int controller_handle, uint64_t target_id, uint64_t lun)
{
        raid_obj_id_t obj_id;
        raidcfg_array_t *attr;
        int ret_val;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, controller_handle);
        if (obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }

        obj_id = obj_get_comp(&raid_tab_sys, obj_id, OBJ_TYPE_ARRAY);

        while (obj_id > OBJ_NONE) {
                (void) obj_get_attr(&raid_tab_sys, obj_id, (void **)(&attr));
                if (attr->tag.idl.target_id == target_id &&
                    attr->tag.idl.lun == lun)
                        break;

                obj_id = obj_get_sibling(&raid_tab_sys, obj_id);
        }

        if (obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }
        if (obj_id == OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }
        ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret_val);
}

int
raidcfg_get_disk(int controller_handle, disk_tag_t tag)
{
        raid_obj_id_t obj_id;
        raidcfg_disk_t *attr;
        int ret_val;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, controller_handle);
        if (obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }

        obj_id = obj_get_comp(&raid_tab_sys, obj_id, OBJ_TYPE_DISK);

        while (obj_id > OBJ_NONE) {
                (void) obj_get_attr(&raid_tab_sys, obj_id, (void **)(&attr));
                if (attr->tag.cidl.bus == tag.cidl.bus &&
                    attr->tag.cidl.target_id == tag.cidl.target_id &&
                    attr->tag.cidl.lun == tag.cidl.lun)
                        break;

                obj_id = obj_get_sibling(&raid_tab_sys, obj_id);
        }

        if (obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }
        if (obj_id == OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }
        ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret_val);
}

int
raidcfg_open_controller(int handle, char **plugin_err_str)
{
        raid_obj_id_t obj_id;
        int ret;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }

        ret = obj_controller_act(&raid_tab_sys, obj_id,
            ACT_CONTROLLER_OPEN, NULL, plugin_err_str);
        if (ret < SUCCESS) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ret);
        }
        (void) mutex_unlock(&raidcfg_mp);

        return (SUCCESS);
}

int
raidcfg_close_controller(int handle, char **plugin_err_str)
{
        raid_obj_id_t obj_id;
        int ret;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }

        ret = obj_controller_act(&raid_tab_sys, obj_id,
            ACT_CONTROLLER_CLOSE, NULL, plugin_err_str);
        if (ret < SUCCESS) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ret);
        }
        (void) mutex_unlock(&raidcfg_mp);

        return (SUCCESS);
}

int
raidcfg_get_type(int handle)
{
        raid_obj_id_t obj_id;
        int ret_val;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }
        ret_val = raid_obj_get_type(&raid_tab_sys, obj_id);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret_val);
}

int
raidcfg_get_attr(int handle, void *attr)
{
        raid_obj_id_t obj_id;
        raid_obj_type_id_t type;
        void *data;
        int ret, size;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        if (attr == NULL) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_INVALID);
        }

        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }

        type = raid_obj_get_type(&raid_tab_sys, obj_id);
        ret = obj_get_attr(&raid_tab_sys, obj_id, &data);
        if (ret < SUCCESS) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ret);
        }

        switch (type) {
        case    OBJ_TYPE_CONTROLLER:
                size = sizeof (controller_attr_t);
                break;
        case    OBJ_TYPE_ARRAY:
                size = sizeof (array_attr_t);
                break;
        case    OBJ_TYPE_HSP:
                {
                        raidcfg_hsp_t *dst = attr;
                        hsp_attr_t *src = data;
                        controller_attr_t *ctlr_attr;
                        array_attr_t *array_attr;

                        dst->associated_id = src->associated_id;
                        dst->type = src->type;

                        obj_id = obj_get_controller(&raid_tab_sys, obj_id);
                        ret = obj_get_attr(&raid_tab_sys, obj_id,
                            (void **)(&ctlr_attr));
                        if (ret < SUCCESS) {
                                (void) mutex_unlock(&raidcfg_mp);
                                return (ret);
                        }

                        if (src->type == HSP_TYPE_LOCAL) {
                                obj_id = obj_locate_array(&raid_tab_sys,
                                    ctlr_attr->controller_id,
                                    src->associated_id);
                                ret = obj_get_attr(&raid_tab_sys, obj_id,
                                    (void **)(&array_attr));
                                if (ret < SUCCESS) {
                                        (void) mutex_unlock(&raidcfg_mp);
                                        return (ret);
                                }

                                dst->tag.idl.target_id =
                                    array_attr->tag.idl.target_id;
                                dst->tag.idl.lun = array_attr->tag.idl.lun;
                        }
                }
                (void) mutex_unlock(&raidcfg_mp);
                return (SUCCESS);
        case    OBJ_TYPE_DISK:
                size = sizeof (disk_attr_t);
                break;
        case    OBJ_TYPE_ARRAY_PART:
                {
                        raidcfg_arraypart_t *dst = attr;
                        arraypart_attr_t *src = data;
                        controller_attr_t *ctlr_attr;
                        disk_attr_t *disk_attr;

                        dst->disk_id = src->disk_id;
                        dst->offset = src->offset;
                        dst->size = src->size;
                        dst->state = src->state;

                        obj_id = obj_get_controller(&raid_tab_sys, obj_id);
                        ret = obj_get_attr(&raid_tab_sys, obj_id,
                            (void **)(&ctlr_attr));
                        if (ret < SUCCESS) {
                                (void) mutex_unlock(&raidcfg_mp);
                                return (ret);
                        }

                        obj_id = obj_locate_disk(&raid_tab_sys,
                            ctlr_attr->controller_id, src->disk_id);
                        if (obj_id <= OBJ_NONE) {
                                dst->tag.cidl.bus = (uint64_t)OBJ_ATTR_NONE;
                                dst->tag.cidl.target_id =
                                    (uint64_t)OBJ_ATTR_NONE;
                                dst->tag.cidl.lun = (uint64_t)OBJ_ATTR_NONE;
                                (void) mutex_unlock(&raidcfg_mp);
                                return (SUCCESS);
                        }

                        ret = obj_get_attr(&raid_tab_sys, obj_id,
                            (void **)(&disk_attr));
                        if (ret < SUCCESS) {
                                (void) mutex_unlock(&raidcfg_mp);
                                return (ret);
                        }

                        dst->tag.cidl.bus = disk_attr->tag.cidl.bus;
                        dst->tag.cidl.target_id = disk_attr->tag.cidl.target_id;
                        dst->tag.cidl.lun = disk_attr->tag.cidl.lun;
                }
                (void) mutex_unlock(&raidcfg_mp);
                return (SUCCESS);
        case    OBJ_TYPE_DISK_SEG:
                size = sizeof (diskseg_attr_t);
                break;
        case    OBJ_TYPE_TASK:
                size = sizeof (task_attr_t);
                break;
        case    OBJ_TYPE_PROP:
                {
                        property_attr_t *src = data, *dst = attr;

                        dst->prop_id = src->prop_id;
                        dst->prop_type = src->prop_type;
                        if (dst->prop_size == 0) {
                                dst->prop_size = src->prop_size;
                                (void) mutex_unlock(&raidcfg_mp);
                                return (SUCCESS);
                        }

                        if (dst->prop_size < src->prop_size)
                                size = dst->prop_size;
                        else
                                size = src->prop_size;

                        (void) memcpy(dst->prop, src->prop, size);
                        (void) mutex_unlock(&raidcfg_mp);
                        return (SUCCESS);
                }
        default:
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_TYPE);
        }

        (void) memcpy(attr, data, size);

        (void) mutex_unlock(&raidcfg_mp);
        return (ret);
}

int
raidcfg_get_container(int handle)
{
        raid_obj_id_t obj_id;
        int ret_val;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }

        obj_id = raid_obj_get_container(&raid_tab_sys, obj_id);
        if (obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }
        ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret_val);
}

int
raidcfg_list_head(int handle, raid_obj_type_id_t type)
{
        raid_obj_id_t obj_id;
        int ret_val;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }

        obj_id = obj_get_comp(&raid_tab_sys, obj_id, type);
        if (obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }
        ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret_val);
}

int
raidcfg_list_next(int handle)
{
        raid_obj_id_t obj_id;
        int ret_val;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }

        obj_id = obj_get_sibling(&raid_tab_sys, obj_id);
        if (obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }
        ret_val = raid_obj_to_handle(&raid_tab_sys, obj_id);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret_val);
}

int
raidcfg_set_attr(int handle, uint32_t set_cmd, void *value,
    char **plugin_err_str)
{
        raid_obj_id_t obj_id;
        raid_obj_type_id_t type;
        int ret;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }

        type = raid_obj_get_type(&raid_tab_sys, obj_id);
        if (raid_obj_op_sys[type].set_attr == NULL) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_OP_NO_IMPL);
        }

        ret = raid_obj_op_sys[type].set_attr(&raid_tab_sys,
            obj_id, set_cmd, value, plugin_err_str);

        (void) mutex_unlock(&raidcfg_mp);
        return (ret);
}

int
raidcfg_update_fw(int handle, char *file, char **plugin_err_str)
{
        raid_obj_id_t obj_id;
        int ret;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        obj_id = raid_handle_to_obj(&raid_tab_sys, handle);
        if (obj_id < OBJ_NONE) {
                raid_handle_delete(handle);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }

        if (raid_obj_get_type(&raid_tab_sys, obj_id) != OBJ_TYPE_CONTROLLER) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_OP_NO_IMPL);
        }

        ret = raid_obj_op_sys[OBJ_TYPE_CONTROLLER].act(&raid_tab_sys,
            obj_id, ACT_CONTROLLER_FLASH_FW, file, plugin_err_str);

        (void) mutex_unlock(&raidcfg_mp);
        return (ret);
}

int
raidcfg_create_array(int num_of_comps, int *disk_handles,
    uint32_t raid_level, uint64_t size, uint32_t stripe_size,
    char **plugin_err_str)
{
        raid_obj_id_t *disk_obj_ids, obj_id;
        array_attr_t *array_attr;
        raid_obj_handle_t array_handle;
        int i, ret;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);

        disk_obj_ids = calloc(num_of_comps, sizeof (raid_obj_id_t));
        if (disk_obj_ids == NULL) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_NOMEM);
        }

        /* convert disk handles into disk object ids; */
        for (i = 0; i < num_of_comps; ++i) {
                if (*(disk_handles + i) == OBJ_SEPARATOR_BEGIN ||
                    *(disk_handles + i) == OBJ_SEPARATOR_END) {
                        *(disk_obj_ids + i) = *(disk_handles + i);
                        continue;
                }

                *(disk_obj_ids + i) = raid_handle_to_obj(&raid_tab_sys,
                    *(disk_handles + i));
                if (raid_obj_get_type(&raid_tab_sys, *(disk_obj_ids + i)) !=
                    OBJ_TYPE_DISK) {
                        free(disk_obj_ids);
                        (void) obj_rescan(&raid_tab_sys);
                        (void) mutex_unlock(&raidcfg_mp);
                        return (ERR_DEVICE_TYPE);
                }
        }

        /* Create an empty array object */
        obj_id = raid_obj_create(&raid_tab_sys, OBJ_TYPE_ARRAY);
        if (obj_id < OBJ_NONE) {
                free(disk_obj_ids);
                (void) obj_rescan(&raid_tab_sys);
                (void) mutex_unlock(&raidcfg_mp);
                return (obj_id);
        }
        (void) raid_obj_clear_status(&raid_tab_sys, obj_id,
            OBJ_STATUS_CMD_CLEAN);

        array_attr = raid_obj_get_data_ptr(&raid_tab_sys, obj_id);
        array_attr->array_id = (uint32_t)OBJ_ATTR_NONE;
        array_attr->raid_level = raid_level;
        array_attr->capacity = size;
        array_attr->stripe_size = stripe_size;
        array_attr->write_policy = CACHE_WR_ON;
        array_attr->read_policy = CACHE_RD_ON;

        ret = raid_obj_op_sys[OBJ_TYPE_ARRAY].create_obj(&raid_tab_sys, obj_id,
            num_of_comps, disk_obj_ids, plugin_err_str);
        free(disk_obj_ids);

        if (ret < SUCCESS) {
                (void) obj_rescan(&raid_tab_sys);
                (void) mutex_unlock(&raidcfg_mp);
                return (ret);
        }

        /* create_obj() method should put the array object in the device tree */
        array_handle = raid_obj_to_handle(&raid_tab_sys, obj_id);

        (void) obj_rescan(&raid_tab_sys);
        (void) mutex_unlock(&raidcfg_mp);
        return (array_handle);
}

int
raidcfg_delete_array(int array_handle, char **plugin_err_str)
{
        raid_obj_id_t array_obj_id;
        int ret;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);

        if (raidcfg_get_type(array_handle) != OBJ_TYPE_ARRAY) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_TYPE);
        }

        array_obj_id = raid_handle_to_obj(&raid_tab_sys, array_handle);
        if (array_obj_id < OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (array_obj_id);
        }
        if (array_obj_id == OBJ_NONE) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_INVALID);
        }

        ret = raid_obj_op_sys[OBJ_TYPE_ARRAY].delete_obj(&raid_tab_sys,
            array_obj_id, plugin_err_str);
        (void) obj_rescan(&raid_tab_sys);

        (void) mutex_unlock(&raidcfg_mp);
        return (ret);
}

int
raidcfg_set_hsp(raidcfg_hsp_relation_t *hsp_relations,
    char **plugin_err_str)
{
        raid_obj_id_t disk_obj_id, array_obj_id;
        raid_obj_id_t *hsp_relation_objs;
        int ret;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        if (hsp_relations == NULL) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_OP_ILLEGAL);
        }

        hsp_relation_objs = malloc(2 * sizeof (raid_obj_id_t));
        if (hsp_relation_objs == NULL) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_NOMEM);
        }

        (void) obj_rescan(&raid_tab_sys);

        if (hsp_relations->array_handle != OBJ_ATTR_NONE) {
                array_obj_id = raid_handle_to_obj(&raid_tab_sys,
                    hsp_relations->array_handle);
                if (array_obj_id < OBJ_NONE) {
                        free(hsp_relation_objs);
                        (void) mutex_unlock(&raidcfg_mp);
                        return (array_obj_id);
                }
                if (array_obj_id == OBJ_NONE) {
                        (void) free(hsp_relation_objs);
                        (void) mutex_unlock(&raidcfg_mp);
                        return (ERR_DEVICE_NOENT);
                }
                if (raidcfg_get_type(hsp_relations->array_handle) !=
                    OBJ_TYPE_ARRAY) {
                        free(hsp_relation_objs);
                        (void) mutex_unlock(&raidcfg_mp);
                        return (ERR_DEVICE_TYPE);
                }
        } else
                array_obj_id = OBJ_ATTR_NONE;

        disk_obj_id = raid_handle_to_obj(&raid_tab_sys,
            hsp_relations->disk_handle);
        if (disk_obj_id < OBJ_NONE) {
                free(hsp_relation_objs);
                (void) mutex_unlock(&raidcfg_mp);
                return (disk_obj_id);
        }
        if (disk_obj_id == OBJ_NONE) {
                free(hsp_relation_objs);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }
        if (raidcfg_get_type(hsp_relations->disk_handle) !=
            OBJ_TYPE_DISK) {
                free(hsp_relation_objs);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_TYPE);
        }

        hsp_relation_objs[0] = array_obj_id;
        hsp_relation_objs[1] = disk_obj_id;

        ret = raid_obj_op_sys[OBJ_TYPE_HSP].bind_obj(&raid_tab_sys,
            hsp_relation_objs, plugin_err_str);

        (void) obj_rescan(&raid_tab_sys);
        free(hsp_relation_objs);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret);
}

int
raidcfg_unset_hsp(raidcfg_hsp_relation_t *hsp_relations,
    char **plugin_err_str)
{
        raid_obj_id_t disk_obj_id, array_obj_id;
        raid_obj_id_t *hsp_relation_objs;
        int ret;

        (void) mutex_lock(&raidcfg_mp);
        (void) obj_rescan(&raid_tab_sys);
        if (hsp_relations == NULL) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_OP_ILLEGAL);
        }

        hsp_relation_objs = malloc(2 * sizeof (raid_obj_id_t));
        if (hsp_relation_objs == NULL) {
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_NOMEM);
        }

        (void) obj_rescan(&raid_tab_sys);

        if (hsp_relations->array_handle != OBJ_ATTR_NONE) {
                array_obj_id = raid_handle_to_obj(&raid_tab_sys,
                    hsp_relations->array_handle);
                if (array_obj_id < OBJ_NONE) {
                        free(hsp_relation_objs);
                        (void) mutex_unlock(&raidcfg_mp);
                        return (array_obj_id);
                }
                if (array_obj_id == OBJ_NONE) {
                        free(hsp_relation_objs);
                        (void) mutex_unlock(&raidcfg_mp);
                        return (ERR_DEVICE_NOENT);
                }
                if (raidcfg_get_type(hsp_relations->array_handle) !=
                    OBJ_TYPE_ARRAY) {
                        free(hsp_relation_objs);
                        (void) mutex_unlock(&raidcfg_mp);
                        return (ERR_DEVICE_TYPE);
                }
        } else
                array_obj_id = OBJ_ATTR_NONE;

        disk_obj_id = raid_handle_to_obj(&raid_tab_sys,
            hsp_relations->disk_handle);
        if (disk_obj_id < OBJ_NONE) {
                free(hsp_relation_objs);
                (void) mutex_unlock(&raidcfg_mp);
                return (disk_obj_id);
        }
        if (disk_obj_id == OBJ_NONE) {
                free(hsp_relation_objs);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_NOENT);
        }
        if (raidcfg_get_type(hsp_relations->disk_handle) !=
            OBJ_TYPE_DISK) {
                free(hsp_relation_objs);
                (void) mutex_unlock(&raidcfg_mp);
                return (ERR_DEVICE_TYPE);
        }

        hsp_relation_objs[0] = array_obj_id;
        hsp_relation_objs[1] = disk_obj_id;

        ret = raid_obj_op_sys[OBJ_TYPE_HSP].unbind_obj(&raid_tab_sys,
            hsp_relation_objs, plugin_err_str);

        (void) obj_rescan(&raid_tab_sys);
        free(hsp_relation_objs);
        (void) mutex_unlock(&raidcfg_mp);

        return (ret);
}

/*
 * RaidCfg lib routines
 */
void
raidcfg_init(void)
{
        (void) mutex_init(&raidcfg_mp, USYNC_THREAD, NULL);
        raid_plugin_init();
        (void) raid_handle_init();
        (void) obj_rescan(&raid_tab_sys);
}

void
raidcfg_fini(void)
{
        /*
         * Need to close all opened controllers before destroying object table
         */
        (void) obj_rescan(&raid_tab_sys);
        raid_handle_fini();
        raid_obj_tab_destroy(&raid_tab_sys);
        raid_plugin_init();
        (void) mutex_destroy(&raidcfg_mp);
}

/*
 * Support routines
 */
static int
intcompare(const void *p1, const void *p2)
{
        int i, j;
        i = *((int *)p1);
        j = *((int *)p2);
        return (i - j);
}

static uint64_t
raid_space_noalign(raid_obj_tab_t *raid_tab, uint32_t raid_level, int num,
    raid_obj_id_t *disk_objs, arraypart_attr_t *arraypart_attrs)
{
        disk_attr_t *disk_attr;
        diskseg_attr_t *diskseg_attr;
        raid_obj_id_t obj_id;
        uint64_t offset, capacity;
        int i, disk_num, sub_array_num, disk_layer;

        /* Find out the maximum available space for all disks */
        for (i = 0; i < num; ++i) {
                if ((disk_objs[i] == OBJ_SEPARATOR_BEGIN) ||
                    (disk_objs[i] == OBJ_SEPARATOR_END))
                        continue;

                (void) obj_get_attr(raid_tab, disk_objs[i],
                    (void **)(&disk_attr));
                obj_id = obj_get_comp(raid_tab, disk_objs[i],
                    OBJ_TYPE_DISK_SEG);
                if (obj_id == OBJ_NONE) {
                        arraypart_attrs[i].offset = 0;
                        arraypart_attrs[i].size = disk_attr->capacity;
                        continue;
                }

                (void) obj_get_attr(raid_tab, obj_id, (void **)
                    (&diskseg_attr));
                arraypart_attrs[i].offset = 0;
                arraypart_attrs[i].size = diskseg_attr->offset;
                offset = diskseg_attr->offset + diskseg_attr->size;

                while ((obj_id = obj_get_sibling(raid_tab, obj_id)) !=
                    OBJ_NONE) {
                        (void) obj_get_attr(raid_tab, obj_id,
                            (void **)(&diskseg_attr));
                        if ((diskseg_attr->offset - offset) >
                            arraypart_attrs[i].size) {
                                arraypart_attrs[i].offset = offset;
                                arraypart_attrs[i].size = diskseg_attr->offset -
                                    offset;
                        }

                        offset = diskseg_attr->offset + diskseg_attr->size;
                }

                if ((disk_attr->capacity - offset) > arraypart_attrs[i].size) {
                        arraypart_attrs[i].offset = offset;
                        arraypart_attrs[i].size = disk_attr->capacity -
                            offset;
                }
        }

        capacity = OBJ_ATTR_NONE;
        disk_num = 0;
        disk_layer = 0;
        sub_array_num = 0;
        for (i = 0; i < num; ++i) {
                if (disk_objs[i] == OBJ_SEPARATOR_BEGIN) {
                        ++ disk_layer;
                        continue;
                }
                if (disk_objs[i] == OBJ_SEPARATOR_END) {
                        -- disk_layer;
                        if (disk_layer != 0)
                                ++ sub_array_num;
                        continue;
                }

                if (capacity > arraypart_attrs[i].size)
                        capacity = arraypart_attrs[i].size;
                ++disk_num;
        }

        switch (raid_level) {
        case    RAID_LEVEL_0:
                capacity = capacity * disk_num;
                break;
        case    RAID_LEVEL_1:
                capacity = capacity * disk_num / 2;
                break;
        case    RAID_LEVEL_1E:
                capacity = capacity * disk_num / 2;
                break;
        case    RAID_LEVEL_5:
                capacity = capacity * (disk_num - 1);
                break;
        case    RAID_LEVEL_10:
                capacity = capacity * disk_num / 2;
                break;
        case    RAID_LEVEL_50:
                capacity = capacity * (disk_num - sub_array_num);
                break;
        default:
                return (ERR_ARRAY_LEVEL);
        }

        return (capacity);
}

/*
 * Raid handle maintenance routines
 */
static int
raid_handle_init()
{
        int i;
        void *ptr;

        raid_handle_sys.handle_num += HANDLER_SLOTS;
        ptr = realloc(raid_handle_sys.handles,
            raid_handle_sys.handle_num * sizeof (handle_attr_t));
        if (ptr == NULL)
                return (ERR_NOMEM);
        raid_handle_sys.handles = ptr;

        /* Clean up the new allocated handles */
        for (i = raid_handle_sys.handle_num - HANDLER_SLOTS;
            i < raid_handle_sys.handle_num; ++i) {
                bzero(&raid_handle_sys.handles[i], sizeof (handle_attr_t));
                raid_handle_sys.handles[i].type = OBJ_TYPE_ALL;
                raid_handle_sys.handles[i].next = i + 1;
        }

        /* For the first time of allocation, set up the system object handle */
        if (raid_handle_sys.handle_num == HANDLER_SLOTS) {
                raid_handle_sys.handles[0].type = OBJ_TYPE_SYSTEM;
                raid_handle_sys.handles[0].next = 0;
                raid_handle_sys.unused = 1;
                raid_handle_sys.used = 0;
        }
        return (SUCCESS);
}

static void
raid_handle_fini()
{
        raid_obj_handle_t i;

        i = raid_handle_sys.used;

        /* Close all opened controllers */
        while (i != 0) {
                if ((raid_handle_sys.handles[i].type == OBJ_TYPE_CONTROLLER) &&
                    (raid_handle_sys.handles[i].fd != 0) &&
                    (raid_handle_sys.handles[i].raid_lib != NULL))
                        raid_handle_sys.handles[i].raid_lib->close_controller(
                            raid_handle_sys.handles[i].controller_id, NULL);
                i = raid_handle_sys.handles[i].next;
        }

        /* Clean up handle space */
        raid_handle_sys.handle_num = 0;
        raid_handle_sys.unused = 0;
        raid_handle_sys.used = 0;
        free(raid_handle_sys.handles);
        raid_handle_sys.handles = NULL;
}

static raid_obj_handle_t
raid_handle_new(raid_obj_type_id_t type)
{
        int ret;

        if (raid_handle_sys.unused == raid_handle_sys.handle_num - 1) {
                ret = raid_handle_init();
                if (ret < SUCCESS)
                        return (ret);
        }

        ret = raid_handle_sys.unused;
        raid_handle_sys.unused = raid_handle_sys.handles[ret].next;

        raid_handle_sys.handles[ret].next = raid_handle_sys.used;
        raid_handle_sys.used = ret;
        raid_handle_sys.handles[ret].type = type;

        return (ret);
}

static void
raid_handle_delete(raid_obj_handle_t handle)
{
        int i = raid_handle_sys.used, j = 0;

        if (handle == 0)
                return;

        while (i != 0 && i != handle) {
                j = i;
                i = raid_handle_sys.handles[i].next;
        }

        if (i == handle) {
                if (j != 0)
                        raid_handle_sys.handles[j].next =
                            raid_handle_sys.handles[i].next;
                else
                        raid_handle_sys.used =
                            raid_handle_sys.handles[i].next;

                raid_handle_sys.handles[i].type = OBJ_TYPE_ALL;
                raid_handle_sys.handles[i].next =
                    raid_handle_sys.unused;
                raid_handle_sys.unused = i;
        }
}

static void
raid_handle_delete_controller_comp(uint32_t controller_id)
{
        int i = raid_handle_sys.used, j;

        while (i != 0) {
                j = i;
                i = raid_handle_sys.handles[i].next;
                if ((raid_handle_sys.handles[j].controller_id ==
                    controller_id) &&
                    (raid_handle_sys.handles[j].type !=
                    OBJ_TYPE_CONTROLLER))
                raid_handle_delete(j);
        }
}

static raid_obj_id_t
raid_handle_to_obj(raid_obj_tab_t *raid_tab, raid_obj_handle_t handle)
{
        handle_attr_t *handle_attr;
        raid_obj_id_t obj_id;

        if (handle == OBJ_SYSTEM)
                return (OBJ_SYSTEM);

        handle_attr = raid_handle_sys.handles + handle;

        switch (handle_attr->type) {
        case    OBJ_TYPE_SYSTEM:
                return (OBJ_SYSTEM);
        case    OBJ_TYPE_CONTROLLER:
                obj_id = obj_locate_controller(raid_tab,
                    handle_attr->controller_id);
                break;
        case    OBJ_TYPE_ARRAY:
                obj_id = obj_locate_array(raid_tab,
                    handle_attr->controller_id, handle_attr->array_id);
                break;
        case    OBJ_TYPE_HSP:
                obj_id = obj_locate_hsp(raid_tab,
                    handle_attr->controller_id, handle_attr->disk_id,
                    handle_attr->array_id);
                break;
        case    OBJ_TYPE_DISK:
                obj_id = obj_locate_disk(raid_tab,
                    handle_attr->controller_id, handle_attr->disk_id);
                break;
        case    OBJ_TYPE_ARRAY_PART:
                obj_id = obj_locate_arraypart(raid_tab,
                    handle_attr->controller_id, handle_attr->array_id,
                    handle_attr->disk_id);
                break;
        case    OBJ_TYPE_DISK_SEG:
                obj_id = obj_locate_diskseg(raid_tab,
                    handle_attr->controller_id,
                    handle_attr->disk_id, handle_attr->seq_id);
                break;
        case    OBJ_TYPE_TASK:
                obj_id = obj_locate_task(raid_tab,
                    handle_attr->controller_id, handle_attr->task_id);
                break;
        case    OBJ_TYPE_PROP:
                obj_id = obj_locate_prop(raid_tab,
                    handle_attr->controller_id, handle_attr->disk_id,
                    handle_attr->prop_id);
                break;
        default:
                return (ERR_DEVICE_INVALID);
        }

        if (obj_id < OBJ_NONE)
                return (obj_id);
        if (obj_id == OBJ_NONE)
                return (ERR_DEVICE_NOENT);

        (void) raid_obj_set_handle(raid_tab, obj_id, handle);
        return (obj_id);
}

static raid_obj_handle_t
raid_obj_to_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_id_t obj_id_backup = obj_id;
        raid_obj_type_id_t type;
        raid_obj_handle_t handle;
        controller_attr_t *controller_attr;
        array_attr_t *array_attr;
        hsp_attr_t *hsp_attr;
        disk_attr_t *disk_attr;
        arraypart_attr_t *arraypart_attr;
        diskseg_attr_t *diskseg_attr;
        task_attr_t *task_attr;
        property_attr_t *prop_attr;

        if (obj_id == OBJ_SYSTEM)
                return (OBJ_SYSTEM);

        /* If the object mapped by a handle */
        handle = raid_obj_get_handle(raid_tab, obj_id);
        if (handle != 0)
                return (handle);

        /* Search for existing handles */
        for (handle = raid_handle_sys.used; handle != 0;
            handle = raid_handle_sys.handles[handle].next)
                if (raid_handle_to_obj(raid_tab, handle) == obj_id)
                        break;

        if (handle != 0)
                return (handle);

        /* Allocate new handle for this object */
        type = raid_obj_get_type(raid_tab, obj_id);
        handle = raid_handle_new(type);
        (void) raid_obj_set_handle(raid_tab, obj_id, handle);
        raid_handle_sys.handles[handle].type = type;

        switch (type) {
        case OBJ_TYPE_SYSTEM:
                break;
        case OBJ_TYPE_CONTROLLER:
                controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].controller_id =
                    controller_attr->controller_id;
                break;
        case OBJ_TYPE_ARRAY:
                array_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].array_id = array_attr->array_id;
                obj_id = obj_get_controller(raid_tab, obj_id);
                controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].controller_id =
                    controller_attr->controller_id;
                break;
        case OBJ_TYPE_HSP:
                hsp_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].array_id =
                    hsp_attr->associated_id;
                obj_id = raid_obj_get_container(raid_tab, obj_id);
                disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].disk_id = disk_attr->disk_id;
                obj_id = obj_get_controller(raid_tab, obj_id);
                controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].controller_id =
                    controller_attr->controller_id;
                break;
        case OBJ_TYPE_DISK:
                disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].disk_id = disk_attr->disk_id;
                obj_id = obj_get_controller(raid_tab, obj_id);
                controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].controller_id =
                    controller_attr->controller_id;
                break;
        case OBJ_TYPE_ARRAY_PART:
                arraypart_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].disk_id =
                    arraypart_attr->disk_id;
                obj_id = raid_obj_get_container(raid_tab, obj_id);
                array_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].array_id =
                    array_attr->array_id;
                obj_id = obj_get_controller(raid_tab, obj_id);
                controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].controller_id =
                    controller_attr->controller_id;
                break;
        case OBJ_TYPE_DISK_SEG:
                diskseg_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].seq_id = diskseg_attr->seq_no;
                obj_id = raid_obj_get_container(raid_tab, obj_id);
                disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].disk_id =
                    disk_attr->disk_id;
                obj_id = obj_get_controller(raid_tab, obj_id);
                controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].controller_id =
                    controller_attr->controller_id;
                break;
        case OBJ_TYPE_TASK:
                task_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].task_id = task_attr->task_id;
                obj_id = obj_get_controller(raid_tab, obj_id);
                controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].controller_id =
                    controller_attr->controller_id;
                break;
        case OBJ_TYPE_PROP:
                prop_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].prop_id =
                    prop_attr->prop_id;
                obj_id = raid_obj_get_container(raid_tab, obj_id);
                disk_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].disk_id = disk_attr->disk_id;
                obj_id = obj_get_controller(raid_tab, obj_id);
                controller_attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                raid_handle_sys.handles[handle].controller_id =
                    controller_attr->controller_id;
                break;
        default:
                return (ERR_DEVICE_INVALID);
        }

        (void) raid_obj_set_handle(raid_tab, obj_id_backup, handle);
        return (handle);
}

static raid_lib_t *
raid_obj_get_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_handle_t handle;
        controller_attr_t *attr;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
                return (NULL);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        handle = raid_handle_sys.used;
        while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
            raid_handle_sys.handles[handle].controller_id !=
            attr->controller_id)
                handle = raid_handle_sys.handles[handle].next;

        if (handle == 0)
                return (NULL);

        return (raid_handle_sys.handles[handle].raid_lib);
}

static int
raid_obj_set_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_lib_t *raid_lib)
{
        raid_obj_handle_t handle;
        controller_attr_t *attr;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
                return (ERR_DEVICE_TYPE);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        handle = raid_handle_sys.used;
        while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
            raid_handle_sys.handles[handle].controller_id !=
            attr->controller_id)
                handle = raid_handle_sys.handles[handle].next;

        if (handle == 0)
                return (ERR_DEVICE_NOENT);

        raid_handle_sys.handles[handle].raid_lib = raid_lib;
        return (SUCCESS);
}

static int
raid_obj_get_fd(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_handle_t handle;
        controller_attr_t *attr;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
                return (ERR_DEVICE_TYPE);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        handle = raid_handle_sys.used;
        while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
            raid_handle_sys.handles[handle].controller_id !=
            attr->controller_id)
                handle = raid_handle_sys.handles[handle].next;

        if (handle == 0)
                return (ERR_DEVICE_NOENT);

        return (raid_handle_sys.handles[handle].fd);
}

static int
raid_obj_set_fd(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id, int fd)
{
        raid_obj_handle_t handle;
        controller_attr_t *attr;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
                return (ERR_DEVICE_TYPE);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        handle = raid_handle_sys.used;
        while (raid_handle_sys.handles[handle].type != OBJ_TYPE_CONTROLLER ||
            raid_handle_sys.handles[handle].controller_id !=
            attr->controller_id)
                handle = raid_handle_sys.handles[handle].next;

        if (handle == 0)
                return (ERR_DEVICE_NOENT);

        raid_handle_sys.handles[handle].fd = fd;
        return (SUCCESS);
}

/*
 * Raid object maintenance routines
 */
static int
obj_scan_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_status_t status;
        raid_obj_type_id_t type;
        int ret, i, obj_type_cnt, comp_num;
        raid_obj_id_t *comp_list;

        status = raid_obj_get_status(raid_tab, obj_id);
        if (status < SUCCESS)
                return (status);

        if (status & OBJ_STATUS_SCANCOMP)
                return (SUCCESS);

        type = raid_obj_get_type(raid_tab, obj_id);
        /* type less than OBJ_TYPE_SYSTEM means error */
        if (type < OBJ_TYPE_SYSTEM)
                return (ERR_DEVICE_INVALID);

        for (obj_type_cnt = OBJ_SYSTEM; obj_type_cnt < OBJ_TYPE_ALL;
            ++obj_type_cnt) {
                if (raid_obj_op_sys[type].compnum != NULL)
                        comp_num = raid_obj_op_sys[type].compnum(
                            raid_tab, obj_id, obj_type_cnt);
                else
                        comp_num = 0;

                if (comp_num < SUCCESS)
                        return (comp_num);
                if (comp_num == 0)
                        continue;

                comp_list = calloc(comp_num, sizeof (raid_obj_id_t));
                if (comp_list == NULL)
                        return (ERR_NOMEM);

                for (i = 0; i < comp_num; ++i) {
                        *(comp_list + i) = raid_obj_create(raid_tab,
                            obj_type_cnt);
                        if (*(comp_list + i) < SUCCESS) {
                                ret = *(comp_list + i);
                                free(comp_list);
                                return (ret);
                        }

                        (void) raid_obj_clear_status(raid_tab,
                            *(comp_list + i), OBJ_STATUS_CMD_CLEAN);
                        (void) raid_obj_add_org(raid_tab, *(comp_list + i),
                            obj_id);
                }

                if (raid_obj_op_sys[type].complist != NULL)
                        raid_obj_op_sys[type].complist(raid_tab,
                            obj_id, comp_num, comp_list, obj_type_cnt);
                free(comp_list);
        }

        (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_SCANCOMP);
        return (SUCCESS);
}

static int
obj_rescan(raid_obj_tab_t *raid_tab)
{
        int ret;

        raid_obj_tab_destroy(raid_tab);

        if (raid_obj_tab_create(raid_tab, HASH_SLOTS) != SUCCESS)
                return (ERR_NOMEM);

        if ((ret = raid_obj_create_system_obj(raid_tab)) != SUCCESS) {
                raid_obj_tab_destroy(raid_tab);
                return (ret);
        }

        return (SUCCESS);
}

static raid_obj_id_t
obj_get_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_type_id_t obj_type)
{
        raid_obj_id_t id;
        raid_obj_type_id_t type;
        raid_obj_status_t status;
        int ret;

        if ((obj_type < OBJ_TYPE_SYSTEM) || (obj_type > OBJ_TYPE_ALL))
                return (ERR_DEVICE_TYPE);

        status = raid_obj_get_status(raid_tab, obj_id);
        if (status < SUCCESS)
                return (status);

        if (!(status & OBJ_STATUS_SCANCOMP)) {
                ret = obj_scan_comp(raid_tab, obj_id);
                if (ret < SUCCESS)
                        return (ret);
        }

        id = raid_obj_get_comp(raid_tab, obj_id);
        if (id <= OBJ_NONE)
                return (id);

        type = raid_obj_get_type(raid_tab, id);
        if (type < OBJ_TYPE_SYSTEM)
                return (type);

        if (type == obj_type)
                return (id);

        while (id > OBJ_NONE) {
                id = raid_obj_get_sibling(raid_tab, id);
                if (id <= OBJ_NONE)
                        return (id);

                type = raid_obj_get_type(raid_tab, id);
                if (type < OBJ_TYPE_SYSTEM)
                        return (type);

                if (type == obj_type)
                        break;
        };

        return (id);
}

static raid_obj_id_t
obj_get_sibling(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_id_t id;
        raid_obj_type_id_t type, obj_type;

        id = obj_id;
        obj_type = raid_obj_get_type(raid_tab, id);
        if (obj_type < OBJ_TYPE_SYSTEM)
                return (obj_type);

        do {
                id = raid_obj_get_sibling(raid_tab, id);
                if (id < OBJ_NONE)
                        return (id);

                type = raid_obj_get_type(raid_tab, id);
                if (type < OBJ_TYPE_SYSTEM)
                        return (type);
        } while ((type != obj_type) && (id != OBJ_NONE));

        return (id);
}

static int
obj_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id, void **data)
{
        raid_obj_type_id_t type;
        raid_obj_status_t status;
        void *attr;
        int ret = SUCCESS;

        status = raid_obj_get_status(raid_tab, obj_id);
        if (status < SUCCESS)
                return (status);

        type = raid_obj_get_type(raid_tab, obj_id);
        if (type < OBJ_TYPE_SYSTEM)
                return (type);

        if (!(status & OBJ_STATUS_OPENED)) {
                if (raid_obj_op_sys[type].get_attr == NULL)
                        (void) raid_obj_set_status(raid_tab, obj_id,
                            OBJ_STATUS_OPENED);
                else
                        ret = raid_obj_op_sys[type].get_attr(raid_tab, obj_id);
        }
        if (ret < SUCCESS)
                return (ret);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL && type != OBJ_TYPE_SYSTEM)
                return (ERR_DEVICE_INVALID);

        *data = attr;
        return (SUCCESS);
}

static raid_obj_id_t
obj_locate_controller(raid_obj_tab_t *raid_tab, uint32_t controller_id)
{
        raid_obj_id_t obj_id;
        controller_attr_t *attr;

        obj_id = obj_get_comp(raid_tab, OBJ_SYSTEM, OBJ_TYPE_CONTROLLER);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        do {
                attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                if (attr == NULL)
                        return (ERR_DEVICE_INVALID);

                if (attr->controller_id == controller_id)
                        break;
        } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) != OBJ_NONE);

        return (obj_id);
}

static raid_obj_id_t
obj_locate_array(raid_obj_tab_t *raid_tab, uint32_t controller_id,
    uint32_t array_id)
{
        raid_obj_id_t obj_id;

        obj_id = obj_locate_controller(raid_tab, controller_id);
        if (obj_id < OBJ_NONE)
                return (obj_id);

        obj_id = obj_locate_array_recur(raid_tab, obj_id, array_id);

        return (obj_id);
}

static raid_obj_id_t
obj_locate_array_recur(raid_obj_tab_t *raid_tab,
    raid_obj_id_t container_obj_id, uint32_t array_id)
{
        raid_obj_id_t obj_id, ret;
        array_attr_t *attr;

        obj_id = obj_get_comp(raid_tab, container_obj_id, OBJ_TYPE_ARRAY);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        do {
                attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                if (attr == NULL)
                        return (ERR_DEVICE_INVALID);

                if (attr->array_id == array_id)
                        break;

                ret = obj_locate_array_recur(raid_tab, obj_id, array_id);
                if (ret != OBJ_NONE)
                        return (ret);

        } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);

        return (obj_id);
}

static raid_obj_id_t
obj_locate_hsp(raid_obj_tab_t *raid_tab, uint32_t controller_id,
    uint32_t disk_id, uint32_t array_id)
{
        raid_obj_id_t obj_id;
        hsp_attr_t *hsp_attr;

        obj_id = obj_locate_disk(raid_tab, controller_id, disk_id);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_HSP);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        do {
                (void) obj_get_attr(raid_tab, obj_id, (void **)(&hsp_attr));
                if (hsp_attr->associated_id == array_id)
                        break;

                obj_id = obj_get_sibling(raid_tab, obj_id);
                if (obj_id < OBJ_NONE)
                        return (obj_id);
        } while (obj_id > OBJ_NONE);

        return (obj_id);
}

static raid_obj_id_t
obj_locate_disk(raid_obj_tab_t *raid_tab, uint32_t controller_id,
    uint32_t disk_id)
{
        raid_obj_id_t obj_id;
        disk_attr_t *attr;

        obj_id = obj_locate_controller(raid_tab, controller_id);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_DISK);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        do {
                attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                if (attr == NULL)
                        return (ERR_DEVICE_INVALID);

                if (attr->disk_id == disk_id)
                        break;
        } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);

        return (obj_id);
}

static raid_obj_id_t
obj_locate_arraypart(raid_obj_tab_t *raid_tab, uint32_t controller_id,
    uint32_t array_id, uint32_t disk_id)
{
        raid_obj_id_t obj_id;

        arraypart_attr_t *attr;

        obj_id = obj_locate_array(raid_tab, controller_id, array_id);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_ARRAY_PART);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        do {
                attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                if (attr == NULL)
                        return (ERR_DEVICE_INVALID);

                if (attr->disk_id == disk_id)
                        break;
        } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) >
            OBJ_NONE);

        return (obj_id);
}

static raid_obj_id_t
obj_locate_diskseg(raid_obj_tab_t *raid_tab, uint32_t controller_id,
    uint32_t disk_id, uint32_t seq_no)
{
        raid_obj_id_t obj_id;
        diskseg_attr_t *attr;

        obj_id = obj_locate_disk(raid_tab, controller_id, disk_id);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_DISK_SEG);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        do {
                attr = raid_obj_get_data_ptr(raid_tab, obj_id);
                if (attr == NULL)
                        return (ERR_DEVICE_INVALID);

                if (attr->seq_no == seq_no)
                        break;
        } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);

        return (obj_id);
}

static raid_obj_id_t
obj_locate_task(raid_obj_tab_t *raid_tab, uint32_t controller_id,
    uint32_t task_id)
{
        raid_obj_id_t obj_id, obj_id2, task_obj_id;
        task_attr_t *attr;

        obj_id = obj_locate_controller(raid_tab, controller_id);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_ARRAY);
        if (obj_id < OBJ_NONE)
                return (obj_id);

        do {
                obj_id2 = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_ARRAY);
                while (obj_id2 != OBJ_NONE) {
                        task_obj_id = obj_get_comp(raid_tab, obj_id2,
                            OBJ_TYPE_TASK);

                        if (task_obj_id < OBJ_NONE)
                                return (task_obj_id);

                        if (task_obj_id == OBJ_NONE) {
                                obj_id2 = obj_get_sibling(raid_tab, obj_id2);
                                continue;
                        }

                        attr = raid_obj_get_data_ptr(raid_tab, task_obj_id);
                        if (attr == NULL)
                                return (ERR_DEVICE_INVALID);

                        if (attr->task_id == task_id)
                                return (task_obj_id);

                        obj_id2 = obj_get_sibling(raid_tab, obj_id2);
                }

                task_obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_TASK);
                if (task_obj_id < OBJ_NONE)
                        return (task_obj_id);

                if (task_obj_id == OBJ_NONE)
                        continue;

                attr = raid_obj_get_data_ptr(raid_tab, task_obj_id);
                if (attr == NULL)
                        return (ERR_DEVICE_INVALID);

                if (attr->task_id == task_id)
                        return (task_obj_id);
        } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);

        if (obj_id < OBJ_NONE)
                return (obj_id);

        obj_id = obj_locate_controller(raid_tab, controller_id);
        obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_DISK);
        if (obj_id < OBJ_NONE)
                return (obj_id);

        do {
                task_obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_TASK);
                if (task_obj_id < OBJ_NONE)
                        return (task_obj_id);

                if (task_obj_id == OBJ_NONE)
                        continue;

                attr = raid_obj_get_data_ptr(raid_tab, task_obj_id);
                if (attr == NULL)
                        return (ERR_DEVICE_INVALID);

                if (attr->task_id == task_id)
                        return (task_obj_id);
        } while ((obj_id = obj_get_sibling(raid_tab, obj_id)) > OBJ_NONE);

        return (obj_id);
}

static raid_obj_id_t
obj_locate_prop(raid_obj_tab_t *raid_tab, uint32_t controller_id,
    uint32_t disk_id, uint32_t prop_id)
{
        raid_obj_id_t obj_id;
        property_attr_t *prop_attr;

        obj_id = obj_locate_disk(raid_tab, controller_id, disk_id);
        if (obj_id < OBJ_NONE)
                return (obj_id);

        obj_id = obj_get_comp(raid_tab, obj_id, OBJ_TYPE_PROP);
        if (obj_id <= OBJ_NONE)
                return (obj_id);

        do {
                (void) obj_get_attr(raid_tab, obj_id, (void **)(&prop_attr));
                if (prop_attr->prop_id == prop_id)
                        break;

                obj_id = obj_get_sibling(raid_tab, obj_id);
                if (obj_id < OBJ_NONE)
                        return (obj_id);
        } while (obj_id > OBJ_NONE);

        return (obj_id);
}

static raid_obj_id_t
obj_get_controller(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_id_t id = obj_id;

        while (raid_obj_get_type(raid_tab, id) != OBJ_TYPE_CONTROLLER) {
                id = raid_obj_get_container(raid_tab, id);
                if ((id == OBJ_SYSTEM) || (id < OBJ_NONE))
                        return (ERR_DEVICE_INVALID);
        }

        return (id);
}

/*
 * Raid object operation routines
 */
static int
obj_sys_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_type_id_t comp_type)
{
        DIR *dir;
        struct dirent *dp;
        int num = 0;

        if ((raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_SYSTEM))
                return (ERR_DEVICE_TYPE);

        if (comp_type != OBJ_TYPE_CONTROLLER)
                return (0);

        if ((dir = opendir(CFGDIR)) == NULL)
                return (ERR_DRIVER_NOT_FOUND);

        while ((dp = readdir(dir)) != NULL) {
                uint32_t controller_id;
                char path[MAX_PATH_LEN];

                if (strcmp(dp->d_name, ".") == 0 ||
                    strcmp(dp->d_name, "..") == 0)
                        continue;

                if (sscanf(dp->d_name, "c%u", &controller_id) != 1)
                        continue;

                if (controller_id_to_path(controller_id, path) == SUCCESS)
                        ++ num;
        }

        (void) closedir(dir);
        return (num);
}

static int
obj_sys_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    int num, raid_obj_id_t *comp_list, raid_obj_type_id_t comp_type)
{
        DIR *dir;
        struct dirent *dp;
        controller_attr_t *attr;
        uint32_t controller_id;
        uint32_t *tmplist;
        char path[MAX_PATH_LEN];
        int i = 0;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_SYSTEM)
                return (ERR_DEVICE_TYPE);
        if ((num <= 0) || (comp_list == NULL))
                return (ERR_OP_ILLEGAL);

        if (comp_type != OBJ_TYPE_CONTROLLER)
                return (0);

        if ((dir = opendir(CFGDIR)) == NULL)
                return (ERR_DRIVER_NOT_FOUND);
        tmplist = calloc(num, sizeof (uint32_t));
        if (tmplist == NULL) {
                return (ERR_NOMEM);
        }
        while ((dp = readdir(dir)) != NULL) {
                if (strcmp(dp->d_name, ".") == 0 ||
                    strcmp(dp->d_name, "..") == 0)
                        continue;

                if (sscanf(dp->d_name, "c%u", &controller_id) != 1)
                        continue;

                if (controller_id_to_path(controller_id, path) == SUCCESS) {
                        tmplist[i] = controller_id;
                        ++ i;
                }
        }
        qsort((void *)tmplist, num, sizeof (uint32_t), intcompare);
        for (i = 0; i < num; i++) {
                attr = raid_obj_get_data_ptr(raid_tab,
                    *(comp_list + i));

                if (attr == NULL) {
                        free(tmplist);
                        return (ERR_DEVICE_INVALID);
                }

                attr->controller_id = tmplist[i];
        }
        free(tmplist);
        (void) closedir(dir);
        return (SUCCESS);
}

static int
obj_controller_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_type_id_t comp_type)
{
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;
        controller_attr_t *ctl_attrp;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
                return (ERR_DEVICE_TYPE);

        if ((comp_type != OBJ_TYPE_ARRAY) && (comp_type != OBJ_TYPE_DISK))
                return (0);

        raid_lib = raid_obj_get_lib(raid_tab, obj_id);
        fd = raid_obj_get_fd(raid_tab, obj_id);
        ctl_attrp = raid_obj_get_data_ptr(raid_tab, obj_id);
        if ((raid_lib == NULL) || (ctl_attrp == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->compnum(ctl_attrp->controller_id, 0,
            OBJ_TYPE_CONTROLLER, comp_type);

        return (ret);
}

static int
obj_controller_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    int comp_num, raid_obj_id_t *comp_list, raid_obj_type_id_t comp_type)
{
        raid_lib_t *raid_lib;
        controller_attr_t *ctl_attrp;
        int ret, i, fd;
        uint32_t *ids;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
                return (ERR_DEVICE_TYPE);

        if ((comp_type != OBJ_TYPE_ARRAY) && (comp_type != OBJ_TYPE_DISK))
                return (0);

        if ((comp_num <= 0) || (comp_list == NULL))
                return (ERR_OP_ILLEGAL);

        for (i = 0; i < comp_num; ++i)
                if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
                    comp_type)
                        return (ERR_DEVICE_TYPE);

        raid_lib = raid_obj_get_lib(raid_tab, obj_id);
        ctl_attrp = raid_obj_get_data_ptr(raid_tab, obj_id);
        fd = raid_obj_get_fd(raid_tab, obj_id);
        if ((raid_lib == NULL) || (ctl_attrp == NULL)|| (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ids = malloc(comp_num * sizeof (uint32_t));
        if (ids == NULL)
                return (ERR_NOMEM);

        ret = raid_lib->complist(ctl_attrp->controller_id, 0,
            OBJ_TYPE_CONTROLLER, comp_type, comp_num, ids);
        if (ret < SUCCESS) {
                free(ids);
                return (ret);
        }
        qsort((void *)ids, comp_num, sizeof (uint32_t), intcompare);
        for (i = 0; i < comp_num; ++ i) {
                array_attr_t *array_attr;
                disk_attr_t *disk_attr;
                void *attr_buf;

                attr_buf = raid_obj_get_data_ptr(raid_tab, *(comp_list + i));
                if (attr_buf == NULL) {
                        free(ids);
                        return (ERR_DEVICE_INVALID);
                }

                switch (comp_type) {
                case OBJ_TYPE_ARRAY:
                        array_attr = attr_buf;
                        array_attr->array_id = *(ids + i);
                        break;
                case OBJ_TYPE_DISK:
                        disk_attr = attr_buf;
                        disk_attr->disk_id = *(ids + i);
                        break;
                default:
                        free(ids);
                        return (ERR_DEVICE_INVALID);
                }
        }

        free(ids);
        return (SUCCESS);
}

static int
obj_controller_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        controller_attr_t *attr;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
                return (ERR_DEVICE_TYPE);

        if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
                return (SUCCESS);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        raid_lib = raid_obj_get_lib(raid_tab, obj_id);
        fd = raid_obj_get_fd(raid_tab, obj_id);

        /*
         * For a controller, even it's not opened, we can still
         * get the driver name
         */

        if (fd == 0)
                return (SUCCESS);

        if (raid_lib == NULL) {
                return (SUCCESS);
        }

        ret = raid_lib->get_attr(attr->controller_id, OBJ_ATTR_NONE,
            OBJ_ATTR_NONE, OBJ_TYPE_CONTROLLER, attr);
        if (ret < SUCCESS)
                return (ret);

        (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);

        return (ret);
}

static int
obj_controller_act(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    uint32_t sub_cmd, void *prop_list, char **plugin_err_str)
{
        controller_attr_t *attr;
        raid_lib_t *raid_lib;
        int ret, fd;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_CONTROLLER)
                return (ERR_DEVICE_TYPE);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);

        raid_lib = raid_obj_get_lib(raid_tab, obj_id);
        fd = raid_obj_get_fd(raid_tab, obj_id);

        switch (sub_cmd) {
        case ACT_CONTROLLER_OPEN:
                /* Check if already opened */

                if (fd > 0)
                        return (SUCCESS);

                /* Check if plugin is already attached */
                if (raid_lib == NULL) {
                        raid_lib = raid_find_lib(raid_tab, obj_id);
                        if (raid_lib == NULL)
                                return (ERR_DRIVER_NOT_FOUND);
                }

                ret = raid_lib->open_controller(attr->controller_id,
                    plugin_err_str);
                if (ret == SUCCESS) {
                        (void) raid_obj_set_lib(raid_tab, obj_id, raid_lib);
                        (void) raid_obj_set_fd(raid_tab, obj_id, 1);
                }
                break;
        case ACT_CONTROLLER_CLOSE:

                if (fd <= 0)
                        return (SUCCESS);

                if (raid_lib == NULL) {
                        return (SUCCESS);
                }
                ret = raid_lib->close_controller(attr->controller_id,
                    plugin_err_str);
                if (ret == SUCCESS) {
                        (void) raid_obj_set_fd(raid_tab, obj_id, 0);
                        (void) raid_obj_set_lib(raid_tab, obj_id, NULL);
                        raid_handle_delete_controller_comp(attr->controller_id);
                }
                break;
        case ACT_CONTROLLER_FLASH_FW:
                {
                        char            *filebuf;
                        int             image_fd;
                        uint32_t        size;
                        struct stat     statbuf;

                        if (prop_list == NULL)
                                return (ERR_OP_ILLEGAL);

                        /* Open firmware image file */
                        image_fd = open((const char *)prop_list,
                            O_RDONLY | O_NDELAY);
                        if (image_fd == -1)
                                return (ERR_OP_FAILED);

                        if (fstat(image_fd, &statbuf) != 0) {
                                (void) close(image_fd);
                                return (ERR_OP_FAILED);
                        }

                        filebuf = malloc(statbuf.st_size);
                        if (filebuf == NULL) {
                                (void) close(image_fd);
                                return (ERR_NOMEM);
                        }

                        size = read(image_fd, filebuf, statbuf.st_size);
                        if (size != statbuf.st_size) {
                                (void) close(image_fd);
                                free(filebuf);
                                return (ERR_OP_FAILED);
                        }

                        if (fd <= 0) {
                                (void) close(image_fd);
                                free(filebuf);
                                return (ERR_DRIVER_CLOSED);
                        }

                        if (raid_lib == NULL) {
                                (void) close(image_fd);
                                free(filebuf);
                                return (ERR_DRIVER_CLOSED);
                        }
                        if (raid_lib->flash_fw == NULL) {
                                (void) close(image_fd);
                                free(filebuf);
                                return (ERR_OP_NO_IMPL);
                        }

                        ret = raid_lib->flash_fw(attr->controller_id,
                            filebuf, size, plugin_err_str);
                }
                break;
        default:
                return (ERR_OP_ILLEGAL);
        }

        return (ret);
}

static int
obj_array_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_type_id_t comp_type)
{
        array_attr_t *attr;
        controller_attr_t *ctl_attrp;
        raid_obj_id_t controller_obj_id;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY)
                return (ERR_DEVICE_TYPE);

        if (comp_type != OBJ_TYPE_ARRAY_PART &&
            comp_type != OBJ_TYPE_ARRAY &&
            comp_type != OBJ_TYPE_TASK)
                return (0);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->compnum(ctl_attrp->controller_id, attr->array_id,
            OBJ_TYPE_ARRAY, comp_type);

        return (ret);
}

static int
obj_array_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    int comp_num, raid_obj_id_t *comp_list, raid_obj_type_id_t comp_type)
{
        array_attr_t *attr;
        controller_attr_t *ctl_attrp;
        raid_obj_id_t controller_obj_id;
        raid_lib_t *raid_lib;
        int ret, i, fd;
        uint32_t *ids;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY)
                return (ERR_DEVICE_TYPE);

        if (comp_type != OBJ_TYPE_ARRAY_PART &&
            comp_type != OBJ_TYPE_ARRAY &&
            comp_type != OBJ_TYPE_TASK)
                return (0);

        if (comp_num <= 0 || comp_list == NULL)
                return (ERR_OP_ILLEGAL);

        for (i = 0; i < comp_num; ++i)
                if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
                    comp_type)
                        return (ERR_DEVICE_TYPE);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ids = malloc(comp_num * sizeof (uint32_t));
        if (ids == NULL)
                return (ERR_NOMEM);

        ret = raid_lib->complist(ctl_attrp->controller_id,
            attr->array_id, OBJ_TYPE_ARRAY, comp_type, comp_num, ids);

        if (ret < SUCCESS) {
                free(ids);
                return (ret);
        }

        for (i = 0; i < comp_num; ++ i) {
                array_attr_t *array_attr;
                arraypart_attr_t *arraypart_attr;
                task_attr_t *task_attr;
                void *attr_buf;

                attr_buf = raid_obj_get_data_ptr(raid_tab, *(comp_list + i));
                if (attr_buf == NULL) {
                        free(ids);
                        return (ERR_DEVICE_INVALID);
                }

                switch (comp_type) {
                case OBJ_TYPE_ARRAY:
                        array_attr = attr_buf;
                        array_attr->array_id = *(ids + i);
                        break;
                case OBJ_TYPE_ARRAY_PART:
                        arraypart_attr = attr_buf;
                        arraypart_attr->disk_id = *(ids + i);
                        break;
                case OBJ_TYPE_TASK:
                        task_attr = attr_buf;
                        task_attr->task_id = *(ids + i);
                        break;
                default:
                        free(ids);
                        return (ERR_DEVICE_INVALID);
                }
        }


        free(ids);
        return (ret);
}

static int
obj_array_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        array_attr_t *attr;
        controller_attr_t *ctl_attrp;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;
        raid_obj_id_t controller_obj_id;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY)
                return (ERR_DEVICE_TYPE);

        if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
                return (SUCCESS);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->get_attr(ctl_attrp->controller_id,
            attr->array_id, 0, OBJ_TYPE_ARRAY, attr);

        if (ret < SUCCESS)
                return (ret);

        (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);

        return (ret);
}

static int
obj_array_set_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    uint32_t sub_cmd, uint32_t *value, char **plugin_err_str)
{
        array_attr_t *attr;
        controller_attr_t *ctl_attrp;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;
        raid_obj_id_t controller_obj_id;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY)
                return (ERR_DEVICE_TYPE);

        switch (sub_cmd) {
        case SET_CACHE_WR_PLY:
                if (*value != CACHE_WR_OFF &&
                    *value != CACHE_WR_ON)
                        return (ERR_OP_ILLEGAL);
                break;
        case SET_CACHE_RD_PLY:
                if (*value != CACHE_RD_OFF &&
                    *value != CACHE_RD_ON)
                        return (ERR_OP_ILLEGAL);
                break;
        case SET_ACTIVATION_PLY:
                if (*value != ARRAY_ACT_ACTIVATE)
                        return (ERR_OP_ILLEGAL);
                break;
        default:
                return (ERR_OP_ILLEGAL);
        }

        (void) obj_get_attr(raid_tab, obj_id, (void **)(&attr));

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        if (raid_lib->set_attr == NULL)
                return (ERR_OP_NO_IMPL);

        ret = raid_lib->set_attr(ctl_attrp->controller_id,
            attr->array_id, sub_cmd, value, plugin_err_str);

        return (ret);
}

static int
obj_disk_compnum(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_type_id_t comp_type)
{
        disk_attr_t *attr;
        controller_attr_t *ctl_attrp;
        raid_obj_id_t controller_obj_id;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_DISK)
                return (ERR_DEVICE_TYPE);

        if (comp_type != OBJ_TYPE_DISK_SEG &&
            comp_type != OBJ_TYPE_HSP &&
            comp_type != OBJ_TYPE_TASK &&
            comp_type != OBJ_TYPE_PROP)
                return (0);
        ret = obj_get_attr(raid_tab, obj_id, (void **)(&attr));
        if ((ret != SUCCESS) || (attr == NULL)) {
                return (ERR_DEVICE_INVALID);
        }
        if (attr->state == DISK_STATE_FAILED) {
                return (SUCCESS);
        }

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->compnum(ctl_attrp->controller_id,
            attr->disk_id, OBJ_TYPE_DISK, comp_type);

        return (ret);
}

static int
obj_disk_complist(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    int comp_num, raid_obj_id_t *comp_list, raid_obj_type_id_t comp_type)
{
        disk_attr_t *attr;
        controller_attr_t *ctl_attrp;
        raid_obj_id_t controller_obj_id;
        raid_lib_t *raid_lib;
        int ret, i, fd;
        uint32_t *ids;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_DISK)
                return (ERR_DEVICE_TYPE);

        if (comp_type != OBJ_TYPE_DISK_SEG &&
            comp_type != OBJ_TYPE_HSP &&
            comp_type != OBJ_TYPE_TASK &&
            comp_type != OBJ_TYPE_PROP)
                return (0);

        if (comp_num <= 0 || comp_list == NULL)
                return (ERR_OP_ILLEGAL);

        for (i = 0; i < comp_num; ++i)
                if (raid_obj_get_type(raid_tab, *(comp_list + i)) !=
                    comp_type)
                        return (ERR_DEVICE_TYPE);
        ret = obj_get_attr(raid_tab, obj_id, (void **)(&attr));
        if ((ret != SUCCESS) || (attr == NULL)) {
                return (ERR_DEVICE_INVALID);
        }
        if (attr->state == DISK_STATE_FAILED) {
                return (SUCCESS);
        }

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ids = malloc(comp_num * sizeof (uint32_t));
        if (ids == NULL)
                return (ERR_NOMEM);

        ret = raid_lib->complist(ctl_attrp->controller_id,
            attr->disk_id, OBJ_TYPE_DISK, comp_type, comp_num, ids);

        if (ret < SUCCESS) {
                free(ids);
                return (ret);
        }

        for (i = 0; i < comp_num; ++ i) {
                diskseg_attr_t *diskseg_attr;
                hsp_attr_t *hsp_attr;
                task_attr_t *task_attr;
                property_attr_t *prop_attr;
                void *attr_buf;

                attr_buf = raid_obj_get_data_ptr(raid_tab, *(comp_list + i));
                if (attr_buf == NULL) {
                        free(ids);
                        return (ERR_DEVICE_INVALID);
                }

                switch (comp_type) {
                case OBJ_TYPE_DISK_SEG:
                        diskseg_attr = attr_buf;
                        diskseg_attr->seq_no = *(ids + i);
                        break;
                case OBJ_TYPE_HSP:
                        hsp_attr = attr_buf;
                        hsp_attr->associated_id = *(ids + i);
                        break;
                case OBJ_TYPE_TASK:
                        task_attr = attr_buf;
                        task_attr->task_id = *(ids + i);
                        break;
                case OBJ_TYPE_PROP:
                        prop_attr = attr_buf;
                        prop_attr->prop_id = *(ids + i);
                        break;
                default:
                        free(ids);
                        return (ERR_DEVICE_INVALID);
                }
        }


        free(ids);
        return (ret);
}

static int
obj_disk_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        disk_attr_t *attr;
        controller_attr_t *ctl_attrp;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;
        raid_obj_id_t controller_obj_id;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_DISK)
                return (ERR_DEVICE_TYPE);

        if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
                return (SUCCESS);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->get_attr(ctl_attrp->controller_id,
            attr->disk_id, 0, OBJ_TYPE_DISK, attr);

        if (ret < SUCCESS)
                return (ret);

        (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);

        return (ret);
}

static int
obj_hsp_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        hsp_attr_t *attr;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_HSP)
                return (ERR_DEVICE_TYPE);

        if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
                return (SUCCESS);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        if (attr->associated_id == (uint32_t)OBJ_ATTR_NONE)
                attr->type = HSP_TYPE_GLOBAL;
        else
                attr->type = HSP_TYPE_LOCAL;

        return (SUCCESS);
}

static int
obj_arraypart_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        arraypart_attr_t *attr;
        array_attr_t *array_attr;
        controller_attr_t *ctl_attrp;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;
        raid_obj_id_t controller_obj_id, array_obj_id;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_ARRAY_PART)
                return (ERR_DEVICE_TYPE);

        if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
                return (SUCCESS);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        array_obj_id = raid_obj_get_container(raid_tab, obj_id);
        if (array_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        array_attr = raid_obj_get_data_ptr(raid_tab, array_obj_id);
        if (array_attr == NULL)
                return (ERR_DEVICE_INVALID);

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->get_attr(ctl_attrp->controller_id,
            array_attr->array_id, attr->disk_id,
            OBJ_TYPE_ARRAY_PART, attr);

        if (ret < SUCCESS)
                return (ret);

        (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);

        return (ret);
}

static int
obj_diskseg_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        diskseg_attr_t *attr;
        disk_attr_t *disk_attr;
        controller_attr_t *ctl_attrp;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;
        raid_obj_id_t controller_obj_id, disk_obj_id;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_DISK_SEG)
                return (ERR_DEVICE_TYPE);

        if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
                return (SUCCESS);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        disk_obj_id = raid_obj_get_container(raid_tab, obj_id);
        if (disk_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        disk_attr = raid_obj_get_data_ptr(raid_tab, disk_obj_id);
        if (disk_attr == NULL)
                return (ERR_DEVICE_INVALID);

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->get_attr(ctl_attrp->controller_id,
            disk_attr->disk_id, attr->seq_no, OBJ_TYPE_DISK_SEG, attr);

        if (ret < SUCCESS)
                return (ret);

        (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);

        return (ret);
}

static int
obj_task_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        task_attr_t *attr;
        controller_attr_t *ctl_attrp;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;
        raid_obj_id_t controller_obj_id;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_TASK)
                return (ERR_DEVICE_TYPE);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->get_attr(ctl_attrp->controller_id,
            attr->task_id, OBJ_ATTR_NONE, OBJ_TYPE_TASK, attr);

        return (ret);
}

static int
obj_prop_get_attr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        property_attr_t *attr, *attr_new;
        disk_attr_t *disk_attr;
        controller_attr_t *ctl_attrp;
        raid_lib_t *raid_lib;
        int ret = SUCCESS, fd;
        raid_obj_id_t controller_obj_id, disk_obj_id;

        if (raid_obj_get_type(raid_tab, obj_id) != OBJ_TYPE_PROP)
                return (ERR_DEVICE_TYPE);

        if (raid_obj_get_status(raid_tab, obj_id) & OBJ_STATUS_OPENED)
                return (SUCCESS);

        attr = raid_obj_get_data_ptr(raid_tab, obj_id);
        if (attr == NULL)
                return (ERR_DEVICE_INVALID);

        disk_obj_id = raid_obj_get_container(raid_tab, obj_id);
        if (disk_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        disk_attr = raid_obj_get_data_ptr(raid_tab, disk_obj_id);
        if (disk_attr == NULL)
                return (ERR_DEVICE_INVALID);

        controller_obj_id = obj_get_controller(raid_tab, obj_id);
        if (controller_obj_id < OBJ_NONE)
                return (ERR_DEVICE_INVALID);

        ctl_attrp = raid_obj_get_data_ptr(raid_tab, controller_obj_id);
        if (ctl_attrp == NULL) {
                return (ERR_DEVICE_INVALID);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        /* Get the property size at first */
        attr->prop_size = 0;
        ret = raid_lib->get_attr(ctl_attrp->controller_id,
            disk_attr->disk_id, OBJ_ATTR_NONE, OBJ_TYPE_PROP, attr);

        if (ret < SUCCESS)
                return (ret);

        /* Allocate memory for property and fill the buffer */
        attr_new = realloc(attr, sizeof (property_attr_t) + attr->prop_size);
        if (attr_new == NULL)
                return (ERR_NOMEM);

        (void) raid_obj_set_data_ptr(raid_tab, obj_id, attr_new);

        ret = raid_lib->get_attr(ctl_attrp->controller_id,
            disk_attr->disk_id, OBJ_ATTR_NONE, OBJ_TYPE_PROP, attr_new);

        if (ret < SUCCESS)
                return (ret);

        (void) raid_obj_set_status(raid_tab, obj_id, OBJ_STATUS_OPENED);

        return (ret);
}

static int
obj_array_create(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
    int num_of_comp, raid_obj_id_t *disk_list, char **plugin_err_str)
{
        controller_attr_t *controller_attr;
        array_attr_t *array_attr, array_attr2;
        disk_attr_t *disk_attr;
        arraypart_attr_t *arraypart_attrs;
        raid_obj_id_t obj_id, controller_obj_id = OBJ_NONE;
        raid_lib_t *raid_lib;
        int i, j, ret, fd;
        int disk_cnt = 0, disk_set_num = 0, set_num = 0, layer_cnt = 0;
        uint64_t min_disk_capacity = 0;

        array_attr = raid_obj_get_data_ptr(raid_tab, array_obj_id);
        if (array_attr == NULL)
                return (ERR_DEVICE_INVALID);

        /* Check the disk layout expression */
        if (disk_list[0] != OBJ_SEPARATOR_BEGIN ||
            disk_list[num_of_comp - 1] != OBJ_SEPARATOR_END)
                return (ERR_ARRAY_LAYOUT);
        for (i = 0; i < num_of_comp; ++i) {
                if (disk_list[i] == OBJ_SEPARATOR_BEGIN) {
                        if (disk_cnt != 0)
                                return (ERR_ARRAY_LAYOUT);
                        ++layer_cnt;
                        continue;
                }
                if (disk_list[i] == OBJ_SEPARATOR_END) {
                        if (disk_set_num == 0)
                                disk_set_num = disk_cnt;
                        else if (disk_set_num != disk_cnt && disk_cnt != 0)
                                return (ERR_ARRAY_LAYOUT);
                        disk_cnt = 0;
                        ++set_num;
                        --layer_cnt;
                        continue;
                }
                switch (array_attr->raid_level) {
                case RAID_LEVEL_0:
                case RAID_LEVEL_1:
                case RAID_LEVEL_1E:
                case RAID_LEVEL_5:
                        if (layer_cnt != 1)
                                return (ERR_ARRAY_LAYOUT);
                        break;
                case RAID_LEVEL_10:
                case RAID_LEVEL_50:
                        if (layer_cnt != 2)
                                return (ERR_ARRAY_LAYOUT);
                        break;
                default:
                        return (ERR_ARRAY_LEVEL);
                }
                ++disk_cnt;
        }

        if (layer_cnt != 0)
                return (ERR_ARRAY_LAYOUT);

        switch (array_attr->raid_level) {
        case RAID_LEVEL_0:
                if (disk_set_num < 2 || set_num != 1)
                        return (ERR_ARRAY_LAYOUT);
                break;
        case RAID_LEVEL_1:
                if (disk_set_num != 2 || set_num != 1)
                        return (ERR_ARRAY_LAYOUT);
                break;
        case RAID_LEVEL_1E:
        case RAID_LEVEL_5:
                if (disk_set_num < 3 || set_num != 1)
                        return (ERR_ARRAY_LAYOUT);
                break;
        case RAID_LEVEL_10:
                if (disk_set_num != 2 || set_num < 2)
                        return (ERR_ARRAY_LAYOUT);
                break;
        case RAID_LEVEL_50:
                if (disk_set_num < 3 || set_num < 2)
                        return (ERR_ARRAY_LAYOUT);
                break;
        default:
                return (ERR_ARRAY_LEVEL);
        }

        arraypart_attrs = calloc(num_of_comp, sizeof (arraypart_attr_t));
        if (arraypart_attrs == NULL)
                return (ERR_NOMEM);

        for (i = 0; i < num_of_comp; ++i) {
                /* Keep seperators */
                if (*(disk_list + i) == OBJ_SEPARATOR_BEGIN) {
                        arraypart_attrs[i].disk_id =
                            (uint32_t)OBJ_SEPARATOR_BEGIN;
                        continue;
                }

                if (*(disk_list + i) == OBJ_SEPARATOR_END) {
                        arraypart_attrs[i].disk_id =
                            (uint32_t)OBJ_SEPARATOR_END;
                        continue;
                }

                disk_cnt++;
                /* Check if it's a disk */
                if (raid_obj_get_type(raid_tab, *(disk_list + i)) !=
                    OBJ_TYPE_DISK)
                        return (ERR_DEVICE_TYPE);

                /* Check if it's duplicated with other disks */
                for (j = 0; j < i; ++j)
                        if (*(disk_list + j) == *(disk_list + i)) {
                                free(arraypart_attrs);
                                return (ERR_DEVICE_DUP);
                        }

                /* Check disk status */
                ret = obj_get_attr(raid_tab, *(disk_list + i),
                    (void **)(&disk_attr));
                if (ret != SUCCESS)
                        return (ret);

                if (disk_attr->state != DISK_STATE_GOOD) {
                        free(arraypart_attrs);
                        return (ERR_DISK_STATE);
                }

                /* All disks must belong to the same controller */
                obj_id = obj_get_controller(raid_tab, *(disk_list + i));
                if (obj_id <= OBJ_NONE)
                        return (obj_id);
                if (controller_obj_id == OBJ_NONE) {
                        controller_obj_id = obj_id;
                        ret = obj_get_attr(raid_tab, controller_obj_id,
                            (void **)(&controller_attr));
                } else if (obj_id != controller_obj_id) {
                        free(arraypart_attrs);
                        return (ERR_DRIVER_ACROSS);
                }

                /* Check if the disk contains too many segments */
                obj_id = obj_get_comp(raid_tab, *(disk_list + i),
                    OBJ_TYPE_DISK_SEG);
                j = 0;
                while (obj_id > OBJ_NONE) {
                        ++j;
                        obj_id = obj_get_sibling(raid_tab, obj_id);
                }
                if (j > controller_attr->max_seg_per_disk) {
                        free(arraypart_attrs);
                        return (ERR_DISK_SEG_AMOUNT);
                }

                /* Check if controller is a hostraid controller */
                if (controller_attr->capability & RAID_CAP_DISK_TRANS) {
                        /*
                         * For hostraid, the first disk should
                         * be with of minimum capacity
                         */
                        if (min_disk_capacity == 0) {
                                min_disk_capacity = disk_attr->capacity;

                                /* Can not specify capacity for hostraid */
                                if (array_attr->capacity != 0) {
                                        free(arraypart_attrs);
                                        return (ERR_OP_ILLEGAL);
                                }
                        } else if (min_disk_capacity > disk_attr->capacity) {
                                free(arraypart_attrs);
                                return (ERR_DISK_SPACE);
                        }

                        /* Disk should not be used for hostraid */
                        obj_id = obj_get_comp(raid_tab, *(disk_list + i),
                            OBJ_TYPE_DISK_SEG);
                        if (obj_id < OBJ_NONE) {
                                free(arraypart_attrs);
                                return (obj_id);
                        } else if (obj_id > OBJ_NONE) {
                                free(arraypart_attrs);
                                return (ERR_DISK_NOT_EMPTY);
                        }
                }

                arraypart_attrs[i].disk_id = disk_attr->disk_id;
                arraypart_attrs[i].offset = OBJ_ATTR_NONE;
                arraypart_attrs[i].size = OBJ_ATTR_NONE;
        }

        /* Check if array amount exceeds limit */
        if (controller_attr->max_array_num <=
            obj_controller_compnum(raid_tab, controller_obj_id,
            OBJ_TYPE_ARRAY))
                return (ERR_ARRAY_AMOUNT);


        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        /* Check if the controller can support the array RAID level */
        switch (array_attr->raid_level) {
        case    RAID_LEVEL_0:
                if (!(controller_attr->capability & RAID_CAP_RAID0)) {
                        free(arraypart_attrs);
                        return (ERR_ARRAY_LEVEL);
                }
                break;
        case    RAID_LEVEL_1:
                if (!(controller_attr->capability & RAID_CAP_RAID1)) {
                        free(arraypart_attrs);
                        return (ERR_ARRAY_LEVEL);
                }
                break;
        case    RAID_LEVEL_1E:
                if (!(controller_attr->capability & RAID_CAP_RAID1E)) {
                        free(arraypart_attrs);
                        return (ERR_ARRAY_LEVEL);
                }
                break;
        case    RAID_LEVEL_5:
                if (!(controller_attr->capability & RAID_CAP_RAID5)) {
                        free(arraypart_attrs);
                        return (ERR_ARRAY_LEVEL);
                }
                break;
        case    RAID_LEVEL_10:
                if (!(controller_attr->capability & RAID_CAP_RAID10)) {
                        free(arraypart_attrs);
                        return (ERR_ARRAY_LEVEL);
                }
                break;
        case    RAID_LEVEL_50:
                if (!(controller_attr->capability & RAID_CAP_RAID50)) {
                        free(arraypart_attrs);
                        return (ERR_ARRAY_LEVEL);
                }
                break;
        default:
                free(arraypart_attrs);
                return (ERR_ARRAY_LEVEL);
        }

        /* Check if plug in can calculate the maximum size */
        (void) memcpy(&array_attr2, array_attr, sizeof (array_attr_t));
        array_attr2.capacity = OBJ_ATTR_NONE;
        ret = raid_lib->array_create(controller_attr->controller_id,
            &array_attr2, num_of_comp, arraypart_attrs, plugin_err_str);

        /* If plugin/driver will not calculate space */
        if (ret == ERR_OP_NO_IMPL) {
                /* Calculate the maximum capacity */
                array_attr2.capacity = raid_space_noalign(raid_tab,
                    array_attr2.raid_level, num_of_comp, disk_list,
                    arraypart_attrs);

                /*
                 * If controller is capable to allocate space,
                 * set offset and size attributes to OBJ_ATTR_NONE
                 * and let the controller to determine these value
                 */
                if (controller_attr->capability & RAID_CAP_SMART_ALLOC)
                        for (i = 0; i < num_of_comp; ++i) {
                                arraypart_attrs[i].offset =
                                    OBJ_ATTR_NONE;
                                arraypart_attrs[i].size =
                                    OBJ_ATTR_NONE;
                        }

                /* There's no enough space for specified capacity */
                if (array_attr->capacity > array_attr2.capacity) {
                        free(arraypart_attrs);
                        return (ERR_ARRAY_SIZE);
                }

                /* capacity == 0, allocate maximum space */
                if (array_attr->capacity == 0)
                        array_attr->capacity = array_attr2.capacity;
        } else if (ret < SUCCESS) {
                free(arraypart_attrs);
                return (ret);
        } else if (array_attr2.capacity < array_attr->capacity) {
                /* Return the maximum size */
                array_attr->capacity = array_attr2.capacity;
                free(arraypart_attrs);
                return (ERR_ARRAY_SIZE);
        }

        if (array_attr->capacity < ARRAYPART_MIN_SIZE * disk_cnt) {
                free(arraypart_attrs);
                return (ERR_ARRAY_SIZE);
        }


        ret = raid_lib->array_create(controller_attr->controller_id,
            array_attr, num_of_comp, arraypart_attrs, plugin_err_str);
        free(arraypart_attrs);

        if (ret != SUCCESS)
                return (ret);

        /* Add array object into device tree so that we can map the handle */
        (void) raid_obj_add_org(raid_tab, array_obj_id, controller_obj_id);

        return (ret);
}

static int
obj_array_delete(raid_obj_tab_t *raid_tab, raid_obj_id_t array_obj_id,
    char **plugin_err_str)
{
        raid_obj_id_t controller_obj_id;
        controller_attr_t *controller_attr;
        array_attr_t *array_attr;
        raid_lib_t *raid_lib;
        int ret, fd;
        uint32_t *disk_ids = NULL;

        controller_obj_id = obj_get_controller(raid_tab, array_obj_id);
        if (controller_obj_id <= OBJ_NONE)
                return (controller_obj_id);

        ret = obj_get_attr(raid_tab, controller_obj_id,
            (void **)(&controller_attr));
        if (ret < SUCCESS) {
                return (ret);
        }
        ret = obj_get_attr(raid_tab, array_obj_id, (void **)(&array_attr));
        if (ret < SUCCESS)
                return (ret);

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        ret = raid_lib->array_delete(controller_attr->controller_id,
            array_attr->array_id, plugin_err_str);
        if (ret < SUCCESS) {
                if (disk_ids)
                        free(disk_ids);
                return (ret);
        }

        if (disk_ids)
                free(disk_ids);
        return (ret);
}

static int
obj_hsp_bind(raid_obj_tab_t *raid_tab, raid_obj_id_t *obj_ids,
    char **plugin_err_str)
{
        raid_obj_id_t obj_id, controller_obj_id = OBJ_NONE;
        raid_obj_id_t array_obj_id, disk_obj_id;
        hsp_relation_t *hsp_relation;
        controller_attr_t *controller_attr;
        array_attr_t *array_attr;
        arraypart_attr_t *arraypart_attr;
        disk_attr_t *disk_attr;
        diskseg_attr_t *diskseg_attr;
        hsp_attr_t *hsp_attr;
        raid_lib_t *raid_lib;
        int ret, fd;

        hsp_relation = malloc(sizeof (hsp_relation_t));
        if (hsp_relation == NULL)
                return (ERR_NOMEM);

        array_obj_id = *(obj_ids);
        disk_obj_id = *(obj_ids + 1);

        if (raid_obj_get_type(raid_tab, disk_obj_id) != OBJ_TYPE_DISK ||
            (array_obj_id != OBJ_ATTR_NONE &&
            raid_obj_get_type(raid_tab, array_obj_id) !=
            OBJ_TYPE_ARRAY)) {
                free(hsp_relation);
                return (ERR_DEVICE_TYPE);
        }

        /* Get controller attributes */
        if (controller_obj_id == OBJ_NONE)
                controller_obj_id = obj_get_controller(raid_tab,
                    disk_obj_id);
        else if (controller_obj_id != obj_get_controller(raid_tab,
            disk_obj_id)) {
                free(hsp_relation);
                return (ERR_DRIVER_ACROSS);
        }

        ret = obj_get_attr(raid_tab, controller_obj_id,
            (void **)(&controller_attr));

        /* Get disk attributes */
        ret = obj_get_attr(raid_tab,  disk_obj_id,
            (void **)(&disk_attr));
        if (disk_attr->state == DISK_STATE_FAILED) {
                free(hsp_relation);
                return (ERR_DISK_STATE);
        }

        /* If it's not a hsp disk, check if there's occupied space */
        if (obj_get_comp(raid_tab, disk_obj_id, OBJ_TYPE_HSP) ==
            OBJ_NONE) {
                obj_id = obj_get_comp(raid_tab, disk_obj_id,
                    OBJ_TYPE_DISK_SEG);
                while (obj_id != OBJ_NONE) {
                        ret = obj_get_attr(raid_tab, obj_id,
                            (void **)(&diskseg_attr));
                        if (!(diskseg_attr->state &
                            DISKSEG_STATE_RESERVED)) {
                                free(hsp_relation);
                                return (ERR_DISK_NOT_EMPTY);
                        }
                        obj_id = obj_get_sibling(raid_tab, obj_id);
                }
        }

        if (array_obj_id != OBJ_ATTR_NONE) {
                /* If local hsp is supported */
                if (!(controller_attr->capability & RAID_CAP_L_HSP)) {
                        free(hsp_relation);
                        return (ERR_OP_ILLEGAL);
                }

                if (raid_obj_get_type(raid_tab, array_obj_id) !=
                    OBJ_TYPE_ARRAY) {
                        free(hsp_relation);
                        return (ERR_DEVICE_TYPE);
                }

                /* Get array attributes */
                ret = obj_get_attr(raid_tab, array_obj_id,
                    (void **)(&array_attr));
                /* RAID 0 array can not use hsp */
                if (array_attr->raid_level == RAID_LEVEL_0) {
                        free(hsp_relation);
                        return (ERR_ARRAY_LEVEL);
                }

                /* If It's belong to another controller */
                if (controller_obj_id != obj_get_controller(raid_tab,
                    array_obj_id)) {
                        free(hsp_relation);
                        return (ERR_DRIVER_ACROSS);
                }

                /* Get an array part attributes */
                if ((array_attr->raid_level == RAID_LEVEL_10) ||
                    (array_attr->raid_level == RAID_LEVEL_50))
                        obj_id = obj_get_comp(raid_tab, array_obj_id,
                            OBJ_TYPE_ARRAY);
                else
                        obj_id = array_obj_id;
                obj_id = obj_get_comp(raid_tab, obj_id,
                    OBJ_TYPE_ARRAY_PART);
                ret = obj_get_attr(raid_tab, obj_id,
                    (void **)(&arraypart_attr));

                /* Check if disk space is enough for array */
                if (arraypart_attr->size > disk_attr->capacity) {
                        free(hsp_relation);
                        return (ERR_DISK_SPACE);
                }
                if (controller_attr->capability & RAID_CAP_ARRAY_ALIGN)
                        if ((arraypart_attr->size +
                            arraypart_attr->offset) >
                            disk_attr->capacity) {
                        free(hsp_relation);
                        return (ERR_DISK_SPACE);
                        }
        } else if (!(controller_attr->capability & RAID_CAP_G_HSP)) {
                /* if global hsp is supported */
                free(hsp_relation);
                return (ERR_OP_ILLEGAL);
        }

        /*
         * If the array is already associated with the
         * local hsp, or it's a global hsp, ignore it
         */
        obj_id = obj_get_comp(raid_tab, disk_obj_id, OBJ_TYPE_HSP);
        if (obj_id > OBJ_NONE) {
                if (obj_get_attr(raid_tab, obj_id,
                    (void **)&hsp_attr) >= SUCCESS) {
                        if (((hsp_attr->type == HSP_TYPE_GLOBAL) &&
                            (array_obj_id != OBJ_ATTR_NONE)) ||
                            ((hsp_attr->type == HSP_TYPE_LOCAL) &&
                            (array_obj_id == OBJ_ATTR_NONE))) {
                                free(hsp_relation);
                                return (ERR_OP_ILLEGAL);
                        }
                }
        }

        if (array_obj_id != OBJ_ATTR_NONE)
                hsp_relation->array_id = array_attr->array_id;
        else
                hsp_relation->array_id = (uint32_t)OBJ_ATTR_NONE;
        hsp_relation->disk_id = disk_attr->disk_id;

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        if (raid_lib->hsp_bind == NULL) {
                free(hsp_relation);
                return (ERR_OP_NO_IMPL);
        }

        ret = raid_lib->hsp_bind(controller_attr->controller_id,
            hsp_relation, plugin_err_str);

        free(hsp_relation);
        return (ret);
}

static int
obj_hsp_unbind(raid_obj_tab_t *raid_tab, raid_obj_id_t *obj_ids,
    char **plugin_err_str)
{
        raid_obj_id_t obj_id, controller_obj_id = OBJ_NONE;
        raid_obj_id_t array_obj_id, disk_obj_id;
        hsp_relation_t *hsp_relation;
        controller_attr_t *controller_attr;
        array_attr_t *array_attr;
        disk_attr_t *disk_attr;
        hsp_attr_t *hsp_attr;
        raid_lib_t *raid_lib;
        int ret, fd;

        hsp_relation = malloc(sizeof (hsp_relation_t));
        if (hsp_relation == NULL)
                return (ERR_NOMEM);

        array_obj_id = *(obj_ids);
        disk_obj_id = *(obj_ids + 1);

        if (raid_obj_get_type(raid_tab, disk_obj_id) != OBJ_TYPE_DISK) {
                free(hsp_relation);
                return (ERR_DEVICE_TYPE);
        }

        /* Get controller attributes */
        if (controller_obj_id == OBJ_NONE)
                controller_obj_id = obj_get_controller(raid_tab,
                    disk_obj_id);
        else if (controller_obj_id != obj_get_controller(raid_tab,
            disk_obj_id)) {
                free(hsp_relation);
                return (ERR_DRIVER_ACROSS);
        }

        ret = obj_get_attr(raid_tab, controller_obj_id,
            (void **)(&controller_attr));

        /* Get disk attributes */
        ret = obj_get_attr(raid_tab,  disk_obj_id,
            (void **)(&disk_attr));
        if (disk_attr->state == DISK_STATE_FAILED) {
                free(hsp_relation);
                return (ERR_DISK_STATE);
        }

        /* If it's not a hsp disk */
        obj_id = obj_get_comp(raid_tab, disk_obj_id, OBJ_TYPE_HSP);
        if (obj_id == OBJ_NONE) {
                free(hsp_relation);
                return (ERR_DISK_STATE);
        }
        ret = obj_get_attr(raid_tab, obj_id, (void **)(&hsp_attr));

        if (array_obj_id != OBJ_ATTR_NONE) {
                if (raid_obj_get_type(raid_tab, array_obj_id) !=
                    OBJ_TYPE_ARRAY) {
                        free(hsp_relation);
                        return (ERR_DEVICE_TYPE);
                }

                /* Get array attributes */
                ret = obj_get_attr(raid_tab, array_obj_id,
                    (void **)(&array_attr));

                /* If It's belong to another controller */
                if (controller_obj_id != obj_get_controller(raid_tab,
                    array_obj_id)) {
                        free(hsp_relation);
                        return (ERR_DRIVER_ACROSS);
                }

                /* If want to remove an array from a global hsp */
                if (hsp_attr->type == HSP_TYPE_GLOBAL) {
                        free(hsp_relation);
                        return (ERR_OP_ILLEGAL);
                }

                do {
                        (void) obj_get_attr(raid_tab, obj_id,
                            (void **)(&hsp_attr));

                        if (hsp_attr->associated_id ==
                            array_attr->array_id ||
                            hsp_attr->type == HSP_TYPE_GLOBAL)
                                break;

                        obj_id = obj_get_sibling(raid_tab, obj_id);
                } while (obj_id > OBJ_NONE);
        } else if (hsp_attr->type != HSP_TYPE_GLOBAL) {
                /* if global hsp is supported */
                free(hsp_relation);
                return (ERR_OP_ILLEGAL);
        }

        /*
         * If array is associated with a local hsp, or remove a
         * global hsp disk
         */
        if ((obj_id && (array_obj_id != OBJ_ATTR_NONE)) ||
            (array_obj_id == OBJ_ATTR_NONE)) {
                if (array_obj_id != OBJ_ATTR_NONE)
                        hsp_relation->array_id = array_attr->array_id;
                else
                        hsp_relation->array_id =
                            (uint32_t)OBJ_ATTR_NONE;
                hsp_relation->disk_id = disk_attr->disk_id;
        } else {
                free(hsp_relation);
                return (ERR_OP_ILLEGAL);
        }

        raid_lib = raid_obj_get_lib(raid_tab, controller_obj_id);
        fd = raid_obj_get_fd(raid_tab, controller_obj_id);
        if ((raid_lib == NULL) || (fd == 0))
                return (ERR_DRIVER_CLOSED);

        if (raid_lib->hsp_unbind == NULL) {
                free(hsp_relation);
                return (ERR_OP_NO_IMPL);
        }

        ret = raid_lib->hsp_unbind(controller_attr->controller_id,
            hsp_relation, plugin_err_str);

        free(hsp_relation);
        return (ret);
}

/*
 * Object maintennance routines
 */
static int
raid_obj_create_system_obj(raid_obj_tab_t *raid_tab)
{
        raid_obj_t *raid_obj;
        int ret;

        raid_obj = calloc(1, sizeof (raid_obj_t));
        if (raid_obj == NULL)
                return (ERR_NOMEM);

        raid_obj->obj_id = OBJ_SYSTEM;
        raid_obj->obj_type_id = OBJ_TYPE_SYSTEM;
        raid_obj->data = NULL;

        ret = raid_obj_tab_insert(raid_tab, raid_obj->obj_id, raid_obj);
        if (ret == ERR_DEVICE_DUP) {
                free(raid_obj);
                return (ERR_DEVICE_UNCLEAN);
        }

        return (SUCCESS);
}

static raid_obj_id_t
raid_obj_id_new(raid_obj_tab_t *raid_tab)
{
        ++ raid_tab->obj_id_cnt;
        if (raid_tab->obj_id_cnt <= 0)
                return (ERR_DEVICE_OVERFLOW);

        return (raid_tab->obj_id_cnt);
}

static void *
raid_obj_attr_new(raid_obj_type_id_t obj_type)
{
        void *obj_attr = NULL;

        switch (obj_type) {
        case    OBJ_TYPE_CONTROLLER:
                obj_attr = calloc(1, sizeof (controller_attr_t));
                break;
        case    OBJ_TYPE_ARRAY:
                obj_attr = calloc(1, sizeof (array_attr_t));
                break;
        case    OBJ_TYPE_DISK:
                obj_attr = calloc(1, sizeof (disk_attr_t));
                break;
        case    OBJ_TYPE_HSP:
                obj_attr = calloc(1, sizeof (hsp_attr_t));
                break;
        case    OBJ_TYPE_ARRAY_PART:
                obj_attr = calloc(1, sizeof (arraypart_attr_t));
                break;
        case    OBJ_TYPE_DISK_SEG:
                obj_attr = calloc(1, sizeof (diskseg_attr_t));
                break;
        case    OBJ_TYPE_TASK:
                obj_attr = calloc(1, sizeof (task_attr_t));
                break;
        case    OBJ_TYPE_PROP:
                obj_attr = calloc(1, sizeof (property_attr_t));
                break;
        default:
                break;
        }

        return (obj_attr);
}

static raid_obj_id_t
raid_obj_create(raid_obj_tab_t *raid_tab, raid_obj_type_id_t obj_type)
{
        raid_obj_t *raid_obj;
        int ret;
        void *data_ptr;

        raid_obj = calloc(1, sizeof (raid_obj_t));
        if (raid_obj == NULL)
                return (ERR_NOMEM);

        raid_obj->obj_id = raid_obj_id_new(raid_tab);
        if (raid_obj->obj_id < OBJ_NONE)
                return (ERR_DEVICE_OVERFLOW);

        ret = raid_obj_tab_insert(raid_tab, raid_obj->obj_id, raid_obj);
        if (ret == ERR_DEVICE_DUP) {
                free(raid_obj);
                return (ERR_DEVICE_DUP);
        }

        data_ptr = raid_obj_attr_new(obj_type);
        if (data_ptr == NULL) {
                (void) raid_obj_delete(raid_tab, raid_obj->obj_id);
                return (ERR_NOMEM);
        }

        (void) raid_obj_set_data_ptr(raid_tab, raid_obj->obj_id, data_ptr);

        (void) raid_obj_set_type(raid_tab, raid_obj->obj_id, obj_type);
        return (raid_obj->obj_id);
}

static int
raid_obj_delete(raid_obj_tab_t *raid_tab, raid_obj_id_t raid_obj_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_remove(raid_tab, raid_obj_id);
        if (obj != NULL) {
                free(obj->data);
                free(obj);
                return (SUCCESS);
        }

        return (ERR_DEVICE_NOENT);
}

static int
raid_obj_add_org(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_id_t container_id)
{
        raid_obj_id_t tmp, tmp1;

        tmp = raid_obj_get_comp(raid_tab, container_id);
        if (tmp < OBJ_NONE)
                return (ERR_DEVICE_NOENT);

        if (tmp == OBJ_NONE) {
                (void) raid_obj_set_container(raid_tab, obj_id, container_id);
                (void) raid_obj_set_comp(raid_tab, container_id, obj_id);
                return (SUCCESS);
        }

        while ((tmp1 = raid_obj_get_sibling(raid_tab, tmp)) != OBJ_NONE)
                tmp = tmp1;

        if (raid_obj_set_sibling(raid_tab, tmp, obj_id) < SUCCESS)
                return (ERR_DEVICE_NOENT);
        (void) raid_obj_set_container(raid_tab, obj_id, container_id);

        return (SUCCESS);
}

static raid_obj_type_id_t
raid_obj_get_type(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        if ((obj->obj_type_id < OBJ_TYPE_SYSTEM) ||
            (obj->obj_type_id >= OBJ_TYPE_ALL))
                return (ERR_DEVICE_INVALID);

        return (obj->obj_type_id);
}

static int
raid_obj_set_type(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_type_id_t type)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        if ((type < OBJ_TYPE_SYSTEM) || (type >= OBJ_TYPE_ALL))
                return (ERR_DEVICE_TYPE);

        obj->obj_type_id = type;
        return (SUCCESS);
}

static raid_obj_status_t
raid_obj_get_status(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        return (obj->status);
}

static int
raid_obj_set_status(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_status_t status)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        obj->status = obj->status | status;

        return (SUCCESS);
}

static int
raid_obj_clear_status(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_status_t status)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        obj->status = obj->status & ~status;

        return (SUCCESS);
}

static raid_obj_id_t
raid_obj_get_container(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        return (obj->container);
}

static int
raid_obj_set_container(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_id_t container_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        obj->container = container_id;
        return (SUCCESS);
}

static raid_obj_id_t
raid_obj_get_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        return (obj->component);
}

static int
raid_obj_set_comp(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_id_t comp)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        obj->component = comp;
        return (SUCCESS);
}

static raid_obj_id_t
raid_obj_get_sibling(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        return (obj->sibling);
}

static int
raid_obj_set_sibling(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_id_t sibling)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        obj->sibling = sibling;

        return (SUCCESS);
}

static void *
raid_obj_get_data_ptr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (NULL);

        return (obj->data);
}

static int
raid_obj_set_data_ptr(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    void *data)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        obj->data = data;

        return (SUCCESS);
}

static raid_obj_handle_t
raid_obj_get_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        return (obj->handle);
}

static int
raid_obj_set_handle(raid_obj_tab_t *raid_tab, raid_obj_id_t obj_id,
    raid_obj_handle_t handle)
{
        raid_obj_t *obj;

        obj = raid_obj_tab_find(raid_tab, obj_id);
        if (obj == NULL)
                return (ERR_DEVICE_NOENT);

        obj->handle = handle;
        return (SUCCESS);
}
/*
 * Object list maintennance routines
 */
static void
raid_list_create(raid_list_t *list, size_t offset)
{
        list->head = NULL;
        list->tail = NULL;
        list->offset = offset;
}

static void *
raid_list_head(raid_list_t *list)
{
        return (list->head);
}

static void *
raid_list_next(raid_list_t *list, void *obj)
{
        raid_list_el_t *el = LIST_OBJ_TO_EL(list, obj);

        return (el->next);
}

static void
raid_list_insert_tail(raid_list_t *list, void *obj)
{
        raid_list_el_t *el = LIST_OBJ_TO_EL(list, obj), *el1;

        el->prev = list->tail;
        list->tail = obj;

        el->next = NULL;

        if (list->head == NULL)
                list->head = obj;

        if (el->prev != NULL) {
                el1 = LIST_OBJ_TO_EL(list, el->prev);
                el1->next = obj;
        }
}

static void
raid_list_remove(raid_list_t *list, void *obj)
{
        raid_list_el_t *el = LIST_OBJ_TO_EL(list, obj), *el1;

        if (list->head == obj)
                list->head = el->next;

        if (list->tail == obj)
                list->tail = el->prev;

        if (el->next != NULL) {
                el1 = LIST_OBJ_TO_EL(list, el->next);
                el1->prev = el->prev;
        }

        if (el->prev != NULL) {
                el1 = LIST_OBJ_TO_EL(list, el->prev);
                el1->next = el->next;
        }

        el->prev = el->next = NULL;
}

static void *
raid_list_remove_head(raid_list_t *list)
{
        void *obj = list->head;

        if (obj != NULL)
                raid_list_remove(list, obj);

        return (obj);
}

static void *
raid_list_find(raid_list_t *list, raid_obj_id_t obj_id)
{
        raid_obj_t *obj;

        for (obj = raid_list_head(list); obj != NULL;
            obj = raid_list_next(list, obj))
                        if (obj->obj_id == obj_id)
                                break;

        return (obj);
}

static int
raid_obj_tab_create(raid_obj_tab_t *tab, size_t hash_slots)
{
        unsigned i;

        if (hash_slots == 0)
                return (ERR_OP_ILLEGAL);

        tab->slots = hash_slots;

        if ((tab->table = calloc(hash_slots, sizeof (raid_list_t))) == NULL)
                return (ERR_NOMEM);

        for (i = 0; i < hash_slots; i++)
                raid_list_create(&tab->table[i], offsetof(raid_obj_t, el));

        return (SUCCESS);
}

static void
raid_obj_tab_destroy(raid_obj_tab_t *tab)
{
        unsigned i;

        for (i = 0; i < tab->slots; i++) {
                struct raid_obj_t *obj;

                while ((obj = raid_list_remove_head(&tab->table[i])) != NULL)
                        free(obj);

                raid_list_destroy(&tab->table[i]);
        }

        if (tab->table)
                free(tab->table);

        tab->table = NULL;
        tab->slots = 0;
        tab->obj_id_cnt = 0;
}

static int
raid_obj_tab_insert(raid_obj_tab_t *tab, raid_obj_id_t id, void *obj)
{
        raid_list_t *list;

        list = OBJ_TAB_SLOT(tab, id);

        if (raid_list_find(list, id) != NULL)
                return (ERR_DEVICE_DUP);

        raid_list_insert_tail(list, obj);

        return (SUCCESS);
}

static void *
raid_obj_tab_remove(raid_obj_tab_t *tab, raid_obj_id_t id)
{
        raid_list_t *list;
        raid_obj_t *obj;

        list = OBJ_TAB_SLOT(tab, id);

        if ((obj = raid_list_find(list, id)) != NULL)
                raid_list_remove(list, obj);

        return (obj);
}

static void *
raid_obj_tab_find(raid_obj_tab_t *tab, raid_obj_id_t id)
{
        raid_list_t *list;
        raid_obj_t *obj;

        list = OBJ_TAB_SLOT(tab, id);
        obj = raid_list_find(list, id);

        return (obj);
}

static void
raid_list_destroy(raid_list_t *list)
{
        list->head = NULL;
        list->tail = NULL;
        list->offset = 0;
}

/*
 * Plug-in maintennance routines
 */
static int
controller_id_to_path(uint32_t controller_id, char *path)
{
        int fd;
        char buf[MAX_PATH_LEN] = {0}, buf1[MAX_PATH_LEN] = {0}, *colon;

        (void) snprintf(buf, MAX_PATH_LEN, "%s/c%d", CFGDIR, controller_id);
        if (readlink(buf, buf1, sizeof (buf1)) < 0)
                return (ERR_DRIVER_NOT_FOUND);

        if (buf1[0] != '/')
                (void) snprintf(buf, sizeof (buf), "%s/", CFGDIR);
        else
                buf[0] = 0;
        (void) strlcat(buf, buf1, MAX_PATH_LEN);

        colon = strrchr(buf, ':');
        if (colon == NULL)
                return (ERR_DRIVER_NOT_FOUND);
        else
                *colon = 0;

        (void) snprintf(path, MAX_PATH_LEN, "%s:devctl", buf);

        fd = open(path, O_RDONLY | O_NDELAY);

        if (fd < 0)
                return (ERR_DRIVER_NOT_FOUND);

        (void) close(fd);

        return (SUCCESS);
}

static char *
controller_id_to_driver_name(uint32_t controller_id)
{
        char buf[MAX_PATH_LEN];
        di_node_t di_node;
        char *name, *tmp;
        int ret;

        ret = controller_id_to_path(controller_id, buf);
        if (ret < SUCCESS)
                return (NULL);

        tmp = strrchr(buf, ':');
        if (tmp != NULL)
                *tmp = 0;

        tmp = strstr(buf, "pci");
        if (tmp == NULL)
                return (NULL);

        di_node = di_init(tmp, DINFOPROP);
        if (di_node == DI_NODE_NIL)
                return (NULL);

        name = di_driver_name(di_node);

        return (name);
}

static void
raid_plugin_init()
{
        raid_lib_t *raid_lib = raid_lib_sys;

        while (raid_lib) {
                raid_lib_sys = raid_lib->next;
                (void) dlclose(raid_lib->lib_handle);
                free(raid_lib);
                raid_lib = raid_lib_sys;
        }
}

static raid_lib_t *
raid_plugin_load(char *driver_name)
{
        char buf[MAX_PATH_LEN] = {0};
        raid_lib_t *supplib;
        void *sym;

        supplib = calloc(1, sizeof (raid_lib_t));
        if (supplib == NULL)
                return (NULL);

        (void) snprintf(buf, MAX_PATH_LEN, "%s/%s.so.1",
            SUPP_PLUGIN_DIR, driver_name);

        supplib->lib_handle = dlopen(buf, RTLD_LAZY);
        if (supplib->lib_handle == NULL) {
                free(supplib);
                return (NULL);
        }

        supplib->name = driver_name;

        if ((sym = dlsym(supplib->lib_handle, "rdcfg_version")) == NULL)
                supplib->version = RDCFG_PLUGIN_V1;
        else {
                supplib->version = *((uint32_t *)sym);
                if (supplib->version != RDCFG_PLUGIN_V1) {
                        (void) dlclose(supplib->lib_handle);
                        free(supplib);
                        return (NULL);
                }
        }

        if ((sym = dlsym(supplib->lib_handle, "rdcfg_open_controller")) ==
            NULL) {
                (void) dlclose(supplib->lib_handle);
                free(supplib);
                return (NULL);
        } else
                supplib->open_controller = (int(*)(uint32_t, char **))sym;

        if ((sym = dlsym(supplib->lib_handle, "rdcfg_close_controller")) ==
            NULL) {
                (void) dlclose(supplib->lib_handle);
                free(supplib);
                return (NULL);
        } else
                supplib->close_controller = (int (*)(uint32_t, char **))sym;

        if ((sym = dlsym(supplib->lib_handle, "rdcfg_compnum")) == NULL) {
                (void) dlclose(supplib->lib_handle);
                free(supplib);
                return (NULL);
        } else
                supplib->compnum = (int (*)(uint32_t, uint32_t,
                    raid_obj_type_id_t, raid_obj_type_id_t))sym;

        if ((sym = dlsym(supplib->lib_handle, "rdcfg_complist")) == NULL) {
                (void) dlclose(supplib->lib_handle);
                free(supplib);
                return (NULL);
        } else
                supplib->complist = (int (*)(uint32_t, uint32_t,
                    raid_obj_type_id_t, raid_obj_type_id_t, int, void *))sym;

        if ((sym = dlsym(supplib->lib_handle, "rdcfg_get_attr")) == NULL) {
                (void) dlclose(supplib->lib_handle);
                free(supplib);
                return (NULL);
        } else
                supplib->get_attr = (int (*)(uint32_t, uint32_t, uint32_t,
                    raid_obj_type_id_t, void*))sym;

        if ((sym = dlsym(supplib->lib_handle, "rdcfg_array_create")) == NULL) {
                (void) dlclose(supplib->lib_handle);
                free(supplib);
                return (NULL);
        } else
                supplib->array_create = (int (*)(uint32_t, array_attr_t *, int,
                    arraypart_attr_t *, char **))sym;

        if ((sym = dlsym(supplib->lib_handle, "rdcfg_array_delete")) == NULL) {
                (void) dlclose(supplib->lib_handle);
                free(supplib);
                return (NULL);
        } else
                supplib->array_delete =
                    (int (*)(uint32_t, uint32_t, char **))sym;

        supplib->hsp_bind = (int (*)(uint32_t, hsp_relation_t *,
            char **))dlsym(supplib->lib_handle, "rdcfg_hsp_bind");
        supplib->hsp_unbind = (int (*)(uint32_t, hsp_relation_t *,
            char **))dlsym(supplib->lib_handle, "rdcfg_hsp_unbind");
        supplib->set_attr = (int (*)(uint32_t, uint32_t, uint32_t, uint32_t *,
            char **))dlsym(supplib->lib_handle, "rdcfg_set_attr");
        supplib->flash_fw = (int (*)(uint32_t, char *, uint32_t, char **))
            dlsym(supplib->lib_handle, "rdcfg_flash_fw");

        supplib->next = raid_lib_sys;
        raid_lib_sys = supplib;
        return (supplib);
}

static raid_lib_t *
raid_find_lib(raid_obj_tab_t *raid_tab, raid_obj_id_t controller_obj_id)
{
        controller_attr_t *controller_attr;
        raid_lib_t *raid_lib;
        char *driver_name;
        raid_obj_handle_t handle;

        /* Check if it's mapped to handle structure */
        handle = raid_obj_to_handle(raid_tab, controller_obj_id);
        if (raid_handle_sys.handles[handle].raid_lib != NULL)
                return (raid_handle_sys.handles[handle].raid_lib);

        (void) obj_get_attr(raid_tab, controller_obj_id,
            (void **)(&controller_attr));

        /* Check if the plugin module is already loaded */
        driver_name = controller_id_to_driver_name(
            controller_attr->controller_id);
        if (driver_name == NULL)
                return (NULL);

        raid_lib = raid_lib_sys;
        while (raid_lib != NULL) {
                if (raid_lib->name != NULL &&
                    strcmp(driver_name, raid_lib->name) == 0)
                        return (raid_lib);

                raid_lib = raid_lib->next;
        }

        /* Loading the plugin module */
        raid_lib = raid_plugin_load(driver_name);

        return (raid_lib);
}