Recv() не прерывается сигналом в многопоточной среде

У меня есть поток, который находится в блокирующем цикле recv(), и я хочу закончить (предположим, что это не может быть изменено на select() или любой другой асинхронный подход).

У меня также есть обработчик сигнала, который ловит SIGINT, и теоретически он должен сделать return recv() с ошибкой и errno установлен на EINTR.

Но это не так, я полагаю, имеет какое-то отношение к тому, что приложение многопоточное. Существует еще один поток, который, тем временем, ждет вызова pthread_join().

Что здесь происходит?

EDIT:

ОК, теперь я явно доставляю сигнал для всех блокирующих потоков recv() через pthread_kill() из основного потока (который приводит к тому же глобальному обработчику сигналов SIGINT, хотя множественные вызовы являются доброкачественными). Но вызов recv() по-прежнему не разблокирован.

EDIT:

Я написал образец кода, который воспроизводит проблему.

  • Основной поток подключает сокет к ошибочному удалённому хосту, который не позволит подключиться.
  • Все сигналы заблокированы.
  • Запустится поток потоков.
  • Основной разблокирует и устанавливает обработчик для SIGINT.
  • Чтение потока разблокирует и устанавливает обработчик для SIGUSR1.
  • Обработчик сигнала основного потока отправляет SIGUSR1 в прочитанный поток.

Интересно, что если я заменил recv() на sleep(), он будет прерван просто отлично.

PS

В качестве альтернативы вы можете просто открыть UDP-сокет вместо использования сервера.

клиент

#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>

static void
err(const char *msg)
{
    perror(msg);
    abort();
}

static void
blockall()
{
    sigset_t ss;
    sigfillset(&ss);
    if (pthread_sigmask(SIG_BLOCK, &ss, NULL))
        err("pthread_sigmask");
}

static void
unblock(int signum)
{
    sigset_t ss;
    sigemptyset(&ss);
    sigaddset(&ss, signum);
    if (pthread_sigmask(SIG_UNBLOCK, &ss, NULL))
        err("pthread_sigmask");
}

void
sigusr1(int signum)
{
    (void)signum;
    printf("%lu: SIGUSR1\n", pthread_self());
}

void*
read_thread(void *arg)
{
    int sock, r;
    char buf[100];

    unblock(SIGUSR1);
    signal(SIGUSR1, &sigusr1);
    sock = *(int*)arg;
    printf("Thread (self=%lu, sock=%d)\n", pthread_self(), sock);
    r = 1;
    while (r > 0)
    {
        r = recv(sock, buf, sizeof buf, 0);
        printf("recv=%d\n", r);
    }
    if (r < 0)
        perror("recv");
    return NULL;
}

int sock;
pthread_t t;

void
sigint(int signum)
{
    int r;
    (void)signum;
    printf("%lu: SIGINT\n", pthread_self());
    printf("Killing %lu\n", t);
    r = pthread_kill(t, SIGUSR1);
    if (r)
    {
        printf("%s\n", strerror(r));
        abort();
    }
}

int
main()
{
    pthread_attr_t attr;
    struct sockaddr_in addr;

    printf("main thread: %lu\n", pthread_self());
    memset(&addr, 0, sizeof addr);
    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socket < 0)
        err("socket");
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8888);
    if (inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) <= 0)
        err("inet_pton");
    if (connect(sock, (struct sockaddr *)&addr, sizeof addr))
        err("connect");

    blockall();
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    if (pthread_create(&t, &attr, &read_thread, &sock))
        err("pthread_create");
    pthread_attr_destroy(&attr);
    unblock(SIGINT);
    signal(SIGINT, &sigint);

    if (sleep(1000))
        perror("sleep");
    if (pthread_join(t, NULL))
        err("pthread_join");
    if (close(sock))
        err("close");

    return 0;
}

сервер

import socket
import time

