1.

Introduction to File and Directory Operations

Linux's filesystem is mutable: create with touch/mkdir, duplicate with cp, relocate/rename
with mv, and delete with rm/shred. These are atomic (fast, no partial states) but require root
for system files (sudo).

 Key Principles: Case-sensitive; paths (absolute/relative); recursion for dirs (-r);

verbosity (-v) for feedback.
 Why They Matter: Essential for scripting, backups, and cleanup. From Nemeth et
al.: "Combine with ls -l before/after to verify (e.g., ls -l file1; cp file1 file2; ls -l
file2)."
 Workflow: View first (ls -la), operate, verify (pwd; ls -l).

2. Creating and Updating Files: touch

The touch command creates empty files or updates timestamps (access/modification times)
without altering content—useful for placeholders or triggering builds.

2.1 Basic Syntax

text
touch [options] [file1 [file2 ...]]

 Default (Provided): Creates new file if missing; updates mtime/atime if exists.

 Multiple: touch file1 file2 creates/updates several.

2.2 Key Options (From Barrett)

Option Description Example Effect

Updates atime (e.g., for
-a Change access time only. touch -a [Link]
log simulation).
Updates mtime (e.g.,
-m Change modification time only. touch -m [Link] for make
dependencies).
touch -t
Set specific timestamp Sets mtime/atime to
-t STAMP 202510231200
(YYYYMMDDhhmm[.ss]). Oct 23, 2025 12:00.
[Link]
-r touch -r [Link] Copies times from
Use reference file's times.
REF_FILE [Link] [Link].
Updates only; no error
-c No create: Skip if file exists. touch -c [Link]
for missing.

 From Shotts: "Empty files are zero-byte—use cat > file for content."

2.3 Examples

text
$ cd ~/work/docs
$ touch [Link] # Creates empty /home/user/work/docs/[Link]
$ ls -l [Link] # -rw-r--r-- 1 user user 0 Oct 23 10:00 [Link]

$ touch -m [Link] # Updates mtime (content unchanged)

$ ls -l [Link] # Now: Oct 23 10:05 [Link]

$ touch -t 202510231030 [Link] # Timestamp to 10:30 AM

 Batch: touch $(seq 1 5).txt (creates [Link] to [Link]).

2.4 Tips

 Pitfalls: Permission denied? Check dir ownership (ls -ld .).

 Use Case: touch .gitignore for Git ignores.

3. Creating Directories: mkdir

The mkdir ("make directory") command builds new dirs—single or nested.

3.1 Basic Syntax

text
mkdir [options] dir1 [dir2 ...]

 Default (Provided): Creates single-level dir.

3.2 Key Options

Option Description Example Effect

Parents: Create nested (no mkdir -p Builds full path;
-p
error if exists). mydir1/mydir2/mydir3 idempotent.
-m Set permissions (octal, e.g., Owner-only access
mkdir -m 700 secure/
MODE 755). (drwx------).
Verbose: Announce "created directory
-v mkdir -v temp/
creations. 'temp/'"

 From Linux Pocket Guide: "-p is essential for scripts—avoids mkdir -p $(dirname
file) boilerplate."

3.3 Examples

text
$ mkdir projects # Single: /home/user/work/projects
$ mkdir -p backups/2025/oct/docs # Nested: Creates all levels
$ tree backups # backups \n └── 2025 \n └── oct \n └── docs

$ mkdir -v -m 755 shared/ # Verbose, standard perms

mkdir: created directory 'shared/'

 Multiple: mkdir dirA dirB.

3.4 Tips

 Pitfalls: Exists? Use -p to avoid errors.

 Integration: mkdir -p ~/backups/$(date +%Y%m%d) (daily backup dir).

4. Copying Files and Directories: cp

The cp ("copy") command duplicates files/dirs, preserving or modifying attributes.

4.1 Basic Syntax

text
cp [options] source [source2 ...] destination

 Rules (Provided): Last arg is dest (file/dir); multiple sources → dir dest.

4.2 Key Options (From Provided and Shotts)

Option Description Example Effect

