Linux Resume Ultime - UNIX TP1 to TP9

TP1 - Introduction

Linux Basics: Know Where You Are

Before touching files, you must know the room you are standing in. If you skip this, every later command becomes guesswork.

🏠 Imagine Linux as a big house

The command line is you walking inside the house. pwd says "you are here". ls opens your eyes. cd moves your feet. man is the instruction book.

pwd # print the current room ls -la # list everything, even hidden toys cd .. # go to the parent room man 1 pwd # read the manual for pwd

Bad logic to kill now "I know ls, so I know Linux" is false. ls only shows objects. Linux skill means knowing paths, permissions, owners, devices, processes, and services.

📚 Man pages are bookshelves

man is split into sections. User commands live in section 1, system calls in section 2, C library functions in section 3, file formats in section 5, admin tools in section 8.

5-year-old version If two toys have the same name, the section tells you which toy box to open.

🗂️ FHS is the house map

/ is the front door. /home is users' bedrooms. /etc is the rule book. /bin and /usr/bin hold tools. /var is where changing things like logs live.

Exam shortcut If it configures the system, think /etc. If it changes all the time, think /var. If it is personal, think /home.

🔎 Useful `ls` patterns

Question	Command	Simple idea
Long details	`ls -l`	Show owner, group, size, date, permissions.
Hidden files too	`ls -la`	Show the secret files starting with a dot.
Newest first	`ls -lt`	Sort by time, newest on top.
Oldest first	`ls -ltr`	Reverse the time order.
Six-character names	`ls ??????`	Each `?` is exactly one character.
Starts with D or d	`ls [Dd]*`	Use brackets for choices.

TP2 - Boot the System

Boot: How Linux Wakes Up

A powered-off machine is asleep. Booting is the morning routine that brings it to life.

⏰ The wake-up chain

Firmware checks the body.
BIOS/UEFI checks hardware and finds something bootable.
GRUB chooses the brain.
GRUB loads the selected Linux kernel and can enter edit or command mode.
Kernel becomes boss of hardware.
It manages CPU, memory, devices, and mounts the first root environment.
PID 1 starts the city.
systemd starts services and targets.

🧰 Systemd tools

Need	Command	ELI5 meaning
See processes	`ps -ef`, `pstree -p`	Who is awake, and who woke them up?
Read kernel messages	`dmesg`, `journalctl -k`	Read the machine's morning diary.
Manage service	`systemctl status nginx`	Ask if the web-server worker is okay.
Change target	`systemctl isolate multi-user.target`	Switch to another system mood.
Shutdown	`shutdown -h now`	Tell everyone: stop now.
Reboot at midnight	`shutdown -r 00:00 "message"`	Schedule a restart and warn users.

GRUB correction Do not edit /boot/grub/grub.cfg as your normal plan. The cleaner source is /etc/default/grub, then regenerate with update-grub or grub-mkconfig.

TP3 - Virtual Filesystems and Libraries

Kernel, Devices, and Shared Libraries

Linux has real files and fake-looking files that are actually windows into the kernel. Do not confuse them.

🧠 Kernel info

uname tells you about the kernel. lscpu tells you about the CPU. /proc and /sys are not normal folders; they are live reports from the kernel.

uname -v uname -a lscpu cat /proc/modules lsmod

🧩 Modules

A module is a plug-in for the kernel. Load it when needed; remove it when not needed. Example: ip_tables helps firewall rules.

modinfo ip_tables modinfo -a ip_tables sudo modprobe -r ip_tables sudo modprobe ip_tables

🔌 Devices are represented as files

/dev/sda is a disk-like block device. /dev/tty is a character device. udev creates device nodes dynamically when hardware appears.

Tool	Use	Simple image
`lspci -v`	Show PCI devices	Look at big internal cards.
`lspci -k`	Show kernel drivers	Which teacher handles each card?
`lsusb -v`	Show USB devices	Look at things plugged into USB.
`lsusb -t`	Show USB tree	Draw the USB family tree.

📦 Shared libraries

Programs often borrow common code from .so files. That saves memory, like many children using one big box of crayons instead of each child buying a box.

Runtime check

ldd /sbin/init lists libraries required by the executable.

Library map

ldconfig -p reads the linker cache, built from config such as /etc/ld.so.conf.

Do not abuse LD_LIBRARY_PATH It is temporary and can make programs load the wrong library. Use it for tests, not as your lazy permanent fix.

TP4 - Package Management

Packages: Installing Toys Without Breaking the Room

A package is a prepared box of software. The package manager knows where files go and what extra boxes are needed.

📦 dpkg vs apt

`dpkg`

It installs a local .deb file, but it is not smart about fetching missing dependencies.

