path: root/ru_RU.KOI8-R/books/developers-handbook/driverbasics/chapter.sgml

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

     $FreeBSD$
     $FreeBSDru: frdp/doc/ru_RU.KOI8-R/books/developers-handbook/driverbasics/chapter.sgml,v 1.1 2001/01/10 08:45:03 andy Exp $

     Original revision: 1.3
-->

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

  <para>üÔÕ ÇÌÁ×Õ ÎÁÐÉÓÁÌ íÀÒÒÜÊ óÔÏËÅÌÉ (Murray Stokely) ÎÁ ÏÓÎÏ×Å ÍÎÏÖÅÓÔ×Á
    ÉÓÔÏÞÎÉËÏ×, ×ËÌÀÞÁÑ ÓÐÒÁ×ÏÞÎÕÀ ÓÔÒÁÎÉÃÕ intro(4), ÓÏÚÄÁÎÎÕÀ äÖÏÒÇÏÍ
    ÷ÕÎÛÅÍ (Joerg Wunsch).</para>

  <sect1>
    <title>÷×ÅÄÅÎÉÅ</title>

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

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

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

  <sect1>
    <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 */

DECLARE_MODULE(skeleton, skel_loader, 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 kldload -v ./skeleton.ko
        </screen>
      </para>
    </sect2>
  </sect1>

  <sect1>
    <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>
    <title>óÉÍ×ÏÌØÎÙÅ ÕÓÔÒÏÊÓÔ×Á</title>

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

    <para>÷ ÜÔÏÍ ÐÒÏÓÔÏÍ ÐÒÉÍÅÒÅ ÐÓÅ×ÄÏ-ÕÓÔÒÏÊÓÔ×Ï ÚÁÐÏÍÉÎÁÅÔ ËÁËÉÅ ÕÇÏÄÎÏ
      ÚÎÁÞÅÎÉÑ, ËÏÔÏÒÙÅ ×Ù × ÎÅÇÏ ÚÁÐÉÓÙ×ÁÅÔÅ, É ÚÁÔÅÍ ÍÏÖÅÔ ×ÙÄÁ×ÁÔØ ÉÈ
      ÎÁÚÁÄ ÐÒÉ ÞÔÅÎÉÉ ÉÚ ÜÔÏÇÏ ÕÓÔÒÏÊÓÔ×Á.</para>

    <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
};

typedef 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 acts 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(256,M_ECHOBUF,M_WAITOK); */
    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>

    <para>ðÅÒÅÄ ÔÅÍ, ËÁË ÕÓÔÁÎÁ×ÌÉ×ÁÔØ ÜÔÏÔ ÄÒÁÊ×ÅÒ, × ×ÁÛÅÊ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÅ
      ×ÁÍ ÎÕÖÎÏ ÓÏÚÄÁÔØ ÆÁÊÌ ÕÓÔÒÏÊÓÔ×Á ÐÒÉ ÐÏÍÏÝÉ ËÏÍÁÎÄÙ, ÐÏÄÏÂÎÏÊ
      ÓÌÅÄÕÀÝÅÊ:</para>

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

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

    <screen>
&prompt.root echo -n "Test Data" > /dev/echo
&prompt.root cat /dev/echo
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>
    <title>óÅÔÅ×ÙÅ ÄÒÁÊ×ÅÒÙ</title>

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

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