Programmation systeme en C sous Linux

I
II
Programmation système
en C sous
Linux
Christophe Blaess
Eyrolles

I
Avant-propos
La dynamique des logiciels libres en général et du système Gnu/Linux en particulier a pris
récemment une importance surprenante. Le volume de trafic dans les forums de
discussion Usenet. le nombre de revues traitant de Linux, et même l'écho qu'obtient ce
système auprès des grandes entreprises informatiques commerciales laissent augurer de
l'envergure à laquelle peut prétendre le projet Linux, initié par une poignée de
développeurs il y a moins de dix ans.
Bien au-delà du «pingouin aux oeufs d'or» dont trop de gens aimeraient profiter, il s'agit en
réalité d'un phénomène technologique particulièrement intéressant. La conception même
du noyau Linux ainsi que celle de tout l'environnement qui l'accompagne sont des
éléments passionnants pour le programmeur. La possibilité de consulter les sources du
système d'exploitation, de la bibliothèque C ou de la plupart des applications représente
une richesse inestimable non seulement pour les passionnés qui désirent intervenir sur le
noyau, mais également pour les développeurs curieux de comprendre les mécanismes
intervenant dans les programmes qu'ils utilisent.
Dans cet ouvrage, j'aimerais communiquer le plaisir que j'éprouve depuis plusieurs
années à travailler quotidiennement avec un système Linux. Je me suis trouvé
professionnellement dans divers environnements industriels utilisant essentiellement des
systèmes Unix classiques. L'emploi de PC fonctionnant sous Linux nous a permis de
multiplier le nombre de postes de travail et d'enrichir nos systèmes en créant des stations
dédiées à des tâches précises (filtrage et diffusion de données, postes de supervision... ),
tout en conservant une homogénéité dans les systèmes d'exploitation des machines
utilisées.
Ce livre est consacré à Linux en tant que noyau, mais également à la bibliothèque Gnu
GlibC, qui lui offre toute sa puissance applicative. On considérera que le lecteur est à
l'aise avec le langage C et avec les commandes élémentaires d'utilisation du système
Linux. Dans les programmes fournis en exemple, l'effort a porté sur la lisibilité du code
source plutôt que sur l'élégance du codage. Les ouvrages d'initiation au langage C sont
nombreux on conseillera l'indispensable [KERNIGHAN 1994], ainsi que l'excellent cours
[CASSAGNE 1998], disponible librement sur Internet. En ce qui concerne l'installation et
l'utilisation de Linux, on se tournera vers [WELSH 1995] ou [DUMAS 1998].
Le premier chapitre présentera rapidement les concepts et les outils nécessaires au
développement sous Linux. Les utilitaires ne seront pas détaillés en profondeur, on se
reportera aux documentations les accompagnant (pages de manuels, fichiers info. etc.).
Nous aborderons ensuite la programmation proprement dite avec Linux et la GlibC. Nous
pouvons distinguer cinq parties successives :
• Les chapitres 2 à 11 sont plus particulièrement orientés vers l'exécution des
programmes. Nous y verrons les identifications des processus, l'accès à
l'environnement, le lancement et
II
l'arrêt d'un logiciel. Nous traiterons également des signaux, en examinant les
extensions temps-réel Posix.1b, des entrées-sorties simples et de l'ordonnancement
des processus. Nous terminerons cette partie par une présentation des threads
Posix.1c.
• La deuxième partie sera consacrée à la mémoire. tant au niveau des mécanismes
d'allocation et de libération que de l'utilisation effective des blocs ou des chaînes de
caractères. Cette partie recouvrira les chapitres 13 à 17 et se terminera par l'étude des
traitements avancés sur les blocs de mémoire, comme les expressions régulières ou le
cryptage DES.
• Nous aurons ensuite une série de chapitres consacrés aux fichiers. Les chapitres 18 et
19 serviront à caractériser les descripteurs de fichiers et les flux. puis les chapitres 20
à 22 décriront les opérations sur les répertoires, les attributs des fichiers et les hases
de données disponibles avec la GIibC.
• Les chapitres 23 à 27 peuvent être considérés comme traitant des données elles-
mêmes, aussi bien les types spécifiques comme les caractères étendus que les
fonctions mathématiques, les informations fournies par le système d'exploitation ou
l'internationalisation des programmes.
• Enfin, la dernière partie de ce livre mettra l'accent sur les communications, tout
d'abord entre processus résidant sur le même système, avec les mécanismes
classiques et les IPC Système V. Nous verrons ensuite une introduction à la
programmation réseau et à l'utilisation des terminaux pour configurer des liaisons
série. Dans cette partie qui s'étend des chapitres 28 a 33, on examinera également
certains mécanismes d'entrée-sortie avancés permettant des multiplexages de canaux
de communication ou des traitements asynchrones.
On remarquera que j'accorde une importance assez grande à l'appartenance d'une
fonction aux normes logicielles courantes. C'est une garantie de portabilité des
applications. Les standards que je considère généralement sont le C Ansi (qu'on devrait
d'ailleurs plutôt nommer Iso C), Posix.1 qui est habituellement considéré comme «la»
norme Posix. Posix.1b qui caractérise les extensions temps-réel, Posix.1c qui normalise
les threads, Posix.1e qui traite de la sécurité des autorisations d'accès. Les spécifications
Unix 98 (Single Unix Version 2) sont également importantes car elles représentent une
bonne partie de ce qu'on peut s'attendre à trouver sur l'essentiel des stations Unix
actuelles.
La rédaction de ce livre a réclamé beaucoup de temps et a dévoré les moments de loisir
que j'aurais pu consacrer à ma famille. Mon épouse, Anne-Sophie, et mes filles, Jennifer et
Mina, l'ont accepté et m'ont soutenu tout au long de ce projet. Je leur dédie ce travail.
Soulac-sur-Mer; avril 2000.
Christophe BLAESS.
mailto: [e-mail]
http://perso.club-internet.fr/ccb

III
Table des matières
AVANT-PROPOS...........................................................................................................I
1 ........................................................................................................................................1
CONCEPTS ET OUTILS ..............................................................................................1
GÉNÉRALITÉS SUR LE DÉVELOPPEMENT SOUS LINUX .....................................................1
OUTILS DE DÉVELOPPEMENT ..........................................................................................3
ÉDITEURS DE TEXTE .......................................................................................................4
Vi et Emacs.................................................................................................................4
Éditeurs Gnome ou Kde..............................................................................................4
Nedit ...........................................................................................................................6
COMPILATEUR, ÉDITEUR DE LIENS..................................................................................6
DÉBOGUEUR, PROFÏLEUR................................................................................................9
TRAITEMENT DU CODE SOURCE ....................................................................................14
Vérificateur de code..................................................................................................14
Mise en forme...........................................................................................................14
Utilitaires divers.......................................................................................................16
CONSTRUCTION D'APPLICATION ...................................................................................18
DISTRIBUTION DU LOGICIEL..........................................................................................19
Archive classique......................................................................................................19
Paquetage à la manière Red Hat..............................................................................20
ENVIRONNEMENTS DE DÉVELOPPEMENT INTÉGRÉ........................................................21
CONTRÔLE DE VERSION ................................................................................................21
BIBLIOTHÈQUES SUPPLÉMENTAIRES POUR LE DÉVELOPPEMENT ...................................22
interface utilisateur en mode texte............................................................................23
Developpement sous X-Window................................................................................23
Les environnements Kde et Gnome...........................................................................24
CONCLUSION ................................................................................................................24
2 ......................................................................................................................................25
LA NOTION DE PROCESSUS...................................................................................25
PRESENTATION DES PROCESSUS....................................................................................25
IDENTIFICATION PAR LE PID.........................................................................................26
IDENTIFICATION DE L'UTILISATEUR CORRESPONDANT AU PROCESSUS ..........................29
IDENTIFICATION GROUPE D'UTILISATEURS DU PROCESSUS............................................35
IDENTIFICATION DU GROUPE DE PROCESSUS .................................................................38
IDENTIFICATION DE SESSION .........................................................................................41
CAPACITÉS D'UN PROCESSUS ........................................................................................43
CONCLUSION ................................................................................................................46
3 ......................................................................................................................................47
ACCÈS À L'ENVIRONNEMENT..............................................................................47
IV
VARIABLES D'ENVIRONNEMENT ...................................................................................47
VARIABLES D'ENVIRONNEMENT COURAMMENT UTILISÉES...........................................54
ARGUMENTS EN LIGNE DE COMMANDE ........................................................................56
OPTIONS SIMPLES - POSIX.2 .........................................................................................58
OPTIONS LONGUES - GNU.............................................................................................60
Sous-options.............................................................................................................63
EXEMPLE COMPLET D'ACCÈS L'ENVIRONNEMENT.........................................................64
CONCLUSION................................................................................................................70
4......................................................................................................................................71
EXÉCUTION DES PROGRAMMES.........................................................................71
LANCEMENT D'UN NOUVEAU PROGRAMME...................................................................71
CAUSES D'ÉCHEC DE LANCEMENT D'UN PROGRAMME...................................................77
FONCTIONS SIMPLIFIÉES POUR EXÉCUTER UN SOUS-PROGRAMME ................................80
CONCLUSION................................................................................................................88
5......................................................................................................................................89
FIN D'UN PROGRAMME..........................................................................................89
TERMINAISON D'UN PROGRAMME.................................................................................89
Terminaison normale d'un processus.......................................................................89
Terminaison anormale d'un processus.....................................................................92
EXÉCUTION AUTOMATIQUE DE ROUTINES DE TERMINAISON.........................................94
ATTENDRE LA FIN D'UN PROCESSUS FILS ......................................................................98
SIGNALER UNE ERREUR ..............................................................................................109
CONCLUSION..............................................................................................................117
6....................................................................................................................................119
GESTION CLASSIQUE DES SIGNAUX................................................................119
GÉNÉRALITÉS.............................................................................................................119
LISTE DES SIGNAUX SOUS LINUX................................................................................121
Signaux SIGABRT et SIGIOT.................................................................................121
Signaux SIGALRM, SIGVTALRM et SlGPROF.....................................................122
Signaux SIGBUS et SIGSEGV................................................................................122
Signaux SIGCHLD et SIGCLD..............................................................................123
Signaux SIGFPE et SIGSTKFLT............................................................................123
Signal SIGHUP......................................................................................................123
Signal SIGILL.........................................................................................................124
Signal SIGINT........................................................................................................125
Signaux SIGIO et SIGPOLL...................................................................................125
Signal SIGKILL......................................................................................................125
Signal SIGPIPE......................................................................................................126
Signal SIGQUIT.....................................................................................................126

V
Signaux SIGSTOP, SIGCONT, et SIGTSTP...........................................................126
Signal SIGTERM ....................................................................................................127
Signal SIGTRAP.....................................................................................................127
Signaux SIGTTIN et SIGTTGU ..............................................................................127
Signal SIGURG.......................................................................................................128
Signaux SIGUSR1 et SIGUSR2 ..............................................................................128
Signal SIGWINCH..................................................................................................128
Signaux SIGXCPU et SIGXFSZ..............................................................................129
Signaux temps-réel .................................................................................................129
ÉMISSION D'UN SIGNAL SOUS LINUX...........................................................................132
DÉLIVRANCE DES SIGNAUX — APPELS-SYSTÈME LENTS ............................................134
RÉCEPTION DES SIGNAUX AVEC L'APPEL-SYSTÈME SIGNAL( ).....................................136
CONCLUSIONS ............................................................................................................145
GESTION DES SIGNAUX POSIX.1........................................................................147
EXEMPLES D'UTILISATION DE SIGACTION( ) ................................................................152
ATTENTE D'UN SIGNAL ...............................................................................................161
ÉCRITURE CORRECTE D'UN GESTIONNAIRE DE SIGNAUX .............................................163
UTILISATION D'UN SAUT NON LOCAL ..........................................................................165
UN SIGNAL PARTICULIER : L'ALARME .........................................................................168
CONCLUSION ..............................................................................................................170
8 ....................................................................................................................................171
SIGNAUX TEMPS-RÉEL POSIX. LB.....................................................................171
CARACTÉRISTIQUES DES SIGNAUX TEMPS-RÉEL .........................................................172
Nombre de signaux temps-réel ...............................................................................172
Empilement des signaux bloqués............................................................................173
Délivrance prioritaire des signaux.........................................................................173
Informations supplémentaires fournies au gestionnaire.........................................174
ÉMISSION D'UN SIGNAL TEMPS-RÉEL...........................................................................175
TRAITEMENT RAPIDE DES SIGNAUX TEMPS-RÉEL ........................................................182
CONCLUSION ..............................................................................................................186
9 ....................................................................................................................................187
SOMMEIL DES PROCESSUS..................................................................................187
ET CONTRÔLE DES RESSOURCES.....................................................................187
ENDORMIR UN PROCESSUS..........................................................................................187
SOMMEIL UTILISANT LES TEMPORISATIONS DE PRÉCISION..........................................193
SUIVRE L'EXÉCUTION D'UN PROCESSUS.......................................................................201
OBTENIR DES STATISTIQUES SUR UN PROCESSUS ........................................................205
LIMITER LES RESSOURCES CONSOMMÉES PAR UN PROCESSUS.....................................207
CONCLUSION ..............................................................................................................214
VI
10..................................................................................................................................215
ENTRÉES-SORTIE SIMPLIFIÉES.........................................................................215
FLUX STANDARD D'UN PROCESSUS.............................................................................215
ECRITURE FORMATÉE DANS FLUX ..............................................................................218
AUTRES FONCTIONS D'ÉCRITURE FORMATÉE ..............................................................225
ÉCRITURES SIMPLES CARACTÈRES OU DE CHAÎNES.....................................................229
SAISIE DE CARACTÈRES ..............................................................................................231
RÉINJECTION DE CARACTÈRE .....................................................................................235
SAISIE CHAÎNES DE CARACTÈRES ...............................................................................237
LECTURES FORMATÉES DEPUIS UN FLUX ....................................................................242
CONCLUSION..............................................................................................................251
11..................................................................................................................................253
ORDONNANCEMENT DES PROCESSUS............................................................253
ÉTATS D'UN PROCESSUS .............................................................................................253
FONCTIONNEMENT MULTITÂCHE, PRIORITÉS..............................................................257
MODIFICATION LA PRIORITÉ D'UN AUTRE PROCESSUS ................................................261
LES MÉCANISMES D'ORDONNANCEMENT SOUS LINUX................................................263
Ordonnancement sous algorithme FIFO................................................................263
Ordonnancement sous algorithme RR....................................................................264
Ordonnancement sous algorithme OTHER............................................................265
Récapitulation........................................................................................................265
Temps-réel ?...........................................................................................................265
MODIFICATION DE LA POLITIQUE D'ORDONNANCEMENT ............................................266
CONCLUSION..............................................................................................................275
12..................................................................................................................................277
THREADS POSIX.1C................................................................................................277
PRÉSENTATION...........................................................................................................277
IMPLÉMENTATION ......................................................................................................278
CRÉATION DE THREADS..............................................................................................279
ATTRIBUTS DES THREADS...........................................................................................285
DÉROUIEMENT ET ANNULATION D'UN THREAD ..........................................................289
ZONES D'EXCLUSIONS MUTUELLES.............................................................................296
ATTENTE DE CONDITIONS...........................................................................................301
SÉMAPHORES POSIX,1B..............................................................................................306
DONNÉES PRIVÉES D'UN THREAD................................................................................309
LES THREADS ET LES SIGNAUX...................................................................................310
CONCLUSION..............................................................................................................313
13..................................................................................................................................315

VII
GESTION DE LA MÉMOIRE..................................................................................315
DU PROCESSUS........................................................................................................315
ROUTINES CLASSIQUES D'ALLOCATION ET DE LIBÉRATION DE MÉMOIRE ....................315
Utilisation de malloc( )...........................................................................................316
Utilisation de calloc( )............................................................................................321
Utilisation de realloc( ) ..........................................................................................324
Utilisation de free( ) ...............................................................................................325
Règles de bonne conduite pour l'allocation et la libération de mémoire................326
Désallocation automatique avec alloca( )..............................................................328
DÉBOGAGE DES ALLOCATIONS MÉMOIRE....................................................................331
Configuration de l'algorithme utilisé par malloc( ) .......................................334
Suivi intégré des allocations et des libérations.......................................................335
Surveillance automatique des zones allouées.........................................................338
Fonctions d'encadrement personnalisées...............................................................342
CONCLUSION ..............................................................................................................350
14 ..................................................................................................................................351
GESTION AVANCÉE DE LA MÉMOIRE .............................................................351
VERROUILLAGE DE PAGES EN MÉMOIRE .....................................................................351
PROJECTION D'UN FICHIER SUR UNE ZONE MÉMOIRE...................................................355
PROTECTION DE L'ACCÈS Â LA MÉMOIRE ....................................................................366
CONCLUSION ..............................................................................................................371
15 ..................................................................................................................................373
UTILISATION DES BLOCS MÉMOIRE ...............................................................373
ET DES CHAÎNES.....................................................................................................373
MANIPULATION DE BLOCS DE MÉMOIRE .....................................................................373
MESURES, COPIES ET COMPARAISONS DE CHAÎNES .....................................................378
RECHERCHES DANS UNE ZONE DE MÉMOIRE OU DANS UNE CHAÎNE ............................392
Recherche dans un bloc de mémoire ......................................................................393
Recherche de caractères dans une chaîne..............................................................394
Recherche de sous-chaînes.....................................................................................395
Analyse lexicale......................................................................................................398
CONCLUSION ..............................................................................................................401
16 ..................................................................................................................................403
ROUTINES AVANCÉES DE TRAITEMENT DES BLOCS MÉMOIRE............403
UTILISATION DES EXPRESSIONS RÉGULIÈRES..............................................................403
CRYPTAGE DE DONNÉES .............................................................................................410
Cryptage élémentaire .............................................................................................410
VIII
Cryptage simple et mots de passe...........................................................................411
Cryptage de blocs de mémoire avec DES...............................................................414
CONCLUSION..............................................................................................................419
17..................................................................................................................................421
TRIS, RECHERCHES...............................................................................................421
ET STRUCTURATION DES DONNÉES................................................................421
FONCTIONS DE COMPARAISON....................................................................................421
RECHERCHE LINÉAIRE, DONNÉES NON TRIÉES ............................................................424
RECHERCHES DICHOTOMIQUES DANS UNE TABLE ORDONNÉE ....................................428
MANIPULATION, EXPLORATION ET PARCOURS D'UN ARBRE BINAIRE..........................434
GESTION D'UNE TABLE DE HACHAGE..........................................................................440
RÉCAPITULATIF SUR LES MÉTHODES D'ACCÈS AUX DONNÉES.....................................446
CONCLUSION..............................................................................................................447
18..................................................................................................................................449
FLUX DE DONNÉES ................................................................................................449
DIFFÉRENCES ENTRE FLUX ET DESCRIPTEURS.............................................................449
OUVERTURE ET FERMETURE D'UN FLUX .....................................................................451
Ouverture normale d'un flux ..................................................................................451
Fermeture d'un flux................................................................................................453
Présentation des buffers associés aux flux.............................................................453
Ouvertures particulières de flux.............................................................................455
LECTURES ET ÉCRITURES DANS UN FLUX....................................................................457
POSITIONNEMENT DANS UN FLUX...............................................................................461
Positionnement classique.......................................................................................462
Positionnement compatible Unix 98.......................................................................463
Fichiers â trous ......................................................................................................466
Problèmes de portabilité........................................................................................468
PARAMÉTRAGE DES BUFFERS ASSOCIÉS À UN FLUX....................................................468
Type de buffers.......................................................................................................469
Modification du type et de la taille du buffer.........................................................470
ÉTAT D'UN FLUX.........................................................................................................473
CONCLUSION..............................................................................................................475
9....................................................................................................................................477
DESCRIPTEURS DE FICHIERS.............................................................................477
OUVERTURE ET FERMETURE D'UN DESCRIPTEUR DE FICHIER......................................477
LECTURE OU ÉCRITURE SUR UN DESCRIPTEUR FICHIER...............................................485
Primitives de lecture...............................................................................................485
Primitives d'écriture...............................................................................................488