/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "isns_server.h"
#include "isns_msgq.h"
#include "isns_htab.h"
#include "isns_dd.h"
#include "isns_cache.h"
#include "isns_obj.h"
#include "isns_pdu.h"
#include "isns_dseng.h"
#include "isns_scn.h"
#include "isns_utils.h"

/*
 * extern global variables
 */
extern const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE];

extern msg_queue_t *sys_q;
extern msg_queue_t *scn_q;

extern int cache_flag;

/*
 * extern functions.
 */

/*
 * global variables
 */

/*
 * local variables
 */

/*
 * local functions.
 */
static matrix_t *new_matrix(uint32_t, uint32_t);

static int
cb_update_ds_attr(
	void *p1,
	void *p2
)
{
	int ec = 0;

	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
	uint32_t tag = lcp->id[1];
	uint32_t which;
	isns_attr_t *attr;

	uint32_t len;
	uchar_t *name;
	lookup_ctrl_t lc;
	uint32_t uid;

	switch (tag) {
	case ISNS_DD_NAME_ATTR_ID:
		which = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
		break;
	case ISNS_DD_FEATURES_ATTR_ID:
		which = ATTR_INDEX_DD(ISNS_DD_FEATURES_ATTR_ID);
		break;
	case ISNS_DD_SET_NAME_ATTR_ID:
		which = ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID);
		break;
	case ISNS_DD_SET_STATUS_ATTR_ID:
		which = ATTR_INDEX_DDS(ISNS_DD_SET_STATUS_ATTR_ID);
		break;
	default:
		ASSERT(0);
		break;
	}

	attr = &obj->attrs[which];

	switch (tag) {
	case ISNS_DD_NAME_ATTR_ID:
	case ISNS_DD_SET_NAME_ATTR_ID:
		len = lcp->data[1].ui;
		name = lcp->data[2].ptr;
		lc.type = lcp->type;
		lc.curr_uid = 0;
		lc.id[0] = which;
		lc.op[0] = OP_STRING;
		lc.data[0].ptr = name;
		lc.op[1] = 0;
		/* check if the name is in use */
		uid = is_obj_there(&lc);
		if (uid != 0) {
			if (uid != get_obj_uid(obj)) {
				ec = ERR_NAME_IN_USE;
			}
			return (ec);
		}
		if (len > attr->len) {
			uchar_t *tmp = (uchar_t *)malloc(len);
			if (tmp != NULL) {
				free(attr->value.ptr);
				attr->value.ptr = tmp;
			} else {
				/* memory exhausted */
				return (ISNS_RSP_INTERNAL_ERROR);
			}
		}
		(void) strcpy((char *)attr->value.ptr, (char *)name);
		attr->len = len;
		break;
	case ISNS_DD_FEATURES_ATTR_ID:
	case ISNS_DD_SET_STATUS_ATTR_ID:
		if (attr->tag != tag ||
		    attr->value.ui != lcp->data[1].ui) {
			attr->tag = tag;
			attr->len = 4;
			attr->value.ui = lcp->data[1].ui;
		} else {
			return (ec);
		}
		break;
	}

	/* cache has been updated, set the flag */
	SET_CACHE_UPDATED();

	/* update data store */
	if (sys_q != NULL) {
		ec = write_data(DATA_UPDATE, obj);
	}

	return (ec);
}

static isns_obj_t *
make_member_node(
	const uint32_t uid,
	isns_attr_t *attr1
)
{
	isns_obj_t *obj = NULL;
	isns_attr_t *attr;
	isns_attr_t tmp;

	switch (attr1->tag) {
	case ISNS_DD_ISCSI_NAME_ATTR_ID:
		obj = obj_calloc(OBJ_ISCSI);
		attr = &obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];
		tmp.tag = ISNS_ISCSI_NAME_ATTR_ID;
		tmp.len = attr1->len;
		tmp.value.ptr = attr1->value.ptr;
		if (assign_attr(attr, &tmp) != 0) {
			free_object(obj);
			obj = NULL;
		} else if (uid != 0) {
			(void) set_obj_uid(obj, uid);
		}
		break;
	default:
		ASSERT(0);
		break;
	}

	return (obj);
}

static isns_obj_t *
make_member_dd(
	const uint32_t uid
)
{
	isns_obj_t *obj = NULL;
	isns_attr_t name = { 0 };

	obj = obj_calloc(OBJ_DD);
	if (obj != NULL) {
		(void) set_obj_uid(obj, uid);
		name.tag = ISNS_DD_NAME_ATTR_ID;
		if (assign_attr(
		    &obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)],
		    &name) != 0) {
			free_object(obj);
			obj = NULL;
		}
	}

	return (obj);
}

