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     return -1;
 227   }
 228
 229   free (err);
 230
 231   udev_settle ();
 232
 233   return 0;
 234 }
 235
 236 int
 237 do_lvcreate (const char *logvol, const char *volgroup, int mbytes)
 238 {
 239   char *err;
 240   int r;
 241   char size[64];
 242
 243   snprintf (size, sizeof size, "%d", mbytes);
 244
 245   r = command (NULL, &err,
 246                "lvm", "lvcreate",
 247                "-L", size, "-n", logvol, volgroup, NULL);
 248   if (r == -1) {
 249     reply_with_error ("%s", err);
 250     free (err);
 251     return -1;
 252   }
 253
 254   free (err);
 255
 256   udev_settle ();
 257
 258   return 0;
 259 }
 260
 261 int
 262 do_lvresize (const char *logvol, int mbytes)
 263 {
 264   char *err;
 265   int r;
 266   char size[64];
 267
 268   snprintf (size, sizeof size, "%d", mbytes);
 269
 270   r = command (NULL, &err,
 271                "lvm", "lvresize",
 272                "--force", "-L", size, logvol, NULL);
 273   if (r == -1) {
 274     reply_with_error ("%s", err);
 275     free (err);
 276     return -1;
 277   }
 278
 279   free (err);
 280   return 0;
 281 }
 282
 283 int
 284 do_lvresize_free (const char *logvol, int percent)
 285 {
 286   char *err;
 287   int r;
 288
 289   if (percent < 0 || percent > 100) {
 290     reply_with_error ("percentage must be [0..100] (was %d)", percent);
 291     return -1;
 292   }
 293
 294   char size[64];
 295   snprintf (size, sizeof size, "+%d%%FREE", percent);
 296
 297   r = command (NULL, &err,
 298                "lvm", "lvresize", "-l", size, logvol, NULL);
 299   if (r == -1) {
 300     reply_with_error ("%s", err);
 301     free (err);
 302     return -1;
 303   }
 304
 305   free (err);
 306   return 0;
 307 }
 308
 309 /* Super-dangerous command used for testing.  It removes all
 310  * LVs, VGs and PVs permanently.
 311  */
 312 int
 313 do_lvm_remove_all (void)
 314 {
 315   char **xs;
 316   int i, r;
 317   char *err;
 318
 319   /* Remove LVs. */
 320   xs = do_lvs ();
 321   if (xs == NULL)
 322     return -1;
 323
 324   for (i = 0; xs[i] != NULL; ++i) {
 325     /* Deactivate the LV first.  On Ubuntu, lvremove '-f' option
 326      * does not remove active LVs reliably.
 327      */
 328     (void) command (NULL, NULL, "lvm", "lvchange", "-an", xs[i], NULL);
 329     udev_settle ();
 330
 331     r = command (NULL, &err, "lvm", "lvremove", "-f", xs[i], NULL);
 332     if (r == -1) {
 333       reply_with_error ("lvremove: %s: %s", xs[i], err);
 334       free (err);
 335       free_strings (xs);
 336       return -1;
 337     }
 338     free (err);
 339   }
 340   free_strings (xs);
 341
 342   /* Remove VGs. */
 343   xs = do_vgs ();
 344   if (xs == NULL)
 345     return -1;
 346
 347   for (i = 0; xs[i] != NULL; ++i) {
 348     /* Deactivate the VG first, see note above. */
 349     (void) command (NULL, NULL, "lvm", "vgchange", "-an", xs[i], NULL);
 350     udev_settle ();
 351
 352     r = command (NULL, &err, "lvm", "vgremove", "-f", xs[i], NULL);
 353     if (r == -1) {
 354       reply_with_error ("vgremove: %s: %s", xs[i], err);
 355       free (err);
 356       free_strings (xs);
 357       return -1;
 358     }
 359     free (err);
 360   }
 361   free_strings (xs);
 362
 363   /* Remove PVs. */
 364   xs = do_pvs ();
 365   if (xs == NULL)
 366     return -1;
 367
 368   for (i = 0; xs[i] != NULL; ++i) {
 369     r = command (NULL, &err, "lvm", "pvremove", "-f", xs[i], NULL);
 370     if (r == -1) {
 371       reply_with_error ("pvremove: %s: %s", xs[i], err);
 372       free (err);
 373       free_strings (xs);
 374       return -1;
 375     }
 376     free (err);
 377   }
 378   free_strings (xs);
 379
 380   udev_settle ();
 381
 382   /* There, that was easy, sorry about your data. */
 383   return 0;
 384 }
 385
 386 int
 387 do_lvremove (const char *device)
 388 {
 389   char *err;
 390   int r;
 391
 392   r = command (NULL, &err,
 393                "lvm", "lvremove", "-f", device, NULL);
 394   if (r == -1) {
 395     reply_with_error ("%s", err);
 396     free (err);
 397     return -1;
 398   }
 399
 400   free (err);
 401
 402   udev_settle ();
 403
 404   return 0;
 405 }
 406
 407 int
 408 do_vgremove (const char *device)
 409 {
 410   char *err;
 411   int r;
 412
 413   r = command (NULL, &err,
 414                "lvm", "vgremove", "-f", device, NULL);
 415   if (r == -1) {
 416     reply_with_error ("%s", err);
 417     free (err);
 418     return -1;
 419   }
 420
 421   free (err);
 422
 423   udev_settle ();
 424
 425   return 0;
 426 }
 427
 428 int
 429 do_pvremove (const char *device)
 430 {
 431   char *err;
 432   int r;
 433
 434   r = command (NULL, &err,
 435                "lvm", "pvremove", "-ff", device, NULL);
 436   if (r == -1) {
 437     reply_with_error ("%s", err);
 438     free (err);
 439     return -1;
 440   }
 441
 442   free (err);
 443
 444   udev_settle ();
 445
 446   return 0;
 447 }
 448
 449 int
 450 do_pvresize (const char *device)
 451 {
 452   char *err;
 453   int r;
 454
 455   r = command (NULL, &err,
 456                "lvm", "pvresize", device, NULL);
 457   if (r == -1) {
 458     reply_with_error ("%s: %s", device, err);
 459     free (err);
 460     return -1;
 461   }
 462
 463   free (err);
 464   return 0;
 465 }
 466
 467 int
 468 do_pvresize_size (const char *device, int64_t size)
 469 {
 470   char *err;
 471   int r;
 472
 473   char buf[32];
 474   snprintf (buf, sizeof buf, "%" PRIi64 "b", size);
 475
 476   r = command (NULL, &err,
 477                "lvm", "pvresize",
 478                "--setphysicalvolumesize", buf,
 479                device, NULL);
 480   if (r == -1) {
 481     reply_with_error ("%s: %s", device, err);
 482     free (err);
 483     return -1;
 484   }
 485
 486   free (err);
 487   return 0;
 488 }
 489
 490 int
 491 do_vg_activate (int activate, char *const *volgroups)
 492 {
 493   char *err;
 494   int r, i, argc;
 495   const char **argv;
 496
 497   argc = count_strings (volgroups) + 4;
 498   argv = malloc (sizeof (char *) * (argc+1));
 499   if (argv == NULL) {
 500     reply_with_perror ("malloc");
 501     return -1;
 502   }
 503
 504   argv[0] = "lvm";
 505   argv[1] = "vgchange";
 506   argv[2] = "-a";
 507   argv[3] = activate ? "y" : "n";
 508   for (i = 4; i <= argc; ++i)
 509     argv[i] = volgroups[i-4];
 510
 511   r = commandv (NULL, &err, (const char * const*) argv);
 512   if (r == -1) {
 513     reply_with_error ("vgchange: %s", err);
 514     free (err);
 515     return -1;
 516   }
 517
 518   free (err);
 519
 520   udev_settle ();
 521
 522   return 0;
 523 }
 524
 525 int
 526 do_vg_activate_all (int activate)
 527 {
 528   char *empty[] = { NULL };
 529   return do_vg_activate (activate, empty);
 530 }
 531
 532 int
 533 do_lvrename (const char *logvol, const char *newlogvol)
 534 {
 535   char *err;
 536   int r;
 537
 538   r = command (NULL, &err,
 539                "lvm", "lvrename",
 540                logvol, newlogvol, NULL);
 541   if (r == -1) {
 542     reply_with_error ("%s -> %s: %s", logvol, newlogvol, err);
 543     free (err);
 544     return -1;
 545   }
 546
 547   free (err);
 548
 549   udev_settle ();
 550
 551   return 0;
 552 }
 553
 554 int
 555 do_vgrename (const char *volgroup, const char *newvolgroup)
 556 {
 557   char *err;
 558   int r;
 559
 560   r = command (NULL, &err,
 561                "lvm", "vgrename",
 562                volgroup, newvolgroup, NULL);
 563   if (r == -1) {
 564     reply_with_error ("%s -> %s: %s", volgroup, newvolgroup, err);
 565     free (err);
 566     return -1;
 567   }
 568
 569   free (err);
 570
 571   udev_settle ();
 572
 573   return 0;
 574 }
 575
 576 static char *
 577 get_lvm_field (const char *cmd, const char *field, const char *device)
 578 {
 579   char *out;
 580   char *err;
 581   int r = command (&out, &err,
 582                    "lvm", cmd,
 583                    "--unbuffered", "--noheadings", "-o", field,
 584                    device, NULL);
 585   if (r == -1) {
 586     reply_with_error ("%s: %s", device, err);
 587     free (out);
 588     free (err);
 589     return NULL;
 590   }
 591
 592   free (err);
 593
 594   trim (out);
 595   return out;                   /* Caller frees. */
 596 }
 597
 598 char *
 599 do_pvuuid (const char *device)
 600 {
 601   return get_lvm_field ("pvs", "pv_uuid", device);
 602 }
 603
 604 char *
 605 do_vguuid (const char *vgname)
 606 {
 607   return get_lvm_field ("vgs", "vg_uuid", vgname);
 608 }
 609
 610 char *
 611 do_lvuuid (const char *device)
 612 {
 613   return get_lvm_field ("lvs", "lv_uuid", device);
 614 }
 615
 616 static char **
 617 get_lvm_fields (const char *cmd, const char *field, const char *device)
 618 {
 619   char *out;
 620   char *err;
 621   int r = command (&out, &err,
 622                    "lvm", cmd,
 623                    "--unbuffered", "--noheadings", "-o", field,
 624                    device, NULL);
 625   if (r == -1) {
 626     reply_with_error ("%s: %s", device, err);
 627     free (out);
 628     free (err);
 629     return NULL;
 630   }
 631
 632   free (err);
 633
 634   char **ret = split_lines (out);
 635   free (out);
 636
 637   if (ret == NULL)
 638     return NULL;
 639
 640   size_t i;
 641   for (i = 0; ret[i] != NULL; ++i)
 642     trim (ret[i]);
 643
 644   return ret;
 645 }
 646
 647 char **
 648 do_vgpvuuids (const char *vgname)
 649 {
 650   return get_lvm_fields ("vgs", "pv_uuid", vgname);
 651 }
 652
 653 char **
 654 do_vglvuuids (const char *vgname)
 655 {
 656   return get_lvm_fields ("vgs", "lv_uuid", vgname);
 657 }
 658
 659 int
 660 do_vgscan (void)
 661 {
 662   char *err;
 663   int r;
 664
 665   r = command (NULL, &err,
 666                "lvm", "vgscan", NULL);
 667   if (r == -1) {
 668     reply_with_error ("%s", err);
 669     free (err);
 670     return -1;
 671   }
 672
 673   free (err);
 674   return 0;
 675 }
 676
 677 /* Convert a non-canonical LV path like /dev/mapper/vg-lv or /dev/dm-0
 678  * to a canonical one.
 679  *
 680  * This is harder than it should be.  A LV device like /dev/VG/LV is
 681  * really a symlink to a device-mapper device like /dev/dm-0.  However
 682  * at the device-mapper (kernel) level, nothing is really known about
 683  * LVM (a userspace concept).  Therefore we use a convoluted method to
 684  * determine this, by listing out known LVs and checking whether the
 685  * rdev (major/minor) of the device we are passed matches any of them.
 686  *
 687  * Note use of 'stat' instead of 'lstat' so that symlinks are fully
 688  * resolved.
 689  *
 690  * Returns:
 691  *   1  =  conversion was successful, path is an LV
 692  *         '*ret' is set to the updated path if 'ret' is non-NULL.
 693  *   0  =  path is not an LV
 694  *  -1  =  error, reply_with_* has been called
 695  *
 696  */
 697 int
 698 lv_canonical (const char *device, char **ret)
 699 {
 700   struct stat stat1, stat2;
 701
 702   int r = stat (device, &stat1);
 703   if (r == -1) {
 704     reply_with_perror ("stat: %s", device);
 705     return -1;
 706   }
 707
 708   char **lvs = do_lvs ();
 709   if (lvs == NULL)
 710     return -1;
 711
 712   size_t i;
 713   for (i = 0; lvs[i] != NULL; ++i) {
 714     r = stat (lvs[i], &stat2);
 715     if (r == -1) {
 716       reply_with_perror ("stat: %s", lvs[i]);
 717       free_strings (lvs);
 718       return -1;
 719     }
 720     if (stat1.st_rdev == stat2.st_rdev) { /* found it */
 721       if (ret) {
 722         *ret = strdup (lvs[i]);
 723         if (*ret == NULL) {
 724           reply_with_perror ("strdup");
 725           free_strings (lvs);
 726           return -1;
 727         }
 728       }
 729       free_strings (lvs);
 730       return 1;
 731     }
 732   }
 733
 734   /* not found */
 735   free_strings (lvs);
 736   return 0;
 737 }
 738
 739 /* Test if a device is a logical volume (RHBZ#619793). */
 740 int
 741 do_is_lv (const char *device)
 742 {
 743   return lv_canonical (device, NULL);
 744 }
 745
 746 /* Return canonical name of LV to caller (RHBZ#638899). */
 747 char *
 748 do_lvm_canonical_lv_name (const char *device)
 749 {
 750   char *canonical;
 751   int r = lv_canonical (device, &canonical);
 752   if (r == -1)
 753     return NULL;
 754
 755   if (r == 0) {
 756     reply_with_error ("%s: not a logical volume", device);
 757     return NULL;
 758   }
 759
 760   return canonical;             /* caller frees */
 761 }