Linux Storage Fundamentals on Linuxize

Block Devices, Partitions, and Filesystems in Linux Explained

hello@linuxize.com (Linuxize) — Sat, 15 Aug 2026 10:35:00 +0200

You attach a new disk to a server, run lsblk , and the drive is there. Then you try to copy a file onto it and nothing works, because there is no path to copy to. The disk is visible to the kernel, but it has no partition, no filesystem, and no place in the directory tree.

Linux storage is built from four layers stacked on top of each other, and most confusion comes from treating them as one thing. This guide explains what a block device, a partition, a filesystem, and a mount point each are, how they connect, and which command shows you the state of each layer.

What a Block Device Is

A block device is how the kernel represents a piece of storage that can be read and written in fixed-size chunks called blocks, rather than one byte at a time. Hard drives, SSDs, USB sticks, SD cards, and the virtual disks of a cloud instance are all block devices.

Every block device gets a file under /dev. The name depends on the driver that claims the hardware:

/dev/sda, /dev/sdb - SATA, SAS, and USB storage
/dev/nvme0n1 - the first namespace of the first NVMe drive
/dev/vda - a virtual disk on a KVM or cloud guest
/dev/mmcblk0 - an SD card or eMMC device

These files are not ordinary files. Running ls -l on one shows what they really are:

Terminal
ls -l /dev/sda /dev/null

output

brw-rw---- 1 root disk 8, 0 Aug 14 09:12 /dev/sda
crw-rw-rw- 1 root root 1, 3 Aug 14 09:12 /dev/null

The first character of the permission string is the giveaway. b marks a block device and c marks a character device such as /dev/null. The pair of numbers where a file size would normally appear, 8, 0, is the major and minor number that identifies the driver and the specific device it handles.

The kernel also publishes every block device under /sys/block, which is where tools such as lsblk read their information from. A block device at this stage is just an addressable range of storage. Nothing on it means anything yet.

Partitions Divide a Disk

A partition is a labeled region of a block device. The disk keeps a small table near its start that records where each region begins and ends, and the kernel exposes each region as its own block device: /dev/sda1, /dev/sda2, and so on. NVMe and SD devices insert a p before the number, so the first partition of /dev/nvme0n1 is /dev/nvme0n1p1.

Two partition table formats are in common use:

MBR (also called msdos) is the older format. It supports four primary partitions, works around that limit with extended partitions, and cannot address a disk larger than 2 TiB with standard 512-byte sectors.
GPT is the modern format. It commonly provides 128 partition entries, supports disks far larger than MBR, and stores a backup copy of the table at the end of the disk. UEFI firmware supports both GPT and legacy MBR, though GPT is the standard choice for current UEFI installations.

To see which format a disk uses, run fdisk with the -l flag:

Terminal
sudo fdisk -l /dev/sda

The output starts with the disk size and model, then prints a Disklabel type line that reads either gpt or dos, followed by the partition list.

Partitioning is a convention rather than a hard requirement. You can create a filesystem directly on a whole disk, and some storage appliances do exactly that. On a system that boots from the disk, though, partitions are what separate the EFI system partition, the boot files, and the root filesystem from each other.

A partition still holds no structure. It marks out space and stops there.

Filesystems Give a Partition Structure

A filesystem is the format written inside a partition that turns raw space into directories, filenames, permissions, and timestamps. Creating one is called formatting, and the mkfs family of commands does it:

Warning

Creating a filesystem destroys any existing filesystem and data on the target. Before running mkfs, confirm the device name with lsblk -f, verify that it is the intended empty partition, and make sure it is not mounted.

Terminal
sudo mkfs.ext4 /dev/sdb1

This writes ext4 metadata across /dev/sdb1, including the superblock, the inode tables, and the free-space maps. From that moment the partition can hold files, and each file gets an inode that stores its metadata.

Linux supports many filesystem types, and the choice matters:

ext4 - the default on most Debian and Ubuntu installations, stable and well understood
xfs - the default on RHEL and derivatives, strong with large files and parallel writes
btrfs - supports snapshots, checksums, and built-in volume management
vfat - used for EFI System Partitions and broadly compatible removable drives
exfat - suited to large removable drives shared with Windows and macOS
swap - not a filesystem for files at all, but a formatted area the kernel uses as swap space

Formatting also assigns the filesystem a UUID, and optionally a label. Both identify the filesystem itself rather than the device it happens to sit on. This distinction matters more than it first appears: device names are assigned in detection order, so a disk that is /dev/sdb today can come up as /dev/sdc after you add another drive or reboot a cloud instance. The UUID does not move. That is why configuration files should reference UUID= instead of /dev/sdb1.

Mount Points Attach a Filesystem to the Tree

Linux has no drive letters. Every filesystem on the machine appears somewhere inside a single tree that starts at /. A mount point is the directory where a filesystem is attached, and mounting is the act of attaching it. Create the mount point, then attach the filesystem:

Terminal
sudo mkdir -p /srv/data
sudo mount /dev/sdb1 /srv/data

The first command creates the directory if it does not already exist. After the second command, everything written under /srv/data lands on /dev/sdb1, while the rest of the tree stays on whatever filesystem holds /. The reader cannot tell from the path alone which disk a file lives on, which is the point of the design.

A mount point is an ordinary directory. There is no special flag that makes /srv/data mountable, and any empty directory works.

Info

If the directory already contains files when you mount over it, those files are hidden rather than deleted. They are still on the underlying filesystem and reappear once you unmount.

A manual mount command lasts until reboot. To make it persistent, the filesystem needs an entry in /etc/fstab , which the system reads at boot and mounts automatically.

Walking Through One Real Layout

Putting the four layers side by side makes the stack easier to read. The -o flag selects the columns, and adding TYPE shows what each row actually is:

Terminal
lsblk -o NAME,TYPE,FSTYPE,LABEL,MOUNTPOINTS

output

NAME TYPE FSTYPE LABEL MOUNTPOINTS
nvme0n1 disk
├─nvme0n1p1 part vfat /boot/efi
├─nvme0n1p2 part ext4 boot /boot
└─nvme0n1p3 part LVM2_member
├─vg0-root lvm ext4 root /
└─vg0-swap lvm swap [SWAP]
sdb disk
└─sdb1 part xfs data /srv/data

Read it from the outside in. nvme0n1 and sdb have TYPE of disk and no filesystem of their own, because they are the block devices. The indented rows marked part are partitions. The FSTYPE column tells you which of those partitions were formatted, and with what. The MOUNTPOINTS column tells you where each formatted filesystem was attached.

nvme0n1p3 shows all four layers coming apart cleanly. It is a partition, it has a format, but that format is LVM2_member rather than a filesystem you can browse, and it has no mount point. Its two children are the layer that carries the actual filesystems.

The sdb disk is the simple case: one disk, one partition, one XFS filesystem labeled data, mounted at /srv/data.

Where LVM, RAID, and Encryption Fit

The four layers describe the common path, but Linux lets you insert extra layers between the partition and the filesystem. Each one consumes a block device and produces a new one.

LVM groups one or more physical volumes into a volume group, then carves logical volumes out of it. The logical volume is a block device at /dev/mapper/vg0-root, and you format that instead of the partition. Logical volumes can be resized and moved between disks without repartitioning, which is why servers so often use them.

Software RAID combines several devices into one /dev/md0 device with mirroring or striping across the members. The filesystem sits on /dev/md0 and never sees the individual disks.

LUKS encryption wraps a device in an encrypted container. Unlocking it produces a decrypted block device under /dev/mapper, and the filesystem goes there. lsblk shows the container with TYPE of crypt.

These stack in any sensible order, and a common server layout runs all of them at once: partition, then LUKS, then LVM, then ext4. Each layer only needs to know about the block device directly beneath it.

Quick Reference

Layer	What it is	Typical name	Inspect with
Block device	Raw addressable storage exposed by the kernel	`/dev/sda`, `/dev/nvme0n1`	`lsblk -d`, `ls -l /dev/sd*`
Partition	A labeled region of a block device	`/dev/sda1`, `/dev/nvme0n1p1`	`sudo fdisk -l`, `lsblk`
Filesystem	The format written inside a partition	ext4, xfs, btrfs, vfat	`lsblk -f`, `blkid`
Mount point	The directory where a filesystem is attached	`/`, `/boot`, `/srv/data`	`findmnt`, `df -h`

FAQ

What is the difference between a partition and a filesystem?
A partition reserves a region of a disk and records its boundaries in the partition table. A filesystem is the structure written inside that region so it can store files. A freshly created partition has no filesystem, which is why mkfs is a separate step after fdisk or parted.

Is /dev/sda a file or a device?
Both, in a sense. /dev/sda is a special file that acts as the interface to the device, so tools can open, read, and write it with ordinary file operations. The leading b in ls -l output marks it as a block device rather than a regular file.

Why does my disk name change between reboots?
Kernel device names are assigned in detection order, not fixed to the hardware. Adding a drive or rebooting a virtual machine can shift /dev/sdb to /dev/sdc. Refer to filesystems by UUID= or LABEL= in /etc/fstab and scripts so the reference survives reordering.

How do I tell which disk a directory lives on?
Pass the path to findmnt --target, for example findmnt --target /srv/data, and it prints the source device, filesystem type, and mount options for the filesystem containing that path. Running df -h /srv/data shows the source device, capacity, usage, and mount point instead.

Can I create a filesystem without partitioning first?
Yes. Running mkfs.ext4 /dev/sdb creates an ext4 filesystem directly on the whole disk with no partition table. Filesystem-aware tools such as lsblk -f and blkid still detect it, while partitioning tools report that no partition table is present. This is destructive and should only be done intentionally on a verified empty data disk. Use partitions for boot disks and workflows that expect a partition table.

Conclusion

Once you can name which layer a problem sits on, the next check becomes clearer: a missing device is a kernel or cabling question, an unknown partition or filesystem needs inspection before you change it, and a known unmounted filesystem calls for mount. Start with lsblk -f on any unfamiliar machine, since it shows three of the four layers in a single screen.

lsblk Command in Linux: List Block Devices

hello@linuxize.com (Linuxize) — Thu, 13 Aug 2026 11:20:00 +0200

When you plug in a new drive, set up a fresh partition, or try to remember which disk is mounted where, you need a quick way to see every block device attached to the system. The lsblk command reads information from sysfs and the udev database and prints a tidy tree of disks, partitions, loop devices, and LVM volumes, together with their sizes and mount points.

This guide explains how to use lsblk to inspect block devices, pick the columns you need, and format the output for scripts.

lsblk Syntax

The general form of the command is:

txt
lsblk [OPTIONS] [DEVICE...]

With no arguments, lsblk lists every block device except RAM disks and empty devices. You can pass one or more device paths to limit the output, for example lsblk /dev/sda.

Unlike fdisk , lsblk does not need root privileges for most queries, which makes it safer for quick checks.

Basic Usage

Run lsblk with no options to see a tree of all devices on the system:

Terminal
lsblk

output

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
sda 8:0 0 465.8G 0 disk
├─sda1 8:1 0 512M 0 part /boot/efi
├─sda2 8:2 0 16G 0 part [SWAP]
└─sda3 8:3 0 449.3G 0 part /
sdb 8:16 1 14.3G 0 disk
└─sdb1 8:17 1 14.3G 0 part /media/john/usb
sr0 11:0 1 1024M 0 rom

Each row describes one device. The tree characters on the left show which partitions belong to which disk. The TYPE column tells you whether the entry is a whole disk, a partition, an optical rom, an LVM lvm volume, a crypt container, and so on. The MOUNTPOINTS column is empty when the partition is not mounted.

The RM column is 1 when the kernel marks a device as removable, and RO is 1 for read-only devices. Some USB drives report RM as 0, so use the TRAN column when you specifically need to identify USB storage.

Hide Partitions and Child Devices

When you only care about top-level devices, pass the -d (or --nodeps) flag to hide their partitions, holders, and slaves:

Terminal
lsblk -d

output

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
sda 8:0 0 465.8G 0 disk
sdb 8:16 1 14.3G 0 disk
sr0 11:0 1 1024M 0 rom

This is handy when you do not want partition noise. It does not filter by device type, so entries such as the sr0 optical drive can still appear.

Snap packages mount as loop devices, so on an Ubuntu desktop the list can fill with loop0 through loop20 before you reach the real disks. Exclude them by major number with -e (or --exclude):

Terminal
lsblk -e 7

Major number 7 is the loop driver. You can pass several numbers as a comma-separated list, for example lsblk -e 7,11 to drop optical drives as well.

Show Filesystem Information

Passing -f (or --fs) replaces the default columns with filesystem details such as the type, label, UUID, and how full each mounted filesystem is:

Terminal
lsblk -f

output

NAME FSTYPE FSVER LABEL UUID FSAVAIL FSUSE% MOUNTPOINTS
sda
├─sda1 vfat FAT32 4F3A-91BC 470.1M 8% /boot/efi
├─sda2 swap 1 9f4b5a44-6d1e-44a8-a0ae-2c3d3e4f1234 [SWAP]
└─sda3 ext4 1.0 root be2e1f8e-7a0b-4ab1-9f1d-5c6d7e8f9012 312.5G 25% /
sdb
└─sdb1 vfat FAT32 USB 1A2B-3C4D 12.8G 10% /media/john/usb

This is usually the fastest way to find a UUID for /etc/fstab or to confirm which filesystem type sits on a given partition.

Pick Specific Columns

The default columns cover the common cases, but you can choose exactly what to show with the -o (or --output) option. Pass a comma-separated list of column names:

Terminal
lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS

output

NAME SIZE TYPE MOUNTPOINTS
sda 465.8G disk
├─sda1 512M part /boot/efi
├─sda2 16G part [SWAP]
└─sda3 449.3G part /
sdb 14.3G disk
└─sdb1 14.3G part /media/john/usb
sr0 1024M rom

To see the full list of columns lsblk understands, run:

Terminal
lsblk --list-columns

On util-linux versions older than 2.41, that option does not exist yet, and lsblk --help prints the column list instead.

