/* * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved. */ /* * User Objects. * * User objects are used to manage and protect resources that * have been created for a user context. Each user object * maintains a reference count and a read/write mutex to * provide the appropriate access to the object depending * on the operation at hand. * * For example when initializing or creating a PD user object, * the active context would hold a write lock, but to simply * reference the PD object as in a CQ create operation, a * read lock is only required. * * Each user object also maintains a "live" flag. If this flag * is not set, then lookups on this user object will fail * even if it still resides in the associated user object * management table. This specifically handles the case * where a get operation blocks and does not acquire the lock * until after the object has been destroyed (but not yet * released). Destroy operations set the "live" flag to 0 * prior to dropping their write lock on the user object. * This allows the reader to realize when it receives the * lock that the object has been destroyed so it can then * release it's reference to the user object, and allow it to * be freed (the storage will not be freed until the last reference * is released). */ #include <sys/debug.h> #include <sys/kmem.h> #include <sys/sunddi.h> #include <sys/ib/clients/of/sol_ofs/sol_ofs_common.h> extern char *sol_ofs_dbg_str; static sol_ofs_uobj_t *ofs_uobj_find(sol_ofs_uobj_table_t *, uint_t, int); /* * Function: * sol_ofs_uobj_tbl_init * Input: * uo_tbl - A pointer to the user object resource management table * to initialize. * Output: * None * Returns: * None * Description: * Initializes the specified user object resource managment table. */ void sol_ofs_uobj_tbl_init(sol_ofs_uobj_table_t *uo_tbl, size_t uobj_sz) { ASSERT(uo_tbl != NULL); rw_init(&uo_tbl->uobj_tbl_lock, NULL, RW_DRIVER, NULL); uo_tbl->uobj_tbl_used_blks = 0; uo_tbl->uobj_tbl_num_blks = 0; uo_tbl->uobj_tbl_uo_cnt = 0; uo_tbl->uobj_tbl_uo_sz = uobj_sz; uo_tbl->uobj_tbl_uo_root = NULL; } /* * Function: * sol_ofs_uobj_tbl_fini * Input: * uo_tbl - A pointer to the user object resource management table * to be released. * Output: * None * Returns: * None * Description: * Releases any resources held by the specified user object resource * managment table. The table is no longer valid upon return. NOTE: * the table should be empty when this routine is called, so this * really is more of just a sanity check. */ void sol_ofs_uobj_tbl_fini(sol_ofs_uobj_table_t *uo_tbl) { int i, j; uint32_t size; sol_ofs_uobj_blk_t *blk; ASSERT(uo_tbl != NULL); rw_enter(&uo_tbl->uobj_tbl_lock, RW_WRITER); if (uo_tbl->uobj_tbl_uo_cnt > 0) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ TBL FINI: object count not zero (cnt=%d)", uo_tbl->uobj_tbl_uo_cnt); } /* * Go through the roots looking for blocks to free. Warn if any * our found (there shouldn't be any). */ for (i = 0; i < uo_tbl->uobj_tbl_used_blks; i++) { blk = uo_tbl->uobj_tbl_uo_root[i]; if (!blk) { continue; } for (j = 0; j < SOL_OFS_UO_BLKSZ; j++) { if (blk->ofs_uoblk_blks[j]) { /* * This is an error, we may want to free * ultimately sol_ofs_uobj_free * (blk->ofs_uoblk_blks[j]); */ SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ TBL FINI: blk %p, slot %d non null", blk, j); } } kmem_free(blk, sizeof (*blk)); } if (uo_tbl->uobj_tbl_uo_root) { size = uo_tbl->uobj_tbl_num_blks * sizeof (sol_ofs_uobj_blk_t *); kmem_free(uo_tbl->uobj_tbl_uo_root, size); } rw_exit(&uo_tbl->uobj_tbl_lock); rw_destroy(&uo_tbl->uobj_tbl_lock); } /* * Function: * uverbs_uob_init * Input: * uobj - Pointer to the user object to initialize. * user_handle - A user space handle to associates with the object. * Generally used to identify object in asynchronous * notifications. * uob_type - The type of user object. * Ouput: * uobj - Initialized user object. * Returns: * None * Description: * Initialize a new user object. The object will have one reference * placed on it. */ void sol_ofs_uobj_init(sol_ofs_uobj_t *uobj, uint64_t user_handle, sol_ofs_uobj_type_t uobj_type) { uobj->uo_user_handle = user_handle; uobj->uo_refcnt = 1; uobj->uo_type = uobj_type; uobj->uo_id = -1; uobj->uo_live = 0; rw_init(&uobj->uo_lock, NULL, RW_DRIVER, NULL); mutex_init(&uobj->uo_reflock, NULL, MUTEX_DRIVER, NULL); } /* * Function: * ofs_uobj_fini * Input: * uobj - Pointer to the user object to be cleaned up. * Ouput: * None * Returns: * None * Description: * Performs user object cleanup prior to releasing memory. */ static void ofs_uobj_fini(sol_ofs_uobj_t *uobj) { rw_destroy(&uobj->uo_lock); mutex_destroy(&uobj->uo_reflock); } /* * Function: * sol_ofs_uobj_ref * Input: * uobj - Pointer to the user object * Ouput: * None * Returns: * None * Description: * Place a reference on the specified user object. */ void sol_ofs_uobj_ref(sol_ofs_uobj_t *uobj) { mutex_enter(&uobj->uo_reflock); uobj->uo_refcnt++; ASSERT(uobj->uo_refcnt != 0); mutex_exit(&uobj->uo_reflock); } /* * Function: * sol_ofs_uobj_deref * Input: * uobj - Pointer to the user object * free_func - Pointer to release function, called if the * last reference is removed for the user object. * Ouput: * None * Returns: * None * Description: * Remove a reference to a user object. If a free function * was specified and the last reference is released, then the * free function is invoked to release the user object. */ void sol_ofs_uobj_deref(sol_ofs_uobj_t *uobj, void (*free_func)(sol_ofs_uobj_t *uobj)) { SOL_OFS_DPRINTF_L5(sol_ofs_dbg_str, "UOBJ_DEREF: uobj = %p, " "refcnt=%d", uobj, uobj->uo_refcnt); mutex_enter(&uobj->uo_reflock); ASSERT(uobj->uo_refcnt != 0); uobj->uo_refcnt--; if (uobj->uo_refcnt == 0) { mutex_exit(&uobj->uo_reflock); if (free_func) free_func(uobj); } else { mutex_exit(&uobj->uo_reflock); } } /* * Function: * sol_ofs_uobj_add * Input: * uo_tbl - A pointer to the user object resource management table * to which the object should be added. * uobj - A pointer ot the user object to be added; a reference * should exist on this object prior to addition, and the * object should be removed prior to all references being * removed. * Output: * uobj - The user object "uo_id" is updated and should be * used in subsequent lookup operations. * Returns: * DDI_SUCCESS on success, else error code. * Description: * Add a user object to the specified user object resource management * table. * */ int sol_ofs_uobj_add(sol_ofs_uobj_table_t *uo_tbl, sol_ofs_uobj_t *uobj) { int i, j, empty = -1; sol_ofs_uobj_blk_t *blk; rw_enter(&uo_tbl->uobj_tbl_lock, RW_WRITER); /* * Try to find an empty slot for the new user object. */ for (i = 0; i < uo_tbl->uobj_tbl_used_blks; i++) { blk = uo_tbl->uobj_tbl_uo_root[i]; if (blk != NULL && blk->ofs_uo_blk_avail > 0) { SOL_OFS_DPRINTF_L5(sol_ofs_dbg_str, "UOBJ ADD: table:%p, available blks:%d", uo_tbl, blk->ofs_uo_blk_avail); for (j = 0; j < SOL_OFS_UO_BLKSZ; j++) { if (blk->ofs_uoblk_blks[j] == NULL) { blk->ofs_uoblk_blks[j] = uobj; uobj->uo_id = j + (i * SOL_OFS_UO_BLKSZ); uobj->uo_uobj_sz = uo_tbl->uobj_tbl_uo_sz; blk->ofs_uo_blk_avail--; uo_tbl->uobj_tbl_uo_cnt++; goto obj_added; } } } else if (blk == NULL && empty < 0) { /* * Remember the first empty blk we came across. */ empty = i; } } /* * No entries were available, we must allocate a new block. If we did * not find a empty block available, then we must allocate/reallocate * the root array (copying any existing blk pointers to it). */ if (empty < 0) { if (uo_tbl->uobj_tbl_used_blks == uo_tbl->uobj_tbl_num_blks) { sol_ofs_uobj_blk_t **p; uint_t newsz; newsz = uo_tbl->uobj_tbl_num_blks + SOL_OFS_UO_BLKSZ; SOL_OFS_DPRINTF_L5(sol_ofs_dbg_str, "UOBJ ADD: Increasing uobj table size to %d", newsz); p = kmem_zalloc(newsz * sizeof (*p), KM_NOSLEEP); if (!p) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ ADD: Mem alloc fail\n"); rw_exit(&uo_tbl->uobj_tbl_lock); return (1); } if (uo_tbl->uobj_tbl_uo_root) { uint_t oldsz; oldsz = (uint_t)uo_tbl->uobj_tbl_num_blks * (int)(sizeof (*p)); bcopy(uo_tbl->uobj_tbl_uo_root, p, oldsz); kmem_free(uo_tbl->uobj_tbl_uo_root, oldsz); } uo_tbl->uobj_tbl_uo_root = p; uo_tbl->uobj_tbl_num_blks = newsz; } empty = uo_tbl->uobj_tbl_used_blks; uo_tbl->uobj_tbl_used_blks++; } /* * There are enough free block pointers in the root, allocate * a new block. */ blk = kmem_zalloc(sizeof (*blk), KM_NOSLEEP); if (!blk) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ ADD: Mem alloc fail\n"); rw_exit(&uo_tbl->uobj_tbl_lock); return (1); } ASSERT(uo_tbl->uobj_tbl_uo_root[empty] == NULL); uo_tbl->uobj_tbl_uo_root[empty] = blk; blk->ofs_uo_blk_avail = SOL_OFS_UO_BLKSZ - 1; /* * Use the first slot in this new block to add the new user object. */ uobj->uo_id = empty * SOL_OFS_UO_BLKSZ; blk->ofs_uoblk_blks[0] = uobj; uobj->uo_uobj_sz = uo_tbl->uobj_tbl_uo_sz; uo_tbl->uobj_tbl_uo_cnt++; obj_added: rw_exit(&uo_tbl->uobj_tbl_lock); return (0); } /* * Function: * sol_ofs_uobj_remove * Input: * uo_tbl - A pointer to the user object resource management table * from which the object should be removed. * uobj - A pointer ot the user object to be removed. * Output: * None * Returns: * A pointer to the user object that was removed on success, otherwise * NULL. * Description: * Remove a user object from the specified user resource management * table. * * The uobj uo_lock must be held as a writer before calling this. */ sol_ofs_uobj_t * sol_ofs_uobj_remove(sol_ofs_uobj_table_t *uo_tbl, sol_ofs_uobj_t *uobj) { uint_t i, j; sol_ofs_uobj_blk_t *blk; sol_ofs_uobj_t *p; ASSERT(uo_tbl != NULL); ASSERT(uobj != NULL); p = NULL; rw_enter(&uo_tbl->uobj_tbl_lock, RW_WRITER); if (!uobj->uo_live) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ REMOVE: object 0x%P, already removed", (void *)uobj); goto remove_done; } if ((uo_tbl->uobj_tbl_uo_cnt == 0) || !(uo_tbl->uobj_tbl_uo_root)) { /* * The table is empty, just return not found * Don't panic, userland app could have double free'd * let them deal with it. */ SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ REMOVE: table 0x%P empty", (void *)uo_tbl); goto remove_done; } i = uobj->uo_id / SOL_OFS_UO_BLKSZ; j = uobj->uo_id % SOL_OFS_UO_BLKSZ; if (i >= uo_tbl->uobj_tbl_used_blks) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ REMOVE: object id %d exceeds table size", uobj->uo_id); goto remove_done; } ASSERT(i < uo_tbl->uobj_tbl_num_blks); blk = uo_tbl->uobj_tbl_uo_root[i]; if (blk == NULL) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ REMOVE: object id %d points to invalid root", uobj->uo_id); goto remove_done; } if (blk->ofs_uoblk_blks[j] == NULL) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ REMOVE: object id %d points to invalid block", uobj->uo_id); goto remove_done; } /* * Mark as dead */ uobj->uo_live = 0; p = blk->ofs_uoblk_blks[j]; blk->ofs_uoblk_blks[j] = NULL; blk->ofs_uo_blk_avail++; if (blk->ofs_uo_blk_avail == SOL_OFS_UO_BLKSZ) { kmem_free(blk, sizeof (*blk)); uo_tbl->uobj_tbl_uo_root[i] = NULL; } uo_tbl->uobj_tbl_uo_cnt--; remove_done: rw_exit(&uo_tbl->uobj_tbl_lock); return (p); } /* * Function: * ofs_uobj_find * Input: * uo_tbl - A pointer to the user object resource management table * to be used for the lookup. * uo_id - The user object ID to lookup. This ID was set when * the object was added to the resource management table. * add_ref - A non zero value indicates that the user objects reference * count should be updated to reflect and additional * reference before it is returned. * Output: * None * Returns: * A pointer to the user object associated with the uo_id if found, * otherwise NULL. * Description: * Lookup and return a user object from the specified user resource * management table. */ static sol_ofs_uobj_t * ofs_uobj_find(sol_ofs_uobj_table_t *uo_tbl, uint32_t uo_id, int add_ref) { uint32_t i, j; sol_ofs_uobj_blk_t *blk; sol_ofs_uobj_t *uobj; ASSERT(uo_tbl != NULL); uobj = NULL; rw_enter(&uo_tbl->uobj_tbl_lock, RW_READER); if ((uo_tbl->uobj_tbl_uo_cnt == 0) || !(uo_tbl->uobj_tbl_uo_root)) { /* * The table is empty, just return not found * Don't panic, userland app could have double free'd * let them deal with it. */ SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ FIND: id %d in tbl 0x%P - tbl empty", uo_id, (void *)uo_tbl); goto find_done; } i = uo_id / SOL_OFS_UO_BLKSZ; j = uo_id % SOL_OFS_UO_BLKSZ; if (i >= uo_tbl->uobj_tbl_used_blks) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ FIND: Index not valid, %d", uo_id); goto find_done; } /* * Get the user object, and if valid perform a get (ref++). * The caller issuing the find, must release the reference * when done. */ blk = uo_tbl->uobj_tbl_uo_root[i]; if (blk != NULL) { ASSERT(i < uo_tbl->uobj_tbl_num_blks); uobj = blk->ofs_uoblk_blks[j]; if (uobj == NULL) { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ FIND: Index %d not found, blk = %p", uo_id, blk->ofs_uoblk_blks[j]); } else if (add_ref) { sol_ofs_uobj_ref(uobj); } } else { SOL_OFS_DPRINTF_L2(sol_ofs_dbg_str, "UOBJ FIND: Uobject not found, %d", uo_id); goto find_done; } find_done: rw_exit(&uo_tbl->uobj_tbl_lock); return (uobj); } /* * Function: * sol_ofs_uobj_get_read * Input: * tbl - Pointer to the user object managment table to * be used in the lookup. * uo_id - The ID to object mapping, assigned to the user * object at addition to the table. * Ouput: * None * Returns: * A pointer to the user object associated with uo_id or NULL * if the entry does not exist. * Description: * Lookup a user object and place a reference on it. Acquires * the object with a READ lock. The reference and lock should * be released using the sol_ofs_uobj_put() call. */ sol_ofs_uobj_t * sol_ofs_uobj_get_read(sol_ofs_uobj_table_t *tbl, uint32_t uo_id) { sol_ofs_uobj_t *uobj; uobj = ofs_uobj_find(tbl, uo_id, 1); if (!uobj) return (NULL); rw_enter(&uobj->uo_lock, RW_READER); /* * If object was destroyed before we got the lock, just release * our reference and indicate we didn't find the object. */ if (!uobj->uo_live) { sol_ofs_uobj_put(uobj); return (NULL); } return (uobj); } /* * Function: * sol_ofs_uobj_get_write * Input: * tbl - Pointer to the user object managment table to * be used in the lookup. * uo_id - The ID to object mapping, assigned to the user * object at addition to the table. * Ouput: * None * Returns: * A pointer to the user object associated with uo_id or NULL * if the entry does not exist. * Description: * Lookup a user object and place a reference on it. Acquires * the object with a WRITE lock. The reference and lock should * be released using the sol_ofs_uobj_put() call. */ sol_ofs_uobj_t * sol_ofs_uobj_get_write(sol_ofs_uobj_table_t *tbl, uint32_t uo_id) { sol_ofs_uobj_t *uobj; uobj = ofs_uobj_find(tbl, uo_id, 1); if (!uobj) return (NULL); rw_enter(&uobj->uo_lock, RW_WRITER); /* * If object was destroyed before we got the lock, just release * our reference and indicate we didn't find the object. */ if (!uobj->uo_live) { sol_ofs_uobj_put(uobj); return (NULL); } return (uobj); } /* * Function: * sol_ofs_uobj_free * Input: * uobj - A pointer to the Solaris User Verbs kernel agent user * object to be freed. * Output: * None. * Returns: * None. * Description: * Called when the user object is no longer referenced, it will release * any user object resources and free the container object memory. * NOTE: Currently there is a stipulation that the user object be the * first element of any user object specialization. */ void sol_ofs_uobj_free(sol_ofs_uobj_t *uobj) { size_t sz; ASSERT(uobj); /* * Cleanup common user object and then free memory using * length based on associated object type. */ ofs_uobj_fini(uobj); sz = uobj->uo_uobj_sz; if (sz) kmem_free(uobj, sz); } /* * Function: * sol_ofs_uobj_put * Input: * uobj - Pointer to the user object * Ouput: * None * Returns: * None * Description: * Remove a lock associated with a user object, and decrement * the reference held. On the last deference the user object * will be freed. */ void sol_ofs_uobj_put(sol_ofs_uobj_t *uobj) { rw_exit(&uobj->uo_lock); sol_ofs_uobj_deref(uobj, sol_ofs_uobj_free); }
