sigaction

SIGACTION(2)            Linux Programmeurs Handleiding            SIGACTION(2)



NAAM
       sigaction, sigprocmask, sigpending, sigsuspend - POSIX signaal
       behandelings functies

OVERZICHT
       #include <signal.h>


       int sigaction(int signum, const struct sigaction *act, struct sigaction
       *oudeact);

       int sigprocmask(int hoe, const sigset_t *set, sigset_t *oudeset);

       int sigpending(sigset_t *set);

       int sigsuspend(const sigset_t *masker);

BESCHRIJVING
       De sigaction systeem aanroep wordt gebruikt om de genomen actie door
       een proces bij het ontvangst van een signaal te veranderen.

       signum bepaald het signaal en kan elk geldig signaal zijn behalve
       SIGKILL {vermoord} en SIGSTOP {stop}.

       Als act on-gelijk nul is wordt de nieuwe actie voor het signaal signum
       geïnstalleerd van act.  Als oudeact niet-null is, dan wordt de vorige
       actie bewaard in oudeact.

       De sigaction structuur is bepaald als

              struct sigaction {
                  void (*sa_handler)(int);
                  void (*sa_sigaction)(int, siginfo_t *, void *);
                  sigset_t sa_mask;
                  int sa_flags;
                  void (*sa_restorer)(void);
              }

       Het sa_restorer element is verouderd en zou niet gebruikt moeten
       worden.  POSIX geeft geen sa_restorer element op.

       sa_handler Geeft de actie die verbonden zal worden met signum op, en
       mag SIG_DFL {signaal standaard} zijn voor de standaard actie, SIG_IGN
       {signaal negeer} om het signaal te negeren, of een pointer naar een
       signaal behandelaar functie.

       sa_mask Geeft een masker van signalen die geblokkeerd zouden moeten
       worden tijdens de uitvoering van de signaal behandelaar. In toevoeging
       daarop zal het signaal dat de behandelaar af liet gaan geblokkeerd
       worden, tenzij de SA_NODEFER {*niet uitstellen} of SA_NOMASK {*geen
       masker} vlaggen worden gebruikt.

       sa_flags Geeft een aantal vlaggen op die het gedrag van het signaal
       behandelings proces aanpassen. Het wordt gevormd door de bitsgewijze OF
       {incl.} van nul of meer van het volgende:

              SA_NOCLDSTOP
                     {*geen kind stop} Als signum , SIGCHLD is, ontvang geen
                     bericht wanneer kind processen stoppen (dat is, wanneer
                     kind processen 1 van SIGSTOP, SIGTSTP, SIGTTIN of SIGTTOU
                     ontvangen).

              SA_ONESHOT {1 keer} of SA_RESETHAND {herzet behandelaar}
                     Herstel de signaal actie naar de standaard toestand zodra
                     de signaal behandelaar aangeroepen is geweest. (Dit is
                     het standaard gedrag van de signal(2) systeem aanroep.)

              SA_RESTART
                     {*herstart} Geef gedrag overeenkomend met BSD signaal-
                     regels door bepaalde systeem aanroepen herstartbaar te
                     maken door signalen heen.

              SA_NOMASK {*geen masker} or SA_NODEFER {*geen uitstel}
                     Voorkom niet dat het signaal ontvangen wordt binnen in
                     zijn eigen signaal behandelaar.

              SA_SIGINFO
                     {*signaal informatie} De signaal behandelaar neemt 3
                     argumenten, niet 1. In dit geval zou sa_sigaction gezet
                     moeten zijn inplaats van sa_handler.  (Het sa_sigaction
                     veld werd toegevoegd in Linux 2.1.86.)

       De siginfo_t grootheid van sa_sigaction is een "struct" met de volgende
       elementen

              siginfo_t {
                  int      si_signo;  /* Signaal nummer */
                  int      si_errno;  /* Een errno waarde */
                  int      si_code;   /* Signaal code */
                  pid_t    si_pid;    /* Zendende proces ID */
                  uid_t    si_uid;    /* Echte gebruiker ID van het zendende proces */
                  int      si_status; /* Teruggeef waarde, of signaal */
                  clock_t  si_utime;  /* Gebruiker tijd verbruikt */
                  clock_t  si_stime;  /* Systeem tijd verbruikt */
                  sigval_t si_value;  /* Signaal waarde */
                  int      si_int;    /* POSIX.1b signaal */
                  void *   si_ptr;    /* POSIX.1b signaal */
                  void *   si_addr;   /* Geheugen plaats die de fout veroorzaakte */
                  int      si_band;   /* "Band" gebeurtenis */
                  int      si_fd;     /* Bestandsindicator */
              }

       si_signo, si_errno en si_code zijn bepaald voor alle signalen.
       kill(2), POSIX.1b signalen en SIGCHLD vullen si_pid en si_uid in.
       SIGCHLD vult ook: si_status, si_utime en si_stime in.  si_int en si_ptr
       worden opgegeven door de zender van het POSIX.1b signaal.  SIGILL
       {*ziek}, SIGFPE {*drijvende komma uitzondering}, SIGSEGV {*seg v} en
       SIGBUS {*bus} vullen si_addr in met het adres van de fout.  SIGPOLL
       {*onderzoek} vult si_band en si_fd in.

       si_code geeft aan waarom dit signaal gezonden werd. Het is een waarde,
       geen bitmasker. De waardes die mogelijk zijn voor elk signaal zijn
       hieronder gegeven in deze tabel:

       ┌───────────────────────────────────────────────────────────────┐
       │                           si_code                             │
       ├─────────────────────────────┬─────────────────────────────────┤
       │Waarde                       │ Signaal herkomst                │
       ├─────────────────────────────┼─────────────────────────────────┤
       │SI_USER {*gebruiker}         │  vermoord, "sigsend" of "raise" │
       ├─────────────────────────────┼─────────────────────────────────┤
       │SI_KERNEL {*kernel}          │  De kernel                      │
       ├─────────────────────────────┼─────────────────────────────────┤
       │SI_QUEUE {*rij}              │  "sigqueue"                     │
       ├─────────────────────────────┼─────────────────────────────────┤
       │SI_TIMER {*uurwerk}          │  uurwerk liep af                │
       ├─────────────────────────────┼─────────────────────────────────┤
       │SI_MESGQ {*?}                │  "mesgq" toestand veranderd     │
       ├─────────────────────────────┼─────────────────────────────────┤
       │SI_ASYNCIO {*ongelijktijdig} │  "AIO" afgemaakt                │
       ├─────────────────────────────┼─────────────────────────────────┤
       │SI_SIGIO {*in/uit}           │  in de wachtrij geplaatst SIGIO │
       └─────────────────────────────┴─────────────────────────────────┘

       ┌──────────────────────────────────────────────────────────┐
       │                  SIGILL {signaal ziek}                   │
       ├─────────────────────────────┬────────────────────────────┤
       │ILL_ILLOPC {*ziek opcode}    │ onwettige opcode           │
       ├─────────────────────────────┼────────────────────────────┤
       │ILL_ILLOPN {*ziek operand}   │ onwettige operand          │
       ├─────────────────────────────┼────────────────────────────┤
       │ILL_ILLADR {*ziek adres}     │ onwettige adresseer "mode" │
       ├─────────────────────────────┼────────────────────────────┤
       │ILL_ILLTRP {*ziek val}       │ onwettige valkuil {"trap"} │
       ├─────────────────────────────┼────────────────────────────┤
       │ILL_PRVOPC {*prive opcode}   │ geprivilegieerde opcode    │
       ├─────────────────────────────┼────────────────────────────┤
       │ILL_PRVREG {*prive register} │ geprivilegieerd register   │
       ├─────────────────────────────┼────────────────────────────┤
       │ILL_COPROC {*help processor} │ hulpprocessor fout         │
       ├─────────────────────────────┼────────────────────────────┤
       │ILL_BADSTK {*slechte stapel} │ inwendige stapel fout      │
       └─────────────────────────────┴────────────────────────────┘

       ┌─────────────────────────────────────────────────────────────────────┐
       │           SIGFPE {signaal drijvende komma uitzondering}             │
       ├────────────────────────────────┬────────────────────────────────────┤
       │FPE_INTDIV {*heel delen}        │ geheel getal delen door nul        │
       ├────────────────────────────────┼────────────────────────────────────┤
       │FPE_INTOVF {*heel overloop}     │ geheel getal overloop              │
       ├────────────────────────────────┼────────────────────────────────────┤
       │FPE_FLTDIV {*dr.kma. delen}     │ drijvende komma deel door nul      │
       ├────────────────────────────────┼────────────────────────────────────┤
       │FPE_FLTOVF {*dr.kma. overloop}  │ drijvende komma overloop           │
       ├────────────────────────────────┼────────────────────────────────────┤
       │FPE_FLTUND {*dr.kma. onderloop} │ drijvende komma onderloop          │
       ├────────────────────────────────┼────────────────────────────────────┤
       │FPE_FLTRES {*dr.kma. resultaat} │ drijvende komma onprecies antwoord │
       ├────────────────────────────────┼────────────────────────────────────┤
       │FPE_FLTINV {*dr.kma. ongeldig}  │ drijvende komma ongeldige operatie │
       ├────────────────────────────────┼────────────────────────────────────┤
       │FPE_FLTSUB {*dr.kma. subscript} │ index {"subscript"} buiten bereik  │
       └────────────────────────────────┴────────────────────────────────────┘

       ┌────────────────────────────────────────────────────────────────────────┐
       │                      SIGSEGV {signaal segment ?}                       │
       ├─────────────────────────────────┬──────────────────────────────────────┤
       │SEGV_DIRECTORIEERR {*kaart fout} │ adres niet verbonden met object      │
       ├─────────────────────────────────┼──────────────────────────────────────┤
       │SEGV_ACCERR {*toegang fout}      │ ongeld. toestemm. voor "mapped" obj. │
       └─────────────────────────────────┴──────────────────────────────────────┘

       ┌────────────────────────────────────────────────────────────┐
       │                   SIGBUS {signaal bus}                     │
       ├────────────────────────────┬───────────────────────────────┤
       │BUS_ADRALN {*adres oplijn}  │ ongeldige adres oplijning     │
       ├────────────────────────────┼───────────────────────────────┤
       │BUS_ADRERR {*adres fout}    │ niet bestaand materieel adres │
       ├────────────────────────────┼───────────────────────────────┤
       │BUS_OBJERR {*voorwerp fout} │ object eigen "hardware" fout  │
       └────────────────────────────┴───────────────────────────────┘

       ┌────────────────────────────────────────────────┐
       │          SIGTRAP {signaal val(kuil)}           │
       ├───────────┬────────────────────────────────────┤
       │TRAP_BRKPT │ {*breekpunt} proces breekpunt      │
       ├───────────┼────────────────────────────────────┤
       │TRAP_TRACE │ {*volg} proces volg {"trace"} punt │
       └───────────┴────────────────────────────────────┘

       ┌──────────────────────────────────────────────────────────────────────┐
       │                       SIGCHLD {signaal kind}                         │
       ├────────────────────────────┬─────────────────────────────────────────┤
       │CLD_EXITED {*eindigde}      │ kind is beëindigd                      │
       ├────────────────────────────┼─────────────────────────────────────────┤
       │CLD_KILLED {*vermoord}      │ kind werd vermoord                      │
       ├────────────────────────────┼─────────────────────────────────────────┤
       │CLD_DUMPED {*gedumpt}       │ kind eindigde abnormaal                 │
       ├────────────────────────────┼─────────────────────────────────────────┤
       │CLD_TRAPPED {*gevangen}     │ gevolgd {"traced"} kind viel in valkuil │
       ├────────────────────────────┼─────────────────────────────────────────┤
       │CLD_STOPPED {*gestopt}      │ kind is gestopt                         │
       ├────────────────────────────┼─────────────────────────────────────────┤
       │CLD_CONTINUED {*doorgegaan} │ gestopt kind is doorgegaan              │
       └────────────────────────────┴─────────────────────────────────────────┘

       ┌────────────────────────────────────────────────────────────┐
       │                SIGPOLL {signaal onderzoek}                 │
       ├───────────────────────┬────────────────────────────────────┤
       │POLL_IN {*in}          │ gegevens invoer beschikbaar        │
       ├───────────────────────┼────────────────────────────────────┤
       │POLL_OUT {*uit}        │ uitvoer buffers beschikbaar        │
       ├───────────────────────┼────────────────────────────────────┤
       │POLL_MSG {*bericht}    │ invoer bericht beschikbaar         │
       ├───────────────────────┼────────────────────────────────────┤
       │POLL_ERR {*fout}       │ in/uit fout                        │
       ├───────────────────────┼────────────────────────────────────┤
       │POLL_PRI {*prioriteit} │ hoge prioriteit invoer beschikbaar │
       ├───────────────────────┼────────────────────────────────────┤
       │POLL_HUP {*hangop}     │ apparaat los gemaakt               │
       └───────────────────────┴────────────────────────────────────┘

       De sigprocmask aanroep wordt gebruikt om de lijst van momenteel
       geblokkeerde signalen te veranderen. Het gedrag van de aanroep is
       afhankelijk van de waarde van hoe, als volgt.

              SIG_BLOCK
                     {*blokkeer} De set van geblokkeerde signalen is de
                     vereniging van de huidige set en het set argument.

              SIG_UNBLOCK
                     {*niet-blokkeer} De signalen in set worden verwijderd uit
                     de huidige set geblokkeerde signalen. Het is wettig om te
                     proberen een signaal te on-blokkeren dat niet geblokkeerd
                     wordt.

              SIG_SETMASK
                     {*zet masker} De set van geblokkeerde signalen wordt
                     gezet naar het argument set.

       Als oudeset niet-null is dan wordt de vorige waarde van het signaal
       masker bewaard in oudeset.

       De sigpending aanroep laat het beoordelen van wachtende {eng: pending}
       signalen toe (degenen die opgekomen zijn terwijl zo geblokkeerd waren).
       Het signaal masker van wachtende signalen wordt bewaard in set.

       De sigsuspend aanroep vervangt tijdelijk het signaal masker voor het
       proces met dat gegeven door masker en schort dan het proces op totdat
       een signaal ontvangen wordt.


