三十三、Linux 进程与信号——中断系统调用和函数可重入性

33.1 中断系统调用

• 进程调用 “慢” 系统调用时，如果发生了信号，内核会重启系统调用。
• 慢系统调用
  • 可能会永久阻塞的系统调用
  • 从终端设备、管道或网络设备上的文件读取
  • 向上述文件写入
  • 某些设备上的文件打开
  • pause 和 wait 系统调用
  • 一些设备的 ioctl 操作
  • 一些进程间通信函数

33.1.1 慢系统调用引起的调用重启

#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>


void sig_handler(int signo)
{
    if(signo == SIGTSTP){
        printf("SIGTSTP occured
");
    }
}

int main(void)
{
    char buffer[512];
    ssize_t size;

    if(signal(SIGTSTP, sig_handler) == SIG_ERR){
        perror("signal sigtstp error");
    }

    printf("begin running and waiting for signal
");
    size = read(STDIN_FILENO, buffer, 512);
    if(size < 0){
        perror("read error");
    }

    printf("reading finished
");

    if(write(STDOUT_FILENO, buffer, size) != size) {
        perror("write error");
    }
    printf("end running
");
    return 0;
}

33.1.2 自定义函数

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

void sig_handler(int signo)
{
    if(signo == SIGTSTP){
        printf("SIGTSTP occured
");
    }
}

void call_fun(void)
{
    printf("begin running call_fun
");
    sleep(10);
    printf("end running call_fun
");
}

int main()
{
    if(signal(SIGTSTP, sig_handler) == SIG_ERR){
        perror("signal sigtstp error");
    }

    printf("begin running main
");
    call_fun();
    printf("end running main
");
}

33.2 函数可重入性

• 在调用某个函数过程中出现信号，且该信号处理函数中再次调用该函数
  • 访问全局或静态变量的函数是不可重入函数
    • 即前后数据不一致
  • 若是函数内部的局部变量，则此函数是可重入函数
    • 即前后数据一致
• 程序片段如下：

　　

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int g_v[10];
int *h_v;    ///< 堆中变量

void set(int val)
{
    int a_v[10];

    int i = 0;
    for(; i < 10; i++) {
        a_v[i] = val;
        g_v[i] = val;
        h_v[i] = val;
        sleep(1);
    }

    printf("g_v:");
    for(i = 0; i < 10; i++){
        if(i != 0) {
            printf(", %d", g_v[i]);
        }
        else {
            printf(", %d", g_v[i]);
        }
    }
    printf("
");

    printf("h_v:");
    for(i = 0; i < 10; i++){
        if(i != 0) {
            printf(", %d", h_v[i]);
        }
        else {
            printf(", %d", h_v[i]);
        }
    }

    printf("
");
    printf("a_v:");
    for(i = 0; i < 10; i++){
        if(i != 0) {
            printf(", %d", a_v[i]);
        }
        else {
            printf(", %d", a_v[i]);
        }
    }
}

void sig_handler(int signo)
{
    if(signo == SIGTSTP){
        printf("SIGTSTP occured
");
        set(20);
        printf("
end SIGTSTP
");
    }
}
int main(void)
{
    if(signal(SIGTSTP, sig_handler) == SIG_ERR){
        perror("signal sigtstp error");
    }

    h_v = (int *)calloc(10, sizeof(int));

    printf("begin running main
");
    set(10);
    printf("
end running main
");
    return 0;
}

　　运行结果：

　　

　　全局变量中的数据不可控，局部变量都为 10

　　第一次调用 set 函数的时候，set(10) 中的循环运行了 2 次，此时 i = 2，然后中断，再次运行set(20) 函数，此时将所有变量中的值覆盖掉了，中断完了之后，函数继续从中断的地方运行，此时中断的地方 i = 2，则全局变量和堆变量从此处开始运行，后面的 20 都被 10 给覆盖。