of/sol_ofs/sol_uobj.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 (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);
}