Ubuntu Manpage: select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO

nombre
sinopsis
descripción
valor devuelto
errores
ejemplo
conforme a
observaciones
véase también

NOMBRE

       select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - multiplexación de E/S síncrona

SINOPSIS

       /* Según POSIX 1003.1-2001 */
       #include <sys/select.h>

       /* Según estándares anteriores */
       #include <sys/time.h>
       #include <sys/types.h>
       #include <unistd.h>

       int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

       int  pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout,
       const sigset_t *sigmask);

       FD_CLR(int fd, fd_set *set);
       FD_ISSET(int fd, fd_set *set);
       FD_SET(int fd, fd_set *set);
       FD_ZERO(fd_set *set);

DESCRIPCIÓN

Las funciones select y pselect esperan a que un número de descriptores de fichero cambien de estado.

Su función es idéntica, con tres diferencias:

(i) La función select usa un plazo de espera (timeout) que es de tipo struct timeval (con segundos y
microsegundos), mientras pselect usa el tipo struct timespec (con segundos y nanosegundos).

(ii) La función select puede actualizar el parámetro timeout para indicar el tiempo sobrante. La
función pselect no modifica este parámetro.

(iii) La función select no tiene parámetro sigmask , y se comporta como pselect llamada con el argumento
sigmask a NULL.

Se miran tres conjuntos independientes de descriptores. Aquéllos listados en readfds serán observados
para ver si hay caracteres que llegan a estar disponibles para lectura (más concretamente, para ver si
una operación de lectura no se bloqueará - en particular, un descriptor de fichero está también preparado
en fin-de-fichero), aquéllos en writefds serán observados para ver si una operación de escritura no se
bloqueará, y aquéllos en exceptfds serán observados para ver si ocurren excepciones. En caso de éxito,
los conjuntos se modifican en marcha para indicar qué descriptores cambiaron realmente su estado.

Se proporcionan cuatro macros para manipular los conjuntos. FD_ZERO limpiará un conjunto. FD_SET y
FD_CLR añaden o borran un descriptor dado a o de un conjunto. FD_ISSET mira a ver si un descriptor es
parte del conjunto; esto es útil después de que select regrese.

n es el descriptor con el número más alto en cualquiera de los tres conjuntos, más 1.

timeout es un límite superior de la cantidad de tiempo transcurrida antes de que select regrese. Puede
ser cero, causando que select regrese inmediatamente. Si timeout es NULL (no hay tiempo de espera),
select puede bloquear indefinidamente.

