2. Les commandes internes

2.1. . et source

Ces commandes synonymes exécutent le fichier (et ces éventuels arguments) qui leur est passé en argument dans le shell courant (i.e. par de fork).


$ source ~/.bash_profile                                                        

 ou

$ . ~/.bash_profile

2.2. export et unset

La commande export permet d'initialiser une variable d'environnement, i.e. une variable qui sera transmise à tous les processus fils du shell.


$ export OSTYPE=Linux                                                           
$ export CPUTYPE=K7
$ export PAGER=less
$ echo $OSTYPE $CPUTYPE $PAGER
Linux K7 less

La commande unset permet de supprimer le contenu d'une variable (d'environnement ou autre).


$ echo $OSTYPE                                                                  
Linux
$ unset OSTYPE    # la variable n'est pas préfixée par le symbole $             
$ echo $OSTYPE


2.3.  alias/unalias

Ce mécanisme permet de définir ou de redéfinir une commande. Exemple :


$ alias la='/bin/ls -a --color=auto'   # definition de l'alias la               
$ alias rm='/bin/rm -i'                # definition de l'alias rm
$ alias                                # afficher les alias courants
$ alias la='/bin/ls -a --color=auto'
$ alias rm='/bin/rm -i'

En général, on place ces alias dans le fichier ~/.bashrc. Si on veut supprimer un alias on utilise la commande unalias comme suit :


$ unalias rm                                                                    
$ alias                                # afficher les alias courants
$ alias la='/bin/ls -a --color=auto'

Pour ré-accéder à la commande masquée par son alias, comme dans l'exemple précédent où nous avons surchargé la commande classique rm, il suffit de :

  • Soit utiliser la commande par son nom absolu : /bin/rm.

  • Soit faire précéder la commande du caractère backslash (\), on tape donc toujours dans le cadre de l'exemple précédent : \rm

2.4. umask

