Le système de fichiers

Le système de fichiers#

Hide code cell source

 
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

La hiérarchie FHS#

Sous Linux, tous les fichiers sont organisés dans une arborescence unique dont la racine est / (le répertoire racine, prononcé slash). Il n’y a pas de lettres de lecteur comme sous Windows (C:, D:). Un disque supplémentaire n’apparaît pas comme une nouvelle lettre de lecteur : il est monté (mounted) dans l’arborescence existante, généralement sous /mnt ou /media.

Cette organisation est définie par le FHS (Filesystem Hierarchy Standard), une norme maintenue par la Linux Foundation qui décrit l’objectif et le contenu de chaque répertoire standard. Connaître le FHS permet de savoir immédiatement où chercher un fichier de configuration, un binaire, un log ou une bibliothèque.

Définition 6 (Filesystem Hierarchy Standard (FHS))

Le FHS est une norme qui définit la structure des répertoires d’un système Linux. Elle distingue deux critères orthogonaux :

  • Partageable vs. non-partageable : les fichiers partageables peuvent être montés en lecture seule sur plusieurs machines (ex. /usr). Les fichiers non-partageables sont spécifiques à la machine locale (ex. /etc, /var).

  • Statique vs. variable : les fichiers statiques ne changent pas sans intervention de l’administrateur (binaires, documentations). Les fichiers variables sont modifiés par les programmes en cours d’exécution (logs, bases de données, fichiers temporaires).

Répertoires principaux#

/ — Racine. Le point de départ de l’arborescence entière. Ne contient que les répertoires standard et les fichiers strictement nécessaires au démarrage du système.

/bin — Binaires essentiels. Contient les exécutables nécessaires au fonctionnement du système en mode mono-utilisateur et pendant le démarrage : ls, cp, mv, rm, cat, bash, grep… Depuis les distributions modernes utilisant systemd, /bin est souvent un lien symbolique vers /usr/bin.

/sbin — Binaires système. Exécutables réservés à l’administrateur système (root) pour la maintenance et la configuration : fdisk, fsck, ip, ifconfig, reboot, shutdown. Souvent lien symbolique vers /usr/sbin.

/etc — Configuration. Contient tous les fichiers de configuration du système et des applications installées. Ces fichiers sont en texte clair, versionables avec Git, et lisibles par n’importe quel éditeur. Exemples : /etc/passwd (comptes utilisateurs), /etc/fstab (montages), /etc/nginx/nginx.conf (configuration nginx), /etc/ssh/sshd_config (configuration SSH).

/home — Répertoires personnels. Chaque utilisateur dispose d’un répertoire personnel sous /home/[utilisateur]/ (par exemple /home/alice/). C’est là que sont stockés les fichiers personnels, les configurations utilisateur (~/.bashrc, ~/.ssh/) et les projets.

/root — Répertoire personnel de root. L’administrateur système (root) a son répertoire personnel en /root/ et non dans /home/, pour des raisons de disponibilité lors du démarrage.

/var — Données variables. Contient les données qui changent fréquemment pendant le fonctionnement normal : journaux système (/var/log/), bases de données (/var/lib/), files d’attente de courrier (/var/mail/), files d’impression (/var/spool/), fichiers PID des processus (/var/run/, lien vers /run/).

/tmp — Fichiers temporaires. Répertoire pour les fichiers temporaires créés par les programmes. Son contenu est généralement effacé au redémarrage (ou géré par tmpfs en mémoire RAM). Les programmes ne doivent pas supposer que les fichiers y survivent d’une session à l’autre.

/proc — Système de fichiers virtuel des processus. N’existe pas sur le disque : c’est un système de fichiers synthétique créé par le noyau en mémoire. Il expose des informations sur les processus en cours (/proc/[pid]/) et sur le matériel (/proc/cpuinfo, /proc/meminfo, /proc/net/).

/sys — Système de fichiers virtuel du noyau. Similaire à /proc, sysfs expose la structure interne du noyau : pilotes, périphériques, paramètres noyau. On peut lire et écrire dans ces fichiers pour interroger ou configurer le matériel.

/dev — Fichiers de périphériques. Contient les fichiers spéciaux représentant les périphériques matériels et virtuels. Exemples : /dev/sda (premier disque SATA), /dev/sda1 (première partition), /dev/tty1 (premier terminal), /dev/null (discard), /dev/zero (source de zéros), /dev/random (entropie).

