Shell Linux

Cette référence fournit les bases pour les tâches usuelles menées par un utilisateur sur un système Linux.

Interpréteur de commandes

Linux est un sytème d’exploitation multi-tâches et multi-utilisateurs.

Cette dernière caractéristique permet à plusieurs utilisateurs d’utiliser le système simultanément.

Afin de définir les limites d’utilisation du système pour chaque utilisateur, on attribue à chacun d’eux un compte utilisateur.

Ainsi, lorsqu’on veut utiliser un système Linux, il faut d’abord se connecter à son compte par une procédure appelée login qui consiste à fournir son identifiant et son mot de passe. Si ceux-ci sont connus du système, on a alors accès au système pour y exécuter des programmes.

Il y a 2 catégories d’utilisateurs :

  1. l'administrateur : c’est celui qui, en principe, a installé le système. Il pourra modifier les préférences générales du système et créer de nouveaux comptes utilisateur. Lui seul pourra installer une application modifiant le système. Sous Linux, son nom est root.

  2. les utilisateurs “standards” : ce sont les autres utilisateurs du système. Ils ont des pouvoirs et accès limités

Bien que Linux dispose d’interfaces graphiques (KDE, Gnome …​), on l’exploite souvent dans un mode appelé ligne de commande. Ce mode qui va vous sembler très “rustique” est cependant très pratique dès lors qu’on désire travailler à distance sur un système Linux (ce qui est souvent le cas lorsqu’on fait de l’administration système).

Pour exploiter ce mode ligne de commande tant redouté mais jamais inégalé , on exécute un logiciel appelé terminal (ou console). Ce logiciel vous donne accès à un interpréteur de commandes en ligne — on dit aussi shell — dont le rôle est d’offrir une interface vers le système d’exploitation par l’intermédiaire de commandes :

  • soit saisies à la main depuis le terminal

  • soit exécutées en séquence depuis un fichier de commandes (ou script) dans lequel elles auront été stockées au préalable.

Shell signifie “coquille” en français. On peut donc considérer l’interpréteur de commandes comme une coquille autour du système d’exploitation qui constitue donc le “noyau” (ou kernel en anglais) du système complet.

Ce qui s’affiche à l’écran lorsqu’on lance un shell s’appelle une invite de commande (ou prompt). Celle-ci indique que l’interpréteur de commandes est en attente de saisie d’une commande.

L’invite de commande est personnalisable mais elle renseigne généralement sur :

  1. le nom de l’utilisateur couramment connecté au système ;

  2. l’endroit où il se trouve dans l’arborescence de fichiers du système ;

  3. le type de compte (“administrateur” ou “standard”).

Par exemple, lorsque l’utilisateur standard ragnar est connecté sur une machine nommée pluton, son invite de commande peut ressembler à ceci :

ragnar@pluton:~/Documents >

