1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873
|
=head1 NAME
virt-resize - Resize a virtual machine disk
=head1 SYNOPSIS
virt-resize [--resize /dev/sdaN=[+/-]<size>[%]]
[--expand /dev/sdaN] [--shrink /dev/sdaN]
[--ignore /dev/sdaN] [--delete /dev/sdaN] [...] indisk outdisk
=head1 DESCRIPTION
Virt-resize is a tool which can resize a virtual machine disk, making
it larger or smaller overall, and resizing or deleting any partitions
contained within.
Virt-resize B<cannot> resize disk images in-place. Virt-resize
B<should not> be used on live virtual machines - for consistent
results, shut the virtual machine down before resizing it.
If you are not familiar with the associated tools:
L<virt-filesystems(1)> and L<virt-df(1)>, we recommend you go and read
those manual pages first.
=head1 EXAMPLES
=over 4
=item 1.
This example takes C<olddisk> and resizes it into C<newdisk>,
extending one of the guest’s partitions to fill the extra 5GB of
space:
virt-filesystems --long -h --all -a olddisk
truncate -r olddisk newdisk
truncate -s +5G newdisk
# Note "/dev/sda2" is a partition inside the "olddisk" file.
virt-resize --expand /dev/sda2 olddisk newdisk
=item 2.
As above, but make the /boot partition 200MB bigger, while giving the
remaining space to /dev/sda2:
virt-resize --resize /dev/sda1=+200M --expand /dev/sda2 \
olddisk newdisk
=item 3.
As in the first example, but expand a logical volume as the final
step. This is what you would typically use for Linux guests that use
LVM:
virt-resize --expand /dev/sda2 --LV-expand /dev/vg_guest/lv_root \
olddisk newdisk
=item 4.
As in the first example, but the output format will be qcow2 instead
of a raw disk:
qemu-img create -f qcow2 -o preallocation=metadata newdisk.qcow2 15G
virt-resize --expand /dev/sda2 olddisk newdisk.qcow2
=back
=head1 DETAILED USAGE
=head2 EXPANDING A VIRTUAL MACHINE DISK
=over 4
=item 1. Shut down the virtual machine
=item 2. Locate input disk image
Locate the input disk image (ie. the file or device on the host
containing the guest’s disk). If the guest is managed by libvirt, you
can use C<virsh dumpxml> like this to find the disk image name:
# virsh dumpxml guestname | xpath /domain/devices/disk/source
Found 1 nodes:
-- NODE --
<source dev="/dev/vg/lv_guest" />
=item 3. Look at current sizing
Use L<virt-filesystems(1)> to display the current partitions and
sizes:
# virt-filesystems --long --parts --blkdevs -h -a /dev/vg/lv_guest
Name Type Size Parent
/dev/sda1 partition 101M /dev/sda
/dev/sda2 partition 7.9G /dev/sda
/dev/sda device 8.0G -
(This example is a virtual machine with an 8 GB disk which we would
like to expand up to 10 GB).
=item 4. Create output disk
Virt-resize cannot do in-place disk modifications. You have to have
space to store the resized output disk.
To store the resized disk image in a file, create a file of a suitable
size:
# rm -f outdisk
# truncate -s 10G outdisk
Or use L<lvcreate(1)> to create a logical volume:
# lvcreate -L 10G -n lv_name vg_name
Or use L<virsh(1)> vol-create-as to create a libvirt storage volume:
# virsh pool-list
# virsh vol-create-as poolname newvol 10G
=item 5. Resize
virt-resize takes two mandatory parameters, the input disk and the
output disk (both can be e.g. a device, a file, or a URI to a remote
disk). The output disk is the one created in the previous step.
# virt-resize indisk outdisk
This command just copies disk image C<indisk> to disk image C<outdisk>
I<without> resizing or changing any existing partitions. If
C<outdisk> is larger, then an extra, empty partition is created at the
end of the disk covering the extra space. If C<outdisk> is smaller,
then it will give an error.
More realistically you'd want to expand existing partitions in the
disk image by passing extra options (for the full list see the
L</OPTIONS> section below).
L</--expand> is the most useful option. It expands the named
partition within the disk to fill any extra space:
# virt-resize --expand /dev/sda2 indisk outdisk
(In this case, an extra partition is I<not> created at the end of the
disk, because there will be no unused space).
L</--resize> is the other commonly used option. The following would
increase the size of /dev/sda1 by 200M, and expand /dev/sda2
to fill the rest of the available space:
# virt-resize --resize /dev/sda1=+200M --expand /dev/sda2 \
indisk outdisk
If the expanded partition in the image contains a filesystem or LVM
PV, then if virt-resize knows how, it will resize the contents, the
equivalent of calling a command such as L<pvresize(8)>,
L<resize2fs(8)>, L<ntfsresize(8)>, L<btrfs(8)>, L<xfs_growfs(8)>,
or L<resize.f2fs(8)>.
However virt-resize does not know how to resize some filesystems, so
you would have to online resize them after booting the guest.
# virt-resize --expand /dev/sda2 nbd://example.com outdisk
The input disk can be a URI, in order to use a remote disk as the
source. The URI format is compatible with guestfish. See
L<guestfish(1)/ADDING REMOTE STORAGE>.
Other options are covered below.
=item 6. Test
Thoroughly test the new disk image I<before> discarding the old one.
If you are using libvirt, edit the XML to point at the new disk:
# virsh edit guestname
Change E<lt>source ...E<gt>, see
L<http://libvirt.org/formatdomain.html#elementsDisks>
Then start up the domain with the new, resized disk:
# virsh start guestname
and check that it still works. See also the L</NOTES> section below
for additional information.
=item 7. Resize LVs etc inside the guest
(This can also be done offline using L<guestfish(1)>)
Once the guest has booted you should see the new space available, at
least for filesystems that virt-resize knows how to resize, and for
PVs. The user may need to resize LVs inside PVs, and also resize
filesystem types that virt-resize does not know how to expand.
=back
=head2 SHRINKING A VIRTUAL MACHINE DISK
Shrinking is somewhat more complex than expanding, and only an
overview is given here.
Firstly virt-resize will not attempt to shrink any partition content
(PVs, filesystems). The user has to shrink content before passing the
disk image to virt-resize, and virt-resize will check that the content
has been shrunk properly.
(Shrinking can also be done offline using L<guestfish(1)>)
After shrinking PVs and filesystems, shut down the guest, and proceed
with steps 3 and 4 above to allocate a new disk image.
Then run virt-resize with any of the I<--shrink> and/or I<--resize>
options.
=head2 IGNORING OR DELETING PARTITIONS
virt-resize also gives a convenient way to ignore or delete partitions
when copying from the input disk to the output disk. Ignoring a
partition speeds up the copy where you don't care about the existing
contents of a partition. Deleting a partition removes it completely,
but note that it also renumbers any partitions after the one which is
deleted, which can leave some guests unbootable.
=head2 QCOW2 AND NON-SPARSE RAW FORMATS
If the input disk is in qcow2 format, then you may prefer that the
output is in qcow2 format as well. Alternately, virt-resize can
convert the format on the fly. The output format is simply determined
by the format of the empty output container that you provide. Thus to
create qcow2 output, use:
qemu-img create -f qcow2 -o preallocation=metadata outdisk [size]
instead of the truncate command.
Similarly, to get non-sparse raw output use:
fallocate -l size outdisk
(on older systems that don’t have the L<fallocate(1)> command use
C<dd if=/dev/zero of=outdisk bs=1M count=..>)
=head2 LOGICAL PARTITIONS
Logical partitions (a.k.a. F</dev/sda5+> on disks using DOS partition
tables) cannot be resized.
To understand what is going on, firstly one of the four partitions
F</dev/sda1-4> will have MBR partition type C<05> or C<0f>. This is
called the B<extended partition>. Use L<virt-filesystems(1)> to see
the MBR partition type.
Logical partitions live inside the extended partition.
The extended partition can be expanded, but not shrunk (unless you
force it, which is not advisable). When the extended partition is
copied across, all the logical partitions contained inside are copied
over implicitly. Virt-resize does not look inside the extended
partition, so it copies the logical partitions blindly.
You cannot specify a logical partition (F</dev/sda5+>) at all on the
command line. Doing so will give an error.
=head1 OPTIONS
=over 4
=item B<--help>
Display help.
=item B<--align-first> B<auto>
=item B<--align-first> B<never>
=item B<--align-first> B<always>
Align the first partition for improved performance (see also the
I<--alignment> option).
The default is I<--align-first auto> which only aligns the first
partition if it is safe to do so. That is, only when we know how to
fix the bootloader automatically, and at the moment that can only be
done for Windows guests.
I<--align-first never> means we never move the first partition.
This is the safest option. Try this if the guest does not boot
after resizing.
I<--align-first always> means we always align the first partition (if
it needs to be aligned). For some guests this will break the
bootloader, making the guest unbootable.
=item B<--alignment> N
Set the alignment of partitions to C<N> sectors. The default in
virt-resize E<lt> 1.13.19 was 64 sectors, and after that is 128
sectors.
Assuming 512 byte sector size inside the guest, here are some
suitable values for this:
=over 4
=item I<--alignment 1> (512 bytes)
The partitions would be packed together as closely as possible, but
would be completely unaligned. In some cases this can cause very poor
performance. See L<virt-alignment-scan(1)> for further details.
=item I<--alignment 8> (4K)
This would be the minimum acceptable alignment for reasonable
performance on modern hosts.
=item I<--alignment 128> (64K)
This alignment provides good performance when the host is using high
end network storage.
=item I<--alignment 2048> (1M)
This is the standard alignment used by all newly installed guests
since around 2008.
=back
=item B<--colors>
=item B<--colours>
Use ANSI colour sequences to colourize messages. This is the default
when the output is a tty. If the output of the program is redirected
to a file, ANSI colour sequences are disabled unless you use this
option.
=item B<-d>
=item B<--debug>
(Deprecated: use I<-v> option instead)
Enable debugging messages.
=item B<--delete> PART
Delete the named partition. It would be more accurate to describe
this as "don't copy it over", since virt-resize doesn't do in-place
changes and the original disk image is left intact.
Note that when you delete a partition, then anything contained in the
partition is also deleted. Furthermore, this causes any partitions
that come after to be I<renumbered>, which can easily make your guest
unbootable.
You can give this option multiple times.
=item B<--expand> PART
Expand the named partition so it uses up all extra space (space left
over after any other resize changes that you request have been done).
If virt-resize knows how, it will expand the direct content of the
partition. For example, if the partition is an LVM PV, it will expand
the PV to fit (like calling L<pvresize(8)>). Virt-resize leaves any
other content it doesn't know about alone.
Currently virt-resize can resize:
=over 4
=item *
ext2, ext3 and ext4 filesystems.
=item *
NTFS filesystems, if libguestfs was compiled with support for NTFS.
The filesystem must have been shut down consistently last time it was
used. Additionally, L<ntfsresize(8)> marks the resized filesystem as
requiring a consistency check, so at the first boot after resizing
Windows will check the disk.
=item *
LVM PVs (physical volumes). virt-resize does not usually resize
anything inside the PV, but see the I<--LV-expand> option. The user
could also resize LVs as desired after boot.
=item *
Btrfs filesystems, if libguestfs was compiled with support for btrfs.
=item *
XFS filesystems, if libguestfs was compiled with support for XFS.
=item *
Linux swap partitions.
Please note that libguestfs I<destroys> the existing swap content
by recreating it with C<mkswap>, so this should not be used when
the guest is suspended.
=item *
f2fs filesystems, if libguestfs was compiled with support for f2fs.
=back
Note that you cannot use I<--expand> and I<--shrink> together.
=item B<--format> B<raw>
Specify the format of the input disk image. If this flag is not
given then it is auto-detected from the image itself.
If working with untrusted raw-format guest disk images, you should
ensure the format is always specified.
Note that this option I<does not> affect the output format.
See L</QCOW2 AND NON-SPARSE RAW FORMATS>.
=item B<--ignore> PART
Ignore the named partition. Effectively this means the partition is
allocated on the destination disk, but the content is not copied
across from the source disk. The content of the partition will be
blank (all zero bytes).
You can give this option multiple times.
=item B<--LV-expand> LOGVOL
This takes the logical volume and, as a final step, expands it to fill
all the space available in its volume group. A typical usage,
assuming a Linux guest with a single PV F</dev/sda2> and a root device
called F</dev/vg_guest/lv_root> would be:
virt-resize indisk outdisk \
--expand /dev/sda2 --LV-expand /dev/vg_guest/lv_root
This would first expand the partition (and PV), and then expand the
root device to fill the extra space in the PV.
The contents of the LV are also resized if virt-resize knows how to do
that. You can stop virt-resize from trying to expand the content by
using the option I<--no-expand-content>.
Use L<virt-filesystems(1)> to list the filesystems in the guest.
You can give this option multiple times, I<but> it doesn't
make sense to do this unless the logical volumes you specify
are all in different volume groups.
=item B<--machine-readable>
=item B<--machine-readable>=format
This option is used to make the output more machine friendly
when being parsed by other programs. See
L</MACHINE READABLE OUTPUT> below.
=item B<-n>
=item B<--dry-run>
Print a summary of what would be done, but don’t do anything.
=item B<--no-copy-boot-loader>
By default, virt-resize copies over some sectors at the start of the
disk (up to the beginning of the first partition). Commonly these
sectors contain the Master Boot Record (MBR) and the boot loader, and
are required in order for the guest to boot correctly.
If you specify this flag, then this initial copy is not done. You may
need to reinstall the boot loader in this case.
=item B<--no-extra-partition>
By default, virt-resize creates an extra partition if there is any
extra, unused space after all resizing has happened. Use this option
to prevent the extra partition from being created. If you do this
then the extra space will be inaccessible until you run fdisk, parted,
or some other partitioning tool in the guest.
Note that if the surplus space is smaller than 10 MB, no extra
partition will be created.
=item B<--no-expand-content>
By default, virt-resize will try to expand the direct contents
of partitions, if it knows how (see I<--expand> option above).
If you give the I<--no-expand-content> option then virt-resize
will not attempt this.
=item B<--no-sparse>
Turn off sparse copying. See L</SPARSE COPYING> below.
=item B<--ntfsresize-force>
Pass the I<--force> option to L<ntfsresize(8)>, allowing resizing
even if the NTFS disk is marked as needing a consistency check.
You have to use this option if you want to resize a Windows
guest multiple times without booting into Windows between each
resize.
=item B<--output-format> B<raw>
Specify the format of the output disk image. If this flag is not
given then it is auto-detected from the image itself.
If working with untrusted raw-format guest disk images, you should
ensure the format is always specified.
Note that this option I<does not create> the output format. This
option just tells libguestfs what it is so it doesn't try to guess it.
You still need to create the output disk with the right format. See
L</QCOW2 AND NON-SPARSE RAW FORMATS>.
=item B<-q>
=item B<--quiet>
Don’t print the summary.
=item B<--resize> PART=SIZE
Resize the named partition (expanding or shrinking it) so that it has
the given size.
C<SIZE> can be expressed as an absolute number followed by
b/K/M/G to mean bytes, Kilobytes, Megabytes, or Gigabytes;
or as a percentage of the current size;
or as a relative number or percentage.
For example:
--resize /dev/sda2=10G
--resize /dev/sda4=90%
--resize /dev/sda2=+1G
--resize /dev/sda2=-200M
--resize /dev/sda1=+128K
--resize /dev/sda1=+10%
--resize /dev/sda1=-10%
You can increase the size of any partition. Virt-resize will expand
the direct content of the partition if it knows how (see I<--expand>
above).
You can only I<decrease> the size of partitions that contain
filesystems or PVs which have already been shrunk. Virt-resize will
check this has been done before proceeding, or else will print an
error (see also I<--resize-force>).
You can give this option multiple times.
=item B<--resize-force> PART=SIZE
This is the same as I<--resize> except that it will let you decrease
the size of any partition. Generally this means you will lose any
data which was at the end of the partition you shrink, but you may not
care about that (eg. if shrinking an unused partition, or if you can
easily recreate it such as a swap partition).
See also the I<--ignore> option.
=item B<--shrink> PART
Shrink the named partition until the overall disk image fits in the
destination. The named partition B<must> contain a filesystem or PV
which has already been shrunk using another tool (eg. L<guestfish(1)>
or other online tools). Virt-resize will check this and give an error
if it has not been done.
The amount by which the overall disk must be shrunk (after carrying
out all other operations requested by the user) is called the
"deficit". For example, a straight copy (assume no other operations)
from a 5GB disk image to a 4GB disk image results in a 1GB deficit.
In this case, virt-resize would give an error unless the user
specified a partition to shrink and that partition had more than a
gigabyte of free space.
Note that you cannot use I<--expand> and I<--shrink> together.
=item B<--unknown-filesystems> B<ignore>
=item B<--unknown-filesystems> B<warn>
=item B<--unknown-filesystems> B<error>
Configure the behaviour of virt-resize when asking to expand a
filesystem, and neither libguestfs has the support it, nor virt-resize
knows how to expand the content of the filesystem.
I<--unknown-filesystems ignore> will cause virt-resize to silently
ignore such filesystems, and nothing is printed about them.
I<--unknown-filesystems warn> (the default behaviour) will cause
virt-resize to warn for each of the filesystem that cannot be
expanded, but still continuing to resize the disk.
I<--unknown-filesystems error> will cause virt-resize to error out
at the first filesystem that cannot be expanded.
See also L</"unknown/unavailable method for expanding the TYPE filesystem on DEVICE/LV">.
=item B<-v>
=item B<--verbose>
Enable debugging messages.
=item B<-V>
=item B<--version>
Display version number and exit.
=item B<-x>
Enable tracing of libguestfs API calls.
=back
=head1 MACHINE READABLE OUTPUT
The I<--machine-readable> option can be used to make the output more
machine friendly, which is useful when calling virt-resize from other
programs, GUIs etc.
There are two ways to use this option.
Firstly use the option on its own to query the capabilities of the
virt-resize binary. Typical output looks like this:
$ virt-resize --machine-readable
virt-resize
ntfsresize-force
32bitok
ntfs
btrfs
A list of features is printed, one per line, and the program exits
with status 0.
Secondly use the option in conjunction with other options to make the
regular program output more machine friendly.
At the moment this means:
=over 4
=item 1.
Progress bar messages can be parsed from stdout by looking for this
regular expression:
^[0-9]+/[0-9]+$
=item 2.
The calling program should treat messages sent to stdout (except for
progress bar messages) as status messages. They can be logged and/or
displayed to the user.
=item 3.
The calling program should treat messages sent to stderr as error
messages. In addition, virt-resize exits with a non-zero status code
if there was a fatal error.
=back
Versions of the program prior to 1.13.9 did not support the
I<--machine-readable> option and will return an error.
It is possible to specify a format string for controlling the output;
see L<guestfs(3)/ADVANCED MACHINE READABLE OUTPUT>.
=head1 NOTES
=head2 "Partition 1 does not end on cylinder boundary."
Virt-resize aligns partitions to multiples of 128 sectors (see the
I<--alignment> parameter). Usually this means the partitions will not
be aligned to the ancient CHS geometry. However CHS geometry is
meaningless for disks manufactured since the early 1990s, and doubly
so for virtual hard drives. Alignment of partitions to cylinders is
not required by any modern operating system.
=head2 GUEST BOOT STUCK AT "GRUB"
If a Linux guest does not boot after resizing, and the boot is stuck
after printing C<GRUB> on the console, try reinstalling grub.
guestfish -i -a newdisk
><fs> cat /boot/grub/device.map
# check the contents of this file are sensible or
# edit the file if necessary
><fs> grub-install / /dev/vda
><fs> exit
For more flexible guest reconfiguration, including if you need to
specify other parameters to grub-install, use L<virt-rescue(1)>.
=head2 RESIZING WINDOWS BOOT PARTITIONS
In Windows Vista and later versions, Microsoft switched to using a
separate boot partition. In these VMs, typically F</dev/sda1> is the
boot partition and F</dev/sda2> is the main (C:) drive. Resizing the
first (boot) partition causes the bootloader to fail with
C<0xC0000225> error. Resizing the second partition (ie. C: drive)
should work.
=head2 WINDOWS CHKDSK
Windows disks which use NTFS must be consistent before virt-resize can
be used. If the ntfsresize operation fails, try booting the original
VM and running C<chkdsk /f> on all NTFS partitions, then shut down the
VM cleanly. For further information see:
L<https://bugzilla.redhat.com/show_bug.cgi?id=975753>
I<After resize> Windows may initiate a lengthy "chkdsk" on first boot
if NTFS partitions have been expanded. This is just a safety check
and (unless it find errors) is nothing to worry about.
=head2 WINDOWS UNMOUNTABLE_BOOT_VOLUME BSOD
After sysprepping a Windows guest and then resizing it with
virt-resize, you may see the guest fail to boot with an
C<UNMOUNTABLE_BOOT_VOLUME> BSOD. This error is caused by having
C<ExtendOemPartition=1> in the sysprep.inf file. Removing this line
before sysprepping should fix the problem.
=head2 WINDOWS 8
Windows 8 "fast startup" can prevent virt-resize from resizing NTFS
partitions. See
L<guestfs(3)/WINDOWS HIBERNATION AND WINDOWS 8 FAST STARTUP>.
=head2 SPARSE COPYING
You should create a fresh, zeroed target disk image for virt-resize to
use.
Virt-resize by default performs sparse copying. This means that it
does not copy blocks from the source disk which are all zeroes. This
improves speed and efficiency, but will produce incorrect results if
the target disk image contains unzeroed data.
The main time this can be a problem is if the target is a host
partition (eg. S<C<virt-resize source.img /dev/sda4>>) because the
usual partitioning tools tend to leave whatever data happened to be on
the disk before.
If you have to reuse a target which contains data already, you should
use the I<--no-sparse> option. Note this can be much slower.
=head2 "unknown/unavailable method for expanding the TYPE filesystem on DEVICE/LV"
Virt-resize was asked to expand a partition or a logical volume
containing a filesystem with the type C<TYPE>, but there is no
available nor known expanding method for that filesystem.
This may be due to either of the following:
=over 4
=item 1.
There corresponding filesystem is not available in libguestfs,
because there is no proper package in the host with utilities for it.
This is usually the case for C<btrfs>, C<ntfs>, C<xfs>, and C<f2fs>
filesystems.
Check the results of:
virt-resize --machine-readable
guestfish -a /dev/null run : available
guestfish -a /dev/null run : filesystem_available TYPE
In this case, it is enough to install the proper packages
adding support for them. For example, C<libguestfs-xfs> on
Red Hat Enterprise Linux, CentOS, Debian, Ubuntu, and distributions
derived from them, for supporting the C<xfs> filesystem.
=item 2.
Virt-resize has no support for expanding that type of filesystem.
In this case, there’s nothing that can be done to let virt-resize
expand that type of filesystem.
=back
In both cases, virt-resize will not expand the mentioned filesystem;
the result (unless I<--unknown-filesystems error> is specified)
is that the partitions containing such filesystems will be actually
bigger as requested, but the filesystems will still be usable at
their older sizes.
=head1 ALTERNATIVE TOOLS
There are several proprietary tools for resizing partitions. We
won't mention any here.
L<parted(8)> and its graphical shell gparted can do some types of
resizing operations on disk images. They can resize and move
partitions, but I don't think they can do anything with the contents,
and they certainly don't understand LVM.
L<guestfish(1)> can do everything that virt-resize can do and a lot
more, but at a much lower level. You will probably end up
hand-calculating sector offsets, which is something that virt-resize
was designed to avoid. If you want to see the guestfish-equivalent
commands that virt-resize runs, use the I<--debug> flag.
L<dracut(8)> includes a module called C<dracut-modules-growroot> which
can be used to grow the root partition when the guest first boots up.
There is documentation for this module in an associated README file.
=head1 EXIT STATUS
This program returns 0 if successful, or non-zero if there was an
error.
=head1 SEE ALSO
L<virt-filesystems(1)>,
L<virt-df(1)>,
L<guestfs(3)>,
L<guestfish(1)>,
L<lvm(8)>,
L<pvresize(8)>,
L<lvresize(8)>,
L<resize2fs(8)>,
L<ntfsresize(8)>,
L<btrfs(8)>,
L<xfs_growfs(8)>,
L<resize.f2fs(8)>,
L<virsh(1)>,
L<parted(8)>,
L<truncate(1)>,
L<fallocate(1)>,
L<grub(8)>,
L<grub-install(8)>,
L<virt-rescue(1)>,
L<virt-sparsify(1)>,
L<virt-alignment-scan(1)>,
L<http://libguestfs.org/>.
=head1 AUTHOR
Richard W.M. Jones L<http://people.redhat.com/~rjones/>
=head1 COPYRIGHT
Copyright (C) 2010-2012 Red Hat Inc.
|