sysbox-fs closes a container's seccomp listener on a transient POLLERR, so mount/umount fail with ENOSYS

// End-to-end reproduction of the sysbox-fs 0.7.1 listener loss.
// A tracee traps getppid() to a seccomp user-notification listener; the
// supervisor runs sysbox-fs's connHandler loop (tracer.go) under notify_lock
// contention while its polling thread takes signals.
//   loop=orig:    any revents other than POLLIN ends the loop and closes the
//                 listener (sysbox-fs 0.7.1 and master).
//   loop=patched: a lone POLLERR polls again.
// The tracee reports the first getppid() that fails with ENOSYS, the error a
// system container's processes get from mount() once its listener is closed.
//
// usage: chain <orig|patched> <seconds> <signal-interval-us>
#define _GNU_SOURCE
#include <errno.h>
#include <linux/filter.h>
#include <linux/seccomp.h>
#include <poll.h>
#include <pthread.h>
#include <signal.h>
#include <stdatomic.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

static int listener, report_fd, patched;
static atomic_int stop, loop_ended;
static atomic_long n_pollerr;
static pthread_t poller;

static void on_sig(int s) { (void)s; }

static void send_fd(int sock, int fd) {
    char c = 0;
    struct iovec iov = {&c, 1};
    char buf[CMSG_SPACE(sizeof(int))];
    struct msghdr m = {.msg_iov = &iov, .msg_iovlen = 1, .msg_control = buf, .msg_controllen = sizeof buf};
    struct cmsghdr *h = CMSG_FIRSTHDR(&m);
    h->cmsg_level = SOL_SOCKET; h->cmsg_type = SCM_RIGHTS; h->cmsg_len = CMSG_LEN(sizeof(int));
    memcpy(CMSG_DATA(h), &fd, sizeof(int));
    if (sendmsg(sock, &m, 0) < 0) { perror("sendmsg"); exit(1); }
}

static int recv_fd(int sock) {
    char c;
    struct iovec iov = {&c, 1};
    char buf[CMSG_SPACE(sizeof(int))];
    struct msghdr m = {.msg_iov = &iov, .msg_iovlen = 1, .msg_control = buf, .msg_controllen = sizeof buf};
    if (recvmsg(sock, &m, 0) <= 0) { perror("recvmsg"); exit(1); }
    int fd;
    memcpy(&fd, CMSG_DATA(CMSG_FIRSTHDR(&m)), sizeof(int));
    return fd;
}

static void *tracee_loop(void *a) {
    (void)a;
    for (;;) {
        if (syscall(__NR_getppid) < 0 && errno == ENOSYS) {
            if (write(report_fd, "E", 1) != 1) _exit(1);
            pause();
        }
    }
    return NULL;
}

static void tracee(int sock) {
    struct sock_filter f[] = {
        BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr)),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_getppid, 0, 1),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_USER_NOTIF),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
    };
    struct sock_fprog prog = {sizeof f / sizeof f[0], f};
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) { perror("prctl"); exit(1); }
    int fd = syscall(__NR_seccomp, SECCOMP_SET_MODE_FILTER, SECCOMP_FILTER_FLAG_NEW_LISTENER, &prog);
    if (fd < 0) { perror("seccomp"); exit(1); }
    send_fd(sock, fd);
    close(fd);
    for (int i = 0; i < 16; i++) { pthread_t t; pthread_create(&t, NULL, tracee_loop, NULL); }
    pause();
}

// sysbox-fs's process() goroutines: receive and answer.
static void *responder(void *a) {
    (void)a;
    while (!stop && !loop_ended) {
        struct seccomp_notif req; memset(&req, 0, sizeof req);
        if (ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, &req) < 0) continue;
        struct seccomp_notif_resp resp = {.id = req.id, .flags = SECCOMP_USER_NOTIF_FLAG_CONTINUE};
        ioctl(listener, SECCOMP_IOCTL_NOTIF_SEND, &resp);
    }
    return NULL;
}

static void *lock_hammer(void *a) {
    (void)a;
    __u64 id = 1;
    while (!stop && !loop_ended) ioctl(listener, SECCOMP_IOCTL_NOTIF_ID_VALID, &id);
    return NULL;
}

// tracer.go connHandler, seccompUnusedNotif == true.
static void *conn_handler(void *a) {
    (void)a;
    for (;;) {
        struct pollfd p = {listener, POLLIN, 0};
        if (poll(&p, 1, -1) < 0) {
            if (errno == EINTR) { if (stop) return NULL; continue; }
            break;
        }
        if (stop) return NULL;
        if (p.revents == POLLERR) {
            n_pollerr++;
            if (patched) continue;
        }
        if (p.revents != POLLIN) break;
        // NotifReceive + process() are done by the responder threads here.
    }
    loop_ended = 1;
    close(listener); // seccompSessionDelete
    return NULL;
}

int main(int argc, char **argv) {
    if (argc != 4 || (strcmp(argv[1], "orig") && strcmp(argv[1], "patched"))) {
        fprintf(stderr, "usage: %s <orig|patched> <seconds> <signal-interval-us>\n", argv[0]);
        return 2;
    }
    patched = !strcmp(argv[1], "patched");
    int secs = atoi(argv[2]), interval = atoi(argv[3]);
    int sv[2], rp[2];
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) || pipe(rp)) { perror("setup"); return 1; }
    pid_t child = fork();
    if (child == 0) { close(sv[0]); close(rp[0]); report_fd = rp[1]; tracee(sv[1]); _exit(0); }
    close(sv[1]); close(rp[1]);
    listener = recv_fd(sv[0]);

    struct sigaction sa; memset(&sa, 0, sizeof sa);
    sa.sa_handler = on_sig;
    sigaction(SIGUSR1, &sa, NULL);

    pthread_t t;
    for (int i = 0; i < 4; i++) pthread_create(&t, NULL, responder, NULL);
    for (int i = 0; i < 4; i++) pthread_create(&t, NULL, lock_hammer, NULL);
    pthread_create(&poller, NULL, conn_handler, NULL);

    struct timespec start, now; clock_gettime(CLOCK_MONOTONIC, &start);
    double enosys_at = -1;
    long sent = 0;
    for (;;) {
        clock_gettime(CLOCK_MONOTONIC, &now);
        double el = (now.tv_sec - start.tv_sec) + (now.tv_nsec - start.tv_nsec) / 1e9;
        if (el >= secs) break;
        struct pollfd r = {rp[0], POLLIN, 0};
        if (poll(&r, 1, 0) == 1) { enosys_at = el; break; }
        if (!loop_ended) { pthread_kill(poller, SIGUSR1); sent++; }
        usleep(interval);
    }
    stop = 1;
    if (!loop_ended) { pthread_kill(poller, SIGUSR1); pthread_join(poller, NULL); }
    kill(child, SIGKILL);
    waitpid(child, NULL, 0);
    printf("loop=%s signals=%ld POLLERR=%ld listener_closed=%s tracee_ENOSYS=%s",
           argv[1], sent, n_pollerr, loop_ended ? "yes" : "no", enosys_at >= 0 ? "yes" : "no");
    if (enosys_at >= 0) printf(" (after %.2fs)", enosys_at);
    printf("\n");
    return 0;
}