int signalfd(int fd, const sigset_t *mask, int flags);  

L'argument mask indique l'ensemble des signaux que l'appelant souhaite accepter via le descripteur de fichiers. Cet argument est un ensemble de signaux dont le contenu peut être initialisé en utilisant les macros décrites dans sigsetops(3). Normalement, l'ensemble de signaux devant être reçus via le descripteur de fichiers devrait être bloqué avec sigprocmask(2), pour éviter que les signaux soient gérés conformément à leurs dispositions par défaut. Il n'est pas possible de recevoir les signaux SIGKILL ou SIGSTOP via un descripteur de fichiers signalfd ; ces signaux sont silencieusement ignorés s'ils sont spécifiés dans mask.

Si l'argument fd vaut -1, l'appel crée un nouveau descripteur de fichiers et lui associe l'ensemble de signaux spécifié dans mask. Si fd ne vaut pas -1, il doit spécifier un descripteur de fichiers existant et valide, et mask est utilisé pour remplacer l'ensemble de signaux associé à ce descripteur.

L'argument flags n'est actuellement pas utilisé et doit être spécifié à zéro. Dans le futur, il pourrait être utilisé pour des fonctionnalités supplémentaires.

signalfd() renvoie un descripteur de fichiers qui accepte les opérations suivantes :

read(2)

Si un ou plusieurs des signaux spécifiés dans mask est en attente du processus, le tampon fourni à read(2) est utilisé pour renvoyer une ou plusieurs structures signalfd_siginfo (voir plus loin) qui décrivent les signaux. L'appel read(2)

returns information for as many signals as are pending and will fit in the supplied buffer. Le tampon doit avoir une taille d'au moins sizeof(struct signalfd_siginfo) octets. La valeur de retour de read(2) est le nombre total d'octets lus.

La conséquence d'un read(2) est que les signaux sont consommés, ainsi ils ne sont plus en attente pour le processus (c'est-à-dire qu'ils ne seront pas interceptés par des gestionnaires de signaux et ne peuvent pas être acceptés avec sigwaitinfo(2)).

Si aucun des signaux de mask est en attente du processus, read(2) soit bloquera jusqu'à ce qu'un des signaux de mask soit généré pour le processus, soit échouera avec l'erreur EAGAIN si le descripteur de fichiers a été rendu non bloquant (via l'utilisation de l'opération F_SETFL de fcntl(2) pour définir l'attribut O_NONBLOCK).

poll(2), select(2) (et semblables)

Le descripteur de fichiers est accessible en lecture (l'argument readfds de select(2) ; POLLIN de poll(2)) si un ou plusieurs des signaux de mask est en attente pour le processus.

Le descripteur de fichiers accepte également les autres API de multiplexage de descripteur de fichiers : pselect(2), ppoll(2) et epoll(7).

close(2)

Lorsque le descripteur de fichiers n'est plus nécessaire, il devrait être fermé. Lorsque tous les descripteurs de fichiers associés au même objet signalfd ont été fermés, les ressources pour l'objet sont libérées par le noyau.

struct signalfd_siginfo {
    uint32_t ssi_signo;   /* Signal number */
    int32_t  ssi_errno;   /* Error number (unused) */
    int32_t  ssi_code;    /* Signal code */
    uint32_t ssi_pid;     /* PID of sender */
    uint32_t ssi_uid;     /* Real UID of sender */
    int32_t  ssi_fd;      /* File descriptor (SIGIO) */
    uint32_t ssi_tid;     /* Kernel timer ID (POSIX timers)
    uint32_t ssi_band;    /* Band event (SIGIO) */
    uint32_t ssi_overrun; /* POSIX timer overrun count */
    uint32_t ssi_trapno;  /* Unused */
    int32_t  ssi_status;  /* Exit status or signal (SIGCHLD) */
    int32_t  ssi_int;     /* Integer sent by sigqueue(2) */
    uint64_t ssi_ptr      /* Pointer sent by sigqueue(2) */;
    uint64_t ssi_utime;   /* User CPU time consumed (SIGCHLD) */
    uint64_t ssi_stime;   /* System CPU time consumed (SIGCHLD) */
    uint64_t ssi_addr;    /* Address that generated signal
                             (for hardware-generated signals) */
    uint8_t  pad[X];      /* Pad size to 128 bytes (allow for
                              additional fields in the future) */
};

Sémantique de fork(2)

Sémantique de execve(2)

EBADF

Le descripteur de fichiers n'est pas un descripteur de fichiers valide.

EINVAL

fd n'est pas un descripteur de fichiers signalfd valide ; ou flags n'est pas nul.

EMFILE

La limite par processus des descripteurs de fichiers ouverts a été atteinte.

ENFILE

La limite à l'échelle du système du nombre total de fichiers ouverts a été atteinte.

ENODEV

Impossible de monter le périphérique anonyme inode (interne).

ENOMEM

Il n'y a pas suffisamment de mémoire pour créer un nouveau descripteur de fichiers signalfd.

L'argument flags est un ajout de la glibc à l'appel système sous-jacent.

Un processus peut créer plusieurs descripteurs de fichiers signalfd. Cela lui permet d'accepter différents signaux sur différents descripteurs de fichiers. (Cela peut être utile pour la surveillance des descripteurs de fichiers avec select(2), poll(2) ou epoll(7) : l'arrivée de signaux différents rendra prêts des descripteurs différents.) Si un signal apparaît dans mask pour plus d'un des descripteurs de fichiers, les occurences de ce signal peuvent être lues (une fois) à partir de n'importe lequel des descripteurs.  

$ ./signalfd_demo
^C                    # Control-C génère SIGINT
Got SIGINT
^C
Got SIGINT
^\                    # Control-\ génère SIGQUIT
Got SIGQUIT
$

#include <sys/signalfd.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)

int
main(int argc, char *argv[])
{
    sigset_t mask;
    int sfd;
    struct signalfd_siginfo fdsi;
    ssize_t s;

    sigemptyset(&mask);
    sigaddset(&mask, SIGINT);
    sigaddset(&mask, SIGQUIT);

    /* Block signals so that they aren't handled
       according to their default dispositions */

    if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
        handle_error("sigprocmask");

    sfd = signalfd(-1, &mask, 0);
    if (sfd == -1)
        handle_error("signalfd");

    for (;;) {
        s = read(sfd, &fdsi, sizeof(struct signalfd_siginfo));
        if (s != sizeof(struct signalfd_siginfo))
            handle_error("read");

        if (fdsi.ssi_signo == SIGINT) {
            printf("Got SIGINT\n");
        } else if (fdsi.ssi_signo == SIGQUIT) {
            printf("Got SIGQUIT\n");
            exit(EXIT_SUCCESS);
        } else {
            printf("Read unexpected signal\n");
        }
    }
}

Ce document est une traduction réalisée par Alain Portal <aportal AT univ-montp2 DOT fr> le 23 avril 2008 et révisée le 6 juin 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 2 signalfd ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.

NOM

SYNOPSIS

DESCRIPTION

La structure signalfd_siginfo

Sémantique de fork(2)

Sémantique de execve(2)

Sémantique des threads

VALEUR RENVOYÉE

ERREURS

VERSIONS

CONFORMITÉ

NOTES

BOGUES

EXEMPLE

VOIR AUSSI

TRADUCTION