SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/md/dm-ioctl.c

   1 /*
   2  * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
   3  * Copyright (C) 2004 - 2006 Red Hat, Inc. All rights reserved.
   4  *
   5  * This file is released under the GPL.
   6  */
   7
   8 #include "dm.h"
   9
  10 #include <linux/module.h>
  11 #include <linux/vmalloc.h>
  12 #include <linux/miscdevice.h>
  13 #include <linux/init.h>
  14 #include <linux/wait.h>
  15 #include <linux/slab.h>
  16 #include <linux/dm-ioctl.h>
  17 #include <linux/hdreg.h>
  18 #include <linux/compat.h>
  19
  20 #include <asm/uaccess.h>
  21
  22 #define DM_MSG_PREFIX "ioctl"
  23 #define DM_DRIVER_EMAIL "dm-devel@redhat.com"
  24
  25 /*-----------------------------------------------------------------
  26  * The ioctl interface needs to be able to look up devices by
  27  * name or uuid.
  28  *---------------------------------------------------------------*/
  29 struct hash_cell {
  30         struct list_head name_list;
  31         struct list_head uuid_list;
  32
  33         char *name;
  34         char *uuid;
  35         struct mapped_device *md;
  36         struct dm_table *new_map;
  37 };
  38
  39 struct vers_iter {
  40     size_t param_size;
  41     struct dm_target_versions *vers, *old_vers;
  42     char *end;
  43     uint32_t flags;
  44 };
  45
  46
  47 #define NUM_BUCKETS 64
  48 #define MASK_BUCKETS (NUM_BUCKETS - 1)
  49 static struct list_head _name_buckets[NUM_BUCKETS];
  50 static struct list_head _uuid_buckets[NUM_BUCKETS];
  51
  52 static void dm_hash_remove_all(int keep_open_devices);
  53
  54 /*
  55  * Guards access to both hash tables.
  56  */
  57 static DECLARE_RWSEM(_hash_lock);
  58
  59 /*
  60  * Protects use of mdptr to obtain hash cell name and uuid from mapped device.
  61  */
  62 static DEFINE_MUTEX(dm_hash_cells_mutex);
  63
  64 static void init_buckets(struct list_head *buckets)
  65 {
  66         unsigned int i;
  67
  68         for (i = 0; i < NUM_BUCKETS; i++)
  69                 INIT_LIST_HEAD(buckets + i);
  70 }
  71
  72 static int dm_hash_init(void)
  73 {
  74         init_buckets(_name_buckets);
  75         init_buckets(_uuid_buckets);
  76         return 0;
  77 }
  78
  79 static void dm_hash_exit(void)
  80 {
  81         dm_hash_remove_all(0);
  82 }
  83
  84 /*-----------------------------------------------------------------
  85  * Hash function:
  86  * We're not really concerned with the str hash function being
  87  * fast since it's only used by the ioctl interface.
  88  *---------------------------------------------------------------*/
  89 static unsigned int hash_str(const char *str)
  90 {
  91         const unsigned int hash_mult = 2654435387U;
  92         unsigned int h = 0;
  93
  94         while (*str)
  95                 h = (h + (unsigned int) *str++) * hash_mult;
  96
  97         return h & MASK_BUCKETS;
  98 }
  99
 100 /*-----------------------------------------------------------------
 101  * Code for looking up a device by name
 102  *---------------------------------------------------------------*/
 103 static struct hash_cell *__get_name_cell(const char *str)
 104 {
 105         struct hash_cell *hc;
 106         unsigned int h = hash_str(str);
 107
 108         list_for_each_entry (hc, _name_buckets + h, name_list)
 109                 if (!strcmp(hc->name, str)) {
 110                         dm_get(hc->md);
 111                         return hc;
 112                 }
 113
 114         return NULL;
 115 }
 116
 117 static struct hash_cell *__get_uuid_cell(const char *str)
 118 {
 119         struct hash_cell *hc;
 120         unsigned int h = hash_str(str);
 121
 122         list_for_each_entry (hc, _uuid_buckets + h, uuid_list)
 123                 if (!strcmp(hc->uuid, str)) {
 124                         dm_get(hc->md);
 125                         return hc;
 126                 }
 127
 128         return NULL;
 129 }
 130
 131 /*-----------------------------------------------------------------
 132  * Inserting, removing and renaming a device.
 133  *---------------------------------------------------------------*/
 134 static struct hash_cell *alloc_cell(const char *name, const char *uuid,
 135                                     struct mapped_device *md)
 136 {
 137         struct hash_cell *hc;
 138
 139         hc = kmalloc(sizeof(*hc), GFP_KERNEL);
 140         if (!hc)
 141                 return NULL;
 142
 143         hc->name = kstrdup(name, GFP_KERNEL);
 144         if (!hc->name) {
 145                 kfree(hc);
 146                 return NULL;
 147         }
 148
 149         if (!uuid)
 150                 hc->uuid = NULL;
 151
 152         else {
 153                 hc->uuid = kstrdup(uuid, GFP_KERNEL);
 154                 if (!hc->uuid) {
 155                         kfree(hc->name);
 156                         kfree(hc);
 157                         return NULL;
 158                 }
 159         }
 160
 161         INIT_LIST_HEAD(&hc->name_list);
 162         INIT_LIST_HEAD(&hc->uuid_list);
 163         hc->md = md;
 164         hc->new_map = NULL;
 165         return hc;
 166 }
 167
 168 static void free_cell(struct hash_cell *hc)
 169 {
 170         if (hc) {
 171                 kfree(hc->name);
 172                 kfree(hc->uuid);
 173                 kfree(hc);
 174         }
 175 }
 176
 177 /*
 178  * The kdev_t and uuid of a device can never change once it is
 179  * initially inserted.
 180  */
 181 static int dm_hash_insert(const char *name, const char *uuid, struct mapped_device *md)
 182 {
 183         struct hash_cell *cell, *hc;
 184
 185         /*
 186          * Allocate the new cells.
 187          */
 188         cell = alloc_cell(name, uuid, md);
 189         if (!cell)
 190                 return -ENOMEM;
 191
 192         /*
 193          * Insert the cell into both hash tables.
 194          */
 195         down_write(&_hash_lock);
 196         hc = __get_name_cell(name);
 197         if (hc) {
 198                 dm_put(hc->md);
 199                 goto bad;
 200         }
 201
 202         list_add(&cell->name_list, _name_buckets + hash_str(name));
 203
 204         if (uuid) {
 205                 hc = __get_uuid_cell(uuid);
 206                 if (hc) {
 207                         list_del(&cell->name_list);
 208                         dm_put(hc->md);
 209                         goto bad;
 210                 }
 211                 list_add(&cell->uuid_list, _uuid_buckets + hash_str(uuid));
 212         }
 213         dm_get(md);
 214         mutex_lock(&dm_hash_cells_mutex);
 215         dm_set_mdptr(md, cell);
 216         mutex_unlock(&dm_hash_cells_mutex);
 217         up_write(&_hash_lock);
 218
 219         return 0;
 220
 221  bad:
 222         up_write(&_hash_lock);
 223         free_cell(cell);
 224         return -EBUSY;
 225 }
 226
 227 static void __hash_remove(struct hash_cell *hc)
 228 {
 229         struct dm_table *table;
 230
 231         /* remove from the dev hash */
 232         list_del(&hc->uuid_list);
 233         list_del(&hc->name_list);
 234         mutex_lock(&dm_hash_cells_mutex);
 235         dm_set_mdptr(hc->md, NULL);
 236         mutex_unlock(&dm_hash_cells_mutex);
 237
 238         table = dm_get_table(hc->md);
 239         if (table) {
 240                 dm_table_event(table);
 241                 dm_table_put(table);
 242         }
 243
 244         if (hc->new_map)
 245                 dm_table_destroy(hc->new_map);
 246         dm_put(hc->md);
 247         free_cell(hc);
 248 }
 249
 250 static void dm_hash_remove_all(int keep_open_devices)
 251 {
 252         int i, dev_skipped, dev_removed;
 253         struct hash_cell *hc;
 254         struct list_head *tmp, *n;
 255
 256         down_write(&_hash_lock);
 257
 258 retry:
 259         dev_skipped = dev_removed = 0;
 260         for (i = 0; i < NUM_BUCKETS; i++) {
 261                 list_for_each_safe (tmp, n, _name_buckets + i) {
 262                         hc = list_entry(tmp, struct hash_cell, name_list);
 263
 264                         if (keep_open_devices &&
 265                             dm_lock_for_deletion(hc->md)) {
 266                                 dev_skipped++;
 267                                 continue;
 268                         }
 269                         __hash_remove(hc);
 270                         dev_removed = 1;
 271                 }
 272         }
 273
 274         /*
 275          * Some mapped devices may be using other mapped devices, so if any
 276          * still exist, repeat until we make no further progress.
 277          */
 278         if (dev_skipped) {
 279                 if (dev_removed)
 280                         goto retry;
 281
 282                 DMWARN("remove_all left %d open device(s)", dev_skipped);
 283         }
 284
 285         up_write(&_hash_lock);
 286 }
 287
 288 static int dm_hash_rename(uint32_t cookie, const char *old, const char *new)
 289 {
 290         char *new_name, *old_name;
 291         struct hash_cell *hc;
 292         struct dm_table *table;
 293
 294         /*
 295          * duplicate new.
 296          */
 297         new_name = kstrdup(new, GFP_KERNEL);
 298         if (!new_name)
 299                 return -ENOMEM;
 300
 301         down_write(&_hash_lock);
 302
 303         /*
 304          * Is new free ?
 305          */
 306         hc = __get_name_cell(new);
 307         if (hc) {
 308                 DMWARN("asked to rename to an already existing name %s -> %s",
 309                        old, new);
 310                 dm_put(hc->md);
 311                 up_write(&_hash_lock);
 312                 kfree(new_name);
 313                 return -EBUSY;
 314         }
 315
 316         /*
 317          * Is there such a device as 'old' ?
 318          */
 319         hc = __get_name_cell(old);
 320         if (!hc) {
 321                 DMWARN("asked to rename a non existent device %s -> %s",
 322                        old, new);
 323                 up_write(&_hash_lock);
 324                 kfree(new_name);
 325                 return -ENXIO;
 326         }
 327
 328         /*
 329          * rename and move the name cell.
 330          */
 331         list_del(&hc->name_list);
 332         old_name = hc->name;
 333         mutex_lock(&dm_hash_cells_mutex);
 334         hc->name = new_name;
 335         mutex_unlock(&dm_hash_cells_mutex);
 336         list_add(&hc->name_list, _name_buckets + hash_str(new_name));
 337
 338         /*
 339          * Wake up any dm event waiters.
 340          */
 341         table = dm_get_table(hc->md);
 342         if (table) {
 343                 dm_table_event(table);
 344                 dm_table_put(table);
 345         }
 346
 347         dm_kobject_uevent(hc->md, KOBJ_CHANGE, cookie);
 348
 349         dm_put(hc->md);
 350         up_write(&_hash_lock);
 351         kfree(old_name);
 352         return 0;
 353 }
 354
 355 /*-----------------------------------------------------------------
 356  * Implementation of the ioctl commands
 357  *---------------------------------------------------------------*/
 358 /*
 359  * All the ioctl commands get dispatched to functions with this
 360  * prototype.
 361  */
 362 typedef int (*ioctl_fn)(struct dm_ioctl *param, size_t param_size);
 363
 364 static int remove_all(struct dm_ioctl *param, size_t param_size)
 365 {
 366         dm_hash_remove_all(1);
 367         param->data_size = 0;
 368         return 0;
 369 }
 370
 371 /*
 372  * Round up the ptr to an 8-byte boundary.
 373  */
 374 #define ALIGN_MASK 7
 375 static inline void *align_ptr(void *ptr)
 376 {
 377         return (void *) (((size_t) (ptr + ALIGN_MASK)) & ~ALIGN_MASK);
 378 }
 379
 380 /*
 381  * Retrieves the data payload buffer from an already allocated
 382  * struct dm_ioctl.
 383  */
 384 static void *get_result_buffer(struct dm_ioctl *param, size_t param_size,
 385                                size_t *len)
 386 {
 387         param->data_start = align_ptr(param + 1) - (void *) param;
 388
 389         if (param->data_start < param_size)
 390                 *len = param_size - param->data_start;
 391         else
 392                 *len = 0;
 393
 394         return ((void *) param) + param->data_start;
 395 }
 396
 397 static int list_devices(struct dm_ioctl *param, size_t param_size)
 398 {
 399         unsigned int i;
 400         struct hash_cell *hc;
 401         size_t len, needed = 0;
 402         struct gendisk *disk;
 403         struct dm_name_list *nl, *old_nl = NULL;
 404
 405         down_write(&_hash_lock);
 406
 407         /*
 408          * Loop through all the devices working out how much
 409          * space we need.
 410          */
 411         for (i = 0; i < NUM_BUCKETS; i++) {
 412                 list_for_each_entry (hc, _name_buckets + i, name_list) {
 413                         needed += sizeof(struct dm_name_list);
 414                         needed += strlen(hc->name) + 1;
 415                         needed += ALIGN_MASK;
 416                 }
 417         }
 418
 419         /*
 420          * Grab our output buffer.
 421          */
 422         nl = get_result_buffer(param, param_size, &len);
 423         if (len < needed) {
 424                 param->flags |= DM_BUFFER_FULL_FLAG;
 425                 goto out;
 426         }
 427         param->data_size = param->data_start + needed;
 428
 429         nl->dev = 0;    /* Flags no data */
 430
 431         /*
 432          * Now loop through filling out the names.
 433          */
 434         for (i = 0; i < NUM_BUCKETS; i++) {
 435                 list_for_each_entry (hc, _name_buckets + i, name_list) {
 436                         if (old_nl)
 437                                 old_nl->next = (uint32_t) ((void *) nl -
 438                                                            (void *) old_nl);
 439                         disk = dm_disk(hc->md);
 440                         nl->dev = huge_encode_dev(disk_devt(disk));
 441                         nl->next = 0;
 442                         strcpy(nl->name, hc->name);
 443
 444                         old_nl = nl;
 445                         nl = align_ptr(((void *) ++nl) + strlen(hc->name) + 1);
 446                 }
 447         }
 448
 449  out:
 450         up_write(&_hash_lock);
 451         return 0;
 452 }
 453
 454 static void list_version_get_needed(struct target_type *tt, void *needed_param)
 455 {
 456     size_t *needed = needed_param;
 457
 458     *needed += sizeof(struct dm_target_versions);
 459     *needed += strlen(tt->name);
 460     *needed += ALIGN_MASK;
 461 }
 462
 463 static void list_version_get_info(struct target_type *tt, void *param)
 464 {
 465     struct vers_iter *info = param;
 466
 467     /* Check space - it might have changed since the first iteration */
 468     if ((char *)info->vers + sizeof(tt->version) + strlen(tt->name) + 1 >
 469         info->end) {
 470
 471         info->flags = DM_BUFFER_FULL_FLAG;
 472         return;
 473     }
 474
 475     if (info->old_vers)
 476         info->old_vers->next = (uint32_t) ((void *)info->vers -
 477                                            (void *)info->old_vers);
 478     info->vers->version[0] = tt->version[0];
 479     info->vers->version[1] = tt->version[1];
 480     info->vers->version[2] = tt->version[2];
 481     info->vers->next = 0;
 482     strcpy(info->vers->name, tt->name);
 483
 484     info->old_vers = info->vers;
 485     info->vers = align_ptr(((void *) ++info->vers) + strlen(tt->name) + 1);
 486 }
 487
 488 static int list_versions(struct dm_ioctl *param, size_t param_size)
 489 {
 490         size_t len, needed = 0;
 491         struct dm_target_versions *vers;
 492         struct vers_iter iter_info;
 493
 494         /*
 495          * Loop through all the devices working out how much
 496          * space we need.
 497          */
 498         dm_target_iterate(list_version_get_needed, &needed);
 499
 500         /*
 501          * Grab our output buffer.
 502          */
 503         vers = get_result_buffer(param, param_size, &len);
 504         if (len < needed) {
 505                 param->flags |= DM_BUFFER_FULL_FLAG;
 506                 goto out;
 507         }
 508         param->data_size = param->data_start + needed;
 509
 510         iter_info.param_size = param_size;
 511         iter_info.old_vers = NULL;
 512         iter_info.vers = vers;
 513         iter_info.flags = 0;
 514         iter_info.end = (char *)vers+len;
 515
 516         /*
 517          * Now loop through filling out the names & versions.
 518          */
 519         dm_target_iterate(list_version_get_info, &iter_info);
 520         param->flags |= iter_info.flags;
 521
 522  out:
 523         return 0;
 524 }
 525
 526
 527
 528 static int check_name(const char *name)
 529 {
 530         if (strchr(name, '/')) {
 531                 DMWARN("invalid device name");
 532                 return -EINVAL;
 533         }
 534
 535         return 0;
 536 }
 537
 538 /*
 539  * Fills in a dm_ioctl structure, ready for sending back to
 540  * userland.
 541  */
 542 static int __dev_status(struct mapped_device *md, struct dm_ioctl *param)
 543 {
 544         struct gendisk *disk = dm_disk(md);
 545         struct dm_table *table;
 546
 547         param->flags &= ~(DM_SUSPEND_FLAG | DM_READONLY_FLAG |
 548                           DM_ACTIVE_PRESENT_FLAG);
 549
 550         if (dm_suspended(md))
 551                 param->flags |= DM_SUSPEND_FLAG;
 552
 553         param->dev = huge_encode_dev(disk_devt(disk));
 554
 555         /*
 556          * Yes, this will be out of date by the time it gets back
 557          * to userland, but it is still very useful for
 558          * debugging.
 559          */
 560         param->open_count = dm_open_count(md);
 561
 562         if (get_disk_ro(disk))
 563                 param->flags |= DM_READONLY_FLAG;
 564
 565         param->event_nr = dm_get_event_nr(md);
 566
 567         table = dm_get_table(md);
 568         if (table) {
 569                 param->flags |= DM_ACTIVE_PRESENT_FLAG;
 570                 param->target_count = dm_table_get_num_targets(table);
 571                 dm_table_put(table);
 572         } else
 573                 param->target_count = 0;
 574
 575         return 0;
 576 }
 577
 578 static int dev_create(struct dm_ioctl *param, size_t param_size)
 579 {
 580         int r, m = DM_ANY_MINOR;
 581         struct mapped_device *md;
 582
 583         r = check_name(param->name);
 584         if (r)
 585                 return r;
 586
 587         if (param->flags & DM_PERSISTENT_DEV_FLAG)
 588                 m = MINOR(huge_decode_dev(param->dev));
 589
 590         r = dm_create(m, &md);
 591         if (r)
 592                 return r;
 593
 594         r = dm_hash_insert(param->name, *param->uuid ? param->uuid : NULL, md);
 595         if (r) {
 596                 dm_put(md);
 597                 return r;
 598         }
 599
 600         param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
 601
 602         r = __dev_status(md, param);
 603         dm_put(md);
 604
 605         return r;
 606 }
 607
 608 /*
 609  * Always use UUID for lookups if it's present, otherwise use name or dev.
 610  */
 611 static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
 612 {
 613         struct mapped_device *md;
 614         void *mdptr = NULL;
 615
 616         if (*param->uuid)
 617                 return __get_uuid_cell(param->uuid);
 618
 619         if (*param->name)
 620                 return __get_name_cell(param->name);
 621
 622         md = dm_get_md(huge_decode_dev(param->dev));
 623         if (!md)
 624                 goto out;
 625
 626         mdptr = dm_get_mdptr(md);
 627         if (!mdptr)
 628                 dm_put(md);
 629
 630 out:
 631         return mdptr;
 632 }
 633
 634 static struct mapped_device *find_device(struct dm_ioctl *param)
 635 {
 636         struct hash_cell *hc;
 637         struct mapped_device *md = NULL;
 638
 639         down_read(&_hash_lock);
 640         hc = __find_device_hash_cell(param);
 641         if (hc) {
 642                 md = hc->md;
 643
 644                 /*
 645                  * Sneakily write in both the name and the uuid
 646                  * while we have the cell.
 647                  */
 648                 strncpy(param->name, hc->name, sizeof(param->name));
 649                 if (hc->uuid)
 650                         strncpy(param->uuid, hc->uuid, sizeof(param->uuid)-1);
 651                 else
 652                         param->uuid[0] = '\0';
 653
 654                 if (hc->new_map)
 655                         param->flags |= DM_INACTIVE_PRESENT_FLAG;
 656                 else
 657                         param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
 658         }
 659         up_read(&_hash_lock);
 660
 661         return md;
 662 }
 663
 664 static int dev_remove(struct dm_ioctl *param, size_t param_size)
 665 {
 666         struct hash_cell *hc;
 667         struct mapped_device *md;
 668         int r;
 669
 670         down_write(&_hash_lock);
 671         hc = __find_device_hash_cell(param);
 672
 673         if (!hc) {
 674                 DMWARN("device doesn't appear to be in the dev hash table.");
 675                 up_write(&_hash_lock);
 676                 return -ENXIO;
 677         }
 678
 679         md = hc->md;
 680
 681         /*
 682          * Ensure the device is not open and nothing further can open it.
 683          */
 684         r = dm_lock_for_deletion(md);
 685         if (r) {
 686                 DMWARN("unable to remove open device %s", hc->name);
 687                 up_write(&_hash_lock);
 688                 dm_put(md);
 689                 return r;
 690         }
 691
 692         __hash_remove(hc);
 693         up_write(&_hash_lock);
 694
 695         dm_kobject_uevent(md, KOBJ_REMOVE, param->event_nr);
 696
 697         dm_put(md);
 698         param->data_size = 0;
 699         return 0;
 700 }
 701
 702 /*
 703  * Check a string doesn't overrun the chunk of
 704  * memory we copied from userland.
 705  */
 706 static int invalid_str(char *str, void *end)
 707 {
 708         while ((void *) str < end)
 709                 if (!*str++)
 710                         return 0;
 711
 712         return -EINVAL;
 713 }
 714
 715 static int dev_rename(struct dm_ioctl *param, size_t param_size)
 716 {
 717         int r;
 718         char *new_name = (char *) param + param->data_start;
 719
 720         if (new_name < param->data ||
 721             invalid_str(new_name, (void *) param + param_size) ||
 722             strlen(new_name) > DM_NAME_LEN - 1) {
 723                 DMWARN("Invalid new logical volume name supplied.");
 724                 return -EINVAL;
 725         }
 726
 727         r = check_name(new_name);
 728         if (r)
 729                 return r;
 730
 731         param->data_size = 0;
 732         return dm_hash_rename(param->event_nr, param->name, new_name);
 733 }
 734
 735 static int dev_set_geometry(struct dm_ioctl *param, size_t param_size)
 736 {
 737         int r = -EINVAL, x;
 738         struct mapped_device *md;
 739         struct hd_geometry geometry;
 740         unsigned long indata[4];
 741         char *geostr = (char *) param + param->data_start;
 742
 743         md = find_device(param);
 744         if (!md)
 745                 return -ENXIO;
 746
 747         if (geostr < param->data ||
 748             invalid_str(geostr, (void *) param + param_size)) {
 749                 DMWARN("Invalid geometry supplied.");
 750                 goto out;
 751         }
 752
 753         x = sscanf(geostr, "%lu %lu %lu %lu", indata,
 754                    indata + 1, indata + 2, indata + 3);
 755
 756         if (x != 4) {
 757                 DMWARN("Unable to interpret geometry settings.");
 758                 goto out;
 759         }
 760
 761         if (indata[0] > 65535 || indata[1] > 255 ||
 762             indata[2] > 255 || indata[3] > ULONG_MAX) {
 763                 DMWARN("Geometry exceeds range limits.");
 764                 goto out;
 765         }
 766
 767         geometry.cylinders = indata[0];
 768         geometry.heads = indata[1];
 769         geometry.sectors = indata[2];
 770         geometry.start = indata[3];
 771
 772         r = dm_set_geometry(md, &geometry);
 773         if (!r)
 774                 r = __dev_status(md, param);
 775
 776         param->data_size = 0;
 777
 778 out:
 779         dm_put(md);
 780         return r;
 781 }
 782
 783 static int do_suspend(struct dm_ioctl *param)
 784 {
 785         int r = 0;
 786         unsigned suspend_flags = DM_SUSPEND_LOCKFS_FLAG;
 787         struct mapped_device *md;
 788
 789         md = find_device(param);
 790         if (!md)
 791                 return -ENXIO;
 792
 793         if (param->flags & DM_SKIP_LOCKFS_FLAG)
 794                 suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG;
 795         if (param->flags & DM_NOFLUSH_FLAG)
 796                 suspend_flags |= DM_SUSPEND_NOFLUSH_FLAG;
 797
 798         if (!dm_suspended(md))
 799                 r = dm_suspend(md, suspend_flags);
 800
 801         if (!r)
 802                 r = __dev_status(md, param);
 803
 804         dm_put(md);
 805         return r;
 806 }
 807
 808 static int do_resume(struct dm_ioctl *param)
 809 {
 810         int r = 0;
 811         unsigned suspend_flags = DM_SUSPEND_LOCKFS_FLAG;
 812         struct hash_cell *hc;
 813         struct mapped_device *md;
 814         struct dm_table *new_map;
 815
 816         down_write(&_hash_lock);
 817
 818         hc = __find_device_hash_cell(param);
 819         if (!hc) {
 820                 DMWARN("device doesn't appear to be in the dev hash table.");
 821                 up_write(&_hash_lock);
 822                 return -ENXIO;
 823         }
 824
 825         md = hc->md;
 826
 827         new_map = hc->new_map;
 828         hc->new_map = NULL;
 829         param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
 830
 831         up_write(&_hash_lock);
 832
 833         /* Do we need to load a new map ? */
 834         if (new_map) {
 835                 /* Suspend if it isn't already suspended */
 836                 if (param->flags & DM_SKIP_LOCKFS_FLAG)
 837                         suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG;
 838                 if (param->flags & DM_NOFLUSH_FLAG)
 839                         suspend_flags |= DM_SUSPEND_NOFLUSH_FLAG;
 840                 if (!dm_suspended(md))
 841                         dm_suspend(md, suspend_flags);
 842
 843                 r = dm_swap_table(md, new_map);
 844                 if (r) {
 845                         dm_table_destroy(new_map);
 846                         dm_put(md);
 847                         return r;
 848                 }
 849
 850                 if (dm_table_get_mode(new_map) & FMODE_WRITE)
 851                         set_disk_ro(dm_disk(md), 0);
 852                 else
 853                         set_disk_ro(dm_disk(md), 1);
 854         }
 855
 856         if (dm_suspended(md))
 857                 r = dm_resume(md);
 858
 859
 860         if (!r) {
 861                 dm_kobject_uevent(md, KOBJ_CHANGE, param->event_nr);
 862                 r = __dev_status(md, param);
 863         }
 864
 865         dm_put(md);
 866         return r;
 867 }
 868
 869 /*
 870  * Set or unset the suspension state of a device.
 871  * If the device already is in the requested state we just return its status.
 872  */
 873 static int dev_suspend(struct dm_ioctl *param, size_t param_size)
 874 {
 875         if (param->flags & DM_SUSPEND_FLAG)
 876                 return do_suspend(param);
 877
 878         return do_resume(param);
 879 }
 880
 881 /*
 882  * Copies device info back to user space, used by
 883  * the create and info ioctls.
 884  */
 885 static int dev_status(struct dm_ioctl *param, size_t param_size)
 886 {
 887         int r;
 888         struct mapped_device *md;
 889
 890         md = find_device(param);
 891         if (!md)
 892                 return -ENXIO;
 893
 894         r = __dev_status(md, param);
 895         dm_put(md);
 896         return r;
 897 }
 898
 899 /*
 900  * Build up the status struct for each target
 901  */
 902 static void retrieve_status(struct dm_table *table,
 903                             struct dm_ioctl *param, size_t param_size)
 904 {
 905         unsigned int i, num_targets;
 906         struct dm_target_spec *spec;
 907         char *outbuf, *outptr;
 908         status_type_t type;
 909         size_t remaining, len, used = 0;
 910
 911         outptr = outbuf = get_result_buffer(param, param_size, &len);
 912
 913         if (param->flags & DM_STATUS_TABLE_FLAG)
 914                 type = STATUSTYPE_TABLE;
 915         else
 916                 type = STATUSTYPE_INFO;
 917
 918         /* Get all the target info */
 919         num_targets = dm_table_get_num_targets(table);
 920         for (i = 0; i < num_targets; i++) {
 921                 struct dm_target *ti = dm_table_get_target(table, i);
 922
 923                 remaining = len - (outptr - outbuf);
 924                 if (remaining <= sizeof(struct dm_target_spec)) {
 925                         param->flags |= DM_BUFFER_FULL_FLAG;
 926                         break;
 927                 }
 928
 929                 spec = (struct dm_target_spec *) outptr;
 930
 931                 spec->status = 0;
 932                 spec->sector_start = ti->begin;
 933                 spec->length = ti->len;
 934                 strncpy(spec->target_type, ti->type->name,
 935                         sizeof(spec->target_type));
 936
 937                 outptr += sizeof(struct dm_target_spec);
 938                 remaining = len - (outptr - outbuf);
 939                 if (remaining <= 0) {
 940                         param->flags |= DM_BUFFER_FULL_FLAG;
 941                         break;
 942                 }
 943
 944                 /* Get the status/table string from the target driver */
 945                 if (ti->type->status) {
 946                         if (ti->type->status(ti, type, outptr, remaining)) {
 947                                 param->flags |= DM_BUFFER_FULL_FLAG;
 948                                 break;
 949                         }
 950                 } else
 951                         outptr[0] = '\0';
 952
 953                 outptr += strlen(outptr) + 1;
 954                 used = param->data_start + (outptr - outbuf);
 955
 956                 outptr = align_ptr(outptr);
 957                 spec->next = outptr - outbuf;
 958         }
 959
 960         if (used)
 961                 param->data_size = used;
 962
 963         param->target_count = num_targets;
 964 }
 965
 966 /*
 967  * Wait for a device to report an event
 968  */
 969 static int dev_wait(struct dm_ioctl *param, size_t param_size)
 970 {
 971         int r;
 972         struct mapped_device *md;
 973         struct dm_table *table;
 974
 975         md = find_device(param);
 976         if (!md)
 977                 return -ENXIO;
 978
 979         /*
 980          * Wait for a notification event
 981          */
 982         if (dm_wait_event(md, param->event_nr)) {
 983                 r = -ERESTARTSYS;
 984                 goto out;
 985         }
 986
 987         /*
 988          * The userland program is going to want to know what
 989          * changed to trigger the event, so we may as well tell
 990          * him and save an ioctl.
 991          */
 992         r = __dev_status(md, param);
 993         if (r)
 994                 goto out;
 995
 996         table = dm_get_table(md);
 997         if (table) {
 998                 retrieve_status(table, param, param_size);
 999                 dm_table_put(table);
1000         }
1001
1002  out:
1003         dm_put(md);
1004         return r;
1005 }
1006
1007 static inline fmode_t get_mode(struct dm_ioctl *param)
1008 {
1009         fmode_t mode = FMODE_READ | FMODE_WRITE;
1010
1011         if (param->flags & DM_READONLY_FLAG)
1012                 mode = FMODE_READ;
1013
1014         return mode;
1015 }
1016
1017 static int next_target(struct dm_target_spec *last, uint32_t next, void *end,
1018                        struct dm_target_spec **spec, char **target_params)
1019 {
1020         *spec = (struct dm_target_spec *) ((unsigned char *) last + next);
1021         *target_params = (char *) (*spec + 1);
1022
1023         if (*spec < (last + 1))
1024                 return -EINVAL;
1025
1026         return invalid_str(*target_params, end);
1027 }
1028
1029 static int populate_table(struct dm_table *table,
1030                           struct dm_ioctl *param, size_t param_size)
1031 {
1032         int r;
1033         unsigned int i = 0;
1034         struct dm_target_spec *spec = (struct dm_target_spec *) param;
1035         uint32_t next = param->data_start;
1036         void *end = (void *) param + param_size;
1037         char *target_params;
1038
1039         if (!param->target_count) {
1040                 DMWARN("populate_table: no targets specified");
1041                 return -EINVAL;
1042         }
1043
1044         for (i = 0; i < param->target_count; i++) {
1045
1046                 r = next_target(spec, next, end, &spec, &target_params);
1047                 if (r) {
1048                         DMWARN("unable to find target");
1049                         return r;
1050                 }
1051
1052                 r = dm_table_add_target(table, spec->target_type,
1053                                         (sector_t) spec->sector_start,
1054                                         (sector_t) spec->length,
1055                                         target_params);
1056                 if (r) {
1057                         DMWARN("error adding target to table");
1058                         return r;
1059                 }
1060
1061                 next = spec->next;
1062         }
1063
1064         r = dm_table_set_type(table);
1065         if (r) {
1066                 DMWARN("unable to set table type");
1067                 return r;
1068         }
1069
1070         return dm_table_complete(table);
1071 }
1072
1073 static int table_prealloc_integrity(struct dm_table *t,
1074                                     struct mapped_device *md)
1075 {
1076         struct list_head *devices = dm_table_get_devices(t);
1077         struct dm_dev_internal *dd;
1078
1079         list_for_each_entry(dd, devices, list)
1080                 if (bdev_get_integrity(dd->dm_dev.bdev))
1081                         return blk_integrity_register(dm_disk(md), NULL);
1082
1083         return 0;
1084 }
1085
1086 static int table_load(struct dm_ioctl *param, size_t param_size)
1087 {
1088         int r;
1089         struct hash_cell *hc;
1090         struct dm_table *t;
1091         struct mapped_device *md;
1092
1093         md = find_device(param);
1094         if (!md)
1095                 return -ENXIO;
1096
1097         r = dm_table_create(&t, get_mode(param), param->target_count, md);
1098         if (r)
1099                 goto out;
1100
1101         r = populate_table(t, param, param_size);
1102         if (r) {
1103                 dm_table_destroy(t);
1104                 goto out;
1105         }
1106
1107         r = table_prealloc_integrity(t, md);
1108         if (r) {
1109                 DMERR("%s: could not register integrity profile.",
1110                       dm_device_name(md));
1111                 dm_table_destroy(t);
1112                 goto out;
1113         }
1114
1115         r = dm_table_alloc_md_mempools(t);
1116         if (r) {
1117                 DMWARN("unable to allocate mempools for this table");
1118                 dm_table_destroy(t);
1119                 goto out;
1120         }
1121
1122         down_write(&_hash_lock);
1123         hc = dm_get_mdptr(md);
1124         if (!hc || hc->md != md) {
1125                 DMWARN("device has been removed from the dev hash table.");
1126                 dm_table_destroy(t);
1127                 up_write(&_hash_lock);
1128                 r = -ENXIO;
1129                 goto out;
1130         }
1131
1132         if (hc->new_map)
1133                 dm_table_destroy(hc->new_map);
1134         hc->new_map = t;
1135         up_write(&_hash_lock);
1136
1137         param->flags |= DM_INACTIVE_PRESENT_FLAG;
1138         r = __dev_status(md, param);
1139
1140 out:
1141         dm_put(md);
1142
1143         return r;
1144 }
1145
1146 static int table_clear(struct dm_ioctl *param, size_t param_size)
1147 {
1148         int r;
1149         struct hash_cell *hc;
1150         struct mapped_device *md;
1151
1152         down_write(&_hash_lock);
1153
1154         hc = __find_device_hash_cell(param);
1155         if (!hc) {
1156                 DMWARN("device doesn't appear to be in the dev hash table.");
1157                 up_write(&_hash_lock);
1158                 return -ENXIO;
1159         }
1160
1161         if (hc->new_map) {
1162                 dm_table_destroy(hc->new_map);
1163                 hc->new_map = NULL;
1164         }
1165
1166         param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
1167
1168         r = __dev_status(hc->md, param);
1169         md = hc->md;
1170         up_write(&_hash_lock);
1171         dm_put(md);
1172         return r;
1173 }
1174
1175 /*
1176  * Retrieves a list of devices used by a particular dm device.
1177  */
1178 static void retrieve_deps(struct dm_table *table,
1179                           struct dm_ioctl *param, size_t param_size)
1180 {
1181         unsigned int count = 0;
1182         struct list_head *tmp;
1183         size_t len, needed;
1184         struct dm_dev_internal *dd;
1185         struct dm_target_deps *deps;
1186
1187         deps = get_result_buffer(param, param_size, &len);
1188
1189         /*
1190          * Count the devices.
1191          */
1192         list_for_each (tmp, dm_table_get_devices(table))
1193                 count++;
1194
1195         /*
1196          * Check we have enough space.
1197          */
1198         needed = sizeof(*deps) + (sizeof(*deps->dev) * count);
1199         if (len < needed) {
1200                 param->flags |= DM_BUFFER_FULL_FLAG;
1201                 return;
1202         }
1203
1204         /*
1205          * Fill in the devices.
1206          */
1207         deps->count = count;
1208         count = 0;
1209         list_for_each_entry (dd, dm_table_get_devices(table), list)
1210                 deps->dev[count++] = huge_encode_dev(dd->dm_dev.bdev->bd_dev);
1211
1212         param->data_size = param->data_start + needed;
1213 }
1214
1215 static int table_deps(struct dm_ioctl *param, size_t param_size)
1216 {
1217         int r = 0;
1218         struct mapped_device *md;
1219         struct dm_table *table;
1220
1221         md = find_device(param);
1222         if (!md)
1223                 return -ENXIO;
1224
1225         r = __dev_status(md, param);
1226         if (r)
1227                 goto out;
1228
1229         table = dm_get_table(md);
1230         if (table) {
1231                 retrieve_deps(table, param, param_size);
1232                 dm_table_put(table);
1233         }
1234
1235  out:
1236         dm_put(md);
1237         return r;
1238 }
1239
1240 /*
1241  * Return the status of a device as a text string for each
1242  * target.
1243  */
1244 static int table_status(struct dm_ioctl *param, size_t param_size)
1245 {
1246         int r;
1247         struct mapped_device *md;
1248         struct dm_table *table;
1249
1250         md = find_device(param);
1251         if (!md)
1252                 return -ENXIO;
1253
1254         r = __dev_status(md, param);
1255         if (r)
1256                 goto out;
1257
1258         table = dm_get_table(md);
1259         if (table) {
1260                 retrieve_status(table, param, param_size);
1261                 dm_table_put(table);
1262         }
1263
1264  out:
1265         dm_put(md);
1266         return r;
1267 }
1268
1269 /*
1270  * Pass a message to the target that's at the supplied device offset.
1271  */
1272 static int target_message(struct dm_ioctl *param, size_t param_size)
1273 {
1274         int r, argc;
1275         char **argv;
1276         struct mapped_device *md;
1277         struct dm_table *table;
1278         struct dm_target *ti;
1279         struct dm_target_msg *tmsg = (void *) param + param->data_start;
1280
1281         md = find_device(param);
1282         if (!md)
1283                 return -ENXIO;
1284
1285         r = __dev_status(md, param);
1286         if (r)
1287                 goto out;
1288
1289         if (tmsg < (struct dm_target_msg *) param->data ||
1290             invalid_str(tmsg->message, (void *) param + param_size)) {
1291                 DMWARN("Invalid target message parameters.");
1292                 r = -EINVAL;
1293                 goto out;
1294         }
1295
1296         r = dm_split_args(&argc, &argv, tmsg->message);
1297         if (r) {
1298                 DMWARN("Failed to split target message parameters");
1299                 goto out;
1300         }
1301
1302         table = dm_get_table(md);
1303         if (!table)
1304                 goto out_argv;
1305
1306         ti = dm_table_find_target(table, tmsg->sector);
1307         if (!dm_target_is_valid(ti)) {
1308                 DMWARN("Target message sector outside device.");
1309                 r = -EINVAL;
1310         } else if (ti->type->message)
1311                 r = ti->type->message(ti, argc, argv);
1312         else {
1313                 DMWARN("Target type does not support messages");
1314                 r = -EINVAL;
1315         }
1316
1317         dm_table_put(table);
1318  out_argv:
1319         kfree(argv);
1320  out:
1321         param->data_size = 0;
1322         dm_put(md);
1323         return r;
1324 }
1325
1326 /*-----------------------------------------------------------------
1327  * Implementation of open/close/ioctl on the special char
1328  * device.
1329  *---------------------------------------------------------------*/
1330 static ioctl_fn lookup_ioctl(unsigned int cmd)
1331 {
1332         static struct {
1333                 int cmd;
1334                 ioctl_fn fn;
1335         } _ioctls[] = {
1336                 {DM_VERSION_CMD, NULL}, /* version is dealt with elsewhere */
1337                 {DM_REMOVE_ALL_CMD, remove_all},
1338                 {DM_LIST_DEVICES_CMD, list_devices},
1339
1340                 {DM_DEV_CREATE_CMD, dev_create},
1341                 {DM_DEV_REMOVE_CMD, dev_remove},
1342                 {DM_DEV_RENAME_CMD, dev_rename},
1343                 {DM_DEV_SUSPEND_CMD, dev_suspend},
1344                 {DM_DEV_STATUS_CMD, dev_status},
1345                 {DM_DEV_WAIT_CMD, dev_wait},
1346
1347                 {DM_TABLE_LOAD_CMD, table_load},
1348                 {DM_TABLE_CLEAR_CMD, table_clear},
1349                 {DM_TABLE_DEPS_CMD, table_deps},
1350                 {DM_TABLE_STATUS_CMD, table_status},
1351
1352                 {DM_LIST_VERSIONS_CMD, list_versions},
1353
1354                 {DM_TARGET_MSG_CMD, target_message},
1355                 {DM_DEV_SET_GEOMETRY_CMD, dev_set_geometry}
1356         };
1357
1358         return (cmd >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[cmd].fn;
1359 }
1360
1361 /*
1362  * As well as checking the version compatibility this always
1363  * copies the kernel interface version out.
1364  */
1365 static int check_version(unsigned int cmd, struct dm_ioctl __user *user)
1366 {
1367         uint32_t version[3];
1368         int r = 0;
1369
1370         if (copy_from_user(version, user->version, sizeof(version)))
1371                 return -EFAULT;
1372
1373         if ((DM_VERSION_MAJOR != version[0]) ||
1374             (DM_VERSION_MINOR < version[1])) {
1375                 DMWARN("ioctl interface mismatch: "
1376                        "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)",
1377                        DM_VERSION_MAJOR, DM_VERSION_MINOR,
1378                        DM_VERSION_PATCHLEVEL,
1379                        version[0], version[1], version[2], cmd);
1380                 r = -EINVAL;
1381         }
1382
1383         /*
1384          * Fill in the kernel version.
1385          */
1386         version[0] = DM_VERSION_MAJOR;
1387         version[1] = DM_VERSION_MINOR;
1388         version[2] = DM_VERSION_PATCHLEVEL;
1389         if (copy_to_user(user->version, version, sizeof(version)))
1390                 return -EFAULT;
1391
1392         return r;
1393 }
1394
1395 static void free_params(struct dm_ioctl *param)
1396 {
1397         vfree(param);
1398 }
1399
1400 static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl **param)
1401 {
1402         struct dm_ioctl tmp, *dmi;
1403
1404         if (copy_from_user(&tmp, user, sizeof(tmp) - sizeof(tmp.data)))
1405                 return -EFAULT;
1406
1407         if (tmp.data_size < (sizeof(tmp) - sizeof(tmp.data)))
1408                 return -EINVAL;
1409
1410         dmi = vmalloc(tmp.data_size);
1411         if (!dmi)
1412                 return -ENOMEM;
1413
1414         if (copy_from_user(dmi, user, tmp.data_size)) {
1415                 vfree(dmi);
1416                 return -EFAULT;
1417         }
1418
1419         *param = dmi;
1420         return 0;
1421 }
1422
1423 static int validate_params(uint cmd, struct dm_ioctl *param)
1424 {
1425         /* Always clear this flag */
1426         param->flags &= ~DM_BUFFER_FULL_FLAG;
1427
1428         /* Ignores parameters */
1429         if (cmd == DM_REMOVE_ALL_CMD ||
1430             cmd == DM_LIST_DEVICES_CMD ||
1431             cmd == DM_LIST_VERSIONS_CMD)
1432                 return 0;
1433
1434         if ((cmd == DM_DEV_CREATE_CMD)) {
1435                 if (!*param->name) {
1436                         DMWARN("name not supplied when creating device");
1437                         return -EINVAL;
1438                 }
1439         } else if ((*param->uuid && *param->name)) {
1440                 DMWARN("only supply one of name or uuid, cmd(%u)", cmd);
1441                 return -EINVAL;
1442         }
1443
1444         /* Ensure strings are terminated */
1445         param->name[DM_NAME_LEN - 1] = '\0';
1446         param->uuid[DM_UUID_LEN - 1] = '\0';
1447
1448         return 0;
1449 }
1450
1451 static int ctl_ioctl(uint command, struct dm_ioctl __user *user)
1452 {
1453         int r = 0;
1454         unsigned int cmd;
1455         struct dm_ioctl *uninitialized_var(param);
1456         ioctl_fn fn = NULL;
1457         size_t param_size;
1458
1459         /* only root can play with this */
1460         if (!capable(CAP_SYS_ADMIN))
1461                 return -EACCES;
1462
1463         if (_IOC_TYPE(command) != DM_IOCTL)
1464                 return -ENOTTY;
1465
1466         cmd = _IOC_NR(command);
1467
1468         /*
1469          * Check the interface version passed in.  This also
1470          * writes out the kernel's interface version.
1471          */
1472         r = check_version(cmd, user);
1473         if (r)
1474                 return r;
1475
1476         /*
1477          * Nothing more to do for the version command.
1478          */
1479         if (cmd == DM_VERSION_CMD)
1480                 return 0;
1481
1482         fn = lookup_ioctl(cmd);
1483         if (!fn) {
1484                 DMWARN("dm_ctl_ioctl: unknown command 0x%x", command);
1485                 return -ENOTTY;
1486         }
1487
1488         /*
1489          * Trying to avoid low memory issues when a device is
1490          * suspended.
1491          */
1492         current->flags |= PF_MEMALLOC;
1493
1494         /*
1495          * Copy the parameters into kernel space.
1496          */
1497         r = copy_params(user, &param);
1498
1499         current->flags &= ~PF_MEMALLOC;
1500
1501         if (r)
1502                 return r;
1503
1504         r = validate_params(cmd, param);
1505         if (r)
1506                 goto out;
1507
1508         param_size = param->data_size;
1509         param->data_size = sizeof(*param);
1510         r = fn(param, param_size);
1511
1512         /*
1513          * Copy the results back to userland.
1514          */
1515         if (!r && copy_to_user(user, param, param->data_size))
1516                 r = -EFAULT;
1517
1518  out:
1519         free_params(param);
1520         return r;
1521 }
1522
1523 static long dm_ctl_ioctl(struct file *file, uint command, ulong u)
1524 {
1525         return (long)ctl_ioctl(command, (struct dm_ioctl __user *)u);
1526 }
1527
1528 #ifdef CONFIG_COMPAT
1529 static long dm_compat_ctl_ioctl(struct file *file, uint command, ulong u)
1530 {
1531         return (long)dm_ctl_ioctl(file, command, (ulong) compat_ptr(u));
1532 }
1533 #else
1534 #define dm_compat_ctl_ioctl NULL
1535 #endif
1536
1537 static const struct file_operations _ctl_fops = {
1538         .unlocked_ioctl  = dm_ctl_ioctl,
1539         .compat_ioctl = dm_compat_ctl_ioctl,
1540         .owner   = THIS_MODULE,
1541 };
1542
1543 static struct miscdevice _dm_misc = {
1544         .minor          = MISC_DYNAMIC_MINOR,
1545         .name           = DM_NAME,
1546         .nodename       = "mapper/control",
1547         .fops           = &_ctl_fops
1548 };
1549
1550 /*
1551  * Create misc character device and link to DM_DIR/control.
1552  */
1553 int __init dm_interface_init(void)
1554 {
1555         int r;
1556
1557         r = dm_hash_init();
1558         if (r)
1559                 return r;
1560
1561         r = misc_register(&_dm_misc);
1562         if (r) {
1563                 DMERR("misc_register failed for control device");
1564                 dm_hash_exit();
1565                 return r;
1566         }
1567
1568         DMINFO("%d.%d.%d%s initialised: %s", DM_VERSION_MAJOR,
1569                DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL, DM_VERSION_EXTRA,
1570                DM_DRIVER_EMAIL);
1571         return 0;
1572 }
1573
1574 void dm_interface_exit(void)
1575 {
1576         if (misc_deregister(&_dm_misc) < 0)
1577                 DMERR("misc_deregister failed for control device");
1578
1579         dm_hash_exit();
1580 }
1581
1582 /**
1583  * dm_copy_name_and_uuid - Copy mapped device name & uuid into supplied buffers
1584  * @md: Pointer to mapped_device
1585  * @name: Buffer (size DM_NAME_LEN) for name
1586  * @uuid: Buffer (size DM_UUID_LEN) for uuid or empty string if uuid not defined
1587  */
1588 int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid)
1589 {
1590         int r = 0;
1591         struct hash_cell *hc;
1592
1593         if (!md)
1594                 return -ENXIO;
1595
1596         mutex_lock(&dm_hash_cells_mutex);
1597         hc = dm_get_mdptr(md);
1598         if (!hc || hc->md != md) {
1599                 r = -ENXIO;
1600                 goto out;
1601         }
1602
1603         if (name)
1604                 strcpy(name, hc->name);
1605         if (uuid)
1606                 strcpy(uuid, hc->uuid ? : "");
1607
1608 out:
1609         mutex_unlock(&dm_hash_cells_mutex);
1610
1611         return r;
1612 }