IUT Aix-en-Provence

Département Informatique

Cours 3 d’Unix

Cyril Pain-Barre
Année 2003-2004
 Sommaire

I. Un peu plus de commandes ............................................................................................................. 3

I.1. cat : concaténer des fichiers ...................................................................................................... 3
I.2. wc : compter les caractères, mots et lignes de fichiers.............................................................. 4
I.3. file : analyser le contenu d’un fichier .......................................................................................... 4
I.4. expr : calculer une expression ................................................................................................... 5
I.5. find : rechercher des fichiers ...................................................................................................... 7
I.6. tty : connaître son terminal....................................................................................................... 10
II. Processus ...................................................................................................................................... 11
II.1. Introduction.............................................................................................................................. 11
II.2. Processus lancés par un shell ................................................................................................ 11
II.3. Lancement en parallèle........................................................................................................... 12
II.4. jobs : lister les processus lancés par le shell .......................................................................... 13
II.5. ps : obtenir une liste de processus existants .......................................................................... 13
II.6. Agir sur un processus avec les caractères de contrôle .......................................................... 15
II.7. kill : tuer un processus gênant ................................................................................................ 15
III. Expressions régulières et utilitaires .............................................................................................. 16
III.1. Présentation ........................................................................................................................... 16
III.2. Utilisation dans vi ................................................................................................................... 19
III.3. grep : filtrer les lignes de fichiers............................................................................................ 19

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 3/21

I. Un peu plus de commandes

I.1. cat : concaténer des fichiers

La commande permettant de concaténer des fichiers est la commande cat. Elle sert aussi
beaucoup pour visualiser des petits fichiers.

Utilisation :

cat {référence}

Elle ne fait qu’écrire sur sa sortie standard le contenu des fichiers qui lui sont passés en
arguments. Ils apparaissent ainsi concaténés à l’écran (collés les uns à la suite des autres).
Sans argument, cat se contente d’écrire sur sa sortie standard ce qu’elle lit sur son entrée
standard, jusqu’à rencontrer la marque de fin de fichiers (Ctrl d).

Pour créer un fichier avec cat, il faut rediriger sa sortie standard. Si en plus aucun
argument n’est spécifié, c’est ce qui est tapé au clavier qui est écrit dans le fichier.

Exemples
[cpb@duo tpunix]$ cat [Link]
#include <iostream>

using namespace std;

int main (void)

{
cout << "Ce texte a été écrit sur la sortie standard" << endl ;
cerr << "Ce texte a été écrit sur la sortie d’erreur" << endl ;
return 0;

} // main()

affichage à l’écran du contenu du fichier [Link]. Celui-ci contient

visiblement un petit programme C++ qui écrit un message dans chaque sortie
(standard et erreur).
[cpb@duo tpunix]$ cat fic* > les_fic

création du fichier les_fic qui contient la concaténation du contenu de tous les

fichiers dont le nom commence par fic. Les fichiers sont concaténés dans l’ordre
ASCII de leur nom (par exemple, fic1 avant fic2…).

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 4/21

[cpb@duo tpunix]$ cat > [Link]

Tout ce texte jusqu’à l’appui de la touche Ctrl-d sera écrit...
(même cette ligne)
...dans le fichier [Link].
Magique, non ?

Ctrl d

sans argument, cat écrit sur sa sortie standard (ici, le fichier [Link]) ce
qu’elle lit sur son entrée standard (ici le clavier).

I.2. wc : compter les caractères, mots et lignes de fichiers

La commande wc permet d’effectuer tout ou partie de ces comptages, sur un ou plusieurs
fichiers.

Utilisation :

wc [-cwl] {référence}

Effectue le comptage des caractères (si –c positionnée), des mots (si –w) et des lignes (si
-l) de chacun des fichiers passés en arguments ou, à défaut, ce qu’elle lit sur son entrée
standard jusqu’à rencontrer Ctrl d (la marque de fin de fichier). Si aucune option n’est
spécifiée, wc effectue les trois comptages.

Exemples
[cpb@duo tpunix]$ wc -l /etc/passwd
258 /etc/passwd

Il y a (a priori) 258 utilisateurs recensés dans le fichier /etc/passwd.

[cpb@duo tpunix]$ ls /users/etud1 | wc -l
48

Il y a 137 fichiers dans le répertoire /users/etud1.

I.3. file : analyser le contenu d’un fichier

Les extensions des noms de fichiers étant libres, il n’est pas évident de savoir ce que
contient un fichier sans risquer de faire une bêtise. La commande file analyse le contenu des
fichiers (ou répertoires) passés en arguments et indique ce qu’il contient (lorsqu’elle arrive à
le déterminer…).

Utilisation :

file référence {référence}

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 5/21