static int
get_member_info(
	isns_obj_t *assoc,
	uint32_t *m_type,
	uint32_t *m_id,
	int flag
)
{
	int ec = 0;
	lookup_ctrl_t lc = { 0 };

	isns_obj_t *obj;
	isns_attr_t *attr1, *attr2;
	uint32_t tmp_id = 0;
	int i = 0;

	*m_type = 0;
	*m_id = 0;

	attr1 = &assoc->attrs[ATTR_INDEX_ASSOC_ISCSI(
	    ISNS_DD_ISCSI_INDEX_ATTR_ID)];
	attr2 = &assoc->attrs[ATTR_INDEX_ASSOC_ISCSI(
	    ISNS_DD_ISCSI_NAME_ATTR_ID)];

	lc.type = OBJ_ISCSI;
	if (attr1->tag != 0 && attr1->value.ui != 0) {
		*m_id = attr1->value.ui;
		lc.id[i] = UID_ATTR_INDEX[OBJ_ISCSI];
		lc.op[i] = OP_INTEGER;
		lc.data[i].ui = *m_id;
		i ++;
	}
	if (attr2->tag != 0) {
		lc.id[i] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
		lc.op[i] = OP_STRING;
		lc.data[i].ptr = attr2->value.ptr;
		i ++;
	} else if (scn_q != NULL || sys_q != NULL) {
		lc.id[i] = ISNS_ISCSI_NAME_ATTR_ID;
	}

	/* a member id or member name is required */
	if (i == 0) {
		if (flag != 0) {
			/* add member */
			return (ISNS_RSP_INVALID_REGIS);
		} else {
			/* remove member (isnsp msg request only) */
			return (0);
		}
	}

	ec = cache_lookup(&lc, &tmp_id, cb_clone_attrs);

	if (ec == 0 && tmp_id == 0) {
		if (flag != 0) {
			/* add member */
			if (attr1->tag == 0 || sys_q == NULL) {
				/* object does not exist, create one */
				obj = make_member_node(*m_id, attr2);
				if (obj == NULL) {
					ec = ISNS_RSP_INTERNAL_ERROR;
				} else {
					ec = register_assoc(obj, &tmp_id);
					if (ec != 0) {
						free_object(obj);
					}
				}
			} else {
				/* don't create it if uid is specified */
				ec = ISNS_RSP_NO_SUCH_ENTRY;
			}
		} else {
			/* remove member */
			ec = ERR_NO_SUCH_ASSOCIATION;
		}
	}

	if (attr1->tag == 0) {
		attr1->tag = ISNS_DD_ISCSI_INDEX_ATTR_ID;
		attr1->len = 4;
		attr1->value.ui = tmp_id;
	} else if (attr2->tag == 0) {
		attr2->tag = ISNS_DD_ISCSI_NAME_ATTR_ID;
		attr2->len = strlen((char *)lc.data[1].ptr);
		attr2->len += 4 - (attr2->len % 4);
		attr2->value.ptr = lc.data[1].ptr;
	}

	*m_type = OBJ_ISCSI;
	*m_id = tmp_id;

	return (ec);
}

static int
get_dds_member_info(
	uint32_t m_id
)
{
	int ec = 0;
	lookup_ctrl_t lc;

	isns_obj_t *obj;
	uint32_t tmp_id;

	if (m_id != 0) {
		SET_UID_LCP(&lc, OBJ_DD, m_id);
	} else {
		return (ISNS_RSP_INVALID_REGIS);
	}

	tmp_id = is_obj_there(&lc);

	if (tmp_id == 0) {
		/* object does not exist, create one */
		obj = make_member_dd(m_id);
		if (obj != NULL) {
			ec = register_object(obj, NULL, NULL);
		} else {
			/* no memory */
			ec = ISNS_RSP_INTERNAL_ERROR;
		}
	}

	return (ec);
}

static int
update_matrix(
	matrix_t *matrix,
	const uchar_t op,
	const uint32_t puid,
	const uint32_t m_id,
	int ddd_flag
)
{
	int ec = 0;

	uint32_t new_x = 0, new_y = 0;
	matrix_t *tmp_matrix;

	uint32_t i, j, k = 0;
	uint32_t x_info;
	bmp_t *bmp, *tmp_bmp;

	uint32_t primary = GET_PRIMARY(m_id);
	uint32_t second = GET_SECOND(m_id);

	if (primary >= matrix->x) {
		if (op == '-') {
			ec = ERR_NO_SUCH_ASSOCIATION;
			goto update_matrix_done;
		}
		/* enlarge the matrix on x axis */
		if (primary >= matrix->x * 2) {
			new_x = primary + 1;
		} else {
			new_x = matrix->x * 2;
		}
	}

	i = 0;
	while (i < matrix->y) {
		bmp = MATRIX_X_UNIT(matrix, i);
		x_info = MATRIX_X_INFO(bmp);
		if (x_info == puid) {
			break;
		} else if (x_info == 0 && k == 0) {
			/* the first available slot */
			k = i;
		}
		i ++;
	}
	if (i == matrix->y) {
		if (op == '-') {
			ec = ERR_NO_SUCH_ASSOCIATION;
			goto update_matrix_done;
		} else if (k == 0) {
			new_y = matrix->y * 2;
		} else {
			i = k;
		}
	}

	/*
	 * enlarge the matrix.
	 */
	if (new_x != 0 || new_y != 0) {
		if (new_x == 0) {
			new_x = matrix->x;
		}
		if (new_y == 0) {
			new_y = matrix->y;
		}
		tmp_matrix = new_matrix(new_x, new_y);
		if (tmp_matrix != NULL) {
			j = 0;
			while (j < matrix->y) {
				bmp = MATRIX_X_UNIT(matrix, j);
				x_info = MATRIX_X_INFO(bmp);
				if (x_info != 0) {
					tmp_bmp = MATRIX_X_UNIT(tmp_matrix, j);
					(void) memcpy((void *)tmp_bmp,
					    (void *)bmp, SIZEOF_X_UNIT(matrix));
				}
				j ++;
			}
			free(matrix->m);
			matrix->x = tmp_matrix->x;
			matrix->y = tmp_matrix->y;
			matrix->m = tmp_matrix->m;
			free(tmp_matrix);
		} else {
			ec = ISNS_RSP_INTERNAL_ERROR;
			goto update_matrix_done;
		}
	}

	bmp = MATRIX_X_UNIT(matrix, i);

	MATRIX_X_INFO(bmp) = puid;
	if (op == '+') {
		if (TEST_MEMBERSHIP(bmp, primary, second) == 0) {
			SET_MEMBERSHIP(bmp, primary, second);
			SET_CACHE_UPDATED();
			if (ddd_flag != 0) {
				bmp = MATRIX_X_UNIT(matrix, 0);
				ASSERT(MATRIX_X_INFO(bmp) ==
				    ISNS_DEFAULT_DD_ID);
				CLEAR_MEMBERSHIP(bmp, primary, second);
			}
		} else {
			ec = ERR_ALREADY_ASSOCIATED;
		}
	} else if (op == '-') {
		if (TEST_MEMBERSHIP(bmp, primary, second) != 0) {
			CLEAR_MEMBERSHIP(bmp, primary, second);
			SET_CACHE_UPDATED();
			if (ddd_flag != 0) {
				i = 1;
				while (i < matrix->y) {
					bmp = MATRIX_X_UNIT(matrix, i);
					x_info = MATRIX_X_INFO(bmp);
					if (x_info != 0 &&
					    TEST_MEMBERSHIP(bmp,
					    primary, second) != 0) {
						break;
					}
					i ++;
				}
				if (i == matrix->y) {
					bmp = MATRIX_X_UNIT(matrix, 0);
					ASSERT(MATRIX_X_INFO(bmp) ==
					    ISNS_DEFAULT_DD_ID);
					SET_MEMBERSHIP(bmp, primary, second);
				}
			}
		} else {
			ec = ERR_NO_SUCH_ASSOCIATION;
		}
	}

update_matrix_done:
	return (ec);
}

