Le Shell

« Less sucks less more than more.

That's why I use more less, and less more.. »
    Inconnu
Shell
Interêt ?
● Interface utilisateur non graphique
– terminaux texte
– accès distant
● Interpréteur de scripts
– traitement "par lots"
– automatisation
● Lancement de tâches multiples
– tâche combinées (pipes)
– job control
   
Shell
Oui mais...

● C'est un programme "normal"

● Le choix est vaste
– sh, sash, ksh, csh, tcsh, ash, bash, psh, fish,
...
● On peut exécuter plusieurs shells en
parallèle (unix est multitâche)
● Plusieurs utilisateurs peuvent exécuter un
shell en même temps (unix est multi-
utilisateurs)
   
Shell
Terminaux

vt100
xterm console vga

   
Shell
Autopsie d'un « login »

   
Shell
Environnement

● Un shell donné s'exécute dans un

environnement propre et clos contenant
des variables
● Cet environnement est :
– est modifiable
– est transitoire
● L'environnement initial
– est défini au niveau système
– peut être modifié par l'utilisateur
   
Shell
Environnement

   
Filesystem
Le système de fichiers (filesystem)

● Organisé hiérarchiquement dans sa totalité

depuis la racine («/»)
● Sensible à la casse (des caractères)
● Utilise '/' pour séparer les répertoires dans
un chemin
● Peut contenir n'importe quel caractère
● Taille pratique d'un nom de fichier illimitée
● Pas de notion «d'extensions»
●
 
Distro-dépendant malgré le «standard»
 
Filesystem
Le système de fichiers (filesystem)

   
Filesystem
L'organisation du filesystem (fs)

Une seule arborescence

   
Filesystem
Balade dans le «fs»
● Se déplacer dans le filesystem
cd chemin  (chemin relatif)
cd /chemin (chemin absolu)
● Voir le contenu du répertoire
ls (contenu du répertoire courant)
ls chemin (contenu de « chemin »)
● Connaître le répertoire courant
pwd (print working directory)

   
Filesystem
Balade dans le «fs»
Répertoires à part :

/   : racine du filesystem

.   : répertoire courant

..  : répertoire parent

~   : répertoire maison («home dir»,

correspond à $HOME)

   
Filesystem
Lieux touristiques du «fs»
Répertoire essentiels au fonctionnement

/ : racine

/bin, /sbin : binaires systèmes

/etc : configuration système

/boot : kernel et 2eme étage du bootloader

   
Filesystem
Lieux touristiques du «fs»

/usr : binaires d'usage courant

/home : répertoires utilisateurs
/var : données variables (sgbd, logs)
/proc : information système temps réèl
/mnt, /media : point montage temporaire
/sys : bus systèmes
/tmp : répertoire temporaire
lost+found : objets trouvés

   
Shell
$PATH

● Variable d'environnement
● Contient une suite de chemins séparés
par ':'
● Les exécutables seront recherchés dans
ces chemins

   
Shell
$PATH

Répertoire '.' danger !

● risque d'exécuter un trojan

– n'importe qui peut écrire dans /tmp (entre
autres) !

● le shell perd du temps à chaque 'cd'

   
Shell
Entrée/Sorties

● Par défaut tout processus possède :

– 1 entrée
– 2 sorties
● Ces I/O sont distinctes pour chaque processus
● Pour les programmes interactifs (comme les
shells) :
– les entrées proviennent du clavier
– les sorties s'affichent sur l'écran

   
Shell
Entrée/Sorties
STDIN (entrée standard) : ce qui est envoyé
vers le processus
STDOUT (sortie standard) : ce qui est
envoyé par le processus
STDERR (sortie erreur standard) : les
erreurs renvoyés par le processus

   
Shell
Entrée/Sorties

Ces entrés/sorties standard sont en fait des

noms symboliques, correspondant à des
« descripteurs de fichiers » :

● STDIN (INput) : descripteur de fichier 0

● STDOUT (OUTput) : descripteur de fichier 1

