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

1.2     ! haad        1: /*        $NetBSD: dm_target.c,v 1.1.2.17 2008/12/03 00:10:41 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 "netbsd-dm.h"
        !            38: #include "dm.h"
        !            39: 
        !            40: static dm_target_t* dm_target_alloc(const char *);
        !            41: 
        !            42: TAILQ_HEAD(dm_target_head, dm_target);
        !            43: 
        !            44: static struct dm_target_head dm_target_list =
        !            45: TAILQ_HEAD_INITIALIZER(dm_target_list);
        !            46: 
        !            47: /*
        !            48:  * Search for name in TAIL and return apropriate pointer.
        !            49:  */
        !            50: dm_target_t*
        !            51: dm_target_lookup_name(const char *dm_target_name)
        !            52: {
        !            53:        dm_target_t *dm_target;
        !            54:         int dlen; int slen;
        !            55: 
        !            56:        slen = strlen(dm_target_name)+1;
        !            57: 
        !            58:        TAILQ_FOREACH (dm_target, &dm_target_list, dm_target_next) {
        !            59:                dlen = strlen(dm_target->name)+1;
        !            60: 
        !            61:                if (dlen != slen)
        !            62:                        continue;
        !            63:                
        !            64:                if (strncmp(dm_target_name, dm_target->name, slen) == 0)
        !            65:                                        return dm_target;
        !            66:        }
        !            67: 
        !            68:        return NULL;
        !            69: }
        !            70: 
        !            71: /*
        !            72:  * Insert new target struct into the TAIL.
        !            73:  * dm_target
        !            74:  *   contains name, version, function pointer to specifif target functions.
        !            75:  */
        !            76: int
        !            77: dm_target_insert(dm_target_t *dm_target)
        !            78: {
        !            79:        dm_target_t *dmt;
        !            80: 
        !            81:        dmt = dm_target_lookup_name(dm_target->name);
        !            82: 
        !            83:        if (dmt != NULL)
        !            84:                return EEXIST;
        !            85:        
        !            86:        TAILQ_INSERT_TAIL(&dm_target_list, dm_target, dm_target_next);
        !            87:        
        !            88:        return 0;
        !            89: }
        !            90: 
        !            91: 
        !            92: /*
        !            93:  * Remove target from TAIL, target is selected with it's name.
        !            94:  */
        !            95: int
        !            96: dm_target_rem(char *dm_target_name)
        !            97: {
        !            98:        dm_target_t *dm_target;
        !            99:        
        !           100:        KASSERT(dm_target_name != NULL);
        !           101:                    
        !           102:        dm_target = dm_target_lookup_name(dm_target_name);
        !           103:        if (dm_target == NULL)
        !           104:                return ENOENT;
        !           105:        
        !           106:        TAILQ_REMOVE(&dm_target_list,
        !           107:            dm_target, dm_target_next);
        !           108:        
        !           109:        (void)kmem_free(dm_target, sizeof(dm_target_t));
        !           110: 
        !           111:        return 0;
        !           112: }
        !           113: 
        !           114: /*
        !           115:  * Destroy all targets and remove them from queue.
        !           116:  * This routine is called from dm_detach, before module
        !           117:  * is unloaded.
        !           118:  */
        !           119: 
        !           120: int
        !           121: dm_target_destroy(void)
        !           122: {
        !           123:        dm_target_t *dm_target;
        !           124: 
        !           125:        while (TAILQ_FIRST(&dm_target_list) != NULL){
        !           126: 
        !           127:                dm_target = TAILQ_FIRST(&dm_target_list);
        !           128:                
        !           129:                TAILQ_REMOVE(&dm_target_list, TAILQ_FIRST(&dm_target_list),
        !           130:                dm_target_next);
        !           131:                
        !           132:                (void)kmem_free(dm_target, sizeof(dm_target_t));
        !           133:        }
        !           134:        
        !           135:        return 0;
        !           136: }
        !           137: 
        !           138: /*
        !           139:  * Allocate new target entry.
        !           140:  */
        !           141: dm_target_t*
        !           142: dm_target_alloc(const char *name)
        !           143: {
        !           144:        return kmem_zalloc(sizeof(dm_target_t), KM_NOSLEEP);
        !           145: }
        !           146: 
        !           147: /*
        !           148:  * Return prop_array of dm_target dictionaries.
        !           149:  */
        !           150: prop_array_t
        !           151: dm_target_prop_list(void)
        !           152: {
        !           153:        prop_array_t target_array,ver;
        !           154:        prop_dictionary_t target_dict;
        !           155:        dm_target_t *dm_target;
        !           156: 
        !           157:        size_t i;
        !           158: 
        !           159:        target_array = prop_array_create();
        !           160:        
        !           161:        TAILQ_FOREACH (dm_target, &dm_target_list, dm_target_next){
        !           162: 
        !           163:                target_dict  = prop_dictionary_create();
        !           164:                ver = prop_array_create();
        !           165:                prop_dictionary_set_cstring(target_dict, DM_TARGETS_NAME,
        !           166:                    dm_target->name);
        !           167: 
        !           168:                for (i = 0; i < 3; i++)
        !           169:                        prop_array_add_uint32(ver, dm_target->version[i]);
        !           170: 
        !           171:                prop_dictionary_set(target_dict, DM_TARGETS_VERSION, ver);
        !           172:                prop_array_add(target_array, target_dict);
        !           173: 
        !           174:                prop_object_release(ver);
        !           175:                prop_object_release(target_dict);
        !           176:        }
        !           177: 
        !           178:        return target_array;
        !           179: }
        !           180: 
        !           181: /* Initialize dm_target subsystem. */
        !           182: int
        !           183: dm_target_init(void)
        !           184: {
        !           185:        dm_target_t *dmt,*dmt1,*dmt2,*dmt3,*dmt4,*dmt5,*dmt6;
        !           186:        int r;
        !           187: 
        !           188:        r = 0;
        !           189:        
        !           190:        dmt = dm_target_alloc("linear");
        !           191:        dmt1 = dm_target_alloc("zero");
        !           192:        dmt2 = dm_target_alloc("error");
        !           193:        dmt3 = dm_target_alloc("striped");
        !           194:        dmt4 = dm_target_alloc("mirror");
        !           195:        dmt5 = dm_target_alloc("snapshot");
        !           196:        dmt6 = dm_target_alloc("snapshot-origin");
        !           197:        
        !           198:        dmt->version[0] = 1;
        !           199:        dmt->version[1] = 0;
        !           200:        dmt->version[2] = 2;
        !           201:        strlcpy(dmt->name, "linear", DM_MAX_TYPE_NAME);
        !           202:        dmt->init = &dm_target_linear_init;
        !           203:        dmt->status = &dm_target_linear_status;
        !           204:        dmt->strategy = &dm_target_linear_strategy;
        !           205:        dmt->deps = &dm_target_linear_deps;
        !           206:        dmt->destroy = &dm_target_linear_destroy;
        !           207:        dmt->upcall = &dm_target_linear_upcall;
        !           208:        
        !           209:        r = dm_target_insert(dmt);
        !           210:                
        !           211:        dmt1->version[0] = 1;
        !           212:        dmt1->version[1] = 0;
        !           213:        dmt1->version[2] = 0;
        !           214:        strlcpy(dmt1->name, "zero", DM_MAX_TYPE_NAME);
        !           215:        dmt1->init = &dm_target_zero_init;
        !           216:        dmt1->status = &dm_target_zero_status;
        !           217:        dmt1->strategy = &dm_target_zero_strategy;
        !           218:        dmt1->deps = &dm_target_zero_deps; 
        !           219:        dmt1->destroy = &dm_target_zero_destroy; 
        !           220:        dmt1->upcall = &dm_target_zero_upcall;
        !           221:        
        !           222:        r = dm_target_insert(dmt1);
        !           223: 
        !           224:        dmt2->version[0] = 1;
        !           225:        dmt2->version[1] = 0;
        !           226:        dmt2->version[2] = 0;
        !           227:        strlcpy(dmt2->name, "error", DM_MAX_TYPE_NAME);
        !           228:        dmt2->init = &dm_target_error_init;
        !           229:        dmt2->status = &dm_target_error_status;
        !           230:        dmt2->strategy = &dm_target_error_strategy;
        !           231:        dmt2->deps = &dm_target_error_deps; 
        !           232:        dmt2->destroy = &dm_target_error_destroy; 
        !           233:        dmt2->upcall = &dm_target_error_upcall;
        !           234:        
        !           235:        r = dm_target_insert(dmt2);
        !           236:        
        !           237:        dmt3->version[0] = 1;
        !           238:        dmt3->version[1] = 0;
        !           239:        dmt3->version[2] = 3;
        !           240:        strlcpy(dmt3->name, "striped", DM_MAX_TYPE_NAME);
        !           241:        dmt3->init = &dm_target_linear_init;
        !           242:        dmt3->status = &dm_target_linear_status;
        !           243:        dmt3->strategy = &dm_target_linear_strategy;
        !           244:        dmt3->deps = &dm_target_linear_deps;
        !           245:        dmt3->destroy = &dm_target_linear_destroy;
        !           246:        dmt3->upcall = NULL;
        !           247:        
        !           248:        r = dm_target_insert(dmt3);
        !           249: 
        !           250:        dmt4->version[0] = 1;
        !           251:        dmt4->version[1] = 0;
        !           252:        dmt4->version[2] = 3;
        !           253:        strlcpy(dmt4->name, "mirror", DM_MAX_TYPE_NAME);
        !           254:        dmt4->init = NULL;
        !           255:        dmt4->status = NULL;
        !           256:        dmt4->strategy = NULL;
        !           257:        dmt4->deps = NULL;
        !           258:        dmt4->destroy = NULL;
        !           259:        dmt4->upcall = NULL;
        !           260:        
        !           261:        r = dm_target_insert(dmt4);
        !           262: 
        !           263:        dmt5->version[0] = 1;
        !           264:        dmt5->version[1] = 0;
        !           265:        dmt5->version[2] = 5;
        !           266:        strlcpy(dmt5->name, "snapshot", DM_MAX_TYPE_NAME);
        !           267:        dmt5->init = &dm_target_snapshot_init;
        !           268:        dmt5->status = &dm_target_snapshot_status;
        !           269:        dmt5->strategy = &dm_target_snapshot_strategy;
        !           270:        dmt5->deps = &dm_target_snapshot_deps;
        !           271:        dmt5->destroy = &dm_target_snapshot_destroy;
        !           272:        dmt5->upcall = &dm_target_snapshot_upcall;
        !           273:        
        !           274:        r = dm_target_insert(dmt5);
        !           275:        
        !           276:        dmt6->version[0] = 1;
        !           277:        dmt6->version[1] = 0;
        !           278:        dmt6->version[2] = 5;
        !           279:        strlcpy(dmt6->name, "snapshot-origin", DM_MAX_TYPE_NAME);
        !           280:        dmt6->init = &dm_target_snapshot_orig_init;
        !           281:        dmt6->status = &dm_target_snapshot_orig_status;
        !           282:        dmt6->strategy = &dm_target_snapshot_orig_strategy;
        !           283:        dmt6->deps = &dm_target_snapshot_orig_deps;
        !           284:        dmt6->destroy = &dm_target_snapshot_orig_destroy;
        !           285:        dmt6->upcall = &dm_target_snapshot_orig_upcall;
        !           286: 
        !           287:        r = dm_target_insert(dmt6);
        !           288:        
        !           289:        return r;
        !           290: }

CVSweb <webmaster@jp.NetBSD.org>