/usr — Ressources système partagées. Contient la majorité des binaires, bibliothèques et documentations installés par le gestionnaire de paquets : /usr/bin/ (binaires), /usr/lib/ (bibliothèques), /usr/share/ (données indépendantes de l’architecture : icônes, locales, man pages…), /usr/local/ (logiciels installés manuellement, hors gestionnaire de paquets).

/opt — Logiciels optionnels. Convention pour les applications commerciales ou les logiciels qui s’installent dans un répertoire autonome (par exemple /opt/google/chrome/).

/mnt — Point de montage temporaire. Répertoire traditionnellement utilisé pour monter temporairement des systèmes de fichiers : clés USB, partitions supplémentaires, partages réseau.

/media — Périphériques amovibles. Sur les distributions modernes, les périphériques amovibles (clés USB, CD-ROM) sont automatiquement montés sous /media/[utilisateur]/[label].

/boot — Fichiers de démarrage. Contient le noyau Linux (vmlinuz-*), le disque RAM initial (initrd.img-*) et les fichiers du chargeur de démarrage GRUB.

/lib — Bibliothèques essentielles. Bibliothèques dynamiques nécessaires aux binaires de /bin et /sbin : libc.so.6, les modules noyau. Souvent lien symbolique vers /usr/lib.

/run — Données d’exécution volatiles. Système de fichiers tmpfs (en mémoire) pour les données d’exécution de la session courante : fichiers PID, sockets Unix, informations de montage. Remplace l’ancien /var/run.

Remarque 5

La distinction entre /bin et /usr/bin est historiquement liée aux contraintes matérielles des premiers systèmes Unix : le disque principal (contenant /) et le disque secondaire (contenant /usr) pouvaient être séparés. /bin ne contenait que le strict nécessaire pour que le système démarre et puisse monter /usr. Aujourd’hui, avec les capacités des disques modernes et l’architecture systemd, cette distinction a perdu sa raison d’être. Sur Debian depuis Bookworm (2023), Fedora depuis la version 17, et Arch, /bin, /sbin, /lib sont des liens symboliques vers leurs équivalents dans /usr.

La commande find#

find est l’un des outils les plus puissants de Linux. Elle parcourt récursivement une arborescence de répertoires pour trouver des fichiers selon des critères variés.

Définition 8 (find — recherche de fichiers)

La syntaxe générale de find est :

find [répertoire(s)] [expression(s)]

find parcourt récursivement le(s) répertoire(s) indiqué(s) et évalue l’expression pour chaque fichier rencontré. Si l’expression est vraie, le fichier est affiché (ou traité selon l’action spécifiée).


