Linux--Signal

1. Signal
Signal wird verwendet, um den Prozess darüber zu informieren, dass ein asynchrones Ereignis aufgetreten ist. Der Kernel kann aufgrund interner Ereignisse auch Signale an den Prozess senden und den Prozess darüber informieren, dass ein Ereignis aufgetreten ist. Beachten Sie, dass Signale nur dazu verwendet werden, einen Prozess darüber zu informieren, welche Ereignisse eingetreten sind, und keine Daten an den Prozess weitergeben.

**Verwenden Sie den Befehl kill-l, um die systemdefinierte Signalliste anzuzeigen

2. Wie Signale generiert werden
① Senden Sie ein Signal in den Vordergrund über eine Tastaturkombinationstaste ( (Hinzufügen & nach einem Befehl) Kann zur Ausführung an den Hintergrund gesendet werden)

a. Die Standardaktion von SIGQUIT besteht darin, den Prozess und Core Dump zu beenden. Wenn der Prozess abnormal beendet wird, können Sie festlegen, dass alle Speicherdaten auf der Festplatte gespeichert werden. Dies wird normalerweise als Core-Dump bezeichnet (ein Fehler. Sie können die Kerndatei mit einem Debugger überprüfen, um die Ursache des Fehlers herauszufinden.) Standardmäßig dürfen Kerndateien nicht generiert werden, da die Kerndatei möglicherweise Benutzerkennwörter enthält, was für Sie nicht sicher ist Mit dem Befehl ulimit können Sie diesen Grenzwert während der Entwicklung und beim Debuggen ändern, um die Generierung von Kerndateien zu ermöglichen.
Verwenden Sie den Befehl ulimit -c 1024

Der Befehl ulimit ändert das Ressourcenlimit des Shell-Prozesses. Die Leiterplatte des Testprozesses wird vom Shell-Prozess kopiert, sodass sie auch den gleichen Ressourcenlimitwert hat B. der Shell-Prozess. Auf diese Weise kann ein Core Dump generiert werden.
② Senden Sie ein Signal an den Prozess, indem Sie die Systemfunktion aufrufen.

Ein Kill-Befehl wird durch Aufruf der Kill-Funktion implementiert. Die Kill-Funktion kann ein bestimmtes Signal an einen bestimmten Prozess senden (ein Signal an sich selbst senden
int kill(pid_t pid, int signo);
int). raise( int signo);
alle geben 0 bei Erfolg und -1 bei Fehler zurück; die

abort-Funktion bewirkt, dass der aktuelle Prozess das SIGABRT-Signal empfängt und abnormal beendet wird.
void abort(void);

Wie die Exit-Funktion ist auch die Abort-Funktion immer erfolgreich, daher gibt es keinen Rückgabewert.

③ Durch Softwarebedingungen erzeugte Signale

a.alarm-Funktion und SIGALRM-Signal
unsigned int alarm (unsigned int seconds); Durch Aufrufen der Alarmfunktion kann ein Wecker eingestellt werden Teilen Sie dem Kernel mit, dass er nach Sekunden ein SIGALRM-Signal an den aktuellen Prozess senden soll. Der Rückgabewert der Funktion ist 0 oder die Anzahl der verbleibenden Sekunden in der zuvor eingestellten Alarmzeit.
3. So gehen Sie mit Signalen um
① Ignorieren Sie dieses Signal

② Führen Sie die Standardverarbeitungsaktion des Signals aus und beenden Sie normalerweise den Prozess

③ Erfassen Sie das Signal

IV, Signalzustellung und -blockierung
①, Blockierung

Der eigentliche Verarbeitungsvorgang der Signalausführung wird als Signalzustellung (Delivery) bezeichnet, und der Zustand zwischen Signalgenerierung und -zustellung wird als Signal ausstehend (Pending) bezeichnet ). Ein Prozess kann sich dafür entscheiden, ein Signal zu blockieren. Das blockierte Signal bleibt beim Generieren im Status „Ausstehend“ und die Übermittlungsaktion wird erst ausgeführt, wenn der Prozess die Blockierung des Signals aufhebt. Blockieren und Ignorieren sind unterschiedlich. Solange das Signal blockiert ist, wird es nicht zugestellt, während Ignorieren eine optionale Verarbeitungsaktion nach der Zustellung ist.
Darstellung von Signalen im Kernel

Jedes Signal verfügt über zwei Flag-Bits, die Blockierung und Ausstehen anzeigen, und es gibt auch eine Funktion. Zeiger repräsentieren Verarbeitungsaktionen. Wenn ein Signal generiert wird, setzt der Kernel das Warte-Flag des Signals im Prozesssteuerungsblock und löscht das Flag erst, wenn das Signal geliefert wird
Wenn dieses Signal mehrmals generiert wird, bevor der Prozess ein Signal entsperrt, in Reguläre Linux-Signale, die vor der Zustellung mehrmals generiert werden, werden nur einmal gezählt, während Echtzeitsignale, die vor der Zustellung mehrmals generiert werden, nacheinander in eine Warteschlange gestellt werden können. Jedes Signal hat nur ein Bit des ausstehenden Flags, das entweder 0 oder 1 ist. Es wird nicht aufgezeichnet, wie oft das Signal generiert wurde. Das Blockierungsflag wird auch auf diese Weise ausgedrückt. (Leer ist ein Zustand, ausstehend zeigt Anwesenheit oder Abwesenheit an) Ausstehende und blockierende Flags können mit demselben Datentyp gespeichert werden. sigset_t wird als Signalsatz bezeichnet, und ein blockierender Signalsatz wird auch als Signalmaske des aktuellen Prozesses bezeichnet. Der „Schutzschild“ sollte hier als Blockieren und nicht als Ignorieren verstanden werden.
②, Signalsatz-Betriebsfunktion

