సిగ్నల్
సిగ్నల్ అనేది ఒక ప్రాసెస్ లేదా థ్రెడ్‌కు కొన్ని ముఖ్యమైన పరిస్థితి వచ్చిందని తెలియజేయడానికి రూపొందించబడిన ఈవెంట్. ప్రాసెస్ లేదా థ్రెడ్ సిగ్నల్ అందుకున్నప్పుడు, ప్రాసెస్ లేదా థ్రెడ్ దాని పనిని ఆపివేసి కొంత చర్య తీసుకుంటుంది. ఇంటర్-ప్రాసెస్ కమ్యూనికేషన్ కోసం సిగ్నల్ ఉపయోగకరంగా ఉండవచ్చు.
ప్రామాణిక సంకేతాలు
సిగ్నల్స్ హెడర్ ఫైల్‌లో నిర్వచించబడ్డాయి సిగ్నల్.హెచ్ స్థూల స్థిరాంకంగా. సిగ్నల్ పేరు SIG తో ప్రారంభమైంది మరియు సిగ్నల్ యొక్క చిన్న వివరణ తరువాత. కాబట్టి, ప్రతి సిగ్నల్‌కు ప్రత్యేకమైన సంఖ్యా విలువ ఉంటుంది. మీ ప్రోగ్రామ్ ఎల్లప్పుడూ సిగ్నల్స్ పేరును ఉపయోగించాలి, సిగ్నల్స్ నంబర్ కాదు. కారణం సిస్టమ్ ప్రకారం సిగ్నల్ నంబర్ భిన్నంగా ఉండవచ్చు కానీ పేర్ల అర్థం ప్రామాణికంగా ఉంటుంది.
స్థూల NSIG సిగ్నల్ నిర్వచించిన మొత్తం సంఖ్య. యొక్క విలువ NSIG నిర్వచించిన మొత్తం సిగ్నల్ సంఖ్య కంటే ఒకటి ఎక్కువ (అన్ని సిగ్నల్ నంబర్‌లు వరుసగా కేటాయించబడతాయి).
కిందివి ప్రామాణిక సంకేతాలు:
| సిగ్నల్ పేరు | వివరణ |
| SIGHUP | ప్రక్రియను నిలిపివేయండి. SIGHUP సిగ్నల్ యూజర్ టెర్మినల్ డిస్‌కనెక్ట్ రిపోర్ట్ చేయడానికి ఉపయోగించబడుతుంది, బహుశా రిమోట్ కనెక్షన్ పోయినందున లేదా హ్యాంగ్ అప్ అయినందున. |
| సైన్ | ప్రక్రియకు అంతరాయం కలిగించండి. వినియోగదారు INTR అక్షరాన్ని టైప్ చేసినప్పుడు (సాధారణంగా Ctrl + C) SIGINT సిగ్నల్ పంపబడుతుంది. |
| సిగ్క్యూట్ | ప్రక్రియను విడిచిపెట్టండి. వినియోగదారు QUIT అక్షరాన్ని టైప్ చేసినప్పుడు (సాధారణంగా Ctrl + ) SIGQUIT సిగ్నల్ పంపబడుతుంది. |
| సీల్ | చట్టవిరుద్ధమైన సూచన. చెత్త లేదా ప్రత్యేక సూచనలను అమలు చేయడానికి ప్రయత్నించినప్పుడు, SIGILL సిగ్నల్ ఉత్పత్తి అవుతుంది. అలాగే, స్టాక్ ఓవర్‌ఫ్లో అయినప్పుడు లేదా సిగ్నల్ హ్యాండ్లర్‌ని అమలు చేయడంలో సిస్టమ్‌కు సమస్య ఉన్నప్పుడు SIGILL జనరేట్ చేయవచ్చు. |
| సిగ్ట్రాప్ | ట్రేస్ ట్రాప్. బ్రేక్ పాయింట్ ఇన్‌స్ట్రక్షన్ మరియు ఇతర ట్రాప్ ఇన్‌స్ట్రక్షన్ SIGTRAP సిగ్నల్‌ని ఉత్పత్తి చేస్తాయి. డీబగ్గర్ ఈ సిగ్నల్‌ని ఉపయోగిస్తుంది. |
| SIGABRT | గర్భస్రావం. అబార్ట్ () ఫంక్షన్ అని పిలవబడినప్పుడు SIGABRT సిగ్నల్ ఉత్పత్తి అవుతుంది. ఈ సిగ్నల్ ప్రోగ్రామ్ ద్వారానే కనుగొనబడిన మరియు abort () ఫంక్షన్ కాల్ ద్వారా నివేదించబడిన లోపాన్ని సూచిస్తుంది. |
| SIGFPE | ఫ్లోటింగ్ పాయింట్ మినహాయింపు. ప్రాణాంతకమైన అంకగణిత లోపం సంభవించినప్పుడు SIGFPE సిగ్నల్ ఉత్పత్తి అవుతుంది. |
| SIGUSR1 మరియు SIGUSR2 | SIGUSR1 మరియు SIGUSR2 సిగ్నల్స్ మీకు నచ్చిన విధంగా ఉపయోగించవచ్చు. సాధారణ ఇంటర్-ప్రాసెస్ కమ్యూనికేషన్ కోసం సిగ్నల్ అందుకున్న ప్రోగ్రామ్‌లో వారికి సిగ్నల్ హ్యాండ్లర్ రాయడం ఉపయోగకరంగా ఉంటుంది. |
సంకేతాల డిఫాల్ట్ చర్య
ప్రతి సిగ్నల్ డిఫాల్ట్ చర్యను కలిగి ఉంటుంది, కింది వాటిలో ఒకటి:
పదం: ప్రక్రియ ముగుస్తుంది.
కోర్: ప్రక్రియ ముగుస్తుంది మరియు కోర్ డంప్ ఫైల్‌ను ఉత్పత్తి చేస్తుంది.
ఇగ్ని: ప్రక్రియ సిగ్నల్‌ను విస్మరిస్తుంది.
ఆపు: ప్రక్రియ ఆగిపోతుంది.
ఖాతా: ప్రక్రియ నిలిపివేయడం నుండి కొనసాగుతుంది.
హ్యాండ్లర్ ఫంక్షన్ ఉపయోగించి డిఫాల్ట్ చర్య మార్చబడవచ్చు. కొన్ని సిగ్నల్ డిఫాల్ట్ చర్య మార్చబడదు. సిగ్గిల్ మరియు SIGABRT సిగ్నల్ యొక్క డిఫాల్ట్ చర్య మార్చబడదు లేదా విస్మరించబడదు.
సిగ్నల్ హ్యాండ్లింగ్
ఒక ప్రక్రియ ఒక సిగ్నల్‌ని అందుకున్నట్లయితే, ఆ ప్రక్రియకు ఆ రకమైన సిగ్నల్ కోసం చర్య యొక్క ఎంపిక ఉంటుంది. ప్రక్రియ సిగ్నల్‌ను విస్మరించవచ్చు, హ్యాండ్లర్ ఫంక్షన్‌ను పేర్కొనవచ్చు లేదా ఆ రకమైన సిగ్నల్ కోసం డిఫాల్ట్ చర్యను ఆమోదించవచ్చు.
- సిగ్నల్ కోసం పేర్కొన్న చర్య విస్మరించబడితే, సిగ్నల్ వెంటనే విస్మరించబడుతుంది.
- ప్రోగ్రామ్ వంటి ఫంక్షన్ ఉపయోగించి హ్యాండ్లర్ ఫంక్షన్‌ను నమోదు చేయవచ్చు సంకేతం లేదా sigaction . దీనిని హ్యాండ్లర్ సిగ్నల్ క్యాచ్‌లు అంటారు.
- సిగ్నల్ నిర్వహించబడకపోతే లేదా విస్మరించబడకపోతే, దాని డిఫాల్ట్ చర్య జరుగుతుంది.
మేము ఉపయోగించి సిగ్నల్‌ను నిర్వహించగలము సంకేతం లేదా sigaction ఫంక్షన్ ఇక్కడ మనం ఎంత సులభమైనవి అని చూస్తాము సంకేతం () సిగ్నల్‌లను నిర్వహించడానికి ఫంక్షన్ ఉపయోగించబడుతుంది.
intసంకేతం() (intసంతకం, శూన్యం (*ఫంక్షన్)(int))ది సంకేతం () కాల్ చేస్తుంది ఫంక్షన్ ప్రక్రియ సిగ్నల్ అందుకుంటే ఫంక్షన్ సంతకం . ది సంకేతం () ఫంక్షన్‌కు పాయింటర్‌ను అందిస్తుంది ఫంక్షన్ ఒకవేళ విజయవంతమైతే లేదా అది ఎర్రర్నో మరియు -1 కు దోషాన్ని అందిస్తుంది.
ది ఫంక్షన్ పాయింటర్ మూడు విలువలను కలిగి ఉంటుంది:
- SIG_DFL : ఇది సిస్టమ్ డిఫాల్ట్ ఫంక్షన్‌కు సూచిక SIG_DFL () , లో ప్రకటించబడింది h శీర్షిక ఫైల్. సిగ్నల్ యొక్క డిఫాల్ట్ చర్య తీసుకోవడానికి ఇది ఉపయోగించబడుతుంది.
- SIG_IGN : ఇది సిస్టమ్ విస్మరించే ఫంక్షన్‌కి సూచిక SIG_IGN () , లో ప్రకటించబడింది h శీర్షిక ఫైల్.
- వినియోగదారు నిర్వచించిన హ్యాండ్లర్ ఫంక్షన్ పాయింటర్ : వినియోగదారు నిర్వచించిన హ్యాండ్లర్ ఫంక్షన్ రకం శూన్యం (*) (int) , అంటే తిరిగి వచ్చే రకం శూన్యమైనది మరియు రకం int యొక్క ఒక వాదన.
ప్రాథమిక సిగ్నల్ హ్యాండ్లర్ ఉదాహరణ
#చేర్చండి#చేర్చండి
#చేర్చండి
శూన్యంsig_handler(intసంతకం){
// హ్యాండ్లర్ ఫంక్షన్ యొక్క రిటర్న్ రకం శూన్యంగా ఉండాలి
printf (' nహ్యాండ్లర్ ఫంక్షన్ లోపల n');
}
intప్రధాన(){
సంకేతం(సైన్,sig_handler); // సిగ్నల్ హ్యాండ్లర్‌ని నమోదు చేయండి
కోసం(inti=1;;i++){ //అనంతమైన చుట్టు
printf ('%d: ప్రధాన ఫంక్షన్ లోపల n',i);
నిద్ర(1); // 1 సెకను ఆలస్యం
}
తిరిగి 0;
}
Example1.c యొక్క అవుట్‌పుట్ యొక్క స్క్రీన్ షాట్‌లో, ప్రధాన ఫంక్షన్‌లో అనంతమైన లూప్ అమలు చేయబడుతుందని మనం చూడవచ్చు. యూజర్ Ctrl+C టైప్ చేసినప్పుడు, ప్రధాన ఫంక్షన్ ఎగ్జిక్యూషన్ ఆగిపోతుంది మరియు సిగ్నల్ యొక్క హ్యాండ్లర్ ఫంక్షన్ ప్రారంభించబడుతుంది. హ్యాండ్లర్ ఫంక్షన్ పూర్తయిన తర్వాత, ప్రధాన ఫంక్షన్ అమలు తిరిగి ప్రారంభించబడింది. వినియోగదారు టైప్ చేసినప్పుడు Ctrl+, ప్రాసెస్ నిష్క్రమించబడుతుంది.
సిగ్నల్స్ ఉదాహరణను విస్మరించండి
#చేర్చండి#చేర్చండి
#చేర్చండి
intప్రధాన(){
సంకేతం(సైన్,SIG_IGN); // సిగ్నల్‌ను విస్మరించినందుకు సిగ్నల్ హ్యాండ్లర్‌ని నమోదు చేయండి
కోసం(inti=1;;i++){ //అనంతమైన చుట్టు
printf ('%d: ప్రధాన ఫంక్షన్ లోపల n',i);
నిద్ర(1); // 1 సెకను ఆలస్యం
}
తిరిగి 0;
}
ఇక్కడ హ్యాండ్లర్ ఫంక్షన్ నమోదు చేయబడింది SIG_IGN () సిగ్నల్ చర్యను విస్మరించడం కోసం ఫంక్షన్. కాబట్టి, యూజర్ Ctrl+C టైప్ చేసినప్పుడు, సైన్ సిగ్నల్ ఉత్పత్తి అవుతోంది కానీ చర్య విస్మరించబడింది.
సిగ్నల్ హ్యాండ్లర్ ఉదాహరణని తిరిగి నమోదు చేయండి
#చేర్చండి#చేర్చండి
#చేర్చండి
శూన్యంsig_handler(intసంతకం){
printf (' nహ్యాండ్లర్ ఫంక్షన్ లోపల n');
సంకేతం(సైన్,SIG_DFL); // డిఫాల్ట్ చర్య కోసం సిగ్నల్ హ్యాండ్లర్‌ను తిరిగి నమోదు చేయండి
}
intప్రధాన(){
సంకేతం(సైన్,sig_handler); // సిగ్నల్ హ్యాండ్లర్‌ని నమోదు చేయండి
కోసం(inti=1;;i++){ //అనంతమైన చుట్టు
printf ('%d: ప్రధాన ఫంక్షన్ లోపల n',i);
నిద్ర(1); // 1 సెకను ఆలస్యం
}
తిరిగి 0;
}
Example3.c యొక్క అవుట్‌పుట్ స్క్రీన్‌షాట్‌లో, యూజర్ మొదటిసారి Ctrl+C అని టైప్ చేసినప్పుడు, హ్యాండ్లర్ ఫంక్షన్ ప్రారంభించబడిందని మనం చూడవచ్చు. హ్యాండ్లర్ ఫంక్షన్‌లో, సిగ్నల్ హ్యాండ్లర్ తిరిగి నమోదు చేసుకోండి SIG_DFL సిగ్నల్ యొక్క డిఫాల్ట్ చర్య కోసం. యూజర్ రెండవ సారి Ctrl+C టైప్ చేసినప్పుడు, ప్రాసెస్ డిఫాల్ట్ చర్యగా నిలిపివేయబడుతుంది సైన్ సంకేతం.
సంకేతాలను పంపుతోంది:
ఒక ప్రక్రియ కూడా తనకు లేదా మరొక ప్రక్రియకు సంకేతాలను స్పష్టంగా పంపగలదు. సిగ్నల్స్ పంపడానికి రైజ్ () మరియు కిల్ () ఫంక్షన్ ఉపయోగించవచ్చు. సిగ్నల్.హెచ్ హెడర్ ఫైల్‌లో రెండు విధులు ప్రకటించబడ్డాయి.
int పెంచండి (intసంతకం)సిగ్నల్ పంపడానికి ఉపయోగించే రైజ్ () ఫంక్షన్ సంతకం కాలింగ్ ప్రక్రియకు (స్వయంగా). ఇది విజయవంతమైతే సున్నా మరియు విఫలమైతే నాన్‌జెరో విలువను అందిస్తుంది.
intచంపండి(pid_t పిడ్, intసంతకం)సిగ్నల్ పంపడానికి ఉపయోగించే కిల్ ఫంక్షన్ సంతకం పేర్కొన్న ప్రక్రియ లేదా ప్రక్రియ సమూహానికి పిడ్ .
SIGUSR1 సిగ్నల్ హ్యాండ్లర్ ఉదాహరణ
#చేర్చండి#చేర్చండి
శూన్యంsig_handler(intసంతకం){
printf ('ఇన్సైడ్ హ్యాండ్లర్ ఫంక్షన్ n');
}
intప్రధాన(){
సంకేతం(SIGUSR1,sig_handler); // సిగ్నల్ హ్యాండ్లర్‌ని నమోదు చేయండి
printf ('ప్రధాన ఫంక్షన్ లోపల n');
పెంచండి (SIGUSR1);
printf ('ప్రధాన ఫంక్షన్ లోపల n');
తిరిగి 0;
}
ఇక్కడ, ఈ ప్రక్రియ SIGUSR1 సిగ్నల్‌ను రైజ్ () ఫంక్షన్‌ని ఉపయోగించి పంపుతుంది.
కిల్ ఉదాహరణ ప్రోగ్రామ్‌తో పెంచండి
#చేర్చండి#చేర్చండి
#చేర్చండి
శూన్యంsig_handler(intసంతకం){
printf ('ఇన్సైడ్ హ్యాండ్లర్ ఫంక్షన్ n');
}
intప్రధాన(){
pid_t పిడ్;
సంకేతం(SIGUSR1,sig_handler); // సిగ్నల్ హ్యాండ్లర్‌ని నమోదు చేయండి
printf ('ప్రధాన ఫంక్షన్ లోపల n');
పిడ్=గెట్‌పిడ్(); // స్వయంగా ప్రాసెస్ ID
చంపండి(పిడ్,SIGUSR1); // SIGUSR1 ని స్వయంగా పంపండి
printf ('ప్రధాన ఫంక్షన్ లోపల n');
తిరిగి 0;
}
ఇక్కడ, ప్రక్రియ పంపండి SIGUSR1 ఉపయోగించి స్వయంగా సిగ్నల్ చంపండి () ఫంక్షన్ గెట్‌పిడ్ () దాని యొక్క ప్రాసెస్ ID ని పొందడానికి ఉపయోగించబడుతుంది.
తదుపరి ఉదాహరణలో తల్లిదండ్రులు మరియు పిల్లల ప్రక్రియలు ఎలా కమ్యూనికేట్ చేస్తాయో (ఇంటర్ ప్రాసెస్ కమ్యూనికేషన్) చూద్దాం చంపండి () మరియు సిగ్నల్ ఫంక్షన్.
సిగ్నల్స్ తో పేరెంట్ చైల్డ్ కమ్యూనికేషన్
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
శూన్యంsig_handler_parent(intసంతకం){
printf ('తల్లిదండ్రులు: పిల్లల నుండి ప్రతిస్పందన సంకేతాన్ని అందుకున్నారు n');
}
శూన్యంsig_handler_ చైల్డ్(intసంతకం){
printf (చైల్డ్: పేరెంట్ నుండి సిగ్నల్ వచ్చింది n');
నిద్ర(1);
చంపండి(getppid(),SIGUSR1);
}
intప్రధాన(){
pid_t పిడ్;
ఉంటే((పిడ్=ఫోర్క్())<0){
printf ('ఫోర్క్ విఫలమైంది n');
బయటకి దారి (1);
}
/ * పిల్లల ప్రక్రియ */
లేకపోతే ఉంటే(పిడ్==0){
సంకేతం(SIGUSR1,sig_handler_ చైల్డ్); // సిగ్నల్ హ్యాండ్లర్‌ని నమోదు చేయండి
printf ('పిల్ల: సిగ్నల్ కోసం వేచి ఉంది n');
పాజ్();
}
/ * తల్లిదండ్రుల ప్రక్రియ */
లేకపోతే{
సంకేతం(SIGUSR1,sig_handler_parent); // సిగ్నల్ హ్యాండ్లర్‌ని నమోదు చేయండి
నిద్ర(1);
printf ('పేరెంట్: చైల్డ్‌కు సిగ్నల్ పంపుతోంది n');
చంపండి(పిడ్,SIGUSR1);
printf ('తల్లిదండ్రులు: ప్రతిస్పందన కోసం వేచి ఉంది n');
పాజ్();
}
తిరిగి 0;
}
ఇక్కడ, ఫోర్క్ () ఫంక్షన్ పిల్లల ప్రక్రియను సృష్టిస్తుంది మరియు సున్నా చైల్డ్ ప్రాసెస్‌కు మరియు పిల్లల ప్రాసెస్ ఐడిని పేరెంట్ ప్రాసెస్‌కు తిరిగి ఇస్తుంది. కాబట్టి, తల్లిదండ్రులు మరియు పిల్లల ప్రక్రియను నిర్ణయించడానికి పిడ్ తనిఖీ చేయబడింది. మాతృ ప్రక్రియలో, ఇది 1 సెకను పాటు నిద్రపోతుంది, తద్వారా పిల్లల ప్రక్రియ సిగ్నల్ హ్యాండ్లర్ ఫంక్షన్‌ను నమోదు చేయవచ్చు మరియు తల్లిదండ్రుల నుండి సిగ్నల్ కోసం వేచి ఉంటుంది. 1 సెకను తర్వాత మాతృ ప్రక్రియ పంపండి SIGUSR1 పిల్లల ప్రక్రియకు సిగ్నల్ మరియు పిల్లల నుండి ప్రతిస్పందన సిగ్నల్ కోసం వేచి ఉండండి. పిల్లల ప్రక్రియలో, మొదట అది పేరెంట్ నుండి సిగ్నల్ కోసం వేచి ఉంది మరియు సిగ్నల్ అందుకున్నప్పుడు, హ్యాండ్లర్ ఫంక్షన్ ప్రారంభించబడుతుంది. హ్యాండ్లర్ ఫంక్షన్ నుండి, పిల్లల ప్రక్రియ మరొకటి పంపుతుంది SIGUSR1 తల్లిదండ్రులకు సంకేతం. ఇక్కడ getppid () పేరెంట్ ప్రాసెస్ ID పొందడానికి ఫంక్షన్ ఉపయోగించబడుతుంది.
ముగింపు
లైనక్స్‌లో సిగ్నల్ ఒక పెద్ద అంశం. ఈ ఆర్టికల్లో మనం సిగ్నల్‌ను చాలా ప్రాథమికంగా ఎలా నిర్వహించాలో చూశాము, అలాగే సిగ్నల్ ఎలా ఉత్పత్తి అవుతుందో, ఒక ప్రక్రియ తనకు మరియు ఇతర ప్రక్రియకు ఎలా సిగ్నల్ పంపగలదు, ఇంటర్-ప్రాసెస్ కమ్యూనికేషన్ కోసం సిగ్నల్ ఎలా ఉపయోగపడుతుందో కూడా తెలుసుకున్నాము.