Annotation of src/sys/dev/dm/dm_table.c, revision 1.2

1.2     ! haad        1: /*        $NetBSD: dm_table.c,v 1.1.2.12 2008/11/05 13:45:02 haad Exp $      */
        !             2: 
        !             3: /*
        !             4:  * Copyright (c) 2008 The NetBSD Foundation, Inc.
        !             5:  * All rights reserved.
        !             6:  *
        !             7:  * This code is derived from software contributed to The NetBSD Foundation
        !             8:  * by Adam Hamsik.
        !             9:  *
        !            10:  * Redistribution and use in source and binary forms, with or without
        !            11:  * modification, are permitted provided that the following conditions
        !            12:  * are met:
        !            13:  * 1. Redistributions of source code must retain the above copyright
        !            14:  *    notice, this list of conditions and the following disclaimer.
        !            15:  * 2. Redistributions in binary form must reproduce the above copyright
        !            16:  *    notice, this list of conditions and the following disclaimer in the
        !            17:  *    documentation and/or other materials provided with the distribution.
        !            18:  *
        !            19:  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
        !            20:  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
        !            21:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
        !            22:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
        !            23:  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
        !            24:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
        !            25:  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
        !            26:  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
        !            27:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
        !            28:  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
        !            29:  * POSSIBILITY OF SUCH DAMAGE.
        !            30:  */
        !            31: 
        !            32: #include <sys/types.h>
        !            33: #include <sys/param.h>
        !            34: 
        !            35: #include <sys/kmem.h>
        !            36: 
        !            37: #include "dm.h"
        !            38: 
        !            39: /*
        !            40:  * There are two types of users of this interface:
        !            41:  * 
        !            42:  * a) Readers such as
        !            43:  *    dmstrategy, dmgetdisklabel, dmsize, dm_dev_status_ioctl,
        !            44:  *    dm_table_deps_ioctl, dm_table_status_ioctl, dm_table_reload_ioctl
        !            45:  *
        !            46:  * b) Writers such as
        !            47:  *    dm_dev_remove_ioctl, dm_dev_resume_ioctl, dm_table_clear_ioctl
        !            48:  *
        !            49:  * Writers can work with table_head only when there are no readers. I
        !            50:  * use reference counting on io_cnt.
        !            51:  *
        !            52:  */
        !            53: 
        !            54: static int dm_table_busy(dm_table_head_t *, uint8_t );
        !            55: static void dm_table_unbusy(dm_table_head_t *);
        !            56: 
        !            57: /*
        !            58:  * Function to increment table user reference counter. Return id
        !            59:  * of table_id table.
        !            60:  * DM_TABLE_ACTIVE will return active table id.
        !            61:  * DM_TABLE_INACTIVE will return inactive table id.
        !            62:  */
        !            63: static int
        !            64: dm_table_busy(dm_table_head_t *head, uint8_t table_id)
        !            65: {
        !            66:        uint8_t id;
        !            67: 
        !            68:        id = 0;
        !            69: 
        !            70:        mutex_enter(&head->table_mtx);
        !            71: 
        !            72:        if (table_id == DM_TABLE_ACTIVE)
        !            73:                id = head->cur_active_table;
        !            74:        else
        !            75:                id = 1 - head->cur_active_table;
        !            76: 
        !            77:        head->io_cnt++;
        !            78: 
        !            79:        mutex_exit(&head->table_mtx);
        !            80:        return id;
        !            81: }
        !            82: 
        !            83: /*
        !            84:  * Function release table lock and eventually wakeup all waiters.
        !            85:  */
        !            86: static void
        !            87: dm_table_unbusy(dm_table_head_t *head)
        !            88: {
        !            89:        KASSERT(head->io_cnt != 0);
        !            90: 
        !            91:        mutex_enter(&head->table_mtx);
        !            92:        
        !            93:        if (--head->io_cnt == 0)
        !            94:                cv_broadcast(&head->table_cv);
        !            95:        
        !            96:        mutex_exit(&head->table_mtx);
        !            97: }
        !            98: 
        !            99: /*
        !           100:  * Return current active table to caller, increment io_cnt reference counter.
        !           101:  */
        !           102: dm_table_t *
        !           103: dm_table_get_entry(dm_table_head_t *head, uint8_t table_id)
        !           104: {
        !           105:        uint8_t id;
        !           106: 
        !           107:        id = dm_table_busy(head, table_id);
        !           108:        
        !           109:        return &head->tables[id];
        !           110: }
        !           111: 
        !           112: /*
        !           113:  * Decrement io reference counter and wake up all callers, with table_head cv.
        !           114:  */
        !           115: void
        !           116: dm_table_release(dm_table_head_t *head, uint8_t table_id)
        !           117: {
        !           118:        dm_table_unbusy(head);
        !           119: }
        !           120: 
        !           121: /*
        !           122:  * Switch table from inactive to active mode. Have to wait until io_cnt is 0.
        !           123:  */
        !           124: void
        !           125: dm_table_switch_tables(dm_table_head_t *head)
        !           126: {
        !           127:        mutex_enter(&head->table_mtx);
        !           128: 
        !           129:        while (head->io_cnt != 0)
        !           130:                cv_wait(&head->table_cv, &head->table_mtx);
        !           131: 
        !           132:        head->cur_active_table = 1 - head->cur_active_table;
        !           133: 
        !           134:        mutex_exit(&head->table_mtx);
        !           135: }
        !           136: 
        !           137: /*
        !           138:  * Destroy all table data. This function can run when there are no
        !           139:  * readers on table lists.
        !           140:  *
        !           141:  * XXX Is it ok to call kmem_free and potentialy VOP_CLOSE with held mutex ?xs
        !           142:  */
        !           143: int
        !           144: dm_table_destroy(dm_table_head_t *head, uint8_t table_id)
        !           145: {
        !           146:        dm_table_t       *tbl;
        !           147:        dm_table_entry_t *table_en;
        !           148:        uint8_t id;
        !           149: 
        !           150:        mutex_enter(&head->table_mtx);
        !           151: 
        !           152:        printf("dm_Table_destroy called with %d--%d\n", table_id, head->io_cnt);
        !           153:        
        !           154:        while (head->io_cnt != 0)
        !           155:                cv_wait(&head->table_cv, &head->table_mtx);
        !           156: 
        !           157:        if (table_id == DM_TABLE_ACTIVE)
        !           158:                id = head->cur_active_table;
        !           159:        else
        !           160:                id = 1 - head->cur_active_table;
        !           161:        
        !           162:        tbl = &head->tables[id];
        !           163:        
        !           164:        while (!SLIST_EMPTY(tbl)) {           /* List Deletion. */
        !           165:                table_en = SLIST_FIRST(tbl);
        !           166:                /*
        !           167:                 * Remove target specific config data. After successfull
        !           168:                 * call table_en->target_config must be set to NULL.
        !           169:                 */
        !           170:                table_en->target->destroy(table_en); 
        !           171:        
        !           172:                SLIST_REMOVE_HEAD(tbl, next);
        !           173: 
        !           174:                kmem_free(table_en, sizeof(*table_en));
        !           175:        }
        !           176: 
        !           177:        mutex_exit(&head->table_mtx);
        !           178:        
        !           179:        return 0;
        !           180: }
        !           181: 
        !           182: /*
        !           183:  * Return length of active table in device.
        !           184:  */
        !           185: uint64_t
        !           186: dm_table_size(dm_table_head_t *head)
        !           187: {
        !           188:        dm_table_t  *tbl;
        !           189:        dm_table_entry_t *table_en;
        !           190:        uint64_t length;
        !           191:        uint8_t id;
        !           192:        
        !           193:        length = 0;
        !           194: 
        !           195:        id = dm_table_busy(head, DM_TABLE_ACTIVE);
        !           196:                
        !           197:        /* Select active table */
        !           198:        tbl = &head->tables[id];
        !           199:        
        !           200:        /*
        !           201:         * Find out what tables I want to select.
        !           202:         * if length => rawblkno then we should used that table.
        !           203:         */
        !           204:        SLIST_FOREACH(table_en, tbl, next)
        !           205:            length += table_en->length;
        !           206: 
        !           207:        dm_table_unbusy(head);
        !           208:        
        !           209:        return length / DEV_BSIZE;
        !           210: }
        !           211: 
        !           212: /*
        !           213:  * Return > 0 if table is at least one table entry (returns number of entries)
        !           214:  * and return 0 if there is not. Target count returned from this function
        !           215:  * doesn't need to be true when userspace user receive it (after return
        !           216:  * there can be dm_dev_resume_ioctl), therfore this isonly informative.
        !           217:  */
        !           218: int
        !           219: dm_table_get_target_count(dm_table_head_t *head, uint8_t table_id)
        !           220: {      
        !           221:        dm_table_entry_t *table_en;
        !           222:        dm_table_t *tbl;
        !           223:        uint32_t target_count;
        !           224:        uint8_t id;
        !           225: 
        !           226:        target_count = 0;
        !           227: 
        !           228:        id = dm_table_busy(head, table_id);
        !           229: 
        !           230:        tbl = &head->tables[id];
        !           231: 
        !           232:        SLIST_FOREACH(table_en, tbl, next)
        !           233:            target_count++;
        !           234: 
        !           235:        dm_table_unbusy(head);
        !           236:        
        !           237:        return target_count;
        !           238: }
        !           239: 
        !           240: 
        !           241: /*
        !           242:  * Initialize table_head structures, I'm trying to keep this structure as
        !           243:  * opaque as possible.
        !           244:  */
        !           245: void
        !           246: dm_table_head_init(dm_table_head_t *head)
        !           247: {
        !           248:        head->cur_active_table = 0;
        !           249:        head->io_cnt = 0;
        !           250:        
        !           251:        /* Initialize tables. */
        !           252:        SLIST_INIT(&head->tables[0]);
        !           253:        SLIST_INIT(&head->tables[1]);
        !           254: 
        !           255:        mutex_init(&head->table_mtx, MUTEX_DEFAULT, IPL_NONE);
        !           256:        cv_init(&head->table_cv, "dm_io");
        !           257: }
        !           258: 
        !           259: /*
        !           260:  * Destroy all variables in table_head
        !           261:  */
        !           262: void
        !           263: dm_table_head_destroy(dm_table_head_t *head)
        !           264: {
        !           265:        KASSERT(!mutex_owned(&head->table_mtx));
        !           266:        KASSERT(!cv_has_waiters(&head->table_cv));
        !           267:        /* tables doens't exists when I call this routine, therefore
        !           268:           it doesn't make sense to have io_cnt != 0 */
        !           269:        KASSERT(head->io_cnt == 0); 
        !           270:        
        !           271:        cv_destroy(&head->table_cv);
        !           272:        mutex_destroy(&head->table_mtx);
        !           273: }

CVSweb <webmaster@jp.NetBSD.org>