virt-resize(1)

📦

version 1.57.3 · 15 versions

💅 virt-resize(1) — Resize a virtual machine disk

Virtualization Support

🌸 NAME

virt-resize — resize a virtual machine disk, bestie. That's the whole vibe.

✨ SYNOPSIS

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

💖 DESCRIPTION

Okay so virt-resize is this iconic tool that resizes a virtual machine disk — makes it bigger or smaller overall — and it can also resize or delete any partitions inside it. Slay.

But listen: virt-resize cannot resize disk images in-place. And it should not be used on live virtual machines. For consistent results, shut the virtual machine down before resizing it. No cap.

If you're not familiar with the associated tools — virt-filesystems(1) and virt-df(1) — we recommend you go read those manual pages first. They're the supporting cast, and they ate.

🎀 EXAMPLES

This example takes "olddisk" and resizes it into "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

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

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

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

🦋 DETAILED USAGE

🌟 EXPANDING A VIRTUAL MACHINE DISK

Shut down the virtual machine — yes, actually shut it down. Live resizing is not the move here.
Locate input disk image — locate the input disk image, like 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 -e /domain/devices/disk/source
Found 1 nodes:
-- NODE --
<source dev="/dev/vg/lv_guest" />

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

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

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 "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), btrfs(8), xfs_growfs(8), or 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 "ADDING REMOTE STORAGE" in guestfish(1).

Other options are covered below.

Test — thoroughly test the new disk image before discarding the old one. Like, do not skip this part, bestie.

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

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 A VIRTUAL MACHINE DISK

Shrinking is somewhat more complex than expanding, and only an overview is given here. Not me giving you the whole saga — just the highlights.

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.

🍓 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. So like, be careful — this is giving consequences.

🦋 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 fallocate(1) command use dd if=/dev/zero of=outdisk bs=1M count=..)

🧚 LOGICAL PARTITIONS

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

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.

👑 OPTIONS

--help — Display help. Iconic behaviour, honestly.
--align-first auto — 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 unbootable. So like, highkey risky.
--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 this:

--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 storage.
--alignment 2048 (1M) — This is the standard alignment used by all newly installed guests since around 2008.

--colors — 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.
--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.
-d, --debug — (Deprecated: use -v option instead.)
--delete PART — yeet the named partition 🗑️. Ngl, "don't copy it over" is way more accurate, bestie — virt-resize doesn't do in-place edits, so your original disk image stays completely untouched.

Lowkey important: when you delete a partition, everything inside it is deleted too. And the way that it renumbers every partition that comes after it? That can casually make your guest unbootable 😭. Not cute.

You can slide this option in multiple times.

--expand PART — grow the named partition so it eats up all the extra space (like, all the space left over after whatever other resize glow-ups you asked for are done) 🔥.

If virt-resize knows how, it'll expand the direct content of the partition too. Case in point: if the partition is an LVM PV, it expands the PV to fit (basically pvresize(8) energy). Anything else it doesn't recognise? It leaves alone, respectfully.

Currently virt-resize can resize:

ext2, ext3 and ext4 filesystems.
NTFS filesystems, if libguestfs was compiled with support for NTFS.

The filesystem has to have been shut down consistently the last time it was used. Also, ntfsresize(8) marks the resized filesystem as needing a consistency check, so the first boot after resizing, Windows will check the disk. Foreshadowing 🫣.

LVM PVs (physical volumes). virt-resize doesn't usually resize anything inside the PV — but see the --LV-expand option. You could also resize LVs yourself after boot, main character energy.
Btrfs filesystems, if libguestfs was compiled with support for btrfs.
XFS filesystems, if libguestfs was compiled with support for XFS.
Linux swap partitions.

Please note 😳 libguestfs destroys the existing swap content by recreating it with mkswap, so do NOT use this when the guest is suspended.

f2fs filesystems, if libguestfs was compiled with support for f2fs.

Heads up: you cannot use --expand and --shrink together. Pick a lane 💅.

--format raw — specify the format of the input disk image. If you don't pass this flag, it gets auto-detected from the image itself.

If you're working with untrusted raw-format guest disk images, you should always make sure the format is specified. Safety first, bestie ✨.

Note that this option does not affect the output format — see "QCOW2 AND NON-SPARSE RAW FORMATS".

--ignore PART — ignore the named partition 🙈. Effectively that means the partition gets allocated on the destination disk, but the content isn't copied across from the source disk. So the partition's content is 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

So this would first expand the partition (and PV), and then expand the root device to fill the extra space in the PV. Beautiful, honestly 👑

The contents of the LV also get resized if virt-resize knows how to do that. You can stop virt-resize from trying to expand the content by using the option --no-expand-content.

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

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

--machine-readable
--machine-readable=format — this option makes the output more machine friendly when other programs are parsing it 🤖. See "MACHINE READABLE OUTPUT" below.
-n, --dry-run — print a summary of what would be done, but don't actually do anything 🧚. A little vision board moment.
--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 those sectors contain the Master Boot Record (MBR) and the boot loader, and they're required for the guest to boot correctly 🙏.

If you specify this flag, that initial copy just... doesn't happen. You may need to reinstall the boot loader in this case. You've been warned 💀.