Useful columns include UUID, LABEL, MODEL, SERIAL, VENDOR, FSTYPE, PARTTYPE, HOTPLUG, and TRAN (transport, for example sata, nvme, or usb).

To add columns to the default set rather than replace it, prefix the list with +. For example, this command adds the model and serial number:

Terminal
lsblk -o +MODEL,SERIAL

The -O (or --output-all) flag has a different purpose: it displays every available column.

Show Device Paths

By default, lsblk prints short names such as sda1. If you want the full /dev path in the NAME column, add -p (or --paths):

Terminal
lsblk -p

output

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
/dev/sda 8:0 0 465.8G 0 disk
├─/dev/sda1 8:1 0 512M 0 part /boot/efi
├─/dev/sda2 8:2 0 16G 0 part [SWAP]
└─/dev/sda3 8:3 0 449.3G 0 part /

Full paths are easier to copy into a script or a mount command.

List a Single Device

You can pass a device path to inspect only that device and its partitions:

Terminal
lsblk /dev/sda

This narrows the output to one disk, which is useful on servers with many drives.

Flat and ASCII Output

The tree layout is readable in a terminal but awkward to parse in scripts. Use -l (or --list) to print one device per line with no tree characters:

Terminal
lsblk -l

output

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
sda 8:0 0 465.8G 0 disk
sda1 8:1 0 512M 0 part /boot/efi
sda2 8:2 0 16G 0 part [SWAP]
sda3 8:3 0 449.3G 0 part /

If your terminal does not render Unicode box-drawing characters correctly, swap them for plain ASCII with -i (or --ascii).

Machine-Readable Output

For scripts, the -J (or --json) flag prints the same information as structured JSON that is easy to parse with tools such as jq:

Terminal
lsblk -J -o NAME,SIZE,FSTYPE /dev/sda

output

{
"blockdevices": [
{
"name": "sda",
"size": "465.8G",
"fstype": null,
"children": [
{
"name": "sda1",
"size": "512M",
"fstype": "vfat"
},
{
"name": "sda2",
"size": "16G",
"fstype": "swap"
},
{
"name": "sda3",
"size": "449.3G",
"fstype": "ext4"
}
]
}
]
}

Each disk becomes an object, and its partitions appear in the children array, so the tree relationship survives the conversion. Fields that do not apply are null rather than empty strings, which keeps the types stable for jq.

You can also use -P (pairs) for line-oriented KEY="value" output, or -r (raw) for space-separated fields with no padding.

The default columns can change between util-linux releases. In scripts, always select the columns you expect with -o, then choose a predictable format such as -J, -P, or -l.

For example, to list only mounted ext4 partitions in a script:

Terminal
lsblk -lnp -o NAME,FSTYPE,MOUNTPOINTS | awk '$2 == "ext4" && $3 != "" {print $1, $3}'

The -n (or --noheadings) flag drops the header row so that the output is pure data.

Show Sizes in Bytes

Sizes are printed in human-readable units by default, for example 465.8G. For exact values, use -b (or --bytes):

Terminal
lsblk -b -o NAME,SIZE

This is the form you want when comparing sizes in a script, since 465.8G is not directly comparable with 449.3G as a string.

Quick Reference

Common lsblk flags and what they do:

-a - Include empty devices and RAM disks that are normally hidden.
-b - Print sizes in bytes instead of human-readable units.
-d - Hide partitions, holders, and slaves.
-e LIST - Exclude devices by major number (7 is loop).
-f - Show filesystem information (type, label, UUID, usage).
-i - Use plain ASCII characters for the tree instead of Unicode.
-J - Output as JSON.
-l - Use a flat list instead of the tree layout.
-n - Omit the header row.
-o LIST - Choose which columns to display.
-o +LIST - Add columns to the default output.
-O - Display every available column.
-p - Print full device paths such as /dev/sda1.
-P - Output as KEY="value" pairs for shell scripts.
-r - Raw output with no padding.
-S - Show information about SCSI devices only.
-t - Print topology information (alignment, I/O sizes).

FAQ

How is lsblk different from fdisk -l?
lsblk reads from sysfs and udev and shows a tree of devices with mount points and filesystem details, all without root privileges for the common cases. fdisk -l reads the partition table directly from the device and focuses on partition layout, sector offsets, and disk identifiers. Use lsblk for a quick overview and fdisk when you care about the raw partition table.

Why is a device missing from lsblk output?
Run lsblk -a to include empty devices and RAM disks that are normally hidden. If you just connected or changed a device, run udevadm settle before trying lsblk again so udev can finish processing the event. A drive that the kernel never detected cannot appear in the list; check the cable or port and inspect recent messages with sudo dmesg | tail -n 30.

How can I get only the UUID of a partition?
Combine -n to drop the header, -o UUID to pick the column, and the device path:
lsblk -no UUID /dev/sda3.

Does lsblk show LVM and encrypted volumes?
Yes. LVM logical volumes appear as children of their physical volume with type lvm, and LUKS-encrypted containers show as crypt. The tree layout makes the stacking relationship easy to follow.

Can lsblk show disk model or serial number?
Yes. Add them to the output list: lsblk -o NAME,MODEL,SERIAL,SIZE. Some virtual devices do not expose these fields, so they may be empty.

Conclusion

lsblk is the fastest way to answer the “what disks and partitions does this machine have?” question, and its JSON and column-selection options make it equally useful inside scripts. Pair it with df for usage stats and with mount when you are ready to attach a new device.

What Is an Inode in Linux

hello@linuxize.com (Linuxize) — Sun, 19 Jul 2026 09:35:00 +0200

Running out of disk space normally means that a filesystem has no free bytes left. Sometimes, however, a command fails with “No space left on device” while df -h still shows available space. One possible cause is inode exhaustion: the filesystem can store more data, but it has no free metadata records for new files.

To understand why this happens, and why filenames and file contents are stored separately, you need to know what an inode is. This guide explains what an inode stores, how it relates to filenames and hard links, and how to check inode usage.

What an Inode Is

An inode (short for “index node”) is a data structure that a Unix-style filesystem uses to store metadata about a file or directory. Each file has an inode number that identifies it within that filesystem. The same number can appear on another filesystem, so an inode number is not unique across the entire system.

The inode holds almost everything the system needs to know about the file, except for its name and, in the usual case, the data itself. It records:

The file type, such as a regular file, directory, or symbolic link
The permissions and owner and group IDs
The file size and allocated blocks
The access, data modification, and status change timestamps
The hard-link count, which is the number of directory entries pointing to the file
The block map or extents that locate the file’s data

The exact on-disk format depends on the filesystem, but these fields are the ones you see through tools such as ls and stat.

Filenames Are Separate from Inodes

The detail that surprises many users is that the filename is not stored in the inode. A directory contains entries that map names to inode numbers. When you open report.txt, the system looks up that name in the directory, finds the inode number, reads the inode, and locates the file’s data.

This separation is what makes hard links possible. A hard link is another directory entry that points to the same inode. Both names are equal, and removing one name only decreases the inode’s link count. The filesystem releases the file’s storage after the last link is removed and no process still has the file open.

For a practical comparison of the two link types, see hard links vs symbolic links .

Viewing Inode Numbers

To see the inode number of a file, use the -i option with ls:

Terminal
ls -i report.txt

output

1310720 report.txt

The first column, 1310720, is the inode number. To list inode numbers for everything in a directory, run ls -li, which adds the inode number as the leftmost column of the long listing.

To display the metadata associated with the inode, use the stat command:

Terminal
stat report.txt

output

 File: report.txt
Size: 482 Blocks: 8 IO Block: 4096 regular file
Device: 8,1 Inode: 1310720 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 1000/ linuxize) Gid: ( 1000/ linuxize)
Access: 2026-01-01 14:02:11.000000000 +0100
Modify: 2026-01-01 13:55:40.000000000 +0100
Change: 2026-01-01 13:55:40.000000000 +0100
Birth: 2026-01-01 13:55:40.000000000 +0100

The Inode field shows the inode number, and Links shows the hard-link count. Change is the status change time, commonly called ctime. It changes when inode metadata such as permissions, ownership, or the link count changes. It is not the file creation time. The separate Birth field shows creation time when the filesystem supports it.

The filename appears at the top because you passed it to stat; it is not part of the inode.

How Filesystems Allocate Inodes

Inode allocation depends on the filesystem. Ext2, ext3, and ext4 create inode tables when the filesystem is formatted. This gives the filesystem a fixed inode density, so a workload that creates millions of small files can use every inode before it uses every data block.

You cannot change the inode density of an existing ext4 filesystem in place. Growing the filesystem can add block groups and more inodes, but if the filesystem cannot be expanded, the practical options are to remove unneeded files, move the workload, or recreate the filesystem with a higher inode count.

XFS and Btrfs allocate inodes dynamically from available filesystem space instead of creating one fixed inode table at format time. They can still reject new files when the filesystem runs out of usable data or metadata space, but they do not have the same fixed inode-count limit as ext4.

Checking Inode Usage

To see how many inodes the filesystem containing /var has and how many are free, pass the path to df with the -i option:

Terminal
df -i /var

output

Filesystem Inodes IUsed IFree IUse% Mounted on
/dev/sdb1 655360 655360 0 100% /var

The IUse% column is the one to watch. Here, inode usage on /var is at 100 percent even though the byte-based df -h /var might still report free space. The filesystem cannot create another file until an inode becomes available.

A large cache, session directory, mail queue, or temporary directory is a common source of inode exhaustion. GNU du can count inodes instead of bytes. The following command stays on the /var filesystem, checks two directory levels, and displays the largest totals at the bottom:

Terminal
sudo du --inodes -x -d 2 /var 2>/dev/null |
 sort -n |
 tail -20

Repeat the command on the directory with the highest count and increase the depth if needed. For other counting methods, see the guide on counting files in a directory .

Warning

Do not remove files only because a directory has a high inode count. First identify which application owns the files and use its cleanup or retention policy when one is available.

After cleanup, run df -i /var again to confirm that free inodes are available.

Conclusion

An inode connects a file’s metadata to its stored data while the directory keeps the filename separately. When a filesystem reports “No space left on device” despite having free bytes, check the affected path with df -i before deciding what to remove.

stat Command in Linux: Display File and Filesystem Information

hello@linuxize.com (Linuxize) — Wed, 06 Nov 2019 21:21:47 +0100

stat is a command-line utility that displays detailed information about given files or file systems.

This article explains how to use the stat command.

stat Command Syntax

The syntax for the stat command is as follows:

txt
stat [OPTION]... FILE...

stat accepts one or more input FILE names and includes a number of options that control the command behavior and output.

Displaying File Information

Here is an example of running stat on a regular file:

Terminal
stat file.txt

The output will look something like this:

output

 File: file.txt
Size: 4030 Blocks: 8 IO Block: 4096 regular file
Device: 801h/2049d Inode: 13633379 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 1000/ linuxize) Gid: ( 1000/ linuxize)
Access: 2019-11-06 09:52:17.991979701 +0100
Modify: 2019-11-06 09:52:17.971979713 +0100
Change: 2019-11-06 09:52:17.971979713 +0100
Birth: -

When invoked without any options, stat displays the following file information:

File — The name of the file.
Size — The size of the file in bytes.
Blocks — The number of allocated blocks the file takes.
IO Block — The size in bytes of every block.
File type — For example: regular file, directory, or symbolic link.
Device — Device number in hex and decimal.
Inode — The inode number.
Links — Number of hard links.
Access — File permissions in numeric and symbolic form.
Uid — User ID and name of the owner .
Gid — Group ID and name of the owning group.
Context — The SELinux security context (shown only on SELinux-enabled systems).
Access — The last time the file was accessed.
Modify — The last time the file’s content was modified.
Change — The last time the file’s attributes or content changed.
Birth — File creation time. Supported on Linux kernel 4.11 and later on filesystems that record it (ext4, btrfs, xfs). Shows - when the filesystem does not store birth time.

To learn more about file timestamps and how to update them, see the touch command guide .

Displaying Filesystem Information

To get information about the filesystem where the given file resides, instead of information about the file itself, use the -f (--file-system) option:

Terminal
stat -f file.txt

The output of the command will look like this:

output

 File: "package.json"
ID: 8eb53097b4494d20 Namelen: 255 Type: ext2/ext3
Block size: 4096 Fundamental block size: 4096
Blocks: Total: 61271111 Free: 25395668 Available: 22265851
Inodes: Total: 15630336 Free: 13979610

When stat is invoked with the -f option, it shows the following information:

File — The name of the file.
ID — Filesystem ID in hex.
Namelen — Maximum length of file names.
Fundamental block size — The size of each block on the filesystem.
Blocks:
- Total — Number of total blocks in the filesystem.
- Free — Number of free blocks in the filesystem.
- Available — Number of free blocks available to non-root users.
Inodes:
- Total — Number of total inodes in the filesystem.
- Free — Number of free inodes in the filesystem.

Dereference (Follow) Symlinks

By default, stat does not follow symlinks . If you run the command on a symlink, the output will include information about the symlink, not the file it points to:

Terminal
stat /etc/resolv.conf

output

 File: /etc/resolv.conf -> ../run/systemd/resolve/stub-resolv.conf
Size: 39 Blocks: 0 IO Block: 4096 symbolic link
Device: 801h/2049d Inode: 8126659 Links: 1
Access: (0777/lrwxrwxrwx) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2019-11-06 21:12:26.875956073 +0100
Modify: 2018-07-24 11:11:48.128794519 +0200
Change: 2018-07-24 11:11:48.128794519 +0200
Birth: -

To dereference (follow) the symlink and display information about the file it points to, use the -L (--dereference) option:

Terminal
stat -L /etc/resolv.conf

output

 File: /etc/resolv.conf
Size: 715 Blocks: 8 IO Block: 4096 regular file
Device: 17h/23d Inode: 989 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 101/systemd-resolve) Gid: ( 103/systemd-resolve)
Access: 2019-11-06 20:35:25.603689619 +0100
Modify: 2019-11-06 20:35:25.555689733 +0100
Change: 2019-11-06 20:35:25.555689733 +0100
Birth: -

