Linux File Types and Links

Published: December 2025 | Topic: File System Fundamentals for DevOps

Understanding Linux file types and links is essential for effective system management. From organizing configuration files to managing application data, knowing how files are structured and linked helps you troubleshoot issues, optimize storage, and implement efficient deployment strategies.

The "Everything is a File" Philosophy

Linux follows a unique philosophy: everything is a file. This includes:

• Regular files: Documents, programs, scripts, data
• Directories: Special files that contain other files
• Links: References to other files
• Devices: Hardware interfaces represented as files
• Sockets: Network communication endpoints
• Named pipes: Inter-process communication channels

This unified approach simplifies system programming and administration. You can use the same commands (like cat, echo, ls) to interact with different types of "files".

Linux File Types: The First Character

Identifying File Types with ls -l

The first character in ls -l output indicates the file type:

$ ls -l
-rw-r--r-- 1 user group 2048 Dec 1 file.txt
drwxr-xr-x 2 user group 4096 Dec 1 directory/
lrwxrwxrwx 1 user group 10 Dec 1 link -> target
crw-r--r-- 1 root root 1, 3 Dec 1 /dev/null
brw-rw---- 1 root disk 8, 0 Dec 1 /dev/sda
srw-rw-rw- 1 user group 0 Dec 1 socket
prw------- 1 user group 0 Dec 1 pipe
# ↑ First character indicates file type

- Regular File

The most common file type. Contains data of any kind: text, binary, images, etc.

# Examples:
/etc/passwd
/home/user/.bashrc
/var/log/syslog
/usr/bin/bash

DevOps Relevance: Configuration files, log files, scripts, application binaries.

d Directory

A special file that contains other files. Acts as a container for organizing the filesystem.

# Examples:
/etc/
/var/log/
/home/user/
/usr/bin/

DevOps Relevance: Organizing configuration, logs, application data, and deployment artifacts.

l Symbolic Link

A pointer to another file or directory. Contains a path to the target file.

# Examples:
/usr/bin/python → python3.9
/etc/localtime → ../usr/share/zoneinfo/UTC

DevOps Relevance: Version management, configuration switching, dependency management.

c Character Device

Represents a character-oriented hardware device. Data is processed character by character.

# Examples:
/dev/tty1 (terminal)
/dev/null (data sink)
/dev/random (random data)

DevOps Relevance: Interacting with terminals, handling input/output redirection.

b Block Device

Represents a block-oriented hardware device. Data is processed in fixed-size blocks.

# Examples:
/dev/sda (hard disk)
/dev/sdb1 (partition)
/dev/loop0 (loop device)

DevOps Relevance: Disk management, filesystem operations, container storage.

s Socket

A special file for network communication between processes. Allows data exchange.

# Examples:
/var/run/docker.sock
/var/run/mysql/mysql.sock
/tmp/.X11-unix/X0

DevOps Relevance: Docker communication, database connections, inter-service communication.

p Named Pipe (FIFO)

First-In-First-Out special file for inter-process communication.

# Examples:
Created with: mkfifo mypipe
Used for: process communication

DevOps Relevance: Script coordination, logging pipelines, process communication.

Identifying File Types in DevOps

Use these commands to identify and work with different file types:

# Check file type
$ file /etc/passwd
/etc/passwd: ASCII text

$ file /dev/null
/dev/null: character special

# Find all symbolic links in a directory
$ find /etc -type l | head -5

# Check if a path is a directory
$ [ -d /etc ] && echo "Is a directory"

# Check if a path is a regular file
$ [ -f /etc/passwd ] && echo "Is a regular file"

Understanding Inodes: The File's Identity

What is an Inode?

An inode (index node) is a data structure that stores metadata about a file, but not the filename or the file data itself.

Inode #1234
Size: 4096 bytes
Owner: alice
Permissions: 644
Timestamps
Data block pointers

→

Data Blocks
Actual file content

Each inode contains:

• File size in bytes
• Device ID where the file is stored
• User ID of the file owner
• Group ID of the file group
• File mode (permissions and file type)
• Timestamps: access, modification, change times
• Link count: number of hard links to the file
• Pointers to data blocks on disk

# View inode number and file details
$ ls -i file.txt
123456 file.txt

$ stat file.txt
File: file.txt
Size: 4096 Blocks: 8 IO Block: 4096 regular file
Device: 801h/2049d Inode: 123456 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 1000/ alice) Gid: ( 1000/ alice)
Access: 2023-12-01 10:00:00.000000000 +0000
Modify: 2023-12-01 09:00:00.000000000 +0000
Change: 2023-12-01 09:00:00.000000000 +0000

Inode Limits and DevOps Implications

Filesystems have a fixed number of inodes allocated during creation. Running out of inodes can happen even with free disk space!

# Check inode usage on filesystem
$ df -i
Filesystem Inodes IUsed IFree IUse% Mounted on
/dev/sda1 655360 123456 531904 19% /

# Find directories with many files (high inode usage)
$ find /var -type f | cut -d/ -f1-3 | sort | uniq -c | sort -rn