/*ARGSUSED*/
static int
update_dd_matrix(
	const uchar_t op,
	const uint32_t dd_id,
	const uint32_t m_type,
	const uint32_t m_id
)
{
	matrix_t *matrix;

	ASSERT(m_type == OBJ_ISCSI);

	matrix = cache_get_matrix(OBJ_DD);

	return (update_matrix(matrix, op, dd_id, m_id, 1));
}

static int
update_dds_matrix(
	const uchar_t op,
	const uint32_t dds_id,
	const uint32_t m_id
)
{
	matrix_t *dds_matrix = cache_get_matrix(OBJ_DDS);

	return (update_matrix(dds_matrix, op, dds_id, m_id, 0));
}

static int
clear_matrix(
	matrix_t *matrix,
	const uint32_t uid,
	bmp_t **p,
	uint32_t *n,
	int ddd_flag
)
{
	int ec = 0;
	bmp_t *bmp;
	uint32_t x_info;
	int i, j;

	uint32_t primary;
	uint32_t second;

	if (p != NULL) {
		*p = NULL;
		*n = 0;
	}

	i = 0;
	while (i < matrix->y) {
		bmp = MATRIX_X_UNIT(matrix, i);
		x_info = MATRIX_X_INFO(bmp);
		if (x_info == uid) {
			if (p != NULL) {
				/* dup it for caller */
				*n = matrix->x;
				*p = (bmp_t *)malloc(*n * sizeof (bmp_t));
				if (*p != NULL) {
					(void) memcpy(*p, &bmp[MATRIX_X_HEADER],
					    *n * sizeof (bmp_t));
				} else {
					ec = ISNS_RSP_INTERNAL_ERROR;
				}
			}
			/* clean it */
			(void) memset(bmp, 0, SIZEOF_X_UNIT(matrix));
			break;
		}
		i ++;
	}

	if (ddd_flag != 0 && p != NULL) {
		bmp = MATRIX_X_UNIT(matrix, 0);
		ASSERT(MATRIX_X_INFO(bmp) == ISNS_DEFAULT_DD_ID);
		/* Test the membership for each node which is a */
		/* member in the dd that is being deleted. */
		FOR_EACH_MEMBER(*p, *n, i, {
			j = get_dd_id(i, 0);
			if (j == 0) {
				/* put it to the default dd */
				primary = GET_PRIMARY(i);
				second = GET_SECOND(i);
				SET_MEMBERSHIP(bmp, primary, second);
			}
		});
	}

	return (ec);
}

static int
get_matrix(
	matrix_t *matrix,
	const uint32_t uid,
	bmp_t **p,
	uint32_t *n
)
{
	int ec = 0;
	bmp_t *bmp;
	uint32_t x_info;
	int i;

	*n = 0;
	*p = NULL;

	i = 0;
	while (i < matrix->y) {
		bmp = MATRIX_X_UNIT(matrix, i);
		x_info = MATRIX_X_INFO(bmp);
		if (x_info == uid) {
			/* dup it for caller */
			*n = matrix->x;
			*p = (bmp_t *)malloc(*n * sizeof (bmp_t));
			if (*p != NULL) {
				(void) memcpy(*p, &bmp[MATRIX_X_HEADER],
				    *n * sizeof (bmp_t));
			} else {
				*n = 0;
				ec = ISNS_RSP_INTERNAL_ERROR;
			}
			break;
		}
		i ++;
	}

	return (ec);
}

static int
clear_dd_matrix(
	const uint32_t dd_id,
	bmp_t **p,
	uint32_t *n
)
{
	matrix_t *matrix = cache_get_matrix(OBJ_DD);

	return (clear_matrix(matrix, dd_id, p, n, 1));
}

static int
clear_dds_matrix(
	const uint32_t dds_id
)
{
	matrix_t *matrix = cache_get_matrix(OBJ_DDS);

	return (clear_matrix(matrix, dds_id, NULL, NULL, 0));
}

int
get_dd_matrix(
	const uint32_t dd_id,
	bmp_t **p,
	uint32_t *n
)
{
	matrix_t *matrix = cache_get_matrix(OBJ_DD);

	return (get_matrix(matrix, dd_id, p, n));
}

int
get_dds_matrix(
	const uint32_t dds_id,
	bmp_t **p,
	uint32_t *n
)
{
	matrix_t *matrix = cache_get_matrix(OBJ_DDS);

	return (get_matrix(matrix, dds_id, p, n));
}

/*ARGSUSED*/
static int
cb_get_dds_status(
	void *p1,
	void *p2
)
{
	isns_obj_t *obj = (isns_obj_t *)p1;

	isns_attr_t *attr = &obj->attrs[
	    ATTR_INDEX_DDS(ISNS_DD_SET_STATUS_ATTR_ID)];

	return (DDS_ENABLED(attr->value.ui) ? 1 : 0);
}

static int
get_dds_status(
	uint32_t dds_id
)
{
	lookup_ctrl_t lc;

	if (dds_id == 0) {
		return (0);
	}

	SET_UID_LCP(&lc, OBJ_DDS, dds_id);

	return (cache_lookup(&lc, NULL, cb_get_dds_status));
}

int
is_dd_active(
	uint32_t dd_id
)
{
	int active = 0;

	matrix_t *dds_matrix;
	uint32_t primary;
	uint32_t second;
	uint32_t x_info;
	bmp_t *bmp;
	int i;

	if (dd_id == 0) {
		return (active);
	}

	dds_matrix = cache_get_matrix(OBJ_DDS);
	primary = GET_PRIMARY(dd_id);
	second = GET_SECOND(dd_id);

	if (primary < dds_matrix->x) {
		i = 0;
		while (i < dds_matrix->y) {
			bmp = MATRIX_X_UNIT(dds_matrix, i);
			x_info = MATRIX_X_INFO(bmp);
			if (x_info != 0 &&
			    TEST_MEMBERSHIP(bmp, primary, second) != 0) {
				if (get_dds_status(x_info) != 0) {
					active = 1;
					break;
				}
			}
			i ++;
		}
	}

	return (active);
}

