/* * 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_cache.h" #include "isns_msgq.h" #include "isns_obj.h" #include "isns_htab.h" /* * external variables */ extern msg_queue_t *sys_q; #ifdef DEBUG extern int verbose_lock; #endif /* * global data */ int cache_flag = 0; /* * local variables */ static cache_t *imc; /* * local functions. */ /* * **************************************************************************** * cache_init: * create the cache data initially, including to invoke individual * functions for creating the hash tables for object storage and * discovery domain membership matrix. * * return - 0: no error; 1: otherwise. * * **************************************************************************** */ int cache_init(void) { /* * allocate global cache memory. */ imc = (cache_t *)calloc(sizeof (cache_t), 1); if (imc == NULL || obj_tab_init(imc) != 0 || dd_matrix_init(imc) != 0) { cache_destroy(); return (1); /* no memory */ } /* * initialize global cache rwlock. */ (void) rwlock_init(&imc->l, USYNC_PROCESS, NULL); /* * inintialize global cache functions. */ imc->get_hval = obj_hval; imc->get_uid = get_obj_uid; imc->set_uid = set_obj_uid; imc->timestamp = get_timestamp; imc->add_hook = add_object; imc->replace_hook = replace_object; imc->cmp = obj_cmp; imc->clone = assoc_clone; imc->ddd = update_ddd; #ifdef DEBUG imc->dump = obj_dump; #endif return (0); } /* * **************************************************************************** * cache_destroy: * destroy the cache data. * * **************************************************************************** */ void cache_destroy(void) { /* do nothing */ } /* * **************************************************************************** * cache_lock: * grab the lock on the cache data. * * mode - the read/write mode of the lock. * return - error code. * * **************************************************************************** */ int cache_lock(int mode) { int ret = 0; switch (mode) { case CACHE_WRITE: ret = rw_wrlock(&imc->l); #ifdef DEBUG if (verbose_lock) { printf("cache locked for writing.\n"); } #endif break; case CACHE_READ: ret = rw_rdlock(&imc->l); #ifdef DEBUG if (verbose_lock) { printf("cache locked for reading.\n"); } #endif break; case CACHE_TRY_READ: ret = rw_tryrdlock(&imc->l); #ifdef DEBUG if (verbose_lock) { if (ret == 0) { printf("cache locked for reading.\n"); } else { printf("cache locked for reading failed.\n"); } } #endif break; default: break; } return (ret); } /* * **************************************************************************** * cache_unlock: * release the lock on the cache data. * if the cache was locked for writing, a synchronization between * the cache and persistent data store needs to be performed. * * mode - the read/write mode which the cache data was locked for. * ec - 0: commit the cache update; otherwise retreat it. * return - error code. * * **************************************************************************** */ int cache_unlock(int mode, int ec) { if (mode != CACHE_NO_ACTION) { /* sync between cache and data store */ if (mode == CACHE_WRITE) { if (sys_q) { ec = data_sync(ec); } /* rest the cache update flag */ RESET_CACHE_UPDATED(); } ASSERT(!IS_CACHE_UPDATED()); /* unlock it */ (void) rw_unlock(&imc->l); #ifdef DEBUG if (verbose_lock) { printf("cache unlocked.\n"); } #endif } return (ec); } /* * **************************************************************************** * cache_lock_read: * grab the read lock on the cache. * * return - error code. * * **************************************************************************** */ int cache_lock_read(void) { return (cache_lock(CACHE_READ)); } /* * **************************************************************************** * cache_lock_write: * grab the write lock on the cache. * * return - error code. * * **************************************************************************** */ int cache_lock_write(void) { return (cache_lock(CACHE_WRITE)); } /* * **************************************************************************** * cache_unlock_sync: * synchronize the cache with persistent data store and * release the lock. * * ec - 0: commit the cache update; otherwise retreat it. * return - error code. * * **************************************************************************** */ int cache_unlock_sync(int ec) { return (cache_unlock(CACHE_WRITE, ec)); } /* * **************************************************************************** * cache_unlock_nosync: * release the lock, no need to sync the data between cache and * data store. * if the cache has been updated, do not call this function, call * cache_unlock_sync() with non-zero error code to indicate the * sync action. * * return - error code. * * **************************************************************************** */ int cache_unlock_nosync(void) { return (cache_unlock(CACHE_READ, 0)); } /* * **************************************************************************** * cache_get_htab: * get the hash table for individual type of object. * * type - the object type. * return - the hash table. * * **************************************************************************** */ htab_t * cache_get_htab(isns_type_t type) { if (type > 0 && type < MAX_OBJ_TYPE) { return (imc->t[type]); } return (NULL); } /* * **************************************************************************** * cache_get_matrix: * get the membership matrix for a discovery domain or a * discovery domain set. * * type - the discovery domain or discovery domain set object type. * return - the matrix. * * **************************************************************************** */ matrix_t * cache_get_matrix(isns_type_t type) { matrix_t *x = NULL; switch (type) { case OBJ_DD: x = imc->x[0]; break; case OBJ_DDS: x = imc->x[1]; break; default: break; } return (x); } /* * **************************************************************************** * cache_lookup: * invoke the hash table lookup for looking up a specific object and * perform the callback function on the object. * * lcp - the object lookup control data. * uid_p - the pointer of object UID for returning. * callback - the callback function for the object. * return - error code. * * **************************************************************************** */ int cache_lookup(lookup_ctrl_t *lcp, uint32_t *uid_p, int (*callback)(void *, void *)) { return (htab_lookup(imc->t[lcp->type], lcp, (lcp->op[0] == OP_INTEGER) ? lcp->data[0].ui : 0, uid_p, callback, 0)); } /* * **************************************************************************** * cache_lookup: * invoke the hash table lookup for looking up a specific object, * the callback function is going to change the key of the object. * * lcp - the object lookup control data. * uid_p - the pointer of object UID for returning. * callback - the callback function for the object. * return - error code. * * **************************************************************************** */ int cache_rekey(lookup_ctrl_t *lcp, uint32_t *uid_p, int (*callback)(void *, void *)) { return (htab_lookup(imc->t[lcp->type], lcp, (lcp->op[0] == OP_INTEGER) ? lcp->data[0].ui : 0, uid_p, callback, 1)); } /* * **************************************************************************** * cache_add: * invoke hash table add to add an object. * * obj - the object being added. * flag - 0: a real object; * otherwise an association object for discovery domain membership. * uid_p - the pointer of object UID for returning. * update_p - the pointer of flag (update object or newly register) * for returning. * return - error code. * * **************************************************************************** */ int cache_add(isns_obj_t *obj, int flag, uint32_t *uid_p, int *update_p) { return (htab_add(imc->t[obj->type], obj, flag, uid_p, update_p)); } /* * **************************************************************************** * cache_remove: * invoke hash table remove to remove an object. * * lcp - the lookup control data for the object being removed. * flag - 0: a real object; * otherwise an association object for discovery domain membership. * return - the removed object. * * **************************************************************************** */ isns_obj_t * cache_remove(lookup_ctrl_t *lcp, int flag) { return (htab_remove(imc->t[lcp->type], lcp, (lcp->op[0] == OP_INTEGER) ? lcp->data[0].ui : 0, flag)); } /* * **************************************************************************** * cache_dump_htab: * dump the hash table for debugging purpose. * * type - the object type. * * **************************************************************************** */ #ifdef DEBUG void cache_dump_htab(isns_type_t type) { (void) htab_dump(imc->t[type]); } #endif
