OpenSolaris_b135/cmd/isns/isnsd/obj.c
/*
* 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.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "isns_server.h"
#include "isns_msgq.h"
#include "isns_htab.h"
#include "isns_cache.h"
#include "isns_pdu.h"
#include "isns_obj.h"
#include "isns_dd.h"
#include "isns_func.h"
#include "isns_dseng.h"
#include "isns_log.h"
#include "isns_scn.h"
#include "isns_utils.h"
#include "isns_esi.h"
/*
* external variables
*/
#ifdef DEBUG
extern int verbose_mc;
extern void print_object(char *, isns_obj_t *);
#endif
extern msg_queue_t *sys_q;
extern msg_queue_t *scn_q;
extern pthread_mutex_t el_mtx;
extern int cache_flag;
/*
* global data
*/
/*
* local variables
*/
/* type of parent object */
const int TYPE_OF_PARENT[MAX_OBJ_TYPE_FOR_SIZE] = {
0,
0,
ISCSI_PARENT_TYPE,
PORTAL_PARENT_TYPE,
PG_PARENT_TYPE,
0, /* OBJ_DD */
0, /* OBJ_DDS */
0, /* MAX_OBJ_TYPE */
0, /* OBJ_DUMMY1 */
0, /* OBJ_DUMMY2 */
0, /* OBJ_DUMMY3 */
0, /* OBJ_DUMMY4 */
ASSOC_ISCSI_PARENT_TYPE,
ASSOC_DD_PARENT_TYPE
};
/* number of children object type */
const int NUM_OF_CHILD[MAX_OBJ_TYPE] = {
0,
MAX_ENTITY_CHILD,
MAX_ISCSI_CHILD,
MAX_PORTAL_CHILD,
MAX_PG_CHILD,
0,
0
};
/* type of a child object */
const int TYPE_OF_CHILD[MAX_OBJ_TYPE][MAX_CHILD_TYPE] = {
{ 0, 0 },
{ OBJ_ISCSI, OBJ_PORTAL },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 }
};
/* number of attributes of certain type of object */
const int NUM_OF_ATTRS[MAX_OBJ_TYPE_FOR_SIZE] = {
0,
NUM_OF_ENTITY_ATTRS,
NUM_OF_ISCSI_ATTRS,
NUM_OF_PORTAL_ATTRS,
NUM_OF_PG_ATTRS,
NUM_OF_DD_ATTRS,
NUM_OF_DDS_ATTRS,
0, /* MAX_OBJ_TYPE */
0, /* OBJ_DUMMY1 */
0, /* OBJ_DUMMY2 */
0, /* OBJ_DUMMY3 */
0, /* OBJ_DUMMY4 */
NUM_OF_ASSOC_ISCSI_ATTRS,
NUM_OF_ASSOC_DD_ATTRS
};
/* the tag of UID of each type of object */
static const int UID_TAG[MAX_OBJ_TYPE_FOR_SIZE] = {
0,
ISNS_ENTITY_INDEX_ATTR_ID,
ISNS_ISCSI_NODE_INDEX_ATTR_ID,
ISNS_PORTAL_INDEX_ATTR_ID,
ISNS_PG_INDEX_ATTR_ID,
ISNS_DD_ID_ATTR_ID,
ISNS_DD_SET_ID_ATTR_ID,
0, /* MAX_OBJ_TYPE */
0, /* OBJ_DUMMY1 */
0, /* OBJ_DUMMY2 */
0, /* OBJ_DUMMY3 */
0, /* OBJ_DUMMY4 */
ISNS_DD_ISCSI_INDEX_ATTR_ID,
ISNS_DD_ID_ATTR_ID
};
/* the index of UID of each type of object */
const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE] = {
0,
ATTR_INDEX_ENTITY(ISNS_ENTITY_INDEX_ATTR_ID),
ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_INDEX_ATTR_ID),
ATTR_INDEX_PORTAL(ISNS_PORTAL_INDEX_ATTR_ID),
ATTR_INDEX_PG(ISNS_PG_INDEX_ATTR_ID),
ATTR_INDEX_DD(ISNS_DD_ID_ATTR_ID),
ATTR_INDEX_DDS(ISNS_DD_SET_ID_ATTR_ID),
0, /* MAX_OBJ_TYPE */
0, /* OBJ_DUMMY1 */
0, /* OBJ_DUMMY2 */
0, /* OBJ_DUMMY3 */
0, /* OBJ_DUMMY4 */
ATTR_INDEX_ASSOC_ISCSI(ISNS_DD_ISCSI_INDEX_ATTR_ID),
ATTR_INDEX_ASSOC_DD(ISNS_DD_ID_ATTR_ID)
};
/* the index of the key attributes of each type of object */
static const int KEY_ATTR_INDEX[MAX_OBJ_TYPE][MAX_KEY_ATTRS] = {
{ 0 },
{ ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID), 0 },
{ ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID),
0 },
{ ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID),
ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID),
0 },
{ ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID),
ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID),
ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID) },
{ ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID), 0 },
{ ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID), 0 }
};
/* the operating methods for key attributes of each type of object */
static const int KEY_ATTR_OP[MAX_OBJ_TYPE][MAX_KEY_ATTRS] = {
{ 0 },
{ OP_STRING, 0 },
{ OP_STRING, 0 },
{ OP_MEMORY_IP6, OP_INTEGER, 0 },
{ OP_STRING, OP_MEMORY_IP6, OP_INTEGER },
{ OP_STRING, 0 },
{ OP_STRING, 0 }
};
/* the size of each type of object */
static const int SIZEOF_OBJ[MAX_OBJ_TYPE_FOR_SIZE] = {
0,
sizeof (isns_entity_t),
sizeof (isns_iscsi_t),
sizeof (isns_portal_t),
sizeof (isns_pg_t),
sizeof (isns_dd_t),
sizeof (isns_dds_t),
0,
0,
0,
0,
0,
sizeof (isns_assoc_iscsi_t),
sizeof (isns_assoc_dd_t)
};
#ifdef DEBUG
const int NUM_OF_REF[MAX_OBJ_TYPE_FOR_SIZE] = {
#else
static const int NUM_OF_REF[MAX_OBJ_TYPE_FOR_SIZE] = {
#endif
0,
0,
0,
0,
PG_REF_COUNT,
0,
0,
0,
0,
0,
0,
0,
0,
0
};
/* the type of the reference object */
static const int TYPE_OF_REF[MAX_OBJ_TYPE][MAX_REF_COUNT + 1] = {
{ 0 },
{ 0 },
{ OBJ_PG, OBJ_PORTAL, 0 },
{ OBJ_PG, OBJ_ISCSI, 0 },
{ 0, OBJ_ISCSI, OBJ_PORTAL },
{ 0 },
{ 0 }
};
/* the operating method for match operation of the reference object */
#define MAX_REF_MATCH (2)
static const int REF_MATCH_OPS[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
{ 0, 0 },
{ 0, 0 },
{ OP_STRING, 0 },
{ OP_MEMORY_IP6, OP_INTEGER },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 }
};
/* the index of the attribute of being matched object */
static const int REF_MATCH_ID1[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
{ 0, 0 },
{ 0, 0 },
{ ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID), 0 },
{ ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID),
ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID) },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 }
};
/* the index of the attribute of matching object */
static const int REF_MATCH_ID2[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
{ 0, 0 },
{ 0, 0 },
{ ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID), 0 },
{ ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID),
ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID) },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 }
};
/*
* local functions.
*/
static uint32_t get_reg_period();
static char *make_unique_name(int *, uint32_t);
static lookup_ctrl_t *set_lookup_ctrl(lookup_ctrl_t *, isns_obj_t *);
static int setup_ref_lcp(lookup_ctrl_t *,
const isns_obj_t *, const isns_obj_t *);
static int setup_deref_lcp(lookup_ctrl_t *,
const isns_obj_t *, isns_type_t);
static int cb_get_parent(void *, void *);
static int cb_node_child(void *, void *);
static int cb_set_ref(void *, void *);
static int cb_clear_ref(void *, void *);
static int cb_add_child(void *, void *);
static int cb_remove_child(void *, void *);
static int cb_verify_ref(void *, void *);
static int cb_ref_new2old(void *, void *);
static int cb_new_ref(void *, void *);
static int ref_new2old(
lookup_ctrl_t *, isns_type_t, uint32_t, const isns_obj_t *);
static int ref_new2new(
lookup_ctrl_t *, const isns_obj_t *, const isns_obj_t *);
static int new_ref(const isns_obj_t *, const isns_obj_t *);
static uint32_t setup_parent_lcp(lookup_ctrl_t *, isns_obj_t *);
static int set_obj_offline(isns_obj_t *);
static int copy_attrs(isns_obj_t *, const isns_obj_t *);
static isns_obj_t *make_default_pg(const isns_obj_t *, const isns_obj_t *);
static isns_obj_t *(*const make_ref[MAX_OBJ_TYPE])
(const isns_obj_t *, const isns_obj_t *) = {
NULL,
NULL,
&make_default_pg,
&make_default_pg,
NULL,
NULL,
NULL
};
static uint32_t entity_hval(void *, uint16_t, uint32_t *);
static uint32_t iscsi_hval(void *, uint16_t, uint32_t *);
static uint32_t portal_hval(void *, uint16_t, uint32_t *);
static uint32_t pg_hval(void *, uint16_t, uint32_t *);
static uint32_t dd_hval(void *, uint16_t, uint32_t *);
static uint32_t dds_hval(void *, uint16_t, uint32_t *);
static uint32_t (*const hval_func[MAX_OBJ_TYPE])
(void *, uint16_t, uint32_t *) = {
NULL,
&entity_hval,
&iscsi_hval,
&portal_hval,
&pg_hval,
&dd_hval,
&dds_hval
};
/*
* ****************************************************************************
*
* entity_hval:
* caculate the hash value of a network entity object.
*
* p - the pointer pointers to network entity object or
* the lookup control data, both have the key attribute
* of a network entity object.
* chunk- which chunk of the hash table.
* flags- pointer to flags.
* return - the hash value.
*
* ****************************************************************************
*/
static uint32_t
entity_hval(
void *p,
/* LINTED E_FUNC_ARG_UNUSED */
uint16_t chunk,
uint32_t *flags
)
{
uchar_t *key;
isns_obj_t *obj;
lookup_ctrl_t *lcp;
if ((*flags & FLAGS_CTRL_MASK) == 0) {
/* p pointers to a network entity object */
obj = (isns_obj_t *)p;
key = obj->attrs[ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID)].
value.ptr;
} else {
/* p is lookup control data */
lcp = (lookup_ctrl_t *)p;
key = lcp->data[0].ptr;
}
return (htab_compute_hval(key));
}
/*
* ****************************************************************************
*
* iscsi_hval:
* caculate the hash value of an iscsi storage node object.
*
* p - the pointer pointers to iscsi storage node object or
* the lookup control data, both have the key attribute
* of an iscsi storage node object.
* chunk- which chunk of the hash table.
* flags- pointer to flags.
* return - the hash value.
*
* ****************************************************************************
*/
static uint32_t
iscsi_hval(
void *p,
/* LINTED E_FUNC_ARG_UNUSED */
uint16_t chunk,
uint32_t *flags
)
{
uchar_t *key;
isns_obj_t *obj;
lookup_ctrl_t *lcp;
if ((*flags & FLAGS_CTRL_MASK) == 0) {
/* p pointers to an iscsi storage node object */
obj = (isns_obj_t *)p;
key = obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)].
value.ptr;
} else {
/* p is lookup control data */
lcp = (lookup_ctrl_t *)p;
key = lcp->data[0].ptr;
}
return (htab_compute_hval(key));
}
/*
* ****************************************************************************
*
* portal_hval:
* caculate the hash value of a portal object.
*
* p - the pointer pointers to a portal object or the lookup control
* data, both have the key attributes of a portal object.
* chunk- which chunk of the hash table.
* flags- pointer to flags.
* return - the hash value.
*
* ****************************************************************************
*/
static uint32_t
portal_hval(
void *p,
/* LINTED E_FUNC_ARG_UNUSED */
uint16_t chunk,
uint32_t *flags
)
{
char buff[INET6_ADDRSTRLEN + 8] = { 0 };
char buff2[8] = { 0 };
uchar_t *key;
isns_obj_t *obj;
lookup_ctrl_t *lcp;
in6_addr_t *ip;
uint32_t port;
if ((*flags & FLAGS_CTRL_MASK) == 0) {
/* p pointers to a portal object */
obj = (isns_obj_t *)p;
ip = obj->attrs[ATTR_INDEX_PORTAL
(ISNS_PORTAL_IP_ADDR_ATTR_ID)].value.ip;
port = obj->attrs[ATTR_INDEX_PORTAL
(ISNS_PORTAL_PORT_ATTR_ID)].value.ui;
} else {
/* p is lookup control data */
lcp = (lookup_ctrl_t *)p;
ip = lcp->data[0].ip;
port = lcp->data[1].ui;
}
key = (uchar_t *)inet_ntop(AF_INET6, (void *)ip,
buff, sizeof (buff));
(void) snprintf(buff2, sizeof (buff2), "%d", port);
(void) strcat((char *)key, buff2);
return (htab_compute_hval(key));
}
/*
* ****************************************************************************
*
* pg_hval:
* caculate the hash value of a portal group object.
*
* p - the pointer pointers to a portal group object or the lookup
* control data, both have the key attributes of a portal object.
* chunk- which chunk of the hash table.
* flags- pointer to flags.
* return - the hash value.
*
* ****************************************************************************
*/
static uint32_t
pg_hval(
void *p,
uint16_t chunk,
uint32_t *flags
)
{
char buff[INET6_ADDRSTRLEN + 8] = { 0 };
char buff2[8] = { 0 };
uchar_t *key = NULL;
isns_obj_t *obj;
lookup_ctrl_t *lcp;
in6_addr_t *ip = NULL;
uint32_t port;
if ((*flags & FLAGS_CTRL_MASK) == 0) {
/* p is a portal group object */
obj = (isns_obj_t *)p;
if (chunk == 0) {
/* the first chunk */
key = obj->attrs[ATTR_INDEX_PG
(ISNS_PG_ISCSI_NAME_ATTR_ID)].value.ptr;
} else {
/* another chunk */
ip = obj->attrs[ATTR_INDEX_PG
(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)].value.ip;
port = obj->attrs[ATTR_INDEX_PG
(ISNS_PG_PORTAL_PORT_ATTR_ID)].value.ui;
}
} else {
/* p is a lookup control data */
lcp = (lookup_ctrl_t *)p;
/* clear the chunk flags */
*flags &= ~FLAGS_CHUNK_MASK;
if (lcp->op[0] == OP_STRING) {
/* the first chunk */
key = lcp->data[0].ptr;
} else {
/* another chunk */
ip = lcp->data[0].ip;
port = lcp->data[1].ui;
*flags |= 1;
}
}
if (key == NULL) {
key = (uchar_t *)inet_ntop(AF_INET6, (void *)ip,
buff, sizeof (buff));
(void) snprintf(buff2, sizeof (buff2), "%d", port);
(void) strcat((char *)key, buff2);
}
return (htab_compute_hval(key));
}
/*
* ****************************************************************************
*
* dd_hval:
* caculate the hash value of a DD object.
*
* p - the pointer pointers to a DD object or the lookup control data,
* both have the key attributes of a DD object.
* chunk- which chunk of the hash table.
* flags- pointer to flags.
* return - the hash value.
*
* ****************************************************************************
*/
static uint32_t
dd_hval(
void *p,
/* LINTED E_FUNC_ARG_UNUSED */
uint16_t chunk,
uint32_t *flags
)
{
uchar_t *key;
isns_obj_t *obj;
lookup_ctrl_t *lcp;
if ((*flags & FLAGS_CTRL_MASK) == 0) {
/* p is a DD object */
obj = (isns_obj_t *)p;
key = obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)].
value.ptr;
} else {
/* p is a lookup control data */
lcp = (lookup_ctrl_t *)p;
key = lcp->data[0].ptr;
}
return (htab_compute_hval(key));
}
/*
* ****************************************************************************
*
* dds_hval:
* caculate the hash value of a DD-set object.
*
* p - the pointer pointers to a DD-set object or the lookup control data,
* both have the key attributes of a DD-set object.
* chunk- which chunk of the hash table.
* flags- pointer to flags.
* return - the hash value.
*
* ****************************************************************************
*/
static uint32_t
dds_hval(
void *p,
/* LINTED E_FUNC_ARG_UNUSED */
uint16_t chunk,
uint32_t *flags
)
{
uchar_t *key;
isns_obj_t *obj;
lookup_ctrl_t *lcp;
if ((*flags & FLAGS_CTRL_MASK) == 0) {
/* p is a DD-set object */
obj = (isns_obj_t *)p;
key = obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID)].
value.ptr;
} else {
/* p is lookup control data */
lcp = (lookup_ctrl_t *)p;
key = lcp->data[0].ptr;
}
return (htab_compute_hval(key));
}
/*
* ****************************************************************************
*
* obj_hval:
* caculate the hash value of an object.
*
* p - the pointer pointers to an object or lookup control data,
* both has the object type and the key attributes of an object.
* chunk- which chunk of the hash table.
* flags- pointer to flags.
* return - the hash value.
*
* ****************************************************************************
*/
uint32_t
obj_hval(
void *p,
uint16_t chunk,
uint32_t *flags
)
{
isns_type_t type = ((isns_obj_t *)p)->type;
return (hval_func[type](p, chunk, flags));
}
/*
* ****************************************************************************
*
* get_obj_uid:
* get the UID of an object.
*
* p - the pointer pointers to an object.
* return - the UID.
*
* ****************************************************************************
*/
uint32_t
get_obj_uid(
const void *p
)
{
isns_obj_t *obj = (isns_obj_t *)p;
isns_attr_t *attr = &obj->attrs[UID_ATTR_INDEX[obj->type]];
uint32_t uid = attr->value.ui;
return (uid);
}
/*
* ****************************************************************************
*
* set_obj_uid:
* set the UID of an object.
*
* p - the pointer pointers to an object.
* uid - the UID.
* return - the UID.
*
* ****************************************************************************
*/
uint32_t
set_obj_uid(
void *p,
uint32_t uid
)
{
isns_obj_t *obj = (isns_obj_t *)p;
isns_attr_t *attr = &obj->attrs[UID_ATTR_INDEX[obj->type]];
/* set the tag, len and value */
attr->tag = UID_TAG[obj->type];
attr->len = 4;
attr->value.ui = uid;
return (uid);
}
/*
* ****************************************************************************
*
* obj_cmp:
* compare between two objects or an object with a lookup control data.
*
* p1 - the pointer points to an object.
* p2 - the pointer points to an object or a lookup control data.
* flags- 0: p2 is an object; otherwise p2 is a lookup control data.
* return - the comparsion result.
*
* ****************************************************************************
*/
int
obj_cmp(
void *p1,
void *p2,
int flags
)
{
isns_obj_t *obj = (isns_obj_t *)p1;
lookup_ctrl_t buff = { 0 };
lookup_ctrl_t *lcp;
uint32_t uid;
if (flags == 0) {
lcp = set_lookup_ctrl(&buff, (isns_obj_t *)p2);
} else {
lcp = (lookup_ctrl_t *)p2;
uid = get_obj_uid(obj);
/* the object are linked with decending order by */
/* the object UID, if the object UID is greater than */
/* or equal to the current UID, it needs to compare */
/* for the next one. */
if (lcp->curr_uid != 0 && uid >= lcp->curr_uid) {
return (-1);
}
}
return (key_cmp(lcp, obj));
}
/*
* ****************************************************************************
*
* replace_object:
* replace an existing object with the new one.
*
* p1 - the pointer points to an object being replaced.
* p2 - the pointer points to a new object.
* uid_p- points to uid for returning.
* flag - 0: do not free the source object, otherwise free it.
* return - error code.
*
* ****************************************************************************
*/
int
replace_object(
void *p1,
void *p2,
uint32_t *uid_p,
int flag
)
{
int ec = 0;
#ifndef SKIP_SRC_AUTH
uint32_t *pp_dst, *pp_src, swap;
#endif
int online;
isns_obj_t *dst = (isns_obj_t *)p1;
isns_obj_t *src = (isns_obj_t *)p2;
if (src->type == OBJ_DD || src->type == OBJ_DDS) {
/* replace not allowed */
return (ERR_NAME_IN_USE);
}
online = is_obj_online(dst);
/* set cache update flag */
SET_CACHE_UPDATED();
/* update parent uid */
#ifndef SKIP_SRC_AUTH
pp_dst = get_parent_p(dst);
if (pp_dst != NULL) {
pp_src = get_parent_p(src);
swap = *pp_dst;
*pp_dst = *pp_src;
if (swap != 0) {
*pp_src = swap;
}
}
#endif
/* update all of attributes */
if (copy_attrs(dst, src) != 0) {
return (ISNS_RSP_INTERNAL_ERROR);
}
/* free up the src object */
if (flag != 0) {
(void) free_object(src);
} else if (online == 0) {
(void) set_obj_uid(src, get_obj_uid(dst));
(void) set_obj_offline(src);
}
/* update data store */
if (sys_q != NULL) {
ec = write_data(DATA_UPDATE, dst);
} else {
/* we should never have duplicated entry in data store */
ec = ISNS_RSP_INTERNAL_ERROR;
}
/* trigger a scn */
if (ec == 0) {
if (scn_q != NULL) {
(void) make_scn((online == 0) ?
ISNS_OBJECT_ADDED :
ISNS_OBJECT_UPDATED,
dst);
}
if (uid_p != NULL) {
*uid_p = get_obj_uid(dst);
}
}
return (ec);
}
/*
* ****************************************************************************
*
* add_object:
* post function after adding a new object.
*
* p - object which has been added.
* return - error code.
*
* ****************************************************************************
*/
int
add_object(
void *p
)
{
int ec = 0;
isns_obj_t *obj = (isns_obj_t *)p;
/* add the new object to data store */
if (sys_q != NULL) {
ec = write_data(DATA_ADD, obj);
}
/* trigger a scn */
if (ec == 0 && scn_q != NULL) {
(void) make_scn(ISNS_OBJECT_ADDED, obj);
}
return (ec);
}
/*
* ****************************************************************************
*
* obj_tab_init:
* initialize the object hash tables.
*
* c - points to the cache.
* return - error code.
*
* ****************************************************************************
*/
int
obj_tab_init(
struct cache *c
)
{
htab_t *t;
htab_init();
/*
* allocate an array of pointer for the object hash tables.
*/
c->t = (struct htab **)calloc(sizeof (struct htab *), MAX_OBJ_TYPE);
if (c->t == NULL) {
return (1);
}
/*
* hash table for network entity objects.
*/
t = htab_create(UID_FLAGS_SEQ, 8, 1);
if (t != NULL) {
t->c = c;
c->t[OBJ_ENTITY] = t;
} else {
return (1);
}
/*
* hash table for iscsi storage node objects.
*/
t = htab_create(UID_FLAGS_SEQ, 8, 1);
if (t != NULL) {
t->c = c;
c->t[OBJ_ISCSI] = t;
} else {
return (1);
}
/*
* hash table for portal objects.
*/
t = htab_create(UID_FLAGS_SEQ, 8, 1);
if (t != NULL) {
t->c = c;
c->t[OBJ_PORTAL] = t;
} else {
return (1);
}
/*
* hash table for portal group objects.
*/
t = htab_create(UID_FLAGS_SEQ, 8, 2);
if (t != NULL) {
t->c = c;
c->t[OBJ_PG] = t;
} else {
return (1);
}
/*
* hash table for discovery domain objects.
*/
t = htab_create(0, 6, 1);
if (t != NULL) {
t->c = c;
c->t[OBJ_DD] = t;
} else {
return (1);
}
/*
* hash table for discovery domain set objects.
*/
t = htab_create(0, 4, 1);
if (t != NULL) {
t->c = c;
c->t[OBJ_DDS] = t;
} else {
return (1);
}
return (0);
}
/*
* ****************************************************************************
*
* get_ref_np:
* get the ref pointer of the portal group object.
*
* obj - portal group object.
* return - ref pointer.
*
* ****************************************************************************
*/
static uint32_t *
get_ref_np(
isns_obj_t *obj,
int n
)
{
uint32_t *refp =
obj->type == OBJ_PG ? &((isns_pg_t *)obj)->ref[n] : NULL;
return (refp);
}
#ifdef DEBUG
uint32_t
#else
static uint32_t
#endif
get_ref_n(
isns_obj_t *obj,
int n
)
{
return (*get_ref_np(obj, n));
}
static uint32_t *
get_ref_p(
isns_obj_t *obj,
isns_type_t rt
)
{
isns_type_t t = obj->type;
int i = 0;
while (i < NUM_OF_REF[t]) {
if (rt == TYPE_OF_REF[t][i + 1]) {
return (get_ref_np(obj, i));
}
i ++;
}
return (NULL);
}
uint32_t
get_ref_t(
isns_obj_t *obj,
isns_type_t type
)
{
uint32_t *refp = get_ref_p(obj, type);
if (refp != NULL) {
return (*refp);
/* LINTED E_NOP_ELSE_STMT */
} else {
ASSERT(0);
}
return (0);
}
/*
* ****************************************************************************
*
* get_parent_p:
* get the pointer of the parent object.
*
* obj - an object.
* return - parent object pointer.
*
* ****************************************************************************
*/
uint32_t *const
get_parent_p(
const isns_obj_t *obj
)
{
uint32_t *pp;
switch (obj->type) {
case OBJ_ISCSI:
pp = &((isns_iscsi_t *)obj)->puid;
break;
case OBJ_PORTAL:
pp = &((isns_portal_t *)obj)->puid;
break;
case OBJ_PG:
pp = &((isns_pg_t *)obj)->puid;
break;
case OBJ_ASSOC_ISCSI:
pp = &((isns_assoc_iscsi_t *)obj)->puid;
break;
case OBJ_ASSOC_DD:
pp = &((isns_assoc_dd_t *)obj)->puid;
break;
default:
pp = NULL;
break;
}
return (pp);
}
uint32_t
get_parent_uid(
const isns_obj_t *obj
)
{
uint32_t *pp = get_parent_p(obj);
if (pp != NULL) {
return (*pp);
}
return (0);
}
/*
* ****************************************************************************
*
* get_child_np:
* get the pointer of the UID array of the n'th child of an object.
*
* obj - an object.
* n - the child index.
* return - the pointer of the UID array.
*
* ****************************************************************************
*/
static uint32_t **
get_child_np(
isns_obj_t *obj,
int n
)
{
uint32_t **pp =
obj->type == OBJ_ENTITY ? &((isns_entity_t *)obj)->cuid[n] : NULL;
return (pp);
}
/*
* ****************************************************************************
*
* get_child_n:
* get the UID array of the n'th child of an object.
*
* obj - an object.
* n - the child index.
* return - the UID array.
*
* ****************************************************************************
*/
#ifdef DEBUG
uint32_t *
#else
static uint32_t *
#endif
get_child_n(
isns_obj_t *obj,
int n
)
{
uint32_t **pp = get_child_np(obj, n);
if (pp != NULL) {
return (*pp);
}
ASSERT(0);
return (NULL);
}
/*
* ****************************************************************************
*
* get_child_p:
* get the pointer of the UID array of the child matching the type.
*
* base - an object.
* child_type - the child object type.
* return - the pointer of the UID array.
*
* ****************************************************************************
*/
static uint32_t **
get_child_p(
isns_obj_t *base,
int child_type
)
{
uint32_t **pp = NULL;
int i = 0;
while (i < NUM_OF_CHILD[base->type]) {
if (child_type == TYPE_OF_CHILD[base->type][i]) {
pp = get_child_np(base, i);
break;
}
i ++;
}
return (pp);
}
/*
* ****************************************************************************
*
* get_child_t:
* get the UID array of the child object matching the type.
*
* base - an object.
* child_type - the child object type.
* return - the UID array.
*
* ****************************************************************************
*/
uint32_t *
get_child_t(
isns_obj_t *base,
int child_type
)
{
uint32_t **pp = get_child_p(base, child_type);
if (pp != NULL) {
return (*pp);
} else {
return (NULL);
}
}
/*
* ****************************************************************************
*
* key_cmp:
* compare the object against the lookup control data.
*
* lcp - the lookup control data.
* obj - an object.
* return - comparison result.
*
* ****************************************************************************
*/
int
key_cmp(
lookup_ctrl_t *lcp,
isns_obj_t *obj
)
{
int i = 0;
int match = 1;
while (i < MAX_LOOKUP_CTRL && lcp->op[i] > 0 && match) {
isns_attr_t *attr = &obj->attrs[lcp->id[i]];
switch (lcp->op[i]) {
case OP_STRING:
match = (strcmp((const char *)lcp->data[i].ptr,
(const char *)attr->value.ptr) == 0);
break;
case OP_INTEGER:
match = (lcp->data[i].ui == attr->value.ui);
break;
case OP_MEMORY_IP6:
match = !memcmp((void *)lcp->data[i].ip,
(void *)attr->value.ip,
sizeof (in6_addr_t));
break;
default:
ASSERT(0);
match = 0;
break;
}
i ++;
}
if (i && match) {
return (0);
} else {
return (1);
}
}
/*
* ****************************************************************************
*
* set_lookup_ctrl:
* fill in the lookup control data for an object.
*
* lcp - the lookup control data.
* obj - an object.
* return - the lookup control data.
*
* ****************************************************************************
*/
static lookup_ctrl_t *
set_lookup_ctrl(
lookup_ctrl_t *lcp,
isns_obj_t *obj
)
{
isns_type_t type = obj->type;
uint32_t id, op;
int i = 0;
lcp->type = type;
while (i < MAX_KEY_ATTRS) {
op = KEY_ATTR_OP[type][i];
if (op != 0) {
id = KEY_ATTR_INDEX[type][i];
lcp->id[i] = id;
lcp->op[i] = op;
lcp->data[i].ui = obj->attrs[id].value.ui;
} else {
break;
}
i ++;
}
return (lcp);
}
/*
* ****************************************************************************
*
* assign_attr:
* assign an attribute.
*
* attr - the attribute being assigned.
* tmp - the attribute.
* return - error code.
*
* ****************************************************************************
*/
int
assign_attr(
isns_attr_t *attr,
const isns_attr_t *tmp
)
{
uint32_t t;
switch (tmp->tag) {
case ISNS_EID_ATTR_ID:
case ISNS_DD_SET_NAME_ATTR_ID:
case ISNS_DD_NAME_ATTR_ID:
if (tmp->len == 0 && attr->len == 0) {
int len;
char *name = make_unique_name(&len, tmp->tag);
if (name != NULL) {
attr->value.ptr = (uchar_t *)name;
attr->tag = tmp->tag;
attr->len = len;
} else {
/* memory exhausted */
return (1);
}
}
case ISNS_PORTAL_NAME_ATTR_ID:
case ISNS_ISCSI_NAME_ATTR_ID:
case ISNS_ISCSI_ALIAS_ATTR_ID:
case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
case ISNS_PG_ISCSI_NAME_ATTR_ID:
case ISNS_DD_ISCSI_NAME_ATTR_ID:
if (tmp->len == 0) {
return (0);
} else if (tmp->len >= attr->len) {
attr->value.ptr = realloc(
attr->value.ptr, tmp->len + 1);
}
if (attr->value.ptr != NULL) {
(void) strncpy((char *)attr->value.ptr,
(char *)tmp->value.ptr, tmp->len);
attr->value.ptr[tmp->len] = 0;
attr->tag = tmp->tag;
attr->len = tmp->len;
} else {
/* memory exhausted */
return (1);
}
break;
case ISNS_MGMT_IP_ADDR_ATTR_ID:
case ISNS_PORTAL_IP_ADDR_ATTR_ID:
case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
if (attr->value.ip == NULL) {
attr->value.ip = (in6_addr_t *)calloc(1, tmp->len);
}
if (attr->value.ip != NULL) {
(void) memcpy((void *)attr->value.ip,
(void *)tmp->value.ip, tmp->len);
attr->tag = tmp->tag;
attr->len = tmp->len;
} else {
/* memory exhausted */
return (1);
}
break;
case ISNS_ENTITY_INDEX_ATTR_ID:
case ISNS_PORTAL_INDEX_ATTR_ID:
case ISNS_ISCSI_NODE_INDEX_ATTR_ID:
case ISNS_PG_INDEX_ATTR_ID:
case ISNS_DD_SET_ID_ATTR_ID:
case ISNS_DD_ID_ATTR_ID:
if (attr->value.ui != 0) {
break;
}
case ISNS_ENTITY_PROTOCOL_ATTR_ID:
case ISNS_VERSION_RANGE_ATTR_ID:
case ISNS_PORTAL_PORT_ATTR_ID:
case ISNS_ESI_PORT_ATTR_ID:
case ISNS_SCN_PORT_ATTR_ID:
case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
case ISNS_ISCSI_SCN_BITMAP_ATTR_ID:
case ISNS_PG_PORTAL_PORT_ATTR_ID:
case ISNS_PG_TAG_ATTR_ID:
case ISNS_DD_SET_STATUS_ATTR_ID:
case ISNS_DD_ISCSI_INDEX_ATTR_ID:
attr->tag = tmp->tag;
attr->len = tmp->len;
attr->value.ui = tmp->value.ui;
break;
case ISNS_ENTITY_REG_PERIOD_ATTR_ID:
attr->tag = tmp->tag;
attr->len = tmp->len;
attr->value.ui = tmp->value.ui;
t = get_reg_period();
if (attr->value.ui > t) {
attr->value.ui = t;
} else if (attr->value.ui < ONE_DAY) {
attr->value.ui = ONE_DAY;
}
break;
case ISNS_ESI_INTERVAL_ATTR_ID:
attr->tag = tmp->tag;
attr->len = tmp->len;
attr->value.ui = tmp->value.ui;
if (attr->value.ui > ONE_DAY) {
attr->value.ui = ONE_DAY;
} else if (attr->value.ui < MIN_ESI_INTVAL) {
attr->value.ui = MIN_ESI_INTVAL; /* 20 seconds */
}
break;
default:
ASSERT(0);
/* don't assign the attribute */
break;
}
return (0);
}
/*
* ****************************************************************************
*
* copy_attrs:
* copy all of attributes from one object to another.
*
* dst - the destination object.
* tmp - the source object.
* return - error code.
*
* ****************************************************************************
*/
static int
copy_attrs(
isns_obj_t *dst,
const isns_obj_t *src
)
{
int i = 0;
int n = NUM_OF_ATTRS[dst->type];
isns_attr_t *dst_attr;
const isns_attr_t *src_attr;
while (i < n) {
src_attr = &(src->attrs[i]);
if (src_attr->tag != 0) {
dst_attr = &(dst->attrs[i]);
if (assign_attr(dst_attr, src_attr) != 0) {
return (1);
}
}
i ++;
}
return (0);
}
/*
* ****************************************************************************
*
* extract_attr:
* extract an attribute from a TLV format data.
*
* attr - the attribute.
* tlv - the TLV format data.
* return - error code.
*
* ****************************************************************************
*/
int
extract_attr(
isns_attr_t *attr,
const isns_tlv_t *tlv,
int flag
)
{
int ec = 0;
uint32_t min_len = 4, max_len = 224;
switch (tlv->attr_id) {
case ISNS_EID_ATTR_ID:
min_len = 0;
case ISNS_PORTAL_NAME_ATTR_ID:
case ISNS_ISCSI_ALIAS_ATTR_ID:
case ISNS_DD_SET_NAME_ATTR_ID:
case ISNS_DD_NAME_ATTR_ID:
max_len = 256;
case ISNS_ISCSI_NAME_ATTR_ID:
case ISNS_PG_ISCSI_NAME_ATTR_ID:
if (tlv->attr_len < min_len || tlv->attr_len > max_len) {
ec = ISNS_RSP_MSG_FORMAT_ERROR;
} else {
attr->tag = tlv->attr_id;
attr->len = tlv->attr_len;
attr->value.ptr = (uchar_t *)&(tlv->attr_value[0]);
}
break;
case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
attr->tag = tlv->attr_id;
attr->len = tlv->attr_len;
attr->value.ptr = (uchar_t *)&(tlv->attr_value[0]);
break;
case ISNS_MGMT_IP_ADDR_ATTR_ID:
case ISNS_PORTAL_IP_ADDR_ATTR_ID:
case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
if (tlv->attr_len != 16) {
ec = ISNS_RSP_MSG_FORMAT_ERROR;
} else {
attr->tag = tlv->attr_id;
attr->len = tlv->attr_len;
attr->value.ip = (void *)&(tlv->attr_value[0]);
}
break;
case ISNS_ENTITY_PROTOCOL_ATTR_ID:
case ISNS_VERSION_RANGE_ATTR_ID:
case ISNS_ENTITY_REG_PERIOD_ATTR_ID:
/* fall throught */
case ISNS_PORTAL_PORT_ATTR_ID:
case ISNS_ESI_INTERVAL_ATTR_ID:
case ISNS_ESI_PORT_ATTR_ID:
case ISNS_SCN_PORT_ATTR_ID:
/* fall throught */
case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
/* fall throught */
case ISNS_PG_PORTAL_PORT_ATTR_ID:
/* fall throught */
case ISNS_DD_SET_ID_ATTR_ID:
case ISNS_DD_SET_STATUS_ATTR_ID:
/* fall throught */
case ISNS_DD_ID_ATTR_ID:
if (tlv->attr_len != 4) {
ec = ISNS_RSP_MSG_FORMAT_ERROR;
break;
}
case ISNS_PG_TAG_ATTR_ID:
attr->tag = tlv->attr_id;
attr->len = tlv->attr_len;
if (tlv->attr_len == 4) {
attr->value.ui = ntohl(*(uint32_t *)
&(tlv->attr_value[0]));
} else {
attr->value.ui = 0;
}
break;
case ISNS_ISCSI_SCN_BITMAP_ATTR_ID:
/* ignore scn bitmap attribute during object registration, */
/* it is registered by scn_reg message. */
case ISNS_ENTITY_ISAKMP_P1_ATTR_ID:
case ISNS_ENTITY_CERT_ATTR_ID:
case ISNS_PORTAL_SEC_BMP_ATTR_ID:
case ISNS_PORTAL_ISAKMP_P1_ATTR_ID:
case ISNS_PORTAL_ISAKMP_P2_ATTR_ID:
case ISNS_PORTAL_CERT_ATTR_ID:
break;
case ISNS_PORTAL_INDEX_ATTR_ID:
case ISNS_ISCSI_NODE_INDEX_ATTR_ID:
case ISNS_PG_INDEX_ATTR_ID:
if (flag == 0) {
if (tlv->attr_len != 4) {
ec = ISNS_RSP_MSG_FORMAT_ERROR;
} else {
attr->tag = tlv->attr_id;
attr->len = tlv->attr_len;
attr->value.ui = ntohl(*(uint32_t *)
&(tlv->attr_value[0]));
}
break;
}
case ISNS_ENTITY_INDEX_ATTR_ID:
case ISNS_TIMESTAMP_ATTR_ID:
default:
if (flag == 0) {
ec = ISNS_RSP_INVALID_QRY;
} else {
ec = ISNS_RSP_INVALID_REGIS;
}
break;
}
return (ec);
}
/*
* ****************************************************************************
*
* copy_attr:
* copy an attribute from a TLV format data.
*
* attr - the attribute.
* tlv - the TLV format data.
* return - error code.
*
* ****************************************************************************
*/
static int
copy_attr(
isns_attr_t *attr,
const isns_tlv_t *tlv
)
{
int ec = 0;
isns_attr_t tmp = { 0 };
/* extract the attribute first */
ec = extract_attr(&tmp, tlv, 1);
/* assign the attribute */
if (ec == 0 && tmp.tag != 0) {
if (assign_attr(attr, &tmp) != 0) {
ec = ISNS_RSP_INTERNAL_ERROR;
}
}
return (ec);
}
/*
* ****************************************************************************
*
* get_timestamp:
* get current timestamp.
*
* return - current timestamp.
*
* ****************************************************************************
*/
uint32_t
get_timestamp(
)
{
uint32_t t;
int flag;
/* block the scheduler */
(void) pthread_mutex_lock(&el_mtx);
/* get most current time */
if (sys_q != NULL) {
/* need to wakeup idle */
flag = 1;
} else {
flag = 0;
}
t = get_stopwatch(flag);
/* unblock it */
(void) pthread_mutex_unlock(&el_mtx);
return (t);
}
/*
* ****************************************************************************
*
* get_reg_period:
* get the longest registration period.
*
* return - the longest registration period.
*
* ****************************************************************************
*/
static uint32_t
get_reg_period(
)
{
uint32_t t;
uint32_t period;
/* get most current time */
t = get_timestamp();
/* just one second before the end of the world */
period = INFINITY - t - 1;
return (period);
}
/*
* ****************************************************************************
*
* obj_calloc:
* allocate memory space for an object.
*
* type - the object type.
* return - pointer of the object being allocated.
*
* ****************************************************************************
*/
isns_obj_t *
obj_calloc(
int type
)
{
isns_obj_t *obj = NULL;
obj = (isns_obj_t *)calloc(1, SIZEOF_OBJ[type]);
if (obj != NULL) {
obj->type = type;
#ifdef DEBUG
if (verbose_mc) {
printf("object(%d) allocated\n", type);
}
#endif
}
return (obj);
}
/*
* ****************************************************************************
*
* make_default_entity:
* generate a default network entity object.
*
* return - pointer of the default network entity object.
*
* ****************************************************************************
*/
isns_obj_t *
make_default_entity(
)
{
uint32_t t;
isns_obj_t *obj = obj_calloc(OBJ_ENTITY);
isns_attr_t *attr;
if (obj != NULL) {
int len;
char *eid = make_unique_name(&len, ISNS_EID_ATTR_ID);
if (!eid) {
free(obj);
return (NULL);
}
attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID)];
/* set default entity name */
attr->tag = ISNS_EID_ATTR_ID;
attr->len = len;
attr->value.ptr = (uchar_t *)eid;
/* set default registration period */
attr = &obj->attrs[
ATTR_INDEX_ENTITY(ISNS_ENTITY_REG_PERIOD_ATTR_ID)];
if (attr->tag == 0) {
attr->tag = ISNS_ENTITY_REG_PERIOD_ATTR_ID;
attr->len = 4;
t = get_reg_period();
attr->value.ui = t;
}
}
return (obj);
}
/*
* ****************************************************************************
*
* make_default_pg:
* generate a default portal group object.
*
* iscsi - the iscsi storage node object.
* portal - the portal object.
* return - pointer of the default portal group object.
*
* ****************************************************************************
*/
static isns_obj_t *
make_default_pg(
const isns_obj_t *p1,
const isns_obj_t *p2
)
{
const isns_obj_t *iscsi, *portal;
const isns_attr_t *name, *addr, *port;
isns_obj_t *pg;
uchar_t *pg_name;
in6_addr_t *pg_addr;
isns_attr_t *attr;
uint32_t *refp;
if (p1->type == OBJ_ISCSI) {
iscsi = p1;
portal = p2;
} else {
iscsi = p2;
portal = p1;
}
name = &iscsi->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];
addr = &portal->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID)];
port = &portal->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID)];
pg = obj_calloc(OBJ_PG);
pg_name = (uchar_t *)malloc(name->len);
pg_addr = (in6_addr_t *)malloc(addr->len);
if (pg != NULL && pg_name != NULL && pg_addr != NULL) {
(void) strcpy((char *)pg_name, (char *)name->value.ptr);
attr = &pg->attrs[ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID)];
attr->tag = ISNS_PG_ISCSI_NAME_ATTR_ID;
attr->len = name->len;
attr->value.ptr = pg_name;
(void) memcpy((void *)pg_addr,
(void *)addr->value.ip, addr->len);
attr = &pg->attrs[ATTR_INDEX_PG(
ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)];
attr->tag = ISNS_PG_PORTAL_IP_ADDR_ATTR_ID;
attr->len = addr->len;
attr->value.ip = pg_addr;
attr = &pg->attrs[ATTR_INDEX_PG(
ISNS_PG_PORTAL_PORT_ATTR_ID)];
attr->tag = ISNS_PG_PORTAL_PORT_ATTR_ID;
attr->len = port->len;
attr->value.ui = port->value.ui;
attr = &pg->attrs[ATTR_INDEX_PG(
ISNS_PG_TAG_ATTR_ID)];
attr->tag = ISNS_PG_TAG_ATTR_ID;
attr->len = 4;
attr->value.ui = ISNS_DEFAULT_PGT;
refp = get_ref_p(pg, OBJ_ISCSI);
*refp = get_obj_uid(iscsi);
refp = get_ref_p(pg, OBJ_PORTAL);
*refp = get_obj_uid(portal);
(void) set_parent_obj(pg, get_parent_uid(iscsi));
} else {
free(pg);
free(pg_name);
free(pg_addr);
pg = NULL;
}
return (pg);
}
/*
* ****************************************************************************
*
* reg_get_entity:
* parse the Operating Attributes of the DevAttrReg message and
* create the Network Entity object if it has one.
*
* p - the pointer of the object for returning.
* op - the operating attributes.
* op_len - the length of the operating attributes.
* return - error code.
*
* ****************************************************************************
*/
int
reg_get_entity(
isns_obj_t **p,
isns_tlv_t **op,
uint16_t *op_len
)
{
int ec = 0;
isns_tlv_t *tmp;
uint16_t tmp_len;
isns_attr_t *attr;
isns_obj_t *entity = NULL;
tmp = *op;
tmp_len = *op_len;
/* parse the entity object */
if (tmp_len >= 8 && IS_ENTITY_KEY(tmp->attr_id)) {
entity = obj_calloc(OBJ_ENTITY);
if (entity != NULL) {
do {
attr = &entity->attrs[
ATTR_INDEX_ENTITY(tmp->attr_id)];
ec = copy_attr(attr, tmp);
NEXT_TLV(tmp, tmp_len);
} while (ec == 0 &&
tmp_len >= 8 &&
IS_ENTITY_ATTR(tmp->attr_id));
} else {
ec = ISNS_RSP_INTERNAL_ERROR;
}
if (ec == 0) {
/* set default registration period */
attr = &entity->attrs[
ATTR_INDEX_ENTITY(ISNS_ENTITY_REG_PERIOD_ATTR_ID)];
if (attr->tag == 0) {
attr->tag = ISNS_ENTITY_REG_PERIOD_ATTR_ID;
attr->len = 4;
attr->value.ui = get_reg_period();
}
} else if (entity != NULL) {
free(entity);
entity = NULL;
}
}
*p = entity;
*op = tmp;
*op_len = tmp_len;
return (ec);
}
/*
* ****************************************************************************
*
* reg_get_iscsi:
* parse the Operating Attributes of the DevAttrReg message and
* create an iSCSI Storage Node object.
*
* p - the pointer of the object for returning.
* pg_key1 - the pointer of iscsi storage node name for returning.
* op - the operating attributes.
* op_len - the length of the operating attributes.
* return - error code.
*
* ****************************************************************************
*/
static int
reg_get_iscsi(
isns_obj_t **p,
isns_attr_t *pg_key1,
isns_tlv_t **op,
uint16_t *op_len
)
{
int ec = 0;
isns_tlv_t *tmp;
uint16_t tmp_len;
isns_attr_t *attr;
isns_obj_t *obj = NULL;
tmp = *op;
tmp_len = *op_len;
/* keep the iscsi storage node name for */
/* parsing a pg object which is immediately */
/* followed with a PGT by the iscsi storage node */
pg_key1->tag = PG_KEY1;
pg_key1->len = tmp->attr_len;
pg_key1->value.ptr = (uchar_t *)&tmp->attr_value[0];
/* parse one iscsi storage node object */
obj = obj_calloc(OBJ_ISCSI);
if (obj != NULL) {
/* parse key & non-key attributes */
do {
attr = &obj->attrs[
ATTR_INDEX_ISCSI(tmp->attr_id)];
ec = copy_attr(attr, tmp);
NEXT_TLV(tmp, tmp_len);
} while (ec == 0 &&
tmp_len >= 8 &&
IS_ISCSI_ATTR(tmp->attr_id));
} else {
/* no memory */
ec = ISNS_RSP_INTERNAL_ERROR;
}
*p = obj;
*op = tmp;
*op_len = tmp_len;
return (ec);
}
/*
* ****************************************************************************
*
* reg_get_portal:
* parse the Operating Attributes of the DevAttrReg message and
* create a Portal object.
*
* p - the pointer of the object for returning.
* pg_key1 - the pointer of portal ip addr for returning.
* pg_key2 - the pointer of portal port for returning.
* op - the operating attributes.
* op_len - the length of the operating attributes.
* return - error code.
*
* ****************************************************************************
*/
static int
reg_get_portal(
isns_obj_t **p,
isns_attr_t *pg_key1,
isns_attr_t *pg_key2,
isns_tlv_t **op,
uint16_t *op_len
)
{
int ec = 0;
isns_tlv_t *tmp;
uint16_t tmp_len;
isns_attr_t *attr;
isns_obj_t *obj = NULL;
isns_tlv_t *ip;
tmp = *op;
tmp_len = *op_len;
/* keep the portal ip addr */
pg_key1->tag = PG_KEY2;
pg_key1->len = tmp->attr_len;
pg_key1->value.ip = (void *)&tmp->attr_value[0];
ip = tmp;
NEXT_TLV(tmp, tmp_len);
if (tmp_len > 8 &&
tmp->attr_id == PORTAL_KEY2 &&
tmp->attr_len == 4) {
/* keep the portal port */
pg_key2->tag = PG_KEY3;
pg_key2->len = tmp->attr_len;
pg_key2->value.ui = ntohl(*(uint32_t *)&tmp->attr_value[0]);
/* parse one portal object */
obj = obj_calloc(OBJ_PORTAL);
if (obj != NULL) {
/* copy ip addr attribute */
attr = &obj->attrs[
ATTR_INDEX_PORTAL(ip->attr_id)];
ec = copy_attr(attr, ip);
/* copy port attribute */
if (ec == 0) {
attr = &obj->attrs[
ATTR_INDEX_PORTAL(tmp->attr_id)];
ec = copy_attr(attr, tmp);
}
/* parse non-key attributes */
NEXT_TLV(tmp, tmp_len);
while (ec == 0 &&
tmp_len >= 8 &&
IS_PORTAL_ATTR(tmp->attr_id)) {
attr = &obj->attrs[
ATTR_INDEX_PORTAL(
tmp->attr_id)];
ec = copy_attr(attr, tmp);
NEXT_TLV(tmp, tmp_len);
}
} else {
/* no memory */
ec = ISNS_RSP_INTERNAL_ERROR;
}
} else {
/* ip address is not followed by port */
ec = ISNS_RSP_MSG_FORMAT_ERROR;
}
*p = obj;
*op = tmp;
*op_len = tmp_len;
return (ec);
}
/*
* ****************************************************************************
*
* reg_get_pg:
* parse the Operating Attributes of the DevAttrReg message and
* create a Portal Group object.
*
* p - the pointer of the object for returning.
* op - the operating attributes.
* op_len - the length of the operating attributes.
* return - error code.
*
* ****************************************************************************
*/
static int
reg_get_pg(
isns_obj_t **p,
isns_tlv_t **op,
uint16_t *op_len
)
{
int ec = 0;
isns_tlv_t *tmp;
uint16_t tmp_len;
isns_attr_t *attr;
isns_obj_t *obj = NULL;
tmp = *op;
tmp_len = *op_len;
/* parse a complete pg object */
obj = obj_calloc(OBJ_PG);
if (obj != NULL) {
/* parse attributes */
do {
attr = &obj->attrs[
ATTR_INDEX_PG(tmp->attr_id)];
ec = copy_attr(attr, tmp);
NEXT_TLV(tmp, tmp_len);
} while (ec == 0 &&
tmp_len >= 8 &&
IS_PG_ATTR(tmp->attr_id));
} else {
ec = ISNS_RSP_INTERNAL_ERROR;
}
*p = obj;
*op = tmp;
*op_len = tmp_len;
return (ec);
}
/*
* ****************************************************************************
*
* reg_get_pg1:
* parse the Operating Attributes of the DevAttrReg message and
* create a Portal Group object which is followed to a Portal object.
*
* p - the pointer of the object for returning.
* pgt - the size-3 array of pointers which have the pg portal ip addr, port
* and the pg tag attributes.
* op - the operating attributes.
* op_len - the length of the operating attributes.
* return - error code.
*
* ****************************************************************************
*/
static int
reg_get_pg1(
isns_obj_t **p,
isns_attr_t const *pgt,
isns_tlv_t **op,
uint16_t *op_len
)
{
int ec = 0;
isns_tlv_t *tmp;
uint16_t tmp_len;
isns_attr_t *attr;
isns_obj_t *obj = NULL;
int i = 0;
tmp = *op;
tmp_len = *op_len;
if (pgt[0].tag == PG_KEY2 &&
pgt[1].tag == PG_KEY3) {
/* the pg iscsi storage node name is */
/* followed to a portal group tag */
obj = obj_calloc(OBJ_PG);
if (obj != NULL) {
/* copy pg iscsi storage node name */
attr = &obj->attrs[
ATTR_INDEX_PG(tmp->attr_id)];
ec = copy_attr(attr, tmp);
/* copy pg ip addr, pg port & pgt */
while (ec == 0 && i < 3) {
attr = &obj->attrs[
ATTR_INDEX_PG(pgt[i].tag)];
ec = assign_attr(attr, &pgt[i]);
i ++;
}
NEXT_TLV(tmp, tmp_len);
} else {
/* no memory */
ec = ISNS_RSP_INTERNAL_ERROR;
}
} else {
ec = ISNS_RSP_MSG_FORMAT_ERROR;
}
*p = obj;
*op = tmp;
*op_len = tmp_len;
return (ec);
}
/*
* ****************************************************************************
*
* reg_get_pg2:
* parse the Operating Attributes of the DevAttrReg message and
* create a Portal Group object which is followed to a iSCSI
* Storage Node object.
*
* p - the pointer of the object for returning.
* pgt - the size-3 array of pointers which have the pg iscsi storage
* node name and the pg tag attributes.
* op - the operating attributes.
* op_len - the length of the operating attributes.
* return - error code.
*
* ****************************************************************************
*/
static int
reg_get_pg2(
isns_obj_t **p,
isns_attr_t const *pgt,
isns_tlv_t **op,
uint16_t *op_len
)
{
int ec = 0;
isns_tlv_t *tmp;
uint16_t tmp_len;
isns_attr_t *attr;
isns_obj_t *obj = NULL;
int i = 0;
isns_tlv_t *ip;
tmp = *op;
tmp_len = *op_len;
/* keep ip address */
ip = tmp;
NEXT_TLV(tmp, tmp_len);
if (tmp_len > 8 &&
/* expect pg portal port */
tmp->attr_id == PG_KEY3 &&
tmp->attr_len == 4 &&
/* expect pg tag */
pgt[2].tag == PG_PGT &&
/* expect pg iscsi storage node name only */
pgt[1].tag == 0 &&
pgt[0].tag == PG_KEY1) {
/* the pg portal ip addr & port is followed */
/* to a pg tag and we have the iscsi storage */
/* node parsed previously */
obj = obj_calloc(OBJ_PG);
if (obj != NULL) {
/* copy the pg ip addr */
attr = &obj->attrs[
ATTR_INDEX_PG(ip->attr_id)];
ec = copy_attr(attr, ip);
/* copy the pg port */
if (ec == 0) {
attr = &obj->attrs[
ATTR_INDEX_PG(tmp->attr_id)];
ec = copy_attr(attr, tmp);
}
/* copy pg iscsi storage node name & pgt */
while (ec == 0 && i < 3) {
attr = &obj->attrs[
ATTR_INDEX_PG(pgt[i].tag)];
ec = assign_attr(attr, &pgt[i]);
i += 2;
}
NEXT_TLV(tmp, tmp_len);
} else {
ec = ISNS_RSP_INTERNAL_ERROR;
}
} else {
ec = ISNS_RSP_MSG_FORMAT_ERROR;
}
*p = obj;
*op = tmp;
*op_len = tmp_len;
return (ec);
}
/*
* ****************************************************************************
*
* reg_get_obj:
* parse and create one object from the rest of Operating Attributes
* of the DevAttrReg message, the object can be iSCSI Storage Node,
* Portal or Portal Group.
*
* p - the pointer of the object for returning.
* pgt - an attribute array with size 3, the elements are:
* 0: the first pg key attribute, it is either the name of an
* iscsi storage node object or the ip addr of a portal object.
* 1: the second pg key attribute, i.e. the portal port.
* 2: the portal group tag attribute.
* op - the operating attributes.
* op_len - the length of the operating attributes.
* return - error code.
*
* ****************************************************************************
*/
int
reg_get_obj(
isns_obj_t **p,
isns_attr_t *pgt,
isns_tlv_t **op,
uint16_t *op_len
)
{
int ec = 0;
int derefd = 0;
uint32_t pg_tag;
if (*op_len == 0) {
*p = NULL;
return (0);
}
switch ((*op)->attr_id) {
case ISCSI_KEY:
ec = reg_get_iscsi(p, &pgt[0], op, op_len);
pgt[1].tag = 0;
pgt[2].tag = 0;
break;
case PORTAL_KEY1:
ec = reg_get_portal(p, &pgt[0], &pgt[1], op, op_len);
pgt[2].tag = 0;
break;
case PG_KEY1:
if (pgt[2].tag == PG_PGT) {
/* pg iscsi storage node name is */
/* followed to a pgt */
ec = reg_get_pg1(p, pgt, op, op_len);
} else {
/* a complete pg object */
ec = reg_get_pg(p, op, op_len);
pgt[0].tag = 0;
pgt[1].tag = 0;
pgt[2].tag = 0;
}
break;
case PG_KEY2:
/* pg portal ip addr is followed to a pgt */
ec = reg_get_pg2(p, pgt, op, op_len);
break;
case PG_PGT:
switch (pgt[0].tag) {
case 0:
/* portal group tag does not follow */
/* iscsi storage node or portal object */
*p = NULL;
ec = ISNS_RSP_MSG_FORMAT_ERROR;
break;
case PG_KEY1:
case PG_KEY2:
pgt[2].tag = PG_PGT;
pgt[2].len = (*op)->attr_len;
pg_tag = 0;
switch ((*op)->attr_len) {
case 4:
pg_tag = ntohl(*(uint32_t *)
&(*op)->attr_value[0]);
case 0:
pgt[2].value.ui = pg_tag;
break;
default:
*p = NULL;
ec = ISNS_RSP_MSG_FORMAT_ERROR;
break;
}
if (ec == 0) {
derefd = 1;
NEXT_TLV(*op, *op_len);
ec = reg_get_obj(p, pgt, op, op_len);
}
break;
default:
/* should never happen */
ASSERT(0);
*p = NULL;
ec = ISNS_RSP_INTERNAL_ERROR;
break;
}
break;
default:
*p = NULL;
ec = ISNS_RSP_MSG_FORMAT_ERROR;
break;
}
if (ec == 0 && derefd == 0) {
ec = update_deref_obj(*p);
}
if (ec != 0 && *p != NULL) {
free_one_object(*p);
*p = NULL;
}
return (ec);
}
/*
* ****************************************************************************
*
* reg_auth_src:
* Authorize the source attribute the DevAttrReg message.
* The update can only performed by the node who has the owenership.
*
* p - the pointer of the object for returning.
* pgt - an attribute array with size 3, the elements are:
* 0: the first pg key attribute, it is either the name of an
* iscsi storage node object or the ip addr of a portal object.
* 1: the second pg key attribute, i.e. the portal port.
* 2: the portal group tag attribute.
* op - the operating attributes.
* op_len - the length of the operating attributes.
* return - error code.
*
* ****************************************************************************
*/
int
reg_auth_src(
isns_type_t type,
uint32_t uid,
uchar_t *src
)
{
lookup_ctrl_t lc;
uint32_t puid;
puid = is_parent_there(src);
if (TYPE_OF_PARENT[type] != 0) {
SET_UID_LCP(&lc, type, uid);
uid = cache_lookup(&lc, NULL, cb_get_parent);
type = TYPE_OF_PARENT[type];
}
if (uid != 0 && puid == 0) {
SET_UID_LCP(&lc, type, uid);
uid = cache_lookup(&lc, NULL, cb_node_child);
}
if (puid != uid) {
return (0);
}
return (1);
}
/*
* ****************************************************************************
*
* is_obj_online:
* determine if the object is currently registered with the server.
*
* obj - the object being checked.
* return - 0: not registered, otherwise registered.
*
* ****************************************************************************
*/
int
is_obj_online(
const isns_obj_t *obj
)
{
int online = 1;
switch (obj->type) {
case OBJ_ISCSI:
online = obj->attrs[ATTR_INDEX_ISCSI(
ISNS_ISCSI_NODE_TYPE_ATTR_ID)].value.ui == 0 ? 0 : 1;
break;
default:
break;
}
return (online);
}
static int
set_obj_offline(
isns_obj_t *obj
)
{
switch (obj->type) {
case OBJ_ISCSI:
obj->attrs[ATTR_INDEX_ISCSI(
ISNS_ISCSI_NODE_TYPE_ATTR_ID)].value.ui = 0;
break;
default:
break;
}
return (0);
}
/*
* ****************************************************************************
*
* assoc_clone:
* clone the association object.
*
* p - the object being cloned.
* clone_flag - 0: the object is being removed;
* 1: only the association is being removed.
* return - the clone object.
*
* ****************************************************************************
*/
void *
assoc_clone(
void *p,
int clone_flag
)
{
isns_type_t type;
isns_obj_t *clone;
const isns_attr_t *src_attr;
isns_attr_t *dst_attr;
uint32_t id, op;
int i = 0;
const isns_obj_t *obj;
uint32_t dd_flag;
int online;
int state;
obj = (isns_obj_t *)p;
if (obj->type != OBJ_ISCSI) {
return (NULL);
}
dd_flag = (get_dd_id(get_obj_uid(obj), ISNS_DEFAULT_DD_ID) == 0) ?
0 : 1;
online = is_obj_online(obj);
state = (clone_flag << 2) | (dd_flag << 1) | online;
/* clone_flag dd_flag online action */
/* 0 0 0 ASSERT(0) */
/* 0 0 1 NULL */
/* 0 1 0 itself */
/* 0 1 1 clone it */
/* 1 0 0 NULL */
/* 1 0 1 itself */
/* 1 1 0 itself */
/* 1 1 1 itself */
switch (state) {
case 0:
ASSERT(0);
case 1:
case 4:
return (NULL);
case 2:
case 5:
case 6:
case 7:
return (p);
case 3:
default:
break;
}
type = obj->type;
clone = obj_calloc(type);
if (clone != NULL) {
id = UID_ATTR_INDEX[type];
src_attr = &(obj->attrs[id]);
dst_attr = &(clone->attrs[id]);
if (assign_attr(dst_attr, src_attr) != 0) {
free_one_object(clone);
return (NULL);
}
while (i < MAX_KEY_ATTRS) {
op = KEY_ATTR_OP[type][i];
if (op != 0) {
id = KEY_ATTR_INDEX[type][i];
src_attr = &(obj->attrs[id]);
dst_attr = &(clone->attrs[id]);
if (assign_attr(dst_attr, src_attr) != 0) {
free_one_object(clone);
return (NULL);
}
} else {
break;
}
i ++;
}
}
return ((void *)clone);
}
/*
* ****************************************************************************
*
* free_one_object:
* free up one object.
*
* obj - the object being freed.
*
* ****************************************************************************
*/
void
free_one_object(
isns_obj_t *obj
)
{
int i;
uint32_t *cuid;
if (obj == NULL) {
return;
}
for (i = 0; i < NUM_OF_ATTRS[obj->type]; i++) {
isns_attr_t *attr = &obj->attrs[i];
switch (attr->tag) {
case ISNS_EID_ATTR_ID:
case ISNS_ISCSI_NAME_ATTR_ID:
case ISNS_ISCSI_ALIAS_ATTR_ID:
case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
case ISNS_PG_ISCSI_NAME_ATTR_ID:
case ISNS_PORTAL_IP_ADDR_ATTR_ID:
case ISNS_PORTAL_NAME_ATTR_ID:
case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
case ISNS_DD_SET_NAME_ATTR_ID:
case ISNS_DD_NAME_ATTR_ID:
case ISNS_DD_ISCSI_NAME_ATTR_ID:
case ISNS_DD_FC_PORT_NAME_ATTR_ID:
case ISNS_DD_PORTAL_IP_ADDR_ATTR_ID:
#ifdef DEBUG
if (verbose_mc) {
printf("memory(%d) deallocated\n",
attr->len);
}
#endif
free(attr->value.ptr);
attr->value.ptr = NULL;
break;
default:
break;
}
}
/* free child uids */
i = 0;
while (i < NUM_OF_CHILD[obj->type]) {
cuid = get_child_n(obj, i);
free(cuid);
i ++;
}
/* at last, free the object itself */
#ifdef DEBUG
if (verbose_mc) {
printf("object(%d) deallocated\n", obj->type);
}
#endif
free(obj);
}
/*
* ****************************************************************************
*
* free_object:
* free up one object.
*
* obj - the object being freed.
*
* ****************************************************************************
*/
void
free_object(
isns_obj_t *obj
)
{
free_one_object(obj);
}
/*
* ****************************************************************************
*
* set_parent_obj:
* set the parent object UID.
*
* obj - the child object.
* puid- the parent object UID.
* return - error code.
*
* ****************************************************************************
*/
int
set_parent_obj(
isns_obj_t *obj,
uint32_t puid
)
{
uint32_t *const p = get_parent_p(obj);
if (p != NULL) {
*p = puid;
}
return (0);
}
/*
* ****************************************************************************
*
* buff_child_obj:
* add a child object UID to the child object array.
*
* obj - the parent object.
* child_type - the type of the child object.
* number - the number of the child object.
* return - the length of the child object UID array.
*
* ****************************************************************************
*/
int
buff_child_obj(
const isns_type_t ptype,
const isns_type_t ctype,
const void *c,
void const ***child
)
{
int ec = 0;
int i = 0;
void const ***pp, **p;
uint32_t num, new_num;
pp = NULL;
/* get the pointer of the array which the child belongs to */
while (i < NUM_OF_CHILD[ptype]) {
if (TYPE_OF_CHILD[ptype][i] == ctype) {
pp = &child[i];
break;
}
i ++;
}
/* the child type is not applicable */
if (pp == NULL) {
return (ec);
}
p = *pp;
/* get an empty slot from the uid array for this child */
if (p != NULL) {
num = (uint32_t)*p;
i = 0;
while (i < num) {
if (p[++i] == NULL) {
/* found it */
p[i] = c;
return (ec);
}
}
p = *pp;
new_num = num + 1;
} else {
num = 0;
new_num = 1;
}
/* the array is full, enlarge the child uid array */
p = (void const **)realloc(p, (new_num + 1) * sizeof (void *));
if (p != NULL) {
*pp = p;
*p = (void *)new_num;
p[new_num] = c;
} else {
ec = ISNS_RSP_INTERNAL_ERROR;
}
return (ec);
}
/*
* ****************************************************************************
*
* update_child_object:
* update the child object of a network entity object.
*
* puid - the UID of the parent object, i.e. the network entity object.
* child_type - the type of the child object.
* child_uid - the uid of the child object.
* return - error code.
*
* ****************************************************************************
*/
int
update_child_obj(
const isns_type_t ptype,
const uint32_t puid,
void const ***child,
int child_flag
)
{
int ec = 0;
lookup_ctrl_t lc;
SET_UID_LCP(&lc, ptype, puid);
lc.data[1].ptr = (uchar_t *)child;
lc.data[2].ui = child_flag;
ec = cache_lookup(&lc, NULL, cb_add_child);
return (ec);
}
int
update_ref_obj(
const isns_obj_t *obj
)
{
uint32_t uid;
lookup_ctrl_t lc;
isns_type_t t;
t = obj->type;
if (TYPE_OF_REF[t][0] != 0) {
(void) setup_ref_lcp(&lc, obj, NULL);
lc.id[2] = t;
lc.data[2].ui = get_obj_uid(obj);
uid = 0;
do {
lc.curr_uid = uid;
(void) cache_lookup(&lc, &uid, cb_set_ref);
} while (uid != 0);
}
return (0);
}
/*
* ****************************************************************************
*
* verify_ref_obj:
* update the reference bit of a portal group object.
*
* obj - the object being ref'ed.
* return - error code.
*
* ****************************************************************************
*/
int
verify_ref_obj(
const isns_type_t ptype,
const uint32_t puid,
void const ***child
)
{
int ec = 0;
lookup_ctrl_t lc;
SET_UID_LCP(&lc, ptype, puid);
lc.data[1].ptr = (uchar_t *)child;
ec = cache_lookup(&lc, NULL, cb_verify_ref);
return (ec);
}
int
update_deref_obj(
isns_obj_t *obj
)
{
int ec = 0;
isns_type_t t, rt;
lookup_ctrl_t lc;
int i, ref_count;
uint32_t uid, *refp;
t = obj->type;
i = ref_count = 0;
while (i < NUM_OF_REF[t]) {
rt = TYPE_OF_REF[t][i + 1];
(void) setup_deref_lcp(&lc, obj, rt);
uid = is_obj_there(&lc);
if (uid != 0) {
refp = get_ref_p(obj, lc.type);
*refp = uid;
ref_count ++;
}
i ++;
}
if (i > 0 && ref_count == 0) {
ec = ISNS_RSP_INVALID_REGIS;
}
return (ec);
}
/*
* ****************************************************************************
*
* register_object:
* add one object to the object container.
*
* obj - the object being added.
* uid_p- the pointer for returning object UID.
* update_p- the pointer for returning flag which indicates if the object
* is newly registered or updated with an existing one.
* return - error code.
*
* ****************************************************************************
*/
int
register_object(
isns_obj_t *obj,
uint32_t *uid_p,
int *update_p
)
{
return (cache_add(obj, 0, uid_p, update_p));
}
/*
* ****************************************************************************
*
* register_assoc:
* add one association object to the object container, the association
* object has only the information for discovery domain membership, i.e.
* a name and UID only.
*
* obj - the association object being added.
* uid_p- the pointer for returning object UID.
* return - error code.
*
* ****************************************************************************
*/
int
register_assoc(
isns_obj_t *obj,
uint32_t *uid_p
)
{
return (cache_add(obj, 1, uid_p, NULL));
}
/*
* ****************************************************************************
*
* is_obj_there:
* check if the object is registered or not.
*
* lcp - the lookup control data.
* return - the object UID.
*
* ****************************************************************************
*/
uint32_t
is_obj_there(
lookup_ctrl_t *lcp
)
{
uint32_t uid;
(void) cache_lookup(lcp, &uid, NULL);
return (uid);
}
uint32_t
is_parent_there(
uchar_t *src
)
{
lookup_ctrl_t lc;
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 = src;
lc.op[1] = 0;
return (cache_lookup(&lc, NULL, cb_get_parent));
}
/*
* ****************************************************************************
*
* setup_ref_lcp:
* prepare the lookup control data for looking up a portal group
* object which references to a iscsi stroage node and/or a portal
* object.
*
* lcp - the lookup control data.
* iscsi- the ref'ed iscsi storage node object.
* portal- the ref'ed portal object.
* return - error code.
*
* ****************************************************************************
*/
static int
setup_ref_lcp(
lookup_ctrl_t *lcp,
const isns_obj_t *iscsi,
const isns_obj_t *portal
)
{
int i = 0, j = 0;
lcp->curr_uid = 0;
lcp->type = TYPE_OF_REF[iscsi->type][0];
/* extrace the matching attributes from iscsi storage node object */
while (iscsi != NULL &&
i < MAX_REF_MATCH &&
REF_MATCH_OPS[iscsi->type][i] > 0) {
lcp->id[i] = REF_MATCH_ID2[iscsi->type][i];
lcp->op[i] = REF_MATCH_OPS[iscsi->type][i];
lcp->data[i].ptr = iscsi->attrs[
REF_MATCH_ID1[iscsi->type][i]].value.ptr;
i ++;
}
/* extrace the matching attributes from portal object */
while (portal != NULL &&
i < MAX_LOOKUP_CTRL &&
j < MAX_REF_MATCH &&
REF_MATCH_OPS[portal->type][j] > 0) {
lcp->id[i] = REF_MATCH_ID2[portal->type][j];
lcp->op[i] = REF_MATCH_OPS[portal->type][j];
lcp->data[i].ptr = portal->attrs[
REF_MATCH_ID1[portal->type][j]].value.ptr;
j ++;
i ++;
}
if (i < MAX_LOOKUP_CTRL) {
lcp->op[i] = 0;
}
return (0);
}
static int
setup_deref_lcp(
lookup_ctrl_t *lcp,
const isns_obj_t *pg,
isns_type_t t
)
{
int i = 0;
lcp->curr_uid = 0;
lcp->type = t;
/* extrace the matching attributes from iscsi storage node object */
while (i < MAX_REF_MATCH &&
REF_MATCH_OPS[t][i] > 0) {
lcp->id[i] = REF_MATCH_ID1[t][i];
lcp->op[i] = REF_MATCH_OPS[t][i];
lcp->data[i].ptr = pg->attrs[
REF_MATCH_ID2[t][i]].value.ptr;
i ++;
}
if (i < MAX_LOOKUP_CTRL) {
lcp->op[i] = 0;
}
return (0);
}
/*
* ****************************************************************************
*
* setup_parent_lcp:
* prepare the lookup control data for looking up parent object
* with a child object.
*
* lcp - the lookup control data.
* obj - the child object.
* return - parent object UID.
*
* ****************************************************************************
*/
static uint32_t
setup_parent_lcp(
lookup_ctrl_t *lcp,
isns_obj_t *obj
)
{
isns_type_t ptype;
uint32_t puid;
puid = get_parent_uid(obj);
if (puid != 0) {
ptype = TYPE_OF_PARENT[obj->type];
SET_UID_LCP(lcp, ptype, puid);
lcp->data[1].ui = obj->type;
lcp->data[2].ui = get_obj_uid(obj);
}
return (puid);
}
static int
cb_get_parent(
void *p1,
/* LINTED E_FUNC_ARG_UNUSED */
void *p2
)
{
return (get_parent_uid(p1));
}
static int
cb_node_child(
void *p1,
/* LINTED E_FUNC_ARG_UNUSED */
void *p2
)
{
isns_obj_t *obj = (isns_obj_t *)p1;
uint32_t num, uid;
uint32_t *cuid = get_child_t(obj, OBJ_ISCSI);
if (cuid != NULL) {
num = *cuid;
} else {
num = 0;
}
while (num > 0) {
uid = *++cuid;
if (uid != 0) {
return (uid);
}
num --;
}
return (0);
}
/*
* ****************************************************************************
*
* cb_set_ref:
* callback function which sets the reference bit to 1 according to
* the type of object.
*
* p1 - the object.
* p2 - the lcp.
* return - error code.
*
* ****************************************************************************
*/
static int
cb_set_ref(
void *p1,
void *p2
)
{
isns_obj_t *obj = (isns_obj_t *)p1;
lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
isns_type_t t;
uint32_t u;
uint32_t *refp;
t = lcp->id[2];
u = lcp->data[2].ui;
refp = get_ref_p(obj, t);
*refp = u;
/* successful */
return (0);
}
/*
* ****************************************************************************
*
* cb_clear_ref:
* callback function which clears the reference bit according to
* the type of object.
*
* p1 - the object.
* p2 - the lcp.
* return - 1: the object is no longer ref'ed, 0: otherwise.
*
* ****************************************************************************
*/
static int
cb_clear_ref(
void *p1,
void *p2
)
{
isns_obj_t *obj = (isns_obj_t *)p1;
lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
isns_type_t t;
uint32_t *refp;
int i = 0;
uint32_t ref;
t = lcp->data[2].ui;
refp = get_ref_p(obj, t);
*refp = 0;
while (i < NUM_OF_REF[obj->type]) {
ref = get_ref_n(obj, i);
if (ref != 0) {
return (0);
}
i ++;
}
return (1);
}
static int
cb_add_child(
void *p1,
void *p2
)
{
isns_obj_t *obj = (isns_obj_t *)p1;
lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
const void ***child;
const void **vpp;
uint32_t vnum;
int child_flag;
uint32_t **upp, *up;
uint32_t num;
isns_obj_t *o;
int i = 0;
child = (const void ***)lcp->data[1].ptr;
child_flag = lcp->data[2].ui;
while (i < NUM_OF_CHILD[obj->type]) {
vpp = child[i];
if (vpp != NULL &&
(vnum = (uint32_t)*vpp) > 0 &&
*(vpp + 1) != NULL) {
upp = get_child_np(obj, i);
if (*upp == NULL) {
if (child_flag == 0 &&
sizeof (typeof (**upp)) ==
sizeof (typeof (**child))) {
*upp = (uint32_t *)vpp;
vpp = NULL;
child[i] = NULL;
}
num = vnum;
} else {
num = **upp + vnum;
}
if (vpp != NULL) {
/* copy required */
up = (uint32_t *)realloc(*upp,
(num + 1) * sizeof (uint32_t));
if (up == NULL) {
return (ISNS_RSP_INTERNAL_ERROR);
}
*upp = up;
*up = num;
up += num;
vpp += vnum;
while (vnum > 0) {
if (*vpp == NULL) {
*up = 0;
} else if (child_flag == 0) {
*up = (uint32_t)*vpp;
*vpp = NULL;
} else {
o = (isns_obj_t *)*vpp;
*up = get_obj_uid(o);
if (is_obj_online(o) == 0) {
free_object(o);
}
*vpp = NULL;
}
up --;
vpp --;
vnum --;
}
}
}
i ++;
}
return (0);
}
/*
* ****************************************************************************
*
* cb_remove_child:
* callback function which removes a child object UID from the
* children objet UID array of the parent object.
*
* p1 - the object.
* p2 - the lcp.
* return - 1: no more such type of child object, 0: otherwise.
*
* ****************************************************************************
*/
static int
cb_remove_child(
void *p1,
void *p2
)
{
isns_obj_t *obj = (isns_obj_t *)p1;
lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
uint32_t child_type = lcp->data[1].ui;
uint32_t child_uid = lcp->data[2].ui;
uint32_t *cuidp, cuid, num_of_child = 0;
int i;
/* get the children object UID array */
cuidp = get_child_t(obj, child_type);
if (cuidp != NULL) {
num_of_child = *cuidp;
}
/* remove it */
while (num_of_child > 0) {
cuid = *++cuidp;
if (cuid == child_uid) {
*cuidp = 0;
break;
}
num_of_child --;
}
/* check if all of child object UIDs are removed */
i = 0;
while (i < NUM_OF_CHILD[obj->type]) {
cuidp = get_child_n(obj, i);
if (cuidp != NULL) {
num_of_child = *cuidp;
while (num_of_child > 0) {
cuid = *++cuidp;
if (cuid != 0) {
return (0);
}
num_of_child --;
}
}
i ++;
}
return (1);
}
static int
cb_verify_ref(
void *p1,
void *p2
)
{
int ec = 0;
isns_obj_t *parent = (isns_obj_t *)p1;
lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
const void ***child;
const void **vpp;
const void *vp;
uint32_t vnum;
const void **evpp;
const void *evp;
uint32_t evnum;
isns_type_t pt; /* parent object type */
isns_type_t ct; /* child object type */
isns_type_t rt; /* ref object type */
isns_type_t et; /* peer object type */
uint32_t *up;
uint32_t u;
uint32_t unum;
lookup_ctrl_t lc;
uint8_t flag[MAX_OBJ_TYPE + 1] = { 0 };
int i, j, k;
pt = parent->type;
child = (const void ***)lcp->data[1].ptr;
for (i = 0; i < NUM_OF_CHILD[pt]; i++) {
ct = TYPE_OF_CHILD[pt][i];
rt = TYPE_OF_REF[ct][0];
if (rt == 0) {
continue;
}
et = TYPE_OF_REF[ct][1];
vpp = child[i];
if (vpp != NULL) {
vnum = (uint32_t)*vpp;
up = get_child_t(parent, et);
if (up != NULL) {
unum = *up;
} else {
unum = 0;
}
} else {
vnum = 0;
}
j = vnum;
while (j > 0) {
vp = vpp[j];
if (vp != NULL) {
(void) setup_ref_lcp(&lc, vp, NULL);
k = unum;
while (k > 0) {
u = up[k];
if (u != 0) {
ec = ref_new2old(
&lc, et, u, vp);
if (ec != 0) {
return (ec);
}
}
k --;
} /* End of while each unum */
}
j --;
} /* End of while each vnum */
if (flag[ct] != 0) {
continue;
}
evnum = 0;
j = 0;
while (j < NUM_OF_CHILD[pt]) {
if (TYPE_OF_CHILD[pt][j] == et) {
evpp = child[j];
if (evpp != NULL) {
evnum = (uint32_t)*evpp;
}
break;
}
j ++;
}
j = vnum;
while (j > 0) {
vp = vpp[j];
k = evnum;
while (k > 0) {
evp = evpp[k];
if (vp != NULL && evp != NULL) {
(void) setup_ref_lcp(&lc, vp, evp);
ec = ref_new2new(&lc, vp, evp);
if (ec != 0) {
return (ec);
}
}
k --;
}
j --;
} /* End of while each vnum */
flag[et] = 1;
} /* End of for each type of child */
return (ec);
}
static int
cb_ref_new2old(
void *p1,
void *p2
)
{
isns_obj_t *obj = (isns_obj_t *)p1;
lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
isns_type_t et;
uint32_t uu;
uint32_t ref;
int match;
et = lcp->id[2];
uu = lcp->data[2].ui;
ref = get_ref_t(obj, et);
if (ref == uu) {
match = 1;
} else {
match = 0;
}
return (match);
}
static int
cb_new_ref(
void *p1,
void *p2
)
{
int ec = 0;
lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
isns_obj_t *a = (isns_obj_t *)p1;
isns_obj_t *b = (isns_obj_t *)lcp->data[2].ptr;
ec = new_ref(a, b);
return (ec);
}
static int
ref_new2old(
lookup_ctrl_t *lcp,
isns_type_t et,
uint32_t uu,
const isns_obj_t *vp
)
{
int ec = 0;
int match;
uint32_t uid;
lookup_ctrl_t lc;
lcp->id[2] = et;
lcp->data[2].ui = uu;
uid = 0;
do {
lcp->curr_uid = uid;
match = cache_lookup(lcp, &uid, cb_ref_new2old);
} while (match == 0 && uid != 0);
if (match == 0) {
/* no such ref, create a default one */
SET_UID_LCP(&lc, et, uu);
lc.data[2].ptr = (uchar_t *)vp;
ec = cache_lookup(&lc, NULL, cb_new_ref);
}
return (ec);
}
static int
ref_new2new(
lookup_ctrl_t *lcp,
const isns_obj_t *p1,
const isns_obj_t *p2
)
{
int ec = 0;
if (is_obj_there(lcp) != 0) {
return (0);
}
ec = new_ref(p1, p2);
return (ec);
}
static int
new_ref(
const isns_obj_t *p1,
const isns_obj_t *p2
)
{
int ec = 0;
isns_obj_t *obj;
obj = make_ref[p1->type](p1, p2);
if (obj != NULL) {
ec = register_object(obj, NULL, NULL);
} else {
ec = ISNS_RSP_INTERNAL_ERROR;
}
return (ec);
}
/*
* ****************************************************************************
*
* do_dereg:
* Physically remove an object along with the children objects,
* the reference object and the parent object recursively.
* Apporiate SCN is triggered.
*
* lcp - the lookup control for the object being removed.
* parent_flag - 1: the object being removed is the parent object;
* 0: otherwise.
* child_flag - 1: the object being removed is a child object;
* 0: otherwise.
* pending - 1: do not remove the ESI entry immediately;
* 0: remove the ESI entry without any delay.
* return - error code.
*
* ****************************************************************************
*/
static int
do_dereg(
lookup_ctrl_t *lcp,
int parent_flag,
int child_flag,
int pending
)
{
int ec = 0;
isns_obj_t *obj;
uint32_t *cuidp, num;
isns_type_t type;
uint32_t uid;
int i;
/* remove the object from object container */
obj = cache_remove(lcp, 0);
if (obj == NULL) {
return (0);
}
/* trigger a scn */
if (scn_q != NULL) {
(void) make_scn(ISNS_OBJECT_REMOVED, obj);
}
/* dereg children */
i = 0;
while (ec == 0 && !parent_flag &&
i < NUM_OF_CHILD[obj->type]) {
type = TYPE_OF_CHILD[obj->type][i];
cuidp = get_child_n(obj, i);
if (cuidp != NULL) {
num = *cuidp;
} else {
num = 0;
}
while (ec == 0 && num > 0) {
uid = cuidp[num];
if (uid != 0) {
SET_UID_LCP(lcp, type, uid);
ec = do_dereg(lcp,
parent_flag,
1,
pending);
}
num --;
}
i ++;
}
/* clear the ref bit on the ref'd object */
if (ec == 0 && TYPE_OF_REF[obj->type][0] > 0) {
uid = 0;
do {
(void) setup_ref_lcp(lcp, obj, NULL);
lcp->curr_uid = uid;
lcp->data[2].ui = obj->type;
if (cache_lookup(lcp, &uid, cb_clear_ref) != 0) {
UPDATE_LCP_UID(lcp, uid);
ec = do_dereg(lcp,
parent_flag,
child_flag,
pending);
}
} while (uid != 0);
}
/* remove it from the parent */
if (ec == 0 && !child_flag &&
TYPE_OF_PARENT[obj->type] > 0 &&
(uid = setup_parent_lcp(lcp, obj)) != 0) {
if (cache_lookup(lcp, NULL, cb_remove_child) != 0) {
UPDATE_LCP_UID(lcp, uid);
ec = do_dereg(lcp,
1,
child_flag,
0);
}
}
if (ec == 0 && !child_flag) {
/* remove it from persistent data store */
if (sys_q) {
ec = write_data(DATA_DELETE, obj);
}
/* remove esi event entry */
if (ec == 0) {
(void) esi_remove_obj(obj, pending);
}
/* save the parent uid for caller */
if (TYPE_OF_PARENT[obj->type] != 0) {
lcp->curr_uid = get_parent_uid(obj);
} else {
/* it's the parent itself */
lcp->curr_uid = get_obj_uid(obj);
}
}
/* remove this portal from scn registry */
if (ec == 0 &&
obj->type == OBJ_PORTAL) {
(void) remove_scn_portal(get_obj_uid(obj));
}
/* free the object */
(void) free_object(obj);
return (ec);
}
/*
* ****************************************************************************
*
* dereg_assoc:
* Remove one association object from object container.
*
* lcp - the lookup control for the object being removed.
* return - error code.
*
* ****************************************************************************
*/
int
dereg_assoc(
lookup_ctrl_t *lcp
)
{
isns_obj_t *obj;
obj = cache_remove(lcp, 1);
/* free the object */
if (obj != NULL) {
free_object(obj);
}
return (0);
}
/*
* ****************************************************************************
*
* dereg_object:
* Remove one object from object container.
*
* lcp - the lookup control for the object being removed.
* return - error code.
*
* ****************************************************************************
*/
int
dereg_object(
lookup_ctrl_t *lcp,
int pending
)
{
return (do_dereg(lcp, 0, 0, pending));
}
/*
* ****************************************************************************
*
* data_sync:
* Synchronize the cache with persistent data store.
* Flush the cache data to data store if the input ec is zero,
* retreat the changes in cache and ignore data store update
* if there is an error.
*
* ec - error code.
* return - error code.
*
* ****************************************************************************
*/
int
data_sync(
int ec
)
{
/* cache is updated successfully, commit the data to data store */
if (IS_CACHE_UPDATED()) {
if (ec == 0) {
ec = write_data(DATA_COMMIT, NULL);
}
if (ec == 0) {
/* successful, trigger the SCN */
(void) queue_msg_set(scn_q, SCN_TRIGGER, (void *)NULL);
} else {
shutdown_server();
}
} else {
/* ignore all SCNs which have been generated */
(void) queue_msg_set(scn_q, SCN_IGNORE, (void *)NULL);
(void) write_data(DATA_RETREAT, NULL);
}
return (ec);
}
static pthread_mutex_t name_mtx[3] = {
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER
};
static const char *name_pattern[3] = {
"ENTITY_ID_%d",
"DD_%d",
"DD-Set_%d"
};
static uint32_t name_count[3] = {
0,
0,
0
};
/*
* ****************************************************************************
*
* make_unique_name:
* make a default unique name for a newly registered network entity,
* discovery domain or discovery domain set object.
*
* len - pointer of the length of the new name for returning.
* tag - which attribute of the new name is for.
* return - the name being made.
*
* ****************************************************************************
*/
static char *
make_unique_name(
int *len,
uint32_t tag
)
{
int i;
int count;
char name[32] = { 0 };
char *p;
lookup_ctrl_t lc;
lc.curr_uid = 0;
switch (tag) {
case ISNS_EID_ATTR_ID:
i = 0;
lc.type = OBJ_ENTITY;
lc.id[0] = ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID);
break;
case ISNS_DD_NAME_ATTR_ID:
i = 1;
lc.type = OBJ_DD;
lc.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
break;
case ISNS_DD_SET_NAME_ATTR_ID:
i = 2;
lc.type = OBJ_DDS;
lc.id[0] = ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID);
break;
default:
ASSERT(0);
break;
}
lc.op[0] = OP_STRING;
lc.op[1] = 0;
do {
(void) pthread_mutex_lock(&name_mtx[i]);
count = ++ name_count[i];
(void) pthread_mutex_unlock(&name_mtx[i]);
/* no more space, failure */
if (count == 0) {
return (NULL);
}
(void) sprintf(name, name_pattern[i], count);
lc.data[0].ptr = (uchar_t *)name;
} while (is_obj_there(&lc) != 0);
/* 4-bytes aligned length */
*len = strlen(name);
*len = *len + (4 - *len % 4);
p = (char *)malloc(*len);
if (p != NULL) {
(void) strcpy(p, name);
}
return (p);
}
#ifdef DEBUG
void
obj_dump(
void *p
)
{
print_object(NULL, (isns_obj_t *)p);
}
#endif