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/param.h>
  34 #include <machine/thread.h>
  35 #include <sys/thread2.h>
  36
  37 #include <sys/disk.h>
  38 #include <sys/disklabel.h>
  39 #include <sys/devicestat.h>
  40 #include <sys/device.h>
  41 #include <sys/udev.h>
  42 #include <sys/devfs.h>
  43 #include <sys/malloc.h>
  44 #include <dev/disk/dm/dm.h>
  45
  46 #include "netbsd-dm.h"
  47
  48 extern struct dev_ops dm_ops;
  49
  50 static struct devfs_bitmap dm_minor_bitmap;
  51 uint64_t dm_dev_counter;
  52
  53 static dm_dev_t *dm_dev_lookup_name(const char *);
  54 static dm_dev_t *dm_dev_lookup_uuid(const char *);
  55 static dm_dev_t *dm_dev_lookup_minor(int);
  56
  57 static struct dm_dev_head dm_dev_list =
  58 TAILQ_HEAD_INITIALIZER(dm_dev_list);
  59
  60 static struct lock dm_dev_mutex;
  61
  62 /* dm_dev_mutex must be held by caller before using disable_dev. */
  63 static void
  64 disable_dev(dm_dev_t * dmv)
  65 {
  66         KKASSERT(lockstatus(&dm_dev_mutex, curthread) == LK_EXCLUSIVE);
  67
  68         TAILQ_REMOVE(&dm_dev_list, dmv, next_devlist);
  69
  70         lockmgr(&dmv->dev_mtx, LK_EXCLUSIVE);
  71         while (dmv->ref_cnt != 0)
  72                 cv_wait(&dmv->dev_cv, &dmv->dev_mtx);
  73         lockmgr(&dmv->dev_mtx, LK_RELEASE);
  74 }
  75 /*
  76  * Generic function used to lookup dm_dev_t. Calling with dm_dev_name
  77  * and dm_dev_uuid NULL is allowed.
  78  */
  79 dm_dev_t *
  80 dm_dev_lookup(const char *dm_dev_name, const char *dm_dev_uuid,
  81     int dm_dev_minor)
  82 {
  83         dm_dev_t *dmv;
  84
  85         dmv = NULL;
  86         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
  87
  88         /* KKASSERT(dm_dev_name != NULL && dm_dev_uuid != NULL && dm_dev_minor
  89          * > 0); */
  90         if (dm_dev_minor > 0)
  91                 if ((dmv = dm_dev_lookup_minor(dm_dev_minor)) != NULL) {
  92                         dm_dev_busy(dmv);
  93                         lockmgr(&dm_dev_mutex, LK_RELEASE);
  94                         return dmv;
  95                 }
  96         if (dm_dev_name != NULL)
  97                 if ((dmv = dm_dev_lookup_name(dm_dev_name)) != NULL) {
  98                         dm_dev_busy(dmv);
  99                         lockmgr(&dm_dev_mutex, LK_RELEASE);
 100                         return dmv;
 101                 }
 102         if (dm_dev_uuid != NULL)
 103                 if ((dmv = dm_dev_lookup_uuid(dm_dev_uuid)) != NULL) {
 104                         dm_dev_busy(dmv);
 105                         lockmgr(&dm_dev_mutex, LK_RELEASE);
 106                         return dmv;
 107                 }
 108         lockmgr(&dm_dev_mutex, LK_RELEASE);
 109         return NULL;
 110 }
 111
 112
 113 /*
 114  * Lookup device with its minor number.
 115  */
 116 static dm_dev_t *
 117 dm_dev_lookup_minor(int dm_dev_minor)
 118 {
 119         dm_dev_t *dmv;
 120
 121         TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
 122                 if (dm_dev_minor == dmv->minor)
 123                         return dmv;
 124         }
 125
 126         return NULL;
 127 }
 128 /*
 129  * Lookup device with it's device name.
 130  */
 131 static dm_dev_t *
 132 dm_dev_lookup_name(const char *dm_dev_name)
 133 {
 134         dm_dev_t *dmv;
 135
 136         TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
 137                 if (strcmp(dm_dev_name, dmv->name) == 0)
 138                         return dmv;
 139         }
 140
 141         return NULL;
 142 }
 143 /*
 144  * Lookup device with it's device uuid. Used mostly by LVM2tools.
 145  */
 146 static dm_dev_t *
 147 dm_dev_lookup_uuid(const char *dm_dev_uuid)
 148 {
 149         dm_dev_t *dmv;
 150
 151         TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
 152                 if (strcmp(dm_dev_uuid, dmv->uuid) == 0)
 153                         return dmv;
 154         }
 155
 156         return NULL;
 157 }
 158 /*
 159  * Insert new device to the global list of devices.
 160  */
 161 int
 162 dm_dev_insert(dm_dev_t * dev)
 163 {
 164         dm_dev_t *dmv;
 165         int r;
 166
 167         dmv = NULL;
 168         r = 0;
 169
 170         KKASSERT(dev != NULL);
 171         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 172         if (((dmv = dm_dev_lookup_uuid(dev->uuid)) == NULL) &&
 173             ((dmv = dm_dev_lookup_name(dev->name)) == NULL) &&
 174             ((dmv = dm_dev_lookup_minor(dev->minor)) == NULL)) {
 175
 176                 TAILQ_INSERT_TAIL(&dm_dev_list, dev, next_devlist);
 177
 178         } else
 179                 r = EEXIST;
 180
 181         lockmgr(&dm_dev_mutex, LK_RELEASE);
 182         return r;
 183 }
 184
 185 /*
 186  * Remove device selected with dm_dev from global list of devices.
 187  */
 188 dm_dev_t *
 189 dm_dev_rem(dm_dev_t *dmv, const char *dm_dev_name, const char *dm_dev_uuid,
 190     int dm_dev_minor)
 191 {
 192         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 193
 194         if (dmv != NULL) {
 195                 disable_dev(dmv);
 196         } else if (dm_dev_minor > 0) {
 197                 if ((dmv = dm_dev_lookup_minor(dm_dev_minor)) != NULL)
 198                         disable_dev(dmv);
 199         } else if (dm_dev_name != NULL) {
 200                 if ((dmv = dm_dev_lookup_name(dm_dev_name)) != NULL)
 201                         disable_dev(dmv);
 202         } else if (dm_dev_uuid != NULL) {
 203                 if ((dmv = dm_dev_lookup_name(dm_dev_uuid)) != NULL)
 204                         disable_dev(dmv);
 205         }
 206
 207         lockmgr(&dm_dev_mutex, LK_RELEASE);
 208
 209         return dmv;
 210 }
 211
 212 int
 213 dm_dev_create(dm_dev_t **dmvp, const char *name, const char *uuid, int flags)
 214 {
 215         dm_dev_t *dmv;
 216         char name_buf[MAXPATHLEN];
 217         int r, dm_minor;
 218
 219         if ((dmv = dm_dev_alloc()) == NULL)
 220                 return ENOMEM;
 221
 222         if (uuid)
 223                 strncpy(dmv->uuid, uuid, DM_UUID_LEN);
 224         else
 225                 dmv->uuid[0] = '\0';
 226
 227         if (name)
 228                 strlcpy(dmv->name, name, DM_NAME_LEN);
 229
 230         dm_minor = devfs_clone_bitmap_get(&dm_minor_bitmap, 0);
 231
 232         dm_table_head_init(&dmv->table_head);
 233
 234         lockinit(&dmv->dev_mtx, "dmdev", 0, LK_CANRECURSE);
 235         cv_init(&dmv->dev_cv, "dm_dev");
 236
 237         if (flags & DM_READONLY_FLAG)
 238                 dmv->flags |= DM_READONLY_FLAG;
 239
 240         aprint_debug("Creating device dm/%s\n", name);
 241         ksnprintf(name_buf, sizeof(name_buf), "mapper/%s", dmv->name);
 242
 243         devstat_add_entry(&dmv->stats, name, 0, DEV_BSIZE,
 244             DEVSTAT_NO_ORDERED_TAGS,
 245             DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER,
 246             DEVSTAT_PRIORITY_DISK);
 247
 248         dmv->devt = disk_create_named(name_buf, dm_minor, dmv->diskp, &dm_ops);
 249         reference_dev(dmv->devt);
 250
 251         /* Make sure the device are immediately available */
 252         sync_devs();
 253
 254         dmv->devt->si_drv1 = dmv;
 255         dmv->devt->si_drv2 = dmv->diskp;
 256
 257         dmv->minor = minor(dmv->devt);
 258         udev_dict_set_cstr(dmv->devt, "subsystem", "disk");
 259
 260         if ((r = dm_dev_insert(dmv)) != 0)
 261                 dm_dev_destroy(dmv);
 262
 263         /* Increment device counter After creating device */
 264         ++dm_dev_counter; /* XXX: was atomic 64 */
 265         *dmvp = dmv;
 266
 267         return r;
 268 }
 269
 270 int
 271 dm_dev_destroy(dm_dev_t *dmv)
 272 {
 273         int minor;
 274
 275         /* Destroy active table first.  */
 276         dm_table_destroy(&dmv->table_head, DM_TABLE_ACTIVE);
 277
 278         /* Destroy inactive table if exits, too. */
 279         dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
 280
 281         dm_table_head_destroy(&dmv->table_head);
 282
 283         minor = dkunit(dmv->devt);
 284         disk_destroy(dmv->diskp);
 285         devstat_remove_entry(&dmv->stats);
 286
 287         release_dev(dmv->devt);
 288         devfs_clone_bitmap_put(&dm_minor_bitmap, minor);
 289
 290         lockuninit(&dmv->dev_mtx);
 291         cv_destroy(&dmv->dev_cv);
 292
 293         /* Destroy device */
 294         (void)dm_dev_free(dmv);
 295
 296         /* Decrement device counter After removing device */
 297         --dm_dev_counter; /* XXX: was atomic 64 */
 298
 299         return 0;
 300 }
 301
 302 /*
 303  * dm_detach 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         dm_dev_rem(dmv, NULL, NULL, -1);
 310
 311         /* Destroy and free the device */
 312         dm_dev_destroy(dmv);
 313
 314         return 0;
 315 }
 316
 317 int
 318 dm_dev_remove_all(int gentle)
 319 {
 320         dm_dev_t *dmv, *dmv2;
 321         int r;
 322
 323         r = 0;
 324
 325         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 326
 327         /*
 328          * Process in reverse order so that it can deal with inter-depentent
 329          * devices.
 330          */
 331         TAILQ_FOREACH_REVERSE_MUTABLE(dmv, &dm_dev_list, dm_dev_head,
 332             next_devlist, dmv2) {
 333                 if (gentle && dmv->is_open) {
 334                         r = EBUSY;
 335                         continue;
 336                 }
 337
 338                 disable_dev(dmv);
 339                 dm_dev_destroy(dmv);
 340         }
 341         lockmgr(&dm_dev_mutex, LK_RELEASE);
 342
 343         return r;
 344 }
 345
 346 /*
 347  * Allocate new device entry.
 348  */
 349 dm_dev_t *
 350 dm_dev_alloc(void)
 351 {
 352         dm_dev_t *dmv;
 353
 354         dmv = kmalloc(sizeof(dm_dev_t), M_DM, M_WAITOK | M_ZERO);
 355
 356         if (dmv != NULL)
 357                 dmv->diskp = kmalloc(sizeof(struct disk), M_DM, M_WAITOK | M_ZERO);
 358
 359         return dmv;
 360 }
 361 /*
 362  * Freed device entry.
 363  */
 364 int
 365 dm_dev_free(dm_dev_t * dmv)
 366 {
 367         KKASSERT(dmv != NULL);
 368
 369         if (dmv->diskp != NULL)
 370                 (void) kfree(dmv->diskp, M_DM);
 371
 372         (void) kfree(dmv, M_DM);
 373
 374         return 0;
 375 }
 376
 377 void
 378 dm_dev_busy(dm_dev_t * dmv)
 379 {
 380         lockmgr(&dmv->dev_mtx, LK_EXCLUSIVE);
 381         dmv->ref_cnt++;
 382         lockmgr(&dmv->dev_mtx, LK_RELEASE);
 383 }
 384
 385 void
 386 dm_dev_unbusy(dm_dev_t * dmv)
 387 {
 388         KKASSERT(dmv->ref_cnt != 0);
 389
 390         lockmgr(&dmv->dev_mtx, LK_EXCLUSIVE);
 391         if (--dmv->ref_cnt == 0)
 392                 cv_broadcast(&dmv->dev_cv);
 393         lockmgr(&dmv->dev_mtx, LK_RELEASE);
 394 }
 395 /*
 396  * Return prop_array of dm_targer_list dictionaries.
 397  */
 398 prop_array_t
 399 dm_dev_prop_list(void)
 400 {
 401         dm_dev_t *dmv;
 402         prop_array_t dev_array;
 403         prop_dictionary_t dev_dict;
 404
 405         dev_array = prop_array_create();
 406
 407         lockmgr(&dm_dev_mutex, LK_EXCLUSIVE);
 408
 409         TAILQ_FOREACH(dmv, &dm_dev_list, next_devlist) {
 410                 dev_dict = prop_dictionary_create();
 411
 412                 prop_dictionary_set_cstring(dev_dict, DM_DEV_NAME, dmv->name);
 413                 prop_dictionary_set_uint32(dev_dict, DM_DEV_DEV, dmv->minor);
 414
 415                 prop_array_add(dev_array, dev_dict);
 416                 prop_object_release(dev_dict);
 417         }
 418
 419         lockmgr(&dm_dev_mutex, LK_RELEASE);
 420         return dev_array;
 421 }
 422 /*
 423  * Initialize global device mutex.
 424  */
 425 int
 426 dm_dev_init(void)
 427 {
 428         TAILQ_INIT(&dm_dev_list);       /* initialize global dev list */
 429         lockinit(&dm_dev_mutex, "dmdevlist", 0, LK_CANRECURSE);
 430         devfs_clone_bitmap_init(&dm_minor_bitmap);
 431         return 0;
 432 }
 433
 434 /*
 435  * Destroy all devices created in device-mapper. Remove all tables
 436  * free all allocated memmory.
 437  */
 438 int
 439 dm_dev_uninit(void)
 440 {
 441         /* Force removal of all devices */
 442         dm_dev_remove_all(0);
 443
 444         lockuninit(&dm_dev_mutex);
 445         return 0;
 446 }