Cette commande permet de spécifier (si elle est suivie d'un argument valide) ou d'afficher la valeur du masque de création des objets i.e. des fichiers.


$ umask  # affiche la valeur telle que prédéfinie dans ~/.bash_profile          
0077
$ umask 0027
$ umask
0027

2.5. Historique

Ce mécanisme a pour rôle de mémoriser les n dernières commandes entrées, ce nombre étant un paramètre réglable (c.f. variables d'environnements HISTSIZE et HISTFILESIZE). Cela permet de visualiser, d'éditer et/ou exécuter à nouveau les commandes mémorisées.


$ history 10   # liste les 10 dernières commandes mémo. avec leur numéro d'ordre
   93  ulimit -aS
   94  ulimit -Sn 2048
   95  man bash
   96  history
   97  echo $HISTSIZE
   98  history 10
   99  ls -la
  100  cd tmp
  101  ll
  102  history 10
                                                   

Pour relancer une commande, il suffit de l'appeler par son numéro (relativement à l'historique) en la préfixant par le caractère !. Par exemple, si on veut relancer la commande 99, il suffit de faire :


$ !99                                                                           
ls -la
total 8
drwx------    2 pascal   pascal       4096 Aug 11 19:15 .
drwxr-xr-x    4 pascal   pascal       4096 Aug 11 19:15 ..

Tableau 3. Quelques commandes de manipulation de l'historique

Expression Sémantique
!!Répéter la dernière commande.
!nRépéter la commande numéro n.
!-nRépéter la nième précédent la dernière de l'historique, i.e. !-2 : avant dernière commande.
!texteRépéter la dernière commande commençant par texte.
!?texteRépéter la dernière commande contenant texte.
!:nRépéter le nième mot de la dernière commande.
!$Répéter le dernier mot de la dernière commande.
!*Répéter tous les arguments de la dernière commande.
^old^newRépéter la dernière commande en commençant par remplacer la première occurence de old par new.
!n:s^old^newRépéter la nième commande en commençant par remplacer la première occurence de old par new.
!n:gs^old^newRépéter la nième commande en commençant par remplacer toutes les occurences de old par new (substitution globale).

2.6. Completion

Ce mécanisme permet, selon le contexte, de compléter les noms de fichiers, d'utilisateurs, de machines ou de variables à partir de la saisie d'un préfixe suivi de la frappe du caractère « TAB ». Le contexte par défaut étant celui de fichiers.

Supposons, par exemple, que le contenu du répertoire courant soit le suivant :


_merge.pl       check.pl             fdate.sh             mytest.pl
_pidof.pl       crlf.pl              gen-meta-index.pl    replace_header_html.pl
_split.pl       extract.pl           idle.pl              rotate.pl
_test.pl        extract_piste.sh     logfile-1.2.pl       rsync.pl
bidir.pl        fcomp.sh             mylock.sh

Alors la séquence suivante : $ ls l<TAB> est résolue en (seule correspondance possible) : $ ls logfile-1.2.pl

Tandis que la séquence ci-contre : $ ls ext<TAB> est résolue partiellement en : $ ls extract suivie de l'émission d'un bip qui signale que cette expansion est incomplète puisque deux fichiers correspondent au préfixe saisi. La commande précédente suivie à nouveau de la séquence <TAB> permet d'obtenir l'ensemble des réponses potentielles :


$ ls extract<TAB><TAB>                              
extract.pl*       extract_piste.sh*                                             
$ ls extract

La saisie d'un seul caractère supplémentaire permet dans ce dernier cas de lever l'ambiguïté.

Enfin, il est possible de limiter les correspondances potentielles à la completion en positionnant la variable FIGNORE. Dans l'exemple suivant, on exclut des correspondances possibles les fichiers suffixés en .o, .out et *~.


$ export FIGNORE=".o:.out:*~"                                                   

Contexte utilisateur : le mécanisme de completion peut être utilisé pour compléter les noms d'utilisateurs. Il faut utiliser le préfixe ~ (il change le contexte de la completion) :


$ cd ~pa<TAB>                                                                   
$ cd ~pascal

Contexte de variables : le mécanisme de completion peut être utilisé pour compléter les noms de variables. Il faut utiliser le préfixe $ (il change le contexte de la completion) :


$ varia_1=10                                                                    
$ echo $var<TAB>
$ echo $varia_1 <ENTREE>
10

Contexte de nom d'hôte : le mécanisme de completion peut être utilisé pour compléter les noms de machines. Il faut utiliser le préfixe @ (il change le contexte de la completion) :


$ @tu<TAB>                                                                      
$ @tux<TAB>
$ @tux.corto.home 

2.7. Navigation dans les répertoires

2.7.1. Commandes cd

Supposons qu'un utilisateur ait souvent besoin de se rendre alternativement dans le répertoire /home/cvsroot/ et dans son propre répertoire ~/projets, il peut alors :

  • pour se rendre en /home/cvsroot/C-network/, taper :


$ cd /home/cvsroot/C-network                                                    

  • et pour se rendre en ~/projets, taper :


$ cd ~/projets                                                                  
                                                              

Mais, cet utilisateur peut aussi se simplifier la vie en positionnant la variable cdpath, ainsi :


$ export CDPATH="/home/cvsroot:~"                                               

Ainsi, il peut se contenter de :

  • taper dans le premier cas :


$ cd C-network                                                                  
/home/cvsroot/C-network

  • et dans le second :


$ cd projets                                                                    
~/projets

2.7.2. Pile de répertoires : pushd, popd et dirs

Une pile est une structure de données qui permet de mémoriser des entrées et dont la stratégie d'accès est de type LIFO (Last In, First Out), i.e. on accède uniquement au sommet de la pile.

La pile des répertoires est géré par les trois primitives suivantes :

  • La commande pushd permet de changer de répertoire (comme cd), mais l'ancien répertoire est conservé dans la pile (il est empilé).

  • La commande popd permet de changer de répertoire (comme cd), en dépilant le sommet de la pile.

  • La commande dirs permet d'afficher le contenu de la pile.

L'exemple suivant permet d'en comprendre le fonctionnement :

 
$ pwd 1 
/home/pascal/enseignement/NeoTechIII/V2L-PRAI/csh                               

$ pushd /usr/local/etc 2 
/usr/local/etc ~/enseignement/NeoTechIII/V2L-PRAI/csh

$ pwd 3 
/usr/local/etc

$ popd 4 
~/enseignement/NeoTechIII/V2L-PRAI/csh

$ pwd 5 
/home/pascal/enseignement/NeoTechIII/V2L-PRAI/csh

$ pushd /usr/local/etc
/usr/local/etc ~/enseignement/NeoTechIII/V2L-PRAI/csh

$ pwd 
/usr/local/etc

$ dirs -v 6 
0       /usr/local/etc
1       ~/enseignement/NeoTechIII/V2L-PRAI/csh

1

Affiche le chemin courant.

2

Se rend dans le répertoire spécifié et l'empile au sommet de la pile.

3

Affiche le chemin courant.

4

Dépile le sommet et se rend dans le répertoire indiqué.

5

Affiche le chemin courant.

6

Affiche le contenu de la pile, en commençant par le sommet.

2.8.  Gestion des processus

2.8.1. Les processus

Un processus est l'instance d'un programme en exécution. C'est une structure de données qui contient du code statique, des données statiques et dynamiques et un environnement d'exécution. Un processus possède un cycle de vie marqué par des états comme l'exécution (runnable), la suspension, l'attente, le sommeil, l'état zombie... Pour se voir allouer des tranches de temps (time slice) d'exécution sur le CPU, un processus doit être dans l'état exécutable.

Chaque programme démarré par le shell nécessite la création d'un nouveau processus, on a ainsi une arborescence de processus, puisqu'une nouvelle instance ne possède qu'un seul parent. L'utilitaire ps permet d'obtenir un instantané des processus en cours

$ > ps 
  PID1  TTY2       TIME3 CMD4

  544 pts/0    00:00:00 bash                                                    
 1473 pts/0    00:00:00 emacs
 1479 pts/0    00:00:00 ssh
 1481 pts/0    00:00:00 ps

1

Process IDentifier, identifiant (unique) du processus.

2

TTY device, terminal d'exécution.

3

TIME consumed, temps CPU consommé.

4

La commande exécutée.

Le système identifie chaque processus au moyen d'un entier appelé pid. Dans l'exemple précédent, la première ligne identifie le processus numéro 544, qui un shell (GNU/bash) sur le terminal /dev/pts/0.

La commande ps l (c.f. exemple suivant) permet d'obtenir plus de détails sur les processus. On y trouve les paramètres suivants :

  • l'uid : propriétaire du processus,

  • le pid : identifiant du processus,

  • le ppid : identifiant du père du processus,

  • le pri : i.e. priorité d'ordonnancement,

  • le nice : priorité assignée par nice ; la modification de cette valeur permet d'influer sur l'algorithme d'ordonnancement [scheduling],

  • le vsz : donne la taille de la mémoire virtuelle utilisée (exprimée en kilo-octet),

  • le rss : taille de la mémoire réelle utilisée (exprimée en kilo-octet).

  • le wchan : le canal d'attente, i.e. une adresse sur une structure de données identifiant la ressource ou l'évènement pour lequel le processus est en attente,

  • le state : état du processus parmi (R, S, T, Z ...),

  • le tty : le terminal associé au processus,

  • le time : temps cpu accumulé (utilisateur et système),

  • enfin la commande elle-même.


$ ps l
F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY        TIME COMMAND
0  1000   544   543  11   0  2400 1516 wait4  S    pts/0      0:00 -bash
0  1000  1473   544   9   0  6152 2276 signal T    pts/0      0:00 emacs toto
0  1000  1479   544   9   0  2652 1396 signal T    pts/0      0:00 ssh -v -p 22 pascal@godel                  
0  1000  1489   544  17   0  3280 1412 -      R    pts/0      0:00 ps l

L'invocation d'un programme déclenche un nouveau processus chargé de son exécution et pendant ce temps, le shell (père du processu) est suspendu jusqu'à la terminaison de ce processus. On parle alors d'éxecution interactive (ou en avant-plan [foreground]). Il est évidement possible d'exécuter un processus de manière asynchrone [background], i.e. de permettre au shell d'exécuter de nouvelles commandes immédiatement. Il suffit pour se faire de postfixer la commande à exécuter de manière asynchrone par le caractère "ampersand" : &. Voici un exemple (noter le numéro du processus : 20713) :


$ fetchmail &                                                                   
[2] 20713

GNU/bash reprend le mécanisme de suspension d'un processus interactif (introduit par csh par la commande ^Z (lire <CTRL>-Z). La reprise peut se faire de manière asynchrone (arrière plan) par la commande bg ou de manière interactive (avant plan) avec la commande symétrique fg.

Pour finir, signalons la commande top qui permet d'avoir des informations en temps réel sur les processus (rafraîchissement toutes les 3 secondes, par défaut sous Debian). En voici un exemple tronqué :


top - 08:35:24 up 1 day, 45 min,  1 user,  load average: 0.05, 0.05, 0.00       
Tasks:  41 total,   2 running,  37 sleeping,   2 stopped,   0 zombie
Cpu(s):   3.6% user,   1.7% system,   0.0% nice,  94.7% idle
Mem:    513024k total,   110736k used,   402288k free,    23804k buffers
Swap:   498004k total,        0k used,   498004k free,    43080k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  Command            
  302 root      18   0  1980 1980 1520 R  3.0  0.4   0:27.77 wdmLogin 
  293 root      12 -10 56732 7088 1700 S  1.3  1.4   0:49.73 XFree86  
 1490 pascal    11   0   932  932  748 R  0.7  0.2   0:00.33 top           
    2 root       9   0     0    0    0 S  0.3  0.0   0:00.65 keventd   
    1 root       8   0   464  464  408 S  0.0  0.1   0:04.90 init  
    3 root      19  19     0    0    0 S  0.0  0.0   0:00.06 ksoftirqd_CPU0  
    4 root       9   0     0    0    0 S  0.0  0.0   0:00.00 kswapd 
    5 root       9   0     0    0    0 S  0.0  0.0   0:00.00 bdflush 
    6 root       9   0     0    0    0 S  0.0  0.0   0:00.09 kupdated 
    7 root       9   0     0    0    0 S  0.0  0.0   0:00.00 i2oevtd
    9 root       9   0     0    0    0 S  0.0  0.0   0:00.62 kjournald
   40 root       9   0     0    0    0 S  0.0  0.0   0:00.00 khubd
   75 root       9   0     0    0    0 S  0.0  0.0   0:00.01 kjournald
   76 root       9   0     0    0    0 S  0.0  0.0   0:01.12 kjournald
   77 root       9   0     0    0    0 S  0.0  0.0   0:00.56 kjournald
   78 root       9   0     0    0    0 S  0.0  0.0   0:00.58 kjournald
   79 root       9   0     0    0    0 S  0.0  0.0   0:00.03 kjournald
   80 root       9   0     0    0    0 S  0.0  0.0   0:00.04 kjournald
   98 root       9   0     0    0    0 S  0.0  0.0   0:00.00 eth0
  164 root       9   0   756  756  644 S  0.0  0.1   0:00.20 syslogd
  167 root       9   0  1240 1240  416 S  0.0  0.2   0:00.52 klogd
  185 root       9   0  1348 1348 1236 S  0.0  0.3   0:00.02 sshd 
  194 root       9   0  2964 2964  684 S  0.0  0.6   0:00.22 xfs 
  253 root       8   0  1380 1376 1008 S  0.0  0.3   0:00.01 bash
  256 root       9   0   372  372  316 S  0.0  0.1   0:00.02 tee
  257 root       9   0   352  352  300 S  0.0  0.1   0:00.01 logger=
  267 daemon     9   0   552  552  480 S  0.0  0.1   0:00.00 atd
  270 root       8   0   660  660  552 S  0.0  0.1   0:00.00 cron
  283 root       9   0  1236 1236 1172 S  0.0  0.2   0:00.21 wdm
  287 root       9   0   444  444  388 S  0.0  0.1   0:00.00 getty
  288 root       9   0   444  444  388 S  0.0  0.1   0:00.01 getty
  289 root       9   0   444  444  388 S  0.0  0.1   0:00.00 getty
  290 root       9   0   444  444  388 S  0.0  0.1   0:00.00 getty
  291 root       9   0   444  444  388 S  0.0  0.1   0:00.00 getty
  292 root       9   0   444  444  388 S  0.0  0.1   0:00.01 getty
  294 root       9   0  1328 1328 1256 S  0.0  0.3   0:00.02 wdm
  541 root       9   0  1924 1924 1776 S  0.0  0.4   0:00.08 sshd
  543 pascal     9   0  2000 2000 1828 S  0.0  0.4   0:01.08 sshd
  544 pascal     9   0  1516 1516 1212 S  0.0  0.3   0:00.25 bash
 1473 pascal     9   0  2276 2276 1504 T  0.0  0.4   0:00.21 emacs
 1479 pascal     9   0  1396 1396 1136 T  0.0  0.3   0:00.14 ssh

2.8.2. Les signaux

Les signaux sont une forme limitée de communication inter-processus. Ils permettent de prévenir les processus de l'occurence de certains évènements. Il est possible d'envoyer des signaux à des processus interactifs à partir du clavier. La commande suivante permet de connaître les associations clés/signaux :


$ stty -a
speed 38400 baud; rows 53; columns 80; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = M-^?; eol2 = M-^?;
start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
flush = ^O; 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
echoctl echoke

Ainsi, la séquence <CTRL>-C (^C) permet d'envoyer le signal de terminaison (SIGINT signal), la séquence <CTRL>-\ (^\) permet d'envoyer un autre signal de terminaison (SIGQUIT), la séquence <CTRL>-Z (^Z) permet d'envoyer le signal de suspension (SIGTSTP). Par défaut, les deux premiers signaux (SIGINT et SIGQUIT) termine le processus, tandis que le troisième ne fait que suspendre l'éxecution, i.e. elle peut donc être reprise. Ce comportement par défaut peut cependant être redéfini au sein d'un processus.

Sur une architecture GNU/Linux on trouve 62 signaux. La commande, improprement nommée kill (c.f. man 1 kill) permet d'envoyer des signaux à un processus. Sa syntaxe est la suivante : kill <signal> <pus>, où <signal> est le signal envoyé au processus de numéro <pus>

La liste des signaux délivrables par la commande kill peut être obtenue de la manière suivante :


$ kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL
 5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE
 9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2
13) SIGPIPE     14) SIGALRM     15) SIGTERM     17) SIGCHLD
18) SIGCONT     19) SIGSTOP     20) SIGTSTP     21) SIGTTIN
22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO
30) SIGPWR      31) SIGSYS      32) SIGRTMIN    33) SIGRTMIN+1
34) SIGRTMIN+2  35) SIGRTMIN+3  36) SIGRTMIN+4  37) SIGRTMIN+5
38) SIGRTMIN+6  39) SIGRTMIN+7  40) SIGRTMIN+8  41) SIGRTMIN+9
42) SIGRTMIN+10 43) SIGRTMIN+11 44) SIGRTMIN+12 45) SIGRTMIN+13                 
46) SIGRTMIN+14 47) SIGRTMIN+15 48) SIGRTMAX-15 49) SIGRTMAX-14
50) SIGRTMAX-13 51) SIGRTMAX-12 52) SIGRTMAX-11 53) SIGRTMAX-10
54) SIGRTMAX-9  55) SIGRTMAX-8  56) SIGRTMAX-7  57) SIGRTMAX-6
58) SIGRTMAX-5  59) SIGRTMAX-4  60) SIGRTMAX-3  61) SIGRTMAX-2
62) SIGRTMAX-1  63) SIGRTMAX 

