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