daemon/lvm.c

   1 /* libguestfs - the guestfsd daemon
   2  * Copyright (C) 2009 Red Hat Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <inttypes.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/stat.h>
  27
  28 #include "daemon.h"
  29 #include "c-ctype.h"
  30 #include "actions.h"
  31 #include "optgroups.h"
  32
  33 int
  34 optgroup_lvm2_available (void)
  35 {
  36   return prog_exists ("lvm");
  37 }
  38
  39 /* LVM actions.  Keep an eye on liblvm, although at the time
  40  * of writing it hasn't progressed very far.
  41  */
  42
  43 static char **
  44 convert_lvm_output (char *out, const char *prefix)
  45 {
  46   char *p, *pend;
  47   char **r = NULL;
  48   int size = 0, alloc = 0;
  49   int len;
  50   char buf[256];
  51   char *str;
  52
  53   p = out;
  54   while (p) {
  55     pend = strchr (p, '\n');    /* Get the next line of output. */
  56     if (pend) {
  57       *pend = '\0';
  58       pend++;
  59     }
  60
  61     while (*p && c_isspace (*p))        /* Skip any leading whitespace. */
  62       p++;
  63
  64     /* Sigh, skip trailing whitespace too.  "pvs", I'm looking at you. */
  65     len = strlen (p)-1;
  66     while (*p && c_isspace (p[len]))
  67       p[len--] = '\0';
  68
  69     if (!*p) {                  /* Empty line?  Skip it. */
  70       p = pend;
  71       continue;
  72     }
  73
  74     /* Prefix? */
  75     if (prefix) {
  76       snprintf (buf, sizeof buf, "%s%s", prefix, p);
  77       str = buf;
  78     } else
  79       str = p;
  80
  81     if (add_string (&r, &size, &alloc, str) == -1) {
  82       free (out);
  83       return NULL;
  84     }
  85
  86     p = pend;
  87   }
  88
  89   free (out);
  90
  91   if (add_string (&r, &size, &alloc, NULL) == -1)
  92     return NULL;
  93
  94   sort_strings (r, size-1);
  95   return r;
  96 }
  97
  98 char **
  99 do_pvs (void)
 100 {
 101   char *out, *err;
 102   int r;
 103
 104   r = command (&out, &err,
 105                "lvm", "pvs", "-o", "pv_name", "--noheadings", NULL);
 106   if (r == -1) {
 107     reply_with_error ("%s", err);
 108     free (out);
 109     free (err);
 110     return NULL;
 111   }
 112
 113   free (err);
 114
 115   return convert_lvm_output (out, NULL);
 116 }
 117
 118 char **
 119 do_vgs (void)
 120 {
 121   char *out, *err;
 122   int r;
 123
 124   r = command (&out, &err,
 125                "lvm", "vgs", "-o", "vg_name", "--noheadings", NULL);
 126   if (r == -1) {
 127     reply_with_error ("%s", err);
 128     free (out);
 129     free (err);
 130     return NULL;
 131   }
 132
 133   free (err);
 134
 135   return convert_lvm_output (out, NULL);
 136 }
 137
 138 char **
 139 do_lvs (void)
 140 {
 141   char *out, *err;
 142   int r;
 143
 144   r = command (&out, &err,
 145                "lvm", "lvs",
 146                "-o", "vg_name,lv_name", "--noheadings",
 147                "--separator", "/", NULL);
 148   if (r == -1) {
 149     reply_with_error ("%s", err);
 150     free (out);
 151     free (err);
 152     return NULL;
 153   }
 154
 155   free (err);
 156
 157   return convert_lvm_output (out, "/dev/");
 158 }
 159
 160 /* These were so complex to implement that I ended up auto-generating
 161  * the code.  That code is in stubs.c, and it is generated as usual
 162  * by generator.ml.
 163  */
 164 guestfs_int_lvm_pv_list *
 165 do_pvs_full (void)
 166 {
 167   return parse_command_line_pvs ();
 168 }
 169
 170 guestfs_int_lvm_vg_list *
 171 do_vgs_full (void)
 172 {
 173   return parse_command_line_vgs ();
 174 }
 175
 176 guestfs_int_lvm_lv_list *
 177 do_lvs_full (void)
 178 {
 179   return parse_command_line_lvs ();
 180 }
 181
 182 int
 183 do_pvcreate (const char *device)
 184 {
 185   char *err;
 186   int r;
 187
 188   r = command (NULL, &err,
 189                "lvm", "pvcreate", device, NULL);
 190   if (r == -1) {
 191     reply_with_error ("%s", err);
 192     free (err);
 193     return -1;
 194   }
 195
 196   free (err);
 197
 198   udev_settle ();
 199
 200   return 0;
 201 }
 202
 203 int
 204 do_vgcreate (const char *volgroup, char *const *physvols)
 205 {
 206   char *err;
 207   int r, argc, i;
 208   const char **argv;
 209
 210   argc = count_strings (physvols) + 3;
 211   argv = malloc (sizeof (char *) * (argc + 1));
 212   if (argv == NULL) {
 213     reply_with_perror ("malloc");
 214     return -1;
 215   }
 216   argv[0] = "lvm";
 217   argv[1] = "vgcreate";
 218   argv[2] = volgroup;
 219   for (i = 3; i <= argc; ++i)
 220     argv[i] = physvols[i-3];
 221
 222   r = commandv (NULL, &err, (const char * const*) argv);
 223   if (r == -1) {
 224     reply_with_error ("%s", err);
 225     free (err);
 226     free (argv);
 227     return -1;
 228   }
 229
 230   free (err);
 231   free (argv);
 232
 233   udev_settle ();
 234
 235   return 0;
 236 }
 237
 238 int
 239 do_lvcreate (const char *logvol, const char *volgroup, int mbytes)
 240 {
 241   char *err;
 242   int r;
 243   char size[64];
 244
 245   snprintf (size, sizeof size, "%d", mbytes);
 246
 247   r = command (NULL, &err,
 248                "lvm", "lvcreate",
 249                "-L", size, "-n", logvol, volgroup, NULL);
 250   if (r == -1) {
 251     reply_with_error ("%s", err);
 252     free (err);
 253     return -1;
 254   }
 255
 256   free (err);
 257
 258   udev_settle ();
 259
 260   return 0;
 261 }
 262
 263 int
 264 do_lvresize (const char *logvol, int mbytes)
 265 {
 266   char *err;
 267   int r;
 268   char size[64];
 269
 270   snprintf (size, sizeof size, "%d", mbytes);
 271
 272   r = command (NULL, &err,
 273                "lvm", "lvresize",
 274                "--force", "-L", size, logvol, NULL);
 275   if (r == -1) {
 276     reply_with_error ("%s", err);
 277     free (err);
 278     return -1;
 279   }
 280
 281   free (err);
 282   return 0;
 283 }
 284
 285 int
 286 do_lvresize_free (const char *logvol, int percent)
 287 {
 288   char *err;
 289   int r;
 290
 291   if (percent < 0 || percent > 100) {
 292     reply_with_error ("percentage must be [0..100] (was %d)", percent);
 293     return -1;
 294   }
 295
 296   char size[64];
 297   snprintf (size, sizeof size, "+%d%%FREE", percent);
 298
 299   r = command (NULL, &err,
 300                "lvm", "lvresize", "-l", size, logvol, NULL);
 301   if (r == -1) {
 302     reply_with_error ("%s", err);
 303     free (err);
 304     return -1;
 305   }
 306
 307   free (err);
 308   return 0;
 309 }
 310
 311 /* Super-dangerous command used for testing.  It removes all
 312  * LVs, VGs and PVs permanently.
 313  */
 314 int
 315 do_lvm_remove_all (void)
 316 {
 317   char **xs;
 318   int i, r;
 319   char *err;
 320
 321   /* Remove LVs. */
 322   xs = do_lvs ();
 323   if (xs == NULL)
 324     return -1;
 325
 326   for (i = 0; xs[i] != NULL; ++i) {
 327     /* Deactivate the LV first.  On Ubuntu, lvremove '-f' option
 328      * does not remove active LVs reliably.
 329      */
 330     (void) command (NULL, NULL, "lvm", "lvchange", "-an", xs[i], NULL);
 331     udev_settle ();
 332
 333     r = command (NULL, &err, "lvm", "lvremove", "-f", xs[i], NULL);
 334     if (r == -1) {
 335       reply_with_error ("lvremove: %s: %s", xs[i], err);
 336       free (err);
 337       free_strings (xs);
 338       return -1;
 339     }
 340     free (err);
 341   }
 342   free_strings (xs);
 343
 344   /* Remove VGs. */
 345   xs = do_vgs ();
 346   if (xs == NULL)
 347     return -1;
 348
 349   for (i = 0; xs[i] != NULL; ++i) {
 350     /* Deactivate the VG first, see note above. */
 351     (void) command (NULL, NULL, "lvm", "vgchange", "-an", xs[i], NULL);
 352     udev_settle ();
 353
 354     r = command (NULL, &err, "lvm", "vgremove", "-f", xs[i], NULL);
 355     if (r == -1) {
 356       reply_with_error ("vgremove: %s: %s", xs[i], err);
 357       free (err);
 358       free_strings (xs);
 359       return -1;
 360     }
 361     free (err);
 362   }
 363   free_strings (xs);
 364
 365   /* Remove PVs. */
 366   xs = do_pvs ();
 367   if (xs == NULL)
 368     return -1;
 369
 370   for (i = 0; xs[i] != NULL; ++i) {
 371     r = command (NULL, &err, "lvm", "pvremove", "-f", xs[i], NULL);
 372     if (r == -1) {
 373       reply_with_error ("pvremove: %s: %s", xs[i], err);
 374       free (err);
 375       free_strings (xs);
 376       return -1;
 377     }
 378     free (err);
 379   }
 380   free_strings (xs);
 381
 382   udev_settle ();
 383
 384   /* There, that was easy, sorry about your data. */
 385   return 0;
 386 }
 387
 388 int
 389 do_lvremove (const char *device)
 390 {
 391   char *err;
 392   int r;
 393
 394   r = command (NULL, &err,
 395                "lvm", "lvremove", "-f", device, NULL);
 396   if (r == -1) {
 397     reply_with_error ("%s", err);
 398     free (err);
 399     return -1;
 400   }
 401
 402   free (err);
 403
 404   udev_settle ();
 405
 406   return 0;
 407 }
 408
 409 int
 410 do_vgremove (const char *device)
 411 {
 412   char *err;
 413   int r;
 414
 415   r = command (NULL, &err,
 416                "lvm", "vgremove", "-f", device, NULL);
 417   if (r == -1) {
 418     reply_with_error ("%s", err);
 419     free (err);
 420     return -1;
 421   }
 422
 423   free (err);
 424
 425   udev_settle ();
 426
 427   return 0;
 428 }
 429
 430 int
 431 do_pvremove (const char *device)
 432 {
 433   char *err;
 434   int r;
 435
 436   r = command (NULL, &err,
 437                "lvm", "pvremove", "-ff", device, NULL);
 438   if (r == -1) {
 439     reply_with_error ("%s", err);
 440     free (err);
 441     return -1;
 442   }
 443
 444   free (err);
 445
 446   udev_settle ();
 447
 448   return 0;
 449 }
 450
 451 int
 452 do_pvresize (const char *device)
 453 {
 454   char *err;
 455   int r;
 456
 457   r = command (NULL, &err,
 458                "lvm", "pvresize", device, NULL);
 459   if (r == -1) {
 460     reply_with_error ("%s: %s", device, err);
 461     free (err);
 462     return -1;
 463   }
 464
 465   free (err);
 466   return 0;
 467 }
 468
 469 int
 470 do_pvresize_size (const char *device, int64_t size)
 471 {
 472   char *err;
 473   int r;
 474
 475   char buf[32];
 476   snprintf (buf, sizeof buf, "%" PRIi64 "b", size);
 477
 478   r = command (NULL, &err,
 479                "lvm", "pvresize",
 480                "--setphysicalvolumesize", buf,
 481                device, NULL);
 482   if (r == -1) {
 483     reply_with_error ("%s: %s", device, err);
 484     free (err);
 485     return -1;
 486   }
 487
 488   free (err);
 489   return 0;
 490 }
 491
 492 int
 493 do_vg_activate (int activate, char *const *volgroups)
 494 {
 495   char *err;
 496   int r, i, argc;
 497   const char **argv;
 498
 499   argc = count_strings (volgroups) + 4;
 500   argv = malloc (sizeof (char *) * (argc+1));
 501   if (argv == NULL) {
 502     reply_with_perror ("malloc");
 503     return -1;
 504   }
 505
 506   argv[0] = "lvm";
 507   argv[1] = "vgchange";
 508   argv[2] = "-a";
 509   argv[3] = activate ? "y" : "n";
 510   for (i = 4; i <= argc; ++i)
 511     argv[i] = volgroups[i-4];
 512
 513   r = commandv (NULL, &err, (const char * const*) argv);
 514   if (r == -1) {
 515     reply_with_error ("vgchange: %s", err);
 516     free (err);
 517     free (argv);
 518     return -1;
 519   }
 520
 521   free (err);
 522   free (argv);
 523
 524   udev_settle ();
 525
 526   return 0;
 527 }
 528
 529 int
 530 do_vg_activate_all (int activate)
 531 {
 532   char *empty[] = { NULL };
 533   return do_vg_activate (activate, empty);
 534 }
 535
 536 int
 537 do_lvrename (const char *logvol, const char *newlogvol)
 538 {
 539   char *err;
 540   int r;
 541
 542   r = command (NULL, &err,
 543                "lvm", "lvrename",
 544                logvol, newlogvol, NULL);
 545   if (r == -1) {
 546     reply_with_error ("%s -> %s: %s", logvol, newlogvol, err);
 547     free (err);
 548     return -1;
 549   }
 550
 551   free (err);
 552
 553   udev_settle ();
 554
 555   return 0;
 556 }
 557
 558 int
 559 do_vgrename (const char *volgroup, const char *newvolgroup)
 560 {
 561   char *err;
 562   int r;
 563
 564   r = command (NULL, &err,
 565                "lvm", "vgrename",
 566                volgroup, newvolgroup, NULL);
 567   if (r == -1) {
 568     reply_with_error ("%s -> %s: %s", volgroup, newvolgroup, err);
 569     free (err);
 570     return -1;
 571   }
 572
 573   free (err);
 574
 575   udev_settle ();
 576
 577   return 0;
 578 }
 579
 580 static char *
 581 get_lvm_field (const char *cmd, const char *field, const char *device)
 582 {
 583   char *out;
 584   char *err;
 585   int r = command (&out, &err,
 586                    "lvm", cmd,
 587                    "--unbuffered", "--noheadings", "-o", field,
 588                    device, NULL);
 589   if (r == -1) {
 590     reply_with_error ("%s: %s", device, err);
 591     free (out);
 592     free (err);
 593     return NULL;
 594   }
 595
 596   free (err);
 597
 598   trim (out);
 599   return out;                   /* Caller frees. */
 600 }
 601
 602 char *
 603 do_pvuuid (const char *device)
 604 {
 605   return get_lvm_field ("pvs", "pv_uuid", device);
 606 }
 607
 608 char *
 609 do_vguuid (const char *vgname)
 610 {
 611   return get_lvm_field ("vgs", "vg_uuid", vgname);
 612 }
 613
 614 char *
 615 do_lvuuid (const char *device)
 616 {
 617   return get_lvm_field ("lvs", "lv_uuid", device);
 618 }
 619
 620 static char **
 621 get_lvm_fields (const char *cmd, const char *field, const char *device)
 622 {
 623   char *out;
 624   char *err;
 625   int r = command (&out, &err,
 626                    "lvm", cmd,
 627                    "--unbuffered", "--noheadings", "-o", field,
 628                    device, NULL);
 629   if (r == -1) {
 630     reply_with_error ("%s: %s", device, err);
 631     free (out);
 632     free (err);
 633     return NULL;
 634   }
 635
 636   free (err);
 637
 638   char **ret = split_lines (out);
 639   free (out);
 640
 641   if (ret == NULL)
 642     return NULL;
 643
 644   size_t i;
 645   for (i = 0; ret[i] != NULL; ++i)
 646     trim (ret[i]);
 647
 648   return ret;
 649 }
 650
 651 char **
 652 do_vgpvuuids (const char *vgname)
 653 {
 654   return get_lvm_fields ("vgs", "pv_uuid", vgname);
 655 }
 656
 657 char **
 658 do_vglvuuids (const char *vgname)
 659 {
 660   return get_lvm_fields ("vgs", "lv_uuid", vgname);
 661 }
 662
 663 int
 664 do_vgscan (void)
 665 {
 666   char *err;
 667   int r;
 668
 669   r = command (NULL, &err,
 670                "lvm", "vgscan", NULL);
 671   if (r == -1) {
 672     reply_with_error ("%s", err);
 673     free (err);
 674     return -1;
 675   }
 676
 677   free (err);
 678   return 0;
 679 }
 680
 681 /* Convert a non-canonical LV path like /dev/mapper/vg-lv or /dev/dm-0
 682  * to a canonical one.
 683  *
 684  * This is harder than it should be.  A LV device like /dev/VG/LV is
 685  * really a symlink to a device-mapper device like /dev/dm-0.  However
 686  * at the device-mapper (kernel) level, nothing is really known about
 687  * LVM (a userspace concept).  Therefore we use a convoluted method to
 688  * determine this, by listing out known LVs and checking whether the
 689  * rdev (major/minor) of the device we are passed matches any of them.
 690  *
 691  * Note use of 'stat' instead of 'lstat' so that symlinks are fully
 692  * resolved.
 693  *
 694  * Returns:
 695  *   1  =  conversion was successful, path is an LV
 696  *         '*ret' is set to the updated path if 'ret' is non-NULL.
 697  *   0  =  path is not an LV
 698  *  -1  =  error, reply_with_* has been called
 699  *
 700  */
 701 int
 702 lv_canonical (const char *device, char **ret)
 703 {
 704   struct stat stat1, stat2;
 705
 706   int r = stat (device, &stat1);
 707   if (r == -1) {
 708     reply_with_perror ("stat: %s", device);
 709     return -1;
 710   }
 711
 712   char **lvs = do_lvs ();
 713   if (lvs == NULL)
 714     return -1;
 715
 716   size_t i;
 717   for (i = 0; lvs[i] != NULL; ++i) {
 718     r = stat (lvs[i], &stat2);
 719     if (r == -1) {
 720       reply_with_perror ("stat: %s", lvs[i]);
 721       free_strings (lvs);
 722       return -1;
 723     }
 724     if (stat1.st_rdev == stat2.st_rdev) { /* found it */
 725       if (ret) {
 726         *ret = strdup (lvs[i]);
 727         if (*ret == NULL) {
 728           reply_with_perror ("strdup");
 729           free_strings (lvs);
 730           return -1;
 731         }
 732       }
 733       free_strings (lvs);
 734       return 1;
 735     }
 736   }
 737
 738   /* not found */
 739   free_strings (lvs);
 740   return 0;
 741 }
 742
 743 /* Test if a device is a logical volume (RHBZ#619793). */
 744 int
 745 do_is_lv (const char *device)
 746 {
 747   return lv_canonical (device, NULL);
 748 }
 749
 750 /* Return canonical name of LV to caller (RHBZ#638899). */
 751 char *
 752 do_lvm_canonical_lv_name (const char *device)
 753 {
 754   char *canonical;
 755   int r = lv_canonical (device, &canonical);
 756   if (r == -1)
 757     return NULL;
 758
 759   if (r == 0) {
 760     reply_with_error ("%s: not a logical volume", device);
 761     return NULL;
 762   }
 763
 764   return canonical;             /* caller frees */
 765 }