Annotation of src/sys/dev/dm/dm_dev.c, revision 1.7

1.7     ! haad        1: /*        $NetBSD: dm_dev.c,v 1.6 2009/09/09 22:38:49 haad Exp $      */
1.2       haad        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: 
1.3       haad       35: #include <sys/disk.h>
1.2       haad       36: #include <sys/disklabel.h>
                     37: #include <sys/ioctl.h>
                     38: #include <sys/ioccom.h>
                     39: #include <sys/kmem.h>
                     40: 
                     41: #include "netbsd-dm.h"
                     42: #include "dm.h"
                     43: 
                     44: static dm_dev_t* dm_dev_lookup_name(const char *);
                     45: static dm_dev_t* dm_dev_lookup_uuid(const char *);
                     46: static dm_dev_t* dm_dev_lookup_minor(int);
                     47: 
                     48: static struct dm_dev_head dm_dev_list =
                     49: TAILQ_HEAD_INITIALIZER(dm_dev_list);
                     50: 
                     51: kmutex_t dm_dev_mutex;
                     52: 
1.7     ! haad       53: /* dm_dev_mutex must be holdby caller before using disable_dev. */
1.2       haad       54: __inline static void
                     55: disable_dev(dm_dev_t *dmv)
                     56: {
                     57:                TAILQ_REMOVE(&dm_dev_list, dmv, next_devlist);
                     58:                 mutex_enter(&dmv->dev_mtx);
                     59:                 mutex_exit(&dm_dev_mutex);
                     60:                 while(dmv->ref_cnt != 0) 
                     61:                      cv_wait(&dmv->dev_cv, &dmv->dev_mtx);
                     62:                 mutex_exit(&dmv->dev_mtx);
                     63: } 
                     64: 
                     65: /*
                     66:  * Generic function used to lookup dm_dev_t. Calling with dm_dev_name 
                     67:  * and dm_dev_uuid NULL is allowed.
                     68:  */
                     69: dm_dev_t*
                     70: dm_dev_lookup(const char *dm_dev_name, const char *dm_dev_uuid,
                     71:        int dm_dev_minor) 
                     72: {
                     73:        dm_dev_t *dmv;
                     74:        
                     75:        dmv = NULL;
                     76:        mutex_enter(&dm_dev_mutex);
                     77:        
                     78:        /* KASSERT(dm_dev_name != NULL && dm_dev_uuid != NULL && dm_dev_minor > 0); */
                     79:        if (dm_dev_minor > 0)
                     80:                if ((dmv = dm_dev_lookup_minor(dm_dev_minor)) != NULL){
                     81:                        dm_dev_busy(dmv);
                     82:                        mutex_exit(&dm_dev_mutex);
                     83:                        return dmv;
                     84:                }
                     85:        
                     86:        if (dm_dev_name != NULL)        
                     87:                if ((dmv = dm_dev_lookup_name(dm_dev_name)) != NULL){
                     88:                        dm_dev_busy(dmv);
                     89:                        mutex_exit(&dm_dev_mutex);
                     90:                        return dmv;     
                     91:                }
                     92:        
                     93:        if (dm_dev_uuid != NULL)
1.3       haad       94:                if ((dmv = dm_dev_lookup_uuid(dm_dev_uuid)) != NULL){
1.2       haad       95:                        dm_dev_busy(dmv);
                     96:                        mutex_exit(&dm_dev_mutex);
                     97:                        return dmv;
                     98:                }
                     99:        mutex_exit(&dm_dev_mutex);      
                    100:        return NULL;    
                    101: }
                    102: 
                    103:  
                    104: /*
                    105:  * Lookup device with its minor number.
                    106:  */
                    107: static dm_dev_t*
                    108: dm_dev_lookup_minor(int dm_dev_minor)
                    109: {
                    110:        dm_dev_t *dmv;
                    111:        
                    112:        TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
                    113:                if (dm_dev_minor == dmv->minor)
                    114:                        return dmv;
                    115:        }
                    116:        
                    117:        return NULL;
                    118: }
                    119: 
                    120: /*
                    121:  * Lookup device with it's device name.
                    122:  */
                    123: static dm_dev_t*
                    124: dm_dev_lookup_name(const char *dm_dev_name)
                    125: {
                    126:        dm_dev_t *dmv;
                    127:        int dlen; int slen;
                    128: 
                    129:        slen = strlen(dm_dev_name);
                    130: 
                    131:        if (slen == 0)
                    132:                return NULL;
                    133:        
                    134:        TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
                    135: 
                    136:                dlen = strlen(dmv->name);
                    137:                
                    138:                if(slen != dlen)
                    139:                        continue;
                    140: 
                    141:                if (strncmp(dm_dev_name, dmv->name, slen) == 0)
                    142:                        return dmv;
                    143:        }
                    144: 
                    145:        return NULL;
                    146: }
                    147: 
                    148: /*
                    149:  * Lookup device with it's device uuid. Used mostly by LVM2tools.
                    150:  */
                    151: static dm_dev_t*
                    152: dm_dev_lookup_uuid(const char *dm_dev_uuid)
                    153: {
                    154:        dm_dev_t *dmv;
                    155:        size_t len;
                    156:        
                    157:        len = 0;
                    158:        len = strlen(dm_dev_uuid);
                    159:        
                    160:        if (len == 0)
                    161:                return NULL;
                    162: 
                    163:        TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
                    164: 
                    165:                if (strlen(dmv->uuid) != len)
                    166:                        continue;
                    167:        
                    168:                if (strncmp(dm_dev_uuid, dmv->uuid, strlen(dmv->uuid)) == 0)
                    169:                        return dmv;
                    170:        }
                    171: 
                    172:        return NULL;
                    173: }
                    174: 
                    175: /*
                    176:  * Insert new device to the global list of devices.
                    177:  */
                    178: int
                    179: dm_dev_insert(dm_dev_t *dev)
                    180: {
                    181:        dm_dev_t *dmv;
                    182:        int r;
                    183: 
                    184:        dmv = NULL;
                    185:        r = 0;
                    186:        
                    187:        KASSERT(dev != NULL);
                    188:        mutex_enter(&dm_dev_mutex);
                    189:        if (((dmv = dm_dev_lookup_uuid(dev->uuid)) == NULL) &&
                    190:            ((dmv = dm_dev_lookup_name(dev->name)) == NULL) &&
                    191:            ((dmv = dm_dev_lookup_minor(dev->minor)) == NULL)){
                    192: 
                    193:                TAILQ_INSERT_TAIL(&dm_dev_list, dev, next_devlist);
                    194:        
                    195:        } else
                    196:                r = EEXIST;
                    197:                
                    198:        mutex_exit(&dm_dev_mutex);              
                    199:        return r;
                    200: }
                    201: 
                    202: #ifdef notyet 
                    203: /*
                    204:  * Lookup device with its minor number.
                    205:  */
                    206: int
                    207: dm_dev_test_minor(int dm_dev_minor)
                    208: {
                    209:        dm_dev_t *dmv;
                    210:        
                    211:        mutex_enter(&dm_dev_mutex);
                    212:        TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
                    213:                if (dm_dev_minor == dmv->minor){
                    214:                        mutex_exit(&dm_dev_mutex);
                    215:                        return 1;
                    216:                }
                    217:        }
                    218:        mutex_exit(&dm_dev_mutex);
                    219:        
                    220:        return 0;
                    221: }
                    222: #endif
                    223: 