#include <signal.h>
int sigemptyset(sigset_t *set);//初始化对应的信号集bit位为0
int sigfillset(sigset_t *set);//初始化对象的信号集bit位为1
int sigaddset(sigset_t *set, int signo);//添加有效信号 
int sigdelset(sigset_t *set, int signo);//删除有效信号
int sigismember(const sigset_t *set, int signo);//判断一个信号集的有效信号中是否包含某种信号，包含返回1，不包含返回0。

③, sigprocmask

Rufen Sie die Funktion sigprocmask auf, um das Signalmaskenwort (Blockierungssignalsatz) des Prozesses zu lesen oder zu ändern.
int sigprocmask(int how, const sigset_t *set, sigset_t *oset); 0 bei Erfolg, -1 bei Fehler;
Wenn der Aufruf von sigprocmask mehrere aktuell ausstehende Signale entsperrt, dann mindestens eines der Signale müssen geliefert werden.
Die Bedeutung des How-Parameters

SIG_BLOCK-Set enthält die Signale, die wir zur aktuellen Signalmaske hinzufügen möchten, und

SIG_UNBLOCK-Set enthält Wir hoffen, dass dies der Fall ist Entsperren Sie das im Wort blockierte Signal vom aktuellen Signal.

SIG_SETMASK setzt das aktuelle Signalmaskierungswort auf den Wert, auf den durch set,

④, sigpending
int sigpending(sigset_t * set );
sigpending liest den ausstehenden Signalsatz des aktuellen Prozesses und sendet ihn über den eingestellten Parameter aus. Wenn der Aufruf erfolgreich ist, wird 0 zurückgegeben, wenn ein Fehler auftritt, wird -1 zurückgegeben.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Anleitung mit dem Programm

#include<stdio.h>  
  2 #include<unistd.h>  
  3 #include<signal.h>  
  4 void printsigset(sigset_t* sig)  
  5 {  
  6     int i=0;  
  7     for(;i<31;i++)  
  8     {  
  9         if(sigismember(sig,i))//判断指定信号是否在目标集合中  
 10         {  
 11             printf("1");  
 12         }  
 13         else  
 14         {  
 15             printf("0");  
 16         }  
 17     }  
 18     printf("\n");  
 19 }  
 20 int main()  
 21 {  
 22     sigset_t s,p;//定义信号集  
 23     sigemptyset(&s);//初始化  
 24     sigemptyset(&p);  
 25     sigaddset(&s,SIGINT);//设置信号ctrl+C  
 26     sigprocmask(SIG_BLOCK,&s,NULL);//设置阻塞信号集，阻塞 SIGINT信号  
 27     while(1)  
 28     {  
 29         sigpending(&p);//获取未决信号集  
 30         printsigset(&p);  
 31         sleep(1);  
 32     }  
 33     return 0;  
 34 }

结果分析：
程序运行时,每秒钟把各信号的未决状态打印一遍,直到按Ctrl-C将会使SIGINT信号处于未决状态,
五、捕捉信号
a.内核如何实现信号的捕捉

如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号，处理过程如下，举例来说明
1. 用户程序注册了SIGQUIT信号的处理函数sighandler。
2. 当前正在执行main函数,这时发生中断或异常切换到内核态。
3. 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。
4. 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函 数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是两个独立的控制流程。
5. sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。
6. 如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了
**（先从用户态―>内核态->返回用户态之前检查有信号递达，返回用户态处理信号->处理完成后再进入内核态->如果没有新的信号递达，返回用户态恢复上下文继续执行）
b.sigaction 
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);
sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回- 1
将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函 数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。
当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么它会被阻塞到当前处理结束为止。 
如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。
c.pause
int pause(void); 
pause函数使调用进程挂起直到有信号递达。如果信号的处理动作是终止进程,则进程终止,pause函数没有机会返回;如果信号的处理动作是忽略,则进程继续处于挂起状态,pause不返回;如果信号的处理动作是捕捉,则调用了信号处理函数之后pause返回-1,
用alarm和pause实现sleep(3)的函数

1 #include<stdio.h>  
 2 #include<unistd.h>  
 3 #include<signal.h>  
 4 void sig_alarm(int signo)  
 5 {  
 6        //do nothing  
 7 }  
 8 unsigned int  my_sleep(unsigned int times)  
 9 {  
 10     struct sigaction new ,old;  
 11     unsigned int unslept=0;  
 12     new.sa_handler=sig_alarm;  
 13     sigemptyset(&new.sa_mask);  
 14     sigemptyset(&old.sa_mask);  
 15     new.sa_flags=0;  
 16     sigaction(SIGALRM,&new,&old);//注册信号处理函数  
 17     alarm(times); //设置闹钟  
 18     pause();  
 19     unslept=alarm(0);//取消闹钟  
 20     sigaction(SIGALRM,&old,NULL);//恢复默认信号处理动作  
 21     return unslept;  
 22 }  
 23 int main()  
 24 {  
 25     while(1)  
 26     {  
 27         my_sleep(5);  
 28         printf("5 senconds pass\n");  
 29     }  
 30     return 0;  
 31 }

六、可重入函数 
当捕捉到信号时,不论进程的主控制流程当前执行到哪儿,都会先跳到信号处理函数中执行,从信号处理函数返回后再继续执行主控制流程。信号处理函数是一个单独的控制流程,因为它和主控制流程是异步的,二者不存在调用和被调用的关系,并且使用不同的堆栈空间。引入了信号处理函数使得一个进程具有多个控制流程,如果这些控制流程访问相同的全局资源(全局变量、硬件资源等),就有可能出现冲突。

以上就是Linux--信号的内容，更多相关内容请关注PHP中文网（www.php.cn）！