path: root/ru_RU.KOI8-R/books/arch-handbook/driverbasics/chapter.xml

<?xml version="1.0" encoding="koi8-r" standalone="no"?>
<!--
     The FreeBSD Russian Documentation Project

     $FreeBSD$
     $FreeBSDru: frdp/doc/ru_RU.KOI8-R/books/arch-handbook/driverbasics/chapter.xml,v 1.10 2004/02/19 17:52:02 andy Exp $

     Original revision: r18565
-->

<chapter id="driverbasics">
  <title>îÁÐÉÓÁÎÉÅ ÄÒÁÊ×ÅÒÏ× ÕÓÔÒÏÊÓÔ× ÄÌÑ FreeBSD</title>

  <para>üÔÕ ÇÌÁ×Õ ÎÁÐÉÓÁÌ &.murray; ÎÁ ÏÓÎÏ×Å ÍÎÏÖÅÓÔ×Á
    ÉÓÔÏÞÎÉËÏ×, ×ËÌÀÞÁÑ ÓÐÒÁ×ÏÞÎÕÀ ÓÔÒÁÎÉÃÕ intro(4), ËÏÔÏÒÕÀ
    ÓÏÚÄÁÌ &a.joerg;.</para>

  <sect1 id="driverbasics-intro">
    <title>÷×ÅÄÅÎÉÅ</title>

    <para>üÔÁ ÇÌÁ×Á Ñ×ÌÑÅÔÓÑ ËÒÁÔËÉÍ ××ÅÄÅÎÉÅÍ × ÐÒÏÃÅÓÓ ÎÁÐÉÓÁÎÉÑ ÄÒÁÊ×ÅÒÏ×
      ÕÓÔÒÏÊÓÔ× ÄÌÑ FreeBSD.  ÷ ÜÔÏÍ ËÏÎÔÅËÓÔÅ ÔÅÒÍÉÎ ÕÓÔÒÏÊÓÔ×Ï ÉÓÐÏÌØÚÕÅÔÓÑ
      × ÏÓÎÏ×ÎÏÍ ÄÌÑ ×ÅÝÅÊ, Ó×ÑÚÁÎÎÙÈ Ó ÏÂÏÒÕÄÏ×ÁÎÉÅÍ, ÏÔÎÏÓÑÝÉÍÓÑ Ë ÓÉÓÔÅÍÅ,
      ÔÁËÉÈ, ËÁË ÄÉÓËÉ, ÐÅÞÁÔÁÀÝÉÅ ÕÓÔÒÏÊÓÔ×Á ÉÌÉ ÇÒÁÆÉÞÅÓËÉÅ ÄÉÓÐÌÅÉ Ó
      ËÌÁ×ÉÁÔÕÒÁÍÉ.  äÒÁÊ×ÅÒ ÕÓÔÒÏÊÓÔ×Á Ñ×ÌÑÅÔÓÑ ÐÒÏÇÒÁÍÍÎÏÊ ËÏÍÐÏÎÅÎÔÏÊ
      ÏÐÅÒÁÃÉÏÎÎÏÊ ÓÉÓÔÅÍÙ, ÕÐÒÁ×ÌÑÀÝÅÊ ÎÅËÏÔÏÒÙÍ ÕÓÔÒÏÊÓÔ×ÏÍ.  éÍÅÀÔÓÑ ÔÁËÖÅ
      ÔÁË ÎÁÚÙ×ÁÅÍÙÅ ÐÓÅ×ÄÏ-ÕÓÔÒÏÊÓÔ×Á, × ÓÌÕÞÁÅ ËÏÔÏÒÙÈ ÄÒÁÊ×ÅÒ ÕÓÔÒÏÊÓÔ×Á
      ÜÍÕÌÉÒÕÅÔ ÐÏ×ÅÄÅÎÉÅ ÕÓÔÒÏÊÓÔ×Á ÐÒÏÇÒÁÍÍÎÏ, ÂÅÚ ÎÁÌÉÞÉÑ ËÁËÏÊ-ÌÉÂÏ
      ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÅÊ ÁÐÐÁÒÁÔÕÒÙ.  äÒÁÊ×ÅÒÙ ÕÓÔÒÏÊÓÔ× ÍÏÇÕÔ ÂÙÔØ
      ×ËÏÍÐÉÌÉÒÏ×ÁÎÙ × ÓÉÓÔÅÍÕ ÓÔÁÔÉÞÅÓËÉ ÉÌÉ ÍÏÇÕÔ ÚÁÇÒÕÖÁÔØÓÑ ÐÏ ÔÒÅÂÏ×ÁÎÉÀ
      ÐÒÉ ÐÏÍÏÝÉ ÍÅÈÁÎÉÚÍÁ ÄÉÎÁÍÉÞÅÓËÏÇÏ ËÏÍÐÏÎÏ×ÝÉËÁ ÑÄÒÁ `kld'.</para>

    <para>âÏÌØÛÉÎÓÔ×Ï ÕÓÔÒÏÊÓÔ× × Unix-ÐÏÄÏÂÎÏÊ ÏÐÅÒÁÃÉÏÎÎÏÊ ÓÉÓÔÅÍÅ ÄÏÓÔÕÐÎÙ
      ÞÅÒÅÚ ÆÁÊÌÙ ÕÓÔÒÏÊÓÔ× (device-nodes), ÉÎÏÇÄÁ ÔÁËÖÅ ÎÁÚÙ×ÁÅÍÙÅ
      ÓÐÅÃÉÁÌØÎÙÍÉ ÆÁÊÌÁÍÉ.  ÷ ÉÅÒÁÒÈÉÉ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÙ ÜÔÉ ÆÁÊÌÙ ÏÂÙÞÎÏ
      ÎÁÈÏÄÑÔÓÑ × ËÁÔÁÌÏÇÅ <filename>/dev</filename>.  ÷ ×ÅÒÓÉÑÈ FreeBSD,
      ÂÏÌÅÅ ÓÔÁÒÙÈ, ÞÅÍ 5.0-RELEASE, × ËÏÔÏÒÙÈ ÐÏÄÄÅÒÖËÁ &man.devfs.5;
      ÎÅ ÉÎÔÅÇÒÉÒÏ×ÁÎÁ × ÓÉÓÔÅÍÕ, ËÁÖÄÙÊ ÆÁÊÌ ÕÓÔÒÏÊÓÔ×Á ÄÏÌÖÅÎ
      ÓÏÚÄÁ×ÁÔØÓÑ ÓÔÁÔÉÞÅÓËÉ É ×ÎÅ ÚÁ×ÉÓÉÍÏÓÔÉ ÏÔ ÎÁÌÉÞÉÑ ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÅÇÏ
      ÄÒÁÊ×ÅÒÁ ÕÓÔÒÏÊÓÔ×Á.  âÏÌØÛÉÎÓÔ×Ï ÆÁÊÌÏ× ÕÓÔÒÏÊÓÔ× × ÓÉÓÔÅÍÅ ÓÏÚÄÁÀÔÓÑ
      ÐÒÉ ÐÏÍÏÝÉ ËÏÍÁÎÄÙ <command>MAKEDEV</command>.</para>

    <para>äÒÁÊ×ÅÒÙ ÕÓÔÒÏÊÓÔ× ÍÏÇÕÔ ÂÙÔØ ÕÓÌÏ×ÎÏ ÒÁÚÄÅÌÅÎÙ ÎÁ Ä×Å ËÁÔÅÇÏÒÉÉ;
      ÄÒÁÊ×ÅÒÙ ÓÉÍ×ÏÌØÎÙÈ É ÓÅÔÅ×ÙÈ ÕÓÔÒÏÊÓÔ×.</para>
  </sect1>

  <sect1 id="driverbasics-kld">
    <title>íÅÈÁÎÉÚÍ ÄÉÎÁÍÉÞÅÓËÏÇÏ ËÏÍÐÏÎÏ×ÝÉËÁ ÑÄÒÁ - KLD</title>

    <para>éÎÔÅÒÆÅÊÓ kld ÐÏÚ×ÏÌÑÅÔ ÓÉÓÔÅÍÎÙÍ ÁÄÍÉÎÉÓÔÒÁÔÏÒÁÍ ÄÉÎÁÍÉÞÅÓËÉ
      ÄÏÂÁ×ÌÑÔØ É ÕÂÉÒÁÔØ ÆÕÎËÃÉÏÎÁÌØÎÏÓÔØ ÉÚ ÒÁÂÏÔÁÀÝÅÊ ÓÉÓÔÅÍÙ.  üÔÏ
      ÐÏÚ×ÏÌÑÅÔ ÒÁÚÒÁÂÏÔÞÉËÁÍ ÄÒÁÊ×ÅÒÏ× ÕÓÔÒÏÊÓÔ× ÚÁÇÒÕÖÁÔØ ÓÏÂÓÔ×ÅÎÎÙÅ
      ÉÚÍÅÎÅÎÉÑ × ÒÁÂÏÔÁÀÝÅÅ ÑÄÒÏ ÂÅÚ ÐÏÓÔÏÑÎÎÙÈ ÐÅÒÅÚÁÇÒÕÚÏË ÄÌÑ
      ÔÅÓÔÉÒÏ×ÁÎÉÑ ÉÚÍÅÎÅÎÉÊ.</para>

    <para>äÌÑ ÒÁÂÏÔÙ Ó ÉÎÔÅÒÆÅÊÓÏÍ kld ÉÓÐÏÌØÚÕÀÔÓÑ ÓÌÅÄÕÀÝÉÅ ËÏÍÁÎÄÙ
      ÐÒÉ×ÉÌÅÇÉÒÏ×ÁÎÎÏÇÏ ÒÅÖÉÍÁ:

      <itemizedlist>
        <listitem>
          <simpara>
            <command>kldload</command> - ÚÁÇÒÕÖÁÅÔ ÎÏ×ÙÊ ÍÏÄÕÌØ ÑÄÒÁ
          </simpara>
        </listitem>

        <listitem>
          <simpara>
            <command>kldunload</command> - ×ÙÇÒÕÖÁÅÔ ÍÏÄÕÌØ ÑÄÒÁ
          </simpara>
        </listitem>

        <listitem>
          <simpara>
            <command>kldstat</command> - ×Ù×ÏÄÉÔ ÓÐÉÓÏË ÚÁÇÒÕÖÅÎÎÙÈ × ÄÁÎÎÙÊ
            ÍÏÍÅÎÔ ÍÏÄÕÌÅÊ
          </simpara>
        </listitem>
      </itemizedlist>
    </para>

    <para>óËÅÌÅÔ ÍÏÄÕÌÑ ÑÄÒÁ</para>

    <programlisting>/*
 * KLD Skeleton
 * Inspired by Andrew Reiter's Daemonnews article
 */

#include &lt;sys/types.h&gt;
#include &lt;sys/module.h&gt;
#include &lt;sys/systm.h&gt;  /* uprintf */
#include &lt;sys/errno.h&gt;
#include &lt;sys/param.h&gt;  /* defines used in kernel.h */
#include &lt;sys/kernel.h&gt; /* types used in module initialization */

/*
 * Load handler that deals with the loading and unloading of a KLD.
 */

static int
skel_loader(struct module *m, int what, void *arg)
{
  int err = 0;

  switch (what) {
  case MOD_LOAD:                /* kldload */
    uprintf("Skeleton KLD loaded.\n");
    break;
  case MOD_UNLOAD:
    uprintf("Skeleton KLD unloaded.\n");
    break;
  default:
    err = EINVAL;
    break;
  }
  return(err);
}

/* Declare this module to the rest of the kernel */

static moduledata_t skel_mod = {
  "skel",
  skel_loader,
  NULL
};

DECLARE_MODULE(skeleton, skel_mod, SI_SUB_KLD, SI_ORDER_ANY);</programlisting>

    <sect2>
      <title>Makefile</title>

      <para>÷Ï FreeBSD ÉÍÅÀÔÓÑ ÚÁÇÏÔÏ×ËÉ ÄÌÑ ×ËÌÀÞÅÎÉÑ × make-ÆÁÊÌÙ, ËÏÔÏÒÙÅ
        ×Ù ÍÏÖÅÔÅ ÉÓÐÏÌØÚÏ×ÁÔØ ÄÌÑ ÂÙÓÔÒÏÊ ËÏÍÐÉÌÑÃÉÉ ÓÏÂÓÔ×ÅÎÎÙÈ ÄÏÐÏÌÎÅÎÉÊ
        Ë ÑÄÒÕ.</para>

      <programlisting>SRCS=skeleton.c
KMOD=skeleton

.include &lt;bsd.kmod.mk&gt;</programlisting>

      <para>ðÒÏÓÔÏÊ ÚÁÐÕÓË ËÏÍÁÎÄÙ <command>make</command> Ó ÜÔÉÍ make-ÆÁÊÌÏÍ
        ÐÒÉ×ÅÄÅÔ Ë ÓÏÚÄÁÎÉÀ ÆÁÊÌÁ <filename>skeleton.ko</filename>, ËÏÔÏÒÙÊ
        ÍÏÖÎÏ ÚÁÇÒÕÚÉÔØ × ×ÁÛÕ ÓÉÓÔÅÍÕ, ÎÁÂÒÁ×:

        <screen>&prompt.root; <userinput>kldload -v ./skeleton.ko</userinput></screen>
      </para>
    </sect2>
  </sect1>

  <sect1 id="driverbasics-access">
    <title>ïÂÒÁÝÅÎÉÅ Ë ÄÒÁÊ×ÅÒÕ ÕÓÔÒÏÊÓÔ×Á</title>

    <para>Unix ÄÁÅÔ ÎÅËÏÔÏÒÙÊ ÏÂÝÉÊ ÎÁÂÏÒ ÓÉÓÔÅÍÎÙÈ ×ÙÚÏ×Ï× ÄÌÑ ÉÓÐÏÌØÚÏ×ÁÎÉÑ
      × ÐÏÌØÚÏ×ÁÔÅÌØÓËÉÈ ÐÒÉÌÏÖÅÎÉÑÈ.  ëÏÇÄÁ ÐÏÌØÚÏ×ÁÔÅÌØ ÏÂÒÁÝÁÅÔÓÑ Ë
      ÆÁÊÌÕ ÕÓÔÒÏÊÓÔ×Á, ×ÙÓÏËÉÅ ÕÒÏ×ÎÉ ÑÄÒÁ ÐÅÒÅÎÁÐÒÁ×ÌÑÀÔ ÜÔÉ ÏÂÒÁÝÅÎÉÑ Ë
      ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÅÍÕ ÄÒÁÊ×ÅÒÕ ÕÓÔÒÏÊÓÔ×Á.  óËÒÉÐÔ
      <command>/dev/MAKEDEV</command> ÓÏÚÄÁÅÔ ÂÏÌØÛÉÎÓÔ×Ï ÆÁÊÌÏ× ÕÓÔÒÏÊÓÔ× ×
      ×ÁÛÅÊ ÓÉÓÔÅÍÅ, ÏÄÎÁËÏ ÅÓÌÉ ×Ù ×ÅÄÅÔÅ ÒÁÚÒÁÂÏÔËÕ Ó×ÏÅÇÏ ÓÏÂÓÔ×ÅÎÎÏÇÏ
      ÄÒÁÊ×ÅÒÁ, ÔÏ ÍÏÖÅÔ ÐÏÑ×ÉÔØÓÑ ÎÅÏÂÈÏÄÉÍÏÓÔØ × ÓÏÚÄÁÎÉÉ ÓÏÂÓÔ×ÅÎÎÙÈ
      ÆÁÊÌÏ× ÕÓÔÒÏÊÓÔ× ÐÒÉ ÐÏÍÏÝÉ ËÏÍÁÎÄÙ <command>mknod</command>.</para>

    <sect2>
      <title>óÏÚÄÁÎÉÅ ÓÔÁÔÉÞÅÓËÉÈ ÆÁÊÌÏ× ÕÓÔÒÏÊÓÔ×</title>

      <para>äÌÑ ÓÏÚÄÁÎÉÑ ÆÁÊÌÁ ÕÓÔÒÏÊÓÔ×Á ËÏÍÁÎÄÅ <command>mknod</command>
        ÔÒÅÂÕÅÔÓÑ ÕËÁÚÁÔØ ÞÅÔÙÒÅ ÁÒÇÕÍÅÎÔÁ.  ÷Ù ÄÏÌÖÎÙ ÕËÁÚÁÔØ ÉÍÑ ÆÁÊÌÁ
        ÕÓÔÒÏÊÓÔ×Á, ÔÉÐ ÕÓÔÒÏÊÓÔ×Á, ÓÔÁÒÛÅÅ ÞÉÓÌÏ ÕÓÔÒÏÊÓÔ×Á É ÍÌÁÄÛÅÅ
        ÞÉÓÌÏ ÕÓÔÒÏÊÓÔ×Á.</para>
    </sect2>

    <sect2>
      <title>äÉÎÁÍÉÞÅÓËÉÅ ÆÁÊÌÙ ÕÓÔÒÏÊÓÔ×</title>

      <para>æÁÊÌÏ×ÁÑ ÓÉÓÔÅÍÁ ÕÓÔÒÏÊÓÔ×, devfs, ÐÒÅÄÏÓÔÁ×ÌÑÅÔ ÄÏÓÔÕÐ Ë
        ÐÒÏÓÔÒÁÎÓÔ×Õ ÉÍÅÎ ÕÓÔÒÏÊÓÔ× ÑÄÒÁ ÉÚ ÇÌÏÂÁÌØÎÏÇÏ ÐÒÏÓÔÒÁÎÓÔ×Á ÉÍÅÎ
        ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÙ.  üÔÏ ÕÓÔÒÁÎÑÅÔ ÐÏÔÅÎÃÉÁÌØÎÕÀ ÐÒÏÂÌÅÍÙ ÎÁÌÉÞÉÑ
        ÄÒÁÊ×ÅÒÁ ÂÅÚ ÓÔÁÔÉÞÅÓËÏÇÏ ÆÁÊÌÁ ÕÓÔÒÏÊÓÔ×Á ÉÌÉ ÆÁÊÌÁ ÕÓÔÒÏÊÓÔ×Á ÂÅÚ
        ÕÓÔÁÎÏ×ÌÅÎÎÏÇÏ ÄÒÁÊ×ÅÒÁ ÕÓÔÒÏÊÓÔ×Á.  Devfs ×ÓÅ ÅÝÅ ÎÁÈÏÄÉÔÓÑ ×
        ÒÁÚÒÁÂÏÔËÅ, ÏÄÎÁËÏ ÏÎÁ ÕÖÅ ÄÏÓÔÁÔÏÞÎÏ ÈÏÒÏÛÏ ÒÁÂÏÔÁÅÔ.</para>
    </sect2>
  </sect1>

  <sect1 id="driverbasics-char">
    <title>óÉÍ×ÏÌØÎÙÅ ÕÓÔÒÏÊÓÔ×Á</title>

    <para>äÒÁÊ×ÅÒ ÓÉÍ×ÏÌØÎÏÇÏ ÕÓÔÒÏÊÓÔ×Á ÐÅÒÅÄÁÅÔ ÄÁÎÎÙÅ ÎÅÐÏÓÒÅÄÓÔ×ÅÎÎÏ ×
      ÉÌÉ ÉÚ ÐÒÏÃÅÓÓÁ ÐÏÌØÚÏ×ÁÔÅÌÑ.  üÔÏ ÓÁÍÙÊ ÒÁÓÐÒÏÓÔÒÁÎÅÎÎÙÊ ÔÉÐ ÄÒÁÊ×ÅÒÁ
      ÕÓÔÒÏÊÓÔ×Á É × ÄÅÒÅ×Å ÉÓÈÏÄÎÙÈ ÔÅËÓÔÏ× ÉÍÅÅÔÓÑ ÄÏÓÔÁÔÏÞÎÏ ÐÒÏÓÔÙÈ
      ÐÒÉÍÅÒÏ× ÔÁËÉÈ ÄÒÁÊ×ÅÒÏ×.</para>

    <para>÷ ÜÔÏÍ ÐÒÏÓÔÏÍ ÐÒÉÍÅÒÅ ÐÓÅ×ÄÏ-ÕÓÔÒÏÊÓÔ×Ï ÚÁÐÏÍÉÎÁÅÔ ËÁËÉÅ ÕÇÏÄÎÏ
      ÚÎÁÞÅÎÉÑ, ËÏÔÏÒÙÅ ×Ù × ÎÅÇÏ ÚÁÐÉÓÙ×ÁÅÔÅ, É ÚÁÔÅÍ ÍÏÖÅÔ ×ÙÄÁ×ÁÔØ ÉÈ
      ÎÁÚÁÄ ÐÒÉ ÞÔÅÎÉÉ ÉÚ ÜÔÏÇÏ ÕÓÔÒÏÊÓÔ×Á.  ðÒÉ×ÅÄÅÎÙ Ä×Å ×ÅÒÓÉÉ, ÏÄÎÁ
      ÄÌÑ &os;&nbsp; 4.X, Á ÄÒÕÇÁÑ ÄÌÑ &os;&nbsp; 5.X.</para>

    <example>
      <title>ðÒÉÍÅÒ ÄÒÁÊ×ÅÒÁ ÐÓÅ×ÄÏ-ÕÓÔÒÏÊÓÔ×Á Echo ÄÌÑ &os;&nbsp;4.X</title>

      <programlisting>/*
 * Simple `echo' pseudo-device KLD
 *
 * Murray Stokely
 */