sigmask es un puntero a una máscara de señales (vea sigprocmask(2)); si es distinto de NULL, pselect
reemplaza en primer lugar la máscara de señales actual por aquella a la que apunta sigmask, luego hace la
funcion `select', y por último restablece la máscara de señales original de nuevo.

La idea de pselect es que si alguien quiere esperar un evento, bien una señal o cualquier otra cosa sobre
un descriptor de fichero, se necesita una comprobación atómica para evitar condiciones de carrera.
(Suponga que el manejador de señales fija una opción global y regresa. Después una comprobación de esta
opción seguida de una llamada a select() podría colgarse indefinidamente si la señal llegó justo después
de la comprobación pero justo antes de la llamada. Por otra parte, pselect le permite bloquear señales en
primer lugar, manejar las señales que hayan llegado, y después llamar a pselect() con la máscara sigmask
deseada, evitando la condición de carrera.) Puesto que en la actualidad Linux no cuenta con una llamada
al sistema pselect() , la rutina actual de glibc2 todavía tiene este defecto.

El plazo de espera o timeout
Las estructuras de tiempo involucradas están definidas en <sys/time.h> y tienen el siguiente aspecto

struct timeval {
long tv_sec; /* segundos */
long tv_usec; /* microsegundos */
};

and

struct timespec {
long tv_sec; /* segundo */
long tv_nsec; /* nanosegundos */
};

(Sin embargo, lea más abajo sobre las versiones de POSIX 1003.1-2001.)

Hay algún código por ahí que llama a select con los tres conjuntos vacíos, n cero, y un timeout distinto
de cero como una forma transportable y curiosa de dormir con una precisión por debajo del segundo.

En Linux, timeout se modifica para reflejar la cantidad de tiempo no dormido; la mayoría de otras
implementaciones no hacen esto. Esto produce problemas cuando el código de Linux que lee timeout se
transporta a otros sistemas operativos, y cuando se transporta a Linux código que reutiliza una struct
timeval para varias selects en un bucle sin reinicializarla. Considere que timeout está indefinido
después de que select regrese.

VALOR DEVUELTO

       En caso de éxito, select y pselect devuelven el número de descriptores contenidos  en  los  conjuntos  de
       descriptores,  que puede ser cero si el tiempo de espera expira antes de que ocurra algo interesante.  En
       caso de error, se devuelve -1, y se pone un valor apropiado en errno; los  conjuntos  y  timeout  estarán
       indefinidos, así que no confíe en sus contenidos tras un error.

ERRORES

       EBADF  Se ha dado un descriptor de fichero inválido en uno de los conjuntos.

       EINTR  Se ha capturado una señal no bloqueante.

       EINVAL n es negativo o el valor contenido en timeout no es válido.

       ENOMEM select no ha sido capaz de reservar memoria para las tablas internas.

EJEMPLO

       #include <stdio.h>
       #include <sys/time.h>
       #include <sys/types.h>
       #include <unistd.h>

       int
       main(void) {
           fd_set rfds;
           struct timeval tv;
           int valret;

           /* Mirar stdin (df 0) para ver si tiene entrada */
           FD_ZERO(&rfds);
           FD_SET(0, &rfds);
           /* Esperar hasta 5 s */
           tv.tv_sec = 5;
           tv.tv_usec = 0;

           valret = select(1, &rfds, NULL, NULL, &tv);
           /* ¡No confiar ahora en el valor de tv! */

           if (valret)
               printf("Los datos ya están disponibles.\n");
               /* FD_ISSET(0, &rfds) será verdadero */
           else
               printf("Ningún dato en 5 segundos.\n");

           return 0;
       }

CONFORME A

       4.4BSD  (la  función  select apareció por primera vez en 4.2BSD). Generalmente es transportable a o desde
       sistemas no-BSD que admitan clones de la capa de zócalos de BSD  (incluyendo  variantes  System  V).  Sin
       embargo,  observe que la variante System V normalmente pone la variable de espera antes de salir, pero la
       variante BSD no.

       La función pselect está definida en IEEE Std 1003.1g-2000 (POSIX.1g), y parte de POSIX  1003.1-2001.   Se
       encuentra  en  glibc2.1  y  posteriores.   Glibc2.0 posee una función con este nombre, que sin embargo no
       acepta un parámetro sigmask.

OBSERVACIONES

       fd_set es un buffer de tamaño fijo. Ejecutar FD_CLR o FD_SET con un valor de fd que sea negativo o  igual
       o  mayor  que  FD_SETSIZE  tendrá  un  comportamiento  indefinido.   Además, POSIX requiere que fd sea un
       descriptor de fichero válido.

       En lo que se refiere a los tipos involucrados, lo habitual es  que  los  dos  campos  de  una  estructura
       timeval  sean  de  tipo  long (como se muestra abajo), y la estructura esté definida en <sys/time.h>.  La
       postura de POSIX 1003.1-2001 es

              struct timeval {
                  time_t         tv_sec;     /* segundos */
                  suseconds_t    tv_usec;    /* microsegundos */
              };

       donde la estructura está definida en <sys/select.h> y los tipos  de  datos  time_t  y  suseconds_t  están
       definidos en <sys/types.h>.

       En  lo  que  se refiere a prototipos, lo habitual es incluir el fichero de cabecera <time.h> para select.
       La postura de POSIX 1003.1-2001 es incluir el fichero <sys/select.h> para  select  y  pselect.   Libc4  y
       libc5 no poseen una cabecera <sys/select.h> ; bajo glibc 2.0 y posteriores esta cabecera sí existe.  Bajo
       glibc 2.0, proporciona incondicionalemente el prototipo incorrecto para  pselect,  bajo  glibc  2.1-2.2.1
       proporciona  pselect  cuando  _GNU_SOURCE  está  definido,  bajo  glibc 2.2.2-2.2.4 lo proporciona cuando
       _XOPEN_SOURCE está definido y tiene un valor de 600 o mayor.  Sin duda, desde POSIX 1003.1-2001,  debería
       dar el prototipo por defecto.

VÉASE TAMBIÉN

       Para un tutorial detallado con ejemplos, vea select_tut(2).

       Para una mera descripción, vea accept(2), connect(2), poll(2), read(2), recv(2), send(2), sigprocmask(2),
       write(2)