sudo dpkg -i discord.deb

`apt`

It talks to repositories and solves dependency chains. Use this when possible.

sudo apt install ./discord.deb

Professor warning If dpkg fails because dependencies are missing, repeating the same command is not strategy. Use apt to resolve the missing boxes.

🛒 Debian package commands

Task	Command
List installed packages	`dpkg -l`
Show files inside a package file	`dpkg -c discord.deb`
List files installed by a package	`dpkg -L discord`
Remove, keep config	`sudo apt remove discord`
Remove with config	`sudo apt purge discord`
Clean unused dependencies	`sudo apt autoremove`
Search packages	`apt-cache search htop`
Show dependencies	`apt-cache depends htop`

🌍 Other distributions

Ubuntu uses Debian-style tools. Red Hat uses RPM/YUM. openSUSE uses Zypper. Same goal, different language.

Family	Low-level	Smart manager	Example
Debian/Ubuntu	`dpkg`	`apt`, `aptitude`	`apt install htop`
Red Hat/Fedora	`rpm`	`yum`	`yum install htop`
openSUSE	RPM base	`zypper`	`zypper install htop`

TP5 - Command Line, Find, Streams

Shell: Talking to Linux Clearly

The shell is not just typing commands. It is variables, children shells, input/output streams, and search tools.

🧃 Streams are straws

A command has three straws: stdin 0 drinks input, stdout 1 spits normal output, and stderr 2 spits errors.

ls > lsfile # stdout to file ls -e 2> errorfile # stderr to file ls > all.txt 2>&1 # stdout and stderr together ls /usr/bin | nl # pipe output into another command ls | tee lsfile # show and save

🎒 Variables

MY_VAR=value stays in the current shell. export MY_VAR=value gives the variable to child shells too.

Common mistake A non-exported variable is like a toy you keep in your hand. Your child shell cannot play with it.

🕵️ Finding things

find searches live. locate searches a database. which checks PATH. type tells if something is builtin, alias, function, or binary.

find . -name "*.sh" sudo find / -maxdepth 4 -name "*.log" locate -i mytestfile whereis -b init which -a chmod type cp ls pwd

TP6 - Text Streams and File Management

Text Filters: Tiny Machines in a Factory

Each filter does one small job. The power comes from combining them.

🏭 The text factory

Tool	Job	Example
`cat`	Print or join files	`cat a b > c`
`less`	Read big files page by page	`less /etc/passwd`
`head` / `tail`	Start or end of file	`tail -n 20 /etc/passwd`
`nl`	Number lines	`nl -b a testfile1`
`wc`	Count words, lines, bytes	`wc -l /etc/passwd`
`od`	Show bytes as characters/hex	`od -c /etc/passwd`
`sort`	Sort lines	`sort -t, -k1,1n testfile`
`tr`	Translate/delete chars	`tr ',' ';'`
`cut`	Take columns	`cut -d',' -f4 testfile`
`paste`	Put files side by side	`paste -d',' a b`
`uniq`	Collapse repeated neighbors	`sort f \| uniq -c`
`sed`	Edit stream text	`sed 's/Employee/Lawyer/g'`

Important uniq only removes neighboring duplicates. If duplicates are scattered, sort first: sort file | uniq.

🔐 Hashes

A hash is a fingerprint. Change one letter in the file, and the fingerprint changes.

md5sum passwdfile > hashpasswd sha256sum passwdfile sha512sum passwdfile

📁 File management

mkdir creates folders. cp copies. mv moves or renames. rm deletes. There is no recycle bin in a normal shell.

mkdir -p test3/test4/test5 cp -p testfile1 /tmp/ mv oldname newname rm -rf test2 file testfile.txt

TP7 - Archives, Regex, Vim, Rights

Archive, Search, Edit, Protect

This TP connects four survival skills: packing files, finding text, editing safely, and controlling access.

🧳 Archives and compression

tar makes a suitcase. gzip, bzip2, and xz squeeze the suitcase smaller.

Need	Command
Create tar	`tar -cvf file.tar testfile1 testfile2`
List tar	`tar -tvf file.tar`
Extract tar	`tar -xvf file.tar`
gzip tar	`tar -czvf file.tar.gz files...`
bzip2 tar	`tar -cvjf file.tar.bz2 files...`
xz tar	`tar -cvJf file.tar.xz files...`
cpio create	`find . \| cpio -o > content.cpio`
cpio extract	`cpio -idvu < content.cpio`

🔍 Regex with grep

Regex is a fishing net for text. Different shapes catch different fish.

