4.1 Create, Delete, Copy, and Move Files and Directories

4.1 Create, Delete, Copy, and Move Files and Directories

Quick Answer: Create directories with mkdir / mkdir -p, empty files with touch, copy with cp (use cp -a to preserve attributes), move or rename with mv, and remove with rm / rm -r. Always verify identity, path, and attributes with pwd, ls -l, and stat before and after changes.

The EX200 essential-tools objective to create, delete, copy, and move files and directories is pure day-to-day Linux administration. Almost every later task—deploying configs under /etc, staging content under /var, or assembling a home-directory lab—depends on getting paths, recursion, and attributes right the first time.

Mental Model: Directory Entries and Trees

A file is data identified by an inode (metadata: size, permissions, timestamps, ownership). A directory is a special file that maps names to inodes. When you cp, mv, or rm, you manipulate names and sometimes data:

Hard and soft links (next section) build on this inode model. For this section, treat every exam path as something you must create correctly, place correctly, and not destroy accidentally.

Creating Directories: mkdir

mkdir project
mkdir -p /home/student/labs/ex200/files
mkdir -m 755 /srv/www
mkdir dir1 dir2 dir3

Why -p matters on the exam: Tasks often specify deep paths (/home/bob/projects/app/config). Without -p, mkdir fails if a parent is missing. With -p, one command builds the whole chain. mkdir -p is also safe when re-running a recipe: existing directories are left alone rather than failing.

Verify:

ls -ld /home/student/labs/ex200/files
namei -l /home/student/labs/ex200/files   # optional path walk

Creating Empty Files and Updating Timestamps: touch

touch notes.txt
touch /tmp/a /tmp/b /tmp/c
touch -t 202608051200.00 stamped.txt     # set explicit timestamp when required

touch creates a zero-length file if the name does not exist, or updates access/modification times if it does. Exam tasks often say “create an empty file named X in directory Y”—touch Y/X after mkdir -p Y is the standard pattern.

Other quick creation methods (already familiar from editing/redirection chapters):

echo 'content' > file.txt
cat > file.txt <<'EOF'
line1
line2
EOF

Prefer touch when content is not required yet; prefer redirection or an editor when the file must contain specific text.

Copying: cp

cp source dest
cp file1 file2 file3 /path/to/dir/
cp -r sourcedir destdir
cp -a sourcedir destdir

Essential options

When to use cp -a

Exam trap: A plain cp -r copies content but may not fully preserve ownership, permissions, timestamps, or special file types the way an administrator backup should. Graders (and real restore drills) often care about:

• Permission bits and ownership
• Timestamps
• Symlinks remaining symlinks
• Extended attributes where relevant

Prefer cp -a when the task says “preserve attributes,” “exact copy,” “backup,” or when copying system trees you will compare with ls -l / stat later.

cp -a /etc/ssh /root/ssh-backup
ls -l /etc/ssh/sshd_config /root/ssh-backup/sshd_config
stat /etc/ssh/sshd_config /root/ssh-backup/sshd_config

If you copy as an unprivileged user into a path you own, ownership of new files is typically your UID—even when the source was root-owned. Only root (or capable processes) can create root-owned copies. Use sudo cp -a when the destination must keep original ownership under restricted paths.

Destination rules

• If dest is an existing directory, sources are placed inside it with the same basenames.
• If dest does not exist and you copy one file, dest becomes the new file name.
• If dest does not exist and you use cp -r srcdir destdir, destdir is created as the copy of srcdir.

cp report.txt /tmp/               # /tmp/report.txt
cp report.txt /tmp/report.bak     # renamed copy
cp -a project /tmp/               # /tmp/project/...

Moving and Renaming: mv

mv oldname newname
mv file1 file2 dir3 /path/to/dir/
mv project /home/student/archive/

mv renames when source and destination are on the same filesystem (inode stays the same; only the directory entry changes). Across filesystems, mv typically copies then removes the original—behavior you notice if a huge tree move is slow or if attributes fail to transfer under restricted permissions.

