sys/dev/disk/dm/dm_dev.c

   1 /*        $NetBSD: dm_dev.c,v 1.8 2010/01/04 00:19:08 haad Exp $      */
   2
   3 /*
   4  * Copyright (c) 2010-2011 Alex Hornung <alex@alexhornung.com>
   5  * Copyright (c) 2008 The NetBSD Foundation, Inc.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to The NetBSD Foundation
   9  * by Adam Hamsik.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/thread2.h>
  34 #include <sys/disk.h>
  35 #include <sys/disklabel.h>
  36 #include <sys/devicestat.h>
  37 #include <sys/device.h>
  38 #include <sys/udev.h>
  39 #include <sys/devfs.h>
  40 #include <sys/malloc.h>
  41 #include <machine/thread.h>
  42 #include <dev/disk/dm/dm.h>
  43 #include <dev/disk/dm/netbsd-dm.h>
  44
  45 extern struct dev_ops dm_ops;
  46
  47 static struct devfs_bitmap dm_minor_bitmap;
  48 uint64_t dm_dev_counter;
  49
  50 static dm_dev_t *dm_dev_lookup_name(const char *);
  51 static dm_dev_t *dm_dev_lookup_uuid(const char *);
  52 static dm_dev_t *dm_dev_lookup_minor(int);
  53 static int dm_dev_destroy(dm_dev_t *);
  54 static dm_dev_t *dm_dev_alloc(const char *, const char *);
  55 static int dm_dev_free(dm_dev_t *);
  56
  57 static TAILQ_HEAD(dm_dev_head, dm_dev) dm_dev_list;
  58
  59 static struct lock dm_dev_mutex;
  60
  61 static char dummy_uuid[DM_UUID_LEN];
  62
  63 /*
  64  * dm_dev_mutex must be held by caller before using disable_dev.
  65  */
  66 static void
  67 disable_dev(dm_dev_t *dmv)
  68 {
  69         KKASSERT(lockstatus(&dm_dev_mutex, curthread) == LK_EXCLUSIVE);
  70
  71         TAILQ_REMOVE(&dm_dev_list, dmv, next_devlist);
  72         dm_dev_counter--;
  73
  74         lockmgr(&dmv->dev_mtx, LK_EXCLUSIVE);
  75         while (dmv->ref_cnt != 0)
  76                 cv_wait(&dmv->dev_cv, &dmv->dev_mtx);
  77         lockmgr(&dmv->dev_mtx, LK_RELEASE);
  78 }
  79
  80 static dm_dev_t *
  81 _dm_dev_lookup(const char *name, const char *uuid, int minor)
  82 {
  83         dm_dev_t *dmv;
  84
  85         if (minor > 0) {
  86                 if ((dmv = dm_dev_lookup_minor(minor)))
  87                         return dmv;
  88         }
  89         if (name != NULL) {
  90                 if ((dmv = dm_dev_lookup_name(name)))
  91                         return dmv;
  92         }
  93         if (uuid != NULL) {
  94                 if ((dmv = dm_dev_lookup_uuid(uuid)))
  95                         return dmv;
  96         }
  97
  98         return NULL;
  99 }
 100
 101 /*
 102  * Generic function used to lookup dm_dev_t. Calling with name NULL
 103  * and uuid NULL is allowed.
 104  */
 105 dm_dev_t *
 106 dm_dev_lookup(const char *name, const char *uuid, int minor)
 107 {
 108         dm_dev_t *dmv;
 109
 110         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 111
 112         dmv = _dm_dev_lookup(name, uuid, minor);
 113         if (dmv)
 114                 dm_dev_busy(dmv);
 115
 116         lockmgr(&dm_dev_mutex, LK_RELEASE);
 117
 118         return dmv;
 119 }
 120
 121
 122 /*
 123  * Lookup device with its minor number.
 124  */
 125 static dm_dev_t *
 126 dm_dev_lookup_minor(int dm_dev_minor)
 127 {
 128         dm_dev_t *dmv;
 129
 130         TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
 131                 if (dm_dev_minor == dmv->minor)
 132                         return dmv;
 133         }
 134
 135         return NULL;
 136 }
 137
 138 /*
 139  * Lookup device with it's device name.
 140  */
 141 static dm_dev_t *
 142 dm_dev_lookup_name(const char *dm_dev_name)
 143 {
 144         dm_dev_t *dmv;
 145
 146         TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
 147                 if (strcmp(dm_dev_name, dmv->name) == 0)
 148                         return dmv;
 149         }
 150
 151         return NULL;
 152 }
 153
 154 /*
 155  * Lookup device with it's device uuid. Used mostly by LVM2tools.
 156  */
 157 static dm_dev_t *
 158 dm_dev_lookup_uuid(const char *dm_dev_uuid)
 159 {
 160         dm_dev_t *dmv;
 161
 162         TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
 163                 if (strcmp(dm_dev_uuid, dmv->uuid) == 0)
 164                         return dmv;
 165         }
 166
 167         return NULL;
 168 }
 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
 185         /*
 186          * Ignore uuid lookup if dev->uuid is zero-filled.
 187          */
 188         if (memcmp(dev->uuid, dummy_uuid, DM_UUID_LEN))
 189                 dmv = dm_dev_lookup_uuid(dev->uuid);
 190
 191         if ((dmv == NULL) &&
 192             (_dm_dev_lookup(dev->name, NULL, dev->minor) == NULL)) {
 193                 TAILQ_INSERT_TAIL(&dm_dev_list, dev, next_devlist);
 194                 dm_dev_counter++;
 195         } else {
 196                 KKASSERT(dmv != NULL);
 197                 r = EEXIST;
 198         }
 199
 200         lockmgr(&dm_dev_mutex, LK_RELEASE);
 201         return r;
 202 }
 203
 204 #if 0
 205 /*
 206  * Remove device selected with dm_dev from global list of devices.
 207  */
 208 dm_dev_t *
 209 dm_dev_lookup_evict(const char *name, const char *uuid, int minor)
 210 {
 211         dm_dev_t *dmv;
 212
 213         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 214
 215         dmv = _dm_dev_lookup(name, uuid, minor);
 216         if (dmv)
 217                 disable_dev(dmv);
 218
 219         lockmgr(&dm_dev_mutex, LK_RELEASE);
 220
 221         return dmv;
 222 }
 223 #endif
 224
 225 int
 226 dm_dev_create(dm_dev_t **dmvp, const char *name, const char *uuid, int flags)
 227 {
 228         dm_dev_t *dmv;
 229         char name_buf[MAXPATHLEN];
 230         int r, dm_minor;
 231
 232         if ((dmv = dm_dev_alloc(name, uuid)) == NULL)
 233                 return ENOMEM;
 234
 235         dm_minor = devfs_clone_bitmap_get(&dm_minor_bitmap, 0);
 236
 237         dm_table_head_init(&dmv->table_head);
 238
 239         lockinit(&dmv->dev_mtx, "dmdev", 0, LK_CANRECURSE);
 240         cv_init(&dmv->dev_cv, "dm_dev");
 241
 242         if (flags & DM_READONLY_FLAG)
 243                 dmv->flags |= DM_READONLY_FLAG;
 244
 245         dmdebug("Creating device dm/%s\n", name);
 246         ksnprintf(name_buf, sizeof(name_buf), "mapper/%s", dmv->name);
 247
 248         devstat_add_entry(&dmv->stats, name, 0, DEV_BSIZE,
 249             DEVSTAT_NO_ORDERED_TAGS,
 250             DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER,
 251             DEVSTAT_PRIORITY_DISK);
 252
 253         dmv->devt = disk_create_named(name_buf, dm_minor, dmv->diskp, &dm_ops);
 254         reference_dev(dmv->devt);
 255
 256         /* Make sure the device are immediately available */
 257         sync_devs();
 258
 259         dmv->devt->si_drv1 = dmv;
 260         dmv->devt->si_drv2 = dmv->diskp;
 261
 262         dmv->minor = minor(dmv->devt);
 263         udev_dict_set_cstr(dmv->devt, "subsystem", "disk");
 264
 265         if ((r = dm_dev_insert(dmv)) != 0)
 266                 dm_dev_destroy(dmv);
 267
 268         *dmvp = dmv;
 269
 270         return r;
 271 }
 272
 273 static int
 274 dm_dev_destroy(dm_dev_t *dmv)
 275 {
 276         int minor;
 277
 278         /* Destroy active table first.  */
 279         dm_table_destroy(&dmv->table_head, DM_TABLE_ACTIVE);
 280
 281         /* Destroy inactive table if exits, too. */
 282         dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
 283
 284         dm_table_head_destroy(&dmv->table_head);
 285
 286         minor = dkunit(dmv->devt);
 287         disk_destroy(dmv->diskp);
 288         devstat_remove_entry(&dmv->stats);
 289
 290         release_dev(dmv->devt);
 291         devfs_clone_bitmap_put(&dm_minor_bitmap, minor);
 292
 293         lockuninit(&dmv->dev_mtx);
 294         cv_destroy(&dmv->dev_cv);
 295
 296         /* Destroy device */
 297         dm_dev_free(dmv);
 298
 299         return 0;
 300 }
 301
 302 /*
 303  * dm_dev_remove is called to completely destroy & remove a dm disk device.
 304  */
 305 int
 306 dm_dev_remove(dm_dev_t *dmv)
 307 {
 308         /* Remove device from list and wait for refcnt to drop to zero */
 309         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 310         disable_dev(dmv);
 311         lockmgr(&dm_dev_mutex, LK_RELEASE);
 312
 313         /* Destroy and free the device */
 314         dm_dev_destroy(dmv);
 315
 316         return 0;
 317 }
 318
 319 int
 320 dm_dev_remove_all(int gentle)
 321 {
 322         dm_dev_t *dmv, *dmv2;
 323         int r;
 324
 325         r = 0;
 326
 327         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 328
 329         /*
 330          * Process in reverse order so that it can deal with inter-depentent
 331          * devices.
 332          */
 333         TAILQ_FOREACH_REVERSE_MUTABLE(dmv, &dm_dev_list, dm_dev_head,
 334             next_devlist, dmv2) {
 335                 if (gentle && dmv->is_open) {
 336                         r = EBUSY;
 337                         continue;
 338                 }
 339
 340                 disable_dev(dmv);
 341                 dm_dev_destroy(dmv);
 342         }
 343         lockmgr(&dm_dev_mutex, LK_RELEASE);
 344
 345         return r;
 346 }
 347
 348 /*
 349  * Allocate new device entry.
 350  */
 351 static dm_dev_t *
 352 dm_dev_alloc(const char *name, const char*uuid)
 353 {
 354         dm_dev_t *dmv;
 355
 356         dmv = kmalloc(sizeof(*dmv), M_DM, M_WAITOK | M_ZERO);
 357         if (dmv == NULL)
 358                 return NULL;
 359
 360         dmv->diskp = kmalloc(sizeof(*dmv->diskp), M_DM, M_WAITOK | M_ZERO);
 361         if (dmv->diskp == NULL) {
 362                 kfree(dmv, M_DM);
 363                 return NULL;
 364         }
 365
 366         if (name)
 367                 strlcpy(dmv->name, name, sizeof(dmv->name));
 368         if (uuid)
 369                 strncpy(dmv->uuid, uuid, sizeof(dmv->uuid));
 370
 371         return dmv;
 372 }
 373
 374 /*
 375  * Freed device entry.
 376  */
 377 static int
 378 dm_dev_free(dm_dev_t *dmv)
 379 {
 380         KKASSERT(dmv != NULL);
 381
 382         if (dmv->diskp != NULL)
 383                 kfree(dmv->diskp, M_DM);
 384
 385         kfree(dmv, M_DM);
 386
 387         return 0;
 388 }
 389
 390 void
 391 dm_dev_busy(dm_dev_t *dmv)
 392 {
 393         lockmgr(&dmv->dev_mtx, LK_EXCLUSIVE);
 394         dmv->ref_cnt++;
 395         lockmgr(&dmv->dev_mtx, LK_RELEASE);
 396 }
 397
 398 void
 399 dm_dev_unbusy(dm_dev_t *dmv)
 400 {
 401         KKASSERT(dmv->ref_cnt != 0);
 402
 403         lockmgr(&dmv->dev_mtx, LK_EXCLUSIVE);
 404         if (--dmv->ref_cnt == 0)
 405                 cv_broadcast(&dmv->dev_cv);
 406         lockmgr(&dmv->dev_mtx, LK_RELEASE);
 407 }
 408
 409 /*
 410  * Return prop_array of dm_targer_list dictionaries.
 411  */
 412 prop_array_t
 413 dm_dev_prop_list(void)
 414 {
 415         dm_dev_t *dmv;
 416         prop_array_t dev_array;
 417         prop_dictionary_t dev_dict;
 418
 419         dev_array = prop_array_create();
 420
 421         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 422
 423         TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
 424                 dev_dict = prop_dictionary_create();
 425
 426                 prop_dictionary_set_cstring(dev_dict, DM_DEV_NAME, dmv->name);
 427                 prop_dictionary_set_uint32(dev_dict, DM_DEV_DEV, dmv->minor);
 428
 429                 prop_array_add(dev_array, dev_dict);
 430                 prop_object_release(dev_dict);
 431         }
 432
 433         lockmgr(&dm_dev_mutex, LK_RELEASE);
 434         return dev_array;
 435 }
 436
 437 /*
 438  * Initialize global device mutex.
 439  */
 440 int
 441 dm_dev_init(void)
 442 {
 443         TAILQ_INIT(&dm_dev_list);       /* initialize global dev list */
 444         lockinit(&dm_dev_mutex, "dmdevlist", 0, LK_CANRECURSE);
 445         devfs_clone_bitmap_init(&dm_minor_bitmap);
 446
 447         memset(dummy_uuid, 0, sizeof(dummy_uuid));
 448         return 0;
 449 }
 450
 451 /*
 452  * Destroy all devices created in device-mapper. Remove all tables
 453  * free all allocated memmory.
 454  */
 455 int
 456 dm_dev_uninit(void)
 457 {
 458         /* Force removal of all devices */
 459         dm_dev_remove_all(0);
 460
 461         lockuninit(&dm_dev_mutex);
 462         return 0;
 463 }