int
get_scope(
	uchar_t *node_name,
	bmp_t **p,
	uint32_t *n
)
{
	int ec = 0;

	lookup_ctrl_t lc;
	uint32_t uid;

	matrix_t *dd_matrix;
	uint32_t primary;
	uint32_t second;
	uint32_t x_info;
	bmp_t *bmp;
	int i, j;

	bmp_t *tmp_p;
	uint32_t tmp_n;

	bmp_t *short_p;
	uint32_t short_n;

	/* clear it */
	*p = NULL;
	*n = 0;

	/* get the source object uid */
	lc.curr_uid = 0;
	lc.type = OBJ_ISCSI;
	lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
	lc.op[0] = OP_STRING;
	lc.data[0].ptr = node_name;
	lc.op[1] = 0;

	uid = is_obj_there(&lc);

	/* no such object */
	if (uid == 0) {
		return (ec);
	}

	dd_matrix = cache_get_matrix(OBJ_DD);
	primary = GET_PRIMARY(uid);
	second = GET_SECOND(uid);

	if (primary < dd_matrix->x) {
		i = 0;
		while (i < dd_matrix->y) {
			bmp = MATRIX_X_UNIT(dd_matrix, i);
			x_info = MATRIX_X_INFO(bmp);
			if (ec == 0 && x_info != 0 &&
			    TEST_MEMBERSHIP(bmp, primary, second) != 0) {
				if (is_dd_active(x_info) != 0 &&
				    (ec = get_dd_matrix(x_info,
				    &tmp_p, &tmp_n)) == 0) {
					if (*p == NULL) {
						*p = tmp_p;
						*n = tmp_n;
					} else {
						if (*n >= tmp_n) {
							short_p = tmp_p;
							short_n = tmp_n;
						} else {
							short_p = *p;
							short_n = *n;
							*p = tmp_p;
							*n = tmp_n;
						}
						j = 0;
						while (j < short_n) {
							(*p)[j] |= short_p[j];
							j ++;
						}
						free(short_p);
					}
				}
			}
			i ++;
		}
	}

	primary ++;
	if (ec == 0 && *p == NULL) {
		*p = (bmp_t *)calloc(primary, sizeof (bmp_t));
		if (*p != NULL) {
			*n = primary;
		} else {
			*n = 0;
			ec = ISNS_RSP_INTERNAL_ERROR;
		}
	}

	if (*p != NULL) {
		(*p)[primary - 1] |= (1 << second);
	}

	return (ec);
}

int
cb_clone_attrs(
	void *p1,
	void *p2
)
{
	int ec = 0;

	isns_obj_t *obj = (isns_obj_t *)p1;
	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;

	isns_attr_t *attr;

	int i = 1;

	while (i < MAX_LOOKUP_CTRL &&
	    lcp->op[i] != 0) {
		i ++;
	}

	while (ec == 0 &&
	    i < MAX_LOOKUP_CTRL &&
	    lcp->id[i] != 0) {
		switch (lcp->id[i]) {
		case ISNS_ISCSI_NAME_ATTR_ID:
			attr = &obj->attrs[ATTR_INDEX_ISCSI(
			    ISNS_ISCSI_NAME_ATTR_ID)];
			lcp->data[i].ptr = (uchar_t *)malloc(attr->len);
			if (lcp->data[i].ptr != NULL) {
				(void) strcpy((char *)lcp->data[i].ptr,
				    (char *)attr->value.ptr);
			} else {
				/* memory exhausted */
				ec = ISNS_RSP_INTERNAL_ERROR;
			}
			break;
		case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
			attr = &obj->attrs[ATTR_INDEX_ISCSI(
			    ISNS_ISCSI_NODE_TYPE_ATTR_ID)];
			lcp->data[i].ui = attr->value.ui;
			break;
		case ISNS_PG_ISCSI_NAME_ATTR_ID:
			attr = &obj->attrs[ATTR_INDEX_PG(
			    ISNS_PG_ISCSI_NAME_ATTR_ID)];
			lcp->data[i].ptr = (uchar_t *)malloc(attr->len);
			if (lcp->data[i].ptr != NULL) {
				(void) strcpy((char *)lcp->data[i].ptr,
				    (char *)attr->value.ptr);
			} else {
				/* memory exhausted */
				ec = ISNS_RSP_INTERNAL_ERROR;
			}
			break;
		case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
			attr = &obj->attrs[ATTR_INDEX_PG(
			    ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)];
			lcp->data[i].ip = (in6_addr_t *)malloc(attr->len);
			if (lcp->data[i].ip != NULL) {
				(void) memcpy(lcp->data[i].ip,
				    attr->value.ip, attr->len);
			} else {
				/* memory exhausted */
				ec = ISNS_RSP_INTERNAL_ERROR;
			}
			break;
		case ISNS_PG_PORTAL_PORT_ATTR_ID:
			attr = &obj->attrs[ATTR_INDEX_PG(
			    ISNS_PG_PORTAL_PORT_ATTR_ID)];
			lcp->data[i].ui = attr->value.ui;
			break;
		case ISNS_PORTAL_IP_ADDR_ATTR_ID:
			attr = &obj->attrs[ATTR_INDEX_PORTAL(
			    ISNS_PORTAL_IP_ADDR_ATTR_ID)];
			lcp->data[i].ip = (in6_addr_t *)malloc(attr->len);
			if (lcp->data[i].ip != NULL) {
				(void) memcpy(lcp->data[i].ip,
				    attr->value.ip, attr->len);
			} else {
				/* memory exhausted */
				ec = ISNS_RSP_INTERNAL_ERROR;
			}
			break;
		case ISNS_PORTAL_PORT_ATTR_ID:
		case ISNS_ESI_PORT_ATTR_ID:
			attr = &obj->attrs[ATTR_INDEX_PORTAL(lcp->id[i])];
			if (attr->tag != 0 && attr->value.ui != 0) {
				lcp->data[i].ui = attr->value.ui;
			} else {
				lcp->data[i].ui = 0;
			}
			break;
		default:
			ASSERT(0);
			lcp->data[i].ui = 0;
			break;
		}
		i ++;
	}

	return (ec);
}

