xref: /illumos-gate/usr/src/lib/libraidcfg/common/raidcfg.c (revision 8bc1b774)

/*
 * 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);
}