Exemples
[homer@duo ~]$ ls -ld Public mbox [Link] /bin/tcsh /dev/sda1
-rwxr-xr-x 1 root root 258288 mar 7 2000 /bin/tcsh
brw-rw---- 1 root disk 8, 1 mai 5 1998 /dev/sda1
drwx------ 5 cpb prof 1024 sep 13 07:05 Public
-rw-r--r-- 1 cpb prof 1063 sep 19 01:06 [Link]
-rw------- 1 cpb prof 551 sep 5 11:35 mbox
[homer@duo ~]$ file Public mbox [Link] /dev/sda1 /bin/tcsh
Public: directory
mbox: English text
[Link]: ASCII C program text
/dev/sda1: block special (8/1)
/bin/tcsh: ELF 32-bit LSB executable, Intel 80386, version 1, dynamically
linked (uses shared libs), stripped

file indique que le premier fichier est un répertoire, le second est un fichier
contenant du texte en anglais, le troisième est le source d’un programme C++, le
quatrième est (une partition d’)un disque dur. Le dernier fichier est un fichier
binaire exécutable.

I.4. expr : calculer une expression

Une commande permettant d’effectuer des calculs numériques et des comparaisons est
expr. Elle peut réaliser aussi d’autres évaluations, notamment sur les chaînes. Le résultat de
l’expression est écrit sur la sortie standard. En revanche, la valeur de retour de expr (voir
« Erreur ! Source du renvoi introuvable. », page Erreur ! Signet non défini.) indique
simplement son succès ou son échec, selon que l’expression était bien formée et évaluable ou
non. Nous ne nous intéresserons qu’à l’évaluation d’expressions arithmétiques et aux
comparaisons.

Utilisation

expr opérande1 opérateur opérande2

Les arguments de expr doivent être séparés par des blancs. opérateur peut être soit un
opérateur arithmétique soit de comparaison.

Opérateurs arithmétiques :

Si l’opérateur est arithmétique, les opérandes doivent être des entiers (positifs ou
négatifs). Si leur signe est spécifié, il doit être collé aux chiffres. Les opérateurs
arithmétiques possibles sont :

+ addition

- soustraction

* multiplication

/ division

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 6/21

% reste de la division entière (Attention, c’est l’opérateur rem de Ada)

Opérateurs de comparaison :

La comparaison est numérique si les opérandes sont des entiers, et lexicographique

(ordre ASCII) sinon. expr affiche 1 si la comparaison est vraie, 0 sinon. Les opérateurs de
comparaison sont :

< strictement inférieur

<= inférieur ou égal

= égal

!= différent

>= supérieur ou égal

> strictement supérieur

Comme d’habitude, les caractères spéciaux doivent être protégés de l’interprétation

par le shell.

Exemples

Opérations arithmétiques :
[cpb@duo ~]$ expr 2 + 3
5
[cpb@duo ~]$ expr 2 \* 3
6
[cpb@duo ~]$ expr 2 - -3
5
[cpb@duo ~]$ expr 7 % -3
1

Comparaisons :
[cpb@duo ~]$ expr 2 \< 3
1
[cpb@duo ~]$ expr 2 \> 3
0
[cpb@duo ~]$ expr toto = tutu
0
[cpb@duo ~]$ expr toto \>= tutu
0
[cpb@duo ~]$ expr toto \<= tutu
1

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 7/21

I.5. find : rechercher des fichiers

La recherche de fichiers (ou répertoires) est réalisée par la commande find. Elle admet un
grand nombre de critères possibles que l’on peut combiner en utilisant des opérateurs
logiques. Elle nous permet même de fabriquer nos propres critères.

Utilisation

find {réf_rép} [expression]

réf_rép sont des références à des répertoires existants. La recherche de fichiers

correspondant aux critères mentionnés par expression va être opérée dans toute l’arborescence
de chacun de ces répertoires (eux y compris). Tous les fichiers accessibles dans ces
arborescences vont être passés, l’un après l’autre, aux cribles des critères exprimés dans
expression. Si expression n’est pas présente, alors le critère –print est pris par défaut (et find
affiche une référence pour chaque fichier accédé).

Le premier argument commençant par un des caractères ‘–’, ‘(’, ‘)’, ‘!’ ou ‘,’ marque le
début de expression. Ce qui précède est considéré comme des réf_rép. Si aucune réf_rép n’est
spécifiée, le répertoire de travail (point) est pris par défaut.

expression est toujours évaluée de gauche à droite. Elle est composée d’une suite de
critères (séparés par des espaces), dont certains sont mentionnés ci-après. Son évaluation
s’arrête (pour le fichier examiné) dès qu’un critère n’est pas satisfait (faux) ou lorsque tous les
critères ont été vérifiés.

Afin de pouvoir exprimer une expression complexe, il est possible d’utiliser le point
d’exclamation pour demander la négation du critère (ou de l’expression entre parenthèses) qui
le suit (après un séparateur), l’opérateur logique OU (noté –o), ainsi que les parenthèses pour
grouper une expression complexe. Lorsqu’un OU est présent, l’expression de droite n’est
évaluée que si celle de gauche est fausse. L’opérateur logique ET est implicite entre deux
critères mais peut aussi être exprimé avec –a.

Il est vivement conseillé d’utiliser les parenthèses afin d’éviter toute ambiguïté dans
l’expression.

