Various fixes, more changes soon.

This commit is contained in:
Marc Fonvieille 2003-01-12 12:16:07 +00:00
parent cbbbe65b73
commit 3009fbaa52
Notes: svn2git 2020-12-08 03:00:23 +00:00
svn path=/head/; revision=15617

View file

@ -1,34 +1,34 @@
<!--
The FreeBSD Documentation Project
The FreeBSD French Documentation Project
$Id: chapter.sgml,v 1.1 2002-02-14 14:25:02 gioria Exp $
Original revision: 1.5
$FreeBSD$
$Id: chapter.sgml,v 1.2 2003-01-12 12:16:07 blackend Exp $
Original revision: 1.5
-->
<chapter id="driverbasics">
<title>Ecrire des pilotes de p&#233;riph&#233;riques pour FreeBSD</title>
<para>Ce chap&icirc;tre a &eacute;t&eacute; &eacute;crit par &.murray avec des s&eacute;lections
depuis une vari&eacute;t&eacute; de codes source inclus dans la page de manuel d'intro(4) de Joerg
<para>Ce chap&icirc;tre a &eacute;t&eacute; &eacute;crit par &a.murray; avec des s&eacute;lections
depuis une vari&eacute;t&eacute; de codes source inclus dans la page de manuel d'&man.intro.4; de Joerg
Wunsch.</para>
<sect1>
<title>Introduction</title>
<para>Ce chap&icirc;tre fournit une br&ecirc;ve introduction sur l'&eacute;criture
de pilotes de p&eacute;riph&eacute;riques pourFreeBSD.
<para>Ce chap&icirc;tre fournit une br&ecirc;ve introduction sur l'&eacute;criture
de pilotes de p&eacute;riph&eacute;riques pour FreeBSD.
Un p&eacute;riph&eacute;rique, dans ce contexte, est un terme utilis&eacute;
le plus souvent pour tout ce qui est li&eacute; au mat&eacute;riel et qui d&eacute;pend
du syst&egrave;me, comme les disques, imprimantes, ou un &eacute;cran avec son clavier.
Un pilote de p&eacute;riph&eacute;rique est un composant logiciel du syst&egrave;me
d'exploitation qui contr&ocirc;le un p&eacute;riph&eacute;rique sp&eacute;cifique. Il y a aussi
ce que l'on apelle les pseudo-p&eacute;riph&eacute;riques ("pseudo-devices") o&ugrave; un pilote
ce que l'on apelle les pseudo-p&eacute;riph&eacute;riques (&ldquo;pseudo-devices&rdquo;) o&ugrave; un pilote
de p&eacute;riph&eacute;rique &eacute;mule le comportement d'un p&eacute;riph&eacute;rique dans un logiciel sans
mat&eacute;riel particulier sous-jacent. Les pilotes de p&eacute;riph&eacute;riques peuvent &ecirc;tre compil&eacute;s
dans le yst&egrave;me statiquement ou charg&eacute; &agrave; la demande via l'&eacute;diteur de liens dynamique du
noyau `kld'.</para>
noyau &ldquo;kld&rdquo;.</para>
<para>La plupart des p&eacute;riph&eacute;riques dans un syst&egrave;me d'exploitation de type Unix
sont accessibles au travers de fichiers sp&eacute;ciaux de p&eacute;riph&eacute;rique (device-nodes), appel&eacute;s parfois
@ -45,7 +45,7 @@
<sect1>
<title>L'&#233;diteur de liens dynamiques du noyau - KLD</title>
<!-- Traduction &agrave; v&eacute;rifier
<!-- Traduction &agrave; v&eacute;rifier
Dynamic Kernel Linker Facility - KLD</title> -->
<para>L'interface kld permet aux administrateurs syst&egrave;me d'ajouter
@ -55,7 +55,7 @@
</para>
<para>L'interface kld est utilis&eacute; au travers des commandes d'administrateur suivantes :
<itemizedlist>
<listitem><simpara><command>kldload</command> - charge un nouveau module dans le noyau</simpara></listitem>
<listitem><simpara><command>kldunload</command> - d&eacute;charge un module du noyau</simpara></listitem>
@ -66,18 +66,18 @@
<para>Structure squelettique d'un module de noyau</para>
<programlisting>/*
* Squelette KLD
* Squelette KLD
* Inspir&eacute; de l'article d'Andrew Reiter paru sur Daemonnews
*/
#include &lt;sys/types.h&gt;
#include &lt;sys/module.h&gt;
#include &lt;sys/systm.h&gt; /* uprintf */
#include &lt;sys/systm.h&gt; /* uprintf */
#include &lt;sys/errno.h&gt;
#include &lt;sys/param.h&gt; /* defines utilise dans kernel.h */
#include &lt;sys/kernel.h&gt; /* types utilise dans le module d'initialisation */
/*
/*
* charge le gestionnaire quit traite du chargement et d&eacute;chargement d'un KLD.
*/
@ -85,7 +85,7 @@ static int
skel_loader(struct module *m, int what, void *arg)
{
int err = 0;
switch (what) {
case MOD_LOAD: /* kldload */
<!-- D&eacute;sol&eacute;, les accents n'existent pas dans la console alors je ne les ai pas mis l&agrave; non plus
@ -131,7 +131,7 @@ KMOD=skeleton
<sect1>
<title>Acc&#233;der au pilote d'un p&#233;riph&#233;rique</title>
<para>Unix fournit un ensemble d'appels syt&egrave;me communs utilisable par
<para>Unix fournit un ensemble d'appels syt&egrave;me communs utilisable par
les applications de l'utilisateur. Les couches sup&eacute;rieures du noyau renvoient
ces appels au pilote de p&eacute;riph&eacute;rique correspondant quand un utilisateur
acc&egrave;de au fichier sp&eacute;cial de p&eacute;riph&eacute;rique. Le script <command>/dev/MAKEDEV</command>
@ -145,7 +145,7 @@ KMOD=skeleton
<para>La commande <command>mknod</command> n&eacute;cessite quatre
arguments pou cr&eacute;er un fichier sp&eacute;cial de p&eacute;riph&eacute;rique. Vous devez sp&eacute;cifier le nom
de ce fichier sp&eacute;cial de p&eacute;riph&eacute;rique, le type de p&eacute;riph&eacute;rique, le num&eacute;ro majeur
de ce fichier sp&eacute;cial de p&eacute;riph&eacute;rique, le type de p&eacute;riph&eacute;rique, le num&eacute;ro majeur
et le num&eacute;ro mineur du p&eacute;riph&eacute;rique.</para>
</sect2>
@ -169,7 +169,7 @@ KMOD=skeleton
l'arbre des sources.</para>
<para>Cet exemple simple de pseudo-p&eacute;riph&eacute;rique enregistre toutes les valeurs
que vous lui avez &eacute;crites et peut vous les renvoyer quand vous les lui
que vous lui avez &eacute;crites et peut vous les renvoyer quand vous les lui
demandez.</para>
<programlisting>/*
@ -182,7 +182,7 @@ KMOD=skeleton
#include &lt;sys/types.h&gt;
#include &lt;sys/module.h&gt;
#include &lt;sys/systm.h&gt; /* uprintf */
#include &lt;sys/systm.h&gt; /* uprintf */
#include &lt;sys/errno.h&gt;
#include &lt;sys/param.h&gt; /* defines utilises dans kernel.h */
#include &lt;sys/kernel.h&gt; /* types utilises dans me module d'initialisation */
@ -235,12 +235,12 @@ MALLOC_DEFINE(M_ECHOBUF, "echobuffer", "cache pour le module echo");
* determiner quelles actions doivent etre faites quand le
* module est charge ou decharge
*/
static int
echo_loader(struct module *m, int what, void *arg)
{
int err = 0;
switch (what) {
case MOD_LOAD: /* kldload */
sdev = make_dev(<literal>&</literal>echo_cdevsw,
@ -266,27 +266,27 @@ echo_loader(struct module *m, int what, void *arg)
return(err);
}
int
int
echo_open(dev_t dev, int oflags, int devtype, struct proc *p)
{
int err = 0;
uprintf("Peripherique \"echo\" ouvert avec succes.\n");
return(err);
}
int
int
echo_close(dev_t dev, int fflag, int devtype, struct proc *p)
{
uprintf("Fermeture du peripherique \"echo.\"\n");
uprintf("Fermeture du peripherique \"echo.\"\n");
return(0);
}
}
/*
/*
* La fonction read prend juste comme parametre
* le cache qui a ete sauve par l'appel &agrave; echo_write()
* et le retourne a l'utilisateur pour acces.
* uio(9)
* uio(9)
*/
int
@ -373,7 +373,7 @@ DEV_MODULE(echo,echo_loader,NULL);</programlisting>
pouvoir &ecirc;tre acessibles. Leur s&eacute;lection est bas&eacute;e sur d'autres d&eacute;cisions
faites &agrave; l'int&eacute;rieur du noyau et plut&ocirc;t que d'appeler open(), l'utilisation
d'un p&eacute;riph&eacute;rique r&eacute;seau se fait g&eacute;n&eacute;ralement en se servant de l'appel syst&egrave;me
socket(2).</para>
&man.socket.2;.</para>
<para>man ifnet(), p&eacute;riph&eacute;rique "en boucle", drivers de Bill Paul,
etc..</para>