Linux Mint: How to View Manage System Partitions [Guide 2024]

On Linux Mint (including current 21.x releases in 2024), “system partitions” usually means the disk partitions that hold your Linux installation and the boot-related pieces (often an EFI System Partition plus your Linux root and/or swap).

Knowing how to view and manage them matters because partition layout drives boot, filesystem mounting, performance, and data safety. A fast read-only view prevents mistakes, and a safe management workflow prevents bricking.

As an Amazon Associate I earn from qualifying purchases.

This guide covers both GUI tools (Disks and GParted) and terminal commands (lsblk, blkid, fdisk/parted, mount/df, and fstab editing), with concrete steps and troubleshooting.

What counts as a system partition in Linux Mint?

In practice, you’ll commonly deal with these types of partitions on Mint systems:

• Root partition (mounts as /): where most Linux files live.
• Boot partition (sometimes): for legacy BIOS setups or certain layouts. Often contains kernel/initramfs.
• EFI System Partition (ESP): the FAT32 partition used to store EFI bootloaders (commonly labeled “EFI” or flagged as ESP).
• Swap partition (optional): used as additional memory backing when RAM is low.
• Home partition (optional): stores /home separately from root.
• Data partitions: for other OSes (like Windows) or shared storage (e.g., NTFS exFAT).

You can view them all, but only some are “system-critical” for boot and core OS operation.

Prerequisites and safety checklist

Before you change partitions (resize, format, edit fstab), do a quick safety pass.

• Backup critical data (especially if you touch NTFS/ext partitions).
• Verify the correct disk and partition (use lsblk and UUIDs).
• Know what you’re mounting: a partition existing on disk doesn’t mean it’s currently mounted.
• Use a live USB** when resizing system partitions: resizing mounted partitions can fail or corrupt data if tools detect a live filesystem.
• Be careful with UUID changes: if you edit labels/UUIDs, you may need to update /etc/fstab.

If you’re unsure, start with read-only viewing and only proceed after you can identify each partition confidently.

View partitions (GUI methods)

GUI tools are ideal for first-time identification: they show devices, partition sizes, filesystem types, and mount status in a readable layout.

Disks (GNOME Disks)

Disks is built into most Linux Mint installations and is usually the fastest way to “see what’s there.” It’s read-only by default for many actions and can also mount/unmount.

1. Open Menu → search for Disks.
2. Select your drive from the left sidebar (e.g., /dev/sda, /dev/nvme0n1).
3. You’ll see a partition list with: size, filesystem, and sometimes labels.
4. Click a partition to view details. Look for fields like Partition type, Filesystem, Mount options, and UUID (depending on Mint version).
5. To check mount status, look for Mounted / Mount point.

When you’re trying to identify the EFI System Partition, check for FAT32 and ESP-related flags (when shown). On some Mint builds, Disks labels it as EFI or shows it as a boot-related partition.

GParted Partition Editor

GParted (gparted package) is more powerful than Disks and is great for resizing and formatting—but it’s also where mistakes cost the most. Use it only after identifying devices correctly.

1. Install GParted if needed: sudo apt update && sudo apt install -y gparted
2. Open Menu → GParted.
3. Choose the correct device at the top-right (e.g., nvme0n1).
4. You’ll get a partition map. Click a partition to inspect details: filesystem type, label, size, and used/free space.
5. Use the top menu for actions (for example, Partition → Mount or Unmount).

GParted uses background checks and will often warn you when you’re resizing something that’s in use. When it refuses, that’s not a bug—usually it’s protecting your data.

View partitions (command-line methods)

Terminal output is consistent across Mint versions and gives the exact identifiers you’ll need for mounting, fstab entries, and troubleshooting.

lsblk: the fast, readable inventory

lsblk shows block devices, partition tree, sizes, filesystem types, and mountpoints. It’s the first command you should run.

1. Run: lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS,UUID,MODEL
2. Identify your main disk (often nvme0n1 or sda).
3. Look for partitions with FSTYPE like ext4, vfat (EFI), ntfs, or swap.
4. Check MOUNTPOINTS to see what’s currently mounted (e.g., / or /home).

For a simpler view focused on mounts: lsblk -f adds filesystem info.

blkid: filesystem and UUID details

blkid prints UUIDs and labels, which are essential for reliable mounting (especially when device names change).

