1 /* $NetBSD: dm_ioctl.c,v 1.21 2010/02/25 20:48:58 jakllsch Exp $ */ 2 3 /* 4 * Copyright (c) 2010-2011 Alex Hornung <alex@alexhornung.com> 5 * Copyright (c) 2008 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Adam Hamsik. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Locking is used to synchronise between ioctl calls and between dm_table's 35 * users. 36 * 37 * ioctl locking: 38 * Simple reference counting, to count users of device will be used routines 39 * dm_dev_busy/dm_dev_unbusy are used for that. 40 * dm_dev_lookup/dm_dev_rem call dm_dev_busy before return(caller is therefore 41 * holder of reference_counter last). 42 * 43 * ioctl routines which change/remove dm_dev parameters must wait on 44 * dm_dev::dev_cv and when last user will call dm_dev_unbusy they will wake 45 * up them. 46 * 47 * table_head locking: 48 * To access table entries dm_table_* routines must be used. 49 * 50 * dm_table_get_entry will increment table users reference 51 * counter. It will return active or inactive table depends 52 * on uint8_t argument. 53 * 54 * dm_table_release must be called for every table_entry from 55 * dm_table_get_entry. Between these to calls tables can'tbe switched 56 * or destroyed. 57 * 58 * dm_table_head_init initialize talbe_entries TAILQS and io_cv. 59 * 60 * dm_table_head_destroy destroy cv. 61 * 62 * There are two types of users for dm_table_head first type will 63 * only read list and try to do anything with it e.g. dmstrategy, 64 * dm_table_size etc. There is another user for table_head which wants 65 * to change table lists e.g. dm_dev_resume_ioctl, dm_dev_remove_ioctl, 66 * dm_table_clear_ioctl. 67 * 68 * NOTE: It is not allowed to call dm_table_destroy, dm_table_switch_tables 69 * with hold table reference counter. Table reference counter is hold 70 * after calling dm_table_get_entry routine. After calling this 71 * function user must call dm_table_release before any writer table 72 * operation. 73 * 74 * Example: dm_table_get_entry 75 * dm_table_destroy/dm_table_switch_tables 76 * This exaple will lead to deadlock situation because after dm_table_get_entry 77 * table reference counter is != 0 and dm_table_destroy have to wait on cv until 78 * reference counter is 0. 79 * 80 */ 81 82 #include <sys/device.h> 83 #include <sys/malloc.h> 84 #include <cpu/atomic.h> 85 #include <dev/disk/dm/dm.h> 86 #include <dev/disk/dm/netbsd-dm.h> 87 88 static int 89 dm_table_deps(dm_table_entry_t *, prop_array_t); 90 static int 91 dm_table_init(dm_target_t *, dm_table_entry_t *, char *); 92 static int 93 dm_table_status(dm_table_entry_t *, prop_dictionary_t, uint32_t); 94 95 static __inline 96 void dm_add_flag(prop_dictionary_t dp, uint32_t *fp, const uint32_t val) 97 { 98 KKASSERT(dp != NULL); 99 prop_dictionary_get_uint32(dp, DM_IOCTL_FLAGS, fp); 100 (*fp) |= val; 101 prop_dictionary_set_uint32(dp, DM_IOCTL_FLAGS, *fp); 102 KKASSERT((*fp) & val); 103 } 104 105 static __inline 106 void dm_remove_flag(prop_dictionary_t dp, uint32_t *fp, const uint32_t val) 107 { 108 KKASSERT(dp != NULL); 109 prop_dictionary_get_uint32(dp, DM_IOCTL_FLAGS, fp); 110 (*fp) &= ~val; 111 prop_dictionary_set_uint32(dp, DM_IOCTL_FLAGS, *fp); 112 KKASSERT(!((*fp) & val)); 113 } 114 115 /* 116 * Print flags sent to the kernel from libdevmapper. 117 */ 118 static int 119 dm_dbg_print_flags(uint32_t flags) 120 { 121 if (dm_debug_level == 0) 122 return 1; 123 124 kprintf("%s --- flags=%08X\n", __func__, flags); 125 126 if (flags & DM_READONLY_FLAG) 127 kprintf(" DM_READONLY_FLAG\n"); 128 if (flags & DM_SUSPEND_FLAG) 129 kprintf(" DM_SUSPEND_FLAG\n"); 130 if (flags & DM_EXISTS_FLAG) 131 kprintf(" DM_EXISTS_FLAG\n"); 132 if (flags & DM_PERSISTENT_DEV_FLAG) 133 kprintf(" DM_PERSISTENT_DEV_FLAG\n"); 134 if (flags & DM_STATUS_TABLE_FLAG) 135 kprintf(" DM_STATUS_TABLE_FLAG\n"); 136 if (flags & DM_ACTIVE_PRESENT_FLAG) 137 kprintf(" DM_ACTIVE_PRESENT_FLAG\n"); 138 if (flags & DM_INACTIVE_PRESENT_FLAG) 139 kprintf(" DM_INACTIVE_PRESENT_FLAG\n"); 140 if (flags & DM_BUFFER_FULL_FLAG) 141 kprintf(" DM_BUFFER_FULL_FLAG\n"); 142 if (flags & DM_SKIP_BDGET_FLAG) 143 kprintf(" DM_SKIP_BDGET_FLAG\n"); 144 if (flags & DM_SKIP_LOCKFS_FLAG) 145 kprintf(" DM_SKIP_LOCKFS_FLAG\n"); 146 if (flags & DM_NOFLUSH_FLAG) 147 kprintf(" DM_NOFLUSH_FLAG\n"); 148 if (flags & DM_QUERY_INACTIVE_TABLE_FLAG) 149 kprintf(" DM_QUERY_INACTIVE_TABLE_FLAG\n"); 150 if (flags & DM_UUID_FLAG) 151 kprintf(" DM_UUID_FLAG\n"); 152 if (flags & DM_SECURE_DATA_FLAG) 153 kprintf(" DM_SECURE_DATA_FLAG\n"); 154 155 return 0; 156 } 157 158 /* 159 * Get list of all available targets from global 160 * target list and sent them back to libdevmapper. 161 */ 162 int 163 dm_list_versions_ioctl(prop_dictionary_t dm_dict) 164 { 165 prop_array_t target_list; 166 uint32_t flags; 167 168 flags = 0; 169 170 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 171 172 dm_dbg_print_flags(flags); 173 target_list = dm_target_prop_list(); 174 175 prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, target_list); 176 prop_object_release(target_list); 177 178 return 0; 179 } 180 181 /* 182 * Create in-kernel entry for device. Device attributes such as name, uuid are 183 * taken from proplib dictionary. 184 */ 185 int 186 dm_dev_create_ioctl(prop_dictionary_t dm_dict) 187 { 188 dm_dev_t *dmv; 189 const char *name, *uuid; 190 int r; 191 uint32_t flags; 192 193 r = 0; 194 flags = 0; 195 name = NULL; 196 uuid = NULL; 197 198 /* Get needed values from dictionary. */ 199 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 200 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 201 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 202 203 dm_dbg_print_flags(flags); 204 205 /* Lookup name and uuid if device already exist quit. */ 206 if ((dmv = dm_dev_lookup(name, uuid, -1)) != NULL) { 207 dm_add_flag(dm_dict, &flags, DM_EXISTS_FLAG); /* Device already exists */ 208 dm_dev_unbusy(dmv); 209 return EEXIST; 210 } 211 212 r = dm_dev_create(&dmv, name, uuid, flags); 213 if (r == 0) { 214 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); 215 dm_add_flag(dm_dict, &flags, DM_EXISTS_FLAG); 216 dm_remove_flag(dm_dict, &flags, DM_INACTIVE_PRESENT_FLAG); 217 } 218 219 return r; 220 } 221 222 /* 223 * Get list of created device-mapper devices from global list and 224 * send it to kernel. 225 * 226 * Output dictionary: 227 * 228 * <key>cmd_data</key> 229 * <array> 230 * <dict> 231 * <key>name<key> 232 * <string>...</string> 233 * 234 * <key>dev</key> 235 * <integer>...</integer> 236 * </dict> 237 * </array> 238 */ 239 int 240 dm_dev_list_ioctl(prop_dictionary_t dm_dict) 241 { 242 prop_array_t dev_list; 243 244 uint32_t flags; 245 246 flags = 0; 247 248 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 249 250 dm_dbg_print_flags(flags); 251 252 dev_list = dm_dev_prop_list(); 253 254 prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, dev_list); 255 prop_object_release(dev_list); 256 257 return 0; 258 } 259 260 /* 261 * Rename selected devices old name is in struct dm_ioctl. 262 * new name is taken from dictionary. 263 * 264 * <key>cmd_data</key> 265 * <array> 266 * <string>...</string> 267 * </array> 268 */ 269 int 270 dm_dev_rename_ioctl(prop_dictionary_t dm_dict) 271 { 272 #if 0 273 prop_array_t cmd_array; 274 dm_dev_t *dmv; 275 276 const char *name, *uuid, *n_name; 277 uint32_t flags, minor; 278 279 name = NULL; 280 uuid = NULL; 281 minor = 0; 282 283 /* Get needed values from dictionary. */ 284 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 285 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 286 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 287 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 288 289 dm_dbg_print_flags(flags); 290 291 cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA); 292 293 prop_array_get_cstring_nocopy(cmd_array, 0, &n_name); 294 295 if (strlen(n_name) + 1 > DM_NAME_LEN) 296 return EINVAL; 297 298 if ((dmv = dm_dev_lookup_evict(name, uuid, minor)) == NULL) { 299 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 300 return ENOENT; 301 } 302 /* change device name */ 303 /* 304 * XXX How to deal with this change, name only used in 305 * dm_dev_routines, should I add dm_dev_change_name which will run 306 * under the dm_dev_list mutex ? 307 */ 308 strlcpy(dmv->name, n_name, DM_NAME_LEN); 309 310 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt); 311 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); 312 prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid); 313 314 dm_dev_insert(dmv); 315 #endif 316 317 /* 318 * XXX: the rename is not yet implemented. The main complication 319 * here is devfs. We'd probably need a new function, rename_dev() 320 * that would trigger a node rename in devfs. 321 */ 322 kprintf("dm_dev_rename_ioctl called, but not implemented!\n"); 323 return ENOSYS; 324 } 325 326 /* 327 * Remove device 328 */ 329 int 330 dm_dev_remove_ioctl(prop_dictionary_t dm_dict) 331 { 332 dm_dev_t *dmv; 333 const char *name, *uuid; 334 uint32_t flags, minor, is_open; 335 336 flags = 0; 337 name = NULL; 338 uuid = NULL; 339 340 /* Get needed values from dictionary. */ 341 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 342 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 343 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 344 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 345 346 dm_dbg_print_flags(flags); 347 348 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 349 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 350 return ENOENT; 351 } 352 353 is_open = dmv->is_open; 354 355 dm_dev_unbusy(dmv); 356 357 if (is_open) 358 return EBUSY; 359 360 return dm_dev_remove(dmv); 361 } 362 363 /* 364 * Try to remove all devices 365 */ 366 int 367 dm_dev_remove_all_ioctl(prop_dictionary_t dm_dict) 368 { 369 uint32_t flags = 0; 370 371 /* Get needed values from dictionary. */ 372 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 373 374 dm_dbg_print_flags(flags); 375 376 /* Gently remove all devices, if possible */ 377 return dm_dev_remove_all(1); 378 } 379 380 /* 381 * Return actual state of device to libdevmapper. 382 */ 383 int 384 dm_dev_status_ioctl(prop_dictionary_t dm_dict) 385 { 386 dm_dev_t *dmv; 387 const char *name, *uuid; 388 uint32_t flags, j, minor; 389 390 name = NULL; 391 uuid = NULL; 392 flags = 0; 393 j = 0; 394 395 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 396 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 397 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 398 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 399 400 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 401 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 402 return ENOENT; 403 } 404 dm_dbg_print_flags(dmv->flags); 405 406 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt); 407 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); 408 prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid); 409 410 if (dmv->flags & DM_SUSPEND_FLAG) 411 dm_add_flag(dm_dict, &flags, DM_SUSPEND_FLAG); 412 413 /* 414 * Add status flags for tables I have to check both active and 415 * inactive tables. 416 */ 417 if ((j = dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))) 418 dm_add_flag(dm_dict, &flags, DM_ACTIVE_PRESENT_FLAG); 419 else 420 dm_remove_flag(dm_dict, &flags, DM_ACTIVE_PRESENT_FLAG); 421 422 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, j); 423 424 if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE)) 425 dm_add_flag(dm_dict, &flags, DM_INACTIVE_PRESENT_FLAG); 426 else 427 dm_remove_flag(dm_dict, &flags, DM_INACTIVE_PRESENT_FLAG); 428 429 dm_dev_unbusy(dmv); 430 431 return 0; 432 } 433 434 /* 435 * Set only flag to suggest that device is suspended. This call is 436 * not supported in NetBSD. 437 */ 438 int 439 dm_dev_suspend_ioctl(prop_dictionary_t dm_dict) 440 { 441 dm_dev_t *dmv; 442 const char *name, *uuid; 443 uint32_t flags, minor; 444 445 name = NULL; 446 uuid = NULL; 447 flags = 0; 448 449 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 450 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 451 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 452 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 453 454 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 455 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 456 return ENOENT; 457 } 458 atomic_set_int(&dmv->flags, DM_SUSPEND_FLAG); 459 460 dm_dbg_print_flags(dmv->flags); 461 462 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt); 463 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, dmv->flags); 464 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); 465 466 dm_dev_unbusy(dmv); 467 468 /* Add flags to dictionary flag after dmv -> dict copy */ 469 dm_add_flag(dm_dict, &flags, DM_EXISTS_FLAG); 470 471 return 0; 472 } 473 474 /* 475 * Simulate Linux behaviour better and switch tables here and not in 476 * dm_table_load_ioctl. 477 */ 478 int 479 dm_dev_resume_ioctl(prop_dictionary_t dm_dict) 480 { 481 dm_dev_t *dmv; 482 const char *name, *uuid; 483 uint32_t flags, minor; 484 485 name = NULL; 486 uuid = NULL; 487 flags = 0; 488 489 /* 490 * char *xml; xml = prop_dictionary_externalize(dm_dict); 491 * kprintf("%s\n",xml); 492 */ 493 494 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 495 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 496 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 497 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 498 499 /* Remove device from global device list */ 500 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 501 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 502 return ENOENT; 503 } 504 atomic_clear_int(&dmv->flags, (DM_SUSPEND_FLAG | DM_INACTIVE_PRESENT_FLAG)); 505 atomic_set_int(&dmv->flags, DM_ACTIVE_PRESENT_FLAG); 506 507 dm_table_switch_tables(&dmv->table_head); 508 509 dm_add_flag(dm_dict, &flags, DM_EXISTS_FLAG); 510 511 dmsetdiskinfo(dmv->diskp, &dmv->table_head); 512 513 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt); 514 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags); 515 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); 516 517 dm_dev_unbusy(dmv); 518 519 /* Destroy inactive table after resume. */ 520 dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE); 521 522 return 0; 523 } 524 525 /* 526 * Table management routines 527 * lvm2tools doens't send name/uuid to kernel with table 528 * for lookup I have to use minor number. 529 */ 530 531 /* 532 * Remove inactive table from device. Routines which work's with inactive tables 533 * doesn't need to synchronise with dmstrategy. They can synchronise themselves with mutex?. 534 */ 535 int 536 dm_table_clear_ioctl(prop_dictionary_t dm_dict) 537 { 538 dm_dev_t *dmv; 539 const char *name, *uuid; 540 uint32_t flags, minor; 541 542 dmv = NULL; 543 name = NULL; 544 uuid = NULL; 545 flags = 0; 546 minor = 0; 547 548 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 549 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 550 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 551 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 552 553 dmdebug("Clearing inactive table from device: %s--%s\n", 554 name, uuid); 555 556 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 557 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 558 return ENOENT; 559 } 560 /* Select unused table */ 561 dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE); 562 563 atomic_clear_int(&dmv->flags, DM_INACTIVE_PRESENT_FLAG); 564 565 dm_dev_unbusy(dmv); 566 567 return 0; 568 } 569 570 /* 571 * Get list of physical devices for active table. 572 * Get dev_t from pdev vnode and insert it into cmd_array. 573 * 574 * XXX. This function is called from lvm2tools to get information 575 * about physical devices, too e.g. during vgcreate. 576 */ 577 int 578 dm_table_deps_ioctl(prop_dictionary_t dm_dict) 579 { 580 dm_dev_t *dmv; 581 dm_table_t *tbl; 582 dm_table_entry_t *table_en; 583 584 prop_array_t cmd_array; 585 const char *name, *uuid; 586 uint32_t flags, minor; 587 588 int table_type; 589 590 name = NULL; 591 uuid = NULL; 592 dmv = NULL; 593 flags = 0; 594 595 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 596 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 597 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 598 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 599 600 /* create array for dev_t's */ 601 cmd_array = prop_array_create(); 602 603 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 604 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 605 return ENOENT; 606 } 607 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); 608 prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmv->name); 609 prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid); 610 611 dmdebug("Getting table deps for device: %s\n", dmv->name); 612 613 /* 614 * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query 615 * INACTIVE TABLE 616 */ 617 if (flags & DM_QUERY_INACTIVE_TABLE_FLAG) 618 table_type = DM_TABLE_INACTIVE; 619 else 620 table_type = DM_TABLE_ACTIVE; 621 622 tbl = dm_table_get_entry(&dmv->table_head, table_type); 623 624 TAILQ_FOREACH(table_en, tbl, next) 625 dm_table_deps(table_en, cmd_array); 626 627 dm_table_release(&dmv->table_head, table_type); 628 dm_dev_unbusy(dmv); 629 630 prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array); 631 prop_object_release(cmd_array); 632 633 return 0; 634 } 635 636 static int 637 dm_table_deps(dm_table_entry_t *table_en, prop_array_t array) 638 { 639 dm_mapping_t *map; 640 int i, size; 641 uint64_t ret, tmp; 642 643 size = prop_array_count(array); 644 645 TAILQ_FOREACH(map, &table_en->pdev_maps, next) { 646 ret = map->data.pdev->udev; 647 for (i = 0; i < size; i++) { 648 if (prop_array_get_uint64(array, i, &tmp) == true) 649 if (ret == tmp) 650 break; /* exists */ 651 } 652 /* 653 * Ignore if the device has already been added by 654 * other tables. 655 */ 656 if (i == size) 657 prop_array_add_uint64(array, ret); 658 } 659 660 return 0; 661 } 662 663 /* 664 * Load new table/tables to device. 665 * Call apropriate target init routine open all physical pdev's and 666 * link them to device. For other targets mirror, strip, snapshot etc. 667 * 668 * Load table to inactive slot table are switched in dm_device_resume_ioctl. 669 * This simulates Linux behaviour better there should not be any difference. 670 */ 671 int 672 dm_table_load_ioctl(prop_dictionary_t dm_dict) 673 { 674 dm_dev_t *dmv; 675 dm_table_entry_t *table_en; 676 dm_table_t *tbl; 677 dm_target_t *target; 678 679 prop_object_iterator_t iter; 680 prop_array_t cmd_array; 681 prop_dictionary_t target_dict; 682 683 const char *name, *uuid, *type; 684 685 uint32_t flags, ret, minor; 686 687 char *str; 688 689 ret = 0; 690 flags = 0; 691 name = NULL; 692 uuid = NULL; 693 dmv = NULL; 694 str = NULL; 695 696 /* 697 * char *xml; xml = prop_dictionary_externalize(dm_dict); 698 * kprintf("%s\n",xml); 699 */ 700 701 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 702 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 703 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 704 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 705 706 cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA); 707 iter = prop_array_iterator(cmd_array); 708 dm_dbg_print_flags(flags); 709 710 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 711 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 712 return ENOENT; 713 } 714 dmdebug("Loading table to device: %s--%d\n", name, 715 dmv->table_head.cur_active_table); 716 717 /* 718 * I have to check if this table slot is not used by another table list. 719 * if it is used I should free them. 720 */ 721 if (dmv->flags & DM_INACTIVE_PRESENT_FLAG) 722 dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE); 723 724 dm_dbg_print_flags(dmv->flags); 725 tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_INACTIVE); 726 727 dmdebug("dmv->name = %s\n", dmv->name); 728 729 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); 730 731 while ((target_dict = prop_object_iterator_next(iter)) != NULL) { 732 prop_dictionary_get_cstring_nocopy(target_dict, 733 DM_TABLE_TYPE, &type); 734 /* 735 * If we want to deny table with 2 or more different 736 * target we should do it here 737 */ 738 if (((target = dm_target_lookup(type)) == NULL) && 739 ((target = dm_target_autoload(type)) == NULL)) { 740 dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE); 741 dm_dev_unbusy(dmv); 742 return ENOENT; 743 } 744 if ((table_en = kmalloc(sizeof(dm_table_entry_t), 745 M_DM, M_WAITOK)) == NULL) { 746 dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE); 747 dm_dev_unbusy(dmv); 748 dm_target_unbusy(target); 749 return ENOMEM; 750 } 751 prop_dictionary_get_uint64(target_dict, DM_TABLE_START, 752 &table_en->start); 753 prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH, 754 &table_en->length); 755 756 dmdebug("dm_ioctl.c... table_en->start = %ju, " 757 "table_en->length = %ju\n", 758 (uintmax_t)table_en->start, 759 (uintmax_t)table_en->length); 760 761 table_en->target = target; 762 table_en->dev = dmv; 763 table_en->target_config = NULL; 764 TAILQ_INIT(&table_en->pdev_maps); 765 766 /* 767 * There is a parameter string after dm_target_spec 768 * structure which points to /dev/wd0a 284 part of 769 * table. String str points to this text. This can be 770 * null and therefore it should be checked before we try to 771 * use it. 772 */ 773 prop_dictionary_get_cstring(target_dict, 774 DM_TABLE_PARAMS, &str); 775 776 TAILQ_INSERT_TAIL(tbl, table_en, next); 777 778 /* 779 * Params string is different for every target, 780 * therfore I have to pass it to target init 781 * routine and parse parameters there. 782 */ 783 dmdebug("DM: str passed in is: \"%s\"\n", str); 784 785 if ((ret = dm_table_init(target, table_en, str)) != 0) { 786 dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE); 787 dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE); 788 kfree(str, M_TEMP); 789 790 dm_dev_unbusy(dmv); 791 return ret; 792 } 793 kfree(str, M_TEMP); 794 } 795 prop_object_iterator_release(iter); 796 797 dm_add_flag(dm_dict, &flags, DM_INACTIVE_PRESENT_FLAG); 798 atomic_set_int(&dmv->flags, DM_INACTIVE_PRESENT_FLAG); 799 800 dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE); 801 802 dm_dev_unbusy(dmv); 803 #if 0 804 dmsetdiskinfo(dmv->diskp, &dmv->table_head); 805 #endif 806 return 0; 807 } 808 809 static int 810 dm_table_init(dm_target_t *target, dm_table_entry_t *table_en, char *params) 811 { 812 int i, n, ret, argc; 813 char **ap, **argv; 814 815 if (params == NULL) 816 return EINVAL; 817 818 n = target->max_argc; 819 if (n) { 820 dmdebug("Max argc %d for %s target\n", n, target->name); 821 } else { 822 n = 20; /* large enough slots for most targets */ 823 } 824 825 argv = kmalloc(sizeof(*argv) * n, M_DM, M_WAITOK | M_ZERO); 826 827 for (ap = argv; 828 ap < &argv[n] && (*ap = strsep(¶ms, " \t")) != NULL;) { 829 if (**ap != '\0') 830 ap++; 831 } 832 argc = ap - argv; 833 834 if (dm_debug_level) { 835 for (i = 0; i < argc; i++) 836 kprintf("DM: argv[%d] = \"%s\"\n", i, argv[i]); 837 } 838 839 KKASSERT(target->init); 840 ret = target->init(table_en, argc, argv); 841 842 kfree(argv, M_DM); 843 844 return ret; 845 } 846 847 /* 848 * Get description of all tables loaded to device from kernel 849 * and send it to libdevmapper. 850 * 851 * Output dictionary for every table: 852 * 853 * <key>cmd_data</key> 854 * <array> 855 * <dict> 856 * <key>type<key> 857 * <string>...</string> 858 * 859 * <key>start</key> 860 * <integer>...</integer> 861 * 862 * <key>length</key> 863 * <integer>...</integer> 864 * 865 * <key>params</key> 866 * <string>...</string> 867 * </dict> 868 * </array> 869 */ 870 int 871 dm_table_status_ioctl(prop_dictionary_t dm_dict) 872 { 873 dm_dev_t *dmv; 874 dm_table_t *tbl; 875 dm_table_entry_t *table_en; 876 877 prop_array_t cmd_array; 878 prop_dictionary_t target_dict; 879 880 uint32_t minor; 881 882 const char *name, *uuid; 883 uint32_t flags; 884 int table_type; 885 886 dmv = NULL; 887 uuid = NULL; 888 name = NULL; 889 flags = 0; 890 891 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 892 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 893 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 894 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 895 896 cmd_array = prop_array_create(); 897 898 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 899 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 900 return ENOENT; 901 } 902 /* 903 * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query 904 * INACTIVE TABLE 905 */ 906 if (flags & DM_QUERY_INACTIVE_TABLE_FLAG) 907 table_type = DM_TABLE_INACTIVE; 908 else 909 table_type = DM_TABLE_ACTIVE; 910 911 if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE)) 912 dm_add_flag(dm_dict, &flags, DM_ACTIVE_PRESENT_FLAG); 913 else { 914 dm_remove_flag(dm_dict, &flags, DM_ACTIVE_PRESENT_FLAG); 915 916 if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE)) 917 dm_add_flag(dm_dict, &flags, DM_INACTIVE_PRESENT_FLAG); 918 else 919 dm_remove_flag(dm_dict, &flags, DM_INACTIVE_PRESENT_FLAG); 920 } 921 922 if (dmv->flags & DM_SUSPEND_FLAG) 923 dm_add_flag(dm_dict, &flags, DM_SUSPEND_FLAG); 924 925 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); 926 927 dmdebug("Status of device tables: %s--%d\n", 928 name, dmv->table_head.cur_active_table); 929 930 tbl = dm_table_get_entry(&dmv->table_head, table_type); 931 932 TAILQ_FOREACH(table_en, tbl, next) { 933 target_dict = prop_dictionary_create(); 934 dmdebug("%016" PRIu64 ", length %016" PRIu64 935 ", target %s\n", table_en->start, table_en->length, 936 table_en->target->name); 937 938 prop_dictionary_set_uint64(target_dict, DM_TABLE_START, 939 table_en->start); 940 prop_dictionary_set_uint64(target_dict, DM_TABLE_LENGTH, 941 table_en->length); 942 943 prop_dictionary_set_cstring(target_dict, DM_TABLE_TYPE, 944 table_en->target->name); 945 946 /* dm_table_get_cur_actv.table ?? */ 947 prop_dictionary_set_int32(target_dict, DM_TABLE_STAT, 948 dmv->table_head.cur_active_table); 949 950 dm_table_status(table_en, target_dict, flags); 951 952 prop_array_add(cmd_array, target_dict); 953 prop_object_release(target_dict); 954 } 955 956 dm_table_release(&dmv->table_head, table_type); 957 dm_dev_unbusy(dmv); 958 959 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags); 960 prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array); 961 prop_object_release(cmd_array); 962 963 return 0; 964 } 965 966 static int 967 dm_table_status(dm_table_entry_t *table_en, 968 prop_dictionary_t target_dict, uint32_t flags) 969 { 970 void *cfg; 971 char *params; 972 int is_table; 973 974 cfg = table_en->target_config; 975 params = NULL; 976 977 is_table = (flags & DM_STATUS_TABLE_FLAG) ? 1 : 0; 978 979 if (is_table && table_en->target->table) { 980 params = table_en->target->table(cfg); 981 } else if (!is_table && table_en->target->info) { 982 params = table_en->target->info(cfg); 983 } else { 984 prop_dictionary_set_cstring(target_dict, DM_TABLE_PARAMS, ""); 985 return ENOTSUP; 986 } 987 988 if (params == NULL) { 989 prop_dictionary_set_cstring(target_dict, DM_TABLE_PARAMS, ""); 990 return ENOMEM; 991 } 992 993 prop_dictionary_set_cstring(target_dict, DM_TABLE_PARAMS, params); 994 kfree(params, M_DM); 995 return 0; 996 } 997 998 int 999 dm_message_ioctl(prop_dictionary_t dm_dict) 1000 { 1001 dm_table_t *tbl; 1002 dm_table_entry_t *table_en; 1003 dm_dev_t *dmv; 1004 const char *name, *uuid; 1005 uint32_t flags, minor; 1006 uint64_t table_start, table_end, sector; 1007 char *msg; 1008 int ret, found = 0; 1009 1010 flags = 0; 1011 name = NULL; 1012 uuid = NULL; 1013 1014 /* Get needed values from dictionary. */ 1015 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); 1016 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); 1017 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); 1018 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); 1019 prop_dictionary_get_uint64(dm_dict, DM_MESSAGE_SECTOR, §or); 1020 1021 dm_dbg_print_flags(flags); 1022 1023 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { 1024 dm_remove_flag(dm_dict, &flags, DM_EXISTS_FLAG); 1025 return ENOENT; 1026 } 1027 1028 /* Get message string */ 1029 prop_dictionary_get_cstring(dm_dict, DM_MESSAGE_STR, &msg); 1030 1031 tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_ACTIVE); 1032 1033 ret = EINVAL; 1034 1035 if (sector == 0) { 1036 if (!TAILQ_EMPTY(tbl)) { 1037 table_en = TAILQ_FIRST(tbl); 1038 found = 1; 1039 } 1040 } else { 1041 TAILQ_FOREACH(table_en, tbl, next) { 1042 table_start = table_en->start; 1043 table_end = table_start + table_en->length; 1044 1045 if ((sector >= table_start) && (sector < table_end)) { 1046 found = 1; 1047 break; 1048 } 1049 } 1050 } 1051 1052 if (found) { 1053 if (table_en->target->message != NULL) 1054 ret = table_en->target->message(table_en, msg); 1055 } 1056 1057 dm_table_release(&dmv->table_head, DM_TABLE_ACTIVE); 1058 1059 kfree(msg, M_TEMP); 1060 dm_dev_unbusy(dmv); 1061 1062 return ret; 1063 } 1064 1065 /* 1066 * For every call I have to set kernel driver version. 1067 * Because I can have commands supported only in other 1068 * newer/later version. This routine is called for every 1069 * ioctl command. 1070 */ 1071 int 1072 dm_check_version(prop_dictionary_t dm_dict) 1073 { 1074 size_t i; 1075 int dm_version[3]; 1076 prop_array_t ver; 1077 1078 ver = prop_dictionary_get(dm_dict, DM_IOCTL_VERSION); 1079 1080 for (i = 0; i < 3; i++) 1081 prop_array_get_uint32(ver, i, &dm_version[i]); 1082 1083 if (DM_VERSION_MAJOR != dm_version[0] || DM_VERSION_MINOR < dm_version[1]) { 1084 dmdebug("libdevmapper/kernel version mismatch " 1085 "kernel: %d.%d.%d libdevmapper: %d.%d.%d\n", 1086 DM_VERSION_MAJOR, DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL, 1087 dm_version[0], dm_version[1], dm_version[2]); 1088 1089 return EIO; 1090 } 1091 prop_array_set_uint32(ver, 0, DM_VERSION_MAJOR); 1092 prop_array_set_uint32(ver, 1, DM_VERSION_MINOR); 1093 prop_array_set_uint32(ver, 2, DM_VERSION_PATCHLEVEL); 1094 1095 prop_dictionary_set(dm_dict, DM_IOCTL_VERSION, ver); 1096 1097 return 0; 1098 } 1099