⚡ Quick Answer
Linux uses a single unified directory tree rooted at
/ (the root directory). Everything — files, devices, network connections — is represented as a file somewhere in this tree. Key directories to know for the A+: /etc (config files), /var (variable data/logs), /home (user files), /bin and /usr/bin (executables), /tmp (temporary files), /boot (kernel and bootloader). Linux uses ext4 as its primary file system. Permissions are controlled with chmod using octal notation (755, 644) or symbolic notation (rwxr-xr-x).
The Linux Directory Tree
Unlike Windows (which uses drive letters like C:\ and D:\), Linux has a single hierarchical file system rooted at /. All storage devices — internal drives, USB drives, network shares — are mounted somewhere within this tree. This design is called the Filesystem Hierarchy Standard (FHS).
Linux Directory Structure
/ root of the entire file system
├── /etc system-wide configuration files
├── /var variable data — logs, databases, mail
├── /home user home directories (/home/username)
├── /bin essential user binaries (ls, cp, mv)
├── /sbin system binaries (ifconfig, fsck) — usually needs root
├── /tmp temporary files — cleared on reboot
├── /boot kernel, bootloader (GRUB), initrd
├── /usr user programs and data
│ ├── /usr/bin non-essential user commands
│ └── /usr/share shared data, man pages, docs
├── /dev device files (sda, tty, null)
├── /proc virtual filesystem — running processes and kernel info
├── /sys virtual filesystem — hardware and kernel interfaces
├── /mnt manual mount point for temporary mounts
├── /media auto-mount point for removable media (USB, CD)
├── /opt optional/third-party software packages
└── /root home directory for the root user (not /home/root)
Key Directories — What's Actually in Each
/etc
Configuration Files
System-wide configuration for all services and applications. No executables — only text config files. If you need to change how a service behaves, the config file lives here. Readable by all users, writable only by root.
/etc/passwd · /etc/hosts · /etc/ssh/sshd_config · /etc/fstab · /etc/apt/sources.list
/var
Variable Data
Data that changes as the system runs — log files, mail spools, databases, cache. If a service writes data while running, it goes in /var. The most important subdirectory for troubleshooting is /var/log.
/var/log/syslog · /var/log/auth.log · /var/log/kern.log · /var/www (web files)
/home
User Home Directories
Each user has a subdirectory here —
/home/sean, /home/alice. Contains the user's personal files, desktop, downloads, and user-specific config files (dotfiles like .bashrc). Users own and control their own home directory./home/username/Desktop · /home/username/.bashrc · /home/username/Documents
/bin & /usr/bin
Executables / Binaries
/bin contains essential commands needed for basic system operation — available even if /usr is not mounted (e.g., in recovery mode). /usr/bin contains general user commands installed with the OS. Most commands you use daily live here.
/bin/ls · /bin/cp · /bin/bash · /usr/bin/grep · /usr/bin/python3
/tmp
Temporary Files
Writable by all users — applications store temporary files here. Contents are typically cleared on reboot. Attackers sometimes use /tmp to stage malware because it's world-writable. Files here should never be considered permanent.
Installer staging files · Temp browser downloads · Application session files
/boot
Boot Files
The Linux kernel, initial RAM disk (initrd/initramfs), and bootloader configuration (GRUB). Do not delete files from /boot — the system will not boot. Usually on a separate partition to ensure the bootloader can always access it.
/boot/vmlinuz (kernel) · /boot/initrd.img · /boot/grub/grub.cfg
/dev
Device Files
Every hardware device is represented as a file. Hard drives are
/dev/sda, /dev/sdb; partitions are /dev/sda1. NVMe drives are /dev/nvme0n1. Special files like /dev/null (discard output) and /dev/zero (generate zeros) live here./dev/sda · /dev/sda1 · /dev/nvme0n1 · /dev/null · /dev/tty
/root
Root User's Home
The home directory for the root (superuser) account. Note: this is NOT /home/root — it is its own top-level directory. Only accessible to the root user. Keeps root's personal files separate from the system and other users.
/root/.bashrc · /root/.ssh · /root/scripts
Linux File System Types
| File System | Used On | Key Features | A+ Relevance |
|---|---|---|---|
| ext4 | Linux (primary) | Journaling, max file size 16 TB, max volume 1 EB. Default on most Linux distros. Backward compatible with ext3/ext2. | Know this is the standard Linux file system |
| ext3 | Linux (older) | Journaling added over ext2. Slower than ext4. Legacy — still found on older systems. | Know it preceded ext4 |
| XFS | Linux (enterprise) | High-performance journaling file system. Default on RHEL/CentOS. Excellent for large files and high I/O workloads. | Know it's a Linux enterprise option |
| FAT32 | USB drives, cross-platform | Compatible with Windows, macOS, Linux. Max file size 4 GB — cannot store files larger than 4 GB. No permissions or journaling. | Common on USB drives — 4 GB limit is exam-tested |
| exFAT | USB, flash drives | FAT32 successor — no 4 GB file size limit. Cross-platform compatible. No journaling. Common on modern USB drives and SD cards. | Replacement for FAT32 for large files on removable media |
| NTFS | Windows (primary) | Journaling, file-level permissions, encryption (EFS), compression, large file support. Linux can read NTFS natively with ntfs-3g driver. | Know Linux can read NTFS drives |
| swap | Linux (virtual memory) | Not a traditional file system — a dedicated partition used as virtual memory overflow when RAM is full. Similar to Windows pagefile. | Know this is Linux's virtual memory partition |
🎯 FAT32's 4 GB Limit — A Frequent Exam Trap
FAT32 cannot store any single file larger than 4 GB. This is a hard limitation of the file system, not the drive size. A common A+ scenario: a user tries to copy a 6 GB video file to a USB drive and gets an error — the cause is FAT32 formatting. The fix is to reformat the drive as exFAT (cross-platform, no 4 GB limit) or NTFS (Windows/Linux only). The drive itself is not broken.
Linux File Permissions
Every file and directory in Linux has permissions assigned to three groups: the owner, the group, and others (everyone else). Each group gets three permission bits: read (r), write (w), and execute (x).
Permission String Breakdown
-
│
r
w
x
│
r
-
x
│
r
-
x
File type (- = file, d = dir, l = link)
Owner: rwx = 7
Group: r-x = 5
Others: r-x = 5
| Octal | Binary | Symbolic | Meaning |
|---|---|---|---|
| 7 | 111 | rwx | Read + Write + Execute |
| 6 | 110 | rw- | Read + Write (no execute) |
| 5 | 101 | r-x | Read + Execute (no write) |
| 4 | 100 | r-- | Read only |
| 0 | 000 | --- | No permissions |
| Common chmod Value | Who Can Do What | Typical Use |
|---|---|---|
| 755 | Owner: rwx · Group: r-x · Others: r-x | Executable scripts, directories — owner can modify, everyone can read/execute |
| 644 | Owner: rw- · Group: r-- · Others: r-- | Regular files — owner can modify, everyone else read-only |
| 700 | Owner: rwx · Group: --- · Others: --- | Private scripts — only the owner can access at all |
| 600 | Owner: rw- · Group: --- · Others: --- | Private files (SSH keys) — only the owner can read or modify |
| 777 | Owner: rwx · Group: rwx · Others: rwx | Everyone can do everything — avoid except /tmp-style directories |
chmod, chown, and chgrp
chmod changes the permission bits on a file or directory. chmod 755 script.sh sets the permissions using octal. chmod +x script.sh adds execute permission for all.
chown changes the owner of a file. chown sean file.txt makes "sean" the owner. chown sean:developers file.txt sets both owner and group. Requires sudo/root to change another user's files.
chgrp changes the group associated with a file. chgrp developers file.txt assigns the file to the "developers" group. Users in that group then have group-level permissions on the file.
Inodes — What They Are
Every file in a Linux file system has an inode — a data structure that stores metadata about the file: owner, permissions, timestamps, file size, and pointers to the actual data blocks on disk. The filename is not stored in the inode — it's stored in the directory that points to the inode.
| Stored in Inode | NOT Stored in Inode |
|---|---|
| File size | Filename |
| Owner (UID) and group (GID) | File path |
| Permissions (rwx bits) | File content |
| Timestamps (created, modified, accessed) | Hard link names |
| Pointers to data blocks on disk | Extended attributes (stored separately) |
| Number of hard links to this inode |
Mount Points
In Linux, adding a new storage device doesn't give it a drive letter — it's mounted at a directory in the file system tree. The directory where a device's file system becomes accessible is the mount point.
| Command | What It Does |
|---|---|
| mount /dev/sdb1 /mnt/usb | Mounts partition sdb1 at the /mnt/usb directory — files on the USB now appear at /mnt/usb/ |
| umount /mnt/usb | Unmounts the device from /mnt/usb (must not be in use). Note: "umount" not "unmount" |
| df -h | Shows all mounted file systems and their disk usage in human-readable format |
| lsblk | Lists block devices (drives and partitions) with their mount points |
| /etc/fstab | The file that defines which partitions/devices should be automatically mounted at boot and at which mount points |
🎯 Linux vs Windows File System Comparison
Linux uses forward slashes (/home/user/file) — Windows uses backslashes (C:\Users\user\file). Linux is case-sensitive — File.txt and file.txt are different files. Windows is case-insensitive. Linux has no drive letters — everything is under /. The Linux equivalent of C:\ is /, the equivalent of the Windows Desktop is ~/Desktop or /home/username/Desktop.
Exam Scenarios
💬 "A Linux technician needs to find where a web server's configuration file is stored. Which directory should they look in?" → /etc — all system-wide configuration files are stored in /etc. For Apache, the config would be /etc/apache2/apache2.conf. For Nginx, /etc/nginx/nginx.conf. If you need to change how a service behaves, the config file is always in /etc.
💬 "A technician notices a Linux server is running low on disk space. Which directory should they check first for large log files that might be consuming space?" → /var/log — log files are stored in /var (variable data). Common large logs include /var/log/syslog, /var/log/auth.log, and application-specific logs. The du -sh /var/log/* command shows each log file's size. Old logs can often be safely compressed or rotated.
💬 "A user runs chmod 644 report.txt. Who can read the file?" → Everyone — chmod 644 gives the owner read+write (6), and both the group and others read-only (4). All users on the system can read the file, but only the owner can modify it. This is the standard permission for regular non-executable files.
💬 "A technician needs to make a shell script executable. Which command should they run?" → chmod +x scriptname.sh — this adds execute permission for the owner (and by default, group and others). Alternatively, chmod 755 scriptname.sh sets read+write+execute for the owner and read+execute for everyone else, which is the standard permission for shared scripts.
💬 "A user tries to copy a 5 GB ISO file to a USB drive and receives an error saying the file is too large. The USB drive has 16 GB free. What is most likely the cause?" → The USB drive is formatted as FAT32, which has a 4 GB maximum file size limit per file. Despite the drive having 16 GB free, it cannot store any single file over 4 GB. The solution is to reformat the USB drive as exFAT (retains cross-platform compatibility) or NTFS, both of which support large files.
💬 "After plugging in a USB drive on a Linux machine, the technician types ls /dev and sees /dev/sdb and /dev/sdb1. What is the difference?" → /dev/sdb is the entire physical USB drive. /dev/sdb1 is the first partition on that drive. In Linux, drives appear as /dev/sda, /dev/sdb, etc. — partitions are numbered: /dev/sda1, /dev/sda2. The technician would mount the partition (/dev/sdb1), not the raw device, to access the files on it.
Studying for the CompTIA A+?
See the best study resources for 220-1201 and 220-1202.