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
  27 #include "daemon.h"
  28 #include "c-ctype.h"
  29 #include "actions.h"
  30 #include "optgroups.h"
  31
  32 int
  33 optgroup_lvm2_available (void)
  34 {
  35   return prog_exists ("lvm");
  36 }
  37
  38 /* LVM actions.  Keep an eye on liblvm, although at the time
  39  * of writing it hasn't progressed very far.
  40  */
  41
  42 static char **
  43 convert_lvm_output (char *out, const char *prefix)
  44 {
  45   char *p, *pend;
  46   char **r = NULL;
  47   int size = 0, alloc = 0;
  48   int len;
  49   char buf[256];
  50   char *str;
  51
  52   p = out;
  53   while (p) {
  54     pend = strchr (p, '\n');    /* Get the next line of output. */
  55     if (pend) {
  56       *pend = '\0';
  57       pend++;
  58     }
  59
  60     while (*p && c_isspace (*p))        /* Skip any leading whitespace. */
  61       p++;
  62
  63     /* Sigh, skip trailing whitespace too.  "pvs", I'm looking at you. */
  64     len = strlen (p)-1;
  65     while (*p && c_isspace (p[len]))
  66       p[len--] = '\0';
  67
  68     if (!*p) {                  /* Empty line?  Skip it. */
  69       p = pend;
  70       continue;
  71     }
  72
  73     /* Prefix? */
  74     if (prefix) {
  75       snprintf (buf, sizeof buf, "%s%s", prefix, p);
  76       str = buf;
  77     } else
  78       str = p;
  79
  80     if (add_string (&r, &size, &alloc, str) == -1) {
  81       free (out);
  82       return NULL;
  83     }
  84
  85     p = pend;
  86   }
  87
  88   free (out);
  89
  90   if (add_string (&r, &size, &alloc, NULL) == -1)
  91     return NULL;
  92
  93   sort_strings (r, size-1);
  94   return r;
  95 }
  96
  97 char **
  98 do_pvs (void)
  99 {
 100   char *out, *err;
 101   int r;
 102
 103   r = command (&out, &err,
 104                "lvm", "pvs", "-o", "pv_name", "--noheadings", NULL);
 105   if (r == -1) {
 106     reply_with_error ("%s", err);
 107     free (out);
 108     free (err);
 109     return NULL;
 110   }
 111
 112   free (err);
 113
 114   return convert_lvm_output (out, NULL);
 115 }
 116
 117 char **
 118 do_vgs (void)
 119 {
 120   char *out, *err;
 121   int r;
 122
 123   r = command (&out, &err,
 124                "lvm", "vgs", "-o", "vg_name", "--noheadings", NULL);
 125   if (r == -1) {
 126     reply_with_error ("%s", err);
 127     free (out);
 128     free (err);
 129     return NULL;
 130   }
 131
 132   free (err);
 133
 134   return convert_lvm_output (out, NULL);
 135 }
 136
 137 char **
 138 do_lvs (void)
 139 {
 140   char *out, *err;
 141   int r;
 142
 143   r = command (&out, &err,
 144                "lvm", "lvs",
 145                "-o", "vg_name,lv_name", "--noheadings",
 146                "--separator", "/", NULL);
 147   if (r == -1) {
 148     reply_with_error ("%s", err);
 149     free (out);
 150     free (err);
 151     return NULL;
 152   }
 153
 154   free (err);
 155
 156   return convert_lvm_output (out, "/dev/");
 157 }
 158
 159 /* These were so complex to implement that I ended up auto-generating
 160  * the code.  That code is in stubs.c, and it is generated as usual
 161  * by generator.ml.
 162  */
 163 guestfs_int_lvm_pv_list *
 164 do_pvs_full (void)
 165 {
 166   return parse_command_line_pvs ();
 167 }
 168
 169 guestfs_int_lvm_vg_list *
 170 do_vgs_full (void)
 171 {
 172   return parse_command_line_vgs ();
 173 }
 174
 175 guestfs_int_lvm_lv_list *
 176 do_lvs_full (void)
 177 {
 178   return parse_command_line_lvs ();
 179 }
 180
 181 int
 182 do_pvcreate (const char *device)
 183 {
 184   char *err;
 185   int r;
 186
 187   r = command (NULL, &err,
 188                "lvm", "pvcreate", device, NULL);
 189   if (r == -1) {
 190     reply_with_error ("%s", err);
 191     free (err);
 192     return -1;
 193   }
 194
 195   free (err);
 196
 197   udev_settle ();
 198
 199   return 0;
 200 }
 201
 202 int
 203 do_vgcreate (const char *volgroup, char *const *physvols)
 204 {
 205   char *err;
 206   int r, argc, i;
 207   const char **argv;
 208
 209   argc = count_strings (physvols) + 3;
 210   argv = malloc (sizeof (char *) * (argc + 1));
 211   if (argv == NULL) {
 212     reply_with_perror ("malloc");
 213     return -1;
 214   }
 215   argv[0] = "lvm";
 216   argv[1] = "vgcreate";
 217   argv[2] = volgroup;
 218   for (i = 3; i <= argc; ++i)
 219     argv[i] = physvols[i-3];
 220
 221   r = commandv (NULL, &err, (const char * const*) argv);
 222   if (r == -1) {
 223     reply_with_error ("%s", err);
 224     free (err);
 225     return -1;
 226   }
 227
 228   free (err);
 229
 230   udev_settle ();
 231
 232   return 0;
 233 }
 234
 235 int
 236 do_lvcreate (const char *logvol, const char *volgroup, int mbytes)
 237 {
 238   char *err;
 239   int r;
 240   char size[64];
 241
 242   snprintf (size, sizeof size, "%d", mbytes);
 243
 244   r = command (NULL, &err,
 245                "lvm", "lvcreate",
 246                "-L", size, "-n", logvol, volgroup, NULL);
 247   if (r == -1) {
 248     reply_with_error ("%s", err);
 249     free (err);
 250     return -1;
 251   }
 252
 253   free (err);
 254
 255   udev_settle ();
 256
 257   return 0;
 258 }
 259
 260 int
 261 do_lvresize (const char *logvol, int mbytes)
 262 {
 263   char *err;
 264   int r;
 265   char size[64];
 266
 267   snprintf (size, sizeof size, "%d", mbytes);
 268
 269   r = command (NULL, &err,
 270                "lvm", "lvresize",
 271                "--force", "-L", size, logvol, NULL);
 272   if (r == -1) {
 273     reply_with_error ("%s", err);
 274     free (err);
 275     return -1;
 276   }
 277
 278   free (err);
 279   return 0;
 280 }
 281
 282 int
 283 do_lvresize_free (const char *logvol, int percent)
 284 {
 285   char *err;
 286   int r;
 287
 288   if (percent < 0 || percent > 100) {
 289     reply_with_error ("percentage must be [0..100] (was %d)", percent);
 290     return -1;
 291   }
 292
 293   char size[64];
 294   snprintf (size, sizeof size, "+%d%%FREE", percent);
 295
 296   r = command (NULL, &err,
 297                "lvm", "lvresize", "-l", size, logvol, NULL);
 298   if (r == -1) {
 299     reply_with_error ("%s", err);
 300     free (err);
 301     return -1;
 302   }
 303
 304   free (err);
 305   return 0;
 306 }
 307
 308 /* Super-dangerous command used for testing.  It removes all
 309  * LVs, VGs and PVs permanently.
 310  */
 311 int
 312 do_lvm_remove_all (void)
 313 {
 314   char **xs;
 315   int i, r;
 316   char *err;
 317
 318   /* Remove LVs. */
 319   xs = do_lvs ();
 320   if (xs == NULL)
 321     return -1;
 322
 323   for (i = 0; xs[i] != NULL; ++i) {
 324     r = command (NULL, &err, "lvm", "lvremove", "-f", xs[i], NULL);
 325     if (r == -1) {
 326       reply_with_error ("lvremove: %s: %s", xs[i], err);
 327       free (err);
 328       free_strings (xs);
 329       return -1;
 330     }
 331     free (err);
 332   }
 333   free_strings (xs);
 334
 335   /* Remove VGs. */
 336   xs = do_vgs ();
 337   if (xs == NULL)
 338     return -1;
 339
 340   for (i = 0; xs[i] != NULL; ++i) {
 341     r = command (NULL, &err, "lvm", "vgremove", "-f", xs[i], NULL);
 342     if (r == -1) {
 343       reply_with_error ("vgremove: %s: %s", xs[i], err);
 344       free (err);
 345       free_strings (xs);
 346       return -1;
 347     }
 348     free (err);
 349   }
 350   free_strings (xs);
 351
 352   /* Remove PVs. */
 353   xs = do_pvs ();
 354   if (xs == NULL)
 355     return -1;
 356
 357   for (i = 0; xs[i] != NULL; ++i) {
 358     r = command (NULL, &err, "lvm", "pvremove", "-f", xs[i], NULL);
 359     if (r == -1) {
 360       reply_with_error ("pvremove: %s: %s", xs[i], err);
 361       free (err);
 362       free_strings (xs);
 363       return -1;
 364     }
 365     free (err);
 366   }
 367   free_strings (xs);
 368
 369   udev_settle ();
 370
 371   /* There, that was easy, sorry about your data. */
 372   return 0;
 373 }
 374
 375 int
 376 do_lvremove (const char *device)
 377 {
 378   char *err;
 379   int r;
 380
 381   r = command (NULL, &err,
 382                "lvm", "lvremove", "-f", device, NULL);
 383   if (r == -1) {
 384     reply_with_error ("%s", err);
 385     free (err);
 386     return -1;
 387   }
 388
 389   free (err);
 390
 391   udev_settle ();
 392
 393   return 0;
 394 }
 395
 396 int
 397 do_vgremove (const char *device)
 398 {
 399   char *err;
 400   int r;
 401
 402   r = command (NULL, &err,
 403                "lvm", "vgremove", "-f", device, NULL);
 404   if (r == -1) {
 405     reply_with_error ("%s", err);
 406     free (err);
 407     return -1;
 408   }
 409
 410   free (err);
 411
 412   udev_settle ();
 413
 414   return 0;
 415 }
 416
 417 int
 418 do_pvremove (const char *device)
 419 {
 420   char *err;
 421   int r;
 422
 423   r = command (NULL, &err,
 424                "lvm", "pvremove", "-ff", device, NULL);
 425   if (r == -1) {
 426     reply_with_error ("%s", err);
 427     free (err);
 428     return -1;
 429   }
 430
 431   free (err);
 432
 433   udev_settle ();
 434
 435   return 0;
 436 }
 437
 438 int
 439 do_pvresize (const char *device)
 440 {
 441   char *err;
 442   int r;
 443
 444   r = command (NULL, &err,
 445                "lvm", "pvresize", device, NULL);
 446   if (r == -1) {
 447     reply_with_error ("%s: %s", device, err);
 448     free (err);
 449     return -1;
 450   }
 451
 452   free (err);
 453   return 0;
 454 }
 455
 456 int
 457 do_pvresize_size (const char *device, int64_t size)
 458 {
 459   char *err;
 460   int r;
 461
 462   char buf[32];
 463   snprintf (buf, sizeof buf, "%" PRIi64 "b", size);
 464
 465   r = command (NULL, &err,
 466                "lvm", "pvresize",
 467                "--setphysicalvolumesize", buf,
 468                device, NULL);
 469   if (r == -1) {
 470     reply_with_error ("%s: %s", device, err);
 471     free (err);
 472     return -1;
 473   }
 474
 475   free (err);
 476   return 0;
 477 }
 478
 479 int
 480 do_vg_activate (int activate, char *const *volgroups)
 481 {
 482   char *err;
 483   int r, i, argc;
 484   const char **argv;
 485
 486   argc = count_strings (volgroups) + 4;
 487   argv = malloc (sizeof (char *) * (argc+1));
 488   if (argv == NULL) {
 489     reply_with_perror ("malloc");
 490     return -1;
 491   }
 492
 493   argv[0] = "lvm";
 494   argv[1] = "vgchange";
 495   argv[2] = "-a";
 496   argv[3] = activate ? "y" : "n";
 497   for (i = 4; i <= argc; ++i)
 498     argv[i] = volgroups[i-4];
 499
 500   r = commandv (NULL, &err, (const char * const*) argv);
 501   if (r == -1) {
 502     reply_with_error ("vgchange: %s", err);
 503     free (err);
 504     return -1;
 505   }
 506
 507   free (err);
 508
 509   udev_settle ();
 510
 511   return 0;
 512 }
 513
 514 int
 515 do_vg_activate_all (int activate)
 516 {
 517   char *empty[] = { NULL };
 518   return do_vg_activate (activate, empty);
 519 }
 520
 521 int
 522 do_lvrename (const char *logvol, const char *newlogvol)
 523 {
 524   char *err;
 525   int r;
 526
 527   r = command (NULL, &err,
 528                "lvm", "lvrename",
 529                logvol, newlogvol, NULL);
 530   if (r == -1) {
 531     reply_with_error ("%s -> %s: %s", logvol, newlogvol, err);
 532     free (err);
 533     return -1;
 534   }
 535
 536   free (err);
 537
 538   udev_settle ();
 539
 540   return 0;
 541 }
 542
 543 int
 544 do_vgrename (const char *volgroup, const char *newvolgroup)
 545 {
 546   char *err;
 547   int r;
 548
 549   r = command (NULL, &err,
 550                "lvm", "vgrename",
 551                volgroup, newvolgroup, NULL);
 552   if (r == -1) {
 553     reply_with_error ("%s -> %s: %s", volgroup, newvolgroup, err);
 554     free (err);
 555     return -1;
 556   }
 557
 558   free (err);
 559
 560   udev_settle ();
 561
 562   return 0;
 563 }
 564
 565 static char *
 566 get_lvm_field (const char *cmd, const char *field, const char *device)
 567 {
 568   char *out;
 569   char *err;
 570   int r = command (&out, &err,
 571                    "lvm", cmd,
 572                    "--unbuffered", "--noheadings", "-o", field,
 573                    device, NULL);
 574   if (r == -1) {
 575     reply_with_error ("%s: %s", device, err);
 576     free (out);
 577     free (err);
 578     return NULL;
 579   }
 580
 581   free (err);
 582
 583   trim (out);
 584   return out;                   /* Caller frees. */
 585 }
 586
 587 char *
 588 do_pvuuid (const char *device)
 589 {
 590   return get_lvm_field ("pvs", "pv_uuid", device);
 591 }
 592
 593 char *
 594 do_vguuid (const char *vgname)
 595 {
 596   return get_lvm_field ("vgs", "vg_uuid", vgname);
 597 }
 598
 599 char *
 600 do_lvuuid (const char *device)
 601 {
 602   return get_lvm_field ("lvs", "lv_uuid", device);
 603 }
 604
 605 static char **
 606 get_lvm_fields (const char *cmd, const char *field, const char *device)
 607 {
 608   char *out;
 609   char *err;
 610   int r = command (&out, &err,
 611                    "lvm", cmd,
 612                    "--unbuffered", "--noheadings", "-o", field,
 613                    device, NULL);
 614   if (r == -1) {
 615     reply_with_error ("%s: %s", device, err);
 616     free (out);
 617     free (err);
 618     return NULL;
 619   }
 620
 621   free (err);
 622
 623   char **ret = split_lines (out);
 624   free (out);
 625
 626   if (ret == NULL)
 627     return NULL;
 628
 629   size_t i;
 630   for (i = 0; ret[i] != NULL; ++i)
 631     trim (ret[i]);
 632
 633   return ret;
 634 }
 635
 636 char **
 637 do_vgpvuuids (const char *vgname)
 638 {
 639   return get_lvm_fields ("vgs", "pv_uuid", vgname);
 640 }
 641
 642 char **
 643 do_vglvuuids (const char *vgname)
 644 {
 645   return get_lvm_fields ("vgs", "lv_uuid", vgname);
 646 }
 647
 648 int
 649 do_vgscan (void)
 650 {
 651   char *err;
 652   int r;
 653
 654   r = command (NULL, &err,
 655                "lvm", "vgscan", NULL);
 656   if (r == -1) {
 657     reply_with_error ("%s", err);
 658     free (err);
 659     return -1;
 660   }
 661
 662   free (err);
 663   return 0;
 664 }