```bash
# Rechercher par nom (sensible à la casse)
find /home -name "rapport.pdf"

# Rechercher par nom (insensible à la casse)
find /home -iname "*.PDF"

# Rechercher par type
find /etc -type f      # fichiers ordinaires
find /etc -type d      # répertoires
find /etc -type l      # liens symboliques

# Rechercher par taille
find /var/log -size +10M        # plus grand que 10 Mo
find /tmp -size -1k             # plus petit que 1 Ko
find /home -size 100k           # exactement 100 Ko

# Rechercher par date de modification (en jours)
find /var/log -mtime -7         # modifié il y a moins de 7 jours
find /tmp -mtime +30            # modifié il y a plus de 30 jours
find /var -mmin -60             # modifié il y a moins de 60 minutes

# Rechercher par permissions
find /usr/bin -perm 755         # permissions exactement 755
find /etc -perm -o+w            # accessible en écriture par "others"

# Rechercher par propriétaire
find /home -user alice
find /var -group www-data

# Combiner des critères (AND implicite)
find /var/log -name "*.log" -size +1M -mtime -7

# Action : exécuter une commande pour chaque fichier trouvé
# {} est remplacé par le nom du fichier, \; termine la commande
find /tmp -mtime +7 -exec rm {} \;

# Action avec + : passe tous les fichiers d'un coup à la commande
# (plus efficace car lance moins de processus)
find /tmp -mtime +7 -exec rm {} +

# Afficher les détails (comme ls -l)
find /home/alice -name "*.py" -exec ls -lh {} \;

# -maxdepth et -mindepth : contrôler la profondeur de recherche
find /etc -maxdepth 1 -name "*.conf"   # seulement dans /etc, pas ses sous-répertoires
find /usr -mindepth 3 -name "*.h"      # à partir du 3ème niveau

# Exclure des répertoires
find /home -not -path "*/\.*"          # exclure les fichiers/répertoires cachés
find / -name "*.log" -not -path "/proc/*" -not -path "/sys/*"

Exemple 8 (find avec -exec et xargs)

# Trouver tous les fichiers .pyc et les supprimer
find . -name "*.pyc" -delete

# Trouver les gros fichiers de log et afficher leur taille
find /var/log -name "*.log" -size +5M -exec du -sh {} \;

# Compter le nombre de fichiers Python dans un projet
find . -name "*.py" -type f | wc -l

# Rechercher du texte dans les fichiers Python du projet courant
# xargs est plus efficace que -exec pour les grandes listes
find . -name "*.py" -type f | xargs grep -l "TODO"

# Corriger les permissions de tous les scripts shell
find /opt/scripts -name "*.sh" -exec chmod 755 {} +

# Trouver les fichiers sans propriétaire (potentiellement dangereux)
find / -nouser -o -nogroup 2>/dev/null


## Les inodes, liens durs et liens symboliques

### L'inode : la véritable identité d'un fichier

Sur un système de fichiers Linux (ext4, btrfs, xfs…), chaque fichier est représenté par deux structures distinctes :

1. **L'inode** : une structure de données qui contient les métadonnées du fichier (permissions, propriétaire, groupe, dates, taille, pointeurs vers les blocs de données). L'inode est identifié par un **numéro d'inode** unique au sein d'un système de fichiers.

2. **L'entrée de répertoire** (*directory entry*) : l'association entre un **nom de fichier** et le **numéro d'inode** correspondant. Un répertoire n'est qu'une table de correspondance nom → inode.

```{prf:definition} Inode
:label: definition-03-04
Un **inode** (*index node*) est une structure de données d'un système de fichiers qui décrit un fichier ou un répertoire. Un inode contient : le type de fichier, les permissions, l'UID du propriétaire, le GID du groupe, la taille, les horodatages (atime, mtime, ctime), le nombre de liens durs, et les pointeurs vers les blocs de données sur le disque. Ce que l'inode ne contient **pas** : le nom du fichier (qui est stocké dans le répertoire).

# Afficher le numéro d'inode d'un fichier
ls -i fichier.txt
stat fichier.txt

# Exemple de sortie de stat :
#   File: fichier.txt
#   Size: 1024        Blocks: 8          IO Block: 4096   regular file
# Device: fd00h/64768d    Inode: 2883588    Links: 1
# Access: (0644/-rw-r--r--)  Uid: ( 1000/ alice)   Gid: ( 1000/ alice)
# Access: 2024-03-15 10:23:45.000000000 +0100
# Modify: 2024-03-15 10:23:45.000000000 +0100
# Change: 2024-03-15 10:23:45.000000000 +0100

Les liens durs#

Un lien dur (hard link) est une nouvelle entrée de répertoire qui pointe vers le même inode qu’un fichier existant. Il n’y a pas de différence entre le fichier « original » et le lien dur : ils sont deux noms différents pour le même inode, le même contenu.

# Créer un lien dur
ln fichier_original.txt lien_dur.txt

# Vérifier : les deux fichiers ont le même inode
ls -li fichier_original.txt lien_dur.txt
# Les numéros d'inode sont identiques

# Le compteur de liens (Links) est maintenant 2
stat fichier_original.txt | grep Links

# Supprimer l'un des deux noms ne supprime pas les données
# (le compteur de liens passe à 1)
rm fichier_original.txt
cat lien_dur.txt    # le contenu est toujours accessible

Remarque 6

Les liens durs ont deux limitations importantes :

  1. Ils ne peuvent pas traverser les systèmes de fichiers. Un lien dur ne peut pointer que vers un inode du même système de fichiers (même partition). On ne peut pas créer un lien dur de /home vers /tmp si ces deux répertoires sont sur des partitions différentes.

  2. Ils ne peuvent pas pointer vers des répertoires (sauf par le noyau pour . et ..). Cette restriction évite les cycles dans l’arborescence, qui compliqueraient les algorithmes de parcours.