# Common inode exhaustion scenarios:
# - Small files (logs, cache entries) accumulating
# - Docker/container images with many layers
# - Email servers with many small messages

DevOps Tip: Monitor inode usage along with disk space. Use df -i regularly in your monitoring.

Linux Links: Hard Links vs Symbolic Links

The Two Types of Links in Linux

Links allow multiple names to refer to the same file. Understanding the difference is crucial for system management.

Hard Links

Multiple directory entries pointing to the same inode. All hard links are equal - no "original" vs "link".

Directory Entry 1
"file.txt" → inode #1234

=

Inode #1234
File Metadata + Data

←

Directory Entry 2
"backup.txt" → inode #1234

# Create a hard link
$ ln original.txt hardlink.txt

# Verify they share the same inode
$ ls -i original.txt hardlink.txt
123456 original.txt
123456 hardlink.txt

# Check link count increases
$ ls -l original.txt
-rw-r--r-- 2 user group 1024 Dec 1 original.txt
# ↑ Link count is now 2

Symbolic Links (Soft Links)

A special file containing a path to another file. Like a shortcut or pointer.

Symbolic Link
"link.txt" → "original.txt"

→

Directory Entry
"original.txt" → inode #1234

→

Inode #1234
File Metadata + Data

# Create a symbolic link
$ ln -s original.txt symlink.txt

# Verify it's a link with different inode
$ ls -l symlink.txt
lrwxrwxrwx 1 user group 12 Dec 1 symlink.txt -> original.txt

$ ls -i original.txt symlink.txt
123456 original.txt
789012 symlink.txt
# ↑ Different inodes!

Hard Links vs Symbolic Links: Detailed Comparison