1. Run: sudo blkid
2. Search for the device/UUID you care about (like a specific UUID=... for your root filesystem).
3. Note LABEL= and UUID= if present.

If you’re planning to mount by UUID, record the exact string (including hyphens).

fdisk: partition table overview (MBR/GPT)

fdisk is useful to quickly confirm whether a disk uses MBR or GPT and to view partition boundaries.

1. Find your disk name with lsblk (e.g., /dev/nvme0n1).
2. Run: sudo fdisk -l /dev/nvme0n1
3. Look for “Disklabel type: gpt” or “dos” and the partition table entries.

Don’t use fdisk’s interactive write mode unless you’re intentionally editing partition boundaries.

parted: scriptable partition info

parted is another strong option, especially when you want clear GPT/MBR structure output.

1. Run: sudo parted /dev/nvme0n1 print
2. If you need more detail, run: sudo parted /dev/nvme0n1 unit s print
3. Identify which partition is the ESP (usually a small FAT32 partition, often ~100–600MiB).

When troubleshooting boot issues, this helps verify partition alignment and sizes.

Understand mounts: what’s mounted vs what exists

Partitions exist as devices on disk. Filesystems become “active” only after they’re mounted at a mount point.

df -h: mounted filesystem usage

df -h shows mounted filesystems and their usage (human-readable).

1. Run: df -hT
2. Find rows for /, /home, and other mount points.

If you’re looking for what Mint is currently using, df is usually the fastest sanity check.

mount and /proc/mounts: where devices are attached

mount (or cat /proc/mounts) shows the exact mapping of devices to mount points.

1. Run: mount | grep -E ' /| /home| /boot| /boot/efi'
2. Or run: cat /proc/mounts | grep -E '/(boot|home)'

Mount output includes options like rw/ro, which matters when debugging failures.

/etc/fstab: how partitions mount at boot

/etc/fstab tells Linux what to mount automatically at boot using UUIDs/labels. If something changed on disk, this file often becomes the culprit.

1. Open it (read-only first): sudo nano /etc/fstab
2. Look for lines starting with UUID= or LABEL=.
3. Confirm mount points (e.g., /, /home, /boot/efi).
4. Check the filesystem type column (ext4, vfat, ntfs, etc.) and options (commonly defaults or noatime).

If you change labels/UUIDs, you must update matching fstab entries or the system may fail to boot or drop to a maintenance shell.

Manage partitions: what you can do safely from each tool

“Manage” can mean many things: mount/unmount, formatting, resizing, labeling, or repairing filesystems. Some actions are safe and reversible; others are destructive.

The safest approach on a live system: view everything first, then do changes with a clear rollback plan.

Mount and unmount partitions

You can mount partitions temporarily (until reboot) or manage them via fstab for automatic mounting.

• GUI: Use Disks or GParted to mount/unmount.
• Terminal: Use udisksctl or mount/umount.

Prefer UUID-based mounting for accuracy.

Create or remove mount points

Mount points are directories. Linux won’t mount into random files—only proper empty directories (or directories that won’t break expectations).

1. Create: sudo mkdir -p /mnt/mydrive
2. Mount the partition onto it (see “Mount a partition by UUID”).

When done, unmount the device first before deleting the directory.

Change partition labels and UUIDs (and update fstab)

Labels are human-friendly and often used in fstab. UUIDs are machine-friendly and usually recommended for stability.

• Label: change filesystem label (not partition “name” in GUI terms).
• UUID: changes can happen after reformatting. If you change it, update fstab.

After label changes, verify with blkid.

Resize partitions (caveats for live filesystems)

Resizing requires careful tool selection. For many filesystem types (especially ext4), tools behave differently depending on whether the filesystem is mounted and writable.

• Best practice: boot into a live session or unmount the target filesystem.
• Common rule: don’t resize your mounted root filesystem on a running system unless you fully understand the risks and tool behavior.

GParted will often refuse or warn when it detects issues like “device is busy.” Don’t override those warnings casually.

Format partitions (data loss warning)

Formatting wipes the filesystem structures and typically erases existing data. If the partition holds important data, back it up first.

