Linux Disk Partitioning with ‘parted’ | Reference Guide

Are you finding it challenging to manage disk partitioning in Linux? You’re not alone. Many system administrators find this task a bit daunting, but there’s a tool that can make this process a breeze. Like a skilled architect, the ‘parted’ command in Linux can help you design and manage your disk partitions. These partitions can be created, deleted, and resized, even on drives larger than 2TB, making parted an extremely versatile tool for disk management.

This guide will walk you through the parted command, from basic usage to advanced techniques. We’ll explore parted’s core functionality, delve into its advanced features, and even discuss common issues and their solutions.

So, let’s dive in and start mastering the parted command in Linux!

TL;DR: How Do I Use the Parted Command in Linux?

The parted command is a powerful tool used to manipulate disk partitions in Linux. It is a highly customizable command, but the basic syntax follows the pattern, sudo parted [argument] device [actions]....

Here’s a simple example:

sudo parted /dev/sda print

# Output:
# Model: ATA ST1000LM024 HN-M (scsi)
# Disk /dev/sda: 1000GB
# Sector size (logical/physical): 512B/4096B
# Partition Table: gpt
# Disk Flags: 
#
# Number  Start   End     Size    File system  Name  Flags
#  1      1049kB  538MB   537MB   fat32              boot, esp
#  2      538MB   1000GB  1000GB  ext4

In this example, we used the sudo parted /dev/sda print command to display the partition table for the disk /dev/sda. The output shows the disk model, size, sector size, partition table type, and a list of partitions with their start and end points, size, file system, name, and flags.

This is just a basic way to use the parted command in Linux, but there’s much more to learn about managing disk partitions efficiently. Continue reading for more detailed information and advanced usage scenarios.

Getting Started with Parted

The parted command is a powerful tool that can help you manage disk partitions effectively. Here’s a simple step-by-step guide on how to use the parted command to create, delete, and resize disk partitions.

Creating a Partition with Parted

Let’s start with creating a partition. Here’s an example of how to create a new partition on disk /dev/sda:

sudo parted /dev/sda mkpart primary ext4 1MiB 500MiB

# Output:
# Warning: The existing file system will be destroyed and you will lose all your data on the partition. Do you want to continue?
# Yes/No? Yes
# Information: You may need to update /etc/fstab.

In this example, we used the mkpart command to create a new primary partition of type ext4, starting at 1MiB and ending at 500MiB on the disk /dev/sda. The output warns us that the existing file system will be destroyed, and we need to confirm with ‘Yes’. After the partition is created, it informs us that we may need to update /etc/fstab, which is the file system table in Linux.

Deleting a Partition with Parted

Deleting a partition is just as straightforward. Here’s how you can delete a partition (in this case, partition 1) on disk /dev/sda:

sudo parted /dev/sda rm 1

# Output:
# Information: You may need to update /etc/fstab.

In this example, we used the rm command to delete the partition number 1 on the disk /dev/sda. The output informs us again that we may need to update /etc/fstab.

Resizing a Partition with Parted

Resizing a partition is a bit more complex. Here’s an example of how to resize partition 1 on disk /dev/sda to end at 1GiB:

sudo parted /dev/sda resizepart 1 1GiB

# Output:
# Warning: Shrinking a partition can cause data loss, are you sure you want to continue?
# Yes/No? Yes
# Information: You may need to update /etc/fstab.

In this example, we used the resizepart command to resize the partition number 1 on the disk /dev/sda to end at 1GiB. The output warns us that shrinking a partition can cause data loss, and we need to confirm with ‘Yes’. Once again, it informs us that we may need to update /etc/fstab.

Advantages and Pitfalls of Using Parted

The parted command is a powerful tool, but it comes with its own set of advantages and potential pitfalls. On the positive side, parted supports disks larger than 2TB and partition tables of various types, including MBR and GPT. It also allows you to manipulate partitions while keeping the data intact.

However, the parted command is not without its challenges. It can be complex to use, especially for beginners. Also, while parted tries to preserve data when modifying partitions, there’s always a risk of data loss, especially when resizing or deleting partitions. Therefore, it’s crucial to back up your data before making any significant changes.

Advanced Parted Command Usage

