text: // general protection fault in io_uring_setup
  // https://syzkaller.appspot.com/bug?id=06b7d55a62acca161485
  // status:3
  // autogenerated by syzkaller (https://github.com/google/syzkaller)
  
  #define _GNU_SOURCE
  
  #include <dirent.h>
  #include <endian.h>
  #include <errno.h>
  #include <fcntl.h>
  #include <setjmp.h>
  #include <signal.h>
  #include <stdarg.h>
  #include <stdbool.h>
  #include <stdint.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <sys/mman.h>
  #include <sys/prctl.h>
  #include <sys/stat.h>
  #include <sys/syscall.h>
  #include <sys/types.h>
  #include <sys/wait.h>
  #include <time.h>
  #include <unistd.h>
  
  static __thread int skip_segv;
  static __thread jmp_buf segv_env;
  
  static void segv_handler(int sig, siginfo_t* info, void* ctx)
  {
    uintptr_t addr = (uintptr_t)info->si_addr;
    const uintptr_t prog_start = 1 << 20;
    const uintptr_t prog_end = 100 << 20;
    int skip = __atomic_load_n(&skip_segv, __ATOMIC_RELAXED) != 0;
    int valid = addr < prog_start || addr > prog_end;
    if (skip && valid) {
      _longjmp(segv_env, 1);
    }
    exit(sig);
  }
  
  static void install_segv_handler(void)
  {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = SIG_IGN;
    syscall(SYS_rt_sigaction, 0x20, &sa, NULL, 8);
    syscall(SYS_rt_sigaction, 0x21, &sa, NULL, 8);
    memset(&sa, 0, sizeof(sa));
    sa.sa_sigaction = segv_handler;
    sa.sa_flags = SA_NODEFER | SA_SIGINFO;
    sigaction(SIGSEGV, &sa, NULL);
    sigaction(SIGBUS, &sa, NULL);
  }
  
  #define NONFAILING(...)                                                        \
    ({                                                                           \
      int ok = 1;                                                                \
      __atomic_fetch_add(&skip_segv, 1, __ATOMIC_SEQ_CST);                       \
      if (_setjmp(segv_env) == 0) {                                              \
        __VA_ARGS__;                                                             \
      } else                                                                     \
        ok = 0;                                                                  \
      __atomic_fetch_sub(&skip_segv, 1, __ATOMIC_SEQ_CST);                       \
      ok;                                                                        \
    })
  
  static void sleep_ms(uint64_t ms)
  {
    usleep(ms * 1000);
  }
  
  static uint64_t current_time_ms(void)
  {
    struct timespec ts;
    if (clock_gettime(CLOCK_MONOTONIC, &ts))
      exit(1);
    return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
  }
  
  static bool write_file(const char* file, const char* what, ...)
  {
    char buf[1024];
    va_list args;
    va_start(args, what);
    vsnprintf(buf, sizeof(buf), what, args);
    va_end(args);
    buf[sizeof(buf) - 1] = 0;
    int len = strlen(buf);
    int fd = open(file, O_WRONLY | O_CLOEXEC);
    if (fd == -1)
      return false;
    if (write(fd, buf, len) != len) {
      int err = errno;
      close(fd);
      errno = err;
      return false;
    }
    close(fd);
    return true;
  }
  
  #define SIZEOF_IO_URING_SQE 64
  #define SIZEOF_IO_URING_CQE 16
  #define SQ_HEAD_OFFSET 0
  #define SQ_TAIL_OFFSET 64
  #define SQ_RING_MASK_OFFSET 256
  #define SQ_RING_ENTRIES_OFFSET 264
  #define SQ_FLAGS_OFFSET 276
  #define SQ_DROPPED_OFFSET 272
  #define CQ_HEAD_OFFSET 128
  #define CQ_TAIL_OFFSET 192
  #define CQ_RING_MASK_OFFSET 260
  #define CQ_RING_ENTRIES_OFFSET 268
  #define CQ_RING_OVERFLOW_OFFSET 284
  #define CQ_FLAGS_OFFSET 280
  #define CQ_CQES_OFFSET 320
  
  struct io_sqring_offsets {
    uint32_t head;
    uint32_t tail;
    uint32_t ring_mask;
    uint32_t ring_entries;
    uint32_t flags;
    uint32_t dropped;
    uint32_t array;
    uint32_t resv1;
    uint64_t resv2;
  };
  
  struct io_cqring_offsets {
    uint32_t head;
    uint32_t tail;
    uint32_t ring_mask;
    uint32_t ring_entries;
    uint32_t overflow;
    uint32_t cqes;
    uint64_t resv[2];
  };
  
  struct io_uring_params {
    uint32_t sq_entries;
    uint32_t cq_entries;
    uint32_t flags;
    uint32_t sq_thread_cpu;
    uint32_t sq_thread_idle;
    uint32_t features;
    uint32_t resv[4];
    struct io_sqring_offsets sq_off;
    struct io_cqring_offsets cq_off;
  };
  
  #define IORING_OFF_SQ_RING 0
  #define IORING_OFF_SQES 0x10000000ULL
  
  #define sys_io_uring_setup 425
  static long syz_io_uring_setup(volatile long a0, volatile long a1,
                                 volatile long a2, volatile long a3,
                                 volatile long a4, volatile long a5)
  {
    uint32_t entries = (uint32_t)a0;
    struct io_uring_params* setup_params = (struct io_uring_params*)a1;
    void* vma1 = (void*)a2;
    void* vma2 = (void*)a3;
    void** ring_ptr_out = (void**)a4;
    void** sqes_ptr_out = (void**)a5;
    uint32_t fd_io_uring = syscall(sys_io_uring_setup, entries, setup_params);
    uint32_t sq_ring_sz =
        setup_params->sq_off.array + setup_params->sq_entries * sizeof(uint32_t);
    uint32_t cq_ring_sz = setup_params->cq_off.cqes +
                          setup_params->cq_entries * SIZEOF_IO_URING_CQE;
    uint32_t ring_sz = sq_ring_sz > cq_ring_sz ? sq_ring_sz : cq_ring_sz;
    *ring_ptr_out = mmap(vma1, ring_sz, PROT_READ | PROT_WRITE,
                         MAP_SHARED | MAP_POPULATE | MAP_FIXED, fd_io_uring,
                         IORING_OFF_SQ_RING);
    uint32_t sqes_sz = setup_params->sq_entries * SIZEOF_IO_URING_SQE;
    *sqes_ptr_out =
        mmap(vma2, sqes_sz, PROT_READ | PROT_WRITE,
             MAP_SHARED | MAP_POPULATE | MAP_FIXED, fd_io_uring, IORING_OFF_SQES);
    return fd_io_uring;
  }
  
  static int inject_fault(int nth)
  {
    int fd;
    fd = open("/proc/thread-self/fail-nth", O_RDWR);
    if (fd == -1)
      exit(1);
    char buf[16];
    sprintf(buf, "%d", nth + 1);
    if (write(fd, buf, strlen(buf)) != (ssize_t)strlen(buf))
      exit(1);
    return fd;
  }
  
  static void kill_and_wait(int pid, int* status)
  {
    kill(-pid, SIGKILL);
    kill(pid, SIGKILL);
    for (int i = 0; i < 100; i++) {
      if (waitpid(-1, status, WNOHANG | __WALL) == pid)
        return;
      usleep(1000);
    }
    DIR* dir = opendir("/sys/fs/fuse/connections");
    if (dir) {
      for (;;) {
        struct dirent* ent = readdir(dir);
        if (!ent)
          break;
        if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
          continue;
        char abort[300];
        snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
                 ent->d_name);
        int fd = open(abort, O_WRONLY);
        if (fd == -1) {
          continue;
        }
        if (write(fd, abort, 1) < 0) {
        }
        close(fd);
      }
      closedir(dir);
    } else {
    }
    while (waitpid(-1, status, __WALL) != pid) {
    }
  }
  
  static void setup_test()
  {
    prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
    setpgrp();
    write_file("/proc/self/oom_score_adj", "1000");
  }
  
  static void setup_fault()
  {
    static struct {
      const char* file;
      const char* val;
      bool fatal;
    } files[] = {
        {"/sys/kernel/debug/failslab/ignore-gfp-wait", "N", true},
        {"/sys/kernel/debug/fail_futex/ignore-private", "N", false},
        {"/sys/kernel/debug/fail_page_alloc/ignore-gfp-highmem", "N", false},
        {"/sys/kernel/debug/fail_page_alloc/ignore-gfp-wait", "N", false},
        {"/sys/kernel/debug/fail_page_alloc/min-order", "0", false},
    };
    unsigned i;
    for (i = 0; i < sizeof(files) / sizeof(files[0]); i++) {
      if (!write_file(files[i].file, files[i].val)) {
        if (files[i].fatal)
          exit(1);
      }
    }
  }
  
  static void execute_one(void);
  
  #define WAIT_FLAGS __WALL
  
  static void loop(void)
  {
    int iter = 0;
    for (;; iter++) {
      int pid = fork();
      if (pid < 0)
        exit(1);
      if (pid == 0) {
        setup_test();
        execute_one();
        exit(0);
      }
      int status = 0;
      uint64_t start = current_time_ms();
      for (;;) {
        if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
          break;
        sleep_ms(1);
        if (current_time_ms() - start < 5000) {
          continue;
        }
        kill_and_wait(pid, &status);
        break;
      }
    }
  }
  
  void execute_one(void)
  {
    NONFAILING(syz_io_uring_setup(0x17ae, 0, 0x20ffa000, 0x20ff5000, 0, 0));
    NONFAILING(*(uint32_t*)0x20000204 = 0);
    NONFAILING(*(uint32_t*)0x20000208 = 0);
    NONFAILING(*(uint32_t*)0x2000020c = 0);
    NONFAILING(*(uint32_t*)0x20000210 = 0);
    NONFAILING(*(uint32_t*)0x20000218 = -1);
    NONFAILING(*(uint32_t*)0x2000021c = 0);
    NONFAILING(*(uint32_t*)0x20000220 = 0);
    NONFAILING(*(uint32_t*)0x20000224 = 0);
    inject_fault(5);
    NONFAILING(
        syz_io_uring_setup(0x3040, 0x20000200, 0x20ffb000, 0x20ffd000, 0, 0));
  }
  int main(void)
  {
    syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
    inject_fault(5);
    syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
    syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
    setup_fault();
    install_segv_handler();
    loop();
    return 0;
  }
  