Tous les termes des expressions — y compris (,), !, -o et –a — doivent être

séparés par un ou plusieurs séparateurs.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 8/21

Extrait de la liste des critères reconnus :

-print
Ce critère est toujours vrai. Il a pour effet de provoquer l’affichage de la référence
relative du fichier en cours d’analyse. Cette référence est relative au répertoire racine
de l’arborescence explorée. S’il n’est pas indiqué, ce critère est toujours rajouté pour
être évalué en dernier, sauf si le critère –exec ou –ok a été évalué ;

-type type
vrai si et seulement si le fichier en cours d’analyse est du type type, où type peut
être :
f pour fichier ordinaire
d pour fichier répertoire

-user nom
vrai ssi nom est le propriétaire du fichier en cours d’analyse ;

-group groupe
vrai ssi groupe est le groupe du fichier ;

-name motif
vrai ssi le nom du fichier (et non pas sa référence) correspond au motif. La
description du motif est la même que pour le shell. Mais il faut protéger les caractères
spéciaux pour ne pas qu’ils soient interprétés par le shell ;

-newer référence
vrai ssi le fichier est plus récent que le fichier référence ;

-mtime [+|–]n
vrai ssi la dernière modification du fichier remonte à plus de (+), moins de (–), ou
exactement n jours. Attention, le | entre le + et le – marque une alternative entre ces
deux caractères, il n’est pas à écrire ;

-atime [+|–]n
vrai ssi le dernier accès au fichier a eu lieu il y a plus de (+), moins de (–), ou
exactement n jours ;

-exec commande ;
vrai ssi commande retourne une valeur vraie1. commande est donc exécutée. Elle
peut comporter des options et des arguments. Le point virgule indique où commande
se termine. Il doit être protégé car c’est un caractère spécial du shell. Dans
commande, on peut utiliser l’expression {} qui sera remplacée par une référence du
fichier en cours d’analyse. Une fois de plus, les accolades sont des caractères
spéciaux du shell qu’il faut donc protéger ;

-ok commande ;
même chose que –exec mais un message demande s’il faut exécuter la commande
(réponse y ou Y) ou pas (dans ce cas –ok est faux).

1
La valeur de retour d’une commande sera vue dans « Code de retour des commandes », page Erreur ! Signet
non défini..

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 9/21

Exemples

La commande suivante recherche dans l’arborescence de /var les fichiers ordinaires dont
le nom comporte cpb, et affiche leur référence :
[cpb@duo ~]$ find /var –type f –name \*cpb\* -print
find: /var/lib/nfs/sm: Permission non accordée
find: /var/lib/nfs/[Link]: Permission non accordée
find: /var/lib/pgsql: Permission non accordée
find: /var/lib/slocate: Permission non accordée
find: /var/log/samba: Permission non accordée
find: /var/log/squid: Permission non accordée
/var/spool/mail/cpb
find: /var/spool/at: Permission non accordée
find: /var/spool/cron: Permission non accordée
find: /var/spool/news/.xauth: Permission non accordée
find: /var/spool/squid: Permission non accordée
find: /var/spool/intercheck/infected: Permission non accordée
find: /var/gdm: Permission non accordée

toutes les lignes commençant par find: sont des messages d’erreur. Seule la ligne
/var/spool/mail/cpb indique un fichier correspondant aux critères.

Dans la commande précédente, le critère –print figure à la fin pour que l’affichage de la
référence des fichiers ne soit fait que s’ils vérifient les critères –type et –name. Si –print se
trouve ailleurs, cela change considérablement l’affichage, comme le montre l’exemple ci-
dessous (seules les premières lignes du résultat sont reportées sur ce document) :
[cpb@duo ~]$ find /var -print -type f -name \*cpb\*
/var
/var/tmp
/var/tmp/A8_6Cadre.[Link]
/var/tmp/[Link]
/var/tmp/[Link]
/var/tmp/[Link]
/var/tmp/[Link]
/var/tmp/[Link]
/var/lib
/var/lib/rpm
/var/lib/rpm/[Link]
/var/lib/rpm/[Link]
/var/lib/rpm/[Link]
/var/lib/rpm/[Link]
/var/lib/rpm/[Link]
/var/lib/rpm/[Link]
...etc.

La commande suivante recherche dans l’arborescence du répertoire de travail de

l’utilisateur, les fichiers ordinaires dont l’extension est adb, ads ou squ, et affiche leur
référence :
[cpb@duo ~/tp]$ find -type f \( -name '*.ad[bs]' -o -name '*.squ' \) -print
./tpada/p_rationnels_g.ads
./tpada/p_rationnels_g-[Link]
./tpada/p_rationnels_g-[Link]
./tpada/tscl_rationnels.adb
./tpada/ts_rationnels.[Link]

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 10/21