Parmi ces signaux, deux ne peuvent être ni ignorés, ni détournés. Il s'agit du SIGKILL (terminaison) et du SIGSTOP (suspension ou stop) (à ne pas confondre avec le SIGTSTP vu précédemment).

2.8.3. Jobs

Cette notion inventée par la branche BSD d'Unix™ et introduite par csh est désormais disponible sur toutes les distributions Unixlibres.

Un job est soit un processus, soit un groupe de processus lancé par le shell. Un job peut être suspendu, redémarré, terminé, executé interactivement ou de manière asynchrone. Le shell sait gérer plusieurs jobs simultanément, toutefois à un instant donné seul un job peut avoir accès au terminal. Les jobs sont intéressants dès que les processus qu'ils contrôlent ont une durée de vie de quelques secondes. Analysons la séquence suivante :

$ su toor 1 
Password:
# id
uid=0(root) gid=0(wheel) groups=0(wheel)
# suspend 2 

Suspended
$ jobs 3
[1]  - Running                xemacs C-csh_n_tcsh.xml
[2]  + Suspended              su toor
$ du -s -h /usr & 4
[3] 21136
$ ls3.7G    /usr 5
[3]    Exit 1                 du -s -h /usr 6
$ ls    /usr 
C-csh_n_tcsh.xml Makefile         _mystyle.xsl     images           my_style.xsl
CVS              _mystyle.css     html             my_print.dsl