Customizing the Output

The stat command has two options that allow you to customize the output: -c (--format="format") and --printf="format".

The difference between these two options is that when two or more files are used as operands, --format automatically adds a newline after each file’s output, while --printf interprets backslash escapes.

Here are the most commonly used format directives:

Directive	Description
`%n`	File name
`%s`	Total size in bytes
`%b`	Number of blocks allocated
`%A`	Permissions in human-readable form
`%a`	Permissions in octal
`%U`	User name of owner
`%G`	Group name of owner
`%i`	Inode number
`%F`	File type
`%y`	Time of last modification (human-readable)
`%x`	Time of last access (human-readable)
`%z`	Time of last status change (human-readable)
`%w`	Time of file birth (human-readable)

For example, to view only the type of the file, you would run:

Terminal
stat --format="%F" /dev/null

output

character special file

You can combine any number of format directives and optionally use custom separators:

Terminal
stat --format="%n,%F" /dev/null

output

/dev/null,character special file

To interpret special characters like newline or tab, use the --printf option:

Terminal
stat --printf='Name: %n\nPermissions: %a\n' /etc

\n prints a new line:

output

Name: /etc
Permissions: 755

The stat command can also display information in terse form, which is useful for parsing by other utilities. Use the -t (--terse) option:

Terminal
stat -t /etc

output

/etc 12288 24 41ed 0 0 801 8126465 147 0 0 1573068933 1573068927 1573068927 0 4096

For a complete list of all format directives, run man stat or stat --help.

Info

This guide uses GNU stat syntax on Linux. On BSD/macOS systems, stat uses different flags and format options.

Quick Reference

Command	Description
`stat file`	Display file information
`stat -f file`	Display filesystem information
`stat -L file`	Follow symlinks
`stat -t file`	Terse output for parsing
`stat --format="%F" file`	Show file type only
`stat --format="%s" file`	Show file size in bytes
`stat --format="%A %U %n" file`	Show permissions, owner, and name
`stat --printf='%n\t%s\n' file`	Custom output with tab separator

Troubleshooting

Birth time shows -
The filesystem does not record creation time, or the kernel is older than 4.11. Birth time is stored on ext4, btrfs, xfs, and tmpfs. Check your filesystem type with df -T /path.

Context field is missing from output
The Context (SELinux) field only appears on SELinux-enabled systems. On standard Ubuntu or Debian systems it will not be shown.

Output fields differ between systems
The exact output depends on the kernel version, filesystem type, and whether SELinux is active. Fields like Birth and Context may not appear on all systems.

FAQ

What is the difference between stat and ls?
ls shows a summary of file information suitable for listing directories. stat shows the complete low-level metadata for a single file, including inode number, block count, and all three timestamps.

How do I show only the file size with stat?
Use stat --format="%s" filename. This prints the size in bytes. To get a human-readable size, use du -sh instead.

Why does the Birth time show -?
The filesystem does not store creation time. Filesystems such as ext4, btrfs, and xfs do record birth time on Linux kernel 4.11 and later. Older filesystems like ext2/ext3 do not support it.

How do I use stat in a script to get a file’s permissions?
Use stat --format="%a" filename for octal permissions or stat --format="%A" filename for the symbolic form. These are easy to assign to a variable: perms=$(stat --format="%a" file).

What is the difference between Modify time and Change time?
Modify time (mtime) changes when the file’s content is written. Change time (ctime) changes when content or metadata (permissions, ownership, links) changes. See the touch command guide for how to update these timestamps.

Conclusion

The stat command prints detailed information about given files and file systems. In Linux, several other commands can display file information, with ls being the most used one, but it shows only a subset of the information provided by stat. For filesystem usage summaries, see the df command guide .

If you have any questions or feedback, feel free to leave a comment below.

df Command in Linux: Check Disk Space Usage

hello@linuxize.com (Linuxize) — Sat, 09 Feb 2019 21:31:47 +0100

When you need to investigate a disk-full alert, check available space before a deployment, or verify inode usage, the df command is usually the first tool to run.

The df command (short for disk free) reports how much disk space is used and available on mounted filesystems. It is one of the essential tools for monitoring storage on Linux systems.

This guide explains how to use the df command with practical examples covering all common options.

df Command Syntax

The general syntax for the df command is:

txt
df [OPTIONS] [FILESYSTEM...]

When used without any arguments, df displays information about all mounted filesystems :

Terminal
df

output

Filesystem 1K-blocks Used Available Use% Mounted on
dev 8172848 0 8172848 0% /dev
run 8218640 1696 8216944 1% /run
/dev/nvme0n1p3 222284728 183057872 27865672 87% /
tmpfs 8218640 150256 8068384 2% /dev/shm
tmpfs 8218640 0 8218640 0% /sys/fs/cgroup
tmpfs 8218640 24 8218616 1% /tmp
/dev/nvme0n1p1 523248 107912 415336 21% /boot
/dev/sda1 480588496 172832632 283320260 38% /data
tmpfs 1643728 40 1643688 1% /run/user/1000

Each line includes the following columns:

Filesystem - The name of the filesystem.
1K-blocks - The total size of the filesystem in 1K blocks.
Used - The used space in 1K blocks.
Available - The available space in 1K blocks.
Use% - The percentage of used space.
Mounted on - The directory on which the filesystem is mounted.

To display information for a specific filesystem, pass its name or mount point to the df command:

Terminal
df /

output

Filesystem 1K-blocks Used Available Use% Mounted on
/dev/nvme0n1p3 222284728 183057872 27865672 87% /

Human-Readable Output

By default, df shows sizes in 1K blocks. To display sizes in a human-readable format (KB, MB, GB), use the -h option:

Terminal
df -h

output

Filesystem Size Used Avail Use% Mounted on
dev 7.8G 0 7.8G 0% /dev
run 7.9G 1.8M 7.9G 1% /run
/dev/nvme0n1p3 212G 176G 27G 88% /
tmpfs 7.9G 145M 7.7G 2% /dev/shm
tmpfs 7.9G 0 7.9G 0% /sys/fs/cgroup
tmpfs 7.9G 24K 7.9G 1% /tmp
/dev/nvme0n1p1 511M 106M 406M 21% /boot
/dev/sda1 459G 165G 271G 38% /data
tmpfs 1.6G 16K 1.6G 1% /run/user/1000

This is the most commonly used form of the df command.

Display Filesystem Types

The -T option adds a “Type” column showing the filesystem type of each partition:

Terminal
df -Th

output

Filesystem Type Size Used Avail Use% Mounted on
dev devtmpfs 7.8G 0 7.8G 0% /dev
run tmpfs 7.9G 1.8M 7.9G 1% /run
/dev/nvme0n1p3 ext4 212G 176G 27G 88% /
tmpfs tmpfs 7.9G 145M 7.7G 2% /dev/shm
/dev/nvme0n1p1 vfat 511M 106M 406M 21% /boot
/dev/sda1 ext4 459G 165G 271G 38% /data

Filter by Filesystem Type

To show only filesystems of a specific type, use the -t option followed by the type name. For example, to list only ext4 partitions:

Terminal
df -h -t ext4

output

Filesystem Size Used Avail Use% Mounted on
/dev/nvme0n1p3 212G 176G 27G 88% /
/dev/sda1 459G 165G 271G 38% /data

To exclude a specific filesystem type, use the -x option. The following command hides all tmpfs filesystems:

Terminal
df -h -x tmpfs

output

Filesystem Size Used Avail Use% Mounted on
dev 7.8G 0 7.8G 0% /dev
/dev/nvme0n1p3 212G 176G 27G 88% /
/dev/nvme0n1p1 511M 106M 406M 21% /boot
/dev/sda1 459G 165G 271G 38% /data

Excluding tmpfs is useful when you want to focus on physical disks and partitions.

Display Total Disk Space

The --total option appends a row at the bottom that sums all filesystems:

Terminal
df -h --total

The last line of the output shows the total size, used space, and available space across all mounted filesystems.

Display Inode Usage

An inode is a data structure in Linux filesystems that stores metadata about a file or directory, such as its size, owner, permissions, and timestamps. Each file uses one inode, and a filesystem has a fixed number of inodes.

To display inode usage instead of block usage, use the -i option:

Terminal
df -ih /

output

Filesystem Inodes IUsed IFree IUse% Mounted on
/dev/nvme0n1p3 14M 1.9M 12M 14% /

The output includes the following columns:

Inodes - The total number of inodes on the filesystem.
IUsed - The number of used inodes.
IFree - The number of free (unused) inodes.
IUse% - The percentage of used inodes.

Running out of inodes prevents creating new files even if disk space is available. This can happen on filesystems with many small files. Our guide on what an inode is covers how to track down the directories consuming them.

Custom Output Format

The --output option lets you select which columns to display. Specify a comma-separated list of field names:

Terminal
df -h -t ext4 --output=source,size,used,avail,pcent

output

Filesystem Size Used Avail Use%
/dev/nvme0n1p3 212G 176G 27G 88%
/dev/sda1 459G 165G 271G 38%

The available field names are:

source - The filesystem source.
fstype - The filesystem type.
file - The file name when a file argument is supplied.
size - Total disk space.
used - Used disk space.
avail - Available disk space.
pcent - Percentage of used space.
itotal - Total number of inodes.
iused - Number of used inodes.
iavail - Number of available inodes.
ipcent - Percentage of used inodes.
target - The mount point.

POSIX Output for Scripts

When parsing df output in a shell script, the default format can wrap long device names onto two lines, which breaks tools like awk. The -P (--portability) option forces one line per filesystem:

Terminal
df -P /

output

Filesystem 1024-blocks Used Available Capacity Mounted on
/dev/nvme0n1p3 222284728 183057872 27865672 87% /

For example, to extract the used percentage for the root filesystem:

Terminal
df -P / | awk 'NR==2 {print $5}'

output

88%

Add --sync to force a filesystem sync before reading, which gives more accurate results immediately after large writes.

df vs du

df reports usage at the filesystem level by reading filesystem metadata. The du command walks a directory tree and sums the sizes of visible files.

The two often disagree. When df shows a disk as full but du reports less, a process is usually holding a deleted file open. Find those files with:

Terminal
sudo lsof +L1

Restart or stop the owning process to release the space.

Quick Reference

For a printable quick reference, see the df cheatsheet .

Command	Description
`df`	Show all mounted filesystems
`df /`	Show a specific filesystem
`df -h`	Human-readable sizes (KB, MB, GB)
`df -T`	Show filesystem types
`df -t ext4`	Show only ext4 filesystems
`df -x tmpfs`	Exclude tmpfs filesystems
`df -h --total`	Show total across all filesystems
`df -i`	Show inode usage
`df -ih /`	Inode usage in human-readable format
`df --output=source,size,pcent`	Custom output columns
`df -P /`	POSIX one-line output for scripts
`df --sync -h`	Force sync before reading sizes

Troubleshooting

df: no file systems processed
This usually means the provided path is invalid or no longer mounted. Verify the path with ls and check active mounts with mount or findmnt.

df and du show different usage values
df reports filesystem-level usage, while du reports visible files in directories. The difference is often caused by deleted files that are still open or filesystem metadata usage.

Disk appears full but no large files are visible
A process may still hold a deleted file open. List deleted-but-open files with sudo lsof +L1, then restart or stop the relevant process to release the space.

Inodes are at 100 percent but space is still available
The filesystem has too many small files. Check with df -ih, then locate high file-count paths with find and clean or archive old files.

FAQ

What is the difference between df and du?
df reports free and used space on entire filesystems. The du command reports the disk space used by individual files and directories. Use df for an overview and du to find what is consuming space.

Why does df show less available space than expected?
Most Linux filesystems reserve a percentage of space (usually 5%) for the root user. This reserved space is not counted as “available” for regular users. You can adjust it with tune2fs -m.

Why does df show a disk is full but du shows less usage?
This can happen when deleted files are still held open by running processes. The space is not released until the process closes the file. Use sudo lsof +L1 to find deleted files that are still open.

What does it mean when inodes are full?
When a filesystem runs out of inodes, you cannot create new files even if disk space is available. This typically happens on filesystems with a large number of very small files. You can check inode usage with df -ih.

How do I check disk space on a remote server?
Connect via SSH and run df -h. You can also run it directly with ssh user@host df -h without opening an interactive session.

Conclusion

The df command is essential for monitoring disk space on Linux systems. Use df -h for a quick human-readable overview, -T to see filesystem types, -i to check inode usage, and --total for a combined summary. When filesystem totals do not match visible directory usage, compare the results with du and check for deleted files still held open by running processes.

du Command in Linux: Check Disk Usage

hello@linuxize.com (Linuxize) — Wed, 07 Aug 2019 21:55:47 +0100

When a disk fills up, the first question is always the same: what is taking up all the space? The du command, short for “disk usage,” answers that question. It reports the estimated amount of disk space used by files and directories, so you can track down the largest offenders and free up room.

This guide explains how to use the du command, covers its most common options such as -s and -h, and shows practical examples for checking disk usage on a Linux system.

du Command Syntax

The general syntax for the du command is as follows:

txt
du [OPTION]... [FILE]...

If the given FILE is a directory, du will report disk usage for that directory and its subdirectories. If no FILE is specified, du will report the disk usage of the current working directory .

How to Use the du Command

When executed without any option, du displays the disk usage of the given file or directory and each of its subdirectories in filesystem blocks.

Terminal
du ~/Documents

You can also pass multiple files and directories to the du command as arguments:

Terminal
du ~/Documents ~/Pictures ~/.zshrc

If you run du on a file or directory for which you do not have permissions, you will get something like “du: cannot read directory”. In this situation, you will need to prepend the command with sudo .

du has many options. The following sections cover the most frequently used ones.

Display Disk Usage in Human-Readable Format

By default, du reports sizes in filesystem blocks, which are hard to read at a glance. The -h (--human-readable) option prints sizes in units such as K, M, and G.

For example, to get the size of /var and all of its subdirectories in a human-readable format, run:

Terminal
sudo du -h /var

