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