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