We are using sudo because most of the files and directories inside the /var directory are owned by the root user and are not readable by regular users. The output will look something like this:

output

...
4.0K /var/lib/apt/mirrors/partial
8.0K /var/lib/apt/mirrors
205M /var/lib/apt
2.9G /var/lib/

Show the Total Size of a Directory

By default, du prints a line for every subdirectory. To report only the total size of the specified directory, and not each subdirectory, use the -s (--summarize) option. Combined with -h, the du -sh command is one of the most common ways to check how much space a directory uses:

Terminal
sudo du -sh /var

output

2.9G /var

This tells you that /var uses 2.9G in total, without listing every subdirectory inside it.

Show the Size of Every File

The -a (--all) option tells du to report the disk space usage of each file within the directory, not only the directories.

Terminal
du -a ~/Documents

Display a Grand Total

The -c (--total) option tells du to report a grand total. This is useful when you want to get the combined size of two or more directories.

Terminal
sudo du -csh /var/log /var/lib

output

1.2G /var/log
2.9G /var/lib
4.1G total

Limit the Directory Depth

If you want to display the disk usage of n-level subdirectories, use the --max-depth option and specify the subdirectory level. For example, to get a report about the first-level directories you would use:

Terminal
sudo du -h --max-depth=1 /var/lib

output

...
544K /var/lib/usbutils
4.0K /var/lib/acpi-support
205M /var/lib/apt
2.9G /var/lib

Show the Apparent Size

The default behavior of the du utility is to report the disk space used by the directory or file. To find the apparent size of a file, use the --apparent-size switch. The “apparent size” of a file is how much data is actually in the file.

Terminal
sudo du -sh --apparent-size /var/lib

output

2.9G /var/lib

Use Shell Patterns with du

du also allows you to use shell patterns. For example, to get the size of all directories starting with “Do” in your home directory you would run:

Terminal
sudo du -csh ~/Do*

output

102M /home/linuxize/Documents
358M /home/linuxize/Downloads
460M total

Using du with Other Commands

The du command can be combined with other commands using pipes.

For example, to print the 5 largest directories inside the /var directory, pass the output of du to the sort command to sort the directories by their size. Then pipe the output to the head command, which prints only the top 5 entries:

