Как работают outsb, insb, outsw, insw ... ?

[Белый пони]

Чем сабж отличается от "обычных" inb и outb и др.?
Читал скудный ман, там про это ничего нет, а поиск в гугле выдаёт ссылки на этот самый ман

OUTB(2)                                                         Linux Programmer's Manual                                                         OUTB(2)

NAME
       outb, outw, outl, outsb, outsw, outsl, inb, inw, inl, insb, insw, insl, outb_p, outw_p, outl_p, inb_p, inw_p, inl_p - port I/O

DESCRIPTION
       This  family  of functions is used to do low-level port input and output.  The out* functions do port output, the in* functions do port input; the
       b-suffix functions are byte-width and the w-suffix functions word-width; the _p-suffix functions pause until the I/O completes.

       They are primarily designed for internal kernel use, but can be used from user space.

       You compile with -O or -O2 or similar.  The functions are defined as inline macros, and will not be substituted in without  optimization  enabled,
       causing unresolved references at link time.

       You use ioperm(2) or alternatively iopl(2) to tell the kernel to allow the user space application to access the I/O ports in question.  Failure to
       do this will cause the application to receive a segmentation fault.

CONFORMING TO
       outb() and friends are hardware-specific.  The value argument is passed first and the port argument is passed second, which is the opposite  order
       from most DOS implementations.

SEE ALSO
       ioperm(2), iopl(2)

COLOPHON
       This  page  is  part  of  release 3.24 of the Linux man-pages project.  A description of the project, and information about reporting bugs, can be
       found at http://www.kernel.org/doc/man-pages/.

Linux                                                                   1995-11-29                                                                OUTB(2)