grep -i '^this' regex.txt grep -i 'example$' regex.txt grep -i 'example\.' regex.txt grep -E 'wonderful|wonderwomen' regex.txt grep -F 'wonder(full|women)' regex.txt

✍️ Vim basics

Vim has modes. Normal mode is for commands. Insert mode is for writing text. If you mix them up, Vim feels hostile because you are speaking the wrong language.

i # insert mode Esc # normal mode dd # delete line yy / p # copy / paste :wq # save and quit :q! # quit without saving

🛡️ Ownership and permissions

A file has an owner, a group, and others. Each can read r, write w, or execute/search x.

Need	Command	Meaning
Create user	`sudo useradd -m -d /home/newuser newuser`	Create account and home.
Change owner	`sudo chown newuser filerights`	Give the file to a user.
Change group	`sudo chgrp newuser filerights`	Put the file in a group.
Read/write for all	`chmod 666 filerights`	Everyone can read and write.
Sticky bit	`chmod o+t testdir`	Only owner/root deletes inside.
Setuid	`chmod u+s setuidfile`	Run with file owner's privileges.
Setgid	`chmod g+s testdir`	New files inherit directory group.
Default mask	`umask 0026`	Subtract permissions from new files.

Permission trap Capital S or T means the special bit is set but execute/search permission is missing. That is usually a warning sign, not a feature.

TP8 - Processes, Links, Containers

Processes Are Little Workers

A process is a running program. Signals are messages you send to workers: stop, continue, terminate, or die now.

🏃 Monitor and signal processes

Need	Command	Kid version
All processes	`ps -ef`	Class photo of all workers.
Live dashboard	`top`	Watch workers in real time.
Memory	`free -h`	How much desk space is free?
Find bash PIDs	`pgrep -l bash`	Find workers by name.
List signals	`kill -l`	List all messages you can send.
Gentle stop	`kill -15 PID`	Please clean up and stop.
Forced stop	`kill -9 PID`	Stop now, no goodbye.
Pause/resume	`kill -19 PID` / `kill -18 PID`	Freeze / continue.
By exact name	`pkill -x -15 nginx`	Signal all matching workers.

Nginx master vs worker Killing the master usually ends the workers. Killing a worker often makes the master create a replacement. That is not a contradiction; it is supervision.

🧵 Jobs, screen, tmux

Ctrl+Z pauses a foreground job. fg brings it back. bg lets it continue behind you. screen and tmux keep terminal sessions alive.

sleep 1000 Ctrl+Z fg bg jobs nohup sleep 500 & tmux

⚖️ Priority

nice starts a command with a priority. renice changes priority after the process is already running.

nice -n 5 sleep 1000 & ps -u $(whoami) -o pid,ni,cmd renice -n 10 -p PID renice -n 1 -u $(whoami)

🔗 Hard links vs symbolic links

Hard link

Two names point to the same inode. Change one, the other changes because they are the same data.

ln filelink1 filelink2

Symbolic link

A shortcut containing a path. If the target disappears, the link becomes broken.

ln -s filelink3 filelink4

📦 Containers with LXD

A virtual machine is a whole pretend computer. A container is a small separated room sharing the host kernel. LXD containers are lighter, but they are still Linux-on-Linux isolation, not full hardware emulation.

sudo apt install lxd-installer lxc list lxc image list lxc launch ubuntu:20.04 mycontainer lxc exec mycontainer -- /bin/bash

TP9 - Partitions, Filesystems, LVM

Storage: Toy Boxes, Labels, and Shelves

A disk is raw space. A partition cuts it. A filesystem organizes it. A mount attaches it to the house.

🧱 Storage stack

See disks.
lsblk, cat /proc/partitions, fdisk -l.
Create partitions.
Use fdisk, gdisk, or parted.
Make a filesystem.
mkfs.ext4 /dev/sdb1, mkfs.xfs /dev/sdd1.
Attach it.
mount /dev/sdc1 ~/xfs, then use /etc/fstab for boot-time mounting.

🧰 Storage commands

Need	Command	Meaning
Block devices	`lsblk`, `lsblk -f`	Show disks, partitions, filesystems.
Mounted usage	`df -h`, `df -i`	Show space and inode usage.
UUIDs	`blkid`	Show stable device identifiers.
Check ext FS	`fsck /dev/sdd1`	Repair unmounted ext filesystem.
Swap	`mkswap`, `swapon`, `swapon --show`	Use disk space as emergency memory.
Disk usage	`du -hs /usr`	Measure folder size.
Raw copy	`dd if=testfile of=testfile.123 bs=4096`	Copy bytes carefully.
ext tuning	`tune2fs -l /dev/sdaX`	Read or change ext filesystem settings.

📚 Filesystem personalities

