Programmation avancée sous Linux

Par convention, un système GNU/Linux inclut un répertoire /dev contenant tous les fichiers de périphériques caractère ou bloc des périphériques détectés. Les entrées de /dev ont des noms standardisés correspondants au numéros de périphérique majeur et mineur.

Par exemple, le périphérique maître connecté au contrôleur IDE primaire, qui dispose des numéros de périphérique majeur et mineur~3 et~0, a le nom standard /dev/hda. Si ce périphérique gère les partitions, la première, qui dispose du numéro de périphérique mineur~1, a le nom standard /dev/hda1. Vous pouvez le vérifier sur votre propre système:

% ls -l /dev/hda /dev/hda1
brw-rw??    1 root     disk 3, 0 May 5 1998 /dev/hda
brw-rw??    1 root     disk 3, 1 May 5 1998 /dev/hda1

De même, /dev contient une entrée pour le périphérique caractère qu'est le port parallèle que nous avons utilisé précédemment:

% ls -l /dev/lp0
crw-rw??    1 root daemon 6, 0 May 5 1998 /dev/lp0

Dans la plupart des cas, vous ne devriez pas utiliser mknod pour créer vos propres fichiers de périphérique. Utilisez plutôt les entrées de /dev. Les programmes ne disposant pas des privilèges superutilisateur n'ont pas d'autre choix que de les utiliser puisqu'ils ne peuvent pas créer leur propres entrées. Typiquement, seuls les administrateurs système et les développeurs utilisant des périphériques spécifiques ont besoin de créer leurs propres fichiers de périphérique. La plupart des distributions GNU/Linux proposent des utilitaires d'aide à la création de fichiers de périphérique standards avec les noms corrects.

Comment utiliser ces périphériques? Dans le cas de périphériques caractère, cela peut être relativement simple: ouvrez le périphérique comme s'il s'agissait d'un fichier classique et lisez ou écrivez-y. Vous pouvez même utiliser des commandes conçues pour les fichiers traditionnels, comme cat ou la syntaxe de redirection de votre shell pour envoyer ou lire des données à partir du périphérique.

Par exemple, si vous disposez d'une imprimante connectée sur le premier port parallèle de votre ordinateur, vous pouvez imprimer des fichiers en les envoyant directement sur /dev/lp0(Les utilisateurs de Windows reconnaîtront là un périphérique similaire au fichier magique LPT1 de Windows.). Pour imprimer le contenu de document.txt, invoquez la commande suivante:

% cat document.txt > /dev/lp0