$ du -s -h /usr &

...

$ jobs
[1]    Running                       xemacs C-csh_n_tcsh.xml
[2]  - Suspended                     su toor
[3]  + Suspended (tty output)        du -s -h /usr 7

$ %3 8
du -s -h /usr
3.7G    /usr

$ jobs
[1]  - Running                       xemacs C-csh_n_tcsh.xml
[2]  + Suspended                     su toor

$ %2
# exit 9
$ jobs
[1]  + Running                       xemacs C-csh_n_tcsh.xml

1

Changement d'identité utilisateur.

2

Suspension du processus et restauration de l'identité précédente.

3

Liste des jobs en cours;

4

Lancement d'une nouvelle commande, i.e. un processus de manière asynchrone, celui ci écrira son éventuel résultat sur la sortie standard, sans se préoccuper de ce qu'il peut se passer !

5

Le résultat de la commande du survient au moment où l'utilisateur tape sa commande ls et pertube donc son affichage.

6

Terminaison du processus. La commande ls s'affiche alors.

8

Le comportement du processus change, l'utilisateur est informé que le job 3 est prêt à imprimer son résultat (il est suspendu jusqu'à ce qu'il soit autorisé à la faire).

7

On rappelle le job 3, ce qui lui permet d'afficher son résultat.

