external/gpl2/lvm2/dist/tools/lvconvert.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2005-2007 Red Hat, Inc. All rights reserved.
   5  *
   6  * This file is part of LVM2.
   7  *
   8  * This copyrighted material is made available to anyone wishing to use,
   9  * modify, copy, or redistribute it subject to the terms and conditions
  10  * of the GNU Lesser General Public License v.2.1.
  11  *
  12  * You should have received a copy of the GNU Lesser General Public License
  13  * along with this program; if not, write to the Free Software Foundation,
  14  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 #include "tools.h"
  18 #include "polldaemon.h"
  19 #include "lv_alloc.h"
  20
  21 struct lvconvert_params {
  22         int snapshot;
  23         int zero;
  24
  25         const char *origin;
  26         const char *lv_name;
  27         const char *lv_name_full;
  28         const char *vg_name;
  29         int wait_completion;
  30         int need_polling;
  31
  32         uint32_t chunk_size;
  33         uint32_t region_size;
  34
  35         uint32_t mirrors;
  36         sign_t mirrors_sign;
  37
  38         struct segment_type *segtype;
  39
  40         alloc_policy_t alloc;
  41
  42         int pv_count;
  43         char **pvs;
  44         struct dm_list *pvh;
  45 };
  46
  47 static int _lvconvert_name_params(struct lvconvert_params *lp,
  48                                   struct cmd_context *cmd,
  49                                   int *pargc, char ***pargv)
  50 {
  51         char *ptr;
  52         const char *vg_name = NULL;
  53
  54         if (lp->snapshot) {
  55                 if (!*pargc) {
  56                         log_error("Please specify a logical volume to act as "
  57                                   "the snapshot origin.");
  58                         return 0;
  59                 }
  60
  61                 lp->origin = *pargv[0];
  62                 (*pargv)++, (*pargc)--;
  63                 if (!(lp->vg_name = extract_vgname(cmd, lp->origin))) {
  64                         log_error("The origin name should include the "
  65                                   "volume group.");
  66                         return 0;
  67                 }
  68
  69                 /* Strip the volume group from the origin */
  70                 if ((ptr = strrchr(lp->origin, (int) '/')))
  71                         lp->origin = ptr + 1;
  72         }
  73
  74         if (!*pargc) {
  75                 log_error("Please provide logical volume path");
  76                 return 0;
  77         }
  78
  79         lp->lv_name = lp->lv_name_full = (*pargv)[0];
  80         (*pargv)++, (*pargc)--;
  81
  82         if (strchr(lp->lv_name_full, '/') &&
  83             (vg_name = extract_vgname(cmd, lp->lv_name_full)) &&
  84             lp->vg_name && strcmp(vg_name, lp->vg_name)) {
  85                 log_error("Please use a single volume group name "
  86                           "(\"%s\" or \"%s\")", vg_name, lp->vg_name);
  87                 return 0;
  88         }
  89
  90         if (!lp->vg_name)
  91                 lp->vg_name = vg_name;
  92
  93         if (!validate_name(lp->vg_name)) {
  94                 log_error("Please provide a valid volume group name");
  95                 return 0;
  96         }
  97
  98         if ((ptr = strrchr(lp->lv_name_full, '/')))
  99                 lp->lv_name = ptr + 1;
 100
 101         if (!apply_lvname_restrictions(lp->lv_name))
 102                 return_0;
 103
 104         return 1;
 105 }
 106
 107 static int _read_params(struct lvconvert_params *lp, struct cmd_context *cmd,
 108                         int argc, char **argv)
 109 {
 110         int region_size;
 111         int pagesize = lvm_getpagesize();
 112
 113         memset(lp, 0, sizeof(*lp));
 114
 115         if (arg_count(cmd, snapshot_ARG) &&
 116             (arg_count(cmd, mirrorlog_ARG) || arg_count(cmd, mirrors_ARG) ||
 117              arg_count(cmd, repair_ARG))) {
 118                 log_error("--snapshot argument cannot be mixed "
 119                           "with --mirrors, --repair or --log");
 120                 return 0;
 121         }
 122
 123         if (!arg_count(cmd, background_ARG))
 124                 lp->wait_completion = 1;
 125
 126         if (arg_count(cmd, snapshot_ARG))
 127                 lp->snapshot = 1;
 128
 129         if (arg_count(cmd, mirrors_ARG)) {
 130                 lp->mirrors = arg_uint_value(cmd, mirrors_ARG, 0);
 131                 lp->mirrors_sign = arg_sign_value(cmd, mirrors_ARG, 0);
 132         }
 133
 134         lp->alloc = arg_uint_value(cmd, alloc_ARG, ALLOC_INHERIT);
 135
 136         if (lp->snapshot) {
 137                 if (arg_count(cmd, regionsize_ARG)) {
 138                         log_error("--regionsize is only available with mirrors");
 139                         return 0;
 140                 }
 141
 142                 if (arg_sign_value(cmd, chunksize_ARG, 0) == SIGN_MINUS) {
 143                         log_error("Negative chunk size is invalid");
 144                         return 0;
 145                 }
 146                 lp->chunk_size = arg_uint_value(cmd, chunksize_ARG, 8);
 147                 if (lp->chunk_size < 8 || lp->chunk_size > 1024 ||
 148                     (lp->chunk_size & (lp->chunk_size - 1))) {
 149                         log_error("Chunk size must be a power of 2 in the "
 150                                   "range 4K to 512K");
 151                         return 0;
 152                 }
 153                 log_verbose("Setting chunksize to %d sectors.", lp->chunk_size);
 154
 155                 if (!(lp->segtype = get_segtype_from_string(cmd, "snapshot")))
 156                         return_0;
 157
 158                 lp->zero = strcmp(arg_str_value(cmd, zero_ARG,
 159                                                 (lp->segtype->flags &
 160                                                  SEG_CANNOT_BE_ZEROED) ?
 161                                                 "n" : "y"), "n");
 162
 163         } else {        /* Mirrors */
 164                 if (arg_count(cmd, chunksize_ARG)) {
 165                         log_error("--chunksize is only available with "
 166                                   "snapshots");
 167                         return 0;
 168                 }
 169
 170                 if (arg_count(cmd, zero_ARG)) {
 171                         log_error("--zero is only available with snapshots");
 172                         return 0;
 173                 }
 174
 175                 /*
 176                  * --regionsize is only valid if converting an LV into a mirror.
 177                  * Checked when we know the state of the LV being converted.
 178                  */
 179
 180                 if (arg_count(cmd, regionsize_ARG)) {
 181                         if (arg_sign_value(cmd, regionsize_ARG, 0) ==
 182                                     SIGN_MINUS) {
 183                                 log_error("Negative regionsize is invalid");
 184                                 return 0;
 185                         }
 186                         lp->region_size = arg_uint_value(cmd, regionsize_ARG, 0);
 187                 } else {
 188                         region_size = 2 * find_config_tree_int(cmd,
 189                                                 "activation/mirror_region_size",
 190                                                 DEFAULT_MIRROR_REGION_SIZE);
 191                         if (region_size < 0) {
 192                                 log_error("Negative regionsize in "
 193                                           "configuration file is invalid");
 194                                 return 0;
 195                         }
 196                         lp->region_size = region_size;
 197                 }
 198
 199                 if (lp->region_size % (pagesize >> SECTOR_SHIFT)) {
 200                         log_error("Region size (%" PRIu32 ") must be "
 201                                   "a multiple of machine memory "
 202                                   "page size (%d)",
 203                                   lp->region_size, pagesize >> SECTOR_SHIFT);
 204                         return 0;
 205                 }
 206
 207                 if (lp->region_size & (lp->region_size - 1)) {
 208                         log_error("Region size (%" PRIu32
 209                                   ") must be a power of 2", lp->region_size);
 210                         return 0;
 211                 }
 212
 213                 if (!lp->region_size) {
 214                         log_error("Non-zero region size must be supplied.");
 215                         return 0;
 216                 }
 217
 218                 if (!(lp->segtype = get_segtype_from_string(cmd, "mirror")))
 219                         return_0;
 220         }
 221
 222         if (activation() && lp->segtype->ops->target_present &&
 223             !lp->segtype->ops->target_present(cmd, NULL, NULL)) {
 224                 log_error("%s: Required device-mapper target(s) not "
 225                           "detected in your kernel", lp->segtype->name);
 226                 return 0;
 227         }
 228
 229         if (!_lvconvert_name_params(lp, cmd, &argc, &argv))
 230                 return_0;
 231
 232         lp->pv_count = argc;
 233         lp->pvs = argv;
 234
 235         return 1;
 236 }
 237
 238 static struct volume_group *_get_lvconvert_vg(struct cmd_context *cmd,
 239                                               const char *lv_name, const char *uuid)
 240 {
 241         dev_close_all();
 242
 243         return vg_read_for_update(cmd, extract_vgname(cmd, lv_name),
 244                                   NULL, 0);
 245 }
 246
 247 static struct logical_volume *_get_lvconvert_lv(struct cmd_context *cmd __attribute((unused)),
 248                                                 struct volume_group *vg,
 249                                                 const char *name,
 250                                                 const char *uuid,
 251                                                 uint32_t lv_type __attribute((unused)))
 252 {
 253         struct logical_volume *lv = find_lv(vg, name);
 254
 255         if (!lv || (uuid && strcmp(uuid, (char *)&lv->lvid)))
 256                 return NULL;
 257
 258         return lv;
 259 }
 260
 261 static int _update_lvconvert_mirror(struct cmd_context *cmd __attribute((unused)),
 262                                     struct volume_group *vg __attribute((unused)),
 263                                     struct logical_volume *lv __attribute((unused)),
 264                                     struct dm_list *lvs_changed __attribute((unused)),
 265                                     unsigned flags __attribute((unused)))
 266 {
 267         /* lvconvert mirror doesn't require periodical metadata update */
 268         return 1;
 269 }
 270
 271 static int _finish_lvconvert_mirror(struct cmd_context *cmd,
 272                                     struct volume_group *vg,
 273                                     struct logical_volume *lv,
 274                                     struct dm_list *lvs_changed __attribute((unused)))
 275 {
 276         int r = 0;
 277
 278         if (!collapse_mirrored_lv(lv)) {
 279                 log_error("Failed to remove temporary sync layer.");
 280                 return 0;
 281         }
 282
 283         lv->status &= ~CONVERTING;
 284
 285         log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
 286
 287         if (!vg_write(vg))
 288                 return_0;
 289
 290         if (!suspend_lv(cmd, lv)) {
 291                 log_error("Failed to lock %s", lv->name);
 292                 vg_revert(vg);
 293                 goto out;
 294         }
 295
 296         if (!vg_commit(vg)) {
 297                 resume_lv(cmd, lv);
 298                 goto_out;
 299         }
 300
 301         log_very_verbose("Updating \"%s\" in kernel", lv->name);
 302
 303         if (!resume_lv(cmd, lv)) {
 304                 log_error("Problem reactivating %s", lv->name);
 305                 goto out;
 306         }
 307
 308         r = 1;
 309         log_print("Logical volume %s converted.", lv->name);
 310 out:
 311         backup(vg);
 312         return r;
 313 }
 314
 315 static struct poll_functions _lvconvert_mirror_fns = {
 316         .get_copy_vg = _get_lvconvert_vg,
 317         .get_copy_lv = _get_lvconvert_lv,
 318         .poll_progress = poll_mirror_progress,
 319         .update_metadata = _update_lvconvert_mirror,
 320         .finish_copy = _finish_lvconvert_mirror,
 321 };
 322
 323 int lvconvert_poll(struct cmd_context *cmd, struct logical_volume *lv,
 324                    unsigned background)
 325 {
 326         int len = strlen(lv->vg->name) + strlen(lv->name) + 2;
 327         char *uuid = alloca(sizeof(lv->lvid));
 328         char *lv_full_name = alloca(len);
 329
 330
 331         if (!uuid || !lv_full_name)
 332                 return_0;
 333
 334         if (!dm_snprintf(lv_full_name, len, "%s/%s", lv->vg->name, lv->name))
 335                 return_0;
 336
 337         memcpy(uuid, &lv->lvid, sizeof(lv->lvid));
 338
 339         return poll_daemon(cmd, lv_full_name, uuid, background, 0,
 340                            &_lvconvert_mirror_fns, "Converted");
 341 }
 342
 343 static int _insert_lvconvert_layer(struct cmd_context *cmd,
 344                                    struct logical_volume *lv)
 345 {
 346         char *format, *layer_name;
 347         size_t len;
 348         int i;
 349
 350         /*
 351          * We would like to give the same number for this layer
 352          * and the newly added mimage.
 353          * However, LV name of newly added mimage is determined *after*
 354          * the LV name of this layer is determined.
 355          *
 356          * So, use generate_lv_name() to generate mimage name first
 357          * and take the number from it.
 358          */
 359
 360         len = strlen(lv->name) + 32;
 361         if (!(format = alloca(len)) ||
 362             !(layer_name = alloca(len)) ||
 363             dm_snprintf(format, len, "%s_mimage_%%d", lv->name) < 0) {
 364                 log_error("lvconvert: layer name allocation failed.");
 365                 return 0;
 366         }
 367
 368         if (!generate_lv_name(lv->vg, format, layer_name, len) ||
 369             sscanf(layer_name, format, &i) != 1) {
 370                 log_error("lvconvert: layer name generation failed.");
 371                 return 0;
 372         }
 373
 374         if (dm_snprintf(layer_name, len, MIRROR_SYNC_LAYER "_%d", i) < 0) {
 375                 log_error("layer name allocation failed.");
 376                 return 0;
 377         }
 378
 379         if (!insert_layer_for_lv(cmd, lv, 0, layer_name)) {
 380                 log_error("Failed to insert resync layer");
 381                 return 0;
 382         }
 383
 384         return 1;
 385 }
 386
 387 static int _area_missing(struct lv_segment *lvseg, int s)
 388 {
 389         if (seg_type(lvseg, s) == AREA_LV) {
 390                 if (seg_lv(lvseg, s)->status & PARTIAL_LV)
 391                         return 1;
 392         } else if ((seg_type(lvseg, s) == AREA_PV) &&
 393                    (seg_pv(lvseg, s)->status & MISSING_PV))
 394                 return 1;
 395
 396         return 0;
 397 }
 398
 399 /* FIXME we want to handle mirror stacks here... */
 400 static int _failed_mirrors_count(struct logical_volume *lv)
 401 {
 402         struct lv_segment *lvseg;
 403         int ret = 0;
 404         int s;
 405
 406         dm_list_iterate_items(lvseg, &lv->segments) {
 407                 if (!seg_is_mirrored(lvseg))
 408                         return -1;
 409                 for (s = 0; s < lvseg->area_count; s++)
 410                         if (_area_missing(lvseg, s))
 411                                 ret++;
 412         }
 413
 414         return ret;
 415 }
 416
 417 static struct dm_list *_failed_pv_list(struct volume_group *vg)
 418 {
 419         struct dm_list *failed_pvs;
 420         struct pv_list *pvl, *new_pvl;
 421
 422         if (!(failed_pvs = dm_pool_alloc(vg->vgmem, sizeof(*failed_pvs)))) {
 423                 log_error("Allocation of list of failed_pvs failed.");
 424                 return_NULL;
 425         }
 426
 427         dm_list_init(failed_pvs);
 428
 429         dm_list_iterate_items(pvl, &vg->pvs) {
 430                 if (!(pvl->pv->status & MISSING_PV))
 431                         continue;
 432
 433                 if (!(new_pvl = dm_pool_alloc(vg->vgmem, sizeof(*new_pvl)))) {
 434                         log_error("Allocation of failed_pvs list entry failed.");
 435                         return_NULL;
 436                 }
 437                 new_pvl->pv = pvl->pv;
 438                 dm_list_add(failed_pvs, &new_pvl->list);
 439         }
 440
 441         return failed_pvs;
 442 }
 443
 444 /*
 445  * Walk down the stacked mirror LV to the original mirror LV.
 446  */
 447 static struct logical_volume *_original_lv(struct logical_volume *lv)
 448 {
 449         struct logical_volume *next_lv = lv, *tmp_lv;
 450
 451         while ((tmp_lv = find_temporary_mirror(next_lv)))
 452                 next_lv = tmp_lv;
 453
 454         return next_lv;
 455 }
 456
 457 static void _lvconvert_mirrors_repair_ask(struct cmd_context *cmd,
 458                                           int failed_log, int failed_mirrors,
 459                                           int *replace_log, int *replace_mirrors)
 460 {
 461         const char *leg_policy = NULL, *log_policy = NULL;
 462
 463         int force = arg_count(cmd, force_ARG);
 464         int yes = arg_count(cmd, yes_ARG);
 465
 466         *replace_log = *replace_mirrors = 1;
 467
 468         if (arg_count(cmd, use_policies_ARG)) {
 469                 leg_policy = find_config_tree_str(cmd,
 470                                         "activation/mirror_device_fault_policy",
 471                                         DEFAULT_MIRROR_DEVICE_FAULT_POLICY);
 472                 log_policy = find_config_tree_str(cmd,
 473                                         "activation/mirror_log_fault_policy",
 474                                         DEFAULT_MIRROR_LOG_FAULT_POLICY);
 475                 *replace_mirrors = strcmp(leg_policy, "remove");
 476                 *replace_log = strcmp(log_policy, "remove");
 477                 return;
 478         }
 479
 480         if (yes)
 481                 return;
 482
 483         if (force != PROMPT) {
 484                 *replace_log = *replace_mirrors = 0;
 485                 return;
 486         }
 487
 488         if (failed_log &&
 489             yes_no_prompt("Attempt to replace failed mirror log? [y/n]: ") == 'n') {
 490                 *replace_log = 0;
 491         }
 492
 493         if (failed_mirrors &&
 494             yes_no_prompt("Attempt to replace failed mirror images "
 495                           "(requires full device resync)? [y/n]: ") == 'n') {
 496                 *replace_mirrors = 0;
 497         }
 498 }
 499
 500 static int _using_corelog(struct logical_volume *lv)
 501 {
 502         return !first_seg(_original_lv(lv))->log_lv;
 503 }
 504
 505 static int _lv_update_log_type(struct cmd_context *cmd,
 506                                struct lvconvert_params *lp,
 507                                struct logical_volume *lv,
 508                                int corelog)
 509 {
 510         struct logical_volume *original_lv = _original_lv(lv);
 511         if (_using_corelog(lv) && !corelog) {
 512                 if (!add_mirror_log(cmd, original_lv, 1,
 513                                     adjusted_mirror_region_size(
 514                                         lv->vg->extent_size,
 515                                         lv->le_count,
 516                                         lp->region_size),
 517                                     lp->pvh, lp->alloc))
 518                         return_0;
 519         } else if (!_using_corelog(lv) && corelog) {
 520                 if (!remove_mirror_log(cmd, original_lv,
 521                                        lp->pv_count ? lp->pvh : NULL))
 522                         return_0;
 523         }
 524         return 1;
 525 }
 526
 527 static int _lvconvert_mirrors(struct cmd_context *cmd, struct logical_volume *lv,
 528                               struct lvconvert_params *lp)
 529 {
 530         struct lv_segment *seg;
 531         uint32_t existing_mirrors;
 532         const char *mirrorlog;
 533         unsigned corelog = 0;
 534         int r = 0;
 535         struct logical_volume *log_lv, *layer_lv;
 536         int failed_mirrors = 0, failed_log = 0;
 537         struct dm_list *old_pvh = NULL, *remove_pvs = NULL;
 538
 539         int repair = arg_count(cmd, repair_ARG);
 540         int replace_log = 1, replace_mirrors = 1;
 541
 542         seg = first_seg(lv);
 543         existing_mirrors = lv_mirror_count(lv);
 544
 545         /* If called with no argument, try collapsing the resync layers */
 546         if (!arg_count(cmd, mirrors_ARG) && !arg_count(cmd, mirrorlog_ARG) &&
 547             !arg_count(cmd, corelog_ARG) && !arg_count(cmd, regionsize_ARG) &&
 548             !repair) {
 549                 if (find_temporary_mirror(lv) || (lv->status & CONVERTING))
 550                         lp->need_polling = 1;
 551                 return 1;
 552         }
 553
 554         if (arg_count(cmd, mirrors_ARG) && repair) {
 555                 log_error("You may only use one of --mirrors and --repair.");
 556                 return 0;
 557         }
 558
 559         /*
 560          * Adjust required number of mirrors
 561          *
 562          * We check mirrors_ARG again to see if it
 563          * was supplied.  If not, they want the mirror
 564          * count to remain the same.  They may be changing
 565          * the logging type.
 566          */
 567         if (!arg_count(cmd, mirrors_ARG))
 568                 lp->mirrors = existing_mirrors;
 569         else if (lp->mirrors_sign == SIGN_PLUS)
 570                 lp->mirrors = existing_mirrors + lp->mirrors;
 571         else if (lp->mirrors_sign == SIGN_MINUS)
 572                 lp->mirrors = existing_mirrors - lp->mirrors;
 573         else
 574                 lp->mirrors += 1;
 575
 576         if (repair) {
 577                 cmd->handles_missing_pvs = 1;
 578                 cmd->partial_activation = 1;
 579                 lp->need_polling = 0;
 580                 if (!(lv->status & PARTIAL_LV)) {
 581                         log_error("The mirror is consistent, nothing to repair.");
 582                         return 0;
 583                 }
 584                 if ((failed_mirrors = _failed_mirrors_count(lv)) < 0)
 585                         return_0;
 586                 lp->mirrors -= failed_mirrors;
 587                 log_error("Mirror status: %d of %d images failed.",
 588                           failed_mirrors, existing_mirrors);
 589                 old_pvh = lp->pvh;
 590                 if (!(lp->pvh = _failed_pv_list(lv->vg)))
 591                         return_0;
 592                 log_lv=first_seg(lv)->log_lv;
 593                 if (!log_lv || log_lv->status & PARTIAL_LV)
 594                         failed_log = corelog = 1;
 595         } else {
 596                 /*
 597                  * Did the user try to subtract more legs than available?
 598                  */
 599                 if (lp->mirrors < 1) {
 600                         log_error("Logical volume %s only has %" PRIu32 " mirrors.",
 601                                   lv->name, existing_mirrors);
 602                         return 0;
 603                 }
 604
 605                 /*
 606                  * Adjust log type
 607                  */
 608                 if (arg_count(cmd, corelog_ARG))
 609                         corelog = 1;
 610
 611                 mirrorlog = arg_str_value(cmd, mirrorlog_ARG,
 612                                           corelog ? "core" : DEFAULT_MIRRORLOG);
 613                 if (!strcmp("disk", mirrorlog)) {
 614                         if (corelog) {
 615                                 log_error("--mirrorlog disk and --corelog "
 616                                           "are incompatible");
 617                                 return 0;
 618                         }
 619                         corelog = 0;
 620                 } else if (!strcmp("core", mirrorlog))
 621                         corelog = 1;
 622                 else {
 623                         log_error("Unknown mirrorlog type: %s", mirrorlog);
 624                         return 0;
 625                 }
 626
 627                 log_verbose("Setting logging type to %s", mirrorlog);
 628         }
 629
 630         /*
 631          * Region size must not change on existing mirrors
 632          */
 633         if (arg_count(cmd, regionsize_ARG) && (lv->status & MIRRORED) &&
 634             (lp->region_size != seg->region_size)) {
 635                 log_error("Mirror log region size cannot be changed on "
 636                           "an existing mirror.");
 637                 return 0;
 638         }
 639
 640         /*
 641          * For the most part, we cannot handle multi-segment mirrors. Bail out
 642          * early if we have encountered one.
 643          */
 644         if ((lv->status & MIRRORED) && dm_list_size(&lv->segments) != 1) {
 645                 log_error("Logical volume %s has multiple "
 646                           "mirror segments.", lv->name);
 647                 return 0;
 648         }
 649
 650         if (repair)
 651                 _lvconvert_mirrors_repair_ask(cmd, failed_log, failed_mirrors,
 652                                               &replace_log, &replace_mirrors);
 653
 654  restart:
 655         /*
 656          * Converting from mirror to linear
 657          */
 658         if ((lp->mirrors == 1)) {
 659                 if (!(lv->status & MIRRORED)) {
 660                         log_error("Logical volume %s is already not mirrored.",
 661                                   lv->name);
 662                         return 1;
 663                 }
 664         }
 665
 666         /*
 667          * Downconversion.
 668          */
 669         if (lp->mirrors < existing_mirrors) {
 670                 /* Reduce number of mirrors */
 671                 if (repair || lp->pv_count)
 672                         remove_pvs = lp->pvh;
 673                 if (!lv_remove_mirrors(cmd, lv, existing_mirrors - lp->mirrors,
 674                                        (corelog || lp->mirrors == 1) ? 1U : 0U,
 675                                        remove_pvs, 0))
 676                         return_0;
 677                 if (lp->mirrors > 1 &&
 678                     !_lv_update_log_type(cmd, lp, lv, corelog))
 679                         return_0;
 680         } else if (!(lv->status & MIRRORED)) {
 681                 /*
 682                  * Converting from linear to mirror
 683                  */
 684
 685                 /* FIXME Share code with lvcreate */
 686
 687                 /* FIXME Why is this restriction here?  Fix it! */
 688                 dm_list_iterate_items(seg, &lv->segments) {
 689                         if (seg_is_striped(seg) && seg->area_count > 1) {
 690                                 log_error("Mirrors of striped volumes are not yet supported.");
 691                                 return 0;
 692                         }
 693                 }
 694
 695                 /*
 696                  * FIXME should we give not only lp->pvh, but also all PVs
 697                  * currently taken by the mirror? Would make more sense from
 698                  * user perspective.
 699                  */
 700                 if (!lv_add_mirrors(cmd, lv, lp->mirrors - 1, 1,
 701                                     adjusted_mirror_region_size(
 702                                                 lv->vg->extent_size,
 703                                                 lv->le_count,
 704                                                 lp->region_size),
 705                                     corelog ? 0U : 1U, lp->pvh, lp->alloc,
 706                                     MIRROR_BY_LV))
 707                         return_0;
 708                 if (lp->wait_completion)
 709                         lp->need_polling = 1;
 710         } else if (lp->mirrors > existing_mirrors || failed_mirrors) {
 711                 if (lv->status & MIRROR_NOTSYNCED) {
 712                         log_error("Can't add mirror to out-of-sync mirrored "
 713                                   "LV: use lvchange --resync first.");
 714                         return 0;
 715                 }
 716
 717                 /*
 718                  * We allow snapshots of mirrors, but for now, we
 719                  * do not allow up converting mirrors that are under
 720                  * snapshots.  The layering logic is somewhat complex,
 721                  * and preliminary test show that the conversion can't
 722                  * seem to get the correct %'age of completion.
 723                  */
 724                 if (lv_is_origin(lv)) {
 725                         log_error("Can't add additional mirror images to "
 726                                   "mirrors that are under snapshots");
 727                         return 0;
 728                 }
 729
 730                 /*
 731                  * Log addition/removal should be done before the layer
 732                  * insertion to make the end result consistent with
 733                  * linear-to-mirror conversion.
 734                  */
 735                 if (!_lv_update_log_type(cmd, lp, lv, corelog))
 736                         return_0;
 737                 /* Insert a temporary layer for syncing,
 738                  * only if the original lv is using disk log. */
 739                 if (seg->log_lv && !_insert_lvconvert_layer(cmd, lv)) {
 740                         log_error("Failed to insert resync layer");
 741                         return 0;
 742                 }
 743                 /* FIXME: can't have multiple mlogs. force corelog. */
 744                 if (!lv_add_mirrors(cmd, lv, lp->mirrors - existing_mirrors, 1,
 745                                     adjusted_mirror_region_size(
 746                                                 lv->vg->extent_size,
 747                                                 lv->le_count,
 748                                                 lp->region_size),
 749                                     0U, lp->pvh, lp->alloc,
 750                                     MIRROR_BY_LV)) {
 751                         layer_lv = seg_lv(first_seg(lv), 0);
 752                         if (!remove_layer_from_lv(lv, layer_lv) ||
 753                             !deactivate_lv(cmd, layer_lv) ||
 754                             !lv_remove(layer_lv) || !vg_write(lv->vg) ||
 755                             !vg_commit(lv->vg)) {
 756                                 log_error("ABORTING: Failed to remove "
 757                                           "temporary mirror layer %s.",
 758                                           layer_lv->name);
 759                                 log_error("Manual cleanup with vgcfgrestore "
 760                                           "and dmsetup may be required.");
 761                                 return 0;
 762                         }
 763                         return_0;
 764                 }
 765                 lv->status |= CONVERTING;
 766                 lp->need_polling = 1;
 767         }
 768
 769         if (lp->mirrors == existing_mirrors) {
 770                 if (_using_corelog(lv) != corelog) {
 771                         if (!_lv_update_log_type(cmd, lp, lv, corelog))
 772                                 return_0;
 773                 } else {
 774                         log_error("Logical volume %s already has %"
 775                                   PRIu32 " mirror(s).", lv->name,
 776                                   lp->mirrors - 1);
 777                         if (lv->status & CONVERTING)
 778                                 lp->need_polling = 1;
 779                         return 1;
 780                 }
 781         }
 782
 783         log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
 784
 785         if (!vg_write(lv->vg))
 786                 return_0;
 787
 788         if (!suspend_lv(cmd, lv)) {
 789                 log_error("Failed to lock %s", lv->name);
 790                 vg_revert(lv->vg);
 791                 goto out;
 792         }
 793
 794         if (!vg_commit(lv->vg)) {
 795                 resume_lv(cmd, lv);
 796                 goto_out;
 797         }
 798
 799         log_very_verbose("Updating \"%s\" in kernel", lv->name);
 800
 801         if (!resume_lv(cmd, lv)) {
 802                 log_error("Problem reactivating %s", lv->name);
 803                 goto out;
 804         }
 805
 806         if (failed_log || failed_mirrors) {
 807                 lp->pvh = old_pvh;
 808                 if (failed_log && replace_log)
 809                         failed_log = corelog = 0;
 810                 if (replace_mirrors)
 811                         lp->mirrors += failed_mirrors;
 812                 failed_mirrors = 0;
 813                 existing_mirrors = lv_mirror_count(lv);
 814                 /* Now replace missing devices. */
 815                 if (replace_log || replace_mirrors)
 816                         goto restart;
 817         }
 818
 819         if (!lp->need_polling)
 820                 log_print("Logical volume %s converted.", lv->name);
 821
 822         r = 1;
 823 out:
 824         backup(lv->vg);
 825         return r;
 826 }
 827
 828 static int lvconvert_snapshot(struct cmd_context *cmd,
 829                               struct logical_volume *lv,
 830                               struct lvconvert_params *lp)
 831 {
 832         struct logical_volume *org;
 833         int r = 0;
 834
 835         if (!(org = find_lv(lv->vg, lp->origin))) {
 836                 log_error("Couldn't find origin volume '%s'.", lp->origin);
 837                 return 0;
 838         }
 839
 840         if (org == lv) {
 841                 log_error("Unable to use \"%s\" as both snapshot and origin.",
 842                           lv->name);
 843                 return 0;
 844         }
 845
 846         if (org->status & (LOCKED|PVMOVE|MIRRORED) || lv_is_cow(org)) {
 847                 log_error("Unable to create a snapshot of a %s LV.",
 848                           org->status & LOCKED ? "locked" :
 849                           org->status & PVMOVE ? "pvmove" :
 850                           org->status & MIRRORED ? "mirrored" :
 851                           "snapshot");
 852                 return 0;
 853         }
 854
 855         if (!lp->zero || !(lv->status & LVM_WRITE))
 856                 log_warn("WARNING: \"%s\" not zeroed", lv->name);
 857         else if (!set_lv(cmd, lv, UINT64_C(0), 0)) {
 858                 log_error("Aborting. Failed to wipe snapshot "
 859                           "exception store.");
 860                 return 0;
 861         }
 862
 863         if (!deactivate_lv(cmd, lv)) {
 864                 log_error("Couldn't deactivate LV %s.", lv->name);
 865                 return 0;
 866         }
 867
 868         if (!vg_add_snapshot(org, lv, NULL, org->le_count, lp->chunk_size)) {
 869                 log_error("Couldn't create snapshot.");
 870                 return 0;
 871         }
 872
 873         /* store vg on disk(s) */
 874         if (!vg_write(lv->vg))
 875                 return_0;
 876
 877         if (!suspend_lv(cmd, org)) {
 878                 log_error("Failed to suspend origin %s", org->name);
 879                 vg_revert(lv->vg);
 880                 goto out;
 881         }
 882
 883         if (!vg_commit(lv->vg))
 884                 goto_out;
 885
 886         if (!resume_lv(cmd, org)) {
 887                 log_error("Problem reactivating origin %s", org->name);
 888                 goto out;
 889         }
 890
 891         log_print("Logical volume %s converted to snapshot.", lv->name);
 892         r = 1;
 893 out:
 894         backup(lv->vg);
 895         return r;
 896 }
 897
 898 static int lvconvert_single(struct cmd_context *cmd, struct logical_volume *lv,
 899                             void *handle)
 900 {
 901         struct lvconvert_params *lp = handle;
 902
 903         if (lv->status & LOCKED) {
 904                 log_error("Cannot convert locked LV %s", lv->name);
 905                 return ECMD_FAILED;
 906         }
 907
 908         if (lv_is_cow(lv)) {
 909                 log_error("Can't convert snapshot logical volume \"%s\"",
 910                           lv->name);
 911                 return ECMD_FAILED;
 912         }
 913
 914         if (lv->status & PVMOVE) {
 915                 log_error("Unable to convert pvmove LV %s", lv->name);
 916                 return ECMD_FAILED;
 917         }
 918
 919         if (arg_count(cmd, repair_ARG) && !(lv->status & MIRRORED)) {
 920                 log_error("Can't repair non-mirrored LV \"%s\".", lv->name);
 921                 return ECMD_FAILED;
 922         }
 923
 924         if (lp->snapshot) {
 925                 if (lv->status & MIRRORED) {
 926                         log_error("Unable to convert mirrored LV \"%s\" into a snapshot.", lv->name);
 927                         return ECMD_FAILED;
 928                 }
 929                 if (!archive(lv->vg)) {
 930                         stack;
 931                         return ECMD_FAILED;
 932                 }
 933                 if (!lvconvert_snapshot(cmd, lv, lp)) {
 934                         stack;
 935                         return ECMD_FAILED;
 936                 }
 937         } else if (arg_count(cmd, mirrors_ARG) || (lv->status & MIRRORED)) {
 938                 if (!archive(lv->vg)) {
 939                         stack;
 940                         return ECMD_FAILED;
 941                 }
 942                 if (!_lvconvert_mirrors(cmd, lv, lp)) {
 943                         stack;
 944                         return ECMD_FAILED;
 945                 }
 946         }
 947
 948         return ECMD_PROCESSED;
 949 }
 950
 951 int lvconvert(struct cmd_context * cmd, int argc, char **argv)
 952 {
 953         struct volume_group *vg;
 954         struct lv_list *lvl;
 955         struct lvconvert_params lp;
 956         int ret = ECMD_FAILED;
 957         struct lvinfo info;
 958         int saved_ignore_suspended_devices = ignore_suspended_devices();
 959
 960         if (!_read_params(&lp, cmd, argc, argv)) {
 961                 stack;
 962                 return EINVALID_CMD_LINE;
 963         }
 964
 965         if (arg_count(cmd, repair_ARG)) {
 966                 init_ignore_suspended_devices(1);
 967                 cmd->handles_missing_pvs = 1;
 968         }
 969
 970         log_verbose("Checking for existing volume group \"%s\"", lp.vg_name);
 971
 972         vg = vg_read_for_update(cmd, lp.vg_name, NULL, 0);
 973         if (vg_read_error(vg))
 974                 goto out;
 975
 976         if (!(lvl = find_lv_in_vg(vg, lp.lv_name))) {
 977                 log_error("Logical volume \"%s\" not found in "
 978                           "volume group \"%s\"", lp.lv_name, lp.vg_name);
 979                 goto bad;
 980         }
 981
 982         if (lp.pv_count) {
 983                 if (!(lp.pvh = create_pv_list(cmd->mem, vg, lp.pv_count,
 984                                               lp.pvs, 0)))
 985                         goto_bad;
 986         } else
 987                 lp.pvh = &vg->pvs;
 988
 989         ret = lvconvert_single(cmd, lvl->lv, &lp);
 990
 991 bad:
 992         unlock_vg(cmd, lp.vg_name);
 993
 994         if (ret == ECMD_PROCESSED && lp.need_polling) {
 995                 if (!lv_info(cmd, lvl->lv, &info, 1, 0) || !info.exists) {
 996                         log_print("Conversion starts after activation");
 997                         goto out;
 998                 }
 999                 ret = lvconvert_poll(cmd, lvl->lv,
1000                                      lp.wait_completion ? 0 : 1U);
1001         }
1002 out:
1003         init_ignore_suspended_devices(saved_ignore_suspended_devices);
1004         vg_release(vg);
1005         return ret;
1006 }