Mieux encore, en remplaçant –print par –ok, find peut demander s’il faut imprimer
chaque fichier trouvé sur l’imprimante de la salle A. Le critère –exec est alors utilisé pour
afficher que l’impression du fichier est lancée. La ligne de commandes devenant grande, elle
est présentée sur deux lignes :
[cpb@duo ~/tp]$ find -type f \( -name '*.ad[bs]' -o -name '*.squ' \)
-ok lpr -PA \{\} \; -exec echo "Impression envoyée" \;
< lpr ... ./tpada/p_rationnels_g.ads > ? y
Impression envoyée
< lpr ... ./tpada/p_rationnels_g-[Link] > ? n
< lpr ... ./tpada/p_rationnels_g-[Link] > ? n
< lpr ... ./tpada/tscl_rationnels.adb > ? y
Impression envoyée
< lpr ... ./tpada/ts_rationnels.[Link] > ? n

selon la réponse donnée à find, celle-ci exécute ou non la commande du critère

-ok (puis celle de –exec). Notons que dans cet exemple, le code de retour de lpr et
de echo est toujours vrai.

I.6. tty : connaître son terminal

Le clavier et l’écran sont regroupés sous le terme générique de terminal. Un terminal est
mis à disposition de l’utilisateur à chaque fois que celui-ci ouvre une fenêtre texte nécessitant
des entrées au clavier et des sorties à l’écran (de type aterm, celle où tcsh est exécuté). Pour
connaître le terminal en cours d’utilisation, il suffit de taper la commande tty sans option ni
argument.

Le terminal d’un utilisateur est un fichier spécial, dans lequel il est possible d’écrire
(selon ses permissions). Tout ce qui y est écrit est affiché sur la fenêtre utilisant ce
(fichier) terminal.

Exemples
[cpb@duo ~]$ tty
/dev/pts/1
[cpb@duo ~]$ ls -l /dev/pts/1
crw------- 1 cpb tty 136, 1 sep 19 05:42 /dev/pts/1
on remarque le c indiquant un fichier spécial, que cpb en est le propriétaire et
possède les droits de lecture et d’écriture.
[cpb@duo ~]$ echo Salut > /dev/pts/1

exécuté dans une fenêtre quelconque, cela a pour effet d’écrire Salut dans la
fenêtre où a été tapée tty.

Il existe un terminal fictif /dev/null, sur lequel tout le monde a les droits de
lecture et d’écriture, mais qui ne représente rien : tout ce qui est écrit dedans est perdu
et rien ne peut y être lu. Ce fichier est principalement utilisé comme destination de la
redirection d’une sortie d’une commande afin de se débarrasser des informations
(inutiles) qu’elle y écrit.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 11/21

Exemple
[cpb@duo ~]$ echo Salut > /dev/null

n’importe qui peut exécuter cette commande qui n’a aucun effet car Salut n’est
écrit nulle part.

II. Processus

II.1. Introduction
Pour rester très simple, un processus est ce que le système crée afin d’exécuter un
programme. Il possède un environnement qui comporte le code exécutable, la mémoire
allouée par le système, les descripteurs des fichiers utilisés, la pile d’exécution…

La différence entre un programme et un processus peut se comprendre facilement, en

remarquant qu’un même programme comme /bin/tcsh (l’interpréteur de commandes que
nous utilisons) peut être exécuté par plusieurs utilisateurs sur plusieurs fenêtres (ou sur la
même) en même temps. C’est un processus distinct qui est activé à chaque fois alors que
c’est le même programme. Ces processus sont indépendants et disposent chacun d’une partie
de la mémoire, de leurs propres entrées-sorties, etc.

Un processus est identifié par un numéro unique : le pid (processus identifier). Il a un

propriétaire et un groupe, qui sont utilisés par le système pour autoriser ou interdire les
opérations qu’il effectue (lecture/écriture dans un fichier, dans la mémoire, …). Par exemple,
lorsqu’un utilisateur lance la commande ls, le processus créé pour l’exécuter est propriété de
l’utilisateur et possède son groupe2. Lorsque ce processus tente de lire le contenu d’un
répertoire, le système utilise ces informations (et celles du répertoire) pour vérifier qu’il a bien
le droit de le faire.

Un processus est toujours lancé par un autre, appelé son processus père. Exception faite
du processus init, portant le numéro 1, qui est le patriarche de tous car c’est le noyau (le
cœur) du système Unix. Un processus finit généralement par mourir, notamment lorsqu’il a
terminé l’exécution de son code (programme).

II.2. Processus lancés par un shell

Lorsque vous rentrez une commande correspondant à un fichier exécutable3, le shell (pour
nous, tcsh) va demander au système de créer un processus fils pour exécuter cette commande.
Puis il attend que son fils meure (parce qu’il a fini son office ou qu’il a été interrompu) avant
d’afficher le prompt vous invitant à rentrer une autre commande.

2
Il est possible qu’un processus ne soit pas propriété de l’utilisateur qui l’a lancé et/ou n’ait pas son groupe.
C’est le cas de certains programmes qui ont besoin, pour réaliser leur travail, de garder comme propriétaire et/ou
groupe, ceux du fichier exécutable. Mais ceci est une autre histoire…
3
Certaines commandes comme cd ou pwd sont internes à l’interpréteur de commandes qui les exécute lui-
même. Ce ne sont donc pas des fichiers exécutables.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 12/21

