How To Restore Deleted Files In Linux

7 min read

Accidentally deleting a critical file is a moment of panic familiar to every Linux user, from beginners to seasoned system administrators. On the flip side, the data is rarely gone instantly; the filesystem simply marks the space occupied by that file as available for new data. Now, unlike some operating systems that move deleted items to a "Recycle Bin" by default, the Linux command line often executes removal commands like rm immediately and permanently, bypassing any safety net. Understanding this mechanism is the key to successful recovery. Whether you are working on a local workstation, a headless server, or a virtual machine, knowing how to restore deleted files in Linux can save hours of rework and prevent catastrophic data loss Worth keeping that in mind. That alone is useful..

Understanding How Linux Handles Deletion

Before diving into recovery tools, Make sure you grasp what happens when you delete a file. It matters. In Linux filesystems (ext4, XFS, Btrfs, ZFS), a file consists of two main parts: the inode (metadata containing permissions, timestamps, and pointers to data blocks) and the data blocks themselves (the actual content).

When you run rm filename, the system performs an unlink system call. This removes the directory entry (the filename) and decrements the link count in the inode. If the link count reaches zero and no process has the file open, the filesystem marks the inode and its associated data blocks as "free." **The data remains physically on the disk until it is overwritten by new write operations.

This distinction creates the golden rule of data recovery: Stop writing to the affected partition immediately. Every new log entry, package installation, or temporary file creation increases the probability of overwriting the sectors containing your lost data. If the file was on your root partition (/), the safest course of action is to power down the machine physically (pull the plug if necessary) and boot from a live USB environment to perform recovery.

Some disagree here. Fair enough.

Scenario 1: Recovering Files Still Held Open by a Process

This is the most common "oh no" moment for administrators. Because the process holds a file descriptor, the link count never hits zero, and the data blocks are not marked as free. You accidentally deleted a massive log file or a database file that a running service (like Apache, MySQL, or a custom Python script) still has open. The file is invisible to ls but fully accessible via the /proc filesystem Small thing, real impact. Still holds up..

Steps to Recover via /proc

  1. Identify the Process ID (PID) holding the file open. Use lsof (List Open Files):

    lsof | grep deleted
    

    Look for entries marked (deleted). Note the PID (second column) and the File Descriptor (FD) number (fourth column, usually a number followed by a letter like u or w).

  2. manage to the Process File Descriptor Directory:

    cd /proc//fd
    

    Replace <PID> with the actual Process ID Simple as that..

  3. Locate the Symlink: Run ls -l. You will see numbered symlinks pointing to the original file paths, marked (deleted). Find the number matching the FD from step 1.

  4. Copy the Data to Safety: The symlink acts as a portal to the inode. Simply copy it to a safe location on a different partition if possible:

    cp  /home/user/recovered_file.log
    

    Example: cp 4 /home/user/recovered_mysql.ibd

This method is instantaneous, requires no external tools, and works perfectly as long as the process hasn't crashed or been restarted.

Scenario 2: Recovering from Backup and Snapshots

If the file is truly unlinked and no process holds it open, your first line of defense should always be your backup strategy. Modern Linux infrastructure often includes layers of snapshots that users forget exist.

LVM Snapshots

If your filesystem sits on an LVM (Logical Volume Manager) logical volume, check for existing snapshots:

lvs

If a snapshot exists (often created automatically by backup scripts or manual maintenance), you can mount it read-only and copy the file out:

mkdir /mnt/recovery
mount -o ro /dev/vg0/snap_var /mnt/recovery
cp /mnt/recovery/path/to/file /home/user/
umount /mnt/recovery

Filesystem Snapshots (Btrfs / ZFS)

If you are using Btrfs or ZFS, you likely have a solid snapshot mechanism built-in.

  • Btrfs: btrfs subvolume list / shows snapshots. Mount the specific snapshot ID (mount -o subvolid=XXX /dev/sdX /mnt) and retrieve the file.
  • ZFS: zfs list -t snapshot lists datasets. You can clone a snapshot (zfs clone tank/data@snap tank/recovery) or simply access the .zfs/snapshot directory hidden in the root of the dataset to browse previous versions instantly.