Aspect	Hard Links	Symbolic Links
Inode	Shares same inode as original	Has its own inode
Link Count	Increases link count in inode	Doesn't affect original's link count
Cross-Filesystem	❌ Not allowed	✅ Allowed
Link to Directory	❌ Not allowed (except root)	✅ Allowed
Original Deleted	✅ Link still works (data preserved until last link gone)	❌ Link breaks (dangling link)
Disk Space	Minimal (just directory entry)	Small (stores path string)
Performance	Same as original (direct access)	Slight overhead (path resolution)
Permissions	Same as original (shared inode)	Always 777 (but target's permissions apply)
ls -l Output	Looks like regular file	Shows "l" type and target with →
Creation Command	ln source target	ln -s source target

⚠️ Common Link Pitfalls in DevOps

• Broken symlinks: When the target is moved/deleted, symlinks become broken (dangling)
• Circular references: Symlinks pointing to themselves or creating loops
• Permission confusion: Symlinks show 777 but use target's permissions
• Link traversal attacks: Security risk with symlinks in writable directories
• Backup issues: Hard links can confuse backup tools about "duplicate" files

# Find broken symlinks
$ find /path -type l ! -exec test -e {} \; -print

# Find symlinks to directories (potential security risk)
$ find /path -type l -exec ls -ld {} \;

Practical Link Usage in DevOps

Real-World Use Cases for Links

Version Management

Switch between different versions of software or configurations.

# Python version management
$ ln -sf /usr/bin/python3.9 /usr/bin/python

# Application version switching
$ ln -sf /opt/app/v2.1.0 /opt/app/current

Configuration Management

Manage different environment configurations.

# Environment-specific configs
$ ln -sf config.production.json config.json

# Shared configuration files
$ ln -s /etc/ssl/certs/ca-certificates.crt
    /opt/app/certs/ca-bundle.crt

Log Management

Rotate logs without interrupting applications.

# Log rotation pattern
$ mv app.log app.log.1
$ ln -sf /var/log/app/app.log
    /var/run/app/app.log

Dependency Management

Point to shared libraries or resources.

# Library version aliasing
$ ln -s libssl.so.1.1 libssl.so

# Shared data directories
$ ln -s /shared/data /opt/app/data

Docker/Container Link Patterns

Containers make extensive use of links for various purposes:

# Docker socket access
$ ls -l /var/run/docker.sock
srw-rw---- 1 root docker 0 Dec 1 /var/run/docker.sock
# ↑ It's a socket file, not a regular file

# Volume mounts often use bind mounts (similar to hard links)
$ docker run -v /host/path:/container/path app

# Symbolic links in container images
$ docker exec container ls -l /usr/bin/python
lrwxrwxrwx 1 root root 9 Nov 1 /usr/bin/python -> python3.9

Working with Special Device Files

/dev Directory: Device Files in Action

The /dev directory contains device files that represent hardware and virtual devices.

Common Character Devices

# /dev/null - The data sink
$ echo "unwanted output" > /dev/null

# /dev/zero - Infinite zero bytes
$ dd if=/dev/zero of=file.bin bs=1M count=100

# /dev/random - Random data
$ head -c 32 /dev/random | base64

# /dev/tty - Current terminal
$ echo "Hello" > /dev/tty

Common Block Devices

# Disk devices
$ ls -l /dev/sd*
brw-rw---- 1 root disk 8, 0 Dec 1 /dev/sda
brw-rw---- 1 root disk 8, 1 Dec 1 /dev/sda1

# Loop devices (for mounting files as disks)
$ losetup -f
/dev/loop0

# Check device type
$ file -s /dev/sda1
/dev/sda1: Linux filesystem data

Sockets and Named Pipes in DevOps

Inter-Process Communication Files

Sockets (Type: s)

Network communication endpoints, often used for local IPC.

# Docker daemon socket
$ ls -l /var/run/docker.sock
srw-rw---- 1 root docker 0 Dec 1 /var/run/docker.sock

# MySQL socket
$ ls -l /var/run/mysqld/mysqld.sock
srwxrwxrwx 1 mysql mysql 0 Dec 1 mysqld.sock

# Test socket connection
$ echo "status" | nc -U /var/run/mysqld/mysqld.sock

Named Pipes (FIFO) (Type: p)

First-In-First-Out files for process communication.

# Create a named pipe
$ mkfifo mypipe

# Use in shell scripting
# Terminal 1: Read from pipe
$ while true; do cat mypipe; done

# Terminal 2: Write to pipe
$ echo "Hello" > mypipe

# Check pipe type
$ ls -l mypipe
prw-r--r-- 1 user group 0 Dec 1 mypipe

Essential Commands for Working with File Types and Links

File Type Identification

$ ls -l # View file types in first column
$ file filename # Determine file type
$ stat filename # Detailed file info including inode
$ find /path -type f # Find regular files
$ find /path -type d # Find directories
$ find /path -type l # Find symbolic links

Link Management

$ ln source target # Create hard link
$ ln -s source target # Create symbolic link
$ readlink symlink # Show where symlink points
$ ls -i file # Show inode number
$ find -L /path -type l -exec test ! -e {} \; -print
# Find broken symlinks

Inode Management

$ df -i # Show inode usage by filesystem
$ ls -i file # Show file's inode number
$ find /path -printf "%i %p\n" # List inodes with paths
$ debugfs -R "stat <123456>" /dev/sda1
# Examine inode directly (for experts)

Troubleshooting File Type Issues

Common Problems and Solutions

Broken Symbolic Links

When the target file is moved or deleted.

# Find broken links
$ find /path -type l -exec test ! -e {} \; -print

# Fix: Update or remove broken link
$ ln -sf new_target broken_link
$ rm broken_link

Inode Exhaustion

Filesystem has free space but no inodes.

# Check inode usage
$ df -i

# Find directories with many files
$ find /path -type f | cut -d/ -f1-3 |
    sort | uniq -c | sort -rn

Device File Issues

Missing or incorrect device files.

# Check if device file exists
$ ls -l /dev/null

# Create missing device file
$ mknod /dev/mycdev c 1 3
# Major=1, Minor=3 (like /dev/null)

File Type Confusion

Commands failing due to wrong file type.

# Check actual file type
$ file suspicious_file

# Test with appropriate command
$ cat regular_file.txt
$ cd directory/
$ readlink symbolic_link

Best Practices for DevOps

Working with File Types and Links

1. Prefer symbolic links over hard links for most DevOps use cases (more flexible, visible)
2. Monitor inode usage along with disk space in your monitoring systems
3. Use absolute paths for symbolic links that might be accessed from different locations
4. Regularly check for broken links in configuration directories
5. Understand device files when working with containers, volumes, or specialized hardware
6. Use file command to verify file types when debugging
7. Be careful with symlinks in shared/writable directories (security risk)
8. Document important links in your infrastructure documentation
9. Test link behavior during deployment to ensure they work as expected
10. Clean up temporary named pipes and sockets after use

Practice Scenarios for DevOps Engineers

1. Your application reports "Too many open files" but df -h shows plenty of disk space. What do you check?
2. You need to switch between Python 3.8 and 3.9 for different applications. How would you manage this with links?
3. A log rotation script is failing. You discover it's trying to move a symbolic link instead of the actual log file. How do you fix this?
4. Your Docker container can't connect to the Docker socket. You check and find /var/run/docker.sock exists. What do you check next?
5. You need to share a configuration file between two containers without duplicating it. What link strategy would you use?
6. During deployment, your script needs to atomically switch from old to new version. How can links help?
7. You find a directory with thousands of small cache files. How do you determine if this is causing inode exhaustion?

Key Takeaways

• Linux has 7 file types: Regular (-), Directory (d), Symbolic link (l), Character device (c), Block device (b), Socket (s), Named pipe (p)
• Inodes store metadata: Everything except filename and actual data
• Hard links share inodes: Multiple names for same data, can't cross filesystems
• Symbolic links are pointers: Contain paths to targets, can cross filesystems
• Monitor inode usage: Can exhaust even with free disk space
• Everything is a file: Simplifies system programming and administration
• Links are powerful tools: For version management, configuration switching, and resource sharing

Understanding file types and links gives you deeper insight into how Linux systems work and provides powerful tools for managing applications and infrastructure in DevOps environments.