static matrix_t *
new_matrix(
	uint32_t x,
	uint32_t y
)
{
	matrix_t *matrix;

	matrix = (matrix_t *)malloc(sizeof (matrix_t));
	if (matrix != NULL) {
		matrix->x = x;
		matrix->y = y;
		matrix->m = (bmp_t *)calloc(y, SIZEOF_X_UNIT(matrix));
		if (matrix->m == NULL) {
			free(matrix);
			matrix = NULL;
		}
	}

	return (matrix);
}

int
dd_matrix_init(
	struct cache *c
)
{
	matrix_t *x;
	bmp_t *bmp;
	uint32_t primary;
	uint32_t second;

	/*
	 * allocate an array of pointer for dd and dd-set matrix.
	 */
	c->x = (matrix_t **)calloc(2, sizeof (matrix_t *));
	if (c->x == NULL) {
		return (1);
	}

	/*
	 * create dd matrix.
	 */
	x = new_matrix(8, 64);
	if (x != NULL) {
		x->c = c;
		c->x[0] = x;
	} else {
		return (1);
	}

	/*
	 * Mark the first array on the y axis for Default DD.
	 */
	bmp = MATRIX_X_UNIT(x, 0);
	MATRIX_X_INFO(bmp) = ISNS_DEFAULT_DD_ID;

	/*
	 * create dd set matrix.
	 */
	x = new_matrix(2, 16);
	if (x != NULL) {
		x->c = c;
		c->x[1] = x;
	} else {
		return (1);
	}

	/*
	 * Mark the first array on the y axis for Default DD-set.
	 */
	bmp = MATRIX_X_UNIT(x, 0);
	MATRIX_X_INFO(bmp) = ISNS_DEFAULT_DD_SET_ID;

	/*
	 * Add Default DD as a member of Default DD-set.
	 */
	primary = GET_PRIMARY(ISNS_DEFAULT_DD_ID);
	second = GET_SECOND(ISNS_DEFAULT_DD_ID);
	SET_MEMBERSHIP(bmp, primary, second);

	return (0);
}

static uint32_t
get_ds_id(
	matrix_t *matrix,
	uint32_t m_id,
	uint32_t curr_id
)
{
	bmp_t *bmp;
	uint32_t primary = GET_PRIMARY(m_id);
	uint32_t second = GET_SECOND(m_id);
	uint32_t dd_id = 0;
	uint32_t uid;
	int i = 0;

	if (matrix->x > primary) {
		while (i < matrix->y) {
			bmp = MATRIX_X_UNIT(matrix, i);
			uid = MATRIX_X_INFO(bmp);
			if (uid > curr_id &&
			    TEST_MEMBERSHIP(bmp, primary, second) != 0) {
				if (dd_id == 0 || uid < dd_id) {
					dd_id = uid;
				}
			}
			i ++;
		}
	}

	return (dd_id);
}

uint32_t
get_common_dd(
	uint32_t m_id1,
	uint32_t m_id2,
	uint32_t curr_id
)
{
	matrix_t *matrix;

	bmp_t *bmp;
	uint32_t primary1 = GET_PRIMARY(m_id1);
	uint32_t second1 = GET_SECOND(m_id1);
	uint32_t primary2 = GET_PRIMARY(m_id2);
	uint32_t second2 = GET_SECOND(m_id2);
	uint32_t dd_id = 0;
	int i = 0;

	matrix = cache_get_matrix(OBJ_DD);

	if (matrix->x > primary1 && matrix->x > primary2) {
		while (i < matrix->y) {
			bmp = MATRIX_X_UNIT(matrix, i);
			if (MATRIX_X_INFO(bmp) > curr_id &&
			    TEST_MEMBERSHIP(bmp, primary1, second1) != 0 &&
			    TEST_MEMBERSHIP(bmp, primary2, second2) != 0) {
				dd_id = MATRIX_X_INFO(bmp);
				break;
			}
			i ++;
		}
	}

	return (dd_id);
}

uint32_t
get_dd_id(
	uint32_t m_id,
	uint32_t curr_id
)
{
	matrix_t *matrix = cache_get_matrix(OBJ_DD);

	return (get_ds_id(matrix, m_id, curr_id));
}

uint32_t
get_dds_id(
	uint32_t m_id,
	uint32_t curr_id
)
{
	matrix_t *matrix = cache_get_matrix(OBJ_DDS);

	return (get_ds_id(matrix, m_id, curr_id));
}

static int
create_ds_object(
	isns_type_t type,
	isns_obj_t **ds_p,
	isns_attr_t *name_attr,
	isns_attr_t *uid_attr,
	isns_attr_t *status_attr
)
{
	int ec = 0;

	isns_obj_t *obj;
	int id1, id2, id3;

	if (type == OBJ_DD) {
		id1 = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
		id2 = ATTR_INDEX_DD(ISNS_DD_ID_ATTR_ID);
		id3 = ATTR_INDEX_DD(ISNS_DD_FEATURES_ATTR_ID);
	} else {
		ASSERT(type == OBJ_DDS);
		id1 = ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID);
		id2 = ATTR_INDEX_DDS(ISNS_DD_SET_ID_ATTR_ID);
		id3 = ATTR_INDEX_DDS(ISNS_DD_SET_STATUS_ATTR_ID);
	}

	obj = obj_calloc(type);
	if (obj != NULL &&
	    (name_attr != NULL && name_attr->tag != 0 &&
	    assign_attr(&obj->attrs[id1], name_attr) == 0) &&
	    (uid_attr == NULL || uid_attr->value.ui == 0 ||
	    assign_attr(&obj->attrs[id2], uid_attr) == 0) &&
	    (status_attr == NULL || status_attr->value.ui == 0 ||
	    assign_attr(&obj->attrs[id3], status_attr) == 0)) {
		*ds_p = obj;
	} else {
		/* no memory */
		free_object(obj);
		ec = ISNS_RSP_INTERNAL_ERROR;
	}

	return (ec);
}