Les liens symboliques#

Un lien symbolique (symbolic link ou symlink) est un type de fichier spécial qui contient le chemin (absolu ou relatif) vers une autre cible. Contrairement aux liens durs, les liens symboliques peuvent traverser les systèmes de fichiers et pointer vers des répertoires.

# Créer un lien symbolique
ln -s /chemin/vers/cible nom_du_lien

# Exemple : créer un lien vers un binaire
ln -s /opt/logiciel/bin/programme /usr/local/bin/programme

# Exemple : lien vers un répertoire
ln -s /var/www/html /home/alice/site_web

# Afficher les liens symboliques (l devant les permissions)
ls -la | grep '^l'
# lrwxrwxrwx  1 alice alice 11 mars  10 site_web -> /var/www/html

# Résoudre un lien symbolique (trouver la cible finale)
readlink lien.txt                  # affiche le chemin immédiat
readlink -f lien.txt               # résout tous les liens en chaîne

# Supprimer un lien symbolique (ne supprime pas la cible !)
rm nom_du_lien
# ou
unlink nom_du_lien

Exemple 9 (Liens symboliques dans la pratique)

Les liens symboliques sont omniprésents sous Linux. Quelques exemples concrets :

# Sur une distribution moderne, /bin est un lien vers /usr/bin
ls -la /bin
# lrwxrwxrwx 1 root root 7 /bin -> usr/bin

# La version Python par défaut est souvent un lien
ls -la /usr/bin/python3
# lrwxrwxrwx ... python3 -> python3.11

# Nginx active un site en créant un lien
# (de sites-available vers sites-enabled)
sudo ln -s /etc/nginx/sites-available/monsite /etc/nginx/sites-enabled/monsite

# Accès rapide depuis le répertoire personnel
ln -s /var/log/nginx ~/logs_nginx
tail ~/logs_nginx/access.log   # facile à retenir


## Montage des systèmes de fichiers

Sous Linux, tout système de fichiers (partition disque, clé USB, partage réseau, image ISO) doit être **monté** dans l'arborescence avant d'être accessible.

### mount et umount

```bash
# Afficher les systèmes de fichiers montés
mount
# ou plus lisible :
findmnt

# Monter une partition dans un répertoire (point de montage)
sudo mount /dev/sdb1 /mnt/usb

# Monter avec un type de système de fichiers spécifique
sudo mount -t ext4 /dev/sdb1 /mnt/data
sudo mount -t vfat /dev/sdc1 /mnt/cle_usb
sudo mount -t ntfs-3g /dev/sdb1 /mnt/windows

# Monter une image ISO
sudo mount -o loop image.iso /mnt/iso

# Monter en lecture seule
sudo mount -o ro /dev/sdb1 /mnt/backup

# Remonter en lecture-écriture une partition montée en lecture seule
sudo mount -o remount,rw /mnt/backup

# Démonter un système de fichiers
sudo umount /mnt/usb
# ou par le périphérique
sudo umount /dev/sdb1

# Forcer le démontage (si des processus utilisent encore des fichiers)
sudo umount -l /mnt/usb    # lazy unmount

Le fichier /etc/fstab#

Le fichier /etc/fstab (file systems table) définit les systèmes de fichiers à monter automatiquement au démarrage.

Définition 9 (/etc/fstab)

/etc/fstab est un fichier de configuration qui décrit les systèmes de fichiers à monter au démarrage. Chaque ligne non commentée définit un montage selon six champs :

<périphérique> <point_de_montage> <type_fs> 


- **périphérique** : `/dev/sda1`, `UUID=xxxx`, `LABEL=data`, ou une adresse réseau (NFS).
- **point_de_montage** : répertoire dans lequel le FS sera monté.
- **type_fs** : `ext4`, `btrfs`, `xfs`, `vfat`, `swap`, `nfs`, `tmpfs`…
- **options** : `defaults`, `ro`, `noexec`, `nosuid`, `noatime`, `user`, etc.
- **dump** : `0` (ne pas sauvegarder), `1` (sauvegarder avec `dump`).
- **pass** : ordre de vérification `fsck` au démarrage. `0` = pas de vérification, `1` = racine en premier, `2` = les autres.

Exemple 10 (Exemple de /etc/fstab)

# Afficher le contenu de /etc/fstab
cat /etc/fstab

# <périphérique>              <montage>  <type>  <options>        <dump> <pass>
UUID=a1b2c3d4-e5f6-7890-abcd  /          ext4    errors=remount-ro  0      1
UUID=f1e2d3c4-b5a6-7890-dcba  /boot      ext4    defaults           0      2
UUID=12345678-90ab-cdef-0123  none       swap    sw                 0      0
tmpfs                          /tmp       tmpfs   defaults,nosuid,nodev 0  0

# Partage NFS
192.168.1.10:/partage          /mnt/nfs   nfs     defaults,_netdev   0      0

# Clé USB par label
LABEL=BACKUP                   /mnt/sauvegarde vfat  user,noauto,utf8  0  0

# Monter tout ce qui est dans /etc/fstab (non encore monté)
sudo mount -a

# Vérifier la syntaxe de /etc/fstab sans monter
sudo findmnt --verify


## Visualisation : l'arborescence FHS

```{code-cell} python
:tags: [hide-input]

