lib/activate/activate.c

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