Un job asynchrone qui veut lire sur l'entrée standard alors que ce canal n'a pas été redirigé est toujours suspendu. Il faut le relancer de manière interactive pour qu'il puisse collecter ses données sur l'entrée standard.

9

On rappelle le job 2 et on le termine explicitement par un exit. Il reste alors un seul job en exécution asynchrone.

La liste des jobs en cours est donnée par la commande jobs.

Le caractère % en première position dénote un job.

Le tableau suivant (c.f. « Tableau 4, «  référencement des jobs » ») récapitule les différentes manières de référencer un job.

Tableau 4.  référencement des jobs

Expression Sémantique
%njob numéro n.
%strjob commençant par la chaine str.
%?strjob contenant la chaine str.

Le tableau suivant (c.f. « Tableau 4, «  référencement des jobs » ») donne les commandes de contrôle d'un job.

Tableau 5.  Commandes contrôlant les jobs

Expression Sémantique
bg [name]

Place le job name en exécution asynchrone.

Si l'argument name n'est pas précisé, la commande s'applique au job courant.

name &Place le job name en exécution asynchrone.
fg [name]

Place le job name en exécution interactive.

Si l'argument name n'est pas précisé, la commande s'applique au job courant.

namePlace le job name en exécution interactive.
stop nameSuspend le job name.

