Home | History | Annotate | Line # | Download | only in dm
dm_target.c revision 1.36 
      1 /*        $NetBSD: dm_target.c,v 1.36 2019/12/21 16:00:29 tkusumi 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 #include <sys/cdefs.h>
     32 __KERNEL_RCSID(0, "$NetBSD: dm_target.c,v 1.36 2019/12/21 16:00:29 tkusumi Exp $");
     33 
     34 #include <sys/types.h>
     35 #include <sys/param.h>
     36 #include <sys/kmem.h>
     37 #include <sys/module.h>
     38 
     39 #include "netbsd-dm.h"
     40 #include "dm.h"
     41 
     42 static dm_target_t *dm_target_lookup_name(const char *);
     43 
     44 TAILQ_HEAD(dm_target_head, dm_target);
     45 
     46 static struct dm_target_head dm_target_list =
     47 TAILQ_HEAD_INITIALIZER(dm_target_list);
     48 
     49 static kmutex_t dm_target_mutex;
     50 
     51 /*
     52  * Called indirectly from dm_table_load_ioctl to mark target as used.
     53  */
     54 void
     55 dm_target_busy(dm_target_t *target)
     56 {
     57 
     58 	atomic_inc_32(&target->ref_cnt);
     59 }
     60 
     61 /*
     62  * Release reference counter on target.
     63  */
     64 void
     65 dm_target_unbusy(dm_target_t *target)
     66 {
     67 
     68 	KASSERT(target->ref_cnt > 0);
     69 	atomic_dec_32(&target->ref_cnt);
     70 }
     71 
     72 /*
     73  * Try to autoload target module if it was not found in current
     74  * target list.
     75  */
     76 dm_target_t *
     77 dm_target_autoload(const char *dm_target_name)
     78 {
     79 	char name[30];
     80 	unsigned int gen;
     81 	dm_target_t *dmt;
     82 
     83 	snprintf(name, sizeof(name), "dm_target_%s", dm_target_name);
     84 	name[29] = '\0';
     85 
     86 	do {
     87 		gen = module_gen;
     88 
     89 		/* Try to autoload target module */
     90 		module_autoload(name, MODULE_CLASS_MISC);
     91 	} while (gen != module_gen);
     92 
     93 	mutex_enter(&dm_target_mutex);
     94 	dmt = dm_target_lookup_name(dm_target_name);
     95 	if (dmt != NULL)
     96 		dm_target_busy(dmt);
     97 	mutex_exit(&dm_target_mutex);
     98 
     99 	return dmt;
    100 }
    101 
    102 /*
    103  * Lookup for target in global target list.
    104  */
    105 dm_target_t *
    106 dm_target_lookup(const char *dm_target_name)
    107 {
    108 	dm_target_t *dmt;
    109 
    110 	if (dm_target_name == NULL)
    111 		return NULL;
    112 
    113 	mutex_enter(&dm_target_mutex);
    114 
    115 	dmt = dm_target_lookup_name(dm_target_name);
    116 	if (dmt != NULL)
    117 		dm_target_busy(dmt);
    118 
    119 	mutex_exit(&dm_target_mutex);
    120 
    121 	return dmt;
    122 }
    123 
    124 /*
    125  * Search for name in TAIL and return apropriate pointer.
    126  */
    127 static dm_target_t *
    128 dm_target_lookup_name(const char *dm_target_name)
    129 {
    130 	dm_target_t *dm_target;
    131 	size_t dlen;
    132 	size_t slen;
    133 
    134 	slen = strlen(dm_target_name) + 1;
    135 
    136 	TAILQ_FOREACH(dm_target, &dm_target_list, dm_target_next) {
    137 		dlen = strlen(dm_target->name) + 1;
    138 		if (dlen != slen)
    139 			continue;
    140 
    141 		if (strncmp(dm_target_name, dm_target->name, slen) == 0)
    142 			return dm_target;
    143 	}
    144 
    145 	return NULL;
    146 }
    147 
    148 /*
    149  * Insert new target struct into the TAIL.
    150  * dm_target
    151  *   contains name, version, function pointer to specifif target functions.
    152  */
    153 int
    154 dm_target_insert(dm_target_t *dm_target)
    155 {
    156 	dm_target_t *dmt;
    157 
    158 	/* Sanity check for any missing function */
    159 	if (dm_target->init == NULL) {
    160 		printf("%s missing init\n", dm_target->name);
    161 		return EINVAL;
    162 	}
    163 	if (dm_target->table == NULL) {
    164 		printf("%s missing table\n", dm_target->name);
    165 		return EINVAL;
    166 	}
    167 	if (dm_target->strategy == NULL) {
    168 		printf("%s missing strategy\n", dm_target->name);
    169 		return EINVAL;
    170 	}
    171 	if (dm_target->destroy == NULL) {
    172 		printf("%s missing destroy\n", dm_target->name);
    173 		return EINVAL;
    174 	}
    175 	if (dm_target->upcall == NULL) {
    176 		printf("%s missing upcall\n", dm_target->name);
    177 		return EINVAL;
    178 	}
    179 
    180 	mutex_enter(&dm_target_mutex);
    181 
    182 	dmt = dm_target_lookup_name(dm_target->name);
    183 	if (dmt != NULL) {
    184 		mutex_exit(&dm_target_mutex);
    185 		return EEXIST;
    186 	}
    187 	TAILQ_INSERT_TAIL(&dm_target_list, dm_target, dm_target_next);
    188 
    189 	mutex_exit(&dm_target_mutex);
    190 
    191 	return 0;
    192 }
    193 
    194 /*
    195  * Remove target from TAIL, target is selected with its name.
    196  */
    197 int
    198 dm_target_rem(const char *dm_target_name)
    199 {
    200 	dm_target_t *dmt;
    201 
    202 	KASSERT(dm_target_name != NULL);
    203 
    204 	mutex_enter(&dm_target_mutex);
    205 
    206 	dmt = dm_target_lookup_name(dm_target_name);
    207 	if (dmt == NULL) {
    208 		mutex_exit(&dm_target_mutex);
    209 		return ENOENT;
    210 	}
    211 	if (dmt->ref_cnt > 0) {
    212 		mutex_exit(&dm_target_mutex);
    213 		return EBUSY;
    214 	}
    215 	TAILQ_REMOVE(&dm_target_list, dmt, dm_target_next);
    216 
    217 	mutex_exit(&dm_target_mutex);
    218 
    219 	kmem_free(dmt, sizeof(dm_target_t));
    220 
    221 	return 0;
    222 }
    223 
    224 /*
    225  * Destroy all targets and remove them from queue.
    226  * This routine is called from dm_detach, before module
    227  * is unloaded.
    228  */
    229 int
    230 dm_target_destroy(void)
    231 {
    232 	dm_target_t *dm_target;
    233 
    234 	mutex_enter(&dm_target_mutex);
    235 
    236 	while ((dm_target = TAILQ_FIRST(&dm_target_list)) != NULL) {
    237 		TAILQ_REMOVE(&dm_target_list, dm_target, dm_target_next);
    238 		kmem_free(dm_target, sizeof(dm_target_t));
    239 	}
    240 	KASSERT(TAILQ_EMPTY(&dm_target_list));
    241 
    242 	mutex_exit(&dm_target_mutex);
    243 
    244 	mutex_destroy(&dm_target_mutex);
    245 
    246 	return 0;
    247 }
    248 
    249 /*
    250  * Allocate new target entry.
    251  */
    252 dm_target_t *
    253 dm_target_alloc(const char *name)
    254 {
    255 	dm_target_t *dmt;
    256 
    257 	dmt = kmem_zalloc(sizeof(dm_target_t), KM_SLEEP);
    258 	if (dmt == NULL)
    259 		return NULL;
    260 
    261 	if (name)
    262 		strlcpy(dmt->name, name, sizeof(dmt->name));
    263 
    264 	return dmt;
    265 }
    266 
    267 /*
    268  * Return prop_array of dm_target dictionaries.
    269  */
    270 prop_array_t
    271 dm_target_prop_list(void)
    272 {
    273 	prop_array_t target_array;
    274 	dm_target_t *dm_target;
    275 
    276 	target_array = prop_array_create();
    277 
    278 	mutex_enter(&dm_target_mutex);
    279 
    280 	TAILQ_FOREACH(dm_target, &dm_target_list, dm_target_next) {
    281 		prop_array_t ver;
    282 		prop_dictionary_t target_dict;
    283 		int i;
    284 
    285 		target_dict = prop_dictionary_create();
    286 		ver = prop_array_create();
    287 		prop_dictionary_set_cstring(target_dict, DM_TARGETS_NAME,
    288 		    dm_target->name);
    289 
    290 		for (i = 0; i < 3; i++)
    291 			prop_array_add_uint32(ver, dm_target->version[i]);
    292 
    293 		prop_dictionary_set(target_dict, DM_TARGETS_VERSION, ver);
    294 		prop_array_add(target_array, target_dict);
    295 
    296 		prop_object_release(ver);
    297 		prop_object_release(target_dict);
    298 	}
    299 
    300 	mutex_exit(&dm_target_mutex);
    301 
    302 	return target_array;
    303 }
    304 
    305 /*
    306  * Initialize dm_target subsystem.
    307  */
    308 int
    309 dm_target_init(void)
    310 {
    311 	dm_target_t *dmt;
    312 
    313 	mutex_init(&dm_target_mutex, MUTEX_DEFAULT, IPL_NONE);
    314 
    315 	dmt = dm_target_alloc("linear");
    316 	dmt->version[0] = 1;
    317 	dmt->version[1] = 0;
    318 	dmt->version[2] = 2;
    319 	dmt->init = &dm_target_linear_init;
    320 	dmt->table = &dm_target_linear_table;
    321 	dmt->strategy = &dm_target_linear_strategy;
    322 	dmt->sync = &dm_target_linear_sync;
    323 	dmt->destroy = &dm_target_linear_destroy;
    324 	dmt->upcall = &dm_target_linear_upcall;
    325 	dmt->secsize = &dm_target_linear_secsize;
    326 	if (dm_target_insert(dmt))
    327 		printf("Failed to insert linear\n");
    328 
    329 	dmt = dm_target_alloc("striped");
    330 	dmt->version[0] = 1;
    331 	dmt->version[1] = 0;
    332 	dmt->version[2] = 3;
    333 	dmt->init = &dm_target_stripe_init;
    334 	dmt->info = &dm_target_stripe_info;
    335 	dmt->table = &dm_target_stripe_table;
    336 	dmt->strategy = &dm_target_stripe_strategy;
    337 	dmt->sync = &dm_target_stripe_sync;
    338 	dmt->destroy = &dm_target_stripe_destroy;
    339 	dmt->upcall = &dm_target_stripe_upcall;
    340 	dmt->secsize = &dm_target_stripe_secsize;
    341 	if (dm_target_insert(dmt))
    342 		printf("Failed to insert striped\n");
    343 
    344 	dmt = dm_target_alloc("error");
    345 	dmt->version[0] = 1;
    346 	dmt->version[1] = 0;
    347 	dmt->version[2] = 0;
    348 	dmt->init = &dm_target_error_init;
    349 	dmt->table = &dm_target_error_table;
    350 	dmt->strategy = &dm_target_error_strategy;
    351 	dmt->destroy = &dm_target_error_destroy;
    352 	dmt->upcall = &dm_target_error_upcall;
    353 	if (dm_target_insert(dmt))
    354 		printf("Failed to insert error\n");
    355 
    356 	dmt = dm_target_alloc("zero");
    357 	dmt->version[0] = 1;
    358 	dmt->version[1] = 0;
    359 	dmt->version[2] = 0;
    360 	dmt->init = &dm_target_zero_init;
    361 	dmt->table = &dm_target_zero_table;
    362 	dmt->strategy = &dm_target_zero_strategy;
    363 	dmt->destroy = &dm_target_zero_destroy;
    364 	dmt->upcall = &dm_target_zero_upcall;
    365 	if (dm_target_insert(dmt))
    366 		printf("Failed to insert zero\n");
    367 
    368 	return 0;
    369 }
    370