s = socket.socket(socket.AF_INET)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('127.0.0.1',8888))
s.listen(1)
c = []
while True:
    (conn, addr) =  s.accept()
    c.append(conn)

Ответы

Ответ 1

Обычно сигналы не прерывают системные вызовы с помощью EINTR. Исторически сложилось два возможных поведения доставки сигнала: поведение BSD (syscalls автоматически перезапускается, когда прерывается сигналом) и поведение системы Unix System V (syscalls возвращает -1 с errno, установленным на EINTR при прерванном сигнале). Linux (ядро) принял последний, но разработчики библиотеки GNU C (правильно) считали поведение BSD более разумным, и поэтому на современных Linux-системах вызов signal (который является библиотечной функцией) приводит к тому, что BSD поведение.

POSIX допускает любое поведение, поэтому рекомендуется всегда использовать sigaction, где вы можете установить флаг SA_RESTART или опустить его в зависимости от поведения, которое вы хотите. См. Документацию для sigaction здесь:

http://www.opengroup.org/onlinepubs/9699919799/functions/sigaction.html

Ответ 2

В многопоточном приложении нормальные сигналы могут быть доставлены на любой поток произвольно. Используйте pthread_kill для отправки сигнала в интересующий вас поток.

Ответ 3

Вызывается ли обработчик сигнала в том же потоке, который ждет в recv()? Возможно, вам придется явно маскировать SIGINT во всех других потоках через pthread_sigmask()

Ответ 4

Как упоминалось в сообщении на <R.. > , действительно возможно изменить действия сигнала. Я часто создаю свою собственную "сигнальную" функцию, которая использует sigaction. Здесь я использую

typedef void Sigfunc(int);

static Sigfunc* 
_signal(int signum, Sigfunc* func)
{
    struct sigaction act, oact;

    act.sa_handler = func;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;

    if (signum != SIGALRM)
        act.sa_flags |= SA_NODEFER; //SA_RESTART;

    if (sigaction(signum, &act, &oact) < 0)
        return (SIG_ERR);
    return oact.sa_handler;
}

код >

Атрибут, о котором идет речь, является полем or'ing of sa_flags. Это с man-страницы для 'sigaction': SA_RESTART обеспечивает поведение, подобное BSD, позволяющее перезапускать системные вызовы через сигналы. SA_NODEFER означает, что сигнал принимается из собственного обработчика сигнала.

Когда сигнальные вызовы заменяются на "_signal", поток прерывается. На выходе выводится "прерванный системный вызов", а recv возвращает -1, когда SIGUSR1 был отправлен. Программа полностью остановилась с тем же выходом, когда SIGINT был отправлен, но прервал вызов в конце.

Я не писал серверную часть кода, я просто изменил тип сокета на "DGRAM, UDP", чтобы клиент мог начать.

Ответ 5

Вы можете установить тайм-аут в Linux recv: Linux: есть ли чтение или recv из сокета с таймаутом?

Когда вы получаете сигнал, вызов выполняется в классе, выполняющем получение.

void* signalThread( void* ptr )
{
    CapturePkts* cap=(CapturePkts*)ptr;
    sigset_t sigSet=cap->getSigSet();
    int sig=-1;
    sigwait(&sigSet,&sig); //signalThread: signal capture thread enabled;
    cout << "signal=" << sig << " caught,ending process" << endl;
    cap->setDone();
    return 0;
}

class CapturePkts
{
     CapturePkts() : _done(false) {}

     sigset_t getSigSet() { return _sigSet; }

     void setDone() {_done=true;}

     bool receive( uint8_t *buffer, int32_t bufSz, int32_t &nbytes)
     {
         bool ret=true;
         while( ! _done ) {
         nbytes = ::recv( _sockid, buffer, bufSz, 0 );
         if(nbytes < 1 ) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
               nbytes=0; //wait for next read event
            else
               ret=false;
         }
         return ret;
     }

     private:
     sigset_t _sigSet;
     bool _done;
};