int
create_dd_object(
	isns_tlv_t *op,
	uint16_t op_len,
	isns_obj_t **dd_p
)
{
	int ec = 0;
	uint8_t *value;
	isns_attr_t name = { 0 };
	isns_attr_t dd_id = { 0 }, features = { 0 };

	name.tag = ISNS_DD_NAME_ATTR_ID;

	while (op_len > 8 && ec == 0) {
		value = &op->attr_value[0];
		switch (op->attr_id) {
		case ISNS_DD_ID_ATTR_ID:
			if (op->attr_len == 4) {
				dd_id.tag = ISNS_DD_ID_ATTR_ID;
				dd_id.len = 4;
				dd_id.value.ui = ntohl(*(uint32_t *)value);
			} else if (op->attr_len != 0) {
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
			}
			break;
		case ISNS_DD_NAME_ATTR_ID:
			if (op->attr_len > 0 &&
			    op->attr_len <= 256) {
				name.len = op->attr_len;
				name.value.ptr = (uchar_t *)value;
			} else if (op->attr_len != 0) {
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
			}
			break;
		case ISNS_DD_ISCSI_INDEX_ATTR_ID:
		case ISNS_DD_ISCSI_NAME_ATTR_ID:
			break;
		case ISNS_DD_FC_PORT_NAME_ATTR_ID:
		case ISNS_DD_PORTAL_INDEX_ATTR_ID:
		case ISNS_DD_PORTAL_IP_ADDR_ATTR_ID:
		case ISNS_DD_PORTAL_PORT_ATTR_ID:
			ec = ISNS_RSP_REGIS_NOT_SUPPORTED;
			break;
		case ISNS_DD_FEATURES_ATTR_ID:
			if (op->attr_len == 4) {
				features.tag = ISNS_DD_FEATURES_ATTR_ID;
				features.len = op->attr_len;
				features.value.ui = ntohl(*(uint32_t *)value);
			} else if (op->attr_len != 0) {
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
			}
			break;
		default:
			ec = ISNS_RSP_INVALID_REGIS;
			break;
		}
		NEXT_TLV(op, op_len);
	}

	if (ec == 0) {
		ec = create_ds_object(OBJ_DD, dd_p,
		    &name, &dd_id, &features);
	}

	return (ec);
}

int
create_dds_object(
	isns_tlv_t *op,
	uint16_t op_len,
	isns_obj_t **dds_p
)
{
	int ec = 0;
	uint8_t *value;
	isns_attr_t name = { 0 };
	isns_attr_t dds_id = { 0 }, code = { 0 };

	name.tag = ISNS_DD_SET_NAME_ATTR_ID;

	while (op_len > 8 && ec == 0) {
		value = &op->attr_value[0];
		switch (op->attr_id) {
		case ISNS_DD_SET_ID_ATTR_ID:
			if (op->attr_len == 4) {
				dds_id.tag = ISNS_DD_ID_ATTR_ID;
				dds_id.len = 4;
				dds_id.value.ui = ntohl(*(uint32_t *)value);
			} else if (op->attr_len != 0) {
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
			}
			break;
		case ISNS_DD_SET_NAME_ATTR_ID:
			if (op->attr_len > 0 &&
			    op->attr_len <= 256) {
				name.len = op->attr_len;
				name.value.ptr = (uchar_t *)value;
			} else if (op->attr_len != 0) {
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
			}
			break;
		case ISNS_DD_SET_STATUS_ATTR_ID:
			if (op->attr_len == 4) {
				code.tag = ISNS_DD_SET_STATUS_ATTR_ID;
				code.len = op->attr_len;
				code.value.ui = ntohl(*(uint32_t *)value);
			} else if (op->attr_len != 0) {
				ec = ISNS_RSP_MSG_FORMAT_ERROR;
			}
			break;
		case ISNS_DD_ID_ATTR_ID:
			break;
		default:
			ec = ISNS_RSP_INVALID_REGIS;
			break;
		}
		NEXT_TLV(op, op_len);
	}

	if (ec == 0) {
		ec = create_ds_object(OBJ_DDS, dds_p,
		    &name, &dds_id, &code);
	}

	return (ec);
}

int
adm_create_dd(
	isns_obj_t **dd_p,
	uchar_t *name,
	uint32_t uid,
	uint32_t features
)
{
	uint32_t len;
	isns_attr_t name_attr = { 0 };
	isns_attr_t uid_attr = { 0 };
	isns_attr_t features_attr = { 0 };

	name_attr.tag = ISNS_DD_NAME_ATTR_ID;
	if (name != NULL) {
		/* need to include the null terminator */
		/* and be on 4 bytes aligned */
		len = strlen((char *)name) + 1;
		len += 4 - (len % 4);
		name_attr.len = len;
		name_attr.value.ptr = name;
	}

	uid_attr.tag = ISNS_DD_ID_ATTR_ID;
	uid_attr.len = 4;
	uid_attr.value.ui = uid;

	features_attr.tag = ISNS_DD_FEATURES_ATTR_ID;
	features_attr.len = 4;
	features_attr.value.ui = features;

	return (create_ds_object(OBJ_DD, dd_p,
	    &name_attr, &uid_attr, &features_attr));
}

int
adm_create_dds(
	isns_obj_t **dds_p,
	uchar_t *name,
	uint32_t uid,
	uint32_t code
)
{
	uint32_t len;
	isns_attr_t name_attr = { 0 };
	isns_attr_t uid_attr = { 0 };
	isns_attr_t code_attr = { 0 };

	name_attr.tag = ISNS_DD_SET_NAME_ATTR_ID;
	if (name != NULL) {
		/* need to include the null terminator */
		/* and be on 4 bytes aligned */
		len = strlen((char *)name) + 1;
		len += 4 - (len % 4);
		name_attr.len = len;
		name_attr.value.ptr = name;
	}

	uid_attr.tag = ISNS_DD_SET_ID_ATTR_ID;
	uid_attr.len = 4;
	uid_attr.value.ui = uid;

	code_attr.tag = ISNS_DD_SET_STATUS_ATTR_ID;
	code_attr.len = 4;
	code_attr.value.ui = code;

	return (create_ds_object(OBJ_DDS, dds_p,
	    &name_attr, &uid_attr, &code_attr));
}