Enfin, la commande kill permet aussi d'envoyer des signaux aux jobs, en utilisant le même référencement des jobs qu'en « Tableau 4, «  référencement des jobs » ». Ainsi, la commande suivante met fin au job 1 :


$ kill -SIGTERM %1                                                              

Commande nohupEn GNU/bash, tous les processus (y compris les processus asynchrones) sont terminés lors d'un logout, l'exécution de cette commande déclenchant l'envoi du signal SIGHUP à tous les processus fils. Si un processus doit poursuivre son exécution au-delà du shell qui lui a donné naissance, il faut utiliser la commande nohup (c.f. man 1 nohup).

2.8.4. ulimit

Cette commande a pour objet de définir des limites à la consommation des ressources du système par les processus. Il s'agit d'un intervalle définit par une borne haute (H : qui ne peut être modifiée qu'à la baisse, sauf par le super-utilisateur) et une borne basse (S : qui peut être accrue jusqu'aux valeurs de la borne haute).


$ ulimit -a        # affichage de toutes les limites (= min(S, H))              
core file size        (blocks, -c) 0
data seg size         (kbytes, -d) unlimited
file size             (blocks, -f) unlimited
max locked memory     (kbytes, -l) unlimited
max memory size       (kbytes, -m) unlimited
open files                    (-n) 1024
pipe size          (512 bytes, -p) 8
stack size            (kbytes, -s) 8192
cpu time             (seconds, -t) unlimited
max user processes            (-u) 4096
virtual memory        (kbytes, -v) unlimited