--no-extra-partition — by default, virt-resize creates an extra partition if there's any extra, unused space after all the resizing has happened. Use this option to prevent that extra partition from being created. If you do this, the extra space will be inaccessible until you run fdisk, parted, or some other partitioning tool inside the guest 🛠️.

Note that if the surplus space is smaller than 10 MB, no extra partition will be created anyway.

--no-expand-content — by default, virt-resize tries to expand the direct contents of partitions, if it knows how (see the --expand option above).

If you give the --no-expand-content option, virt-resize won't attempt this. Hands off 🫶.

--no-sparse — turn off sparse copying. See "SPARSE COPYING" below.
--ntfsresize-force — 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 resize 🔁.
--output-format raw — specify the format of the output disk image. If this flag isn't given, it's auto-detected from the image itself.

If you're working with untrusted raw-format guest disk images, you should make sure the format is always specified ✨.

Note that this option does not create the output format. It just tells libguestfs what it is so it doesn't try to guess. You still need to create the output disk with the right format. See "QCOW2 AND NON-SPARSE RAW FORMATS".

-q, --quiet — don't print the summary 🤫.
--resize PART=SIZE — resize the named partition (expanding or shrinking it) so 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 above).

You can only decrease the size of partitions that contain filesystems or PVs which have already been shrunk. virt-resize will check that this has been done before proceeding, or else it'll print an error (see also --resize-force). It's giving responsible queen 💅.

You can give this option multiple times.

--resize-force PART=SIZE — same as --resize except it'll let you decrease the size of any partition. Generally that means you'll lose any data that was at the end of the partition you shrank 😭 — but you may not care about that (eg. if you're shrinking an unused partition, or if you can easily recreate it, such as a swap partition).

🤖 MACHINE READABLE OUTPUT 🤖

okay so the --machine-readable option exists to make the output more machine friendly, which is lowkey iconic when you're calling virt-resize from other programs, GUIs, etc. 🫶

There are two ways to use this option, bestie.

✨ Way 1: the vibe check

First up, 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. slay.

✨ Way 2: the actual resize

Secondly, use the option in conjunction with other options to make the regular program output more machine friendly.

At the moment this means:

Progress bar messages can be parsed from stdout by looking for this regular expression:

^[0-9]+/[0-9]+$

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.
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. ancient history fr fr.

It is possible to specify a format string for controlling the output; see "ADVANCED MACHINE READABLE OUTPUT" in guestfs(3). fancy.

🌸 NOTES 🌸

💀 "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. so like… ignore that message, it's giving 1992 🎀

😭 GUEST BOOT STUCK AT "GRUB"

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). she's got you 🫶

🪟 RESIZING WINDOWS BOOT PARTITIONS

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. not me touching the boot partition… don't 💀

🔍 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 "chkdsk /f" on all NTFS partitions, then shut down the VM cleanly. For further information see: https://bugzilla.redhat.com/show_bug.cgi?id=975753

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. she's just being thorough, bestie ��

💀 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 "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. periodt.

🪟 WINDOWS 8

Windows 8 "fast startup" can prevent virt-resize from resizing NTFS partitions. See "WINDOWS HIBERNATION AND WINDOWS 8 FAST STARTUP" in guestfs(3). iykyk.

🦋 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. ⚠️ like this is a real "incorrect results" situation, not a cute little quirk.

The main time this can be a problem is if the target is a host partition (eg. "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 --no-sparse option. Note this can be much slower. sacrifice, honestly 💅

🙈 "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 "TYPE", but there is no available nor known expanding method for that filesystem.

This may be due to either of the following:

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 "btrfs", "ntfs", "xfs", and "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, "libguestfs-xfs" on Red Hat Enterprise Linux, CentOS, Debian, Ubuntu, and distributions derived from them, for supporting the "xfs" filesystem.

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.

In both cases, virt-resize will not expand the mentioned filesystem; the result (unless --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. so the partition ate but the filesystem didn't, awkward 🎀

👑 ALTERNATIVE TOOLS 👑

There are several proprietary tools for resizing partitions. We won't mention any here. gatekeeping, love that for us.

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.

✨ EXIT STATUS ✨

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

💖 AUTHOR 💖

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

🌈 COPYRIGHT 🌈

📜 LICENSE 📜

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.

💜 yes bestie, the ALL CAPS warranty disclaimer is supposed to be like that. it's legally iconic.

🐛 BUGS 🐛

To get a list of bugs against libguestfs, use this link: https://bugzilla.redhat.com/buglist.cgi?component=libguestfs&product=Virtualization+Tools

To report a new bug against libguestfs, use this link: https://bugzilla.redhat.com/enter_bug.cgi?component=libguestfs&product=Virtualization+Tools

When reporting a bug, please supply:

The version of libguestfs.
Where you got libguestfs (eg. which Linux distro, compiled from source, etc)
Describe the bug accurately and give a way to reproduce it.
Run libguestfs-test-tool(1) and paste the complete, unedited output into the bug report.

okay that's the whole page, you're officially a virt-resize girlie now 💅 this was guestfs-tools-1.57.3, dated 2026-09-16, and yes the page is literally called virt-resize(1) — go resize something, bestie, and remember: zero the target first 🎀✨💖

📦 where this page comes from

centos-stream 10: guestfs-tools 1.57.3-1.el10 · GPL-2.0-or-later AND LGPL-2.0-or-later
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms