Вычисления высокой доступности: как справиться с невозвратным системным вызовом, не рискуя ложными срабатываниями?

Мое второе предложение — использовать ptrace для поиска текущего указателя инструкции. У вас может быть родительский поток, который отслеживает ваш процесс и прерывает его каждую секунду, чтобы проверить текущее значение RIP. Это довольно сложно, поэтому я написал демонстрационную программу: (только для x86_64, но это можно исправить, изменив имена регистров.)

#define _GNU_SOURCE
#include <unistd.h>
#include <sched.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/syscall.h>
#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <linux/ptrace.h>
#include <sys/user.h>
#include <time.h>

// this number is arbitrary - find a better one.
#define STACK_SIZE (1024 * 1024)

int main_thread(void *ptr) {
    // "main" thread is now running under the monitor
    printf("Hello from main!");
    while (1) {
        int c = getchar();
        if (c == EOF) { break; }
        nanosleep(&(struct timespec) {0, 200 * 1000 * 1000}, NULL);
        putchar(c);
    }
    return 0;
}

int main(int argc, char *argv[]) {
    void *vstack = malloc(STACK_SIZE);
    pid_t v;
    if (clone(main_thread, vstack + STACK_SIZE, CLONE_PARENT_SETTID | CLONE_FILES | CLONE_FS | CLONE_IO, NULL, &v) == -1) { // you'll want to check these flags
        perror("failed to spawn child task");
        return 3;
    }
    printf("Target: %d; %d\n", v, getpid());
    long ptv = ptrace(PTRACE_SEIZE, v, NULL, NULL);
    if (ptv == -1) {
        perror("failed monitor sieze");
        exit(1);
    }
    struct user_regs_struct regs;
    fprintf(stderr, "beginning monitor...\n");
    while (1) {
        sleep(1);
        long ptv = ptrace(PTRACE_INTERRUPT, v, NULL, NULL);
        if (ptv == -1) {
            perror("failed to interrupt main thread");
            break;
        }
        int status;
        if (waitpid(v, &status, __WCLONE) == -1) {
            perror("target wait failed");
            break;
        }
        if (!WIFSTOPPED(status)) { // this section is messy. do it better.
            fputs("target wait went wrong", stderr);
            break;
        }
        if ((status >> 8) != (SIGTRAP | PTRACE_EVENT_STOP << 8)) {
            fputs("target wait went wrong (2)", stderr);
            break;
        }
        ptv = ptrace(PTRACE_GETREGS, v, NULL, &regs);
        if (ptv == -1) {
            perror("failed to peek at registers of thread");
            break;
        }
        fprintf(stderr, "%d -> RIP %x RSP %x\n", time(NULL), regs.rip, regs.rsp);
        ptv = ptrace(PTRACE_CONT, v, NULL, NULL);
        if (ptv == -1) {
            perror("failed to resume main thread");
            break;
        }
    }
    return 2;
}

Обратите внимание, что это не код производственного качества. Вам нужно будет сделать кучу ремонтных работ.

Основываясь на этом, вы должны быть в состоянии выяснить, продвигается ли счетчик программ, и можете объединить это с другими частями информации (например, /proc/PID/status), чтобы определить, занят ли он в системном вызове. Вы также можете расширить использование ptrace, чтобы проверить, какие системные вызовы используются, чтобы вы могли проверить, разумно ли ждать.

Это хакерское решение, но я не думаю, что вы найдете нехакерское решение этой проблемы. Несмотря на хакерство, я не думаю (это не проверено), что это будет особенно медленно; моя реализация приостанавливает отслеживаемый поток один раз в секунду на очень короткое время, которое, как я полагаю, будет в диапазоне сотен микросекунд. Теоретически это около 0,01% потери эффективности.

Я думаю, вам нужен общий маркер активности.

Пусть основной поток (или, в более общем случае, все рабочие потоки) обновляет общий маркер активности текущим временем (или тактом часов, например, путем вычисления «текущей» наносекунды из clock_gettime(CLOCK_MONOTONIC, ...)), а поток сердцебиения периодически проверяет, когда этот маркер активности обновлялся в последний раз, отменяя себя (и, таким образом, останавливая широковещательную передачу пульса), если в течение разумного времени не было никакого обновления активности.

Эту схему можно легко расширить с помощью флага состояния, если рабочая нагрузка очень спорадическая. Основной рабочий поток устанавливает флаг и обновляет маркер активности, когда он начинает единицу работы, и очищает флаг, когда работа завершена. Если работа не выполняется, пульсация отправляется без проверки маркера активности. Если работа выполняется, пульсация останавливается, если время, прошедшее с момента обновления маркера активности, превышает максимальное время обработки, разрешенное для единицы работы. (Каждый из нескольких рабочих потоков в этом случае нуждается в собственном маркере активности и флаге, а поток пульса можно спроектировать таким образом, чтобы он останавливался, когда какой-либо один рабочий поток застревает или только когда застревают все рабочие потоки, в зависимости от их целей и важности для системы. общая система).

(Значение маркера активности (и рабочий флаг), конечно, должно быть защищено мьютексом, который должен быть получен перед чтением или записью значения.)

Возможно, поток сердцебиения также может привести к самоубийству всего процесса (например, kill(getpid(), SIGQUIT)), чтобы его можно было перезапустить, вызывая его в цикле в сценарии-оболочке, особенно если перезапуск процесса очищает условие в ядре, которое может вызвать проблема в первую очередь.

Одним из возможных способов может быть другой набор сообщений пульса от основного потока к потоку пульса. Если он перестает получать сообщения в течение определенного периода времени, он также прекращает их отправку. (И можно попробовать другое восстановление, например, перезапустить процесс.)

Чтобы решить проблему с основным потоком, фактически просто находящимся в длительном сне, установите (правильно синхронизированный) флаг, который устанавливает поток пульса, когда он решил, что основной поток, должно быть, потерпел неудачу - и основной поток должен проверить этот флаг в подходящее время (например, после потенциального ожидания), чтобы убедиться, что он не был зарегистрирован как мертвый. Если это так, он перестает работать, потому что его работа уже была занята другим узлом.

Основной поток также может отправлять события I-am-alive потоку пульса в другое время, а не только один раз в цикле, например, если он переходит к длительной операции. Без этого невозможно определить разницу между неисправным основным потоком и спящим основным потоком.