Ce comportement dit séquentiel ou synchrone est exactement celui que l’on attend
généralement, car on n’aimerait pas voir le prompt s’afficher en plein milieu de ce qu’affiche
le processus de notre commande, et ne plus savoir ensuite si il est terminé.

Cependant, il y a des processus dont on ne veut pas attendre la fin pour continuer à taper
des commandes. C’est le cas par exemple des applications graphiques (qui ouvrent au moins
une fenêtre pour dialoguer), ou des programmes ne nécessitant aucune donnée en provenance
de l’utilisateur.

II.3. Lancement en parallèle

Afin d’éviter cette attente, on peut très simplement lancer des commandes en parallèle4.
Dans ce cas, le shell n’attendra pas la mort du processus pour continuer son traitement, c’est à
dire afficher le prompt et attendre une nouvelle commande.

Le lancement en parallèle (appelé aussi en « tâche de fond » ou en « background ») se

demande sur la ligne de commande de tcsh en rajoutant le caractère spécial ‘&’ tout à la fin
de l’expression de la commande (après les options, les arguments et les redirections).

Exemples
[cpb@duo ~]$ aterm &
[1] 4767

lancement en parallèle d’une fenêtre aterm. Le processus créé porte le numéro

4767 et son numéro de job est 1 (voir commande jobs ci-après) ;
[cpb@duo ~]$ cmd1 –o1 arg1 < ref1 &
[2] 4801

lancement en parallèle de cmd1 avec l’option –o1 et l’argument arg1, avec

redirection de l’entrée standard depuis ref1. Le processus créé porte le numéro
4801 (job numéro 2).

Le caractère ‘&’, comme le pipe ‘|’, est un séparateur de commandes.

Ainsi la ligne de commandes :

[cpb@duo ~]$ cmd1 –o1 arg1 < ref1 & cmd2 –o2 arg2

a pour effet de lancer en parallèle la commande cmd1 –o1 arg1 < ref1 et de lancer
en séquentiel (en attendant sa fin), la commande cmd2 –o2 arg2. On aurait pu lancer cette
dernière en parallèle en tapant :
[cpb@duo ~]$ cmd1 –o1 arg1 < ref1 & cmd2 –o2 arg2 &

En contrepartie du lancement parallèle, la commande ne peut rien recevoir du

clavier sur la fenêtre d’où le shell l’a lancé puisque c’est lui qui va en avoir besoin
pour recevoir une autre commande de la part de l’utilisateur.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 13/21

Les applications graphiques quant à elles, ouvrent au moins une fenêtre et

demandent au système un nouveau terminal (donc un nouveau fichier) pour utiliser le
clavier dans cette fenêtre.

II.4. jobs : lister les processus lancés par le shell

La commande jobs est une commande interne de tcsh5. Elle demande l’affichage de la
liste des processus fils du shell sur lequel elle est tapée, et qui ne sont pas terminés. Le
numéro de job est celui affiché entre crochets lorsqu’on lance un processus en parallèle (voir
exemples « Lancement en parallèle »).

Utilisation :

jobs [-l]

L’option –l demande aussi l’affichage du numéro de processus.

Exemples
[alfred@pi ~]$ aterm &
[1] 3626
[alfred@pi ~]$ find / -name truc > [Link] &
[2] 3673
[alfred@pi ~]$ jobs
[1] + Running aterm
[2] - Running find / -name truc > [Link]
[alfred@pi ~]$ jobs -l
[1] + 3626 Running aterm
[2] - 3673 Running find / -name truc > [Link]

II.5. ps : obtenir une liste de processus existants

La commande ps permet d’obtenir une liste de tout ou partie des processus créés par le
système et toujours vivants. Elle admet de nombreuses options (en particulier sous Linux)
dont seulement celles indiquées ici vous serviront habituellement. Comme d’habitude, se
reporter au manuel en ligne (man) pour connaître toutes les options.

Utilisation

ps [x][a][l|u]

Attention, il n’y a pas de tiret devant les options. Sans option, ps affiche simplement les
informations sur les processus de l’utilisateur qui sont rattachés au terminal (fenêtre) sur
lequel elle a été lancée. Avec l’option x, tous les processus de l’utilisateur sont affichés même

4
Remarquons qu’un pipeline est constitué d’un ensemble de processus lancés en parallèle et communicant entre
eux.
5
C’est aussi une commande interne de csh, sh, bash, etc.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 14/21

ceux qui ne sont pas rattachés au terminal. L’option a demande aussi l’affichage des
processus n’appartenant pas à l’utilisateur (rattachés au terminal ou pas, selon x). L’option l
demande un affichage d’informations plus détaillées (en particulier, la colonne PPID indique
le numéro du processus père du processus détaillé par la ligne correspondante). Enfin,
l’option u (inutilisable avec l’option l) demande un affichage où figure le nom du propriétaire
du processus (mais pas le PPID).