● STDERR (ERRor) : descripteur de fichier 2

   
Shell
Entrée/Sorties : cat
cat : copie STDIN (ou un fichier) sur STDOUT 
(écrit les erreurs, s'il y a, sur STDERR)
user@host:~$ cat
azerty
azerty
qsdfg
qsdfg

user@host:~$ cat /etc/hosts
127.0.0.1       localhost
127.0.1.1       michel

# The following lines are desirable for IPv6 capable hosts
::1     ip6­localhost ip6­loopback
fe00::0 ip6­localnet

user@host:~$ cat /etc/bidon
cat: /etc/bidon: Aucun fichier ou répertoire de ce type
user@host:~$

   
Shell
Redirections d'E/S

Les E/S peuvent être redirigées de ou vers un fichier

processus < fichier
STDIN provient du fichier (et non plus du clavier)

processus > fichier
STDOUT est écrit dans fichier (et non plus sur le terminal)

processus 2> fichier
STDERR est écrit dans fichier (et non plus sur le terminal)

processus > fichier1 2> fichier2
STDOUT est écrit dans fichier1 et STDERR dans fichier2

   
Shell
Redirections d'E/S

user@pluton:~$ cat < /etc/hostname
pluton
user@pluton:~$ cat /etc/hostname
pluton
user@pluton:~$ cat /etc/hostname > /tmp/test
user@pluton:~$ cat /tmp/test
pluton
user@pluton:~$ cat /etc/hostname > /dev/null
user@pluton:~$ cat < /etc/hostname > /dev/null
user@pluton:~$ cat /etc/hostname
pluton
user@pluton:~$ cat /etc/portnaouak
cat: /etc/portnaouak: Aucun fichier ou répertoire de ce type
user@pluton:~$ cat /etc/portnaouak 2> /dev/null
user@pluton:~$ cat /etc/hostname /etc/portnaouak > out.txt 2> err.txt
user@pluton:~$ cat out.txt
pluton
user@pluton:~$ cat err.txt
cat: /etc/portnaouak: Aucun fichier ou répertoire de ce type
   
Shell
Redirections d'E/S

user@pluton:~$ cat /etc/hostname
pluton
user@pluton:~$ cat /etc/hostname >> /tmp/test
user@pluton:~$ cat /tmp/test
pluton
pluton
user@pluton:~$ cat /etc/hostname > /tmp/test
user@pluton:~$ cat /tmp/test
pluton
user@pluton:~$ cat /etc/hostname > /tmp/test
user@pluton:~$ cat /tmp/test
pluton
user@pluton:~$ cat /etc/hostname >> /tmp/test
user@pluton:~$ cat /tmp/test
pluton
pluton
user@pluton:~$

   
Shell
Entrées/sorties : devices spéciaux

Plusieurs "devices" (fichiers dans /dev) ont une

vocation particulière :
/dev/null
trou noir annihiliant tout ce qui lui est envoyé

/dev/zero
envoie des zéros ad-vitam

/dev/random /dev/urandom
fournisseurs officiels de hazard

/dev/full
dispositif hypochondriaque : se plaint toujours (d'être plein)

   
Shell
Redirections d'E/S : travaux
1) Copier le contenu de /etc/passwd dans le
fichier /tmp/users.txt
2) Ecrire «linus» à la fin de users.txt
3) Vider le fichier users.txt
4) Remplir users.txt de "zéros" (utiliser le
dispositif fournisseur de zéros : /dev/zero)
5) Rediriger l'erreur standard de 'ls -lR /' dans
/tmp/users.txt
6) Vider le fichier users.txt (d'une autre manière
  qu'en 3)  
Shell
Pipes

● Les «pipes» (pipelines) permettent

d'envoyer la sortie d'une commande
(STDOUT) à l'entrée d'une autre (STDIN) :

   
Shell
Pipes
● On trouve très souvent la commande grep au
milieu de pipelines
● grep permet de n'afficher une ligne que si elle
contient une chaine de caractères donnée
● Sa syntaxe est :
grep chaîne fichier
affiche les lignes de fichier contenant
"chaîne"
grep chaîne
affiche les lignes lues sur l'entrée standard
(STDIN) contenant "chaîne"
   
Shell
Pipes : exemples (compliqués)
user@pluton:~$ cat /etc/passwd | grep root
root:x:0:0:root:/root:/bin/bash
user@pluton:~$ ls | grep test
test.txt
user@pluton:~$ ip link | grep UP
1: lo: <LOOPBACK,UP,10000> mtu 16436 qdisc noqueue 
3: eth1: <BROADCAST,MULTICAST,UP,10000> mtu 1500 qdisc pfifo_fast qlen 1000
6: tun0: <POINTOPOINT,MULTICAST,NOARP,UP,10000> mtu 1500 qdisc pfifo_fast qlen 100
user@pluton:~$ ip link | grep UP > uplinks.txt
user@pluton:~$ cat uplinks.txt | grep eth
3: eth1: <BROADCAST,MULTICAST,UP,10000> mtu 1500 qdisc pfifo_fast qlen 1000
user@pluton:~$ ip link | grep UP | grep eth
3: eth1: <BROADCAST,MULTICAST,UP,10000> mtu 1500 qdisc pfifo_fast qlen 1000
user@pluton:~$ history | awk '{ print $2 }' | sort | uniq  ­c | sort ­nr ­k1 | head ­10
    164 ls
     74 cd
     62 ssh
     55 ping
Il n'y a pas de limitation
pratique au nombre de
     55 man
     53 make
     51 ip
     47 more
user@pluton:~$  "pipes" que l'on peut
enchaîner...
   
Shell
Pipes
● Les pipes et les redirections peuvent être
combinées

   
Shell
Pipes & Redirections
Attention à l'ordre des redirections et des pipelines
a | b 2> c
– le résultat de la commande a est passé à b
– les erreurs de b sont redirigées dans le fichier c

a 2> c | b
– le résultat de la commande a est passé à b
– les erreurs de a sont redirigées dans le fichier c

user@pluton:~$ cat /etc/toto /etc/passwd | grep root 2> /dev/null
cat: /etc/toto: Aucun fichier ou répertoire de ce type
root:x:0:0:root:/root:/bin/bash
user@pluton:~$ cat /etc/toto /etc/passwd root 2> /dev/null | grep root
root:x:0:0:root:/root:/bin/bash
user@pluton:~$ 
   
Shell
Complétion

● Permet de compléter une saisie

utilisateur dans le shell
● Affecté à la touche « tab »
● La complétion affiche la plus grande
correspondance unique
● S'applique aux commandes et à leurs
arguments (selon configuration)
● « tab-tab » affiche toutes les
correspondances possibles
   
Shell
Editeur de ligne

● l'éditeur de ligne permet d'éditer....

... la ligne !
● raccourcis clavier identiques à Emacs

CTRL + a  : début de ligne

CTRL + e  : fin de ligne

CTRL + k  : coupe de la position courante jusqu'à la fin de la ligne

CTRL + y  : colle ce qui a été précédemment coupé

   
Shell
Historique
● bash mémorise toutes les commandes dans un
d'historique
● cet historique est enregistré dans un fichier
lorsque le shell se termine
● cet historique est lu depuis un fichier au
démarrage d'un shell
● le nom du fichier est défini dans $HISTFILE et la
taille de l'historique dans $HISTFILESIZE
● le rappel de commandes :
– par numéro (!numéro)
– par nom (!debutnom)
   
– après recherche (ctrl-r)
Shell
Historique
user@host:~$ echo $HISTFILE
/home/user/.bash_history
user@host:~$ echo $HISTFILESIZE
1500
user@host:~$ history | tail ­n 5
 1429  history 
 1430  kill ­9 18487
 1431  echo $HISTFILE
 1432  echo $HISTFILESIZE
 1433  history | tail ­n 5
user@host:~$ tail ­n 5 $HISTFILE
ls
history 
ls /ttest
history 
kill ­9 18487
user@host:~$ !1431
user@host:~$ echo $HISTFILE
/home/user/.bash_history
user@host:~$ !echo
echo $HISTFILE
/home/user/.bash_history
  user@host:~$  
Shell
Historique

user@host:~$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
...
postfix:x:111:118::/var/spool/postfix:/bin/false
user@host:~$ !cat | grep root
root:x:0:0:root:/root:/bin/bash
user@host:~$ bash
user@host:~$ history | tail ­n 5
1476 ls
1427 history 
1428 ls /ttest
1429 history 
1430 kill ­9 18487
user@host:~$

   
Shell
Historique

Remarques

● si le shell B est ouvert alors que le shell A est

en cours, B ne verra pas les commandes de A
dans l'historique
● si le shell B est fermé avant le shell A, les
commandes de B seront plus haut dans
l'historique
● si le shell est tué, il ne pourra pas mettre
l'historique à jour
   
Shell
Historique

   
Shell
Globbing
Permet de nommer plusieurs fichiers d'un seul
coup grâce à des « jokers » (wildcards)
? : accepte un seul caractère
* : accepte n'importe quel caractère 0 ou n fois
[chars] : denote une liste de caractères acceptée (liste,
suite alphabétique ou suite numérique)
[^chars] ou [!chars] : dénote une classe de
caractères refusée (liste, suite alphabétique ou suite
numérique)
{e1,e2,e3} : remplace les arguments par les éléments
de la liste
{e1,e2}{e3,e4} : remplace les arguments par le
   
produit cartésien des deux listes
Shell
Globbing
abc? : accepte un fichier de 4 lettres commençant par
abc
abc* : accepte un fichier de 3 lettres ou plus
commençant par abc
*abc* : accepte un fichier de 3 lettres ou plus contenant
abc
[ab]c : accepte un fichier de 2 lettres commençant par
'a' ou 'b'
[a­m]* : accepte un fichier commençant par une lettre
comprise alphabétiquement entre 'a' et 'm' inclus
*[0­1][0­9] : accepte un fichier se terminant par un
nombre compris entre '00' et '19'
[13579]*[a­z] : accepte un fichier commençant par un
   
nombre impair et se terminant par une minuscule
Shell
Globbing
[^13579]*[^a­z] : accepte un fichier commençant par un
nombre pair et se terminant par une majuscule

{a,b,c} : accepte les fichiers nommés 'a', 'b' ou 'c'

{a*,*b*,*c} : accepte les fichiers dont le nom commence

par 'a', contient 'b' ou se termine par 'c'

*{.doc,.odt,.rtf} : accepte les fichiers nommés '*.doc',

'*.odt' ou '*.rtf'

{photo,image}{.jpg,.png} : accepte les fichiers nommés

'photo.jpg', 'photo.png', 'image.jpg' ou 'image.png'

{jean,pierre}{,­jean} : accepte les fichiers dont le nom

est 'jean', 'jean-jean', 'pierre' ou 'pierre-jean'
   
Shell
Globbing : classes
Les classes sont des listes prédéfinies de 
caractères, utilisables entre [: et :] :

alnum : [a-zA-Z0-9] punct : ponctuation

alpha : [a-zA-Z] space : espace, tabulation, ...
ascii : caractère ascii (...) upper : [A-Z]
blank : espace ou tabulation word : [a-zA-Z0-9_]
cntrl : caractère de contrôle xdigit : [a-fA-F0-9]
digit : [0-9]
graph : caractères Exemple :
imprimables et visibles
lower : [a-z] [[:alnum:]] : accepte un
print : caractère imprimable caractère alphanumérique
Voir : man 7 glob
   
Shell
Globbing : les limites
● On ne peut pas matcher '/'
● On doit matcher explicitement le
caractère '.'
● Ce ne sont pas des expressions régulières
● On ne peut donc pas appliquer de
numération à des classes
Il est par exemple impossible de matcher tous
les noms de fichiers se terminant par des
nombres

   
Commandes de base
De l'aide : man

man commande
affiche le manuel de la commande commande
– options
-t : produit une sortie postscript pour impression
– exemples
man ­t ls | lpr
man man

   
Commandes de base
De l'aide : man
man divise la documentation en 9 sections :
1. Executable programs or shell commands
2. System calls (functions provided by the kernel)
3. Library calls (functions within program libraries)
4. Special files (usually found in /dev)
5. File formats and conventions (e.g. /etc/passwd)
6. Games
7. Miscellaneous (including macro packages and conventions
8. System administration commands (usually only for root)
9. Kernel routines [Non standard]

cela permet d'éviter les ambiguïtés :

 
man glob ≠ man 7 glob  
Commandes de base
Aide : help, apropos, whatis

help commande
affiche le manuel d'une commande interne (builtin)

apropos sujet
affiche les pages de man correspondant au sujet

whatis commande
affiche une information succinte sur la commande

   
Commandes de base
cd

cd argument
« rentre » dans le répertoire argument

Après un changement de répertoire courant, l'ancien répertoire courant est stocké

dans '-', permettant d'y revenir avec 'cd -'
– exemples
cd
(equivaut à 'cd ~' et 'cd $HOME')
cd ..
cd ­
cd /tmp
cd tmp

   
Commandes de base
$CDPATH

● $CDPATH permet d'offrir des chemins

directement accessibles via « cd »
● Comme pour $PATH, les chemins sont
concaténés avec ':' :

$ echo $CDPATH
/home/user:/var:/home/user/doc
$

   
Commandes de base
ls

ls ­a ls ­t
Liste tous les fichiers (incluant .*) Affiche les plus récents en premier

ls ­l ls ­S
Affichage long (droits, propriétaire, Affiche les plus gros en premier
groupe, taille, date)
ls ­1
ls ­R Affiche le listing sur une colonne
Liste les fichiers récursivement

Les options se combinent directement entre­elles
ex : ls ­laRt

   
Commandes de base
ls

ls option argument
liste les fichiers/répertoires correspondant à argument ou dans le répertoire argument
– options
-a : affiche tous les fichiers (y compris ceux commencant par '.')
-l : listing étendu
-R : récursif
-S : tri par taille
-t : tri par date de modification
-1 : affichage sur une colone
– exemples
ls *.txt
ls /etc
ls /etc/host*
ls /etc/rc[1­3].d
ls /media/win/Program\ Files/
ls ­laR ~

   
Commandes de base
{mk,rm}dir
mkdir [­p] répertoire1 répertoire2 ...
crée les répertoires répertoire1, répertoire2, ...
l'option -p per et destination (fichier ou répertoire)
– options
-p : crée les répertoires supérieurs si nécessaire
– exemples
mkdir $HOME/documents
mkdir test $HOME/images_iso
mkdir ­p $HOME/documents/personnel/{photos,factures}

rmdir répertoire1 répertoire2
supprime les répertoires répertoire1, répertoire2, ...
ces répertoires doivent être vides pour pouvoir être supprimés (utiliser rm ­rf sinon)
– exemples
rmdir $HOME/documents
rmdir test $HOME/images_iso
rmdir $HOME/documents/personnel/{photos,factures,}
   
Commandes de base
cp & mv
cp source destination
copie la source (fichier ou répertoire) vers la destination (fichier ou répertoire)
– options
-p : préserve les droits
-R : récursif
-f : force l'écrasement de la destination
– exemples
cp *.txt /tmp
cp test.txt toast.txt
cp ­Rf /home /var/backup

mv source destination
déplace la source (fichier ou répertoire) vers la destination (fichier ou répertoire)
permet aussi de renommer un fichier
– exemples
mv *.txt /tmp
mv test.txt toast.txt
   
Commandes de base
rm & touch
rm argument
Supprime le fichier ou répertoire argument
– options
-R : récursif
-f : force la suppression
– exemples
rm ­rf /
rm toast.txt

touch fichier
Crée le fichier s'il n'existe pas, ou met la date de modification du fichier à l'heure
courant s'il existe
La commande ':>' permet aussi de créer un fichier
– exemples
touch toast.txt

   
Commandes de base
egrep
egrep options patron fichier
liste les fichiers/répertoires contenant une chaine correspondant à patron.
si fichier n'est pas spécifié, grep travaille sur STDIN
– options
-v : inverse le comportement de egrep (n'affiche que les lignes qui ne
correspondent pas)
-i : insensible à la casse
-R : récursif
– patrons d'expression régulières
si l'on utilise grep au lieu de egrep, il faut mettre un '\' devant les caractères ?, +, {, }, |, (, et )

. n'importe quel caractère
* le caractère précédent 0 ou plusieurs fois
+ le caractère précédent 1 fois au moins
? le caractère précédent 0 ou 1 fois
{n} le caractère précédent exactement n fois
{m,n} le caractère précédent de m à n fois
{n,} le caractère précédent n fois ou plus
[a­z] un caractère en minuscule
[a­zA­Z] une lettre
[0­9] un chiffre
^/$ le début/la fin de ligne
| séparateur pour spécifier de multiples expression 
 
 
(ou logique)
Commandes de base
egrep
● Matcher une ligne commençant par « foo » :
egrep "^foo.*"
● Matcher une ligne commençant par « foo » ou contenant « bar » :
egrep "^foo|bar"
● Matcher une ligne commençant par « foo » ou commençant par « bar » :
egrep "^(foo|bar)"
● Matcher une ligne commençant par « foo » et contenant « bar » :
egrep "^foo.*bar"
● Matcher une ligne commençant par « foo » et se terminant par « bar » :
egrep "^foo.*bar$"
● Matcher une ligne se terminant par un espace suivi d'un nombre de 1 à 3 chiffres :
egrep "[[:space:]]+[0­9]{1,3}$"
● Matcher une ligne se terminant par un espace suivi d'un nombre de 1 à 3 chiffres :
egrep "[[:space:]]+[0­9]{1,3}$"
● Matcher une ligne contenant le caractère '*' :
egrep "*"
● Matcher une ligne contenant le caractère '*' ou le caractère '?' :
  egrep "*|?"  
Commandes de base
cat, less, tee et wc
cat fichier1 fichier2 ...
affiche le contenu de fichier1 fichier2 ... sur la sortie standard
si cat est appellé sans arguments, la source est l'entrée standard
– exemple
cat /dev/urandom
less fichier1 fichier2 ...
comme cat, affiche le contenu de fichier1 fichier2 ... sur la sortie standard mais
effectue un arret à chaque page
si less est appellé sans arguments, la source est l'entrée standard
– exemple
less /etc/password

tee fichier
duplique l'entrée standard vers la sortie standard et dans un fichier
– exemple
vmstat 1 | tee toto
wc option fichier
compte le nombre de lignes (-l), bytes (-c), mots (-w) .... dans fichier (ou sur STDIN si
aucun fichier n'est spécifié)
  ● exemple  
wc ­l /etc/passwd
Commandes de base
tail et head
head [­nX] fichier1 fichier2 ...
affiche les X dernières lignes de fichier1 fichier2 ... sur la sortie standard
si tail est appellé sans arguments, la source est l'entrée standard
– exemple
head ­n1 /etc/passwd

tail [­nX] [­f] fichier1 fichier2 ...
affiche les X dernières lignes de fichier1 fichier2 ... sur la sortie standard
si tail est appellé sans arguments, la source est l'entrée standard et le nombre de
lignes est 10
l'option -f permet de faire un 'tail' continu sur un fichier qui croit
– exemple
tail ­n5 /var/log/syslog
tail ­f /var/log/syslog

Une combinaison des deux permet d'afficher la nième ligne d'un fichier :
head ­n10 /etc/passwd | tail ­n1 : affiche la 9ème (10-1) ligne de /etc/passwd
head ­n20 /etc/group | tail ­n3 : affiche les lignes 17 à 20 (20-3 -> 20) lignes de
  /etc/group  
Commandes de base
Versions 'z' & 'bz'
zcat fichier1 fichier2 ...
bzcat fichier1 fichier2 ...
comme cat, mais sur des fichiers gzippés/bzippés
si zcat/bzcat est appellé sans arguments, la source est l'entrée standard
– exemples
zcat myfile.gz
bzcat myfile.bz2

zless fichier1 fichier2 ...
bzless fichier1 fichier2 ...
comme less, mais sur des fichiers gzippés/bzippés
si less est appellé sans arguments, la source est l'entrée standard
– exemples
bzless myfile.bz2

zgrep options patron fichier
duplique l'entrée standard vers la sortie standard et dans un fichier
– exemples
  zgrep user myfile.gz  
Shell
Commandes multiples

● Le shell permet l'exécution de commandes

successives en les séparant par ';' :
ls > ~/liste.txt; cd ­; ls >> ~/liste.txt
● Le shell permet d'exécuter une commande
uniquement si la précédente a marché :
cat fichier > /dev/null && echo "le fichier existe"
grep ­i "effacez moi" fichier && rm ­f fichier
● Le shell permet d'exécuter une commande
uniquement si la précédent a échoué :
cat fichier > /dev/null|| echo "le fichier n'existe pas"
grep ­i "gardez moi" ~/fichier.txt || rm ­f fichier.txt
   
Shell
Job control

● Fonctionnalité interne au shell

● Permet de gérer des tâches (processus)
multiples dans un même shell :
– suspension temporaire : le processus est
arrêté jusqu'à nouvel ordre
– arrêt définitif : le processus est terminé
– mise en arrière/avant plan : le processus
reçoit l'entrée clavier
● Un processus peut ignorer l'arrêt définitif,
 
mais pas la suspension  
Shell
Job control
● Suspendre (stopper) un processus : <Ctrl>z
● Arrêter (terminer) un processus : <Ctrl>c
(si le processus est à l'avant plan)
● Arrêter (terminer) un processus : kill %n 
(si le processus est à l'arrière plan)
● Voir la liste des processus du terminal (jobs) : jobs
'+' est le job « courant » (%% ou %+)
'-' est le job « précédent » (%­)
● Mettre un job en arrière plan : bg %n ou %n&
● Mettre un job en avant plan : fg %n ou %n
 ●  
Lancer un job en arrière plan : commande &
Shell
Job control
$ sleep 100
<ctrl­z>
[1]+  Stopped                 sleep 100
$ sleep 200 &
[2] 19858
$ jobs
[1]+  Stopped                 sleep 100
[2]­  Running                 sleep 200 &
$ bg %1
[1]+ sleep 100
$ jobs
[1]­  Running                 sleep 100
[2]+  Running                 sleep 200 &
$ kill %1 
$ <return>
[1]­  Complété              sleep 100
$ fg
sleep 200 <ctrl­c>
   
$ jobs
$