Linux

Conservatoire National des Arts et Métiers
Centre associé de Strasbourg
—
Certificat Professionnel de Technicien Micro
Réseau et Internet
—
UV TMRI-1 - Systèmes en réseaux
1 valeur, 100 heures
Introduction au système Linux
Rémi LEBLOND
(remi.leblond@laposte.net)
23 mars 2004
2
Table des matières
1 Introduction 9
1.1 Qu’est-ce qu’un logiciel libre ? . . . . . . . . . . . . . . . . . . . 9
1.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.1.2 L’importance du code source . . . . . . . . . . . . . . . . 9
1.1.3 Les libertés apportées aux utilisateurs de logiciels libres . 11
1.1.4 La FSF et le projet GNU - La licence GPL . . . . . . . . 11
1.2 Concepts de base de Linux . . . . . . . . . . . . . . . . . . . . . 14
1.2.1 Origines : Le système UNIX . . . . . . . . . . . . . . . . 14
1.2.2 Le système Linux . . . . . . . . . . . . . . . . . . . . . . 16
1.2.3 Historique du projet Linux . . . . . . . . . . . . . . . . . 17
1.3 Les distributions de Linux . . . . . . . . . . . . . . . . . . . . . 21
1.3.1 Installation et configuration manuelle . . . . . . . . . . . 21
1.3.2 Les distributions . . . . . . . . . . . . . . . . . . . . . . 22
1.3.3 Standardisation des distributions . . . . . . . . . . . . . . 24
2 Fonctionnalités de Linux 27
2.1 Fonctionnalités du noyau . . . . . . . . . . . . . . . . . . . . . . 27
2.1.1 Présentation rapide . . . . . . . . . . . . . . . . . . . . . 27
2.1.2 Découpage du système . . . . . . . . . . . . . . . . . . . 28
2.1.3 Le noyau Linux . . . . . . . . . . . . . . . . . . . . . . . 29
2.1.4 Le couple GNU - Linux . . . . . . . . . . . . . . . . . . 32
2.1.5 Notion de processus . . . . . . . . . . . . . . . . . . . . 37
2.1.6 Parallèle avec Windows . . . . . . . . . . . . . . . . . . 38
2.2 Principe du système de fichiers . . . . . . . . . . . . . . . . . . . 39
2.2.1 Notion de système de fichier . . . . . . . . . . . . . . . . 39
2.2.2 Les différents types de fichiers . . . . . . . . . . . . . . . 39
2.2.3 Structure du système de fichiers . . . . . . . . . . . . . . 40
2.3 Sécurité et utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . 44
2.3.1 Notion de système multi-utilisateur . . . . . . . . . . . . 44
2.3.2 Méta-données sur les fichiers . . . . . . . . . . . . . . . . 45
2.3.3 Processus de connexion . . . . . . . . . . . . . . . . . . 46
3
4 TABLE DES MATIÈRES
3 Arborescence d’un système Linux 47

3.1 Systèmes de fichier . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.1.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.2 Présentation des principaux répertoires . . . . . . . . . . . . . . . 49
3.2.1 / . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2.2 /bin/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2.3 /sbin/ . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2.4 /home/ . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2.5 /root/ . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.2.6 /etc/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.2.7 /var/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.2.8 /usr/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.2.9 /opt/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2.10 /dev/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2.11 /mnt/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.2.12 /boot/ . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.2.13 /tmp/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.14 /lib/ . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.15 /proc/ . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.3 Montage de systèmes de fichier . . . . . . . . . . . . . . . . . . . 56
3.3.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.3.2 La commande mount . . . . . . . . . . . . . . . . . . . 56
3.3.3 Le fichier /etc/fstab . . . . . . . . . . . . . . . . . . 58
4 Utilisation de Linux 61
4.1 Trouver de l’aide . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.1.1 Le manuel . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.1.2 TexInfo . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.1.3 Les HOWTO . . . . . . . . . . . . . . . . . . . . . . . . 62
4.1.4 Les documentations . . . . . . . . . . . . . . . . . . . . 63
4.1.5 Autres sources d’information . . . . . . . . . . . . . . . . 63
4.2 Les commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.2.1 Principes de base . . . . . . . . . . . . . . . . . . . . . . 64
4.2.2 Les entrées - sorties de commandes . . . . . . . . . . . . 64
4.2.3 Redirection de commandes . . . . . . . . . . . . . . . . . 66
4.3 Entrer et sortir de Linux . . . . . . . . . . . . . . . . . . . . . . . 67
4.3.1 Connexion à un système Linux . . . . . . . . . . . . . . . 67
4.3.2 Déconnexion d’un système Linux . . . . . . . . . . . . . 69
4.3.3 Arrêt et redémarrage du système . . . . . . . . . . . . . . 70
4.4 Parcours du système de fichier . . . . . . . . . . . . . . . . . . . 71
4.4.1 Identifier le répertoire courant . . . . . . . . . . . . . . . 71
TABLE DES MATIÈRES 5
4.4.2 Naviguer dans les répertoires . . . . . . . . . . . . . . . . 75

4.4.3 Créer un nouveau répertoire . . . . . . . . . . . . . . . . 76
4.4.4 Supprimer un répertoire . . . . . . . . . . . . . . . . . . 77
4.5 L’éditeur de texte vi . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.6 Manipulation de fichier . . . . . . . . . . . . . . . . . . . . . . . 82
4.6.1 Visualiser le contenu d’un fichier . . . . . . . . . . . . . 83
4.6.2 Copie de fichier . . . . . . . . . . . . . . . . . . . . . . . 83
4.6.3 Déplacement de fichier . . . . . . . . . . . . . . . . . . . 84
4.6.4 Suppression de fichier . . . . . . . . . . . . . . . . . . . 84
4.6.5 Liens de fichiers . . . . . . . . . . . . . . . . . . . . . . 84
4.6.6 Recherche de fichier . . . . . . . . . . . . . . . . . . . . 86
4.6.7 Recherche de texte dans un fichier . . . . . . . . . . . . . 88
4.6.8 Compression et décompression des fichiers . . . . . . . . 90
4.7 Manipulation de processus . . . . . . . . . . . . . . . . . . . . . 91
4.7.1 Qu’est-ce qu’un processus . . . . . . . . . . . . . . . . . 91
4.7.2 Lancer une commande en tâche de fond . . . . . . . . . . 91
4.7.3 Interaction avec les processus . . . . . . . . . . . . . . . 93
4.7.4 Planifier l’exécution automatique de processus . . . . . . 94
4.8 L’environnement utilisateur . . . . . . . . . . . . . . . . . . . . . 94
4.8.1 Les variables d’environnement . . . . . . . . . . . . . . . 94
4.8.2 Les alias . . . . . . . . . . . . . . . . . . . . . . . . . . 94
4.8.3 Portée de l’environnement . . . . . . . . . . . . . . . . . 96
4.8.4 Les fichiers de définition de l’environnement . . . . . . . 96
4.9 Définition des droits d’accès . . . . . . . . . . . . . . . . . . . . 97
4.9.1 Identification des utilisateurs . . . . . . . . . . . . . . . . 97
4.9.2 Le fichier /etc/passwd : Fichier des utilisateurs du système 98
4.9.3 Le fichier /etc/group : Fichier des groupes d’utilisateurs 98
4.9.4 Droits élémentaires sur les fichiers . . . . . . . . . . . . . 99
4.9.5 Définition des droits d’accès . . . . . . . . . . . . . . . . 102
5 Installation de Linux 105

5.1 Avant de commencer l’installation . . . . . . . . . . . . . . . . . 105
5.1.1 Configuration minimale . . . . . . . . . . . . . . . . . . 105
5.1.2 Récupération des informations sur le matériel . . . . . . . 105
5.1.3 Sauvegarde des données . . . . . . . . . . . . . . . . . . 107
5.1.4 Amorçage . . . . . . . . . . . . . . . . . . . . . . . . . . 108
5.1.5 Partitionnement du disque . . . . . . . . . . . . . . . . . 109
5.2 Déclaration des utilisateurs locaux . . . . . . . . . . . . . . . . . 115
5.2.1 Création des utilisateurs . . . . . . . . . . . . . . . . . . 115
5.2.2 Création des groupes . . . . . . . . . . . . . . . . . . . . 116
6 Mise en réseau 119

6.1 Principes généraux des réseaux . . . . . . . . . . . . . . . . . . . 119
6.1.1 Les classes de réseau IP . . . . . . . . . . . . . . . . . . 119
6.2 Configuration de base . . . . . . . . . . . . . . . . . . . . . . . . 119
6.2.1 Affectation d’adresse . . . . . . . . . . . . . . . . . . . . 119
6.2.2 Définition de règles de routage . . . . . . . . . . . . . . . 121
6.2.3 Test de la configuration . . . . . . . . . . . . . . . . . . . 121
6.2.4 Résolution des noms de machines . . . . . . . . . . . . . 122
6.3 Centralisation de configuration . . . . . . . . . . . . . . . . . . . 122
6.3.1 Installation d’un serveur NIS . . . . . . . . . . . . . . . . 122
6.3.2 Mise en oeuvre d’un serveur de noms (DNS) . . . . . . . 125
6.3.3 Partage de configuration réseau via DHCP . . . . . . . . . 125
6.4 Partage de ressources . . . . . . . . . . . . . . . . . . . . . . . . 125
6.4.1 Accès distant par telnet . . . . . . . . . . . . . . . . . . . 125
6.4.2 Partage de fichiers par NFS . . . . . . . . . . . . . . . . . 125
6.4.3 Publication de fichier via FTP . . . . . . . . . . . . . . . 125
6.4.4 Publication Web via HTTP . . . . . . . . . . . . . . . . . 125
7 Compilation du noyau 127

7.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
7.2 Installation des fichiers sources . . . . . . . . . . . . . . . . . . . 128
7.3 Paramétrage de la compilation . . . . . . . . . . . . . . . . . . . 129
7.4 Compilation et installation du noyau . . . . . . . . . . . . . . . . 130
7.5 Compilation et installation des modules . . . . . . . . . . . . . . 133
8 Les scripts shell 135

Présentation du cours
Objectifs du cours
Le cours systèmes informatiques en réseau vise à fournir aux auditeurs les
compétences suivantes :
Pour chacun des deux systèmes Windows et Linux, être capable de les instal-
ler, les administrer, créer et gérer un réseau dans ces environnements, installer des
logiciels bureautiques.
Ce document ne traite uniquement le système Linux.
Admission et pré-requis
Cette formation s’adresse à toute personne en situation d’emploi ou de re-
cherche d’emploi. Elle est ouverte aux bénéficiaires d’emplois-jeunes ou aux aides
éducateurs préparant leur insertion professionnelle future. Aucun diplôme en in-
formatique n’est à priori exigé. Il est cependant souhaitable d’avoir déjà utilisé
un ordinateur et d’avoir une certaine pratique de son système d’exploitation. Des
connaissances générales correspondant au niveau Baccalauréat sont exigées. Un
entretien préalable à l’inscription permettra, le cas échéant, de s’assurer du niveau
d’entrée du candidat.
7
Chapitre 1
Introduction
Dans ce chapitre, nous introduirons la notion de logiciel libre, nous aborde-

rons ensuite le système Linux sous un angle historique, puis technique. A l’issue
de ce chapitre, nous devrions avoir une vision globale de Linux nous permettant
d’aborder la manipulation du système.
1.1 Qu’est-ce qu’un logiciel libre ?

1.1.1 Introduction
Il est difficile de parler du système Linux sans aborder une de ses principales
caractéristiques : il s’agit d’un logiciel libre. Mais qu’entend-on par logiciel libre ?
Dans cette section, nous introduirons la notion de logiciel libre afin de bien
comprendre son esprit et les possibilités qu’elle offre à ses utilisateurs.
1.1.2 L’importance du code source

Pour comprendre le concept de logiciel libre, il faut d’abord comprendre ce
qu’est un logiciel (ou encore un programme, ou une application).
Du point de vue de l’utilisateur, un logiciel est souvent vu comme une applica-
tion qui répond à l’un de ses besoins (traitement de textes, programme de dessin,
jeu, etc... ). Nous l’envisageons sous une perspective un peu plus large, prenant
en compte son mode d’élaboration, pour nous permettre d’évaluer les libertés que
nous pouvons prendre à son égard.
Pour créer un logiciel, un programmeur l’écrit dans un langage de programma-
tion (C, Perl, Python, Java, ...) compréhensible et utilisable par les programmeurs.
Un outil appelé compilateur permet ensuite de convertir ce langage en un code
binaire (dit langage machine) qui est le seul que puisse interpréter un ordinateur.
9
10 CHAPITRE 1. INTRODUCTION
Le logiciel dans sa forme compréhensible par les programmeurs est appelé

