Resize a Linux Root Partition Without

Rebooting
Table of Contents
 Introduction
 Requirements
 Provision Additional Space
 Verify
 Summary

Introduction
A typical Linux server deployed from a ProfitBricks supplied image has a single storage
volume, /dev/vda. If we take a look at that using fdisk we will see that the disk is divided into
two partitions. The first one, /dev/vda1, is the boot partition where the OS resides. The second
partition, /dev/vda2, is configured as swap space.
root@debian:~# fdisk -l /dev/vda

Disk /dev/vda: 50 GiB, 53687091200 bytes, 104857600 sectors

Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x0041f8a8

Device Boot Start End Sectors Size Id Type

/dev/vda1 2048 96471039 96468992 46G 83 Linux
/dev/vda2 96471040 104857599 8386560 4G 82 Linux swap / Solaris

In the example above, the total 50 GB storage volume is split into 46 GB usable space and 4 GB for
swap. What if after provisioning we find that 46 GB of disk space is not enough but we prefer not to
add an additional storage volume? The goal is to increase the amount of disk space available on the
root filesystem. This can be accomplished with minimal disruption. We do not need to reboot the
server!

Requirements
 A Linux Server created from a ProfitBricks supplied image.
 SSH or console access (via the DCD) to the Linux Server.
  The partprobe command. Can be installed from the parted package on most Linux
distributions.
 The fdisk, swapoff, mkswap, swapon, and resize2fs commands. Likely available by
default.
 A current snapshot or other backup of the system you are working on. Just to be safe!

Provision Additional Space

To increase the size of the hard drive, go into the DCD (Data Center Designer) and upscale the
drive.

After you have increased the amount of drive space, click on "provisioning" to process the change.
Takes around a minute and your hard drive is bigger.
We then need to switch off the swap - so make sure you can live a few minutes without swap space:
root@debian:~# swapoff -a

Once swap has been disabled, we need to reconfigure the partitions using fdisk:
We will delete the two existing partitions first. We run fdisk /dev/vda and then use
the d command to delete partition 2, and then delete partition 1. Follow the example below:
root@debian:~# fdisk /dev/vda

Command (m for help): d

Partition number (1,2, default 2):

Partition 2 has been deleted.

Command (m for help): d

Selected partition 1
Partition 1 has been deleted.

Now we recreate our partitions. In the example we have 4 GB of swap space. So we need to keep at
least that much space available for the new swap partition.
Recreate /dev/vda1 first. Press n to create a new partition. Enter p to create a primary partition.
We can press Enter to accept the default value of 2048 for the first sector. Then enter a size for the
partition. You can enter a value in GB, so if we are increasing the disk to 100 GB, we subtract our 4
GB for swap, and enter +96G for 96 GB.
Command (m for help): n
Partition type
p primary (0 primary, 0 extended, 4 free)
e extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-209715199, default 2048):
Last sector, +sectors or +size{K,M,G,T,P} (2048-209715199, default 209715199): +96G

Created a new partition 1 of type 'Linux' and of size 96 GiB.

Now we recreate the swap partition following a simalar process. Press n and then p to create a new
primary partition. Press Enterto accept the default value for "First sector". We can also
press Enter again to accept the default value for "Last sector".
Command (m for help): n
Partition type
p primary (1 primary, 0 extended, 3 free)
e extended (container for logical partitions)
Select (default p): p
Partition number (2-4, default 2): 2
First sector (201328640-209715199, default 201328640):
Last sector, +sectors or +size{K,M,G,T,P} (201328640-209715199, default 209715199):

Created a new partition 2 of type 'Linux' and of size 4 GiB.

Since this second partition is going to be used for swap space, we need to change the partition type.
This can be done by pressing tat the fdisk prompt. We then press 2 to select the second partition. If
you want to see the list of available partition types, press L, otherwise enter 82 to select "Linux
swap / Solaris".
Command (m for help): t
Partition number (1,2, default 2): 2
Partition type (type L to list all types): L

0 Empty 24 NEC DOS 81 Minix / old Lin bf Solaris

