dm_target.c revision 1.9.2.7
1 /* $NetBSD: dm_target.c,v 1.9.2.7 2010/10/09 03:32:05 yamt 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 #include <sys/module.h> 37 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 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 atomic_inc_32(&target->ref_cnt); 58 } 59 /* 60 * Release reference counter on target. 61 */ 62 void 63 dm_target_unbusy(dm_target_t * target) 64 { 65 KASSERT(target->ref_cnt > 0); 66 atomic_dec_32(&target->ref_cnt); 67 } 68 /* 69 * Try to autoload target module if it was not found in current 70 * target list. 71 */ 72 dm_target_t * 73 dm_target_autoload(const char *dm_target_name) 74 { 75 char name[30]; 76 u_int gen; 77 dm_target_t *dmt; 78 79 snprintf(name, sizeof(name), "dm_target_%s", dm_target_name); 80 name[29] = '\0'; 81 82 do { 83 gen = module_gen; 84 85 /* Try to autoload target module */ 86 (void) module_autoload(name, MODULE_CLASS_MISC); 87 } while (gen != module_gen); 88 89 mutex_enter(&dm_target_mutex); 90 dmt = dm_target_lookup_name(dm_target_name); 91 if (dmt != NULL) 92 dm_target_busy(dmt); 93 mutex_exit(&dm_target_mutex); 94 95 return dmt; 96 } 97 /* 98 * Lookup for target in global target list. 99 */ 100 dm_target_t * 101 dm_target_lookup(const char *dm_target_name) 102 { 103 dm_target_t *dmt; 104 105 dmt = NULL; 106 107 if (dm_target_name == NULL) 108 return NULL; 109 110 mutex_enter(&dm_target_mutex); 111 112 dmt = dm_target_lookup_name(dm_target_name); 113 if (dmt != NULL) 114 dm_target_busy(dmt); 115 116 mutex_exit(&dm_target_mutex); 117 118 return dmt; 119 } 120 /* 121 * Search for name in TAIL and return apropriate pointer. 122 */ 123 static dm_target_t * 124 dm_target_lookup_name(const char *dm_target_name) 125 { 126 dm_target_t *dm_target; 127 int dlen; 128 int slen; 129 130 slen = strlen(dm_target_name) + 1; 131 132 TAILQ_FOREACH(dm_target, &dm_target_list, dm_target_next) { 133 dlen = strlen(dm_target->name) + 1; 134 if (dlen != slen) 135 continue; 136 137 if (strncmp(dm_target_name, dm_target->name, slen) == 0) 138 return dm_target; 139 } 140 141 return NULL; 142 } 143 /* 144 * Insert new target struct into the TAIL. 145 * dm_target 146 * contains name, version, function pointer to specifif target functions. 147 */ 148 int 149 dm_target_insert(dm_target_t * dm_target) 150 { 151 dm_target_t *dmt; 152 153 mutex_enter(&dm_target_mutex); 154 155 dmt = dm_target_lookup_name(dm_target->name); 156 if (dmt != NULL) { 157 mutex_exit(&dm_target_mutex); 158 return EEXIST; 159 } 160 TAILQ_INSERT_TAIL(&dm_target_list, dm_target, dm_target_next); 161 162 mutex_exit(&dm_target_mutex); 163 164 return 0; 165 } 166 167 168 /* 169 * Remove target from TAIL, target is selected with it's name. 170 */ 171 int 172 dm_target_rem(char *dm_target_name) 173 { 174 dm_target_t *dmt; 175 176 KASSERT(dm_target_name != NULL); 177 178 mutex_enter(&dm_target_mutex); 179 180 dmt = dm_target_lookup_name(dm_target_name); 181 if (dmt == NULL) { 182 mutex_exit(&dm_target_mutex); 183 return ENOENT; 184 } 185 if (dmt->ref_cnt > 0) { 186 mutex_exit(&dm_target_mutex); 187 return EBUSY; 188 } 189 TAILQ_REMOVE(&dm_target_list, 190 dmt, dm_target_next); 191 192 mutex_exit(&dm_target_mutex); 193 194 (void) kmem_free(dmt, sizeof(dm_target_t)); 195 196 return 0; 197 } 198 /* 199 * Destroy all targets and remove them from queue. 200 * This routine is called from dm_detach, before module 201 * is unloaded. 202 */ 203 int 204 dm_target_destroy(void) 205 { 206 dm_target_t *dm_target; 207 208 mutex_enter(&dm_target_mutex); 209 while (TAILQ_FIRST(&dm_target_list) != NULL) { 210 211 dm_target = TAILQ_FIRST(&dm_target_list); 212 213 TAILQ_REMOVE(&dm_target_list, TAILQ_FIRST(&dm_target_list), 214 dm_target_next); 215 216 (void) kmem_free(dm_target, sizeof(dm_target_t)); 217 } 218 mutex_exit(&dm_target_mutex); 219 220 mutex_destroy(&dm_target_mutex); 221 222 return 0; 223 } 224 /* 225 * Allocate new target entry. 226 */ 227 dm_target_t * 228 dm_target_alloc(const char *name) 229 { 230 return kmem_zalloc(sizeof(dm_target_t), KM_SLEEP); 231 } 232 /* 233 * Return prop_array of dm_target dictionaries. 234 */ 235 prop_array_t 236 dm_target_prop_list(void) 237 { 238 prop_array_t target_array, ver; 239 prop_dictionary_t target_dict; 240 dm_target_t *dm_target; 241 242 size_t i; 243 244 target_array = prop_array_create(); 245 246 mutex_enter(&dm_target_mutex); 247 248 TAILQ_FOREACH(dm_target, &dm_target_list, dm_target_next) { 249 250 target_dict = prop_dictionary_create(); 251 ver = prop_array_create(); 252 prop_dictionary_set_cstring(target_dict, DM_TARGETS_NAME, 253 dm_target->name); 254 255 for (i = 0; i < 3; i++) 256 prop_array_add_uint32(ver, dm_target->version[i]); 257 258 prop_dictionary_set(target_dict, DM_TARGETS_VERSION, ver); 259 prop_array_add(target_array, target_dict); 260 261 prop_object_release(ver); 262 prop_object_release(target_dict); 263 } 264 265 mutex_exit(&dm_target_mutex); 266 267 return target_array; 268 } 269 /* Initialize dm_target subsystem. */ 270 int 271 dm_target_init(void) 272 { 273 dm_target_t *dmt, *dmt3; 274 int r; 275 276 r = 0; 277 278 mutex_init(&dm_target_mutex, MUTEX_DEFAULT, IPL_NONE); 279 280 dmt = dm_target_alloc("linear"); 281 dmt3 = dm_target_alloc("striped"); 282 283 dmt->version[0] = 1; 284 dmt->version[1] = 0; 285 dmt->version[2] = 2; 286 strlcpy(dmt->name, "linear", DM_MAX_TYPE_NAME); 287 dmt->init = &dm_target_linear_init; 288 dmt->status = &dm_target_linear_status; 289 dmt->strategy = &dm_target_linear_strategy; 290 dmt->sync = &dm_target_linear_sync; 291 dmt->deps = &dm_target_linear_deps; 292 dmt->destroy = &dm_target_linear_destroy; 293 dmt->upcall = &dm_target_linear_upcall; 294 295 r = dm_target_insert(dmt); 296 297 dmt3->version[0] = 1; 298 dmt3->version[1] = 0; 299 dmt3->version[2] = 3; 300 strlcpy(dmt3->name, "striped", DM_MAX_TYPE_NAME); 301 dmt3->init = &dm_target_stripe_init; 302 dmt3->status = &dm_target_stripe_status; 303 dmt3->strategy = &dm_target_stripe_strategy; 304 dmt3->sync = &dm_target_stripe_sync; 305 dmt3->deps = &dm_target_stripe_deps; 306 dmt3->destroy = &dm_target_stripe_destroy; 307 dmt3->upcall = &dm_target_stripe_upcall; 308 309 r = dm_target_insert(dmt3); 310 311 return r; 312 } 313
Indexes created Tue Sep 30 17:09:57 GMT 2025