$ ulimit -Ss 16384 # augmenter la limite S de la pile (=s) à 16Ko
$ ulimit -aS       # affichage des limites S (basses)
core file size        (blocks, -c) 0
data seg size         (kbytes, -d) unlimited
file size             (blocks, -f) unlimited
max locked memory     (kbytes, -l) unlimited
max memory size       (kbytes, -m) unlimited
open files                    (-n) 1024
pipe size          (512 bytes, -p) 8
stack size            (kbytes, -s) 16384
cpu time             (seconds, -t) unlimited
max user processes            (-u) 4096
virtual memory        (kbytes, -v) unlimited

$ ulimit -Sn 2048  # augmenter la limite S du nb max. de fichiers ouverts
-bash: ulimit: open files: cannot modify limit: Operation not permitted

2.9. Redirection de commandes

Rapellons que, sous Unix™ en général et sous GNU/Linux en particulier, il existe trois canaux d'E/S standard :

  • L'entrée standard [stdin] associée au fd [file descriptor] 0 liée traditionnellement au clavier.

  • La sortie standard [stdout] associée au fd 1, liée traditionnellement à l'écran du terminal.

  • La sortie standard d'erreur [stderr] associée au fd 2, liée traditionnellement à l'écran du terminal.

Formellement, un descripteur de fichier est un entier non signé utilisé par les processus pour référencer les canaux d'E/S.

La puissance et la flexibilité du concept des canaux standards d'E/S tient essentiellement au fait que le shell peut rediriger ces canaux aussi bien sur des fichiers, que l'écran ou le clavier.

Tableau 6. Redirections

