File Types and Links (Hard vs Soft Links)

Published on November 19, 2025 by Team SKY | Tags: DevOps

Understanding Linux file types and links is essential for effective file system management. Links allow multiple names to point to the same file data, while different file types serve specific purposes in the system. This guide explores hard links, soft links, and various file types with practical examples.

Linux File Types

In Linux, everything is a file. The first character in ls -l output indicates the file type:

📄
-

Regular File

Standard files containing data, text, programs, or any content.

Examples: documents, images, scripts, binaries

Create: touch file.txt, nano document

📁
d

Directory

Containers that hold files and other directories.

Examples: /home, /etc, /var/log

Create: mkdir newdir

🔗
l

Symbolic Link

Pointers to other files or directories (soft links).

Examples: shortcuts to files in different locations

Create: ln -s target linkname

⚙️
c

Character Device

Devices that transfer data character by character.

Examples: terminals, keyboards, serial ports

Location: /dev/tty1, /dev/null

💾
b

Block Device

Devices that transfer data in blocks.

Examples: hard drives, USB drives, CD-ROM

Location: /dev/sda1, /dev/sr0

🔌
s

Socket

Inter-process communication endpoints.

Examples: network sockets, Unix domain sockets

Location: /var/run/ databases, services

📮
p

Named Pipe

First-In-First-Out (FIFO) communication channels.

Examples: inter-process communication

Create: mkfifo pipe_name

Understanding Inodes

Inodes are data structures that store information about files (except the filename and actual data).

Inode 1234
├── Permissions: -rw-r--r--
├── Owner: john:users
├── Size: 1024 bytes
├── Creation Time: Nov 19 10:30
├── Modification Time: Nov 19 10:35
├── Link Count: 2
└── Data Blocks: 2048, 2049, 2050

File Names pointing to this inode:
├── /home/john/document.txt
└── /home/john/backups/doc_backup.txt
Inode Insight: Use ls -i to see inode numbers, stat filename for detailed inode information, and df -i to check inode usage on filesystems.

Hard Links vs Soft Links

Aspect Hard Links Soft Links (Symbolic Links)
Definition Multiple directory entries pointing to same inode Special file containing path to target file
Inode Same inode as original file Different inode from target
Cross-Filesystem ❌ Not allowed ✅ Allowed
Directory Links ❌ Not allowed (except . and ..) ✅ Allowed
Original File Deletion Data remains until all links deleted Link becomes broken (dangling)
File Size Same size as original Small (contains path length)
ls -l Output Looks like regular file lrwxrwxrwx → target_path

Visual Representation

Hard Link: File1 ↔ Inode ↔ File2 (both equal)

Soft Link: LinkFile → Path → TargetFile (pointer)

Creating and Managing Links

🔗

Hard Links

Create additional names for the same file data

ln original_file link_name

Examples:

  • ln document.txt backup_doc.txt - Create hard link
  • ls -i document.txt backup_doc.txt - Check same inode
  • echo "new content" > document.txt - Both files updated

Note: Cannot link directories or across filesystems

🔗

Soft Links (Symbolic)

Create pointers to files or directories

ln -s target_path link_name

Examples:

  • ln -s /var/log/syslog syslog_link - Link to system log
  • ln -s ../config/app.conf app_config - Relative path link
  • ln -s /mnt/remote/share/ remote_data - Cross-filesystem

Note: Can link directories and work across filesystems

👁️

Link Inspection

Examine and verify link properties

ls -l link_name

Commands:

  • ls -l - See link type and target
  • ls -i - View inode numbers
  • readlink link_name - Show link target
  • file link_name - Identify link type
  • stat link_name - Detailed link information

Practical Examples

Hands-On Link Practice

# 1. Create test files and directory
mkdir link_test && cd link_test
echo "Original file content" > original.txt
ls -li original.txt

# 2. Create hard link
ln original.txt hard_link.txt
ls -li *.txt  # Notice same inode numbers

# 3. Create soft link
ln -s original.txt soft_link.txt
ls -l  # Notice 'l' type and arrow

# 4. Test modifications
echo "Appended content" >> original.txt
cat hard_link.txt  # Shows updated content
cat soft_link.txt  # Also shows updated content

# 5. Check link properties
readlink soft_link.txt
stat hard_link.txt
stat soft_link.txt

# 6. Test deletion scenarios
rm original.txt
cat hard_link.txt  # Still works - data preserved
cat soft_link.txt  # Broken link - "No such file or directory"

# 7. Clean up
rm hard_link.txt soft_link.txt
cd .. && rmdir link_test

Use Cases and Best Practices

When to Use Hard Links

  • Backup Systems: Multiple references to same data without duplication
  • Version Control: Git uses hard links internally for efficiency
  • Space Efficiency: No extra storage used for additional links
  • Data Integrity: Data persists until all links are removed

When to Use Soft Links

  • Directory Shortcuts: Quick access to deeply nested directories
  • Cross-Filesystem Links: Linking between different storage devices
  • Version Management: /usr/bin/python → /usr/bin/python3.9
  • Application Compatibility: Maintaining backward compatibility
  • Configuration Flexibility: Pointing to different config files

Best Practices

  • Use absolute paths for soft links to avoid broken links when moving
  • Regularly check for broken soft links with find /path -type l -xtype l
  • Be cautious with recursive operations on directories containing links
  • Understand that hard links increase link count in inode
  • Use unlink command to remove single links safely
Important Considerations:
• Hard links cannot span different filesystems
• Deleting all hard links permanently removes the file data
• Soft links can become broken if the target is moved or deleted
• Some commands (like tar) have options to handle links specially
• Be careful with recursive operations that might follow symbolic links

Advanced Link Operations

Finding Links:
find /path -samefile filename - Find all hard links to a file
find /path -inum 12345 - Find files by inode number
find /path -type l - Find all symbolic links
find /path -type l -ls - Detailed info about symbolic links

Link Management:
ln -f existing_link new_target - Force update existing link
ln -i target link - Interactive (prompt before overwrite)
unlink broken_link - Remove a single link
cp -P file link - Copy without following symbolic links
cp -L file link - Copy by following symbolic links

Real-World Examples

System Administration:
# Create log directory shortcut
sudo ln -s /var/log/apache2/ /home/admin/apache_logs

# Version management for Python
sudo ln -s /usr/bin/python3.9 /usr/bin/python
sudo ln -s /usr/bin/pip3 /usr/bin/pip

Development:
# Link to shared libraries
ln -s /usr/local/lib/libcustom.so /project/libs/

# Configuration management
ln -s /etc/app/config.prod /app/config

Backup Strategy:
# Create hard links for backup without duplication
cp -al /source/data /backup/daily.0
# Subsequent backups use hard links for unchanged files

Key Takeaways

Hard links and soft links provide powerful ways to manage file references in Linux. Hard links create multiple directory entries for the same data (same inode), while soft links create pointers to target files (different inode). Understanding when to use each type, their limitations, and best practices is crucial for efficient file system management, backup strategies, and system administration.

Next Step: Explore Linux process management to understand how the system handles running programs and system services.