import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import seaborn as sns

sns.set_theme(style="white", font_scale=1.0)

fig, ax = plt.subplots(figsize=(18, 13))
ax.set_xlim(-0.5, 18.5)
ax.set_ylim(-0.5, 13.5)
ax.axis('off')
ax.set_title("Hiérarchie FHS — Filesystem Hierarchy Standard",
             fontsize=16, fontweight='bold', pad=15)

palette = sns.color_palette("muted", 12)

# Données de l'arborescence : (label, x_centre, y_centre, couleur, parent_xy)
nodes = [
    # Racine
    ("/", 9.0, 12.5, palette[0], None),

    # Niveau 1
    ("/bin",   1.0, 10.5, palette[1], (9.0, 12.5)),
    ("/sbin",  2.5, 10.5, palette[1], (9.0, 12.5)),
    ("/etc",   4.0, 10.5, palette[2], (9.0, 12.5)),
    ("/home",  5.5, 10.5, palette[3], (9.0, 12.5)),
    ("/root",  7.0, 10.5, palette[3], (9.0, 12.5)),
    ("/var",   9.0, 10.5, palette[4], (9.0, 12.5)),
    ("/tmp",  10.5, 10.5, palette[5], (9.0, 12.5)),
    ("/proc", 12.0, 10.5, palette[6], (9.0, 12.5)),
    ("/sys",  13.5, 10.5, palette[6], (9.0, 12.5)),
    ("/dev",  15.0, 10.5, palette[7], (9.0, 12.5)),
    ("/usr",  16.5, 10.5, palette[8], (9.0, 12.5)),
    ("/boot",  9.0,  8.5, palette[9], (9.0, 12.5)),
    ("/opt",  10.5,  8.5, palette[5], (9.0, 12.5)),
    ("/mnt",  12.0,  8.5, palette[1], (9.0, 12.5)),
    ("/media",13.5,  8.5, palette[1], (9.0, 12.5)),
    ("/run",  15.0,  8.5, palette[6], (9.0, 12.5)),
    ("/lib",  16.5,  8.5, palette[1], (9.0, 12.5)),

    # Sous-répertoires de /var
    ("/var/log",  7.5, 6.5, palette[4], (9.0, 10.5)),
    ("/var/lib",  9.0, 6.5, palette[4], (9.0, 10.5)),
    ("/var/tmp", 10.5, 6.5, palette[4], (9.0, 10.5)),

    # Sous-répertoires de /usr
    ("/usr/bin",  15.0, 6.5, palette[8], (16.5, 10.5)),
    ("/usr/lib",  16.5, 6.5, palette[8], (16.5, 10.5)),
    ("/usr/share",18.0, 6.5, palette[8], (16.5, 10.5)),

    # Sous-répertoires de /etc
    ("/etc/ssh",  3.0, 6.5, palette[2], (4.0, 10.5)),
    ("/etc/nginx",5.0, 6.5, palette[2], (4.0, 10.5)),

    # Sous-répertoires de /home
    ("/home/alice", 5.0, 4.5, palette[3], (5.5, 10.5)),
    ("/home/bob",   6.5, 4.5, palette[3], (5.5, 10.5)),
]