Useful options: -i (interactive), -n (no clobber), -v (verbose).

Exam use cases: Rename files to match a required name, relocate a completed project into a grading path, or reorganize after creating content in the wrong directory. Unlike cp, successful mv does not leave the original path behind—do not use mv when you still need the source in place.

Removing: rm and rmdir

rmdir — empty directories only

rmdir emptydir
rmdir -p a/b/c     # remove c, then b, then a if each becomes empty

If the directory is not empty, rmdir fails. That is a safety feature, not a bug.

rm — files and trees

rm file.txt
rm -r directory/
rm -rf directory/     # recursive + force (no prompts; dangerous)
rm -i file1 file2     # prompt each

Exam discipline:

1. pwd and ls before rm -r.
2. Prefer absolute paths for destructive commands on system trees.
3. Avoid casual rm -rf / patterns and watch trailing spaces/globs (rm -rf $VAR/ when VAR is empty is catastrophic in scripts).
4. Remember that rm removes names; if other hard links exist, data may remain under another name (next section).

Aliases on some interactive shells map rm to rm -i. On exams, know the real binary behavior and do not assume prompts will always save you—especially in scripts or bash -c.

Building a Complete Workflow

Typical multi-step task wording: “Create directory structure X; place files; copy a template preserving permissions; move the tree to Y; remove temporary files.”

whoami
mkdir -p /home/student/work/app/{bin,etc,data}
touch /home/student/work/app/etc/app.conf
echo 'listen=8080' > /home/student/work/app/etc/app.conf
cp -a /usr/share/doc /home/student/work/app/data/doc-backup 2>/dev/null || true
mv /home/student/work/app /home/student/final-app
rm -r /home/student/work
ls -laR /home/student/final-app

Brace expansion {bin,etc,data} creates multiple siblings under one parent—fast and accurate under time pressure. Confirm with ls -laR or targeted find.

Preserving Attributes and Comparing Results

After copies that must match the source:

ls -l source dest
stat source dest
getfacl source dest     # if ACLs are in play later

Timestamps, mode bits, and ownership are the first things graders or automated checks compare. If you used plain cp and the task implied an archival copy, fix with a fresh cp -a rather than manually chasing every bit.

Common Pitfalls

1. Forgetting -r / -a on directories — cp dir dest without recursion fails or does not copy the tree as intended.
2. Using cp when the task wants a rename — leaves duplicates and wrong paths.
3. Using mv when you still need the original — source disappears.
4. rm -r on the wrong path — no recycle bin on the exam.
5. Creating as root under a user home — ownership ends up root:root; fix with chown or recreate as the correct user.
6. Assuming cp -r equals cp -a — attribute and symlink handling differ; prefer -a for admin-quality trees.
7. Relative path mistakes — always pwd when staging multi-step file trees.

RHEL Practice Drill

mkdir -p /tmp/sg-files/{src,dst}
echo alpha > /tmp/sg-files/src/a.txt
cp -a /tmp/sg-files/src/a.txt /tmp/sg-files/dst/a-copy.txt
mv /tmp/sg-files/dst/a-copy.txt /tmp/sg-files/dst/a-renamed.txt
cp -a /tmp/sg-files/src /tmp/sg-files/dst/src-backup
rm /tmp/sg-files/src/a.txt
rmdir /tmp/sg-files/src || rm -r /tmp/sg-files/src
ls -laR /tmp/sg-files

Explain to yourself after each step what still exists and what attributes ls -l shows.

Section Checkpoint

You should be able to build nested directories with mkdir -p, create files with touch or redirection, copy single files and whole trees with correct recursion, use cp -a when attributes must survive, relocate or rename with mv, and remove files or empty/non-empty directories with rmdir / rm -r without collateral damage. Those operations are the foundation for links and archives in the next sections.