Exemples
[cpb@duo ~]$ ps
PID TTY TIME CMD
4722 pts/8 00:00:00 tcsh
4790 pts/8 00:00:00 ps

Les seuls processus actifs sur la fenêtre sont tcsh6 et ps (qui va mourir immédiatement
après avoir écrit cette liste). En rajoutant /dev/ devant l’élément TTY, on obtient la
référence absolue du (fichier) terminal auquel le processus est rattaché.
[cpb@duo ~]$ aterm &
[1] 4767

Lancement d’un aterm (fenêtre graphique représentant un terminal) en parallèle.

[cpb@duo ~]$ ps
PID TTY TIME CMD
4722 pts/8 00:00:00 tcsh
4767 pts/8 00:00:00 aterm
4790 pts/8 00:00:00 ps
Il porte le numéro 4767 et est rattaché au même terminal (mais dans la fenêtre il doit
être rattaché un autre terminal).
[cpb@duo ~]$ ps l
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
000 5778 4722 4720 6 0 2192 1176 sigact S pts/8 0:00 tcsh
000 5778 4767 4722 0 0 2404 1348 locks_ S pts/8 0:00 aterm
000 5778 4791 4722 12 0 2524 872 - R pts/8 0:00 ps l
On obtient plus de renseignements, notamment le numéro d’utilisateur (UID) du
propriétaire du processus, mais surtout le pid de son père (PPID). On remarque que
aterm et ps ont le même père (le shell tcsh).
[cpb@duo ~]$ ps x
PID TTY STAT TIME COMMAND
4696 ? S 0:00 /usr/X11R6/bin/wmaker
4720 ? R 0:00 aterm -ls
4722 pts/8 S 0:00 tcsh
4767 pts/8 S 0:00 aterm
4768 pts/10 S 0:00 tcsh
4792 pts/8 R 0:00 ps x
[cpb@duo ~]$ ps lx
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
100 5778 4696 4692 0 0 3940 2292 locks_ S ? 0:00 /usr/X11R6/
000 5778 4720 4696 0 0 2404 1356 - R ? 0:00 aterm -ls
000 5778 4722 4720 7 0 2192 1176 sigact S pts/8 0:00 tcsh
000 5778 4767 4722 0 0 2404 1348 locks_ S pts/8 0:00 aterm
000 5778 4768 4767 1 0 2148 1088 comple S pts/10 0:00 tcsh
000 5778 4795 4722 13 0 2524 872 - R pts/8 0:00 ps lx

6
Le nom qu’il porte au démarrage est différent selon les versions. Cela tend à être tcsh (sur Red Hat 7.2) mais
c’était –csh sur la Red Hat 6.2.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 15/21

On remarque qu’un tcsh (pid 4768) a été créé par aterm (la fenêtre). Il dispose d’un
nouveau terminal qui est le fichier /dev/pts/10.

II.6. Agir sur un processus avec les caractères de contrôle

Lorsque le clavier peut être utilisé par un processus, certains caractères dits de contrôle
permettent d’agir sur son déroulement. Deux sont indiqués ci-dessous (il y en a d’autres) :

Ctrl c ou Ctrl C provoque la mort du processus (si celui-ci le veut bien) ;

Ctrl z provoque l’interruption du processus, dont on pourra déclencher ensuite la

continuation en exécutant la commande fg pour le faire repartir séquentiellement,
ou bg pour le faire repartir en parallèle.

II.7. kill : tuer un processus gênant

Il arrive que certains processus s’emballent et doivent être arrêtés par l’utilisateur. S’il
n’est pas possible de le faire avec la touche Ctrl c, il faut alors utiliser la commande kill.
Celle-ci sert à envoyer des signaux à des processus, qui sont censés les traiter. Bien entendu,
on ne peut envoyer des signaux qu’à des processus dont on est propriétaire (sauf si l’on est
root).

Utilisation :

kill [-l] [-n] (pid|%job) {pid|%job}

pid est le numéro d’un processus à qui on adresse le signal numéro n (n peut être aussi un
identificateur de signal, cf. ci-dessous). À la place du numéro de processus, on peut indiquer
le numéro de job en utilisant %job. Mais dans ce cas, le job doit être un fils du shell où est tapé
la commande kill.

Il y a 39 signaux différents sur la Red Hat 6.2. L’option –l permet d’en obtenir une liste.
Chacun a une signification. Pour l’instant seuls les trois suivants nous intéressent :

15 ou TERM signal gentil, demandant aux processus atteints de se terminer

proprement. C’est à priori le signal qu’il faut préférer ;

2 ou INT signal plus brutal demandant un arrêt immédiat. C’est celui généralement
provoqué par l’appui sur les touches Ctrl c. À utiliser si le précédent n’a
pas marché.

9 ou KILL signal le plus violent. Il provoque la mort sans condition des processus
atteints. À utiliser en dernier recours.

Si -n n’est pas spécifié (ni l’option -l), le signal pris par défaut est TERM.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 16/21

Exemples
[cpb@duo ~]$ tcsh

lancement d’un tcsh en séquentiel.

