Introduction

Avant toute chose, je précise d'emblée que cet article est une initiation. Il pourra vous intéresser si, et seulement si, vous ne connaissez rien à la programmation du noyau de Linux.

Bien évidemment, nous ne partons pas au hasard, notre but est le suivant : créer un fichier spécial /dev/glop qui réagisse de la façon suivante :

	eureka:~$ cat /dev/glop
	A long time ago, in a galaxy far far away...
	eureka:~$ 

Rappel sur les fichiers spéciaux

crw--w--w-   1 esellin  users      4,   0 Aug 29 18:29 /dev/console
brw-rw----   1 root     disk       3,  65 Jun 11 22:06 /dev/hdb1
brw-rw----   1 root     disk       3,  66 Jun 11 22:06 /dev/hdb2
crw-rw----   1 root     daemon     6,   0 Apr 28  1995 /dev/lp0
crw-rw----   1 root     daemon     6,   1 Apr 28  1995 /dev/lp1
brw-rw-rw-   1 root     disk      23,   0 Jul 18  1994 /dev/mcd
crw-rw-rw-   1 root     root       4,  64 Aug 29 18:46 /dev/ttyS0
crw-rw-rw-   1 root     root       4,  65 Jul 18  1994 /dev/ttyS1

• un mode caractère ou bloc qui est signalé par un c ou un b en première position dans les droits du fichier. Lorsqu'un périphérique est utilisé en mode caractére, une demande de lecture ou d'écriture est immédiatement prise en charge et physiquement effectuée. C'est le cas par exemple pour les terminaux, les imprimantes ou les ports séries. À l'opposé, le mode bloc signifie que les accès au périphérique se font de manière différée au travers de buffers caches. Le mode bloc est utilisé pour les disques durs ou les lecteurs de CD-ROM.

• un numéro majeur : il sert à connaître le type de périphérique. Sur les exemples ci-dessus, on constate que le numéro majeur 4 est utilisé pour les terminaux, 3 pour les disques durs IDE, 6 pour les imprimantes, 23 pour le pilote de mon lecteur de CD-ROM Mitsumi et 4 pour les ports séries.

• un numéro mineur : il sert à préciser le périphérique parmi plusieurs du même type. Par exemple, pour les imprimantes (majeur 6), le mineur 0 est associé à lp0 et le mineur 1 à lp1.

Notez bien que l'attribution des numéros majeur et mineur est faite arbitrairement. Une liste exhaustive de ces attributions est donnée dans le fichier Documentation/devices.txt des sources du noyau.

Pour créer un fichier spécial, on utilise, en tant que root, la commande mknod de la façon suivante :

	mknod fichier {bc} majeur mineur

À chacun de ces drivers est associé le mode et le numéro majeur du type de périphérique qu'il prend en charge. Par exemple, lorsque le driver des disques durs IDE démarre, il informe le noyau qu'il va s'occuper de tous les fichiers spéciaux en mode bloc et de numéro majeur égal à 3, puisque 3 est le numéro majeur qu'on a attribué aux disques durs IDE. Le noyau tient à jour une table des drivers et ainsi, il sait quel driver appeler lorsqu'un appel système tel que open(), read() ou write() est lancé sur un fichier spécial.

À tout moment, la commande cat /proc/devices vous donne, pour les modes caractère et bloc, les numéros majeurs actuellement reconnus par les drivers chargés en mémoire.

Ainsi, par exemple, quand on éxécute la commande cat foobar >/dev/lp1, le noyau regarde les propriétés du fichier /dev/lp1, il constate que c'est un fichier spécial en mode caractère de numéro majeur 6 et de numéro mineur 1, et il appelle le driver correspondant qui va, de son côté, envoyer le fichier foobar vers l'imprimante lp1 par une méthode qui ne regarde que lui.

Sous Linux, les modules sont des fichiers objets (.o) qu'on peut charger en mémoire et décharger à n'importe quel moment grâce aux commandes insmod et rmmod utilisées en tant que root. La commande lsmod, quant à elle, donne la liste des modules actuellement chargés en mémoire.

Un module doit contenir deux fonctions particulières :

• int init_module(void) : Cette fonction est appelée par le noyau au démarrage du module. Son principal but est d'initialiser le périphérique et d'installer le driver. Elle renvoie 0 si tout s'est bien passé.

• void cleanup_module(void) : Cette fonction est appelée par le noyau lorsque le module est déchargé de la mémoire par la commande rmmod.

Pour compiler un module, utilisez la ligne de commande suivante :

	gcc -D__KERNEL__ -DMODULE -O2 -c glop.c

Let's go...

• les fonctions de la librairie C, décrites dans les sections 2 et 3 du manuel, ne sont pas utilisables
• il faut faire un usage modéré de la pile (et donc des variables locales)
• il faut proscrire l'attente active (par des boucles)
• les "pointeurs fous" sont interdits !