“code source”, et dans sa version en langage machine “binaire”. Le passage du
code source au binaire est réalisé à l’aide d’un compilateur.
Code source
Binaire
#include<stdio.h>
int main(void)
{ 01000111101101101
int a=0, pid; 00010101001011110
pid = fork(); 01101010111100000
if (pid == 0)
Compilation 01101101001001100
{ 0011011101010110
// Programme du fils
printf("Je suis le fils\n"); 011110110110110
} 0110110111011010
else
{
// Programme du père Exécution
int i,j;
// Attente de la fin du fils
//wait();
for (i=0; i<10; i++)
F IG . 1.1 – Processus de création d’une application
Si le code source est facilement compréhensible par un humain (pour peu qu’il
connaisse le langage utilisé), le binaire n’est réellement exploitable que par une
machine. Ainsi, s’il est très difficile de comprendre les rouages d’un logiciel si
on ne dispose que du fichier binaire, l’analyse du code source dévoile tous les
mécanismes mis en oeuvre par le logiciel1 .
Le code source est donc essentiel en matière de logiciel, car sa connaissance
permet d’examiner le fonctionnement d’une application et éventuellement de l’amé-
liorer ou d’en corriger les bogues. C’est aussi, par exemple, le garant de l’absence
de porte dérobée compromettant la sécurité d’un système informatique ou de fonc-
tionnalité malicieuse. [APR]
1
Ce qui explique que bien des éditeurs de logiciel soient opposés à la divulgation des codes
sources de leurs applications, au titre compréhensible de la protection de leurs “secrets de fabrica-
tion”.
1.1. QU’EST-CE QU’UN LOGICIEL LIBRE ? 11
1.1.3 Les libertés apportées aux utilisateurs de logiciels libres

Un logiciel libre est un logiciel garantissant un certain nombre de libertés à
ses utilisateurs. Nous allons procéder par analogie en comparant le code source
d’un logiciel à une recette de cuisine.
Imaginons que vous vous trouvez dans un restaurant et que vous mangez un
excellent plat. Peut-être aurez vous l’envie de pouvoir le cuisiner chez vous pour
vos amis ?
C’est impossible si vous n’avez pas la recette du plat. Vous pouvez toujours le
manger dans le restaurant, mais même si vous connaissez le goût, vous ne savez
comment le reproduire. La liberté d’échanger des recettes de cuisines est essen-
tielle pour les cuisiniers comme pour les simples gourmets.
En informatique, il en va de même pour un un logiciel. Le code source est la
recette, le binaire est le plat déjà cuisiné. La plupart des logiciels dits logiciels
propriétaires sont distribués sans leur code source, et il est interdit d’essayer de
comprendre leur fonctionnement. Il est interdit de les partager avec vos amis, et il
est interdit d’essayer de les modifier pour les adapter à vos besoins.
A l’opposé un logiciel libre garantit aux utilisateurs quatre libertés :
– la liberté d’utiliser le logiciel, pour quelque usage que ce soit,
– la liberté d’étudier le fonctionnement du programme, et de l’adapter à vos
propres besoins,
– la liberté de redistribuer des copies de façon à pouvoir aider votre voisin,
– la liberté d’améliorer le programme, et de diffuser vos améliorations au
public, de façon à ce que l’ensemble de la communauté en tire avantage.
Ce sont ces libertés fondamentales à l’utilisation de l’informatique, à la créa-
tion et au partage des informations, que l’APRIL2 entend protéger et développer.
Les logiciels libres sont avant tout porteurs de liberté de partage et d’accès à la
connaissance.
Elles sont bien sûr essentielles aux informaticiens, mais aussi aux utilisateurs,
pour lesquelles elles garantissent la capacité de maîtriser les outils et les informa-
tions sans risque de dépendance vis-à-vis d’un quelconque éditeur de logiciels.
Les logiciels libres ont connu un succès planétaire grâce à l’effort de dévelop-
pement entrepris voilà plus de 15 ans dans le cadre du projet GNU.
1.1.4 La FSF et le projet GNU - La licence GPL

Richard STALLMAN, considéré par tous comme le père des logiciels libres
a commencé à penser au logiciel libre lorsqu’il travaillait au laboratoire d’intelli-
gence artificielle au MIT dans les années 1980.
2
APRIL : Agence pour la Promotion de l’informatique Libre
F IG . 1.2 – Logo des applications Open Source
En 1983, Richard M. STALLMAN initie le projet GNU (GNU est un jeu de

mots récursif signifiant GNU’s Not Unix). Ce projet vise à concevoir un sys-
tème d’exploitation complet et entièrement libre. Ce système sera compatible avec
UNIX, mais sera différent car il n’exploitera pas les sources originales d’AT&T.
Pour soutenir le développement du projet GNU, la Free Software Foundation
(http ://www.fsf.org) est créée en 1985.
F IG . 1.3 – Logo du projet GNU
Pour valider ce système, une base légale est nécessaire. Cette base légale, créée
de toutes pièces, est la licence GNU GPL (pour GNU General Public License).
La GNU GPL est la licence des logiciels libres par excellence. Elle détermine
des conditions de distribution qui garantissent les libertés de l’utilisateur. Un pro-
gramme protégé par la GPL est libre, mais la GPL impose aussi que tout travail
dérivé de ce logiciel reste libre. On peut estimer à plus de 70% le nombre de
logiciels libres qui son protégés par la GNU GPL. [APR]
Il faut distinguer les logiciels libres de logiciels du domaine public (freeware).
En effet, les logiciels libres sont systématiquement livrés avec leur code source,
qu’il est possible de modifier à condition de redistribuer les sources modifiées.
1.1. QU’EST-CE QU’UN LOGICIEL LIBRE ? 13
Cette obligation n’existe pas pour les logiciels du domaine public, dont seule la
version binaire est gratuite.
L’utilisation de logiciels du domaine publique pour un usage professionnel
est stratégiquement risquée car il est impossible de s’assurer que les mises à jour
ultérieures du logiciel resteront gratuites. On peut ainsi imaginer un éditeur dis-
tribuant gratuitement son logiciel pour faciliter sa diffusion et, une fois le marché
acquit ferait payer les nouvelles versions3.
Ce scénario est impossible avec des logiciels libres exploitant la licence GPL,
car cette dernière oblige chaque contributeur à diffuser librement les sources de
toute adaptation d’un logiciel libre. Même si une nouvelle version devenait pro-
priétaire, ce qui est tout à fait envisageable4 , il serait toujours possible de pour-
suivre le développement de l’application dans sa version “libre” à partir des sources
de l’avant dernière version (qui était libre).
Il existe d’autres licences qualifiées de libres, bien que souvent moins contrai-
gnantes quant à la divulgation des sources (la licence BSD, la licence Mozilla... ).
Il faut toutefois souligner que la licence GPL, véritable clef de voûte d’un grand
nombre de logiciels libres (dont Linux), n’a jamais été éprouvée devant la justice 5 .
La question de sa validité juridique reste donc levée.
Bien que cela puisse paraître contradictoire, il est tout à fait possible de com-
mercialiser une solution exploitant la licence GPL, à condition de rendre dispo-
nibles les sources des programmes. Par exemple, si une société A développe une
solution basée sur un logiciel libre adapté par ses soins, il peut la commercialiser
et en tirer des bénéfices financiers. Par contre, elle est tenue de rendre les sources
de ses adaptations disponibles gratuitement. De ce fait, une société concurrente B
peut reprendre ces sources, les modifier et les commercialiser à son tour. La so-
ciété A peut alors se sentir lésée par cette divulgation de son travail, mais comme
la société B est aussi tenue de publier les sources de ses modifications, elle peut à
son tour profiter des améliorations apportées pour les intégrer à son offre. De plus,
la société A n’est plus contrainte d’assurer seule la maintenance et l’évolution de
sa solution, elle est désormais aidée par la société B. Pour que ce modèle soit ren-
table, il faut bien entendu que la société A garde une plus value par rapport à la
société B, autre que le code source de sa solution.
Ce fonctionnement nous oblige à revoir notre façon d’envisager l’approche
commerciale de l’industrie informatique. La plus value d’une entreprise choisis-
sant de commercialiser du logiciel libre ne réside plus dans la rétention du code
3
Ceci est une simple supposition, nous savons bien que le marché de l’informatique n’est pas
aussi perfide...
4
Le propriétaire d’un programme peut changer à tout moment la licence le protégeant. Par
contre, la licence GPL interdit l’intégration de code protégé par la GPL dans des programmes ne
répondant pas à cette licence.
5
Du moins au moment de la rédaction de ce document...
source de ses programmes, jusqu’alors considéré comme le patrimoine le plus

précieux de l’éditeur. L’enjeu se situe sur le service rendu à ses clients afin de
proposer les solutions les plus adaptées en se basant sur un ensemble de briques
de bases puisées parmi les logiciels libres.
Cette approche permet d’optimiser le travail des différents acteurs qui, au lieu
de redévelopper maintes fois le même code source, peuvent s’appuyer sur un tra-
vail existant en l’améliorant si besoin, pour le plus grand bien de la communauté.
A titre d’exemple, essayez d’imaginer les ressources financières et humaines qui
ont été gaspillées à développer les fonctionnalités communes des différents trai-
tements de texte que nous avons connu jusqu’à présent. N’aurait-il pas été plus
fructueux de capitaliser ce travail dans le développement d’une solution libre ?
Bien évidement, cette réflexion ne convient pas du tout à des acteurs ayant
réussi à verrouiller un marché autour d’une situation de monopole comme l’a
fait Microsoft dans le domaine de la bureautique. Le logiciel libre est aussi une
solution permettant d’éviter ce genre de situation. Il constitue en ce sens un garde-
fou précieux pour le futur.
D’une autre façon, une entreprise ayant développé une application pour ses be-
soins internes peut trouver un intérêt évident à publier les sources de cette dernière
sous une licence GPL. En effet, si la solution proposée est adoptée par d’autres
utilisateurs, l’ensemble de ces derniers peut collaborer à la maintenance et l’évo-
lution de l’application et, ainsi, se partager les coûts inhérents.
1.2 Concepts de base de Linux

1.2.1 Origines : Le système UNIX
Linux est le noyau d’un système d’exploitation libre de type Unix, écrit initia-
lement par Linus Torvalds en 1991 et auquel un grand nombre de programmeurs
ont contribué par Internet depuis. [GIC02]
Les origines de tous les systèmes Unix remontent à la première version d’un
système d’exploitation expérimental développé par Denis Ritchie et Ken Thomp-
son dans les laboratoires AT&T’s Bell Laboratories en 1969. Ce système a avant
tout été développé par des programmeurs, pour des programmeurs, et reprenait un
certain nombre de concepts qui avaient été développés auparavant pour le système
d’exploitation Multics (abréviation de “Multiplexed Information and Computing
Service”), dont le rôle était de fournir des services informatiques centralisés à un
grand nombre de personnes. Multics n’a jamais réellement vu le jour car il était
trop ambitieux par rapport aux moyens de l’époque, en revanche, le système Unix
initial a engendré un grand nombre d’autres systèmes plus ou moins compatibles,
du fait notamment de son mode de distribution original.
1.2. CONCEPTS DE BASE DE LINUX 15
Pour l’anecdote, la dénomination “Unix” provient de la contraction de “Unics”

(abréviation de “Uniplexed Information and Computing Service”), terme forgé
ironiquement pour bien signaler qu’Unix était une version allégée de ce que Mul-
tics aurait dû être.
Unix a été développé en utilisant le langage de programmation C. Ce langage
a la particularité d’être portable6 sur un grand nombre d’architectures différentes,
ce que ne permet pas l’utilisation d’un langage de programmation de bas niveau
comme l’assembleur7 , alors largement utilisé pour la réalisation de systèmes d’ex-
ploitation. La particularité d’Unix, comparé à d’autres systèmes comme Windows
par exemple, tient du fait qu’il a été développé puis distribué sous la forme de code
source et de spécifications8 . A partir de ce code source, chaque éditeur pouvait
mettre au point sa propre version d’Unix, afin de l’adapter à son besoin. Ce mode
de distribution a permis une rapide expansion d’Unix, puisque chaque construc-
teur s’est empressé de porter Unix sur ses machines, ce que n’aurait pas pu faire
AT&T9 . Il n’existe donc pas une unique version d’Unix, mais toute une famille
de systèmes Unix. L’utilisation du langage C donna à Unix une de ses caractéris-
tiques les plus importantes : son universalité. Unix n’a, aujourd’hui encore, pas
d’équivalent dans ce domaine et il y a fort peu de familles d’ordinateurs ne dispo-
sant pas d’au moins une version d’Unix10 .
Il existe différentes versions commerciales d’Unix, il faut signaler que seules
celles qui sont positionnées dans le haut de gammes survivent à la confrontation
avec Linux :
Solaris : L’Unix de Sun,
AIX : L’Unix d’IBM,
HP/UX : L’Unix de Hewlett Packard,
QNX : Un Unix destiné aux systèmes embarqués,
6
Un programme est dit portable s’il peut s’exécuter, moyennant de faibles adaptations, sur
différents environnements.
7
L’assembleur est un langage de programmation très proche du langage machine, il décom-
pose finement chaque opération, ce qui le rend difficilement lisible. Un programme en assembleur
est fortement lié à l’architecture de la machine pour laquelle il est écrit. Il permet donc de réali-
ser des programmes fortement optimisés mais très peu portables. Lorsque l’on utilise un langage
de programmation plus évolué, comme le langage C, le programme est généralement transformé
automatiquement en assembleur lors de la compilation. Le même programme C peut donc être
facilement transformé en différents programmes assembleurs adaptés à de diverses architectures,
simplement en utilisant des compilateurs différents.
8
L’utilisation du code source d’AT&T nécessitait le payement d’une licence
9
En tout cas, pas aussi rapidement et, certainement, pas aussi bien, puisque chaque constructeur
est le mieux placé pour adapter un système sur ses machines.
10
Ce qui est loin d’être le cas de Windows, qui ne fonctionne réellement que sur des architec-
tures de type PC.
IRIX : L’Unix destiné aux stations Silicon Graphics,

SCO Unix : Un Unix bas de gamme pour PC (qui souffre actuellement de la
concurrence de Linux).
Il existe aussi différentes versions non commerciales d’Unix (hormis Linux) :
FreeBSD une variante libre de l’Unix BSD,
Minix basé sur une architecture à micro noyau et uniquement destiné à l’étude
des systèmes d’exploitation. Du fait de ses importantes limitations, ce sys-
tème ne peut pas être utilisé en production.
L’inconvénient du mode de distribution d’Unix est la divergence des solutions
proposées par les différents fournisseurs. Ainsi, même s’ils exploitent des racines
communes, les différentes améliorations apportées par les distributeurs de sys-
tèmes Unix ont aboutis à des systèmes de moins en moins compatibles.
Pour éviter une trop grande divergence, les différents fournisseurs de systèmes
Unix se sont récemment accordés pour définir l’ensemble des fonctionnalités que
tous les systèmes Unix doivent supporter, et ce afin de résoudre les problèmes
engendrés par les incompatibilités existantes entre ces différents systèmes. Unix
est donc un terme générique pour représenter l’ensemble de tous ces systèmes,
dont Linux fait partie.
Linux apparaît aujourd’hui comme un Unix universel que tout le monde ap-
pelait de ses voeux, par contre, il risque aussi de subir la même dérive que les
systèmes Unix si l’on y prend pas garde.
1.2.2 Le système Linux

Bien que compatible avec les dernières spécifications Unix, Linux ne contient
pas une ligne du code source du système Unix original, ce qui en fait ce que l’on
appelle un clone11 . Cela dit, il s’agit réellement d’un système Unix à part entière.
En tant que tel, il dispose des fonctionnalités fournies par les systèmes Unix : il
est multitâche, multi-utilisateur et orienté réseau. Vous aurez donc, avec Linux, un
système fiable, fonctionnel et performant.
Installé sur un poste de travail, Linux vous permettra de réaliser les opéra-
tions les plus classiques, comme effectuer un travail bureautique, naviguer sur
Internet, réaliser l’acquisition, la capture et le retraitement d’images, réaliser des
animations 3D ou encore programmer12 . C’est toutefois installé sur un serveur
que Linux révèle toute sa puissance : c’est un système fiable, qui peut fonctionner
plusieurs mois en continu. En temps que système Unix, il s’intègre parfaitement
11
Et évite le payement de la licence AT&T.
12
Créé par des programmeurs passionnés, Linux offre un choix unique d’outils de développe-
ment
F IG . 1.4 – Tux : La “mascotte” de Linux
dans un réseau et il permet de faire fonctionner un grand nombre d’outils très

performants et disponibles gratuitement (base de données, serveur Web, serveur
d’applications, serveur de messagerie, serveur d’authentification... ). Enfin, il s’in-
tègre parfaitement dans un environnement Windows dans lequel il peut remplacer
avantageusement un serveur Windows NT. De plus, contrairement à l’installation
de Linux sur les postes clients, son installation sur un serveur n’est pas ressen-
tie directement13 par les utilisateurs, ce qui permet une migration en douceur et
évite de se confronter à un problème culturel (surtout lié à l’utilisation de la suite
bureautique Office de Microsoft).
1.2.3 Historique du projet Linux

1991 : une naissance dans l’anonymat
Linus Torvalds, étudiant à l’université d’Helsinki (Finlande) installe le sys-
tème Minix14 sur son i386. Le système s’avérant trop limité pour lui, il décide
d’aller plus loin sur la base de ce qui existe. Linux (Linus’ Unix, l’Unix de Linus)
0.0.1 est né au mois d’août 1991. Afin de poursuivre les développements, Linus
lance un appel à contribution sur le forum de discussion comp.os.minix en
13
Un indice tout de même : Si vous remplacez un serveur Windows par un serveur Linux, les
utilisateurs se rendrons peut-être compte que ce dernier plante moins souvent...
14
Minix est un petit Unix développé par M. TANNENBAUM dans un but éducatif et pouvant
fonctionner sur tout PC équipé au minimum de processeurs Intel 8086.
F IG . 1.5 – Linus TORVLADS
ces termes :
Bonjour à tous les utilisateurs de minix.
Je développe un système d’exploitation (gratuit) (c’est juste un

passe-temps, je ne prétends pas à un système aussi important et
professionnel que GNU) pour les clones AT 386(486).
Dépendant au départ du système Minix, Linux devient autonome le 5 octobre

1991, lors de la sortie officielle de la version 0.0.2. Cette version permet de faire
tourner quelques applications GNU (logiciels libres) essentielles comme le com-
pilateur gcc15 ou le shell bash. Linus prend la décision de mettre le code source
sous licence GPL : tout le monde peut alors participer au développement de Linux.
C’est certainement une des principales clefs du succès de Linux...
Une maîtrise originale de l’ensemble du développement en permet l’accès
au plus grand nombre, sans aucune restriction de contenu. Ainsi, nul cahier des
charges, nulle équipe isolée (et restreinte) de développeurs : ce sont les échanges
d’idées et de bouts de codes qui vont améliorer le système. Afin de garder l’ho-
mogénéité globale du système, Linus se charge de valider les apports réalisés par
les contributeurs du projet. C’est donc lui qui valide la sortie de chaque nouvelle
version du noyau16 .
C’est de là qu’est né le succès actuel de Linux. En effet, l’apport constant
des développeurs toujours plus nombreux, avec leurs améliorations ou leurs idées
15
gcc : GNU cross compilator.
16
Aujourd’hui ce mode de validation semble arriver à un point de saturation, Linus TORVALDS
n’ayant plus suffisamment de disponibilité pour valider efficacement toutes les modifications ap-
portées au noyau par les nombreux contributeurs (ce n’est qu’un homme après tout).
nouvelles, permet à Linux d’être toujours plus proche des besoins de ses utilisa-
teurs. [2LI]
Lien avec le projet GNU

Un des objectifs du projet GNU est le développement d’un système com-
plet basé sur Unix. Pour cela, vu l’ampleur de la tâche à accomplir, les dévelop-
peurs GNU se ont commencé à développer les outils périphériques (compilateurs,
éditeurs de texte, client réseau... ) en se basant sur des systèmes Unix existants
(FreeBSD ou Minix le plus souvent), l’étape suivante étant le développement du
noyau du système.
Il existe depuis longtemps un projet GNU visant à réaliser un système complet
architecturé autour du micro-noyau Mach17 : Ce projet très ambitieux s’appelle
Hurd18 et il commence seulement aujourd’hui à devenir exploitable. Le projet
Hurd a été rattrapé par le développement du noyau Linux qui, associé aux ou-
tils GNU, constitue le premier système d’exploitation entièrement libre. On parle
donc couramment de système GNU/Linux.
1991-1994 : un développement original

Le développement anarchique de Linux ne lui permet pas, au départ, de deve-
nir un système compétitif face aux autres systèmes du marché. Son principal point
faible réside dans son système de fichiers hérité de Minix. Seule l’intégration à Li-
nux du Second Extended Filesystem (ext2fs), conçu par Rémi CARD à partir du
système de fichiers du système Unix BSD, permet d’en faire un système fiable.
Ext2fs offre enfin les performances et les services de systèmes de fichiers pro-
fessionnels. Il devient naturellement un standard. La présence dans le processus
de développement de développeurs venant de nombreux horizons permet à Linux
d’exister sur de nombreuses plates-formes (Mac, Atari, Amiga, Alpha) autres que
sa plate-forme d’origine (Intel). Petit à petit, Linux devient un système Unix com-
plet compatible avec les autres systèmes Unix, offrant toujours plus de services de
qualité professionnelle au plus grand nombre. [2LI]
1995 : une année charnière

L’explosion d’Internet donne un second souffle au développement de Linux :
non seulement pour permettre à la communauté des développeurs de Linux de
17
Ce micro noyau est aussi utilisé pour des systèmes comme MacOsX.
18
‘Hurd’ stands for ‘Hird of Unix-Replacing Daemons’. And, then, ‘Hird’ stands for ‘Hurd of
Interfaces Representing Depth’. We have here, to my knowledge, the first software to be named
by a pair of mutually recursive acronyms.
continuer à s’étendre, mais aussi et surtout pour donner à Linux une existence
réelle sur le marché des systèmes d’exploitation. Ainsi, ses qualités d’OS libre (et
gratuit), robuste et performant font qu’il est choisi par de plus en plus de fournis-
seurs d’accès à Internet. Il est ainsi devenu aujourd’hui le leader sur le marché de
l’hébergement de sites Web.
Parallèlement, l’apparition et le développement de sociétés privées telles que
RedHat, Caldera ou VA Linux donne une envergure jusqu’alors inconnue à Linux :
les distributions deviennent de plus en plus conviviales et simples à installer, et des
services professionnels sont mis en place pour faciliter l’implantation de Linux
dans les entreprises. [2LI]
1996 : l’année du décollage

– RedHat Linux est élu meilleur OS par InfoWorld,
– Linux commence à faire parler de lui dans les média,
– Netscape et Corel commencent à distribuer des versions Linux de leurs pro-
duits,
– Début de la guerre anti-Microsoft menée par Netscape,
– Échec d’OS/2 Warp d’IBM (Linux semble alors constituer la seule alterna-
tive crédible à l’hégémonie de Windows dans le domaine des systèmes pour
PC),
– Les administrateurs système se familiarisent avec Linux,
– Début du projet KDE19 : on commence à développer des projets conviviaux
pour le grand public. [2LI]
1997 : une reconnaissance "professionnelle"

– Des clusters (grappes) d’ordinateurs sous Linux sont utilisés pour les effets
spéciaux de Titanic ou du Pic de Dante,
– Linux est utilisé pour le système de tri de courrier de la poste américaine,
– Linux fait son apparition dans les systèmes embarqués (téléphones cellu-
laires, navettes spatiales),
– Linux s’impose dans les milieux scientifiques et professionnels spécialisés.
[2LI]
1998 : Linux aux portes du grand public

– Oracle, Sun ou Informix adoptent Linux et fournissent des versions de leurs
produits phare adaptées pour ce système20 ,
19
KDE : Killer Desktop Environment.
20
Ces versions sont généralement vendues moins chères que pour les autres plates-formes.
1.3. LES DISTRIBUTIONS DE LINUX 21
– De grandes sociétés commencent à déployer Linux sur une partie de leur

parc informatique (France Télécom, Cisco),
– Linux commence à faire peur aux éditeurs d’autres systèmes d’exploitation
(documents d’Halloween de Microsoft21 ),
– Linux est présent sur 25% des serveurs d’entreprises. [2LI]
1999 : la reconnaissance du marché des entreprises et des marchés financiers

– Linux est présent sur 35% des serveurs d’entreprises,
– Les salons Linux se multiplient (LinuxExpo, EuroLinux... ),
– Début de la médiatisation de Linux dans les média traditionnels (télévision,
radio),
– Linux est largement présenté comme une alternative au système Windows
de Microsoft dans le domaine des serveurs,
– Multiplication des revues spécialisées,
– Entrée en bourse de certains des principaux acteurs de Linux (RedHat, VA
Linux). [2LI]
Le système GNU/Linux est aujourd’hui réputé pour sa fiabilité et sa robus-
tesse. Ceci est dû en partie à la liberté des logiciels qui le composent : l’accès
aux sources permettant de corriger très facilement et rapidement une erreur de
programmation.
GNU/Linux est aujourd’hui utilisé aussi bien par les entreprises que par les
utilisateurs finaux (on estime actuellement le nombre d’utilisateurs à plusieurs
dizaines de millions).
Les plus grandes sociétés informatiques (IBM, Sun, HP, ...) conscientes des
qualités des logiciels libres existants, rejoignent le nombre des partisans de ce
système, et contribuent à son développement. [APR]
1.3 Les distributions de Linux

1.3.1 Installation et configuration manuelle
Initialement, l’installation de Linux était une opération fastidieuse et relati-
vement compliquée (comparée à celle d’un système Windows, par exemple) et
l’usage d’un système Unix “brut” n’est pas à la portée de tout le monde. Tradi-
tionnellement, pour installer un système Linux, il fallait récupérer sur internet les
codes sources, les compiler sur sa machine et assembler le tout manuellement. La
21
Il s’agit d’un mail interne de la société Microsoft faisant part de son inquiétude vis à vis de
l’essor de Linux et précisant sa stratégie de lutte contre les logiciels libres. Ce document avait alors
été intercepté et largement diffusé sur Internet.
complexité de ces opérations est telle qu’elle réservait l’installation de Linux à

des experts.
Linux doit en grande partie sa réputation de système complexe à installer à
cette époque que certains qualifient avec nostalgie “d’héroïque”. Heureusement,
les choses se sont grandement simplifiées depuis.
1.3.2 Les distributions

Pour faciliter l’installation et l’utilisation de systèmes Linux, on a vu appa-
raître des “distributions”, intégrant dans un environnement homogène l’ensemble
des outils nécessaires à une utilisation courante et automatisant au maximum l’ins-
tallation et le paramétrage du système. Ces distributions facilitent grandement
l’installation de Linux et leur qualité s’est grandement accrue ces derniers temps,
au point que n’importe qui peut aujourd’hui installer un système Linux viable sans
trop de problème.
La plupart des distributions de linux sont l’oeuvre de sociétés commerciales,
ce qui peut sembler en contradiction avec la notion de logiciel libre. Il faut souli-
gner que la licence GPL n’interdit pas la vente de logiciels libres, par contre elle
oblige de rendre publiques et librement utilisables le code source de tout logiciel
basé sur un logiciel libre. Voici les principales distributions qu’il est possible de
rencontrer :
RedHat est l’une des distributions les plus connues dans le milieu profession-
nel (au moins aux USA), même si ce n’est pas la plus standard. C’est la
première distribution dont l’entreprise a été introduite en bourse. Un grand
nombre de logiciel est disponible prêt à l’emploi pour cette version de Li-
nux.
Mandrake est une distribution française, certainement la version la plus diffusée
en France. Très agréable à utiliser, surtout sur un poste client, elle est très
bien traduite en Français et bénéficie de mises à jours très régulières. Cette
réactivité est peut-être même un défaut de cette distribution dans le cadre
d’un usage professionnel. Il est en effet difficile de suivre le rythme de mise
à jour imposé et la migration d’une version à l’autre est souvent probléma-
tique22 . Il faut signaler que la société Mandrake a été placé en redressement
judiciaire en janvier 2003.
Suse est une distribution allemande. Une des distributions les plus utilisées en
Europe (surtout en Allemagne, où Linux est très populaire). Très complète
22
Des régressions ont même été constatées lors du lancement de versions majeures, du fait de
l’introduction hâtive d’outils non stabilisés (comme le compilateur gcc 3.0 dans la Mandrake 8.0,
par exemple). Mandrake a tenu compte de ses erreurs et a mis en place des procédures de tests
plus rigoureuses pour la version 9 de sa distribution.
en terme de nombre de logiciels disponibles, elle a connu récemment des

problèmes financiers (qui semblent depuis être résolus, notamment grâce à
l’appui de certains gros acteurs du marché informatique).
Debian est complète, puissante et disponible sur un grand nombre de plates-
formes. Cette distribution est reconnue pour sa stabilité et la rigueur des
tests d’intégration (chaque modification est soigneusement réceptionnée et
testée sur l’ensemble des plates-formes supportées avant d’être intégrée).
De ce fait, ses mises à jour sont relativement rares mais chacune d’elle peut
être utilisée avec sérénité dès sa sortie. Ce rythme de mise à jour s’adapte
bien à un usage professionnel, d’autant plus que, du fait de la rigueur des
tests de non régression, le passage d’une version à une autre ne pose généra-
lement pas de difficultés. C’est une des distribution favorite des utilisateurs
avancés de Linux, par contre, son installation reste relativement complexe.
SlackWare est une des premières distributions de Linux. Elle bénéficie d’une
forte expérience mais peut paraître relativement rustique. C’est la distribu-
tion des nostalgiques du Linux de la première heure.
Lindows OS , comme son nom l’indique, se positionne en concurrence de Win-
dows pour le poste client. Il a été annoncé à grand renfort de polémiques
comme étant un système révolutionnaire, capable de faire tourner indiffé-
remment des applications Windows ou Linux. Le plus grand coup de pousse
médiatique a été apporté par Microsoft lui même23 lorsqu’il a porté plainte
contre l’éditeur pour violation de sa marque déposée "Windows" susceptible
d’induire le consommateur en erreur. Tout ce battage médiatique s’est calmé
depuis la sortie commerciale de la distribution : En fait de système révolu-
tionnaire, il s’agit d’une distribution classique24 destinée au poste de travail,
dont le “look’n feel” est très largement inspiré de celui de Windows. Elle
utilise l’émulateur Wine pour faire fonctionner les applications Windows,
ce que propose la quasi totalité des distributions Linux. Cette déception
n’empêche pas Lindows de s’améliorer progressivement et de marquer des
points sur le plan commercial. La chaîne de distribution Woolmark propose,
par exemple, des PC bas de gamme équipés de ce Lindows en lieu et place
de Windows. Une version spécifique va même être lancée pour concurrencer
l’édition Tablet PC de Windows XP.
Corel-Linux était proposée comme une alternative à Windows pour les postes
clients (pas pour les serveurs). Elle privilégiait donc la facilité d’utilisation
et d’installation. Corel a abandonné le développement des distributions Li-
nux pour se recentrer sur son coeur de métier, à savoir l’édition de logiciels.
23
Les deux éditeurs sont d’ailleurs presque voisins.
24
Et très pauvre en matière d’applications fournies, d’ailleurs...
Les distributions actuelles éprouvent encore quelques difficultés pour optimi-

ser les périphériques exotiques, et souvent seules les fonctionnalités de base sont
correctement configurées après une installation classique. Les outils de configura-
tion des distributions vous permettront sans doute de configurer votre système de
base simplement, mais pour aller au-delà, il faudra sans doute intervenir manuel-
lement.
Néanmoins, il faut reconnaître que celui qui installe Linux à partir d’une dis-
tribution récente sur un ordinateur assez vieux (c’est-à-dire un ordinateur qui ne
dispose pas des derniers périphériques et cartes graphiques à la mode), ou dont les
constituants sont de marque courante, obtient rapidement un système fonctionnel
et capable de réaliser la plupart des opérations qu’il désire. En particulier, celui
qui utilise son ordinateur dans un cadre professionnel (pour écrire des lettres, les
imprimer, naviguer sur Internet pour récupérer des informations, programmer... )
peut parfaitement se contenter de l’installation par défaut. Ce problème de confi-
guration apparaît principalement pour les particuliers, qui souvent disposent de
machines hétéroclites et absolument non standards (carte son, cartes vidéo... ).
1.3.3 Standardisation des distributions

Pour faire le poids vis à vis des autres Unix et de Red Hat, plusieurs éditeurs
de distributions Linux ont signé un accord visant à développer un OS commun
pour les serveurs.
Il s’agit des éditeurs suivants :
– Suse Linux,
– Caldera,
– Turbolinux
– Conectiva.
Si chaque distributeur proposera une distribution quelque peu différente, le
coeur de l’OS, c’est-à-dire la version du noyau Linux retenue, ainsi que les ap-
plications de base, formeront un standard commun pour l’industrie, espèrent les
quatre entreprises.
Concrètement, les prochaines distributions pour serveurs de Caldera, Turboli-
nux, Suse et Conectiva seront estampillées "United Linux". Elles posséderont un
CD commun intégrant le noyau, les librairies et les modules d’installation.
La création de ce label commun a pour but de faire tomber les deux principales
critiques formulées par les entreprises à l’encontre de Linux :
– le manque de certification pour développer des applications profession-
nelles compatibles,
– la fragmentation du code des composants de base.
But moins avouable de ce regroupement, elle permet de profiter de l’implan-
tation complémentaire des participants sur différents marchés pour concurencer
l’actuel leader des distributions Linux : RedHat.

Chapitre 2
Fonctionnalités de Linux
Dans ce chapitre, nous aborderons les différentes fonctionnalités d’un système

Linux. Nous verrons comment celles-ci sont prises en charge par le système.
2.1 Fonctionnalités du noyau

2.1.1 Présentation rapide
Le noyau LINUX a les caractéristiques techniques suivantes :
– Multi-tâches et multi-utilisateur,
– Multi-plate-forme (Intel x86 et Itanium, Alpha, MIPS, PowerPC, SPARC,
etc.)
– Espace mémoire pour applications en mode protégé 32 bits. Support de la
gestion de la mémoire virtuelle (64 bits en cours de développement),
– Architecture SMP (Symetric Multi-Processing) sur plate-forme Intel et Sun,
– Support de plusieurs systèmes de fichiers : FAT16, FAT32, NTFS, Ext2FS,
Ext3FS, ReiserFs, XFS, JFS, HPFS...
– Performance élevée en réseau : Support de la grande majorité des proto-
coles actuels (TCP/IP 4 et 6, IPX/SPX, AppleTalk... ), partage de ressources
(NFS, SMB... ),
– Gestion évoluée du stockage sur disque (Striping-RAID 0, mirroring-RAID
1 logiciel et RAID 5 logiciel, gestion de volumes logiques),
– Interface graphique : XFree86 qui est une implantation libre de l’architec-
ture standard X.
Il fonctionne sur une trés grande diversité de plate-formes matérielles, depuis
les PDA1 jusqu’aux systèmes centraux IBM, en passant par les super-calculateurs
1
IBM a même présenté plusieurs prototypes de montres fonctionnant avec Linux. Au delà de la
prouhesse technologique, on est en droit de s’interroger sur l’utilité pratique de telles réalisations,
27
28 CHAPITRE 2. FONCTIONNALITÉS DE LINUX
SGI.
Ce système est largement utilisé dans les milieux universitaires, il est donc
très souvent à la pointe de la recherche : Ainsi, Linux a été le premier système à
supporter le protocole IP v6 ou le processeur 64bits Itanium d’Intel.
Aujourd’hui, Linux occupe une place de choix dans les serveurs d’infrastruc-
ture (routeurs, serveur de nom, serveur DHCP, serveur Web, serveur FTP... ) et
commence à obtenir ses lettres de noblesse au coeur des solutions d’entreprise.
Par contre, il butte encore assez nettement dans sa conquête du poste client,
souffrant de la position dominante de Windows et sur la difficulté de changer les
habitudes des utilisateurs. En effet, autant le changement de l’OS d’un serveur
est imperceptible par les utilisateurs, autant il est très sensible dès qu’il touche le
poste de travail.
2.1.2 Découpage du système

Comme tout logiciel d’une certaine taille, Linux est d’une grande complexité.
Cette complexité implique un grand nombre d’erreurs, d’anomalies et de dys-
fonctionnement potentiels. En effet, pour qu’un système informatique fonctionne
correctement, il faut implémenter un très grand nombre de fonctionnalités et pré-
voir une action appropriée pour chaque événement possible. Un programme aussi
complexe est quasiment impossible à appréhender dans sa globalité par un déve-
loppeur. De plus, une erreur de programmation touchant une fonction donnée peut
avoir des répercussions difficilement prévisibles sur d’autres fonctions du système
(effet de bord).
Pour résoudre ce problème, il est courant de subdiviser le système en compo-
sants indépendants, dont le mauvais fonctionnement potentiel ne peut perturber
que partiellement les autres parties du système. Il va de soi que, lorsqu’un com-
posant du système rencontre une avarie, ceux qui l’utilisent risquent fort de se
retrouver dans un état d’erreur assez difficile à gérer. Cela peut souvent provoquer
leur propre perte. Par conséquent, plus un composant est utilisé, plus il doit être
fiable.
Or il est un composant à la base de tout dans Linux : le noyau (“kernel” en
anglais). C’est le coeur du système et, en fait, c’est précisément le système Linux.
Heureusement, ce composant est d’une très grande fiabilité, et il n’est pas rare de
voir un système Linux fonctionner plusieurs mois ou années sans rencontrer de
problème.
Lorsque l’on parle de Linux en temps que système d’exploitation, on désigne
en fait le noyau Linux accompagné d’outils permettant d’utiliser ce dernier. Ces
même si elle prouve la grande souplesse du système Linux.

2.1. FONCTIONNALITÉS DU NOYAU 29
outils sont en grande partie issus du projet GNU. Tous ces outils mis bouts à bouts
représentent bien plus que le noyau Linux lui même.
Pour simplifier, on peut dire qu’il y a plus de GNU que de Linux dans un
système Linux fonctionnel. C’est pour cette raison qu’il est plus correct de parler
d’un système GNU/Linux, bien qu’il soit courant de ne citer que le nom du noyau.
2.1.3 Le noyau Linux

Le noyau Unix joue le rôle d’intermédiaire entre les programmes et le matériel
du système. Il a pour buts :
– de partager équitablement et efficacement les ressources entre les différents
processus. Il gère la mémoire pour tous les programmes en cours d’exécu-
tion (processus), et s’assure qu’ils occupent tous une part équitable (ou non)
du temps processeur.
– de faciliter l’utilisation du système informatique. Pour cela, il fournit une
interface simple à utiliser aux programmes pour leur permettre de commu-
niquer avec le matériel (appels système).
Généralement, le noyau est constitué d’un seul fichier binaire comportant l’en-
semble des fonctions. Ce fichier est issu de la compilation du noyau. On parle alors
d’un noyau monolithique car toutes les fonctions du noyau se retrouvent dans un
seul fichier binaire. Tout changement du noyau nécessite alors une nouvelle com-
pilation de ce dernier et un redémarrage du système (voir figure 2.1, page 30).
Il est possible d’obtenir plus de souplesse en utilisant le mécanisme des mo-
dules. Ces derniers sont des entités indépendantes prenant en charge des services
généralement assurés par le noyau (pilotes de périphériques, généralement). On
peut les compiler séparément, les insérer et les retirer2 du noyau à n’importe quel
moment. Ce mécanisme permet d’obtenir un noyau à géométrie variable, dont ont
peu étendre ou réduire les fonctionnalités en fonction des besoins (voir figure 2.2,
page 31).
En raison de cette souplesse, l’utilisation des modules est devenu la méthode
préférée pour coder certaines fonctionnalités du noyau. Bon nombre de pilotes de
périphériques utilisés occasionnellement, tels que PCMCIA et les gestionnaires
de cartouches QIC-80/40, sont des modules chargeables.
L’utilisation de modules chargeables rend également possible la réalisation
d’un noyau générique fonctionnel et relativement efficace. Ce type de noyau est
capable de fonctionner correctement sur différents types de configurations.
2
Il semble que les prochaines versions de Linux ne permettront plus de retirer des modules du
noyau, en raison de la trop grande complexité de ce mécanisme. La suppression de cette fonction-
nalité devrait permettre de gagner en fiabilité et en facilité de maintenance.
Noyau du système
Fonction A
Fonction B
Fonction C
Fonction D
Fonction E
Fonction H
Fonction F Fonction G
Fonction I
Contour fonctionnel du noyau
F IG . 2.1 – Prise en charge de fonctions par un noyau monolythique

Module A
Fonction A
Module B
Contour fonctionnel du noyau
Fonction B Noyau du système

Fonction C
Fonction D
Fonction E
Module F Fonction H
Fonction F Fonction G
Module I
Fonction I
F IG . 2.2 – Prise en charge de fonctions par un noyau modulaire

Les noyaux fournis avec les distributions font largement appel aux modules
pour pouvoir s’adapter aux multiples configurations différentes sur lesquelles elles
sont susceptibles de pouvoir être installées. Ces noyaux peuvent donc être quali-
fiés de “passent-partout”. Ceci explique pourquoi il est préferable de recompiler
soit-même le noyau de son système pour l’adapter au mieux à sa configuration (et
supprimer du noyau tout ce qui n’a pas lieu d’y être).
2.1.4 Le couple GNU - Linux

Le noyau gère quasiment tout (mémoire, disques, systèmes de fichiers, réseau,
clavier, droits des utilisateurs, etc.), mais il n’est pas exploitable tel quel. Il est par
exemple incapable de proposer à l’utilisateur une interface lui permettant d’indi-
quer interractivement les commandes qu’il doit exécuter.
Ces opérations sont du ressort d’autres modules développés par la Free Soft-
ware Foundation. Parmi ces modules, on trouve le “shell” (ce qui signifie grosso
modo “environnement utilisateur”). Le shell est capable de lire des commandes
saisies au clavier, de les exécuter et d’afficher leurs résultats à l’écran. En général,
les programmes capables de réaliser ces opérations sont appelés des interpréteurs
de commandes. Mais le shell est bien plus que cela, car il peut être programmé,
et il peut gérer les processus (en arrêter un, en lancer un autre, etc.). En fait, les
commandes que le shell peut exécuter sont en nombre très réduit. La plupart des
commandes sont tout simplement d’autres programmes (voir figure 2.3).
Utilisé comme seule interface utilisateur, le shell permet d’exécuter directe-
ment des programmes en ligne de commande, basés sur une interface utilisateur
en mode caractères3 . Ces programmes sont souvent développés sous la licence
GNU, soit par la Free Software Foundation, soit par des bénévoles. On retrouve
ici l’ensemble des commandes Unix courantes. Ces commandes sont absolument
essentielles pour pouvoir utiliser le système, mais elles sont assez rébarbatives et
peu d’utilisateurs acceptent de s’en contenter4 .
C’est pour cela qu’une couche supplémentaire a été développée, pour intro-
duire une interface graphique plus conviviale : XWindow.
Encore une fois, cette couche logicielle est constituée de plusieurs composants
dont les plus importants sont :
– Le serveur X, capable de fournir les services graphiques aux autres appli-
cations.
– Le gestionnaire de fenêtre (“Window Manager” en anglais) est le com-
posant qui se place juste au-dessus du serveur X. Il est en charge, comme
son nom l’indique, de gérer les fenêtres des applications graphiques sous X.
3
Comme on le fait avec MS-DOS, par exemple.
4
Surtout ceux qui sont habitués aux systèmes Windows ou Macintosh...
Applications
Utilisateur
Compilateur Utilisateur
gcc
Editeur de
texte
vi, emacs
Serveur Web
apache Noyau linux Interface
graphique
Interpréteurs X11
de scrips
perl, python
Interpréteur de
commandes
shell bash...
F IG . 2.3 – Architecture d’un système GNU/Linux

C’est le gestionnaire de fenêtres qui prend en charge la gestion des déco-

rations des fenêtres de premier niveau (c’est-à-dire des fenêtres principales
des programmes). Par exemple, il s’occupe d’afficher les bords, la barre
de titre, les boutons de réduction et de restauration, etc. des fenêtres. C’est
également lui qui s’occupe du positionnement des fenêtres, et qui donc per-
met à l’utilisateur de déplacer et de réduire les fenêtres des applications
graphiques. L’utilisateur est libre d’utiliser le gestionnaire de fenêtre qu’il
désire, selon ses propres goûts et ses désirs, pouvant ainsi personnaliser son
environnement de travail5 .
– Il existe des environnements graphiques complets qui, en plus d’un gestion-
naire de fenêtre souvent extrêmement puissant, fournissent la plupart des
outils classiques que l’on est en droit d’attendre d’un système graphique
moderne. Ainsi, ces environnements comprennent des éditeurs, des outils de
configuration, des navigateurs Internet, des logiciels multimédia... En plus
de ces applications, ils fournissent un cadre standard pour les applications
graphiques qui savent communiquer avec eux. Ce cadre permet d’améliorer
l’intégration des diverses applications entre elles, et c’est la raison pour la-
quelle on appelle souvent ces environnements des gestionnaires de bureau.
KDE et Gnome sont des exemples de tels environnements de travail.
– Enfin, au-dessus de toutes ces couches logicielles, on trouve les applica-
tions X, qui sont aussi diverses que variées (traitement de texte, tableurs, lo-
giciels de dessin...). Quelques-unes de ces applications sont simplement des
habillages (“front-end” en anglais) d’applications en ligne de commande,
c’est-à-dire des interfaces graphiques à des programmes non graphiques
existants.
Ce concept permet :
– d’avoir un composant métier unique utilisé par plusieurs interfaces diffé-
rentes (réutilisation de code),
– de rendre indépendante le code métier de celui de l’interface utilisateur.
Encore une fois, la stabilité en est d’autant plus accrue.
En résumé, un système GNU/Linux est structuré de la manière suivante (voir
figure 2.6, page 37) :
– le noyau Linux,
– le shell,
– les programmes en ligne de commande, dont le serveur XWindow,
– le gestionnaire de fenêtre,
5
Contrairement à des systèmes comme Windows ou MacOs, Linux n’est pas lié à une inter-
face graphique bien définie. Il est ainsi facilement possible d’utiliser une interface ressemblant à
celle de Windows, de MacOs ou issue de votre imagination. Il est même possible, dans certaines
conditions, de changer radicalement d’interface graphique sans quitter les programmes en cours
d’exécution.
F IG . 2.4 – Exemple d’interface utilisateur graphique utilisant WindowMaker

F IG . 2.5 – Exemple d’interface utilisateur graphique utilisant KDE

– le gestionnaire de bureau,
– les applications XWindow.
Application XWindow
Gestionnaire de bureau
Utilisateur
Gestionnaire de fenêtres d’application
graphique
Programmes en ligne Serveur X
de commande
Interpréteur de commandes
Noyau Linux
Utilisateur
d’application
en ligne de
Matériel commande
F IG . 2.6 – Structure du système GNU/Linux
2.1.5 Notion de processus

Un processus est un programme en exécution. Chaque processus est une entité
indépendante disposant de son propre espace mémoire.
Tout travail réalisé par Linux est pris en charge par un processus. Le principal
rôle du noyau consiste à gérer les processus pour leur fournir les ressources né-
cessaire à leur déroulement et leur permettre d’interagir avec le monde extérieur.
Dès son lancement, le noyau lance un premier processus (init) qui est l’ancêtre
de tous les processus lancés sur le système par la suite (appels systèmes fork et
exec). Chaque processus peut lancer d’autres processus, il est alors le père de ces
derniers (et ces processus sont ses fils).
Le système maintient une table des processus en fonctionnement avec tous
les attributs caractérisent chacun d’eux. Cette table peut être représentée sous la
forme d’un arbre généalogique, puisque tout processus à un père (sauf init) et peut
avoir des fils (voir figure 2.7, page 38).
Init
Demons
lpd crond getty 1 getty 2
login login
Le processus "login" est le père du processus "shell"
shell shell
Ce processus à deux fils Les deux processus sont distincts
meme s’ils sont basés sur le meme
programme ("shell")
ls programme 1
F IG . 2.7 – Exemple d’arborescence de processus
2.1.6 Parallèle avec Windows

Il n’est pas évident d’établir un parallèle avec MS Windows du fait de la
structuration très différentes des deux systèmes. Cependant, on peut considérer
que le noyau Linux correspond aux modules KERNEL ou IO.SYS de Windows,
que le shell correspond aux interpréteurs de commandes COMMAND.COM ou
CMD.EXE, que les programmes en ligne de commande correspondent aux pro-
grammes DOS ou console classiques (xcopy, fdisk, format...), que le serveur X
correspond au couple pilote de carte graphique (GDI), que le gestionnaire de fe-
nêtre correspond au module USER, et le gestionnaire de bureau à l’explorateur,
les fonctionnalités d’OLE et aux programmes fournis avec Windows.
2.2. PRINCIPE DU SYSTÈME DE FICHIERS 39
La différence essentielle vient de la grande souplesse de Linux qui permet de

se constituer un système sur mesure en fonction de ses besoins. En effet, pour-
quoi allourdir un serveur d’une interface graphique si cette dernière n’est jamais
utilisée ? Avec Linux, il est possible de ne garder que les composants utiles à la
destination du système, ce qui explique grandement l’efficacité observée sur des
configurations modestes.
2.2 Principe du système de fichiers

Il est nécessaire de définir rapidement les termes qui vont être utilisés dans
cette section, car les systèmes de fichiers Unix sont très différents des systèmes de
fichiers du DOS et de Windows. La connaissance de ce vocabulaire est nécessaire
pour la compréhension de la structure du système de fichiers de Linux.
2.2.1 Notion de système de fichier

Toute l’information maintenue par le système est enregistrée dans des fichiers
organisés dans une structure hiérarchique de répertoires. Comme pour les proces-
sus, chaque fichier possède des attributs qui peuvent être modifiés par les utilisa-
teurs par l’intermédiaire des commandes du système.
Linux étant un système multi-utilisateurs, certains attributs des processus et
des fichiers déterminent les droits des utilisateurs à les utiliser ou à les modifier.
Ces droits sont associés à une identification de chaque utilisateur pour le système.
2.2.2 Les différents types de fichiers

Linux reprend le principe général des systèmes Unix suivant lequel “tout est
fichier” (ou presque). En effet, la quasi-totalité des composants du système est
représentée sous la forme de fichiers. Cela peu surprendre de prime abord, mais
dès que l’on a compris le principe, cela facilite énormement la programmation et
la maintenance du système.
Les différents types de fichiers sous Linux sont :
les fichiers normaux : ce sont des collections d’octets. Il n’existe pas de diffé-
rence entre les fichiers texte et les fichiers binaires.
les répertoires : ce sont des fichiers contenant les noms des fichiers et leurs nu-
méros d’inode. Un répertoire contient toujours deux sous répertoires spé-
ciaux ’.’ et ’..’ qui correspondent respectivement au répertoire courant et au
répertoire père.
les liens symboliques : permettent de présenter une image d’un fichier sous un
autre nom ou à un autre endroit sans dupliquer les données. Un lien sym-
bolique “pointe” vers un autre fichier, appelé fichier cible. La notion de lien
symbolique peut être comparée à celle de raccourcis sous Windows, à la
différence qu’ici, cette notion est prise en charge dans le système de base
alors que, sous Windows, il s’agit d’un ajout tardif qu’il est assez facile de
contourner6 .
les fichiers spéciaux en mode bloc : sont les portes sur les périphériques fonc-
tionnant par blocs de données (ex : disques). L’accès à un périphérique en
mode bloc peut se faire aléatoirement (accès à n’importe quel emplacement
du fichier).
les fichiers spéciaux en mode caractère : sont les portes vers les périphériques
fournissant ou consommant les données octet par octet. L’accès à un pé-
riphérique en mode caractère ne peut se faire que séquentiellement (accès
successif à chaque emplacement du fichier), si bien qu’il est impossible
d’accéder au bloc n avant de parcourir le bloc n-1. Ce type d’accès séquen-
tiel est assez bien illustré par le fonctionnement d’un lecteur de bande.
les tubes nommés "FIFO" 7 : permettent à deux processus sans relation de pa-
renté de s’échanger des données comme par un tube. L’écriture et la lecture
dans un tube sont nécessairement séquentielles. L’écriture rempli le tube, la
lecture le vide. On dit que la lecture des données d’un tube est destructive
(voir figure 2.8, page 40).
Essai Essai
Tube FIFO
i a s s E
Ecriture Lecture
F IG . 2.8 – Exemple de tube nommé FIFO
2.2.3 Structure du système de fichiers

Comme la plupart des systèmes de fichiers, les systèmes de fichiers Unix
sont structurés hiérarchiquement, et regroupent les fichiers dans des répertoires. Il
6
Il suffit d’éditer le contenu d’un raccourci Windows avec un éditeur de texte pour ce rendre
compte qu’il s’agit en fait d’un fichier texte interprété par le système.
7
FIFO : First In First Out (premier arrivé, premier sorti).
existe un répertoire racine, d’où débutent tous les chemins possibles dans le sys-
tème de fichiers. Chaque fichier ou répertoire a un nom qui permet aux utilisateurs
du système de l’identifier. Le seul répertoire qui n’a pas de nom est le répertoire
racine.
Les systèmes de fichiers Unix n’ont pas les mêmes limitations sur les noms
que les systèmes de fichiers FAT et FAT32 utilisés par Windows. Les noms des
fichiers et des répertoires peuvent être très longs (jusqu’à 256 caractères par nom),
et ils prennent en compte la casse des lettres8 .
Les fichiers contiennent des données au sens large, ce peut être des données
(texte, image, film, son, paramètres de programmes ou du système... ), ou des
programmes. En fait, Unix (et donc Linux) manipule généralement l’ensemble de
ses composants sous la forme de fichiers. Les répertoires sont eux-mêmes des fi-
chiers spéciaux, interprétés par le système différemment des autres fichiers. Nous
verrons plus loin (voir 3.2.10, page 53) que les périphériques du système sont,
eux aussi, représentés sous la forme de fichiers. Cette orientation “fichier” systé-
matique facilite grandement l’utilisation avancée d’un système Unix, mais peut
dérouter les habitués des systèmes Windows.
Les noms de répertoires et de fichiers sont séparés par un caractère spécial. Ce
caractère est traditionnellement, sous Unix, la barre oblique de division (nommée
“slash” en anglais) : “/”. Comme le répertoire racine n’a pas de nom, il peut être
accédé directement avec un simple “slash”.
La qualification complète d’un fichier se fait en précisant le nom du répertoire
à chaque niveau et en séparant par des slashes chacun de ces noms. Cette quali-
fication porte le nom de “chemin” d’accès (“path” en anglais). L’exemple suivant
vous montre l’allure d’un chemin d’accès typique sous Unix :
/home/remi/CNAM/linux/linux.tex
Les utilisateurs du DOS et de Windows prendront garde ici au fait que Micro-
soft a préféré la barre oblique inverse (nommée “backslash” en anglais) “backs-
lash”, rendant ainsi tous ses systèmes incompatibles avec les systèmes Unix, et
générant ainsi beaucoup de problèmes supplémentaires là où il n’était pas néces-
saire d’en avoir9 .
Les utilisateurs du DOS et de Windows constateront ici que les chemins d’ac-
cès Unix ne comportent pas de spécification de lecteurs. Les systèmes de fichiers
8
Ce qui signifie qu’il fait une différence entre les caractères majuscules et minuscules. Ainsi,
trois fichiers nommés “Fichier”, “fichier” et “FICHIER” seront distingés par le système de fichiers,
alors qu’ils seraient confondus sur un système Windows.
9
Le coût de cette ânerie, ainsi que celle des marqueurs de fin de ligne dans les fichiers textes,
doit atteindre des sommes astronomiques dans tous les projets de portage ou de développement
d’applications portables.
Unix sont dits mono-tête, ce qui signifie qu’ils n’ont qu’un seul point de départ :
le répertoire racine (voir figure 2.10, page 44). Les systèmes Microsoft sont multi-
têtes, puisqu’ils ont un point de départ par lecteur et par partition (voir figure 2.9,
page 43).
Le fait de n’avoir qu’un seul point de départ est beaucoup plus simple, et
permet, encore une fois, d’écrire les programmes plus simplement et donc avec
moins de bogues potentiels. Les habitués du DOS ne manquerons pas de se poser
la question :
“Mais alors, comment spécifie-t-on le lecteur que l’on veut utiliser ?”
Cette question a deux réponses :
– Premièrement, on n’accède pas aux lecteurs, mais aux systèmes de fichiers.
Les utilisateurs du DOS devront donc réapprendre qu’un lecteur représente
un périphérique physique, et qu’il est possible qu’il contienne plusieurs
systèmes de fichiers. Il est, par exemple, très courant qu’un disque dur de
grande capacité soit divisé en plusieurs partitions indépendantes, considérés
comme des entités distinctes (même par windows). Ils devront également se
rendre compte qu’un système de fichiers n’est pas nécessairement stocké sur
un lecteur : il peut être stocké dans un fichier10 , accessible par le réseau11 ,
ou encore généré par un composant du système12 .
– Cependant, le problème de l’accès aux systèmes de fichiers se pose malgré
tout. Pour accéder à un système de fichiers, il faut réaliser une opération que
l’on nomme le “montage”. Cette opération associe le répertoire racine de ce
système de fichiers à l’un des répertoires de l’arborescence existante. Ce ré-
pertoire est couramment appelé “point de montage”. Par exemple, il est cou-
rant de monter le lecteur de disquette dans le répertoire /mnt/floppy/.
Ainsi, si la disquette contient le fichier linux.tex, ce fichier sera acces-
sible grâce au chemin suivant :
/mnt/floppy/ventes1999.sdw
Cette solution permet d’accéder à tous les systèmes de fichiers de la même
manière, à partir d’un seul répertoire racine, que ces systèmes de fichiers
soient EXT2, FAT, ISO9660, NTFS ou Amiga...
En pratique, c’est nettement plus souple. Cela permet, par exemple, de dé-
placer la localisation physique de fichiers sans modifier leur emplacement
logique dans l’arborescence (pour stocker sur un volume réseau des infor-
mations qui étaient stockées sur un disque local, par exemple). Ce type
de modification est totalement transparente pour l’utilisateur final, qui ne
se rend généralement pas compte de l’emplacement physique des données
10
C’est le cas par exemple pour les images disques de CD-ROM.
11
C’est le cas des systèmes de fichiers réseau, “Network File System” en anglais.
12
C’est le cas des systèmes de fichiers virtuels du noyau (voir3.2.15, page 55).
qu’il manipule. Il ne connait que l’emplacement logique de ses données,

c’est à dire leur emplacement dans l’arborescence des répertoires.
Poste de travail
|_ A: (disquette)
|_ C: (disque dur 1, partition 1)
| |_ Mes Documents
| |_ Program Files
| |_ Windows
|_ D: (disque dur 1, partition 2)
| |_ Programmes Perso
| |_ Documents Perso
|_ E: (cdrom 1)
F IG . 2.9 – Répertoires et points de montage sous Windows
On prendra garde à toujours démonter les systèmes de fichiers pour les lec-
teurs amovibles. Linux utilise en effet des zones de la mémoire que l’on appelle
les tampons (“buffers” en anglais), pour y stocker des données des systèmes de
fichiers montés, et il n’écrit ces données que lorsque c’est nécessaire. Ce mé-
canisme permet d’accélérer les lectures et les écritures sur les disques, mais a
l’inconvénient de nécessiter une requête de vidange des tampons (opération que
l’on appelle “sync”) avant de retirer le lecteur ou avant d’éteindre le système.
Si on ne le fait pas, des données seront certainement perdues. Le système effec-
tue le sync lorsqu’il s’arrête (par l’une des commandes halt, shutdown ou
reboot), mais il ne le fait pas si on coupe le courant brutalement. C’est pour
cela qu’il faut toujours arrêter le système proprement. De manière similaire, Li-
nux empêche l’éjection des CD-ROM tant qu’ils sont montés. En revanche, il ne
peut rien faire pour les lecteurs de disquettes, c’est à l’utilisateur de prendre garde
à les démonter avant de retirer la disquette.
Deux derniers points auxquels les utilisateurs de DOS et Windows devront
faire attention :
– Les fichiers ne sont pas identifiés par leur extension. Un nom de fichier peut
contenir un ou plusieurs points, et une extension peut être arbitrairement
longue. En particulier, un nom de fichier peut commencer par un point.
Dans ce cas, ce fichier sera considéré comme caché par les programmes, et
on ne les verra que si on le demande explicitement,
– Les systèmes de fichiers Unix font la distinction entre les majuscules et les
minuscules. Il faut donc prendre garde à la manière dont on écrit les noms
/ (disque dur 2, partition 1)

|_ etc
|_ home (disque dur 2, partition 2)
|_ mnt
| |_ floppy (disquette)
| |_ cdrom (cdrom 1)
| |_ disque_C (disque dur 1, partition 1)
| | |_ Mes Documents
| | |_ Program Files
| | |_ Windows
| |_ disque_D (disque dur 1, partition 2)
| |_ Programmes Perso
| |_ Documents Perso
|_ opt
|_ usr
F IG . 2.10 – Répertoires et points de montage sous Linux
de fichiers et de répertoires. Cependant, la plupart des répertoires et des

fichiers ont un nom écrit complètement en minuscules.
2.3 Sécurité et utilisateurs

2.3.1 Notion de système multi-utilisateur
Linux est un système multi-utilisateur. Cela signifie que plusieurs personnes
peuvent utiliser l’ordinateur, simultanément ou les unes à la suite des autres. Le
système se charge de faire respecter les droits de chaque utilisateur. Les ressources
de la machine sont ainsi partagées équitablement, tant au niveau de la puissance
de calcul qu’au niveau de la mémoire, du disque, des imprimantes...
Évidemment, une question se pose : comment plusieurs utilisateurs peuvent-
ils se partager le clavier et l’écran ? La réponse est simple : en pratique, ils ne le
peuvent pas. Par conséquent, il n’y a que trois solutions possibles :
– Soit on connecte à l’ordinateur d’autres claviers et d’autres écrans (on ap-
pelle un couple clavier/écran un “terminal”),
– Soit on accède au système par l’intermédiaire d’un autre ordinateur via le
réseau,
– Soit les utilisateurs lancent tour à tour leurs programmes. La dernière solu-
tion nécessite que les programmes ne soient pas interactifs : ils doivent être
2.3. SÉCURITÉ ET UTILISATEURS 45
capable de fonctionner sans intervention de celui qui les a lancés.

Pour être multi-utilisateur, le système doit satisfaire certains critères :
– Il doit être multitâche, c’est-à-dire qu’il doit être capable de faire fonction-
ner plusieurs programmes simultanément sur la même machine, en parta-
geant les ressources de celle-ci,
– Il doit être fiable, Car un arrêt du système peut déranger un nombre arbi-
traire de personnes, y compris celles qui ne sont pas à proximité de l’ordi-
nateur,
– Il doit être sûr, car il ne faut pas que les erreurs ou les malveillances d’un
utilisateur ne puissent déranger les autres. Les droits d’accès de chaque uti-
lisateur doivent donc pouvoir être définis et respectés.
Le multitâche est assuré au niveau du noyau. Chaque programme en cours
d’exécution (on les appelle “processus”) fonctionne dans sa propre zone de mé-
moire, qui est complètement contrôlée par le noyau. Les ressources du processeur
sont partagées entre les processus, et il est impossible à l’un d’entre eux de mono-
poliser la mémoire, le disque ou quoi que ce soit. Les processus doivent toujours
passer par le noyau pour effectuer une opération, ce qui permet un contrôle absolu.
La fiabilité est également assurée au niveau du noyau. Les zones de mémoire
utilisées par chaque processus (encore appelées “espaces d’adressage”) sont bien
distinctes et bien identifiées par le noyau. Cela implique qu’il est impossible à
un processus de perturber le fonctionnement d’un autre processus. Ainsi, si un
processus fait une faute, il est purement et simplement terminé par le noyau. Cela
est sans appel : le noyau est le seul maître à bord.
Enfin, la sécurité est assurée par le noyau et par le système de fichiers. Le
noyau centralise tous les accès aux périphériques, il peut donc contrôler qui a le
droit d’utiliser chaque péripherique en se référant aux droits d’accès définis par
l’administrateur du système.
2.3.2 Méta-données sur les fichiers

Au niveau du système de fichiers, la sécurité est assurée par le stockage d’in-
formations additionnelles pour chaque fichier ou répertoire. Ces informations per-
mettent de connaître :
– le numéro de l’utilisateur qui possède le fichier ou le répertoire. En géné-
ral, le propriétaire est simplement celui qui l’a créé. Cependant, l’adminis-
trateur peut changer le propriétaire d’un fichier à tout moment.
– le numéro du groupe auquel appartient le fichier ou le répertoire. Tout
fichier ou répertoire appartient à un groupe unique, qui est utilisé pour cal-
culer les droits des utilisateurs faisant partie de ce groupe. Par défaut, un
fichier nouvellement créé par un utilisateur appartient au groupe de base de
l’utilisateur (attention, ce comportement varie selon les systèmes). L’utili-

sateur peut toutefois donner ses fichiers à n’importe quel groupe dont il fait
partie.
– les droits d’accès au fichier ou au répertoire pour le propriétaire, pour les
utilisateurs faisant partie du groupe auquel appartient le fichier ou le réper-
toire, et pour tous les utilisateurs en général. Ces droits comprennent le droit
de lecture (représenté par la lettre ’r’, pour “Read”), le droit d’écriture (re-
présenté par la lettre ’w’, pour “Writeable”), le droit d’exécution (représenté
par la lettre ’x’, pour “eXecutable”) et quelques attributs supplémentaires
(qui seront détaillés plus loin - voir 4.9.4, page 99).
2.3.3 Processus de connexion

Lorsqu’un utilisateur désire se connecter à un système Linux, le système lui
présente une mire de connexion lui demandant de décliner son identité. L’utilisa-
teur entre alors son nom de connexion (appelé communément “login”).
Le système recherche alors dans le fichier passwd s’il trouve une entrée cor-
respondant au login saisi par l’utilisateur. Si ce n’est pas le cas, il retourne une
erreur, sinon, il demande éventuellement13 la saisie d’un mot de passe.
Nous avons vu que, pour des raisons évidentes de sécurité, le mot de passe ne
figure pas en clair dans fichier passwd, qui ne contiennent qu’un mot de passe
crypté. Le cryptage se fait à l’aide de la fonction de cryptage à sens unique crypt.
Cette fonction permet de crypter une chaîne de caractère pour obtenir une autre
chaîne à partir de laquelle il est impossible de retrouver la chaîne initiale.
Le système crypte donc le mot de passe saisi par l’utilisateur et compare la
chaîne obtenue avec celle qui est contenue dans le fichier passwd. Si les deux
chaînes correspondent, c’est que le mot de passe est correct, sinon, la connexion
est refusée.
Lors de l’établissement de la connexion, l’utilisateur est placé dans son ré-
pertoire de base et le programme de base est lancé. La session de l’utilisateur se
terminera avec ce dernier.
13
Tous les comptes utilisateur ne sont pas forcement protégés par un mot de passe, bien que cela
ne soit pas recommandé.
Chapitre 3
Arborescence d’un système Linux
Les informations données ici peuvent ne pas être correctes pour votre distribu-
tion. En effet, certaines distributions utilisent une structure légèrement différente.
Les informations données ici sont conformes à la norme de hiérarchie de systèmes
de fichiers version 2.0 (“FHS” en anglais). Vous pouvez consulter ce document
pour une description exhaustive du système de fichiers de Linux.
3.1 Systèmes de fichier
3.1.1 Principe
Il n’existe pas de norme d’organisation du système de fichiers, mais un stan-

dard est à peu près suivi par les différentes distributions de Linux. L’organisation
traditionnelle du répertoire racine est décrite dans le tableau suivant (voir tableau
3.1, page 48).
Le répertoire de base / s’appelle : répertoire racine (root) par analogie avec la
racine d’un arbre représentant le système de fichiers. Il n’est pas standard d’ajouter
des répertoires au niveau de la racine.
Ce système de fichiers peut résider sur différentes partitions, différents sup-
ports physiques ou sur d’autres machines sur le réseau. Ce découpage est com-
plètement transparent pour les utilisateurs du système de fichiers. Les différentes
parties peuvent être connectées au démarrage du système ou à la demande, en
cours d’utilisation.
47
48 CHAPITRE 3. ARBORESCENCE D’UN SYSTÈME LINUX
Répertoire Description du contenu

/bin Fichiers exécutables nécessaires à l’initialisation
/boot Noyau et fichiers nécessaires au démarrage
/dev Fichiers spéciaux décrivant les périphériques du système
/etc Fichiers de configuration du système
/home Répertoires personnels des utilisateurs
/lib Librairies système et modules
/lost+found Fichiers retrouvés par fsck. On retrouve ce répertoire au point de mon-
tage de toutes les partitions montées avec le droit d’écriture.
/mnt Points de montage des systèmes de fichiers non permanents (CD-ROM,
disquettes... )
/proc Système de fichiers virtuel décrivant le fonctionnement du système (uti-
lisation des ressources, état des processus... )
/root Répertoire personnel de l’administrateur du système (super utilisateur)
/sbin Fichiers exécutables réservés à l’administration du système
/tmp Fichiers temporaires
/usr Programmes, librairies et fichiers accessibles en lecture seule
/var Données variables liées à la machine (spool, traces... )
TAB . 3.1 – Présentation rapide des principaux répertoires d’un système de fichier
Linux
3.2. PRÉSENTATION DES PRINCIPAUX RÉPERTOIRES 49
3.2 Présentation des principaux répertoires

3.2.1 /
Répertoire racine. Point de départ de toute la hiérarchie du système de fichiers.
Le système de fichiers contenant ce répertoire est monté automatiquement par le
noyau pendant l’amorçage du système. Ce système de fichiers est appelé système
de fichiers racine (“root” en anglais).
3.2.2 /bin/
Répertoire contenant les commandes générales nécessaires à l’utilisation cou-
rante du système. Tous les utilisateurs peuvent utiliser les commandes de ce ré-
pertoire.
Exemple de commandes de /bin/ :
– bash : l’interpréteur de commandes (shell),
– ls : permet de lister le contenu d’un répertoire,
– cd : permet de changer de répertoire courant,
– cat, more : permet d’afficher le contenu d’un fichier,
– vi : l’éditeur de texte...
3.2.3 /sbin/
Répertoire contenant les commandes nécessaires à l’administration du sys-
tème. Seuls les administrateurs ont accès à ces programmes, les autres utilisateurs
n’y ont pas accès.
Exemple de commandes de /sbin/ :
– reboot : permet de redémarrer le système,
– halt : permet d’arrêter le système,
– fdisk : permet de modifier le partitionnement des disques,
– fsck : permet de vérifier l’état des systèmes de fichiers,
– mkfs : création de systèmes de fichier...
3.2.4 /home/
Le répertoire /home/ contient les répertoires des utilisateurs disposant d’un
compte sur la machine. Chaque utilisateur possède généralement son propre réper-
toire. Le répertoire personnel de chaque utilisateur contient ses fichiers personnels
et les fichiers de configurations qui lui sont propres.
Les répertoires personnels se retrouvent généralement tous au même niveau

(exemple : /home/util1 pour celui de util1), mais il est possible de créer des struc-
tures de groupes de travail en organisant les sous-répertoires (exemple : /home/compta/util1
si util1 fait partie du service comptabilité et /home/info/util2 si util2 fait partie du
service informatique).
Il est bon de placer ce répertoire dans un système de fichiers indépendant, afin
d’éviter que sa saturation ne perturbe le fonctionnement du système complet. Il
peut être judicieux de placer ce répertoire sur un système de fichier réseau (NFS,
par exemple), ce qui permet à un utilisateur de retrouver son répertoire personnel
sur toutes les machines du réseau sur lesquels il se connecte (profil flottant).
Exemples de fichiers de configuration présents dans le répertoire personnel
d’un utilisateur :
– .bashrc : script exécuté à chaque connexion de l’utilisateur. Il permet de
définir des alias, d’exécuter des commandes ou de positionner des variables
d’environnement, par exemple,
– .bash_logout : idem pour la déconnexion,
– .bash_history : historique des commandes utilisées,
– GNUstep/, KDE/ : répertoires contenant les fichiers de configuration per-
sonnels pour les environnements graphiques WindowMaker et KDE...
3.2.5 /root/
Répertoire contenant le répertoire personnel de l’administrateur. Même s’il
serait tout à fait envisageable de placer ce répertoire sous /home/, il est recom-
mandé de le placer au plus près de la racine pour éviter qu’un problème sur le
système de fichiers des utilisateurs (utilisation de NFS et lien réseau cassé, par
exemple) ne l’empêche de travailler.
Ce répertoire est généralement uniquement accessible à l’administrateur sys-
tème.
3.2.6 /etc/
Ce répertoire contient les fichiers de configuration du système. Exemples de
fichiers situés dans /etc/ :
– /etc/passwd contient la liste des utilisateurs du système,
– /etc/group contient la liste des groupes du système,
– /etc/fstab contient la définition des montages de systèmes de fichiers,
– /etc/lilo.conf contient la définition des paramètres d’amorçage (uti-
lisé pour configuré un double boot, par exemple),
– /etc/exports description des répertoires exportés par NFS,
– /etc/hosts traduction d’adresses IP en noms d’hôte,
– /etc/resolv.conf règles de résolution des noms de domaine...

On trouve les sous-répertoires suivants :
– /etc/X11/ contient les fichiers de configuration de XWindow,
– /etc/rc.d/ contient les scripts de démarrage du système,
– /etc/init.d/ contient les scripts de démarrage des différents services
(deamons) du systèmes (apache, MySql. . .),
– /etc/cron/ contient les tâches à effectuer à la périodicité donnée (daily,
hourly, monthly, weekly),
– /etc/skel/ contient les fichiers à recopier dans le répertoire d’un nouvel
utilisateur,
– /etc/sysconfig/ contient les fichiers de configuration des périphé-
riques.
Le répertoire /etc/opt/ contient les fichiers de configuration des applica-
tions.
3.2.7 /var/
Répertoire contenant toutes les données variables du système, c’est à dire les
données pouvant être modifiées lors de l’utilisation courante du système ou de ses
applications.
– /var/opt/ contient les données variables des applications.
– /var/log/ contient les fichiers de trace de fonctionnement du système 1 .
– /var/spool/ contient les données en attente de traitement. Les travaux
d’impression en cours, les mails et les fax en attente d’émission, les travaux
programmés en attente d’exécution sont tous stockés dans ce répertoire. Le
répertoire spool contient des sous-répertoires de gestion des files d’impres-
sion (lpd), de courriers (mail), de forums (news), etc. Ces sous-répertoires
peuvent contenir, momentanément, des fichiers de taille importante.
– /var/locks/ contient les verrous sur les ressources système. Certaines
ressources ne peuvent être utilisées que par une seule application (par exemple,
un modem). Les applications qui utilisent de telles ressources le signalent
en créant un fichier de verrou dans ce répertoire.
– /var/cache/ contient les données de résultats intermédiaires des appli-
cations. Les applications qui doivent stocker des résultats intermédiaires
doivent les placer dans ce répertoire.
– /var/catman contient les fichiers d’aide mis en forme. Ce répertoire
contient les pages de manuel mises en forme pour un accès plus rapide lors
1
Une grande partie du travail d’administration consiste à suivre les enregistrements afin de
détecter les mauvais fonctionnements. Le programme logrotate permet de conserver un historique
des fichiers. Il existe des outils de gestion des fichiers de trace pour permettre, entre autres, la
détection des intrusions sur le système.
d’une deuxième utilisation.

– /var/lib contient quelques fichiers de configuration /var/lock les
fichiers de verrous des applications /var/run les fichiers contenant les
"pid" des processus du système
3.2.8 /usr/
Répertoire contenant les fichiers du système partageables en réseau et en lec-
ture seule.
Le répertoire /usr contient de nombreux sous-répertoires. On retrouve presque
la même organisation que sous la racine, mais le contenu est destiné aux utilisa-
teurs plus qu’au système lui-même.
La structure de /usr est la suivante :
– /usr/X11R6/ contient la hiérarchie des fichiers XWindow 2 . Ce réper-
toire contient des sous-répertoires bin/, lib/ et include/, où se trouvent
les exécutables de XWindow, les bibliothèques et les fichiers d’en-têtes pour
créer des programmes pour XWindow en C et C++. On retrouve, dans ce
répertoire, une hiérarchie de fichiers ressemblant à celle de la racine, mais
dédiée à l’environnement XWindow.
– /usr/bin/ contient les commandes utilisateurs supplémentaires 3 du sys-
tème,
– /usr/doc/ contient les documentations en ligne,
– /usr/etc/ contient la configuration des commandes utilisateurs,
– /usr/games/ contient les (éventuels) jeux,
– /usr/include/ contient les fichiers d’en-têtes du système pour le com-
pilateur C/C++. Les fichiers de ce répertoire sont utilisés pour réaliser des
programmes dans les langages de programmation C et C++.
– /usr/lib/ contient les bibliothèques partagées de tous les programmes
de /usr/bin/ et /usr/sbin/ et les bibliothèques statiques pour la
création de programmes.
– /usr/local/ contient les outils installés en dehors du contexte de la dis-
tribution. “local” ne signifie pas ici que les programmes qui se trouvent dans
ce répertoire ne peuvent pas être partagés sur le réseau, mais plutôt que ce
sont des extensions du système qu’on ne trouve donc que localement sur un
site donné. Ce sont donc les extensions qui ne font pas partie de la distribu-
tion de Linux utilisée, et qui doivent être conservées lors des mises à jour
ultérieures de cette distribution. Ce répertoire contient les sous-répertoires
bin, lib, include et src, qui ont la même signification que les répertoires du
2
Protocole X, version 11 révision 6.
3
C’est à dire les commandes autres que les commandes de base.
même nom de /usr/.

– /usr/man/ contient les fichiers des pages du manuel en ligne,
– /usr/sbin/ contient les commandes d’administration supplémentaires.
Ces commandes ne sont normalement utilisées que par l’administrateur sys-
tème.
– /usr/share/ contient les fichiers de configuration partagés,
– /usr/src/ contient les fichiers sources du noyau et des applications de la
distribution. Normalement, ce répertoire ne doit contenir que le code source
des applications dépendantes de la distribution que vous utilisez. Il est vi-
vement recommandé de conserver les sources du noyau de Linux 4 sur son
disque, afin de pouvoir changer la configuration du système à tout moment.
Il est recommandé que ce répertoire soit placé sur un système de fichiers en
lecture seule, et que les applications utilisent le répertoire /var/opt/ pour tra-
vailler.
3.2.9 /opt/
Répertoire contenant les applications complémentaires (add-on) n’appartenant
pas à la distribution installée.
3.2.10 /dev/
Répertoire contenant tous les fichiers spéciaux permettant d’accéder aux pé-
riphériques. Sous Linux, la plupart des périphériques sont accessibles au travers
de fichiers spéciaux, grâce auxquels l’envoi et la réception des données vers les
périphériques peuvent être réalisés de manière uniforme. Il existe un tel fichier
pour chaque périphérique.
Ce répertoire peut être géré de deux façons :
– dans un système de fichier classique. Dans ce cas, il est nécessaire de créer
un fichier spécial pour chaque périphérique installé. Cette solution présente
l’avantage de permettre un contrôle précis des droits d’accès aux périphé-
riques.
– une autre possibilité est d’utiliser un système de fichiers virtuel de type
devfs, géré directement par le noyau. Le répertoire /dev/ ne contient dans
ce cas que les fichiers spéciaux des périphériques pour lesquels le noyau
dispose d’un gestionnaire intégré ou chargé dynamiquement. Cette dernière
solution présente l’avantage de gérer correctement les périphériques bran-
ché à chaud sur le système (sur le bus USB, par exemple).
4
Elles se trouvent dans le répertoire /usr/src/linux/
Le répertoire /dev/ contient beaucoup de fichiers spéciaux pour des péri-

phériques qui ne sont pas physiquement présents dans la machine (disques IDE
ou ports série, par exemple). Dans ce cas, les opérations sur les fichiers spéciaux
des périphériques non installés seront tout simplement refusées par le noyau ou
ne produisent pas de résultat.
Exemples de fichiers du répertoire /dev/ :
– /dev/hda désigne le premier disque dur IDE du système,
– /dev/hda1, la première partition de ce disque.
– /dev/cdrom désigne le lecteur de CD-ROM.
– /dev/usb/scanner0 désigne le premier scanner USB.
– /dev/console désigne la console du système.
3.2.11 /mnt/
Répertoire réservé au montage des systèmes de fichiers non-permanents (CD-
ROM, disquettes, etc.). Ce répertoire peut contenir plusieurs sous-répertoires pour
chaque périphérique amovible, afin de permettre d’en monter plusieurs simulta-
nément.
Notez qu’il est assez courant de disposer de liens symboliques dans la racine
référençant les principaux systèmes de fichiers, afin d’en simplifier l’accès. Par
exemple, il est courant5 , bien que peu élégant, d’avoir un répertoire /floppy/
référençant le lecteur de disquette et un répertoire /cdrom/ référençant le lecteur
de CD-ROM.
3.2.12 /boot/
Ce répertoire contient le noyau6 de Linux et ses informations de symboles7 .
Ce répertoire est souvent le point de montage d’un système de fichiers de très
petite taille, dédié au noyau. Dans ce cas, il est recommandé de monter ce dernier
en lecture seule. On notera que sur certains systèmes, le noyau reste placé dans
le répertoire racine. Cette technique n’est pas recommandée, car on ne peut pas
monter en lecture seule la partition racine en utilisation normale du système.
5
Ce principe est appliqué sur la distribution Debian, par exemple.
6
Il s’agit généralement d’un fichier dénommé vmlinuz et contenant le Noyau comprimé de
Linux. Les noyaux comprimés se décompriment automatiquement lors de l’amorçage du système.
Ils ont l’avantage de pouvoir être stocké sur une disquette, une carte flash de faible capacité ou
derrière un lien réseau bas débit.
7
Dans le fichier /boot/System.map
3.2.13 /tmp/
Ce répertoire permet de stocker des données temporaires. Il dispose générale-
ment de droits d’accès particuliers permettant à chaque utilisateur d’y créer des
fichiers sans pouvoir consulter les fichiers des autres utilisateurs.
3.2.14 /lib/
Répertoire contenant les bibliothèques partagées (“DLL” en anglais, pour “Dy-
namic Link Library”) utilisées par les programmes du système.
/lib/modules contient les modules additionnels du noyau. Ces modules
sont des composants logiciels du noyau, mais ne sont pas chargés immédiatement
pendant l’amorçage. Ils peuvent en revanche être chargés et déchargés dynami-
quement, lorsque le système est en fonctionnement. Il est fortement recommandé
que ce répertoire soit placé dans le système de fichiers racine.
3.2.15 /proc/
Ce répertoire représente le point de montage du pseudo système de fichiers du
noyau. Ce dernier contient des fichiers permettant d’accéder aux informations sur
le matériel, la configuration du noyau et sur les processus en cours d’exécution.
On retrouvera, par exemple, un répertoire par processus actif. Chacun porte le
numéro du processus décrit et contient les fichiers suivants :
– cmdline contient la ligne de commande qui a créé le processus,
– status contient des informations sur l’état du processus (en attente, en
exécution, propriétaire... ),
– exe est un lien vers le fichier exécutable utilisé par le processus...
Dans le répertoire /proc/, on retrouve des fichiers contenants des informa-
tions générales sur le système. Par exemple :
– uptime contient le temps de fonctionnement du système,
– stat contient diverses statistiques sur l’utilisation des ressources du sys-
tème (CPU, mémoire... ),
– meminfo contient un récapitulatif de l’utilisation de la mémoire.
– cpuinfo contient une description des CPU du système...
[root@rapido root]# cat /proc/cpuinfo

processor : 0
vendor_id : AuthenticAMD
cpu family : 6
model : 6
model name : AMD Athlon(tm) XP 1600+
stepping : 2
cpu MHz : 1394.455
cache size : 256 KB
fdiv_bug : no
hlt_bug : no
f00f_bug : no
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 1
wp : yes
flags : fpu vme de tsc msr pae mce cx8 apic sep mtrr
pge mca cmov pat pse36 mmx fxsr sse syscall
mmxext 3dnowext 3dnow
bogomips : 2778.72
3.3 Montage de systèmes de fichier

3.3.1 Principe
Nous avons vu que la hiérarchie des fichiers de Linux était monotête, c’est à
dire qu’il partait d’un racine unique, contrairement à Windows qui présente une
racine par système de fichier (une pour chaque partition du disque dur, pour la
disquette, le CD-ROM, les lecteurs réseaux... ).
Tout fichier accessible par un système Unix est inséré dans une grande arbo-
rescence, la hiérarchie des fichiers, commençant à la racine /. Les fichiers de cette
arborescence peuvent résider sur différents périphériques et ce, de façon transpa-
rente pour l’utilisateur.
Ainsi, pour pouvoir exploiter plusieurs systèmes de fichier différents, nous
devons rattacher ces derniers à l’arborescence des fichiers du système. Cette opé-
ration s’appelle le montage de systèmes de fichiers. Elle permet de rattacher la
racine d’un système de fichier à un emplacement de l’arborescence des fichiers du
système, nommé “point de montage”.
3.3.2 La commande mount

La commande mount permet d’attacher un système de fichiers trouvé sur
un périphérique quelconque à l’arborescence des fichiers du système. A l’inverse
umount le détachera à nouveau. La syntaxe de cette commande est la suivante :
mount -t <type de système de fichier> <nom fichier> <emplacement>
3.3. MONTAGE DE SYSTÈMES DE FICHIER 57
Où :
– Type de système de fichier, décrit le format utilisé par le sys-
tème de fichier à monter. Voir la liste des principaux types (voir tableau
3.2, page 57). Si l’option “-t” n’est mentionnée, ou si le type “auto” est
précisé, la recherche de type est effectuée sur le superblock (dans l’ordre :
minix, ext, ext2, xia, iso9660 sont supportés). Si cette recherche échoue,
et si /proc/filesystems existe, alors tous les types de systèmes de
fichiers listés seront essayés successivement.
Type Signification
ext2 Système de fichier standard de Linux
ext3 Système de fichier journalisé de Linux
fat Système de fichier FAT (DOS)
vfat Système de fichier FAT32 (depuis Windows
95r2)
iso9660 Système de fichier des CD-ROM
ntfs Système de fichier de Windows NT (lecture
seule)
nfs Système de fichier réseau (Unix)
smb Système de fichier réseau (Windows)
TAB . 3.2 – Principaux types de systèmes de fichiers supportés par la commande
mount
– Nom fichier est le nom du fichier contenant le système de fichier à mon-

ter. Il s’agit généralement de fichiers du répertoire /dev/. Par exemple :
– /dev/hda1 pour la première partition du premier disque dur (le disque
A),
– /dev/hdb3 pour la troisième partition du deuxième disque dur (le disque
B),
– /dev/fd0 pour le premier lecteur de disquette,
– /dev/scd0 pour le premier lecteur de CD-ROM SCSI.
– Emplacement est le repertoire de la hiérarchie des fichiers où sera monté
le système de fichiers. Le contenu précédent du répertoire (s’il n’était pas
vide), ainsi que son propriétaire et ses modes d’accès initiaux deviennent
invisibles tant que le nouveau système de fichiers reste monté. Le chemin
d’accès du répertoire représente alors la racine du système de fichiers se
trouvant sur le périphérique.
3.3.3 Le fichier /etc/fstab

Nous avons vu comment utiliser monter des systèmes de fichiers à l’aide de
la commande mount mais il est évident qu’il serait fastidieux de recourir sys-
tématiquement à cette commande pour monter les systèmes de fichiers utilisés
couramment.
Le fichier /etc/fstab, contient des lignes décrivant les systèmes de fichiers
habituellement montés, leurs répertoires, et leurs options. Ce fichier est utilisé
dans trois buts :
– Le montage automatique des systèmes de fichiers couramment utilisés. La
commande mount -a [-t type] (généralement exécutée dans un script
de démarrage) monte tous les systèmes de fichiers indiqués dans fstab
(ou uniquement ceux du type indiqué), à l’exception de ceux dont la ligne
contient le mot-clé “noauto”.
– La simplification du montage des systèmes de fichiers. Lorsque l’on monte
un système de fichiers mentionné dans la fstab, il suffit d’indiquer le
point de montage, ou le périphérique (exemple : mount /mnt/cdrom
pour monter le CD-ROM).
– La “démocratisation du droit de montage des systèmes de fichiers”. Nor-
malement, seul le Super-Utilisateur peut monter des systèmes de fichiers.
Néanmoins, si la ligne de la fstab contient l’option user, n’importe quel
utilisateur peut monter le système de fichiers correspondant.
Ainsi, avec une ligne :
/dev/cdrom /cd iso9660 ro,user,noauto,unhide
dans le fichier /etc/fstab, n’importe quel utilisateur peut monter le
système iso9660 se trouvant sur son CDROM en utilisant la commande
mount /dev/cdrom.
3.3. MONTAGE DE SYSTÈMES DE FICHIER 59
/dev/hda5 / ext2 defaults 1 1

/dev/hda7 /home ext2 defaults 1 1
/dev/hda8 /var ext2 defaults 1 1
/dev/hdb2 /tmp ext2 defaults 1 1
none /dev/pts devpts mode=0620 0 0
none /dev/shm tmpfs defaults 0 0
/dev/scd0 /mnt/cdrom auto user,iocharset=iso8859-15,
umask=0,exec,codepage=850,
ro,noauto 0 0
/dev/fd0 /mnt/floppy auto user,iocharset=iso8859-15,
umask=0,sync,exec,codepage=850,
noauto 0 0
/dev/hda1 /mnt/windows vfat iocharset=iso8859-15,umask=0,
codepage=850 0 0
none /proc proc defaults 0 0
/dev/hda6 none swap exec,dev,suid,rw 1 1
F IG . 3.1 – Exemple de fichier fstab

Chapitre 4
Utilisation de Linux
Dans ce chapitre, nous allons aborder la manipulation courante d’un système

Linux correctement installé. Pour les auditeurs du TMRI, il s’agit de PC sur les-
quels sont installés des systèmes Mandrake Linux 8.1. Dans un premier temps, les
manipulations se feront en mode texte afin de bien comprendre le fonctionnement
du système, puis nous aborderons le mode graphique.
4.1 Trouver de l’aide

Il existe plusieurs types d’aide en ligne :
– le manuel de référence
– les "HOWTO"
– les documents du "Linux Documentation Project", alias LDP
– les fichiers de documentation des paquetages
4.1.1 Le manuel
Le manuel en ligne est accessible par la commande man. Il est organisé en
différentes sections :
La syntaxe de la commande man est :
man {options} {section} commande
Par défaut, les sections sont parcourues dans l’ordre des numéros. Il est pos-
sible de préciser le numéro de section lors de l’ouverture du manuel :
man kill
man 2 kill
61
62 CHAPITRE 4. UTILISATION DE LINUX
Section Intitulé
1 les commandes utilisateur
2 les appels système
3 les bibliothèques de programmation
4 les fichiers spéciaux
5 les formats de fichiers
6 les jeux
7 divers
8 les commandes d’administration
9 le noyau
TAB . 4.1 – Sections du manuel (commande man)
Lors de la lecture du manuel, il est possible de rechercher un motif à l’aide

de la commande /motif. Cette commande positionne le curseur sur la première
occurrence du motif. Pour se positionner sur l’occurrence suivante, on utilisera la
touche n, pour l’occurrence précédente, N. Pour quitter le manuel, on utilisera la
touche Q.
La variable d’environnement MANPATH donne le chemin de recherche des
pages de manuel :
MANPATH=/usr/man:/usr/local/man
Il existe une base de mots clés pour la recherche dans les pages de manuel.
Cette base est construite par la commande /usr/sbin/makewhatis. Les
commandes apropos et whatis permettent d’effectuer des recherches dans
cette base de données. [ATR]
4.1.2 TexInfo
C’est un projet de la FSF (Free Software Foundation) pour remplacer les pages
de manuel classiques. La base de données d’informations est répartie et accessible
par la commande info. Cette commande permet de visualiser en mode interactif
des documents hypertexte. Le système est auto renseigné, il suffit de lancer info
et de naviguer dans cet environnement pour avoir l’aide en ligne. [ATR]
4.1.3 Les HOWTO

Les HOWTO sont des documents expliquant comment effectuer une tâche
donnée comme : "Installer Linux sur le même disque que Windows NT". Ils
4.1. TROUVER DE L’AIDE 63
sont disponibles dans plusieurs formats (texte, PostScript, HTML) et sont ins-
tallés dans le répertoire /usr/doc/HOWTO. Ce sont les premiers documents à
consulter lorsqu’on recherche une information pouvant s’exprimer par Comment
faire pour ? ”.
Il existe des traductions françaises de ces documents à l’adresse suivante :
http://www.freenix.fr/linux/HOWTO/ [ATR]
4.1.4 Les documentations

A partir du répertoire /usr/doc, on trouve les documentations des paque-
tages installés. Le contenu est assez inégal et dépend du concepteur du paquetage.
C’est néanmoins une ressource importante en terme de documentation. [ATR]
4.1.5 Autres sources d’information

Les sites Web
Certains sites Web proposent de la documentation en ligne ou téléchargeable

sur le système Linux (voir tableau 4.2, page 63).
Nom URL
Linux Center http ://linux-center.org/fr/
Unix Guru Universe http ://www.ugu.com/
LDP http ://sunsite.unc.edu/mdw/linux.html/
Le guide du ROOTard http ://www.freenix.fr/linux/Guide
TAB . 4.2 – Sites Web de documentation sur Linux
D’autres sites proposent des nouvelles concernant Linux et les logiciels libres
en général. Ce sont de bonnes sources pour se tenir informé des nouvelles versions
de logiciels (voir tableau 4.3, page 63).
Nom URL
Freshmeat http ://www.freshmeat.net
Da Linux French Page http ://linuxfr.org/
TAB . 4.3 – Sites Web de nouvelles sur Linux
Les forums
Un grand nombre de forums existe traitant en totalité ou partie de Linux. Les
plus importants et les plus fréquentés sont :
– fr.comp.os.linux.configuration
– fr.comp.os.linux.annonce
– fr.comp.os.linux.moderated
– comp.os.linux.answers
– comp.os.linux.security
– comp.os.linux.setup
4.2 Les commandes

4.2.1 Principes de base
Nous allons voir les commandes utilisateur principales de Linux (il en existe
plusieurs centaines). Les commandes sont des programmes écrits avec n’importe
quel langage informatique pour résoudre un problème donné. Le système est évo-
lutif et il est facile d’ajouter de nouvelles commandes. Toutefois, avant d’écrire
une commande, il faut vérifier qu’il n’existe pas quelqu’un ayant déjà effectué ce
travail par une recherche sur le système ou sur le Web.
Une commande Linux est toujours composée de la même façon :
nom_commande {options} liste_de_paramètres
Les options sont généralement composées du signe - et d’un caractère ou d’un
mot. Elles modifient, ou précisent, le fonctionnement de la commande. La liste
des paramètres permet de spécifier la cible de la commande. Les options et les
paramètres sont séparés par des caractères blancs (espace ou tabulation).
4.2.2 Les entrées - sorties de commandes

Nous avons constaté jusqu’à présent que les commandes utilisaient l’écran
et le clavier pour communiquer avec l’utilisateur. Ce mode de fonctionnement est
tout à fait adapté à une utilisation interactive du système, dans laquelle l’utilisateur
transmet des ordres au système à l’aide du clavier et lit les réponses du système
sur l’écran.
Tous les programmes Linux sont lancés avec trois flux de données ouverts :
l’entrée standard (stdin), la sortie standard (stdout) et la sortie des erreurs (stderr).
Par défaut, l’entrée standard est le clavier et les sorties sont dirigées sur l’écran.
Il est possible de rediriger l’entrée ou la sortie vers un fichier ou vers une autre
commande. Ceci permet d’enchaîner des traitements sur un flot de données.
4.2. LES COMMANDES 65
D’une façon générale, on retrouve donc trois flux pour toutes les commandes :
– La sortie standard, sur laquelle la commande va envoyer les réponses obte-
nues. La commande ls, par exemple, va envoyer sur la sortie standard la
liste des fichiers du répertoire courant,
– La sortie erreur, sur laquelle la commande va envoyer ses messages d’erreur.
La commande ls, par exemple, va envoyer sur la sortie erreur ses messages
indiquant les erreurs rencontrées (un fichier qui n’existe pas, un problème
de droit d’accès, une erreur de syntaxe dans les options... ),
– L’entrée standard, dans laquelle la commande va lire les réponses à ses ques-
tions. Quand la commande rm, par exemple, demande de confirmer la sup-
pression de fichier, elle lit la réponses (“y” ou “n”) sur l’entrée standard.
Par défaut, les sorties standard et erreur sont redirigées sur l’écran et l’entrée
standard est prise sur le clavier (voir figure 4.1, page 65).
Sortie standard
Entrée standard Commande
Clavier
Sortie erreur
F IG . 4.1 – Les entrées-sorties de commandes
Exemple :
[remi@pc1 essai]$ rm a toto

rm: remove write-protected file ‘a’? y (sortie standard,
réponse lue sur entrée standard)
rm: cannot remove ‘toto’: Aucun fichier ou répertoire de ce type
(sortie erreur)
[remi@pc1 essai]$ ls . toto

ls: toto: Aucun fichier ou répertoire de ce type
(sortie erreur)
.: (sortie standard)
bilan1999 bilan2001 prévision2000 prévision2002
bilan2000 prévision1999 prévision2001
4.2.3 Redirection de commandes

Nous avons vu que, par défaut, les entrées de commandes proviennent du cla-
vier et les sorties (standard et erreur) sont envoyées sur l’écran, ce qui convient
généralement dans le cadre d’une utilisation interactive du système. Il est toute-
fois possible de rediriger les entrées comme les sorties vers ou depuis (voir tableau
4.4, page 68) :
– un fichier,
– une autre commande.
Redirection vers un fichier

Pour rediriger la sortie standard d’une commande vers un fichier, on ajoute
le symbole > suivi du nom du fichier vers lequel on désire rediriger le flux de
sortie. La ligne de commande ls > toto permet de créer1 un fichier nommé
toto contenant la liste des fichiers du répertoire courant.
On obtient un résultat légèrement différente en utilisant ». Ici le flux de la
sortie standard est ajouté à la fin du fichier et ne remplace plus l’ensemble du
contenu du fichier. De ce fait, si le fichier “toto” contient le texte “Ceci est mon
texte”, la commande ls >> toto ajoutera la liste des fichiers à la fin du texte
“Ceci est mon texte”, alors que ls > toto aurait écrasé le contenu du fichier
toto.
[remi@pc1 essai]$ cat toto

Ceci est mon texte
[remi@pc1 essai]$ ls >> toto
[remi@pc1 essai]$ cat toto
Ceci est mon texte
bilan1999
bilan2000
bilan2001
prévision1999
prévision2000
prévision2001
prévision2002
toto
Nous savons maintenant rediriger la sortie standard des commandes dans un

fichier. Pour rediriger la sortie des erreurs, nous utilisons 2> ou 2», de la même
façon que > ou ».
1
Si le fichier “toto” existe, il sera écrasé.
4.3. ENTRER ET SORTIR DE LINUX 67
Ainsi, ls > toto 2> erreurs2 permet d’obtenir la liste des fichiers du
répertoire courant dans le fichier “toto” et de stoker les éventuelles erreurs géné-
rées par la commandes dans le fichier “erreurs”.
Pour rediriger l’entrée standard d’une commande depuis un fichier, on utilise
< après la commande. Ainsi, rm fichier1 < fichier2 permet d’utiliser
“fichier2” pour l’entrée standard de la commande rm fichier1.
Redirection vers une autre commande

Pour rediriger la sortie standard d’une commande vers l’entrée standard d’une
autre commande, on ajoute le symbole | suivi du nom de la commande vers la-
quelle on souhaite rediriger le flux de données. Ce dernier sera reçu par l’entrée
standard de la commande réceptrice et traité de la même façon que si elle avait été
saisie au clavier.
Lorsque l’on réalise ce type de redirection, il faut noter que les processus pro-
ducteur et consommateur du flux de données sont automatiquement synchronisés
(le consommateur se met en attente si le producteur n’émmet plus de données,
le producteur fait de même si le consommateur n’est pas en mesure de traiter les
données envoyées sur son entrée standard).
Pour rediriger la sortie erreur, on utilise le symbole 2|.
4.3 Entrer et sortir de Linux

4.3.1 Connexion à un système Linux
Nous avons vu que Linux est un système multi-utilisateur, ce qui signifie que
plusieurs personnes différentes sont susceptibles d’utiliser une même machine. Il
est donc nécessaire que chacun s’identifie clairement auprès du système. Cette
opération est réalisée lors de l’opération dite de login (du verbe anglais “to log
in”, qui signifie “s’enregistrer” dans le système).
Chaque utilisateur d’un système Linux est identifié par un nom unique : son
login. Lorsqu’un utilisateur veut se connecter à un système Linux, il doit préci-
ser son login lorsque le système lui présente sa mire de connexion. Certains login
peuvent être associés à un mot de passe, dans ce cas, le système le demandera
à l’utilisateur après qu’il ait saisi son login. La mire de connexion peut être gra-
phique ou en mode texte.
Une fois que l’utilisateur a été identifié, il peut accéder au système. Pour cela,
le système vous donne accès à un “interpréteur de commandes”, positionné à un
2
Ce qui équivalent à ls 2> erreurs > toto, l’ordre des redirection n’ayant pas de signification.
Saisie Signification
commande La commande est exécutée normalement, le
symbole d’invite sera affiché lorsqu’elle se ter-
minera.
commande & La commande est exécutée en arrière-plan, ce
qui signifie qu’elle n’a en principe pas accès au
terminal.
Le shell reprend donc la main immédiatement,
et affiche son symbole d’invite alors que la com-
mande continue à s’exécuter en tâche de fond.
Bash affiche une ligne du type [1] 2496
indiquant le numéro du job à l’arrière-plan suivi
du PID c’est-à-dire de l’identifiant de proces-
sus. Lorsque la commande se termine, Bash af-
fichera une ligne :
[1]+ Done commande
juste avant de proposer un nouveau symbole
d’invite.
commande > fichier La commande est exécutée, mais sa sortie stan-
dard est dirigée vers le fichier indiqué. Seule la
sortie d’erreur s’affiche à l’écran.
commande >> fichier La sortie standard est ajoutée en fin de fichier
sans en écraser le contenu.
commande < fichier La commande est exécutée, mais ses informa-
tions d’entrée seront lues depuis le fichier qui
est indiqué plutôt que depuis le terminal.
commande1 | commande2 Les deux commandes sont exécutées simulta-
nément, l’entrée standard de la seconde étant
connectée par un tube (pipe) à la sortie standard
de la première.
TAB . 4.4 – Syntaxe de redirection de sortie standard vers une autre commande
4.3. ENTRER ET SORTIR DE LINUX 69
endroit particulier du système de fichier : le répertoire de base de l’utilisateur, en-

core appelé “home directory” (pour répertoire “maison”). Comme son nom l’in-
dique, ce répertoire peut être utilisé comme bon lui semble par son propriétaire :
il est libre d’y enregistrer ses données personnelles, d’y donner accès aux autres
utilisateurs ou, au contraire, de le protéger. Il est aussi utilisé pour y placer des
fichiers de configuration propres à l’utilisateur. Il y a généralement un répertoire
de base par utilisateur.
Généralement, le répertoire de base des utilisateur a la forme suivante :
/home/<login de l’utilisateur>
Sur tout système Linux, il existe un utilisateur bien particulier qui bénéficie
de tous les droits sur le système : l’administrateur du système, communément
appelé utilisateur “root”. Cet utilisateur se connecte comme tous les autres, mais
nécessite de respecter certaines précautions évidentes :
– l’accès à ce compte devra être soigneusement contrôlé puisqu’un utilisateur
connecté sur le compte root dispose de tous les droits sur le système,
– les manipulations réalisées sous le compte root doivent soigneusement ré-
fléchies, car elles sont faites “sans filet” et toute erreur de manipulation peut
avoir de graves conséquences sur le système.
4.3.2 Déconnexion d’un système Linux

Il est très important de se déconnecter et de ne jamais laisser une session ou-
verte sans surveillance, car une personne mal intentionnée pourrait très bien uti-
liser ce terminal à vos dépends. Il aurait tous vos droits, et effectuerait ses opéra-
tions en votre nom. La sécurité du système garantissant que vous seul pouvez vous
connecter sous ce nom, grâce au mot de passe, vous seriez donc responsable des
agissements de l’intrus. Le problème est d’autant plus sensible pour les sessions
de l’utilisateur “root”.
Pour quitter l’interpréteur de commande, vous pouvez utiliser :
– la commande logout, qui ne fonctionne qu’avec l’interpréteur de com-
mandes de connexion,
– la combinaison de touches CTRL + D,
– la commande exit.
Ces deux dernières commandes ont pour effet de sortir de l’interpréteur de
commande courant3 . Si ce dernier se trouve être le shell de connexion, alors l’uti-
lisateur est déconnecté de la machine.
3
Nous verrons par la suite comment il est possible d’ouvrir en cascade plusieurs interpréteurs
de commande.
4.3.3 Arrêt et redémarrage du système

Il faut bien comprendre que Linux, tout comme la plupart des systèmes d’ex-
ploitation modernes, ne peut pas être arrêté en éteignant directement l’ordinateur,
comme on le faisait autrefois avec le DOS. En effet, la plupart des systèmes d’ex-
ploitation utilisent une partie de la mémoire de l’ordinateur pour y stocker tempo-
rairement les données qui ont été lues à partir du disque et celles qui doivent y être
écrites. Cette zone de mémoire constitue ce qu’on appelle un tampon (“buffer” en
anglais), et elle sert à accélérer les accès aux périphériques plus lents, que sont les
disques durs et lecteurs de CD-ROM. Il va de soi qu’une requête de lecture sur des
données déjà situées en mémoire est infiniment plus rapide que si elles ne s’y trou-
vaient pas. Il est en revanche plus difficile de comprendre pourquoi les requêtes
d’écriture doivent être différées. La raison est la suivante : le système préfère dif-
férer l’écriture physique sur le disque parce qu’une autre requête d’écriture dans la
même zone du disque peut très bien avoir lieu ultérieurement. Si les données qui
n’ont pas été écrites sont ainsi modifiées par une requête ultérieure, il n’est plus
nécessaire de les écrire, et ainsi le système peut économiser un temps précieux
en ne le faisant pas. Si les données à écrire sont contiguës à celles d’une requête
précédente, le système peut les écrire en bloc, ce qui est toujours plus rapide que
de faire plusieurs écritures partielles (notamment parce que les têtes de lecture du
disque n’ont pas à être déplacées). Enfin, si les données qui doivent être écrites
font l’objet d’une requête de lecture, il va de soi qu’elles sont immédiatement ac-
cessibles. On voit que cette stratégie permet de travailler beaucoup plus vite. De
facto, Linux utilise toute la mémoire vive libre pour ses tampons d’entrées / sor-
ties, ce qui en fait un système extrêmement performant. Le gain en performances
peut facilement atteindre un facteur 3 ou 4.
Le problème majeur est évidemment que si on éteint l’ordinateur brutalement,
les données dont l’écriture a été différée sont perdues. Pire, parmi ces données, il
est probable qu’il y ait des informations vitales pour le système de fichiers, ce qui
fait qu’il risque fort d’être endommagé.
L’arrêt du système est une opération qui est du ressort de l’administrateur. On
ne peut normalement le réaliser que sous le compte root, mais il est possible de
déléguer ce droit à d’autres utilisateurs. Plusieurs commandes sont disponibles,
les plus simples sont données ci-dessous :
halt Permet d’arrêter le système,

reboot Permet de le redémarrer le système,
shutdown Permet de réaliser les opérations précédentes avec plus de souplesse
(par exemple, il est possible de différer l’arrêt du système et d’envoyer préa-
lablement un message d’avertissement aux utilisateurs.).
4.4. PARCOURS DU SYSTÈME DE FICHIER 71
Remarquez qu’un système Linux bien configuré4 peut fonctionner en continu

pendant de très longues périodes (plusieurs mois ou années) sans nécessiter d’être
arrêter ou redémarré régulièrement. Dans le cadre d’une entreprise, l’arrêt d’un
système est donc rare (normalement, uniquement pour des opérations de mainte-
nance, mais il s’agit le plus souvent d’économiser de l’électricité).
4.4 Parcours du système de fichier
Commande Syntaxe Description

cd cd repertoire_destination Change de répertoire courant. Re-
tourne au répertoire personnel si on
ne précise pas de répertoire de des-
tination. L’option ’-’ permet de re-
tourner au répertoire précédent.
pwd pwd Retourne le nom du répertoire cou-
rant.
mkdir mkdir nom_repertoire Crée un nouveau répertoire.
rmdir rmdir repertoire Supprime un répertoire vide. On
peut également utiliser la com-
mande rm.
TAB . 4.5 – Commandes de manipulation de répertoire
4.4.1 Identifier le répertoire courant

La commande pwd (pour “Present Working Directory”) permet d’afficher le
chemin complet du répertoire courant :
[remi@pc1 remi]$ pwd

/home/remi
Vous remarquerez que le nom du répertoire courant (“remi”, ici) appairait dans
l’invite de commande (aussi appelé le “prompt”). Ce comportement est paramé-
trable, il serait envisageable de faire apparaître le chemin complet dans l’invite de
commande5 .
4
Et disposant d’une alimentation électrique stable, c’est à dire équipée d’un onduleur.
5
Ce ne serait pas forcement judicieux, vu la longueur moyenne des chemins.
Lister le contenu d’un répertoire

La commande ls permet de lister le contenu du répertoire courant.
[remi@pc1 remi]$ ls
C/ GNUstep/ Lettres/ Nautilus/ remi.leblond.free.fr
CNAM/ guide.zip Mail/ nohup.out RPMS/
Desktop/ Guide.zip mbox nsmail/ sciemat/
email/ IMAGES/ memoire/ portable/ src/
emap_264.exe kvirc-2.0.0/ MIDI/ prog/ tmp/
Dans la liste retournée par ls, nous distinguons les répertoires, dont le nom
se termine par /, des autres fichiers. Nous remarquons que le nom des fichier est
sensible à la case (les fichiers guide.zip et Guide.zip sont distincts, ce qui n’aurait
pas été possible avec Windows). Il faudra donc prendre garde à l’utilisation des
majuscules lors du nommage des fichiers.
Il est possible de préciser en argument de la commande ls le nom d’un fichier
ou d’un répertoire6 :
[remi@pc1 remi]$ ls guide.zip
guide.zip
[remi@pc1 remi]$ ls email/
photo1.jpg photo3.jpg photo5.jpg photo7.jpg photo9.jpg
photo2.jpg photo4.jpg photo6.jpg photo8.jpg
Cela permet de lister uniquement un élément du répertoire (dans le cas d’un
fichier, il s’agit du fichier lui même, pour un répertoire, il s’agit des fichiers qu’il
contient).
Il est possible de préciser un motif de recherche (voir tableau 4.6, page 73)
pour faire porter la commande sur tous les fichiers que la commande ne retourne
que les noms de fichiers répondant à ce motif. Par exemple, si on désire afficher
les noms des fichiers commençants par p :
[remi@pc1 remi]$ ls e*
emap_264.exe
email:
photo1.jpg photo3.jpg photo5.jpg photo7.jpg photo9.jpg
photo2.jpg photo4.jpg photo6.jpg photo8.jpg
Exemple d’utilisation des symboles de substitution :
6
Certains interpréteurs de commandes, comme le bash, offre une fonctionnalité d’aide à la
saisie des noms de commande et de fichier. Ainsi, après avoir tapé les premières lettres d’une
commande ou d’un nom de fichier, le système vous proposera la suite si vous appuyez sur la
touche TAB.
Symbole Signification
∗ Ensemble de caractères quelconques
? Un caractère quelconque
{a, b, toto} Un caractère ou un mot valant a, b ou toto
[abc] Un caractère valant a, b ou c
[a − c] Un caractère compris entre a et c
TAB . 4.6 – Symboles de substitution
[remi@pc1 essai]$ ls
[remi@pc1 essai]$ ls bilan*
bilan1999 bilan2000 bilan2001
[remi@pc1 essai]$ ls *2001
bilan2001 prévision2001
[remi@pc1 essai]$ ls bilan{1999,2001}
bilan1999 bilan2001
[remi@pc1 essai]$ ls prévision200[12]
prévision2001 prévision2002
[remi@pc1 essai]$ ls bilan200?
bilan2000 bilan2001
[remi@pc1 essai]$ ls prévision200[0-2]
prévision2000 prévision2001 prévision2002
Il est possible d’obtenir plus de renseignement de la commande ls en l’utili-
sant avec l’option -l. Cette option permet de faire apparaître :
– les droits d’accès au fichier,
– les nombre de liens existants sur ce fichier,
– le nom du propriétaire de ce fichier,
– le groupe de propriétaire du fichier,
– la taille du fichier,
– la date de dernière modification.
[remi@pc1 remi]$ ls -l
total 2196
drwxrwxr-x 2 remi remi 4096 fév 24 23:42 aide/
...
drwx------ 2 remi remi 4096 fév 20 22:55 tmp/
Cet affichage présente beaucoup d’informations :

– Le premier caractère donne le type du fichier :

– ‘-‘ pour un fichier normal
– ‘p’ pour un FIFO
– ‘b’ pour un fichier spécial en mode bloc
– ‘c’ pour un fichier spécial en mode caractère
– ‘d’ pour un répertoire
– Les neuf caractères suivants donnent les droits d’accès
– Le champ suivant donne le nombre de liens sur le fichier
– On trouve ensuite le nom du propriétaire et du groupe du fichier
– Le champ suivant donne la taille en octets du fichier
– La date de la dernière modification est indiquée selon deux formats :
– avec l’année pour les fichiers vieux de plus de 6 mois ou de plus d’une
heure dans le futur,
– avec l’heure pour les autres cas.
– Enfin, le nom du fichier.
La commande stat permet d’afficher la "fiche signalétique" du fichier, re-
groupant les principales méta-données de ce dernier.
bash$ stat file1

File: "file1"
Size: 3562 Filetype: Regular File
Mode: (0777/-rwxrwxrwx) Uid: ( 500/ sandra) Gid: ( 500/ sandr
Device: 8,0 Inode: 2043 Links: 1
Access: Wed Nov 18 18:52:42 1997(00000.00:26:18)
Modify: Wed Nov 18 18:52:42 1997(00000.00:26:18)
Change: Wed Nov 18 18:52:59 1997(00000.00:26:01)
En plus des attributs déjà vus, cette commande affiche :

– le type du fichier en toutes lettres
– les droits d’accès en numérique (voir plus loin)
– la référence du périphérique physique (device)
– le numéro d’inode
– les dates de dernier accès, dernière modification et dernier changement.
L’option -a de la commande ls permet de faire apparaître les fichiers cachés
du répertoire. Les fichiers cachés ont simplement un nom dont la première lettre
est ’.’. Ces fichiers n’ont pas d’autre caractéristiques que de ne pas apparaître
par défaut lors de la consultation des répertoires. Il ne bénéficient pas de droits
d’accès particuliers et peuvent être manipulés comme tout autre fichier. Pour les
rendre visibles, il suffit de les renommer.
[remi@pc1 remi]$ ls -a
./ .gimp-1.2/
../ .gnome/
.AbiSuite/ .gnome-desktop/
aide/ .gnome_private/
.ArmageTronrc .gnucash/
.aumixrc .gnupg/
.bash_history GNUstep/
.bash_logout .gphoto/
.bash_profile .grip
.bash_profile~ .gtkrc
.bashrc .gtoasterrc
C/ .ICEauthority
Enfin, l’option -R (pour Récursif) de la commande ls permet de parcourir les

éventuels sous répertoires.
4.4.2 Naviguer dans les répertoires

La commande cd permet de changer de répertoire courant. Utilisée seule, elle
permet de revenir au répertoire de connexion de l’utilisateur courant. Suivi d’un
nom de répertoire, elle permet de descendre dans ce répertoire. Suivi de ’..’, elle
permet de remonter dans le répertoire précédant. Suivi de ’/’, elle permet de re-
monter à la racine du système de fichier (voir 4.7, page 75 pour les autres symboles
utilisables).
Symbole Signification
.. Répertoire précédant
. Répertoire courant
/ Racine du système de fichier
~ Répertoire de connexion de l’utilisateur courant
~util Répertoire de connexion de l’utilisateur "util"
TAB . 4.7 – Symboles de définition des chemins d’accès
Exemple d’utilisation de la commande cd :

/home/remi
[remi@pc1 remi]$ ls
C/ essai/ latex2e.ps MIDI/ prog/
CNAM/ GNUstep/ Lettres/ Nautilus/ remi.leblond.free.fr/
Desktop/ guide.zip Mail/ nohup.out RPMS/

email/ IMAGES/ mbox nsmail/ sciemat/
emap_264.exe kvirc-2.0.0/ memoire/ portable/ src/
[remi@pc1 remi]$ cd essai
[remi@pc1 essai]$ pwd
/home/remi/essai
[remi@pc1 essai]$ cd ..
/home/remi
La commande cd peut être utilisée avec des chemins de différents types :
Des chemins absolus , c’est à dire définis depuis la racine du système de fichier.
Exemple :
cd /home/remi
Des chemins relatifs au répertoire courant. C’est à dire définissant le déplace-
ment nécessaire pour atteindre le répertoire voulu depuis le répertoire cou-
rant. Exemple :
cd ../../etc permet d’atteindre le répertoire /etc depuis le répertoire
/home/remi
4.4.3 Créer un nouveau répertoire

La commande mkdir (“Make Directory”) suivie d’un nom permet de créer
un nouveau répertoire en dessous du répertoire courant.
Exemple d’utilisation de la commande mkdir :
[remi@pc1 essai]$ mkdir "Mon répertoire"
bilan2000 Mon répertoire/ prévision2000 prévision2002
[remi@pc1 essai]$ cd "Mon répertoire"
[remi@pc1 Mon répertoire]$ ls
[remi@pc1 Mon répertoire]$ pwd
/home/remi/essai/Mon répertoire
4.5. L’ÉDITEUR DE TEXTE VI 77
4.4.4 Supprimer un répertoire

La commande rmdir, ou rd (“Remove Directory”) permet de supprimer un
répertoire vide. S’ils existent, les fichiers contenus dans le répertoire à effacer
devront être supprimés au préalable.
Exemple d’utilisation de la commande rmdir :
bilan2000 Mon répertoire/ prévision2000 prévision2002
[remi@pc1 essai]$ rmdir Mon\ répertoire
[remi@pc1 essai]$ cd ..
[remi@pc1 remi]$ rmdir essai
rmdir: ‘essai’: Le répertoire n’est pas vide.
Comme nous avons vu que les répertoires étaient des fichier d’un type particu-
lier, il est également possible d’utiliser la commande rm pour les supprimer, mais
à condition d’utiliser l’option -R afin de permettre une suppression récursive des
fichiers contenus dans le répertoire (il y a toujours au moins . et ..).
4.5 L’éditeur de texte vi

L’éditeur de texte utilisé le plus souvent sous Unix est vi, c’est un éditeur de
texte pleine page qui, derrière ses apparences rustiques, est très puissant pour qui
maîtrise sont utilisation.
Il existe sous Unix un très grand nombre d’éditeurs de texte, dont certains re-
prennent une copie conforme de l’ergonomie Windows, mais aucun n’est aussi
rependu que vi. vi présente l’avantage d’être présent sur tous les systèmes Unix et
fonctionne généralement même sur un système en mauvaise forme 7 , son appren-
tissage est donc essentiel à qui veut utiliser correctement un système Unix.
Par contre, son ergonomie particulière risque fortement de perturber les ha-
bitués des éditeurs de texte sous Windows. Oubliez ici votre souris, elle ne vous
sera que d’une faible utilité. Ne cherchez pas les commandes dans un quelconque
menu ou une barre d’icône, il n’y en a pas... Après ce petit lavage de cerveau, nous
allons pouvoir nous pencher sur la question.
Utilisez la commande vi suivi éventuellement du nom du fichier à éditer pour
entrer dans l’éditeur. Vous voyez alors apparaître le contenu de votre fichier et
7
Très utile pour intervenir sur un système saturé et pour rétablir rapidement une situation saine.

cp cp sources destination Copie les fichiers source vers la
destination. Il peut y avoir plu-
sieurs sources, mais il n’y a tou-
jours qu’une seule destination. S’il
y a plusieurs sources, la destination
est nécessairement un répertoire.
mv mv sources destination Déplace les fichiers source vers la
destination.
rm rm fichier(s) Supprime un ou plusieurs fichier(s).
L’option ’-R’ permet de parcourir le
contenu des éventuels répertoires.
ln ln -s fichier nom_lien Crée un lien vers un fichier exis-
tant. L’option ’-s’, qui permet de
créer un lien symbolique au lieu
d’un lien physique, est a privilégier
car la gestion des liens physiques
peut très vite devenir complexe.
TAB . 4.8 – Commandes de manipulation de fichiers
l’interface utilisateur de vi (voir figure 4.2, page 79). En fait, l’interface utilisateur
de vi se résume à la dernière ligne, en bas de l’écran. Austère non ?
Ceci est le bilan de l’année 2000 :
L’année 2000 a vraiment été une bonne année !!!

~
~
~
"bilan2000" 3L, 85C 1,35 Tout
F IG . 4.2 – Interface utilisateur de vi
L’éditeur vi permute régulièrement entre deux modes différents (voir figure

4.4, page 81) :
– Le mode édition, qui permet la saisie de texte,
– Le mode de commande, qui permet de faire appel aux commandes de vi.
Pour passer du mode “édition” au mode “commande”, il faut presser la touche
ECHAP. Pour passer du mode “commande” au mode “édition”, il faut entrer une
commande d’édition (voir tableau 4.9, page 80). Généralement, vi se lance en
mode “édition”. Il est possible de se déplacer dans le texte à l’aide des touches de
direction, aussi bien en mode “édition”8 . qu’en mode “commande”.
O : Ajout d’une ligne avant la line courante
i : Ajout de texte avant la position courante

a : Ajout de texte après la position courante
Ceci est une ligne de texte

A : Ajout de texte en fin de ligne
Position courante
I : Ajout de texte en début de ligne
o : Ajout d’une ligne après la line courante
F IG . 4.3 – Exemple d’utilisation des commandes d’insertion de vi
Voici les commandes nécessaires pour ajouter une ligne en fin de fichier :
8
Certaines versions de vi ne permettent pas les déplacements en mode “édition”
Commande Explication
a Ajoute du texte après la position courante
A Ajoute du texte à la fin de la ligne courante
i Ajoute du texte avant la position courante
I Ajoute du texte au début de la ligne courante
o Ajoute une nouvelle ligne après la ligne courante
O Ajoute une nouvelle ligne avant la ligne courante
x Supprime le caractère courant
r Remplace le caractère courant
R Remplace les caractères suivants (mode "refrappe")
dd Efface la ligne courante
dw Efface le mot courant
d$ Efface la fin de la ligne courante
cw Change le mot courant
c$ Change la fin de la ligne courante
cˆ Change le début de la ligne courante (de la position courante
au début de la ligne)
J Joint la ligne courante et la ligne suivante
<numéro>G Atteint un numéro de ligne
G Atteint la fin du fichier
:q Quitte l’éditeur (provoque une erreur si le fichier a été mo-
difié depuis le dernier enregistrement).
:q ! Quitte l’éditeur en ignorant les modifications apportées au
fichier
:w Enregistre le fichier courant
:wq ou :x Quitte l’éditeur en enregistrant les modifications du docu-
ment
/<texte> Recherche le texte à partir de la position courante en des-
cendant dans le fichier
?<texte> Recherche le texte à partir de la position courante en remon-
tant dans le fichier
n Atteint la prochaine occurrence du texte recherché (dans le
sens défini pour la recherche)
u Annule le résultat de la dernière commande
. Recommence la dernière commande
m<car> Marque la ligne courante. La marque porte le nom du ca-
ractère suivant “m”
’<car> Retourne à une ligne marquée.
TAB . 4.9 – Commandes de l’éditeur vi

Mode "commande" Mode "édition"
Saisie d’une commande d’insertion

Exemple de commande :
a, i, cw, A, I
d’édition
Session
Saisie de texte
Touche "Echap"
F IG . 4.4 – Basculement entre les deux modes de vi
– Tapez la commande vi suivie du nom du fichiers à modifier,

– Passer en mode “commande” en frappant ECHAP (facultatif car vi se
trouve généralement déjà en mode “commande” au moment du lancement),
– Se déplacer sur la dernière ligne du fichier à l’aide des flèches de direction
ou en frappant “G” pour y accéder directement,
– Frappez “O” pour ajouter une nouvelle ligne après la ligne courante, ou “A”
suivi de la touche “ENTRÉE”,
– Saisissez la nouvelle ligne,
– Repasser en mode “commande” en frappant la touche ECHAP,
– Entrez la commande “ :wq” pour sauvegarder les modifications et quitter
l’éditeur.
Motif Signification
^ Début de la ligne
$ Fin de la ligne
. Caractère quelconque
[abc] Un caractère parmi a, b et c
[a-z] Un caractère entre "a" et "z"
* Répétition quelconque du motif précédant (de 0
à n fois)
+ Répétition du motif précédent (de 1 à n fois)
TAB . 4.10 – Motifs de recherche utilisables avec vi
Pour effectuer une recherche, il est possible d’utiliser des motifs de recherche
(voir tableau 4.10, page 81). Ainsi, pour rechercher toutes les lignes contenant les
mots “toto” et “tutu” dans cet ordre, nous utiliserons la commande :
/toto.*tutu
De même, pour rechercher toutes les lignes commençant par “toto”, nous uti-
lisons la commande suivante :
/^toto
De même, pour rechercher les lignes commençant par “toto” et finissant par
un numéro, nous utiliserons la commande suivante :
/^toto.*[0-9]$
4.6 Manipulation de fichier

cp cp sources destination Copie les fichiers source vers la
destination. Il peut y avoir plu-
sieurs sources, mais il n’y a tou-
jours qu’une seule destination. S’il
y a plusieurs sources, la destination
est nécessairement un répertoire.
mv mv sources destination Déplace les fichiers source vers la
destination.
rm rm fichier(s) Supprime un ou plusieurs fichier(s).
L’option ’-R’ permet de parcourir le
contenu des éventuels répertoires.
ln ln -s fichier nom_lien Crée un lien vers un fichier exis-
tant. L’option ’-s’, qui permet de
créer un lien symbolique au lieu
d’un lien physique, est a privilégier
car la gestion des liens physiques
peut très vite devenir complexe.
TAB . 4.11 – Commandes de manipulation de fichiers
4.6. MANIPULATION DE FICHIER 83
4.6.1 Visualiser le contenu d’un fichier

La commande cat suivi d’un nom de fichier permet d’afficher l’ensemble du
contenu d’un fichier. Si on indique le nom de plusieurs fichiers, la commande cat
concatène le contenu de ces fichiers (d’où le nom de la commande).
[remi@pc1 essai]$ cat bilan2000

Ceci est le bilan de l’année 2000 :
L’année 2000 a vraiment été une bonne année !!!
Un problème se pose lorsque l’ensemble du fichier ne peut pas s’afficher à

l’écran : seule la fin du fichier est alors visible. Dans ce cas, la commande more
permet d’afficher le contenu d’un fichier écran par écran (l’utilisateur doit appuyer
sur la touche ESPACE pour faire défiler le texte d’un écran ou ENTRÉE pour faire
défiler d’une ligne. La commande more s’utilise de la même façon que cat.
Lors de l’affichage du contenu d’un fichier à l’aide de la commande more,
l’utilisateur dispose d’outils de navigation et de recherche de texte comparables à
ceux que propose l’éditeur de texte vi (voir 4.5, page 77) :
Commande Action
/<texte> Permet de recherche le texte <texte> dans le fi-
chier affiché (/<texte>/i permet de ne pas tenir
compte de la différence entre les majuscules et
les minuscules).
’n’ et ’N’ Permettent respectivement de rechercher la pro-
chaine et la précédente occurrence du texte re-
cherché avec la commande précédente.
“<n>G” Permet d’atteindre la nême ligne du fichier. Uti-
lisé seul, G permet d’atteindre la fin du fichier.
4.6.2 Copie de fichier

La commande cp (comme “CoPy”) permet de copier des fichiers. La syntaxe
à utiliser est la suivante :
cp cible destination
La cible peut être un fichier à copier ou un ensemble de fichiers défini en
saisissant une liste de nom séparée par des espaces ou en utilisant des motifs (voir
tableau 4.6, page 73).
Si le dernier argument correspond à un nom de répertoire, cp copie dans ce
répertoire chaque fichier indiqué en conservant le même nom. Sinon, s’il n’y a
que deux fichiers indiqués, il copie le premier sur le second. Une erreur se produit
si le dernier argument n’est pas un répertoire, et si plus de deux fichiers sont
indiqués.
Voici quelques exemples d’utilisation de la commande cp :
– cp fichier1 fichier2 : Duplication de “fichier1” vers “fichier2”,
– cp fichier1 fichier2 mon_répertoire/ : Copies des fichiers
“fichier1” et “fichier2” dans le répertoire “mon_repertoire”,
– cp fichier[12] mon_répertoire/ : Idem, mais en utilisant un
motif de substitution.
Il est possible d’utiliser l’option -R pour effectuer une copie récursive de fi-
chiers (par exemple, pour recopier tous les fichiers d’un répertoire, avec les sous
répertoires qu’il contient.
L’option -i permet d’interroger l’utilisateur avant d’écraser des fichiers exis-
tants.
4.6.3 Déplacement de fichier

La commande mv (comme “MoVe”) permet de déplacer des fichiers. Elle uti-
lise la même syntaxe que la commande cp. Elle peut être utilisée pour renommer
un fichier lorsque la source et la cible se trouvent dans le même répertoire.
Exemples d’utilisation de la commande mv :
– mv fichier1 fichier2 : Renom-mage “fichier1” en “fichier2”,
– cp fichier1 fichier2 mon_répertoire/ : Déplacement des fi-
chiers “fichier1” et “fichier2” dans le répertoire “mon_repertoire”,
– cp fichier[12] mon_répertoire/ : Idem, mais en utilisant un
motif de substitution.
4.6.4 Suppression de fichier

La commande rm (comme “ReMove”) suivie du nom d’un ou plusieurs fichier
permet de supprimer des fichiers.
Il est possible d’utiliser l’option -R pour effectuer une suppression récursive
de fichiers (par exemple, pour supprimer tous les fichiers d’un répertoire, avec les
sous répertoires qu’il contient).
L’option -i permet d’interroger l’utilisateur pour confirmer chaque suppres-
sion.
4.6.5 Liens de fichiers

Il est possible de définir des liens pointant vers un fichier unique. Tous les liens
sont alors manipulés comme pourraient l’être le fichier pointé. Pour l’utilisateur, il
n’y a pas de différence entre le lien et le fichier pointé et il utilisera le lien comme
s’il s’agissait du fichier original.
On distingue deux types de liens :
– Les liens physiques,
– Les liens symboliques.
Les liens physiques
Ils correspondent à un référencement multiple d’un même fichier du disque.

Généralement, il n’y a qu’une seule référence par fichier du disque, mais Linux
permet d’en créer plusieurs. Dans ce cas, aucun des liens n’est plus important
qu’un autre, qu’il ait été créé en premier ou en dernier. Il n’y a pas de notion de
généalogie. Un lien physique ne peut être définis qu’au sein du même système
de fichier. Il est alors impossible de distinguer le fichier original d’un autre lien.
Lors de la suppression d’un fichier lié plusieurs fois, le fichier du disque n’est
réellement détruit qu’après la suppression du dernier lien y faisant référence (voir
figure 4.5, page 85).
La création d’un lien physique se fait à l’aide de la commande ln sans para-
mètres :
ln nom_du_fichier nom_du_lien
L’utilisation des liens physiques peut être périlleuse, du fait qu’il est impos-
sible de distinguer le fichier orignal (ou maître) de ses références. Elle doit donc
être évitée dans la mesure du possible. On utilisera donc de préférence des liens
symboliques.
Fichier Fichier
Disque
F IG . 4.5 – Lien physique

Les liens symboliques
Un lien symbolique correspond à un pointeur vers un autre fichier. Contraire-

ment aux liens physiques, on distingue ici clairement le fichier référencé du lien
y faisant référence (voir figure 4.6, page 86). La suppression du lien n’a aucune
conséquence sur le fichier référencé. De même, la suppression d’un fichier n’a
aucune conséquence sur les liens y faisant référence (les liens sont alors “cassés”
car ils pointent vers un fichier qui n’existe pas). Les liens symboliques peuvent
être comparés aux raccourcis de Windows, à la différence qu’il s’agit ici d’une
fonction de base du système de fichier et non d’une verrue qu’il est facile de
contourner (en éditant directement un fichier raccourci “Windows” à l’aide d’un
éditeur de texte vous remarquerez qu’il s’agit en fait d’un fichier ASCII contenant,
entre autre, le nom du fichier pointé).
La création d’un lien symbolique se fait à l’aide de la commande ln en utili-
sant l’option ’-s’ :
ln -s nom_du_fichier nom_du_lien
Fichier Lien vers "fichier"
Disque
F IG . 4.6 – Lien symbolique
4.6.6 Recherche de fichier

Il existe plusieurs commandes permettant de rechercher des fichiers dans un
système Linux. Traditionnellement, la commande find permet de retrouver un
fichier en parcourant l’arborescence des répertoires. La commande locate per-
met d’accélérer très sensiblement les recherches en exploitant une base de données
des fichiers du système.

find find "répertoire initial" Permet de rechercher, suivant de
nombreux critères, des fichiers à
partir d’un répertoire de base. L’op-
tion -name permet, par exemple, de
filtrer la recherche sur le nom des
fichiers.
locate locate motif_recherche Permet de rechercher un fichier en
se basant sur une base de donnée et
non sur un parcours de l’ensemble
du système de fichiers (beaucoup
plus rapide). La base de donnée doit
être tenue à jour à l’aide de la com-
mande updatedb.
TAB . 4.12 – Commandes de recherche de fichiers
La commande find
Il vous sera sans doute nécessaire de rechercher des fichiers selon un critère
donné dans toute une arborescence de répertoires. Pour cela, vous utiliserez la
commande find. Cette commande est très puissante, mais dispose d’une syn-
taxe assez compliquée, du fait des nombreuses possibilités qu’elle offre. Pour re-
chercher un fichier en se basant sur son nom, la syntaxe de la commande est la
suivante :
find répertoire -name nom
où répertoire est le répertoire à partir duquel la recherche doit commencer
et nom est le nom du fichier à rechercher. Ce nom peut contenir des caractères
génériques du shell (des espaces, par exemple), mais dans ce cas il doit être placé
entre guillemets afin d’éviter que ce dernier ne les interprète.
[remi@pc1 remi]$ find . -name toto

./CNAM/IA/DONNEES/toto
./essai/toto
find accepte d’autre options de recherche que le nom (partie -name de la

ligne de commande), et peut effectuer d’autres actions que l’affichage du chemin
des fichiers trouvés. Consultez les pages de manuel pour plus d’information à ce
sujet [GIC02].
La commande locate
La commande locate9 fournit une façon sécurisée d’indexer et de recher-
cher rapidement des fichiers sur votre système. Elle exploite une base de données
des fichiers du système sur laquelle elle effectue ses recherches, ce qui lui permet
d’être beaucoup plus rapide que la commande find, qui recherche dans l’arbo-
rescence des fichier même. Ainsi, pour rechercher le fichier “toto” dans l’arbores-
cence des fichiers du système, nous utiliserons la commande suivante :
locate toto
La constitution de la base de données des fichiers du système est réalisée à
l’aide de la commande slocate -c -u (-c pour lire le fichier de paramé-
trage /etc/updatedb.conf et -u pour créer un base de données). Cette com-
mande doit être lancée régulièrement pour maintenir une base de données à jour.
4.6.7 Recherche de texte dans un fichier

cat cat fichier Affiche le contenu du fichier sur la
sortie standard.
more more fichier Affiche le contenu d’un fichier ou
de l’entrée standard sur la sortie
standard en faisant une pause à
chaque écran.
grep grep motif (fichiers) Recherche un motif dans des fi-
chiers ou dans l’entrée standard. On
utilise les mêmes motifs que pour
les recherches dans vi.
TAB . 4.13 – Commandes de manipulation du contenu des fichiers
Recherche
La recherche d’une chaîne de caractères dans un ou plusieurs fichiers peut se
faire à l’aide de la commande rep. Cette commande prend en premier paramètre
le texte à rechercher, puis la liste des fichiers dans lequel ce texte doit être trouvé :
grep texte fichiers

grep "texte" fichiers
9
En fait, il s’agit de la commande slocate, version sécurisée de locate
Le texte peut être placé entre guillemets si nécessaire (en particulier, s’il contient
des espaces ou des caractères interprétés par le shell, comme * et ?. Utilisé sans
préciser de nom de fichier, grep recherche le texte sur l’entrée standard (par dé-
faut, le clavier).
[remi@pc1 essai]$ grep année *

bilan2001:Ceci est le bilan de l’année 2001 :
bilan2001:L’année 2001 a vraiment été une bonne année !!!
grep accepte un grand nombre d’options, qui ne seront pas décrites ici. Par
exemple, l’option -i permet de ne pas distinguer les majuscules des minuscules
lors de la recherche. Consulter les pages de manuel pour plus d’information à ce
sujet.
Remplacement de texte
Le remplacement de texte dans un fichier peut être effectué de manière au-

tomatique, c’est-à-dire sans avoir à ouvrir le fichier dans un éditeur, grâce à la
commande sed (abréviation de l’anglais “Stream Editor”). Cette commande est
en fait un utilitaire de manipulation de flux de données, qui permet d’effectuer des
traitements plus généraux que le simple remplacement de texte, mais c’est malgré
tout pour cette opération qu’elle reste la plus utilisée.
sed peut travailler à la volée sur un flux de données textuelles, que ce flux
provienne de l’entrée standard ou d’un fichier. Par défaut, il écrit le résultat de son
travail sur le flux de sortie standard. Les opérations qu’il doit effectuer sur le flux
de données peuvent être spécifiées de différentes manières, soit en fournissant un
fichier script à l’aide de l’option -f, soit directement sur la ligne de commande,
avec l’option -e. La syntaxe utilisée pour appeler sed est donc typiquement la
suivante :
sed -e "commandes" fichier > résultat
ou :
sed -f script fichier > résultat
où fichier est le fichier sur lequel sed doit travailler, et résultat est le
fichier devant recevoir le flux de données modifiées. Notez que cette commande
utilise une redirection du flux de sortie standard dans un fichier.
sed peut effectuer un grand nombre de commandes différentes et est réelle-
ment un outil très puissant. Cependant, nous ne verrons ici que la commande qui
permet d’effectuer un remplacement de texte. Cette commande utilise la syntaxe
suivante :
s/texte/remplacement/options
où texte est le texte à rechercher, remplacement est le texte de rempla-

cement, et options est un jeu d’options exprimant la manière dont le rempla-
cement doit être fait. Les options sont spécifiées à l’aide de simple caractères,
les plus utiles étant sans doute g, qui permet d’effectuer un remplacement global
(au lieu de ne remplacer que la première occurrence sur la ligne du texte rencon-
trée), et I, qui permet d’effectuer une recherche sans tenir compte de la casse des
caractères.
Par exemple, la ligne de commande suivante :
sed -e "s/bonjour/bonsoir/g" test.txt > modif.txt
permet de remplacer toutes les occurrences de la chaîne de caractères “bon-
jour” par la chaîne de caractères “bonsoir” dans le texte du fichier test.txt, et
d’enregistrer le résultat dans le fichier modif.txt.
Il ne faut pas utiliser le même nom de fichier pour le fichier source et le fichier
de résultat. En effet, sed lit le fichier source à la volée, et effectuer une redi-
rection sur ce fichier pendant son traitement provoquerait la perte irrémédiable
de son contenu. Pour résoudre ce problème, on pourra utiliser un nom de fichier
temporaire, et écraser le fichier original par ce fichier une fois la commande sed
exécutée [GIC02].
4.6.8 Compression et décompression des fichiers

Linux fournit un grand nombre de programmes de compression de fichiers. Le
meilleur est sans doute bzip2, et le plus compatible sans doute compress. Ce-
pendant, le plus utilisé et le plus courant, surtout pour la distribution des sources,
reste incontestablement gzip. Nous allons décrire brièvement comment compri-
mer et décomprimer des fichiers avec gzip et bzip2 dans ce paragraphe.
La compression d’un fichier se fait de manière élémentaire :
gzip fichier
où fichier est le fichier à comprimer. Après avoir effectué son travail,
gzip renomme le fichier comprimé en fichier.gz. La compression d’un fi-
chier avec bzip2 utilise exactement la même syntaxe, à ceci près qu’il faut rem-
placer gzip par bzip2. De plus, le nom du fichier comprimé porte l’extension
.bz2 au lieu de .gz. Le fichier obtenu est donc nommé fichier.bz2.
La décompression d’un fichier se fait à l’aide de la commande suivante :
gunzip fichier.gz qui est équivalent à gzip -d fichier.gz
ou
bunzip2 fichier.bz2
selon qu’il a été comprimé avec gzip ou bzip2. Après décompression, l’ex-
tension complémentaire .gz ou .bz2 est supprimée du nom de fichier [GIC02].
4.7. MANIPULATION DE PROCESSUS 91
4.7 Manipulation de processus

ps ps Permet de consulter la liste des processus en
cours. Par défaut, seuls les processus lancés de-
puis l’interpréteur de commande courant sont
listés. L’option ’-edf’ permet de retourner la
liste exhaustive des processus actifs dans le sys-
tème.
kill kill -signal pid Permet de demander l’arrêt de l’exécution d’un
processus. L’option ’-9’ est plus violente et
force l’arrêt immédiat du processus, sans pas-
ser par la procédure de sortie éventuellement
prévue dans le programme. Cette option est à
utiliser lorsque le processus ne répond pas à la
première "sommation".
jobs jobs Permet de consulter la liste des travaux lancés
en arrière plan depuis l’interpréteur de com-
mande courant.
top top Application permettant de surveiller en temps
réel l’activité du système (processus actifs, uti-
lisation mémoire et processeur... ).
TAB . 4.14 – Commandes de gestion des processus
4.7.1 Qu’est-ce qu’un processus

Un processus est un programme qui s’exécute. Chaque processus est indépen-
dant des autres dans la mesure où il dispose d’une zone mémoire qui lui est propre
et qui reste inaccessible aux autres. L’ensemble des processus actifs du sytème se
dispute l’accès aux ressources disponibles (au moins la CPU).
Chaque processus est nécessairement créé par un autre processus (son proces-
sus père), à l’exception du processus “init”, lancé au démarrage du systéme et, de
ce fait, ancêtre de tous les autres.
4.7.2 Lancer une commande en tâche de fond

Par défaut, lorsqu’un processus crée un processus fils, il se met en attente de la
fin de ce dernier. Par exemple, lorsqu’on lance la compression d’un gros fichier à
l’aide de la commande gzip mon_gros_fichier, il est impossible d’utiliser

l’interpréteur de commande avant la fin de la compression.
Pour récupérer la main avant la fin du processus fils, il est possible de lancer
ce dernier en arrière plan. Il suffit pour celà de finir la ligne de commande par le
caractère “&”.
Le système affiche alors le numéro du processus fils et redonne la main à
l’utilisateur. Lorsque le processus fils se termine, le processus père est averti par
un message.
Exemple :
[remi@rapido remi]$ gzip mon_gros_fichier &

[1] 3515
[remi@rapido remi]$ ls
...
[remi@rapido remi]$
[1]+ Done gzip mon_gros_fichier
Il est possible de passer un traitement à l’arrière plan ou, au contraire, à l’avant

plan, au cours de son exécution à l’aide des commandes bg (pour background :
arrière-plan) et fg (pour foreground : premier plan). Pour utiliser ces commandes,
vous devez avoir la main sur le shell. Si vous ne l’avez pas, vous devez inter-
ompre le processus fils qui s’exécute en premier plan à l’aide de la combinaison
de touches CTRL + Z, qui a pour effet de mettre le processus courant en veille.
La commande jobs
La commande jobs permet d’afficher la liste des travaux pris en charge par
l’interpréteur de commande sur lequel elle est lancée.
Exemple :
[remi@rapido remi]$ gzip mon_gros_fichier

(appui sur CTRL + Z)
[1]+ Stopped gzip mon_gros_fichier
[remi@rapido remi]$ bg
[1]+ gzip mon_gros_fichier &
[remi@rapido remi]$ jobs
[1]+ Running gzip mon_gros_fichier &
Il est alors possible de repasser un travail donné au premier plan en tapant fg

suivi du numéro de travail (fg 1 pour repasser le premier travail, par exemple).
Autre exemple d’utilisation de la commande jobs :
4.7. MANIPULATION DE PROCESSUS 93
[remi@rapido remi]$ jobs

[1] Running emacs CNAM/linux/utilisation.tex &
[2]- Running xdvi &
[3]+ Running gv &
[4]+ Stopped vi
Où ou peut lire les informations suivantes :

– [1] représente le numéro de job,
– Running représente l’état du job (Running ou Stopped),
– Le nom de la commande correspondant au job.
Ou peut intervenir sur les jobs à l’aide des commandes suivantes :
– fg [numéro de jobs] permet de faire passer un jobs au premier plan.
– bg [numéro de job] permet de faire passer un job en tâche de fonds.
Comme nous venons de le voir, la notion de “job” est propre à chaque inter-
préteur de commande. Ainsi, il pourra y avoir un job 1 dans chacun d’entre eux.
La commande ps
La commande top
4.7.3 Interaction avec les processus

Principes des signaux
Numéro de signal Signification

15 Terminaison “douce 10 ” de processus
9 Destruction “violente 11 ” de processus
19 Suspension de processus
18 Reprise d’exécution de processus suspendu
TAB . 4.15 – Principaux signaux de contrôle de processus
Envoi de signal à un processus

La commande kill permet d’envoyer un signal à un processus du système.
La syntaxe de cette commande est la suivante :
kill -<numéro de signal> <numéro du ou des processus
Ainsi, la commande kill -9 1245 permet de stopper “violemment” le
processus 1245.
4.7.4 Planifier l’exécution automatique de processus

Il existe plusieurs façons de programmer l’exécution automatique de proces-
sus. Une des plus connues est utilise la commande crontab, qui permet de pla-
nifier le lancement d’une commande.
La commande crontab est propre à chaque utilisateur. Elle utilise un fichier
de paramétrage, couramment appelé “crontab”, dont chaque ligne désigne une
commande programmée. Chaque ligne est composée de six champs, séparés par
des espaces :
– Les minutes (de 0 à 6012 ),
– Les heures (de 0 à 2413 ),
– Le jour du mois (de 0 à 31),
– Le mois (de 0 à 12),
– Le jour de la semaine (de 0 à 7, 0 et 7 désignant le dimanche).
– La commande à lancer.
Pour les cinq premiers champs, il est possible d’utiliser14 :
– Des plages de valeurs : 1-4,
– Des énumérations de valeurs : 1,2,3,4,
– Toutes les valeurs possibles : *,
– Tous les multiples d’une valeur : */2 pour désigner les valeurs paires.
La commande passée dans le sixième champ peut éventuellement contenir des
valeurs à passer sur l’entrée standard (pour répondre à des questions, par exemple)
en utilisant le caractère ’%’.
Exemple : rm -i fichier%y% permet de répondre ’y’ à la demande de
confirmation de destruction de fichier.
4.8 L’environnement utilisateur

4.8.1 Les variables d’environnement
4.8.2 Les alias

Principe
Les alias permettent à chaque utilisateur de définir ses propres commandes
12
0 et 60 étant confondus.
13
0 et 24 étant confondus.
14
Les deux pouvant être combinés (exemple : 1,4,6-10,12).
4.8. L’ENVIRONNEMENT UTILISATEUR 95
Définition d’un alias

[remi@pc1 essai]$ alias toto="ls -l"
[remi@pc1 essai]$ toto
total 4
-rw-rw-r-- 1 remi remi 0 fév 22 18:27 bilan1999
-rw-rw-r-- 1 remi remi 0 fév 22 18:27 prévision1999
Liste des alias existants

Utilisée seule, la commande alias permet de lister les alias définis pour
l’utilisateur courant.
[remi@pc1 essai]$ alias

alias cd..=’cd ..’
alias cp=’cp -i’
alias d=’ls’
alias df=’df -h -x supermount’
alias du=’du -h’
alias l=’ls’
alias la=’ls -a’
alias ll=’ls -l -k’
alias ls=’ls -F --color=auto’
alias lsd=’ls -d */’
alias md=’mkdir’
alias mv=’mv -i’
alias p=’cd -’
alias rd=’rmdir’
alias rm=’rm -i’
alias s=’cd ..’
alias toto=’ls -l’
Suppression d’un alias

La commande unalias permet de supprimer un alias.
[remi@pc1 essai]$ unalias toto

[remi@pc1 essai]$ toto

bash: toto: command not found
4.8.3 Portée de l’environnement
4.8.4 Les fichiers de définition de l’environnement
Lorsque l’on utilise le shell bash, ce qui correspond à la plupart des cas,
l’environnement utilisateur est défini dans les deux fichiers suivants :
.bash_profile est un script interprété lors de la connexion de l’utilisateur. Il est

chargé de mettre en place l’environnement de l’utilisateur (voir figure 4.7,
page 96). Par convention, ce fichier se contente de définir les variables d’en-
vironnement, les définitions d’alias et de fonctions sont définies dans le fi-
chier .bashrc,
# .bash_profile
# Get the aliases and functions

if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi
# User specific environment and startup programs
PATH=$PATH:$HOME/bin
CVSROOT=/home/sources
export PATH
unset USERNAME
F IG . 4.7 – Exemple de fichier .bash_profile
.bashrc contient la définition des alias et fonctions propres à l’utilisateur. Ce fi-

chier fait souvent appel à un fichier global au système (voir figure 4.8, page
97, qui fait appel au fichier /etc/bashrc).
4.9. DÉFINITION DES DROITS D’ACCÈS 97
# .bashrc
# User specific aliases and functions
# Source global definitions

if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
F IG . 4.8 – Exemple de fichier .bashrc
4.9 Définition des droits d’accès

4.9.1 Identification des utilisateurs
Au niveau du noyau, chaque utilisateur est identifié de manière unique par un
numéro dans le système : son uid (User IDentifier). Ce numéro est utilisé pour
vérifier les droits de l’utilisateur, ou, autrement dit, ce qu’il peut faire. Les droits
des utilisateurs comprennent la possibilité de lire ou écrire un fichier, d’accéder
ou non à une ressource ou d’exécuter un programme.
Il est possible de définir plusieurs utilisateurs ayant le même uid. Ceux-ci au-
ront les mêmes droits d’accès, mais pourront bénéficier de mots de passe, de ré-
pertoires de départ ou d’interpréteur de commandes différents.
Il est également possible de créer un ou plusieurs “groupes” d’utilisateurs,
et de leur donner des droits particuliers. Chaque groupe est aussi identifié par
un numéro : gid (Group IDentifier). Tous les utilisateurs qui font partie de ce
groupe recevront les droits du groupe. Ainsi, des classes d’utilisateurs peuvent
être facilement définies, et ces classes peuvent se voir attribuer un peu plus de
privilèges que les utilisateurs normaux selon les nécessités. Il existe toutefois un
utilisateur spécial, qui a tous les droits : l’administrateur du système (“root” en
anglais). Aucune restriction ne s’applique à cet utilisateur, car il doit être capable
de gérer le système, l’installer, l’arrêter, le mettre à jour si nécessaire, et de définir
les utilisateurs et leurs droits.
Il existe plusieurs façon de gérer les utilisateurs et les groupes :
Les fichiers locaux situés dans le système de fichier et utilisés par les outil de
connexion et de vérification de droits d’accès.
Un serveur d’authentification a qui le système s’adresse pour identifier de fa-
çon centralisée les utilisateurs, groupes et leurs droits.
L’identification par fichier locaux se base principalement sur deux fichiers :
– Le fichier /etc/passwd qui contient la liste des utilisateurs du système,
– Le fichier /etc/group qui contient la liste des groupes d’utilisateur du

système.
Le rôle du serveur d’autentification est donc de fournir à ses clients les infor-
mations équivalentes à celles qui auraient été stockées dans les fichiers locaux de
chacun d’eux.
4.9.2 Le fichier /etc/passwd : Fichier des utilisateurs du

système
Par exemple, un utilisateur est représenté par une ligne du type :
remi:*:500:500:Rémi LEBLOND:/home/remi:/bin/bash
Cette ligne comporte les champs suivants séparés par le caractère ‘ :’ :

– nom de l’utilisateur pour l’identification sur le système (login),
– mot de passe crypté,
– numéro d’utilisateur (uid),
– numéro de groupe d’utilisateur par défaut (gid). Tout utilisateur est affecté
à un et un seul groupe de base. Il peut, par ailleurs, faire partie d’un grand
nombre d’autres groupes.
– nom complet ; ce champ peut contenir de nombreuses informations, il cor-
respond à un champ de remarque,
– répertoire de base de l’utilisateur,
– programme à lancer au démarrage (programme de base), généralement un
interpréteur de commande (shell). La durée de vie de ce processus corres-
pond à celle de la session utilisateur, c’est à dire que la session de l’utilisa-
teur se terminera avec le processus. Il est possible de préciser ici tout type de
programme, ce qui permet de limiter le champ d’action d’un utilisateur (en
le connectant directement au programme qu’il doit utiliser, par exemple).
4.9.3 Le fichier /etc/group : Fichier des groupes d’utilisa-

teurs
/etc/group est un fichier ASCII qui définit les groupes auxquels appartient
chaque utilisateur. Il y a une ligne par groupe, et chaque ligne a le format :
nom_du_groupe:mot_de_passe:GID:liste_utilisateurs
Par exemple :
actrices:*:400:sandra,meg,michelle
Une ligne de ce fichier comporte les champs suivants, séparés par des carac-
tères ‘ :’ :
– Le nom du groupe,
– Le mot de passe encrypté du groupe. Si ce champ est vide (presque tou-
jours), aucun mot de passe n’est nécessaire.
– numéro du groupe (gid),
– liste des utilisateurs appartenant au groupe séparés par des virgules.
Lors de la connexion, un utilisateur est associé à tous les groupes dans lesquels
il est inscrit. Il peut le vérifier à l’aide de la commande id, ou groups.
[remi@pc1 remi]$ id
uid=501(remi) gid=501(remi) groupes=501(remi),100(users),
101(cvs),200(compta)
[remi@pc1 remi]$ groups
remi users cvs compta
Nous voyons ici que le groupe principal de l’utilisateur “remi” est le groupe
“remi” et qu’il fait également partie des groupes “users”, “cvs” et “compta”.
4.9.4 Droits élémentaires sur les fichiers

Les droits d’accès peuvent être décomposés en droits élémentaires définissant
les droits d’accès aux fichiers. Ces droits élémentaires sont décrits plus loin (voir
tableau 4.16, page 100 et voir tableau 4.17, page 100).
Le droit de lecture correspond à la possibilité d’ouvrir et de consulter un fi-
chier, ou de lister le contenu d’un répertoire. Le droit d’écriture correspond à la
possibilité de modifier un fichier, ou de créer ou supprimer un fichier d’un réper-
toire. Enfin, le droit d’exécution correspond à la possibilité d’exécuter un fichier
contenant un programme, ou d’entrer dans un répertoire. On notera par exemple
qu’il est possible d’obtenir la liste des fichiers d’un répertoire sans pouvoir s’y
déplacer, ou encore de modifier un fichier sans pouvoir le lire. On prendra garde
également que le fait d’avoir le droit d’écriture sur un fichier ne donne pas le
droit de le supprimer (cependant, on peut le vider !). Pour cela, il faut avoir le
droit d’écriture sur le répertoire contenant ce fichier. Comme on le voit, les droits
d’accès aux fichiers et aux répertoires sont très souples.
Ces droits sont attribués séparément pour le propriétaire, le groupe et les autres
utilisateurs (c’est-à-dire les utilisateurs qui ne font pas partie du groupe auquel
appartient le fichier). Il est donc possible de donner par exemple tous les droits
au propriétaire d’un fichier, et seulement le droit de lecture aux autres utilisateurs.
Cette configuration est celle qui est choisie par défaut lors de la création d’un
fichier, elle assure que seul le propriétaire peut modifier ou exécuter ce fichier,
tout en laissant la possibilité aux autres de le lire. Ce choix privilégie la sécurité

des données de chacun en laissant le maximum de liberté aux autres. Si plusieurs
personnes doivent travailler sur les mêmes fichiers, il suffit de les regrouper dans
un groupe, de donner les fichiers sur lesquels ils doivent travailler à ce groupe, et
de donner les droits d’écriture aux membres de ce groupe sur ces fichiers.
Abrév. Nom Signification

r Droit de lecture Droit de consulter le contenu d’un
(“r” pour Read) fichier
w Droit d’écriture Droit de modifier le contenu d’un fi-
(“w” pour Write) chier
x Droit d’exécution Droit d’exécuter un fichier conte-
(“x” pour eXecu- nant un programme
table)
TAB . 4.16 – Droit d’accès élémentaires aux fichiers
Abrév. Nom Signification

r Droit de listage Droit de consulter la liste des fi-
chiers d’un répertoire
w Droit de modifi- Droit de modifier la liste des fi-
cation chiers d’un répertoire.
Cela signifie donc ajouter de nou-
veaux fichiers ou en supprimer
d’anciens.
x Droit d’accès Droit d’accéder au contenu du ré-
pertoire.
TAB . 4.17 – Droit d’accès élémentaires aux répertoires
La sécurité du système est transitive, cela signifie que tout programme lancé
par un utilisateur s’exécute en son nom et reçoit donc les droits de cet utilisateur.
Le processus correspondant se voit donc attribuer les mêmes restrictions que l’uti-
lisateur qui l’a lancé. Il dispose également des droits du groupe auquel le fichier
du programme appartient. Il existe toutefois quelques exceptions à cette règle,
pour les programmes dont le comportement est bien connu et qu’il est impossible
de détourner de leur fonction initiale. C’est notamment le cas de quelques com-
mandes systèmes (comme passwd, qui permet de changer de mot de passe), qui
peuvent être lancées par les utilisateurs et qui s’exécutent toutefois au nom du
système (dans le compte root). Il est donc impossible à un utilisateur de violer les
règles de sécurité du système. Pour parvenir à ce comportement, il faut utiliser des
attributs spéciaux sur les fichiers de ces programmes.
Le premier attribut spécial est le bit “setuid” (qui est l’abréviation de l’anglais
“SET User IDentifier”. Il ne peut être placé qu’au niveau des droits du propriétaire
sur le fichier. Il permet d’indiquer que le fichier est exécutable, et que lorsque le
programme qu’il contient est lancé par un utilisateur, le processus correspondant
s’exécute avec les droits du propriétaire du fichier et non pas avec ceux de l’utili-
sateur qui l’a lancé. Cependant, le système conserve tout de même le numéro de
l’utilisateur réel qui a lancé le processus, ce qui fait que le programme peut savoir
par qui il a été lancé et au nom de qui il s’exécute. Un processus dispose donc
toujours de deux numéros d’utilisateur :
– le numéro de l’utilisateur réel (“real user id” en anglais), qui est le numéro
de l’utilisateur qui a lancé le programme,
– le numéro de l’utilisateur effectif (“effective user id” en anglais), qui est le
numéro de l’utilisateur avec les droits duquel le processus fonctionne.
Le bit setuid permet donc simplement d’affecter le numéro du propriétaire du
fichier au numéro d’utilisateur effectif du processus lorsqu’il est lancé. Le fait
de conserver le numéro de l’utilisateur réel permet au programme de réaliser des
vérifications de sécurité additionnelles. Par exemple, la commande passwd, qui
permet de changer le mot de passe d’un utilisateur, a besoin des droits de l’utili-
sateur root pour enregistrer le nouveau mot de passe. Il dispose donc du bit setuid
pour que tous les utilisateurs puissent l’utiliser. Cependant, même s’il s’exécute
au nom de l’utilisateur root, il ne doit pas permettre à n’importe qui de changer le
mot de passe des autres utilisateurs : seul l’utilisateur root a le droit de faire cette
opération. Il utilise donc le numéro de l’utilisateur réel qui a lancé la commande
pour savoir si c’est bien l’utilisateur root qui l’a lancé.
Le bit setuid est l’attribut le plus couramment utilisé, essentiellement pour
certaines commandes systèmes. Il est représenté par la lettre ’s’ (comme “Setuid”),
et il remplace le droit d’exécution (’x’) des fichiers pour le propriétaire des fichiers
(rappelons que le bit setuid implique que le fichier est exécutable). Il n’a aucune
signification pour les répertoires.
Le deuxième attribut spécial est le bit “setgid” (qui est l’abréviation de l’an-
glais “SET Group IDentifier”). Ce bit fonctionne un peu de la même manière que
le bit setuid, à ceci près qu’il fixe le numéro de groupe effectif du processus lancé
à celui de son fichier exécutable. Cet attribut est également représenté par la lettre
’s’, et remplace le droit d’exécution (’x’) pour les utilisateurs du groupe auquel
appartient le fichier exécutable. Contrairement au bit setuid cependant, il a une
signification pour les répertoires. Un répertoire disposant du bit setgid permet de
faire en sorte que tous les fichiers qui sont créés dans ce répertoire se voient au-
tomatiquement attribués le même groupe que le répertoire. Ce bit est relativement
peu utilisé.
Enfin, le troisième et dernier attribut spécial est le bit “sticky”. Cet attribut
remplace l’attribut exécutable pour les autres utilisateurs que le propriétaire du
fichier ou du répertoire et les membres du groupe auquel il appartient. Contraire-
ment aux bits setuid et setgid, il est représenté par la lettre ’t’ (pour “sTickky”). Sa
signification est assez spéciale : elle permet de faire en sorte que les programmes
restent chargés en mémoire après leur terminaison, ce qui permet de les relancer
plus rapidement. Afin de ne pas consommer la mémoire de manière permanente,
le code du programme est placé automatiquement dans le swap s’il n’est toujours
pas relancé après un certain temps, mais même dans ce cas, tous les calculs de
chargement sont déjà effectués. Le lancement des programmes marqués de ce bit
sera donc toujours accéléré. Sachez cependant ne pas abuser du bit sticky car la
mémoire (même virtuelle) est encore une ressource rare.
Pour les répertoires, sa signification est totalement différente : elle permet de
restreindre les droits des utilisateurs sur les répertoires ayant ce bit positionné.
Ce bit fait en sorte que même si un utilisateur dispose des droits d’écriture sur
le répertoire, il ne peut pas supprimer tous les fichiers de ce répertoire. Les seuls
fichiers qu’il est autorisé à supprimer sont ses propres fichiers. Bien entendu, il
est toujours possible d’ajouter des fichiers dans le répertoire en question.
En résumé, on a donc deux symboles supplémentaires, ‘s’ et ‘t’, pouvant
prendre la place du ‘x’ dans la liste des droits. Ces symboles signifient :
‘s’ : dans le cas d’un fichier exécutable, celui-ci sera exécuté avec les droits du
propriétaire ou du groupe en fonction de la place du symbole. Dans le cas
d’un répertoire, tous les fichiers créés dans ce répertoire appartiendront au
même groupe que celui du répertoire.
‘t’ (sticky bit) : pour les fichiers exécutables, demande de garder le code en mé-
moire après l’exécution. Pour les répertoires, permet de limiter la destruc-
tion des fichiers au propriétaire du répertoire, du fichier ou au super utilisa-
teur .
4.9.5 Définition des droits d’accès

Changement de propriétaire
Les commandes chown et chgrp permettent de changer, respectivement le
propriétaire et le groupe d’un fichier.
Changement de la matrice des droits

La commande chmod permet de modifier les droits d’un ou plusieurs fichiers
en utilisant le mode numérique ou le mode littéral.
La commande umask permet de fixer les droits qui seront enlevés par défaut
pour la création de nouveaux fichiers. Cette commande est généralement lancée
une fois lors de l’ouverture de session, elle est intégrée à l’interpréteur de com-
mandes et sa syntaxe varie en fonction de celui que l’on utilise. Il est conseillé de
positionner le masque en numérique pour s’affranchir des différences syntaxiques.
Chapitre 5
Installation de Linux
Dans cette partie, nous allons apprendre à installer Linux sur une machine
de type PC faisant également fonctionner le système Windows NT. La distribution
utilisée est une Mandrake 8.1. Le but est d’obtenir une configuration conforme à
celle utilisée dans les chapitres précédents.
5.1 Avant de commencer l’installation

5.1.1 Configuration minimale
La configuration minimale supportée par Linux est un 386 avec au minimum
12 Mo de mémoire vive. Il va de soi qu’avec un tel foudre de guerre, vous ne
pourrez pas aller bien loin, une configuration raisonnable serait plutôt un 486DX2
66MHz avec au moins 32Mo de mémoire. La quantité de mémoire est de loin
le facteur le plus important, et si vous voulez utiliser l’environnement graphique
X11, il faut au minimum compter sur 64 Mo de mémoire vive. Vous pourrez donc
parfaitement transformer un vieux 486 ou Pentium en routeur ou en Firewall avec
partage de connexion à Internet par exemple. Vous n’aurez donc certainement
aucun problème avec les ordinateurs puissants qui se vendent actuellement.
5.1.2 Récupération des informations sur le matériel

Avant de commencer quoi que ce soit, vous devriez récupérer le maximum
de données concernant votre matériel. En effet, ces informations peuvent être
particulièrement utiles pour diagnostiquer la cause des éventuels problèmes de
configuration du matériel que vous pourriez rencontrer. Bien que les distributions
récentes soient capables de détecter le matériel le plus courant, vous aurez aussi
peut être à spécifier certains paramètres matériels lors de l’installation et, dans
105
106 CHAPITRE 5. INSTALLATION DE LINUX
le pire des cas, lors du premier démarrage de Linux. Les informations dont vous
aurez certainement besoin sont les suivantes :
– type de processeur, avec sa marque et éventuellement sa vitesse,
– type de carte mère, avec sa marque et impérativement son chipset,
– type de branchement de la souris (série, PS/2, interface bus propriétaire),
– nombre de ports série, ainsi que leurs paramètres (ports d’entrée/sortie,
lignes d’interruption),
– nombre de ports parallèle, ainsi que leurs paramètres (ports d’entrée/sortie,
lignes d’interruption),
– si vous disposez d’un contrôleur SCSI, marque et modèle de ce contrôleur
(modèle du chipset de la carte SCSI),
– sinon, nom du contrôleur de disque IDE (regardez sur le chipset de la carte
mère),
– types de disques durs (IDE, IDE UltraDMA 33, 66 ou 100, SCSI), ainsi que
leurs taille et leur position dans le système (contrôleurs auxquels ils sont
connectés, numéros d’unités logiques SCSI),
– type de lecteur de CD-ROM (IDE, ATAPI, SCSI, connecté sur carte son)
et le type de leur branchement s’ils sont externes (port parallèle, SCSI ou
USB),
– nom, modèle et marque de la carte graphique, type de chipset utilisé par
cette carte et taille de sa mémoire vidéo,
– nom, modèle et marque de l’écran, avec ses fréquences de balayage hori-
zontales et verticales, sa bande passante et les fréquences recommandées
par le constructeur pour les différentes résolutions,
– type de carte son (ISA, PCI, PnP) ainsi que le nom du chipset utilisé par
cette carte,
– type de carte réseau (ISA, PCI, PnP) ainsi que le nom de son chipset,
– type de modem (interne, externe) et, si le modem est interne, sa nature (mo-
dem complet ou émulation).
Vous pouvez obtenir ces informations en consultant la documentation fournie
avec votre ordinateur, les sites Web des constructeurs des différents composants,
les informations fournies par le programme de configuration du BIOS ou affi-
chées directement par le BIOS au démarrage de la machine, ou tout simplement
en ouvrant le boîtier de la machine et en regardant ce qu’il y a à l’intérieur. Vous
pouvez également récupérer les informations indiquées dans la configuration de
MS Windows si celui-ci est installé.
Il se peut que vous n’ayez pas besoin de ces informations et que l’installa-
tion se passe sans problème. Cependant, si d’aventure Linux exige que vous les
connaissiez, mieux vaut pouvoir lui répondre.
Bien que cela soit assez rare, certains composants ou périphériques addition-
nels peuvent ne pas être gérés par Linux, faute d’avoir un gestionnaire de péri-
5.1. AVANT DE COMMENCER L’INSTALLATION 107
phérique adéquat (cet état de fait est en général dû à une rétention d’information
de la part des fabricants, qui empêchent ainsi les développeurs de Linux d’écrire
les gestionnaires de périphériques dans de bonnes conditions). C’est en particu-
lier le cas de nombre de périphériques bas de gamme conçus pour ne fonctionner
qu’avec MS Windows, ou de quelques périphériques exotiques. Les Win-modems
ont une triste réputation à ce sujet (il s’agit de modems incomplets, dont une par-
tie du traitement de signal est reporté dans un logiciel spécifique à Windows),
ainsi que des imprimantes dites “GDI”, qui ne comprennent que les commandes
graphiques de Windows. Vous pourrez également avoir des problèmes avec des
cartes de numérisation vidéo analogiques ainsi que certaines cartes de décom-
pression MPEG. Certaines marques se distinguent par le fait qu’elles refusent
obstinément de développer des gestionnaires de périphérique pour leur matériel
ou, pire encore, de fournir les informations nécessaires aux développeurs de Li-
nux pour écrire ces gestionnaires sous licence libre. Mais il est toujours recom-
mandé, de manière générale, de bien se renseigner auprès des vendeurs et des
groupes de discussion avant tout achat de matériel... Vous pourrez trouver une
liste (non exhaustive) de matériel testé sous Linux dans la liste de matériel compa-
tible (http ://www.linuxdoc.org/HOWTO/Hardware-HOWTO/). La Linux Hard-
ware Data base (http ://lhd.datapower.com/) vous permettra également d’effectuer
une recherche sur n’importe quel type de matériel et sur n’importe quel modèle
très facilement. Il existe d’autres sites réalisant périodiquement des tests sur le ma-
tériel récent, comme par exemple Linux-Hardware (http ://www.linuxhardware.org).
5.1.3 Sauvegarde des données

L’installation du système de base est l’opération la plus délicate, puisqu’il faut
travailler au niveau le plus bas. La moindre erreur peut provoquer une catastrophe,
ce qui peut aller jusqu’à recommencer complètement l’installation. Si vous instal-
lez Linux pour la première fois sur votre ordinateur, ou s’il n’y a pas d’autre
système d’exploitation installé dessus, vous en serez quitte pour quelques heures
perdues. Sinon, ce qui est le plus à craindre, c’est la perte totale de vos données,
y compris celles des autres systèmes installés ! Donc :
IL FAUT DONC FAIRE UNE SAUVEGARDE DE VOS DONNÉES
Si vous disposez d’un lecteur de bande, le problème de la sauvegarde est très

simple : vous n’avez qu’à faire une sauvegarde complète. Dans le cas contraire,
vous allez sans doute devoir trier vos fichiers afin d’identifier ceux auxquels vous
tenez réellement, et les recopier sur un support physique fiable (évitez absolument
les disquettes, ils sont lents et n’ont jamais été fiables). Vous pouvez par exemple
faire un CD de sauvegarde si cous disposez d’un graveur de CD.
En fait, l’idéal est tout simplement de disposer d’un autre disque dur, que l’on
pourra consacrer complètement à l’installation de Linux. Ainsi, vous pourrez ex-
périmenter tout à loisir, sans craindre de perdre vos précieuses données. De plus,
l’installation de Linux sur un disque vierge est nettement plus facile que sur un
disque où Windows est déjà installé, parce que vous n’avez pas à dégager de la
place pour son installation. Prenez toutefois garde au fait que Linux restera ca-
pable d’accéder aux données de votre premier disque dur, et que toute erreur de
manipulation peut détruire les données qui s’y trouvent. Par exemple, si vous ne
spécifiez pas le bon disque dur lors de la création des systèmes de fichiers, vous
perdrez à nouveau toutes vos données. L’achat d’un tiroir peut être la vraie solu-
tion, car vous n’aurez qu’un seul disque à un instant donné dans votre ordinateur.
Toutefois, cette technique a l’inconvénient de ne pas vous permettre d’accéder aux
données de votre disque Windows à partir de Linux.
5.1.4 Amorçage
Pour commencer votre installation, vous devez avant tout démarrer votre or-
dinateur sous Linux. La méthode la plus simple est certainement de mettre le CD
d’amorçage de votre distribution dans le lecteur de CD et de redémarrer l’ordina-
teur. Il faut que votre BIOS soit configuré pour amorcer le système sur le lecteur
de CD pour que cette solution fonctionne. Si votre BIOS ne vous permet pas de le
faire, il ne vous reste plus qu’à utiliser l’une des disquettes fournies avec votre dis-
tribution. Dans tous les cas, Linux doit se lancer, et le programme d’installation
doit démarrer. Suivez les indications fournies avec votre distribution pour cette
étape.
En général, les distributions fournissent un petit utilitaire DOS nommé RAWRITE.EXE
qui permet de créer une disquette d’amorçage à partir d’un noyau très simplement.
Il s’utilise avec la ligne de commande suivante :
rawrite image lecteur:
où image est l’image d’une des disquettes d’amorçage (que vous trouverez
sur le CD d’amorçage de votre distribution), et lecteur est le lecteur de dis-
quette utilisé (en général, A:). Vous pouvez aussi consulter la documentation de
votre distribution pour savoir comment indiquer au noyau les modules qu’il doit
charger, ou comment créer une disquette de démarrage pour un autre noyau.
Dans la majorité des distributions, les outils nécessaires à l’installation sont
placés sur un disque virtuel en mémoire après le démarrage de Linux. C’est en
particulier le cas du programme d’installation. Cela est normal, puisque Linux
n’est pas encore installé, d’une part, et que ces outils ne tiennent pas facilement sur
une disquette, d’autre part. Ces outils sont donc souvent comprimés. Vous devez
malgré tout avoir déjà accès aux périphériques de votre ordinateur, en particulier
aux disques, pour poursuivre votre installation.
5.1.5 Partitionnement du disque

La deuxième opération après le démarrage du système est le partitionnement
du disque dur. Cette étape est de loin la plus dangereuse, mais elle est absolument
nécessaire. Elle ne pose pas de problème lorsqu’on installe Linux sur une machine
neuve, mais peut être délicate si un autre système d’exploitation est déjà installé
ou doit être installé en parallèle. Cette section décrit les principes de base du par-
titionnement, la manière de récupérer de la place sur un disque dur et l’opération
de partitionnement proprement dite.
Notion de partition
Une “partition” est, comme son nom l’indique, une partie d’un disque dur. Les
partitions permettent de diviser l’espace de stockage des disques durs en zones
indépendantes de taille restreinte, et dans lesquelles différents systèmes ou diffé-
rentes données peuvent être stockées de manière totalement indépendante. L’opé-
ration de “partitionnement” est l’opération de création des différentes partitions
d’un disque dur.
L’installation de plusieurs systèmes d’exploitation nécessite souvent d’allouer
une partition à chaque système, car les systèmes d’exploitation ne comprennent
généralement pas le format des systèmes de fichiers les uns des autres. Il éga-
lement est parfois nécessaire, pour un même système, de définir plusieurs parti-
tions, qui seront utilisées à des fins spécifiques. Par exemple, Linux fonctionne
nettement mieux si on lui attribue une partition de “swap” (dite aussi “partition
d’échange”) pour stocker des données peu utilisées qui se trouve en mémoire
lorsqu’il a besoin de plus de mémoire qu’il n’en est physiquement installée sur
la machine. De même, il est possible de créer plusieurs partitions pour séparer les
données utilisateurs des programmes, ce qui permet de faciliter les mécanismes
de sauvegarde d’une part, et d’assurer une plus grande sécurité des données lors
des opérations de maintenance du système d’autre part.
Sur les machines de type PC, chaque disque dur peut être découpé en quatre
partitions dites “primaires”. La position, la taille et le type de ces partitions sont
enregistrées dans le premier secteur du disque dur, que l’on appelle souvent le
“Master Boot Record” (“MBR” en abrégé). Le MBR ne contient que quatre en-
trées pour la définition des partitions, d’où la limite de quatre partitions primaires.
Le type des partitions est un code numérique qui indique le système d’exploita-
tion capable de l’utiliser et sa nature (partition de swap ou système de fichiers par
exemple). À titre d’exemple, Linux utilise principalement deux types de partition :
les partitions de swap (numéro 82) et les partitions pour les systèmes de fichiers
(type 83).
Bien entendu, la limitation à quatre partitions seulement est extrêmement contrai-
gnante, aussi la notion de partition étendue a-t-elle été introduite. Une “partition
étendue” est une partition primaire spéciale, dans laquelle il est possible de définir
jusqu’à 64 sous-partitions. Ces sous-partitions sont appelées des “partitions logi-
ques”. Les données ne sont jamais stockées dans la partition étendue elle-même,
mais dans ses partitions logiques (voir figure 5.1, page 110).
Partition primaire Partition étendue
Partitions logiques
F IG . 5.1 – Exemple de partitionnement de disque
On ne peut définir qu’une seule partition étendue sur un disque donné, mais
cela n’empêche pas d’avoir des partitions primaires normales à côté de celle-ci.
Il est donc recommandé, lorsque l’on crée la quatrième partition, de créer une
partition étendue et non une partition primaire, afin de se réserver la possibilité de
créer de nouvelles partitions ultérieurement. Il faut toutefois savoir que certains
systèmes ne peuvent pas être installés sur des partitions logiques (notamment DOS
et Windows 9x/Millénium), bien qu’ils soient capables d’y accéder une fois qu’ils
ont démarré.
Outre la table des partitions primaires, le MBR contient un petit programme,
appelé le “bootstrap loader”, qui permet de charger le premier secteur d’une des
partitions primaires. Ce secteur est communément appelé le “secteur de boot”,
parce qu’il contient le programme capable de charger le système d’exploitation.
La partition dont le secteur de boot est chargé par le bootstrap loader est appelée la
“partition active”. Il ne peut y avoir qu’une seule partition active à chaque instant :
celle du système d’exploitation principal.
Amorçage du système
Généralement, le programme stocké sur le secteur de boot d’une partition a
pour but de charger le système d’exploitation qui y est installé. Cependant, pour
certains systèmes d’exploitation, ce programme est très évolué et permet de lancer
d’autres systèmes d’exploitation, éventuellement installés sur d’autre partitions

ou d’autres disques durs. Ces programmes sont alors appelés des “gestionnaires
d’amorçage”.
Linux dispose de deux gestionnaires d’amorçages très puissants : le GRUB et
LILO. Windows NT, 2000 ou XP disposent également d’un gestionnaire d’amor-
çage capable de lancer d’autres systèmes d’exploitation : NTLDR.
Pour résumer, lors du démarrage d’un PC, le BIOS charge le MBR du pre-
mier disque dur en mémoire et exécute le bootstrap loader. Celui-ci cherche en-
suite à charger le secteur de boot de la partition active, et exécute le gestionnaire
d’amorçage qui s’y trouve. Ce gestionnaire peut donner accès aux différents sys-
tèmes d’exploitation, qu’ils soient situés sur d’autres partitions ou même d’autres
disques durs. La manière dont chaque système est lancé dépend bien sûr du sys-
tème. Il faut donc, en général, lancer chaque système d’exploitation avec son
propre chargeur. Cependant, on peut toujours utiliser un gestionnaire d’amorçage
d’un autre système en rusant quelque peu : il suffit d’indiquer à ce gestionnaire de
charger le secteur de boot de la partition d’installation du système que l’on désire
lancer si celui-ci n’est pas pris en charge directement. Dans ce cas, le gestionnaire
d’amorçage ne fait que passer la main au chargeur de l’autre système.
Plan de partitionnement
Avant de se lancer dans l’opération de partitionnement proprement dite, il faut
établir un plan de partitionnement. Cela consiste tout simplement à déterminer la
taille et la nature de chaque partition dans le système. Il est normal, sur un système
où seul Linux sera utilisé, de disposer d’au moins trois partitions :
– une partition de swap, que Linux utilisera pour y stocker temporairement
des données lorsqu’il aura besoin de récupérer un peu de place en mémoire.
Il est recommandé de placer cette partition au début du disque (c’est à dire
au plus près du cylindre 0, là où le taux de transfert est le plus rapide),
– une partition pour le système de fichiers racine (point de montage /, dans
laquelle doit se trouver l’ensemble des fichiers du système. Cette partition
doit se trouver dans les 1024 premiers cylindres pour que le BIOS puisse y
accéder et charger le gestionnaire d’amorçage du système,
– une partition devant contenir les données des utilisateurs (point de montage
/home/.
L’avantage d’avoir une partition séparée pour toutes les données des utilisa-
teurs est considérable, puisque dans ce cas on peut mettre à jour le système ou
le réinstaller complètement sans avoir à faire de sauvegarde de ces données. De
plus, les fichiers de configuration importants peuvent être sauvegardés sur cette
partition avant la réinstallation, ce qui est extrêmement pratique. Ce type de parti-
tionnement est à prendre sérieusement en considération, surtout pour les machines
de particuliers, sur lesquels un grand nombre de programmes peuvent être instal-

lés simplement pour les tester. Il n’est donc pas rare, dans ces conditions, d’avoir
à refaire une installation complète pour ń nettoyer ż rapidement le système.
Toutefois, si l’on ne dispose pas de beaucoup de place sur le disque, il est
possible de regrouper la partition racine et la partition contenant les données utili-
sateurs. Un mauvais dimentionnement de ces partitions aura dans ce cas de moins
lourdes conséquences (si une partition est pleine, on ne peut pas facilement utiliser
l’espace restant sur les autres partitions).
Si votre machine est destinée à accueillir plusieurs systèmes d’exploitation, il
est vivement recommandé de créer au moins une partition FAT ou FAT32. Cette
partition permettra en effet d’échanger des données entre Linux et les autres sys-
tèmes d’exploitation, car les systèmes de fichiers FAT sont reconnus par tous les
systèmes d’exploitation courants. Notez que si Windows NT4 doit être installé,
vous devrez créer une partition FAT plutôt qu’une partition FAT32, car Windows
NT ne reconnaît pas, sans programme additionnel, les partitions FAT32. Ce pro-
blème ne se pose plus pour Windows 2000 et pour XP. Notez également que bien
que Linux sache parfaitement lire les partitions NTFS (utilisées par Windows
NT4, Windows 2000 et par XP), l’écriture sur ces partitions est expérimentale
et n’est donc pas conseillée. Inversement, aucun système Windows ne sait lire les
systèmes de fichiers Linux, quels qu’ils soient. Avoir une partition FAT est donc
incontournable dans ce cas de configuration.
Si la machine doit être d’une fiabilité absolue ou si vous êtes soumis à des
contraintes d’exploitation fortes, vous pouvez opter pour des solutions radicales
qui consistent à séparer les données d’exploitation (normalement situées dans le
répertoire /var/) des fichiers des programmes, et de les placer dans une partition
dédiée. Vous pourrez alors ne monter que cette partition en lecture/écriture. Ainsi,
en cas de crash système, seule la partition contenant les données d’exploitation
devra être réparée, ou à l’extrême rigueur réinitialisée complètement par les scripts
de démarrage.
Rien ne vous empêche de créer d’autres partitions si vous le désirez. Sachez
cependant que les systèmes de fichiers de Linux ne sont pas aussi limités que
les systèmes de fichiers FAT et FAT32 en ce qui concerne les tailles maximales
des partitions, et que par conséquent, créer une multitude de partitions n’est pas
nécessaire et n’est certainement pas une bonne idée. La création de partitions sup-
plémentaires peut malgré tout s’avérer nécessaire, par exemple pour y installer
d’autres systèmes d’exploitation. Dans ce cas, vous aurez certainement à créer
une partition étendue et des partitions logiques.
La grande difficulté dans l’établissement du plan de partitionnement est de
bien déterminer ses besoins en place disque, aussi bien pour les programmes que
pour les données et le swap. Cependant, d’une manière générale, on peut considé-
rer que ce qui est le plus important pour un particulier, ce sont ses données, et que
le système ne va pas prendre des dizaines de giga-octets sur le disque ! Si vous

décidez de placer les programmes et les données utilisateurs dans deux partitions
séparées, vous pouvez envisager le plan de partitionnement suivant :
Une partition de swap deux fois la mémoire vive de l’ordinateur si vous ne dis-
posez pas de beaucoup d’espace disque, 256 Mo sinon. Il est inutile de
consacrer plus de place que cela, car il est très rare d’avoir besoin de plus
de 384 Mo de mémoire virtuelle (la mémoire virtuelle est la somme de la
mémoire libre et de la taille des partitions ou fichiers d’échange). Notez que
la règle du double de la mémoire vive est tout à fait empirique. Elle se base
sur le principe que si le système a besoin de plus de swap, c’est que de
toutes façons il n’est pas dimensionné pour ce qu’on lui demande de faire.
Cela dit, vous pouvez mettre autant de swap que vous le désirez si vous en
avez réellement besoin (par exemple pour manipuler de très grandes photos
ou des fichiers de très grande taille). Si vous avez un gros disque, vous pou-
vez utiliser une très grande partition de swap : elle ne sera quasiment pas
utilisée, mais le jour où vous en aurez besoin, elle sera là. Après tout, abus
de bien ne nuit pas... Sachez que de toutes façons, si un jour il fallait plus
de mémoire virtuelle, vous pourriez créer un fichier d’échange temporaire.
une partition racine contenant le système, les programmes et les fichiers de confi-
guration : environ 2 Go. Il est possible de travailler avec 1 Go, mais on n’est
vraiment pas à l’aise avec XWindow ou si l’on désire compiler des pro-
grammes récupérés sur Internet (ce qui est assez courant). Il est inutile de
dépasser les 3 Go pour cette partition, si l’on a besoin de plus de place, c’est
que le répertoire des données de travail /var/ devient trop gros et dans ce
cas on a intérêt à le placer sur une partition qui lui est dédiée. Notez que
l’on a intérêt à placer cette partition au début du disque pour deux raisons :
premièrement, c’est à cet endroit que le disque dur est le plus rapide, et
deuxièmement, certains BIOS ne sont pas capables d’accéder aux cylindres
de numéro supérieur à 1024 et ne peuvent donc pas accéder au gestionnaire
d’amorçage du système s’il est installé sur cette partition,
une partition pour les répertoires personnels des utilisateurs le reste de l’es-
pace disponible sur le disque moins, bien entendu, l’espace nécessaire aux
partitions des autres systèmes d’exploitation et celui d’une éventuelle parti-
tion de sauvegarde ou d’échange de données,
une partition de sauvegarde ou d’échange de données , éventuellement. Elle sera
utilisée pour échanger des données entre systèmes dans le cas d’une confi-
guration multi-boot. Cette partition devra être en FAT16 si les autres sys-
tèmes ne supportent pas les partitions de type FAT32 (par exemple DOS,
Windows 95 première édition ou Windows NT4), mais on préférera tout
de même la FAT32 si possible (Windows 95 OSR2 ou plus, ou Windows
2000 ou XP). Cette partition pourra faire environ 1 Go, soit la taille né-
cessaire pour stocker une image disque de CD-ROM plus quelques fichiers
complémentaires. Elle pourra être de taille supérieure si un autre système
d’exploitation y est installé.
La partition du système dont on utilise le gestionnaire d’amorçage doit être

placée de préférence avant le cylindre 1024. En effet, certains BIOS ne peuvent
pas accéder aux cylindres suivants, et le bootstrap loader ne peut donc pas charger
le gestionnaire d’amorçage du système dans ce cas. Cela signifie que la deuxième
partition doit être la partition du système d’exploitation principal (cela a en plus
l’avantage de donner les accès disque les plus rapides pour les fichiers de ce sys-
tème).
Notez que ce plan de partitionnement utilise les quatre entrées de la table des
partitions, et ne permet donc pas d’en ajouter une complémentaire. Si l’on désire
installer un autre système d’exploitation, on pourra le faire sur la partition FAT
(auquel cas on pourra lui consacrer plus d’un giga-octets), soit sur un deuxième
disque dur. Si cela ne s’avère pas possible (par exemple parce que l’on veut instal-
ler Windows NT, Windows 2000 ou XP sur une partition NTFS tout en conservant
la partition FAT), on devra créer une partition étendue. Je préconise dans ce cas de
placer les deux dernières partitions (la partition d’échange et la partition des ré-
pertoires personnels des utilisateurs) dans des partitions logiques de cette partition
étendue, ce qui laisse libre la troisième partition primaire pour un autre système
d’exploitation. Bien entendu, ce plan de partitionnement est une suggestion et
vous êtes absolument libre d’en choisir un autre. Je ne le fournis que pour aider
ceux qui ne savent pas comment effectuer leur partitionnement précisément. Il de-
vrait convenir pour tous les disques de plus de 4 Go, qui sont monnaie courante à
présent.
Utilisation de parted
L’utilitaire GNU parted est le standard en ce qui concerne les manipulations

de partitions sous Linux. Cet outil s’utilise en ligne de commande, et peut donc
être utilisé à partir d’un terminal en mode texte pendant la phase d’installation,
si votre distribution l’inclut avec ses outils d’installation standards. Vous pourrez
lancer parted avec la simple commande suivante :
parted disque
5.2. DÉCLARATION DES UTILISATEURS LOCAUX 115
5.2 Déclaration des utilisateurs locaux

5.2.1 Création des utilisateurs
Modification des fichiers de configuration
Le fichier /etc/passwd contient la définition des utilisateurs locaux du sys-
tème, chaque utilisateur y est décrit par une entrée (voir 4.9.2, page 98 pour la
structuration des enregistrements de ce fichier). Ainsi, pour créer un nouvel utili-
sateur, il suffit de rajouter une ligne dans le fichier /etc/passwd.
Par exemple, pour créer l’utilisateur nommé “Rémi LEBLOND”, utilisant le
login “remi’, ayant le répertoire de connexion /home/remi, utilisant l’interpré-
teur de commande bash, ayant un identifiant numérique 500 et faisant partie du
groupe 500, nous ajouterons la ligne suivante au fichier /etc/passwd :
remi:*:500:500:Rémi LEBLOND:/home/remi:/bin/bash
Le deuxième champs de cette ligne indique le mot de passe de l’utilisateur. Il

peut être :
– Vide, si l’utilisateur n’a pas de mot de passe,
– le mot de passe crypté par l’algorithme à sens unique crypt1 ,
Exemple de mot de passe crypté : “jn37OT0surAy.”
– le caractère ’*’ pour indiquer que le mot de passe crypté est stocké dans le
fichier /etc/shadow.
Utilisation d’outils système

Généralement, la plupart des distributions Linux propose des outils facilitant
la manipulation du fichier des utilisateurs. Il s’agit, soit d’outils en commandes en
ligne de commande, soit d’outils graphiques.
La commande useradd permet de créer de nouveaux utilisateurs.
Exemple d’utilisation : Création d’un nouvel utilisateur “util1”.
# useradd util1
# passwd util1
Changing password for user util1.
New UNIX password:
Retype new UNIX password:
passwd: all authentication tokens updated successfully.
1
La fonction crypt est celle utilisée pour le cryptage des mots de passe. Elle est basée sur
l’algorithme DES (Data Encryption Standard) avec des variantes prévues entre autres choses pour
éviter l’implémentation matérielle d’un casseur de code.
Le nouveau compte utilisateur sera inséré dans les fichiers du système quand
c’est nécessaire, le répertoire personnel sera créé, et les fichiers initiaux copiés à
partir du répertoire /etc/skel, cela dépendant des options présentes en ligne
de commandes. La commande crée un groupe pour chaque utilisateur ajouté au
système, à moins que l’option -n ne soit fournie. Comme la grande majorité des
commandes Linux, useradd accepte un grand nombre d’options permettant, par
exemple, de spécifier l’emplacement du répertoire personnel ou le groupe princi-
pal. Se reporter à la page de manuel pour plus d’informations.
A l’inverse, la commande userdel permet de supprimer des comptes utili-
sateur.
La distribution Mandrake dispose d’un outil graphique permettant de gérer les
utilisateurs et les groupe : userdrake (voir figure 5.2, page 116).
F IG . 5.2 – Exemple de fenêtre UserDrake
5.2.2 Création des groupes

Modification des fichiers de configuration
Le fichier /etc/group contient la définition des groupes locaux du système,

chaque groupe y est décrit par une entrée (voir ??, page ?? pour la structuration
des enregistrements de ce fichier). Ainsi, pour créer un nouveau groupe, il suffit
de rajouter une ligne dans le fichier /etc/group.
5.2. DÉCLARATION DES UTILISATEURS LOCAUX 117
Utilisation d’outils système

Chapitre 6
Mise en réseau
Dans ce chapitre, nous allons aborder la configuration d’un système Linux

pour l’intégrer à un réseau local.
6.1 Principes généraux des réseaux

6.1.1 Les classes de réseau IP
Classe Plage disponible

A 10.0.0.0
B 172.16.0.0 à 172.31.0.0
C 192.168.0.0 à 192.168.255.0
TAB . 6.1 – Classes de réseaux IP disponibles pour une utilisation privée
6.2 Configuration de base

6.2.1 Affectation d’adresse
La commande ifconfig permet de configurer (et maintenir ensuite) les in-
terfaces réseau.
La configuration d’une interface réseau consiste à lui attribuer une adresse IP
et à indiquer à quel type de réseau elle est raccordée. Ainsi, pour déclarer une
nouvelle interface réseau, la syntaxe de la commande ifconfig est la suivante :
ifconfig [nom de l’interface] [adresse IP] options up|down.
119
120 CHAPITRE 6. MISE EN RÉSEAU
Les nouvelles interfaces sont activées par défaut, mais il est possible de les désac-
tiver à l’aide du paramètre “down”.
Le nom de l’interface peut généralement prendre les valeurs suivantes :
lo : pour loopback, l’interface de réseau virtuel local à la machine,
eth0 : la première carte Ethernet installée. La deuxième carte Ethernet porterait
le nom eth1,
<nom d’une interface> :1 : le premier alias de l’interface. Il est possible de dé-
finir des alias des interfaces existantes. Chacun d’entre eux peut être confi-
guré indépendamment à l’aide de la commande ifconfig.
Les options les plus courantes sont :
netmask : Définit le masque de réseau IP pour cette interface. La valeur par dé-
faut de cette valeur correspond au masque réseau usuel pour les classes A,
B ou C (déduite de l’adresse IP), mais toute autre valeur peut être définie
selon les besoins en sous- réseaux.
up : Cette option active l’interface. Elle est implicitement spécifiée si une nou-
velle adresse est affectée à l’interface (voir plus loin).
down : Cette option arrête le fonctionnement du pilote pour cette interface, et est
utilisée lorsque les choses commencent à aller mal.
pointopoint adresse : Ce mot clé valide le mode point à point d’une interface,
signifiant qu’il existe un lien direct entre 2 machines, sans que personne
d’autre ne puisse être à l’écoute.
Si aucun argument n’est donné, ifconfig affiche simplement l’état des inter-
faces actuellement définies. Si seul le paramètre interface est donné, il affiche
seulement l’état de l’interface correspondante. Si seul le paramètre -a est fourni,
il affiche l’état de toutes les interfaces, même celles qui ne sont pas actives.
[root@rapido remi]# ifconfig

eth0 Lien encap:Ethernet HWaddr 00:50:FC:49:D0:FB
inet adr:192.168.0.1 Bcast:192.168.0.255 Masque:255.255.2
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:1663 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 lg file transmission:100
RX bytes:0 (0.0 b) TX bytes:112830 (110.1 Kb)
Interruption:11 Adresse de base:0x9000
lo Lien encap:Boucle locale

inet adr:127.0.0.1 Masque:255.255.255.0
6.2. CONFIGURATION DE BASE 121
UP LOOPBACK RUNNING MTU:16436 Metric:1

RX packets:13989 errors:0 dropped:0 overruns:0 frame:0
TX packets:13989 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 lg file transmission:0
RX bytes:805767 (786.8 Kb) TX bytes:805767 (786.8 Kb)
6.2.2 Définition de règles de routage

La commande route manipule la table de routage IP du noyau. Son utili-
sation première consiste à configurer des routes statiques vers des hôtes ou des
réseaux via une interface, après sa configuration par le programme ifconfig.
Utilisée seule, la commande route permet d’afficher la table de routage ac-
tive du système.
[root@rapido remi]# route

Table de routage IP du noyau
Destination Passerelle Genmask Indic Metric Ref Use If
192.168.0.0 * 255.255.255.0 U 0 0 0 et
127.0.0.0 * 255.255.255.0 U 0 0 0 lo
Pour définir une nouvelle route à l’aide de la commande route, il faut :

– Choisir l’action :
– del pour supprimer une route,
– add pour ajoute une route.
– Choisir la destination de la route :
– -net pour ajouter une route dont la cible est un réseau,
– -host si la cible est un hôte.
– Choisir la cible de la route : l’hôte ou le réseau destination.
– Définir les éventuelles options :
– netmask spécifie le masque réseau de la route à ajouter,
– gw suivi de l’adresse de la passerelle signifie que tout paquet IP envoyé à
cette adresse sera routé par la passerelle spécifiée.
6.2.3 Test de la configuration

Commande ping permet de tester la communication vers un hôte spécifié par
son adresse ou son nom. Par défaut, la commande ping s’exécute en boucle, il
faut donc l’interrompre par CTRL-C.
[root@rapido remi]# ping brouette

PING brouette (192.168.0.10) from 192.168.0.1 : 56(84) bytes of data.
64 bytes from rapido (192.168.0.1): icmp_seq=0 ttl=255 time=80 usec

--- rapido ping statistics ---

3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max/mdev = 0.046/0.059/0.080/0.015 ms
6.2.4 Résolution des noms de machines

Jusqu’à présent, nous avons désigné les différents composants du réseaux par
leur adresse IP. Si cette désignation convient parfaitement à un système informa-
tique, elle n’est pas naturelle pour un être humain normalement constitué. Aussi,
pour des raisons de commodité, nous allons voir comment attribuer de véritables
noms aux machines du réseau.
Le fichier /etc/hosts permet de nommer les machines du réseau, ce qui
permet de traduire une adresse IP en nom et vice versa. Chaque ligne du fichier
permet de nommer une adresse IP. Elles commence donc par l’adresse IP suivie
des différents noms associés à cette adresse. Par exemple :
[root@rapido root]# cat /etc/hosts

127.0.0.1 rapido localhost.localdomain localhost
192.168.0.10 brouette
192.168.0.1 rapido
6.3 Centralisation de configuration

6.3.1 Installation d’un serveur NIS
Présentation
Lorsqu’un réseau partage des informations entre différentes machines, il est
intéressant de centraliser la gestion des mots de passe pour permettre aux utilisa-
teurs de se connecter de n’importe où. Pour cela, il faut installer un serveur NIS
sur le réseau. NIS signifie Network Information System.
L’intérêt de NIS repose donc sur une bibliothèque de données à consulter.
Ce système de pages jaunes (Yellow Pages en anglais, à l’origine du yp débu-
tant les commandes NIS) repose sur RPC, au même titre que NFS. Le partage
d ?informations permet de mettre en commun des fichiers tels que /etc/passwd
ou /etc/hosts pour partager les mots de passe ou les alias de machines.
6.3. CENTRALISATION DE CONFIGURATION 123
La configuration d’une connexion NIS demande un rien de maîtrise, et se dé-

compose en deux étapes distinctes :
– La mise en oeuvre du serveur,
– La configuration des clients.
La première phase porte sur la mise en place d’un serveur et la génération
de cartes, bases de données issues des données en partage. La seconde phase
concerne chacun des clients. Le serveur Le serveur NIS s’appelle ypserv. Nous
allons utiliser la centralisation des mots de passe comme support de notre exemple
et nous supposerons que le paquetage ypserv a été installé. Pour cela, on peut
vérifier la présence de l’exécutable ypserv dans le répertoire /usr/sbin et
l’existence d’un répertoire /var/yp dans lequel se trouve un fichier Makefile.
Pour faire les choses proprement et bien séparer les données, il faut créer
un répertoire /etc/NIS dans lequel nous allons placer une copie des fichiers
passwd, shadow et group du répertoire /etc/. Nous allons retirer tous les
utilisateurs qui doivent être exportés des fichiers originaux, et ne laisser que ceux-
ci dans les copies (i.e. on supprime dans les copies les utilisateurs et groupes ayant
un identificateur supérieur à 500).
Dans le fichier /var/yp/Makefile, il faut mettre les variables YPSRC-
DIR et YPPWDDIR valant /etc/NIS, et de même ne laisser sur la ligne “all :”
que les services nécessaires, c’est à dire passwd, shadow et group. On doit donc
retrouver les lignes suivantes dans le fichier /var/yp/Makefile :
...
YPSRCDIR = /etc/NIS
YPPWDDIR = /etc/NIS
...
all: passwd group shadow
Il reste à fixer un nom de domaine NIS par la commande domainname

<nom domaine>, puis lancer la commande make dans le répertoire /var/yp.
Par cette manipulation, on génère la bibliothèque de données accessibles.
Finalement, il ne reste plus qu’à lancer le serveur par la commande ypserv et
le démon yppasswdd -D /etc/NIS pour activer la partie serveur. Il peut être
utile de mettre ces étapes dans un script de démarrage tout comme la définition
du nom de domaine NIS. Pour cela, il suffit de rajouter ces quelques lignes dans
le fichier /etc/rc.d/rc.inet2 (ou son équivalent suivant les distributions),
après avoir écrit le nom de domaine NIS dans le fichier /etc/nisdomainname :
if [ -r /etc/nisdomainname ]; then
nisdomainname ?cat /etc/nisdomainname?
fi
if [ -x ${NET}/ypserv ]; then
echo -n " ypserv?
${NET}/ypserv
fi
if [ -x ${NET}/rpc.yppasswdd ]; then
echo -n " yppasswdd?
${NET}/rpc.yppasswdd
fi
Après un redémarrage, le serveur NIS sera en place. Le client Pour la confi-

guration du client, il faut rajouter l’adresse IP (ou son nom s’il est défini dans
/etc/hosts) du serveur dans le fichier /etc/yp.conf. La ligne à rajouter sera la
suivante :
ypserver nom_du_serveur
Il faut également changer dans le fichier nsswitch.conf l’ordre de re-

cherche sur les fichiers partagés par le serveur NIS. Typiquement, on retrouve une
ligne du genre :
passwd: nis files
Finalement il ne reste plus qu’à lancer ypbind, la configuration est terminée

et l’accès au serveur NIS est désormais possible. Pour le vérifier, nous allons ré-
cupérer le fichier passwd.byname ou passwd.byuid qui a été généré après
la commande make sur le serveur.
Pour ce faire, nous appelons la commande ypcat passwd.byname. Enfin,

la gestion des mots de passe ne se fait plus par la commande passwd mais par
yppasswd, aussi est-il judicieux de remplacer passwd par un lien symbolique
vers la commande yppasswd par la ligne suivante :
ln -s yppasswd passwd
6.4. PARTAGE DE RESSOURCES 125
6.3.2 Mise en oeuvre d’un serveur de noms (DNS)

6.3.3 Partage de configuration réseau via DHCP
6.4 Partage de ressources

6.4.1 Accès distant par telnet
6.4.2 Partage de fichiers par NFS
6.4.3 Publication de fichier via FTP
6.4.4 Publication Web via HTTP
Chapitre 7
Compilation du noyau
Le but de ce chapitre est de confectionner un noyau adapté au mieux à nos

besoins afin de remplacer celui qui a été installé par la distribution. Nous nous
basons pour cela sur l’installation qui a été réalisée lors du précédant chapitre,
en partant du principe que le compilateur gcc et l’outil make fonctionnent cor-
rectement.
7.1 Principe
Le noyau de Linux qui est fourni avec votre distribution est un noyau qui a
été spécialement conçu pour démarrer correctement sur le plus grand nombre de
machines possibles. Il ne s’agit donc pas d’un noyau optimal, d’où l’intérêt de
compiler un noyau plus adapté.
La compilation du noyau est une spécificité des systèmes libres, qui n’est pos-
sible que parce que l’on dispose des sources du noyau. Cependant, même pour
certains Unix commerciaux, il est possible d’effectuer une édition de liens, les
modules du noyau étant fournis sous la forme de fichiers objets. La compilation
ou l’édition de liens du noyau est une opération technique qui peut surprendre un
habitué des systèmes fermés que sont par exemple Windows ou OS/2. Cependant,
elle permet d’obtenir un noyau très petit, optimisé pour la machine sur laquelle
il tourne, et donc à la fois économe en mémoire et performant. Il est donc re-
commandé d’effectuer cette compilation : pourquoi conserver un monstre capable
de gérer des périphériques qui ne sont pas et ne seront jamais installé sur votre
système ?
La compilation du noyau de Linux nécessite de disposer des dernières sources
du noyau (version 2.4.17. au 22/10/2001) et d’un compilateur. Il est évident que
le compilateur idéal est le compilateur GNU C/C++ GCC. On utilisera la version
la plus stable actuellement, à savoir la version 2.95.3. Je supposerai dans la suite
127
128 CHAPITRE 7. COMPILATION DU NOYAU
de ce document que vous disposez de la dernière version du noyau, à savoir la

version 2.4.17 [GIC02].
La compilation du noyau n’est pas très difficile, cependant, elle nécessite de
répondre correctement aux questions de configuration. Les erreurs peuvent être
multiples, et seront fatales. Il est donc fortement conseillé de disposer d’une dis-
quette de démarrage afin de réparer le système en cas d’erreur. Par ailleurs, il
faut toujours conserver le dernier noyau utilisable en sauvegarde dans le réper-
toire /boot/. Il faut également ajouter une entrée spécifiant ce noyau dans le
programme de démarrage (lilo), afin de pouvoir sélectionner l’ancien noyau en
cas d’erreur. Ces opérations seront également décrites en détail plus loin [GIC02].
La compilation du noyau se passe en quatre étapes :
– installation des fichiers sources,
– réponse aux questions de configuration,
– compilation du nouveau noyau,
– installation du nouveau noyau,
– compilation des modules,
– installation des modules.
7.2 Installation des fichiers sources

Les sources les plus récentes du noyau peuvent être trouvées sur le site “http ://www.kernel.org”.
Il est possible de récupérer les sources complètes, sous la forme d’une archive
comprimée d’environ 24 Mo. Toutefois, dans un soucis de commodité, nous utili-
serons dans ce chapitre les sources fournies avec notre distribution.
Généralement, les sources du noyaux Linux sont installés dans le répertoire
/usr/src/linux/. On devra donc renommer temporairement le répertoire
originel avant d’installer les sources du nouveau noyau, ou au moins en faire une
sauvegarde. Une autre solution est d’installer les fichiers du noyau dans un réper-
toire /usr/src/linux_version/ et d’utiliser un lien symbolique /usr/src/linux/
pour sélectionner la version que l’on veut compiler. Cela permet de conserver plu-
sieurs jeux de sources de versions différentes, et de travailler sur la version cou-
rante dans le répertoire /usr/src/linux/ facilement. Les commandes sui-
vantes permettront d’extraire les sources dans le répertoire dédié au sources de
Linux. Elles supposent qu’il existe déjà un lien symbolique /usr/src/linux/
vers le répertoire des fichiers sources actuels de Linux :
cd /usr/src
rm linux
mkdir linux-2.4.17
ln -s linux-2.4.17 linux
7.3. PARAMÉTRAGE DE LA COMPILATION 129
tar xvfz linux-2.4.17.tar.gz

[GIC02]
7.3 Paramétrage de la compilation

Pour pouvoir paramétrer votre compilation, il est nécessaire de ce placer dans
le répertoire contenant les sources du noyau. Pour cela, utilisez la commande :
cd /usr/src/linux
La configuration du noyau peut se faire “à l’ancienne” avec la commande sui-
vante :
make config
Cette commande pose une série de questions auxquelles il faut pouvoir ré-
pondre correctement du premier coup. On n’a pas le droit à l’erreur ici, faute de
quoi il faut tout reprendre à zéro.
Il est nettement plus convivial d’utiliser la version Tcl/Tk sous X11. Cette
version donne l’accès aux différentes options sans un ordre quelconque, et ne
présente que les options réalisables étant données celles déjà fixées. Cette méthode
est évidemment la méthode conseillée (voir figure 7.1, page 129). Pour l’utiliser,
il suffit de taper la commande suivante :
make xconfig
F IG . 7.1 – Le résultat de la commande make xconfig sous XWindow
Si l’on ne dispose pas encore de X11 on peut utiliser la version texte avec
menu en tapant la commande suivante :
make menuconfig
Quelle que soit la méthode utilisée, il faut répondre par “Y” (pour “Yes”), “N”
(pour “No”) ou “M” (pour “Module”) lorsque c’est possible. “Y” et “M” incluent
la fonctionnalité courante dans le noyau ou sous la forme d’un module, “N” la sup-
prime. “M” permet d’utiliser la fonctionnalité en tant que module du noyau. En
général, l’utilisation des modules permet d’alléger le noyau car les fonctionnalités
sont chargées et déchargées dynamiquement. Cependant, les fonctionnalités né-
cessaires au démarrage de Linux, comme les gestionnaires de disques et systèmes
de fichiers par exemple, ne doivent en aucun cas être placées dans des modules,
car alors le système ne pourrait pas démarrer.
Quand vous avez configuré votre compilation, sortez de l’utilitaire en sauve-
gardant vos modifications (“Save and Exit”).
[GIC02]
Remarque : Si vous voulez retrouver le paramétrage initial, vous pouvez uti-
liser la commande make mrproper. Il est possible de sauvegarder un état de
configuration à l’aide de la commande make backup.
7.4 Compilation et installation du noyau

Une fois la configuration du noyau réalisée, la compilation peut être lancée.
Pour cela, il suffit de lancer les trois commandes suivantes dans le répertoire
/usr/src/linux :
make dep
make clean
make bzImage
La première commande génère les dépendances entre les fichiers du noyau.

Ces dépendances sont utilisées par les fichiers makefile. La deuxième commande
effectue le ménage nécessaire pour supprimer tous les fichiers objets pouvant ré-
sulter d’une précédente compilation. Cette opération est nécessaire afin d’éviter
de mélanger des fichiers ayant été compilés avec des options de configuration dif-
férentes. Enfin, la troisième commande lance la compilation et l’édition de lien
proprement dite.
Une fois la compilation achevée, il faut installer le nouveau noyau. Cette opé-
ration nécessite beaucoup de prudence, car si le noyau nouvellement créé n’est
pas bon, le système ne redémarrera plus. C’est pour cela qu’il est conseillé de
conserver toujours deux versions du noyau, dont on est sûr que l’une d’entre elle
fonctionne parfaitement. En pratique, cela revient à conserver la version originale
du noyau installé par votre distribution. Pour cela, il faut en faire une copie de
sauvegarde.
7.4. COMPILATION ET INSTALLATION DU NOYAU 131
En général, le noyau est installé dans le répertoire /boot/. Il porte souvent

le nom de “vmlinuz”, pour le sauvegarder, il suffit donc de taper par exemple la
commande suivante :
cp vmlinuz vmlinuz.old
Il faut également indiquer au gestionnaire d’amorçage qu’il faut qu’il donne
maintenant la possibilité de démarrer l’ancienne version du noyau sous ce nouveau
nom. Pour LILO, il suffit d’éditer le fichier /etc/lilo.conf et d’y ajouter une
nouvelle configuration. En pratique, cela revient à dupliquer la configuration du
noyau actuel et à changer simplement le nom du noyau à charger (paramètre “ima-
ge” de la configuration dans /etc/lilo.conf) et le nom de la configuration
(paramètre “label”). Vous devrez aussi rajouter l’option “prompt” si elle n’y est
pas déjà, afin que LILO vous demande la configuration à lancer à chaque démar-
rage. Dans notre exemple, le nom du noyau à utiliser pour la configuration de sau-
vegarde sera “vmlinuz.old”. De même, si la configuration initiale de Linux porte
le nom “linux”, vous pouvez utiliser le nom “VieuxLinux” pour la configuration
de sauvegarde (voir figure 7.2, page 132).
Une fois le fichier /etc/lilo.conf mis à jour, il faut réinstaller LILO, ce
qui se fait simplement en invoquant la commande lilo.
[root@pc1 linux]# lilo

Added Linux *
Added VieuxLinux
Added Windows
Si l’on otient un message différent, il faut corriger son fichier /etc/lilo.conf

et ne sourtout pas tenter de redémarrer le système avant la résolution du problème
(il ne redemarrerait probablement pas et il faudrait utiliser la disquette de secour).
L’image du nouveau noyau a été créée dans le répertoire /usr/src/linux/arch/i386/boot/,
sous le nom bzImage. L’installation se fait donc simplement par une copie dans
/boot/ en écrasant le noyau actuel vmlinuz :
cp /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz
Il faut également copier le fichier System.map du répertoire /usr/src/linux/
dans le répertoire /boot/ :
cp System.map /boot
Ce fichier contient la liste de tous les symboles du nouveau noyau, il est utilisé
par quelques utilitaires systèmes.
Si vous utiliser LILO, il vous faudra le réinstaller à nouveau pour qu’il prennent
en compte le nouveau noyau. Cela se fait avec la même commande que celle uti-
lisée précédemment : lilo.
Il faut ensuite redémarrer la machine avec la commande reboot et vérifier
que le nouveau noyau fonctionne bien. S’il ne se charge pas correctement, c’est
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
default=linux
keytable=/boot/fr-latin1.klt
lba32
prompt
timeout=50
message=/boot/message
menu-scheme=wb:bw:wb:bw
image=/boot/vmlinuz
label=Linux
root=/dev/hdb1
append=" devfs=mount"
read-only
image=/boot/vmlinuz.old
label=VieuxLinux
root=/dev/hdb1
append=" devfs=mount"
read-only
other=/dev/hda1
label=Windows
table=/dev/hda
F IG . 7.2 – Exemple de fichier lilo.conf

7.5. COMPILATION ET INSTALLATION DES MODULES 133
que les options de configuration choisies ne sont pas correctes. Il faut donc utiliser
le noyau sauvegardé, vérifier ses choix et tout recommencer. Attention cependant,
cette fois, il ne faut pas recommencer la sauvegarde du noyau, puisque cette opé-
ration écraserait le bon noyau avec un noyau défectueux.
Si le nouveau noyau démarre correctement, il ne reste plus qu’à installer les
modules [GIC02].
7.5 Compilation et installation des modules

Si le système a redémarré correctement, on peut compiler les modules et les
installer. Il n’est pas nécessaire de prendre les mêmes précautions pour les mo-
dules que pour le noyau. Il suffit donc ici de lancer la commande suivante dans le
répertoire /usr/src/linux/ :
make modules
Les modules sélectionnés lors de la configuration sont alors compilés, il ne
reste plus qu’à les installer.
Avant toute installation de nouveaux modules, il est recommandé de déchar-
ger tous les modules présents en mémoire. Cette opération peut être réalisée à
l’aide de la commande modprobe -ar, qui va tenter de décharger les modules
non utilisés. Vous pouvez consulter la liste des modules chargés à l’aide de la
commande lsmod. S’il reste des modules chargés, vous pouvez les supprimer à
l’aide de la commande rmmod suivie du nom du module à supprimer. Pour pou-
voir supprimer un module, il faut que ce dernier ne soit plus utilisé par le système.
Par exemple, pour pouvoir supprimer le module isofs, chargé de la gestion du
système de fichier ISO9660 utilisé pour les CD-ROM, il faut démonter préalable-
ment tous les CD-ROM du système.
Une fois que tous les modules sont déchargés (la commande lsmod retourne
une liste vide), l’installation des modules est alors très simple, puisqu’il suffit
de lancer la commande make modules_install suivante dans le répertoire
/usr/src/linux/.
Les modules sont installés dans le répertoire /lib/module/version/, où
version est le numéro de version du noyau courant. Il est possible que des mo-
dules d’autres versions du noyau existent dans leurs répertoires respectifs. Si vous
n’en avez plus besoin, vous pouvez les effacer. Attention cependant si vous avez
installé des modules additionnels non fournis avec le noyau dans ces répertoires,
vous pourriez encore en avoir besoin.
Les modules sont utilisés par le chargeur de module du noyau, grâce à la com-
mande modprobe. Cette commande a besoin de connaître les dépendances entre
les modules afin de les charger dans le bon ordre. Il faut donc impérativement
mettre à jour le fichier /lib/modules/version/modules.dep à chaque
[root@pc1 linux]# lsmod

Module Size Used by
es1371 26528 0
ac97_codec 9248 0 [es1371]
soundcore 3440 4 [es1371]
af_packet 11984 0 (autoclean)
nls_iso8859-15 3392 3 (autoclean)
nls_cp850 3632 3 (autoclean)
vfat 9744 3 (autoclean)
fat 30240 0 (autoclean) [vfat]
floppy 46608 1 (autoclean)
nls_iso8859-1 2880 1 (autoclean)
isofs 17104 1 (autoclean)
F IG . 7.3 – Exemple d’utilisation de la commande lsmod
fois que l’on installe les modules, à l’aide de la commande depmod -a.
Les modules doivent être installés après avoir installé le noyau et redémarré le
système, faute de quoi la commande depmod peut ne pas trouver trouver tous les
symboles utilisés par les modules dans le noyau en court d’exécution [GIC02].
Chapitre 8
Les scripts shell
Commande ls (-a, -l, expressions générales - glob * [], redirection vers un

fichier) Fichiers et répertoires : même chose, type différents
Commande cat
Suppression de fichier (rm)
Création de répertoire (mkdir)
Suppression de répertoire (rmdir, rm -R)
Copie de fichier (cp) Déplacement de fichier (mv) Liaison de fichiers (ln sta-
tique ou physique)
Editeur vi
Recherche de fichiers (find, locate - updatedb) : -type [df], -name, -size
Recherche et manipulation internes aux fichiers (More, grep, sort, wc... )
Utilisation de pipes pour communication inter-processus (exemple cat|more)
Mise en pratique : recherche des commandes utilisées (ls, cd... )
Principe du PATH
Droits sur les fichiers et répertoires
Essayer de créer un fichier ou un répertoire dans /etc ou /bin
Commande id : voir le groupe de l’utilisateur
Ls -l : Insister sur propriétaire et groupe
Expliquer la signification du champ rwxrw-r–
135
136 CHAPITRE 8. LES SCRIPTS SHELL
Table des figures
1.1 Processus de création d’une application . . . . . . . . . . . . . . 10

1.2 Logo des applications Open Source . . . . . . . . . . . . . . . . 12
1.3 Logo du projet GNU . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4 Tux : La “mascotte” de Linux . . . . . . . . . . . . . . . . . . . . 17
1.5 Linus TORVLADS . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.1 Prise en charge de fonctions par un noyau monolythique . . . . . 30

2.2 Prise en charge de fonctions par un noyau modulaire . . . . . . . 31
2.3 Architecture d’un système GNU/Linux . . . . . . . . . . . . . . . 33
2.4 Exemple d’interface utilisateur graphique utilisant WindowMaker 35
2.5 Exemple d’interface utilisateur graphique utilisant KDE . . . . . . 36
2.6 Structure du système GNU/Linux . . . . . . . . . . . . . . . . . 37
2.7 Exemple d’arborescence de processus . . . . . . . . . . . . . . . 38
2.8 Exemple de tube nommé FIFO . . . . . . . . . . . . . . . . . . . 40
2.9 Répertoires et points de montage sous Windows . . . . . . . . . . 43
2.10 Répertoires et points de montage sous Linux . . . . . . . . . . . . 44
3.1 Exemple de fichier fstab . . . . . . . . . . . . . . . . . . . . . 59
4.1 Les entrées-sorties de commandes . . . . . . . . . . . . . . . . . 65

4.2 Interface utilisateur de vi . . . . . . . . . . . . . . . . . . . . . . 79
4.3 Exemple d’utilisation des commandes d’insertion de vi . . . . . 79
4.4 Basculement entre les deux modes de vi . . . . . . . . . . . . . 81
4.5 Lien physique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
4.6 Lien symbolique . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.7 Exemple de fichier .bash_profile . . . . . . . . . . . . . . . 96
4.8 Exemple de fichier .bashrc . . . . . . . . . . . . . . . . . . . 97
5.1 Exemple de partitionnement de disque . . . . . . . . . . . . . . . 110

5.2 Exemple de fenêtre UserDrake . . . . . . . . . . . . . . . . . . . 116
7.1 Le résultat de la commande make xconfig sous XWindow . . 129
137
138 TABLE DES FIGURES
7.2 Exemple de fichier lilo.conf . . . . . . . . . . . . . . . . . . 132

7.3 Exemple d’utilisation de la commande lsmod . . . . . . . . . . . 134
Liste des tableaux
3.1 Présentation rapide des principaux répertoires d’un système de fichier Linux 48
3.2 Principaux types de systèmes de fichiers supportés par la commande mount 57
4.1 Sections du manuel (commande man) . . . . . . . . . . . . . . . 62

4.2 Sites Web de documentation sur Linux . . . . . . . . . . . . . . . 63
4.3 Sites Web de nouvelles sur Linux . . . . . . . . . . . . . . . . . . 63
4.4 Syntaxe de redirection de sortie standard vers une autre commande 68
4.5 Commandes de manipulation de répertoire . . . . . . . . . . . . . 71
4.6 Symboles de substitution . . . . . . . . . . . . . . . . . . . . . . 73
4.7 Symboles de définition des chemins d’accès . . . . . . . . . . . . 75
4.8 Commandes de manipulation de fichiers . . . . . . . . . . . . . . 78
4.9 Commandes de l’éditeur vi . . . . . . . . . . . . . . . . . . . . . 80
4.10 Motifs de recherche utilisables avec vi . . . . . . . . . . . . . . 81
4.11 Commandes de manipulation de fichiers . . . . . . . . . . . . . . 82
4.12 Commandes de recherche de fichiers . . . . . . . . . . . . . . . . 87
4.13 Commandes de manipulation du contenu des fichiers . . . . . . . 88
4.14 Commandes de gestion des processus . . . . . . . . . . . . . . . 91
4.15 Principaux signaux de contrôle de processus . . . . . . . . . . . . 93
4.16 Droit d’accès élémentaires aux fichiers . . . . . . . . . . . . . . . 100
4.17 Droit d’accès élémentaires aux répertoires . . . . . . . . . . . . . 100
6.1 Classes de réseaux IP disponibles pour une utilisation privée . . . 119
139
Index
. (rép), 75, 77 /etc/passwd (fich), 50, 97, 98, 115, 122

.. (rép), 75, 77 /etc/rc.d/ (rép), 51
.bash_history (fich), 50 /etc/rc.d/rc.inet2 (fich), 123
.bash_logout (fich), 50 /etc/resolv.conf (fich), 51
.bash_profile (fich), 96 /etc/shadow (fich), 115
.bashrc (fich), 50, 96, 97 /etc/skel (rép), 116
/ (rép), 49, 56, 75, 111 /etc/skel/ (rép), 51
/bin/ (rép), 49 /etc/sysconfig/ (rép), 51
/boot/ (rép), 54, 128, 131 /etc/updatedb.conf (fich), 88
/boot/System.map (fich), 54 /etc/yp.conf (fich), 124
/cdrom/ (rép), 54 /floppy/ (rép), 54
/dev/ (rép), 53, 54, 57 /home/ (rép), 49, 50, 111
/dev/cdrom (fich), 54 /lib/ (rép), 55
/dev/console (fich), 54 /lib/module/version/ (rép), 133
/dev/fd0 (fich), 57 /lib/modules (rép), 55
/dev/hda (fich), 54 /lib/modules/version/modules.dep (fich),
/dev/hda1 (fich), 54, 57 133
/dev/hdb3 (fich), 57 /mnt/ (rép), 54
/dev/scd0 (fich), 57 /mnt/floppy/ (rép), 42
/dev/usb/scanner0 (fich), 54 /opt/ (rép), 53
/etc/ (rép), 50, 123 /proc/ (rép), 55
/etc/NIS (rép), 123 /proc/filesystems (fich), 57
/etc/X11/ (rép), 51 /root/ (rép), 50
/etc/bashrc (fich), 96 /sbin/ (rép), 49
/etc/cron/ (rép), 51 /tmp/ (rép), 55
/etc/exports (fich), 50 /usr/ (rép), 52, 53
/etc/fstab (fich), 50, 58 /usr/X11R6/ (rép), 52
/etc/group (fich), 50, 98, 116 /usr/bin/ (rép), 52
/etc/hosts (fich), 50, 122 /usr/doc (rép), 63
/etc/init.d/ (rép), 51 /usr/doc/ (rép), 52
/etc/lilo.conf (fich), 50, 131 /usr/doc/HOWTO (rép), 63
/etc/nisdomainname (fich), 123 /usr/etc/ (rép), 52
/etc/opt/ (rép), 51 /usr/games/ (rép), 52
140
INDEX 141
/usr/include/ (rép), 52 bg (cmd), 92, 93

/usr/lib/ (rép), 52 bin/ (rép), 52
/usr/local/ (rép), 52 Binaire, 10
/usr/man/ (rép), 53 bootstrap loader, 110
/usr/sbin (rép), 123 BSD, 19
/usr/sbin/ (rép), 52, 53 BSD (licence), 13
/usr/sbin/makewhatis (cmd), 62 bzImage (fich), 131
/usr/share/ (rép), 53 bzip2 (cmd), 90
/usr/src/ (rép), 53
/usr/src/linux (rép), 130 C, 9
/usr/src/linux/ (rép), 53, 128, 131, 133 C (langage), 15
/usr/src/linux/arch/i386/boot/ (rép), 131 Caldera, 20
/usr/src/linux_version/ (rép), 128 cat (cmd), 49, 83, 88
/var/ (rép), 51, 112, 113 cd (cmd), 49, 71, 75, 76
/var/cache/ (rép), 51 chgrp (cmd), 102
/var/catman (rép), 51 chmod (cmd), 102
/var/lib (rép), 52 chown (cmd), 102
/var/lock (rép), 52 Cluster, 20
/var/locks/ (rép), 51 cmdline (fich), 55
/var/log/ (rép), 51 Code source, 10
/var/opt/ (rép), 51, 53 compilateur, 9
/var/run (rép), 52 Compilation du noyau, 29
/var/spool/ (rép), 51 compress (cmd), 90
/var/yp (rép), 123 Corel, 20
/var/yp/Makefile (fich), 123 Corel-Linux, 23
< (cmd), 67 cp (cmd), 78, 82–84
> (cmd), 66 cpuinfo (fich), 55
» (cmd), 66 crontab (cmd), 94
2> (cmd), 66 crypt (cmd), 46, 115
2» (cmd), 66 CTRL + D (cmd), 69
2, (cmd)67 Debian, 23
depmod -a (cmd), 134
AIX, 15 depmod (cmd), 134
alias (cmd), 95 devfs, 53
APRIL, 11 Distribution, 22
apropos (cmd), 62 domainname <nom domaine> (cmd),
Assembleur, 15 123
AT&T, 12
AT&T’s Bell, 14 Entrée standard, 64
EuroLinux, 21
bash (cmd), 18, 49, 96, 115 exe (fich), 55
142 INDEX
exit (cmd), 69 Java, 9

ext2, 57 jobs (cmd), 91, 92
ext2 (système de fichier), 19
Ext2fs, 19 KDE, 20
ext3, 57 KDE/ (rép), 50
kill (cmd), 91, 93
fat, 57
fdisk (cmd), 49 lib/ (rép), 52
Licence GPL, 12
fg (cmd), 92, 93
LILO (gestionnaire d’amorçage), 111
find (cmd), 86–88
lilo (cmd), 128, 131
Free Software Foundation, 12
lilo.conf (fich), 132
FreeBSD, 16
Lindows OS, 23
Freeware, 12
LinuxExpo, 21
fsck (cmd), 49
ln (cmd), 78, 82, 85, 86
FSF, 11
locate (cmd), 86–88
fstab (fichier de configuration), 58
login, 46
fstab (fich), 58, 59
logout (cmd), 69
gcc (cmd), 18, 127 loopback (interface réseau), 120
Gestionnaires d’amorçage, 111 ls (cmd), 49, 65, 72–75
GNU, 11 lsmod (cmd), 133, 134
GNU General Public License, 12
Mach, 19
GNUstep/ (rép), 50
make (cmd), 123, 124, 127
GPL, 12
make backup (cmd), 130
grep (cmd), 88, 89
make config (cmd), 129
group (fich), 123
make menuconfig (cmd), 130
groups (cmd), 99
make modules_install (cmd), 133
GRUB (gestionnaire d’amorçage), 111
make mrproper (cmd), 130
gzip (cmd), 90
make xconfig (cmd), 129
halt (cmd), 43, 49, 70 Makefile (fich), 123
HP/UX, 15 man (cmd), 61, 62
Hurd, 19 Mandrake, 22
MANPATH (cmd), 62
id (cmd), 99 Master Boot Record, 109
ifconfig (cmd), 119–121 MBD, 109
include/ (rép), 52 meminfo (fich), 55
info (cmd), 62 Microsoft, 14
Informix, 20 Minix, 16, 17
Internet, 19 Mire de connexion, 46
IRIX, 16 mkdir (cmd), 71, 76
iso9660, 57 mkfs (cmd), 49
INDEX 143
modprobe -ar (cmd), 133 Répertoire de base, 69

modprobe (cmd), 133 RAWRITE.EXE (cmd), 108
module (noyau), 29 rd (cmd), 77
Montage (de système de fichier), 42 reboot (cmd), 43, 49, 70, 131
more (cmd), 49, 83, 88 RedHat, 20, 22
mount -a [-t type] (cmd), 58 RedHat Linux, 20
mount (cmd), 56–58 rep (cmd), 88
Mozilla (licence), 13 Ritchie Denis, 14
Multics, 14 rm (cmd), 65, 71, 77, 78, 82, 84
mv (cmd), 78, 82, 84 rmdir (cmd), 71, 77
rmmod (cmd), 133
Netscape, 20
route (cmd), 121
NFS, 57
Noyau monolithique, 29 SCO Unix, 16
nsswitch.conf (fich), 124 Secteur de boot, 110
NTFS, 57 sed (cmd), 89, 90
NTLDR, 111 shadow (fich), 123
Oracle, 20 shutdown (cmd), 43, 70
OS/2 Warp, 20 SlackWare, 23
slocate -c -u (cmd), 88
parted (cmd), 114 slocate (cmd), 88
Partition, 109 SMB, 57
Partition étendue, 110 Solaris, 15
Partition active, 110 Sortie standard, 64
Partition d’échange, 109 Sortie des erreurs, 64
Partition logique, 110 STALLMAN Richard, 11
partitionnement, 109 stat (cmd), 74
passwd (cmd), 100, 101, 124 stat (fich), 55
passwd (fich), 46, 123 status (fich), 55
passwd.byname (fich), 124 stderr, 64
passwd.byuid (fich), 124 stdin, 64
Perl, 9 stdout, 64
ping (cmd), 121 Sun, 20
Point de montage, 42, 56 Suse, 23
Programme de base, 98 Swap (partition), 109
ps (cmd), 91, 93 sync (cmd), 43
pwd (cmd), 71 Systèmes embarqués, 20
Python, 9 System.map (fich), 131
QNX, 15
Table de routage, 121
Rémi CARD, 19 Thompson Ken, 14
144 INDEX
top (cmd), 91, 93

Tux, 17
umask (cmd), 103

umount (cmd), 56
unalias (cmd), 95
Unics, 15
United Linux, 24
updatedb (cmd), 87
uptime (fich), 55
useradd (cmd), 115, 116
userdel (cmd), 116
userdrake (cmd), 116
VA Linux, 20
vfat, 57
vi (cmd), 49, 77, 79, 81, 83, 88
vi : Editeur de texte, 77
vmlinuz (fich), 54, 131
whatis (cmd), 62
Window Manager, 32
XWindow, 32
ypbind (cmd), 124

yppasswd (cmd), 124
yppasswdd -D /etc/NIS (cmd), 123
ypserv (cmd), 123
Bibliographie
[2LI] Toolinux.
[APR] Association pour la promotion et la recherche en informatique libre.
[ATR] Cours linux - installation et administration.
[GIC02] Guide d’installation et de configuration de Linux. Christian CAS-
TEYDE, 2002.
[GPM01] Le guide du pingouin migrateur... ou comment passer de Windows à
Linux. http ://home.alex.tuxfamily.org/guide/migrateur.html, 2001.
[LEA] Léa book.
[MOR88] Pierre MORVAN. Dictionnaire de l’Informatique. Larousse, 1988.
[PAS01] Principes appliqués des systèmes d’exploitation (avec Java). Vuibert
Informatique, 2001.
[RUT] Linux : Rute user’s tutorial and exposition.
145

Linux

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Linux

Uploaded by

Copyright:

Available Formats

Conservatoire National des Arts et Métiers

Centre associé de Strasbourg

3 Arborescence d’un système Linux 47

4.4.2 Naviguer dans les répertoires . . . . . . . . . . . . . . . . 75

5 Installation de Linux 105

6 Mise en réseau 119

7 Compilation du noyau 127

8 Les scripts shell 135

Dans ce chapitre, nous introduirons la notion de logiciel libre, nous aborde-

1.1 Qu’est-ce qu’un logiciel libre ?

1.1.2 L’importance du code source

Le logiciel dans sa forme compréhensible par les programmeurs est appelé

F IG . 1.1 – Processus de création d’une application

1.1.3 Les libertés apportées aux utilisateurs de logiciels libres

1.1.4 La FSF et le projet GNU - La licence GPL

F IG . 1.2 – Logo des applications Open Source

En 1983, Richard M. STALLMAN initie le projet GNU (GNU est un jeu de

F IG . 1.3 – Logo du projet GNU

source de ses programmes, jusqu’alors considéré comme le patrimoine le plus

1.2 Concepts de base de Linux

Pour l’anecdote, la dénomination “Unix” provient de la contraction de “Unics”

IRIX : L’Unix destiné aux stations Silicon Graphics,

1.2.2 Le système Linux

F IG . 1.4 – Tux : La “mascotte” de Linux

dans un réseau et il permet de faire fonctionner un grand nombre d’outils très

1.2.3 Historique du projet Linux

F IG . 1.5 – Linus TORVLADS

Bonjour à tous les utilisateurs de minix.

Je développe un système d’exploitation (gratuit) (c’est juste un

Dépendant au départ du système Minix, Linux devient autonome le 5 octobre

Lien avec le projet GNU

1991-1994 : un développement original

1995 : une année charnière

1996 : l’année du décollage

1997 : une reconnaissance "professionnelle"

1998 : Linux aux portes du grand public

– De grandes sociétés commencent à déployer Linux sur une partie de leur

1999 : la reconnaissance du marché des entreprises et des marchés financiers

1.3 Les distributions de Linux

complexité de ces opérations est telle qu’elle réservait l’installation de Linux à

1.3.2 Les distributions

en terme de nombre de logiciels disponibles, elle a connu récemment des

Les distributions actuelles éprouvent encore quelques difficultés pour optimi-

1.3.3 Standardisation des distributions

l’actuel leader des distributions Linux : RedHat.

Dans ce chapitre, nous aborderons les différentes fonctionnalités d’un système

2.1 Fonctionnalités du noyau

2.1.2 Découpage du système

même si elle prouve la grande souplesse du système Linux.

2.1.3 Le noyau Linux

Contour fonctionnel du noyau

F IG . 2.1 – Prise en charge de fonctions par un noyau monolythique

Fonction B Noyau du système

F IG . 2.2 – Prise en charge de fonctions par un noyau modulaire

2.1.4 Le couple GNU - Linux

F IG . 2.3 – Architecture d’un système GNU/Linux

C’est le gestionnaire de fenêtres qui prend en charge la gestion des déco-

F IG . 2.4 – Exemple d’interface utilisateur graphique utilisant WindowMaker

F IG . 2.5 – Exemple d’interface utilisateur graphique utilisant KDE

F IG . 2.6 – Structure du système GNU/Linux

2.1.5 Notion de processus

lpd crond getty 1 getty 2

F IG . 2.7 – Exemple d’arborescence de processus

2.1.6 Parallèle avec Windows