[cpb@duo ~]$ ps
PID TTY TIME CMD
2953 pts/2 00:00:00 tcsh
3130 pts/2 00:00:00 tcsh
3152 pts/2 00:00:00 ps
On peut se douter que c’est celui de pid 3130 car ces numéros sont affectés par ordre
croissant.
[cpb@duo ~]$ ps l
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
000 5778 2953 2918 11 0 2192 1176 sigact S pts/2 0:00 tcsh
000 5778 3130 2953 13 0 2404 1348 sigact S pts/2 0:00 tcsh
000 5778 3152 2953 18 0 2524 872 - R pts/2 0:00 ps l
Cette fois c’est sûr.
[cpb@duo ~]$ kill 3130
[cpb@duo ~]$ ps
PID TTY TIME CMD
2953 pts/2 00:00:00 tcsh
3130 pts/2 00:00:00 tcsh
3154 pts/2 00:00:00 ps
le signal TERM n’a pas été suffisant pour tuer ce tcsh.
[cpb@duo ~]$ kill -2 3130
[cpb@duo ~]$ ps
PID TTY TIME CMD
2953 pts/2 00:00:00 tcsh
3130 pts/2 00:00:00 tcsh
3155 pts/2 00:00:00 ps
le signal INT ne l’a pas été non plus.
[cpb@duo ~]$ kill -KILL 3130
Killed
[cpb@duo ~]$ ps
PID TTY TIME CMD
2953 pts/2 00:00:00 tcsh
3156 pts/2 00:00:00 ps
en revanche, KILL l’a été.

III. Expressions régulières et utilitaires

III.1. Présentation
Les expressions régulières est un terme désignant l’expression de motifs de chaînes de
caractères. Ceci, dans l’esprit des motifs de noms de fichiers, en beaucoup plus puissant. Elles
servent à la recherche et/ou au remplacement de chaînes dans des lignes de texte et sont
reconnues par de nombreux utilitaires d’Unix tels que vi, grep, more, less, man, sed, …

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 17/21

Une expression régulière est formée de motifs exprimés par des suites de caractères.
Certains caractères sont spéciaux dans une expression régulière, tels que ^, ., $, [, ], et *.

Ce sont aussi des caractères spéciaux pour tcsh mais oublions tcsh pour l’instant et
leur signification dans celui-ci (bien que de nombreuses similarités seront constatées).

Les caractères spéciaux ont une signification différente de leur symbole. Pour qu’un
caractère spécial soit interprété littéralement (comme son propre symbole), il faut le faire
précéder d’un backslash ‘\’.

Les caractères suivants sont normaux mais acquièrent une signification spéciale s’ils sont
précédés d’un backslash : ?, +, {, }, (, ) et |. Pour que le backslash soit reconnu comme
lui-même, il suffit de le doubler. Tous les autres caractères ne représentent qu’eux-mêmes. En
particulier, tout espace présent dans l’expression régulière doit figurer aussi dans la chaîne.

Syntaxe d’une expression régulière (deux définitions possibles):

exp_reg : := [^]motif[modificateur]{motif[modificateur]}[$]

motif est une description incomplète d’une partie d’une chaîne. Si ^ est présent en
début du premier motif, alors la chaîne doit se trouver au début d’une ligne. Si $ est
présent en fin du dernier motif, elle doit se trouver à la fin de la ligne ;

exp_reg : := exp_reg\|exp_reg

définit une alternative entre deux expressions régulières.

L’expression de motif doit suivre la syntaxe suivante :

motif : := .

le point remplace n’importe quel caractère ;

motif : := [[^]ensemble[[:space:]]]

c’est la même définition d’un ensemble pour les motifs de noms de fichiers.
Cependant, on peut y faire figurer [:space:] (ces crochets sont à taper) qui
représente les caractères d’espacement (espace, tabulations,…). Les caractères
spéciaux perdent leur signification dans l’expression de ensemble ;

motif : := caractère_normal

un caractère normal ne représente que lui-même ;

motif : := \(exp_reg\)

permet de grouper une expression régulière (en vue éventuellement d’utiliser un

modificateur) ;

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 18/21

motif : := \n

où 1 ≤ n ≤ 9. Doit correspondre à ce que la nième expression entre parenthèses a

représenté. Par exemple, si la première expression entre parenthèses est \(a*\) et
qu’elle correspond à aaa dans la ligne analysée, alors à la place de \1 doit aussi se
trouver aaa dans la ligne.

Les modificateurs

Ils permettent de fixer des contraintes sur le nombre d’apparitions du motif (ou donc de
l’expression régulière entre parenthèses) qui le précède. Un modificateur s’exprime selon la
syntaxe suivante :

modificateur : := *

le motif précédent peut apparaître 0 ou plus d’une fois (nombre indéfini) ;

modificateur : := \+

le motif précédent doit apparaître au moins une fois (et peut être plus) ;

modificateur : := \?

le motif précédent doit apparaître au plus une fois (peut être 0) ;