Terminal
sudo du -sh /var/* | sort -rh | head -5

output

2.9G /var/lib
1.2G /var/log
205M /var/cache
72M /var/backups
8.0K /var/spool

Quick Reference

For a printable quick reference, see the du cheatsheet .

Command	Description
`du file`	Show disk usage of a file or directory
`du -h file`	Human-readable output (K, M, G)
`du -sh dir`	Show total size of a directory only
`du -sh *`	Show size of every item in the current directory
`du -ah dir`	Show size of every file and subdirectory
`du -csh dir1 dir2`	Show sizes and a combined grand total
`du -h --max-depth=1 dir`	Limit output to one level of subdirectories
`du -sh --apparent-size file`	Show apparent size rather than disk usage
`du -h dir \| sort -rh \| head -10`	List the 10 largest items in a directory

FAQ

What is the difference between du and df?
du reports the space used by specific files and directories. df reports the total, used, and available space on mounted filesystems. Use du to find what is consuming space, and df to check how much space is left on a disk.

What is the difference between disk usage and apparent size?
Disk usage (du default) reflects the actual space allocated on disk, which is rounded up to the filesystem block size. Apparent size (--apparent-size) is the exact byte count of the file’s data. For small files, disk usage is often larger than the apparent size.

Why does du show different results than the file manager?
File managers typically report apparent size. du reports allocated disk blocks. Sparse files, filesystem block size, and hard links can also cause differences between the two values.

Why do many examples use sudo du?
Some directories, such as parts of /var or /root, are not readable by regular users. Running du with sudo avoids permission errors and produces a more complete size report.

How do I find the largest directories under a path?
Combine du with sort and head:

Terminal
sudo du -sh /var/* | sort -rh | head -10

This lists the ten largest items directly under /var in descending order.

Conclusion

The du command is the standard tool for finding which files and directories are consuming disk space on a Linux system. Unlike df , which reports filesystem-level totals, du lets you drill down into specific directories to locate large files and directories.

smartctl Command in Linux: Check Disk Health with SMART

hello@linuxize.com (Linuxize) — Wed, 08 Jul 2026 09:40:00 +0200

Disks rarely die without warning. Long before a drive stops responding, it usually accumulates reallocated sectors, read errors, or climbing temperatures, and the drive itself keeps count through SMART (Self-Monitoring, Analysis and Reporting Technology). The smartctl command reads those counters, so the question “is this disk failing?” gets an answer based on the drive’s own bookkeeping instead of guesswork.

This guide explains how to use smartctl to check drive health, read the attributes that actually predict failure, run self-tests, and keep an eye on NVMe wear.

smartctl Syntax

The basic syntax is:

txt
smartctl [OPTIONS] DEVICE

DEVICE is normally a whole disk such as /dev/sda, /dev/sdb, or /dev/nvme0, not a mounted directory. Most checks need root because smartctl sends commands directly to the drive. If you are not sure which device names your disks have, run lsblk first.

Installing smartctl

smartctl is part of the smartmontools package.

On Ubuntu, Debian, and Derivatives:

Terminal
sudo apt install smartmontools

On Fedora, RHEL, and Derivatives:

Terminal
sudo dnf install smartmontools

After installation, run smartctl with sudo unless your distribution has granted your user direct access to storage devices.

Checking Whether a Drive Supports SMART

Start with the identity summary:

Terminal
sudo smartctl -i /dev/sda

output

Model Family: Samsung based SSDs
Device Model: Samsung SSD 870 EVO 1TB
Serial Number: S6PTNM0T812345A
Firmware Version: SVT02B6Q
User Capacity: 1,000,204,886,016 bytes [1.00 TB]
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

Besides confirming SMART support, this output gives you the model and serial number, which you will want when matching a physical drive to a device name or claiming a warranty. In the rare case SMART is available but disabled, enable it with sudo smartctl -s on /dev/sda.

Checking Overall Health

The quickest check is the drive’s own verdict:

Terminal
sudo smartctl -H /dev/sda

output

SMART overall-health self-assessment test result: PASSED

A FAILED result means the drive predicts its own failure within 24 hours and warranty replacement is justified; back up immediately.

Warning

Do not read PASSED as “healthy”. The overall verdict flips only when an attribute crosses the manufacturer’s failure threshold, and drives regularly corrupt data while still technically passing. The attributes in the next section tell the real story, and no SMART output replaces working backups.

Reading SMART Attributes

The attribute table is where failure announces itself early:

Terminal
sudo smartctl -A /dev/sda

output

ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE
5 Reallocated_Sector_Ct 0x0033 100 100 010 Pre-fail Always - 0
9 Power_On_Hours 0x0032 097 097 000 Old_age Always - 11284
12 Power_Cycle_Count 0x0032 099 099 000 Old_age Always - 413
177 Wear_Leveling_Count 0x0013 099 099 000 Pre-fail Always - 8
187 Reported_Uncorrect 0x0032 100 100 000 Old_age Always - 0
194 Temperature_Celsius 0x0022 067 052 000 Old_age Always - 33
197 Current_Pending_Sector 0x0032 100 100 000 Old_age Always - 0
198 Offline_Uncorrectable 0x0030 100 100 000 Old_age Offline - 0

Two number systems live in this table. VALUE is a normalized score where higher is better; the drive flags failure when it drops to THRESH. RAW_VALUE is the actual count, and for the attributes that matter, the raw count is what you read.

Four attributes predict failure well, and their healthy raw value is zero:

Reallocated_Sector_Ct (5) - Sectors the drive has retired and remapped to spares. A handful may stay stable for years, but a count that grows between checks is the classic sign of a dying disk.
Reported_Uncorrect (187) - Errors the drive could not correct internally. Any nonzero value correlates strongly with failure.
Current_Pending_Sector (197) - Sectors the drive could not read and is waiting to remap. Pending sectors mean data in those spots is already at risk.
Offline_Uncorrectable (198) - Confirmed unreadable sectors found during offline scanning.

Note the raw values now, check again in a week, and treat growth in any of these four as your cue to replace the drive. Temperature (194) is worth a glance too: sustained operation above roughly 50°C shortens drive life, and a spike often points at a failed case fan.

Running Self-Tests

Attributes are passive bookkeeping; self-tests actively exercise the drive. The test runs inside the drive’s firmware, so you can keep using the system while it works. Start with the short test, which takes a couple of minutes:

Terminal
sudo smartctl -t short /dev/sda

output

=== START OF OFFLINE IMMEDIATE AND SELF-TEST SECTION ===
Sending command: "Execute SMART Short self-test routine immediately in off-line mode".
Testing has begun.
Please wait 2 minutes for test to complete.

The long test (-t long) reads the entire surface and takes from under an hour on an SSD to many hours on a large hard drive; it is the right choice when a short test passes but you still suspect the drive. Check the results once the wait time has passed:

Terminal
sudo smartctl -l selftest /dev/sda

output

Num Test_Description Status Remaining LifeTime(hours) LBA_of_first_error
# 1 Short offline Completed without error 00% 11284 -
# 2 Extended offline Completed without error 00% 10102 -

A failed entry lists the LBA of the first error, which is the drive telling you exactly where it can no longer read. At that point the useful response is replacement, not repair; filesystem-level checks like fsck fix filesystem structures, not failing hardware underneath them.

Checking NVMe Drives

NVMe drives report health through a different log format, and smartctl -a presents the main fields directly:

Terminal
sudo smartctl -a /dev/nvme0

output

=== START OF SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
Critical Warning: 0x00
Temperature: 41 Celsius
Available Spare: 100%
Available Spare Threshold: 10%
Percentage Used: 3%
Data Units Written: 18,536,442 [9.49 TB]
Media and Data Integrity Errors: 0
Error Information Log Entries: 0

Three fields carry the signal. Percentage Used is the drive’s own wear estimate against its rated endurance, so 3% after a year of use projects decades of life, while a value racing toward 100% on a young drive means the workload is chewing through it. Available Spare falling toward its threshold plays the role reallocated sectors play on SATA drives. Media and Data Integrity Errors should be zero, full stop.

Checking Drives in USB Enclosures

USB adapters often hide the drive behind a bridge chip, and smartctl reports Unknown USB bridge instead of SMART data. Most bridges pass SMART through when asked explicitly:

Terminal
sudo smartctl -a -d sat /dev/sdb

The -d sat option tells smartctl to tunnel ATA commands through the bridge. If that fails, -d sntasmedia or -d sntjmicron handle common NVMe-to-USB chips, and some cheap enclosures simply do not pass SMART at all.

Continuous Monitoring with smartd

The smartmontools package also ships smartd, a daemon that polls your drives and warns you instead of waiting for you to remember. A single line in /etc/smartd.conf covers all drives:

/etc/smartd.conftxt
DEVICESCAN -a -o on -S on -s (S/../.././02|L/../../6/03) -m root -M exec /usr/share/smartmontools/smartd-runner

This monitors all detected devices, runs a short self-test daily at 02:00 and a long test on Saturdays at 03:00, and reports problems to root’s mail. Enable it with:

Terminal
sudo systemctl enable --now smartd

Distribution packages ship a commented default config that is close to this already, so often you only need to enable the service.

Troubleshooting

Permission denied or operation not permitted
Run the command with sudo. smartctl needs direct device access, and an unprivileged shell usually cannot send SMART commands to a disk.

SMART support is disabled
If smartctl -i says SMART is available but disabled, turn it on with sudo smartctl -s on /dev/sda, replacing /dev/sda with the correct device.

Unknown USB bridge
Try the SAT passthrough driver with sudo smartctl -a -d sat /dev/sdb. If that fails on an NVMe-to-USB enclosure, try -d sntasmedia or -d sntjmicron. Some adapters do not expose SMART data at all.

No such device or wrong disk shown
Confirm the device path with lsblk before running smartctl. SATA disks usually appear as /dev/sdX, while NVMe drives usually appear as /dev/nvme0 or /dev/nvme0n1.

Quick Reference

Task	Command
Identify drive and SMART support	`sudo smartctl -i /dev/sda`
Overall pass/fail verdict	`sudo smartctl -H /dev/sda`
Attribute table	`sudo smartctl -A /dev/sda`
Full ATA disk report	`sudo smartctl -x /dev/sda`
NVMe health	`sudo smartctl -a /dev/nvme0`
Start a short self-test	`sudo smartctl -t short /dev/sda`
Start a full-surface test	`sudo smartctl -t long /dev/sda`
View self-test results	`sudo smartctl -l selftest /dev/sda`
Drive behind a USB adapter	`sudo smartctl -a -d sat /dev/sdb`

Conclusion

A monthly smartctl -A glance at reallocated, pending, and uncorrectable counts, or smartd doing the same automatically, converts most disk failures from surprises into scheduled replacements. When the numbers start moving, copy the data off first and experiment second; a drive that is reallocating sectors owes you nothing. For checking the filesystems that live on top of healthy drives, see our guide on the fsck command .

fdisk Command in Linux: Create Disk Partitions

hello@linuxize.com (Linuxize) — Tue, 19 May 2020 20:51:34 +0100

The first thing you need to do after installing a new SSD or hard disk is to partition it. A drive needs to have at least one partition before you can format it and store files on it.

In Linux, there are several tools that you can use to create partitions, with fdisk being the most commonly used one.

To create a partition in Linux with fdisk, open the target disk with sudo fdisk /dev/sdX, create a partition table if needed, add a new partition with n, review the layout with p, and write the changes with w.

This guide covers the fdisk command in Linux. If you prefer a more visual interface or need advanced features, consider tools such as cfdisk, parted, or gdisk.

fdisk is a menu-driven command-line utility that allows you to create and manipulate partition tables on a storage device.

Be aware that fdisk is a dangerous tool and should be used with extreme caution. Only root or users with sudo privileges can manipulate the partition tables.

Syntax

The general syntax for the fdisk command is:

txt
fdisk [OPTIONS] DEVICE

For example, to open /dev/sdb:

Terminal
sudo fdisk /dev/sdb

List Partitions

To list the partition table of a device, invoke the fdisk command with the -l option, followed by the device name. For example, to list the /dev/sda partition table and partitions, you would run:

Terminal
sudo fdisk -l /dev/sda

When no device is given as an argument, fdisk will print partition tables of all devices listed in the /proc/partitions file:

Terminal
sudo fdisk -l

output

Disk /dev/nvme0n1: 232.91 GiB, 250059350016 bytes, 488397168 sectors
Disk model: Samsung SSD 960 EVO 250GB
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: gpt
Disk identifier: 6907D1B3-B3AB-7E43-AD20-0707A656A1B5
Device Start End Sectors Size Type
/dev/nvme0n1p1 2048 1050623 1048576 512M EFI System
/dev/nvme0n1p2 1050624 34605055 33554432 16G Linux swap
/dev/nvme0n1p3 34605056 488397134 453792079 216.4G Linux filesystem
Disk /dev/sda: 465.78 GiB, 500107862016 bytes, 976773168 sectors
Disk model: WDC WD5000AAKS-0
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: 0x0001cca3
Device Boot Start End Sectors Size Id Type
/dev/sda1 2048 976771071 976769024 465.8G 83 Linux

The output above shows the current partition tables of all devices that are attached to your system. Generally, SATA device names follow the pattern /dev/sd[a-z], while NVMe device names follow /dev/nvme0n1 and their partitions are named /dev/nvme0n1p1, /dev/nvme0n1p2, and so on.

Create a Partition Table and Partitions

Before opening fdisk, identify the disk you want to partition. The safest way to start is to list only whole disks with lsblk :

Terminal
lsblk -d -o NAME,SIZE,MODEL

output

NAME SIZE MODEL
sda 465.8G WDC WD5000AAKS-0
sdb 298.9G External USB 3.0
nvme0n1 232.9G Samsung SSD 960 EVO 250GB

In this example, /dev/sdb is the external disk we want to partition. Use the whole disk path, such as /dev/sdb, not an existing partition path such as /dev/sdb1.

To start partitioning the drive, run fdisk with the device name. In this example we will work on /dev/sdb:

Terminal
sudo fdisk /dev/sdb

The command prompt will change, and the fdisk dialogue where you can type in commands will open:

output

Welcome to fdisk (util-linux 2.41.3).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
Command (m for help):

Tip

Changes you make to the partition table will not take effect until you write them with the w command. You can exit the fdisk dialogue without saving the changes using the q command.

To get a list of all available commands enter m:

output

Command (m for help): m

If you are partitioning a new drive, create the partition table before creating partitions. Skip this step if the device already has a partition table and you want to keep it.

fdisk supports several partitioning schemes. MBR and GPT are the two most popular partition table standards, and they store partition information on a drive in different ways. GPT is the better choice for most modern systems. The main points to consider when choosing what partitioning standard to use are:

Use MBR to boot the disk in legacy BIOS mode.
Use GPT to boot the disk in UEFI mode.
The MBR standard supports creating a disk partition up to 2 TiB. If you have a disk of 2 TiB or larger, use GPT.
MBR has a limit of 4 primary partitions. If you need more partitions, one of the primary partitions can be set as an extended partition and hold additional logical partitions. With GPT, you can have up to 128 partitions. GPT does not support extended or logical partitions.

In this example, we will use a GPT partition table.

Enter g to create a new empty GPT partition table:

output

Command (m for help): g

output

Created a new GPT disklabel (GUID: 4649EE36-3013-214E-961C-51A9187A7503).

The next step is to create the new partitions.

We will create two partitions. The first one with a size of 100 GiB and the second one will take the rest of the disk space.

Run the n command to create a new partition:

output

Command (m for help): n

You will be prompted to enter the partition number. Hit “Enter” to use the default value (1):

output

Partition number (1-128, default 1):

Next, the command will ask you to specify the first sector. In most cases, use the default value so fdisk can align the partition correctly. Hit “Enter” to use the default value (2048):

output

First sector (2048-500118158, default 2048):

On the next prompt, you will need to enter the last sector. You can use an absolute value for the last sector or a relative value to the start sector, using the + symbol followed by the partition size. The size can be specified in kibibytes (K), mebibytes (M), gibibytes (G), tebibytes (T), or pebibytes (P).

Enter +100G to set the partition size to 100 GiB:

output

Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-500118158, default 500118158): +100G

output

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

By default, the type of the new partition is set to “Linux filesystem”, which is fine for most Linux data partitions.

Change Partition Types

Some partitions need a different type. For example, an EFI System partition, swap partition, LVM physical volume, or RAID member should use the matching partition type so tools and installers can recognize it correctly.

To list the available fdisk partition types, enter l:

output

Command (m for help): l

For GPT disks, common partition types include Linux filesystem, Linux swap, EFI System, Linux LVM, and Linux RAID. For MBR disks, fdisk shows numeric IDs such as 83 Linux, 82 Linux swap / Solaris, and 8e Linux LVM.

For a regular data partition, skip this step and leave the type as Linux filesystem. If you are creating a swap partition instead, enter t, choose the partition number, and then enter the type name, alias, or code shown by l:

output

Command (m for help): t
Partition number (1,2, default 2): 1
Partition type or alias (type L to list all): swap
Changed type of partition 'Linux filesystem' to 'Linux swap'.

Let us create the second partition that will take the rest of the disk space:

output

Command (m for help): n

Use the default values for the partition number, first and last sectors. This will create a partition that will use all available space on the disk.

output

Partition number (2-128, default 2):
First sector (209717248-625142414, default 209717248):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (209717248-625142414, default 625142414):

Once done creating partitions, use the p command to display the new partition table:

output

Command (m for help): p

output

Disk /dev/sdb: 298.9 GiB, 320072933376 bytes, 625142448 sectors
Disk model: nal USB 3.0
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: F8365250-AF58-F74E-B592-D56E3A5DEED1
Device Start End Sectors Size Type
/dev/sdb1 2048 209717247 209715200 100G Linux filesystem
/dev/sdb2 209717248 625142414 415425167 198.1G Linux filesystem

Save the changes by running the w command:

output

Command (m for help): w

The command will write the table to the disk and exit the fdisk menu.

output

The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.

The kernel will read the device partition table without the need to reboot the system.

Deleting a Partition

To delete a partition, use the d command, select the partition number, and then write the changes with w. Deleting a partition removes its entry from the partition table and makes the data inaccessible, so make sure you have a backup.

Activating the Partitions

Now that the partitions have been created, the next step is to format the partitions and mount them to the system’s directory tree.

We will format both partitions to ext4. Formatting erases data on the target partition, so double-check the device names before running these commands:

Terminal
sudo mkfs.ext4 -F /dev/sdb1
sudo mkfs.ext4 -F /dev/sdb2

output

Creating filesystem with 51928145 4k blocks and 12984320 inodes
Filesystem UUID: 63a3457e-c3a1-43f4-a0e6-01a7dbe7dfed
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
4096000, 7962624, 11239424, 20480000, 23887872
Allocating group tables: done
Writing inode tables: done
Creating journal (262144 blocks): done
Writing superblocks and filesystem accounting information: done

In this example, we will mount the partitions to /mnt/audio and /mnt/video directories.

Create the mount points with mkdir :

Terminal
sudo mkdir -p /mnt/audio /mnt/video

Mount the new partitions:

Terminal
sudo mount /dev/sdb1 /mnt/audio
sudo mount /dev/sdb2 /mnt/video

Partitions will stay mounted until you unmount them or shutdown the machine. To automatically mount a partition when your Linux system starts up, define the mount in the /etc/fstab file.

You can now use the new partitions to store files.

Resizing Partitions

fdisk cannot resize partitions. To resize a partition, use tools such as parted or gparted and then resize the filesystem with the appropriate filesystem tool (for example, resize2fs for ext4).

Quick Reference

For a printable quick reference, see the fdisk cheatsheet .

Command	Description
`sudo fdisk -l`	List partition tables for all detected disks
`sudo fdisk -l /dev/sdX`	List the partition table for one disk
`sudo fdisk /dev/sdX`	Open a disk in interactive fdisk mode
`m`	Show help and available interactive commands
`p`	Print the current in-memory partition table
`n`	Create a new partition
`d`	Delete a partition
`l`	List available partition types
`t`	Change a partition type
`g`	Create a new GPT partition table
`o`	Create a new MBR (DOS) partition table
`w`	Write changes to disk and exit
`q`	Quit without saving changes

Troubleshooting

fdisk says the device is busy
Unmount any mounted partitions on the disk and try again. You can check mounts with lsblk and unmount with umount /dev/sdXN.

Changes do not appear after writing the table
The kernel may not have re-read the partition table. Run sudo partprobe /dev/sdX or reboot the system.

Permission denied
Make sure you are running fdisk with sudo or as root.

FAQ

What is the difference between MBR and GPT?
MBR is the legacy partitioning scheme with a 2 TiB disk size limit and up to four primary partitions. GPT is the modern standard that supports larger disks and many more partitions, and it is required for UEFI boot.

How do I convert MBR to GPT?
Back up the disk, then recreate the partition table as GPT and restore the data. For in-place conversion in some cases, use tools such as gdisk or sgdisk, but always verify compatibility and keep a backup.

Can I partition a disk without losing data?
It depends on the existing layout and free space. Partitioning can be destructive, so use reliable backups and test on non-critical disks before making changes.

What is the difference between fdisk and parted?
fdisk is a simple, menu-driven tool that works well for common partitioning tasks. parted supports more advanced operations such as resizing and alignment checks.

Conclusion

fdisk covers most everyday partition work: listing disks, switching between MBR and GPT, adding or removing partitions, and changing types. Reach for parted or gparted when you need resizing or alignment work. For full option detail, run man fdisk.

fsck Command in Linux: Check and Repair Filesystems

hello@linuxize.com (Linuxize) — Tue, 12 Nov 2019 21:31:47 +0100

fsck (filesystem check) is a command-line utility for checking and repairing Linux filesystems. It uses filesystem-specific checkers, such as fsck.ext4, depending on the type of filesystem being checked.

You can use fsck when a partition cannot be mounted, a filesystem is marked dirty, or a system fails to boot because of filesystem errors.

Never run fsck on a mounted filesystem. Running repairs on a mounted partition can corrupt data because the filesystem may change while fsck is checking it.

How to Use fsck

The general syntax is:

txt
fsck [OPTIONS] [FILESYSTEM]

Only root or users with sudo privileges can run fsck.

When no FILESYSTEM is provided as an argument, fsck checks the devices listed in the fstab file.

Before attempting to check or repair filesystems, always unmount them first.

The fsck command is a wrapper for the various Linux filesystem checkers (fsck.*) and accepts different options depending on the filesystem’s type.

Check the manual pages for more information about a specific checker. For example, to view the options available for fsck.ext4, type:

Terminal
man fsck.ext4

Safe fsck Workflow

Before repairing a filesystem, identify the device and confirm that it is not mounted.

List block devices and filesystem types:

Terminal
lsblk -f

Check whether the target device is mounted:

Terminal
mount | grep /dev/sdc1

If the command returns a mount point, unmount the filesystem:

Terminal
sudo umount /dev/sdc1

Run a read-only check first:

Terminal
sudo fsck -n /dev/sdc1

The -n option tells fsck to report problems without writing changes. If the check shows repairable errors, run a safe automatic repair:

Terminal
sudo fsck -p /dev/sdc1

Use -p for safe automatic fixes. Use -y only when you are prepared to answer yes to every repair prompt.

Repair Corrupted Filesystem

The simplest use case of the fsck command is to repair a non-root corrupted ext3 or ext4 filesystem.

If you do not know the device name, use lsblk -f, fdisk, df , or another disk utility to find it.
Unmount the device:
Terminal
```
sudo umount /dev/sdc1
```
Run fsck to repair the filesystem:
Terminal
```
sudo fsck -p /dev/sdc1
```
The -p option tells fsck to automatically repair any problems that can be safely fixed without user intervention.
Once the filesystem is repaired, mount the partition:
Terminal
```
sudo mount /dev/sdc1
```

Repair Root Filesystem

fsck cannot check the root filesystem on a running machine because it cannot be unmounted.

To check or repair the root filesystem, use recovery mode, boot from a live USB or live environment, or force a check during the next boot.

Run fsck in Recovery Mode

Enter the boot menu and choose Advanced Options.
Select Recovery mode and then choose the option to run a file system check.
When prompted to remount the root filesystem, choose “Yes”.
Once done, resume the normal boot.

Run fsck from a Live Environment

Boot from a live USB or another live Linux environment.
Use fdisk or parted to find the root partition name.
Open the terminal and run:
Terminal
```
sudo fsck -p /dev/sda1
```
Once done, reboot and start your system normally.

Check Filesystems on Boot

On most Linux distributions, fsck runs at boot time if a filesystem is marked as dirty or after a certain number of boots or time.

To see the current mount count, check frequency number, check interval, and the time of the last check for a specific partition, use the tune2fs tool:

Terminal
sudo tune2fs -l /dev/sdc1 | grep -i 'last checked\|mount count'

output

Mount count: 292
Maximum mount count: -1
Last checked: Tue Jul 24 11:10:07 2018
Check interval: 0 (<none>)

“Maximum mount count” is the number of mounts after which the filesystem will be checked. The value of 0 or -1 means that fsck will never run.
“Check interval” is the maximal time between two filesystem checks.

If, for example, you want to run fsck after every 25 boots (mounts), type:

Terminal
sudo tune2fs -c 25 /dev/sdc1

You can also set the maximal time between two checks. For example, to set it one month you would run:

Terminal
sudo tune2fs -i 1m /dev/sdc1

To force fsck to run at boot time on systemd distributions pass the following kernel boot parameters:

txt
fsck.mode=force
fsck.repair=yes

On older distributions fsck will run on boot if the /forcefsck file is present:

Terminal
sudo touch /forcefsck

fstab Options

fstab is a configuration file that tells the system how and where to mount the partitions.

The /etc/fstab file contains a list of entries in the following form:

/etc/fstabsh
# [File System] [Mount Point] [File System Type] [Options] [Dump] [PASS]
/dev/sda1 / ext4 defaults 0 1
/dev/sda2 /home ext4 defaults 0 2
server:/dir /media/nfs nfs defaults 0 0

The last, 6th column ([PASS]) is the option that controls the order in which the filesystem checks are done at reboot time.

0 - Do not check.
1 - The filesystems to be checked first and one at a time.
2 - All other filesystems which are checked later and possibly in parallel.

The root filesystem should have a value of 1, and all other filesystems you want to be checked should have a value of 2.

Common fsck Options

Here are the most commonly used fsck options:

-a - Automatically repair the filesystem without prompting.
-n - Do not make any changes to the filesystem (dry run).
-p - Automatically repair problems that can be safely fixed.
-y - Answer “yes” to all repair prompts.
-f - Force checking even if the filesystem seems clean.
-r - Interactively repair the filesystem (prompt for each fix).
-t type - Specify the filesystem type (e.g., ext4).
-A - Check all filesystems listed in /etc/fstab.

For most manual checks, start with -n, then use -p if repairs are needed. The -y option is more aggressive because it accepts every proposed repair.

Exit Codes

The fsck command returns exit codes that indicate the result of the check:

Code	Description
`0`	No errors
`1`	Filesystem errors corrected
`2`	System should be rebooted
`4`	Filesystem errors left uncorrected
`8`	Operational error
`16`	Usage or syntax error
`32`	Checking canceled by user
`128`	Shared-library error

Other Filesystems

The fsck command works primarily with ext2, ext3, and ext4 filesystems. Other filesystems use different tools:

XFS - Use xfs_repair instead of fsck
Btrfs - Use btrfs check or btrfs scrub
NTFS - Use ntfsfix for basic repairs

Troubleshooting

The filesystem is mounted
Unmount the filesystem before running repairs. If it is busy, check which process is using it with lsof or fuser, stop that process, and unmount it again.

The device name is wrong
Use lsblk -f to list devices, filesystems, labels, UUIDs, and mount points. Make sure you are checking the correct partition, not the whole disk.

The root filesystem cannot be unmounted
Boot into recovery mode or use a live USB. The root filesystem cannot be repaired while it is mounted as the active system root.

fsck reports a bad superblock
For ext filesystems, list backup superblocks with sudo mke2fs -n /dev/sdX1, then run fsck with an alternate superblock using -b. Replace /dev/sdX1 with the correct device.

fsck does not repair XFS or Btrfs
Use the filesystem-specific tool. XFS uses xfs_repair, and Btrfs usually uses btrfs scrub or btrfs check.

Quick Reference

For a printable quick reference, see the fsck cheatsheet .

Command	Description
`lsblk -f`	List devices and filesystem types
`sudo umount /dev/sda1`	Unmount a filesystem before repair
`sudo fsck /dev/sda1`	Check filesystem
`sudo fsck -n /dev/sda1`	Check only, no changes
`sudo fsck -p /dev/sda1`	Auto-repair safe issues
`sudo fsck -y /dev/sda1`	Auto-repair all issues
`sudo fsck -f /dev/sda1`	Force check even if clean
`sudo fsck -AR`	Check all `fstab` filesystems except root
`sudo tune2fs -c 25 /dev/sda1`	Check every 25 mounts
`sudo tune2fs -i 1m /dev/sda1`	Check every month

Conclusion

The fsck command checks and repairs Linux filesystems, but it must be used carefully. Identify the correct device, unmount it, run a read-only check first, and use safe repair modes before trying more aggressive options.

How to Mount and Unmount File Systems in Linux

hello@linuxize.com (Linuxize) — Thu, 08 Nov 2018 21:31:47 +0100

In Linux and Unix-like systems, the mount command attaches file systems and removable devices such as USB drives to a mount point in the directory tree. The umount command detaches them when you are done.

This guide explains how to mount and unmount file systems in Linux using the mount and umount commands, including USB drives, ISO files, NFS shares, and persistent /etc/fstab entries.

How to List Mounted File Systems

When used without any argument, the mount command will display all currently attached file systems:

Terminal
mount

By default, the output will include all file systems including the virtual ones such as cgroup, sysfs, and others. Each line contains information about the device name, the directory to which the device is mounted, the type of the filesystem, and the mount options in the following form:

txt
device_name on directory type filesystem_type (options)

To display only certain file systems, use the -t option.

For example, to print only the ext4 partitions you would use:

Terminal
mount -t ext4

Mounting a File System

To mount a file system in a given location (mount point), use the mount command in the following form:

txt
mount [OPTION...] DEVICE_NAME DIRECTORY

Once the file system is attached, the mount point becomes the root directory of the mounted file system.

For example, to mount the /dev/sdb1 file system to the /mnt/media directory you would use:

Terminal
sudo mount /dev/sdb1 /mnt/media

Usually when mounting a device with a common file system such as ext4 or xfs, the mount command will auto-detect the file system type. However, some file systems are not recognized and need to be explicitly specified.

Use the -t option to specify the file system type:

txt
mount -t TYPE DEVICE_NAME DIRECTORY

To specify additional mount options , use the -o option:

txt
mount -o OPTIONS DEVICE_NAME DIRECTORY

Multiple options can be provided as a comma-separated list (do not insert a space after a comma).

You can get a list of all mount options by typing man mount in your terminal.

Mounting a File System using /etc/fstab

When providing just one parameter (either directory or device) to the mount command, it will read the content of the /etc/fstab configuration file to check whether the specified file system is listed or not.

If the /etc/fstab contains information about the given file system, the mount command uses the value for the other parameter and the mount options specified in the fstab file.

The /etc/fstab file contains a list of entries in the following form:

/etc/fstabtxt
[File System] [Mount Point] [File System Type] [Options] [Dump] [Pass]

Use the mount command in one of the following forms to attach a file system specified in the /etc/fstab file:

txt
mount [OPTION...] DIRECTORY
mount [OPTION...] DEVICE_NAME

Mounting USB Drive

On most modern Linux distributions, USB drives will auto-mount when you plug them in, but sometimes you may need to manually mount the drive.

To manually mount a USB device, perform the following steps:

Create the mount point:
Terminal
```
sudo mkdir -p /media/usb
```
To find the device name and filesystem type, use one of the following commands:
Terminal
```
lsblk
fdisk -l
dmesg
```
Assuming that the USB drive uses the /dev/sdd1 device, mount it to the /media/usb directory:
Terminal
```
sudo mount /dev/sdd1 /media/usb
```

Most current Linux distributions can mount exFAT USB drives without extra drivers. If you need to format or repair an exFAT drive, see the exFAT mount guide for exfatprogs usage.

Mounting ISO Files

You can mount an ISO file using the loop device, which is a special pseudo-device that makes a file accessible as a block device.

Start by creating the mount point, it can be any location you want:
Terminal
```
sudo mkdir /media/iso
```
Mount the ISO file to the mount point by typing the following command:
Terminal
```
sudo mount /path/to/image.iso /media/iso -o loop
```
Replace /path/to/image.iso with the path to your ISO file.

Mounting NFS

To mount an NFS share , you will need to have the NFS client package installed on your system.

Install NFS client on Ubuntu, Debian, and Derivatives:
Terminal
```
sudo apt install nfs-common
```
Install NFS client on Fedora, RHEL, and Derivatives:
Terminal
```
sudo dnf install nfs-utils
```

Use the steps below to mount a remote NFS directory on your system:

Create a directory to serve as the mount point for the remote filesystem:
Terminal
```
sudo mkdir /media/nfs
```
Generally, you will want to mount the remote NFS share automatically at boot. To do so, open the /etc/fstab file with your text editor :
Terminal
```
sudo nano /etc/fstab
```
Add the following line to the file, replacing remote.server:/dir with the NFS server IP address or hostname and the exported directory:
/etc/fstabini
```
# <file system> <dir> <type> <options> <dump> <pass>
remote.server:/dir /media/nfs nfs defaults 0 0
```
Mount the NFS share by running the following command:
Terminal
```
sudo mount /media/nfs
```

Mounting a Directory with a Bind Mount

Sometimes you need to make the contents of one directory available at another location without copying any data. A bind mount attaches an existing directory to a second mount point, so both paths show the same files.

Use the --bind option followed by the source and target directories:

Terminal
sudo mount --bind /source/dir /target/dir

Both directories must already exist. After the bind mount, any change made under one path is visible under the other, because they point to the same data.

To make a bind mount persistent, add an entry to /etc/fstab using the bind option:

/etc/fstabini
/source/dir /target/dir none bind 0 0

Creating a Mount Point

Before you mount a file system manually, the target directory must already exist. This directory is called the mount point.

To create a mount point, use mkdir:

Terminal
sudo mkdir -p /mnt/data

Unmounting a File System

To detach a mounted file system, use the umount command followed by either the mount point directory or the device name:

txt
umount DIRECTORY
umount DEVICE_NAME

If the file system is in use, the umount command will fail to detach it. In those situations, you can use the fuser command to find out which processes are accessing the file system:

Terminal
fuser -m DIRECTORY

Once you determine the processes, you can stop them and unmount the file system.

Lazy Unmount

Use the -l (--lazy) option to unmount a busy file system as soon as it is no longer in use:

Terminal
umount -l DIRECTORY

Force Unmount

Use the -f (--force) option to force an unmount. This option is usually used to unmount an unreachable NFS system:

Terminal
umount -f DIRECTORY

Force unmounting is generally not a good idea, as it may corrupt data on the file system.

Quick Reference

For a printable quick reference, see the mount cheatsheet .

Command	Description
`mount`	List all mounted file systems
`mount -t ext4`	List mounted file systems of a specific type
`sudo mount DEVICE DIR`	Mount a device to a directory
`sudo mount -t TYPE DEVICE DIR`	Mount with an explicit file system type
`sudo mount -o OPTIONS DEVICE DIR`	Mount with specific options
`sudo mount DIR`	Mount using /etc/fstab entry
`sudo mount /dev/sdd1 /media/usb`	Mount a USB drive
`sudo mount /path/to/image.iso /media/iso -o loop`	Mount an ISO file
`sudo mount --bind /source/dir /target/dir`	Bind mount one directory to another
`umount DIRECTORY`	Unmount by mount point
`umount DEVICE_NAME`	Unmount by device name
`umount -l DIRECTORY`	Lazy unmount (detach when not busy)
`umount -f DIRECTORY`	Force unmount (use with caution)
`fuser -m DIRECTORY`	Find processes using a mount point
`lsblk`	List block devices and their mount points

Troubleshooting

“Permission denied” when mounting
The mount command requires root privileges. Prefix the command with sudo, or add the device to /etc/fstab with the user option to allow non-root mounts.

“Device or resource busy” when unmounting
A process is still accessing the file system. Run fuser -m DIRECTORY to identify the processes, then stop them before retrying umount. Alternatively, use umount -l for a lazy unmount.

“Wrong fs type, bad option, bad superblock”
The file system type was not detected correctly. Specify it explicitly with the -t flag: sudo mount -t ext4 /dev/sdb1 /mnt/data.

Mount does not persist after reboot
Mounts made with mount are not persistent. To mount a file system automatically at boot, add an entry to /etc/fstab.

“Cannot read superblock” on USB drive
The drive may use a file system that is not available on the running system, or the file system may be damaged. For exFAT drives, current distributions usually mount them natively; install exfatprogs if you need repair tools, then retry the mount.

FAQ

What is the difference between mount and umount?
mount attaches a file system to a directory in the tree, making its contents accessible at that path. umount detaches it, making the directory empty again.

Why is the command umount and not unmount?
The command has been spelled umount since early Unix, a historical convention, not a typo.

How do I make a mount persistent across reboots?
Add an entry to /etc/fstab. The format is: DEVICE MOUNTPOINT FSTYPE OPTIONS DUMP PASS. After editing the file, run sudo mount -a to test that all entries mount without errors.

What is a mount point in Linux?
A mount point is a directory where a file system is attached and made accessible. After mounting, the mounted file system appears under that directory path.

How do I find the device name of a connected drive?
Run lsblk to list all block devices and their mount points. You can also use fdisk -l or check dmesg output right after plugging in the device.

Can I mount a directory to another directory?
Yes, using a bind mount: sudo mount --bind /source/dir /target/dir. This makes the contents of the source directory accessible at the target path without duplicating any data.

Conclusion

The mount command is the primary tool for attaching file systems in Linux, from local partitions and USB drives to ISO images and NFS shares. Use /etc/fstab to make mounts persistent across reboots, and umount to safely detach them when done. For NFS-specific setup, see the NFS mount guide .

Understanding the /etc/fstab File in Linux

hello@linuxize.com (Linuxize) — Wed, 18 Feb 2026 13:00:00 +0100

The /etc/fstab file (filesystem table) is a system configuration file that defines how filesystems, partitions, and storage devices are mounted at boot time. The system reads this file during startup and mounts each entry automatically.

Understanding /etc/fstab is essential when you need to add a new disk, create a swap file , mount a network share , or change mount options for an existing filesystem.

This guide explains the /etc/fstab file format, what each field means, common mount options, and how to add new entries safely.

/etc/fstab Format

The /etc/fstab file is a plain text file with one entry per line. Each line defines a filesystem to mount. Lines beginning with # are comments and are ignored by the system.

To view the contents of the file safely, use less :

Terminal
less /etc/fstab

A typical /etc/fstab file looks like this:

output

# <file system> <mount point> <type> <options> <dump> <pass>
UUID=a1b2c3d4-e5f6-7890-abcd-ef1234567890 / ext4 errors=remount-ro 0 1
UUID=b2c3d4e5-f6a7-8901-bcde-f12345678901 /home ext4 defaults 0 2
UUID=c3d4e5f6-a7b8-9012-cdef-123456789012 none swap sw 0 0
tmpfs /tmp tmpfs defaults,noatime 0 0

Each entry contains six space-separated fields:

txt
UUID=a1b2c3d4... /home ext4 defaults 0 2
[---------------] [---] [--] [------] - -
| | | | | |
| | | | | +-> 6. Pass (fsck order)
| | | | +----> 5. Dump (backup flag)
| | | +-----------> 4. Options
| | +------------------> 3. Type
| +-------------------------> 2. Mount point
+---------------------------------------------> 1. File system

Field Descriptions

File system - The device or partition to mount. This can be specified as:
- A UUID: UUID=a1b2c3d4-e5f6-7890-abcd-ef1234567890
- A disk label: LABEL=home
- A device path: /dev/sda1
- A network path: 192.168.1.10:/export/share (for NFS)
Using UUIDs is recommended because device paths like /dev/sda1 can change if disks are added or removed. To find the UUID of a partition, run blkid:
Terminal
```
sudo blkid
```
Mount point - The directory where the filesystem is attached. The directory must already exist. Common mount points include /, /home, /boot, and /mnt/data. For swap entries, this field is set to none.
Type - The filesystem type. Common values include:
- ext4 - The default Linux filesystem
- xfs - High-performance filesystem used on RHEL-based distributions
- btrfs - Copy-on-write filesystem with snapshot support
- swap - Swap partition or file
- tmpfs - Temporary filesystem stored in memory
- nfs - Network File System
- vfat - FAT32 filesystem (USB drives, EFI partitions)
- auto - Let the kernel detect the filesystem type automatically
Options - A comma-separated list of mount options. See the Common Mount Options section below for details.
Dump - Used by the dump backup utility. A value of 0 means the filesystem is not included in backups. A value of 1 means it is. Most modern systems do not use dump, so this is typically set to 0.
Pass - The order in which fsck checks filesystems at boot. The root filesystem should be 1. Other filesystems should be 2 so they are checked after root. A value of 0 means the filesystem is not checked.

Common Mount Options

The fourth field in each fstab entry is a comma-separated list of mount options. The following options are the most commonly used:

defaults - Uses the standard default options (rw, suid, dev, exec, auto, nouser, async). Some effective behaviors can still vary by filesystem and kernel settings.
ro - Mount the filesystem as read-only.
rw - Mount the filesystem as read-write.
noatime - Do not update file access times. This can improve performance, especially on SSDs.
nodiratime - Do not update directory access times.
noexec - Do not allow execution of binaries on the filesystem.
nosuid - Do not allow set-user-ID or set-group-ID bits to take effect.
nodev - Do not interpret character or block special devices on the filesystem.
nofail - Do not report errors if the device does not exist at boot. Useful for removable drives and network shares.
auto - Mount the filesystem automatically at boot (default behavior).
noauto - Do not mount automatically at boot. The filesystem can still be mounted manually with mount.
user - Allow a regular user to mount the filesystem.
errors=remount-ro - Remount the filesystem as read-only if an error occurs. Common on root filesystem entries.
_netdev - The filesystem requires network access. The system waits for the network to be available before mounting. Use this for NFS, CIFS, and iSCSI mounts.
x-systemd.automount - Mount the filesystem on first access instead of at boot. Managed by systemd.

You can combine multiple options separated by commas:

txt
UUID=a1b2c3d4... /data ext4 defaults,noatime,nofail 0 2

Adding an Entry to /etc/fstab

Before editing /etc/fstab, always create a backup:

Terminal
sudo cp /etc/fstab /etc/fstab.bak

Step 1: Find the UUID

Identify the UUID of the partition you want to mount:

Terminal
sudo blkid /dev/sdb1

output

/dev/sdb1: UUID="d4e5f6a7-b8c9-0123-def0-123456789abc" TYPE="ext4"

Step 2: Create the Mount Point

Create the directory where the filesystem will be mounted:

Terminal
sudo mkdir -p /mnt/data

Step 3: Add the Entry

Open /etc/fstab in a text editor :

Terminal
sudo nano /etc/fstab

Add a new line at the end of the file:

/etc/fstabsh
UUID=d4e5f6a7-b8c9-0123-def0-123456789abc /mnt/data ext4 defaults,nofail 0 2

Step 4: Reload and Test the Entry

On systemd-based systems, reload the generated mount units after editing /etc/fstab:

Terminal
sudo systemctl daemon-reload

Then verify the file syntax and mount relationships:

Terminal
sudo findmnt --verify

Instead of rebooting, use mount -a to mount fstab entries that are not already mounted and do not use the noauto option:

Terminal
sudo mount -a

If the command produces no output, the entry is correct. If there is an error, fix the fstab entry before rebooting, as an incorrect fstab can prevent the system from booting normally.

Verify the filesystem is mounted :

Terminal
df -h /mnt/data

Common fstab Examples

Swap File

To add a swap file to fstab:

/etc/fstabsh
/swapfile none swap sw 0 0

To mount an NFS share that requires network access:

/etc/fstabsh
192.168.1.10:/export/share /mnt/nfs nfs defaults,_netdev,nofail 0 0

To mount a Windows/Samba share with a credentials file:

/etc/fstabsh
//192.168.1.20/share /mnt/smb cifs credentials=/etc/samba/creds,_netdev,nofail 0 0

Set strict permissions on the credentials file so other users cannot read it:

Terminal
sudo chmod 600 /etc/samba/creds

USB or External Drive

To mount a removable drive that may not always be attached:

/etc/fstabsh
UUID=e5f6a7b8-c9d0-1234-ef01-23456789abcd /mnt/usb ext4 defaults,nofail,noauto 0 0

The nofail option prevents boot errors when the drive is not connected. The noauto option prevents automatic mounting; mount it manually with sudo mount /mnt/usb when needed.

tmpfs for /tmp

To mount /tmp as a temporary filesystem in memory:

/etc/fstabsh
tmpfs /tmp tmpfs defaults,noatime,size=2G 0 0

Quick Reference

Task	Command
View fstab contents	`less /etc/fstab`
Back up fstab	`sudo cp /etc/fstab /etc/fstab.bak`
Find partition UUIDs	`sudo blkid`
Reload systemd mount units	`sudo systemctl daemon-reload`
Verify fstab syntax	`sudo findmnt --verify`
Mount all fstab entries	`sudo mount -a`
Check mounted filesystems	`mount` or `df -h`
Check filesystem type	`lsblk -f`
Restore fstab from backup	`sudo cp /etc/fstab.bak /etc/fstab`

Troubleshooting

System does not boot after editing fstab
An incorrect fstab entry can cause a boot failure. Boot into recovery mode or a live USB, mount the root filesystem, and fix or restore /etc/fstab from the backup. Always test with sudo mount -a before rebooting.

mount -a reports “wrong fs type” or “bad superblock”
The filesystem type in the fstab entry does not match the actual filesystem on the device. Use sudo blkid or lsblk -f to check the correct type.

Network share fails to mount at boot
Add the _netdev option to tell the system to wait for network availability before mounting. For systemd-based systems, x-systemd.automount can also help with timing issues.

“mount point does not exist”
The directory specified in the second field does not exist. Create it with mkdir -p /path/to/mountpoint before running mount -a.

UUID changed after reformatting a partition
Reformatting a partition assigns a new UUID. Run sudo blkid to find the new UUID and update the fstab entry accordingly.

FAQ

What happens if I make an error in /etc/fstab?
If the entry references a non-existent device without the nofail option, the system may drop to an emergency shell during boot. Always use nofail for non-essential filesystems and test with sudo mount -a before rebooting.

Should I use UUID or device path (/dev/sda1)?
Use UUID. Device paths can change if you add or remove disks, or if the boot order changes. UUIDs are unique to each filesystem and do not change unless you reformat the partition.

What does the nofail option do?
It tells the system to continue booting even if the device is not present or cannot be mounted. Without nofail, a missing device causes the system to drop to an emergency shell.

How do I remove an fstab entry?
Open /etc/fstab with sudo nano /etc/fstab, delete or comment out the line (add # at the beginning), save the file, and then unmount the filesystem with sudo umount /mount/point.

What is the difference between noauto and nofail?
noauto prevents the filesystem from being mounted automatically at boot; you must mount it manually. nofail still mounts automatically but does not cause a boot error if the device is missing.

Conclusion

The /etc/fstab file controls how filesystems are mounted at boot. Each entry specifies the device, mount point, filesystem type, options, and check order. Always back up fstab before editing, use UUIDs instead of device paths, and test changes with sudo mount -a before rebooting.

Create a Linux Swap File

hello@linuxize.com (Linuxize) — Sun, 01 Apr 2018 00:31:47 +0100

Swap is a space on a disk that is used when the amount of physical RAM is full. When a Linux system runs out of RAM, inactive pages are moved from the RAM to the swap space.

Swap space can take the form of either a dedicated swap partition or a swap file. In most cases, when running Linux on a virtual machine, a swap partition is not present, so the only option is to create a swap file.

Swap helps when you run out of RAM, but it is not a replacement for memory. Heavy swapping usually means your system is under memory pressure and will slow down.

How to add a swap file

Follow these steps to add 1GB of swap to your server. If you want to add 2GB instead of 1GB, replace 1G with 2G. On small systems, 1-2GB is often enough; if you use hibernation, swap should be at least the size of RAM.

Create a file that will be used for swap:
Terminal
```
sudo fallocate -l 1G /swapfile
```
If fallocate is not installed or if you get an error message saying fallocate failed: Operation not supported, you can use the following command to create the swap file:
Terminal
```
sudo dd if=/dev/zero of=/swapfile bs=1024 count=1048576
```
To confirm the file size, run:
Terminal
```
ls -lh /swapfile
```
Only the root user should be able to write and read the swap file. To set the correct permissions type:
Terminal
```
sudo chmod 600 /swapfile
```
If you are using Btrfs, swap files must be created on a No_COW, non-compressed file, otherwise swapon can fail. Create the swap file inside a directory with chattr +C and compression disabled. For example:
Terminal
```
sudo mkdir -p /swap
sudo chattr +C /swap
```
Then create the swap file inside /swap (for example, /swap/swapfile).
Use the mkswap utility to set up the file as Linux swap area:
Terminal
```
sudo mkswap /swapfile
```
Enable the swap with the following command:
Terminal
```
sudo swapon /swapfile
```
To make the change permanent, open the /etc/fstab file and append the following line:
/etc/fstabini
```
/swapfile none swap defaults 0 0
```

To verify that the swap is active, use either swapon or the free command as shown below:

Terminal
sudo swapon --show

output

NAME TYPE SIZE USED PRIO
/swapfile file 1024M 507.4M -1

Terminal
sudo free -h

output

 total used free shared buff/cache available
Mem: 488M 158M 83M 2.3M 246M 217M
Swap: 1.0G 506M 517M

How to adjust the swappiness value

Swappiness is a Linux kernel property that defines how often the system will use the swap space. Swappiness can have a value between 0 and 100. A low value will make the kernel try to avoid swapping whenever possible, while a higher value will make the kernel use the swap space more aggressively.

The default swappiness value is 60. You can check the current swappiness value by typing the following command:

Terminal
cat /proc/sys/vm/swappiness

output

While the swappiness value of 60 is OK for most Linux systems, for production servers, you may need to set a lower value.

For example, to set the swappiness value to 10, you would run the following sysctl command:

Terminal
sudo sysctl vm.swappiness=10

To make this parameter persistent across reboots, append the following line to the /etc/sysctl.conf file:

/etc/sysctl.conftxt
vm.swappiness=10

The optimal swappiness value depends on your system workload and how the memory is being used.

How to remove a swap file

If for any reason you want to deactivate and remove the swap file, follow these steps:

First, deactivate the swap by typing:
Terminal
```
sudo swapoff -v /swapfile
```
Remove the swap file entry /swapfile none swap defaults 0 0 from the /etc/fstab file.
Finally, delete the actual swap file using the rm command:
Terminal
```
sudo rm /swapfile
```

FAQ

How much swap space should I create?
For systems with less than 2 GB of RAM, a swap size of twice the RAM is a common starting point. For systems with 2–8 GB of RAM, matching the RAM size is usually enough. For systems with more than 8 GB of RAM, 4–8 GB of swap is a reasonable ceiling unless you use hibernation, in which case swap must be at least the size of your RAM.

How do I resize an existing swap file?
Turn off the current swap, recreate the file at the new size, reformat it, and re-enable it:

Terminal
sudo swapoff /swapfile
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

My system already has a zram device. Can I still add a swap file?
Yes. Some distributions, such as Fedora and Pop!_OS, enable a zram-based swap device by default. You can add a swap file alongside it using the same steps above. If you run swapon --show and see a /dev/zram entry instead of a file, that is expected. The new swap file will appear as an additional entry once enabled.

Conclusion

For more on memory management, the free and vmstat commands give you a live view of swap usage. If your system is swapping heavily under normal load, adding more RAM is a more effective fix than increasing swap.

dd Command in Linux: Copy Disks, Partitions, and Files

hello@linuxize.com (Linuxize) — Sun, 10 May 2026 08:30:00 +0200

Most of the time when you copy a file on Linux, you reach for cp. It walks the filesystem, respects permissions, and works on individual files. But when you need to copy an entire disk, write an ISO image to a USB stick, or create a byte-for-byte backup of a partition, the filesystem view is not enough. For that, Linux ships with dd, a tool that copies raw data block by block between any two files or devices.

This guide explains how to use dd safely to write ISO images, clone disks, back up partitions, create test files, and benchmark storage performance.

dd Syntax

The general form of the dd command is:

txt
dd if=INPUT of=OUTPUT [OPTIONS]

The two key operands are if (input file) and of (output file). Either one can be a regular file, a block device such as /dev/sda, or even /dev/zero and /dev/urandom. Options control the block size, how many blocks to copy, and what conversions to apply.

Warning

dd writes exactly what you tell it to write, to exactly the target you point it at. Pointing of= at the wrong disk will overwrite that disk without warning or confirmation. Always double-check the target device with lsblk or sudo fdisk -l before running a dd command.

Writing an ISO Image to a USB Drive

The most common use for dd is flashing a Linux ISO to a USB drive so you can boot and install from it. First, identify the USB device with lsblk or sudo fdisk -l:

Terminal
lsblk

output

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
sda 8:0 0 465.8G 0 disk
├─sda1 8:1 0 512M 0 part /boot/efi
└─sda2 8:2 0 465.3G 0 part /
sdb 8:16 1 14.5G 0 disk
└─sdb1 8:17 1 14.5G 0 part

Here sda is the system disk and sdb is the USB drive. Make sure the USB is unmounted before writing to it:

Terminal
sudo umount /dev/sdb1

Then write the ISO image:

Terminal
sudo dd if=ubuntu-24.04-desktop-amd64.iso of=/dev/sdb bs=4M status=progress oflag=sync

Notice that the output target is the whole disk (/dev/sdb), not a partition (/dev/sdb1). Writing an ISO to a partition would leave the USB unbootable. The options do the following:

bs=4M - Read and write 4 MB at a time, which is much faster than the 512-byte default.
status=progress - Print a live progress indicator so you can see how much has been written.
oflag=sync - Flush every write to the device, so the final byte count reflects data actually on disk.

When dd finishes, run sync once more to make sure all buffered writes hit the USB stick before you remove it:

Terminal
sync

For alternative methods and distro-specific tips, see the guide on how to create a bootable Linux USB drive .

Cloning a Whole Disk

To make an exact block-level copy of one disk onto another, point if= and of= at two different block devices:

Terminal
sudo dd if=/dev/sda of=/dev/sdb bs=64K conv=noerror,sync status=progress

The destination disk must be at least as large as the source. Anything already on it is overwritten. The conversion flags handle read errors gracefully:

conv=noerror - Keep going when a read error occurs instead of aborting.
conv=sync - Pad short reads with zeros so the output stays aligned with the source.

Clone offline whenever possible. Cloning a disk that is actively being written to produces an inconsistent copy, especially for databases and journaling filesystems.

Backing Up a Partition to an Image File

dd can also write a partition or whole disk to a regular file. That file becomes a bit-for-bit image you can restore later:

Terminal
sudo dd if=/dev/sda1 of=/backup/sda1.img bs=4M status=progress

To save space, pipe the output through gzip:

Terminal
sudo dd if=/dev/sda1 bs=4M status=progress | gzip -c > /backup/sda1.img.gz

The compressed image is much smaller for filesystems that contain text or empty space, though the compression step adds CPU time.

To restore the image to a partition:

Terminal
gunzip -c /backup/sda1.img.gz | sudo dd of=/dev/sda1 bs=4M status=progress

The target partition must be unmounted during restore, and it must be at least as large as the original.

Backing Up and Restoring the MBR

The Master Boot Record sits in the first 512 bytes of a disk that uses a traditional BIOS partition table. You can back it up with dd:

Terminal
sudo dd if=/dev/sda of=/backup/mbr.img bs=512 count=1

To restore the MBR, swap the input and output:

Terminal
sudo dd if=/backup/mbr.img of=/dev/sda bs=512 count=1

On modern UEFI systems the partition table uses GPT instead of MBR, so this trick only applies to older BIOS installations. For GPT disks, use sgdisk --backup and sgdisk --load-backup from the gdisk package.

Creating an Empty File of a Specific Size

dd is often used to create test files of a known size. The count option sets how many blocks to write, and bs sets the block size:

Terminal
dd if=/dev/zero of=testfile bs=1M count=100

This creates a 100 MB file filled with zeros, useful for testing backups, simulating quota limits, or preparing a swap file. To create a file filled with random data instead, read from /dev/urandom:

Terminal
dd if=/dev/urandom of=random.bin bs=1M count=10

Random data is slower to generate because the kernel has to produce the bytes, while /dev/zero is effectively free.

Creating a Swap File

One practical use of the empty-file pattern is creating a swap file :

Terminal
sudo dd if=/dev/zero of=/swapfile bs=1M count=2048 status=progress
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

The chmod 600 step keeps the swap file readable only by root, which is required by mkswap on most distros. After swapon, the 2 GB swap file is active immediately. Add an entry to /etc/fstab to make it permanent.

Wiping a Disk

To destroy data on a disk before disposing of it or repurposing it, overwrite the entire device with zeros:

Terminal
sudo dd if=/dev/zero of=/dev/sdb bs=4M status=progress

For a stronger wipe that makes recovery harder on traditional spinning disks, use random data:

Terminal
sudo dd if=/dev/urandom of=/dev/sdb bs=4M status=progress

On SSDs, a dd wipe is not the right tool. SSDs remap blocks internally, so a full write does not guarantee every cell was overwritten. Use blkdiscard or the drive vendor’s secure-erase utility instead.

Benchmarking Disk Write Speed

dd is a quick way to measure sustained write throughput. Write a 1 GB file of zeros and let dd report the rate:

Terminal
dd if=/dev/zero of=tempfile bs=1M count=1024 oflag=direct

output

1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 3.1 s, 346 MB/s

The oflag=direct flag bypasses the page cache, so the number reflects actual disk speed rather than memory throughput. For a read benchmark, drop the caches first and then read the file back:

Terminal
sudo sh -c "sync && echo 3 > /proc/sys/vm/drop_caches"
dd if=tempfile of=/dev/null bs=1M

Remove the test file when you are done:

Terminal
rm tempfile

For more detailed I/O profiling, tools like fio and ioping produce more accurate, repeatable results.

Showing Progress on a Running dd

If you started dd without status=progress, you can still ask it to print a status line by sending the USR1 signal to its process. From another terminal, run:

Terminal
sudo kill -USR1 $(pidof dd)

dd will respond by printing the number of bytes copied so far and its current rate, then keep running.

Common Options

A quick rundown of the options covered in this guide, plus a few more worth knowing:

if=FILE - Input file or device.
of=FILE - Output file or device.
bs=N - Block size for both reads and writes (e.g., 4M for 4 MB).
ibs=N / obs=N - Separate input and output block sizes.
count=N - Number of input blocks to copy.
skip=N - Skip N blocks at the start of the input.
seek=N - Skip N blocks at the start of the output.
status=progress - Print progress while copying.
conv=noerror - Continue past read errors.
conv=sync - Pad short reads with zeros to keep block alignment.
oflag=direct - Bypass the kernel page cache on write.
oflag=sync - Flush each write to the device before continuing.

Quick Reference

Command	Description
`sudo dd if=image.iso of=/dev/sdX bs=4M status=progress oflag=sync`	Write an ISO image to a USB drive
`sudo dd if=/dev/sda of=/dev/sdb bs=64K conv=noerror,sync status=progress`	Clone one disk to another
`sudo dd if=/dev/sda1 of=/backup/sda1.img bs=4M status=progress`	Back up a partition to an image file
`sudo dd if=/dev/sda bs=4M status=progress \| gzip -c > disk.img.gz`	Compressed disk image backup
`sudo dd if=/dev/sda of=/backup/mbr.img bs=512 count=1`	Back up the MBR
`dd if=/dev/zero of=testfile bs=1M count=100`	Create a 100 MB file of zeros
`sudo dd if=/dev/zero of=/dev/sdX bs=4M status=progress`	Wipe a disk with zeros
`dd if=/dev/zero of=tempfile bs=1M count=1024 oflag=direct`	Benchmark disk write speed
`sudo kill -USR1 $(pidof dd)`	Ask a running dd for its progress

Troubleshooting

dd: failed to open ‘/dev/sdX’: Permission denied
Writing to a block device requires root privileges. Prefix the command with sudo. If you are already using sudo, double-check that the device path is correct and that the device is not exclusively held by another process.

dd: error writing ‘/dev/sdX’: No space left on device
The destination is smaller than the source. When cloning, the target disk or partition must be at least as large as the source. When writing an ISO, the USB drive must be larger than the ISO file.

The write is much slower than expected
The default block size of 512 bytes forces millions of tiny syscalls. Set bs=4M or bs=64K to speed things up. Also check whether other processes are doing heavy I/O on the same device.

The USB does not boot after writing the ISO
Verify that you wrote the image to the disk (/dev/sdb), not a partition (/dev/sdb1). Also confirm the ISO download with its SHA256 checksum; a truncated or corrupted download produces an unbootable stick.

dd: invalid number: ‘4M’
Older or minimal systems may ship a dd that does not accept the M, G, or K suffixes. On those systems, spell out the block size in bytes (bs=4194304 for 4 MB), or install GNU coreutils.

FAQ

What does dd stand for?
The name comes from the IBM Job Control Language statement “Data Definition.” Because of how often the command is used to overwrite disks by mistake, many Linux users jokingly call it “disk destroyer.” Either way, the behavior is the same: it copies bytes from input to output without touching the filesystem layer.

Is dd faster than cp for copying large files?
For regular files on a normal filesystem, cp is usually just as fast and safer to use. dd only wins when you are copying raw devices, working with exact byte offsets, or deliberately limiting how much data is copied with count.

Can I use dd on an SSD without damaging it?
Reading and writing with dd is fine. The concern with SSDs is full-disk wipes: a single pass of zeros is enough to erase visible data, but repeated full-drive writes wear out the flash cells. For secure erase, use blkdiscard or the drive’s built-in secure-erase command.

How do I see how much data dd has copied?
Add status=progress to the command, or send the running process the USR1 signal with sudo kill -USR1 $(pidof dd). Both methods print the byte count and current throughput without interrupting the copy.

Why use bs=4M instead of the default?
The default block size of 512 bytes means dd issues a separate read and write for every 512 bytes of data. Larger block sizes such as 4 MB dramatically reduce syscall overhead and let the kernel fill the disk pipeline efficiently, often cutting copy times by a factor of ten.

Conclusion

dd is one of the most direct tools in the Linux toolbox. It copies bytes, no more and no less, between any two files or devices. That power makes it indispensable for flashing installers, cloning disks, and building image backups, and the same power makes it unforgiving if you point it at the wrong target.

For related disk tools, see the guides on fdisk for partitioning and df for checking free space.

Linux Storage Fundamentals on Linuxize

Block Devices, Partitions, and Filesystems in Linux Explained

What a Block Device Is #

Partitions Divide a Disk #

Filesystems Give a Partition Structure #

Mount Points Attach a Filesystem to the Tree #

Walking Through One Real Layout #

Where LVM, RAID, and Encryption Fit #

Quick Reference #

FAQ #

Conclusion #

lsblk Command in Linux: List Block Devices

lsblk Syntax #

Basic Usage #

Hide Partitions and Child Devices #

Show Filesystem Information #

Pick Specific Columns #

Show Device Paths #

List a Single Device #

Flat and ASCII Output #

Machine-Readable Output #

Show Sizes in Bytes #

Quick Reference #

FAQ #

Conclusion #

What Is an Inode in Linux

What an Inode Is #

Filenames Are Separate from Inodes #

Viewing Inode Numbers #

How Filesystems Allocate Inodes #

Checking Inode Usage #

Conclusion #

stat Command in Linux: Display File and Filesystem Information

stat Command Syntax #

Displaying File Information #

Displaying Filesystem Information #

Dereference (Follow) Symlinks #

Customizing the Output #

Quick Reference #

Troubleshooting #

FAQ #

Conclusion #

df Command in Linux: Check Disk Space Usage

df Command Syntax #

Human-Readable Output #

Display Filesystem Types #

Filter by Filesystem Type #

Display Total Disk Space #

Display Inode Usage #

Custom Output Format #

POSIX Output for Scripts #

df vs du #

Quick Reference #

Troubleshooting #

FAQ #

Conclusion #

du Command in Linux: Check Disk Usage

du Command Syntax #

How to Use the du Command #

Display Disk Usage in Human-Readable Format #

Show the Total Size of a Directory #

Show the Size of Every File #

Display a Grand Total #

Limit the Directory Depth #

Show the Apparent Size #

Use Shell Patterns with du #

Using du with Other Commands #

Quick Reference #

FAQ #

Conclusion #

smartctl Command in Linux: Check Disk Health with SMART

smartctl Syntax #

Installing smartctl #

Checking Whether a Drive Supports SMART #

Checking Overall Health #

Reading SMART Attributes #

Running Self-Tests #

Checking NVMe Drives #

Checking Drives in USB Enclosures #

Continuous Monitoring with smartd #

What a Block Device Is

Partitions Divide a Disk

Filesystems Give a Partition Structure

Mount Points Attach a Filesystem to the Tree

Walking Through One Real Layout

Where LVM, RAID, and Encryption Fit

Quick Reference

FAQ

Conclusion

lsblk Syntax

Basic Usage

Hide Partitions and Child Devices

Show Filesystem Information

Pick Specific Columns

Show Device Paths

List a Single Device

Flat and ASCII Output

Machine-Readable Output

Show Sizes in Bytes

Quick Reference

FAQ

Conclusion

What an Inode Is

Filenames Are Separate from Inodes

Viewing Inode Numbers

How Filesystems Allocate Inodes

Checking Inode Usage

Conclusion

stat Command Syntax

Displaying File Information

Displaying Filesystem Information

Dereference (Follow) Symlinks

Customizing the Output

Quick Reference

Troubleshooting

FAQ

Conclusion

df Command Syntax

Human-Readable Output

Display Filesystem Types

Filter by Filesystem Type

Display Total Disk Space

Display Inode Usage

Custom Output Format

POSIX Output for Scripts

df vs du

Quick Reference

Troubleshooting

FAQ

Conclusion

du Command Syntax

How to Use the du Command

Display Disk Usage in Human-Readable Format

Show the Total Size of a Directory

Show the Size of Every File

Display a Grand Total

Limit the Directory Depth

Show the Apparent Size

Use Shell Patterns with du

Using du with Other Commands

Quick Reference

FAQ

Conclusion

smartctl Syntax

Installing smartctl

Checking Whether a Drive Supports SMART

Checking Overall Health

Reading SMART Attributes

Running Self-Tests

Checking NVMe Drives

Checking Drives in USB Enclosures

Continuous Monitoring with smartd

Troubleshooting

Quick Reference

Conclusion

Syntax

List Partitions

Create a Partition Table and Partitions

Change Partition Types

Deleting a Partition