1.7     ! haad      224: /*
        !           225:  * dm_dev_lookup_devt look for selected device_t. We keep this routine
        !           226:  * outside of dm_dev_lookup because it is a temporally solution.
        !           227:  *
        !           228:  * TODO: This is a hack autoconf should be more flexible.
        !           229:  */
        !           230: dm_dev_t *
        !           231: dm_dev_detach(device_t devt)
        !           232: {
        !           233:        dm_dev_t *dmv;
        !           234:        
        !           235:        mutex_enter(&dm_dev_mutex);
        !           236:        TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist){
        !           237:                if (devt == dmv->devt){
        !           238:                        disable_dev(dmv);
        !           239:                        return dmv;
        !           240:                }
        !           241:        }
        !           242:        mutex_exit(&dm_dev_mutex);
        !           243:        
        !           244:        return NULL;
        !           245: }
        !           246: 
1.2       haad      247: /* 
                    248:  * Remove device selected with dm_dev from global list of devices. 
                    249:  */
                    250: dm_dev_t*
                    251: dm_dev_rem(const char *dm_dev_name, const char *dm_dev_uuid,
                    252:        int dm_dev_minor)
                    253: {      
                    254:        dm_dev_t *dmv;
                    255:        dmv = NULL;
                    256:        
                    257:        mutex_enter(&dm_dev_mutex);
                    258:        
                    259:        if (dm_dev_minor > 0)
                    260:                if ((dmv = dm_dev_lookup_minor(dm_dev_minor)) != NULL){
                    261:                        disable_dev(dmv);
                    262:                        return dmv;
                    263:                }
                    264:        
                    265:        if (dm_dev_name != NULL)        
                    266:                if ((dmv = dm_dev_lookup_name(dm_dev_name)) != NULL){
                    267:                        disable_dev(dmv);
                    268:                        return dmv;
                    269:                }
                    270:        
                    271:        if (dm_dev_uuid != NULL)
                    272:                if ((dmv = dm_dev_lookup_name(dm_dev_uuid)) != NULL){
                    273:                        disable_dev(dmv);
                    274:                        return dmv;
                    275:                }
                    276:        mutex_exit(&dm_dev_mutex);
                    277: 
                    278:        return NULL;
                    279: }
                    280: 
                    281: /*
                    282:  * Destroy all devices created in device-mapper. Remove all tables
                    283:  * free all allocated memmory. 
                    284:  */
                    285: int
                    286: dm_dev_destroy(void)
                    287: {
                    288:        dm_dev_t *dmv;
                    289:        mutex_enter(&dm_dev_mutex);
                    290: 
                    291:        while (TAILQ_FIRST(&dm_dev_list) != NULL){
                    292: 
                    293:                dmv = TAILQ_FIRST(&dm_dev_list);
                    294:                
                    295:                TAILQ_REMOVE(&dm_dev_list, TAILQ_FIRST(&dm_dev_list),
                    296:                    next_devlist);
                    297: 
                    298:                mutex_enter(&dmv->dev_mtx);
                    299: 
                    300:                while (dmv->ref_cnt != 0)
                    301:                        cv_wait(&dmv->dev_cv, &dmv->dev_mtx);
                    302:                
                    303:                /* Destroy active table first.  */
                    304:                dm_table_destroy(&dmv->table_head, DM_TABLE_ACTIVE);
                    305: 
                    306:                /* Destroy inactive table if exits, too. */
                    307:                dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
                    308: 
                    309:                dm_table_head_destroy(&dmv->table_head);
                    310: 
                    311:                mutex_exit(&dmv->dev_mtx);
                    312:                mutex_destroy(&dmv->dev_mtx);
                    313:                cv_destroy(&dmv->dev_cv);
                    314:                
                    315:                (void)kmem_free(dmv, sizeof(dm_dev_t));
                    316:        }
                    317:        mutex_exit(&dm_dev_mutex);
                    318: 
                    319:        mutex_destroy(&dm_dev_mutex);
                    320:                return 0;
                    321: }
                    322: 
                    323: /*
                    324:  * Allocate new device entry.
                    325:  */
                    326: dm_dev_t*