SymboleSémantique
> <fnom>La sortie standard est redirigée dans le fichier <fnom>. S'il existait, son contenu est perdu et sinon il est créé.
>> <fnom>La sortie standard est redirigée dans le fichier <fnom>, ouvert en mode ajout s'il existait, sinon il est créé.
2> <fnom>La sortie d'erreur est redirigée dans le fichier <fnom>. S'il existait, son contenu est perdu et sinon il est créé.
2>> <fnom>La sortie d'erreur est redirigée dans le fichier <fnom>, ouvert en mode ajout s'il existait, sinon il est créé.
< <fnom>L'entrée standard est le fichier <fnom>.
<< <mot>Lit les entrées du shell jusqu'à une ligne commençant (et contenant uniquement) le mot <mot> qui agit comme un marqueur de fin.

Le positionnement de la variable interne NO_CLOBBER, permet d'éviter l'écrasement des fichiers existants dans le cas de l'utilisation des commandes de redirection > et >&. De plus les commandes >> et >>& ne peuvent être exécutées que sur des fichiers existants.

Enfin, la sémantique initiale des commandes de redirection (après activation de noclobber) peut être explicitement restituée en utilisant le symbole !. Ainsi, les commandes >!, >>!, >&! et >>&! ont un comportement identique à leurs homologues du tableau précédent (i.e. sans le !, c.f. « Tableau 6, « Redirections » »).

EXEMPLES :

$ cat > file.txt << fin_de_saisie                                               
>> première ligne
>> puis une 2e
>> Encore une autre !
>> C'est pas fini ...
>> fin_de_saisie

$  ll file.txt
-rw-------  1 pascal  gnu  - 65 Aug 1 15:58 file.txt

$ cat < file.txt  # équivalent à cat file.txt
première ligne
puis une 2e
Encore une autre !
C'est pas fini ...


$ ( find /home -name "*~" -print 1> fres ) 2> ferr
                  # séparer les sorties standard (> fres) et d'erreur (2> ferr) 
$ cat fres        # les résultats
/home/pascal/enseignement/NeoTechIII/V2L-PRAI/CS2-csh/toto.sh~
/home/pascal/enseignement/NeoTechIII/V2L-PRAI/Progr-V2L/Progr-V2L.xml~
/home/miji/work/these/annexes/annexes.sxw~
/home/miji/work/these/partie1/part_legende/legendes.sxw~
/home/hosts/corto-home/turing/postfix/main.cf~
/home/hosts/corto-home/euler/ulocal-etc/flexbackup/flexbackup.conf~
/home/hosts/corto-home/euler/ulocal-etc/tripwire/twpol.txt~
/home/hosts/corto-home/euler/etc/ssh/sshd_config~
/home/hosts/corto-home/tux/etc/apache/httpd.conf~
/home/hosts/corto-home/tux/etc/apache-ssl/httpd.conf~

$ cat ferr        # les erreurs
find: /home/miji/.ssh: Permission denied
find: /home/miji/work/lit_reu/Dayot: Permission denied
find: /home/miji/Choices: Permission denied
find: /home/miji/pdf: Permission denied
find: /home/miji/tmp: Permission denied
find: /home/miji/.Eterm: Permission denied
find: /home/miji/.mozilla: Permission denied
find: /home/miji/.mutt: Permission denied
find: /home/miji/.netscape: Permission denied
find: /home/miji/.prefs: Permission denied
find: /home/miji/.vnc: Permission denied
find: /home/miji/.Gabber: Permission denied
find: /home/miji/.wmakerconf: Permission denied

2.10.  Tubes [Pipelines]

Le mécanisme de pipeline consiste à rediriger la sortie d'une commande vers l'entrée d'une autre. D'un point de vue syntaxique nous avons la structure suivante :


<commandA> | <commandB>                                                         

Exemple 4.  Utilisation du mécanisme de pipeline


ls -l | sort -k 5n                                                              

La sortie de la commande ls -l est redirigée vers l'entrée de la commande sort -k 5n.

Q : Que permet de réaliser la commande précédente ?
Q :

Que permet de réaliser la commande précédente ?

R :