Interactive: Prompt before cp -i [Link]
-i "overwrite? y/n".
overwrite. backups/
Preserve: Mode, owner, times, cp -p [Link]
-p Copies metadata.
links. backups/
-v Verbose: Show progress. cp -v file1 file2
"'file1' -> 'file2'".
-r / -R Recursive: Copy dirs/contents. cp -r docs backups/
Full tree copy.
Skips if dest
-u Update: Copy only if source newer. cp -u *.txt backups/
exists/newer.
Backup: Rename overwrites cp --backup file1
--backup file2.~1~ created.
(e.g., .~1~). file2

 From Nemeth et al.: "-a (archive) = -dR --preserve=all for exact mirrors."

4.3 Examples

text
$ cp [Link] report_copy.txt # Copy with new name
$ cp [Link] backups/script_backup.sh # To dir with rename
$ ls backups/ # script_backup.sh

$ cp -r docs backups/ # Recursive dir

$ tree backups/ # Full docs structure

$ cp -iv *.txt backups/ # Multiple, interactive, verbose

cp: overwrite 'backups/[Link]'? y
'/home/user/work/docs/[Link]' -> '/home/user/work/backups/[Link]'

 Wildcards: cp *.sh ~/bin/ (all shells to bin).

4.4 Tips

 Pitfalls: Dest dir? Ends with / (e.g., dir1/); else renames.

 Large Copies: rsync -av for progress/resume (advanced).

5. Moving and Renaming: mv

The mv ("move") command relocates or renames—efficient (no duplication for same
filesystem).

5.1 Basic Syntax

text
mv [options] source [source2 ...] destination

 Behavior (Provided): Renames if same dir; moves otherwise.

5.2 Key Options (From Provided and Barrett)

Option Description Example Effect

-i Interactive: Prompt overwrite. mv -i file1 dir/ "overwrite? y/n".
-n No clobber: Skip if dest exists. mv -n [Link] backups/ No action if exists.
-u Update: Move if source newer/missing. mv -u [Link] backups/ Only if needed.
-v Verbose: Show moves. mv -v file1 file2 "'file1' -> 'file2'".
-b Backup: Rename overwrites. mv -b file1 file2 file2.~ created.

 From Shotts: "Like cp + rm but atomic—safer for renames."

5.3 Examples

text
$ mv [Link] report_v2.txt # Rename in place
$ mv [Link] backups/ # Move to dir (no rename)

$ mv -i report_v2.txt docs/ # Interactive to dir

$ mv *.txt backups/new_docs/ # Multiple to dir (creates? No—use mkdir

first)

$ mv report_v2.txt backups/report_final.txt # Move + rename

 Cross-FS: Copies then deletes (slower).

5.4 Tips

 Pitfalls: Dest exists? Use -i/-n; no recursion needed (dirs auto).

 Use Case: mv *.{jpg,png} images/ (move images).

6. Removing Files and Directories: rm

The rm ("remove") command deletes—irreversible, so use cautiously.

6.1 Basic Syntax

text
rm [options] file1 [file2 ...] | dir/

 Default (Provided): Deletes files; errors on dirs.

6.2 Key Options (From Provided and Nemeth)

Option Description Example Effect

-v Verbose: Confirm deletions. rm -v [Link] "removed '[Link]'".
-r / -R Recursive: Delete dir/contents. rm -r old_dir/ Full tree wipe.
-f Force: No prompts/errors. rm -rf junk/ Ignores missing/write-protected.
-i Interactive: Prompt each. rm -ri files/ dir/ "remove file1? y/n".
-d Dir only: Delete empty dirs. rm -d empty/ Like rmdir.

 Combo (Provided): rm -ri for safe recursion.

6.3 Examples

text
$ rm [Link] # Single file

$ rm -v *.tmp # Multiple, verbose

$ rm -r backups/old/ # Dir contents

$ rm -rf /tmp/test/ # Force full dir (careful!)

$ rm -ri docs/ # Prompt for each in dir

rm: descend into directory 'docs/'? y
rm: remove 'docs/[Link]'? y

 Wildcards: rm -v *~ (backup files).

6.4 Tips

 Pitfalls: No undo—rm -rf / destroys system! Use trash-cli for recoverable delete.
 Empty Dirs: rmdir dir/ (errors if non-empty).

7. Secure File Deletion: shred

The shred command overwrites files multiple times before deleting—prevents recovery (e.g.,
forensics).

7.1 Basic Syntax

text
shred [options] file

 Default: 3 passes of random data + delete.

7.2 Key Options (From Provided and Shotts)

Option Description Example Effect

