tools/pvmove.c

   1 /*
   2  * Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.
   3  * Copyright (C) 2004-2010 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 "tools.h"
  17 #include "polldaemon.h"
  18 #include "display.h"
  19
  20 #define PVMOVE_FIRST_TIME   0x00000001      /* Called for first time */
  21
  22 static int _pvmove_target_present(struct cmd_context *cmd, int clustered)
  23 {
  24         const struct segment_type *segtype;
  25         unsigned attr = 0;
  26         int found = 1;
  27         static int _clustered_found = -1;
  28
  29         if (clustered && _clustered_found >= 0)
  30                 return _clustered_found;
  31
  32         if (!(segtype = get_segtype_from_string(cmd, "mirror")))
  33                 return_0;
  34
  35         if (activation() && segtype->ops->target_present &&
  36             !segtype->ops->target_present(cmd, NULL, clustered ? &attr : NULL))
  37                 found = 0;
  38
  39         if (activation() && clustered) {
  40                 if (found && (attr & MIRROR_LOG_CLUSTERED))
  41                         _clustered_found = found = 1;
  42                 else
  43                         _clustered_found = found = 0;
  44         }
  45
  46         return found;
  47 }
  48
  49 static unsigned _pvmove_is_exclusive(struct cmd_context *cmd,
  50                                      struct volume_group *vg)
  51 {
  52         if (vg_is_clustered(vg))
  53                 if (!_pvmove_target_present(cmd, 1))
  54                         return 1;
  55
  56         return 0;
  57 }
  58
  59 /* Allow /dev/vgname/lvname, vgname/lvname or lvname */
  60 static const char *_extract_lvname(struct cmd_context *cmd, const char *vgname,
  61                                    const char *arg)
  62 {
  63         const char *lvname;
  64
  65         /* Is an lvname supplied directly? */
  66         if (!strchr(arg, '/'))
  67                 return arg;
  68
  69         lvname = skip_dev_dir(cmd, arg, NULL);
  70         while (*lvname == '/')
  71                 lvname++;
  72         if (!strchr(lvname, '/')) {
  73                 log_error("--name takes a logical volume name");
  74                 return NULL;
  75         }
  76         if (strncmp(vgname, lvname, strlen(vgname)) ||
  77             (lvname += strlen(vgname), *lvname != '/')) {
  78                 log_error("Named LV and old PV must be in the same VG");
  79                 return NULL;
  80         }
  81         while (*lvname == '/')
  82                 lvname++;
  83         if (!*lvname) {
  84                 log_error("Incomplete LV name supplied with --name");
  85                 return NULL;
  86         }
  87         return lvname;
  88 }
  89
  90 static struct volume_group *_get_vg(struct cmd_context *cmd, const char *vgname)
  91 {
  92         dev_close_all();
  93
  94         return vg_read_for_update(cmd, vgname, NULL, 0);
  95 }
  96
  97 /* Create list of PVs for allocation of replacement extents */
  98 static struct dm_list *_get_allocatable_pvs(struct cmd_context *cmd, int argc,
  99                                          char **argv, struct volume_group *vg,
 100                                          struct physical_volume *pv,
 101                                          alloc_policy_t alloc)
 102 {
 103         struct dm_list *allocatable_pvs, *pvht, *pvh;
 104         struct pv_list *pvl;
 105
 106         if (argc)
 107                 allocatable_pvs = create_pv_list(cmd->mem, vg, argc, argv, 1);
 108         else
 109                 allocatable_pvs = clone_pv_list(cmd->mem, &vg->pvs);
 110
 111         if (!allocatable_pvs)
 112                 return_NULL;
 113
 114         dm_list_iterate_safe(pvh, pvht, allocatable_pvs) {
 115                 pvl = dm_list_item(pvh, struct pv_list);
 116
 117                 /* Don't allocate onto the PV we're clearing! */
 118                 if ((alloc != ALLOC_ANYWHERE) && (pvl->pv->dev == pv_dev(pv))) {
 119                         dm_list_del(&pvl->list);
 120                         continue;
 121                 }
 122
 123                 /* Remove PV if full */
 124                 if ((pvl->pv->pe_count == pvl->pv->pe_alloc_count))
 125                         dm_list_del(&pvl->list);
 126         }
 127
 128         if (dm_list_empty(allocatable_pvs)) {
 129                 log_error("No extents available for allocation");
 130                 return NULL;
 131         }
 132
 133         return allocatable_pvs;
 134 }
 135
 136 /*
 137  * Replace any LV segments on given PV with temporary mirror.
 138  * Returns list of LVs changed.
 139  */
 140 static int _insert_pvmove_mirrors(struct cmd_context *cmd,
 141                                   struct logical_volume *lv_mirr,
 142                                   struct dm_list *source_pvl,
 143                                   struct logical_volume *lv,
 144                                   struct dm_list *lvs_changed)
 145
 146 {
 147         struct pv_list *pvl;
 148         uint32_t prev_le_count;
 149
 150         /* Only 1 PV may feature in source_pvl */
 151         pvl = dm_list_item(source_pvl->n, struct pv_list);
 152
 153         prev_le_count = lv_mirr->le_count;
 154         if (!insert_layer_for_segments_on_pv(cmd, lv, lv_mirr, PVMOVE,
 155                                              pvl, lvs_changed))
 156                 return_0;
 157
 158         /* check if layer was inserted */
 159         if (lv_mirr->le_count - prev_le_count) {
 160                 lv->status |= LOCKED;
 161
 162                 log_verbose("Moving %u extents of logical volume %s/%s",
 163                             lv_mirr->le_count - prev_le_count,
 164                             lv->vg->name, lv->name);
 165         }
 166
 167         return 1;
 168 }
 169
 170 /* Create new LV with mirror segments for the required copies */
 171 static struct logical_volume *_set_up_pvmove_lv(struct cmd_context *cmd,
 172                                                 struct volume_group *vg,
 173                                                 struct dm_list *source_pvl,
 174                                                 const char *lv_name,
 175                                                 struct dm_list *allocatable_pvs,
 176                                                 alloc_policy_t alloc,
 177                                                 struct dm_list **lvs_changed)
 178 {
 179         struct logical_volume *lv_mirr, *lv;
 180         struct lv_list *lvl;
 181         uint32_t log_count = 0;
 182         int lv_found = 0;
 183         int lv_skipped = 0;
 184
 185         /* FIXME Cope with non-contiguous => splitting existing segments */
 186         if (!(lv_mirr = lv_create_empty("pvmove%d", NULL,
 187                                         LVM_READ | LVM_WRITE,
 188                                         ALLOC_CONTIGUOUS, vg))) {
 189                 log_error("Creation of temporary pvmove LV failed");
 190                 return NULL;
 191         }
 192
 193         lv_mirr->status |= (PVMOVE | LOCKED);
 194
 195         if (!(*lvs_changed = dm_pool_alloc(cmd->mem, sizeof(**lvs_changed)))) {
 196                 log_error("lvs_changed list struct allocation failed");
 197                 return NULL;
 198         }
 199
 200         dm_list_init(*lvs_changed);
 201
 202         /* Find segments to be moved and set up mirrors */
 203         dm_list_iterate_items(lvl, &vg->lvs) {
 204                 lv = lvl->lv;
 205                 if ((lv == lv_mirr))
 206                         continue;
 207                 if (lv_name) {
 208                         if (strcmp(lv->name, lv_name))
 209                                 continue;
 210                         lv_found = 1;
 211                 }
 212                 if (lv_is_origin(lv) || lv_is_cow(lv)) {
 213                         lv_skipped = 1;
 214                         log_print("Skipping snapshot-related LV %s", lv->name);
 215                         continue;
 216                 }
 217                 if (lv->status & MIRRORED) {
 218                         lv_skipped = 1;
 219                         log_print("Skipping mirror LV %s", lv->name);
 220                         continue;
 221                 }
 222                 if (lv->status & MIRROR_LOG) {
 223                         lv_skipped = 1;
 224                         log_print("Skipping mirror log LV %s", lv->name);
 225                         continue;
 226                 }
 227                 if (lv->status & MIRROR_IMAGE) {
 228                         lv_skipped = 1;
 229                         log_print("Skipping mirror image LV %s", lv->name);
 230                         continue;
 231                 }
 232                 if (lv->status & LOCKED) {
 233                         lv_skipped = 1;
 234                         log_print("Skipping locked LV %s", lv->name);
 235                         continue;
 236                 }
 237                 if (!_insert_pvmove_mirrors(cmd, lv_mirr, source_pvl, lv,
 238                                             *lvs_changed))
 239                         return_NULL;
 240         }
 241
 242         if (lv_name && !lv_found) {
 243                 log_error("Logical volume %s not found.", lv_name);
 244                 return NULL;
 245         }
 246
 247         /* Is temporary mirror empty? */
 248         if (!lv_mirr->le_count) {
 249                 if (lv_skipped)
 250                         log_error("All data on source PV skipped. "
 251                                   "It contains locked, hidden or "
 252                                   "non-top level LVs only.");
 253                 log_error("No data to move for %s", vg->name);
 254                 return NULL;
 255         }
 256
 257         if (!lv_add_mirrors(cmd, lv_mirr, 1, 1, 0, 0, log_count,
 258                             allocatable_pvs, alloc, MIRROR_BY_SEG)) {
 259                 log_error("Failed to convert pvmove LV to mirrored");
 260                 return_NULL;
 261         }
 262
 263         if (!split_parent_segments_for_layer(cmd, lv_mirr)) {
 264                 log_error("Failed to split segments being moved");
 265                 return_NULL;
 266         }
 267
 268         return lv_mirr;
 269 }
 270
 271 static int _activate_lv(struct cmd_context *cmd, struct logical_volume *lv_mirr,
 272                         unsigned exclusive)
 273 {
 274         int r = 0;
 275
 276         if (exclusive)
 277                 r = activate_lv_excl(cmd, lv_mirr);
 278         else
 279                 r = activate_lv(cmd, lv_mirr);
 280
 281         if (!r)
 282                 stack;
 283
 284         return r;
 285 }
 286
 287 static int _detach_pvmove_mirror(struct cmd_context *cmd,
 288                                  struct logical_volume *lv_mirr)
 289 {
 290         struct dm_list lvs_completed;
 291         struct lv_list *lvl;
 292
 293         /* Update metadata to remove mirror segments and break dependencies */
 294         dm_list_init(&lvs_completed);
 295         if (!lv_remove_mirrors(cmd, lv_mirr, 1, 0, NULL, NULL, PVMOVE) ||
 296             !remove_layers_for_segments_all(cmd, lv_mirr, PVMOVE,
 297                                             &lvs_completed)) {
 298                 return 0;
 299         }
 300
 301         dm_list_iterate_items(lvl, &lvs_completed)
 302                 /* FIXME Assumes only one pvmove at a time! */
 303                 lvl->lv->status &= ~LOCKED;
 304
 305         return 1;
 306 }
 307
 308 static int _update_metadata(struct cmd_context *cmd, struct volume_group *vg,
 309                             struct logical_volume *lv_mirr,
 310                             struct dm_list *lvs_changed, unsigned flags)
 311 {
 312         unsigned exclusive = _pvmove_is_exclusive(cmd, vg);
 313         unsigned first_time = (flags & PVMOVE_FIRST_TIME) ? 1 : 0;
 314         int r = 0;
 315
 316         log_verbose("Updating volume group metadata");
 317         if (!vg_write(vg)) {
 318                 log_error("ABORTING: Volume group metadata update failed.");
 319                 return 0;
 320         }
 321
 322         /* Suspend lvs_changed */
 323         if (!suspend_lvs(cmd, lvs_changed)) {
 324                 vg_revert(vg);
 325                 goto_out;
 326         }
 327
 328         /* Suspend mirrors on subsequent calls */
 329         if (!first_time) {
 330                 if (!suspend_lv(cmd, lv_mirr)) {
 331                         if (!resume_lvs(cmd, lvs_changed))
 332                                 stack;
 333                         vg_revert(vg);
 334                         goto_out;
 335                 }
 336         }
 337
 338         /* Commit on-disk metadata */
 339         if (!vg_commit(vg)) {
 340                 log_error("ABORTING: Volume group metadata update failed.");
 341                 if (!first_time)
 342                         if (!resume_lv(cmd, lv_mirr))
 343                                 stack;
 344                 if (!resume_lvs(cmd, lvs_changed))
 345                         stack;
 346                 vg_revert(vg);
 347                 goto out;
 348         }
 349
 350         /* Activate the temporary mirror LV */
 351         /* Only the first mirror segment gets activated as a mirror */
 352         /* FIXME: Add option to use a log */
 353         if (first_time) {
 354                 if (!_activate_lv(cmd, lv_mirr, exclusive)) {
 355                         if (test_mode()) {
 356                                 r = 1;
 357                                 goto out;
 358                         }
 359
 360                         /*
 361                          * FIXME: review ordering of operations above,
 362                          * temporary mirror should be preloaded in suspend.
 363                          * Also banned operation here when suspended.
 364                          * Nothing changed yet, try to revert pvmove.
 365                          */
 366                         log_error("Temporary pvmove mirror activation failed.");
 367
 368                         /* Ensure that temporary mrror is deactivate even on other nodes. */
 369                         (void)deactivate_lv(cmd, lv_mirr);
 370
 371                         /* Revert metadata */
 372                         if (!_detach_pvmove_mirror(cmd, lv_mirr) ||
 373                             !lv_remove(lv_mirr) ||
 374                             !vg_write(vg) || !vg_commit(vg))
 375                                 log_error("ABORTING: Restoring original configuration "
 376                                           "before pvmove failed. Run pvmove --abort.");
 377
 378                         /* Unsuspend LVs */
 379                         if(!resume_lvs(cmd, lvs_changed))
 380                                 stack;
 381
 382                         goto out;
 383                 }
 384         } else if (!resume_lv(cmd, lv_mirr)) {
 385                 log_error("Unable to reactivate logical volume \"%s\"",
 386                           lv_mirr->name);
 387                 if (!resume_lvs(cmd, lvs_changed))
 388                         stack;
 389                 goto out;
 390         }
 391
 392         /* Unsuspend LVs */
 393         if (!resume_lvs(cmd, lvs_changed)) {
 394                 log_error("Unable to resume logical volumes");
 395                 goto out;
 396         }
 397
 398         r = 1;
 399 out:
 400         backup(vg);
 401         return r;
 402 }
 403
 404 static int _set_up_pvmove(struct cmd_context *cmd, const char *pv_name,
 405                           int argc, char **argv)
 406 {
 407         const char *lv_name = NULL;
 408         char *pv_name_arg;
 409         struct volume_group *vg;
 410         struct dm_list *source_pvl;
 411         struct dm_list *allocatable_pvs;
 412         alloc_policy_t alloc;
 413         struct dm_list *lvs_changed;
 414         struct physical_volume *pv;
 415         struct logical_volume *lv_mirr;
 416         unsigned first_time = 1;
 417         unsigned exclusive;
 418         int r = ECMD_FAILED;
 419
 420         pv_name_arg = argv[0];
 421         argc--;
 422         argv++;
 423
 424         /* Find PV (in VG) */
 425         if (!(pv = find_pv_by_name(cmd, pv_name))) {
 426                 stack;
 427                 return EINVALID_CMD_LINE;
 428         }
 429
 430         if (arg_count(cmd, name_ARG)) {
 431                 if (!(lv_name = _extract_lvname(cmd, pv_vg_name(pv),
 432                                                 arg_value(cmd, name_ARG)))) {
 433                         stack;
 434                         return EINVALID_CMD_LINE;
 435                 }
 436
 437                 if (!validate_name(lv_name)) {
 438                         log_error("Logical volume name %s is invalid", lv_name);
 439                         return EINVALID_CMD_LINE;
 440                 }
 441         }
 442
 443         /* Read VG */
 444         log_verbose("Finding volume group \"%s\"", pv_vg_name(pv));
 445
 446         vg = _get_vg(cmd, pv_vg_name(pv));
 447         if (vg_read_error(vg)) {
 448                 free_vg(vg);
 449                 stack;
 450                 return ECMD_FAILED;
 451         }
 452
 453         exclusive = _pvmove_is_exclusive(cmd, vg);
 454
 455         if ((lv_mirr = find_pvmove_lv(vg, pv_dev(pv), PVMOVE))) {
 456                 log_print("Detected pvmove in progress for %s", pv_name);
 457                 if (argc || lv_name)
 458                         log_error("Ignoring remaining command line arguments");
 459
 460                 if (!(lvs_changed = lvs_using_lv(cmd, vg, lv_mirr))) {
 461                         log_error("ABORTING: Failed to generate list of moving LVs");
 462                         goto out;
 463                 }
 464
 465                 /* Ensure mirror LV is active */
 466                 if (!_activate_lv(cmd, lv_mirr, exclusive)) {
 467                         log_error("ABORTING: Temporary mirror activation failed.");
 468                         goto out;
 469                 }
 470
 471                 first_time = 0;
 472         } else {
 473                 /* Determine PE ranges to be moved */
 474                 if (!(source_pvl = create_pv_list(cmd->mem, vg, 1,
 475                                                   &pv_name_arg, 0)))
 476                         goto_out;
 477
 478                 alloc = arg_uint_value(cmd, alloc_ARG, ALLOC_INHERIT);
 479                 if (alloc == ALLOC_INHERIT)
 480                         alloc = vg->alloc;
 481
 482                 /* Get PVs we can use for allocation */
 483                 if (!(allocatable_pvs = _get_allocatable_pvs(cmd, argc, argv,
 484                                                              vg, pv, alloc)))
 485                         goto_out;
 486
 487                 if (!archive(vg))
 488                         goto_out;
 489
 490                 if (!(lv_mirr = _set_up_pvmove_lv(cmd, vg, source_pvl, lv_name,
 491                                                   allocatable_pvs, alloc,
 492                                                   &lvs_changed)))
 493                         goto_out;
 494         }
 495
 496         /* Lock lvs_changed and activate (with old metadata) */
 497         if (!activate_lvs(cmd, lvs_changed, exclusive))
 498                 goto_out;
 499
 500         /* FIXME Presence of a mirror once set PVMOVE - now remove associated logic */
 501         /* init_pvmove(1); */
 502         /* vg->status |= PVMOVE; */
 503
 504         if (first_time) {
 505                 if (!_update_metadata
 506                     (cmd, vg, lv_mirr, lvs_changed, PVMOVE_FIRST_TIME))
 507                         goto_out;
 508         }
 509
 510         /* LVs are all in status LOCKED */
 511         r = ECMD_PROCESSED;
 512 out:
 513         unlock_and_free_vg(cmd, vg, pv_vg_name(pv));
 514         return r;
 515 }
 516
 517 static int _finish_pvmove(struct cmd_context *cmd, struct volume_group *vg,
 518                           struct logical_volume *lv_mirr,
 519                           struct dm_list *lvs_changed)
 520 {
 521         int r = 1;
 522
 523         if (!dm_list_empty(lvs_changed) &&
 524             !_detach_pvmove_mirror(cmd, lv_mirr)) {
 525                 log_error("ABORTING: Removal of temporary mirror failed");
 526                 return 0;
 527         }
 528
 529         /* Store metadata without dependencies on mirror segments */
 530         if (!vg_write(vg)) {
 531                 log_error("ABORTING: Failed to write new data locations "
 532                           "to disk.");
 533                 return 0;
 534         }
 535
 536         /* Suspend LVs changed */
 537         if (!suspend_lvs(cmd, lvs_changed)) {
 538                 log_error("Locking LVs to remove temporary mirror failed");
 539                 r = 0;
 540         }
 541
 542         /* Suspend mirror LV to flush pending I/O */
 543         if (!suspend_lv(cmd, lv_mirr)) {
 544                 log_error("Suspension of temporary mirror LV failed");
 545                 r = 0;
 546         }
 547
 548         /* Store metadata without dependencies on mirror segments */
 549         if (!vg_commit(vg)) {
 550                 log_error("ABORTING: Failed to write new data locations "
 551                           "to disk.");
 552                 vg_revert(vg);
 553                 if (!resume_lv(cmd, lv_mirr))
 554                         stack;
 555                 if (!resume_lvs(cmd, lvs_changed))
 556                         stack;
 557                 return 0;
 558         }
 559
 560         /* Release mirror LV.  (No pending I/O because it's been suspended.) */
 561         if (!resume_lv(cmd, lv_mirr)) {
 562                 log_error("Unable to reactivate logical volume \"%s\"",
 563                           lv_mirr->name);
 564                 r = 0;
 565         }
 566
 567         /* Unsuspend LVs */
 568         if (!resume_lvs(cmd, lvs_changed))
 569                 stack;
 570
 571         /* Deactivate mirror LV */
 572         if (!deactivate_lv(cmd, lv_mirr)) {
 573                 log_error("ABORTING: Unable to deactivate temporary logical "
 574                           "volume \"%s\"", lv_mirr->name);
 575                 r = 0;
 576         }
 577
 578         log_verbose("Removing temporary pvmove LV");
 579         if (!lv_remove(lv_mirr)) {
 580                 log_error("ABORTING: Removal of temporary pvmove LV failed");
 581                 return 0;
 582         }
 583
 584         /* Store it on disks */
 585         log_verbose("Writing out final volume group after pvmove");
 586         if (!vg_write(vg) || !vg_commit(vg)) {
 587                 log_error("ABORTING: Failed to write new data locations "
 588                           "to disk.");
 589                 return 0;
 590         }
 591
 592         /* FIXME backup positioning */
 593         backup(vg);
 594
 595         return r;
 596 }
 597
 598 static struct volume_group *_get_move_vg(struct cmd_context *cmd,
 599                                          const char *name,
 600                                          const char *uuid __attribute__((unused)))
 601 {
 602         struct physical_volume *pv;
 603
 604         /* Reread all metadata in case it got changed */
 605         if (!(pv = find_pv_by_name(cmd, name))) {
 606                 log_error("ABORTING: Can't reread PV %s", name);
 607                 /* What more could we do here? */
 608                 return NULL;
 609         }
 610
 611         return _get_vg(cmd, pv_vg_name(pv));
 612 }
 613
 614 static struct poll_functions _pvmove_fns = {
 615         .get_copy_name_from_lv = get_pvmove_pvname_from_lv_mirr,
 616         .get_copy_vg = _get_move_vg,
 617         .get_copy_lv = find_pvmove_lv_from_pvname,
 618         .poll_progress = poll_mirror_progress,
 619         .update_metadata = _update_metadata,
 620         .finish_copy = _finish_pvmove,
 621 };
 622
 623 int pvmove_poll(struct cmd_context *cmd, const char *pv_name,
 624                 unsigned background)
 625 {
 626         if (test_mode())
 627                 return ECMD_PROCESSED;
 628
 629         return poll_daemon(cmd, pv_name, NULL, background, PVMOVE, &_pvmove_fns,
 630                            "Moved");
 631 }
 632
 633 int pvmove(struct cmd_context *cmd, int argc, char **argv)
 634 {
 635         char *pv_name = NULL;
 636         char *colon;
 637         int ret;
 638
 639         /* dm raid1 target must be present in every case */
 640         if (!_pvmove_target_present(cmd, 0)) {
 641                 log_error("Required device-mapper target(s) not "
 642                           "detected in your kernel");
 643                 return ECMD_FAILED;
 644         }
 645
 646         if (argc) {
 647                 if (!(pv_name = dm_pool_strdup(cmd->mem, argv[0]))) {
 648                         log_error("Failed to clone PV name");
 649                         return ECMD_FAILED;
 650                 }
 651
 652                 unescape_colons_and_at_signs(pv_name, &colon, NULL);
 653
 654                 /* Drop any PE lists from PV name */
 655                 if (colon)
 656                         *colon = '\0';
 657
 658                 if (!arg_count(cmd, abort_ARG) &&
 659                     (ret = _set_up_pvmove(cmd, pv_name, argc, argv)) !=
 660                     ECMD_PROCESSED) {
 661                         stack;
 662                         return ret;
 663                 }
 664         }
 665
 666         return pvmove_poll(cmd, pv_name, arg_is_set(cmd, background_ARG));
 667 }