1. Confirm the exact device (e.g., /dev/sda3 or /dev/nvme0n1p3) with lsblk -f.
2. In GParted: select the partition → right-click → Format to → choose filesystem (e.g., ext4, vfat).
3. In terminal: use mkfs tools like sudo mkfs.ext4 /dev/nvme0n1p3 (read the command carefully).

Formatting an EFI partition incorrectly can break boot—only format boot-related partitions if you’re confident in the intended purpose.

Repair filesystem issues

If mounts fail or the filesystem is marked dirty, run filesystem checks for the correct type.

• ext4: fsck.ext4 (or fsck with the right filesystem).
• NTFS: ntfsfix is limited; better options exist but require care.
• FAT/vfat: use appropriate fsck tools.

Repairing unmounted filesystems is safer. If it’s mounted, remount as read-only or unmount first when feasible.

Boot-related partition management (EFI, GRUB) without bricking

Mint’s boot flow often relies on the EFI System Partition and bootloader files. Managing those partitions incorrectly is a common path to boot failures.

Identify the EFI System Partition (ESP)

The ESP is usually a small FAT32 partition. You can identify it quickly by filesystem type and mount point.

1. Run: lsblk -f
2. Look for FSTYPE=vfat and small size (often ~100–600MiB).
3. Check if it’s mounted at something like /boot/efi using df -hT.
4. Confirm flags/attributes in parted or fdisk output if needed.

If your system is UEFI, touching the ESP is often how you affect bootloader installation and updates.

Common mistakes that break boot

• Formatting the ESP as ext4 or wiping it entirely.
• Changing UUIDs/labels used by /etc/fstab for /boot/efi without updating entries.
• Mounting ESP read-write when tools expect it read-only (rare, but can happen in recovery).
• Removing EFI bootloader files accidentally (e.g., deleting files in the wrong directory under the ESP).

When you must touch boot partitions, do it carefully

If you’re reinstalling or repairing the bootloader, do it through known recovery steps (Mint tools, boot repair utilities, or documented commands). Avoid “manual cleanup” of the ESP unless you’re following a validated procedure.

As a safe baseline, always capture the ESP’s UUID/label and confirm its mount point before changes:

1. sudo blkid | grep -i -E 'vfat|efi|UUID'
2. grep -n 'boot/efi' /etc/fstab

Choosing the right method: GUI vs terminal

Use this rule of thumb:

Task	Recommended tool	Why
See partition layout quickly	Disks (GUI) or lsblk	Readable view with minimal risk
Confirm UUIDs/labels	blkid	Exact identifiers for reliable mounting
Resize/format	GParted (prefer live)	Guided operations and warnings
Repair filesystems	fsck tools	Type-specific consistency checks
Diagnose boot/fstab issues	/etc/fstab + mount/df	Mount behavior is driven by configuration

Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Support on Ko-Fi

Troubleshooting: when your “system partitions” view doesn’t match reality

Partition problems often look like “I can’t see it,” “it won’t mount,” or “boot fails.” The fix depends on what’s actually wrong: detection, filesystem integrity, or configuration.

No partitions shown / wrong device selected

First, confirm your drive name and whether the kernel sees it.

1. Run: lsblk and check for nvme or sd devices.
2. Try: sudo dmesg | tail -n 60 and look for storage errors.
3. If you’re on a laptop with removable media, verify the device isn’t unplugged.

In GUI tools, always re-check the selected device. People often resize the wrong disk—don’t.

Partitions show up but won’t mount

Mount failures usually come from filesystem errors, wrong mount options, or missing directories.

1. Check: lsblk -f to confirm FSTYPE matches reality.
2. See the error: dmesg | tail -n 80 after attempting mount.
3. Confirm mount point exists: ls -ld /mnt/mydrive.
4. If it’s ext4 and dirty, attempt repair (see “Check and repair ext4”).

If the filesystem is NTFS, be mindful about the difference between read-only mounting and writable mode.

fstab errors and boot drops to emergency shell

If fstab references a UUID that no longer exists, boot may hang or drop into recovery.

1. Boot into recovery/live mode.
2. Mount your root filesystem (if needed) and open: /etc/fstab.
3. Compare each UUID=... to current values from blkid.
4. Fix mount entries and ensure filesystem types are correct (vfat vs ext4, etc.).

Also verify the mountpoint exists in the filesystem tree.

Filesystem won’t mount because it’s marked dirty

Tools may refuse mounting when journal state looks inconsistent.