Читал io.h, но моих знаний не хватило, чтоб понять что к чему, а комментов там нет( Может знатоки ассемблера помогут?

(Нажмите, чтобы показать/скрыть)

#ifndef    _SYS_IO_H
#define    _SYS_IO_H    1

#include <features.h>

__BEGIN_DECLS

/* If TURN_ON is TRUE, request for permission to do direct i/o on the
   port numbers in the range [FROM,FROM+NUM-1].  Otherwise, turn I/O
   permission off for that range.  This call requires root privileges.

   Portability note: not all Linux platforms support this call.  Most
   platforms based on the PC I/O architecture probably will, however.
   E.g., Linux/Alpha for Alpha PCs supports this.  */
extern int ioperm (unsigned long int __from, unsigned long int __num,
                   int __turn_on) __THROW;

/* Set the I/O privilege level to LEVEL.  If LEVEL>3, permission to
   access any I/O port is granted.  This call requires root
   privileges. */
extern int iopl (int __level) __THROW;

#if defined __GNUC__ && __GNUC__ >= 2

static __inline unsigned char
inb (unsigned short int __port)
{
  unsigned char _v;

  __asm__ __volatile__ ("inb %w1,%0":"=a" (_v):"Nd" (__port));
  return _v;
}

static __inline unsigned char
inb_p (unsigned short int __port)
{
  unsigned char _v;

  __asm__ __volatile__ ("inb %w1,%0\noutb %%al,$0x80":"=a" (_v):"Nd" (__port));
  return _v;
}

static __inline unsigned short int
inw (unsigned short int __port)
{
  unsigned short _v;

  __asm__ __volatile__ ("inw %w1,%0":"=a" (_v):"Nd" (__port));
  return _v;
}

static __inline unsigned short int
inw_p (unsigned short int __port)
{
  unsigned short int _v;

  __asm__ __volatile__ ("inw %w1,%0\noutb %%al,$0x80":"=a" (_v):"Nd" (__port));
  return _v;
}

static __inline unsigned int
inl (unsigned short int __port)
{
  unsigned int _v;

  __asm__ __volatile__ ("inl %w1,%0":"=a" (_v):"Nd" (__port));
  return _v;
}

static __inline unsigned int
inl_p (unsigned short int __port)
{
  unsigned int _v;
  __asm__ __volatile__ ("inl %w1,%0\noutb %%al,$0x80":"=a" (_v):"Nd" (__port));
  return _v;
}

static __inline void
outb (unsigned char __value, unsigned short int __port)
{
  __asm__ __volatile__ ("outb %b0,%w1": :"a" (__value), "Nd" (__port));
}

static __inline void
outb_p (unsigned char __value, unsigned short int __port)
{
  __asm__ __volatile__ ("outb %b0,%w1\noutb %%al,$0x80": :"a" (__value),
            "Nd" (__port));
}

static __inline void
outw (unsigned short int __value, unsigned short int __port)
{
  __asm__ __volatile__ ("outw %w0,%w1": :"a" (__value), "Nd" (__port));

}

static __inline void
outw_p (unsigned short int __value, unsigned short int __port)
{
  __asm__ __volatile__ ("outw %w0,%w1\noutb %%al,$0x80": :"a" (__value),
            "Nd" (__port));
}

static __inline void
outl (unsigned int __value, unsigned short int __port)
{
  __asm__ __volatile__ ("outl %0,%w1": :"a" (__value), "Nd" (__port));
}

static __inline void
outl_p (unsigned int __value, unsigned short int __port)
{
  __asm__ __volatile__ ("outl %0,%w1\noutb %%al,$0x80": :"a" (__value),
            "Nd" (__port));
}

static __inline void
insb (unsigned short int __port, void *addr, unsigned long int __count)
{
  __asm__ __volatile__ ("cld ; rep ; insb":"=D" (addr), "=c" (__count)
            :"d" (__port), "0" (addr), "1" (__count));
}

static __inline void
insw (unsigned short int __port, void *addr, unsigned long int __count)
{
  __asm__ __volatile__ ("cld ; rep ; insw":"=D" (addr), "=c" (__count)
            :"d" (__port), "0" (addr), "1" (__count));
}

static __inline void
insl (unsigned short int __port, void *addr, unsigned long int __count)
{
  __asm__ __volatile__ ("cld ; rep ; insl":"=D" (addr), "=c" (__count)
            :"d" (__port), "0" (addr), "1" (__count));
}

static __inline void
outsb (unsigned short int __port, const void *addr, unsigned long int __count)
{
  __asm__ __volatile__ ("cld ; rep ; outsb":"=S" (addr), "=c" (__count)
            :"d" (__port), "0" (addr), "1" (__count));
}

static __inline void
outsw (unsigned short int __port, const void *addr, unsigned long int __count)
{
  __asm__ __volatile__ ("cld ; rep ; outsw":"=S" (addr), "=c" (__count)
              :"d" (__port), "0" (addr), "1" (__count));
}

static __inline void
outsl (unsigned short int __port, const void *addr, unsigned long int __count)
{
  __asm__ __volatile__ ("cld ; rep ; outsl":"=S" (addr), "=c" (__count)
            :"d" (__port), "0" (addr), "1" (__count));
}

#endif    /* GNU C */

__END_DECLS
#endif /* _SYS_IO_H */

Подскажите, в чём там соль? Может у кого-то есть простенький пример использования?

[Yurror]

...Может у кого-то есть простенький пример использования?

Что ты хочешь получить? Ты вообще понял зачем это надо?
Осиль, наконец, как устроен компьютер (по настоящему, а не то что ты знаешь).
Когда изучишь вопросы отпадут.

Как бы в заголовочном файле есть ответ. Сравни параметры передаваемые outb и outsb

(Нажмите, чтобы показать/скрыть)

s значит string version. работает не с одним элементом а с массивом.

[ArcFi]

http://www.google.com/search?q=outsb

http://faydoc.tripod.com/cpu/outsb.htm
http://siyobik.info/index.php?module=x86&id=223

[Белый пони]

http://faydoc.tripod.com/cpu/outsb.htm
http://siyobik.info/index.php?module=x86&id=223

Это я тоже видел, но это же для ассемблера, там на одну переменную меньше Я догадываюсь, конечно, что count - кол-во записываемых символов из строки, но не хочеться наугад тыкать, думал, может есть отдельное описание для С++. Ну да ладно. Спасибо!

[Yurror]

ТАМ В ЗАГОЛОВОЧНОМ ФАЙЛЕ АССЕМБЛЕР ГОЛИМЫЙ!!!
Ты прикидываешься или все так плохо?