shred -v
-v Verbose: Show passes. "pass 1/3...".
[Link]
-u Unlink: Remove after overwriting. shred -u [Link] Overwrite + delete.
-n NUM Passes: Overwrite N times. shred -n 100 [Link] 100 passes (secure).
Zero: Final pass of zeros (hides Looks like quick
-z shred -z -u [Link]
shredding). delete.

 Provided Example: shred -vu -n 100 file1 (verbose, unlink, 100 passes).
 From Barrett: "For SSDs, use wipe or full-disk encryption—shred wears flash."

7.3 Examples

text
$ shred -v [Link] # 3 passes, no delete
shred: [Link]: pass 1/3 (random)...

$ shred -vu -n 5 [Link] # 5 passes + delete

$ ls [Link] # Gone

 Dirs: find . -name "*.tmp" -exec shred -u {} \; (scripted).

7.4 Tips

 Pitfalls: Slow for large files; doesn't work on mounted journals (use fsck).
 Alternatives: srm for recursive secure rm.

8. Best Practices and Command Combinations

 Verification: ls -l before; command; ls -l after.
 Safety Aliases (in ~/.bashrc): alias rm='rm -i'; alias cp='cp -i'; alias mv='mv -i'.
 Scripting: cp -u -r src/ dest/ && mv old/ archive/ (backup before move).
 With Viewing: rm -i $(ls -t | tail -n 3) (interactive delete oldest 3).
 Advanced (from Nemeth): rsync -a --delete src/ dest/ for synced mirrors.
 Common Chains:

Task Command Purpose