Les modificateurs suivants ne sont pas toujours reconnus par l’éditeur vi (cela dépend de la
version) mais le sont par grep :

modificateur : := \{n[,m]\}

le motif précédent doit apparaître n fois, ou entre n et m fois si ,m est spécifié ;

modificateur : := \{n,\}

le motif précédent doit apparaître au moins n fois.

Ce sont les chaînes les plus grandes correspondant au motif modifié qui seront
retenues. Par exemple, le motif a* aura pour correspondance aaa dans la chaîne
bbbaaaccc et non pas la chaîne vide (à méditer).

Les shells et les expressions régulières ayant en commun un grand nombre de

caractères spéciaux dont le backslash, il faudra protéger les expressions par des
quotes pour les faire figurer dans les lignes de commandes.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 19/21

III.2. Utilisation dans vi

vi admet l’utilisation des expressions régulières pour la recherche (et le remplacement) des
chaînes. Notamment, dans les commandes de recherche en avant, par /chaîne, et en arrière,
par ?chaîne, car chaîne peut être une expression régulière. vi se positionnera alors sur la
première chaîne correspondant à l’expression.

La recherche/remplacement mérite quelques explications. Elle était présentée ainsi

précédemment :

:[n[,m]]s/chaîne1/chaîne2/[g]

En fait, chaîne1 peut être une expression régulière. De plus, on peut utiliser le motif \n
dans chaîne2 qui sera remplacé par la chaîne correspondant à la nième expression entre
parenthèses dans chaîne1.

Exemple

Soit un fichier composées des lignes suivantes :

aaab
abbbb
aabb
aaaaa
bbbbb

On veut permuter les groupes de a et ceux de b. Il suffit de taper la commande vi

suivante (en mode commandes) :

:1,$s/\(a*\)\(b*\)/\2\1

III.3. grep : filtrer les lignes de fichiers

grep (global regular expression printer) permet de rechercher dans des fichiers des lignes
contenant une chaîne correspondant à une expression régulière.

Utilisation

grep [-vclniw] exp_reg {référence}

référence est une référence à un fichier ordinaire. Si aucune référence n’est spécifiée, grep
effectue la recherche sur les lignes lues sur son entrée standard. Sans option, les lignes
contenant une chaîne répondant à exp_reg sont imprimées. L’option –v inverse la recherche et
affiche celles ne contenant pas de chaîne correspondant à exp_reg. L’option –c fait
simplement afficher le nombre de lignes qui auraient été écrites. L’option –l permet de
n’afficher que les noms des fichiers dont au moins une ligne correspond à l’exp_reg. L’option
–n demande à ce que chaque ligne écrite soit précédée de son numéro d’apparition dans le
fichier. L’option –i demande de ne pas distinguer les majuscules et les minuscules. L’option
-w indique que exp_reg doit correspondre à un mot.

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 20/21

Exemples

1. Soit le fichier fic composé des quatre lignes suivantes :

and then there was one
chain of command
sandbox
and

Voici le résultat de l’exécution de quelques commandes grep :

[cpb@duo Grep]$ grep 'and' fic
and then there was one
chain of command
sandbox
and
n’affiche que les lignes de fic qui contiennent and
[cpb@duo Grep]$ grep '^and' fic
and then there was one
and
lignes commençant par and
[cpb@duo Grep]$ grep 'and$' fic
chain of command
and
lignes se terminant par and
[cpb@duo Grep]$ grep '^and$' fic
and
lignes commençant et se terminant par and

2. Soit le fichier fic1 composé des six lignes suivantes :

aardvark
bear
cheetah
elephant
quail
tiger

Voici le résultat de quelques commandes grep :

[cpb@duo Grep]$ grep '[ae]' fic1
aardvark
bear
cheetah
elephant
quail
tiger
toutes les lignes contiennent un a ou un e
[cpb@duo Grep]$ grep '^[ae]' fic1
aardvark
elephant
lignes commençant soit par a soit par e

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003

Cours 3 d’Unix Page 21/21

[cpb@duo Grep]$ grep '^[a-e]' fic1

aardvark
bear
cheetah
elephant
lignes commençant par une lettre comprise entre a et e
[cpb@duo Grep]$ grep '^[am-z]' fic1
aardvark
quail
tiger
lignes commençant par a ou une lettre comprise entre m et z
[cpb@duo Grep]$ grep '^[a-e][ae]' fic1
aardvark
bear
lignes commençant par une lettre comprise entre a et e, suivie soit de a, soit de e
[cpb@duo Grep]$ grep '^t....' fic1
tiger
lignes commençant par t et contenant au moins 5 caractères (même
blancs !!)
[cpb@duo Grep]$ grep '^[^aeiouy]\([^aeiouy]\)[aeiouy]\{2\}.*\1$' fic1
cheetah
lignes qui commencent par deux caractères différents d’une voyelle, suivis
de deux voyelles, suivis d’une suite quelconque (ou vide) de caractères, et
se terminant par le même caractère que le 2ème caractère de la ligne

IUT Aix-en-Provence — Informatique © Cyril Pain-Barre, 2003