As you become more comfortable with the basic usage of the parted command, you can start to explore its more advanced features. These include aligning partitions, changing partition types, and managing disk labels. But before we delve into these, let’s familiarize ourselves with some of the command-line arguments or flags that can modify the behavior of the parted command.

Here’s a table with some of the most commonly used parted arguments:

Now that we have a basic understanding of parted command-line arguments, let’s dive deeper into the advanced use of parted.

Aligning Partitions with Parted

Proper partition alignment is essential for optimal disk performance. Here’s an example of how to check partition alignment using parted:

sudo parted /dev/sda align-check opt 1

# Output:
# 1 aligned

In this example, we used the align-check command to check if the partition number 1 on the disk /dev/sda is optimally aligned. The output ‘1 aligned’ indicates that the partition is correctly aligned.

Changing Partition Types with Parted

Sometimes, you may need to change the type of a partition. Here’s an example of how to change the partition type to ‘ext4’ using parted:

sudo parted /dev/sda mkpart primary ext4 1MiB 500MiB

# Output:
# Warning: The existing file system will be destroyed and you will lose all your data on the partition. Do you want to continue?
# Yes/No? Yes
# Information: You may need to update /etc/fstab.

In this example, we used the mkpart command to change the partition type to ‘ext4’ on the disk /dev/sda. The output warns us that the existing file system will be destroyed, and we need to confirm with ‘Yes’. After the partition type is changed, it informs us that we may need to update /etc/fstab.

Managing Disk Labels with Parted

Disk labels or partition tables are essential for managing partitions on a disk. Here’s an example of how to create a new GPT disk label using parted:

sudo parted /dev/sda mklabel gpt

# Output:
# Warning: The existing disk label on /dev/sda will be destroyed and all data on this disk will be lost. Do you want to continue?
# Yes/No? Yes

In this example, we used the mklabel command to create a new GPT disk label on the disk /dev/sda. The output warns us that the existing disk label will be destroyed, and all data on this disk will be lost. We need to confirm with ‘Yes’ to proceed.

These are just a few examples of the advanced uses of the parted command in Linux. As always, remember to back up your data before making any significant changes to your disk partitions.

Exploring Alternatives: fdisk and gdisk

While the parted command is a versatile tool for managing disk partitions in Linux, it’s not the only one. There are alternative commands, such as fdisk and gdisk, which also offer robust features for disk partitioning. Let’s explore these alternatives, their usage examples, benefits, drawbacks, and when to consider using them.

fdisk: The Classic Partitioning Tool

fdisk is a traditional command-line utility that provides disk partitioning functions. It’s widely used due to its simplicity and compatibility with older systems. Here’s an example of how to display the partition table of a disk using fdisk:

sudo fdisk -l /dev/sda

# Output:
# Disk /dev/sda: 931.5 GiB, 1000204886016 bytes, 1953525168 sectors
# Disk model: ST1000LM024 HN-M
# Units: sectors of 1 * 512 = 512 bytes
# Sector size (logical/physical): 512 bytes / 4096 bytes
# I/O size (minimum/optimal): 4096 bytes / 4096 bytes
# Disklabel type: gpt
# Disk identifier: C2D3D3C1-6B2B-4B5D-9B31-5B353B9A5A73

# Device       Start        End   Sectors   Size Type
# /dev/sda1     2048     534527    532480   260M EFI System
# /dev/sda2   534528 1953523711 1952989184 931.3G Linux filesystem

In this example, we used the fdisk -l /dev/sda command to display the partition table for the disk /dev/sda. The output shows the disk’s size, model, units, sector size, I/O size, disk label type, disk identifier, and a list of partitions with their start and end sectors, sectors, size, and type.

gdisk: The Modern GPT-Friendly Tool

gdisk is a newer command-line utility that’s designed to work with modern hardware. It’s GPT-friendly and can handle disks larger than 2TB. Here’s an example of how to create a new partition using gdisk:

sudo gdisk /dev/sda

# Command (? for help): n
# Partition number (1-128, default 1): 1
# First sector (34-1953525134, default = 2048) or {+-}size{KMGTP}: 
# Last sector (2048-1953525134, default = 1953525134) or {+-}size{KMGTP}: +500M
# Hex code or GUID (L to show codes, Enter = 8300): 8300

# Command (? for help): w

# Do you want to proceed? (Y/N): Y