#define MIN(a,b) (((a) < (b)) ? (a) : (b))

#include &lt;sys/types.h&gt;
#include &lt;sys/module.h&gt;
#include &lt;sys/systm.h&gt;  /* uprintf */
#include &lt;sys/errno.h&gt;
#include &lt;sys/param.h&gt;  /* defines used in kernel.h */
#include &lt;sys/kernel.h&gt; /* types used in module initialization */
#include &lt;sys/conf.h&gt;   /* cdevsw struct */
#include &lt;sys/uio.h&gt;    /* uio struct */
#include &lt;sys/malloc.h&gt;

#define BUFFERSIZE 256

/* Function prototypes */
d_open_t	echo_open;
d_close_t	echo_close;
d_read_t	echo_read;
d_write_t	echo_write;

/* Character device entry points */
static struct cdevsw echo_cdevsw = {
	echo_open,
	echo_close,
	echo_read,
	echo_write,
	noioctl,
	nopoll,
	nommap,
	nostrategy,
	"echo",
	33,             /* reserved for lkms - /usr/src/sys/conf/majors */
	nodump,
	nopsize,
	D_TTY,
	-1
};

struct s_echo {
	char msg[BUFFERSIZE];
	int len;
} t_echo;

/* vars */
static dev_t sdev;
static int len;
static int count;
static t_echo *echomsg;

MALLOC_DECLARE(M_ECHOBUF);
MALLOC_DEFINE(M_ECHOBUF, "echobuffer", "buffer for echo module");

/*
 * This function is called by the kld[un]load(2) system calls to
 * determine what actions to take when a module is loaded or unloaded.
 */

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,
                    0,
                    UID_ROOT,
                    GID_WHEEL,
                    0600,
                    "echo");
		/* kmalloc memory for use by this driver */
    		MALLOC(echomsg, t_echo *, sizeof(t_echo), M_ECHOBUF, M_WAITOK);
		printf("Echo device loaded.\n");
		break;
	case MOD_UNLOAD:
		destroy_dev(sdev);
		FREE(echomsg,M_ECHOBUF);
		printf("Echo device unloaded.\n");
		break;
	default:
    		err = EINVAL;
    		break;
  	}
	return(err);
}

int
echo_open(dev_t dev, int oflags, int devtype, struct proc *p)
{
	int err = 0;

	uprintf("Opened device \"echo\" successfully.\n");
	return(err);
}

int
echo_close(dev_t dev, int fflag, int devtype, struct proc *p)
{
	uprintf("Closing device \"echo.\"\n");
	return(0);
}

/*
 * The read function just takes the buf that was saved via
 * echo_write() and returns it to userland for accessing.
 * uio(9)
 */

int
echo_read(dev_t dev, struct uio *uio, int ioflag)
{
	int err = 0;
	int amt;

  /* How big is this read operation?  Either as big as the user wants,
     or as big as the remaining data */
  amt = MIN(uio->uio_resid, (echomsg->len - uio->uio_offset > 0) ? echomsg->len - uio->uio_offset : 0);
  if ((err = uiomove(echomsg->msg + uio->uio_offset,amt,uio)) != 0) {
    uprintf("uiomove failed!\n");
  }

  return err;
}

/*
 * echo_write takes in a character string and saves it
 * to buf for later accessing.
 */

int
echo_write(dev_t dev, struct uio *uio, int ioflag)
{
  int err = 0;

  /* Copy the string in from user memory to kernel memory */
  err = copyin(uio->uio_iov->iov_base, echomsg->msg, MIN(uio->uio_iov->iov_len,BUFFERSIZE));

  /* Now we need to null terminate */
  *(echomsg->msg + MIN(uio->uio_iov->iov_len,BUFFERSIZE)) = 0;
  /* Record the length */
  echomsg->len = MIN(uio->uio_iov->iov_len,BUFFERSIZE);

  if (err != 0) {
    uprintf("Write failed: bad address!\n");
  }

  count++;
  return(err);
}

DEV_MODULE(echo,echo_loader,NULL);</programlisting>

    </example>

    <example>
      <title>ðÒÉÍÅÒ ÄÒÁÊ×ÅÒÁ ÐÓÅ×ÄÏ-ÕÓÔÒÏÊÓÔ×Á Echo ÄÌÑ &os;&nbsp;5.X</title>

      <programlisting>/*
 * Simple `echo' pseudo-device KLD
 *
 * Murray Stokely
 *
 * Converted to 5.X by Sren (Xride) Straarup
 */

#include &lt;sys/types.h&gt;
#include &lt;sys/module.h&gt;
#include &lt;sys/systm.h&gt;  /* uprintf */
#include &lt;sys/errno.h&gt;
#include &lt;sys/param.h&gt;  /* defines used in kernel.h */
#include &lt;sys/kernel.h&gt; /* types used in module initialization */
#include &lt;sys/conf.h&gt;   /* cdevsw struct */
#include &lt;sys/uio.h&gt;    /* uio struct */
#include &lt;sys/malloc.h&gt;

#define BUFFERSIZE 256
#define CDEV_MAJOR      33


/* Function prototypes */
static d_open_t      echo_open;
static d_close_t     echo_close;
static d_read_t      echo_read;
static d_write_t     echo_write;

/* Character device entry points */
static struct cdevsw echo_cdevsw = {
       .d_open = echo_open,
       .d_close = echo_close,
       .d_maj = CDEV_MAJOR,
       .d_name = "echo",
       .d_read = echo_read,
       .d_write = echo_write
};

typedef struct s_echo {
       char msg[BUFFERSIZE];
       int len;
} t_echo;

/* vars */
static dev_t echo_dev;
static int count;
static t_echo *echomsg;

MALLOC_DECLARE(M_ECHOBUF);
MALLOC_DEFINE(M_ECHOBUF, "echobuffer", "buffer for echo module");

