1 /* $NetBSD: activate.c,v 1.1.1.3 2009/12/02 00:26:22 haad Exp $ */ 2 3 /* 4 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved. 5 * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved. 6 * 7 * This file is part of LVM2. 8 * 9 * This copyrighted material is made available to anyone wishing to use, 10 * modify, copy, or redistribute it subject to the terms and conditions 11 * of the GNU Lesser General Public License v.2.1. 12 * 13 * You should have received a copy of the GNU Lesser General Public License 14 * along with this program; if not, write to the Free Software Foundation, 15 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 16 */ 17 18 #include "lib.h" 19 #include "metadata.h" 20 #include "activate.h" 21 #include "memlock.h" 22 #include "display.h" 23 #include "fs.h" 24 #include "lvm-exec.h" 25 #include "lvm-file.h" 26 #include "lvm-string.h" 27 #include "toolcontext.h" 28 #include "dev_manager.h" 29 #include "str_list.h" 30 #include "config.h" 31 #include "filter.h" 32 #include "segtype.h" 33 34 #include <limits.h> 35 #include <fcntl.h> 36 #include <unistd.h> 37 38 #define _skip(fmt, args...) log_very_verbose("Skipping: " fmt , ## args) 39 40 int lvm1_present(struct cmd_context *cmd) 41 { 42 char path[PATH_MAX]; 43 44 if (dm_snprintf(path, sizeof(path), "%s/lvm/global", cmd->proc_dir) 45 < 0) { 46 log_error("LVM1 proc global snprintf failed"); 47 return 0; 48 } 49 50 if (path_exists(path)) 51 return 1; 52 else 53 return 0; 54 } 55 56 int list_segment_modules(struct dm_pool *mem, const struct lv_segment *seg, 57 struct dm_list *modules) 58 { 59 unsigned int s; 60 struct lv_segment *seg2, *snap_seg; 61 struct dm_list *snh; 62 63 if (seg->segtype->ops->modules_needed && 64 !seg->segtype->ops->modules_needed(mem, seg, modules)) { 65 log_error("module string allocation failed"); 66 return 0; 67 } 68 69 if (lv_is_origin(seg->lv)) 70 dm_list_iterate(snh, &seg->lv->snapshot_segs) 71 if (!list_lv_modules(mem, 72 dm_list_struct_base(snh, 73 struct lv_segment, 74 origin_list)->cow, 75 modules)) 76 return_0; 77 78 if (lv_is_cow(seg->lv)) { 79 snap_seg = find_cow(seg->lv); 80 if (snap_seg->segtype->ops->modules_needed && 81 !snap_seg->segtype->ops->modules_needed(mem, snap_seg, 82 modules)) { 83 log_error("snap_seg module string allocation failed"); 84 return 0; 85 } 86 } 87 88 for (s = 0; s < seg->area_count; s++) { 89 switch (seg_type(seg, s)) { 90 case AREA_LV: 91 seg2 = find_seg_by_le(seg_lv(seg, s), seg_le(seg, s)); 92 if (seg2 && !list_segment_modules(mem, seg2, modules)) 93 return_0; 94 break; 95 case AREA_PV: 96 case AREA_UNASSIGNED: 97 ; 98 } 99 } 100 101 return 1; 102 } 103 104 int list_lv_modules(struct dm_pool *mem, const struct logical_volume *lv, 105 struct dm_list *modules) 106 { 107 struct lv_segment *seg; 108 109 dm_list_iterate_items(seg, &lv->segments) 110 if (!list_segment_modules(mem, seg, modules)) 111 return_0; 112 113 return 1; 114 } 115 116 #ifndef DEVMAPPER_SUPPORT 117 void set_activation(int act) 118 { 119 static int warned = 0; 120 121 if (warned || !act) 122 return; 123 124 log_error("Compiled without libdevmapper support. " 125 "Can't enable activation."); 126 127 warned = 1; 128 } 129 int activation(void) 130 { 131 return 0; 132 } 133 int library_version(char *version, size_t size) 134 { 135 return 0; 136 } 137 int driver_version(char *version, size_t size) 138 { 139 return 0; 140 } 141 int target_version(const char *target_name, uint32_t *maj, 142 uint32_t *min, uint32_t *patchlevel) 143 { 144 return 0; 145 } 146 int target_present(struct cmd_context *cmd, const char *target_name, 147 int use_modprobe) 148 { 149 return 0; 150 } 151 int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, struct lvinfo *info, 152 int with_open_count, int with_read_ahead) 153 { 154 return 0; 155 } 156 int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s, 157 struct lvinfo *info, int with_open_count, int with_read_ahead) 158 { 159 return 0; 160 } 161 int lv_snapshot_percent(const struct logical_volume *lv, float *percent, 162 percent_range_t *percent_range) 163 { 164 return 0; 165 } 166 int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv, 167 int wait, float *percent, percent_range_t *percent_range, 168 uint32_t *event_nr) 169 { 170 return 0; 171 } 172 int lvs_in_vg_activated(struct volume_group *vg) 173 { 174 return 0; 175 } 176 int lvs_in_vg_activated_by_uuid_only(struct volume_group *vg) 177 { 178 return 0; 179 } 180 int lvs_in_vg_opened(struct volume_group *vg) 181 { 182 return 0; 183 } 184 int lv_suspend(struct cmd_context *cmd, const char *lvid_s) 185 { 186 return 1; 187 } 188 int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s) 189 { 190 return 1; 191 } 192 int lv_resume(struct cmd_context *cmd, const char *lvid_s) 193 { 194 return 1; 195 } 196 int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s) 197 { 198 return 1; 199 } 200 int lv_deactivate(struct cmd_context *cmd, const char *lvid_s) 201 { 202 return 1; 203 } 204 int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s, 205 int *activate_lv) 206 { 207 return 1; 208 } 209 int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive) 210 { 211 return 1; 212 } 213 int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s, int exclusive) 214 { 215 return 1; 216 } 217 218 int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv) 219 { 220 return 1; 221 } 222 223 int pv_uses_vg(struct physical_volume *pv, 224 struct volume_group *vg) 225 { 226 return 0; 227 } 228 229 void activation_release(void) 230 { 231 return; 232 } 233 234 void activation_exit(void) 235 { 236 return; 237 } 238 239 #else /* DEVMAPPER_SUPPORT */ 240 241 static int _activation = 1; 242 243 void set_activation(int act) 244 { 245 if (act == _activation) 246 return; 247 248 _activation = act; 249 if (_activation) 250 log_verbose("Activation enabled. Device-mapper kernel " 251 "driver will be used."); 252 else 253 log_warn("WARNING: Activation disabled. No device-mapper " 254 "interaction will be attempted."); 255 } 256 257 int activation(void) 258 { 259 return _activation; 260 } 261 262 static int _passes_activation_filter(struct cmd_context *cmd, 263 struct logical_volume *lv) 264 { 265 const struct config_node *cn; 266 struct config_value *cv; 267 char *str; 268 char path[PATH_MAX]; 269 270 if (!(cn = find_config_tree_node(cmd, "activation/volume_list"))) { 271 /* If no host tags defined, activate */ 272 if (dm_list_empty(&cmd->tags)) 273 return 1; 274 275 /* If any host tag matches any LV or VG tag, activate */ 276 if (str_list_match_list(&cmd->tags, &lv->tags) || 277 str_list_match_list(&cmd->tags, &lv->vg->tags)) 278 return 1; 279 280 /* Don't activate */ 281 return 0; 282 } 283 284 for (cv = cn->v; cv; cv = cv->next) { 285 if (cv->type != CFG_STRING) { 286 log_error("Ignoring invalid string in config file " 287 "activation/volume_list"); 288 continue; 289 } 290 str = cv->v.str; 291 if (!*str) { 292 log_error("Ignoring empty string in config file " 293 "activation/volume_list"); 294 continue; 295 } 296 297 /* Tag? */ 298 if (*str == '@') { 299 str++; 300 if (!*str) { 301 log_error("Ignoring empty tag in config file " 302 "activation/volume_list"); 303 continue; 304 } 305 /* If any host tag matches any LV or VG tag, activate */ 306 if (!strcmp(str, "*")) { 307 if (str_list_match_list(&cmd->tags, &lv->tags) 308 || str_list_match_list(&cmd->tags, 309 &lv->vg->tags)) 310 return 1; 311 else 312 continue; 313 } 314 /* If supplied tag matches LV or VG tag, activate */ 315 if (str_list_match_item(&lv->tags, str) || 316 str_list_match_item(&lv->vg->tags, str)) 317 return 1; 318 else 319 continue; 320 } 321 if (!strchr(str, '/')) { 322 /* vgname supplied */ 323 if (!strcmp(str, lv->vg->name)) 324 return 1; 325 else 326 continue; 327 } 328 /* vgname/lvname */ 329 if (dm_snprintf(path, sizeof(path), "%s/%s", lv->vg->name, 330 lv->name) < 0) { 331 log_error("dm_snprintf error from %s/%s", lv->vg->name, 332 lv->name); 333 continue; 334 } 335 if (!strcmp(path, str)) 336 return 1; 337 } 338 339 return 0; 340 } 341 342 int library_version(char *version, size_t size) 343 { 344 if (!activation()) 345 return 0; 346 347 return dm_get_library_version(version, size); 348 } 349 350 int driver_version(char *version, size_t size) 351 { 352 if (!activation()) 353 return 0; 354 355 log_very_verbose("Getting driver version"); 356 357 return dm_driver_version(version, size); 358 } 359 360 int target_version(const char *target_name, uint32_t *maj, 361 uint32_t *min, uint32_t *patchlevel) 362 { 363 int r = 0; 364 struct dm_task *dmt; 365 struct dm_versions *target, *last_target; 366 367 log_very_verbose("Getting target version for %s", target_name); 368 if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS))) 369 return_0; 370 371 if (!dm_task_run(dmt)) { 372 log_debug("Failed to get %s target version", target_name); 373 /* Assume this was because LIST_VERSIONS isn't supported */ 374 return 1; 375 } 376 377 target = dm_task_get_versions(dmt); 378 379 do { 380 last_target = target; 381 382 if (!strcmp(target_name, target->name)) { 383 r = 1; 384 *maj = target->version[0]; 385 *min = target->version[1]; 386 *patchlevel = target->version[2]; 387 goto out; 388 } 389 390 target = (void *) target + target->next; 391 } while (last_target != target); 392 393 out: 394 dm_task_destroy(dmt); 395 396 return r; 397 } 398 399 int module_present(struct cmd_context *cmd, const char *target_name) 400 { 401 int ret = 0; 402 #ifdef MODPROBE_CMD 403 char module[128]; 404 const char *argv[3]; 405 406 if (dm_snprintf(module, sizeof(module), "dm-%s", target_name) < 0) { 407 log_error("module_present module name too long: %s", 408 target_name); 409 return 0; 410 } 411 412 argv[0] = MODPROBE_CMD; 413 argv[1] = module; 414 argv[2] = NULL; 415 416 ret = exec_cmd(cmd, argv); 417 #endif 418 return ret; 419 } 420 421 int target_present(struct cmd_context *cmd, const char *target_name, 422 int use_modprobe) 423 { 424 uint32_t maj, min, patchlevel; 425 426 if (!activation()) 427 return 0; 428 429 #ifdef MODPROBE_CMD 430 if (use_modprobe) { 431 if (target_version(target_name, &maj, &min, &patchlevel)) 432 return 1; 433 434 if (!module_present(cmd, target_name)) 435 return_0; 436 } 437 #endif 438 439 return target_version(target_name, &maj, &min, &patchlevel); 440 } 441 442 /* 443 * Returns 1 if info structure populated, else 0 on failure. 444 */ 445 static int _lv_info(struct cmd_context *cmd, const struct logical_volume *lv, int with_mknodes, 446 struct lvinfo *info, int with_open_count, int with_read_ahead, unsigned by_uuid_only) 447 { 448 struct dm_info dminfo; 449 char *name = NULL; 450 451 if (!activation()) 452 return 0; 453 454 if (!by_uuid_only && 455 !(name = build_dm_name(cmd->mem, lv->vg->name, lv->name, NULL))) 456 return_0; 457 458 log_debug("Getting device info for %s", name); 459 if (!dev_manager_info(lv->vg->cmd->mem, name, lv, with_mknodes, 460 with_open_count, with_read_ahead, &dminfo, 461 &info->read_ahead)) { 462 if (name) 463 dm_pool_free(cmd->mem, name); 464 return_0; 465 } 466 467 info->exists = dminfo.exists; 468 info->suspended = dminfo.suspended; 469 info->open_count = dminfo.open_count; 470 info->major = dminfo.major; 471 info->minor = dminfo.minor; 472 info->read_only = dminfo.read_only; 473 info->live_table = dminfo.live_table; 474 info->inactive_table = dminfo.inactive_table; 475 476 if (name) 477 dm_pool_free(cmd->mem, name); 478 479 return 1; 480 } 481 482 int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, struct lvinfo *info, 483 int with_open_count, int with_read_ahead) 484 { 485 return _lv_info(cmd, lv, 0, info, with_open_count, with_read_ahead, 0); 486 } 487 488 int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s, 489 struct lvinfo *info, int with_open_count, int with_read_ahead) 490 { 491 struct logical_volume *lv; 492 493 if (!(lv = lv_from_lvid(cmd, lvid_s, 0))) 494 return 0; 495 496 return _lv_info(cmd, lv, 0, info, with_open_count, with_read_ahead, 0); 497 } 498 499 /* 500 * Returns 1 if percent set, else 0 on failure. 501 */ 502 int lv_snapshot_percent(const struct logical_volume *lv, float *percent, 503 percent_range_t *percent_range) 504 { 505 int r; 506 struct dev_manager *dm; 507 508 if (!activation()) 509 return 0; 510 511 if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) 512 return_0; 513 514 if (!(r = dev_manager_snapshot_percent(dm, lv, percent, percent_range))) 515 stack; 516 517 dev_manager_destroy(dm); 518 519 return r; 520 } 521 522 /* FIXME Merge with snapshot_percent */ 523 int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv, 524 int wait, float *percent, percent_range_t *percent_range, 525 uint32_t *event_nr) 526 { 527 int r; 528 struct dev_manager *dm; 529 struct lvinfo info; 530 531 /* If mirrored LV is temporarily shrinked to 1 area (= linear), 532 * it should be considered in-sync. */ 533 if (dm_list_size(&lv->segments) == 1 && first_seg(lv)->area_count == 1) { 534 *percent = 100.0; 535 return 1; 536 } 537 538 if (!activation()) 539 return 0; 540 541 if (!lv_info(cmd, lv, &info, 0, 0)) 542 return_0; 543 544 if (!info.exists) 545 return 0; 546 547 if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) 548 return_0; 549 550 if (!(r = dev_manager_mirror_percent(dm, lv, wait, percent, 551 percent_range, event_nr))) 552 stack; 553 554 dev_manager_destroy(dm); 555 556 return r; 557 } 558 559 static int _lv_active(struct cmd_context *cmd, struct logical_volume *lv, 560 unsigned by_uuid_only) 561 { 562 struct lvinfo info; 563 564 if (!_lv_info(cmd, lv, 0, &info, 0, 0, by_uuid_only)) { 565 stack; 566 return -1; 567 } 568 569 return info.exists; 570 } 571 572 static int _lv_open_count(struct cmd_context *cmd, struct logical_volume *lv) 573 { 574 struct lvinfo info; 575 576 if (!lv_info(cmd, lv, &info, 1, 0)) { 577 stack; 578 return -1; 579 } 580 581 return info.open_count; 582 } 583 584 static int _lv_activate_lv(struct logical_volume *lv) 585 { 586 int r; 587 struct dev_manager *dm; 588 589 if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) 590 return_0; 591 592 if (!(r = dev_manager_activate(dm, lv))) 593 stack; 594 595 dev_manager_destroy(dm); 596 return r; 597 } 598 599 static int _lv_preload(struct logical_volume *lv, int *flush_required) 600 { 601 int r; 602 struct dev_manager *dm; 603 604 if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) 605 return_0; 606 607 if (!(r = dev_manager_preload(dm, lv, flush_required))) 608 stack; 609 610 dev_manager_destroy(dm); 611 return r; 612 } 613 614 static int _lv_deactivate(struct logical_volume *lv) 615 { 616 int r; 617 struct dev_manager *dm; 618 619 if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) 620 return_0; 621 622 if (!(r = dev_manager_deactivate(dm, lv))) 623 stack; 624 625 dev_manager_destroy(dm); 626 return r; 627 } 628 629 static int _lv_suspend_lv(struct logical_volume *lv, int lockfs, int flush_required) 630 { 631 int r; 632 struct dev_manager *dm; 633 634 if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) 635 return_0; 636 637 if (!(r = dev_manager_suspend(dm, lv, lockfs, flush_required))) 638 stack; 639 640 dev_manager_destroy(dm); 641 return r; 642 } 643 644 /* 645 * These two functions return the number of visible LVs in the state, 646 * or -1 on error. 647 */ 648 static int _lvs_in_vg_activated(struct volume_group *vg, unsigned by_uuid_only) 649 { 650 struct lv_list *lvl; 651 int count = 0; 652 653 if (!activation()) 654 return 0; 655 656 dm_list_iterate_items(lvl, &vg->lvs) { 657 if (lv_is_visible(lvl->lv)) 658 count += (_lv_active(vg->cmd, lvl->lv, by_uuid_only) == 1); 659 } 660 661 return count; 662 } 663 664 int lvs_in_vg_activated_by_uuid_only(struct volume_group *vg) 665 { 666 return _lvs_in_vg_activated(vg, 1); 667 } 668 669 int lvs_in_vg_activated(struct volume_group *vg) 670 { 671 return _lvs_in_vg_activated(vg, 0); 672 } 673 674 int lvs_in_vg_opened(const struct volume_group *vg) 675 { 676 const struct lv_list *lvl; 677 int count = 0; 678 679 if (!activation()) 680 return 0; 681 682 dm_list_iterate_items(lvl, &vg->lvs) { 683 if (lv_is_visible(lvl->lv)) 684 count += (_lv_open_count(vg->cmd, lvl->lv) > 0); 685 } 686 687 return count; 688 } 689 690 /* 691 * Determine whether an LV is active locally or in a cluster. 692 * Assumes vg lock held. 693 * Returns: 694 * 0 - not active locally or on any node in cluster 695 * 1 - active either locally or some node in the cluster 696 */ 697 int lv_is_active(struct logical_volume *lv) 698 { 699 int ret; 700 701 if (_lv_active(lv->vg->cmd, lv, 0)) 702 return 1; 703 704 if (!vg_is_clustered(lv->vg)) 705 return 0; 706 707 if ((ret = remote_lock_held(lv->lvid.s)) >= 0) 708 return ret; 709 710 /* 711 * Old compatibility code if locking doesn't support lock query 712 * FIXME: check status to not deactivate already activate device 713 */ 714 if (activate_lv_excl(lv->vg->cmd, lv)) { 715 deactivate_lv(lv->vg->cmd, lv); 716 return 0; 717 } 718 719 /* 720 * Exclusive local activation failed so assume it is active elsewhere. 721 */ 722 return 1; 723 } 724 725 /* 726 * Returns 0 if an attempt to (un)monitor the device failed. 727 * Returns 1 otherwise. 728 */ 729 int monitor_dev_for_events(struct cmd_context *cmd, 730 struct logical_volume *lv, int monitor) 731 { 732 #ifdef DMEVENTD 733 int i, pending = 0, monitored; 734 int r = 1; 735 struct dm_list *tmp, *snh, *snht; 736 struct lv_segment *seg; 737 int (*monitor_fn) (struct lv_segment *s, int e); 738 uint32_t s; 739 740 /* skip dmeventd code altogether */ 741 if (dmeventd_monitor_mode() == DMEVENTD_MONITOR_IGNORE) 742 return 1; 743 744 /* 745 * Nothing to do if dmeventd configured not to be used. 746 */ 747 if (monitor && !dmeventd_monitor_mode()) 748 return 1; 749 750 /* 751 * In case of a snapshot device, we monitor lv->snapshot->lv, 752 * not the actual LV itself. 753 */ 754 if (lv_is_cow(lv)) 755 return monitor_dev_for_events(cmd, lv->snapshot->lv, monitor); 756 757 /* 758 * In case this LV is a snapshot origin, we instead monitor 759 * each of its respective snapshots (the origin itself does 760 * not need to be monitored). 761 * 762 * TODO: This may change when snapshots of mirrors are allowed. 763 */ 764 if (lv_is_origin(lv)) { 765 dm_list_iterate_safe(snh, snht, &lv->snapshot_segs) 766 if (!monitor_dev_for_events(cmd, dm_list_struct_base(snh, 767 struct lv_segment, origin_list)->cow, monitor)) 768 r = 0; 769 return r; 770 } 771 772 dm_list_iterate(tmp, &lv->segments) { 773 seg = dm_list_item(tmp, struct lv_segment); 774 775 /* Recurse for AREA_LV */ 776 for (s = 0; s < seg->area_count; s++) { 777 if (seg_type(seg, s) != AREA_LV) 778 continue; 779 if (!monitor_dev_for_events(cmd, seg_lv(seg, s), 780 monitor)) { 781 log_error("Failed to %smonitor %s", 782 monitor ? "" : "un", 783 seg_lv(seg, s)->name); 784 r = 0; 785 } 786 } 787 788 if (!seg_monitored(seg) || (seg->status & PVMOVE)) 789 continue; 790 791 monitor_fn = NULL; 792 793 /* Check monitoring status */ 794 if (seg->segtype->ops->target_monitored) 795 monitored = seg->segtype->ops->target_monitored(seg, &pending); 796 else 797 continue; /* segtype doesn't support registration */ 798 799 /* 800 * FIXME: We should really try again if pending 801 */ 802 monitored = (pending) ? 0 : monitored; 803 804 if (monitor) { 805 if (monitored) 806 log_verbose("%s/%s already monitored.", lv->vg->name, lv->name); 807 else if (seg->segtype->ops->target_monitor_events) 808 monitor_fn = seg->segtype->ops->target_monitor_events; 809 } else { 810 if (!monitored) 811 log_verbose("%s/%s already not monitored.", lv->vg->name, lv->name); 812 else if (seg->segtype->ops->target_unmonitor_events) 813 monitor_fn = seg->segtype->ops->target_unmonitor_events; 814 } 815 816 /* Do [un]monitor */ 817 if (!monitor_fn) 818 continue; 819 820 log_verbose("%sonitoring %s/%s", monitor ? "M" : "Not m", lv->vg->name, lv->name); 821 822 /* FIXME specify events */ 823 if (!monitor_fn(seg, 0)) { 824 log_error("%s/%s: %s segment monitoring function failed.", 825 lv->vg->name, lv->name, seg->segtype->name); 826 return 0; 827 } 828 829 /* Check [un]monitor results */ 830 /* Try a couple times if pending, but not forever... */ 831 for (i = 0; i < 10; i++) { 832 pending = 0; 833 monitored = seg->segtype->ops->target_monitored(seg, &pending); 834 if (pending || 835 (!monitored && monitor) || 836 (monitored && !monitor)) 837 log_very_verbose("%s/%s %smonitoring still pending: waiting...", 838 lv->vg->name, lv->name, monitor ? "" : "un"); 839 else 840 break; 841 sleep(1); 842 } 843 844 r = (monitored && monitor) || (!monitored && !monitor); 845 } 846 847 return r; 848 #else 849 return 1; 850 #endif 851 } 852 853 static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s, 854 int error_if_not_suspended) 855 { 856 struct logical_volume *lv = NULL, *lv_pre = NULL; 857 struct lvinfo info; 858 int r = 0, lockfs = 0, flush_required = 0; 859 860 if (!activation()) 861 return 1; 862 863 if (!(lv = lv_from_lvid(cmd, lvid_s, 0))) 864 goto_out; 865 866 /* Use precommitted metadata if present */ 867 if (!(lv_pre = lv_from_lvid(cmd, lvid_s, 1))) 868 goto_out; 869 870 if (test_mode()) { 871 _skip("Suspending '%s'.", lv->name); 872 r = 1; 873 goto out; 874 } 875 876 if (!lv_info(cmd, lv, &info, 0, 0)) 877 goto_out; 878 879 if (!info.exists || info.suspended) { 880 r = error_if_not_suspended ? 0 : 1; 881 goto out; 882 } 883 884 lv_calculate_readahead(lv, NULL); 885 886 /* If VG was precommitted, preload devices for the LV */ 887 if ((lv_pre->vg->status & PRECOMMITTED)) { 888 if (!_lv_preload(lv_pre, &flush_required)) { 889 /* FIXME Revert preloading */ 890 goto_out; 891 } 892 } 893 894 if (!monitor_dev_for_events(cmd, lv, 0)) 895 /* FIXME Consider aborting here */ 896 stack; 897 898 memlock_inc(); 899 900 if (lv_is_origin(lv_pre) || lv_is_cow(lv_pre)) 901 lockfs = 1; 902 903 if (!_lv_suspend_lv(lv, lockfs, flush_required)) { 904 memlock_dec(); 905 fs_unlock(); 906 goto out; 907 } 908 909 r = 1; 910 out: 911 if (lv_pre) 912 vg_release(lv_pre->vg); 913 if (lv) 914 vg_release(lv->vg); 915 916 return r; 917 } 918 919 /* Returns success if the device is not active */ 920 int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s) 921 { 922 return _lv_suspend(cmd, lvid_s, 0); 923 } 924 925 int lv_suspend(struct cmd_context *cmd, const char *lvid_s) 926 { 927 return _lv_suspend(cmd, lvid_s, 1); 928 } 929 930 static int _lv_resume(struct cmd_context *cmd, const char *lvid_s, 931 int error_if_not_active) 932 { 933 struct logical_volume *lv; 934 struct lvinfo info; 935 int r = 0; 936 937 if (!activation()) 938 return 1; 939 940 if (!(lv = lv_from_lvid(cmd, lvid_s, 0))) 941 goto_out; 942 943 if (test_mode()) { 944 _skip("Resuming '%s'.", lv->name); 945 r = 1; 946 goto out; 947 } 948 949 if (!lv_info(cmd, lv, &info, 0, 0)) 950 goto_out; 951 952 if (!info.exists || !info.suspended) { 953 r = error_if_not_active ? 0 : 1; 954 goto_out; 955 } 956 957 if (!_lv_activate_lv(lv)) 958 goto_out; 959 960 memlock_dec(); 961 fs_unlock(); 962 963 if (!monitor_dev_for_events(cmd, lv, 1)) 964 stack; 965 966 r = 1; 967 out: 968 if (lv) 969 vg_release(lv->vg); 970 971 return r; 972 } 973 974 /* Returns success if the device is not active */ 975 int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s) 976 { 977 return _lv_resume(cmd, lvid_s, 0); 978 } 979 980 int lv_resume(struct cmd_context *cmd, const char *lvid_s) 981 { 982 return _lv_resume(cmd, lvid_s, 1); 983 } 984 985 static int _lv_has_open_snapshots(struct logical_volume *lv) 986 { 987 struct lv_segment *snap_seg; 988 struct lvinfo info; 989 int r = 0; 990 991 dm_list_iterate_items_gen(snap_seg, &lv->snapshot_segs, origin_list) { 992 if (!lv_info(lv->vg->cmd, snap_seg->cow, &info, 1, 0)) { 993 r = 1; 994 continue; 995 } 996 997 if (info.exists && info.open_count) { 998 log_error("LV %s/%s has open snapshot %s: " 999 "not deactivating", lv->vg->name, lv->name, 1000 snap_seg->cow->name); 1001 r = 1; 1002 } 1003 } 1004 1005 return r; 1006 } 1007 1008 int lv_deactivate(struct cmd_context *cmd, const char *lvid_s) 1009 { 1010 struct logical_volume *lv; 1011 struct lvinfo info; 1012 int r = 0; 1013 1014 if (!activation()) 1015 return 1; 1016 1017 if (!(lv = lv_from_lvid(cmd, lvid_s, 0))) 1018 goto out; 1019 1020 if (test_mode()) { 1021 _skip("Deactivating '%s'.", lv->name); 1022 r = 1; 1023 goto out; 1024 } 1025 1026 if (!lv_info(cmd, lv, &info, 1, 0)) 1027 goto_out; 1028 1029 if (!info.exists) { 1030 r = 1; 1031 goto out; 1032 } 1033 1034 if (lv_is_visible(lv)) { 1035 if (info.open_count) { 1036 log_error("LV %s/%s in use: not deactivating", 1037 lv->vg->name, lv->name); 1038 goto out; 1039 } 1040 if (lv_is_origin(lv) && _lv_has_open_snapshots(lv)) 1041 goto_out; 1042 } 1043 1044 lv_calculate_readahead(lv, NULL); 1045 1046 if (!monitor_dev_for_events(cmd, lv, 0)) 1047 stack; 1048 1049 memlock_inc(); 1050 r = _lv_deactivate(lv); 1051 memlock_dec(); 1052 fs_unlock(); 1053 1054 if (!lv_info(cmd, lv, &info, 1, 0) || info.exists) 1055 r = 0; 1056 out: 1057 if (lv) 1058 vg_release(lv->vg); 1059 1060 return r; 1061 } 1062 1063 /* Test if LV passes filter */ 1064 int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s, 1065 int *activate_lv) 1066 { 1067 struct logical_volume *lv; 1068 int r = 0; 1069 1070 if (!activation()) { 1071 *activate_lv = 1; 1072 return 1; 1073 } 1074 1075 if (!(lv = lv_from_lvid(cmd, lvid_s, 0))) 1076 goto out; 1077 1078 if (!_passes_activation_filter(cmd, lv)) { 1079 log_verbose("Not activating %s/%s due to config file settings", 1080 lv->vg->name, lv->name); 1081 *activate_lv = 0; 1082 } else 1083 *activate_lv = 1; 1084 r = 1; 1085 out: 1086 if (lv) 1087 vg_release(lv->vg); 1088 1089 return r; 1090 } 1091 1092 static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, 1093 int exclusive, int filter) 1094 { 1095 struct logical_volume *lv; 1096 struct lvinfo info; 1097 int r = 0; 1098 1099 if (!activation()) 1100 return 1; 1101 1102 if (!(lv = lv_from_lvid(cmd, lvid_s, 0))) 1103 goto out; 1104 1105 if (filter && !_passes_activation_filter(cmd, lv)) { 1106 log_verbose("Not activating %s/%s due to config file settings", 1107 lv->vg->name, lv->name); 1108 goto out; 1109 } 1110 1111 if ((!lv->vg->cmd->partial_activation) && (lv->status & PARTIAL_LV)) { 1112 log_error("Refusing activation of partial LV %s. Use --partial to override.", 1113 lv->name); 1114 goto_out; 1115 } 1116 1117 if (lv_has_unknown_segments(lv)) { 1118 log_error("Refusing activation of LV %s containing " 1119 "an unrecognised segment.", lv->name); 1120 goto_out; 1121 } 1122 1123 if (test_mode()) { 1124 _skip("Activating '%s'.", lv->name); 1125 r = 1; 1126 goto out; 1127 } 1128 1129 if (!lv_info(cmd, lv, &info, 0, 0)) 1130 goto_out; 1131 1132 if (info.exists && !info.suspended && info.live_table) { 1133 r = 1; 1134 goto out; 1135 } 1136 1137 lv_calculate_readahead(lv, NULL); 1138 1139 if (exclusive) 1140 lv->status |= ACTIVATE_EXCL; 1141 1142 memlock_inc(); 1143 if (!(r = _lv_activate_lv(lv))) 1144 stack; 1145 memlock_dec(); 1146 fs_unlock(); 1147 1148 if (r && !monitor_dev_for_events(cmd, lv, 1)) 1149 stack; 1150 1151 out: 1152 if (lv) 1153 vg_release(lv->vg); 1154 1155 return r; 1156 } 1157 1158 /* Activate LV */ 1159 int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive) 1160 { 1161 if (!_lv_activate(cmd, lvid_s, exclusive, 0)) 1162 return_0; 1163 1164 return 1; 1165 } 1166 1167 /* Activate LV only if it passes filter */ 1168 int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s, int exclusive) 1169 { 1170 if (!_lv_activate(cmd, lvid_s, exclusive, 1)) 1171 return_0; 1172 1173 return 1; 1174 } 1175 1176 int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv) 1177 { 1178 struct lvinfo info; 1179 int r = 1; 1180 1181 if (!lv) { 1182 r = dm_mknodes(NULL); 1183 fs_unlock(); 1184 return r; 1185 } 1186 1187 if (!_lv_info(cmd, lv, 1, &info, 0, 0, 0)) 1188 return_0; 1189 1190 if (info.exists) { 1191 if (lv_is_visible(lv)) 1192 r = dev_manager_lv_mknodes(lv); 1193 } else 1194 r = dev_manager_lv_rmnodes(lv); 1195 1196 fs_unlock(); 1197 1198 return r; 1199 } 1200 1201 /* 1202 * Does PV use VG somewhere in its construction? 1203 * Returns 1 on failure. 1204 */ 1205 int pv_uses_vg(struct physical_volume *pv, 1206 struct volume_group *vg) 1207 { 1208 if (!activation()) 1209 return 0; 1210 1211 if (!dm_is_dm_major(MAJOR(pv->dev->dev))) 1212 return 0; 1213 1214 return dev_manager_device_uses_vg(pv->dev, vg); 1215 } 1216 1217 void activation_release(void) 1218 { 1219 dev_manager_release(); 1220 } 1221 1222 void activation_exit(void) 1223 { 1224 dev_manager_exit(); 1225 } 1226 #endif 1227