1 /* libguestfs - the guestfsd daemon
2 * Copyright (C) 2009 Red Hat Inc.
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.
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.
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.
31 #include "optgroups.h"
34 optgroup_lvm2_available (void)
36 return prog_exists ("lvm");
39 /* LVM actions. Keep an eye on liblvm, although at the time
40 * of writing it hasn't progressed very far.
44 convert_lvm_output (char *out, const char *prefix)
48 int size = 0, alloc = 0;
55 pend = strchr (p, '\n'); /* Get the next line of output. */
61 while (*p && c_isspace (*p)) /* Skip any leading whitespace. */
64 /* Sigh, skip trailing whitespace too. "pvs", I'm looking at you. */
66 while (*p && c_isspace (p[len]))
69 if (!*p) { /* Empty line? Skip it. */
76 snprintf (buf, sizeof buf, "%s%s", prefix, p);
81 if (add_string (&r, &size, &alloc, str) == -1) {
91 if (add_string (&r, &size, &alloc, NULL) == -1)
94 sort_strings (r, size-1);
104 r = command (&out, &err,
105 "lvm", "pvs", "-o", "pv_name", "--noheadings", NULL);
107 reply_with_error ("%s", err);
115 return convert_lvm_output (out, NULL);
124 r = command (&out, &err,
125 "lvm", "vgs", "-o", "vg_name", "--noheadings", NULL);
127 reply_with_error ("%s", err);
135 return convert_lvm_output (out, NULL);
144 r = command (&out, &err,
146 "-o", "vg_name,lv_name", "--noheadings",
147 "--separator", "/", NULL);
149 reply_with_error ("%s", err);
157 return convert_lvm_output (out, "/dev/");
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
164 guestfs_int_lvm_pv_list *
167 return parse_command_line_pvs ();
170 guestfs_int_lvm_vg_list *
173 return parse_command_line_vgs ();
176 guestfs_int_lvm_lv_list *
179 return parse_command_line_lvs ();
183 do_pvcreate (const char *device)
188 r = command (NULL, &err,
189 "lvm", "pvcreate", device, NULL);
191 reply_with_error ("%s", err);
204 do_vgcreate (const char *volgroup, char *const *physvols)
210 argc = count_strings (physvols) + 3;
211 argv = malloc (sizeof (char *) * (argc + 1));
213 reply_with_perror ("malloc");
217 argv[1] = "vgcreate";
219 for (i = 3; i <= argc; ++i)
220 argv[i] = physvols[i-3];
222 r = commandv (NULL, &err, (const char * const*) argv);
224 reply_with_error ("%s", err);
237 do_lvcreate (const char *logvol, const char *volgroup, int mbytes)
243 snprintf (size, sizeof size, "%d", mbytes);
245 r = command (NULL, &err,
247 "-L", size, "-n", logvol, volgroup, NULL);
249 reply_with_error ("%s", err);
262 do_lvresize (const char *logvol, int mbytes)
268 snprintf (size, sizeof size, "%d", mbytes);
270 r = command (NULL, &err,
272 "--force", "-L", size, logvol, NULL);
274 reply_with_error ("%s", err);
284 do_lvresize_free (const char *logvol, int percent)
289 if (percent < 0 || percent > 100) {
290 reply_with_error ("percentage must be [0..100] (was %d)", percent);
295 snprintf (size, sizeof size, "+%d%%FREE", percent);
297 r = command (NULL, &err,
298 "lvm", "lvresize", "-l", size, logvol, NULL);
300 reply_with_error ("%s", err);
309 /* Super-dangerous command used for testing. It removes all
310 * LVs, VGs and PVs permanently.
313 do_lvm_remove_all (void)
324 for (i = 0; xs[i] != NULL; ++i) {
325 r = command (NULL, &err, "lvm", "lvremove", "-f", xs[i], NULL);
327 reply_with_error ("lvremove: %s: %s", xs[i], err);
341 for (i = 0; xs[i] != NULL; ++i) {
342 r = command (NULL, &err, "lvm", "vgremove", "-f", xs[i], NULL);
344 reply_with_error ("vgremove: %s: %s", xs[i], err);
358 for (i = 0; xs[i] != NULL; ++i) {
359 r = command (NULL, &err, "lvm", "pvremove", "-f", xs[i], NULL);
361 reply_with_error ("pvremove: %s: %s", xs[i], err);
372 /* There, that was easy, sorry about your data. */
377 do_lvremove (const char *device)
382 r = command (NULL, &err,
383 "lvm", "lvremove", "-f", device, NULL);
385 reply_with_error ("%s", err);
398 do_vgremove (const char *device)
403 r = command (NULL, &err,
404 "lvm", "vgremove", "-f", device, NULL);
406 reply_with_error ("%s", err);
419 do_pvremove (const char *device)
424 r = command (NULL, &err,
425 "lvm", "pvremove", "-ff", device, NULL);
427 reply_with_error ("%s", err);
440 do_pvresize (const char *device)
445 r = command (NULL, &err,
446 "lvm", "pvresize", device, NULL);
448 reply_with_error ("%s: %s", device, err);
458 do_pvresize_size (const char *device, int64_t size)
464 snprintf (buf, sizeof buf, "%" PRIi64 "b", size);
466 r = command (NULL, &err,
468 "--setphysicalvolumesize", buf,
471 reply_with_error ("%s: %s", device, err);
481 do_vg_activate (int activate, char *const *volgroups)
487 argc = count_strings (volgroups) + 4;
488 argv = malloc (sizeof (char *) * (argc+1));
490 reply_with_perror ("malloc");
495 argv[1] = "vgchange";
497 argv[3] = activate ? "y" : "n";
498 for (i = 4; i <= argc; ++i)
499 argv[i] = volgroups[i-4];
501 r = commandv (NULL, &err, (const char * const*) argv);
503 reply_with_error ("vgchange: %s", err);
516 do_vg_activate_all (int activate)
518 char *empty[] = { NULL };
519 return do_vg_activate (activate, empty);
523 do_lvrename (const char *logvol, const char *newlogvol)
528 r = command (NULL, &err,
530 logvol, newlogvol, NULL);
532 reply_with_error ("%s -> %s: %s", logvol, newlogvol, err);
545 do_vgrename (const char *volgroup, const char *newvolgroup)
550 r = command (NULL, &err,
552 volgroup, newvolgroup, NULL);
554 reply_with_error ("%s -> %s: %s", volgroup, newvolgroup, err);
567 get_lvm_field (const char *cmd, const char *field, const char *device)
571 int r = command (&out, &err,
573 "--unbuffered", "--noheadings", "-o", field,
576 reply_with_error ("%s: %s", device, err);
585 return out; /* Caller frees. */
589 do_pvuuid (const char *device)
591 return get_lvm_field ("pvs", "pv_uuid", device);
595 do_vguuid (const char *vgname)
597 return get_lvm_field ("vgs", "vg_uuid", vgname);
601 do_lvuuid (const char *device)
603 return get_lvm_field ("lvs", "lv_uuid", device);
607 get_lvm_fields (const char *cmd, const char *field, const char *device)
611 int r = command (&out, &err,
613 "--unbuffered", "--noheadings", "-o", field,
616 reply_with_error ("%s: %s", device, err);
624 char **ret = split_lines (out);
631 for (i = 0; ret[i] != NULL; ++i)
638 do_vgpvuuids (const char *vgname)
640 return get_lvm_fields ("vgs", "pv_uuid", vgname);
644 do_vglvuuids (const char *vgname)
646 return get_lvm_fields ("vgs", "lv_uuid", vgname);
655 r = command (NULL, &err,
656 "lvm", "vgscan", NULL);
658 reply_with_error ("%s", err);
667 /* Convert a non-canonical LV path like /dev/mapper/vg-lv or /dev/dm-0
668 * to a canonical one.
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.
677 * Note use of 'stat' instead of 'lstat' so that symlinks are fully
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
688 lv_canonical (const char *device, char **ret)
690 struct stat stat1, stat2;
692 int r = stat (device, &stat1);
694 reply_with_perror ("stat: %s", device);
698 char **lvs = do_lvs ();
703 for (i = 0; lvs[i] != NULL; ++i) {
704 r = stat (lvs[i], &stat2);
706 reply_with_perror ("stat: %s", lvs[i]);
710 if (stat1.st_rdev == stat2.st_rdev) { /* found it */
712 *ret = strdup (lvs[i]);
714 reply_with_perror ("strdup");
729 /* Test if a device is a logical volume (RHBZ#619793). */
731 do_is_lv (const char *device)
733 return lv_canonical (device, NULL);
736 /* Return canonical name of LV to caller (RHBZ#638899). */
738 do_lvm_canonical_lv_name (const char *device)
741 int r = lv_canonical (device, &canonical);
746 reply_with_error ("%s: not a logical volume", device);
750 return canonical; /* caller frees */