static int
update_ds_name(
	isns_type_t type,
	uint32_t uid,
	uint32_t tag,
	uint32_t len,
	uchar_t *name
)
{
	int ec = 0;

	lookup_ctrl_t lc;

	SET_UID_LCP(&lc, type, uid);

	lc.id[1] = tag;
	lc.data[1].ui = len;
	lc.data[2].ptr = name;

	ec = cache_rekey(&lc, &uid, cb_update_ds_attr);
	if (uid == 0) {
		ec = ISNS_RSP_INVALID_REGIS;
	}

	return (ec);
}

int
update_dd_name(
	uint32_t uid,
	uint32_t len,
	uchar_t *name
)
{
	/*
	 * We do now allow changing the default DD and DD-set name.
	 */
	if (uid == ISNS_DEFAULT_DD_ID) {
		return (ISNS_RSP_OPTION_NOT_UNDERSTOOD);
	}

	return (update_ds_name(OBJ_DD, uid, ISNS_DD_NAME_ATTR_ID, len, name));
}

int
update_dds_name(
	uint32_t uid,
	uint32_t len,
	uchar_t *name
)
{
	/*
	 * We do now allow changing the default DD and DD-set name.
	 */
	if (uid == ISNS_DEFAULT_DD_ID) {
		return (ISNS_RSP_OPTION_NOT_UNDERSTOOD);
	}

	return (update_ds_name(OBJ_DDS, uid,
	    ISNS_DD_SET_NAME_ATTR_ID, len, name));
}

static int
update_ds_uint32(
	isns_type_t type,
	uint32_t uid,
	uint32_t tag,
	uint32_t value
)
{
	int ec = 0;

	lookup_ctrl_t lc;

	SET_UID_LCP(&lc, type, uid);

	lc.id[1] = tag;
	lc.data[1].ui = value;

	ec = cache_lookup(&lc, &uid, cb_update_ds_attr);
	if (uid == 0) {
		ec = ISNS_RSP_INVALID_REGIS;
	}

	return (ec);
}

int
update_dd_features(
	uint32_t uid,
	uint32_t features
)
{
	return (update_ds_uint32(OBJ_DD, uid,
	    ISNS_DD_FEATURES_ATTR_ID, features));
}

int
update_dds_status(
	uint32_t uid,
	uint32_t enabled
)
{
	return (update_ds_uint32(OBJ_DDS, uid,
	    ISNS_DD_SET_STATUS_ATTR_ID, enabled));
}

int
add_dd_member(
	isns_obj_t *assoc
)
{
	int ec = 0;

	uint32_t dd_id;
	uint32_t m_id, m_type;

	dd_id = get_parent_uid(assoc);
	/*
	 * We do now allow placing any node to the default DD explicitly.
	 */
	if (dd_id == ISNS_DEFAULT_DD_ID) {
		return (ISNS_RSP_OPTION_NOT_UNDERSTOOD);
	}

	ec = get_member_info(assoc, &m_type, &m_id, 1);
	if (ec == 0) {
		ec = update_dd_matrix(
		    '+', /* add member */
		    dd_id,
		    m_type,
		    m_id);
	}

	if (ec == 0) {
		if (sys_q != NULL) {
			/* add the membership to data store */
			ec = write_data(DATA_ADD, assoc);
		}

		/* trigger a management scn */
		if (ec == 0 && scn_q != NULL) {
			(void) make_scn(ISNS_MEMBER_ADDED, assoc);
		}
	}

	return (ec);
}

int
add_dds_member(
	isns_obj_t *assoc
)
{
	int ec = 0;

	uint32_t m_id = assoc->attrs[ATTR_INDEX_ASSOC_DD(
	    ISNS_DD_ID_ATTR_ID)].value.ui;
	uint32_t dds_id;

	dds_id = get_parent_uid(assoc);
	/*
	 * We do now allow changing the membership of the default DD
	 * and DD-set.
	 */
	if (dds_id == ISNS_DEFAULT_DD_SET_ID ||
	    m_id == ISNS_DEFAULT_DD_ID) {
		return (ISNS_RSP_OPTION_NOT_UNDERSTOOD);
	}

	ec = get_dds_member_info(m_id);
	if (ec == 0) {
		ec = update_dds_matrix(
		    '+', /* add member */
		    dds_id,
		    m_id);
	}

	if (ec == 0) {
		if (sys_q != NULL) {
			/* add the membership to data store */
			ec = write_data(DATA_ADD, assoc);
		}

		/* trigger a management scn */
		if (ec == 0 && scn_q != NULL) {
			(void) make_scn(ISNS_MEMBER_ADDED, assoc);
		}
	}

	return (ec);
}

int
remove_dd_member(
	isns_obj_t *assoc
)
{
	int ec = 0;

	uint32_t dd_id;
	uint32_t m_type;
	uint32_t m_id;

	lookup_ctrl_t lc;

	dd_id = get_parent_uid(assoc);
	/*
	 * We do now allow removing the member from default DD explicitly.
	 */
	if (dd_id == ISNS_DEFAULT_DD_ID) {
		return (ISNS_RSP_OPTION_NOT_UNDERSTOOD);
	}

	ec = get_member_info(assoc, &m_type, &m_id, 0);
	if (ec == 0) {
		ec = update_dd_matrix(
		    '-', /* remove member */
		    dd_id,
		    m_type,
		    m_id);
		if (ec == 0) {
			/* update data store */
			if (sys_q != NULL) {
				/* remove it from data store */
				ec = write_data(
				    DATA_DELETE_ASSOC, assoc);
			}

			/* trigger a management scn */
			if (ec == 0 && scn_q != NULL) {
				(void) make_scn(ISNS_MEMBER_REMOVED, assoc);
			}

			/* remove it from object container if */
			/* it is not a registered object */
			if (ec == 0) {
				SET_UID_LCP(&lc, m_type, m_id);
				ec = dereg_assoc(&lc);
			}
		}
	}

	return (ec);
}