# Output:
# Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING PARTITIONS!!
# Do you want to proceed? (Y/N): Y
# OK; writing new GUID partition table (GPT) to /dev/sda.
# The operation has completed successfully.

In this example, we used the gdisk /dev/sda command to create a new partition on the disk /dev/sda. The output prompts for various inputs such as partition number, first sector, last sector, hex code or GUID, and confirmation to write the GPT data. After confirming with ‘Y’, it writes the new GUID partition table (GPT) to /dev/sda.

Decision-Making Considerations

Choosing between parted, fdisk, and gdisk depends on your specific needs and the system you’re working with. If you’re dealing with modern hardware and need to handle large disks, gdisk might be the best choice due to its GPT compatibility. If you’re working with older systems or prefer a simpler interface, fdisk could be a better option. On the other hand, if you need a tool that offers a balance between advanced features and ease of use, the parted command is a solid choice.

Troubleshooting Common Parted Command Issues

Even experienced users can encounter errors or obstacles when using the parted command. Let’s discuss some of these common issues, their solutions, and some best practices for optimizing your use of parted.

Error: Unrecognized Disk Label

One common error you might encounter when using parted is the ‘unrecognized disk label’ error. This typically happens when you’re trying to manipulate a disk that doesn’t have a disk label or has an unrecognized one.

Here’s an example of this error and how to resolve it:

sudo parted /dev/sda print

# Output:
# Error: /dev/sda: unrecognised disk label
# Model: ATA ST1000LM024 HN-M (scsi)
# Disk /dev/sda: 1000GB
# Sector size (logical/physical): 512B/4096B

In this example, we tried to print the partition table for the disk /dev/sda, but parted returned an ‘unrecognised disk label’ error. To resolve this issue, you can create a new disk label (partition table) using the mklabel command. For instance, to create a new gpt disk label, you would use the command sudo parted /dev/sda mklabel gpt.

Error: Partition Being Used

Another common error is the ‘partition being used’ error, which occurs when you try to delete or modify a partition that’s currently in use.

Here’s an example of this error and how to resolve it:

sudo parted /dev/sda rm 1

# Output:
# Error: Partition /dev/sda1 is being used. You must unmount it before you modify it.

In this example, we tried to delete partition 1 on the disk /dev/sda, but parted returned an ‘partition being used’ error. To resolve this issue, you need to unmount the partition before you can modify it. You can do this using the umount command, like so: sudo umount /dev/sda1.

Best Practices and Optimization Tips

When using the parted command, there are several best practices to keep in mind for optimal results:

• Always back up your data before making any significant changes to your disk partitions.
• Use the print command before and after making changes to verify the current state of the disk and to confirm your changes.
• Be aware of the size of your disk and the size of your partitions to avoid over-provisioning.
• Use the align-check command to ensure your partitions are optimally aligned for better performance.
• Regularly check for and install updates to parted to benefit from the latest features and bug fixes.

Understanding Disk Partitioning and File Systems

Before delving into the specifics of the parted command, it’s essential to understand the fundamentals of disk partitioning and file systems in Linux.

Disk Partitioning in Linux

Disk partitioning is the process of dividing a disk’s storage space into separate sections, each of which acts as a separate disk. This division is usually done for reasons like data organization, data isolation, multiple operating systems, and data security.

Here’s an example of how to view the partition table of a disk using parted:

sudo parted /dev/sda print

# Output:
# Model: ATA ST1000LM024 HN-M (scsi)
# Disk /dev/sda: 1000GB
# Sector size (logical/physical): 512B/4096B
# Partition Table: gpt
# Disk Flags: 
#
# Number  Start   End     Size    File system  Name  Flags
#  1      1049kB  538MB   537MB   fat32              boot, esp
#  2      538MB   1000GB  1000GB  ext4

In this example, the sudo parted /dev/sda print command displays the partition table for the disk /dev/sda. The output shows the disk model, size, sector size, partition table type, and a list of partitions with their start and end points, size, file system, name, and flags.

File Systems in Linux

A file system is a method of storing and organizing data on a storage device like a hard drive. In Linux, there are several types of file systems, such as ext4, XFS, and Btrfs, each with its own advantages and disadvantages.

Here’s an example of how to create an ext4 file system on a partition using the mkfs.ext4 command:

sudo mkfs.ext4 /dev/sda1

