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"
40 virt-resize - Resize a virtual machine disk
44 virt-resize [--resize /dev/sdaN=[+/-]<size>[%]]
45 [--expand /dev/sdaN] [--shrink /dev/sdaN]
46 [--ignore /dev/sdaN] [--delete /dev/sdaN] [...] indisk outdisk
50 Virt-resize is a tool which can resize a virtual machine disk, making
51 it larger or smaller overall, and resizing or deleting any partitions
54 Virt-resize B<cannot> resize disk images in-place. Virt-resize
55 B<should not> be used on live virtual machines - for consistent
56 results, shut the virtual machine down before resizing it.
58 If you are not familiar with the associated tools:
59 L<virt-list-partitions(1)>,
60 L<virt-list-filesystems(1)> and
62 we recommend you go and read those manual pages first.
66 Copy C<olddisk> to C<newdisk>, extending one of the guest's partitions
67 to fill the extra 5GB of space.
69 truncate -r olddisk newdisk; truncate -s +5G newdisk
70 virt-list-partitions -lht olddisk
71 # Note "/dev/sda2" is a partition inside the "olddisk" file.
72 virt-resize --expand /dev/sda2 olddisk newdisk
74 As above, but make the /boot partition 200MB bigger, while giving the
75 remaining space to /dev/sda2:
77 virt-resize --resize /dev/sda1=+200M --expand /dev/sda2 olddisk newdisk
81 =head2 EXPANDING A VIRTUAL MACHINE DISK
85 =item 1. Shut down the virtual machine
87 =item 2. Locate input disk image
89 Locate the input disk image (ie. the file or device on the host
90 containing the guest's disk). If the guest is managed by libvirt, you
91 can use C<virsh dumpxml> like this to find the disk image name:
93 # virsh dumpxml guestname | xpath /domain/devices/disk/source
96 <source dev="/dev/vg/lv_guest" />
98 =item 3. Look at current sizing
100 Use L<virt-list-partitions(1)> to display the current partitions and
103 # virt-list-partitions -lht /dev/vg/lv_guest
104 /dev/sda1 ext3 101.9M
108 (This example is a virtual machine with an 8 GB disk which we would
109 like to expand up to 10 GB).
111 =item 4. Create output disk
113 Virt-resize cannot do in-place disk modifications. You have to have
114 space to store the resized output disk.
116 To store the resized disk image in a file, create a file of a suitable
120 # truncate -s 10G outdisk
122 Or use L<lvcreate(1)> to create a logical volume:
124 # lvcreate -L 10G -n lv_name vg_name
126 Or use L<virsh(1)> vol-create-as to create a libvirt storage volume:
129 # virsh vol-create-as poolname newvol 10G
133 virt-resize takes two mandatory parameters, the input disk (eg. device
134 or file) and the output disk. The output disk is the one created in
137 # virt-resize indisk outdisk
139 This command just copies disk image C<indisk> to disk image C<outdisk>
140 I<without> resizing or changing any existing partitions. If
141 C<outdisk> is larger, then an extra, empty partition is created at the
142 end of the disk covering the extra space. If C<outdisk> is smaller,
143 then it will give an error.
145 More realistically you'd want to expand existing partitions in the
146 disk image by passing extra options (for the full list see the
147 L</OPTIONS> section below).
149 L</--expand> is the most useful option. It expands the named
150 partition within the disk to fill any extra space:
152 # virt-resize --expand /dev/sda2 indisk outdisk
154 (In this case, an extra partition is I<not> created at the end of the
155 disk, because there will be no unused space).
157 L</--resize> is the other commonly used option. The following would
158 increase the size of /dev/sda1 by 200M, and expand /dev/sda2
159 to fill the rest of the available space:
161 # virt-resize --resize /dev/sda1=+200M --expand /dev/sda2 \
164 If the expanded partition in the image contains a filesystem or LVM
165 PV, then if virt-resize knows how, it will resize the contents, the
166 equivalent of calling a command such as L<pvresize(8)>,
167 L<resize2fs(8)> or L<ntfsresize(8)>. However virt-resize does not
168 know how to resize some filesystems, so you would have to online
169 resize them after booting the guest. And virt-resize also does not
170 resize anything inside an LVM PV, it just resizes the PV itself and
171 leaves the user to resize any LVs inside that PV as desired.
173 Other options are covered below.
177 Thoroughly test the new disk image I<before> discarding the old one.
179 If you are using libvirt, edit the XML to point at the new disk:
181 # virsh edit guestname
183 Change E<lt>source ...E<gt>, see
184 L<http://libvirt.org/formatdomain.html#elementsDisks>
186 Then start up the domain with the new, resized disk:
188 # virsh start guestname
190 and check that it still works. See also the L</NOTES> section below
191 for additional information.
193 =item 7. Resize LVs etc inside the guest
195 (This can also be done offline using L<guestfish(1)>)
197 Once the guest has booted you should see the new space available, at
198 least for filesystems that virt-resize knows how to resize, and for
199 PVs. The user may need to resize LVs inside PVs, and also resize
200 filesystem types that virt-resize does not know how to expand.
204 =head2 SHRINKING A VIRTUAL MACHINE DISK
206 Shrinking is somewhat more complex than expanding, and only an
207 overview is given here.
209 Firstly virt-resize will not attempt to shrink any partition content
210 (PVs, filesystems). The user has to shrink content before passing the
211 disk image to virt-resize, and virt-resize will check that the content
212 has been shrunk properly.
214 (Shrinking can also be done offline using L<guestfish(1)>)
216 After shrinking PVs and filesystems, shut down the guest, and proceed
217 with steps 3 and 4 above to allocate a new disk image.
219 Then run virt-resize with any of the C<--shrink> and/or C<--resize>
222 =head2 IGNORING OR DELETING PARTITIONS
224 virt-resize also gives a convenient way to ignore or delete partitions
225 when copying from the input disk to the output disk. Ignoring a
226 partition speeds up the copy where you don't care about the existing
227 contents of a partition. Deleting a partition removes it completely,
228 but note that it also renumbers any partitions after the one which is
229 deleted, which can leave some guests unbootable.
249 Display version number and exit.
255 =item B<--resize part=size>
257 Resize the named partition (expanding or shrinking it) so that it has
260 C<size> can be expressed as an absolute number followed by
261 b/K/M/G/T/P/E to mean bytes, Kilobytes, Megabytes, Gigabytes,
262 Terabytes, Petabytes or Exabytes; or as a percentage of the current
263 size; or as a relative number or percentage. For example:
265 --resize /dev/sda2=10G
267 --resize /dev/sda4=90%
269 --resize /dev/sda2=+1G
271 --resize /dev/sda2=-200M
273 --resize /dev/sda1=+128K
275 --resize /dev/sda1=+10%
277 --resize /dev/sda1=-10%
279 You can increase the size of any partition. Virt-resize will expand
280 the direct content of the partition if it knows how (see C<--expand>
283 You can only I<decrease> the size of partitions that contain
284 filesystems or PVs which have already been shrunk. Virt-resize will
285 check this has been done before proceeding, or else will print an
286 error (see also C<--resize-force>).
288 You can give this option multiple times.
294 =item B<--resize-force part=size>
296 This is the same as C<--resize> except that it will let you decrease
297 the size of any partition. Generally this means you will lose any
298 data which was at the end of the partition you shrink, but you may not
299 care about that (eg. if shrinking an unused partition, or if you can
300 easily recreate it such as a swap partition).
302 See also the C<--ignore> option.
308 =item B<--expand part>
310 Expand the named partition so it uses up all extra space (space left
311 over after any other resize changes that you request have been done).
313 If virt-resize knows how, it will expand the direct content of the
314 partition. For example, if the partition is an LVM PV, it will expand
315 the PV to fit (like calling L<pvresize(8)>). Virt-resize leaves any
316 other content it doesn't know about alone.
318 Currently virt-resize can resize:
324 ext2, ext3 and ext4 filesystems when they are contained
325 directly inside a partition.
329 NTFS filesystems contained directly in a partition, if libguestfs was
330 compiled with support for NTFS.
332 The filesystem must have been shut down consistently last time it was
333 used. Additionally, L<ntfsresize(8)> marks the resized filesystem as
334 requiring a consistency check, so at the first boot after resizing
335 Windows will check the disk.
339 LVM PVs (physical volumes). However virt-resize does I<not>
340 resize anything inside the PV. The user will have to resize
345 Note that you cannot use C<--expand> and C<--shrink> together.
351 =item B<--shrink part>
353 Shrink the named partition until the overall disk image fits in the
354 destination. The named partition B<must> contain a filesystem or PV
355 which has already been shrunk using another tool (eg. L<guestfish(1)>
356 or other online tools). Virt-resize will check this and give an error
357 if it has not been done.
359 The amount by which the overall disk must be shrunk (after carrying
360 out all other operations requested by the user) is called the
361 "deficit". For example, a straight copy (assume no other operations)
362 from a 5GB disk image to a 4GB disk image results in a 1GB deficit.
363 In this case, virt-resize would give an error unless the user
364 specified a partition to shrink and that partition had more than a
365 gigabyte of free space.
367 Note that you cannot use C<--expand> and C<--shrink> together.
373 =item B<--ignore part>
375 Ignore the named partition. Effectively this means the partition is
376 allocated on the destination disk, but the content is not copied
377 across from the source disk. The content of the partition will be
378 blank (all zero bytes).
380 You can give this option multiple times.
386 =item B<--delete part>
388 Delete the named partition. It would be more accurate to describe
389 this as "don't copy it over", since virt-resize doesn't do in-place
390 changes and the original disk image is left intact.
392 Note that when you delete a partition, then anything contained in the
393 partition is also deleted. Furthermore, this causes any partitions
394 that come after to be I<renumbered>, which can easily make your guest
397 You can give this option multiple times.
403 =item B<--LV-expand logvol>
405 This takes the logical volume and, as a final step, expands it to fill
406 all the space available in its volume group. A typical usage,
407 assuming a Linux guest with a single PV C</dev/sda2> and a root device
408 called C</dev/vg_guest/lv_root> would be:
410 virt-resize indisk outdisk \
411 --expand /dev/sda2 --LV-expand /dev/vg_guest/lv_root
413 This would first expand the partition (and PV), and then expand the
414 root device to fill the extra space in the PV.
416 The contents of the LV are also resized if virt-resize knows how to do
417 that. You can stop virt-resize from trying to expand the content by
418 using the option C<--no-expand-content>.
420 Use L<virt-list-filesystems(1)> to list the filesystems in
423 You can give this option multiple times, I<but> it doesn't
424 make sense to do this unless the logical volumes you specify
425 are all in different volume groups.
429 my $copy_boot_loader = 1;
431 =item B<--no-copy-boot-loader>
433 By default, virt-resize copies over some sectors at the start of the
434 disk (up to the beginning of the first partition). Commonly these
435 sectors contain the Master Boot Record (MBR) and the boot loader, and
436 are required in order for the guest to boot correctly.
438 If you specify this flag, then this initial copy is not done. You may
439 need to reinstall the boot loader in this case.
443 my $extra_partition = 1;
444 my $min_extra_partition = 10 * 1024 * 1024; # see below
446 =item B<--no-extra-partition>
448 By default, virt-resize creates an extra partition if there is any
449 extra, unused space after all resizing has happened. Use this option
450 to prevent the extra partition from being created. If you do this
451 then the extra space will be inaccessible until you run fdisk, parted,
452 or some other partitioning tool in the guest.
454 Note that if the surplus space is smaller than 10 MB, no extra
455 partition will be created.
459 my $expand_content = 1;
461 =item B<--no-expand-content>
463 By default, virt-resize will try to expand the direct contents
464 of partitions, if it knows how (see C<--expand> option above).
466 If you give the C<--no-expand-content> option then virt-resize
467 will not attempt this.
473 =item B<-d> | B<--debug>
475 Enable debugging messages.
481 =item B<-n> | B<--dryrun>
483 Print a summary of what would be done, but don't do anything.
489 =item B<-q> | B<--quiet>
491 Don't print the summary.
497 GetOptions ("help|?" => \$help,
498 "version" => \$version,
499 "resize=s" => \@resize,
500 "resize-force=s" => \@resize_force,
501 "expand=s" => \$expand,
502 "shrink=s" => \$shrink,
503 "ignore=s" => \@ignore,
504 "delete=s" => \@delete,
505 "lv-expand=s" => \@lv_expand,
506 "copy-boot-loader!" => \$copy_boot_loader,
507 "extra-partition!" => \$extra_partition,
508 "expand-content!" => \$expand_content,
509 "d|debug" => \$debug,
510 "n|dryrun|dry-run" => \$dryrun,
511 "q|quiet" => \$quiet,
513 pod2usage (1) if $help;
515 my $g = Sys::Guestfs->new ();
516 my %h = $g->version ();
517 print "$h{major}.$h{minor}.$h{release}$h{extra}\n";
521 die "virt-resize [--options] indisk outdisk\n" unless @ARGV == 2;
523 # Check in and out images exist.
524 my $infile = $ARGV[0];
525 my $outfile = $ARGV[1];
526 die __x("virt-resize: {file}: does not exist or is not readable\n", file => $infile)
528 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)
533 my $insize = S_ISREG ($s[2]) ? $s[7] : host_blockdevsize ($infile);
535 my $outsize = S_ISREG ($s[2]) ? $s[7] : host_blockdevsize ($outfile);
538 print "$infile size $insize bytes\n";
539 print "$outfile size $outsize bytes\n";
542 # In reality the number of sectors containing boot loader data will be
543 # less than this (although Windows 7 defaults to putting the first
544 # partition on sector 2048, and has quite a large boot loader).
546 # However make this large enough to be sure that we have copied over
547 # the boot loader. We could also do this by looking for the sector
548 # offset of the first partition.
550 # It doesn't matter if we copy too much.
551 my $boot_sectors = 4096;
553 die __x("virt-resize: {file}: file is too small to be a disk image ({sz} bytes)\n",
554 file => $infile, sz => $insize)
555 if $insize < $boot_sectors * 512;
556 die __x("virt-resize: {file}: file is too small to be a disk image ({sz} bytes)\n",
557 file => $outfile, sz => $outsize)
558 if $outsize < $boot_sectors * 512;
560 # Copy the boot loader across.
561 do_copy_boot_loader () if $copy_boot_loader;
563 sub do_copy_boot_loader
565 print "copying boot loader ...\n" if $debug;
566 open IFILE, $infile or die "$infile: $!";
568 my $r = sysread (IFILE, $s, $boot_sectors * 512) or die "$infile: $!";
569 die "$infile: short read" if $r < $boot_sectors * 512;
570 open OFILE, "+<$outfile" or die "$outfile: $!";
571 sysseek OFILE, 0, SEEK_SET or die "$outfile: seek: $!";
572 $r = syswrite (OFILE, $s, $boot_sectors * 512) or die "$outfile: $!";
573 die "$outfile: short write" if $r < $boot_sectors * 512;
576 # Add them to the handle and launch the appliance.
582 $g = Sys::Guestfs->new ();
583 $g->set_trace (1) if $debug;
584 $g->add_drive_ro ($infile);
585 $g->add_drive ($outfile);
589 my $sectsize = $g->blockdev_getss ("/dev/sdb");
591 my $to_be_expanded = 0;
593 # Get the partitions on the source disk.
596 check_source_disk ();
598 sub check_source_disk
602 # Partitions and PVs.
603 my @p = $g->part_list ("/dev/sda");
605 my $name = "/dev/sda" . $_->{part_num};
606 push @partitions, $name;
610 $h{bootable} = $g->part_get_bootable ("/dev/sda", $h{part_num});
611 eval { $h{mbr_id} = $g->part_get_mbr_id ("/dev/sda", $h{part_num}); };
612 $partitions{$name} = \%h;
616 # Examine each partition.
617 my @pvs_full = $g->pvs_full ();
618 examine_partition ($_) foreach @partitions;
620 sub examine_partition
626 my $type = "unknown";
628 $type = $g->vfs_type ($part);
630 $partitions{$part}->{type} = $type;
632 # Can we get the actual size of this object (ie. to find out if it
633 # is smaller than the container for shrinking)?
635 if ($type eq "LVM2_member") { # LVM PV
636 foreach (@pvs_full) {
637 $fssize = $_->{pv_size}
638 if canonicalize ($_->{pv_name}) eq $part;
640 } else { # Something mountable?
642 $g->mount_ro ($part, "/");
644 my %stat = $g->statvfs ("/");
645 $fssize = $stat{bsize} * $stat{blocks};
653 # This might be undef if we didn't successfully find the size. In
654 # that case user won't be allowed to shrink this partition except
656 $partitions{$part}->{fssize} = $fssize;
658 # Is it partition content that we know how to expand?
659 $partitions{$part}->{can_expand_content} = 0;
660 if ($expand_content) {
661 if ($type eq "LVM2_member") {
662 $partitions{$part}->{can_expand_content} = 1;
663 $partitions{$part}->{expand_content_method} = "pvresize";
664 } elsif ($type =~ /^ext[234]$/) {
665 $partitions{$part}->{can_expand_content} = 1;
666 $partitions{$part}->{expand_content_method} = "resize2fs";
667 } elsif ($type eq "ntfs" && feature_available ($g, "ntfsprogs")) {
668 $partitions{$part}->{can_expand_content} = 1;
669 $partitions{$part}->{expand_content_method} = "ntfsresize";
675 print "partitions found: ", join (", ", @partitions), "\n";
676 foreach my $part (@partitions) {
678 foreach (sort keys %{$partitions{$part}}) {
679 print("\t", $_, " = ",
680 defined ($partitions{$part}->{$_})
681 ? $partitions{$part}->{$_} : "undef",
687 # Examine the LVs (for --lv-expand option).
688 my @lvs = $g->lvs ();
690 examine_lv ($_) foreach @lvs;
691 mark_lvs_to_expand ();
697 $lvs{$_}->{name} = $_;
699 my $type = "unknown";
701 $type = $g->vfs_type ($_);
703 $lvs{$_}->{type} = $type;
705 if ($expand_content) {
706 if ($type =~ /^ext[234]$/) {
707 $lvs{$_}->{can_expand_content} = 1;
708 $lvs{$_}->{expand_content_method} = "resize2fs";
709 } elsif ($type eq "ntfs" && feature_available ($g, "ntfsprogs")) {
710 $lvs{$_}->{can_expand_content} = 1;
711 $lvs{$_}->{expand_content_method} = "ntfsresize";
716 sub mark_lvs_to_expand {
719 foreach (@lv_expand) {
720 die __x("virt-resize: no logical volume called {n}\n",
722 unless exists $lvs{$_};
724 if ($lvs{$_}->{can_expand_content}) {
725 $lvs{$_}->{will_expand_content} = 1;
736 $_ = "/dev/$_" unless $_ =~ m{^/dev};
737 $_ = canonicalize ($_);
739 unless (exists $partitions{$_}) {
740 die __x("{p}: partition not found in the source disk image, when using the '{opt}' command line option\n",
745 if ($partitions{$_}->{ignore}) {
746 die __x("{p}: partition ignored, you cannot use it in another command line argument\n",
749 if ($partitions{$_}->{delete}) {
750 die __x("{p}: partition deleted, you cannot use it in another command line argument\n",
758 do_ignore ($_) foreach @ignore;
763 $_ = find_partition ($_, "--ignore");
764 $partitions{$_}->{ignore} = 1;
768 do_delete ($_) foreach @delete;
773 $_ = find_partition ($_, "--delete");
774 $partitions{$_}->{delete} = 1;
777 # Handle --resize and --resize-force.
778 do_resize ($_, 0, "--resize") foreach @resize;
779 do_resize ($_, 1, "--resize-force") foreach @resize_force;
787 # Argument is "part=size" ...
788 my ($part, $sizefield) = split /=/, $_, 2;
789 $part = find_partition ($part, $option);
791 if (exists $partitions{$part}->{newsize}) {
792 die __x("{p}: this partition has already been marked for resizing\n",
796 # Parse the size field.
797 my $oldsize = $partitions{$part}->{part_size};
799 if (!defined ($sizefield) || $sizefield eq "") {
800 die __x("{p}: missing size field in {o} option\n",
801 p => $part, o => $option);
802 } elsif ($sizefield =~ /^([.\d]+)([bKMGTPE])$/) {
803 $newsize = sizebytes ($1, $2);
804 } elsif ($sizefield =~ /^\+([.\d]+)([bKMGTPE])$/) {
805 my $incr = sizebytes ($1, $2);
806 $newsize = $oldsize + $incr;
807 } elsif ($sizefield =~ /^-([.\d]+)([bKMGTPE])$/) {
808 my $decr = sizebytes ($1, $2);
809 $newsize = $oldsize - $decr;
810 } elsif ($sizefield =~ /^([.\d]+)%$/) {
811 $newsize = $oldsize * $1 / 100;
812 } elsif ($sizefield =~ /^\+([.\d]+)%$/) {
813 $newsize = $oldsize + $oldsize * $1 / 100;
814 } elsif ($sizefield =~ /^-([.\d]+)%$/) {
815 $newsize = $oldsize - $oldsize * $1 / 100;
817 die __x("{p}: {f}: cannot parse size field\n",
818 p => $part, f => $sizefield)
822 die __x("{p}: new size is zero or negative\n", p => $part);
824 mark_partition_for_resize ($part, $oldsize, $newsize, $force, $option);
827 sub mark_partition_for_resize
836 # Do nothing if the size is the same.
837 return if $oldsize == $newsize;
839 my $bigger = $newsize > $oldsize;
841 # Check there is space to shrink this.
842 unless ($bigger || $force) {
843 if (! $partitions{$part}->{fssize} ||
844 $partitions{$part}->{fssize} > $newsize) {
845 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",
850 $partitions{$part}->{newsize} = $newsize;
852 if ($partitions{$part}->{can_expand_content} && $bigger) {
853 $partitions{$part}->{will_expand_content} = 1;
858 # Handle --expand and --shrink.
860 if (defined $expand && defined $shrink) {
861 die __"virt-resize: you cannot use options --expand and --shrink together\n"
863 if (defined $expand || defined $shrink) {
864 calculate_surplus ();
867 print "surplus before --expand or --shrink: $surplus (",
868 human_size ($surplus), ")\n";
871 do_expand () if $expand;
872 do_shrink () if $shrink;
875 # (Re-)calculate surplus after doing expand or shrink.
876 calculate_surplus ();
878 # Add up the total space required on the target so far, compared
879 # to the size of the target. We end up with a surplus or deficit.
880 sub calculate_surplus
884 # We need some overhead for partitioning. Worst case would be for
885 # EFI partitioning + massive per-partition alignment.
886 my $overhead = $sectsize * (
887 2 * 64 + # GPT start and end
888 (64 * (@partitions + 1)) + # Maximum alignment
889 ($boot_sectors - 64) # Boot loader
893 foreach (@partitions) {
894 if ($partitions{$_}->{newsize}) {
895 $required += $partitions{$_}->{newsize}
897 $required += $partitions{$_}->{part_size}
901 # Compare that to the actual target disk.
902 $surplus = $outsize - ($required + $overhead);
909 unless ($surplus > 0) {
910 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",
911 h => human_size (-$surplus));
914 my $part = find_partition ($expand, "--expand");
915 my $oldsize = $partitions{$part}->{part_size};
916 mark_partition_for_resize ($part, $oldsize, $oldsize + $surplus,
924 unless ($surplus < 0) {
925 die __"virt-resize: error: cannot use --shrink because there is no deficit\n(see 'deficit' in the virt-resize(1) man page)\n"
928 my $part = find_partition ($shrink, "--shrink");
929 my $oldsize = $partitions{$part}->{part_size};
930 mark_partition_for_resize ($part, $oldsize, $oldsize + $surplus,
935 print_summary () unless $quiet;
940 print __"Summary of changes:\n";
942 foreach my $part (@partitions) {
943 if ($partitions{$part}->{ignore}) {
944 print __x("{p}: partition will be ignored\n", p => $part);
945 } elsif ($partitions{$part}->{delete}) {
946 print __x("{p}: partition will be deleted\n", p => $part);
947 } elsif ($partitions{$part}->{newsize}) {
948 print __x("{p}: partition will be resized from {oldsize} to {newsize}\n",
950 oldsize => human_size ($partitions{$part}->{part_size}),
951 newsize => human_size ($partitions{$part}->{newsize}));
952 if ($partitions{$part}->{will_expand_content}) {
953 print __x("{p}: content will be expanded using the '{meth}' method\n",
955 meth => $partitions{$part}->{expand_content_method});
958 print __x("{p}: partition will be left alone\n", p => $part);
962 foreach my $lv (@lv_expand) {
963 print __x("{n}: LV will be expanded to maximum size\n",
967 foreach my $lv (@lvs) {
968 if ($lvs{$lv}->{will_expand_content}) {
969 print __x("{n}: content will be expanded using the '{meth}' method\n",
971 meth => $lvs{$lv}->{expand_content_method});
976 print __x("There is a surplus of {spl} bytes ({h}).\n",
978 h => human_size ($surplus));
979 if ($extra_partition) {
980 if ($surplus >= $min_extra_partition) {
981 print __"An extra partition will be created for the surplus.\n";
983 print __"The surplus space is not large enough for an extra partition to be created\nand so it will just be ignored.\n";
986 print __"The surplus space will be ignored. Run a partitioning program in the guest\nto partition this extra space if you want.\n";
988 } elsif ($surplus < 0) {
989 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",
991 h => human_size (-$surplus));
997 # Repartition the target disk.
1006 if ($copy_boot_loader) {
1007 $parttype = $g->part_get_parttype ("/dev/sdb");
1011 print "partition table type: $parttype\n" if $debug;
1013 # Delete any existing partitions on the destination disk,
1014 # but leave the bootloader that we copied over intact.
1015 if ($copy_boot_loader) {
1016 # Delete in reverse as an easy way to deal with extended
1018 foreach (sort { $b cmp $a } $g->list_partitions ()) {
1019 if (m{^/dev/.db(\d+)$}) {
1020 $g->part_del ("/dev/sdb", $1);
1024 # Didn't copy over the initial boot loader, so we need
1025 # to make a new partition table here.
1026 $g->part_init ("/dev/sdb", $parttype);
1029 # Work out where to start the first partition.
1030 die __"virt-resize: source disk does not have a first partition\n"
1031 unless exists ($partitions{"/dev/sda1"});
1032 my $start = $partitions{"/dev/sda1"}->{part_start} / $sectsize;
1035 $start = ($start + 63) & ~63;
1037 print "starting to partition from $start\n" if $debug;
1039 # Create the new partitions.
1040 foreach my $part (@partitions) {
1041 unless ($partitions{$part}->{delete}) {
1044 if ($partitions{$part}->{newsize}) {
1045 $size = ($partitions{$part}->{newsize} + $sectsize - 1)
1048 $size = ($partitions{$part}->{part_size} + $sectsize - 1)
1053 my ($target, $end, $part_num) = add_partition ($start, $size);
1054 $partitions{$part}->{target} = $target;
1056 if ($partitions{$part}->{bootable}) {
1057 $g->part_set_bootable ("/dev/sdb", $part_num, 1);
1060 if ($partitions{$part}->{mbr_id}) {
1061 $g->part_set_mbr_id ("/dev/sdb", $part_num,
1062 $partitions{$part}->{mbr_id});
1065 # Start of next partition + alignment.
1067 $start = ($start + 63) & ~63;
1071 # Create surplus partition.
1072 if ($extra_partition && $surplus >= $min_extra_partition) {
1073 add_partition ($start, $outsize / $sectsize - 64 - $start);
1084 my ($target, $end, $part_num);
1086 if ($nextpart <= 3 || $parttype ne "msdos") {
1087 $target = "/dev/sdb$nextpart";
1088 $end = $start + $size - 1;
1089 $g->part_add ("/dev/sdb", "primary", $start, $end);
1090 $part_num = $nextpart++;
1092 if ($nextpart == 4) {
1093 $g->part_add ("/dev/sdb", "extended", $start, -1);
1094 $part_num = $nextpart++;
1097 $target = "/dev/sdb$nextpart";
1098 $end = $start + $size - 1;
1099 $g->part_add ("/dev/sdb", "logical", $start, $end);
1100 $part_num = $nextpart++;
1103 return ($target, $end, $part_num);
1106 # Copy over the data.
1111 foreach my $part (@partitions)
1113 unless ($partitions{$part}->{ignore}) {
1114 my $target = $partitions{$part}->{target};
1116 my $oldsize = $partitions{$part}->{part_size};
1118 if ($partitions{$part}->{newsize}) {
1119 $newsize = $partitions{$part}->{newsize};
1121 $newsize = $partitions{$part}->{part_size};
1124 if (!$quiet && !$debug) {
1126 print __x("Copying {p} ...", p => $part);
1129 $g->copy_size ($part, $target,
1130 $newsize < $oldsize ? $newsize : $oldsize);
1132 if (!$quiet && !$debug) {
1133 print " ", __"done", "\n";
1140 # After copying the data over we must shut down and restart the
1141 # appliance in order to expand the content. The reason for this may
1142 # not be obvious, but it's because otherwise we'll have duplicate VGs
1143 # (the old VG(s) and the new VG(s)) which breaks LVM.
1145 # The restart is only required if we're going to expand something.
1147 if ($to_be_expanded > 0) {
1148 restart_appliance ();
1149 expand_partitions ();
1151 expand_lvs_content ();
1154 sub restart_appliance
1156 # Sync disk and exit.
1161 $g = Sys::Guestfs->new ();
1162 $g->set_trace (1) if $debug;
1163 $g->add_drive ($outfile);
1166 # Target partitions have changed from /dev/sdb to /dev/sda,
1168 foreach my $part (@partitions)
1170 my $target = $partitions{$part}->{target};
1172 if ($target =~ m{/dev/(.)db(.*)}) {
1173 $partitions{$part}->{target} = "/dev/$1da$2";
1175 die "internal error: unexpected partition target: $target";
1181 sub expand_partitions
1183 foreach my $part (@partitions)
1185 unless ($partitions{$part}->{ignore}) {
1186 my $target = $partitions{$part}->{target};
1188 # Expand if requested.
1189 if ($partitions{$part}->{will_expand_content}) {
1190 if (!$quiet && !$debug) {
1191 print __x("Expanding {p} using the '{meth}' method\n",
1193 meth => $partitions{$part}->{expand_content_method});
1195 expand_target_partition ($part)
1202 sub expand_target_partition
1209 die unless $partitions{$part}->{can_expand_content};
1210 die unless $partitions{$part}->{will_expand_content};
1211 die unless $partitions{$part}->{expand_content_method};
1212 die unless $partitions{$part}->{target};
1213 die unless $expand_content;
1215 my $target = $partitions{$part}->{target};
1216 my $method = $partitions{$part}->{expand_content_method};
1217 if ($method eq "pvresize") {
1218 $g->pvresize ($target);
1220 elsif ($method eq "resize2fs") {
1221 $g->e2fsck_f ($target);
1222 $g->resize2fs ($target);
1224 elsif ($method eq "ntfsresize") {
1225 $g->ntfsresize ($target);
1228 die "internal error: unknown method: $method";
1236 foreach (@lv_expand) {
1237 $g->lvresize_free ($_, 100);
1241 sub expand_lvs_content
1246 if ($lvs{$_}->{will_expand_content}) {
1247 my $method = $lvs{$_}->{expand_content_method};
1248 if (!$quiet && !$debug) {
1249 print __x("Expanding {p} using the '{meth}' method\n",
1250 p => $_, meth => $method);
1252 if ($method eq "resize2fs") {
1255 } elsif ($method eq "ntfsresize") {
1256 $g->ntfsresize ($_);
1258 die "internal error: unknown method: $method";
1264 # Sync disk and exit.
1276 $_ *= 1024 if $unit =~ /[KMGTPE]/;
1277 $_ *= 1024 if $unit =~ /[MGTPE]/;
1278 $_ *= 1024 if $unit =~ /[GTPE]/;
1279 $_ *= 1024 if $unit =~ /[TPE]/;
1280 $_ *= 1024 if $unit =~ /[PE]/;
1281 $_ *= 1024 if $unit =~ /[E]/;
1286 # Convert a number of bytes to a human-readable number.
1300 sprintf "%s%dK", $sgn, $_;
1301 } elsif ($_ < 1024 * 1024) {
1302 sprintf "%s%.1fM", $sgn, ($_ / 1024);
1304 sprintf "%s%.1fG", $sgn, ($_ / 1024 / 1024);
1308 # Return the size in bytes of a HOST block device.
1309 sub host_blockdevsize
1314 open BD, "PATH=/usr/sbin:/sbin:\$PATH blockdev --getsize64 $dev |"
1315 or die "blockdev: $!";
1321 # The reverse of device name translation, see
1322 # BLOCK DEVICE NAMING in guestfs(3).
1327 if (m{^/dev/[hv]d([a-z]\d)$}) {
1335 =head2 "Partition 1 does not end on cylinder boundary."
1337 Virt-resize aligns partitions to multiples of 64 sectors. Usually
1338 this means the partitions will not be aligned to the ancient CHS
1339 geometry. However CHS geometry is meaningless for disks manufactured
1340 since the early 1990s, and doubly so for virtual hard drives.
1341 Alignment of partitions to cylinders is not required by any modern
1344 =head2 RESIZING WINDOWS VIRTUAL MACHINES
1346 In Windows Vista and later versions, Microsoft switched to using a
1347 separate boot partition. In these VMs, typically C</dev/sda1> is the
1348 boot partition and C</dev/sda2> is the main (C:) drive. We have not
1349 had any luck resizing the boot partition. Doing so seems to break the
1350 guest completely. However expanding the second partition (ie. C:
1353 Windows may initiate a lengthy "chkdsk" on first boot after a resize,
1354 if NTFS partitions have been expanded. This is just a safety check
1355 and (unless it find errors) is nothing to worry about.
1357 =head1 ALTERNATIVE TOOLS
1359 There are several proprietary tools for resizing partitions. We
1360 won't mention any here.
1362 L<parted(8)> and its graphical shell gparted can do some types of
1363 resizing operations on disk images. They can resize and move
1364 partitions, but I don't think they can do anything with the contents,
1365 and they certainly don't understand LVM.
1367 L<guestfish(1)> can do everything that virt-resize can do and a lot
1368 more, but at a much lower level. You will probably end up
1369 hand-calculating sector offsets, which is something that virt-resize
1370 was designed to avoid. If you want to see the guestfish-equivalent
1371 commands that virt-resize runs, use the C<--debug> flag.
1375 L<virt-list-partitions(1)>,
1376 L<virt-list-filesystems(1)>,
1388 L<http://libguestfs.org/>.
1392 Richard W.M. Jones L<http://people.redhat.com/~rjones/>
1396 Copyright (C) 2010 Red Hat Inc.
1398 This program is free software; you can redistribute it and/or modify
1399 it under the terms of the GNU General Public License as published by
1400 the Free Software Foundation; either version 2 of the License, or
1401 (at your option) any later version.
1403 This program is distributed in the hope that it will be useful,
1404 but WITHOUT ANY WARRANTY; without even the implied warranty of
1405 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1406 GNU General Public License for more details.
1408 You should have received a copy of the GNU General Public License
1409 along with this program; if not, write to the Free Software
1410 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.