/*
 * This function is called by the kld[un]load(2) system calls to
 * determine what actions to take when a module is loaded or unloaded.
 */

static int
echo_loader(struct module *m, int what, void *arg)
{
       int err = 0;

       switch (what) {
       case MOD_LOAD:                /* kldload */
               echo_dev = make_dev(<literal>&</literal>echo_cdevsw,
                   0,
                   UID_ROOT,
                   GID_WHEEL,
                   0600,
                   "echo");
               /* kmalloc memory for use by this driver */
               MALLOC(echomsg, t_echo *, sizeof(t_echo), M_ECHOBUF, M_WAITOK);
               printf("Echo device loaded.\n");
               break;
       case MOD_UNLOAD:
               destroy_dev(echo_dev);
               FREE(echomsg,M_ECHOBUF);
               printf("Echo device unloaded.\n");
               break;
       default:
               err = EINVAL;
               break;
       }
       return(err);
}

static int
echo_open(dev_t dev, int oflags, int devtype, struct thread *p)
{
       int err = 0;

       uprintf("Opened device \"echo\" successfully.\n");
       return(err);
}

static int
echo_close(dev_t dev, int fflag, int devtype, struct thread *p)
{
       uprintf("Closing device \"echo.\"\n");
       return(0);
}

/*
 * The read function just takes the buf that was saved via
 * echo_write() and returns it to userland for accessing.
 * uio(9)
 */

static int
echo_read(dev_t dev, struct uio *uio, int ioflag)
{
	int err = 0;
	int amt;

	/*
         * How big is this read operation?  Either as big as the user wants,
         * or as big as the remaining data
         */
	amt = MIN(uio->uio_resid, (echomsg->len - uio->uio_offset > 0) ?
           echomsg->len - uio->uio_offset : 0);
        if ((err = uiomove(echomsg->msg + uio->uio_offset,amt,uio)) != 0) {
		uprintf("uiomove failed!\n");
	}
	return(err);
}

/*
 * echo_write takes in a character string and saves it
 * to buf for later accessing.
 */

static int
echo_write(dev_t dev, struct uio *uio, int ioflag)
{
       int err = 0;

       /* Copy the string in from user memory to kernel memory */
       err = copyin(uio->uio_iov->iov_base, echomsg->msg,
           MIN(uio->uio_iov->iov_len,BUFFERSIZE - 1));

       /* Now we need to null terminate, then record the length */
       *(echomsg->msg + MIN(uio->uio_iov->iov_len,BUFFERSIZE - 1)) = 0;
       echomsg->len = MIN(uio->uio_iov->iov_len,BUFFERSIZE);

       if (err != 0) {
		uprintf("Write failed: bad address!\n");
       }
       count++;
       return(err);
}

DEV_MODULE(echo,echo_loader,NULL);</programlisting>
    </example>

    <para>äÌÑ ÕÓÔÁÎÏ×ËÉ ÜÔÏÇÏ ÄÒÁÊ×ÅÒÁ ×Ï &os;&nbsp;4.X ÓÎÁÞÁÌÁ ×ÁÍ ÎÕÖÎÏ
      ÓÏÚÄÁÔØ ÆÁÊÌ ÕÓÔÒÏÊÓÔ×Á × ×ÁÛÅÊ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÅ ÐÏ ËÏÍÁÎÄÅ ÔÉÐÁ
      ÓÌÅÄÕÀÝÅÊ:</para>

    <screen>&prompt.root; <userinput>mknod /dev/echo c 33 0</userinput></screen>

    <para>ëÏÇÄÁ ÜÔÏÔ ÄÒÁÊ×ÅÒ ÚÁÇÒÕÖÅÎ, ×Ù ÍÏÖÅÔÅ ×ÙÐÏÌÎÑÔØ ÓÌÅÄÕÀÝÉÅ
      ÄÅÊÓÔ×ÉÑ:</para>

    <screen>&prompt.root; <userinput>echo -n "Test Data" > /dev/echo</userinput>