# Output:
# mke2fs 1.42.13 (17-May-2015)
# Creating filesystem with 261888 4k blocks and 65536 inodes
# Filesystem UUID: 5f3ebe3e-5467-4558-b8f6-1042938c0dab
# Superblock backups stored on blocks: 
#    32768, 98304, 163840, 229376
#
# Allocating group tables: done                            
# Writing inode tables: done                            
# Creating journal (8192 blocks): done
# Writing superblocks and filesystem accounting information: done

In this example, we used the sudo mkfs.ext4 /dev/sda1 command to create an ext4 file system on the partition /dev/sda1. The output shows the creation process, including the allocation of group tables, writing of inode tables, creation of the journal, and writing of superblocks and filesystem accounting information.

The Role of Parted in Disk Management

The parted command plays a crucial role in disk management in Linux. It allows you to create, delete, resize, and manage disk partitions, supporting both MBR and GPT partition tables and disks larger than 2TB. Moreover, it provides a consistent interface for managing partitions, making it easier to automate disk management tasks.

Parted in Larger System Administration Tasks

The parted command is not just a tool for managing disk partitions. It’s also a critical utility for performing larger system administration tasks, like setting up RAID arrays or Logical Volume Management (LVM).

Setting Up RAID Arrays with Parted

RAID (Redundant Array of Independent Disks) is a method of storing the same data in different places on multiple hard disks to protect data in the case of a drive failure. Here’s an example of how you might use parted to prepare disks for a RAID array:

sudo parted /dev/sda mklabel gpt
sudo parted /dev/sdb mklabel gpt
sudo parted /dev/sda mkpart primary ext4 1MiB 100%
sudo parted /dev/sdb mkpart primary ext4 1MiB 100%

# Output:
# Information: You may need to update /etc/fstab.

In this example, we create a GPT label on two disks (/dev/sda and /dev/sdb) and then create a single ext4 partition on each disk, using the entire disk space. These disks could then be used to create a RAID array.

Using Parted with Logical Volume Management (LVM)

LVM is a method of allocating space on mass-storage devices that is more flexible than conventional partitioning methods. Here’s an example of how you might use parted to create a partition for use with LVM:

sudo parted /dev/sda mklabel gpt
sudo parted /dev/sda mkpart primary 1MiB 100%
sudo parted /dev/sda set 1 lvm on

# Output:
# Information: You may need to update /etc/fstab.

In this example, we create a GPT label on a disk (/dev/sda), create a single partition using the entire disk space, and then set the ‘lvm’ flag on the partition. This partition could then be used to create a physical volume for use with LVM.

Related Commands and Further Study

While the parted command is powerful, it’s often used in conjunction with other commands for managing disks and file systems. Some related commands you might find useful include fdisk for partitioning disks, mkfs for creating file systems, mount for mounting file systems, and lsblk for listing block devices.

Further Resources for Mastering Disk Partitioning

For those interested in further expanding their knowledge on disk partitioning and management in Linux, here are some resources:

1. GNU Parted Manual – The official manual for the parted command from the GNU Project.

2. Arch Linux Partitioning Guide – A comprehensive guide on disk partitioning in Arch Linux, but applicable to other Linux distributions as well.

3. Linux Disk Management with LVM – A detailed guide on managing disks using Logical Volume Management (LVM) in Linux.

Wrapping Up: Mastering the Parted Linux Command

In this comprehensive guide, we’ve explored the parted command in Linux, a powerful tool for managing disk partitions. Whether you’re working with a personal computer or administering a large server, understanding how to use the parted command is a crucial skill in the world of Linux.

We began with the basics, learning how to use parted to create, delete, and resize disk partitions. We then delved into more complex uses of parted, such as aligning partitions, changing partition types, and managing disk labels. Along the way, we tackled common issues you might encounter when using parted and provided solutions to help you overcome these challenges.

We also explored alternative commands for disk partitioning, such as fdisk and gdisk, giving you a sense of the broader landscape of tools for managing disk partitions in Linux. Here’s a quick comparison of these tools:

Whether you’re just starting out with the parted command or you’re looking to level up your disk management skills, we hope this guide has given you a deeper understanding of parted and its capabilities.

With its balance of flexibility, ease of use, and compatibility, the parted command is a powerful tool for disk management in Linux. Keep exploring, keep learning, and happy partitioning!