3 # Copyright (C) 2010 Red Hat Inc.
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 2 of the License, or
8 # (at your option) any later version.
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 use Sys::Guestfs::Lib qw(feature_available);
24 use Fcntl qw(S_ISREG SEEK_SET);
29 use Locale::TextDomain 'libguestfs';
31 $Data::Dumper::Sortkeys = 1;
33 die __"virt-resize: sorry this program does not work on a 32 bit host\n"
42 virt-resize - Resize a virtual machine disk
46 virt-resize [--resize /dev/sdaN=[+/-]<size>[%]]
47 [--expand /dev/sdaN] [--shrink /dev/sdaN]
48 [--ignore /dev/sdaN] [--delete /dev/sdaN] [...] indisk outdisk
52 Virt-resize is a tool which can resize a virtual machine disk, making
53 it larger or smaller overall, and resizing or deleting any partitions
56 Virt-resize B<cannot> resize disk images in-place. Virt-resize
57 B<should not> be used on live virtual machines - for consistent
58 results, shut the virtual machine down before resizing it.
60 If you are not familiar with the associated tools:
61 L<virt-list-partitions(1)>,
62 L<virt-list-filesystems(1)> and
64 we recommend you go and read those manual pages first.
68 Copy C<olddisk> to C<newdisk>, extending one of the guest's partitions
69 to fill the extra 5GB of space.
71 truncate -r olddisk newdisk; truncate -s +5G newdisk
72 virt-list-partitions -lht olddisk
73 # Note "/dev/sda2" is a partition inside the "olddisk" file.
74 virt-resize --expand /dev/sda2 olddisk newdisk
76 As above, but make the /boot partition 200MB bigger, while giving the
77 remaining space to /dev/sda2:
79 virt-resize --resize /dev/sda1=+200M --expand /dev/sda2 olddisk newdisk
81 As above, but the output format will be uncompressed qcow2:
83 qemu-img create -f qcow2 newdisk.qcow2 15G
84 virt-resize --expand /dev/sda2 olddisk newdisk.qcow2
88 =head2 EXPANDING A VIRTUAL MACHINE DISK
92 =item 1. Shut down the virtual machine
94 =item 2. Locate input disk image
96 Locate the input disk image (ie. the file or device on the host
97 containing the guest's disk). If the guest is managed by libvirt, you
98 can use C<virsh dumpxml> like this to find the disk image name:
100 # virsh dumpxml guestname | xpath /domain/devices/disk/source
103 <source dev="/dev/vg/lv_guest" />
105 =item 3. Look at current sizing
107 Use L<virt-list-partitions(1)> to display the current partitions and
110 # virt-list-partitions -lht /dev/vg/lv_guest
111 /dev/sda1 ext3 101.9M
115 (This example is a virtual machine with an 8 GB disk which we would
116 like to expand up to 10 GB).
118 =item 4. Create output disk
120 Virt-resize cannot do in-place disk modifications. You have to have
121 space to store the resized output disk.
123 To store the resized disk image in a file, create a file of a suitable
127 # truncate -s 10G outdisk
129 Or use L<lvcreate(1)> to create a logical volume:
131 # lvcreate -L 10G -n lv_name vg_name
133 Or use L<virsh(1)> vol-create-as to create a libvirt storage volume:
136 # virsh vol-create-as poolname newvol 10G
140 virt-resize takes two mandatory parameters, the input disk (eg. device
141 or file) and the output disk. The output disk is the one created in
144 # virt-resize indisk outdisk
146 This command just copies disk image C<indisk> to disk image C<outdisk>
147 I<without> resizing or changing any existing partitions. If
148 C<outdisk> is larger, then an extra, empty partition is created at the
149 end of the disk covering the extra space. If C<outdisk> is smaller,
150 then it will give an error.
152 More realistically you'd want to expand existing partitions in the
153 disk image by passing extra options (for the full list see the
154 L</OPTIONS> section below).
156 L</--expand> is the most useful option. It expands the named
157 partition within the disk to fill any extra space:
159 # virt-resize --expand /dev/sda2 indisk outdisk
161 (In this case, an extra partition is I<not> created at the end of the
162 disk, because there will be no unused space).
164 L</--resize> is the other commonly used option. The following would
165 increase the size of /dev/sda1 by 200M, and expand /dev/sda2
166 to fill the rest of the available space:
168 # virt-resize --resize /dev/sda1=+200M --expand /dev/sda2 \
171 If the expanded partition in the image contains a filesystem or LVM
172 PV, then if virt-resize knows how, it will resize the contents, the
173 equivalent of calling a command such as L<pvresize(8)>,
174 L<resize2fs(8)> or L<ntfsresize(8)>. However virt-resize does not
175 know how to resize some filesystems, so you would have to online
176 resize them after booting the guest. And virt-resize also does not
177 resize anything inside an LVM PV, it just resizes the PV itself and
178 leaves the user to resize any LVs inside that PV as desired.
180 Other options are covered below.
184 Thoroughly test the new disk image I<before> discarding the old one.
186 If you are using libvirt, edit the XML to point at the new disk:
188 # virsh edit guestname
190 Change E<lt>source ...E<gt>, see
191 L<http://libvirt.org/formatdomain.html#elementsDisks>
193 Then start up the domain with the new, resized disk:
195 # virsh start guestname
197 and check that it still works. See also the L</NOTES> section below
198 for additional information.
200 =item 7. Resize LVs etc inside the guest
202 (This can also be done offline using L<guestfish(1)>)
204 Once the guest has booted you should see the new space available, at
205 least for filesystems that virt-resize knows how to resize, and for
206 PVs. The user may need to resize LVs inside PVs, and also resize
207 filesystem types that virt-resize does not know how to expand.
211 =head2 SHRINKING A VIRTUAL MACHINE DISK
213 Shrinking is somewhat more complex than expanding, and only an
214 overview is given here.
216 Firstly virt-resize will not attempt to shrink any partition content
217 (PVs, filesystems). The user has to shrink content before passing the
218 disk image to virt-resize, and virt-resize will check that the content
219 has been shrunk properly.
221 (Shrinking can also be done offline using L<guestfish(1)>)
223 After shrinking PVs and filesystems, shut down the guest, and proceed
224 with steps 3 and 4 above to allocate a new disk image.
226 Then run virt-resize with any of the C<--shrink> and/or C<--resize>
229 =head2 IGNORING OR DELETING PARTITIONS
231 virt-resize also gives a convenient way to ignore or delete partitions
232 when copying from the input disk to the output disk. Ignoring a
233 partition speeds up the copy where you don't care about the existing
234 contents of a partition. Deleting a partition removes it completely,
235 but note that it also renumbers any partitions after the one which is
236 deleted, which can leave some guests unbootable.
238 =head2 QCOW2 AND NON-SPARSE RAW FORMATS
240 If the input disk is in qcow2 format, then you may prefer that the
241 output is in qcow2 format as well. Alternately, virt-resize can
242 convert the format on the fly. The output format is simply determined
243 by the format of the empty output container that you provide. Thus to
244 create qcow2 output, use:
246 qemu-img create [-c] -f qcow2 outdisk [size]
248 instead of the truncate command (use C<-c> for a compressed disk).
250 Similarly, to get non-sparse raw output use:
252 fallocate -l size outdisk
254 (on older systems that don't have the L<fallocate(1)> command use
255 C<dd if=/dev/zero of=outdisk bs=1M count=..>)
275 Display version number and exit.
281 =item B<--resize part=size>
283 Resize the named partition (expanding or shrinking it) so that it has
286 C<size> can be expressed as an absolute number followed by
287 b/K/M/G/T/P/E to mean bytes, Kilobytes, Megabytes, Gigabytes,
288 Terabytes, Petabytes or Exabytes; or as a percentage of the current
289 size; or as a relative number or percentage. For example:
291 --resize /dev/sda2=10G
293 --resize /dev/sda4=90%
295 --resize /dev/sda2=+1G
297 --resize /dev/sda2=-200M
299 --resize /dev/sda1=+128K
301 --resize /dev/sda1=+10%
303 --resize /dev/sda1=-10%
305 You can increase the size of any partition. Virt-resize will expand
306 the direct content of the partition if it knows how (see C<--expand>
309 You can only I<decrease> the size of partitions that contain
310 filesystems or PVs which have already been shrunk. Virt-resize will
311 check this has been done before proceeding, or else will print an
312 error (see also C<--resize-force>).
314 You can give this option multiple times.
320 =item B<--resize-force part=size>
322 This is the same as C<--resize> except that it will let you decrease
323 the size of any partition. Generally this means you will lose any
324 data which was at the end of the partition you shrink, but you may not
325 care about that (eg. if shrinking an unused partition, or if you can
326 easily recreate it such as a swap partition).
328 See also the C<--ignore> option.
334 =item B<--expand part>
336 Expand the named partition so it uses up all extra space (space left
337 over after any other resize changes that you request have been done).
339 If virt-resize knows how, it will expand the direct content of the
340 partition. For example, if the partition is an LVM PV, it will expand
341 the PV to fit (like calling L<pvresize(8)>). Virt-resize leaves any
342 other content it doesn't know about alone.
344 Currently virt-resize can resize:
350 ext2, ext3 and ext4 filesystems when they are contained
351 directly inside a partition.
355 NTFS filesystems contained directly in a partition, if libguestfs was
356 compiled with support for NTFS.
358 The filesystem must have been shut down consistently last time it was
359 used. Additionally, L<ntfsresize(8)> marks the resized filesystem as
360 requiring a consistency check, so at the first boot after resizing
361 Windows will check the disk.
365 LVM PVs (physical volumes). However virt-resize does I<not>
366 resize anything inside the PV. The user will have to resize
371 Note that you cannot use C<--expand> and C<--shrink> together.
377 =item B<--shrink part>
379 Shrink the named partition until the overall disk image fits in the
380 destination. The named partition B<must> contain a filesystem or PV
381 which has already been shrunk using another tool (eg. L<guestfish(1)>
382 or other online tools). Virt-resize will check this and give an error
383 if it has not been done.
385 The amount by which the overall disk must be shrunk (after carrying
386 out all other operations requested by the user) is called the
387 "deficit". For example, a straight copy (assume no other operations)
388 from a 5GB disk image to a 4GB disk image results in a 1GB deficit.
389 In this case, virt-resize would give an error unless the user
390 specified a partition to shrink and that partition had more than a
391 gigabyte of free space.
393 Note that you cannot use C<--expand> and C<--shrink> together.
399 =item B<--ignore part>
401 Ignore the named partition. Effectively this means the partition is
402 allocated on the destination disk, but the content is not copied
403 across from the source disk. The content of the partition will be
404 blank (all zero bytes).
406 You can give this option multiple times.
412 =item B<--delete part>
414 Delete the named partition. It would be more accurate to describe
415 this as "don't copy it over", since virt-resize doesn't do in-place
416 changes and the original disk image is left intact.
418 Note that when you delete a partition, then anything contained in the
419 partition is also deleted. Furthermore, this causes any partitions
420 that come after to be I<renumbered>, which can easily make your guest
423 You can give this option multiple times.
429 =item B<--LV-expand logvol>
431 This takes the logical volume and, as a final step, expands it to fill
432 all the space available in its volume group. A typical usage,
433 assuming a Linux guest with a single PV C</dev/sda2> and a root device
434 called C</dev/vg_guest/lv_root> would be:
436 virt-resize indisk outdisk \
437 --expand /dev/sda2 --LV-expand /dev/vg_guest/lv_root
439 This would first expand the partition (and PV), and then expand the
440 root device to fill the extra space in the PV.
442 The contents of the LV are also resized if virt-resize knows how to do
443 that. You can stop virt-resize from trying to expand the content by
444 using the option C<--no-expand-content>.
446 Use L<virt-list-filesystems(1)> to list the filesystems in
449 You can give this option multiple times, I<but> it doesn't
450 make sense to do this unless the logical volumes you specify
451 are all in different volume groups.
455 my $copy_boot_loader = 1;
457 =item B<--no-copy-boot-loader>
459 By default, virt-resize copies over some sectors at the start of the
460 disk (up to the beginning of the first partition). Commonly these
461 sectors contain the Master Boot Record (MBR) and the boot loader, and
462 are required in order for the guest to boot correctly.
464 If you specify this flag, then this initial copy is not done. You may
465 need to reinstall the boot loader in this case.
469 my $extra_partition = 1;
470 my $min_extra_partition = 10 * 1024 * 1024; # see below
472 =item B<--no-extra-partition>
474 By default, virt-resize creates an extra partition if there is any
475 extra, unused space after all resizing has happened. Use this option
476 to prevent the extra partition from being created. If you do this
477 then the extra space will be inaccessible until you run fdisk, parted,
478 or some other partitioning tool in the guest.
480 Note that if the surplus space is smaller than 10 MB, no extra
481 partition will be created.
485 my $expand_content = 1;
487 =item B<--no-expand-content>
489 By default, virt-resize will try to expand the direct contents
490 of partitions, if it knows how (see C<--expand> option above).
492 If you give the C<--no-expand-content> option then virt-resize
493 will not attempt this.
499 =item B<-d> | B<--debug>
501 Enable debugging messages.
507 =item B<-n> | B<--dryrun>
509 Print a summary of what would be done, but don't do anything.
515 =item B<-q> | B<--quiet>
517 Don't print the summary.
523 GetOptions ("help|?" => \$help,
524 "version" => \$version,
525 "resize=s" => \@resize,
526 "resize-force=s" => \@resize_force,
527 "expand=s" => \$expand,
528 "shrink=s" => \$shrink,
529 "ignore=s" => \@ignore,
530 "delete=s" => \@delete,
531 "lv-expand=s" => \@lv_expand,
532 "copy-boot-loader!" => \$copy_boot_loader,
533 "extra-partition!" => \$extra_partition,
534 "expand-content!" => \$expand_content,
535 "d|debug" => \$debug,
536 "n|dryrun|dry-run" => \$dryrun,
537 "q|quiet" => \$quiet,
539 pod2usage (1) if $help;
541 my $g = Sys::Guestfs->new ();
542 my %h = $g->version ();
543 print "$h{major}.$h{minor}.$h{release}$h{extra}\n";
547 die "virt-resize [--options] indisk outdisk\n" unless @ARGV == 2;
549 # Check in and out images exist.
550 my $infile = $ARGV[0];
551 my $outfile = $ARGV[1];
552 die __x("virt-resize: {file}: does not exist or is not readable\n", file => $infile)
554 die __x("virt-resize: {file}: does not exist or is not writable\nYou have to create the destination disk before running this program.\nPlease read the virt-resize(1) manpage for more information.\n", file => $outfile)
557 # Add them to the handle and launch the appliance.
563 $g = Sys::Guestfs->new ();
564 $g->set_trace (1) if $debug;
565 $g->add_drive_ro ($infile);
566 $g->add_drive ($outfile);
567 $g->set_progress_callback (\&progress_callback) unless $quiet;
571 my $sectsize = $g->blockdev_getss ("/dev/sdb");
573 # Get the size in bytes of each disk.
575 # Originally we computed this by looking at the same of the host file,
576 # but of course this failed for qcow2 images (RHBZ#633096). The right
577 # way to do it is with $g->blockdev_getsize64.
578 my $insize = $g->blockdev_getsize64 ("/dev/sda");
579 my $outsize = $g->blockdev_getsize64 ("/dev/sdb");
582 print "$infile size $insize bytes\n";
583 print "$outfile size $outsize bytes\n";
586 # Create a partition table.
588 # We *must* do this before copying the bootloader across, and copying
589 # the bootloader must be careful not to disturb this partition table
590 # (RHBZ#633766). There are two reasons for this:
592 # (1) The 'parted' library is stupid and broken. In many ways. In
593 # this particular instance the stupid and broken bit is that it
594 # overwrites the whole boot sector when initializating a partition
595 # table. (Upstream don't consider this obvious problem to be a bug).
597 # (2) GPT has a backup partition table located at the end of the disk.
598 # It's non-movable, because the primary GPT contains fixed references
599 # to both the size of the disk and the backup partition table at the
600 # end. This would be a problem for any resize that didn't either
601 # carefully move the backup GPT (and rewrite those references) or
602 # recreate the whole partition table from scratch.
605 create_partition_table ();
607 sub create_partition_table
611 $parttype = $g->part_get_parttype ("/dev/sda");
612 print "partition table type: $parttype\n" if $debug;
614 $g->part_init ("/dev/sdb", $parttype);
617 # In reality the number of sectors containing boot loader data will be
618 # less than this (although Windows 7 defaults to putting the first
619 # partition on sector 2048, and has quite a large boot loader).
621 # However make this large enough to be sure that we have copied over
622 # the boot loader. We could also do this by looking for the sector
623 # offset of the first partition.
625 # It doesn't matter if we copy too much.
626 my $max_bootloader = 4096 * 512;
628 die __x("virt-resize: {file}: file is too small to be a disk image ({sz} bytes)\n",
629 file => $infile, sz => $insize)
630 if $insize < $max_bootloader;
631 die __x("virt-resize: {file}: file is too small to be a disk image ({sz} bytes)\n",
632 file => $outfile, sz => $outsize)
633 if $outsize < $max_bootloader;
635 # Copy the boot loader across.
636 do_copy_boot_loader () if $copy_boot_loader;
638 sub do_copy_boot_loader
640 print "copying boot loader ...\n" if $debug;
642 # Don't disturb the partition table that we just wrote.
643 # https://secure.wikimedia.org/wikipedia/en/wiki/Master_Boot_Record
644 # https://secure.wikimedia.org/wikipedia/en/wiki/GUID_Partition_Table
646 my $bootsect = $g->pread_device ("/dev/sda", 446, 0);
647 die __"virt-resize: short read" if length ($bootsect) < 446;
649 $g->pwrite_device ("/dev/sdb", $bootsect, 0);
652 if ($parttype eq "gpt") {
653 # XXX With 4K sectors does GPT just fit more entries in a
654 # sector, or does it always use 34 sectors?
658 my $loader = $g->pread_device ("/dev/sda", $max_bootloader, $start);
659 die __"virt-resize: short read" if length ($loader) < $max_bootloader;
661 $g->pwrite_device ("/dev/sdb", $loader, $start);
664 my $to_be_expanded = 0;
666 # Get the partitions on the source disk.
669 check_source_disk ();
671 sub check_source_disk
675 # Partitions and PVs.
676 my @p = $g->part_list ("/dev/sda");
678 my $name = "/dev/sda" . $_->{part_num};
679 push @partitions, $name;
683 $h{bootable} = $g->part_get_bootable ("/dev/sda", $h{part_num});
684 eval { $h{mbr_id} = $g->part_get_mbr_id ("/dev/sda", $h{part_num}); };
685 $partitions{$name} = \%h;
689 # Examine each partition.
690 my @pvs_full = $g->pvs_full ();
691 examine_partition ($_) foreach @partitions;
693 sub examine_partition
699 my $type = "unknown";
701 $type = $g->vfs_type ($part);
703 $partitions{$part}->{type} = $type;
705 # Can we get the actual size of this object (ie. to find out if it
706 # is smaller than the container for shrinking)?
708 if ($type eq "LVM2_member") { # LVM PV
709 foreach (@pvs_full) {
710 $fssize = $_->{pv_size}
711 if canonicalize ($_->{pv_name}) eq $part;
713 } else { # Something mountable?
715 $g->mount_ro ($part, "/");
717 my %stat = $g->statvfs ("/");
718 $fssize = $stat{bsize} * $stat{blocks};
726 # This might be undef if we didn't successfully find the size. In
727 # that case user won't be allowed to shrink this partition except
729 $partitions{$part}->{fssize} = $fssize;
731 # Is it partition content that we know how to expand?
732 $partitions{$part}->{can_expand_content} = 0;
733 if ($expand_content) {
734 if ($type eq "LVM2_member") {
735 $partitions{$part}->{can_expand_content} = 1;
736 $partitions{$part}->{expand_content_method} = "pvresize";
737 } elsif ($type =~ /^ext[234]$/) {
738 $partitions{$part}->{can_expand_content} = 1;
739 $partitions{$part}->{expand_content_method} = "resize2fs";
740 } elsif ($type eq "ntfs" && feature_available ($g, "ntfsprogs")) {
741 $partitions{$part}->{can_expand_content} = 1;
742 $partitions{$part}->{expand_content_method} = "ntfsresize";
748 print "partitions found: ", join (", ", @partitions), "\n";
749 foreach my $part (@partitions) {
751 foreach (sort keys %{$partitions{$part}}) {
752 print("\t", $_, " = ",
753 defined ($partitions{$part}->{$_})
754 ? $partitions{$part}->{$_} : "undef",
760 # Examine the LVs (for --lv-expand option).
761 my @lvs = $g->lvs ();
763 examine_lv ($_) foreach @lvs;
764 mark_lvs_to_expand ();
770 $lvs{$_}->{name} = $_;
772 my $type = "unknown";
774 $type = $g->vfs_type ($_);
776 $lvs{$_}->{type} = $type;
778 if ($expand_content) {
779 if ($type =~ /^ext[234]$/) {
780 $lvs{$_}->{can_expand_content} = 1;
781 $lvs{$_}->{expand_content_method} = "resize2fs";
782 } elsif ($type eq "ntfs" && feature_available ($g, "ntfsprogs")) {
783 $lvs{$_}->{can_expand_content} = 1;
784 $lvs{$_}->{expand_content_method} = "ntfsresize";
789 sub mark_lvs_to_expand {
792 foreach (@lv_expand) {
793 die __x("virt-resize: no logical volume called {n}\n",
795 unless exists $lvs{$_};
797 if ($lvs{$_}->{can_expand_content}) {
798 $lvs{$_}->{will_expand_content} = 1;
809 $_ = "/dev/$_" unless $_ =~ m{^/dev};
810 $_ = canonicalize ($_);
812 unless (exists $partitions{$_}) {
813 die __x("{p}: partition not found in the source disk image, when using the '{opt}' command line option\n",
818 if ($partitions{$_}->{ignore}) {
819 die __x("{p}: partition ignored, you cannot use it in another command line argument\n",
822 if ($partitions{$_}->{delete}) {
823 die __x("{p}: partition deleted, you cannot use it in another command line argument\n",
831 do_ignore ($_) foreach @ignore;
836 $_ = find_partition ($_, "--ignore");
837 $partitions{$_}->{ignore} = 1;
841 do_delete ($_) foreach @delete;
846 $_ = find_partition ($_, "--delete");
847 $partitions{$_}->{delete} = 1;
850 # Handle --resize and --resize-force.
851 do_resize ($_, 0, "--resize") foreach @resize;
852 do_resize ($_, 1, "--resize-force") foreach @resize_force;
860 # Argument is "part=size" ...
861 my ($part, $sizefield) = split /=/, $_, 2;
862 $part = find_partition ($part, $option);
864 if (exists $partitions{$part}->{newsize}) {
865 die __x("{p}: this partition has already been marked for resizing\n",
869 # Parse the size field.
870 my $oldsize = $partitions{$part}->{part_size};
872 if (!defined ($sizefield) || $sizefield eq "") {
873 die __x("{p}: missing size field in {o} option\n",
874 p => $part, o => $option);
875 } elsif ($sizefield =~ /^([.\d]+)([bKMGTPE])$/) {
876 $newsize = sizebytes ($1, $2);
877 } elsif ($sizefield =~ /^\+([.\d]+)([bKMGTPE])$/) {
878 my $incr = sizebytes ($1, $2);
879 $newsize = $oldsize + $incr;
880 } elsif ($sizefield =~ /^-([.\d]+)([bKMGTPE])$/) {
881 my $decr = sizebytes ($1, $2);
882 $newsize = $oldsize - $decr;
883 } elsif ($sizefield =~ /^([.\d]+)%$/) {
884 $newsize = $oldsize * $1 / 100;
885 } elsif ($sizefield =~ /^\+([.\d]+)%$/) {
886 $newsize = $oldsize + $oldsize * $1 / 100;
887 } elsif ($sizefield =~ /^-([.\d]+)%$/) {
888 $newsize = $oldsize - $oldsize * $1 / 100;
890 die __x("{p}: {f}: cannot parse size field\n",
891 p => $part, f => $sizefield)
895 die __x("{p}: new size is zero or negative\n", p => $part);
897 mark_partition_for_resize ($part, $oldsize, $newsize, $force, $option);
900 sub mark_partition_for_resize
909 # Do nothing if the size is the same.
910 return if $oldsize == $newsize;
912 my $bigger = $newsize > $oldsize;
914 # Check there is space to shrink this.
915 unless ($bigger || $force) {
916 if (! $partitions{$part}->{fssize} ||
917 $partitions{$part}->{fssize} > $newsize) {
918 die __x("{p}: cannot make this partition smaller because it contains a\nfilesystem, physical volume or other content that is larger than the new size.\nYou have to resize the content first, see virt-resize(1).\n",
923 $partitions{$part}->{newsize} = $newsize;
925 if ($partitions{$part}->{can_expand_content} && $bigger) {
926 $partitions{$part}->{will_expand_content} = 1;
931 # Handle --expand and --shrink.
933 if (defined $expand && defined $shrink) {
934 die __"virt-resize: you cannot use options --expand and --shrink together\n"
936 if (defined $expand || defined $shrink) {
937 calculate_surplus ();
940 print "surplus before --expand or --shrink: $surplus (",
941 human_size ($surplus), ")\n";
944 do_expand () if $expand;
945 do_shrink () if $shrink;
948 # (Re-)calculate surplus after doing expand or shrink.
949 calculate_surplus ();
951 # Add up the total space required on the target so far, compared
952 # to the size of the target. We end up with a surplus or deficit.
953 sub calculate_surplus
957 # We need some overhead for partitioning. Worst case would be for
958 # EFI partitioning + massive per-partition alignment.
959 my $overhead = $sectsize * (
960 2 * 64 + # GPT start and end
961 (64 * (@partitions + 1)) # Maximum alignment
963 ($max_bootloader - 64 * 512); # boot loader
966 foreach (@partitions) {
967 if ($partitions{$_}->{newsize}) {
968 $required += $partitions{$_}->{newsize}
970 $required += $partitions{$_}->{part_size}
974 # Compare that to the actual target disk.
975 $surplus = $outsize - ($required + $overhead);
982 unless ($surplus > 0) {
983 die __x("virt-resize: error: cannot use --expand when there is no surplus space to\nexpand into. You need to make the target disk larger by at least {h}.\n",
984 h => human_size (-$surplus));
987 my $part = find_partition ($expand, "--expand");
988 my $oldsize = $partitions{$part}->{part_size};
989 mark_partition_for_resize ($part, $oldsize, $oldsize + $surplus,
997 unless ($surplus < 0) {
998 die __"virt-resize: error: cannot use --shrink because there is no deficit\n(see 'deficit' in the virt-resize(1) man page)\n"
1001 my $part = find_partition ($shrink, "--shrink");
1002 my $oldsize = $partitions{$part}->{part_size};
1003 mark_partition_for_resize ($part, $oldsize, $oldsize + $surplus,
1008 print_summary () unless $quiet;
1013 print __"Summary of changes:\n";
1015 foreach my $part (@partitions) {
1016 if ($partitions{$part}->{ignore}) {
1017 print __x("{p}: partition will be ignored\n", p => $part);
1018 } elsif ($partitions{$part}->{delete}) {
1019 print __x("{p}: partition will be deleted\n", p => $part);
1020 } elsif ($partitions{$part}->{newsize}) {
1021 print __x("{p}: partition will be resized from {oldsize} to {newsize}\n",
1023 oldsize => human_size ($partitions{$part}->{part_size}),
1024 newsize => human_size ($partitions{$part}->{newsize}));
1025 if ($partitions{$part}->{will_expand_content}) {
1026 print __x("{p}: content will be expanded using the '{meth}' method\n",
1028 meth => $partitions{$part}->{expand_content_method});
1031 print __x("{p}: partition will be left alone\n", p => $part);
1035 foreach my $lv (@lv_expand) {
1036 print __x("{n}: LV will be expanded to maximum size\n",
1040 foreach my $lv (@lvs) {
1041 if ($lvs{$lv}->{will_expand_content}) {
1042 print __x("{n}: content will be expanded using the '{meth}' method\n",
1044 meth => $lvs{$lv}->{expand_content_method});
1049 print __x("There is a surplus of {spl} bytes ({h}).\n",
1051 h => human_size ($surplus));
1052 if ($extra_partition) {
1053 if ($surplus >= $min_extra_partition) {
1054 print __"An extra partition will be created for the surplus.\n";
1056 print __"The surplus space is not large enough for an extra partition to be created\nand so it will just be ignored.\n";
1059 print __"The surplus space will be ignored. Run a partitioning program in the guest\nto partition this extra space if you want.\n";
1061 } elsif ($surplus < 0) {
1062 die __x("virt-resize: error: there is a deficit of {def} bytes ({h}).\nYou need to make the target disk larger by at least this amount,\nor adjust your resizing requests.\n",
1064 h => human_size (-$surplus));
1070 # Repartition the target disk.
1078 # Work out where to start the first partition.
1079 die __"virt-resize: source disk does not have a first partition\n"
1080 unless exists ($partitions{"/dev/sda1"});
1081 my $start = $partitions{"/dev/sda1"}->{part_start} / $sectsize;
1084 $start = ($start + 63) & ~63;
1086 print "starting to partition from $start\n" if $debug;
1088 # Create the new partitions.
1089 foreach my $part (@partitions) {
1090 unless ($partitions{$part}->{delete}) {
1093 if ($partitions{$part}->{newsize}) {
1094 $size = ($partitions{$part}->{newsize} + $sectsize - 1)
1097 $size = ($partitions{$part}->{part_size} + $sectsize - 1)
1102 my ($target, $end, $part_num) = add_partition ($start, $size);
1103 $partitions{$part}->{target} = $target;
1105 if ($partitions{$part}->{bootable}) {
1106 $g->part_set_bootable ("/dev/sdb", $part_num, 1);
1109 if ($partitions{$part}->{mbr_id}) {
1110 $g->part_set_mbr_id ("/dev/sdb", $part_num,
1111 $partitions{$part}->{mbr_id});
1114 # Start of next partition + alignment.
1116 $start = ($start + 63) & ~63;
1120 # Create surplus partition.
1121 if ($extra_partition && $surplus >= $min_extra_partition) {
1122 add_partition ($start, $outsize / $sectsize - 64 - $start);
1133 my ($target, $end, $part_num);
1135 if ($nextpart <= 3 || $parttype ne "msdos") {
1136 $target = "/dev/sdb$nextpart";
1137 $end = $start + $size - 1;
1138 $g->part_add ("/dev/sdb", "primary", $start, $end);
1139 $part_num = $nextpart++;
1141 if ($nextpart == 4) {
1142 $g->part_add ("/dev/sdb", "extended", $start, -1);
1143 $part_num = $nextpart++;
1146 $target = "/dev/sdb$nextpart";
1147 $end = $start + $size - 1;
1148 $g->part_add ("/dev/sdb", "logical", $start, $end);
1149 $part_num = $nextpart++;
1152 return ($target, $end, $part_num);
1155 # Copy over the data.
1160 foreach my $part (@partitions)
1162 unless ($partitions{$part}->{ignore}) {
1163 my $target = $partitions{$part}->{target};
1165 my $oldsize = $partitions{$part}->{part_size};
1167 if ($partitions{$part}->{newsize}) {
1168 $newsize = $partitions{$part}->{newsize};
1170 $newsize = $partitions{$part}->{part_size};
1173 if (!$quiet && !$debug) {
1174 print __x("Copying {p} ...\n", p => $part);
1177 $g->copy_size ($part, $target,
1178 $newsize < $oldsize ? $newsize : $oldsize);
1184 # After copying the data over we must shut down and restart the
1185 # appliance in order to expand the content. The reason for this may
1186 # not be obvious, but it's because otherwise we'll have duplicate VGs
1187 # (the old VG(s) and the new VG(s)) which breaks LVM.
1189 # The restart is only required if we're going to expand something.
1191 if ($to_be_expanded > 0) {
1192 restart_appliance ();
1193 expand_partitions ();
1195 expand_lvs_content ();
1198 sub restart_appliance
1200 # Sync disk and exit.
1205 $g = Sys::Guestfs->new ();
1206 $g->set_trace (1) if $debug;
1207 $g->add_drive ($outfile);
1210 # Target partitions have changed from /dev/sdb to /dev/sda,
1212 foreach my $part (@partitions)
1214 my $target = $partitions{$part}->{target};
1216 if ($target =~ m{/dev/(.)db(.*)}) {
1217 $partitions{$part}->{target} = "/dev/$1da$2";
1219 die "internal error: unexpected partition target: $target";
1225 sub expand_partitions
1227 foreach my $part (@partitions)
1229 unless ($partitions{$part}->{ignore}) {
1230 my $target = $partitions{$part}->{target};
1232 # Expand if requested.
1233 if ($partitions{$part}->{will_expand_content}) {
1234 if (!$quiet && !$debug) {
1235 print __x("Expanding {p} using the '{meth}' method\n",
1237 meth => $partitions{$part}->{expand_content_method});
1239 expand_target_partition ($part)
1246 sub expand_target_partition
1253 die unless $partitions{$part}->{can_expand_content};
1254 die unless $partitions{$part}->{will_expand_content};
1255 die unless $partitions{$part}->{expand_content_method};
1256 die unless $partitions{$part}->{target};
1257 die unless $expand_content;
1259 my $target = $partitions{$part}->{target};
1260 my $method = $partitions{$part}->{expand_content_method};
1261 if ($method eq "pvresize") {
1262 $g->pvresize ($target);
1264 elsif ($method eq "resize2fs") {
1265 $g->e2fsck_f ($target);
1266 $g->resize2fs ($target);
1268 elsif ($method eq "ntfsresize") {
1269 $g->ntfsresize ($target);
1272 die "internal error: unknown method: $method";
1280 foreach (@lv_expand) {
1281 $g->lvresize_free ($_, 100);
1285 sub expand_lvs_content
1290 if ($lvs{$_}->{will_expand_content}) {
1291 my $method = $lvs{$_}->{expand_content_method};
1292 if (!$quiet && !$debug) {
1293 print __x("Expanding {p} using the '{meth}' method\n",
1294 p => $_, meth => $method);
1296 if ($method eq "resize2fs") {
1299 } elsif ($method eq "ntfsresize") {
1300 $g->ntfsresize ($_);
1302 die "internal error: unknown method: $method";
1308 # Sync disk and exit.
1320 $_ *= 1024 if $unit =~ /[KMGTPE]/;
1321 $_ *= 1024 if $unit =~ /[MGTPE]/;
1322 $_ *= 1024 if $unit =~ /[GTPE]/;
1323 $_ *= 1024 if $unit =~ /[TPE]/;
1324 $_ *= 1024 if $unit =~ /[PE]/;
1325 $_ *= 1024 if $unit =~ /[E]/;
1330 # Convert a number of bytes to a human-readable number.
1344 sprintf "%s%dK", $sgn, $_;
1345 } elsif ($_ < 1024 * 1024) {
1346 sprintf "%s%.1fM", $sgn, ($_ / 1024);
1348 sprintf "%s%.1fG", $sgn, ($_ / 1024 / 1024);
1352 # The reverse of device name translation, see
1353 # BLOCK DEVICE NAMING in guestfs(3).
1358 if (m{^/dev/[hv]d([a-z]\d)$}) {
1364 # Not as sophisticated as the guestfish progress bar, because
1365 # I intend to use an external library for this at some point (XXX).
1366 sub progress_callback
1368 my $proc_nr = shift;
1370 my $position = shift;
1373 my $ratio = $position / $total;
1374 if ($ratio < 0) { $ratio = 0 }
1375 elsif ($ratio > 1) { $ratio = 1 }
1377 my $dots = int ($ratio * 76);
1379 print "[", "#"x$dots, "-"x(76-$dots), "]\r";
1380 print "\n" if $ratio == 1;
1385 =head2 "Partition 1 does not end on cylinder boundary."
1387 Virt-resize aligns partitions to multiples of 64 sectors. Usually
1388 this means the partitions will not be aligned to the ancient CHS
1389 geometry. However CHS geometry is meaningless for disks manufactured
1390 since the early 1990s, and doubly so for virtual hard drives.
1391 Alignment of partitions to cylinders is not required by any modern
1394 =head2 RESIZING WINDOWS VIRTUAL MACHINES
1396 In Windows Vista and later versions, Microsoft switched to using a
1397 separate boot partition. In these VMs, typically C</dev/sda1> is the
1398 boot partition and C</dev/sda2> is the main (C:) drive. We have not
1399 had any luck resizing the boot partition. Doing so seems to break the
1400 guest completely. However expanding the second partition (ie. C:
1403 Windows may initiate a lengthy "chkdsk" on first boot after a resize,
1404 if NTFS partitions have been expanded. This is just a safety check
1405 and (unless it find errors) is nothing to worry about.
1407 =head2 GUEST BOOT STUCK AT "GRUB"
1409 If a Linux guest does not boot after resizing, and the boot is stuck
1410 after printing C<GRUB> on the console, try reinstalling grub. This
1411 sometimes happens on older (RHEL 5-era) guests, for reasons we don't
1412 fully understand, although we think is to do with partition alignment.
1414 guestfish -i -a newdisk
1415 ><fs> cat /boot/grub/device.map
1416 # check the contents of this file are sensible or
1417 # edit the file if necessary
1418 ><fs> grub-install / /dev/vda
1421 For more flexible guest reconfiguration, including if you need to
1422 specify other parameters to grub-install, use L<virt-rescue(1)>.
1424 =head1 ALTERNATIVE TOOLS
1426 There are several proprietary tools for resizing partitions. We
1427 won't mention any here.
1429 L<parted(8)> and its graphical shell gparted can do some types of
1430 resizing operations on disk images. They can resize and move
1431 partitions, but I don't think they can do anything with the contents,
1432 and they certainly don't understand LVM.
1434 L<guestfish(1)> can do everything that virt-resize can do and a lot
1435 more, but at a much lower level. You will probably end up
1436 hand-calculating sector offsets, which is something that virt-resize
1437 was designed to avoid. If you want to see the guestfish-equivalent
1438 commands that virt-resize runs, use the C<--debug> flag.
1440 =head1 SHELL QUOTING
1442 Libvirt guest names can contain arbitrary characters, some of which
1443 have meaning to the shell such as C<#> and space. You may need to
1444 quote or escape these characters on the command line. See the shell
1445 manual page L<sh(1)> for details.
1449 L<virt-list-partitions(1)>,
1450 L<virt-list-filesystems(1)>,
1467 L<http://libguestfs.org/>.
1471 Richard W.M. Jones L<http://people.redhat.com/~rjones/>
1475 Copyright (C) 2010 Red Hat Inc.
1477 This program is free software; you can redistribute it and/or modify
1478 it under the terms of the GNU General Public License as published by
1479 the Free Software Foundation; either version 2 of the License, or
1480 (at your option) any later version.
1482 This program is distributed in the hope that it will be useful,
1483 but WITHOUT ANY WARRANTY; without even the implied warranty of
1484 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1485 GNU General Public License for more details.
1487 You should have received a copy of the GNU General Public License
1488 along with this program; if not, write to the Free Software
1489 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.