avec :

  • ragnar@pluton : le nom d’utilisateur puis le nom de la machine séparés par le caractère arobase (→ ‘@’)

  • ~/Documents : le dossier ou répertoire (folder ou directory en anglais) dans lequel l’utilisateur ragnar se trouve actuellement

  • > : un caractère qui renseigne sur le type de profil sous lequel il connecté → standard en l’occurence (un profil administrateur est généralement indiqué par #)

Dans un système Linux, il existe plusieurs interpréteurs de commandes qui possèdent chacun leurs spécificités (→ bash, sh, tcsh …​). Celui utilisé par défaut dans la distribution OpenSUSE lorsqu’on lance l’application “Konsole” est bash (Bourne Again SHell). C’est une évolution du shell ancestral des systèmes Unix dont découle Linux.

Commandes

Une commande est une ligne de texte destinée à être interprétée par le shell. Le résultat de l’interprétation mène généralement à l’exécution d’un programme. Le terme “commande” désigne ainsi souvent la ligne de texte qu’il faut saisir et le résultat auquel elle mène suite à son interprétation par le shell (→ exécuter une commande ≈ lancer un programme).

Exemple
ragnar@pluton:~> sudo fdisk -l /dev/sda

Ce programme prend bien souvent en entrée des options et/ou des arguments qui lui sont fournis par l’intermédiaire de la ligne de commande.

Pour exécuter une commande, il suffit donc de :

  1. saisir son nom suite à l’invite de commande du shell

  2. fournir éventuellement des arguments et/ou options séparés par des espaces

  3. lancer l’exécution en enfonçant la touche ENTREE du clavier.

L’exécution d’une commande peut mener à divers résultats :

  • renvoyer de l’information à l’écran ou dans un fichier ;

  • communiquer à travers le réseau ;

  • produire un message d’erreur ;

  • …​

Aide à la saisie des commandes

Comme les commandes Linux sont souvent longues à saisir, diverses facilités sont offertes :

  • “l’auto-complétion”

  • l’historique des commandes ;

Auto-complétion

Lorsqu’on tape une ligne de commande incomplète, l’interpréteur peut nous aider à la compléter si on appuie sur la touche TAB du clavier (→ touche de tabulation).

Suivant le contexte, il peut nous proposer de compléter automatiquement le nom de la commande ou le nom d’un fichier fourni en tant qu’argument à une commmande.

Si l’interpréteur ne trouve pas de correspondance ou, au contraire, dispose de plusieurs propositions, il ne fait rien mais un 2ième appui sur la touche TAB provoque l’affichage des différentes propositions lorsqu’elles existent. Ne reste plus à l’utilisateur qu’à lever l’ambiguité en tapant les prochaines lettres de la commande ou nom de fichier désiré. Dès qu’aucune ambiguité ne subsiste, un 3ième appui sur TAB complète automatiquement le reste de la commande ou du nom de fichier.

Si trop de propositions existent lors de l’auto-complétion, l’interpréteur demande confirmation avant de les afficher.

Exemple d’auto-complétion pour le traitement de texte LibreOffice et le client d’administration de la base de donnée MySQL mysqladmin
ragnar@pluton:~ > libr  (1)
ragnar@pluton:~ > libreoffice
[...]

ragnar@pluton:~ > m (2)
Display all 141 possibilities? (y or n)
ragnar@pluton:~ > mysql (3)
mysql                      mysqld_safe                mysql_install_db
mysqladmin                 mysqld_safe_helper         mysql_secure_installation
mysqlbinlog                mysqldump                  mysqlshow
mysqlbug                   mysqldumpslow              mysql_upgrade
mysqlcheck                 mysql_fix_extensions
mysqld_multi               mysqlimport
john@pluton:~> mysqla (4)
john@pluton:~> mysqladmin
[...]
1 On veut lancer LibreOffice. On tape libr puis TAB. Le seul exécutable du système qui commence par libr est libreoffice ⇒ le shell complète automatiquement le nom de l’exécutable.
2 On sait que la commande associée à notre client d’administration MySQL commence par ‘m’ ⇒ on tape ‘m’ puis sur TAB ⇒ rien ne se passe ⇒ on appuie une 2ième fois sur TAB. Trop de commandes commencent par ‘m’ ⇒ bash demande s’il faut vraiment afficher toutes les propositions ⇒ on tape ‘n’
3 On se rappelle maintenant que la commande commence par ‘mysql’ ⇒ on complète donc le m avec ‘ysql’ puis on appuie sur TAB ⇒ rien ne se passe ⇒ on appuie une 2ième fois sur TAB ⇒ bash a trouvé 17 commandes qui commencent par ‘mysql’
4 En la voyant dans la liste des commandes proposées, on sait à présent que notre commande est mysqladmin donc on tape le ‘a’ puis sur TAB ⇒ le shell complète tout seul le nom de la commande (→ il ajoute dmin à mysqla). Ne reste plus qu’à exécuter la commande en enfonçant la touche ENTRÉE.

Historique des commandes

L’historique des commandes est une liste numérotée qui recense les dernières commandes tapées dans la console. Cet historique est accessible en tapant la commande history.

Si la liste est trop longue pour être affichée sur un écran, on aura recours à la commande history | less qui permet, entre autres, de parcourir le résultat d’une commande page par page (le caractère ‘|’ est obtenu avec la combinaison de touches AltGr+6) . Taper alors f (pour forward) pour avancer d’une page, b (pour backward) pour reculer d’une page, q( pour quit) pour quitter et revenir à l’invite de commande (→ prompt).

Pour relancer une commande dont on connait le numéro, il suffit alors de saisir, depuis l’invite de commande, son numéro précédé du caractère `!' (sans espace) puis valider en enfonçant la touche ENTRÉE.

Exemple : Rappeler la commande uname -a
ragnar@pluton:~> history
    1  2023-09-09 16:37:20 history
    2  2023-09-09 16:37:46 uname -a
    3  2023-09-09 16:38:10 whereis whereis
    4  2023-09-09 16:38:16 history
ragnar@pluton:~> !2 (1)
uname -a
Linux pluton 3.11.6-4-desktop #1 SMP PREEMPT Wed Oct 30 18:04:56 UTC 2013 (e6d4a27)
x86_64 x86_64 x86_64 GNU/Linux
ragnar@pluton:~>
1 On saisi, précédé du caractère ‘!’, le n° de la commande uname -a indiqué dans le résultat de la commande history pour l’exécuter sans avoir à la retaper.

On peut aussi parcourir les précédentes lignes de commandes avec les touches ↑ et ↓ du clavier. Ceci permet très facilement de reprendre une précédente commande pour l’éditer et la modifier. C’est d’ailleurs cette méthode que l’on a tendance à utiliser en priorité…​

Documentation d’une commande

La documentation d’une commande peut être obtenue en consultant les pages de manuel intégrées à Linux.

Ceci se fait par l’intermédiaire de la commande man suivie du nom de la commande sur laquelle on désire se renseigner.

Exemple pour la commande groups :

man groups

La structure des pages du manuel est assez semblable d’une page à l’autre. On retrouve :

  • le nom et une courte description ;

  • le synopsis c’est-à-dire la syntaxe générale de la commande avec une indication de l’emplacementet des différents arguments et options ;

  • la description complète de la commande ;

  • la liste des options, autant courtes que longues, et leurs éventuels arguments ;

  • l’auteur de la commande et les informations sur les droits d’auteur ;

  • des références vers d’autres commandes pertinentes dans la même catégorie.

Comme les pages de manuel regroupent l’ensemble de la documentation relative à Linux, il arrive parfois que plusieurs pages soient associées à un même nom. Lorsque cela se produit, un numéro est demandé pour aiguiller vers la documentation demandée.

Exemple : 7 pages de manuel existent pour le mot clé time. Celui-ci peut effectivement représenter une commande mais aussi une fonction en Langage C.

claude@topix:/home/claude> man time
Man: find all matching manual pages (set MAN_POSIXLY_CORRECT to avoid this)
 * time (1)
   time (n)
   time (3am)
   time (2)
   time (7)
   time (1p)
   time (3p)
Man: What manual page do you want?
Man:

Pour afficher une page de manuel particulière pour le mot clé time, il suffit de taper sa catégorie caractérisée par ce qu’il y a noté entre parenthèses à la suite de chaque mot time.

Ainsi, pour obtenir la page de manuel de la commande time (et non celle de la fonction C qui porte le même nom), il suffit de taper le numéro 1 (c’est d’ailleurs le choix par défaut puisque précédé du caractère '*').

Les différentes catégories sont les suivantes :

  • 1 : commandes générales (pour l’interpréteur de commande);

  • 2 : appels système (fonctions du langage C);

  • 3 : fonctions de la librairie standard C et d’autres librairies;

  • 4 : fichiers spéciaux et pilotes;

  • 5 : format de fichiers de configuration et de protocoles;

  • 6 : jeux;

  • 7 : autres.

Pour un accès direct à la page de manuel de la commande time, on peut aussi spécifier directement sa catégorie dans la ligne de commande qui invoque man.

Ex. : man 1 time

Pour obtenir de l’aide sur ce qu’il est possible de faire lors de l’affichage d’une page de manuel (se déplacer, rechercher du texte, quitter…​), il suffit de taper sur la touche h du clavier.

Syntaxe générale des commandes

La syntaxe des commandes, c’est-à-dire la manière dont on doit les écrire, est souvent donnée dans les pages de manuel avec la notation suivante :

commande [option]... [argument]...

avec :

  • commande : le nom du programme à exécuter

  • [option]…​: une suite éventuelle d’options qui précisent la façon dont la commande doit travailler.

    Le caractère facultatif de l’option est indiqué par les crochets et les 3 points indiquent qu’il peut y en avoir plusieurs.

  • [argument]…​: une suite éventuelle d’arguments qui indiquent ce sur quoi la commande va agir (ex. : une liste de fichiers).

Exemple :
ragnar@pluton:~> ls -l -a /etc (1)
1 cette commande affiche une liste détaillée (→ -l) de tous les fichiers (→ -a) du répertoire noté /etc. ls est la commande, -l -a sont les options de la commande, /etc est l’argument de la commande

Linux fait la distinction entre majuscules et minuscules. On dit qu’il est sensible à la casse (case sensitive en anglais).

Ainsi, commande, Commande et cOmMaNdE représentent toutes les 3 des commandes différentes.

Cette distinction entre majuscules et minuscules s’appliquent également aux noms de fichiers ou de répertoires.

Les options peuvent être au format court ou long.

Le format court prend la forme d’un tiret suivi d’une seule lettre (par exemple, -s), tandis que le format long est constitué de deux tirets suivis d’un mot (par exemple, --version).

La plupart du temps, les options courtes ont leurs équivalentes longues (ex. -v est équivalent à --version), mais parfois les versions longues n’existent pas. Enfin, pour certaines options, les versions courtes n’existent pas. Que voulez-vous ? La vie n’est pas toujours un long fleuve tranquille…​

Lorsque qu’on donne plusieurs options précédées de tirets simples ou doubles (→ - ou --) ou qu’on passe plusieurs arguments à une commande, ceux-ci doivent être séparés par au minimum 1 espace.

Si un argument comporte un espace, l’argument doit être entouré de double guillemets.

Exemple d’une commande qui affiche le type d’un fichier dont le nom comporte des espaces
ragnar@tpluton:~> file "compte rendu tp linux.odt"

Enfin, il arrive que certaines options nécessitent elle-mêmes des arguments.

Pour le format court, l’argument de l’option est habituellement placé directement suite au nom de l’option.

Exemple d’une commande utilisant une option courte qui requiert une valeur
ragnar@tpluton:~> gcc -obonjour hello.c (1)
1 commande qui compile un fichier hello.c pour en faire un exécutable nommé bonjour

Pour le format long, il s’agit souvent de séparer le nom de l’option et son argument par le caractère '='.

Exemple d’une commande utilisant une option longue à laquelle on peut passer une valeur
ragnar@tpluton:~> gcc --help=warning (1)
1 commande qui affiche toutes les options du compilateur C gcc en rapport avec la gestion des avertissements

Catégories de commandes

La première chose à savoir est que seul l’administrateur d’un système Linux (→ utilisateur root) a accès à la totalité des commandes. En effet, certaines commandes laissées entre les mains d’utilisateurs non expérimentés peuvent causer de grand dégâts. C’est pour cette raison qu’il est toujours fortement recommandé d’utiliser Linux sous un compte d’utilisateur standard et de passer sur le compte administrateur que lorsque ceci s’avère vraiment nécessaire.

Ensuite, parmi les commandes de base disponibles dans le shell, il faut en distinguer 2 types :

  1. les commandes internes dont le code est totalement intégré dans l’exécutable correspondant au shell (→ builtins).

    Ex. : cd ou history pour le shell bash.

    Outre les services qu’elles rendent, elles sont bien adaptées à l’écriture des fichiers de script shell évoqués plus haut.

  2. les commandes externes qui sont des fichiers exécutables à part entière.

    Ces fichiers se trouvent notamment dans les répertoires /bin, /sbin (situés directement dans le répertoire principal du système) et /usr/bin ou /usr/sbin (sous-répertoires du répertoire usr situé dans le répertoire principal).

    • Sous Linux, les répertoires sont séparés par le caractère / (→ slash).

      Sous Windows, on utilise le caractère \ (→ antislash).

    • Il n’est généralement pas nécessaire de spécifier au shell le répertoire où réside une commande externe pour l’exécuter. En effet, celui-ci possède une liste des répertoires dans lesquels il va rechercher les commandes dans le cas où il n’est pas explicitement spécifié dans la ligne de commande.

      Cette liste est mémorisée dans ce qu’on appelle une variable d’environnement. Il en existe un certain nombre mais celle qui mémorise la liste des répertoires dans lesquels seront cherchées les commandes se nomme PATH. Pour l’afficher, on tape la commande :

      echo $PATH

      Noter que lorsqu’on se réfère au contenu d’une variable d’environnement, on précède son nom du signe $.

  • Certaines commandes existent sous forme de commande interne et externe.

    Exemple :
    ragnar@pluton:~> type kill
kill is a shell builtin (1)
ragnar@pluton:~> ls -l /usr/bin/kill
-rwxr-xr-x 1 root root 39168 May  7  2022 /usr/bin/kill (2)
    1 La commande type indique que kill est une commande interne…​
    2 …​Pourtant, cette commande existe bien sous forme d’exécutable

  • 2 conséquences :

    1. si on veut invoquer la commande externe, il faudra indiquer son chemin complet /usr/bin/kill. Le fait de taper simplement kill appellera la commande interne.

    2. si on veut consulter l’aide de la commande interne, il faudra afficher la page de manuel de l’interpréteur (→ man bash) et non celle de la commande (→ man kill).

Comme indiqué en début de chapitre, les commandes peuvent être également classifiées selon le fait qu’elles soient exécutables par tout le monde ou seulement par l’administrateur.

Commandes liées au système de fichier

Organisation du système de fichiers

Le système de fichiers d’un système d’exploitation correspond à la façon dont il va stocker, lire et organiser les informations sur le disque dur ou tout autre périphérique de stockage.

On peut assimiler l’organisation des informations d’un système de fichiers à celle mise en place par une bibliothécaire : les données figurent dans des ouvrages (→ fichiers) qui sont normalement regroupés par sujet sur des étagères (→ répertoires), elle-mêmes appartenant à des rayons (→ répertoires de plus haut niveau) situés dans la bibliothèque (→ répertoire principal appelé répertoire racine). L’emplacement et les caractéristiques d’un ouvrage sont alors répertoriés dans une base de données documentaire (→ table d’allocation de fichier) maintenue par la biblitohécaire (→ système de fichiers).

Linux prend en charge plusieurs plusieurs types de système de fichiers (→ btrfs, ext4, xfs …​). Linux est également capable d’accéder en lecture/écriture aux systèmes de fichiers utilisés par Windows (→ FAT, FAT32, NTFS).

Contrairement à Windows, un système Linux ne comporte qu’une seule arborescence de répertoires qui débute par le répertoire principal appelé répertoire racine (root en anglais) et désigné par le symbole ‘/’.

Ne pas confondre le répertoire root avec l’utilisateur root.

Sous Windows, chaque périphérique de stockage (ex. : disque dur/partition, DVD…​) dispose de sa propre arborescence de fichiers qui débute par la lettre attribuée au périphérique de stockage (ex. : C:\)

linux fs vs windows fs
Figure 1. Arborescence de fichiers Windows vs. Linux

Ci-dessous figure une liste des répertoires standards que l’on peut retrouver dans le répertoire racine de pratiquement toutes les distributions Linux (OpenSUSE, Ubuntu, Debian, RedHat, Slackware, Arch …​).

Arborescence de fichiers standard sous Linux

filesystem hierarchy

  • /bin : contient les programmes (exécutables) qui sont susceptibles d’être utilisés par tous les utilisateurs de la machine.

  • /boot : contient les fichiers de démarrage de Linux.

  • /dev : contient les fichiers contenant les périphériques.

  • /etc : contient les fichiers de configuration.

  • /home : contient les répertoires personnels des utilisateurs.

  • /lib : contient les bibliothèques partagées (généralement des fichiers .so) utilisées par les programmes.

  • /media, /mnt : accès aux périphériques amovibles (SDcard, clé USB…​).

  • /root : dossier personnel de l’utilisateur root.

  • /sbin : contient des programmes système importants qui ne sont exécutables que par l’utilisateur root

  • /tmp : pour le stockage temporaire des fichiers.

  • /usr : dossier d’installation de la plupart des programmes utilisateur.

  • /var : contient des données “variables” (fichiers logs, fichiers de serveur web, …)

Les chemins d’accés absolus et relatifs

On a vu jusqu’à présent que pour accéder à un fichier particulier, on spécifiait son emplacement — ou chemin d’accès (path en anglais) — en précédant son nom par la totalité des répertoires à traverser depuis le répertoire racine en les séparant par le caractère slash (/) : c’est ce qu’on appelle un chemin absolu.

Exemple d’affichage du fichier data.txt situé dans le répertoire /home/claude/Documents/
ragnar@pluton:/> less /home/claude/Documents/data.txt

Un chemin absolu peut également débuter depuis le répertoire de l’utilisateur courant (/home/<user>, <user> étant le nom de l’utilisateur) en spécifiant le caractère tilde (~).

Le même exemple que ci-dessus mais avec un accès qui utilise le “raccourci” ~ à la place de /home/ragnar
ragnar@pluton:/> less ~/Documents/data.txt

Il existe une autre manière de spécifier l’emplacement d’un fichier ou répertoire — nommée chemin relatif — qui est basée sur la notion de répertoire courant. Ce dernier représente le répertoire dans lequel l’utilisateur se trouve actuellement. Son emplacement peut évoluer au cours du temps en utilisant par exemple la commande cd (Change Directory).

Le répertoire courant peut être obtenu :

  • en inspectant l’invite de commande (ou prompt en anglais)

    claude@topix:~/Downloads> (1)
    1 Le répertoire courant est ~/Downloads (c’est-à-dire /home/ragnar/Downloads d’après le prompt qui indique le nom d’utilisateur avant le @)

  • en tapant la commande pwd

    ragnar@pluton:~/Downloads> pwd (1)
/home/ragnar/Downloads
ragnar@pluton:~/Downloads>
    1 On demande au shell d’afficher le répertoire courant avec la commande pwd (→ Print Working Directory)

Pour spécifier le répertoire courant dans une commande, on utilise le point (‘.’).

Exemple de changement de répertoire à partir du répertoire courant
ragnar@pluton:~> cd ./Downloads (1)
ragnar@pluton:~/Downloads>
1 On demande au shell de se déplacer dans le sous-répertoire Downloads situé dans le répertoire courant (→ /home/ragnar) c’est-à-dire /home/ragnar/Downloads.

Le répertoire qui contient le répertoire courant est appelé le répertoire parent. Pour y faire référence dans une commande, on utilise 2 points (‘..’).

Ci-dessous un ensemble de commandes qui illustrent l’utilisation des chemins absolus et relatifs.

Exemple :
ragnar@pluton:~/Downloads> cd /usr/bin (1)
ragnar@pluton:/usr/bin> cd ~/Downloads/ (2)
ragnar@pluton:~/Downloads> cd .. (3)
ragnar@pluton:~> touch ./Documents/compte_rendu.txt (4)
ragnar@pluton:~> cd ../../usr/local/ (5)
ragnar@pluton:/usr/local>
1 Quel que soit le répertoire courant, on se déplace à l’aide d’un chemin absolu dans /usr/bin/. Le repertoire courant devient /usr/bin/.
2 On se déplace dans le sous répertoire Downloads du répertoire de l’utilisateur courant (→ /home/ragnar/Downloads) avec un chemin absolu. Celui-ci devient alors le répertoire courant.
3 On se déplace avec un chemin relatif dans le répertoire parent de ~/Downloads/ c’est-à-dire ~ (→ /home/ragnar).
4 On crée un fichier vide compte_rendu.txt dans le sous-répertoire Documents du répertoire courant à l’aide d’un chemin relatif.
5 On se déplace dans le répertoire /usr/local/ à partir du répertoire courant à l’aide d’un chemin relatif. Le chemin relatif spécifie de “remonter” de 2 niveaux dans l’arborescence de fichiers avant de “redescendre” dans le répertoire usr/ puis dans son sous-répertoire local/.

Propriétés des fichiers

Un fichier est caractérisé par :

  • son type,

  • ses droits d’accès,

  • son propriétaire,

  • son groupe.

La gestion des droits est la même quel que soit le système de fichier installé(ext4, btrfs …​).

Exemple de contenu d’un répertoire
ragnar@pluton:~ > ls -l
rw-r--r-- 1 root root  269 Sep 13 19:50 .gtkrc-2.0
drwxr-xr-x 1 root root   10 Sep 13 19:50 .local
drwxr-xr-x 1 root root   20 Sep 14 15:41 Documents
drwxr-xr-x 1 root root    0 Sep 13 19:50 Downloads
drwxr-xr-x 1 root root    0 Sep 13 19:50 Music
drwxr-xr-x 1 root root    0 Sep 13 19:50 Pictures
drwxr-xr-x 1 root root    0 Sep 13 19:50 Videos
-rw-r--r-- 1 root root    0 Sep 14 15:42 readme.txt
Les droits des fichiers sous Linux

Type

(1erbit)

Droits propriétaire

(les 3 bits suivants)

Droits du groupe

(les 3 bits suivants)

Droits des autres

(les 3 bits suivants):

Propriétaire

Groupe

  • ‘-’ : fichier régulier

  • ‘d’ : répertoire

  • ‘r’ : read

  • ‘w’ : write

  • ‘x’ : execute

    ou

    ‘s’ : suid

  • ‘r’ : read

  • ‘w’ : write

  • ‘x’ : execute

    ou

    ‘s’ : sgid

  • ‘r’ : read

  • ‘w’ : write

  • ‘x’ : execute

    ou

    ‘t’ : sticky bit

Nom de l’utilisateur propriétaire du fichier

Nom du groupe d’utilisateurs ayant des droits particuliers

Lorsque la lettre est présente, le droit est effectif. Lorsque le caractère ‘-’ est présent, cela signifie que le droit est refusé.

Les droits ‘r’ et ‘w’ spécifient les droits en lecture (→ Read) et en écriture (→ Write) sur des fichiers ou répertoires.

L’affichage du contenu d’un fichier/répertoire, sa copie ou son déplacement impliquent l’autorisation de son droit ‘r’ pour l’utilisateur qui lance la commande .

La création, suppression, édition, copie ou déplacement d’un fichier/sous-répertoire dans un répertoire impliquent l’autorisation du droit ‘w’ dans ce dernier pour l’utilisateur qui lance la commande.

Le droit ‘x’ (→ eXecute) ne s’applique qu’aux fichiers exécutables (programmes ou scripts) et aux répertoires. Pour un répertoire, ce droit signifie qu’on peut le “traverser” pour accéder à ses sous répertoires.

La 3ème série de droits — “Droits des autres”) — s’applique aux utilisateurs n’étant ni le propriétaire du fichier/répertoire ni un membre du groupe indiqué.

suid, sgid, sticky bit

Ces droits spéciaux méritent une explication particulière

✓ suid

Ce droit ne s’applique qu’aux fichiers exécutables et non aux répertoires.

Un fichier exécutable possédant ce droit s’exécute sous l’identité de son propriétaire quel que soit l’utilisateur qui le lance.

Linux ignore ce droit pour les exécutables qui sont des scripts (Python, bash …​)

C’est très pratique mais peut s’avérer une faille de sécurité si le propriétaire du fichier est root.

Exemple : la commande passwd, qui permet à n’importe qui de changer son mot de passe, dispose de ce droit. Elle est exécutable par n’importe qui alors qu’elle doit modifier un fichier système (→ /etc/passwd) possédé par l’utilisateur root

localhost:~ # ls -l /usr/bin/passwd
-rwsr-xr-x 1 root shadow 65208 Apr 19 09:36 /usr/bin/passwd (1)
1 un s minuscule apparait à la place du droit x du propriétaire pour signaler l’autorisation du droit suid. Si le fichier n’est pas exécutable par le propriétaire, c’est un ‘S’ majuscule qui est indiqué.

Si un pirate parvient, à l’aide d’un hack, à garder l’identité de root après exécution de la commande, celui-ci prend le contrôle total de la machine. 😱

Pour donner ce droit à un fichier on utilise l’une ou l’autre des commandes suivantes :

  • chmod u+s <exécutable>

    ex. chmod u+s ~/app

  • chmod 4<droits-rwx-en-octal> <exécutable>

    ex. chmod 4755 ~/app

Pour le retirer :

  • chmod u-s <exécutable>

    ex. chmod u-s ~/app

  • chmod 00<droits-rwx-en-octal> <exécutable>

    ex. chmod 00755 ~/app

✓ sgid

Contrairement au droit suid, le droit sgid, s’applique aussi bien aux fichiers exécutables qu’aux répertoires.

Son rôle sur un fichier exécutable est à peu près semblable au suid en permettant de prendre l’identité du groupe — et non du propriétaire — durant son exécution.

Pour un répertoire son rôle est complètement différent. La création de fichiers ou de répertoires dans un répertoire ayant ce droit par un utilisateur aura pour effet qu’ils appartiendront au groupe propriétaire du répertoire.

Ce droit est particulièrement utile pour les répertoires utilisés dans le cadre d’un travail collaboratif entre membres d’un groupe.

Pour donner ce droit à un exécutable/répertoire on utilise l’une ou l’autre des commandes suivantes :

  • chmod g+s <exécutable-ou-répertoire>

    ex. chmod g+s ~/Documents/

  • chmod 2<droits-rwx-en-octal> <exécutable-ou-répertoire>

    ex. chmod 2755 ~/Documents/

Pour le retirer :

  • chmod g-s <exécutable-ou-répertoire>

    ex. chmod g-s ~/Documents/

  • chmod 00<droits-rwx-en-octal> <exécutable-ou-répertoire>

    ex. chmod 00755 ~/Documents/

✓ sticky bit

Ce droit, bien que possible pour un fichier, n’a de sens aujourd’hui que pour un répertoire.

Il n’accorde le droit de suppression d’un fichier dans ce répertoire qu’à son propriétaire (ou à l’utilisateur root).

Pour donner ce droit à un répertoire on utilise l’une ou l’autre des commandes suivantes :

  • chmod o+t <répertoire>

    ex. chmod o+t ~/Documents/

  • chmod 1<droits-rwx-en-octal> <répertoire>

    ex. chmod 1755 ~/Documents

Pour le retirer :

  • chmod o-t <répertoire>

    ex. chmod o-t ~/Documents/

  • chmod 00<droits-rwx-en-octal> <répertoire>

    ex. chmod 00755 ~/Documents

Un bon exemple d’utilisation de ce droit est celui du répertoire /tmp de Linux dans lequel tout le monde peut écrire mais qui interdit à tout utilisateur, autre que le propriétaire du fichier, de le supprimer.

luc@localhost:~> ls -ld /tmp
drwxrwxrwt 1 root root 1618 Sep 21 19:06 /tmp (1)
luc@localhost:~> touch /tmp/dummy.txt (2)
luc@localhost:~> ls -l /tmp/dummy.txt (3)
-rw-r--r-- 1 luc ciel 0 Sep 21 19:06 /tmp/dummy.txt
luc@localhost:~> su john --login (4)
Password:
john@localhost:~> rm /tmp/dummy.txt (5)
rm: remove write-protected regular empty file '/tmp/dummy.txt'? y
rm: cannot remove '/tmp/dummy.txt': Operation not permitted
john@localhost:~> logout (6)
luc@localhost:~> rm /tmp/dummy.txt (7)
luc@localhost:~> ls -l /tmp/dummy.txt (8)
ls: cannot access '/tmp/dummy.txt': No such file or directory
luc@localhost:~>
1 le sticky bit (→ bit t) est positionné sur /tmp
2 l’utilisateur luc crée un fichier dummy.txt dans ce répertoire
3 le fichier appartient à luc
4 on se connecte en tant que l’utilisateur john
5 john essaye de supprimer le fichier mais ceci lui est refusé
6 on reprend l’identité de luc
7 luc supprime avec succès le fichier
8 effectivement, le fichier n’existe plus

Commandes principales

Le tableau ci-dessous recense quelques commandes de base liées au système de fichier :

cd

Change Directory : Permet de se déplacer dans les dossiers.

cd /dossier

ls

List : Liste les fichiers d’un dossier.

ls –al

cat

CATalog : Affiche le contenu d’un ou plusieurs fichier(s).

cat /etc/passwd

cp

CoPy : Copie un fichier

cp filesrc filedest

rm

ReMove : Supprime un fichier ou un dossier non vide

rm file rm –r dossier

mkdir

MaKe DIRectory : Crée un répertoire.

mkdir dossier

rmdir

ReMove DIRectory : Supprime un répertoire vide.

rmdir dossiervide

mv

MoVe : Déplacer ou renomme un fichier.

mv filesrc filedest

touch

Met à jour l’heure du fichier mais est utilisé traditionnellement pour créer un fichier vide

touch fichier

file

Renseigne sur le type du contenu d’un fichier

file fichier

find

Retrouve l’emplacement d’un fichier.

find –name fichier

Dans la suite du document et ce, dans un soucis d’alléger l’affichage, l’invite de commande ne sera plus reproduite en intégralité dans les exemples de commandes. Seul le type de shell, standard ou administrateur, sera respectivement signalé par ‘$’ et ‘#’ en début de ligne. Ce caractère ne devra donc pas être saisi lorsqu’il vous sera demandé de reproduire une commande.

Exemples :
$ ls -l (1)
# halt (2)
1 ici, la commande ls -l doit être saisie dans une console en tant qu’utilisateur standard
2 là, halt doit être saisie dans une console en tant qu’utilisateur root.

Dans l’arborescence Linux, en tapant la commande ls -l on peut parfois rencontrer à la suite du nom d’un fichier une flèche suivie d’un chemin d’accès à un autre fichier :

$ ls -l /usr/bin/firefox
lrwxrwxrwx 1 root root 27 Aug 31 19:34 firefox -> ../lib64/firefox/firefox.sh

Cela signifie que le fichier firefox pointe vers le fichier firefox.sh qui se trouve dans le répertoire ../lib64/firefox.

On dit que firefox est un lien vers le fichier firefox.sh.

Un lien permet d’accéder au même fichier depuis plusieurs endroits de l’arborescence un peu à la manière d’un raccourci sous Windows.

Pour créer un lien sur un fichier, on utilise la commande ln.

Cette commande permet de créer 2 types de lien selon que l’option -s est spécifiée ou non :

  1. les liens symboliques (soft links)

  2. les liens matériels (hard links)

Un lien matériel peut être considéré comme un moyen de donner plusieurs noms à un même fichier.

Un lien symbolique, quant à lui, peut être considéré comme un fichier qui “pointe” sur un autre fichier.

hard vs symbolic links

La conséquence de tout cela est que détruire un fichier pour lequel il existe un lien matériel n’empêchera pas d’accéder à son contenu (ceci se fera alors par le biais du lien matériel et non plus à travers le chemin d’accès du fichier d’origine.)

Par contre, si on détruit un fichier sur lequel ne pointe qu’un seul lien symbolique, son contenu est vraiment perdu et le lien symbolique devient, comme il arrive parfois sur internet, un “lien mort”.

Donc, dans le cas de la figure ci-dessus, si on détruit “File 1” son contenu sera encore accessible par “Hard link to File 1” mais plus par “Symbolic Link to File 1”. Si on détruit alors “Hard link to File 1”, le fichier est définitivement perdu.

Méta-caractères du shell

Des méta-caractères sont des caractères qui remplacent/décrivent d’autres caractères ou qui prennent un sens particulier dans un certain contexte.

Dans le cadre du shell, ces méta-caractères sont généralement utilisés :

Exemple :
$ ls /dev/tty* (1)
1 Cette commande liste tous les fichiers du répertoire /dev dont le nom débute par tty.

Parmi les méta-caractères les plus répandus, on trouve :

  • l’astérisque ‘*’,

  • le point d’interrogation ‘?’

  • le point d’exclamation ‘!’

  • les crochets ‘[ ]’

  • les signes ‘<’ et ‘>’

  • la barre verticale ‘|’ (obtenu avec la combinaison de touches AltGr+6

  • l’esperluette ‘&’

  • le point virgule ‘;’

  • l’antislash ‘\’

Ainsi, lorsqu’ils apparaissent dans des commandes, le shell leur accorde une signification particulière et les traite avant d’exécuter la commande.

Exemple d’utilisation du méta-caractère ; pour enchaîner 2 commandes :
$ echo "Vive " ; uname (1)
Vive (2)
Linux (3)
$
1 le ; permet de saisir plusieurs commandes sur une même ligne. Celles-ci seront exécutées les unes à la suite des autres.
2 Résultat de la commande echo " Vive " qui affiche son argument sur l’écran
3 Résultat de la commande uname qui affiche le nom du système d’exploitation sur lequel on travaille

Des moyens existent cependant pour annuler le sens particulier des méta-caractères au sein des commandes :

  • L'échappement qui annule le sens particulier de tout méta-caractère.

    Il consiste à précéder le méta-caractère par un antislash (‘\’).

    Pour annuler le sens particulier de l’antislash, il suffit de le doubler.

    Exemple : Affichage d’un texte comportant un antislash avec la commande echo
    $ echo Windows7 est installé par défaut dans c:\windows
Windows7 est installé par défaut dans c:windows  (1)

$ echo Windows7 est installé par défaut dans c:\\windows
Windows7 est installé par défaut dans c:\windows (2)
$
    1 il manque l’antislash entre ‘:’ et ‘windows’ car il a été “englouti” par le shell qui lui accorde une signification particulière
    2 en doublant l’antislash dans la commande, l’affichage est conforme à ce qui est attendu

  • les guillemets doubles ("…​") qui annulent l’interprétation par le shell de certains méta-caractères éventuellement présents dans le texte qu’ils délimitent.

    L’utilisation des guillemets double ne désactive pas les mécanismes de substitution de commande et de substitution de variables qui seront abordés ultérieurement.
    Exemple : affichage de texte comportant les signes ‘<’ et ‘>’ et faisant référence à une variable d’environnement
    $ echo le nom de ma machine est <pluton>
bash: syntax error near unexpected token `newline' (1)
$ echo "le nom de ma machine est <pluton>"
le nom de ma machine est <pluton> (2)
$
    1 Le signe ‘<’ a été interprété par le shell ⇒ il génère une erreur car la commande n’a alors plus de sens pour lui
    2 les guillemets double ont annulé l’interprétation des signes ‘<’ et ‘>’ ⇒ le texte est affiché tel quel

  • les guillemets simples (' ') qui annulent le sens de tous les méta-caractères éventuellement présents dans le texte qu’ils délimitent.

    • Leur utilisation revient à précéder chaque méta-caractère du texte par un antislash.

    • Contrairement aux guillemets double, les guillemets simples désactivent les mécanismes de substitution de commande et de substitution de variables

Caractères génériques associés aux fichiers

Les caractères génériques sont des méta-caractères qui vont permettre de désigner un ensemble de fichiers (ou de répertoires) dans une commande sans avoir à les lister individuellement.

Exemple : afficher le type de tous les fichiers du répertoire /etc commençant par ‘e’
$ file /etc/e*
/etc/enscript.cfg: ASCII text
/etc/environment:  ASCII text
/etc/esd.conf:     ASCII text
/etc/ethers:       ASCII text
/etc/exports:      ASCII text
$

  • le caractère ‘*’ remplace n’importe quel nombre de caractères

    Voir exemple ci-dessus.

  • Le caractère ‘?’ remplace n’importe quel caractère unique :

    Exemple : lister tous les fichiers de /usr/bin dont la 2ième lettre est un ‘b’
    $ ls  /usr/bin/?b*

  • Les crochets (‘[ ]’) sont utilisés pour définir un ensemble ou une plage de valeurs :

    Exemple : lister tous les fichiers du répertoire courant dont le nom commençe par un ‘a’ suivi d’un chiffre en seconde position.
    $ ls  a[0123456789]*
    Exemple : la même commande en utilisant une plage valeurs.
    $ ls  a[0-9]*

  • Le point d’exclamation est utilisé avec les crochets pour inverser la signification de la plage de valeurs

    Exemple : lister les fichiers du répertoire courant qui ne commencent pas par la lettre ‘a’
    $ ls  [!a]*

Flux d’entrée/sortie, redirection et tubes

Flux d’entrées/sorties

Dans Linux, chaque programme dispose par défaut de 3 descripteurs de fichier qui pointent sur des canaux de communication appelés flux ou stream en anglais.

streams

C’est par ces 3 flux que le programme :

  • reçoit les informations qu’on lui communique

    ⇒ ce flux est appelé STDIN (STandarD INput) et il est généralement alimenté par ce que l’utilisateur tape au clavier

  • envoie les informations qu’il produit

    ⇒ ce flux est appelé STDOUT (STandarD OUTput) et il correspond généralement à l’écran du terminal où s’exécute le programme

  • communique les erreurs qu’il peut rencontrer

    ⇒ ce flux est appelé STDERR (STandarD ERRor) et, lui aussi, est dirigé normalement vers l’écran

Redirection

Le mécanisme de redirection permet, comme son nom l’indique, de rediriger les flux vers ou depuis des fichiers.

Il est ainsi possible de lister le contenu d’un répertoire non pas à l’écran mais dans un fichier de façon, par exemple, à en garder une trace.

Pour cela, on va utiliser le symbole ‘>’ dans la commande suivi d’un nom de fichier pour lui indiquer d’envoyer les informations produites dans ce fichier.

Exemple : lister le contenu de son répertoire personnel dans le fichier listing.txt puis afficher ce fichier avec la commande cat
$ ls ~ > listing.txt
$ cat listing.txt
bin
Desktop
Documents
Downloads
Music
Pictures
Public
public_html
sketchbook
Templates
Videos
$

Lorsqu’un même fichier est spécifié dans plusieurs commandes redirigées avec ‘>’, le contenu de celui-ci ne contiendra que le résultat de la dernière commande. Son contenu est en effet écrasé suite à chaque redirection.

Si on désire mettre bout à bout (on dit aussi concaténer) les résultats de chaque commande redirigée, on utilise ‘>>’ au lieu de ‘>’.

Exemple : Écrire dans un fichier le nom ainsi que la release du kernel suivis des informations sur la distribution Linux puis afficher le fichier produit
$ echo "== INFOS KERNEL ==" > info_linux.txt (1)
$ uname -rs >> info_linux.txt (2)
$ echo "== INFOS DISTRIB ==" >> info_linux.txt (2)
$ lsb_release -a >> info_linux.txt (2)
$ cat info_linux.txt
== INFOS KERNEL ==
Linux 4.4.76-1-default
== INFOS DISTRIB ==
LSB Version:    n/a
Distributor ID: openSUSE project
Description:    openSUSE Leap 42.3
Release:        42.3
Codename:       n/a
$
1 On redirige avec ‘>’ le résultat de la commande echo dans le fichier “info_linux.txt”. S’il existe déjà, son contenu est écrasé
2 On ajoute les résultats des commandes au fichier grâce à l’utilisation de ‘>>’

Pour rediriger le flux STDERR dans un fichier on va utiliser ‘2>’. le ‘2’ est l’identifiant de STDERR. En effet, chaque flux dispose d’un identifiant :

  • 0 = STDIN ;

  • 1 = STDOUT ;

  • 2 = STDERR.

Exemple : Afficher le contenu des répertoires de la racine du système de fichiers débutant par ‘r’ (normalement root/ et run/ sachant que le répertoire root/ n’est pas accessible à un utilisateur standard :
$ ls /r* (1)
ls: cannot open directory /root: Permission denied
/run:
avahi-autoipd.eno16777736.pid  lock       pcscd          udev
[...]
$ ls  /r* 2> err.txt (2)
/run:
avahi-autoipd.eno16777736.pid  lock       pcscd          udev
[...]
$ cat err.txt (3)
ls: cannot open directory /root: Permission denied
$
1 On tente de lister les répertoires : /root → NOK (Permission denied), /run → OK
2 On redirige le flux d’erreur sur le fichier err.txt ⇒ on ne visualise sur l’écran que STDOUT c’est-à-dire uniquement les informations produites lors de l’exécution normale (le contenu du répertoire /run en l’occurence)
3 On affiche le fichier vers lequel STDERR a été redirigé. Celui-ci ne contient alors que les message d’erreur produits par la commande.

Il est enfin possible de rediriger le flux STDIN avec ‘<’ même si cette opération est plus rare.

Exemple : Convertir du texte en majuscules
$ tr [:lower:] [:upper:] (1)
Ceci représente le texte à convertir en MAJUSCULES. (2)
CECI REPRÉSENTE LE TEXTE À CONVERTIR EN MAJUSCULES. (3)
^C
$ cat foo.txt (4)
Ceci représente le texte à convertir en MAJUSCULES.
$ tr [:lower:] [:upper:] < foo.txt (5)
CECI REPRÉSENTE LE TEXTE À CONVERTIR EN MAJUSCULES.(6)
1 On invoque la commande tr (comme translate).
2 Sans redirection, la commande attend par défaut la saisie d’un texte au clavier (→ STDIN ). La commande convertit le texte en majuscules lorsqu’on appuie sur la touche ↲ du clavier
3 Le résultat de la conversion en majuscules est affiché
4 On affiche le contenu d’un fichier foo.txt qui contient le même texte de départ mêlant à la fois minuscules et majuscules.
5 On exécute cette fois la commande tr en redirigeant l’entrée standard depuis le fichier foo.txt et non depuis le clavier
6 On obtient le même résultat

Les redirections sont très intéressantes pour le dialogue avec les périphériques. En effet, sous Linux, les ports séries ou parallèles sont représentés par des fichiers situés dans le répertoire /dev.

Exemples :
$ echo "trame" > /dev/ttyS0 (1)
$ cat < /dev/ttyS0 (2)
$GPGGA,064036.289,4836.5375,N,00740.9373,E,1,04,3.2,200.2,M,,,,0000*0E
<Ctrl+C>
$
1 envoi le texte “trame” sur le port série /dev/ttyS0 (équivalent de COM1 sur Windows)
2 affichage d’une trame provenant d’un GPS branché sur le port série /dev/ttys0

Tubes (pipe)

Les tubes ou pipes en anglais sont un moyen d’envoyer la sortie d’une commande (→ STDOUT) sur l’entrée (→ STDIN) de la suivante.

Le schéma suivant illustre ce mécanisme :

pipe

Une commande capable de recevoir son entrée via un pipe est appelée un filtre.

Toutes les commandes de Linux ne sont pas des filtres.

Un tube se note à l’aide du caractère ‘|’ (combinaison AltGr+6 sur le clavier).

Exemple d’utilisation d’un tube pour afficher le nombre de lignes d’un fichier
$ sudo cat /var/log/messages | wc -l (1)
6835
1 la commande cat redirige le contenu du fichier /var/log/messages vers la commande wc -l dont le rôle est de compter le nombre de lignes de ce qui lui est fourni en entrée. Le résultat de cet “enchaînement” de commandes informe que le fichier comporte 6835 lignes.

Les tubes sont très souvent utilisés. Il est donc essentiel de bien les maîtriser.

Gestion réseau

Linux dispose d’une multitude de commandes liées au réseau.

Parmi ces commandes, certaines sont couramment utilisées. Ce sont elles que nous allons étudier maintenant.

Configurer une interface réseau : ip

Cette commande remplace et complète la commande ifconfig désormais obsolète.

Elle remplace également d’autres commandes comme arp et route

Cette commande permet, entre autres :

  • d’obtenir des informations sur une interface réseau

  • de configurer une interface réseau (adresse IP, passerelle par défaut…​)

  • d’activer ou désactiver une interface réseau

  • …​

Exemples :
$ ip addr (1)
# ip addr add 192.168.1.15/24 dev eth0 (2)
# ip link set dev eth0 up (3)
1 Affichage des informations sur toutes les interfaces réseau présentes sur la machine
2 Assignation d’une IP statique à l’interface eth0
3 Activation de l’interface eth0

Un aide-mémoire de cette commande est disponible sur ip COMMAND CHEAT SHEET for Red Hat Enterprise Linux link

Tester une connexion réseau : ping

La commande ping permet de tester l’acheminement de trames sur le réseau et, accessoirement, de vérifier qu’une machine est bien présente sur le réseau.

Elle permet aussi de réaliser des statistiques sur les temps de réponse ainsi que sur le pourcentage de paquets de données perdus.

Pour cela, elle utilise le protocole ICMP en envoyant des messages de type ECHO Request qui requièrent de la part du destinataire de répondre par un ECHO Reply.

Sur Linux, ping doit par défaut être arrêté manuellement en tapant Ctrl+C. La commande affiche alors des statistiques sur le temps de propagation aller-retour (Round Trip Time).

$ ping 192.168.1.1
PING 192.168.1.1 (192.168.1.1) 56(84) bytes of data.
64 bytes from 192.168.1.1: icmp_seq=1 ttl=128 time=4.62 ms
64 bytes from 192.168.1.1: icmp_seq=2 ttl=128 time=4.40 ms
64 bytes from 192.168.1.1: icmp_seq=3 ttl=128 time=4.28 ms
^C
--- 192.168.1.1 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2004ms
rtt min/avg/max/mdev = 4.288/4.439/4.622/0.158 ms (1)
$
1 Les valeurs indiquent les temps de propagation aller-retour (→ rtt = Round Trip Time) min., moyen et max. des paquets de données ainsi que la déviation standard (→ mdev)

Lorsqu’un ping reçoit une réponse, on est assuré que :

  • l’ordinateur qu’on utilise est correctement configuré

  • l’ordinateur interrogé est présent et également correctement configuré

  • le réseau qui relie les ordinateurs est opérationnel.

Gestion des processus

Linux est un système d’exploitation multi-tâches et multi-utilisateurs.

De ce fait, il est capable de gérer simultanément un ensemble de programmes lancés par un ou plusieurs utilisateurs.

Un processus (ou tâche) est une instance d’un programme en cours d’exécution. Ainsi, le fait de lancer 3 fois un même programme provoquera la création de 3 processus distincts.

Un processus est identifié par le système à l’aide d’un numéro appelé PID (Process IDentifier).

Il est souvent utile de connaître les processus en cours d’exécution, de les contrôler, voire de les tuer.

Visualiser les processus.

Les 3 commandes les plus utilisées pour visualiser les processus sont :

  • ps

  • top

  • pstree

✓ ps permet d’afficher des informations à un instant donné sur les processus présents en mémoire. Une large gamme d’options est disponible. Celles-ci permettent d’obtenir à peu près toutes les informations sur les processus.

✓ top ajoute un côté dynamique à l’affichage des processus dans le sens où il met à jour automatiquement les informations affichées à l’écran. Le délai de rafraichissement des informations par défaut est de 3 secondes mais ce délai est configurable. L’appui sur la barre d’espace provoque une mise à jour immédiate des informations.

✓ pstree affiche les processus sous la forme d’une arborescence qui met en évidence la parenté entre ceux-ci.

Agir sur un processus avec les signaux

Les signaux sont un moyen de communication avec les processus. Linux prend en charge 64 signaux mais seul un nombre restreint d’entre eux sont utilisés au quotidien.

La façon la plus commune d’envoyer les signaux à un processus est d’utiliser la commande kill. Celle-ci prend en option le numéro du signal à envoyer et le PID du processus destinataire en argument.

La commande kill sera notamment utilisée pour tuer un processus qui ne répond plus mais ce n’est pas sa seule utilisation.

Se souvenir que la commande kill permet d’envoyer toutes sortes de signaux et non simplement le signal nommé SIGKILL qui requiert l’arrêt brutal d’un processus.

Quelques combinaisons de touches permettent également d’envoyer des signaux au processus en cours :

  • Ctrl+C : envoie le signal SIGINT qui provoque généralement l’arrêt du processus

  • Ctrl+Z : envoie le signal SIGTSTP qui demande la suspension du processus

Une autre façon d’envoyer un signal est d’utiliser la commande killall qui prend en argument, non pas le PID du processus, mais son nom. Ceci permet notamment de quitter toutes les instances d’un programme sans avoir à connaitre leur PID ou à leur envoyer individuellement le signal SIGINT.

🞄  🞄  🞄