int
remove_dds_member(
	uint32_t dds_id,
	uint32_t m_id
)
{
	int ec = 0;

	isns_obj_t *clone;

	/*
	 * We do now allow removing the member from default DD-set.
	 */
	if (dds_id == ISNS_DEFAULT_DD_SET_ID) {
		return (ISNS_RSP_OPTION_NOT_UNDERSTOOD);
	}

	if (m_id != 0) {
		ec = update_dds_matrix(
		    '-', /* remove member */
		    dds_id,
		    m_id);
		if (ec == 0) {
			clone = obj_calloc(OBJ_ASSOC_DD);
			if (clone != NULL) {
				(void) set_obj_uid((void *)clone, m_id);
				(void) set_parent_obj(clone, dds_id);
			}
			/* update data store */
			if (sys_q != NULL) {
				if (clone != NULL) {
					/* remove it from data store */
					ec = write_data(
					    DATA_DELETE_ASSOC, clone);
				} else {
					ec = ISNS_RSP_INTERNAL_ERROR;
				}
			}

			/* trigger a management scn */
			if (ec == 0 &&
			    scn_q != NULL &&
			    clone != NULL) {
				(void) make_scn(ISNS_MEMBER_REMOVED, clone);
			}
			free_object(clone);
		}
	}

	return (ec);
}

static int
remove_member_wildchar(
	matrix_t *matrix,
	uint32_t m_id
)
{
	int ec = 0;

	bmp_t *bmp;
	uint32_t x_info;
	int i;

	uint32_t primary = GET_PRIMARY(m_id);
	uint32_t second = GET_SECOND(m_id);

	isns_obj_t *clone;

	if (primary >= matrix->x) {
		return (ec);
	}

	i = 0;
	while (ec == 0 && i < matrix->y) {
		bmp = MATRIX_X_UNIT(matrix, i);
		x_info = MATRIX_X_INFO(bmp);
		if (x_info != 0 &&
		    TEST_MEMBERSHIP(bmp, primary, second) != 0) {
			/* clean the membership */
			CLEAR_MEMBERSHIP(bmp, primary, second);
			/* update data store */
			if (sys_q != NULL) {
				clone = obj_calloc(OBJ_ASSOC_DD);
				if (clone != NULL) {
					(void) set_obj_uid((void *)clone, m_id);
					(void) set_parent_obj(clone, x_info);
					/* remove it from data store */
					ec = write_data(
					    DATA_DELETE_ASSOC, clone);
					free_object(clone);
				} else {
					ec = ISNS_RSP_INTERNAL_ERROR;
				}
			}
		}
		i ++;
	}

	return (ec);
}

int
remove_dd_object(
	uint32_t dd_id
)
{
	matrix_t *dds_matrix;

	bmp_t *p;
	uint32_t n;
	int ec;

	lookup_ctrl_t lc;
	uint32_t uid;

	/*
	 * We do now allow removing the default DD.
	 */
	if (dd_id == ISNS_DEFAULT_DD_ID) {
		return (ISNS_RSP_OPTION_NOT_UNDERSTOOD);
	}

	SET_UID_LCP(&lc, OBJ_DD, dd_id);

	/* de-register the object at first */
	ec = dereg_object(&lc, 0);

	/* clear it from all of dd-set */
	dds_matrix = cache_get_matrix(OBJ_DDS);
	(void) remove_member_wildchar(dds_matrix, dd_id);

	/* clear its member bitmap */
	(void) clear_dd_matrix(dd_id, &p, &n);

	/* deregister the member nodes which are not-registered node */
	/* and have no longer membership in other DD(s). */
	if (p != NULL) {
		SET_UID_LCP(&lc, OBJ_ISCSI, 0);
		FOR_EACH_MEMBER(p, n, uid, {
			lc.data[0].ui = uid;
			(void) dereg_assoc(&lc);
		});
		free(p);
	}

	return (ec);
}

int
remove_dds_object(
	uint32_t dds_id
)
{
	int ec;

	lookup_ctrl_t lc;

	/*
	 * We do now allow removing the default DD-set.
	 */
	if (dds_id == ISNS_DEFAULT_DD_SET_ID) {
		return (ISNS_RSP_OPTION_NOT_UNDERSTOOD);
	}

	(void) clear_dds_matrix(dds_id);

	SET_UID_LCP(&lc, OBJ_DDS, dds_id);

	ec = dereg_object(&lc, 0);

	return (ec);
}

int
update_ddd(
	void *p,
	const uchar_t op
)
{
	isns_obj_t *obj;
	uint32_t uid;

	matrix_t *matrix;

	obj = (isns_obj_t *)p;
	if (obj->type != OBJ_ISCSI) {
		return (0);
	}

	matrix = cache_get_matrix(OBJ_DD);
	uid = get_obj_uid(obj);

	return (update_matrix(matrix, op, ISNS_DEFAULT_DD_ID, uid, 0));
}

int
verify_ddd(
)
{
	int ec = 0;

	lookup_ctrl_t lc;
	isns_obj_t *obj;

	uchar_t *name;
	uint32_t uid;
	uint32_t features;
	uint32_t code;

	/* Ensure the Default DD is registered. */
	uid = ISNS_DEFAULT_DD_ID;

	SET_UID_LCP(&lc, OBJ_DD, uid);

	(void) cache_lock_write();

	if (is_obj_there(&lc) == 0) {
		name = (uchar_t *)DEFAULT_DD_NAME;
		features = DEFAULT_DD_FEATURES;
		ec = adm_create_dd(&obj, name, uid, features);
		if (ec == 0) {
			ec = register_object(obj, NULL, NULL);
			if (ec != 0) {
				free_object(obj);
				goto verify_done;
			}
		} else {
			goto verify_done;
		}
	}

	/* Ensure the Default DD-set is registered. */
	uid = ISNS_DEFAULT_DD_SET_ID;

	SET_UID_LCP(&lc, OBJ_DDS, uid);

	if (is_obj_there(&lc) == 0) {
		name = (uchar_t *)DEFAULT_DD_SET_NAME;
		code = DEFAULT_DD_SET_STATUS;
		ec = adm_create_dds(&obj, name, uid, code);
		if (ec == 0) {
			ec = register_object(obj, NULL, NULL);
			if (ec != 0) {
				free_object(obj);
			}
		}
	}

verify_done:

	ec = cache_unlock_sync(ec);

	return (ec);
}