Signaal
Een signaal is een gebeurtenis die wordt gegenereerd om een proces of thread op de hoogte te stellen dat er een belangrijke situatie is ontstaan. Wanneer een proces of thread een signaal heeft ontvangen, stopt het proces of de thread met wat het doet en onderneemt actie. Signaal kan nuttig zijn voor communicatie tussen processen.
Standaard signalen
De signalen worden gedefinieerd in het headerbestand signaal.h als macroconstante. Signaalnaam is begonnen met een SIG en gevolgd door een korte beschrijving van het signaal. Elk signaal heeft dus een unieke numerieke waarde. Uw programma moet altijd de naam van de signalen gebruiken, niet het signaalnummer. De reden is dat het signaalnummer per systeem kan verschillen, maar de betekenis van namen is standaard.
de macro NSIG is het totale aantal gedefinieerde signalen. De waarde van NSIG één groter is dan het totale aantal gedefinieerde signalen (alle signaalnummers worden opeenvolgend toegewezen).
Hieronder volgen de standaard signalen:
| Signaalnaam: | Beschrijving |
| SIGHUP | Hang het proces op. Het SIGHUP-signaal wordt gebruikt om te melden dat de terminal van de gebruiker is verbroken, mogelijk omdat een externe verbinding is verbroken of wordt opgehangen. |
| SIGINT | Onderbreek het proces. Wanneer de gebruiker het INTR-teken typt (normaal Ctrl + C), wordt het SIGINT-signaal verzonden. |
| SIGQUIT | Sluit het proces af. Wanneer de gebruiker het QUIT-teken typt (normaal gesproken Ctrl + ) wordt het SIGQUIT-signaal verzonden. |
| ZEGEL | Illegale instructie. Wanneer een poging wordt gedaan om afval of geprivilegieerde instructies uit te voeren, wordt het SIGILL-signaal gegenereerd. SIGILL kan ook worden gegenereerd wanneer de stapel overloopt, of wanneer het systeem problemen heeft met het uitvoeren van een signaalverwerker. |
| SIGTRAP | Traceren val. Een breekpuntinstructie en andere trapinstructie zullen het SIGTRAP-signaal genereren. De debugger gebruikt dit signaal. |
| SIGABRT | afbreken. Het SIGABRT-signaal wordt gegenereerd wanneer de functie abort() wordt aangeroepen. Dit signaal geeft een fout aan die is gedetecteerd door het programma zelf en gerapporteerd door de functie-aanroep abort(). |
| SIGFPE | Uitzondering met drijvende komma. Wanneer een fatale rekenfout is opgetreden, wordt het SIGFPE-signaal gegenereerd. |
| SIGUSR1 en SIGUSR2 | De signalen SIGUSR1 en SIGUSR2 kunnen naar wens worden gebruikt. Het is handig om een signaalbehandelaar voor hen te schrijven in het programma dat het signaal ontvangt voor eenvoudige communicatie tussen processen. |
Standaardactie van signalen
Elk signaal heeft een standaardactie, een van de volgende:
Termijn: Het proces wordt beëindigd.
Kern: Het proces wordt beëindigd en produceert een kerndumpbestand.
Ign: Het proces negeert het signaal.
Stop: Het proces stopt.
Rekening: Het proces wordt voortgezet nadat het is gestopt.
Standaardactie kan worden gewijzigd met behulp van de handlerfunctie. De standaardactie van sommige signalen kan niet worden gewijzigd. SIGKILL en SIGABRT de standaardactie van het signaal kan niet worden gewijzigd of genegeerd.
Signaalverwerking
Als een proces een signaal ontvangt, heeft het proces een actiekeuze voor dat soort signaal. Het proces kan het signaal negeren, een handlerfunctie specificeren of de standaardactie voor dat soort signaal accepteren.
- Als de gespecificeerde actie voor het signaal wordt genegeerd, wordt het signaal onmiddellijk weggegooid.
- Het programma kan een handlerfunctie registreren met behulp van functies zoals: signaal of sigactie . Dit heet een handler die het signaal opvangt.
- Als het signaal niet is behandeld of genegeerd, vindt de standaardactie plaats.
We kunnen het signaal verwerken met behulp van: signaal of sigactie functie. Hier zien we hoe de eenvoudigste signaal() functie wordt gebruikt voor het verwerken van signalen.
intsignaal() (intteken, leegte (*functie)(int))De signaal() zal de bellen functie functie als het proces een signaal ontvangt teken . De signaal() geeft een aanwijzer terug naar functie functie indien succesvol of het retourneert een fout naar errno en anders -1.
De functie aanwijzer kan drie waarden hebben:
- SIG_DFL : Het is een verwijzing naar de standaardfunctie van het systeem SIG_DFL () , verklaard in H header-bestand. Het wordt gebruikt voor het nemen van standaardactie van het signaal.
- SIG_IGN : Het is een verwijzing naar de functie voor het negeren van het systeem SIG_IGN () ,aangegeven in H header-bestand.
- Door de gebruiker gedefinieerde handlerfunctie-aanwijzer : Het door de gebruiker gedefinieerde handlerfunctietype is nietig(*)(int) , betekent dat het retourtype ongeldig is en dat één argument van het type int.
Voorbeeld van basissignaalverwerker
#erbij betrekken#erbij betrekken
#erbij betrekken
leegtesig_handler(intteken){
//Retourtype van de handlerfunctie moet ongeldig zijn
printf ('NBinnen handler functieN');
}
inthoofd(){
signaal(SIGINT,sig_handler); // Signaalbehandelaar registreren
voor(intl=1;;l++){ //Oneindige lus
printf ('%d : Binnen hoofdfunctieN',l);
slaap(1); // Vertraging voor 1 seconde
}
opbrengst 0;
}
In de schermafbeelding van de uitvoer van Voorbeeld1.c kunnen we zien dat in de hoofdfunctie oneindige lus wordt uitgevoerd. Wanneer de gebruiker Ctrl+C typt, stopt de uitvoering van de hoofdfunctie en wordt de handlerfunctie van het signaal aangeroepen. Na voltooiing van de handlerfunctie werd de uitvoering van de hoofdfunctie hervat. Wanneer de gebruiker Ctrl+ typt, wordt het proces afgesloten.
Negeer signalen Voorbeeld
#erbij betrekken#erbij betrekken
#erbij betrekken
inthoofd(){
signaal(SIGINT,SIG_IGN); // Registreer signaalbehandelaar voor het negeren van het signaal
voor(intl=1;;l++){ //Oneindige lus
printf ('%d : Binnen hoofdfunctieN',l);
slaap(1); // Vertraging voor 1 seconde
}
opbrengst 0;
}
Hier is de handlerfunctie registreren bij SIG_IGN () functie voor het negeren van de signaalactie. Dus toen de gebruiker Ctrl+C typte, SIGINT signaal wordt gegenereerd, maar de actie wordt genegeerd.
Voorbeeld van signaalhandler opnieuw registreren
#erbij betrekken#erbij betrekken
#erbij betrekken
leegtesig_handler(intteken){
printf ('NBinnen handler functieN');
signaal(SIGINT,SIG_DFL); // Re Registreer signaalhandler voor standaardactie
}
inthoofd(){
signaal(SIGINT,sig_handler); // Signaalbehandelaar registreren
voor(intl=1;;l++){ //Oneindige lus
printf ('%d : Binnen hoofdfunctieN',l);
slaap(1); // Vertraging voor 1 seconde
}
opbrengst 0;
}
In de schermafbeelding van de uitvoer van Voorbeeld3.c kunnen we zien dat wanneer de gebruiker voor het eerst Ctrl+C typte, de handlerfunctie werd aangeroepen. In de handlerfunctie registreert de signaalhandler zich opnieuw bij: SIG_DFL voor standaardactie van het signaal. Wanneer de gebruiker voor de tweede keer Ctrl+C typt, wordt het proces beëindigd, wat de standaardactie is van SIGINT signaal.
Signalen verzenden:
Een proces kan ook expliciet signalen naar zichzelf of naar een ander proces sturen. De functie raise() en kill() kunnen worden gebruikt voor het verzenden van signalen. Beide functies worden gedeclareerd in het signal.h header-bestand.
int salarisverhoging (intteken)De functie raise() die wordt gebruikt voor het verzenden van signalen teken aan het aanroepende proces (zelf). Het retourneert nul als het is gelukt en een waarde die niet nul is als het mislukt.
intdoden(pid_t pid, intteken)De kill-functie die wordt gebruikt voor het verzenden van een signaal teken naar een proces of procesgroep gespecificeerd door pid .
SIGUSR1 Signaal Handler Voorbeeld
#erbij betrekken#erbij betrekken
leegtesig_handler(intteken){
printf ('Binnen handler functie'N');
}
inthoofd(){
signaal(SIGUSR1,sig_handler); // Signaalbehandelaar registreren
printf ('Binnen hoofdfunctie'N');
salarisverhoging (SIGUSR1);
printf ('Binnen hoofdfunctie'N');
opbrengst 0;
}
Hier stuurt het proces het SIGUSR1-signaal naar zichzelf met de functie raise().
Raise with Kill Voorbeeldprogramma
#erbij betrekken#erbij betrekken
#erbij betrekken
leegtesig_handler(intteken){
printf ('Binnen handler functie'N');
}
inthoofd(){
pid_t pid;
signaal(SIGUSR1,sig_handler); // Signaalbehandelaar registreren
printf ('Binnen hoofdfunctie'N');
pid=getpid(); //Proces-ID van zichzelf
doden(pid,SIGUSR1); // Stuur SIGUSR1 naar zichzelf
printf ('Binnen hoofdfunctie'N');
opbrengst 0;
}
Hier, het proces verzenden: SIGUSR1 signaal naar zichzelf met behulp van doden() functie. getpid() wordt gebruikt om de proces-ID van zichzelf te krijgen.
In het volgende voorbeeld zullen we zien hoe ouder- en kindprocessen communiceren (Interprocescommunicatie) met behulp van doden() en signaalfunctie.
Ouder-kindcommunicatie met signalen
#erbij betrekken#erbij betrekken
#erbij betrekken
#erbij betrekken
leegtesig_handler_parent(intteken){
printf ('Ouder: reactiesignaal ontvangen van kind'N');
}
leegtesig_handler_child(intteken){
printf ('Kind: signaal ontvangen van ouder'N');
slaap(1);
doden(getppid(),SIGUSR1);
}
inthoofd(){
pid_t pid;
indien((pid=vork())<0){
printf ('Vork mislukt'N');
Uitgang (1);
}
/* Onderliggend proces */
anders indien(pid==0){
signaal(SIGUSR1,sig_handler_child); // Signaalbehandelaar registreren
printf ('Kind: wacht op signaal'N');
pauze();
}
/* Ouderproces */
anders{
signaal(SIGUSR1,sig_handler_parent); // Signaalbehandelaar registreren
slaap(1);
printf ('Ouder: signaal naar kind sturen'N');
doden(pid,SIGUSR1);
printf ('Ouder: wacht op reactie'N');
pauze();
}
opbrengst 0;
}
Hier, vork() functie maakt een onderliggend proces en retourneert nul naar het onderliggende proces en de ID van het onderliggende proces naar het bovenliggende proces. Dus pid is gecontroleerd om het ouder- en kindproces te bepalen. In het ouderproces wordt het gedurende 1 seconde ingeslapen, zodat het kindproces de signaalverwerkingsfunctie kan registreren en op het signaal van de ouder kan wachten. Na 1 seconde ouderproces verzenden SIGUSR1 signaal naar kind en wacht op het antwoordsignaal van het kind. In het kindproces wacht het eerst op het signaal van de ouder en wanneer het signaal wordt ontvangen, wordt de handlerfunctie aangeroepen. Vanuit de handlerfunctie stuurt het onderliggende proces een ander SIGUSR1 signaal naar de ouder. Hier getppid() functie wordt gebruikt voor het verkrijgen van de ID van het bovenliggende proces.
Conclusie
Signaal in Linux is een groot onderwerp. In dit artikel hebben we gezien hoe signaal vanaf de basis moet worden verwerkt, en we hebben ook kennis gekregen van hoe het signaal wordt gegenereerd, hoe een proces een signaal naar zichzelf en andere processen kan sturen, hoe een signaal kan worden gebruikt voor communicatie tussen processen.