TERUGGEEF WAARDES
       sigaction, sigprocmask, sigpending en sigsuspend geven 0 bij slagen en
       -1 bij fout.


FOUTEN
       EINVAL {ongeldig} Een ongeldig signaal werd opgegeven. Dit zal ook
              voortgebracht worden als een poging wordt gedaan om de actie
              voor SIGKILL of SIGSTOP, te veranderen, die niet gevangen kunnen
              worden.

       EFAULT {fout} act, oldact, set of oldset wijzen naar geheugen dat niet
              een geldig onderdeel van de proces adresruimte is.

       EINTR  {onderbroken} Systeem aanroep werd onderbroken.


OPMERKINGEN
       Het is niet mogelijk om SIGKILL of SIGSTOP te blokkeren met de
       sigprocmask aanroep. Pogingen om dat te doen zullen stilzwijgend
       genegeerd worden.

       Volgens POSIX is het gedrag van een proces ongedefinieerd als het een
       SIGFPE, SIGILL of SIGSEGV negeert dat niet voortgebracht werd door de
       kill() of de raise() functies.  Heel getal delen door nul heeft
       ongedefinieerd gevolg.  Op sommige architecturen zal het een SIGFPE
       signaal veroorzaken.  (Ook het delen van het meest negatieve hele getal
       door -1 kan een SIGFPE veroorzaken.)  Negeren van dit signaal zou tot
       een eindeloze lus kunnen leiden.

       POSIX (B.3.3.1.3) status niet toe de actie voor SIGCHLD naar SIG_IGN te
       zetten.  De BSD en SYSV gedragingen verschillen, wat zorgt dat BSD
       zachtgoed {software ;)}, dat de actie voor SIGCHLD naar SIG_IGN zet
       faalt op Linux.

       De POSIX bepaling bepaald alleen SA_NOCLDSTOP.  Gebruik van andere
       sa_flags {*vlaggen} is niet-draagbaar.

       De SA_RESETHAND vlag is overdraagbaar met de SVr4 vlag met dezelfde
       naam.

       De SA_NODEFER vlag is overeenkomstig met de SVr4 vlag met dezelfde naam
       onder kernels 1.3.9 en nieuwer. Op oudere kernels liet de Linux-
       verwerkelijking het ontvangen van elk signaal toe, niet alleen degenen
       die we installeren (elke sa_mask zetting dus te niet doende)

       De SA_RESETHAND en SA_NODEFER namen voor SVr4 overdraagbaarheid zijn
       alleen aanwezig in bibliotheek versie 3.0.9 en hoger.

       De SA_SIGINFO vlag wordt opgegeven door POSIX.1b. Ondersteuning ervoor
       werd toegevoegd in Linux 2.2.

       sigaction kan aangeroepen worden met een tweede argument nul om de
       huidige signaalbehandelaar te ondervragen. Het kan ook gebruikt worden
       om te testen of een gegeven signaal geldig is voor de huidige machine,
       door het aan te roepen met 'nul' tweede en derde argumenten.

       Zie sigsetops(3) voor details over manipuleren van signaal sets.

VOLDOET AAN
       POSIX, SVr4.  SVr4 beschrijft de EINTR toestand niet.


ZIE
       kill(1) {vermoord}, kill(2) {vermoord}, killpg(2) {vermoord proces
       groep}, pause(2){pauze}," raise(3) {opkomen}, siginterrupt(3) {signaal
       onderbreking}, signal(2) {signaal}, signal(7) {signaal}, sigsetops(3)
       {signaal zet operatie}, sigvec(2) {bsd signaal}


VERTALING
       Dit is een handleiding uit manpages-dev 1.29.  Alles wat tussen
       `{'..`}' staat is aanvullende vertaling, en hoort niet bij de originele
       handleiding.  Email naar <manpages-nl@nl.linux.org>.

       $Id: sigaction.2,v 1.1.1.1 2004/03/21 21:02:25 cor Exp $



Linux 2.2                         8 Mei 1999                      SIGACTION(2)