ext2 old, no journal. ext3 adds journal. ext4 modern default. xfs strong for large data. btrfs snapshots/checksums. vfat removable Windows-friendly media.

🧪 XFS tools

XFS has its own repair and inspection tools. Use the right doctor for the right patient.

xfs_repair -n /dev/sdc1 xfs_repair -v /dev/sdc1 xfs_db /dev/sdc1 xfs_fsr /dev/sdc1

🧮 LVM in one picture

LVM lets you combine physical disks into flexible storage pools, then create logical volumes that can grow more easily.

Physical Volumes -> Volume Group -> Logical Volumes /dev/sdb1 vg_data lv_home /dev/sdc1 lv_logs

Layer	Command	Question answered
PV	`pvs`	Which physical disks are used?
VG	`vgs`	How big is the shared pool?
LV	`lvs`	Which virtual partitions exist?

Exam Traps

Bad Ideas to Stop Believing

This is the part where I do not sugarcoat it. These mistakes lose points because the logic is wrong, not because the command spelling is ugly.

1. "sudo fixes everything" No. It only gives power. If your target is wrong, sudo makes the wrong action more dangerous.

2. "kill -9 is normal" False. Use SIGTERM first. SIGKILL is the hammer when cleanup does not matter or cannot happen.

3. "A symlink is another copy" False. It is a path shortcut. Delete the target, and the symlink points to nothing.

4. "uniq removes all duplicates" False unless duplicates are adjacent. Sort first for scattered duplicates.

5. "ext2 with journal is still ext2" Practically no: adding a journal with tune2fs -j moves it toward ext3 behavior.

6. "dpkg handles dependencies like apt" False. dpkg is lower-level; apt resolves dependency packages.

7. "A mounted filesystem can always be repaired" Dangerous. Many repair tools expect the filesystem to be unmounted.

8. "PATH means Linux searches everywhere" False. It searches only directories listed in PATH.

🧭 Command chooser

pwd

Show current directory.

ls -la

List files with details, including hidden ones.

man

Read command documentation.

systemctl

Manage services and targets.

journalctl -k

Read kernel logs from the journal.

apt install

Install packages with dependency solving.

sed

Edit text streams or files.

grep -E

Search text with extended regex.

ps -ef

List running processes.

kill -15 PID

Ask a process to terminate cleanly.

lsblk -f

Show disks, partitions, and filesystems.

mount

Attach a filesystem to the directory tree.

pvs / vgs / lvs

Inspect LVM layers.

ln / ln -s

Create hard or symbolic links.

tar

Create, list, and extract archives.

Final Resume

The One-Page Revision Checklist

If you can explain these out loud without hiding behind memorized commands, you are actually ready.

✅ What every TP taught

TP	Main lesson	Must-know commands
TP1	Navigate, read docs, understand FHS.	`pwd`, `man`, `ls`, `cd`
TP2	Boot chain and service manager.	`systemctl`, `journalctl`, `shutdown`
TP3	Kernel modules, devices, libraries.	`uname`, `lsmod`, `modinfo`, `lspci`, `ldd`
TP4	Install and remove packages.	`dpkg`, `apt`, `apt-cache`, `yum`, `zypper`
TP5	Shell variables, finding files, streams.	`env`, `set`, `find`, `locate`, `tee`, `xargs`
TP6	Text filters and file management.	`head`, `tail`, `sort`, `tr`, `cut`, `sed`, `rm`
TP7	Archives, regex, Vim, permissions.	`tar`, `gzip`, `grep`, `vim`, `chmod`, `chown`
TP8	Processes, jobs, links, containers.	`ps`, `top`, `kill`, `jobs`, `ln`, `lxc`
TP9	Disks, filesystems, swap, LVM.	`lsblk`, `fdisk`, `mkfs`, `mount`, `df`, `pvs`

📌 Source files used

This website is based on all workspace references: TP1 to TP9 subject PDFs, TP1 to TP5 answer PDFs, and TP6 to TP9 answer text files.

tp1 énoncé.pdf tp1 réponses.pdf tp2 énoncé.pdf tp2 réponses.pdf tp3 énoncé.pdf tp3 réponses.pdf tp4 énoncé.pdf tp4 réponses.pdf tp5 énoncé.pdf tp5 réponses.pdf tp6 énoncé.pdf tp6 réponses.txt tp7 énoncé.pdf tp7 réponses.txt tp8 énoncé.pdf tp8 réponses.txt tp9 énoncé.pdf tp9 réponses.txt

Final idea Linux is a system of names and relationships: files have paths, processes have PIDs, services have units, disks have partitions, filesystems have mount points, and users have permissions. Learn the relationships, then the commands become obvious.