Chapitre 2 : Building and Running Modules partie 8

[Michaël]

Discussion réservée à la traduction de la partie 8 du chapitre 2 "Building and Running Modules"

Le pdf en anglais

Pour travailler, vous devez télécharger les xml en pièce jointe et joindre le xml une fois que vous avez fini. Vous ne devez en aucun cas toucher aux balises ni à l'indentation sinon ça va mettre la pagaille dans le xml final. J'ai utilisé kwrite comme éditeur de texte avec les paramètres par défaut.

[koopajah]

Bonjour,

Je prends !

[koopajah]

Doing It in User Space

Appliquons en espace utilisateur

--------------------------

A Unix programmer who?s addressing kernel issues for the first time might be nervous about writing a module. Writing a user program that reads and writes directly to the device ports may be easier.

Un programmeur Unix qui rencontre, pour la première fois, des problèmes avec le noyau peut être un peu inquiet à l'idée de développer des modules. Ecrire un programme utilisateur qui lit et écrit directement sur les ports des périphériques peut être plus simple.

-------------------------------

Indeed, there are some arguments in favor of user-space programming, and sometimes writing a so-called user-space device driver is a wise alternative to kernel hacking. In this section, we discuss some of the reasons why you might write a driver in user space. This book is about kernel-space drivers, however, so we do not go beyond this introductory discussion.

En effet, il y a plusieurs arguments en faveur de la programmation en espace utilisateur et, parfois, l'écriture d'un pilote de périphérique en espace utilisateur est une sage alternative au hack du noyau. Dans cette section, nous discutions des raisons pour lesquelles vous devriez écrire un pilote en espace utilisateur. Ce livre concerne les pilotes en espace noyau donc nous ne dépasserons pas cette discussion d'introduction.

-------------------------------

The advantages of user-space drivers are :

Les avantages des pilotes en espace utilisateurs sont :

-------------------------------

The full C library can be linked in. The driver can perform many exotic tasks without resorting to external programs (the utility programs implementing usage policies that are usually distributed along with the driver itself).