Rsync / Tar / Cloud Backups

Check your automated rsync jobs, tar archives, or cloud sync folders (Nextcloud, Dropbox, rclone mounts). Restoring from a known good backup is always faster and more reliable than forensic disk scraping.

Scenario 3: Forensic Recovery with extundelete (ext3/ext4)

When no backups exist and the file is not held open, you must scan the raw disk blocks. And for the ubiquitous ext3 and ext4 filesystems, extundelete is the standard go-to tool. It reads the filesystem journal and inode tables to find deleted entries.

Installation

On Debian/Ubuntu: sudo apt install extundelete On RHEL/Fedora: sudo dnf install extundelete On Arch: sudo pacman -S extundelete

Critical Preparation: Unmount or Remount Read-Only

You cannot safely run extundelete on a mounted read-write partition. The kernel might flush buffers or allocate new blocks during the scan, destroying the very data you want.

  1. Unmount the partition: umount /dev/sdXn
  2. If it is the root partition (/), you must boot from a Live USB (like SystemRescue, Ubuntu Live, or Kali).

Running the Recovery

The basic syntax is:

extundelete /dev/sdXn --restore-file /path/to/deleted/file
  • /dev/sdXn: The block device (e.g., /dev/sda3, /dev/nvme0n1p2).
  • --restore-file: Path relative to the root of that partition.

Useful Flags:

  • --restore-all: Recovers everything it can find into a RECOVERED_FILES directory in your current working directory. Use this if you aren't sure of the exact path.
  • --inode <num>: If you know the inode number (from debugfs or ls -i before deletion), this is the most precise method.
  • --after <timestamp> / --before <timestamp>: Limits recovery to files deleted within a specific time window (Unix epoch time).

Output: The tool creates a directory named RECOVERED_FILES in the folder where you ran the command. It attempts to recreate the directory structure. Note that filenames are often recovered, but if the directory entry was overwritten, files may appear named by their inode number (e.g., inode_12345) That's the part that actually makes a difference..

Scenario 4: Generic Carving with TestDisk and PhotoRec

When dealing with **XFS, JFS, ReiserFS, FAT32, NTFS

…or Btrfs, or when extundelete returns nothing useful, stop reaching for journal-based tools and switch to carving. The TestDisk suite handles both problems: TestDisk itself repairs partition tables and offers a limited undelete module, while PhotoRec ignores the filesystem entirely and hunts for file signatures in the raw bytes Still holds up..

TestDisk: Partition-Level Repair and Undelete

Launch it against the whole disk, not the partition:

sudo testdisk /dev/sdX

The TUI walks you through selecting the disk, the partition table type (Intel/PC for BIOS/MBR, EFI GPT for UEFI), then:

  • Analyse → Quick Search, followed by Deeper Search if the original layout isn't found. Deleted or lost partitions are shown in the geometry list; use P to view files inside a candidate before committing.
  • Write to commit a repaired partition table, or Backup BS / Rebuild BS to restore a clobbered boot sector (common after Windows reinstallations or dd accidents).
  • Advanced → Undelete exposes a file browser for FAT, NTFS and ext2 volumes, where deleted entries still present in the directory tree can be copied out with C.

TestDisk is the right first move when the problem is "the whole volume vanished" rather than "one file is missing."

PhotoRec: Signature Carving

PhotoRec reads every block and matches magic bytes, so it works on reformatted, repartitioned, corrupted or unknown filesystems

New on the Blog

The Latest

Keep the Thread Going

A Bit More for the Road

Thank you for reading about How To Restore Deleted Files In Linux. We hope the information has been useful. Feel free to contact us if you have any questions. See you next time — don't forget to bookmark!
⌂ Back to Home