Table of Contents
- What Is a File System?
- The Linux File System Hierarchy: A Bird’s-Eye View
- Key Directories Explained
- Files vs. Directories: Everything Is a File!
- Absolute vs. Relative Paths
- Basic Navigation Commands
- File Permissions and Ownership
- Mounting and Unmounting Drives
- Common Pitfalls for Newbies (and How to Avoid Them)
- Conclusion
- References
1. What Is a File System?
A file system is a set of rules that governs how data is stored, organized, and retrieved on a storage device (e.g., hard drive, SSD, USB stick). It defines:
- How files are named and structured.
- How directories (folders) organize files.
- How permissions control access to files.
- How the operating system reads/writes data to the storage device.
In Linux, the file system adheres to the Filesystem Hierarchy Standard (FHS), a set of guidelines that ensures consistency across all Linux distributions (e.g., Ubuntu, Fedora, Debian). This standardization means the directory structure works the same way, no matter which Linux flavor you use!
2. The Linux File System Hierarchy: A Bird’s-Eye View
Imagine the Linux file system as an upside-down tree. At the top is the root directory (/), and all other directories branch out from it. Unlike Windows, there are no drive letters—external drives, USB sticks, or partitions are “mounted” (attached) to directories within this single tree.
Here’s a simplified diagram to visualize it:
/
├── bin/
├── boot/
├── dev/
├── etc/
├── home/
│ ├── alice/
│ └── bob/
├── lib/
├── media/
│ └── usb-drive/
├── mnt/
├── opt/
├── proc/
├── root/
├── sbin/
├── sys/
├── tmp/
├── usr/
│ ├── bin/
│ ├── lib/
│ └── share/
└── var/ 3. Key Directories Explained
Let’s dive into the most important directories in the Linux file system. Understanding what each contains will help you navigate with purpose.
/ (Root)
The root directory is the starting point of the entire file system. Every file and directory in Linux is a child of /. Think of it as the trunk of the tree—all branches (directories) grow from here.
Example: To list all files in root, run ls / (but you’ll need sudo to see all contents).
/bin and /sbin
- /bin: Contains binary executables (programs) essential for basic system operation. These are available to all users (e.g.,
ls,cp,cd,mkdir). - /sbin: Similar to
/bin, but contains executables for system administration (e.g.,reboot,fdisk,mount). These are typically run by the root user (usesudoto access them).
/boot
Stores files needed to boot the system, such as the Linux kernel (vmlinuz), initial RAM disk (initrd), and bootloader configuration (e.g., grub.cfg for GRUB). Never delete files here—your system might fail to boot!
/dev
Short for devices, this directory contains special files that represent hardware and system devices (e.g., hard drives, keyboards, mice). Linux treats everything as a file, including devices.
Examples:
/dev/sda: The first SATA hard drive./dev/sda1: The first partition on/dev/sda./dev/null: A “black hole” where data is discarded (useful for redirecting unwanted output).
/etc
Short for et cetera, this directory stores system-wide configuration files. Nearly every application and service on your system (e.g., ssh, apache, networking) has config files here.
Examples:
/etc/passwd: User account information./etc/fstab: Disk mounting configuration./etc/hosts: Local DNS mappings.
/home
This is where user-specific files live. Each user gets their own subdirectory (e.g., /home/alice or /home/bob), containing documents, downloads, photos, and personal settings.
- Your home directory is also accessible via the shortcut
~(e.g.,cd ~takes you to your home). - The
sudouser’s home is/root(not in/home).
/lib and /lib64
Store shared libraries (code reused by programs) and kernel modules.
/lib: 32-bit libraries (on 32-bit systems) or core 64-bit libraries (on 64-bit systems)./lib64: 64-bit libraries (on 64-bit systems only).
Example: libc.so.6 is the GNU C library, used by almost all Linux programs.
/media and /mnt
Both are used to mount external storage devices (e.g., USB drives, external HDDs, CDs).
- /media: Automatically used by desktop environments (e.g., GNOME, KDE) to mount removable devices (e.g.,
/media/alice/USB-Drive). - /mnt: Traditionally used for manual mounting (e.g.,
sudo mount /dev/sdb1 /mnt/my-drive).
/opt
Short for optional, this directory is for installing third-party software (e.g., proprietary apps like Google Chrome or Steam). Unlike system packages (installed via apt or dnf), software here is often self-contained.
/proc and /sys
These are virtual file systems—they don’t store data on disk but provide real-time access to system and process information.
- /proc: Contains data about running processes and system resources.
Example:/proc/cpuinfoshows CPU details;/proc/meminfoshows memory usage. - /sys: Exposes hardware and kernel settings (e.g.,
/sys/class/netfor network interfaces).
/root
The home directory for the root user (the superuser with full system access). Regular users cannot write here unless using sudo.
/tmp
Short for temporary, this directory stores files that are only needed temporarily (e.g., logs, caches). Files here are often deleted on reboot, so never store important data here!
/usr
Short for Unix System Resources, this is a secondary hierarchy for user utilities and applications. It contains:
/usr/bin: Non-essential binaries (e.g.,git,python)./usr/lib: Libraries for/usr/binprograms./usr/share: Shared data (e.g., documentation, icons)./usr/local: Custom software installed by the user (e.g., compiled from source).
/var
Short for variable, this directory stores files that change frequently (e.g., logs, spool files, databases).
Examples:
/var/log: System and application logs (e.g.,syslog,auth.log)./var/www: Web server files (for Apache/Nginx)./var/cache: Temporary cached data (e.g., package manager cache).
4. Files vs. Directories: Everything Is a File!
In Linux, everything is treated as a file—even directories, devices, and network sockets. This uniformity simplifies how the system interacts with data.
- Regular files: Text, images, binaries, etc. (e.g.,
document.txt,image.jpg). - Directories: Special files that organize other files (like folders).
- Symbolic links (symlinks): Shortcuts to other files/directories (e.g.,
ln -s /home/alice/docs ~/docscreates a link). - Device files: Represent hardware (e.g.,
/dev/sdafor a hard drive). - Pipes and sockets: For inter-process communication (e.g.,
|in commands uses pipes).
5. Absolute vs. Relative Paths
To navigate the file system, you need to specify paths—the location of a file or directory. There are two types:
Absolute Paths
Start from the root directory (/) and list every directory leading to the target. They always begin with /.
Examples:
/home/alice/Documents/report.pdf/etc/nginx/nginx.conf
Relative Paths
Start from your current working directory (the directory you’re in). They do not begin with /.
Examples:
- If you’re in
/home/alice,Documents/report.pdfpoints to/home/alice/Documents/report.pdf. ../bob(the..means “parent directory”) navigates from/home/aliceto/home/bob.
Pro Tip: Use pwd (print working directory) to check your current location!
6. Basic Navigation Commands
Here are essential commands to move around and manage files:
| Command | Purpose | Example |
|---|---|---|
pwd | Print current working directory | pwd → /home/alice |
ls | List files in current directory | ls → Documents Downloads Music |
ls -la | List all files (including hidden ones) with details | ls -la → Shows permissions, size, etc. |
cd [path] | Change directory | cd Documents → Move to Documents |
cd ~ | Go to your home directory | cd ~ → /home/alice |
cd .. | Go to parent directory | cd .. → From /home/alice to /home |
mkdir [name] | Create a new directory | mkdir Projects → Makes a Projects folder |
touch [file] | Create an empty file | touch notes.txt → Creates notes.txt |
cp [src] [dest] | Copy a file/directory | cp notes.txt ~/Backups/ |
mv [src] [dest] | Move/rename a file/directory | mv notes.txt important-notes.txt |
rm [file] | Delete a file (permanent!) | rm old.txt → Deletes old.txt |
rm -r [dir] | Delete a directory and its contents | rm -r OldProjects → Deletes the folder |
7. File Permissions and Ownership
Linux is a multi-user system, so it uses permissions to control who can read, write, or execute files. Let’s break this down:
Permissions Basics
Run ls -la in any directory, and you’ll see entries like this:
-rw-r--r-- 1 alice alice 1024 Oct 5 14:30 notes.txt The first 10 characters (-rw-r--r--) represent permissions:
- 1st character: File type (
-= regular file,d= directory,l= symlink). - Next 3: Permissions for the owner (user).
- Next 3: Permissions for the group.
- Next 3: Permissions for others (everyone else).
Permission Types
Permissions are represented by letters:
r: Read (view the file/directory).w: Write (edit/delete the file/directory).x: Execute (run the file as a program, or enter a directory).
In the example -rw-r--r--:
- Owner (
alice) hasrw-(read/write, no execute). - Group (
alice) hasr--(read only). - Others have
r--(read only).
Numeric Notation (Chmod)
Permissions can also be represented by numbers (0-7), where:
r= 4,w= 2,x= 1.- Sum the values for each category (owner, group, others).
Example: rw-r--r-- = 644 (owner: 4+2=6; group: 4; others: 4).
To change permissions, use chmod:
chmod 600 secret.txt # Owner: rw-, Group: none, Others: none
chmod +x script.sh # Add execute permission for everyone
chmod u+x script.sh # Add execute permission only for owner Ownership
Every file has an owner (user) and a group. To change ownership:
chown [user]:[group] file→sudo chown bob:users report.txt(gives ownership to userboband groupusers).
8. Mounting and Unmounting Drives
Since Linux uses a single directory tree, external drives (USBs, SSDs) must be mounted (attached) to a directory before use. Here’s how:
Mounting a Drive
- Identify the drive: Use
lsblkto list all storage devices (e.g.,/dev/sdb1is a USB drive). - Create a mount point (directory):
sudo mkdir /mnt/my-usb. - Mount the drive:
sudo mount /dev/sdb1 /mnt/my-usb.
Now you can access the drive’s files at /mnt/my-usb.
Unmounting a Drive
Always unmount before disconnecting to avoid data loss:
sudo umount /mnt/my-usb Automounting with /etc/fstab
To mount drives automatically at boot, edit /etc/fstab (use sudo nano /etc/fstab). Add a line like:
/dev/sdb1 /mnt/my-usb ext4 defaults 0 2 /dev/sdb1: Drive/partition./mnt/my-usb: Mount point.ext4: File system type (e.g.,ntfsfor Windows drives).
9. Common Pitfalls for Newbies (and How to Avoid Them)
- Case sensitivity: Linux filenames are case-sensitive!
File.txtandfile.txtare different. - Accidental deletion:
rm -rf /(as root) will delete your entire system. Always double-check paths before runningrm. - Forgetting
sudo: System files (e.g., in/etcor/usr) requiresudoto edit/delete. - Ignoring permissions: If you can’t edit a file, check permissions with
ls -land usechmodorchownto fix them. - Misusing paths: Use absolute paths (e.g.,
/home/alice/file) if you’re unsure of your current directory.
10. Conclusion
The Linux file system is a logical, unified tree with / at its root. By understanding key directories like /home, /etc, and /var, and mastering commands like cd, ls, and chmod, you’ll navigate Linux with ease. Remember: everything is a file, permissions matter, and the FHS keeps things consistent across distributions.
Practice exploring with ls, cd, and pwd—the more you use it, the more intuitive it becomes!
11. References
- Filesystem Hierarchy Standard (FHS)
- Linux Man Pages (e.g.,
man lsorman chmodfor command details) - Ubuntu File System Explained
- Linux Journey: File System
Let me know in the comments if you have questions—happy Linux-ing! 🐧