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