&prompt.root; <userinput>cat /dev/echo</userinput>
Test Data</screen>

    <para>õÓÔÒÏÊÓÔ×Á, ÏÂÓÌÕÖÉ×ÁÀÝÉÅ ÒÅÁÌØÎÏÅ ÏÂÏÒÕÄÏ×ÁÎÉÅ, ÏÐÉÓÙ×ÁÀÔÓÑ ×
      ÓÌÅÄÕÀÝÅÊ ÇÌÁ×Å.</para>

    <para>äÏÐÏÌÎÉÔÅÌØÎÙÅ ÉÓÔÏÞÎÉËÉ ÉÎÆÏÒÍÁÃÉÉ
      <itemizedlist>
        <listitem>
          <simpara><ulink
            url="http://www.daemonnews.org/200010/blueprints.html">õÞÅÂÎÉË
            ÐÏ ÐÒÏÇÒÁÍÍÉÒÏ×ÁÎÉÀ ÍÅÈÁÎÉÚÍÁ ÄÉÎÁÍÉÞÅÓËÏÇÏ ËÏÍÐÏÎÏ×ÝÉËÁ ÑÄÒÁ
            (KLD)</ulink> - <ulink
            url="http://www.daemonnews.org/">Daemonnews</ulink>
            ïËÔÑÂÒØ 2000
          </simpara>
        </listitem>

        <listitem>
          <simpara><ulink
            url="http://www.daemonnews.org/200007/newbus-intro.html">ëÁË
            ÐÉÓÁÔØ ÄÒÁÊ×ÅÒÙ ÑÄÒÁ × ÐÁÒÁÄÉÇÍÅ NEWBUS</ulink> - <ulink
            url="http://www.daemonnews.org/">Daemonnews</ulink> éÀÌØ 2000
          </simpara>
        </listitem>
      </itemizedlist>
    </para>
  </sect1>

  <sect1 id="driverbasics-block">
    <title>âÌÏÞÎÙÅ ÕÓÔÒÏÊÓÔ×Á (ËÏÔÏÒÙÈ ÂÏÌØÛÅ ÎÅÔ)</title>

    <para>äÒÕÇÉÅ &unix;-ÓÉÓÔÅÍÙ ÍÏÇÕÔ ÐÏÄÄÅÒÖÉ×ÁÔØ ÓÏ ×ÔÏÒÙÍ ÔÉÐÏÍ ÄÉÓËÏ×ÙÈ
      ÕÓÔÒÏÊÓÔ×, ÔÁË ÎÁÚÙ×ÁÅÍÙÈ ÕÓÔÒÏÊÓÔ× Ó ÂÌÏÞÎÏÊ ÏÒÇÁÎÉÚÁÃÉÅÊ.  âÌÏÞÎÙÅ
      ÕÓÔÒÏÊÓÔ×Á Ñ×ÌÑÀÔÓÑ ÄÉÓËÏ×ÙÍÉ ÕÓÔÒÏÊÓÔ×ÁÍÉ, ÄÌÑ ËÏÔÏÒÙÈ ÑÄÒÏ ÏÒÇÁÎÉÚÕÅÔ
      ËÜÛÉÒÏ×ÁÎÉÅ.  ôÁËÏÅ ËÜÛÉÒÏ×ÁÎÉÅ ÄÅÌÁÅÔ ÂÌÏÞÎÙÅ ÕÓÔÒÏÊÓÔ×Á ÐÒÁËÔÉÞÅÓËÉ
      ÂÅÓÐÏÌÅÚÎÙÍÉ, ÉÌÉ ÐÏ ËÒÁÊÎÅÊ ÍÅÒÅ ÎÅÎÁÄ£ÖÎÙÍÉ.  ëÜÛÉÒÏ×ÁÎÉÅ ÉÚÍÅÎÑÅÔ
      ÐÏÓÌÅÄÏ×ÁÔÅÌØÎÏÓÔØ ÏÐÅÒÁÃÉÊ ÚÁÐÉÓÉ, ÌÉÛÁÑ ÐÒÉÌÏÖÅÎÉÅ ×ÏÚÍÏÖÎÏÓÔÉ ÕÚÎÁÔØ
      ÒÅÁÌØÎÏÅ ÓÏÄÅÒÖÉÍÏÅ ÄÉÓËÁ × ÌÀÂÏÊ ÍÏÍÅÎÔ ×ÒÅÍÅÎÉ.  üÔÏ ÄÅÌÁÅÔ
      ÐÒÅÄÓËÁÚÕÅÍÏÅ É ÎÁÄÅÖÎÏÅ ×ÏÓÓÔÁÎÏ×ÌÅÎÉÅ ÄÁÎÎÙÈ ÎÁ ÄÉÓËÅ (ÆÁÊÌÏ×ÙÅ
      ÓÉÓÔÅÍÙ, ÂÁÚÙ ÄÁÎÎÙÈ É ÐÒÏÞÅÅ) ÐÏÓÌÅ ÓÂÏÑ ÎÅ×ÏÚÍÏÖÎÙÍ.  ôÁË ËÁË ÚÁÐÉÓØ
      ÍÏÖÅÔ ÂÙÔØ ÏÔÌÏÖÅÎÎÏÊ, ÔÏ ÎÅÔ ÓÐÏÓÏÂÁ ÓÏÏÂÝÉÔØ ÐÒÉÌÏÖÅÎÉÀ, ÐÒÉ
      ×ÙÐÏÌÎÅÎÉÉ ËÁËÏÊ ÉÍÅÎÎÏ ÏÐÅÒÁÃÉÉ ÚÁÐÉÓÉ ÑÄÒÏ ×ÓÔÒÅÔÉÌÏÓØ Ó ÏÛÉÂËÏÊ, ÞÔÏ
      ÔÁËÉÍ ÏÂÒÁÚÏÍ ÏÓÌÏÖÎÑÅÔ ÐÒÏÂÌÅÍÕ ÃÅÌÏÓÔÎÏÓÔÉ ÄÁÎÎÙÈ.  ðÏ ÜÔÏÊ ÐÒÉÞÉÎÅ
      ÓÅÒØ£ÚÎÙÅ ÐÒÉÌÏÖÅÎÉÑ ÎÅ ÐÏÌÁÇÁÀÔÓÑ ÎÁ ÂÌÏÞÎÙÅ ÕÓÔÒÏÊÓÔ×Á, É, ÎÁ ÓÁÍÏÍ
      ÄÅÌÅ ÐÒÁËÔÉÞÅÓËÉ ×Ï ×ÓÅÈ ÐÒÉÌÏÖÅÎÉÑÈ, ËÏÔÏÒÙÅ ÒÁÂÏÔÁÀÔ Ó ÄÉÓËÏÍ
      ÎÁÐÒÑÍÕÀ, ÉÍÅÅÔÓÑ ÂÏÌØÛÁÑ ÐÒÏÂÌÅÍÁ ×ÙÂÏÒÁ ÕÓÔÒÏÊÓÔ× Ó ÐÏÓÌÅÄÏ×ÁÔÅÌØÎÙÍ
      ÄÏÓÔÕÐÏÍ (ÉÌÉ <quote>raw</quote>), ËÏÔÏÒÙÅ ÄÏÌÖÎÙ ÉÓÐÏÌØÚÏ×ÁÔØÓÑ.
      éÚ-ÚÁ ÒÅÁÌÉÚÁÃÉÉ ÏÔÏÂÒÁÖÅÎÉÑ ËÁÖÄÏÇÏ ÄÉÓËÁ (ÒÁÚÄÅÌÁ) × Ä×Á ÕÓÔÒÏÊÓÔ×Á
      Ó ÒÁÚÎÙÍÉ ÓÍÙÓÌÁÍÉ, ËÏÔÏÒÁÑ ÕÓÌÏÖÎÑÅÔ ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÉÊ ËÏÄ ÑÄÒÁ, ×Ï
      &os; ÐÏÄÄÅÒÖËÁ ÄÉÓËÏ×ÙÈ ÕÓÔÒÏÊÓÔ× Ó ËÜÛÉÒÏ×ÁÎÉÅÍ ÂÙÌÁ ÏÔÂÒÏÛÅÎÁ ×
      ÐÒÏÃÅÓÓÅ ÍÏÄÅÒÎÉÚÁÃÉÉ ÉÎÆÒÁÓÔÒÕËÔÕÒÙ I/O-ÏÐÅÒÁÃÉÊ Ó ÄÉÓËÁÍÉ.</para>
  </sect1>

  <sect1 id="driverbasics-net">
    <title>óÅÔÅ×ÙÅ ÄÒÁÊ×ÅÒÙ</title>

    <para>÷ ÓÌÕÞÁÅ ÄÒÁÊ×ÅÒÏ× ÓÅÔÅ×ÙÈ ÕÓÔÒÏÊÓÔ× ÆÁÊÌÙ ÕÓÔÒÏÊÓÔ× ÄÌÑ ÄÏÓÔÕÐÁ Ë
      ÎÉÍ ÎÅ ÉÓÐÏÌØÚÕÀÔÓÑ.  éÈ ×ÙÂÏÒ ÏÓÎÏ×ÁÎ ÎÁ ÄÒÕÇÏÍ ÍÅÈÁÎÉÚÍÅ, ÒÁÂÏÔÁÀÝÅÍ
      × ÑÄÒÅ, É ÎÅ ÉÓÐÏÌØÚÕÀÝÅÍ ×ÙÚÏ× open(); Ï ÉÓÐÏÌØÚÏ×ÁÎÉÅ ÓÅÔÅ×ÙÈ
      ÕÓÔÒÏÊÓÔ× × ÏÂÝÅÍ ÓÌÕÞÁÅ ÒÁÓÓËÁÚÁÎÏ × ÏÐÉÓÁÎÉÉ ÓÉÓÔÅÍÎÏÇÏ ×ÙÚÏ×Á
      socket(2).</para>

    <para>ðÏÞÉÔÁÊÔÅ ÓÐÒÁ×ÏÞÎÕÀ ÉÎÆÏÒÍÁÃÉÀ Ï ×ÙÚÏ×Å ifnet(), ÕÓÔÒÏÊÓÔ×Å
      loopback, ÐÏÞÉÔÁÊÔÅ ÄÒÁÊ×ÅÒÙ âÉÌÌÁ ðÏÌÁ (Bill Paul), É ÔÁË
      ÄÁÌÅÅ..</para>
  </sect1>
</chapter>