1.4       cegger    327: dm_dev_alloc(void)
1.2       haad      328: {
                    329:        dm_dev_t *dmv;
                    330:        
1.6       haad      331:        dmv = kmem_zalloc(sizeof(dm_dev_t), KM_SLEEP);
1.3       haad      332:        
                    333:        if(dmv != NULL)
1.6       haad      334:                dmv->diskp = kmem_zalloc(sizeof(struct disk), KM_SLEEP);
1.3       haad      335:                
1.2       haad      336:        return dmv;
                    337: }
                    338: 
                    339: /*
                    340:  * Freed device entry.
                    341:  */
                    342: int
                    343: dm_dev_free(dm_dev_t *dmv)
                    344: {
                    345:        KASSERT(dmv != NULL);
1.3       haad      346: 
1.5       haad      347:        mutex_destroy(&dmv->dev_mtx);
1.7     ! haad      348:        mutex_destroy(&dmv->diskp_mtx);
1.5       haad      349:        cv_destroy(&dmv->dev_cv);
                    350: 
1.3       haad      351:        if(dmv->diskp != NULL)
                    352:                (void)kmem_free(dmv->diskp, sizeof(struct disk));
1.2       haad      353:        
                    354:        (void)kmem_free(dmv, sizeof(dm_dev_t));
                    355:        
                    356:        return 0;
                    357: }
                    358: 
                    359: void
                    360: dm_dev_busy(dm_dev_t *dmv)
                    361: {
                    362:        mutex_enter(&dmv->dev_mtx);
                    363:        dmv->ref_cnt++;
                    364:        mutex_exit(&dmv->dev_mtx);
                    365: }      
                    366: 
                    367: void
                    368: dm_dev_unbusy(dm_dev_t *dmv)
                    369: {
                    370:        KASSERT(dmv->ref_cnt != 0);
                    371:        
                    372:        mutex_enter(&dmv->dev_mtx);
                    373:        if (--dmv->ref_cnt == 0)
                    374:                cv_broadcast(&dmv->dev_cv);
                    375:        mutex_exit(&dmv->dev_mtx);
                    376: }
                    377: 
                    378: /*
                    379:  * Return prop_array of dm_targer_list dictionaries.
                    380:  */
                    381: prop_array_t
                    382: dm_dev_prop_list(void)
                    383: {
                    384:        dm_dev_t *dmv;
                    385:        prop_array_t dev_array;
                    386:        prop_dictionary_t dev_dict;
                    387:        
                    388:        dev_array = prop_array_create();
                    389:        
                    390:        mutex_enter(&dm_dev_mutex);
                    391:        
                    392:        TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
                    393:                dev_dict  = prop_dictionary_create();
                    394:                
                    395:                prop_dictionary_set_cstring(dev_dict, DM_DEV_NAME, dmv->name);
                    396:                prop_dictionary_set_uint32(dev_dict, DM_DEV_DEV, dmv->minor);
                    397: 
                    398:                prop_array_add(dev_array, dev_dict);
                    399:                prop_object_release(dev_dict);
                    400:        }
                    401: 
                    402:        mutex_exit(&dm_dev_mutex);      
                    403:        return dev_array;
                    404: }
                    405: 
                    406: /*
                    407:  * Initialize global device mutex.
                    408:  */
                    409: int
1.4       cegger    410: dm_dev_init(void)
1.2       haad      411: {
                    412:        TAILQ_INIT(&dm_dev_list); /* initialize global dev list */
                    413:        mutex_init(&dm_dev_mutex, MUTEX_DEFAULT, IPL_NONE);
                    414:        return 0;
                    415: }

CVSweb <webmaster@jp.NetBSD.org>