descriptions = {
    "/": "Racine",
    "/bin": "Binaires\nessentiels",
    "/sbin": "Binaires\nsystème",
    "/etc": "Configuration\nsystème",
    "/home": "Rép.\npersonnels",
    "/root": "Home\nde root",
    "/var": "Données\nvariables",
    "/tmp": "Fichiers\ntemp.",
    "/proc": "FS virtuel\nprocessus",
    "/sys": "FS virtuel\nnoyau",
    "/dev": "Fichiers\npériph.",
    "/usr": "Ressources\npartagées",
    "/boot": "Fichiers\ndémarrage",
    "/opt": "Logiciels\noptionnels",
    "/mnt": "Montages\ntemp.",
    "/media": "Périph.\namovibles",
    "/run": "Données\nvolatiles",
    "/lib": "Biblio.\nessentielles",
}

# Dessiner les arêtes (parent → enfant)
for label, x, y, color, parent_xy in nodes:
    if parent_xy is not None:
        px, py = parent_xy
        ax.plot([px, x], [py - 0.25, y + 0.25],
                color='#cccccc', lw=1.2, zorder=1)

# Dessiner les nœuds
for label, x, y, color, parent_xy in nodes:
    depth = label.count('/') - (0 if label == '/' else 0)
    radius = 0.55 if depth <= 1 else 0.45

    circle = plt.Circle((x, y), radius, color=color, alpha=0.25, zorder=3)
    ax.add_patch(circle)
    circle_border = plt.Circle((x, y), radius, color=color,
                               fill=False, linewidth=2, zorder=4)
    ax.add_patch(circle_border)

    # Texte du label (nom court)
    short = label.split('/')[-1] if label != '/' else '/'
    ax.text(x, y + 0.1, short if short else '/', ha='center', va='center',
            fontsize=8.5, fontweight='bold', color=color, zorder=5)

    if label in descriptions:
        ax.text(x, y - 0.65, descriptions[label],
                ha='center', va='top', fontsize=6.5, color='#444444',
                style='italic', zorder=5)

# Légende des catégories
legend_data = [
    (palette[1], "Binaires & bibliothèques"),
    (palette[2], "Configuration (/etc)"),
    (palette[3], "Utilisateurs (/home)"),
    (palette[4], "Données variables (/var)"),
    (palette[5], "Temporaire"),
    (palette[6], "Systèmes virtuels"),
    (palette[7], "Périphériques (/dev)"),
    (palette[8], "Ressources partagées (/usr)"),
]
for i, (color, label) in enumerate(legend_data):
    ax.scatter([], [], color=color, s=80, label=label)
ax.legend(loc='lower left', fontsize=8, framealpha=0.9,
          title="Catégories FHS", title_fontsize=9)

plt.tight_layout()
plt.show()

Résumé#

Ce chapitre a couvert l’organisation fondamentale du système de fichiers Linux :

  • Le FHS (Filesystem Hierarchy Standard) définit une arborescence unique dont la racine est /. Chaque répertoire a un rôle précis : /etc pour la configuration, /var pour les données variables, /proc et /sys pour les systèmes de fichiers virtuels du noyau, /usr pour les ressources partagées.

  • La navigation s’effectue avec pwd (répertoire courant), cd (changer de répertoire) et ls (lister). La maîtrise des chemins absolus (depuis /) et relatifs (depuis .) est essentielle.

  • find est un outil de recherche extrêmement puissant qui permet de filtrer par nom, type, taille, date, permissions et d’exécuter des actions sur les fichiers trouvés via -exec ou xargs.

  • L”inode est la structure qui décrit un fichier (métadonnées + pointeurs vers les données). Les liens durs créent plusieurs noms pour un même inode (au sein d’un même système de fichiers). Les liens symboliques sont des fichiers spéciaux qui contiennent un chemin et peuvent traverser les systèmes de fichiers.

  • Le montage (mount, umount) intègre un système de fichiers dans l’arborescence. /etc/fstab automatise les montages au démarrage.

Le prochain chapitre approfondit les permissions Unix — le système qui contrôle qui peut lire, écrire et exécuter chaque fichier — ainsi que les commandes de manipulation de fichiers (touch, cp, mv, rm) et la gestion des utilisateurs et groupes.

Contenu