Backup Recursive, preserve,
cp -rp docs/ backups/$(date +%Y%m%d)/
Copy dated.
Rename
for f in *.txt; do mv "$f" "${f%.txt}.bak"; done Add .bak extension.
Batch
rm -rf /tmp/* (careful!) or find /tmp -name
Clean Temp Auto-clean.
"*.tmp" -delete
Secure Move shred -u [Link]; mv [Link] . Delete securely first.

Summary and Next Steps

 Core Takeaway: touch/mkdir for build (-p for nests); cp for duplicate (-r/-p); mv for
shift (-i/-u); rm for delete (-i/-f); shred for secure. Always verbose/interactive in prod.
 Practice: In ~/test, touch file; mkdir -p nest/; cp -r nest/ copy/; mv copy/ renamed/;
rm -ri renamed/; shred -u file.

1. Introduction
 Purpose: ln (short for "link") creates hard links or symbolic links (symlinks/soft
links) to files or directories.
o Hard links: Point directly to the inode (data block) of a file. They are
indistinguishable from the original file and share the same data.
 o Symbolic links: Point to the path of another file or directory. They act like
shortcuts and can span file systems.
 Why use it?
o Saves disk space by avoiding copies.
o Simplifies file access (e.g., creating aliases).
o Useful in scripting, backups, and system administration.
 Key Reference: In Shotts' book (Chapter 5: "Seeing the World as the Shell Sees It"),
ln is introduced as a tool for manipulating the file system's "web of links,"
highlighting how Unix treats everything as files with multiple entry points.

2. Basic Syntax
text
ln [OPTIONS] SOURCE [TARGET]

 SOURCE: The existing file or directory to link from (required).

 TARGET: The new name or path for the link (optional; defaults to SOURCE's
basename in the current directory).
 If TARGET is omitted, ln creates a link in the current directory with the same name
as SOURCE.
 Exit Status:
o 0: Success.
o 1: General error (e.g., permission denied).
o 2: Misuse of shell builtins (rare).

3. Common Options
Options control link type, behavior, and error handling. Here's a table summarizing key ones
(drawn from GNU Coreutils manual and Shotts' examples):

Example
Option Description Notes
Usage
ln -s Default is hard link;
Create a symbolic link
-s or --symbolic /etc/passwd symlinks can "dangle" if
instead of a hard link.
passlink target is deleted.
Remove existing
Overwrites without
TARGET (if it's a ln -sf oldfile
-f or --force prompting; use
file/link) before newname
cautiously.
creating the new link.
Treat TARGET as a
Prevents recursive
-n or --no-dereference directory (don't follow ln -n file /dir/
linking in directories.
symlinks).
Print names of files Useful for
-v or --verbose ln -v file link
created. logging/scripts.
Prompt before
-i or --interactive removing existing ln -i old new Safer for interactive use.
TARGET.
-b or --backup Backup existing ln -b file link Creates link~ if link
 Example
Option Description Notes
Usage
TARGET by appending
exists.
~ (or custom suffix).
ln -b --
Custom backup suffix Backup becomes
--suffix=SUFFIX suffix=.bak
(pairs with -b). [Link].
file link
Forces file linking even
Don't treat last operand ln -h file1
-h or --no-target-directory if TARGET looks like a
as a directory. file2
dir.
-t DIR or --target- Specify target directory ln -t /tmp/ Links both files into
directory=DIRECTORY for multiple SOURCES. file1 file2 /tmp/.
Dereference all
ln -L symfile Follows symlinks in
-L or --logical symlinks (treat as hard
realfile SOURCE.
links to targets).
Never dereference
ln -P symfile Treats symlinks
-P or --physical symlinks (default for
realfile literally.
hard links).

 Help Command: Run ln --help for a quick summary or man ln for the full manual
page.

4. Hard Links vs. Symbolic Links

Understanding the difference is crucial (as emphasized in Shotts' book, p. 112–114). Use this
table for a quick comparison:

Aspect Hard Links (ln default) Symbolic Links (ln -s)

Creation ln source target ln -s source target
Points to inode (data blocks); same
Target Points to path string; indirect reference.
file on disk.
Must be on the same file system (can't Can cross file systems (e.g., /home to
File Systems
cross partitions). /mnt/usb).
Deleting one link doesn't affect others; Deleting target breaks the link (dangling
Deletion data persists until all links are gone symlink); link file remains but points
(refcount > 0). nowhere.
Size No extra space (just a directory entry). Small file (~4–8 bytes) storing the path.
All links share exact permissions and Link inherits target's permissions; can
Permissions
ownership. be followed if readable.
Can't link directories (except with Can link directories (common for
Directories
superuser privileges via ln -d). shortcuts).
ls -l shows target -> source (arrow
Detection ls -i shows same inode number.
notation).
Data integrity (e.g., multiple names Flexibility (e.g., /etc/alternatives for
Use Case
for one file in backups). package switching).

 Pro Tip: Use ls -li to inspect inodes and link types.

5. Examples
Here are practical, step-by-step examples (inspired by Shotts' hands-on exercises and GNU
docs). Assume you're in a test directory with a file [Link].

Basic Hard Link

text
$ echo "Hello, Linux!" > [Link]
$ ln [Link] [Link] # Creates hard link
$ ls -li # Output: same inode for both files
$ cat [Link] # Shows "Hello, Linux!"
$ rm [Link] # [Link] still works!

Basic Symbolic Link

text
$ ln -s [Link] [Link] # Creates symlink
$ ls -l [Link] # Output: [Link] -> [Link]
$ cat [Link] # Shows content
$ rm [Link] # Now cat [Link] fails: "No such file"

Linking Multiple Files to a Directory

text
$ mkdir links_dir
$ touch [Link] [Link]
$ ln -t links_dir [Link] [Link] # Links both into links_dir
$ ls links_dir/ # Shows [Link] [Link] (as links)

Force Overwrite with Verbose

text
$ ln -sf /path/to/[Link] [Link] # Overwrites if exists, prints
action

Directory Symlink (Cross-File System)

text
$ ln -s /usr/bin /home/user/bin_link # Shortcut to /usr/bin
$ /home/user/bin_link/ls # Runs ls from /usr/bin

6. Common Use Cases

  System Administration: Create symlinks for versioned software (e.g., ln -s
python3.10 python).
 Backups: Hard links in tools like rsync --link-dest to save space.
 Development: Symlink config files (e.g., ln -s ~/dotfiles/.bashrc ~/.bashrc).
 Troubleshooting: Fix broken symlinks with find -type l -xtype l to locate danglers.

7. Tips, Warnings, and Best Practices

 Permissions: You need write access to the target directory and read access to
SOURCE. Root can link anything.
 Warnings:
o Avoid hard-linking across file systems (fails with "Invalid cross-device link").
o Symlinks can create loops (e.g., ln -s dir dir/sub/dir); use -n to prevent.
o Deleting the original doesn't free space for hard links—use unlink or rm on all
links.
 Debugging: Check with file target (e.g., "symbolic link to ...") or readlink -f target for
full path resolution.
 Alternatives: cp -l for hard-linked copies; graphical tools like Nautilus support drag-
and-drop linking.