1 FAT12 27 Hidden NTFS Win 82 Linux swap / So c1 DRDOS/sec (FAT-
2 XENIX root 39 Plan 9 83 Linux c4 DRDOS/sec (FAT-
3 XENIX usr 3c PartitionMagic 84 OS/2 hidden or c6 DRDOS/sec (FAT-
4 FAT16 <32M 40 Venix 80286 85 Linux extended c7 Syrinx
5 Extended 41 PPC PReP Boot 86 NTFS volume set da Non-FS data
6 FAT16 42 SFS 87 NTFS volume set db CP/M / CTOS / .
 7 HPFS/NTFS/exFAT 4d QNX4.x 88 Linux plaintext de Dell Utility
8 AIX 4e QNX4.x 2nd part 8e Linux LVM df BootIt
9 AIX bootable 4f QNX4.x 3rd part 93 Amoeba e1 DOS access
a OS/2 Boot Manag 50 OnTrack DM 94 Amoeba BBT e3 DOS R/O
b W95 FAT32 51 OnTrack DM6 Aux 9f BSD/OS e4 SpeedStor
c W95 FAT32 (LBA) 52 CP/M a0 IBM Thinkpad hi ea Rufus alignment
e W95 FAT16 (LBA) 53 OnTrack DM6 Aux a5 FreeBSD eb BeOS fs
f W95 Ext'd (LBA) 54 OnTrackDM6 a6 OpenBSD ee GPT
10 OPUS 55 EZ-Drive a7 NeXTSTEP ef EFI (FAT-12/16/
11 Hidden FAT12 56 Golden Bow a8 Darwin UFS f0 Linux/PA-RISC b
12 Compaq diagnost 5c Priam Edisk a9 NetBSD f1 SpeedStor
14 Hidden FAT16 <3 61 SpeedStor ab Darwin boot f4 SpeedStor
16 Hidden FAT16 63 GNU HURD or Sys af HFS / HFS+ f2 DOS secondary
17 Hidden HPFS/NTF 64 Novell Netware b7 BSDI fs fb VMware VMFS
18 AST SmartSleep 65 Novell Netware b8 BSDI swap fc VMware VMKCORE
1b Hidden W95 FAT3 70 DiskSecure Mult bb Boot Wizard hid fd Linux raid auto
1c Hidden W95 FAT3 75 PC/IX bc Acronis FAT32 L fe LANstep
1e Hidden W95 FAT1 80 Old Minix be Solaris boot ff BBT
Partition type (type L to list all types): 82

fdisk helpfully informs us that we have changed the partition type with the message:
Changed type of partition 'Linux' to 'Linux swap / Solaris'.

After that, we save using the w command and are returned to a shell prompt:
Command (m for help): w

You may get a message like this before the shell prompt:
The partition table has been altered.
Calling ioctl() to re-read partition table.
Re-reading the partition table failed.: Device or resource busy

The kernel still uses the old table. The new table will be used at the next reboot or
after you run partprobe(8) or kpartx(8).

Lets forgo rebooting and instead tell the kernel about the new partitions using partprobe:
root@debian:~# partprobe

We should be returned to the shell prompt with no output from partprobe.

Now we need to resize our filesystem on /dev/vda1:
root@debian:~# resize2fs /dev/vda1
resize2fs 1.42.12 (29-Aug-2014)
Filesystem at /dev/vda1 is mounted on /; on-line resizing required
old_desc_blocks = 2, new_desc_blocks = 3

The filesystem on /dev/vda1 is now 25165824 (4k) blocks long.

Initialize the new swap location of /dev/vda2:
root@debian:~# mkswap /dev/vda2
Setting up swapspace version 1, size = 4193276 KiB
no label, UUID=c55c25a2-a386-4653-8455-4d9030586dd2

Finally we edit /etc/fstab and replace the old UUID with the new one returned in the output of
the mkswap command. The line to change has no value for "mount point" and has "type" set
to swap.
# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
# <file system> <mount point> <type> <options> <dump> <pass>
UUID=332f8fb5-ff1f-4297-b512-f2c93a277296 / ext4 errors=remount-ro 0
1
/dev/fd0 /media/floppy0 auto rw,user,noauto,exec,utf8 0 0
UUID=c55c25a2-a386-4653-8455-4d9030586dd2 none swap sw 0 0

After editing /etc/fstab, we need to enable swap again:

root@debian:~# swapon -a

Verify
We can verify the new larger disk size by utilizing df and/or fdisk.
Device Boot Start End Sectors Size Id Type
/dev/vda1 2048 201328639 201326592 96G 83 Linux
/dev/vda2 201328640 209715199 8386560 4G 82 Linux swap / Solaris

We can also confirm that the server was not rebooted by looking at the output of uptime:
$ uptime
23:54:21 up 7 days, 1:15, 1 user, load average: 0.00, 0.01, 0.05

Summary
We have successfully increased the amount of disk space available on our Linux server. If you have
any questions or comments, please leave them here, or in the DevOps Community section of this
site.
SHARE

 


 SUBSCRIBE

How to Increase the size of a Linux LVM by expanding the virtual

machine disk
Posted by Jarrod on December 12, 2012Leave a comment (258)Go to comments

This post will cover how to increase the disk space for a VMware virtual machine running Linux that is using
logical volume manager (LVM). Firstly we will be increasing the size of the actual disk on the VMware virtual
machine, so at the hardware level – this is the VM’s .vmdk file. Once this is complete we will get into the
virtual machine and make the necessary changes through the operating system in order to take advantage
of the additional space that has been provided by the hard drive being extended. This will involve creating a
new partition with the new space, expanding the volume group and logical group, then finally resizing the
file system.

As there are a number of different ways to increase disk space I have also posted some different methods
here:

 Use GParted to increase disk size of a Linux native partition – In this article the virtual disk is
expanded, however there is no LVM here just a Linux native partition that is expanded with the
GParted live CD.
 How to Increase the size of a Linux LVM by adding a new disk – In this article a new virtual disk is
added to the virtual machine, a new partition is created, the volume group and logical volume are
both expanded and then the filesystem is resized.
 How to Decrease the size of a Linux LVM – In this article the file system is shrunk followed by the
LVM, allowing you to reclaim space in the volume group.
Update 18/04/2015: I have created a video guide of this post in CentOS 7 shown below.

Important Note: Be very careful when working with the commands in this article as they have the
potential to cause a lot of damage to your data. If you are working with virtual machines make sure you
take a snapshot of your virtual machine beforehand, or otherwise have some other form of up to date
backup before proceeding. Note that a snapshot must not be taken until after the virtual disk has been
increased, otherwise you will not be able to increase it. It could also be worth cloning the virtual machine
first and testing out this method on the clone.
Prerequisites: As this method uses the additional space to create a primary partition, you must not already
have 4 partitions as you will not be able to create more than 4. If you do not have space for another
partition then you will need to consider a different method, there are some others in the above list.
Throughout my examples I will be working with a VMware virtual machine running Debian 6, this was set up
with a 20gb disk and we will be increasing it by 10gb for a total final size of 30gb.

Identifying the partition type

As this method focuses on working with LVM, we will first confirm that our partition type is actually Linux
LVM by running the below command.

fdisk -l

As you can see in the above image /dev/sda5 is listed as “Linux LVM” and it has the ID of 8e. The 8e hex
code shows that it is a Linux LVM, while 83 shows a Linux native partition. Now that we have confirmed we
are working with an LVM we can continue. For increasing the size of a Linux native partition (hex code
83) see this article.
Below is the disk information showing that our initial setup only has the one 20gb disk currently, which is
under the logical volume named /dev/mapper/Mega-root – this is what we will be expanding with the new
disk.

Note that /dev/mapper/Mega-root is the volume made up from /dev/sda5 currently – this is what we will be
expanding.

Increasing the virtual hard disk

First off we increase the allocated disk space on the virtual machine itself. This is done by right clicking the
virtual machine in vSphere, selecting edit settings, and then selecting the hard disk. In the below image I
have changed the previously set hard disk of 20gb to 30gb while the virtual machine is up and running.
Once complete click OK, this is all that needs to be done in VMware for this process.

If you are not able to modify the size of the disk, the provisioned size setting is greyed out. This can happen
if the virtual machine has a snapshot in place, these will need to be removed prior to making the changes to
the disk. Alternatively you may need to shut down the virtual machine if it does not allow you to add or
increase disks on the fly, if this is the case make the change then power it back on.

Detect the new disk space

Once the physical disk has been increased at the hardware level, we need to get into the operating system
and create a new partition that makes use of this space to proceed.

Before we can do this we need to check that the new unallocated disk space is detected by the server, you
can use “fdisk -l” to list the primary disk. You will most likely see that the disk space is still showing as the
same original size, at this point you can either reboot the server and it will detect the changes on boot or
you can rescan your devices to avoid rebooting by running the below command. Note you may need to
change host0 depending on your setup.

echo "- - -" > /sys/class/scsi_host/host0/scan

Below is an image after performing this and confirming that the new space is displaying.

Partition the new disk space

As outlined in my previous images the disk in my example that I am working with is /dev/sda, so we use
fdisk to create a new primary partition to make use of the new expanded disk space. Note that we do not
have 4 primary partitions already in place, making this method possible.

fdisk /dev/sda

We are now using fdisk to create a new partition, the inputs I have entered in are shown below in bold.
Note that you can press ‘m’ to get a full listing of the fdisk commands.

‘n’ was selected for adding a new partition.

WARNING: DOS-compatible mode is deprecated. It's strongly recommended to

switch off the mode (command 'c') and change display units to

sectors (command 'u').

Command (m for help): n

‘p’ is then selected as we are making a primary partition.

Command action

l logical (5 or over)

p primary partition (1-4)

p

As I already have /dev/sda1 and /dev/sda2 as shown in previous images, I have gone with using ‘3’ for this
new partition which will be created as /dev/sda3

Partition number (1-4): 3

We just press enter twice above as by default the first and last cylinders of the unallocated space should be
correct. After this the partition is then ready.

First cylinder (2611-3916, default 2611): "enter"

Using default value 2611
Last cylinder, +cylinders or +size{K,M,G} (2611-3916, default 3916): "enter"
Using default value 3916

‘t’ is selected to change to a partition’s system ID, in this case we change to ‘3’ which is the one we just
created.

Command (m for help): t

Partition number (1-5): 3

The hex code ‘8e’ was entered as this is the code for a Linux LVM which is what we want this partition to be,
as we will be joining it with the original /dev/sda5 Linux LVM.

Hex code (type L to list codes): 8e

Changed system type of partition 3 to 8e (Linux LVM)

‘w’ is used to write the table to disk and exit, basically all the changes that have been done will be saved
and then you will be exited from fdisk.

Command (m for help): w

The partition table has been altered!

Calling ioctl() to re-read partition table.

WARNING: Re-reading the partition table failed with error 16: Device or resource busy.
The kernel still uses the old table. The new table will be used at
the next reboot or after you run partprobe(8) or kpartx(8)
Syncing disks.

You will see a warning which basically means in order to use the new table with the changes a system
reboot is required. If you can not see the new partition using “fdisk -l” you may be able to run “partprobe -s”
to rescan the partitions. In my test I did not require either of those things at this stage (I do a reboot later
on), straight after pressing ‘w’ in fdisk I was able to see the new /dev/sda3 partition of my 10gb of space as
displayed in the below image.

For CentOS/RHEL run a “partx -a /dev/sda3” to avoid rebooting later on.

That’s all for partitioning, we now have a new partition which is making use of the previously unallocated
disk space from the increase in VMware.

Increasing the logical volume

We use the pvcreate command which creates a physical volume for later use by the logical volume manager
(LVM). In this case the physical volume will be our new /dev/sda3 partition.

root@Mega:~# pvcreate /dev/sda3

Device /dev/sda3 not found (or ignored by filtering).

In order to get around this you can either reboot, or use partprobe/partx as previously mentioned to avoid a
reboot, as in this instance the disk does not appear to be there correctly despite showing in “fdisk -l”. After a
reboot or partprobe/partx use the same command which will succeed.

root@Mega:~# pvcreate /dev/sda3

Physical volume "/dev/sda3" successfully created

Next we need to confirm the name of the current volume group using the vgdisplay command. The name
will vary depending on your setup, for me it is the name of my test server. vgdisplay provides lots of
information on the volume group, I have only shown the name and the current size of it for this example.

root@Mega:~# vgdisplay
--- Volume group ---
VG Name Mega
...
VG Size 19.76 GiB

Now we extend the ‘Mega’ volume group by adding in the physical volume of /dev/sda3 which we created
using the pvcreate command earlier.

root@Mega:~# vgextend Mega /dev/sda3

Volume group "Mega" successfully extended
Using the pvscan command we scan all disks for physical volumes, this should confirm the original /dev/sda5
partition and the newly created physical volume /dev/sda3

root@Mega:~# pvscan
PV /dev/sda5 VG Mega lvm2 [19.76 GiB / 0 free]
PV /dev/sda3 VG Mega lvm2 [10.00 GiB / 10.00 GiB free]
Total: 2 [29.75 GiB] / in use: 2 [29.75 GiB] / in no VG: 0 [0 ]

Next we need to increase the logical volume (rather than the physical volume) which basically means we will
be taking our original logical volume and extending it over our new partition/physical volume of /dev/sda3.

Firstly confirm the path of the logical volume using lvdisplay. This path name will vary depending on your
setup.

root@Mega:~# lvdisplay
--- Logical volume ---
LV Path /dev/Mega/root

The logical volume is then extended using the lvextend command.

root@Mega:~# lvextend /dev/Mega/root /dev/sda3

Extending logical volume root to 28.90 GiB
Logical volume root successfully resized

There is then one final step which is to resize the file system so that it can take advantage of this additional
space, this is done using the resize2fs command for ext based file systems. Note that this may take some
time to complete, it took about 30 seconds for my additional space.

root@Mega:~# resize2fs /dev/Mega/root

resize2fs 1.41.12 (17-May-2010)
Filesystem at /dev/Mega/root is mounted on /; on-line resizing required
old desc_blocks = 2, new_desc_blocks = 2
Performing an on-line resize of /dev/Mega/root to 7576576 (4k) blocks.
The filesystem on /dev/Mega/root is now 7576576 blocks long.

Alternatively if you’re running the XFS file system (default as of RedHat/CentOS 7) you can grow the file
system with “xfs_growfs /dev/Mega/root”.

That’s it, now with the ‘df’ command we can see that the total available disk space has been increased.

Summary
With this method we have increased the virtual disk drive through VMware, created a new partition out of
this newly unallocated space within the guest OS, turned it into a physical volume, extended the volume
group, and then finally extended the original logical volume over the newer physical volume resulting in
overall disk space being increased successfully.

16.8.2. EXPANDING A DISK IMAGE

This section demonstrates a simple case of expanding a disk image:

1. Locate the disk image to be resized. You can use the command virsh dumpxml
GuestName for a libvirt guest virtual machine.

2. Decide on how you wish to expand the guest virtual machine. Run virt-df -
h and virt-list-partitions -lh on the guest virtual machine disk, as shown in
the following output:
3. # virt-df -h /dev/vg_guests/RHEL6

4. Filesystem Size Used Available Use%

5. RHEL6:/dev/sda1 98.7M 10.0M 83.6M 11%

6. RHEL6:/dev/VolGroup00/LogVol00 6.8G 2.2G 4.3G 32%

7.

8. # virt-list-partitions -lh /dev/vg_guests/RHEL6

9. /dev/sda1 ext3 101.9M

10. /dev/sda2 pv 7.9G

This example will demonstrate how to:

 Increase the size of the first (boot) partition, from approximately 100MB to 500MB.

 Increase the total disk size from 8GB to 16GB.

 Expand the second partition to fill the remaining space.

 Expand /dev/VolGroup00/LogVol00 to fill the new space in the second partition.

1. Make sure the guest virtual machine is shut down.

2. Rename the original disk as the backup. How you do this depends on the host
physical machine storage environment for the original disk. If it is stored as a file,
use the mv command. For logical volumes (as demonstrated in this example),
use lvrename:
3. # lvrename /dev/vg_guests/RHEL6 /dev/vg_guests/RHEL6.backup

4. Create the new disk. The requirements in this example are to expand the total disk
size up to 16GB. Since logical volumes are used here, the following command is
used:
5. # lvcreate -L 16G -n RHEL6 /dev/vg_guests

6. Logical volume "RHEL6" created

7. The requirements from step 2 are expressed by this command:

8. # virt-resize \

9. /dev/vg_guests/RHEL6.backup /dev/vg_guests/RHEL6 \

10. --resize /dev/sda1=500M \

11. --expand /dev/sda2 \

12. --LV-expand /dev/VolGroup00/LogVol00

The first two arguments are the input disk and output disk. --resize
/dev/sda1=500M resizes the first partition up to 500MB. --expand
/dev/sda2 expands the second partition to fill all remaining space. --LV-expand
/dev/VolGroup00/LogVol00 expands the guest virtual machine logical volume to fill
the extra space in the second partition.

virt-resize describes what it is doing in the output:

Summary of changes:

/dev/sda1: partition will be resized from 101.9M to 500.0M

/dev/sda1: content will be expanded using the 'resize2fs' method

/dev/sda2: partition will be resized from 7.9G to 15.5G

/dev/sda2: content will be expanded using the 'pvresize' method

 /dev/VolGroup00/LogVol00: LV will be expanded to maximum size

/dev/VolGroup00/LogVol00: content will be expanded using the 'resize2fs'

method

Copying /dev/sda1 ...

[#####################################################]

Copying /dev/sda2 ...

[#####################################################]

Expanding /dev/sda1 using the 'resize2fs' method

Expanding /dev/sda2 using the 'pvresize' method

Expanding /dev/VolGroup00/LogVol00 using the 'resize2fs' method

13. Try to boot the virtual machine. If it works (and after testing it thoroughly) you can
delete the backup disk. If it fails, shut down the virtual machine, delete the new disk,
and rename the backup disk back to its original name.

14. Use virt-df or virt-list-partitions to show the new size:

15. # virt-df -h /dev/vg_pin/RHEL6

16. Filesystem Size Used Available Use%

17. RHEL6:/dev/sda1 484.4M 10.8M 448.6M 3%

18. RHEL6:/dev/VolGroup00/LogVol00 14.3G 2.2G 11.4G 16%

Resizing guest virtual machines is not an exact science. If virt-resizefails, there are a
number of tips that you can review and attempt in the virt-resize(1) man page. For some
older Red Hat Enterprise Linux guest virtual machines, you may need to pay particular
attention to the tip regarding GRUB.