Notes Cours Unix Bash

Système UNIX et programmation sous bash
notes de cours
Alain Jacquemard
Professeur des Universités
IMB UMR 5584 CNRS
DIJON
FRANCE
Janvier 2009
2
Chapitre 1
Commandes et
environnement du shell bash
1.1 Redirections des entrées-sorties

Entrées-sorties de commandes
Un des grands intérêts d’Unix est de pouvoir composer des commandes, sans
avoir à les modifier.
Il est nécessaire pour cela d’avoir des mécanismes permettant de rediriger le

flux de sortie d’une première commande sur l’entrée d’une deuxième commande.
Sortie
standard
Entrée
COMMANDE
standard Erreur
standard
La sortie erreur standard

Lorsqu’une commande Unix détecte une anomalie
(ce concept varie d’une commande à l’autre),
elle envoie généralement un message sur
la sortie d’erreur standard.
En mode interactif, ce message est envoyé à l’écran.
3
4 CHAPITRE 1. COMMANDES ET ENVIRONNEMENT DU SHELL BASH
Ex :
supposons que le répertoire Rep ne contienne pas de fichier NomFic. Dans ce

cas :
$ ls NomFic
NomFic not found
Entrée et sortie standards
Sortie
standard
Entrée
COMMANDE
standard Erreur
standard
Généralement, les commandes lisent l’entrée standard et/ou écrivent sur la

sortie standard.
Normalement, l’entrée standard est le clavier et la sortie standard est l’écran.
Il est possible de rediriger ces entrée et sortie standards vers des fichiers.
Redirection de la sortie standard
FicSortie
Entrée
COMMANDE
standard Erreur
standard
Pour que le résultat d’une commande soit rangé dans un fichier FicSortie
au lieu d’apparaı̂tre à l’écran, il faut utiliser la syntaxe :
NomCommande [-Options] [arguments] > FicSortie

1.1. REDIRECTIONS DES ENTRÉES-SORTIES 5
Ex :
ls -l * > Fic
(enregistre les noms de fichiers à un moment donné)
date > Fic

(enregistre la date/heure)
who > Fic

(enregistre les utilisateurs connectés à un moment donné)
Redirection avec concaténation

Attention, si le fichier de redirection FicSortie existe déjà, son contenu est
écrasé avec la redirection > .
Si on veut que ce contenu soit préservé et y ajouter des résultats d’une

commande, il faut utiliser la
redirection avec concaténation >> .
NomCommande [-Options] [argts] >> FicSortie
Ex :
date > Fic

(on enregistre la date dans un (nouveau) fichier Fic)
ls -l * >> Fic
(on enregistre les fichiers présents à un moment donné)
On enregistre les mêmes informations automatiquement une heure plus tard :
echo "date >> Fic" | at now +1 hour
echo "ls -l * >> Fic" | at now +1 hour

Affichage des sorties et redirection

Ex :
supposons que le répertoire Rep contienne un fichier NomFic1 et ne contienne
pas de fichier NomFic2.
Dans ce cas:
$ ls NomFic1 NomFic2
NomFic2 not found
NomFic1
La première ligne correspond à l’affichage de l’erreur standard

et la deuxième ligne correspond à la sortie standard de ls.
Mise en évidence de l’erreur standard

La première ligne d’affichage correspond à l’affichage de l’erreur standard et la
deuxième ligne correspond à la sortie standard de ls.
Preuve :
Redirigeons la sortie standard vers un fichier Resultat
$ ls NomFic1 NomFic2 > Resultat

NomFic2 not found
Seule la première ligne correspondant à l’affichage de l’erreur standard sub-

siste.
D’autre part, on peut vérifier ce que contient Resultat :
$ cat Resultat
NomFic1
Redirection de l’entrée standard
Sortie
standard
FicEntrée COMMANDE
Erreur
standard
Au lieu de fournir des données en les entrant au clavier, ces données peuvent
être lues dans un fichier FicEntrée avec la syntaxe :
NomCommande [-Options] [arguments] < FicEntrée
Ex :
Soit un fichier Fic composé de :
aa bb ccc
ddd eee
pour mettre tout en majuscules on peut effectuer
tr ’[a-z]’ ’[A-Z]’ < Fic
ou
tr ’[[:lower:]]’ ’[[:upper:]]’ < Fic
Composition de commandes
Composer deux commandes, c’est faire opérer une commande sur le résultat
fourni par une autre.
On pourrait :
• rediriger la sortie de la première commande vers un fichier FicInter,
• puis rediriger l’entrée de la deuxième commande afin qu’elle lise ce fichier

FicInter,
• puis supprimer FicInter.
Tubes
Le mécanisme de tube (pipe) permet de :
prendre la sortie standard d’une première commande
et de la rediriger sur l’entrée standard d’une deuxième commande.
NomCommande1 [-Options] [arguments] | NomCommande2 [-Options] [arguments]

Sortie
standard
Entrée
COMMANDE 1 COMMANDE 2
standard Erreur Erreur
standard standard
Exemples
ls /etc | more
ls -a | head
netstat -an | grep ’LISTEN’

(ports de communication en écoute)
tar -cvf - . | gzip > /tmp/Rep.tar.gz

(conversion de l’arborescence du répertoire courant en un fichier, puis compression)
l’opération inverse étant
gunzip /tmp/Rep.tar.gz | tar -xvf
Aspect chronologique
Les commandes liées par un tube sont concurrentes :
• elles s’exécutent simultanément,
• et sont synchronisées par le système.
Ceci veut dire que la deuxième commande est lancée en même temps que la
première,
la deuxième commande est alors bloquée jusqu’à ce que la première ait fini
le remplissage du tube.
Eventuellement la première commande peut être temporairement bloquée si

le tube est plein.
Généralisation
On peut écrire une cascade de commandes :
Com1 | Com2 | Com3 | ....... | ComN
Cela ne présente de l’intérêt que si les N-1 premières écrivent sur leur sortie
et les N-1 dernières lisent sur leur entrée.
Une commande qui lit sur l’entrée standard et écrit sur la sortie standard
est appelée un filtre.
Par exemple :
cat, wc, sort, grep sont des filtres,

echo, ls n’en sont pas.
Enchaı̂nement de commandes
On peut enchaı̂ner des commandes, qui vont se réaliser de manière indépendante.
On utilise la notation ; qui est un séparateur de commandes.
Ex :
$ date ; echo "Bonjour, je suis :" ; who am i
Wed Oct 1 14:26:02 MET 2004
Bonjour, je suis :
johndoe ttyp1 Oct 1 14:26
Parenthèsage et enchaı̂nement
Ne pas confondre :
$ ( echo debut; date; echo "fin" ) > FicP
qui n’affiche rien et qui va construire le fichier FicP de contenu
debut
Wed Oct 1 14:26:02 MET 2004
fin
et
$ echo debut ; date; echo "fin" > FicSP
qui va afficher
debut
Wed Oct 1 14:26:02 MET 2004
et construire le fichier FicSP de contenu
fin
Redirection de l’erreur standard

On peut souhaiter rediriger la sortie d’erreur standard vers un fichier plutôt que
vers l’écran (par exemple pour garder la trace d’une erreur lors du traitement
d’un nombre important de commandes).
La syntaxe est :
NomCommande 2> FicErreur
Si on veut éliminer les messages d’erreur, on peut les rediriger vers le fichier
’trou noir’ /dev/null
Ex :
$ ls NomFic1 NomFic2 2> /dev/null

NomFic1
Redirections simultanées
On peut décider de rediriger à la fois la sortie d’erreur et la sortie standard,

chacune vers un fichier particulier :
NomCommande > FicSortie 2> FicErreur
ou
NomCommande 1> FicSortie 2> FicErreur
1.2 Code de retour

Valeur de retour d’une commande
Toute commande Unix retourne en fin d’exécution une valeur :
• 0 si tout s’est déroulé normalement
• une valeur non nulle en cas d’erreur
Une commande peut donc être assimilée à un prédicat :
• elle vaut VRAI (0) si tout c’est bien passé
• elle vaut FAUX ( 6= 0) en cas d’erreur.
Le code de retour de la dernière commande réalisée est la valeur $?

1.2. CODE DE RETOUR 11
Composition conditionnelle Et Alors

Supposons qu’on veuille enchaı̂ner deux commandes Comm1 et Comm2, mais que
Comm2 ne s’exécute convenablement que si Comm1 s’est déroulée normalement.
On emploie la syntaxe :
Comm1 && Comm2
La commande Comm2 ne sera appelée que si Comm1 a renvoyé une valeur de

