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