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 <string.h>
  24 #include <unistd.h>
  25
  26 #include "daemon.h"
  27 #include "c-ctype.h"
  28 #include "actions.h"
  29 #include "optgroups.h"
  30
  31 int
  32 optgroup_lvm2_available (void)
  33 {
  34   int r = access ("/sbin/lvm", X_OK);
  35   return r == 0;
  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                "/sbin/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                "/sbin/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                "/sbin/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                "/sbin/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] = "/sbin/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                "/sbin/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                "/sbin/lvm", "lvresize",
 271                "-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 /* Super-dangerous command used for testing.  It removes all
 283  * LVs, VGs and PVs permanently.
 284  */
 285 int
 286 do_lvm_remove_all (void)
 287 {
 288   char **xs;
 289   int i, r;
 290   char *err;
 291
 292   /* Remove LVs. */
 293   xs = do_lvs ();
 294   if (xs == NULL)
 295     return -1;
 296
 297   for (i = 0; xs[i] != NULL; ++i) {
 298     r = command (NULL, &err, "/sbin/lvm", "lvremove", "-f", xs[i], NULL);
 299     if (r == -1) {
 300       reply_with_error ("lvremove: %s: %s", xs[i], err);
 301       free (err);
 302       free_strings (xs);
 303       return -1;
 304     }
 305     free (err);
 306   }
 307   free_strings (xs);
 308
 309   /* Remove VGs. */
 310   xs = do_vgs ();
 311   if (xs == NULL)
 312     return -1;
 313
 314   for (i = 0; xs[i] != NULL; ++i) {
 315     r = command (NULL, &err, "/sbin/lvm", "vgremove", "-f", xs[i], NULL);
 316     if (r == -1) {
 317       reply_with_error ("vgremove: %s: %s", xs[i], err);
 318       free (err);
 319       free_strings (xs);
 320       return -1;
 321     }
 322     free (err);
 323   }
 324   free_strings (xs);
 325
 326   /* Remove PVs. */
 327   xs = do_pvs ();
 328   if (xs == NULL)
 329     return -1;
 330
 331   for (i = 0; xs[i] != NULL; ++i) {
 332     r = command (NULL, &err, "/sbin/lvm", "pvremove", "-f", xs[i], NULL);
 333     if (r == -1) {
 334       reply_with_error ("pvremove: %s: %s", xs[i], err);
 335       free (err);
 336       free_strings (xs);
 337       return -1;
 338     }
 339     free (err);
 340   }
 341   free_strings (xs);
 342
 343   udev_settle ();
 344
 345   /* There, that was easy, sorry about your data. */
 346   return 0;
 347 }
 348
 349 int
 350 do_lvremove (const char *device)
 351 {
 352   char *err;
 353   int r;
 354
 355   r = command (NULL, &err,
 356                "/sbin/lvm", "lvremove", "-f", device, NULL);
 357   if (r == -1) {
 358     reply_with_error ("%s", err);
 359     free (err);
 360     return -1;
 361   }
 362
 363   free (err);
 364
 365   udev_settle ();
 366
 367   return 0;
 368 }
 369
 370 int
 371 do_vgremove (const char *device)
 372 {
 373   char *err;
 374   int r;
 375
 376   r = command (NULL, &err,
 377                "/sbin/lvm", "vgremove", "-f", device, NULL);
 378   if (r == -1) {
 379     reply_with_error ("%s", err);
 380     free (err);
 381     return -1;
 382   }
 383
 384   free (err);
 385
 386   udev_settle ();
 387
 388   return 0;
 389 }
 390
 391 int
 392 do_pvremove (const char *device)
 393 {
 394   char *err;
 395   int r;
 396
 397   r = command (NULL, &err,
 398                "/sbin/lvm", "pvremove", "-ff", device, NULL);
 399   if (r == -1) {
 400     reply_with_error ("%s", err);
 401     free (err);
 402     return -1;
 403   }
 404
 405   free (err);
 406
 407   udev_settle ();
 408
 409   return 0;
 410 }
 411
 412 int
 413 do_pvresize (const char *device)
 414 {
 415   char *err;
 416   int r;
 417
 418   r = command (NULL, &err,
 419                "/sbin/lvm", "pvresize", device, NULL);
 420   if (r == -1) {
 421     reply_with_error ("%s: %s", device, err);
 422     free (err);
 423     return -1;
 424   }
 425
 426   free (err);
 427   return 0;
 428 }
 429
 430 int
 431 do_vg_activate (int activate, char *const *volgroups)
 432 {
 433   char *err;
 434   int r, i, argc;
 435   const char **argv;
 436
 437   argc = count_strings (volgroups) + 4;
 438   argv = malloc (sizeof (char *) * (argc+1));
 439   if (argv == NULL) {
 440     reply_with_perror ("malloc");
 441     return -1;
 442   }
 443
 444   argv[0] = "/sbin/lvm";
 445   argv[1] = "vgchange";
 446   argv[2] = "-a";
 447   argv[3] = activate ? "y" : "n";
 448   for (i = 4; i <= argc; ++i)
 449     argv[i] = volgroups[i-4];
 450
 451   r = commandv (NULL, &err, (const char * const*) argv);
 452   if (r == -1) {
 453     reply_with_error ("vgchange: %s", err);
 454     free (err);
 455     return -1;
 456   }
 457
 458   free (err);
 459
 460   udev_settle ();
 461
 462   return 0;
 463 }
 464
 465 int
 466 do_vg_activate_all (int activate)
 467 {
 468   char *empty[] = { NULL };
 469   return do_vg_activate (activate, empty);
 470 }
 471
 472 int
 473 do_lvrename (const char *logvol, const char *newlogvol)
 474 {
 475   char *err;
 476   int r;
 477
 478   r = command (NULL, &err,
 479                "/sbin/lvm", "lvrename",
 480                logvol, newlogvol, NULL);
 481   if (r == -1) {
 482     reply_with_error ("%s -> %s: %s", logvol, newlogvol, err);
 483     free (err);
 484     return -1;
 485   }
 486
 487   free (err);
 488
 489   udev_settle ();
 490
 491   return 0;
 492 }
 493
 494 int
 495 do_vgrename (const char *volgroup, const char *newvolgroup)
 496 {
 497   char *err;
 498   int r;
 499
 500   r = command (NULL, &err,
 501                "/sbin/lvm", "vgrename",
 502                volgroup, newvolgroup, NULL);
 503   if (r == -1) {
 504     reply_with_error ("%s -> %s: %s", volgroup, newvolgroup, err);
 505     free (err);
 506     return -1;
 507   }
 508
 509   free (err);
 510
 511   udev_settle ();
 512
 513   return 0;
 514 }
 515
 516 static char *
 517 get_lvm_field (const char *cmd, const char *field, const char *device)
 518 {
 519   char *out;
 520   char *err;
 521   int r = command (&out, &err,
 522                    "/sbin/lvm", cmd,
 523                    "--unbuffered", "--noheadings", "-o", field,
 524                    device, NULL);
 525   if (r == -1) {
 526     reply_with_error ("%s: %s", device, err);
 527     free (out);
 528     free (err);
 529     return NULL;
 530   }
 531
 532   free (err);
 533
 534   trim (out);
 535   return out;                   /* Caller frees. */
 536 }
 537
 538 char *
 539 do_pvuuid (const char *device)
 540 {
 541   return get_lvm_field ("pvs", "pv_uuid", device);
 542 }
 543
 544 char *
 545 do_vguuid (const char *vgname)
 546 {
 547   return get_lvm_field ("vgs", "vg_uuid", vgname);
 548 }
 549
 550 char *
 551 do_lvuuid (const char *device)
 552 {
 553   return get_lvm_field ("lvs", "lv_uuid", device);
 554 }
 555
 556 static char **
 557 get_lvm_fields (const char *cmd, const char *field, const char *device)
 558 {
 559   char *out;
 560   char *err;
 561   int r = command (&out, &err,
 562                    "/sbin/lvm", cmd,
 563                    "--unbuffered", "--noheadings", "-o", field,
 564                    device, NULL);
 565   if (r == -1) {
 566     reply_with_error ("%s: %s", device, err);
 567     free (out);
 568     free (err);
 569     return NULL;
 570   }
 571
 572   free (err);
 573
 574   char **ret = split_lines (out);
 575   free (out);
 576
 577   if (ret == NULL)
 578     return NULL;
 579
 580   size_t i;
 581   for (i = 0; ret[i] != NULL; ++i)
 582     trim (ret[i]);
 583
 584   return ret;
 585 }
 586
 587 char **
 588 do_vgpvuuids (const char *vgname)
 589 {
 590   return get_lvm_fields ("vgs", "pv_uuid", vgname);
 591 }
 592
 593 char **
 594 do_vglvuuids (const char *vgname)
 595 {
 596   return get_lvm_fields ("vgs", "lv_uuid", vgname);
 597 }