1. Unmount if mounted: sudo umount /dev/sdXn (replace carefully).
2. Run the correct fsck for the filesystem type (e.g., ext4).
3. Reboot or remount after repair.

Never run ext4 fsck on a mounted partition unless the procedure explicitly instructs it.

Resizing fails with “in use” or “busy”

If you’re resizing something mounted (like the root filesystem), GParted and CLI tools will often refuse.

1. Identify what’s mounted with df -hT and mount.
2. Boot from a Mint live USB if you need to resize root or home partitions.
3. In live mode, you can often safely resize partitions that were previously busy.

When tools show “busy,” treat it as a safety requirement, not a nuisance.

Common workflows (copy/paste friendly)

Below are practical tasks you’ll do repeatedly while viewing and managing Mint system partitions.

Find your root partition (/) and its UUID

1. Run: findmnt -n -o SOURCE /
2. Then get UUID: sudo blkid $(findmnt -n -o SOURCE /)

If findmnt isn’t available, use mount | grep ' on / ' to find the device, then run blkid <device>.

List all disks, partitions, mountpoints, and filesystem types

1. Run: lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS,UUID

This is the fastest way to reconcile what exists (partitions) with what’s active (mountpoints).

Unmount a partition safely

1. Find mountpoint/device mapping: findmnt or mount | grep <pattern>
2. Unmount: sudo umount /path/or/device
3. If it says “target is busy,” identify open files: sudo lsof +D /mountpoint (or use fuser -vm /mountpoint).

Mount a partition by UUID

1. Create mount point: sudo mkdir -p /mnt/target
2. Mount by UUID: sudo mount UUID=<uuid-here> /mnt/target
3. Verify: df -hT | grep /mnt/target

If you need specific options (like NTFS permissions), you can add -o flags, but do it carefully and match your intended behavior.

Change a filesystem label and verify it

1. See current label: sudo blkid /dev/nvme0n1p3
2. For ext4 label: sudo e2label /dev/nvme0n1p3 NEW_LABEL
3. Verify: sudo blkid /dev/nvme0n1p3

If your /etc/fstab uses LABEL=, update it to the new label.

Check and repair ext4

1. Identify the device for ext4 (from lsblk -f).
2. Unmount it if mounted.
3. Run: sudo fsck.ext4 -f -y /dev/nvme0n1p3

On a live system, use caution. If you’re repairing your root partition, do it from a live USB or recovery environment.

Check and repair NTFS (read/write caution)

NTFS repair options depend on the condition and what tools are installed. The common lightweight tool is ntfsfix, but it’s not a full replacement for advanced NTFS recovery.

1. Ensure you know the device: lsblk -f
2. Run (example): sudo ntfsfix /dev/sda1
3. After repair attempts, mount again and check behavior.

If data is valuable and NTFS is heavily damaged, stop and consider a dedicated recovery approach rather than repeated repairs.

FAQs

How do I tell which partition is my EFI partition in Linux Mint?

Look for a small vfat filesystem in lsblk -f. It may be mounted at /boot/efi. You can also check /etc/fstab for entries referencing boot/efi.

Should I use UUID or device names like /dev/sda1 in fstab?

Use UUIDs or labels in /etc/fstab. Device names like /dev/sda1 can change after hardware changes or reordering.

Why does GParted show a different layout than Disks?

Usually this is because you selected the wrong disk/device in one tool, or because one tool is reading partition metadata slightly differently. Confirm the device name first with lsblk.

Can I resize my home partition while using Linux Mint?

Typically, you can resize a mounted filesystem only if the tool supports it for that filesystem type and state. For fewer surprises, boot from a live USB and resize from there.

What’s the safest “first change” for beginners?

Start with mounting/unmounting, checking UUIDs, and reading /etc/fstab. Formatting and resizing should come only after you’ve identified the exact target partition and have a backup.

Bottom Line

To view and manage system partitions on Linux Mint in 2024, start with a reliable inventory using lsblk and blkid, then confirm mount behavior with df, mount, and /etc/fstab. GUI tools like Disks and GParted are great for visualization, but UUID-based verification prevents the most common mistakes.

When you’re ready to change anything destructive (resize/format), be strict about identifying the correct device, unmounting or using live sessions, and verifying your configuration afterward.

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.