retour nulle.
Exemple
Afficher, puis Effacer tous les fichiers temporaires :
$ ls -lart /tmp/* && rm -i /tmp/*

$ ls -lart /tmp/.* && rm -i /tmp/.*
Composition conditionnelle Ou Sinon

Supposons qu’on ne veuille exécuter Comm2 que si Comm1 ne s’est pas déroulée
normalement.
On emploie la syntaxe :
Comm1 || Comm2
La commande Comm2 ne sera appelée que si Comm1 a renvoyé une valeur de

retour non nulle.
Exemple
Recopie d’un fichier sur un autre à condition que l’identificateur n’existe pas
déjà :
$ ls -la NvFicPw || cp /etc/passwd NvFicPw

ls : 0653-341 Le fichier NvFicPw n’existe pas.
$
Le message d’erreur provient de la première commande, mais la copie a

effectivement lieu.
Lancement en arrière-plan
Si on veut exécuter une commande sans attendre la fin de son exécution pour
lancer d’autres commandes, on peut la lancer en arrière-plan (background).
On emploie la syntaxe : Comm1 &
Pour afficher les processus en cours on utilise la commande ps qui donnera

le numéro du processus PID.
Pour arrêter un processus :

kill -KILL PID ou kill -9 PID
Un défaut à signaler : les sorties des processus d’arrière-plan apparaissent à

l’écran
Exemple
$ date > FicRésultats
$ maple < FicEntrée >> FicRésultats & [1]
12812
$ xclock & [2]
12827
$
Et si le processus maple doit être stoppé :
$ kill -KILL 12812

$ [1] + Terminé maple &
1.3 Variables d’un shell

Environnement
C’est un ensemble de variables comme, par exemple :
PATH, EDITOR, LOGNAME,
MAIL, SHELL, HOME,
TERM, PS1, PS2
dont les valeurs sont ensuite utilisées par le shell.
La commande env permet de fournir toutes les informations sur l’environnement.

1.3. VARIABLES D’UN SHELL 13
Valeur d’une variable

D’une manière générale si NomVar est un identificateur de variable, sa valeur
actuelle est désignée par $NomVar
On peut donc accéder à la valeur actuelle d’une variable d’environnement

NomVar en envoyant à l’écran sa valeur via la commande echo
$ echo $NomVar
valeurDeNomVar
$
On distinguera bien le $ de l’invite et le $ d’accès à la valeur de l’identificateur
Exemples
$ echo $LOGNAME
alceste
$ echo $HOME
/home/users/etud/iq1/alceste
$ echo $PATH
/usr/bin:/usr/openwin/bin:/usr/local/bin:
/users/etud/iq1/alceste/bin
$ echo $SHELL
/bin/bash
$ echo $PS1
$
$ echo $EDITOR
vi
$ echo $TERM
xterm
Assignation de valeur
On peut assigner une valeur à une variable NomVar par :
NomVar=Valeur
Attention : pas d’espaces de part et d’autre de =
On peut libérer une variable NomVar de sa valeur par :
unset Nomvar
Ex :
$ PS1=’\u\<\$’
alceste<$
permet de changer l’invite système.
Chapitre 2
Langage de commande bash
2.1 Initiation
Les scripts
Un script est un fichier texte qui va comporter des instructions élémentaires
interprétables par l’interpréteur de commande (shell).
Les scripts
• sont plus avantageux que la frappe successive de commandes au clavier,

par exemple :
– lorsqu’on a beaucoup de commandes à enchaı̂ner

– lorsqu’on applique une même action à une grande quantité d’objets
(fichiers, répertoires, utilisateurs,...)
• sont indispensables lorsqu’on veut effectuer un traitement automatique

(démarrer un système, initialiser un environnement, paramétrer un pare-
feu, etc...).
Intérêt des scripts

Ex :
L’ingénieur système veut supprimer les fichiers .rhosts des utilisateurs Ut1,
Ut2, Ut3, Ut4.
Il peut effectuer les 4 commandes :
$ rm -f /home/Ut1/.rhosts
15
16 CHAPITRE 2. LANGAGE DE COMMANDE BASH
L’opérateur écrit 4 fois la même formulation, seule la chaı̂ne correspondant

au nom de l’utilisateur change.
On voudrait pouvoir écrire

$ rm -f /home/X/.rhosts
et faire varier X.
Introduction d’un paramètre

On va enregistrer les commandes communes à l’action demandée sous la forme
d’un fichier script avec l’introduction d’un paramètre représentant l’utilisateur :
#!/bin/bash
# enleverRhosts
# usage : enleverRhosts NomUtilisateur
rm -f /home/$1/.rhosts
Plus tard, on exécutera 4 fois le script, en changeant à chaque fois la valeur

du paramètre :
$ enleverRhosts Ut1 ; enleverRhosts Ut2
$ enleverRhosts Ut3 ; enleverRhosts Ut4
Traitement d’une liste de paramètres

Le stade ultime est de faire travailler le script sur une liste de valeurs de
paramètres correspondant à la liste des utilisateurs :
#!/bin/bash
# enleverRhostsListe
# usage : enleverRhostsListe ListeNoms
for Util in $*
do
rm -f /home/$Util/.rhosts
done
et ensuite exécuter le script sur la liste des utilisateurs :
$ enleverRhostsListe Ut1 Ut2 Ut3 Ut4
Mode exécutable d’un script

Pour pouvoir exécuter un script NomScript, il faut d’abord donner une propriété
spéciale à ce simple fichier texte.
On dit qu’on lui donne le mode exécutable

2.1. INITIATION 17
Cela se réalise en pratique par la commande
$ chmod u+x NomScript
Ensuite, l’utilisateur peut exécuter ce script en tapant seulement (avec éventuellement

des valeurs de paramètres)
$ NomScript ou bien $ ./NomScript
Un script à deux paramètres

Soit le fichier changerExt :
#!/bin/bash
# usage : changerExt Fichier Ext
if ! [ -a $1 ]
then echo "le fichier $1 n’existe pas !!!" ; exit 1
fi
NouveauNom=‘echo $1 | cut -d’.’ -f1‘.$2
mv $1 $NouveauNom
Premières règles d’écriture

La première ligne indique dans quel shell le script doit être interprété :
#!/bin/bash
Les commentaires (chaı̂nes non interprétées) commencent par #
# ce script effectue....
La fin de l’exécution a lieu
• soit lorsque la dernière ligne du script est interprétée et exécutée
• soit lorsque la commande exit est rencontrée
Terminaison impérative
La fin d’exécution par exit permet de transmettre en même temps un code de
retour.
exit 0 renvoie le code 0

(comme dans le cas d’une sortie par la dernière commande du script in-
terprétée avec succès)
exit N avec N entier non nul renvoie le code d’erreur N
Celui qui écrit le script choisit les codes de retour.
Messages de sortie
On peut utiliser echo (avec option e pour les traitements spéciaux de lignes)
Ex :
#!/bin/bash
echo Bonjour
echo -e "\nSur 3 lignes\n"
echo -e "Sur une seule\c"
echo "ligne"
echo -e "\aErreur\a"
On peut utiliser aussi print avec une syntaxe différente (voir man).
Paramètres d’un script
Ce script est supposé opérer sur deux arguments : un fichier et une extension
Il sera lancé avec la syntaxe : changerExt LeFic Ext
Au lancement,
une variable de nom 1 sera instanciée à LeFic
et
une variable de nom 2 sera instanciée à Ext.
Lors de l’exécution du script, la valeur $1 coincidera avec LeFic et la valeur
$2 coincidera avec Ext.
On peut aussi définir des variables locales au script avec des identificateurs
choisis par l’utilisateur.
Parenthèsage des commandes

On peut regrouper des commandes (séparées par des ; )
2.1. INITIATION 19
• entre parenthèses ( ) : la suite est exécutée dans un sous-shell du shell

courant. Attention, les affectations de variable et les changements de
répertoires ne seront pas retransmis au shell courant.
• entre accolades { } : la suite est exécutée dans le shell courant.

L’accolade { doit être suivie d’un espace, et
l’accolade } doit être précédée d’un ; ou se trouver en début de ligne.
Notation des paramètres
• sont désignées par $1,$2,...,$9 les valeurs des neuf premiers arguments
de la commande correspondant au script
• la valeur $0 correspond au nom du script
• la valeur $# correspond au nombre d’arguments
• la valeur $* correspond à la liste des arguments
• la valeur $? correspond au code de retour de la dernière commande
• la valeur $$ correspond au numéro du processus courant
Expressions conditionnelles
Les expressions conditionnelles sont les éléments de base des structures alterna-
tives.
La commande d’évaluation d’une expression conditionnelle peut prendre

l’une des deux formes :
• test ExprTest : forme obsolète
• [ ExprTest ] : dans cette deuxième forme les espaces sont indispens-

ables.
Lorsque cette commande est interprétée elle donne un code de retour nul ou
non nul.
On dit que cette commande prend la valeur VRAI si le code de retour est
nul.
Exemple
test -a Fic
ou bien
[ -a Fic ]
est VRAI si et seulement si le fichier Fic existe.
On pourra ensuite créer une alternative avec une syntaxe du type :
if [ -a Fic ] ; then Comm1 ; else Comm2 ; fi
Expressions conditionnelles sur fichiers

Tests de type de fichier :
ExprTest Vraie si
-f Fic Fic désigne un fichier régulier
-d Rep Rep désigne un répertoire
-s Fic Fic existe et est de taille non nulle
Fic1 -nt Fic2 Fic1 est plus récent que Fic2
Fic1 -ot Fic2 Fic1 est plus ancien que Fic2
Expressions conditionnelles sur entiers

Tests numériques sur des nombres entiers :
ExprTest Vraie si
Nbre1 -eq Nbre2 égalité numérique
Nbre1 -ne Nbre2 inégalité numérique
Nbre1 -gt Nbre2 plus grand numérique
Nbre1 -ge Nbre2 plus grand ou égal numérique
Nbre1 -lt Nbre2 plus petit numérique
Nbre1 -le Nbre2 plus petit ou égal numérique
Expressions conditionnelles sur chaı̂nes

Tests élémentaires sur des chaı̂nes :
ExprTest Vraie si
-n Cha^
ıne Cha^ ıne de longueur non nulle
-z Cha^
ıne Cha^ ıne de longueur nulle
Cha^
ıne = Motif Cha^ ıne satisfait le Motif shell
Cha^
ıne != Motif inégalité
2.1. INITIATION 21
Expressions conditionnelles sur booléens
Tests sur booléens :
ExprTest Vraie si
! Bool Bool faux (négation)
Bool1 -a Bool2 conjonction logique (et)
Bool1 -o Bool2 disjonction logique (ou)
Attention, ne pas confondre avec les connecteurs d’expressions condition-

nelles && et ||
Pièges des tests

Bien distinguer les valeurs numériques des valeurs chaı̂nes, et leur appliquer la
bonne syntaxe.
Par exemple :
[ "01" -eq "1" ] retourne VRAI
[ "01" = "1" ] retourne FAUX
Moyen de le vérifier :
$ [ "01" -eq "1" ] ; echo $?

0
$ [ "01" = "1" ] ; echo $?
1
Considérons l’exemple suivant :
$ Var1="dijon" ; Var2=""
$ [ $Var1 != $Var2 ]
/bin/bash : test : argument expected
La commande test évalue d’abord chacun de ses arguments. Or ici, la

valeur $Var2 est la chaı̂ne vide, qui n’est pas acceptée comme argument valide
par test.
Ceci peut se produire à chaque fois qu’un des arguments de test a comme
valeur la chaı̂ne vide, ou n’a pas de valeur (si par exemple une variable Var n’est
pas initialisée).
$ Var1="dijon" ; Var2=""
$ [ $Var1 != $Var2 ]
/bin/bash : test : argument expected
Si on ne peut exclure l’éventualité d’une valeur chaı̂ne vide, le remède con-

siste à encapsuler par des délimiteurs doublequote ( " ) les membres d’expressions
qui peuvent donner une valeur de chaı̂ne vide.
On peut modifier l’exemple ci-dessus ainsi :
$ [ $Var1 != "$Var2" ] ; echo $?

0
Exemples
$ test ! "01" -eq "1" ; echo $?

1
$ [ ! "01" -eq "1" ] ; echo $?

1
$ ! test "01" -eq "1" ; echo $?

1
$ ! [ "01" -eq "1" ] ; echo $?

1
Combinaisons de conditions
Il y a deux manières de procéder :
• au niveau des expressions conditionnelles elles-mêmes avec les notations

-a -o !
• au niveau des évaluations d’expressions, avec la syntaxe commune aux

commandes générales (parenthèses, && ||).
2.1. INITIATION 23
Combinaison Interprétation
! CommTest négation
CommTest1 && CommTest2 conjonction logique (et)
CommTest1 || CommTest2 disjonction logique (ou)
Exemples
$ [ 0 -eq 0 -o 0 -eq 1 ] ; echo $?

0
$ ! [ 0 -eq 0 -o 0 -eq 1 ] ; echo $?
1
$ ! [ 0 -eq 0 ] || [ 0 -eq 1 ] ; echo $?
1
Structure de contrôle conditionnelle

Syntaxe :
if CommPred ; then Instr1 ; else Instr2 ; fi
La partie else est facultative.
On peut remplacer les ; par des sauts de ligne :
if CommPred
then Instr1
else Instr2
fi
Sémantique :
CommPred est évaluée. Si son code de retour est nul, alors Instr1 est évaluée,
sinon Instr2 l’est.
Structure de contrôle conditionnelle

Exemple de syntaxe complète :
if CommPred1
then Instr1
elif CommPred2
then Instr2
elif CommPred3
then Instr3
else InstrF
fi
CommPred1 est évaluée. Si son code de retour est nul, alors Instr1 est
évaluée, sinon on est ramené à une forme identique, mais de longueur réduite.
Structure de contrôle par aiguillage

Syntaxe :
case Cha^ıne in
Motif1) Instr1 ;;
Motif2) Instr2 ;;
Motif3) Instr3 ;;
...
...
MotifN) InstrN ;;
esac
Les motifs sont très souvent des entiers, et généralement le dernier motif
MotifN est le motif par défaut *
Lecture de mots Unix au clavier

La commande read permet d’entrer des chaı̂nes.
Syntaxe :
read Var1 Var2 ... VarN
Un mot Unix est une chaı̂ne ne contenant ni blanc, ni tabulation, ni saut de
ligne ou retour chariot.
La commande sous la forme ci-dessus lit successivement N mots et les affecte
aux variables Var1, Var2, ...
Ex :
#!/bin/bash
echo -e "Donnez votre nom et votre prénom\c"
echo -e "s’il vous pla^
ıt :\c"
read Nom Prenom
echo Bonjour $Prenom $Nom
Exemple
La structure d’aiguillage est utile pour des menus :
#!/bin/bash
echo "quel éditeur souhaitez-vous ?"
echo -e "1->emacs,2->xedit,3->vi,\c"
echo "autre->ed"
read Choix
case $Choix in
1) EDITOR=emacs ;;
2) EDITOR=xedit ;;
3) EDITOR=vi ;;
2.1. INITIATION 25
*) EDITOR=ed ;;
esac
echo $EDITOR "est votre éditeur"
Structure de contrôle itérative
Itérative explicitement bornée :
for Var in Mot1 Mot2 ... MotN

do Instr
done
Remarque :
une forme plus courte omet in ... quand la liste des Mots coı̈ncide avec
$* (liste des arguments de la commande associée au script).
Exemple
Supposons que Rep ne contienne que des fichiers texte avec extension .txt .
Pour voir les dix premières lignes de chaque fichier de Rep :
for NomFic in Rep/*.txt

do head $NomFic
done
Remarque :
ceci ne fonctionne que si le mécanisme d’expansion (remplacement de *) n’est pas
désactivé.
Structure de contrôle itérative

Itératives non explicitement bornées :
• Itérative de type tant que
while CommPred
do Instr
done
(Instr est interprétée tant que CommPred est vraie)

• Itérative de type jusqu’à ce que
until CommPred
do Instr
done
(Instr est interprétée jusqu’à ce que CommPred soit vraie)
Ejection d’itérative
• break
éjecte de la structure itérative dans laquelle elle figure
• break Nbre
éjecte de Nbre structures itératives successivement imbriquées.
Cette commande ne sera employée qu’en cas d’absolue nécessité.
2.2 Approfondissement
Métacaractères
Les métacaractères (ou caractères spéciaux) interviennent dans les mécanismes
suivants :
• commentaires dans un fichier interprété par le shell : #
• protection (ou déspécialisation) \ : placé devant un caractère spécial, il

lui enlève son interprétation particulière
• séparation de mots : blancs
• redirections : > >> <
• lancements de commandes : ; (séquentiel) | (concurrent) & (arrière-

plan) ; | &
• substitution à une variable de sa valeur : $
• expansion des noms de fichiers : * ? [ [! ] -
• délimitation de chaı̂nes :
’ (quote) " (doublequote) ‘ (antiquote)
• historique
• complétion de noms de fichiers.

2.2. APPROFONDISSEMENT 27
Expansion des noms de fichiers

Ce mécanisme permet d’engendrer une liste de noms de fichiers à l’aide d’une
simple notation.
Il peut être désactivé (bash -f).
Ex :
*.c est une notation génératrice de la liste de tous les fichiers du type
ıne peut être vide, mais ne comporte pas de \ et ne peut
ıne.c où Cha^
Cha^
commencer par .
Ainsi ls *.c se déroule de la manière suivante :
1. la liste de tous les fichiers du type *.c est constituée
2. la commande ls est appliquée à cette liste des fichiers.
Règles du mécanisme d’expansion

métacaractère signification
? un caractère quelconque
* une chaı̂ne quelconque (vide permis)
[ début de définition d’un ensemble
[! début de complémentaire de déf. d’un ens.
] fin de définition d’un ensemble
- marque d’intervalle dans un ensemble
Exceptions :
• les . en début de mot ou immédiatement derrière un /
• les /
Attention : pas d’espace entre [, !, et ce qui suit.
Délimiteurs de chaı̂nes
Ils sont de trois types :
• caractère ’ (quote)
• caractère " (doublequote)
• caractère ‘ (antiquote)
Délimiteur quote
caractère ’ (quote) :
tous les caractères entre deux quotes sont protégés

(s’ils ont un caractère spécial, ils le perdent).
Aucune substitution d’une valeur à un nom de variable ne s’effectuera lors

de l’évaluation de la chaı̂ne entre quotes.
Ex :
$ Var="john"
$ echo $Var
john
$ echo ’$Var’
$Var
Délimiteur doublequote
caractère " (doublequote) :
à l’intérieur d’une chaı̂ne avec doublequotes les caractères $ \ ’ ‘ restent

spéciaux.
On peut utiliser le caractère " dans une telle chaı̂ne, mais il faut le protéger
en l’écrivant \" .
En particulier la substitution des variables (avec $) se réalise, et l’évaluation

des commandes (avec ‘) aussi.
$ Var="john"
$ echo $Var
john
$ echo "$Var"
john
Délimiteur antiquote
caractère ‘ (antiquote) :
toute chaı̂ne délimitée par antiquotes est interprétée comme une commande
opérant sur des arguments :
• les valeurs des arguments sont évalués,
• la commande est réalisée,
• et le résultat de la commande est substitué à la chaı̂ne entre antiquotes.
Exemples
A la chaı̂ne ‘date‘ sera substituée la chaı̂ne
Lun Oct 3 08:42:35 MET 2004
$ echo date
date
$ echo "date"
date
$ echo ‘date‘
Lun Oct 3 08:42:35 MET 2004
Attention, l’évaluation est récursive : le résultat de echo date est la chaı̂ne

date, qui est alors évaluée.
$ ‘echo date‘
Lun Oct 3 08:42:35 MET 2004
Gestion du caractère espace
Rappelons que pour toute commande, les arguments doivent être séparés
par des espaces.
Les chaı̂nes comportant des espaces doivent donc être délimitées par quotes
’ ou doublequotes " .
Calculs
Pour évaluer une expression arithmétique, il est nécessaire de faire appel à la
commande expr
Syntaxe :
expr [arguments]
Ex :
$ expr 1 + 2
3
$ expr 2 + 3 \* 5
17
$ expr $ 2 + 3 $ \* 5
25
Arithmétique entière
Syntaxe Opération
Nbre1 + Nbre2 somme
Nbre1 - Nbre2 différence
Nbre1 \* Nbre2 produit
Nbre1 / Nbre2 quotient
Nbre1 % Nbre2 reste
Lorsqu’un des opérandes n’est pas numérique, un message d’erreur est af-
fiché.
Les expressions peuvent être combinées avec les parenthèses $ et $ .
Incrément, décrément
Une variable NomVar doit être
• incrémentée par :
NomVar=‘expr $NomVar + 1‘
• décrémentée par :
NomVar=‘expr $NomVar - 1‘
Décalage d’arguments
La commande
shift
permet de substituer à la liste des arguments d’un script la liste des argu-
ments privée de son premier élément.
Généralisation :
shift Nbre
itère Nbre fois la commande shift.

Exemple
#!/bin/bash
# testerShift
echo "liste des argts :" $*
shift
echo "après un shift :" $*
shift
echo "après deux shifts :" $*
echo ’$1’ "est maintenant :" $1
Exemple, suite
#!/bin/bash
# testerShift
echo "liste des argts :" $*
shift
echo "après un shift :" $*
shift
echo "après deux shifts :" $*
echo ’$1’ "est maintenant :" $1
Exécutons :
$ testerShift a b c
liste des argts : a b c
après un shift : b c
après deux shifts : c
$1 est maintenant : c
Fonctions
On a vu qu’on pouvait regrouper des séquences de commandes avec des accolades
(de manière à exécuter des commandes dans le contexte courant).
On peut identifier une telle séquence par un nom NomFonc :

• function NomFonc { Comm1 ; ... ; }
• NomFonc() { Comm1 ; ... ; }
La commande return Nbre à l’intérieur d’une définition de fonction permet

de retourner l’entier Nbre
Les fonctions utilisent aussi les notations $1, $2, ... pour leurs argu-
ments.
Exemple
On souhaite écrire un script afficher2P2DArgts qui, lorsqu’on lui présente une
liste d’arguments, affiche les deux premiers et les deux derniers.
On décide de créer une fonction funcAfficheDeuxArgts qui effectue le tra-

vail suivant :
• elle affiche ses deux paramètres
• elle affiche un message dans lequel une chaı̂ne est modifiable (ce sera soit
”premiers”, soit ”derniers” dans le cas qui nous concerne)
cette chaı̂ne modifiable sera placée en troisième position dans la liste des
arguments
Exemple
#!/bin/bash
# afficher2P2DArgts
function funcAfficheDeuxArgts
{
echo -e "les deux $3 argts sont \c"
echo $1 "et" $2
}
funcAfficheDeuxArgts $1 $2 "premiers"
# accès aux 2 derniers argts

NbreDeShifts=‘expr $# - 2‘
shift $NbreDeShifts
# $1 et $2 pointent sur les 2 derniers argts
funcAfficheDeuxArgts $1 $2 "derniers"
Exemple, suite
#!/bin/bash
# afficher2P2DArgts
function funcAfficheDeuxArgts
{
echo -e "les deux $3 argts sont \c"
echo $1 "et" $2
}
funcAfficheDeuxArgts $1 $2 "premiers"
# accès aux 2 derniers argts
NbreDeShifts=‘expr $# - 2‘
shift $NbreDeShifts
# $1 et $2 pointent sur les 2 derniers argts
funcAfficheDeuxArgts $1 $2 "derniers"
Exécutons le script Afficher2P2DArgts :
$ Afficher2P2DArgts a b c d e f g h
les deux premiers argts sont a et b
les deux derniers argts sont g et h
Variables de position
Les paramètres d’une commande correspondant à un script sont aussi appelés
variables de position.
On peut obtenir les valeurs des paramètres par :
${Nbre} où Nbre est strictement positif.
Les accolades ne sont pas nécessaires pour les neuf premiers arguments.
Rappel :
$0 référence le nom de la commande
Autres notations liées aux paramètres

Pour une commande correspondant à un script :
• la valeur $* correspond à la liste des arguments
• la valeur $@ correspond à la liste des arguments

(pas de différence avec le premier si ce n’est pas entre doublequotes)
• la valeur $$ correspond au numéro de processus courant
• la valeur $! correspond au numéro du plus récent processus exécuté en

arrière-plan.
Substitutions conditionnelles :-
On peut substituer une valeur à un identificateur de variable de manière condi-
tionnelle :
• ${Var:-AutreCha^
ıne}
si Var est définie et n’est pas la chaı̂ne vide, l’expression ci-dessus vaut
$Var, sinon elle vaut AutreCha^ ıne
Ex :
positionner automatiquement la variable TERM en cas de connexion depuis
un terminal non graphique :
$ TERM=‘/usr/bin/termdef‘ ; echo $TERM
$ TERM=${TERM:-vt100} ; echo $TERM

vt100
Autres substitutions conditionnelles

• ${Var:=AutreCha^
ıne}
si Var n’est pas définie ou est la chaı̂ne vide, l’expression vaut AutreCha^
ıne,
et Var prendra aussi AutreCha^ ıne comme valeur.
• ${Var:+AutreCha^
ıne}
$Var, sinon AutreCha^ ıne est imprimé par le shell, qui se termine (sauf s’il
est interactif).
• ${Var:?AutreCha^
ıne}
AutreCha^ ıne, sinon elle vaut la chaı̂ne vide.
Expressions conditionnelles sur chaı̂nes

Lorsqu’on a à effectuer des tests lexicographiques sur des chaı̂nes, on doit utiliser
une syntaxe particulière d’évaluation d’expression conditionnelle
Cette syntaxe utilise des crochets doubles :
[[ ExprTest ]]
ExprTest Expression conditionnelle Vraie si

Cha^
ıne1 > Cha^
ıne2 supérieur lexicographique
Cha^
ıne1 < Cha^
ıne2 inférieur lexicographique
Exemples
$ [[ "alain" > "albert" ]] ; echo $?
0
$ [[ "albin" > "albert" ]] ; echo $?
1
Syntaxes alternatives pour calculs

Au lieu d’utiliser expr, il est possible d’utiliser une syntaxe du type C avec
double parenthèses, ou bien avec la commande let :
Ex : formulation alternative de l’incrément/décrément
$ Var=10 ; ((Var++)) ; echo $Var

11
$ ((Var--)) ; echo $Var
10
On peut utiliser aussi la commande let
$ Var=10 ; let Var++ ; echo $Var

11
Syntaxes alternatives pour calculs
Ex : pré-incrément et post-incrément
$ X=10 ; let Y=2*++X ; echo $X ; echo $Y

11
22
$ X=10 ; let Y=2*X++ ; echo $X ; echo $Y

11
20
$ X=1 ; ((Y=-X++)) ; echo $X ; echo $Y

2
-1
Classes de caractères
Les intervalles de caractères de type a-z ne fonctionnent pas de même manière
sur toutes les configurations.
Pour une meilleure portabilité des scripts, il vaut toujours mieux utiliser les
notations de classes.
La notation [[:LaClasse:]] s’identifie à un caractère de la classe désignée.
• [:digit:] chiffres décimaux, équivaut à 0-9
• [:xdigit:] chiffres hexadécimaux
• [:cntrl:] caractères de contrôle

• [:print:] caractères imprimables
• [:upper:] lettres majuscules
• [:lower:] lettres minuscules
• [:alpha:] lettres majuscules ou minuscules
• [:alnum:] lettres ou chiffres décimaux
• [:space:] espaces et tabulations
• [:punct:] caractères de ponctuation.

Exception : le . placé en premier caractère ou après un /
2.3 Compléments sur l’environnement

Variables d’Environnement
Les variables d’un processus shell peuvent être divisées en deux catégories :
• les variables locales au shell dont les applications lancées depuis ce shell
ne peuvent connaı̂tre la valeur
• les variables dites d’environnement ou exportées qui sont transmises aux

applications lancées depuis le shell
Une variable NomVar peut devenir une variable exportée via la commande
export NomVar
Variables locales et d’environnement
• la liste des variables locales au shell est obtenue au moyen de la commande

set
• la liste des variables d’environnement est obtenue au moyen de la com-

mande
env
Les variables d’environnement les plus courantes sont :
PWD HOME PATH PS1 TERM
SHELL USER HOSTNAME LOGNAME MAIL

2.3. COMPLÉMENTS SUR L’ENVIRONNEMENT 37
Exportation
$ VarExportée="VE" ; export VarExportée
$ VarNonExportée="VNE"
$ echo $LOGNAME $VarExportée $VarNonExportée
john VE VNE
On considère le script afficherVariables :
#!/bin/bash
VarLocale="VL"
echo $LOGNAME $VarExportée $VarNonExportée
echo $VarLocale "fin_script"
$ afficherVariables
john VE
VL fin_script
$ echo $VarLocale
Manipulation de variables
• typeset ±Options NomVar=Valeur
(+ pour attribuer, − pour désactiver), permet d’affecter une valeur ainsi
qu’un attribut
Option Attribut
i variable de type entier
l majuscules transformées en minuscules
r variable accessible seulement en lecture
u minuscules transformées en majuscules
x variable exportée
• unset NomVar : supprime la définition de la variable NomVar
Initialisation de l’Environnement
Il y a deux niveaux d’initialisation de l’environnement :
• un shell de login examine
– d’abord le fichier
/etc/profile (environnement public)
– puis un fichier du répertoire privé de l’utilisateur (environnement

privé) :
$HOME/.bash profile, à défaut
$HOME/.bash login, à défaut
$HOME/.profile
et s’il trouve un fichier lisible, il exécute les commandes qui s’y trou-
vent.
Ensuite ce shell de login se comporte comme tout autre shell.
Initialisation de l’Environnement
• un shell qui n’est pas de login examine le fichier $HOME/.bashrc et exécute
les commandes qui s’y trouvent.
Lors de l’exécution d’un script :
• si la variable BASH ENV est définie (i.e. a été définie par un shell de login),
• et s’il existe un fichier référencé par BASH ENV, par exemple $HOME/.bashrc,
ce fichier est interprété par le shell.
Définition de synonymes
Il est possible de définir des alias (synonymes, abbréviations ou surnoms) de
commandes.
Syntaxe :
alias NomAlias=Cha^
ıne
On peut visualiser la valeur d’un alias par :
alias NomAlias
et tous les alias en cours par alias
Enfin, on peut retirer un alias par unalias NomAlias
Fichier d’alias
Généralement les définitions d’alias sont regroupées dans un fichier lu à chaque
ouverture de shell interactif, par exemple un fichier $HOME/.bashrc
Exemples d’alias :
2.3. COMPLÉMENTS SUR L’ENVIRONNEMENT 39
alias rm=’rm -i’

alias mv=’mv -i’
alias cd..=’cd ..’
Le répertoire utilisateur
Le répertoire utilisateur (ou répertoire privé) est référencé par la chaı̂ne
$HOME
Attention, ne pas confondre le répertoire privé de l’utilisateur avec le répertoire

de travail courant, qui est obtenu comme résultat de la commande pwd, ou bien
référencé par la chaı̂ne
$PWD
Chemin de recherche des commandes

La variable d’environnement PATH désigne le chemin de recherche des comman-
des, et a pour valeur une liste des répertoires séparés par des : .
$ echo $PATH
/usr/bin:/usr/local/bin:/home/jcm/bin::
Lorsqu’on invoque une commande LaCommande, le shell cherche successive-

ment dans chacun des répertoires listés dans $PATH s’il existe une commande de
nom LaCommande. Dès qu’il la trouve, il l’exécute.
Le répertoire courant apparaı̂t soit avec la syntaxe ., soit comme chaı̂ne vide
entre deux :.
Recherche de commande
Il peut arriver que deux commandes de même nom LaCommande soient présentes
dans deux répertoires disctincts référencés par $PATH
On peut savoir laquelle sera exécutée :
which LaCommande
indique la référence absolue de LaCommande
$ which ls
/usr/bin/ls
Modifier le chemin de recherche

Modification de la variable PATH :
PATH=$PATH:$HOME/bin:.
Attention, l’ordre d’écriture est très important.
L’écriture
PATH=$HOME/bin:$PATH:.
est plus dangereuse, puisqu’un faux ls placé dans le répertoire $HOME/bin

permet de court-circuiter le vrai ls
Il est commode de placer le changement de PATH dans $HOME/.profile .
Exemple de .profile
$ cat .bash_profile
# .bash_profile
# Get the aliases and functions

if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi
# User specific environment and startup programs
PATH=$PATH:$HOME/bin::
export PATH
unset USERNAME
Chapitre 3
Expressions régulières et
applications
3.1 Les expressions régulières basiques

Expressions régulières
Les expressions régulières (ou rationnelles) permettent de décrire des ensembles
de motifs (ou mots).
Ces expressions régulières sont ensuite utilisées par un certain nombre de

commandes
(grep, ed, sed, vi, expr)
qui les reconnaissent.
Elles sont aussi utilisées hors du monde Unix par certaines applications (con-
struction de filtres dans des systèmes de courrier comme Thunderbird par ex-
emple).
Les caractères spéciaux

Les caractères spéciaux sont les caractères susceptibles d’avoir en certaines
circonstances une interprétation particulière à l’intérieur d’une expression régulière.
Par exemple :
Les caractères [ . * sont spéciaux sauf lorsqu’ils figurent dans la liste des
caractères définissant un ensemble de caractères (délimitée par [ et ]).
Ex :
dans l’expression
41
42 CHAPITRE 3. EXPRESSIONS RÉGULIÈRES ET APPLICATIONS
[.*[!:]
(qui désigne l’un des caractères [ . * ! :),
seuls les caractères en rouge sont spéciaux.
Caractère spécial [
• le caractère [ indique un début de définition d’un ensemble de caractères
Ex : [acd AE]
Caractère spécial .
• le caractère . désigne un caractère quelconque excepté le caractère de fin
de ligne
Ex : grep ’....’ Fic sélectionne les lignes comportant au moins 4

caractères
Caractère spécial *
• le caractère * indique l’itération d’un nombre quelconque de fois,
sauf
s’il est en premier caractère d’une expression
ou
immédiatement après une séquence \( ouvrant la définition d’un champ
Ex :
grep ’ac*b’ Fic sélectionne toute ligne contenant un motif ab ou acb

ou ac.....cb
grep ’*b’ Fic sélectionne toute ligne contenant un motif *b
Caractère spécial *
Soit le fichier Fic :
$ cat Fic
*aba
a*ba*c
*****
aaaaa
3.1. LES EXPRESSIONS RÉGULIÈRES BASIQUES 43
$ grep ’*[*]*’ Fic

*aba
a*ba*c
*****
$ grep ’**’ Fic
*aba
a*ba*c
*****
aaaaa
Caractère spécial ]
Ce caractère a une interprétation spéciale dans le contexte particulier indiqué :
• le caractère ] indique la terminaison de la définition d’un ensemble de

caractères (cette définition ayant commencé à l’occurrence précédente et
la plus externe du caractère [)
Caractère spécial -
• le caractère - permet dans une définition d’ensemble de spécifier l’intervalle
de tous les caractères compris entre le caractère précédent et le caractère
suivant - dans l’expression.
Le caractère - n’est plus spécial s’il suit immédiatement le caractère [ de

début de définition ou précède le caractère ] de fin de définition d’ensemble
Ex : [-a-d] équivaut à [-abcd]
Caractère spécial ^
• le caractère ^ signifie
– le début de ligne lorsqu’il est en début d’expression

– le complément ensembliste lorsqu’il suit immédiatement un caractère
[ de début de définition d’ensemble
Caractère spécial ^
Soit le fichier Fic :
$ cat Fic
*aba
a*ba*c
*****
aaaaa
$ grep ’^*’ Fic

*aba
*****
$ grep ’^[^*]’ Fic
a*ba*c
aaaaa
Caractères spéciaux $ et \
• le caractère $ signifie la fin de ligne lorsqu’il est le dernier caractère d’une
expression
• le caractère \ précédant un caractère spécial lui enlève son interprétation
particulière (sauf à l’intérieur de la définition d’un ensemble).
Exemple :
pour désigner une ligne qui commence par . , on peut utiliser une des deux
expressions :
• ^\.
• ^[.]
Expressions régulières atomiques

Il s’agit d’expressions régulières représentant des ensembles de motifs constitués
d’un seul caractère.
Les différentes formes sont :
• un caractère non spécial quelconque : l’ensemble correspondant ne con-
tient que le mot de un caractère correspondant
• un caractère spécial précédé du caractère \ : l’ensemble ne contient que le
mot d’une seule lettre correspondant
• le caractère spécial . : tout motif d’un caractère, quel qu’il soit, excepté
le caractère de fin de ligne, appartient à l’ensemble défini par l’expression
• une suite de caractères entre [ et ] ne commençant pas par le caractère
^ : tout motif constitué d’un caractère de la suite appartient à l’ensemble
défini par l’expression
• une suite de caractères entre [ et ] et commençant par le caractère ^ :
tout motif caractère n’appartenant pas à la suite appartient à l’ensemble
de motifs défini
• une expression de la forme [:LaClasse:] définit de manière symbolique
une classe de caractères.
Et pour désigner un élément de la classe on utilise la notation [[:LaClasse:]]

Expressions régulières atomiques

Les valeurs possibles de LaClasse sont :
LaClasse signification
digit chiffres décimaux
xdigit chiffres hexadécimaux
alpha lettres majuscules et minuscules
upper lettres majuscules
lower lettres minuscules
alnum caractères alphanumériques (lettres et chiffres)
space caractères d’espacement
cntrl caractères de contrôle
print caractères imprimables
punct caractères de ponctuation
Expressions régulières générales

Elles ont les formes suivantes :
• régulière atomique
• régulière atomique suivie du caractère *

définit l’ensemble de longueur positive ou nulle pouvant être construit sur
l’alphabet défini par cette expression atomique
Ex :
A[ac]*A
désigne des chaı̂nes contenant un motif constitué de deux lettres A séparées
par des lettres a ou c (éventuellement aucune).
• une concaténation (i.e. mise bout à bout) de deux expressions régulières
• toute expression dont le premier caractère est ^ indique que les motifs
désignés doivent être en début de ligne
Ex :
ÂAAAA : lignes commençant par AAAAA
• toute expression dont le dernier caractère est $ indique que les motifs
désignés doivent être en fin de ligne
Ex :
ZZZZZ$ : lignes se terminant par ZZZZZ

• une expression comprise entre $ et $
cette notation est équivalente à l’expression régulière elle-même, c’est-à-
dire utilisée sans $ et $,
Mais son intérêt est de fournir un moyen de repérage et de désignation.
A chaque construction d’un bloc entre $ et $

est associé automatiquement un numéro de bloc, incrémenté de gauche à
droite.
Le bloc de numéro N sera ensuite référencé par la notation \N.

• \N
désigne dans une expression le motif (c’est-à-dire le mot appartenant à
l’ensemble défini par cette expression) de la N-ième sous expression
(définie par le mécanisme de parenthèsage décrit précédemment) de l’expression
complète.
Ex :
$.*$\1\1
désigne les objets obtenus par double concaténation du motif numéro 1 à

lui-même (mots triples).

Ex :
définir les motifs constitués de 2 sous-motifs entrelacés séparés par des - :
par exemple :
jour-nuit-jour-nuit
soleil-lune-soleil-lune
a-b-a-b
Ce type d’expression se désigne par :

$.*$-$.*$-\1-\2
On peut ensuite demander à un éditeur de flux comme sed de modifier

l’ordre des sous-motifs.

$ cat Fic
jour-nuit-jour-nuit
soleil-lune-soleil-lune
a-b-a-b
$ sed ’s/$.*$-$.*$-\1-\2/\2-\1-\2-\1/’ Fic

nuit-jour-nuit-jour
lune-soleil-lune-soleil
b-a-b-a

• \N
désigne dans une expression le motif (c’est-à-dire le mot appartenant à
l’ensemble défini par cette expression) de la N-ième sous expression
(définie par le mécanisme de parenthèsage décrit précédemment) de l’expression
complète.
Quelques règles :
N doit être compris entre 1 et 9
Dans le cas où N est suivi du caractère *, la sous-expression peut être

itérée un nombre quelconque de fois (0 ou plus).

• une expression régulière atomique suivie de
– \{N\} indiquant N occurrences consécutives de caractères de l’ensemble

défini par l’expression atomique donnée
– \{N, \} indiquant un nombre minimal de N occurrences consécutives
de caractères de l’ensemble défini par l’expression atomique donnée
– \{N1,N2\} indiquant un nombre minimal de N1 et un nombre maxi-

mal de N2 occurrences consécutives de caractères de l’ensemble défini
par l’expression atomique donnée.
où les nombres entiers sont donnés sous une forme décimale et sont compris
entre 0 et 255
Exemples
• ^\..*$ ou ^\. ou ^[.].*$ ou ^[.]
désigne les lignes qui commencent par .
• [a-zA-ZO-9]
est l’ensemble de tous les caractères alphanumériques (équivalent dans la
plupart des cas à [[:alnum:]] )
• [â-zA-ZO-9]
est l’ensemble complémentaire du précédent (ensemble des caractères qui
ne sont ni une lettre majuscule ou minuscule, ni un chiffre)
• [-^[]
est l’ensemble des trois caractères - [ et ^
• ^[a-z]*$
désigne les lignes qui sont vides ou bien qui ne contiennent que des lettres
minuscules
• ^[a-z]\{3\}[â-z]\{3\}$
désigne les lignes qui commencent par 3 lettres minuscules et finissent par
3 caractères qui n’en sont pas et ne contiennent aucun autre caractère
• ^*\**$ ou ^\*\**$ ou ^*[*]*$
désigne les lignes non vides qui ne contiennent que des caractères *
• ^.*[[:space:]].*$
désigne les lignes qui contiennent au moins un espace ou une tabulation
• ^.*[[:space:]].*$
désigne les lignes qui contiennent au moins un espace ou une tabulation
• ^.*[[:space:]]\{3\}.*$
désigne les lignes qui contiennent au moins un bloc de trois espaces/tabulations
• ^[[:space:]][[:space:]]*$
désigne les lignes qui ne contiennent que des espaces ou tabulations (mais
au moins un)
• ^[[:space:]]*$
désigne les lignes qui ne contiennent que des espaces ou tabulations (mais
éventuellement aucun : ligne vide)
• ^[[:upper:]]\{10,\}.*$
désigne les lignes qui contiennent en début de ligne au moins dix lettres
majuscules consécutives
• ^$ab$\{2\}.*$
désigne les lignes qui contiennent deux répétitions du motif ab en début
de ligne
• ^.*$ab$\{2\}$
désigne les lignes qui contiennent deux répétitions du motif ab en fin de
ligne
• ^$ab$\{2\}.*$ab$\{2\}$
désigne les lignes qui contiennent deux répétitions du motif ab au début
et en fin de ligne
Exemples
On souhaite envoyer directement à la poubelle les mèls provenant des adresses
qui comportent au moins quatre chiffres consécutifs.
On peut sélectionner ces adresses au moyen de l’expression régulière :
^.*[[:digit:]]\{4,\}.*$
Exemples
comment éliminer les trames NMEA erratiques d’un GPS, i.e celles qui ne sont
pas du type :
• une latitude formée de 4 chiffres suivis de 4 décimales,
• puis une longitude formée de 5 chiffres suivis de 4 décimales,
• le tout suivi d’au moins 4 caractères formant l’altitude.
Il suffit d’exclure les motifs :
^[0-9][0-9][0-9][0-9]\.[0-9][0-9][0-9][0-9]\ [0-9][0-9][0-9][0-9][0-9]\.[0-9][0-9][0-9][0-9]\ ...
Ou encore :
^[0-9]\{4\}\.[0-9]\{4\}\ [0-9]\{5\}\.[0-9]\{4\}\ ....

3.2 Application à l’édition de flux

L’éditeur sed
Le nom sed provient de stream editor, et désigne un éditeur non-interactif.
A l’aide de sed on peut appliquer une commande sur chaque ligne d’un
fichier (ceci permet de traiter des fichiers énormes).
Exemple :
la commande de substitution d’une chaı̂ne par une autre permet l’utilisation
des expressions régulières :
sed ’s/RegExp/Motif/’ LeFic
Substitution simple
Substitution simple de la première occurence de chaque ligne :
$ cat Fic
ababa
abaddaba
baba
$ sed ’s/aba/BAB/’ Fic
BABba
BABddaba
bBAB
Tampons d’édition
sed possède deux tampons :
• le tampon actif des motifs
• le tampon auxiliaire (de sauvegarde)
On peut échanger le contenu des deux tampons avec la commande x
Algorithme de sed
sed réalise un cycle d’instructions sur chaque ligne du fichier édité, de la première
à la dernière.
On peut placer des conditions pour n’effectuer le cycle d’intructions que si

certaines conditions sur la ligne sont remplies
Par exemple,
3.2. APPLICATION À L’ÉDITION DE FLUX 51
• position de la ligne dans le fichier,
• présence/absence d’une expression régulière dans la ligne à traiter
Après chaque cycle, le tampon actif est vidé, sauf si une commande spécifique
pour l’interdire est émise.
Algorithme de sed : détail d’un cycle

1. sed lit une ligne L sur un flux entrant (entrée standard, ou fichier que l’on
désigne)
2. sed enlève le caractère de fin de ligne de L : objet L’
3. sed place cette ligne L’ dans le tampon actif
4. les commandes sont exécutées sur l’objet L’
5. chaque commande peut être munie d’une adresse associée (une forme con-
ditionnelle)
• si la condition n’est pas vérifiée, la commande n’est pas effectuée

• si la condition est vérifiée, la commande est exécutée sur l’objet L’
6. l’objet L”, transformé par l’action de sed, et envoyé en flux de sortie (sur
la sortie standard)
7. un caractère de fin de ligne est ajouté dans le cas où un caractère de fin
de ligne avait été enlevé
Substitution globale
L’option g de la commande s permet la substitution simple de chaque occurence
de chaque ligne :
$ cat Fic
ababa
abaddaba
baba
$ sed ’s/aba/BAB/g’ Fic
BABba
BABddBAB
bBAB
Substitution sur position

On utilise encore la commande s.
On définit chaque bloc au moyen de $ et $
$ cat Fic
aba
EFE
cfc
$ sed ’s/$.$$.$\1/\2\1\2/’ Fic
bab
FEF
fcf
Destruction de lignes
On utilise la commande d.
$ cat Fic
a
$ sed ’/^ *$/d’ Fic
Question : que fait cette commande ?
Destruction de lignes
$ cat Fic
a
$ sed ’/^ *$/d’ Fic

a
b
c
Sélection de motifs
Récupération des 3 derniers caractères de chaque ligne :
$ cat Fic
abcdef
12345678
abc
$ sed ’s/^$.*$$.\{3\}$$/\2/’ Fic
def
678
abc
Sélection de motifs
La commande who donne :
$ who
vahjaj pts/1 Oct 15 17:24 (math.u-bourgogne.fr)
jcm pts/2 Oct 24 14:06 (adijon-152-1-33-66.w83-194.abo.wnd.fr)
On veut afficher uniquement le login et le pays de provenance de la connexion
$ who | sed ’s/$.*$ *pts$.*$\.$..$)$/\1 \3/’

vahjaj fr
jcm fr
Remplacement de caractères
On utilise la commande y .
$ cat Fic
a
b
a
d
$ sed ’y/abcd/XYZT/’ Fic
X
Y
X
T
Opérations directes dans un fichier

On peut toujours effectuer un cycle du type :
sed ’y/abc/XYZ/’ Fic > /tmp/FicAux
mv /tmp/FicAux Fic
Mais on peut également modifier immédiatement le fichier édité :
sed -i ’y/abc/XYZ/’ Fic
Aucun affichage n’est réalisé, le fichier est transformé.
Edition d’une sélection de lignes

On peut sélectionner les lignes à traiter par leur position numérique dans le
fichier.
$ cat Fic
a
b
c
d
$ sed ’1,2 y/abcd/XYZT/’ Fic
X
Y
c
d
$ sed ’3,$ y/abcd/XYZT/’ Fic
a
b
Z
T
Traitement de lignes consécutives

Exemple : joindre les couples de lignes dont la deuxième commence par un
blanc.
sed ’N;s/\n / /g;P;D;’ Fic
• ; est un séparateur de commandes
• N concatène la ligne suivante à la ligne examinée
• \n désigne un saut de ligne
• P retourne le résultat du traitement
• D efface ce qui reste après traitement pour ne pas afficher deux fois la
ligne suivante

Pour concaténer des lignes consécutives dont la première se termine par une
expression donnée (ici : -->)
sed ’:a; /-->$/N; s/-->\n/ /; ta’ Fic
• :a est un label qui référence la ligne que l’on examine
• /-->$/ sélectionne une ligne dans laquelle l’expression régulière est présente
• N concatène la ligne suivante à la ligne examinée
• on effectue ensuite la substitution, en enlevant la fin de ligne
• si la substitution est effectuée, ta renvoie au label a, c’est à dire qu’on se
replace en position d’examiner une prochaine ligne.

Pour concaténer des lignes consécutives dont la première se termine par une
expression donnée (ici : -->)
sed ’:a; /-->$/N; s/-->\n/ /; ta’ Fic
Remarquons qu’ici le label n’est pas indispensable.
$ cat Fic
j’adore-->
vraiment
le-->
sed!
$ sed ’/-->$/N; s/-->\n/ /’ Fic
j’adore vraiment
le sed!
Traitement de blocs de lignes

On va marquer les lignes que l’on veut traiter au moyen d’expressions régulières.
• Pour supprimer toutes les lignes jusqu’à celle contenant la chaı̂ne \begin{document}
sed ’1,/^\\begin{document}$/ d’ LeDoc
• Pour supprimer toutes les lignes à partir de celle contenant la chaı̂ne

\end{document}
sed ’/^\\end{document}$/,$ d’ LeDoc
• Pour supprimer un bloc compris entre deux lignes contenant ces deux
expressions régulières :
sed ’/^\\begin{document}$/,/^\\end{document}$/ d’ LeDoc

Affichage des numéros de ligne

La commande = permet d’obtenir le numéro de la ligne traitée, suivi d’un saut
de ligne.
$ cat Fic
a
b
c
d
$ sed ’=’ Fic
1
a
2
b
3
c
4
d
Affichage des numéros de ligne

$ cat Fic
a
b
c
d
$ sed ’=’ Fic |
sed ’/^[0-9][0-9]*$/N;s/$^[0-9][0-9]*$\n/\1 /’
1 a
2 b
3 c
4 d
Négation
Ex : pour détruire toutes les lignes qui ne comportent pas l’expression

régulière RegExp
sed ’/RegExp/!d’ LeFic
$ cat Lefic
xyxy
xyxz
ababxy
$ sed ’/$.$$.$\1\2/d’ LeFic
xyxz
Chapitre 4
Les systèmes de fichiers
4.1 Principes d’organisation

Notion de fichier
En UNIX, La notion de fichier ne se limite pas à la simple notion de fichier
disque.
On doit considérer un fichier comme un objet typé dont le type permet de

définir l’ensemble des opérations qui peuvent lui être appliquées.
Quelques types de fichiers

Un fichier pourra :
• correspondre à un fichier disque au sens classique du terme

• être associé à une ressource (physique ou logique) du système (device)
comme :
– les terminaux,
– les imprimantes,
– les disques physiques,
– les disques logiques (partitions logiques des disques physiques),
– la mémoire physique ou la kernel memory (qui contient les tables du
noyau)
i-nœuds
À chaque fichier correspond une entrée dans une table contenant l’ensemble des
attributs de ce fichier
(par exemple son type, ses propriétaires ou ses droits d’accès).
59
60 CHAPITRE 4. LES SYSTÈMES DE FICHIERS
Une telle entrée est appelée i-nœud (i-node ou index node).
Identification d’un fichier

Un fichier a donc comme identification un couple constitué de :
• l’identification de la table dans laquelle sont enregistrées ses caractéristiques

(on parle de disque logique organisé en système de gestion de fichiers, en
abrégé disque logique),
• l’indice dans cette table de l’entrée contenant ces caractéristiques.
Les indices peuvent être affichés avec la commande
ls -li
Afficher les indices

$ ls -li /
29 drwxr-xr-x 1 root root 384 Jan 30 2007 bin
1 drwxr-xr-x 1 root root 0 Jan 1 1970 dev
35 drwxr-xr-x 1 root root 0 Jun 8 18:13 etc
1 drwxr-xr-x 1 root root 0 Jan 1 2000 jffs
32 drwxr-xr-x 1 root root 0 Jun 25 22:50 lib
201 drwxr-xr-x 1 root root 0 Feb 3 2007 mnt
1 dr-xr-xr-x 34 root root 0 Jan 1 2000 proc
185 drwxr-xr-x 1 root root 85 Jan 30 2007 rom
45 drwxr-xr-x 1 root root 0 Oct 17 12:22 sbin
41 drwxrwxrwt 7 root root 200 Nov 7 10:36 tmp
52 drwxr-xr-x 1 root root 0 Jun 25 23:06 usr
67 lrwxrwxrwx 1 root root 4 Feb 3 2007 var -> /tmp
155 drwxr-xr-x 1 root root 62 Feb 3 2007 www
Numérotation des i-nœuds

Le numéro 0 n’est pas utilisé pour un i-nœud.
Le numéro 1 a souvent été utilisé pour référencer des mauvais blocs d’information.
Il est maintenant utilisé régulièrement pour des i-nœuds ne correspondant

pas à des données concrètes (tubes fifos, sockets, périphériques, répertoires
vides).
Par suite l’i-nœud de la racine d’un système de fichier vaut normalement 2.
La commande stat permet de récupérer les informations d’un fichier donné.

4.1. PRINCIPES D’ORGANISATION 61
Le type d’un fichier

Le type définit l’ensemble des opérations (et la sémantique de chacune d’elles)
qui peuvent être réaIisées sur le fichier.
L’accès aux fichiers des différents types est réalisé au travers d’un ensemble
de primitives système (points d’accès dans le noyau), de noms génériques (par
exemple open, read, write et close)
Le système se charge, à partir du type d’un fichier et des informations con-

tenues dans le nœud associé, d’appeler les fonctions spécifiques correspondant
à l’objet particulier.
Catégories de fichiers
En première approximation, on peut classifier les différents types de fichiers en
deux grandes catégories selon qu’ils ont :
• un contenu sur disque (fichiers réguliers, répertoires, liens symboliques,

tubes)
• pas de contenu sur le disque (fichiers spéciaux correspondant à des ressources).
Répertoires
Les répertoires jouent un rôle privilégié car leur contenu est interprété par un
certain nombre de fonctions du système :
• ils permettent de structurer l’ensemble des fichiers en arborescence
• ils définissent un mécanisme de désignation extérieure des fichiers indépendemment

de leur localisation dans les tables du système et sur le disque.
Question :
comment savoir si un identificateur correspond à un répertoire ?

Les répertoires sont détectés au moyen de la commande
ls -l
le premier caractère de la ligne correspondant à l’identification du répertoire
étant un d
Répertoires
Les répertoires sont détectés au moyen de la commande

ls -l
le premier caractère de la ligne correspondant à l’identification du répertoire

étant un d
$ ls -l
-rw-r--r-- 1 jac pr 454232 nov 8 11:44 bash.pdf
drwxr-xr-x 2 jac pr 4096 nov 15 11:10 TDsys/
drwx------ 2 jac pr 4096 sep 30 2002 tmp/
Référençage
Le mécanisme de référençage repose sur l’association réalisée dans les répertoires
entre
• chaı̂nes de caractères (appelées liens physiques)
• numéros d’index des fichiers.
La désignation extérieure d’un fichier est réalisée

• en utilisant un lien associé à ce fichier dans un répertoire,
• ce répertoire étant lui-même désigné par le même mécanisme dans un autre
répertoire.
L’origine symbolique de cette arborescence est appelée racine absolue du

système de gestion de fichiers.
Organisation des intra-arborescences

Il y a une table de fichiers pour chaque arborescence indépendante.
Les différentes arborescences peuvent être reliées entre elles par le mécanisme
de montage :
ce mécanisme permet de greffer la racine d’une arborescence non encore

montée, en un point accessible depuis la racine absolue.
Montage
L’une des arborescences, correspondant au disque système, est privilégiée car
• les montages des autres se font par rapport à elle
• sa racine est la racine absolue du système de gestion de fichiers complet.
Le mécanisme de montage repose sur le fait que

4.2. LES RÉFÉRENCES 63
• chaque disque logique constitue une ressource (logique) du système
• et donc c’est un fichier spécial qui possède un lien dans un répertoire

particulier du disque système (le répertoire des ressources /dev).
La commande mount
Cette commande permet de faire correspondre des parties de l’arborescence
avec des partitions, et aussi d’affecter un système extérieur (clé usb, répertoire
réseau, cdrom, etc..) à un répertoire créé dans l’arborescence.
Ce répertoire est appelé point de montage, et le montage est dynamique.
mount /dev/cdrom
va créer un répertoire cdrom, pourvu que le fichier (Linux) /etc/fstab soit

correctement renseigné.
Montage NFS
Le mécanisme de montage peut être étendu afin de permettre l’accès aux fichiers
appartenant à des systèmes distants de manière transparente :
le protocole le plus répandu qui autorise de tels accès est le protocole NFS
(Network File System).
4.2 Les références

Fichiers accessibles et chemins d’accès
Les fichiers accessibles à un instant donné sont :
• ceux du disque système (Le disque système est toujours monté)
• ceux qui appartiennent à un disque logique dont la racine a été montée

relativement au disque système.
Pour tout fichier d’un disque monté, il existe (si le système est consistant),
au moins un chemin de la racine vers ce fichier.
Références absolues d’un fichier

/home/Etud/IQ1/Letudiant/TDsys/couperSansVerif
La liste des noms étiquetant les arrêtes d’un tel chemin identifie sans aucune
ambiguı̈té ce fichier :
cette suite constitue un chemin d’accès (pathname) ou référence absolue

du fichier permettant d’identifier (si tout est normal) le fichier sans aucune
ambiguı̈té.
Observer qu’un même fichier peut avoir plusieurs chemins d’accès.
Dans cette notation, la racine absolue du système de gestion de fichiers a /

comme référence absolue.
Répertoires de travail
Afin de faciliter les repérages, à tout instant, à tout processus (activité dans le
système) est associé un répertoire privilégié appelé
répertoire de travail ou répertoire courant

(working directory ou current directory)
par rapport auquel il lui est possible de réaliser des repérages relatifs.
Les utilisateurs connectés à un système, travaillant sous un shell interactif

(interprète de commandes) ont ainsi, à un instant donné, un répertoire de travail
(il change au cours du temps).
Références relatives
Une désignation par rapport à un répertoire de travail est appelée référence
relative.
Elle s’écrit sous la forme d’une suite de liens, séparés par le caractère / et
ne commençant pas par le caractère /.
Elle correspond à un chemin allant du répertoire de travail à un fichier.
Question :
quelle relation entre la référence relative et la référence absolue ?
Références relatives
Une désignation par rapport à un répertoire de travail est appelée référence
relative.
Elle s’écrit sous la forme d’une suite de liens, séparés par le caractère / et
ne commençant pas par le caractère /.
Elle correspond à un chemin allant du répertoire de travail à un fichier.
4.2. LES RÉFÉRENCES 65
La référence absolue d’un fichier se déduit d’une référence relative en lui

ajoutant en préfixe la référence absolue du répertoire de travail (obtenue par
$PWD).
Ce type de repérage est amélioré par un mécanisme permettant de remonter

vers la racine de l’arborescence.
Les liens .. et .
Le lien .. contenu dans un répertoire est toujours associé au répertoire unique
dont le répertoire est le descendant.
Par ailleurs, un répertoire peut utiliser le lien . pour se désigner dans lui-
même.
Ex : supposons que $PWD vaille /home/Etud/IQ1/Letudiant/TDsys/,

alors :
et
./couperSansVerif
sont deux liens qui désignent le même fichier physique.
.. correspond à /home/Etud/IQ1/Letudiant/
Répertoires (presque) vides

Remarques :
• un répertoire UNIX n’est jamais totalement vide puisqu’il contient tou-

jours au moins les deux liens
. et .. qui ne peuvent (sauf situation anormale)
être détruits
• un répertoire a au moins deux liens physiques
– le lien . dans lui-même

– le lien qu’il possède dans son répertoire père.
Répertoire privé
Chaque utilisateur possède un répertoire particulier, appelé répertoire privé
(home directory)
qui devient automatiquement le répertoire de travail du processus shell lancé
à sa connexion au système (opération login).
On l’obtient par $HOME.
Il est aussi visible dans /etc/passwd :
grep ’LeNom’ /etc/passwd | cut -d’:’ -f6
4.3 Les différents types de fichiers

Les fichiers ordinaires ou réguliers
Ces fichiers (regular file) sont des fichiers sur disque dont le contenu est non
structuré.
Ce contenu correspond donc à une suite de caractères caractérisée par sa
longueur (permet en particulier de détecter la fin de fichier).
Question :
comment calcule-t-on cette longueur ?
Cette longueur est obtenue par wc -c
Les contenus de tels fichiers peuvent être des programmes (binaires ou sources)
ou des données de programmes utilisateurs ou systèmes.
Ces fichiers sont en fait des résultats de programmes (éditeurs de textes,

compilateurs, éditeurs de liens, fichiers résultats, etc.).
Les répertoires usuels

Leur rôle : c’est par leur intermédiaire que les utilisateurs peuvent désigner leurs
fichiers.
Répertoires principaux que l’on trouve (directement ou via des liens sym-
boliques) sur tous les systèmes :
• /bin et /usr/bin contiennent les noms des commandes UNIX non internes
aux différents langages de commandes
• /usr/lbin ou /usr/local/bin contiennent les noms des commandes par-
ticulières à un site donné
Répertoire /bin
Exemple d’un système openWRT flashé sur un Linksys WRT54GL :
$ ls /bin
ash dd grep login netmsg rmdir umount
busybox df gunzip ls netstat sed uname
cat dmesg gzip mkdir pidof sh vi
4.3. LES DIFFÉRENTS TYPES DE FICHIERS 67
chgrp echo ipcalc.sh mknod ping sleep zcat

chmod egrep ipkg mktemp ping6 sync
chown false kill more ps tar
cp fgrep ln mount pwd touch
date firstboot lock mv rm true
Les répertoires usuels

• /dev contient les noms des fichiers spéciaux associés aux ressources
• /etc contient les noms de fichiers système
• /tmp contient les références de fichiers temporaires utilisés par les appli-
cations système
• /usr/tmp contient les références de fichiers temporaires des utilisateurs.
Répertoire /etc
Exemple d’un système openWRT flashé sur un Linksys WRT54GL :
$ ls /etc
TZ firewall.user ipkg.conf profile
banner functions.sh modules protocols
config group modules.d rc.common
crontabs hosts openwrt_version resolv.conf
cryptokeys hotplug.d passwd serverTun.ovpn
dnsmasq.conf httpd.conf passwd- shells
dropbear init.d ppp ssh
ethers inittab preinit sysctl.conf
Les fichiers spéciaux

L’une des originalités du système UNIX réside dans le traitement qu’il fait des
entrées sorties sur périphériques (terminaux, imprimantes, disques, bandes).
L’utilisateur ne voit pas de différence entre les fichiers ordinaires, les répertoires
et les organes périphériques du point de vue de leur référençage.
Un fichier spécial est associé à un dispositif physique.
Les fichiers spéciaux sont traités par le système comme des fichiers sur disque
ordinaires, mais les opérations de lecture ou d’écriture sur ces fichiers activent
les dispositifs physiques associés.
Modes de fichiers spéciaux

On peut distinguer deux types de fichiers spéciaux :
• les fichiers spéciaux en mode bloc comme les disques où les entrées-sorties
sont réalisées par bloc (la taille des blocs étant en général de 512 ou 1 024
caractères) et transitent par des caches du système d’entrées-sorties
• les fichiers spéciaux en mode caractère comme les terminaux pour lesquels
les entrées-sorties sont réalisées caractère par caractère et ne transitent
pas par ces caches.
Autres types de fichiers

De nouveaux types de fichiers sont apparus :
• les tubes nommés ou fifo (first in first out) qui permettent la communi-
cation entre processus,
• les sockets internes UNIX destinées à la communication bidirectionnelle

entre processus,
• les liens symboliques, qui sont des fichiers sur disque dont le contenu est
interprété comme un nom de fichier.
Structure des nœuds d’index

Les informations que l’on trouve dans un i-nœud d’un disque (il existe une table
des nœuds en mémoire) sont :
• l’identification du propriétaire et du groupe propriétaire du fichier
• le type du fichier et les droits d’accès des différents utilisateurs
• la taille du fichier exprimée en nombre de caractères (cette notion n’a pas

de sens pour les fichiers spéciaux)
• le nombre de liens physiques sur le fichier (c’est-à-dire le nombre total

d’entrées correspondant au fichier dans l’ensemble des répertoires du même
disque logique)
• les trois dates significatives (lecture, modification du fichier et modification

du nœud)
• l’adresse des blocs utilisés sur le disque pour ce fichier (uniquement pour
les fichiers sur disque)
• remarque importante : un tel bloc d’informations ne contient aucun nom

pour le fichier correspondant
4.4. LES DROITS D’ACCÈS AUX FICHIERS 69
4.4 Les droits d’accès aux fichiers

Les groupes d’utilisateurs
Tout utilisateur possède un numéro de compte (UID) et appartient à un groupe
particulier.
Ce groupe est repéré soit par un identificateur soit par un numéro (le GID).
On peut récupérer l’identificateur ou le numéro :

• à partir de /etc/passwd
$ grep ’jac’ /etc/passwd
jac:x:503:100:Alain Jacquemard:/home/jacmar:/bin/bash
le troisième champ indique l’UID et le quatrième champ le GID.
• via la commande id :
$ id
uid=503(jac) gid=100(pr) groupes=100(pr)
Catégories d’utilisateurs d’un fichier

Pour un fichier donné, les utilisateurs du système peuvent être classés en trois
catégories :
• le propriétaire du fichier
(catégorie associée au symbole u)
• les membres d’un groupe, appelé groupe propriétaire du fichier
(catégorie associée au symbole g)
• les autres utilisateurs
(catégorie associée au symbole o)
L’ensemble de ces trois catégories est associé

au symbole a.
Les types d’opérations

Trois types d’opérations élémentaires sont contrôlés par le système :
• la lecture (associée au symbole r)
• l’écriture (associée au symbole w)
• l’exécution (associée au symbole x)

Indicateurs de mode d’un fichier

On peut connaı̂tre les modes r,w,x pour les groupes u,g,o
via la commande ls -l qui, parmi d’autres informations,
indique pour un fichier ordinaire LeFic :
groupe
z}|{
-|{z}
rwx rwx |{z}
rwx ... LeFic
utilisateur autres
Chaque lettre est remplacée par un - si le droit n’est pas accordé.
Indicateurs de mode d’un répertoire

On peut connaı̂tre les modes r,w,x pour les groupes u,g,o
via la commande ls -l qui, parmi d’autres informations,
indique pour un répertoire LeRep :
groupe
z}|{
d|{z}
rwx rwx |{z}
rwx ... LeRep
utilisateur autres
Chaque lettre est remplacée par un - si le droit n’est pas accordé.
Mode x pour des répertoires

Le mode x pour un utilisateur (ou une catégorie d’utilisateurs) a une signification
spéciale lorsqu’il est appliqué à un répertoire : il correspond à un droit de transit.
Il signifie que cet utilisateur a la permission :
• de faire figurer ce répertoire dans une référence
• de s’y positionner, c’est-à-dire d’en faire son répertoire de travail
Répertoires en mode x
Ex :
Considérons le répertoire ReP x en mode x pour l’utilisateur jac qui effectue
les commandes suivantes :
$ ls -la | grep ’ReP__x’
d--xrwxrwx 2 jac pr 4096 nov 30 15:44 ReP__x/
$ cd ReP__x
$ ls
ls: .: Permission non accordée
$ cd .. ; ls ReP__x
ls: ReP__x: Permission non accordée

$ mv a* ReP__x
mv: Ne peut créer un fichier de type régulier ‘ReP__x/a.b’:
Permission non accordée
Modes r et w des répertoires

Le droit de lecture d’un répertoire est le droit de lire les noms référencés dans
ce répertoire.
De plus, pour avoir la liste étendue des fichiers (ls -l) d’un répertoire au-
torisé en lecture, il faut aussi que ce dernier soit autorisé en mode x de transit.
Le droit d’écriture d’un répertoire est un droit potentiel permettant d’écrire

dans ce répertoire.
Pour que ce droit d’écriture soit actif, il est nécessaire que le mode x de
transit soit activé.
Ce droit inclut le droit de détruire un fichier du répertoire et cela même sans

aucun droit de lecture ou d’écriture sur ce fichier lui-même.
Répertoires en mode rw
Ex :
Considérons le répertoire RePrw en mode r,w pour l’utilisateur jac qui
effectue les commandes suivantes :
$ ls -la | grep ’RePrw_’
drw-rwxrwx 3 jac pr 4096 nov 30 15:20 RePrw_/
$ cd RePrw_
bash: cd: RePrw_: Permission non accordée
$ ls RePrw_/*
ls: RePrw_/a.b: Permission non accordée
$ cp RePrw_/a.b .
cp: Ne peut évaluer ‘RePrw_/a.b’ par stat():
Permission non accordée
$ date > RePrw_/aa.b
bash: RePrw_/aa.b: Permission non accordée
Les liens du répertoire sont donc visibles, mais on ne peut opérer dessus. On
ne peut pas écrire malgré le w, ni lire les caractéristiques des fichiers malgré le
r.
Répertoires et modes
Règle à retenir :
Pour un répertoire, c’est le mode x qui est primordial, les modes w et r ne

prennent le sens commun que lorsque le mode x est activé.
Répertoires en mode wx
Ex :
Considérons le répertoire ReP wx en mode w,x pour l’utilisateur jac qui
$ ls -la | grep ’ReP_wx’
d-wxrwxrwx 2 jac pr 4096 nov 30 16:00 ReP_wx/
$ ls ReP_wx/
ls: ReP_wx/: Permission non accordée
$ date > ReP_wx/a.b
$ rm ReP_wx/a.b
rm: détruire ‘ReP_wx/a.b’? o
$
On peut donc enregistrer des fichiers, les détruire, mais on ne peut les lister.
Répertoires en mode rx
Ex :
Considérons le répertoire RePr x en mode r,x pour l’utilisateur jac qui
$ ls -la | grep ’RePr_x’
dr-xrwxrwx 2 jac pr 4096 nov 30 19:55 RePr_x/
$ ls RePr_x/
a.b
$ date > RePr_x/b.b
bash: RePr_x/b.b: Permission non accordée
$ cat RePr_x/a.b
Voici les caractères du contenu du fichier a.b
$ rm RePr_x/a.b
rm: détruire ‘RePr_x/a.b’? o
$
On peut donc supprimer le lien par rm, mais seulement après confirmation.
Le cas des fichiers

Pour un fichier ordinaire :
• le droit de lecture donne la possibilité de lire le contenu du fichier

• le droit d’écriture donne la possibilité de modifier le fichier.
Remarques
• Le droit d’accès en écriture donne aussi droit à la destruction de noms de
fichier.
Cette destruction pourra avoir lieu par exemple par une des commandes
rm, cp, mv ou encore par redirection >
• Les fichiers ordinaires pour lesquels le droit en exécution a un sens sont :
– les modules binaires exécutables

– les fichiers texte ASCII susceptibles de contenir un shellscript, ou
plus généralement une procédure en shell
• si le propriétaire d’un fichier n’a plus de droit en écriture dans ce fichier,

il lui sera possible de le détruire quand même par la commande rm , mais
il lui sera demandé une confirmation.
• si ce propriétaire souhaite, dans le cas ci-dessus, être dispensé de confir-

mation, il devra utiliser l’option f de rm :
rm -f NomFic

Tests de droits d’accès des fichiers :
ExprTest Vraie si
-r Fic Fic lisible par le processus
-w Fic Fic modifiable par le processus
-x Fic Fic exécutable par le processus
Le super-utilisateur
Il existe un utilisateur privilégié disposant de tous les droits :
le super-utilisateur, dont l’UID est 0, le GID est 0, et dont l’un des noms de
connexion est root.
Le super-utilisateur a tous les droits :
• sur les fichiers dont il est propriétaire, évidemment.
• sur ceux qui appartiennent à tous les utilisateurs ordinaires.
Il peut lire, écrire, détruire, exécuter (éventuellement) tous les fichiers du

système.
Propriétaire d’un fichier

Le propriétaire du fichier est normalement celui qui a créé le fichier.
Normalement, car il est possible de changer le nom du propriétaire après la

création du fichier, par chown.
Celui qui crée le fichier est l’utilisateur, c’est-à-dire :
• habituellement, la personne qui a ouvert la session.

Le nom du propriétaire est alors la valeur $LOGNAME
• exceptionnellement, celui qui a pris les commandes par la commande su .
La commande su
La commande su LeNom permet de lancer un shell avec une identification arbi-
traire LeNom.
Un mot de passe est bien sûr demandé.
Si l’on utilise la syntaxe su - LeNom ,

le shell lancé est un shell de login, qui lit donc les fichiers d’initialisation (du
type .profile).
Dans le cas où le paramètre LeNom est omis, le shell

est lancé avec l’identification du super-utilisateur.
Changer les attributs d’un i-nœud

• chgrp NouvGrp Lobjet
• chown NouvUtil Lobjet
• chmod -Options Lobjet
Remarques :
• en général, seul le super-utilisateur a le droit d’effectuer les deux premières

opérations
• le fichier qui établit les correspondances

GID ←→ NomDuGroupe
est /etc/group
• l’option R permet de faire opérer récursivement sur un répertoire et ses

descendants
chmod en détail
Plus précisément :
chmod ugo±rwx Lobjet
Il existe aussi le symbole = qui permet d’affecter un droit exclusivement des

autres :
chmod ugo=r Lobjet, affecte le mode r et seulement celui-là.
Le symbole a permet d’affecter à tous les utilisateurs un droit :
chmod a+r Lobjet, affecte le mode r à tous les utilisateurs.
Codage octal des modes

Le mode numérique est obtenu ainsi :
• on utilise des chiffres octaux (de 0 à 7), obtenus à partir des chiffres
basiques 1, 2, 4
• le premier chiffre correspond à l’utilisateur, le second au groupe, le troisième
aux autres.
• pour chaque catégorie d’utilisateur : un chiffre 4 correspond à r, un chiffre
2 à w, un chiffre 1 à x, un chiffre 0 à rien.
• le chiffre correspondant à chaque catégorie est obtenu en sommant les
quantités basiques
Ex :
rw correspond à 6=4+2 , rwx correspond à 7
Exemple de codage octal

Le mode 777, qui autorise tout, est très souvent utilisé dans des répertoires
protégés par le mode 700.
$ chmod 500 f500.exe ; chmod 550 f550.exe ; chmod 700 f700.exe
$ chmod 750 f750.exe ; chmod 777 f777.exe
$ ls -l f???
-r-x------ 1 jac pr 29 déc 7 23:38 f500.exe
-r-xr-x--- 1 jac pr 29 déc 7 23:38 f550.exe
-rwx------ 1 jac pr 29 déc 7 23:37 f700.exe
-rwxr-x--- 1 jac pr 29 déc 7 23:36 f750.exe
-rwxrwxrwx 1 jac pr 29 déc 7 23:33 f777.exe
En fait il y a un quatrième chiffre, placé en tête, correspondant aux bits

spéciaux, que nous supposons nul pour l’instant.
Application : échanger des données

Deux utilisateurs partageant un même disque peuvent échanger des données via
/tmp/
• le premier utilisateur copie le fichier LeFic dans la zone /tmp/ :

cp LeFic /tmp/
• le premier utilisateur donne les droits de lecture à ce fichier à tous les

utilisateurs (éventuellement, il peut restreindre au groupe)
chmod a+r /tmp/LeFic
• puis le deuxième utilisateur copie sur son répertoire courant (répertoire .

):
cp /tmp/LeFic .
Bits spéciaux
Pour assurer les protections, le système utilise 9 bits du i-nœud du fichier
indiquant pour chaque catégorie d’utilisateurs et chacune des opérations si
l’opération est réalisable.
De plus 3 autres bits ont un rôle spécial :
• le set-uid bit
• le set-gid bit
• le sticky bit
Le set-uid bit
Le set-uid bit concerne les fichiers binaires exécutables.
Lorsqu’il est positionné, cela indique que le processus correspondant à une

exécution de ce programme a les droits du propriétaire du programme et non
de l’utilisateur qui le lance.
Le set-uid bit
Le set-uid bit concerne les fichiers binaires exécutables.
Lorsqu’il est positionné, cela indique que le processus correspondant à une

exécution de ce programme a les droits du propriétaire du programme et non
de l’utilisateur qui le lance.
C’est ce mécanisme qui permet à tout utilisateur de modifier le fichier

/etc/passwd, dont root est propriétaire, au travers de la commande passwd :
le set-uid bit est positionné pour le fichier de référence /bin/passwd con-

tenant le programme réalisant cette commande.
Exemple de set-uid bit positionné

Le fichier /etc/passwd ne pourrait être modifié que par son possesseur, qui est
root :
$ ls -l /etc/passwd
-rw-r--r-- 1 root root 352 oct 23 2004 /etc/passwd
Mais, grâce au set-uid positionné sur la commande /bin/passwd, qui se

détecte par le fait que le x du propriétaire est remplacé par un s, tout utilisateur
peut la lancer pour modifier /etc/passwd :
$ which passwd
/bin/passwd
$ ls -l /bin/passwd
-r-s--x--x 1 root root 14256 fév 2 2002 /bin/passwd
Le set-gid bit
Le set-gid a le même rôle que le set-uid bit mais relativement au groupe.
Notons (c’est rare) que :
lorsque le set-uid bit ou le set-gid bit est positionné

alors que le bit d’exécution n’est pas positionné,
l’affichage du s est remplacé par l’affichage d’un S.
Le sticky bit
Le sticky bit assure le maintien (collage) d’un programme en zone de swap même
lorsqu’aucun processus actif ne correspond à une exécution du programme.
Ce mode t permet à un programme, de préférence utilitaire, de demeurer en

mémoire ou en zone de swap, même après que son exécution soit terminée
(exemple: un éditeur de texte).
Le sticky bit
Le sticky bit assure le maintien (collage) d’un programme en zone de swap même
lorsqu’aucun processus actif ne correspond à une exécution du programme.
Ce mode t permet à un programme, de préférence utilitaire, de demeurer en

mémoire ou en zone de swap, même après que son exécution soit terminée
(exemple: un éditeur de texte).
On observera que si un fichier a le sticky-bit positionné est que le bit d’exécution

ne l’est pas, le t est remplacé par T
Codage complet à 4 chiffres

Lorsqu’on code complètement les modes en octal
• il y a 4 chiffres
• le premier chiffre correspond aux modes spéciaux :
– set-uid (valeur 4)
– set-gid (valeur 2)
– sticky bit (valeur 1)
$ chmod 4777 f4777.exe ; chmod 1777 f1777.exe

$ ls -l f????
-rwxrwxrwt 1 jac pr 29 déc 7 23:42 f1777.exe
-rwsrwxrwx 1 jac pr 29 déc 7 23:45 f4777.exe

Tests de droits d’accès des fichiers [ ExprTest ] :
4.5. APPROFONDISSEMENT DES COMMANDES LIÉES AUX SYSTÈMES DE FICHIERS79
ExprTest Vraie si
-r Fic Fic lisible par le processus
-w Fic Fic modifiable par le processus
-x Fic Fic exécutable par le processus
-u Fic Fic a le set-uid bit positionné
-g Fic Fic a le set-gid bit positionné
-k Fic Fic a le sticky bit positionné
-O Fic Fic a comme propriétaire celui du processus
-G Fic Fic a comme groupe celui du processus
4.5 Approfondissement des commandes liées aux

systèmes de fichiers
La commande ls
La commande ls -Options Argts permet de visualiser le contenu d’un ou
plusieurs répertoires. Sans argument, il s’agit du répertoire de travail.
Les options sont :
• l : affichage long :
– le type de fichier (-, d, l, s socket, p fifo)

– le mode
– le nombre de liens physiques
– le propriétaire
– le groupe
– la taille (nombre de caractères)
– la date de modification
– la référence du fichier
• i : donne les numéros d’index des fichiers
• a : affiche aussi les fichiers débutant par .
• A : affiche les fichiers débutant par ., sauf . et ..
• d : n’explore pas les répertoires
• t : trie par date (du plus nouveau au plus vieux) (inverse avec r)
Ex :
liste des fichiers .LeNom˜ et des fichiers LeNom.bak
$ ls .*~ *.bak
La commande cp
Elle réalise la copie physique d’un fichier dans un autre.
Il y a création d’un nouvel i-nœud, et recopie effective du contenu du premier

fichier.
$ cp a.a a.b
$ ls -il a.[ab]
850 -rwxrwxrwx 1 jac pr 29 nov 3 20:19 a.a
878 -rwxr-xr-x 1 jac pr 29 déc 7 23:54 a.b
-> On constate que les i-nœuds sont distincts.
La commande mv
La commande mv change l’identificateur d’un lien physique.
$ ls -il a.b
878 -rwxr-xr-x 1 jac pr 29 déc 7 23:54 a.b
$ mv a.b a.c
$ ls -il a.[a-c]
850 -rwxrwxrwx 1 jac pr 29 nov 3 20:19 a.a
878 -rwxr-xr-x 1 jac pr 29 déc 7 23:54 a.c
-> Les i-nœuds de a.b et a.c sont identiques :

ce sont les mêmes fichiers.
La commande rm
La commande rm supprime un lien de fichier.
Pour qu’un fichier soit réellement supprimé sur le disque, il est nécessaire
qu’il n’existe plus aucun lien correspondant à ce fichier.
Cette condition n’est pas suffisante :
si un processus a ouvert ce fichier avant le lancement de rm, le fichier ne sera

supprimé que lorsque le processus aura terminé.
Nouveau lien physique

On peut créer un nouveau lien physique sur un fichier ordinaire ou spécial via
la commande ln (sans option) :
il en résulte que le fichier en question aura différents identificateurs (pas

nécessairement dans le même répertoire).
Règles à respecter :
• les fichiers sur lesquels ces liens physiques sont créés ne peuvent pas être
des répertoires
• les répertoires dans lesquels les liens sont créés doivent appartenir au même
disque logique que les fichiers.
Liens physiques
$ ln LeFic LeLienPhy ; cp LeFic LaCopie
$ cat LeFic
Voici le contenu du fichier LeFic
$ cat LeLienPhy
$ ls -il LeFic LeLienPhy LaCopie
879 -rw-r--r-- 1 jac pr 34 déc 7 22:53 LaCopie
880 -rw-r--r-- 2 jac pr 34 déc 7 22:51 LeFic
880 -rw-r--r-- 2 jac pr 34 déc 7 22:51 LeLienPhy
-> On a donc deux liens qui correspondent au même i-nœud, donc au même
fichier physique.
-> On peut lier dans deux répertoires différents :

ln LeFic ../LeLienLoin
Liens symboliques
On peut créer un fichier de type lien symbolique dont le contenu est l’identificateur
passé en paramètre.
On utilise l’option -s de ln :
ln -s LeFic LeLienSymb
ou bien
ln -s LeRep LeLienSymb
Le fichier peut être un fichier ordinaire ou spécial, ou un répertoire.

Liens symboliques
$ ln -s LeFic LeLienSymb
$ cat LeFic
$ cat LeLienSymb
$ ls -il L[ae]*
881 lrwxrwxrwx 1 jac pr 5 déc 7 22:57 LeLienSymb -> LeFic
-> On a donc deux identificateurs qui ne correspondent pas au même i-nœud.
-> Le compteur de liens physiques du fichier correspondant ne change pas.
Effet de rm sur les liens

$ ls -il L[ae]*
$ rm LeLienPhy ; rm LeLienSymb
$ ls -il Le*
-> Le compteur de liens physiques change.

$ rm LeFic ; ls -il Le* ; cat LeLienSymb
cat: LeLienSymb: Aucun fichier ou répertoire de ce type
Question : comment déterminer si rm va effacer toute trace du fichier LeFic ?

[ ‘ls -l LeFic | tr -s " " | cut -d’ ’ -f2‘ -eq 1 ]
La commande tar
tar -LaClé LeRep
• c : création d’une archive
• f : le mot Unix qui suit sera le nom de l’archive (si f est suivi de -, alors
tar lit ou écrit sur l’entrée ou la sortie standard)
• v : mode bavard
$ tar -cvf - LeRep | gzip > /tmp/LeFic.tar.gz
$ tar -cvf - . | gzip > /tmp/RepCourant.tar.gz
(la deuxième ligne archive le répertoire courant)
La commande tar
tar LaClé LeFic
• x : extraction d’une archive
• o : donne aux fichiers extraits le propriétaire/groupe utilisant tar
$ gunzip /tmp/LeFic.tar.gz
$ tar -xvf /tmp/LeFic.tar
La commande df
df -a LeRep
fournit les informations suivantes :
• le répertoire de montage
• le nom du fichier spécial correspondant
• le nombre de blocs logiques libres
• le nombre de i-nœuds logiques libres
La commande df
$ df -a
SysFichier 1K-blocs Utilisé la capacité disponible Monté sur
/dev/hda1 37428528 34612244 914992 98% /
none 0 0 0 - /proc
none 0 0 0 - /dev
none 0 0 0 - /dev/pts
none 256908 0 256908 0% /dev/shm
/mnt/cdrom 0 0 0 - /mnt/cdrom
/mnt/floppy 0 0 0 - /mnt/floppy
La commande du
du Lobjet
Fournit l’espace alloué aux différents objets (fichiers réguliers, répertoires).
La commande parcourt récursivement les répertoires (sans paramètre, le

répertoire courant est traité)
4.6 Recherche de fichiers

La commande find
Cette commande recherche récursivement dans les répertoires d’une liste de
Répertoires ListeDeRep les fichiers qui satisfont une liste de conditions booléennes
ListeCond
Syntaxe :
find ListeDeRep ListeCond
Les conditions booléennes de ListeCond sont exprimées à l’aides des con-

ventions :
-Prédicat Objet
Ex :
find . -name LeFic -print
Prédicats associés à find

-Prédicat Objet Vrai si
-print toujours vrai : force l’affichage
-name LeFic l’identificateur est LeFic
-perm LaValOctale le droit a cette valeur octale
-type LeType le fichier a le type donné (f,d,l, ...)
-user LeNom le propriétaire est LeNom
-group LeGroupe le propriétaire est LeGroupe
-size LeNbre fichier de taille LeNbre
-inum LeNbre fichier d’i-node LeNbre
-local fichier d’un disque local
-newer LeFic fichier modifié après LeFic
Prédicats associés à find
Les primitives de la page précédente peuvent être composées avec les opérateurs
de :
• négation !
• conjonction (en concaténant les expressions)

• disjonction -o
et les parenthèses 
Ne pas oublier de déspécialiser les caractères spéciaux du shell le cas échéant.

Chapitre 5
Les processus
5.1 Généralités
Concept de processus
Un programme exécutable produit par compilation et édition de liens est un
objet inerte correspondant au contenu d’un fichier régulier sur disque.
Un processus fournit à un instant donné l’image de l’état d’avancement de

l’exécution d’un tel programme.
On peut donc dire qu’un processus est un objet dynamique qui correspond
à l’exécution du programme
Parfois cependant, un processus peut à certains instants donner l’image de

l’exécution de programmes différents du fait de l’utilisation de mécanismes de
recouvrement.
Constitution d’un processus

Un processus est donc constitué :
• du programme qu’il est en train d’exécuter (c’est-à-dire la suite des in-

structions),
• de l’ensemble des données que le programme manipule,
• d’un ensemble d’informations dont le système a besoin pour prendre en

compte le processus : le bloc de contrôle du processus.
85
86 CHAPITRE 5. LES PROCESSUS
Bloc de contrôle du processus
Il comprend entre autres :
• l’ensemble des valeurs des registres du processeur correspondant à l’état

d’avancement de l’exécution,
• la pile d’exécution,
• les liens avec les utilisateurs et le système d’entrées-sorties.
Ordonnanceur
Toutes les activités dans le système, qu’il s’agisse
• d’activités correspondant à des demandes explicites d’utilisateurs
• d’activités purement système visant à gérer les ressources
sont exécutées dans le contexte d’un processus.
L’un des rôles du système est de permettre à tous les processus d’avancer
dans leur exécution.
Le module du noyau appelé ordonnanceur (scheduler) est chargé d’allouer

le (ou les) processeur(s) aux différents processus.
Caractéristiques d’un processus

Quelques caractéristiques d’un processus sont :
• son identification (un nombre entier),
• l’identification du processus parent,
• ses propriétaires,
• ses groupes propriétaires,
• éventuellement son terminal d’attachement,
• d’autres attributs (priorité, répertoire de travail, différents temps, etc...).

5.1. GÉNÉRALITÉS 87
La commande top
Mem: 12996K used, 1312K free, 0K shrd, 940K buff, 5048K cached
Load average: 0.00, 0.00, 0.00 (State: S=sleeping R=running, W=waiting)
PID USER STATUS RSS PPID %CPU %MEM COMMAND
1281 root R 400 1278 0.5 2.7 top
1276 root S 1396 554 0.3 9.7 sshd
609 root S 1800 1 0.0 12.5 openvpn
554 root S 1088 1 0.0 7.6 sshd
534 root S 476 1 0.0 3.3 nas
1278 root S 440 1276 0.0 3.0 ash
590 nobody S 416 1 0.0 2.9 dnsmasq
540 root S 384 1 0.0 2.6 dropbear
547 root S 368 1 0.0 2.5 httpd
98 root S 364 1 0.0 2.5 syslogd
1 root S 356 0 0.0 2.4 init
94 root S 344 1 0.0 2.4 logger
561 root S 336 1 0.0 2.3 crond
477 root S 324 1 0.0 2.2 wifi
99 root S 320 1 0.0 2.2 klogd
557 root S 264 1 0.0 1.8 telnetd
La commande ps
Elle permet à un utilisateur quelconque d’obtenir la liste de processus appar-
tenant à un ensemble particulier ainsi que certaines de leurs caractéristiques.
Les paramètres optionnels de la commande permettent à l’utilisateur d’indiquer

quel ensemble de processus et quelles caractéristiques l’intéressent.
La commande ps
Sans option, la commande fournit la liste des processus qui appartiennent à
la même session que le processus shell depuis lequel la commande est lancée
(c’est-à-dire ceux qui sont attachés au même terminal).
Pour chaque processus de l’ensemble, les informations fournies sont :
• le numéro d’identification du processus (PID),
• le numéro du terminal (TTY),
• le temps cumulé d’exécution du processus (TIME),
• le nom du fichier correspondant au programme exécuté par le processus

(COMMAND).
La commande ps
L’exemple suivant montre les informations minimales fournies par la commande
ps, l’utilisateur n’ayant a priori rien fait d’autre que se connecter via ssh.
$ ps
PID TTY TIME CMD
38596 pts/3 0:00 -bash
37425 pts/3 0:00 ps
La commande ps -u
Syntaxe : ps -u LeNom .
Elle permet d’obtenir pour chaque processus :
• l’identité du propriétaire du processus (UID)
• l’identité du processus (PID)
• le terminal de contrôle du processus (TTY), une valeur ? correspondant

à l’absence de terminal de contrôle
$ ps -u jac
UID PID TTY TIME CMD
383 430 pts/3 0:00 ps
383 596 pts/3 0:00 -bash
383 748 - 0:00 sshd
Commande ps -l
L’option -l permet d’obtenir pour chaque processus :
• l’UID, le PID, le terminal de contrôle
• l’identité du processus père (PPID)
• l’état du processus (F/S) : la valeur R de la colonne S correspond à l’état

actif et la valeur S à l’état endormi (attente d’un événement)
• des informations relatives à la priorité du processus (C/PRI/NI), un nom-

bre petit correspondra à une grande priorité.
• l’adresse du processus (ADDR) et sa taille (SZ)
• la raison de sa mise en sommeil s’il est endormi (WCHAN)

5.1. GÉNÉRALITÉS 89
Exemple
• l’état du processus (F/S) : la valeur R de la colonne S correspond à l’état
actif et la valeur S à l’état endormi (attente d’un événement)
• des informations relatives à la priorité du processus (C/PRI/NI)
• l’adresse du processus (ADDR) et sa taille (SZ)
• la raison de sa mise en sommeil s’il est endormi (WCHAN)
$ ps -l
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
1 S 383 450 596 0 68 24 128e2 432 pts/3 0:00 vi
1 R 383 446 596 2 61 20 128e2 400 pts/3 0:00 ps
1 R 383 596 048 1 60 20 1978 880 pts/3 0:00 -bash
Questions :
quel est le père du processus 450 ?
quel processus aura priorité ?
Exemples de valeurs du champ S de ps

Pour des processus on peut avoir les codes de champ S (state) :
• O : Non-existant
• R : actif
• W : swappé
• S (ou I) : endormi, oisif (Idle)
• T : arrêté
• Z : annulé (ou terminé, ou zombi)
Ceci varie fortement d’un système à l’autre, on peut récupérer les codes
d’une machine donnée par man ps
La terminaison des processus

Tout processus UNIX qui se termine passe dans un état où il n’utilise plus
aucune ressource si ce n’est une entrée dans la table des processus.
On parle de processus terminé, ou annulé, ou dans l’état zombi.

On détecte un processus en état zombi via la colonne S du ps -l où il est
associé à la lettre Z.
$ ps -lu $LOGNAME
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
140 S 503 7787 7785 0 69 0 - 1579 do_sel ? 00:00:00 sshd
000 S 503 7788 7787 0 69 0 - 698 wait4 pts/0 00:00:00 bash
140 S 503 7820 7818 0 69 0 - 1537 do_sel ? 00:00:00 sshd
000 S 503 7821 7820 0 75 0 - 656 wait4 pts/1 00:00:00 bash
000 R 503 10028 7788 16 76 0 - 606 - pts/0 00:00:01 boucler
000 R 503 14032 7821 0 75 0 - 770 - pts/1 00:00:00 ps
004 Z 503 14037 10028 0 75 0 - 0 do_exi pts/0 00:00:00 expr <def
#!/bin/bash
# boucler
while true
do
x=
done
La terminaison des processus

Il est impératif dans le développement d’application multi-processus de prendre
en compte ces processus annulés et de mettre en place les moyens assurant
l’élimination définitive de ces processus.
Dans le cas contraire, la table des processus risquerait de se trouver pleine

de processus inutiles.
La raison d’être de cet état zombi est de permettre la prise en compte de la

terminaison d’un processus par son père et l’acquisition par celui-ci, de manière
asynchrone des informations sur la manière dont il s’est terminé.
Modification de priorité
La commande nice permet à l’utilisateur de modifier la priorité d’un processus
lui appartenant.
• nice -NbrePositif LaCommande

augmente la valeur Nice de NbrePositif unités (NbrePositif est positif).
• nice -n NbreNegatif LaCommande

diminue la valeur Nice de Nbre unités (NbreNegatif est négatif).
En général, seul le super-utilisateur peut réaliser cette augmentation de
la priorité.
5.2. CLASSES DE PROCESSUS 91
5.2 Classes de processus

Partage de temps
A la base, l’ordonnanceur d’UNIX est orienté vers le partage de temps.
Il repose sur l’association d’une priorité dynamique (recalculée périodiquement)

à chaque processus et la stratégie du tourniquet (round robin) pour arbitrer les
conflits entre processus de même priorité.
L’objectif de l’ordonnanceur est d’assurer à chaque processus sa part d’utilisation

du (ou des) processeur(s).
Concept des classes d’ordonnancement

On divise souvent les processus en deux classes d’ordonnancement :
• classe TS : classe des processus en partage de temps, pour laquelle le
concept de priorité dynamique continue de s’appliquer
• classe RT : classe des processus en temps réel pour lesquels le critère
primordial est le temps de réponse et pour lesquels un ordonnanceur du
type précédent est inadapté.
Démons et processus utilisateurs

On distingue classiquement deux types de processus :
• les processus systèmes ou démons
(qui peuvent fonctionner pendant toute la durée de vie du système)
• les processus utilisateurs
correspondant à l’exécution d’une tâche particulière (normalement d’une
durée de vie limitée)
Cette distinction est formelle, et n’a pas de conséquence en matière d’ordonnancement.
Démons
En principe, les processus système (daemons)
• ne sont sous le contrôle d’aucun terminal
• ont comme propriétaire le super-utilisateur.
Leur rôle :
assurer un certain nombre de services généraux accessibles à tous les utilisa-

teurs du système ou de systèmes distants (cas d’un réseau).
Démons
En général les démons ont comme répertoire de travail la racine absolue du
système de fichiers afin de permettre le démontage de disques logiques sans
avoir à les interrompre.
Ces processus peuvent
• être créés au lancement du système
• ou bien à des dates fixées par l’administrateur du système.
Quelques exemples de démons

• init
• lpsched
• cron
• inetd
Démon init
Son rôle est
• d’assurer que sur chaque ligne de communication série asynchrone à laque-

lle est effectivement connecté un terminal alphanumérique,
existe un processus permettant la connexion des utilisateurs (processus
getty)
• de recueillir les processus orphelins, en particulier pour traiter correcte-

ment le problème de l’élimination des processus annulés (état Z)
Ce processus
• a 1 comme numéro
• il est le processus parent des processus shells créés par les utilisateurs se
connectant depuis un terminal alphanumérique classique.
$ ps -elf | head -2
F S UID PID PPID C PRI NI ADDR SZ WCHAN STIME TTY TIME CMD
100 S root 1 0 0 68 0 - 353 do_sel Jan05 ? 00:00:04 init
Démon lpsched
Son rôle :
assurer l’ordonnancement des requêtes d’impression soumises par les utilisa-

teurs vers la (ou les) imprimante(s).
Ces soumissions se font par exemple via la commande lp
Démon cron
Son rôle :
lancer à des dates spécifiées des commandes particulières.
Ces commandes sont par exemple des sauvegardes, des arrêts/redémarrages

de certains services.
Sur un système particulier, certains utilisateurs peuvent être autorisés à

solliciter ce service d’exécution différée ou périodique via les commandes at ou
batch.
Démon inetd
Son rôle :
superviser les différents services réseau utilisant les protocoles Internet.
Il prend en charge les requêtes distantes

(i.e. émises depuis d’autres systèmes du réseau)
telles que des demandes :
• de connexion distante
• d’exécution de commandes ou de procédures distantes
• de copie de fichiers.
Le démon crée alors à la demande un processus permettant la satisfaction

d’une requête lorsqu’elle est reçue.
Les processus utilisateurs

Rappel :
Les processus utilisateurs sont dédiés à l’exécution d’une tâche particulière,

normalement de durée de vie limitée (mais non bornée).
Processus utilisateurs après connexion

La phase de connexion d’un utilisateur se termine par la création d’un processus
utilisateur qui correspond à l’exécution d’un programme déterminé à l’avance
pour chaque utilisateur (une référence du fichier contenant le programme à
exécuter est spécifiée dans le fichier système /etc/passwd).
Processus utilisateurs après connexion

La phase de connexion d’un utilisateur se termine par la création d’un processus
utilisateur qui correspond à l’exécution d’un programme déterminé à l’avance
pour chaque utilisateur (une référence du fichier contenant le programme à
exécuter est spécifiée dans le fichier système /etc/passwd).
C’est en général un processus correspondant à l’exécution d’un interprète de

langage de commandes shell.
C’est à un tel interprète que l’utilisateur soumettra des commandes dont

l’exécution entraı̂nera, généralement, la création d’au moins un processsus.
Autre génèse de processus utilisateurs

La création de processus utilisateurs peut également être réalisée
• par échappement à des commandes telles que les éditeurs par exemple
• ou si une application programmée par l’utilisateur fait appel à la primitive

de création de processus fork.
Note : le nombre de processus qui peuvent être créés par un utilisateur donné
peut parfois être volontairement limité.
Remarque :
la plupart des processus des utilisateurs sont sous le contrôle d’un terminal,
mais cela n’est absolument pas une caractéristique d’un processus utilisateur.
Commande at
La commande lit sur l’entrée standard une suite de commandes destinée à être
exécutée ultérieurement.
Syntaxes :
• at LeMoment LaDate +LapsDeTemps
• at -f LeFicCommandes LeMoment
lit la suite de commandes dans un fichier
echo "/usr/bin/mail -s \" envoi différé \" jac@machine.fr < LeFic"

at now + 5 hours
• at -l affiche la liste des commandes enregistrées.

• at -d permet d’annuler une commande enregistrée.
Commande at
at LeMoment LaDate +LapsDeTemps
• les commandes utilisent le shell de lancement du répertoire de travail et

les variables d’environnement
• la sortie standard et l’erreur standard sont implicitement dirigées vers la
boı̂te à lettres de l’utilisateur.
• LeMoment peut avoir les formes suivantes : h, hh, hhmm, h:m, h:mm, hh:m ,
hh:mm
• on peut utiliser aussi : noon, midnight, today, tomorrow
• now, avec incrément
• LapsDeTemps : un nombre suivi d’une unité (minutes, hours, days,
weeks, months)
Commande at
Les fichiers de configuration de la commande at:
• si /etc/at.allow existe, seuls les utilisateurs qui y sont listés peuvent

utiliser at
• si /etc/at.allow n’existe pas, /etc/at.deny est lu, et tout utilisateur
qui n’y est pas listé peut exécuter at
• si aucun de ces deux fichiers n’existe, seul le super-utilisateur peut utiliser
at
Configuration par défault :

existence de /etc/at.deny seulement, et sans aucun enregistrement (tout
utilisateur peut alors utiliser at).
Les signaux
La commande kill permet d’envoyer manuellement des signaux à un processus
(ou un groupe de processus).
Syntaxe : kill -Nbre PID ou kill -Sig PID
Nbre Sig Effet

9 KILL terminaison
Sur certains systèmes on a ainsi les signaux :
15 STOP suspension
17 CONT reprise
La commande kill -l permet d’afficher la liste complète des signaux re-
connus par le système.
Les codes peuvent varier sensiblement.
Exécution : programmes réentrants

L’exécution d’un processus suppose l’existence en mémoire centrale de tout ou
partie d’un programme binaire en vue de son exécution.
La majorité des programmes standard d’UNIX sont réentrants : si plusieurs

processus (n’appartenant pas nécessairement au même utilisateur) correspon-
dent à l’exécution d’un même programme, un seul exemplaire physique en
mémoire centrale du programme est partagé par ces différents processus.
Les codes construits par l’éditeur de liens sont par défaut réentrants.
Cette propriété suppose que la zone programme d’un processus soit protégée
en écriture.
Mode utilisateur et mode noyau

Les processus peuvent s’exécuter dans deux modes différents:
• le mode utilisateur (user mode) : dans ce mode le processus n’accède

qu’à son espace d’adressage et exécute des instructions du programme
correspondant (par exemple affecter à un objet z la somme des valeurs de
deux objets x et y)
• le mode noyau ou système (kernel mode) :

le processus exécute alors des instructions qui n’appartiennent pas au pro-
gramme en cours mais au noyau.
Il a accès dans ce mode à des données externes à son espace d’adressage

(essentiellement les tables du système).
Ce passage en mode noyau peut être provoqué de deux manières différentes.
• soit par demande de réalisation d’un appel système par le processus lui-
même,
• soit par une interruption extérieure nécessitant l’exécution d’une séquence

particulière pour la traiter (handler d’interruption).
Génétique des processus et fonction fork

Il existe un processus originel qui a pour identification 0.
Le processus init a pour identification 1.
Puis, tout nouveau processus est le résultat de l’exécution, par le système et

à la demande d’un autre processus, de la fonction de création (appel système
fork).
Un processus UNIX possède un certain nombre de caractéristiques dont cer-

taines sont susceptibles de changer au cours du temps.
Certaines de ses caractéristiques sont héritées du processus parent.
Code après terminaison d’un processus

Tout processus UNIX qui se termine possède une valeur appelée code de retour
(exit status) à laquelle son père peut accéder de manière asynchrone (c’est-à-dire
n’importe quand après que cette terminaison ait eu lieu).
• un code de retour nul correspond à un comportement normal du processus
• un code de retour non nul correspond à la détection par le processus

situation anormale (en cours d’exécution ou à la terminaison).
Terminaison interactive des processus

Normalement un processus (bien entendu s’il ne se trouve pas en arrière-plan)
lancé depuis un shell interactif peut être annulé par l’envoi depuis le terminal
d’un signal d’interruption.
Un tel shell interactif capte le signal et l’envoie au processus, et l’invite du

shell est affichée dès la terminaison du processus.
Ce signal, dénommé généralement SIGINT, est envoyé à la suite de la frappe

simultanée des touches control et c .
On désigne cette séquence de touches par la notation symbolique < ctrl c

>
Contrôle des tâches

Ce mécanisme, plus souple que le contrôle des processus, utilise sa propre syn-
taxe
La commande jobs ou jobs -l

permet de lister les tâches en cours, en associant à chacune d’elles un numéro.
On peut ensuite désigner une tâche par la syntaxe %Nbre
Par exemple, on peut utiliser des commandes

fg %Nbre ou bg %Nbre
pour respectivement passer en avant-plan ou en arrière-plan une tâche de

numéro Nbre.
Contrôle des tâches

$ ./boucler &
$ jobs
[1]+ Running ./boucler &
$ kill -SIGSTOP %1
$ jobs
[1]+ Stopped ./boucler
$ kill -SIGCONT %1
$ jobs
[1]+ Running ./boucler &
$ kill -9 %1
$ jobs
[1]+ Processus arrêté ./boucler
$ jobs
Gestion du terminal
• clear effacement du terminal
• stty cette commande permet entre autres de définir les séquences de
touches correspondant à certains signaux.
– stty -a donne la liste des séquences

– stty erase ’^h’ permet de donner à <ctrl h> l’effet du caractère
d’effacement
– stty intr ’^c’ permet de donner à <ctrl c> l’effet du caractère
de contrôle d’interruption
Commande stty
$ stty -a
speed 38400 baud; rows 24; columns 80; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = Û; eof = ^D;
eol = <undef>; eol2 = <undef>; start = ^Q; stop = ^S;
susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V; flush = Ô;
min = 1; time = 0; -parenb -parodd cs8 -hupcl -cstopb cread
-clocal -crtscts -ignbrk -brkint -ignpar -parmrk -inpck -istrip
-inlcr -igncr icrnl ixon -ixoff -iuclc -ixany -imaxbel opost
-olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0
bs0 vt0 ff0 isig icanon iexten echo echoe echok -echonl -noflsh
-xcase -tostop -echoprt
Table des matières
1 Commandes et environnement du shell bash 3

1.1 Redirections des entrées-sorties . . . . . . . . . . . . . . . . . . . 3
Entrées-sorties de commandes . . . . . . . . . . . . . . . . . . . . 3
La sortie erreur standard . . . . . . . . . . . . . . . . . . . . . . 3
Entrée et sortie standards . . . . . . . . . . . . . . . . . . . . . . 4
Redirection de la sortie standard . . . . . . . . . . . . . . . . . . 4
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Redirection avec concaténation . . . . . . . . . . . . . . . . . . . 5
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Affichage des sorties et redirection . . . . . . . . . . . . . . . . . 6
Mise en évidence de l’erreur standard . . . . . . . . . . . . . . . . 6
Redirection de l’entrée standard . . . . . . . . . . . . . . . . . . . 6
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Composition de commandes . . . . . . . . . . . . . . . . . . . . . 7
Tubes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Aspect chronologique . . . . . . . . . . . . . . . . . . . . . . . . . 8
Généralisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Enchaı̂nement de commandes . . . . . . . . . . . . . . . . . . . . 9
Parenthèsage et enchaı̂nement . . . . . . . . . . . . . . . . . . . . 9
Redirection de l’erreur standard . . . . . . . . . . . . . . . . . . . 10
Redirections simultanées . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Code de retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Valeur de retour d’une commande . . . . . . . . . . . . . . . . . 10
Composition conditionnelle Et Alors . . . . . . . . . . . . . . . . 11
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Composition conditionnelle Ou Sinon . . . . . . . . . . . . . . . . 11
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Lancement en arrière-plan . . . . . . . . . . . . . . . . . . . . . . 12
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3 Variables d’un shell . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Valeur d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . 13
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
101
102 TABLE DES MATIÈRES
Assignation de valeur . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Langage de commande bash 15

2.1 Initiation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Les scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Intérêt des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Introduction d’un paramètre . . . . . . . . . . . . . . . . . . . . 16
Traitement d’une liste de paramètres . . . . . . . . . . . . . . . . 16
Mode exécutable d’un script . . . . . . . . . . . . . . . . . . . . . 16
Un script à deux paramètres . . . . . . . . . . . . . . . . . . . . . 17
Premières règles d’écriture . . . . . . . . . . . . . . . . . . . . . . 17
Terminaison impérative . . . . . . . . . . . . . . . . . . . . . . . 17
Messages de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Paramètres d’un script . . . . . . . . . . . . . . . . . . . . . . . . 18
Parenthèsage des commandes . . . . . . . . . . . . . . . . . . . . 18
Notation des paramètres . . . . . . . . . . . . . . . . . . . . . . . 19
Expressions conditionnelles . . . . . . . . . . . . . . . . . . . . . 19
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Expressions conditionnelles sur fichiers . . . . . . . . . . . . . . . 20
Expressions conditionnelles sur entiers . . . . . . . . . . . . . . . 20
Expressions conditionnelles sur chaı̂nes . . . . . . . . . . . . . . . 20
Expressions conditionnelles sur booléens . . . . . . . . . . . . . . 21
Pièges des tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Combinaisons de conditions . . . . . . . . . . . . . . . . . . . . . 22
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Structure de contrôle conditionnelle . . . . . . . . . . . . . . . . 23
Structure de contrôle conditionnelle . . . . . . . . . . . . . . . . 23
Structure de contrôle par aiguillage . . . . . . . . . . . . . . . . . 24
Lecture de mots Unix au clavier . . . . . . . . . . . . . . . . . . . 24
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Structure de contrôle itérative . . . . . . . . . . . . . . . . . . . . 25
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Structure de contrôle itérative . . . . . . . . . . . . . . . . . . . . 25
Ejection d’itérative . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.2 Approfondissement . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Métacaractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Expansion des noms de fichiers . . . . . . . . . . . . . . . . . . . 27
Règles du mécanisme d’expansion . . . . . . . . . . . . . . . . . . 27
Délimiteurs de chaı̂nes . . . . . . . . . . . . . . . . . . . . . . . . 27
Délimiteur quote . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Délimiteur doublequote . . . . . . . . . . . . . . . . . . . . . . . 28
Délimiteur antiquote . . . . . . . . . . . . . . . . . . . . . . . . . 28
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Gestion du caractère espace . . . . . . . . . . . . . . . . . . . . . 29
Calculs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
TABLE DES MATIÈRES 103
Arithmétique entière . . . . . . . . . . . . . . . . . . . . . . . . . 30
Incrément, décrément . . . . . . . . . . . . . . . . . . . . . . . . 30
Décalage d’arguments . . . . . . . . . . . . . . . . . . . . . . . . 30
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Exemple, suite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Exemple, suite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Variables de position . . . . . . . . . . . . . . . . . . . . . . . . . 33
Autres notations liées aux paramètres . . . . . . . . . . . . . . . 33
Substitutions conditionnelles :- . . . . . . . . . . . . . . . . . . . 33
Autres substitutions conditionnelles . . . . . . . . . . . . . . . . 34
Expressions conditionnelles sur chaı̂nes . . . . . . . . . . . . . . . 34
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Syntaxes alternatives pour calculs . . . . . . . . . . . . . . . . . . 35
Syntaxes alternatives pour calculs . . . . . . . . . . . . . . . . . . 35
Classes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.3 Compléments sur l’environnement . . . . . . . . . . . . . . . . . 36
Variables d’Environnement . . . . . . . . . . . . . . . . . . . . . 36
Variables locales et d’environnement . . . . . . . . . . . . . . . . 36
Exportation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Manipulation de variables . . . . . . . . . . . . . . . . . . . . . . 37
Initialisation de l’Environnement . . . . . . . . . . . . . . . . . . 37
Initialisation de l’Environnement . . . . . . . . . . . . . . . . . . 38
Définition de synonymes . . . . . . . . . . . . . . . . . . . . . . . 38
Fichier d’alias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Le répertoire utilisateur . . . . . . . . . . . . . . . . . . . . . . . 39
Chemin de recherche des commandes . . . . . . . . . . . . . . . . 39
Recherche de commande . . . . . . . . . . . . . . . . . . . . . . . 39
Modifier le chemin de recherche . . . . . . . . . . . . . . . . . . . 40
Exemple de .profile . . . . . . . . . . . . . . . . . . . . . . . . 40
3 Expressions régulières et applications 41

3.1 Les expressions régulières basiques . . . . . . . . . . . . . . . . . 41
Expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . 41
Les caractères spéciaux . . . . . . . . . . . . . . . . . . . . . . . 41
Caractère spécial [ . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Caractère spécial . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Caractère spécial * . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Caractère spécial * . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Caractère spécial ] . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Caractère spécial - . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Caractère spécial ^ . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Caractère spécial ^ . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Caractères spéciaux $ et \ . . . . . . . . . . . . . . . . . . . . . . 44
Expressions régulières atomiques . . . . . . . . . . . . . . . . . . 44

Expressions régulières atomiques . . . . . . . . . . . . . . . . . . 45
Expressions régulières générales . . . . . . . . . . . . . . . . . . . 45
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2 Application à l’édition de flux . . . . . . . . . . . . . . . . . . . . 50
L’éditeur sed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Substitution simple . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Tampons d’édition . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Algorithme de sed . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Algorithme de sed : détail d’un cycle . . . . . . . . . . . . . . . . 51
Substitution globale . . . . . . . . . . . . . . . . . . . . . . . . . 51
Substitution sur position . . . . . . . . . . . . . . . . . . . . . . . 52
Destruction de lignes . . . . . . . . . . . . . . . . . . . . . . . . . 52
Destruction de lignes . . . . . . . . . . . . . . . . . . . . . . . . . 52
Sélection de motifs . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Sélection de motifs . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Remplacement de caractères . . . . . . . . . . . . . . . . . . . . . 53
Opérations directes dans un fichier . . . . . . . . . . . . . . . . . 54
Edition d’une sélection de lignes . . . . . . . . . . . . . . . . . . 54
Traitement de lignes consécutives . . . . . . . . . . . . . . . . . . 54
Traitement de blocs de lignes . . . . . . . . . . . . . . . . . . . . 55
Affichage des numéros de ligne . . . . . . . . . . . . . . . . . . . 56
Affichage des numéros de ligne . . . . . . . . . . . . . . . . . . . 56
Négation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4 Les systèmes de fichiers 59

4.1 Principes d’organisation . . . . . . . . . . . . . . . . . . . . . . . 59
Notion de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Quelques types de fichiers . . . . . . . . . . . . . . . . . . . . . . 59
i-nœuds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Identification d’un fichier . . . . . . . . . . . . . . . . . . . . . . 60
Afficher les indices . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Numérotation des i-nœuds . . . . . . . . . . . . . . . . . . . . . . 60
Le type d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . 61
Catégories de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . 61
Répertoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Répertoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Référençage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Organisation des intra-arborescences . . . . . . . . . . . . . . . . 62
Montage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
La commande mount . . . . . . . . . . . . . . . . . . . . . . . . . 63
Montage NFS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2 Les références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Fichiers accessibles et chemins d’accès . . . . . . . . . . . . . . . 63
Références absolues d’un fichier . . . . . . . . . . . . . . . . . . . 63
Répertoires de travail . . . . . . . . . . . . . . . . . . . . . . . . 64
Références relatives . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Références relatives . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Les liens .. et . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Répertoires (presque) vides . . . . . . . . . . . . . . . . . . . . . 65
Répertoire privé . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.3 Les différents types de fichiers . . . . . . . . . . . . . . . . . . . . 66
Les fichiers ordinaires ou réguliers . . . . . . . . . . . . . . . . . . 66
Les répertoires usuels . . . . . . . . . . . . . . . . . . . . . . . . . 66
Répertoire /bin . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Les répertoires usuels . . . . . . . . . . . . . . . . . . . . . . . . . 67
Répertoire /etc . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Les fichiers spéciaux . . . . . . . . . . . . . . . . . . . . . . . . . 67
Modes de fichiers spéciaux . . . . . . . . . . . . . . . . . . . . . . 68
Autres types de fichiers . . . . . . . . . . . . . . . . . . . . . . . 68
Structure des nœuds d’index . . . . . . . . . . . . . . . . . . . . 68
4.4 Les droits d’accès aux fichiers . . . . . . . . . . . . . . . . . . . . 69
Les groupes d’utilisateurs . . . . . . . . . . . . . . . . . . . . . . 69
Catégories d’utilisateurs d’un fichier . . . . . . . . . . . . . . . . 69
Les types d’opérations . . . . . . . . . . . . . . . . . . . . . . . . 69
Indicateurs de mode d’un fichier . . . . . . . . . . . . . . . . . . 70
Indicateurs de mode d’un répertoire . . . . . . . . . . . . . . . . 70
Mode x pour des répertoires . . . . . . . . . . . . . . . . . . . . . 70
Répertoires en mode x . . . . . . . . . . . . . . . . . . . . . . . . 70
Modes r et w des répertoires . . . . . . . . . . . . . . . . . . . . . 71
Répertoires en mode rw . . . . . . . . . . . . . . . . . . . . . . . 71
Répertoires et modes . . . . . . . . . . . . . . . . . . . . . . . . . 71
Répertoires en mode wx . . . . . . . . . . . . . . . . . . . . . . . 72
Répertoires en mode rx . . . . . . . . . . . . . . . . . . . . . . . 72
Le cas des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Le super-utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Propriétaire d’un fichier . . . . . . . . . . . . . . . . . . . . . . . 74
La commande su . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Changer les attributs d’un i-nœud . . . . . . . . . . . . . . . . . 74
chmod en détail . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Codage octal des modes . . . . . . . . . . . . . . . . . . . . . . . 75

Exemple de codage octal . . . . . . . . . . . . . . . . . . . . . . . 75
Application : échanger des données . . . . . . . . . . . . . . . . . 76
Bits spéciaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Le set-uid bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Le set-uid bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Exemple de set-uid bit positionné . . . . . . . . . . . . . . . . . . 77
Le set-gid bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Le sticky bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Le sticky bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Codage complet à 4 chiffres . . . . . . . . . . . . . . . . . . . . . 78
4.5 Approfondissement des commandes liées aux systèmes de fichiers 79
La commande ls . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
La commande cp . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
La commande mv . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
La commande rm . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Nouveau lien physique . . . . . . . . . . . . . . . . . . . . . . . . 81
Liens physiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Liens symboliques . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Liens symboliques . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Effet de rm sur les liens . . . . . . . . . . . . . . . . . . . . . . . 82
La commande tar . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
La commande tar . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
La commande df . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
La commande df . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
La commande du . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.6 Recherche de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . 84
La commande find . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Prédicats associés à find . . . . . . . . . . . . . . . . . . . . . . . 84
Prédicats associés à find . . . . . . . . . . . . . . . . . . . . . . . 84
5 Les processus 85
5.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Concept de processus . . . . . . . . . . . . . . . . . . . . . . . . . 85
Constitution d’un processus . . . . . . . . . . . . . . . . . . . . . 85
Bloc de contrôle du processus . . . . . . . . . . . . . . . . . . . . 86
Ordonnanceur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Caractéristiques d’un processus . . . . . . . . . . . . . . . . . . . 86
La commande top . . . . . . . . . . . . . . . . . . . . . . . . . . 87
La commande ps . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
La commande ps . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
La commande ps . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
La commande ps -u . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Commande ps -l . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Exemples de valeurs du champ S de ps . . . . . . . . . . . . . . . 89

La terminaison des processus . . . . . . . . . . . . . . . . . . . . 89
La terminaison des processus . . . . . . . . . . . . . . . . . . . . 90
Modification de priorité . . . . . . . . . . . . . . . . . . . . . . . 90
5.2 Classes de processus . . . . . . . . . . . . . . . . . . . . . . . . . 91
Partage de temps . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Concept des classes d’ordonnancement . . . . . . . . . . . . . . . 91
Démons et processus utilisateurs . . . . . . . . . . . . . . . . . . 91
Démons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Démons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Quelques exemples de démons . . . . . . . . . . . . . . . . . . . . 92
Démon init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Démon lpsched . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Démon cron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Démon inetd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Les processus utilisateurs . . . . . . . . . . . . . . . . . . . . . . 93
Processus utilisateurs après connexion . . . . . . . . . . . . . . . 94
Processus utilisateurs après connexion . . . . . . . . . . . . . . . 94
Autre génèse de processus utilisateurs . . . . . . . . . . . . . . . 94
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Commande at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Commande at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Commande at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Les signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Exécution : programmes réentrants . . . . . . . . . . . . . . . . . 96
Mode utilisateur et mode noyau . . . . . . . . . . . . . . . . . . . 96
Génétique des processus et fonction fork . . . . . . . . . . . . . . 97
Code après terminaison d’un processus . . . . . . . . . . . . . . . 97
Terminaison interactive des processus . . . . . . . . . . . . . . . 97
Contrôle des tâches . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Contrôle des tâches . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Gestion du terminal . . . . . . . . . . . . . . . . . . . . . . . . . 98
Commande stty . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

Notes Cours Unix Bash

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Notes Cours Unix Bash

Transféré par

Droits d'auteur :

Formats disponibles

Système UNIX et programmation sous bash

1.1 Redirections des entrées-sorties

Il est nécessaire pour cela d’avoir des mécanismes permettant de rediriger le

La sortie erreur standard

En mode interactif, ce message est envoyé à l’écran.

supposons que le répertoire Rep ne contienne pas de fichier NomFic. Dans ce

Entrée et sortie standards

Généralement, les commandes lisent l’entrée standard et/ou écrivent sur la

Normalement, l’entrée standard est le clavier et la sortie standard est l’écran.

Redirection de la sortie standard

NomCommande [-Options] [arguments] > FicSortie

date > Fic

who > Fic

Redirection avec concaténation

Si on veut que ce contenu soit préservé et y ajouter des résultats d’une

NomCommande [-Options] [argts] >> FicSortie

date > Fic

On enregistre les mêmes informations automatiquement une heure plus tard :

echo "date >> Fic" | at now +1 hour

echo "ls -l * >> Fic" | at now +1 hour

Affichage des sorties et redirection

La première ligne correspond à l’affichage de l’erreur standard

Mise en évidence de l’erreur standard

$ ls NomFic1 NomFic2 > Resultat

Seule la première ligne correspondant à l’affichage de l’erreur standard sub-

Redirection de l’entrée standard

NomCommande [-Options] [arguments] < FicEntrée

Soit un fichier Fic composé de :

pour mettre tout en majuscules on peut effectuer

tr ’[a-z]’ ’[A-Z]’ < Fic

tr ’[[:lower:]]’ ’[[:upper:]]’ < Fic

• rediriger la sortie de la première commande vers un fichier FicInter,

• puis rediriger l’entrée de la deuxième commande afin qu’elle lise ce fichier

• puis supprimer FicInter.

NomCommande1 [-Options] [arguments] | NomCommande2 [-Options] [arguments]

netstat -an | grep ’LISTEN’

tar -cvf - . | gzip > /tmp/Rep.tar.gz

l’opération inverse étant

gunzip /tmp/Rep.tar.gz | tar -xvf

• elles s’exécutent simultanément,

• et sont synchronisées par le système.

Eventuellement la première commande peut être temporairement bloquée si

Com1 | Com2 | Com3 | ....... | ComN

cat, wc, sort, grep sont des filtres,

On utilise la notation ; qui est un séparateur de commandes.

Redirection de l’erreur standard

NomCommande 2> FicErreur

$ ls NomFic1 NomFic2 2> /dev/null

On peut décider de rediriger à la fois la sortie d’erreur et la sortie standard,

NomCommande > FicSortie 2> FicErreur

NomCommande 1> FicSortie 2> FicErreur

1.2 Code de retour

• 0 si tout s’est déroulé normalement

• une valeur non nulle en cas d’erreur

Une commande peut donc être assimilée à un prédicat :

• elle vaut VRAI (0) si tout c’est bien passé

• elle vaut FAUX ( 6= 0) en cas d’erreur.

Le code de retour de la dernière commande réalisée est la valeur $?

Composition conditionnelle Et Alors

Comm1 && Comm2

La commande Comm2 ne sera appelée que si Comm1 a renvoyé une valeur de

Afficher, puis Effacer tous les fichiers temporaires :

$ ls -lart /tmp/* && rm -i /tmp/*

Composition conditionnelle Ou Sinon