Au cas (plus qu'improbable...) où vous ne vous conformeriez pas à ces instructions, voici ce qui pourrait vous arriver :

Unable to handle kernel paging request at virtual address c8002990
current->tss.cr3 = 00fb7000, 
*pde = 00000000
Oops: 0002
CPU:    0
EIP:    0010:[<0183602f>]
EFLAGS: 00010207
eax: 00000041   ebx: 00000fff   ecx: 0099ce58   edx: 08005000
esi: 08002990   edi: 007534c4   ebp: 00f8df90   esp: 00f8df7c
ds: 0018   es: 0018   fs: 002b   gs: 002b   ss: 0018
Process cat (pid: 1576, process nr: 29, stackpage=00f8d000)
Stack: 00000001 08002990 00001000 00b55280 00001000 08002990 00122dbc 007534c4 
       00b55280 08002990 00001000 00af8018 08002990 00001000 bffffb44 0010a5e2 
       00000003 08002990 00001000 08002990 00001000 bffffb44 ffffffda 0805002b 
Call Trace: [<00122dbc>] [<0010a5e2>] 
Code: 88 06 46 ff 05 1c 61 83 01 83 3d 1c 61 83 01 2d 75 0a c7 05 

#define __KERNEL__
#define MODULE

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/mm.h>

#define GLOP_MAJOR	52
#define GLOP_ID		"glop"

static char phrase[] = 
	"A long time ago, in a galaxy far far away...\n";

static char *ptr;

static int glop_read(struct inode *inode, struct file *file, char *buf, int count)
{
	int foo;

Cette fonction sera appelée à chaque demande de lecture du fichier spécial au travers de l'appel système read(). En paramètre, on reçoit :
• Un pointeur inode sur l'i-node du fichier spécial concerné.
• Un pointeur file sur le descripteur de fichier utilisé par le processus appelant.
• Un pointeur buf sur une zone mémoire où on stockera les caractères lus.
• Le nombre count de caractères qu'on désire lire.
Vous trouverez la description complète des structures inode et file dans le fichier /usr/include/linux/fs.h.

Afin de simplifier l'écriture du driver, nous ne lirons qu'un caractère par appel de cette fonction, même si le processus appelant en demande 10 kilos. De toutes manières, un programme bien écrit doit toujours vérifier la valeur renvoyée par read() qui représente le nombre de caractères effectivement lus.

	if ( *ptr == '\0' ) {
		/* On a atteint la fin de la phrase, donc du fichier */
		return 0;
	}

On regarde si le pointeur n'est pas arrivé à la fin de notre phrase. Si c'est le cas, on retourne une valeur nulle qui marque la fin du fichier (cf. man read).

	if ( (foo=verify_area(VERIFY_WRITE,buf,1)) != 0 ) {
		/* On vérifie qu'on a le droit d'écrire à cet endroit */
		return foo;
	}

La fonction verify_area sert ici à vérifier que l'on a bien le droit d'écrire dans la zone buf passée en paramètre.

	/* Ecriture effective du caractère */
	memcpy_tofs(buf,ptr++,1);

La fonction memcpy_tofs est un équivalent de la fonction memcpy qui, rappelons-le, est indisponible dans ce contexte particulier. On écrit un caractère et on incrémente notre pointeur d'une position.

	/* Et on retourne le nombre de caractères lus = 1 */
	return 1;

Finalement, on renvoie le nombre de caractères qu'on a lus. C'est cette valeur que le processus appelant lira au retour de son appel à read().

}

static int glop_open(struct inode *inode, struct file *file)
{

Cette fonction sera appelée à chaque ouverture du fichier spécial au travers de l'appel système open().

	/* Repositionne le pointeur au début de la phrase */
	ptr = phrase;

On repositionne le pointeur au début de la phrase...

	/* Ouverture sans problème */
	return 0;

...et on annonce que tout s'est bien passé.

}

static struct file_operations glop_fops = {
	NULL,		/* seek() */
	glop_read,	/* read() */
	NULL,		/* write() */
	NULL,		/* readdir() */
	NULL,		/* select() */
	NULL,		/* ioctl */
	NULL,		/* mmap */
	glop_open,	/* open */
	NULL,		/* release */
	NULL,		/* fsync */
	NULL,		/* fasync */
	NULL,		/* check_media_change */
	NULL		/* revalidate */
};

int init_module(void)
{

	if ( register_chrdev(GLOP_MAJOR,GLOP_ID,&glop_fops) ) {
		printk("glop: unable to get major %d\n",GLOP_MAJOR);
		return -EIO;
	}

On déclare un nouveau driver en mode caractère. Pour cela, on utilise la fonction register_chrdev en passant comme paramètres :
• le numéro majeur à utiliser
• une courte chaîne de caractères (cf. /proc/devices)
• une structure qui donne la liste des fonctions à appeler lors d'un appel système open(), read(), write(), ...

	return 0;

}

void cleanup_module(void)
{
	unregister_chrdev(GLOP_MAJOR,GLOP_ID);
}

	eureka:~$ cat /dev/glop
	A long time ago, in a galaxy far far away...
	eureka:~$ 

Conclusion

Je compte sur vous pour écrire très bientôt la suite de cet article.

Bonne chance.