La totalité de la bibliothèque C peut être liée. Les pilots peuvent réalisée de nombreuses tâches exotiques sans recourir à des programmes externes (les programmes utilitaires implémentant les règles d'utilisation qui sont habituellement distribuées avec le pilote lui même).

-------------------------------

The programmer can run a conventional debugger on the driver code without having to go through contortions to debug a running kernel.

Le programmeur peut utiliser un debugger conventionel sur le code du pilote sans passer par des contorsions pour débugger un noyau en cours d'exécution.

--------------------------------

If a user-space driver hangs, you can simply kill it. Problems with the driver are unlikely to hang the entire system, unless the hardware being controlled is really misbehaving.

Si un pilote en espace utilisateur plante, vous pouvez simplement le tuer. Des problèmes avec un pilote ont peut de chance de faire planter le système tout entier à moins que le matériel controlé fonctionne vraiment mal.

--------------------------------

User memory is swappable, unlike kernel memory. An infrequently used device with a huge driver won?t occupy RAM that other programs could be using, except when it is actually in use.

La mémoire en espace utilisateur est permutable contrairement à celle du noyau. Un matériel très peu utilisé avec un lourd pilote n'occupera pas la RAM que les autres programmes pourraient utiliser, excepté quand il est réellement en utilisation.

---------------------------------

A well-designed driver program can still, like kernel-space drivers, allow concurrent access to a device.

Un programme de pilote bien développé peut toujours, comme les pilotes en espace noyau, autorisé les accès concurrents à un matériel.

----------------------------------

If you must write a closed-source driver, the user-space option makes it easier for you to avoid ambiguous licensing situations and problems with changing kernel interfaces.

Si vous devez écrire un pilote au code-source propriétaire, l'espace utilisateur rend cette option plus simple et éviter des situations ambigües de licence et les problèmes lors du changement des interfaces du noyau.

[koopajah]

For example, USB drivers can be written for user space; see the (still young) libusb project at <link href="http://libusb.sourceforge.net">libusb.sourceforge.net</link> and "gadgetfs" in the kernel source. Another example is the X server : it knows exactly what the hardware can do and what it can't, and it offers the graphic resources to all X clients. Note, however, that there is a slow but steady drift toward frame-buffer-based graphics environments, where the X server acts only as a server based on a real kernel-space device driver for actual graphic manipulation.

Les pilotes USB peuvent, par exemple, être écrits pour l'espace utilisateur; regardez le projet (encore jeune) libusb à <link href="http://libusb.sourceforge.net">libusb.sourceforge.net</link> et "gadgetfs" dans le code source du noyau. Le serveur X est un autre exemple : il sait exactement ce que le matériel peut et ne peut pas faire et il offre les ressources graphiques à tous les clients X. Notez, cependant, qu'il y a une dérive lente mais régulière vers les environnements graphiques basés sur des tampons d'images, où le serveur X agit seulement comme un serveur reposant sur un vrai pilote de matériel en espace noyau pour la manipulation graphique.

-----------------------------------------

Usually, the writer of a user-space driver implements a server process, taking over from the kernel the task of being the single agent in charge of hardware control. Client applications can then connect to the server to perform actual communication with the device; therefore, a smart driver process can allow concurrent access to the device. This is exactly how the X server works.

Habituellement, le développeur d'un pilote en espace utilisateur implémente un processus serveur, qui prend en charge, depuis le noyau, la tâche d'être l'agent unique en charge du contrôle du matériel. Les applications clientes peuvent alors se connecter au serveur pour réaliser une communication avec le périphérique. Ainsi, un processus pilote intelligent peut autoriser des accès concurrents à ce périphique. C'est exactement le fonctionnement du serveur X.

----------------------------------

But the user-space approach to device driving has a number of drawbacks. The most important are :

L'approche en espace utilisateur du pilotage matériel a quand même certains inconvénients. Les plus importants sont :

--------------------------------------

Interrupts are not available in user space. There are workarounds for this limitation on some platforms, such as the vm86 system call on the IA32 architecture.

Les interruptions ne sont pas dispnibles en espace utilisateur. Il existe des solutions de rechange à cette limitation sur certaines plateformes comme le système vm86 utilisé sur l'architecture IA32.

---------------------------------------

Direct access to memory is possible only by mmapping /dev/mem, and only a privileged user can do that.

Les accès directs à la mémoire ne sont possibles qu'en utilisant mmap /dev/mem et seuls les utilisateurs privilégiés peuvent faire ça.

---------------------------------------

Access to I/O ports is available only after calling ioperm or iopl. Moreover, not all platforms support these system calls, and access to /dev/port can be too slow to be effective. Both the system calls and the device file are reserved to a privileged user.

Les accès aux ports d'entrée/sortie ne sont possibles qu'après avoir appelé ioperm ou iopl. De plus, ces appels ne sont pas supportés sur toutes les plateformes et les accès a /dev/port peuvent être trop lents pour être efficaces. Les deux solution sont en plus réservées aux utilisateurs privilégiés.

-------------------------------------------

Response time is slower, because a context switch is required to transfer information or actions between the client and the hardware.

Le temps de réponse est plus long à cause du changement de contexte requis pour transférer les informations ou les actions entre le client et le matériel.

-------------------------------------------

Worse yet, if the driver has been swapped to disk, response time is unacceptably long. Using the mlock system call might help, but usually you?ll need to lock many memory pages, because a user-space program depends on a lot of library code. mlock, too, is limited to privileged users.

Pire encore, si le pilote a été permuté sur le disque, le temps de réponse devient inadmissiblement long. Utiliser l'appel système mlock pourrait aider, mais, habituellement, vous aurez besoin de verrouiller de nombreuses pages mémoire car un programme en espace utilisateur depend de nombreuses bibliothèques de code. mlock est, lui aussi, limité aux utilisateurs privilégiés.

-----------------------------------------------

The most important devices can?t be handled in user space, including, but not limited to, network interfaces and block devices.

Les matériels les plus importants peuvent être manipulés en espaces utilisateurs, y compris les interfaces réseaux et les périphériques de blocs de secteurs.

[koopajah]

As you see, user-space drivers can't do that much after all. Interesting applications nonetheless exist: for example, support for SCSI scanner devices (implemented by the SANE package)and CD writers (implemented by cdrecord and other tools). In both cases, user-level device drivers rely on the ?SCSI generic? kernel driver, which exports low-level SCSI functionality to user-space programs so they can drive their own hardware.

Comme vous pouvez le voir, les pilotes en espace utilisateur ne peuvent pas faire tant de choses que ça après tout. Des applications interessantes existent tout de même : par exemple le support de scanner SCSI (implémenté par le paquet SANE) ou de graveurs de CD (implémenté par cdrecord et d'autres outils). Dans les deux cas, les pilotes de périphériques de niveau utilisateur reposent sur le pilote SCSI générique du noyau, qui exporte les fonctionnalités SCSI bas-niveau pour que les programmes en espace utilisateur puissent piloter leur propre matériel.

-----------------------------------

One case in which working in user space might make sense is when you are beginning to deal with new and unusual hardware. This way you can learn to manage your hardware without the risk of hanging the whole system. Once you?ve done that, encapsulating the software in a kernel module should be a painless operation.

Travailler en espace utilisateur peut avoir un sens lorsque vous commencez à interagir avec un matériel inhabituel ou nouveau. De cette façon, vous pouvez apprendre à contrôler votre matériel sans risquer de planter le système tout entier. Une fois que vous avez fait ça, encapsuler le logiciel dans un module du noyau devrait être une opération sans douleur.

-------------------------------------

Quick Reference

Référence Rapide

-------------------------------------

This section summarizes the kernel functions, variables, macros, and /proc files that we?ve touched on in this chapter. It is meant to act as a reference. Each item is listed after the relevant header file, if any. A similar section appears at the end of almost every chapter from here on, summarizing the new symbols introduced in the chapter. Entries in this section generally appear in the same order in which they were introduced in the chapter :

Cette section résume les fonctions, variables, macros et fichiers /proc du noyau que nous avons touchés dans ce chapitre. Elle tient lieu de référence. Chaque élément est listé après le fichier d'entête correspondant s'il y en a un. Une section similaire apparaîtra à la fin de presque chaque chapitre à partir de maintenant, résumant les nouveaux symboles introduits dans le chapitre. Les entrées dans cette section apparaissent généralement dans l'ordre dans lequel ils ont été introduits dans le chapitre :

------------------------------------

User-space utilities that load modules into the running kernels and remove them.

Les utilitaires en espace utilisateur qui chargent les modules dans le noyau et les en retire.

-------------------------------------

Macros that designate a module's initialization and cleanup functions.

Les macros qui désignent l'initialisation d'un module et les fonctions de nettoyage.

[koopajah]

Markers for functions (_ _init and _ _exit)and data ( _ _initdata and _ _exitdata) that are only used at module initialization or cleanup time. Items marked for initialization may be discarded once initialization completes; the exit items may be discarded if module unloading has not been configured into the kernel. These markers work by causing the relevant objects to be placed in a special ELF section in the executable file.

Les marqueurs pour les fonctions (_ _init et _ _exit) et les données (_ _initdata et _ _exitdata) qui sont seulement utilisés lors de l'initialisation du module ou de son nettoyage. Les items marqués pour l'initialisation peuvent être écartés une fois l'initialisation terminée; les items de nettoyage peut être écartés sur le déchargement du module n'a pas été configuré dans le noyau. Ces marqueurs fonctionnent en plaçant les objets correspondant dans une section ELF spéciale dans le fichier exécutable.

------------------------------------

One of the most important header files. This file contains definitions of much of the kernel API used by the driver, including functions for sleeping and numerous variable declarations.

C'est l'un des fichiers d'entête les plus importants. Il contient les définitions de la majorité des API du noyau utilisées par le pilote, y compris les fonctions d'attente et de nombreuses déclarations de variables.

-----------------------------------------

The current process.

Le processus courant.

-----------------------------------------

The process ID and command name for the current process.

L'identifiant du processus et le nom de la commande pour le processus courant.

----------------------------------------

A makefile symbol used by the kernel build system to determine which modules should be built in the current directory.

Un symbole de fichier de compilation utilisé par le système de compilation du noyau pour déterminer quels modules doivent être construits dans le répertoire courant.

----------------------------------------

/sys/module is a sysfs directory hierarchy containing information on currentlyloaded modules. /proc/modules is the older, single-file version of that information. Entries contain the module name, the amount of memory each module occupies, and the usage count. Extra strings are appended to each line to specify flags that are currently active for the module.

/sys/module est un répertoire sysfs hiérarchique contenant des informations sur les modules actuellement chargés. /proc/modules est une version plus ancienne en un seul fichier de cette information. Les entrées contiennent le nom du module, la quantité de mémoire que chaque module occupe ainsi que le nombre d'utilisation. Des chaînes de caractères supplémentaires sont ajoutées à chaque ligne pour spécifier les drapeaux actuellement actifs pour le module.

------------------------------------------

An object file from the kernel source directory that describes the environment a module was built for.

Un fichier objet du répertoire des sources du noyau qui décrit l'environnement pour lequel le module a été compilé.

------------------------------------------

Required header. It must be included by a module source.

Un fichier d'entête requis. Il doit être inclus dans le code source d'un module.

-----------------------------------------

A header file containing information on the version of the kernel being built.

Un fichier d'entête contenant les informations sur la version du noyau en cours de construction.

------------------------------------------

Integer macro, useful to #ifdef version dependencies.

Une macro sur un entier, utile pour les dépendances de version de type #ifdef.

------------------------------------------

Macro used to export a symbol to the kernel. The second form exports without using versioning information, and the third limits the export to GPL-licensed modules

Macros utilisées pour exporter un symbole dans le noyau. Le deuxième exporte sans les informations de version et le troisième limite l'export aux modules sous licence GPL.

------------------------------------------

Place documentation on the module in the object file.

Place la documentation du module dans le fichier objet.

------------------------------------------

Macros that declare a module?s initialization and cleanup functions.

Les macros qui sont déclarées à l'initialisation et au nettoyage du module.

-------------------------------------------

Macro that creates a module parameter that can be adjusted by the user when the module is loaded (or at boot time for built-in code). The type can be one of bool, charp, int, invbool, long, short, ushort, uint, ulong, or intarray.

Les macros qui créent un paramètre du module qui peut être ajusté par l'utilisateur quand le module est chargé (ou au moment du démarrage du système pour le code intégré). Son type peut être bool, charp, int, invbool, long, short, ushort, uint, ulong, ou intarray.

--------------------------------------------

The analogue of printf for kernel code.

L'équivalent de printf pour le code source du noyau.

[Michaël]

il ne reste plus que la relecture orthographique