Vous devez disposer des permissions en écriture sur le fichier de périphérique pour que la commande n'échoue pas; sur beaucoup de systèmes GNU/Linux, les permissions sont définies de telle façon que seul root et le démon d'impression système (lpd) puissent écrire dans ce fichier. De plus, ce qui sort de votre imprimante dépend de la façon dont elle interprète les données que vous lui envoyez. Certaines imprimantes imprimeront les fichiers texte plats que vous leur enverrez(Votre imprimante peut nécessiter l'ajout de retours chariot, code ASCII 13, à la fin de chaque ligne et l'ajout d'un caractère de saut de page, code ASCII 12, à la fin de chaque page.), d'autres non. Les imprimantes PostScript interpréteront et imprimeront les fichiers PostScript que vous leur envoyez.

Dans un programme, envoyer des données à un périphérique est aussi simple. Par exemple, cet extrait de code utilise des fonctions d'E/S standard de bas niveau pour envoyer le contenu d'un tampon vers /dev/lp0.

int fd = open ("/dev/lp0", O_WRONLY);
write (fd, buffer, buffer_length);
close (fd);

Le fichier /dev/null, le périphérique nul, est très pratique. Il a deux utilisations; vous êtes probablement familiers avec la première:

• Linux ignore toute donnée écrite vers /dev/null. Une astuce souvent utilisée est de spécifier /dev/null en tant que fichier de sortie lorsque l'on ne veut pas de sortie. Par exemple, pour lancer une commande et ignorer son affichage standard (sans l'afficher ni l'envoyer vers un fichier), redirigez la sortie standard vers /dev/null: % commande_bavarde > /dev/null
• Lire depuis /dev/null renvoie toujours une fin de fichier. Par exemple, si vous ouvrez un descripteur de fichier correspondant à /dev/null en utilisant open puis essayez d'appeler read sur ce descripteur, aucun octet ne sera lu et read renverra 0. Si vous copiez /dev/null vers un autre fichier, la destination sera un fichier de taille nulle: % cp /dev/null fichier_vide % ls -l fichier_vide -rw-rw?? 1 samuel samuel 0 Mar 8 00:27 fichier_vide

Le fichier de périphérique /dev/zero se comporte comme s'il contenait une infinité d'octets à~0. Quelle que soit la quantité de données que vous essayez de lire à partir de /dev/zero, Linux générera suffisamment d'octets nuls.

Pour illustrer cela, exécutons le programme de capture en hexadécimal présenté dans le Listing B.4, « Lecture de Données », de l'Appendice B. Ce programme affiche le contenu d'un fichier au format hexadécimal.

% ./hexdump /dev/zero
0x000000 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x000010 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x000020 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
...

Appuyez sur Ctrl+C une fois convaincu qu'il continuera indéfiniment.

Mettre /dev/zero en correspondance avec la mémoire est une technique d'allocation avancée. Reportez-vous à la Section 5.3.5, « Autres Utilisations de nmap », du Chapitre IPC, « Communication Interprocessus » pour plus d'informations, et consultez l'encadré « Obtenir de la Mémoire Alignée sur des Pages », de la Section 8.9, « mprotect : Définir des Permissions Mémoire », du Chapitre 8, « Appels Système Linux », pour un exemple.

Le fichier /dev/full se comporte comme s'il se trouvait sur un système de fichiers ne comportant plus d'espace libre. Une écriture vers /dev/full échoue et positionne errno à ENOSPC, qui indique que le lecteur de destination est plein.

Par exemple, vous pouvez tenter d'écrire sur /dev/full en utilisant la commande cp:

% cp /etc/fstab /dev/full
cp: écriture de `/dev/full': Aucun espace disponible sur le périphérique

Le fichier /dev/full est essentiellement utile pour tester la façon dont se comporte votre programme s'il tombe à court d'espace disque lors de l'écriture d'un fichier.

Les périphériques spéciaux /dev/random et /dev/urandom donnent accès au dispositif de génération de nombres aléatoires intégré au noyau Linux.

La plupart des fonctions logicielles chargées de générer des nombres aléatoires, comme la fonction rand de la bibliothèque standard du~C, génèrent en fait des nombres pseudo-aléatoires. Bien que ces nombres aient certaines propriétés des nombres aléatoires, ils sont reproductibles: si vous relancez une série avec la même valeur d'initialisation, vous obtiendrez la même séquence de nombres pseudo-aléatoires à chaque fois. Cet inconvénient est inévitable car les ordinateurs sont intrinsèquement déterministes et prévisibles. Pour certaines applications, cependant, ce comportement n'est pas souhaitable; par exemple, il peut être possible de casser un algorithme de chiffrement si l'on connaît la séquence de nombres aléatoires qu'il utilise.

L'obtention de nombres aléatoires plus stricts au sein de programmes informatiques nécessite une source externe d'événements aléatoires. Le noyau Linux utilise une source d'événements aléatoires particulièrement bonne: vous! En mesurant les écarts temporels entre vos actions, comme l'appui sur les touches et les mouvements de la souris, Linux est capable de générer un flux de nombres aléatoires de grande qualité impossible à prédire. Vous pouvez accéder à ce flux en lisant les fichiers /dev/random et /dev/urandom. Les données que vous obtenez sont issues d'un flux d'octets généré aléatoirement.

La différence entre les deux périphériques n'est visible que lorsque Linux a épuisé son stock de nombres aléatoires. Si vous essayez de lire un nombre important d'octets à partir de /dev/random mais ne générez aucune action (vous n'utilisez pas le clavier, ne bougez pas la souris ni n'effectuez aucune autre action de ce type), Linux bloque l'opération de lecture. La génération ne reprendra que lorsque vous effectuerez des actions.

Par exemple, essayez d'afficher le contenu de /dev/random en utilisant la commande od(Nous utilisons od plutôt que le programme hexdump du Listing B.4, même s'il font plus ou moins la même chose, car hexdump se termine lorsqu'il n'y a plus de données à lire, alors que od attend des données supplémentaires. L'option -t x1 indique à od d'afficher le contenu du fichier en hexadécimal.). Chaque ligne affiche~16 nombres aléatoires.

% od -t x1 /dev/random
0000000 2c 9c 7a db 2e 79 3d 65 36 c2 e3 1b 52 75 1e 1a
0000020 d3 6d 1e a7 91 05 2d 4d c3 a6 de 54 29 f4 46 04
0000040 b3 b0 8d 94 21 57 f3 90 61 dd 26 ac 94 c3 b9 3a
0000060 05 a3 02 cb 22 0a bc c9 45 dd a6 59 40 22 53 d4

Le nombre de lignes affichées varie ? il peut y en avoir très peu ? mais la sortie se mettra en pause dès que Linux épuisera son stock de nombres aléatoires. Essayez maintenant de déplacer votre souris ou de saisir quelque chose au clavier et vérifiez que de nouveaux nombres aléatoires apparaissent. Pour en obtenir encore plus, vous pouvez laisser votre chat marcher sur le clavier.

Une lecture à partir de /dev/urandom, en revanche, ne bloque jamais. Si Linux tombe à court de nombre aléatoires, il utilise un algorithme de chiffrement pour générer des octets pseudo-aléatoires à partir de la dernière séquence d'octets aléatoires. Bien que ces octets soient suffisamment aléatoires pour la plupart des utilisations, ils ne satisfont pas autant de tests que ceux obtenus à partir de /dev/random.

Par exemple, si vous invoquez la commande suivante, les octets aléatoires défileront en continu, jusqu'à ce que vous tuiez le programme avec Ctrl+C:

% od -t x1 /dev/urandom
0000000 62 71 d6 3e af dd de 62 c0 42 78 bd 29 9c 69 49
0000020 26 3b 95 bc b9 6c 15 16 38 fd 7e 34 f0 ba ce c3
0000040 95 31 e5 2c 8d 8a dd f4 c4 3b 9b 44 2f 20 d1 54
...

Utiliser des nombres aléatoires provenant de /dev/random dans un programme est une chose assez facile. Le Listing randomnumber présente une fonction qui génère un nombre aléatoire en utilisant les octets lus à partir de /dev/random. Souvenez-vous que la lecture est bloquée jusqu'à ce qu'il y ait suffisamment d'événements aléatoires pour la satisfaire; vous pouvez utiliser /dev/urandom à la place si vous accordez plus de priorité à la rapidité d'exécution et que vous pouvez vous contenter de nombres aléatoires d'une qualité moindre.

#include <assert.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>

/* Renvoie un entier aléatoire entre MIN et MAX inclus. La source utilisée
   est /dev/random. */
int random_number (int min, int max)
{
  /* Stocke un descripteur de fichier pointant vers /dev/random dans une
     variable static. De cette façon, nous n'avons pas besoin d'ouvrir le
     fichier à chaque fois que la fonction est appelée. */
  static int dev_random_fd = -1;
  char* next_random_byte;
  int bytes_to_read;
  unsigned random_value;
  /* S'assure que MAX est plus grand que MIN.  */
  assert (max > min);
  /* S'il s'agit du premier appel de la fonction, ouvre un descripteur
     de fichier pointant vers /dev/random. */
  if (dev_random_fd == -1) {
    dev_random_fd = open ("/dev/random", O_RDONLY);
    assert (dev_random_fd != -1);
  }
  /* Lit suffisamment d'octets aléatoires pour remplir un entier. */
  next_random_byte = (char*) &amp;random_value;
  bytes_to_read = sizeof (random_value);
  /* Boucle jusqu'à ce que l'on ait assez d'octets. Comme /dev/random
     est généré à partir d'actions de l'utilisateur, la lecture peut bloquer
     et ne renvoyer qu'un seul octet à la fois. */
  do {
    int bytes_read;
    bytes_read = read (dev_random_fd, next_random_byte, bytes_to_read);
    bytes_to_read -= bytes_read;
    next_random_byte += bytes_read;
  } while (bytes_to_read > 0);
  /* Calcule un nombre aléatoire dans l'intervalle demandé.  */
  return min + (random_value % (max - min + 1));
}

Un périphérique loopback vous permet de simuler un périphérique bloc en utilisant un fichier disque ordinaire. Imaginez un lecteur de disque pour lequel les données sont écrites et lues à partir d'un fichier appelé image-disque plutôt que depuis les pistes et secteurs d'un disque physique réel ou d'une des partition d'un disque (bien sûr, le fichier image-disque doit se situer sur un disque physique, qui doit être plus grand que le disque simulé). Un périphérique loopback vous permet d'utiliser un fichier de cette façon.

Les périphériques loopback s'appellent /dev/loop0, /dev/loop1, etc. Chacun peut être utilisé pour simuler un périphérique bloc distinct. Notez que seul le superutilisateur peut paramétrer un périphérique loopback.

Un tel périphérique peut être utilisé de la même façon que n'importe quel autre périphérique bloc. En particulier, vous pouvez placer un système de fichiers sur le périphérique puis monter ce système de fichiers comme s'il résidait sur un disque ou une partition classique. Un tel système de fichiers, qui réside entièrement au sein d'un fichier sur disque ordinaire, est appelé système de fichiers virtuel.

Pour construire un système de fichiers et le monter à partir d'un périphérique loopback, suivez ces étapes:

- Créez un fichier vide qui contiendra le système de fichiers virtuel. La taille du fichier sera la taille du périphérique loopback une fois monté. Une façon pratique de construire un fichier d'une taille prédéterminée est d'utiliser la commande dd. Elle copie des blocs (de 512~octets chacun, par défaut) d'un fichier vers un autre. Le fichier /dev/zero convient parfaitement pour être utilisé comme source d'octets nuls. Pour construire un fichier de 10Mo appelé image-disque, utilisez la commande suivante: % dd if=/dev/zero of=/tmp/image-disque count=20480 20480+0 enregistrements lus. 20480+0 enregistrements écrits. % ls -l /tmp/image-disque -rw-rw?? 1 root root 10485760 Mar 8 01:56 /tmp/image-disque

- Le fichier que vous venez de créer est rempli avec des octets à 0. Avant de le monter, vous devez y placer un système de fichiers. Cette opération initialise diverses structures de contrôle nécessaires à l'organisation et au stockage de fichiers et crée le répertoire racine. Vous pouvez placer n'importe quel type de système de fichiers sur votre image disque. Pour créer un système de fichiers ext3 (le type le plus courant pour les disques Linux), utilisez la commande mke2fs. Comme elle est habituellement exécutée sur des périphériques bloc, et non pas des fichiers ordinaires, elle demande une confirmation: /sbin/mke2fs -q -j /tmp/image-disque /tmp/image-disque n'est pas un périphérique spécial à bloc. Procéder malgré tout? (y pour oui, n pour non) y L'option -q supprime les informations récapitulatives sur le système de fichiers nouvellement créé. Supprimez-la si vous êtes curieux. Désormais image-disque contient un nouveau système de fichiers comme s'il s'agissait d'un disque de 10 Mo tout neuf.

- Montez le système de fichiers en utilisant un périphérique loopback. Pour cela, utilisez la commande mount en spécifiant le fichier de l'image disque comme périphérique à monter. Passez également l'option de montage loop=périphérique-loopback, en utilisant l'option -o pour indiquer à mount quel périphérique loopback utiliser. Par exemple, pour monter notre système de fichiers image-disque, utilisez ces commandes. Souvenez-vous, seul le superutilisateur peut utiliser un périphérique loopback. La première commande crée un répertoire, /tmp/virtual-fs, que nous allons utiliser comme point de montage pour le système de fichiers virtuel. % mkdir /tmp/virtual-fs % mount -o loop=/dev/loop0 /tmp/image-disque /tmp/virtual-fs Désormais, l'image disque est montée comme s'il s'agissait d'un disque de 10Mo ordinaire. % df -h /tmp/virtual-fs Sys. De fich. Tail. Occ. Disp. %Occ. Monté sur /tmp/image-disque 9.7M 13k 9.2M 0% /tmp/virtual-fs Vous pouvez l'utiliser comme n'importe quel autre disque: % cd /tmp/virtual-fs % echo "Coucou !" > test.txt % ls -l total 13 drwxr-xr-x 2 root root 12288 Mar 8 02:00 lost+found -rw-rw?? 1 root root 14 Mar 8 02:12 test.txt % cat test.txt Coucou ! Notez que lost+found est un répertoire automatiquement créé par mke2fs(Si le système de fichiers subit des dommage et que des données sont récupérées sans être associées à un fichier, elles sont placées dans lost+found.). Lorsque vous en avez fini, démontez le système de fichiers virtuel. % cd /tmp % umount /tmp/virtual-fs Vous pouvez supprimer image-disque si vous le désirez ou vous pouvez le monter plus tard pour accéder aux fichiers du système de fichiers virtuel. Vous pouvez également le copier sur un autre ordinateur où vous pourrez le monter ? le système de fichiers que vous avez créé sera entièrement intact.

Au lieu de créer un système de fichiers à partir de rien, vous pouvez en copier un à partir d'un périphérique existant. Par exemple, vous pouvez créer l'image du contenu d'un CD-ROM simplement en le copiant à partir d'un lecteur de CD-ROM.

Si vous disposez d'un lecteur de CD-ROM IDE, utilisez le nom de périphérique correspondant, par exemple /dev/hda, décrit précédemment. Si vous disposez d'un lecteur CD-ROM SCSI, le nom de périphérique sera du type /dev/scd0. Le lien symbolique /dev/cdrom peut également exister sur votre système, il pointe alors vers le périphérique approprié. Consultez le fichier /etc/fstab pour déterminer quel périphérique correspond au lecteur de CD-ROM de votre ordinateur.

Copiez simplement le périphérique vers un fichier. Le résultat sera une image disque complète du système de fichiers du CD-ROM situé dans le lecteur ? par exemple:

% cp /dev/cdrom /tmp/cdrom-image

Cette opération peut prendre plusieurs minutes selon le CD-ROM que vous copiez et la vitesse de votre lecteur. Le fichier image résultant sera relativement gros ? il fera la même taille que le contenu du CD-ROM.

Vous pouvez maintenant monter cette image sans disposer du disque original. Par exemple, pour le monter sur /mnt/cdrom, utilisez cette commande:

% mount -o loop=/dev/loop0 /tmp/cdrom-image /mnt/cdrom

Comme l'image est située sur le disque dur, les temps d'accès seront bien inférieurs à ceux du disque CD-ROM original. Notez que la plupart des CD-ROM utilisent le système de fichiers ISO-9660.

Par exemple, vous pouvez déterminer le PTY associé à une fenêtre de terminal donnée en invoquant cette commande au sein de la fenêtre:

% ps -o pid,tty,cmd
  PID TT       CMD
28832 pts/4    bash
29287 pts/4    ps -o pid,tty,cmd

La fenêtre où est lancée la commande s'exécute au sein du PTY~4.

Le PTY a un fichier correspondant dans /dev/pts:

% ls -l /dev/pts/4
crw?w??    1 samuel tty 136, 4 Mar 8 02:56 /dev/pts/4

Notez qu'il s'agit d'un périphérique caractère et son propriétaire est celui du processus pour lequel il a été créé.

Vous pouvez lire ou écrire sur un périphérique PTY. Si vous lisez à partir de celui-ci, vous intercepterez les saisies clavier destinées au programme s'exécutant au sein du PTY. Si vous essayez d'y écrire, les données apparaîtrontdans la fenêtre correspondante.

Essayez d'ouvrir un nouveau terminal et déterminez son PTY en invoquant ps -o pid,tty,cmd. Depuis une autre fenêtre, écrivez du texte sur ce périphérique. Par exemple, si le numéro de PTY du nouveau terminal est~7, invoquez cette commande depuis une autre fenêtre:

% echo "Hello, other window!" > /dev/pts/7

La sortie apparaît dans la fenêtre de terminal. Si vous la fermez, l'entrée numéro~7 de /dev/pts disparaît.

Si vous invoquez ps pour déterminer le TTY depuis un terminal virtuel en mode texte (appuyez sur Ctrl+Alt+F1 pour basculer vers le premier terminal virtuel, par exemple), vous remarquerez qu'il s'exécute au sein d'un périphérique de terminal ordinaire et non pas un PTY:

% ps -o pid,tty,cmd
  PID TT       CMD
29325 tty1     -bash
29353 tty1     ps -o pid,tty,cmd