Show Password


CentOS 7.0 - man page for virt-resize (centos section 1)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

virt-resize(1)			      Virtualization Support			   virt-resize(1)

       virt-resize - Resize a virtual machine disk

	virt-resize [--resize /dev/sdaN=[+/-]<size>[%]]
	  [--expand /dev/sdaN] [--shrink /dev/sdaN]
	  [--ignore /dev/sdaN] [--delete /dev/sdaN] [...] indisk outdisk

       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 cannot resize disk images in-place.	Virt-resize should not be used on live
       virtual machines - for consistent results, shut the virtual machine down before resizing

       If you are not familiar with the associated tools: virt-filesystems(1) and virt-df(1), we
       recommend you go and read those manual pages first.

       1.  Copy "olddisk" to "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

       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

       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

       4.  As in the first example, but the output format will be qcow2 instead of a raw disk:

	    qemu-img create -f qcow2 newdisk.qcow2 15G
	    virt-resize --expand /dev/sda2 olddisk newdisk.qcow2

       1. Shut down the virtual machine
       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 "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" />

       3. Look at current sizing
	   Use 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).

       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 lvcreate(1) to create a logical volume:

	    # lvcreate -L 10G -n lv_name vg_name

	   Or use virsh(1) vol-create-as to create a libvirt storage volume:

	    # virsh pool-list
	    # virsh vol-create-as poolname newvol 10G

       5. Resize
	   virt-resize takes two mandatory parameters, the input disk (eg. device or file) and
	   the output disk.  The output disk is the one created in the previous step.

	    # virt-resize indisk outdisk

	   This command just copies disk image "indisk" to disk image "outdisk" without resizing
	   or changing any existing partitions.  If "outdisk" is larger, then an extra, empty
	   partition is created at the end of the disk covering the extra space.  If "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 "OPTIONS" section below).

	   "--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 not created at the end of the disk, because there
	   will be no unused space).

	   "--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 pvresize(8), resize2fs(8), ntfsresize(8) or btrfs(8).  However virt-resize
	   does not know how to resize some filesystems, so you would have to online resize them
	   after booting the guest.

	   Other options are covered below.

       6. Test
	   Thoroughly test the new disk image before discarding the old one.

	   If you are using libvirt, edit the XML to point at the new disk:

	    # virsh edit guestname

	   Change <source ...>, see 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 "NOTES" section below for additional

       7. Resize LVs etc inside the guest
	   (This can also be done offline using 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.

       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 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 --shrink and/or --resize options.

       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.

       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 [-c] -f qcow2 outdisk [size]

       instead of the truncate command (use -c for a compressed disk).

       Similarly, to get non-sparse raw output use:

	fallocate -l size outdisk

       (on older systems that don't have the fallocate(1) command use "dd if=/dev/zero of=outdisk
       bs=1M count=..")

       Logical partitions (a.k.a. "/dev/sda5+" on disks using DOS partition tables) cannot be

       To understand what is going on, firstly one of the four partitions "/dev/sda1-4" will have
       MBR partition type 05 or "0f".  This is called the extended partition.  Use
       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 ("/dev/sda5+") at all on the command line.  Doing
       so will give an error.

	   Display help.

       --align-first auto
       --align-first never
       --align-first always
	   Align the first partition for improved performance (see also the --alignment option).

	   The default is --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.

	   --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.

	   --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

       --alignment N
	   Set the alignment of partitions to "N" sectors.  The default in virt-resize < 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

	   --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
	       virt-alignment-scan(1) for further details.

	   --alignment 8 (4K)
	       This would be the minimum acceptable alignment for reasonable performance on
	       modern hosts.

	   --alignment 128 (64K)
	       This alignment provides good performance when the host is using high end network

	   --alignment 2048 (1M)
	       This is the standard alignment used by all newly installed guests since around

	   Enable debugging messages.

	   Debug garbage collection and memory allocation.  This is only useful when debugging
	   memory problems in virt-resize or the OCaml libguestfs bindings.

       --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
	   renumbered, which can easily make your guest unbootable.

	   You can give this option multiple times.

       --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
	   pvresize(8)).  Virt-resize leaves any other content it doesn't know about alone.

	   Currently virt-resize can resize:

	   o   ext2, ext3 and ext4 filesystems.

	   o   NTFS filesystems, if libguestfs was compiled with support for NTFS.

	       The filesystem must have been shut down consistently last time it was used.
	       Additionally, ntfsresize(8) marks the resized filesystem as requiring a
	       consistency check, so at the first boot after resizing Windows will check the

	   o   LVM PVs (physical volumes).  virt-resize does not usually resize anything inside
	       the PV, but see the --LV-expand option.	The user could also resize LVs as desired
	       after boot.

	   o   Btrfs filesystems, if libguestfs was compiled with support for btrfs.

	   Note that you cannot use --expand and --shrink together.

       --format 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 does not affect the output format.  See "QCOW2 AND NON-SPARSE

       --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.

       --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 "/dev/sda2" and a root device called "/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

	   Use virt-filesystems(1) to list the filesystems in the guest.

	   You can give this option multiple times, but it doesn't make sense to do this unless
	   the logical volumes you specify are all in different volume groups.

	   This option is used to make the output more machine friendly when being parsed by
	   other programs.  See "MACHINE READABLE OUTPUT" below.

	   Print a summary of what would be done, but don't do anything.

	   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

	   If you specify this flag, then this initial copy is not done.  You may need to
	   reinstall the boot loader in this case.

	   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

	   By default, virt-resize will try to expand the direct contents of partitions, if it
	   knows how (see --expand option above).

	   If you give the --no-expand-content option then virt-resize will not attempt this.

	   Pass the --force option to 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

       --output-format 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 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 "QCOW2 AND NON-SPARSE RAW FORMATS".

	   Don't print the summary.

       --resize part=size
	   Resize the named partition (expanding or shrinking it) so that it has the given size.

	   "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 --expand below).

	   You can only 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 --resize-force).

	   You can give this option multiple times.

       --resize-force part=size
	   This is the same as --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 --ignore option.

       --shrink part
	   Shrink the named partition until the overall disk image fits in the destination.  The
	   named partition must contain a filesystem or PV which has already been shrunk using
	   another tool (eg. 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

	   Note that you cannot use --expand and --shrink together.

	   Display version number and exit.

       The --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

       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:

       1.  Progress bar messages can be parsed from stdout by looking for this regular


       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.

       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.

       Versions of the program prior to 1.13.9 did not support the --machine-readable option and
       will return an error.

   "Partition 1 does not end on cylinder boundary."
       Virt-resize aligns partitions to multiples of 128 sectors (see the --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.

       If a Linux guest does not boot after resizing, and the boot is stuck after printing "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 virt-rescue(1).

       In Windows Vista and later versions, Microsoft switched to using a separate boot
       partition.  In these VMs, typically "/dev/sda1" is the boot partition and "/dev/sda2" is
       the main (C:) drive.  Resizing the first (boot) partition causes the bootloader to fail
       with 0xC0000225 error.  Resizing the second partition (ie. C: drive) should work.

       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 "chkdsk /f" on all
       NTFS partitions, then shut down the VM cleanly.	For further information see:

       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.

       After sysprepping a Windows guest and then resizing it with virt-resize, you may see the
       guest fail to boot with an "UNMOUNTABLE_BOOT_VOLUME" BSOD.  This error is caused by having
       "ExtendOemPartition=1" in the sysprep.inf file.	Removing this line before sysprepping
       should fix the problem.

       Windows 8 "fast startup" can prevent virt-resize from resizing NTFS partitions.	See

       You must create a fresh, zeroed target disk image for virt-resize to use.  Do not reuse a
       target, especially one which contains data already.

       Virt-resize 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.
       "virt-resizesource.img/dev/sda4") because the usual partitioning tools tend to leave
       whatever data happened to be on the disk when making partitions.  In rare cases you may
       need to "ddif=/dev/zeroof=/dev/sdXN" first to ensure the target partition is zeroed.

       There are several proprietary tools for resizing partitions.  We won't mention any here.

       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.

       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 --debug flag.

       dracut(8) includes a module called "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.

       Libvirt guest names can contain arbitrary characters, some of which have meaning to the
       shell such as "#" and space.  You may need to quote or escape these characters on the
       command line.  See the shell manual page sh(1) for details.

       This program returns 0 if successful, or non-zero if there was an error.

       virt-filesystems(1), virt-df(1), guestfs(3), guestfish(1), lvm(8), pvresize(8),
       lvresize(8), resize2fs(8), ntfsresize(8), btrfs(8), virsh(1), parted(8), truncate(1),
       fallocate(1), grub(8), grub-install(8), virt-rescue(1), virt-sparsify(1),
       virt-alignment-scan(1), http://libguestfs.org/.

       Richard W.M. Jones http://people.redhat.com/~rjones/

       Copyright (C) 2010-2012 Red Hat Inc.

       This program is free software; you can redistribute it and/or modify it under the terms of
       the GNU General Public License as published by the Free Software Foundation; either
       version 2 of the License, or (at your option) any later version.

       This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
       without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
       See the GNU General Public License for more details.

       You should have received a copy of the GNU General Public License along with this program;
       if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
       Boston, MA 02110-1301 USA.

       To get a list of bugs against libguestfs, use this link:

       To report a new bug against libguestfs, use this link:

       When reporting a bug, please supply:

       o   The version of libguestfs.

       o   Where you got libguestfs (eg. which Linux distro, compiled from source, etc)

       o   Describe the bug accurately and give a way to reproduce it.

       o   Run libguestfs-test-tool(1) and paste the complete, unedited output into the bug

libguestfs-1.22.6			    2013-08-24				   virt-resize(1)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 09:08 PM.

Unix & Linux Forums Content Copyright©1993-2018. All Rights Reserved.