// https://syzkaller.appspot.com/bug?id=8f0e04b2beffcd42f044d46879cc224f6eb71a99 // autogenerated by syzkaller (https://github.com/google/syzkaller) #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef __NR_bpf #define __NR_bpf 321 #endif static unsigned long long procid; 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 void use_temporary_dir(void) { char tmpdir_template[] = "./syzkaller.XXXXXX"; char* tmpdir = mkdtemp(tmpdir_template); if (!tmpdir) exit(1); if (chmod(tmpdir, 0777)) exit(1); if (chdir(tmpdir)) exit(1); } static void thread_start(void* (*fn)(void*), void* arg) { pthread_t th; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setstacksize(&attr, 128 << 10); int i = 0; for (; i < 100; i++) { if (pthread_create(&th, &attr, fn, arg) == 0) { pthread_attr_destroy(&attr); return; } if (errno == EAGAIN) { usleep(50); continue; } break; } exit(1); } #define BITMASK(bf_off, bf_len) (((1ull << (bf_len)) - 1) << (bf_off)) #define STORE_BY_BITMASK(type, htobe, addr, val, bf_off, bf_len) \ *(type*)(addr) = \ htobe((htobe(*(type*)(addr)) & ~BITMASK((bf_off), (bf_len))) | \ (((type)(val) << (bf_off)) & BITMASK((bf_off), (bf_len)))) typedef struct { int state; } event_t; static void event_init(event_t* ev) { ev->state = 0; } static void event_reset(event_t* ev) { ev->state = 0; } static void event_set(event_t* ev) { if (ev->state) exit(1); __atomic_store_n(&ev->state, 1, __ATOMIC_RELEASE); syscall(SYS_futex, &ev->state, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1000000); } static void event_wait(event_t* ev) { while (!__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE)) syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, 0); } static int event_isset(event_t* ev) { return __atomic_load_n(&ev->state, __ATOMIC_ACQUIRE); } static int event_timedwait(event_t* ev, uint64_t timeout) { uint64_t start = current_time_ms(); uint64_t now = start; for (;;) { uint64_t remain = timeout - (now - start); struct timespec ts; ts.tv_sec = remain / 1000; ts.tv_nsec = (remain % 1000) * 1000 * 1000; syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, &ts); if (__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE)) return 1; now = current_time_ms(); if (now - start > timeout) return 0; } } 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; } struct nlmsg { char* pos; int nesting; struct nlattr* nested[8]; char buf[4096]; }; static void netlink_init(struct nlmsg* nlmsg, int typ, int flags, const void* data, int size) { memset(nlmsg, 0, sizeof(*nlmsg)); struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf; hdr->nlmsg_type = typ; hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags; memcpy(hdr + 1, data, size); nlmsg->pos = (char*)(hdr + 1) + NLMSG_ALIGN(size); } static void netlink_attr(struct nlmsg* nlmsg, int typ, const void* data, int size) { struct nlattr* attr = (struct nlattr*)nlmsg->pos; attr->nla_len = sizeof(*attr) + size; attr->nla_type = typ; if (size > 0) memcpy(attr + 1, data, size); nlmsg->pos += NLMSG_ALIGN(attr->nla_len); } static void netlink_nest(struct nlmsg* nlmsg, int typ) { struct nlattr* attr = (struct nlattr*)nlmsg->pos; attr->nla_type = typ; nlmsg->pos += sizeof(*attr); nlmsg->nested[nlmsg->nesting++] = attr; } static void netlink_done(struct nlmsg* nlmsg) { struct nlattr* attr = nlmsg->nested[--nlmsg->nesting]; attr->nla_len = nlmsg->pos - (char*)attr; } static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type, int* reply_len, bool dofail) { if (nlmsg->pos > nlmsg->buf + sizeof(nlmsg->buf) || nlmsg->nesting) exit(1); struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf; hdr->nlmsg_len = nlmsg->pos - nlmsg->buf; struct sockaddr_nl addr; memset(&addr, 0, sizeof(addr)); addr.nl_family = AF_NETLINK; ssize_t n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0, (struct sockaddr*)&addr, sizeof(addr)); if (n != (ssize_t)hdr->nlmsg_len) { if (dofail) exit(1); return -1; } n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); if (reply_len) *reply_len = 0; if (n < 0) { if (dofail) exit(1); return -1; } if (n < (ssize_t)sizeof(struct nlmsghdr)) { errno = EINVAL; if (dofail) exit(1); return -1; } if (hdr->nlmsg_type == NLMSG_DONE) return 0; if (reply_len && hdr->nlmsg_type == reply_type) { *reply_len = n; return 0; } if (n < (ssize_t)(sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))) { errno = EINVAL; if (dofail) exit(1); return -1; } if (hdr->nlmsg_type != NLMSG_ERROR) { errno = EINVAL; if (dofail) exit(1); return -1; } errno = -((struct nlmsgerr*)(hdr + 1))->error; return -errno; } static int netlink_send(struct nlmsg* nlmsg, int sock) { return netlink_send_ext(nlmsg, sock, 0, NULL, true); } static int netlink_query_family_id(struct nlmsg* nlmsg, int sock, const char* family_name, bool dofail) { struct genlmsghdr genlhdr; memset(&genlhdr, 0, sizeof(genlhdr)); genlhdr.cmd = CTRL_CMD_GETFAMILY; netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr)); netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, family_name, strnlen(family_name, GENL_NAMSIZ - 1) + 1); int n = 0; int err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n, dofail); if (err < 0) { return -1; } uint16_t id = 0; struct nlattr* attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN + NLMSG_ALIGN(sizeof(genlhdr))); for (; (char*)attr < nlmsg->buf + n; attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) { if (attr->nla_type == CTRL_ATTR_FAMILY_ID) { id = *(uint16_t*)(attr + 1); break; } } if (!id) { errno = EINVAL; return -1; } recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); return id; } static int netlink_next_msg(struct nlmsg* nlmsg, unsigned int offset, unsigned int total_len) { struct nlmsghdr* hdr = (struct nlmsghdr*)(nlmsg->buf + offset); if (offset == total_len || offset + hdr->nlmsg_len > total_len) return -1; return hdr->nlmsg_len; } static void netlink_add_device_impl(struct nlmsg* nlmsg, const char* type, const char* name) { struct ifinfomsg hdr; memset(&hdr, 0, sizeof(hdr)); netlink_init(nlmsg, RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr, sizeof(hdr)); if (name) netlink_attr(nlmsg, IFLA_IFNAME, name, strlen(name)); netlink_nest(nlmsg, IFLA_LINKINFO); netlink_attr(nlmsg, IFLA_INFO_KIND, type, strlen(type)); } static void netlink_add_device(struct nlmsg* nlmsg, int sock, const char* type, const char* name) { netlink_add_device_impl(nlmsg, type, name); netlink_done(nlmsg); int err = netlink_send(nlmsg, sock); if (err < 0) { } } static void netlink_add_veth(struct nlmsg* nlmsg, int sock, const char* name, const char* peer) { netlink_add_device_impl(nlmsg, "veth", name); netlink_nest(nlmsg, IFLA_INFO_DATA); netlink_nest(nlmsg, VETH_INFO_PEER); nlmsg->pos += sizeof(struct ifinfomsg); netlink_attr(nlmsg, IFLA_IFNAME, peer, strlen(peer)); netlink_done(nlmsg); netlink_done(nlmsg); netlink_done(nlmsg); int err = netlink_send(nlmsg, sock); if (err < 0) { } } static void netlink_add_hsr(struct nlmsg* nlmsg, int sock, const char* name, const char* slave1, const char* slave2) { netlink_add_device_impl(nlmsg, "hsr", name); netlink_nest(nlmsg, IFLA_INFO_DATA); int ifindex1 = if_nametoindex(slave1); netlink_attr(nlmsg, IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1)); int ifindex2 = if_nametoindex(slave2); netlink_attr(nlmsg, IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2)); netlink_done(nlmsg); netlink_done(nlmsg); int err = netlink_send(nlmsg, sock); if (err < 0) { } } static void netlink_add_linked(struct nlmsg* nlmsg, int sock, const char* type, const char* name, const char* link) { netlink_add_device_impl(nlmsg, type, name); netlink_done(nlmsg); int ifindex = if_nametoindex(link); netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex)); int err = netlink_send(nlmsg, sock); if (err < 0) { } } static void netlink_add_vlan(struct nlmsg* nlmsg, int sock, const char* name, const char* link, uint16_t id, uint16_t proto) { netlink_add_device_impl(nlmsg, "vlan", name); netlink_nest(nlmsg, IFLA_INFO_DATA); netlink_attr(nlmsg, IFLA_VLAN_ID, &id, sizeof(id)); netlink_attr(nlmsg, IFLA_VLAN_PROTOCOL, &proto, sizeof(proto)); netlink_done(nlmsg); netlink_done(nlmsg); int ifindex = if_nametoindex(link); netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex)); int err = netlink_send(nlmsg, sock); if (err < 0) { } } static void netlink_add_macvlan(struct nlmsg* nlmsg, int sock, const char* name, const char* link) { netlink_add_device_impl(nlmsg, "macvlan", name); netlink_nest(nlmsg, IFLA_INFO_DATA); uint32_t mode = MACVLAN_MODE_BRIDGE; netlink_attr(nlmsg, IFLA_MACVLAN_MODE, &mode, sizeof(mode)); netlink_done(nlmsg); netlink_done(nlmsg); int ifindex = if_nametoindex(link); netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex)); int err = netlink_send(nlmsg, sock); if (err < 0) { } } static void netlink_add_geneve(struct nlmsg* nlmsg, int sock, const char* name, uint32_t vni, struct in_addr* addr4, struct in6_addr* addr6) { netlink_add_device_impl(nlmsg, "geneve", name); netlink_nest(nlmsg, IFLA_INFO_DATA); netlink_attr(nlmsg, IFLA_GENEVE_ID, &vni, sizeof(vni)); if (addr4) netlink_attr(nlmsg, IFLA_GENEVE_REMOTE, addr4, sizeof(*addr4)); if (addr6) netlink_attr(nlmsg, IFLA_GENEVE_REMOTE6, addr6, sizeof(*addr6)); netlink_done(nlmsg); netlink_done(nlmsg); int err = netlink_send(nlmsg, sock); if (err < 0) { } } #define IFLA_IPVLAN_FLAGS 2 #define IPVLAN_MODE_L3S 2 #undef IPVLAN_F_VEPA #define IPVLAN_F_VEPA 2 static void netlink_add_ipvlan(struct nlmsg* nlmsg, int sock, const char* name, const char* link, uint16_t mode, uint16_t flags) { netlink_add_device_impl(nlmsg, "ipvlan", name); netlink_nest(nlmsg, IFLA_INFO_DATA); netlink_attr(nlmsg, IFLA_IPVLAN_MODE, &mode, sizeof(mode)); netlink_attr(nlmsg, IFLA_IPVLAN_FLAGS, &flags, sizeof(flags)); netlink_done(nlmsg); netlink_done(nlmsg); int ifindex = if_nametoindex(link); netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex)); int err = netlink_send(nlmsg, sock); if (err < 0) { } } static void netlink_device_change(struct nlmsg* nlmsg, int sock, const char* name, bool up, const char* master, const void* mac, int macsize, const char* new_name) { struct ifinfomsg hdr; memset(&hdr, 0, sizeof(hdr)); if (up) hdr.ifi_flags = hdr.ifi_change = IFF_UP; hdr.ifi_index = if_nametoindex(name); netlink_init(nlmsg, RTM_NEWLINK, 0, &hdr, sizeof(hdr)); if (new_name) netlink_attr(nlmsg, IFLA_IFNAME, new_name, strlen(new_name)); if (master) { int ifindex = if_nametoindex(master); netlink_attr(nlmsg, IFLA_MASTER, &ifindex, sizeof(ifindex)); } if (macsize) netlink_attr(nlmsg, IFLA_ADDRESS, mac, macsize); int err = netlink_send(nlmsg, sock); if (err < 0) { } } static int netlink_add_addr(struct nlmsg* nlmsg, int sock, const char* dev, const void* addr, int addrsize) { struct ifaddrmsg hdr; memset(&hdr, 0, sizeof(hdr)); hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6; hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120; hdr.ifa_scope = RT_SCOPE_UNIVERSE; hdr.ifa_index = if_nametoindex(dev); netlink_init(nlmsg, RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr, sizeof(hdr)); netlink_attr(nlmsg, IFA_LOCAL, addr, addrsize); netlink_attr(nlmsg, IFA_ADDRESS, addr, addrsize); return netlink_send(nlmsg, sock); } static void netlink_add_addr4(struct nlmsg* nlmsg, int sock, const char* dev, const char* addr) { struct in_addr in_addr; inet_pton(AF_INET, addr, &in_addr); int err = netlink_add_addr(nlmsg, sock, dev, &in_addr, sizeof(in_addr)); if (err < 0) { } } static void netlink_add_addr6(struct nlmsg* nlmsg, int sock, const char* dev, const char* addr) { struct in6_addr in6_addr; inet_pton(AF_INET6, addr, &in6_addr); int err = netlink_add_addr(nlmsg, sock, dev, &in6_addr, sizeof(in6_addr)); if (err < 0) { } } static struct nlmsg nlmsg; #define DEVLINK_FAMILY_NAME "devlink" #define DEVLINK_CMD_PORT_GET 5 #define DEVLINK_ATTR_BUS_NAME 1 #define DEVLINK_ATTR_DEV_NAME 2 #define DEVLINK_ATTR_NETDEV_NAME 7 static struct nlmsg nlmsg2; static void initialize_devlink_ports(const char* bus_name, const char* dev_name, const char* netdev_prefix) { struct genlmsghdr genlhdr; int len, total_len, id, err, offset; uint16_t netdev_index; int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); if (sock == -1) exit(1); int rtsock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (rtsock == -1) exit(1); id = netlink_query_family_id(&nlmsg, sock, DEVLINK_FAMILY_NAME, true); if (id == -1) goto error; memset(&genlhdr, 0, sizeof(genlhdr)); genlhdr.cmd = DEVLINK_CMD_PORT_GET; netlink_init(&nlmsg, id, NLM_F_DUMP, &genlhdr, sizeof(genlhdr)); netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1); netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1); err = netlink_send_ext(&nlmsg, sock, id, &total_len, true); if (err < 0) { goto error; } offset = 0; netdev_index = 0; while ((len = netlink_next_msg(&nlmsg, offset, total_len)) != -1) { struct nlattr* attr = (struct nlattr*)(nlmsg.buf + offset + NLMSG_HDRLEN + NLMSG_ALIGN(sizeof(genlhdr))); for (; (char*)attr < nlmsg.buf + offset + len; attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) { if (attr->nla_type == DEVLINK_ATTR_NETDEV_NAME) { char* port_name; char netdev_name[IFNAMSIZ]; port_name = (char*)(attr + 1); snprintf(netdev_name, sizeof(netdev_name), "%s%d", netdev_prefix, netdev_index); netlink_device_change(&nlmsg2, rtsock, port_name, true, 0, 0, 0, netdev_name); break; } } offset += len; netdev_index++; } error: close(rtsock); close(sock); } #define DEV_IPV4 "172.20.20.%d" #define DEV_IPV6 "fe80::%02x" #define DEV_MAC 0x00aaaaaaaaaa static void netdevsim_add(unsigned int addr, unsigned int port_count) { char buf[16]; sprintf(buf, "%u %u", addr, port_count); if (write_file("/sys/bus/netdevsim/new_device", buf)) { snprintf(buf, sizeof(buf), "netdevsim%d", addr); initialize_devlink_ports("netdevsim", buf, "netdevsim"); } } #define WG_GENL_NAME "wireguard" enum wg_cmd { WG_CMD_GET_DEVICE, WG_CMD_SET_DEVICE, }; enum wgdevice_attribute { WGDEVICE_A_UNSPEC, WGDEVICE_A_IFINDEX, WGDEVICE_A_IFNAME, WGDEVICE_A_PRIVATE_KEY, WGDEVICE_A_PUBLIC_KEY, WGDEVICE_A_FLAGS, WGDEVICE_A_LISTEN_PORT, WGDEVICE_A_FWMARK, WGDEVICE_A_PEERS, }; enum wgpeer_attribute { WGPEER_A_UNSPEC, WGPEER_A_PUBLIC_KEY, WGPEER_A_PRESHARED_KEY, WGPEER_A_FLAGS, WGPEER_A_ENDPOINT, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, WGPEER_A_LAST_HANDSHAKE_TIME, WGPEER_A_RX_BYTES, WGPEER_A_TX_BYTES, WGPEER_A_ALLOWEDIPS, WGPEER_A_PROTOCOL_VERSION, }; enum wgallowedip_attribute { WGALLOWEDIP_A_UNSPEC, WGALLOWEDIP_A_FAMILY, WGALLOWEDIP_A_IPADDR, WGALLOWEDIP_A_CIDR_MASK, }; static void netlink_wireguard_setup(void) { const char ifname_a[] = "wg0"; const char ifname_b[] = "wg1"; const char ifname_c[] = "wg2"; const char private_a[] = "\xa0\x5c\xa8\x4f\x6c\x9c\x8e\x38\x53\xe2\xfd\x7a\x70\xae\x0f\xb2\x0f\xa1" "\x52\x60\x0c\xb0\x08\x45\x17\x4f\x08\x07\x6f\x8d\x78\x43"; const char private_b[] = "\xb0\x80\x73\xe8\xd4\x4e\x91\xe3\xda\x92\x2c\x22\x43\x82\x44\xbb\x88\x5c" "\x69\xe2\x69\xc8\xe9\xd8\x35\xb1\x14\x29\x3a\x4d\xdc\x6e"; const char private_c[] = "\xa0\xcb\x87\x9a\x47\xf5\xbc\x64\x4c\x0e\x69\x3f\xa6\xd0\x31\xc7\x4a\x15" "\x53\xb6\xe9\x01\xb9\xff\x2f\x51\x8c\x78\x04\x2f\xb5\x42"; const char public_a[] = "\x97\x5c\x9d\x81\xc9\x83\xc8\x20\x9e\xe7\x81\x25\x4b\x89\x9f\x8e\xd9\x25" "\xae\x9f\x09\x23\xc2\x3c\x62\xf5\x3c\x57\xcd\xbf\x69\x1c"; const char public_b[] = "\xd1\x73\x28\x99\xf6\x11\xcd\x89\x94\x03\x4d\x7f\x41\x3d\xc9\x57\x63\x0e" "\x54\x93\xc2\x85\xac\xa4\x00\x65\xcb\x63\x11\xbe\x69\x6b"; const char public_c[] = "\xf4\x4d\xa3\x67\xa8\x8e\xe6\x56\x4f\x02\x02\x11\x45\x67\x27\x08\x2f\x5c" "\xeb\xee\x8b\x1b\xf5\xeb\x73\x37\x34\x1b\x45\x9b\x39\x22"; const uint16_t listen_a = 20001; const uint16_t listen_b = 20002; const uint16_t listen_c = 20003; const uint16_t af_inet = AF_INET; const uint16_t af_inet6 = AF_INET6; const struct sockaddr_in endpoint_b_v4 = { .sin_family = AF_INET, .sin_port = htons(listen_b), .sin_addr = {htonl(INADDR_LOOPBACK)}}; const struct sockaddr_in endpoint_c_v4 = { .sin_family = AF_INET, .sin_port = htons(listen_c), .sin_addr = {htonl(INADDR_LOOPBACK)}}; struct sockaddr_in6 endpoint_a_v6 = {.sin6_family = AF_INET6, .sin6_port = htons(listen_a)}; endpoint_a_v6.sin6_addr = in6addr_loopback; struct sockaddr_in6 endpoint_c_v6 = {.sin6_family = AF_INET6, .sin6_port = htons(listen_c)}; endpoint_c_v6.sin6_addr = in6addr_loopback; const struct in_addr first_half_v4 = {0}; const struct in_addr second_half_v4 = {(uint32_t)htonl(128 << 24)}; const struct in6_addr first_half_v6 = {{{0}}}; const struct in6_addr second_half_v6 = {{{0x80}}}; const uint8_t half_cidr = 1; const uint16_t persistent_keepalives[] = {1, 3, 7, 9, 14, 19}; struct genlmsghdr genlhdr = {.cmd = WG_CMD_SET_DEVICE, .version = 1}; int sock; int id, err; sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); if (sock == -1) { return; } id = netlink_query_family_id(&nlmsg, sock, WG_GENL_NAME, true); if (id == -1) goto error; netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr)); netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_a, strlen(ifname_a) + 1); netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_a, 32); netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_a, 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_b, 32); netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_b_v4, sizeof(endpoint_b_v4)); netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, &persistent_keepalives[0], 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4, sizeof(first_half_v4)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6, sizeof(first_half_v6)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_c, 32); netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_c_v6, sizeof(endpoint_c_v6)); netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, &persistent_keepalives[1], 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4, sizeof(second_half_v4)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6, sizeof(second_half_v6)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); err = netlink_send(&nlmsg, sock); if (err < 0) { } netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr)); netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_b, strlen(ifname_b) + 1); netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_b, 32); netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_b, 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_a, 32); netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_a_v6, sizeof(endpoint_a_v6)); netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, &persistent_keepalives[2], 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4, sizeof(first_half_v4)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6, sizeof(first_half_v6)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_c, 32); netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_c_v4, sizeof(endpoint_c_v4)); netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, &persistent_keepalives[3], 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4, sizeof(second_half_v4)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6, sizeof(second_half_v6)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); err = netlink_send(&nlmsg, sock); if (err < 0) { } netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr)); netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_c, strlen(ifname_c) + 1); netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_c, 32); netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_c, 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_a, 32); netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_a_v6, sizeof(endpoint_a_v6)); netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, &persistent_keepalives[4], 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4, sizeof(first_half_v4)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6, sizeof(first_half_v6)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_b, 32); netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_b_v4, sizeof(endpoint_b_v4)); netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, &persistent_keepalives[5], 2); netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4, sizeof(second_half_v4)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_nest(&nlmsg, NLA_F_NESTED | 0); netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6, sizeof(second_half_v6)); netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); netlink_done(&nlmsg); err = netlink_send(&nlmsg, sock); if (err < 0) { } error: close(sock); } static void initialize_netdevices(void) { char netdevsim[16]; sprintf(netdevsim, "netdevsim%d", (int)procid); struct { const char* type; const char* dev; } devtypes[] = { {"ip6gretap", "ip6gretap0"}, {"bridge", "bridge0"}, {"vcan", "vcan0"}, {"bond", "bond0"}, {"team", "team0"}, {"dummy", "dummy0"}, {"nlmon", "nlmon0"}, {"caif", "caif0"}, {"batadv", "batadv0"}, {"vxcan", "vxcan1"}, {"netdevsim", netdevsim}, {"veth", 0}, {"xfrm", "xfrm0"}, {"wireguard", "wg0"}, {"wireguard", "wg1"}, {"wireguard", "wg2"}, }; const char* devmasters[] = {"bridge", "bond", "team", "batadv"}; struct { const char* name; int macsize; bool noipv6; } devices[] = { {"lo", ETH_ALEN}, {"sit0", 0}, {"bridge0", ETH_ALEN}, {"vcan0", 0, true}, {"tunl0", 0}, {"gre0", 0}, {"gretap0", ETH_ALEN}, {"ip_vti0", 0}, {"ip6_vti0", 0}, {"ip6tnl0", 0}, {"ip6gre0", 0}, {"ip6gretap0", ETH_ALEN}, {"erspan0", ETH_ALEN}, {"bond0", ETH_ALEN}, {"veth0", ETH_ALEN}, {"veth1", ETH_ALEN}, {"team0", ETH_ALEN}, {"veth0_to_bridge", ETH_ALEN}, {"veth1_to_bridge", ETH_ALEN}, {"veth0_to_bond", ETH_ALEN}, {"veth1_to_bond", ETH_ALEN}, {"veth0_to_team", ETH_ALEN}, {"veth1_to_team", ETH_ALEN}, {"veth0_to_hsr", ETH_ALEN}, {"veth1_to_hsr", ETH_ALEN}, {"hsr0", 0}, {"dummy0", ETH_ALEN}, {"nlmon0", 0}, {"vxcan0", 0, true}, {"vxcan1", 0, true}, {"caif0", ETH_ALEN}, {"batadv0", ETH_ALEN}, {netdevsim, ETH_ALEN}, {"xfrm0", ETH_ALEN}, {"veth0_virt_wifi", ETH_ALEN}, {"veth1_virt_wifi", ETH_ALEN}, {"virt_wifi0", ETH_ALEN}, {"veth0_vlan", ETH_ALEN}, {"veth1_vlan", ETH_ALEN}, {"vlan0", ETH_ALEN}, {"vlan1", ETH_ALEN}, {"macvlan0", ETH_ALEN}, {"macvlan1", ETH_ALEN}, {"ipvlan0", ETH_ALEN}, {"ipvlan1", ETH_ALEN}, {"veth0_macvtap", ETH_ALEN}, {"veth1_macvtap", ETH_ALEN}, {"macvtap0", ETH_ALEN}, {"macsec0", ETH_ALEN}, {"veth0_to_batadv", ETH_ALEN}, {"veth1_to_batadv", ETH_ALEN}, {"batadv_slave_0", ETH_ALEN}, {"batadv_slave_1", ETH_ALEN}, {"geneve0", ETH_ALEN}, {"geneve1", ETH_ALEN}, {"wg0", 0}, {"wg1", 0}, {"wg2", 0}, }; int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (sock == -1) exit(1); unsigned i; for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) netlink_add_device(&nlmsg, sock, devtypes[i].type, devtypes[i].dev); for (i = 0; i < sizeof(devmasters) / (sizeof(devmasters[0])); i++) { char master[32], slave0[32], veth0[32], slave1[32], veth1[32]; sprintf(slave0, "%s_slave_0", devmasters[i]); sprintf(veth0, "veth0_to_%s", devmasters[i]); netlink_add_veth(&nlmsg, sock, slave0, veth0); sprintf(slave1, "%s_slave_1", devmasters[i]); sprintf(veth1, "veth1_to_%s", devmasters[i]); netlink_add_veth(&nlmsg, sock, slave1, veth1); sprintf(master, "%s0", devmasters[i]); netlink_device_change(&nlmsg, sock, slave0, false, master, 0, 0, NULL); netlink_device_change(&nlmsg, sock, slave1, false, master, 0, 0, NULL); } netlink_device_change(&nlmsg, sock, "bridge_slave_0", true, 0, 0, 0, NULL); netlink_device_change(&nlmsg, sock, "bridge_slave_1", true, 0, 0, 0, NULL); netlink_add_veth(&nlmsg, sock, "hsr_slave_0", "veth0_to_hsr"); netlink_add_veth(&nlmsg, sock, "hsr_slave_1", "veth1_to_hsr"); netlink_add_hsr(&nlmsg, sock, "hsr0", "hsr_slave_0", "hsr_slave_1"); netlink_device_change(&nlmsg, sock, "hsr_slave_0", true, 0, 0, 0, NULL); netlink_device_change(&nlmsg, sock, "hsr_slave_1", true, 0, 0, 0, NULL); netlink_add_veth(&nlmsg, sock, "veth0_virt_wifi", "veth1_virt_wifi"); netlink_add_linked(&nlmsg, sock, "virt_wifi", "virt_wifi0", "veth1_virt_wifi"); netlink_add_veth(&nlmsg, sock, "veth0_vlan", "veth1_vlan"); netlink_add_vlan(&nlmsg, sock, "vlan0", "veth0_vlan", 0, htons(ETH_P_8021Q)); netlink_add_vlan(&nlmsg, sock, "vlan1", "veth0_vlan", 1, htons(ETH_P_8021AD)); netlink_add_macvlan(&nlmsg, sock, "macvlan0", "veth1_vlan"); netlink_add_macvlan(&nlmsg, sock, "macvlan1", "veth1_vlan"); netlink_add_ipvlan(&nlmsg, sock, "ipvlan0", "veth0_vlan", IPVLAN_MODE_L2, 0); netlink_add_ipvlan(&nlmsg, sock, "ipvlan1", "veth0_vlan", IPVLAN_MODE_L3S, IPVLAN_F_VEPA); netlink_add_veth(&nlmsg, sock, "veth0_macvtap", "veth1_macvtap"); netlink_add_linked(&nlmsg, sock, "macvtap", "macvtap0", "veth0_macvtap"); netlink_add_linked(&nlmsg, sock, "macsec", "macsec0", "veth1_macvtap"); char addr[32]; sprintf(addr, DEV_IPV4, 14 + 10); struct in_addr geneve_addr4; if (inet_pton(AF_INET, addr, &geneve_addr4) <= 0) exit(1); struct in6_addr geneve_addr6; if (inet_pton(AF_INET6, "fc00::01", &geneve_addr6) <= 0) exit(1); netlink_add_geneve(&nlmsg, sock, "geneve0", 0, &geneve_addr4, 0); netlink_add_geneve(&nlmsg, sock, "geneve1", 1, 0, &geneve_addr6); netdevsim_add((int)procid, 4); netlink_wireguard_setup(); for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) { char addr[32]; sprintf(addr, DEV_IPV4, i + 10); netlink_add_addr4(&nlmsg, sock, devices[i].name, addr); if (!devices[i].noipv6) { sprintf(addr, DEV_IPV6, i + 10); netlink_add_addr6(&nlmsg, sock, devices[i].name, addr); } uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40); netlink_device_change(&nlmsg, sock, devices[i].name, true, 0, &macaddr, devices[i].macsize, NULL); } close(sock); } static void initialize_netdevices_init(void) { int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (sock == -1) exit(1); struct { const char* type; int macsize; bool noipv6; bool noup; } devtypes[] = { {"nr", 7, true}, {"rose", 5, true, true}, }; unsigned i; for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) { char dev[32], addr[32]; sprintf(dev, "%s%d", devtypes[i].type, (int)procid); sprintf(addr, "172.30.%d.%d", i, (int)procid + 1); netlink_add_addr4(&nlmsg, sock, dev, addr); if (!devtypes[i].noipv6) { sprintf(addr, "fe88::%02x:%02x", i, (int)procid + 1); netlink_add_addr6(&nlmsg, sock, dev, addr); } int macsize = devtypes[i].macsize; uint64_t macaddr = 0xbbbbbb + ((unsigned long long)i << (8 * (macsize - 2))) + (procid << (8 * (macsize - 1))); netlink_device_change(&nlmsg, sock, dev, !devtypes[i].noup, 0, &macaddr, macsize, NULL); } close(sock); } #define MAX_FDS 30 static void setup_common() { if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) { } } static void setup_binderfs() { if (mkdir("/dev/binderfs", 0777)) { } if (mount("binder", "/dev/binderfs", "binder", 0, NULL)) { } } static void loop(); static void sandbox_common() { prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0); setsid(); struct rlimit rlim; rlim.rlim_cur = rlim.rlim_max = (200 << 20); setrlimit(RLIMIT_AS, &rlim); rlim.rlim_cur = rlim.rlim_max = 32 << 20; setrlimit(RLIMIT_MEMLOCK, &rlim); rlim.rlim_cur = rlim.rlim_max = 136 << 20; setrlimit(RLIMIT_FSIZE, &rlim); rlim.rlim_cur = rlim.rlim_max = 1 << 20; setrlimit(RLIMIT_STACK, &rlim); rlim.rlim_cur = rlim.rlim_max = 0; setrlimit(RLIMIT_CORE, &rlim); rlim.rlim_cur = rlim.rlim_max = 256; setrlimit(RLIMIT_NOFILE, &rlim); if (unshare(CLONE_NEWNS)) { } if (mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL)) { } if (unshare(CLONE_NEWIPC)) { } if (unshare(0x02000000)) { } if (unshare(CLONE_NEWUTS)) { } if (unshare(CLONE_SYSVSEM)) { } typedef struct { const char* name; const char* value; } sysctl_t; static const sysctl_t sysctls[] = { {"/proc/sys/kernel/shmmax", "16777216"}, {"/proc/sys/kernel/shmall", "536870912"}, {"/proc/sys/kernel/shmmni", "1024"}, {"/proc/sys/kernel/msgmax", "8192"}, {"/proc/sys/kernel/msgmni", "1024"}, {"/proc/sys/kernel/msgmnb", "1024"}, {"/proc/sys/kernel/sem", "1024 1048576 500 1024"}, }; unsigned i; for (i = 0; i < sizeof(sysctls) / sizeof(sysctls[0]); i++) write_file(sysctls[i].name, sysctls[i].value); } static int wait_for_loop(int pid) { if (pid < 0) exit(1); int status = 0; while (waitpid(-1, &status, __WALL) != pid) { } return WEXITSTATUS(status); } static void drop_caps(void) { struct __user_cap_header_struct cap_hdr = {}; struct __user_cap_data_struct cap_data[2] = {}; cap_hdr.version = _LINUX_CAPABILITY_VERSION_3; cap_hdr.pid = getpid(); if (syscall(SYS_capget, &cap_hdr, &cap_data)) exit(1); const int drop = (1 << CAP_SYS_PTRACE) | (1 << CAP_SYS_NICE); cap_data[0].effective &= ~drop; cap_data[0].permitted &= ~drop; cap_data[0].inheritable &= ~drop; if (syscall(SYS_capset, &cap_hdr, &cap_data)) exit(1); } static int do_sandbox_none(void) { if (unshare(CLONE_NEWPID)) { } int pid = fork(); if (pid != 0) return wait_for_loop(pid); setup_common(); sandbox_common(); drop_caps(); initialize_netdevices_init(); if (unshare(CLONE_NEWNET)) { } initialize_netdevices(); setup_binderfs(); loop(); exit(1); } #define FS_IOC_SETFLAGS _IOW('f', 2, long) static void remove_dir(const char* dir) { int iter = 0; DIR* dp = 0; retry: while (umount2(dir, MNT_DETACH | UMOUNT_NOFOLLOW) == 0) { } dp = opendir(dir); if (dp == NULL) { if (errno == EMFILE) { exit(1); } exit(1); } struct dirent* ep = 0; while ((ep = readdir(dp))) { if (strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0) continue; char filename[FILENAME_MAX]; snprintf(filename, sizeof(filename), "%s/%s", dir, ep->d_name); while (umount2(filename, MNT_DETACH | UMOUNT_NOFOLLOW) == 0) { } struct stat st; if (lstat(filename, &st)) exit(1); if (S_ISDIR(st.st_mode)) { remove_dir(filename); continue; } int i; for (i = 0;; i++) { if (unlink(filename) == 0) break; if (errno == EPERM) { int fd = open(filename, O_RDONLY); if (fd != -1) { long flags = 0; if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0) { } close(fd); continue; } } if (errno == EROFS) { break; } if (errno != EBUSY || i > 100) exit(1); if (umount2(filename, MNT_DETACH | UMOUNT_NOFOLLOW)) exit(1); } } closedir(dp); for (int i = 0;; i++) { if (rmdir(dir) == 0) break; if (i < 100) { if (errno == EPERM) { int fd = open(dir, O_RDONLY); if (fd != -1) { long flags = 0; if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0) { } close(fd); continue; } } if (errno == EROFS) { break; } if (errno == EBUSY) { if (umount2(dir, MNT_DETACH | UMOUNT_NOFOLLOW)) exit(1); continue; } if (errno == ENOTEMPTY) { if (iter < 100) { iter++; goto retry; } } } exit(1); } } 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"); if (symlink("/dev/binderfs", "./binderfs")) { } } static void close_fds() { for (int fd = 3; fd < MAX_FDS; fd++) close(fd); } struct thread_t { int created, call; event_t ready, done; }; static struct thread_t threads[16]; static void execute_call(int call); static int running; static void* thr(void* arg) { struct thread_t* th = (struct thread_t*)arg; for (;;) { event_wait(&th->ready); event_reset(&th->ready); execute_call(th->call); __atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED); event_set(&th->done); } return 0; } static void execute_one(void) { int i, call, thread; for (call = 0; call < 84; call++) { for (thread = 0; thread < (int)(sizeof(threads) / sizeof(threads[0])); thread++) { struct thread_t* th = &threads[thread]; if (!th->created) { th->created = 1; event_init(&th->ready); event_init(&th->done); event_set(&th->done); thread_start(thr, th); } if (!event_isset(&th->done)) continue; event_reset(&th->done); th->call = call; __atomic_fetch_add(&running, 1, __ATOMIC_RELAXED); event_set(&th->ready); if (call == 0 || call == 1 || call == 4 || call == 5 || call == 6 || call == 9 || call == 11 || call == 12 || call == 15 || call == 17 || call == 20 || call == 21 || call == 22 || call == 25) break; event_timedwait(&th->done, 50 + (call == 14 ? 500 : 0) + (call == 15 ? 500 : 0) + (call == 20 ? 500 : 0)); break; } } for (i = 0; i < 100 && __atomic_load_n(&running, __ATOMIC_RELAXED); i++) sleep_ms(1); close_fds(); } static void execute_one(void); #define WAIT_FLAGS __WALL static void loop(void) { int iter = 0; for (;; iter++) { char cwdbuf[32]; sprintf(cwdbuf, "./%d", iter); if (mkdir(cwdbuf, 0777)) exit(1); int pid = fork(); if (pid < 0) exit(1); if (pid == 0) { if (chdir(cwdbuf)) exit(1); 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; } remove_dir(cwdbuf); } } uint64_t r[27] = {0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x0, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x0, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff}; void execute_call(int call) { intptr_t res = 0; switch (call) { case 0: res = syscall(__NR_socket, 0x29ul, 2ul, 0); if (res != -1) r[0] = res; break; case 1: *(uint32_t*)0x20000080 = 1; *(uint32_t*)0x20000084 = 5; *(uint64_t*)0x20000088 = 0x20002600; memcpy( (void*)0x20002600, "\xbf\x16\x00\x00\x00\x00\x00\x00\xb7\x07\x00\x00\x01\x00\xf0\xff\x50" "\x70\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\xc0\x00\x95\x00" "\x00\x00\x00\x00\x00\x00\x2b\xa7\x28\x04\x15\x98\xd6\xfb\xd3\x0c\xb5" "\x99\xe8\x3d\x24\xbd\x81\x37\xa3\xaa\x81\xe0\xed\x13\x9a\x85\xd3\x6b" "\xb3\x01\x9d\x13\xbd\x23\x21\xaf\x3c\x2b\xd6\x7c\xe6\x8f\x15\xc0\xec" "\x71\xd0\xe6\xad\xfe\xfc\xf1\xd8\xf7\xfa\xf7\x5e\x0f\x22\x6b\xd9\x17" "\x06\x00\x00\x00\x71\x42\xfa\x9e\xa4\x31\x81\x23\x75\x1c\x0a\x0e\x16" "\x8c\x18\x86\xd0\xd4\xd3\x53\x79\xbd\x22\x3e\xc8\x39\xbc\x16\xee\x98" "\x8e\x6e\x0d\xc8\xce\xdf\x3c\xeb\x9f\xbf\xbf\x9b\x0a\x4d\xef\x23\xd4" "\x30\xf6\x29\x6b\x32\xa8\x34\x38\x81\x07\x20\xa1\x59\xcd\xa9\x03\x63" "\xdb\x3d\x22\x1e\x15\x2d\xfc\xa6\x40\x57\xff\x3c\x47\x44\xae\xac\xcd" "\x36\x41\x11\x0b\xec\x4e\x90\x27\xa0\xc8\x05\x5b\xbf\xc3\xa9\x6d\x2e" "\x89\x10\xc2\xc3\x9e\x4b\xab\xe8\x02\xf5\xab\x3e\x89\xcf\x6c\x66\x2e" "\xd4\x04\x8d\x3b\x3e\x22\x27\x8d\x00\x03\x1e\x53\x88\xee\x5c\x86\x7d" "\xdd\x58\x21\x1d\x6e\xce\x1c\xcb\x0c\xd2\xb6\xd3\xcf\xfd\x96\x28\x67" "\xa3\xa2\xf6\x24\xf9\x92\xda\xa9\x4a\x0c\x55\x6f\x32\x18\xce\x74\x00" "\x68\x72\x5c\x37\x07\x4e\x46\x8e\xe2\x07\xd2\xf7\x39\x02\xeb\xcf\xcf" "\x49\x82\x27\x75\x98\x5b\xf3\x1b\x71\x5f\x58\x88\xb2\x4e\xfa\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\xff\xff\xff" "\x02\x00\x00\x00\x00\x00\x00\x00\x00\xdd\xff\xff\xff\x00\x00\xb2\x7c" "\xf3\xd1\x84\x8a\x54\xd7\x13\x2b\xe1\xbf\xb0\xad\xf9\xde\xab\x33\x23" "\xaa\x9f\xdf\xb5\x2f\xaf\x9c\xb0\x9c\x3b\xfd\x09\x00\x00\x00\xb9\x1a" "\xb2\x19\xef\x00\xbb\x7b\x3d\xe8\xf6\x75\x81\xcf\x79\x6a\xad\x42\x23" "\xb9\xff\x7f\xfc\xad\x3f\x6c\x3c\x2b\x1f\x03\x55\x00\x00\x00\x00\x00" "\x00\x1c\xf4\x1a\xb1\x1f\x12\xfb\x1e\x0a\x49\x40\x34\x00\x7d\xe7\xc6" "\x59\x2d\xf1\xa6\xc6\x4d\x8f\x20\xa6\x77\x45\x40\x9e\x01\x1f\x12\x64" "\xd4\x3f\x15\x3b\x3d\x34\x88\x9f\x40\x15\x9e\x80\x0e\xa2\x47\x4b\x54" "\x05\x00\xa3\x0b\x23\xbc\xee\x46\x76\x2c\x20\x93\xbc\xc9\xea\xe5\xee" "\x3e\x98\x00\x26\xc9\x6f\x80\xee\x1a\x74\xe0\x4b\xde\x74\x07\x50\xfa" "\x4d\x9a\xaa\x70\x59\x89\xb8\xe6\x73\xe3\x29\x6e\x52\xd3\x37\xc5\x6a" "\xbf\x11\x28\x74\xec\x51\xd6\xfe\x04\x8b\xa6\x86\x6a\xde\xba\xb5\x31" "\x68\x77\x0a\x71\xad\x90\x1a\xce\x38\x3e\x41\xd2\x77\xb1\x03\x92\x3a" "\x9d\x97\x1f\x7a\x25\x91\xdb\xe4\xa9\x12\xff\xaf\x6f\x65\x8f\x3f\x9c" "\xd1\x62\x86\x74\x4f\x83\xa8\x3f\x13\x8f\x8f\x92\xef\xd9\x22\x39\xea" "\xfc\xe5\xc1\xb3\xf9\x7a\x29\x7c\x9e\x49\xa0\xc3\x30\x0e\xf7\xb7\xfb" "\x5f\x09\xe0\xc8\xa8\x68\xa3\x53\x40\x9e\x34\xd3\xe8\x22\x79\x63\x75" "\x99\xf3\x5a\xd3\xf7\xff\xff\xff\x3c\xac\x39\x4c\x7b\xbd\xcd\x0e\x0e" "\xb5\x21\x62\xe0\xc4\x10\xad\xe7\xa3\x6b\x26\xa4\xe7\x0f\x03\xcc\x41" "\x46\xa7\x7a\xf0\x2c\x1d\x4c\xef\xd4\xa2\xb9\x4c\x0a\xed\x84\x77\xdf" "\xa8\xce\xef\xb4\x67\xf0\x5c\x69\x77\xc7\x8c\xdb\xf3\x77\x04\xec\x73" "\x75\x55\x39\x2a\x0b\x06\x49\xda\xba\x71\xf8\x97\x14\x49\x10\xfe\x05" "\x00\x38\xec\x9e\x47\xde\x89\x29\x8b\x7b\xf4\xd7\x69\xcc\xc1\x8e\xed" "\xe0\x06\x8c\xa1\x45\x78\x70\xeb\x30\xd2\x11\xe2\x3c\xcc\x8e\x06\xdd" "\xde\xb6\x17\x99\x25\x7a\xb5\x00\x00\x13\xc8\x6b\xa9\xaf\xfb\x12\xec" "\x75\x7c\x72\x34\xc2\x70\x24\x6c\x87\x8d\x01\x16\x0e\x6c\x07\xbf\x6c" "\xf8\x80\x9c\x3a\x0d\x06\x23\x57\xba\x25\x15\x56\x72\x30\xa6\xf8\xb2" "\xad\x1e\x1f\x49\x33\x54\x5f\xc3\xc7\x41\x37\x42\x11\x66\x3f\x6b\x63" "\xb1\xdd\x04\x4d\xd0\xa2\x76\x8e\x82\x59\x72\xfc\x43\x00\x00\x14\x67" "\xc8\x9f\xa0\xf8\x2e\x84\x40\x10\x50\x51\xe5\x51\x0a\x33\xdc\xda\x5e" "\x4e\x20\x2b\xd6\x22\x54\x9c\x4c\xff\xff\xff\x50\x1d\x3a\x5d\xd7\x14" "\x3f\xbf\x22\x1f\xff\x16\x1c\x12\xca\x38\x9c\xbe\x00\x00\x00\x00\x00" "\x00\x0f\xff\x75\x06\x7d\x2a\x21\x4f\x8c\x9d\x9b\x2e\xcf\x63\x1c\x6c" "\x5f\xd9\xc2\x6a\x54\xd4\x3f\xa0\x50\xb8\x8d\x1d\x43\xa8\x64\x5b\xd9" "\x10\x9b\x7e\x07\x86\x9b\xba\x71\x31\x42\x1c\x0f\x39\x11\x3b\xe7\x66" "\x4e\x08\xbd\xd7\x11\x5c\x61\xaf\xcb\x71\x8c\xf3\xc4\x68\x0b\x2f\x6c" "\x7a\x84\x00\xe3\x78\xa9\xb1\x5b\xc2\x0f\x49\xe2\x98\x72\x73\x40\xe8" "\x7c\xde\xfb\x40\xe5\x6e\x9c\xfa\xd9\x73\x34\x7d\x0d\xe7\xba\x47\x54" "\xff\x23\x1a\x1b\x93\x3d\x8f\x93\x1b\x8c\x55\x2b\x2c\x7c\x50\x3f\x3d" "\x0e\x7a\xb0\xe9\x58\xad\xb8\x62\x82\x2e\x40\x00\x99\x95\xae\x16\x6d" "\xeb\x98\x56\x29\x1a\x43\xa6\xf7\xeb\x2e\x32\xce\xfb\xf4\x63\x78\x9e" "\xaf\x79\xb8\xd4\xc2\xbf\x0f\x7a\x2c\xb0\x32\xda\xd1\x30\x07\xb8\x2e" "\x60\x44\xf6\x43\xfc\x8c\xd0\x7a\xe6\x36\xa5\xdb\xe9\x86\x4a\x11\x7d" "\x27\x32\x68\x50\xa7\xc3\xb5\x70\x86\x3f\x53\x2c\x21\x8b\x10\xaf\x13" "\xd7\xbe\x94\x98\x70\x05\x08\x8a\x83\x88\x0c\xca\xb9\xc9\x92\x0c\x2d" "\x2a\xf8\xc5\xe1\x3d\x52\xc8\x3a\xc3\xfa\x7c\x3a\xe6\xc0\x83\x84\x86" "\x5b\x66\xd2\xb4\xdc\xb5\xdd\x9c\xba\x16\xb6\x20\x40\xbf\x87\x02\xae" "\x12\xc7\x7e\x6e\x34\x99\x1a\xf6\x03\xe3\x85\x6a\x34\x6c\xf7\xf9\xfe" "\xeb\x70\x8a\xb2\x2b\x56\x0c\xf8\xa4\xa6\xf3\x1b\xa6\xd9\xb8\xcb\x09" "\x08\x00\x00\x00\x00\x00\x00\x00\x1a\x34\x2c\x01\x00\x00\x00\x00\x00" "\xe6\x67\xa7\x59\x2b\x33\x40\x6f\x1f\x71\xc7\x39\xb5\x5d\xb9\x1d\x23" "\x09\xdc\x7a\xe4\x01\x00\x5f\x52\x05\x3a\x39\xe7\x30\x7c\x09\xff\x3a" "\xc3\xe8\x20\xb0\x1c\x57\xdd\x74\xd4\xaa\xfc\x4c\x38\x3a\x17\xbc\x1d" "\xe5\x34\x7b\xb7\x1c\xa1\x6d\xcb\xbb\xaa\x29\x35\xf6\x02\x32\x59\x84" "\x38\x6b\x21\xb9\x64\x92\xae\x66\x20\x82\xb5\x6c\xf6\x66\xe6\x3a\x75" "\x7c\x0e\xf3\xea\x7a\xf6\x88\x15\x13\xbe\x94\xb3\x62\xe1\x5f\xfc\xa8" "\xec\x45\x3b\x3a\x2a\x67\xbe\x70\xc1\x7b\x0f\x9c\x2e\xac\x76\x58\x16" "\xc3\x0c\x2e\x71\x33\xdc\xa1\xc7\x66\x95\x22\xe8\xdf\xf8\xbc\x57\x0a" "\x93\xfb\xdb\x68\x8c\x3a\xef\x81\x00\x00\x00\x7a\x6e\xa6\xb1\x11\x63" "\x39\x2a\x19\xd8\x79\x95\xb5\x1c\x96\xfe\xbd\x5f\x24\xa3\x49\x98\xd2" "\x01\x0f\xd5\xfa\xcf\x68\xc4\xf8\x4e\x2f\x66\xe2\x7c\x81\xa1\x49\xd7" "\xb3\x31\x98\x3d\x3b\x74\x44\x49\x53\xfc\x12\x16\xdf\xec\x10\xb7\x24" "\xbe\x37\x33\xc2\x6f\x12\x53\x83\x76\xe1\x77\xff\xef\x6f\xd2\x60\x3b" "\xfa\xb9\x68\x31\x95\x7a\x08\xe4\x91\x9a\x46\x3d\x53\x32\xa2\x54\x60" "\x32\xa3\xc0\x6b\x94\xf1\x68\xe8\xfc\x4b\xda\x0c\x29\x47\x23\xfe\x30" "\x6f\x26\xc4\x77\xaf\x4b\x92\x66\x44\x67\x29\x85\xfa\xb7\xcc\x67\xbc" "\x5b\x5f\x5d\x38\xcd\xd8\xdf\x95\x14\x7e\xbe\x1c\xd8\x8b\x0a\x2f\xbb" "\xde\x99\x51\xbe\x42\x82\x7d\xfd\xdf\xef\xb2\x38\xfa\xc2\x30\x3c\xc8" "\x98\x2f\x1e\x55\xb0\x05\xaf\xcf\xea\x5e\xb0\x37\x24\x8f\xef\xad\x6b" "\xb0\x2c\x16\x2c\xe9\x2a\xb1\x77\x44\xc8\xec\x3d\x2e\x80\xcf\x32\x05" "\xd3\x66\x99\xfd\x38\x1b\xc8\x12\x31\xfb\x5e\x12\xe4\x5f\x30\x59\xf3" "\x61\xd0\x8d\x6a\x6d\x01\xdd\x79\xca\x9b\xf2\x4e\x06\x3d\x0c\x27\x3e" "\xd7\x0a\x2b\x70\xbe\x52\x1e\xa2\x7d\xc8\xcf\x3c\x9b\xdf\x83\xb9\x34" "\x05\xdb\x07\xe8\x2e\x2d\xdf\x4c\x4d\x26\xf1\xcd\xd8\xc3\xc9\x73\x6c" "\xf5\xe5\x08\x6d\xe3\xb4\x84\xf8\x67\x3e\x0e\x97\xdd\x7e\x8a\x87\x21" "\x48\x61\x3c\x3a\x04\xf3\xd6\x7f\x43\x75\xba\x5c\x7f\x1b\x00\x33\xf8" "\xdf\xe0\xfd\x9b\xb2\xa7\x08\x01\xf7\x63\x52\x4e\x1d\x79\xd8\x12\xce" "\xd7\x82\x64\x6b\x5f\x79\xc8\xfc\x08\xbb\x5c\x11\x02\x01\x08\xd7\x02" "\xed\xd2\xea\x9c\x96\xcf\xcb\x90\x66\x66\x86\x27\x82\x0d\x2d\x48\xaa" "\x5f\xc0\xa7\xbf\x1b\x51\xaf\xd8\x53\x50\xad\x00\xb7\x8c\x59\x8f\xa8" "\x70\x1b\x00\x08\x84\xde\x79\x0b\x54\xe5\xab\x2e\x8f\xf0\xc7\xae\x23" "\xe0\xb6\xee\xac\x95\xc4\xc2\xee\xf2\xe5\xeb\x1d\x01\x9d\x52\x09\x9f" "\xbd\x40\x4e\x8e\xce\x97\x0f\x67\x73\x6b\xa7\xe9\x60\xbd\x8b\x1e\x41" "\x05\xce\x7e\x31\xf7\xc9\xc3\xe3\xfa\x61\xaa\xb9\x67\x56\x5e\x04\x00" "\x00\x00\x00\x00\x00\x00\xa8\xcf\xda\x89\x0a\x98\xb9\x00\x87\xe9\x1d" "\x70\x3e\x98\x53\x5b\x10\x7b\x8f\x46\x53\xbe\x4c\x46\xa3\xa1\xad\xb0" "\x7d\x22\x69\x52\xb8\x57\x3b\x41\x70\x18\x31\x6f\xa9\x6e\x94\x2e\x35" "\xc4\xba\xa1\x6d\x41\x22\xc8\x63\x70\x9b\x08\xd4\x63\x9a\x19\xa4\x6a" "\xc9\x0a\xc4\x29\x13\xee\x9b\xca\xa8\x75\xfc\x70\x0b\xa3\x67\xca\x31" "\x82\x10\x59\x60\xbe\xf3\x37\x8a\x98\x00\x00\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x03\x18\xa4\x4a" "\xd3\x1b\xaa\xc0\x52\x0a\x91\x33\x01\xe6\x30\xae\x54\x0f\x32\x89\xae" "\xbd\xe8\x63\x3f\x6f\x45\x0c\x07\x38\xe1\x6d\xf6\xc7\xf1\xe0\x83\x2a" "\x2a\x16\xfe\x6e\x39\x95\x97\x35\x75\x82\x48\x03\x2c\xdf\x73\x20\xc6" "\xdc\x87\xb0\x1e\x3f\x9a\x78\x11\xb2\x00\x00\x00\x00\xae\x18\x9d\xe4" "\xb9\xb2\x5f\x7c\x7a\x9c\x32\xe4\xf1\xf2\x2a\xf1\xc0\x63\x15\x27\x0d" "\xe4\xa6\x60\x5e\x4b\x4b\x58\xbe\xf7\x6f\xac\x54\xf1\x1b\x84\xbd\x7b" "\xcd\x6b\x6a\x48\x5e\xdf\xb7\x68\x4c\x77\x0a\x39\xb3\x8b\x08\xe1\x8a" "\x51\xa4\xd4\xe6\x6c\xa2\x1c\x06\xa4\xb4\x19\x8e\x1b\xc2\xef\x99\x0c" "\x9b\xa9\x11\xef\xed\x62\x6e\x5e\xe3\x41\xa1\x7b\xf8\x13\x2b\x5b\x1d" "\xfa\x9f\xd3\x1d\xf2\x13\xc8\x8b\x40\x47\x97\x05\x6f\xd3\xba\xa8\xb2" "\xd6\xcb\x13\x44\x37\xcb\xa0\x19\x3b\xa4\x36\x0b\xdc\xc9\x8a\xad\x25" "\x60\xaa\x58\x29\x1c\x4e\xb9\xd4\xe0\x8a\xd7\xa9\xc5\xf0\x4b\xe1\xab" "\x59\x71\x24\xd8\x4d\xfc\x7b\xd8\xcc\xa8\xf6\x81\x54\xa0\xed\x35\x6e" "\x77\x3a\x79\x7c\xa6\xd6\x67\x48\x85\x7b\x4a\xbb\xf8\x83\x0a\xbe\xea" "\x2a\x46\x34\x2e\x6a\x73\x78\x17\x3c\xb2\x9d\x5c\xdc\xd6\x98\xa0\x20" "\x3f\x78\x11\x6b\x71\x00\x08\x00\x00\x00\x00\x00\x00\x00\x7c\x2d\x86" "\xb9\x44\x72\x80\x7c\x10\xeb\x7c\x8e\x2f\xb8\xbd\x79\xfe\x3a\x83\x16" "\xde\x28\x3e\x0c\x01\x00\x00\x80\x00\x00\x00\x00\x2c", 2189); *(uint64_t*)0x20000090 = 0x20000140; memcpy((void*)0x20000140, "GPL\000", 4); *(uint32_t*)0x20000098 = 0; *(uint32_t*)0x2000009c = 0; *(uint64_t*)0x200000a0 = 0; *(uint32_t*)0x200000a8 = 0; *(uint32_t*)0x200000ac = 0; memset((void*)0x200000b0, 0, 16); *(uint32_t*)0x200000c0 = 0; *(uint32_t*)0x200000c4 = 0; *(uint32_t*)0x200000c8 = -1; *(uint32_t*)0x200000cc = 8; *(uint64_t*)0x200000d0 = 0x20000000; *(uint32_t*)0x20000000 = 0; *(uint32_t*)0x20000004 = 0; *(uint32_t*)0x200000d8 = 0; *(uint32_t*)0x200000dc = 0x10; *(uint64_t*)0x200000e0 = 0x20000000; *(uint32_t*)0x20000000 = 0; *(uint32_t*)0x20000004 = 0; *(uint32_t*)0x20000008 = 0; *(uint32_t*)0x2000000c = 0; *(uint32_t*)0x200000e8 = 0; *(uint32_t*)0x200000ec = 0; *(uint32_t*)0x200000f0 = -1; *(uint32_t*)0x200000f4 = 0; *(uint64_t*)0x200000f8 = 0; res = syscall(__NR_bpf, 5ul, 0x20000080ul, 0x48ul); if (res != -1) r[1] = res; break; case 2: res = syscall(__NR_socket, 2ul, 1ul, 0); if (res != -1) r[2] = res; break; case 3: *(uint32_t*)0x20000100 = 1; *(uint32_t*)0x20000104 = 0x80; *(uint8_t*)0x20000108 = 0; *(uint8_t*)0x20000109 = 0; *(uint8_t*)0x2000010a = 2; *(uint8_t*)0x2000010b = 0; *(uint32_t*)0x2000010c = 0; *(uint64_t*)0x20000110 = 0x200; *(uint64_t*)0x20000118 = 0; *(uint64_t*)0x20000120 = 0; STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 0, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 1, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 2, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 3, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 4, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 5, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 6, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 7, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 8, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 9, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 10, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 11, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 12, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 13, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 14, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 15, 2); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 17, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 18, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 19, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 20, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 21, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 22, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 23, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 24, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 25, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 26, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 27, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 28, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 29, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 30, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 31, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 32, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 33, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 34, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 35, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 36, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 37, 1); STORE_BY_BITMASK(uint64_t, , 0x20000128, 0, 38, 26); *(uint32_t*)0x20000130 = 0; *(uint32_t*)0x20000134 = 0; *(uint64_t*)0x20000138 = 0; *(uint64_t*)0x20000140 = 0; *(uint64_t*)0x20000148 = 0; *(uint64_t*)0x20000150 = 0; *(uint32_t*)0x20000158 = 0xfffffffc; *(uint32_t*)0x2000015c = 0; *(uint64_t*)0x20000160 = 0x10001; *(uint32_t*)0x20000168 = 0; *(uint16_t*)0x2000016c = 0; *(uint16_t*)0x2000016e = 0; *(uint32_t*)0x20000170 = 0; *(uint32_t*)0x20000174 = 0; *(uint64_t*)0x20000178 = 0; syscall(__NR_perf_event_open, 0x20000100ul, 0, 0xaul, -1, 0ul); break; case 4: *(uint64_t*)0x20000fc0 = 0x20000000; *(uint16_t*)0x20000000 = 2; *(uint16_t*)0x20000002 = htobe16(0x4001); *(uint8_t*)0x20000004 = 0xac; *(uint8_t*)0x20000005 = 0x14; *(uint8_t*)0x20000006 = 0x14; *(uint8_t*)0x20000007 = 0xbb; *(uint32_t*)0x20000fc8 = 0x10; *(uint64_t*)0x20000fd0 = 0; *(uint64_t*)0x20000fd8 = 0; *(uint64_t*)0x20000fe0 = 0; *(uint64_t*)0x20000fe8 = 0; *(uint32_t*)0x20000ff0 = 0; syscall(__NR_sendmsg, r[2], 0x20000fc0ul, 0x20000811ul); break; case 5: *(uint32_t*)0x20000040 = r[2]; *(uint32_t*)0x20000044 = r[1]; syscall(__NR_ioctl, r[0], 0x89e0, 0x20000040ul); break; case 6: syscall(__NR_write, -1, 0ul, 0xda00ul); break; case 7: *(uint64_t*)0x20000a80 = 0; *(uint32_t*)0x20000a88 = 0x195; *(uint64_t*)0x20000a90 = 0x20000a00; *(uint64_t*)0x20000a00 = 0x20000280; memset((void*)0x20000280, 3, 1); *(uint64_t*)0x20000a08 = 0x147cd6; *(uint64_t*)0x20000a98 = 2; *(uint64_t*)0x20000aa0 = 0; *(uint64_t*)0x20000aa8 = 0; *(uint32_t*)0x20000ab0 = 0x3680; syscall(__NR_sendmsg, r[0], 0x20000a80ul, 0x20030ul); break; case 8: *(uint32_t*)0x20000200 = r[1]; syscall(__NR_setsockopt, r[2], 1, 0x32, 0x20000200ul, 4ul); break; case 9: syscall(__NR_close, r[2]); break; case 10: syscall(__NR_close, r[0]); break; case 11: *(uint32_t*)0x20000040 = -1; syscall(__NR_bpf, 0x16ul, 0x20000040ul, 4ul); break; case 12: *(uint32_t*)0x20000080 = 0; syscall(__NR_ioctl, -1, 0x400454da, 0x20000080ul); break; case 13: memcpy((void*)0x200000c0, "memory.events\000", 14); res = syscall(__NR_openat, 0xffffff9c, 0x200000c0ul, 0x26e1ul, 0ul); if (res != -1) r[3] = res; break; case 14: *(uint32_t*)0x200000c0 = 0x11; *(uint32_t*)0x200000c4 = 5; *(uint64_t*)0x200000c8 = 0x200002c0; memcpy( (void*)0x200002c0, "\x85\x00\x00\x00\xc6\xb1\xd4\x90\x47\x2c\x7a\x80\xb3\x6b\xc9\xb3\x99" "\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x0b\x00\x00\x00\x00\x00", 33); *(uint64_t*)0x200000d0 = 0x20000040; memcpy((void*)0x20000040, "GPL\000", 4); *(uint32_t*)0x200000d8 = 0; *(uint32_t*)0x200000dc = 0; *(uint64_t*)0x200000e0 = 0; *(uint32_t*)0x200000e8 = 0; *(uint32_t*)0x200000ec = 0; memset((void*)0x200000f0, 0, 16); *(uint32_t*)0x20000100 = 0; *(uint32_t*)0x20000104 = 2; *(uint32_t*)0x20000108 = -1; *(uint32_t*)0x2000010c = 8; *(uint64_t*)0x20000110 = 0; *(uint32_t*)0x20000118 = 0; *(uint32_t*)0x2000011c = 0x10; *(uint64_t*)0x20000120 = 0; *(uint32_t*)0x20000128 = 0; *(uint32_t*)0x2000012c = 0; *(uint32_t*)0x20000130 = 0; *(uint32_t*)0x20000134 = 0; *(uint64_t*)0x20000138 = 0; res = syscall(__NR_bpf, 5ul, 0x200000c0ul, 0x78ul); if (res != -1) r[4] = res; break; case 15: *(uint64_t*)0x200001c0 = 0x20000180; memcpy((void*)0x20000180, "ext4_journal_start\000", 19); *(uint32_t*)0x200001c8 = r[4]; syscall(__NR_bpf, 0x11ul, 0x200001c0ul, 0x10ul); break; case 16: *(uint32_t*)0x20000040 = 0; *(uint32_t*)0x20000044 = -1; *(uint32_t*)0x20000048 = 0; *(uint32_t*)0x2000004c = 0x421; *(uint64_t*)0x20000050 = 0x20000a40; memcpy( (void*)0x20000a40, "bdev!)-%+wl`n\000posi\031Mx_dxl_accesszQ\tU\227\022=J\325\213;" "B\343\032\027f\262@\212\2136\377\377\377\001fE\256a\020{\254\251+" "V\2063Hhk{2\000\024I\367\266\315)\005\207q6\355~\320\262\370\215*" "\b\344\"\036\277\217_[\027@\345\354\020\a\2715w\213yx/" "J\263\252\324W\322\355N\214w\346\231\376 " "\204]8\2240U\263E;\377\241!" "\232\207\210\002\277\253\227B\331\006\362\n\367\037\330v\177D\362\207" "\367}V\211}\360\267\215\205\366\233\314\323Lh.\r\323J\"\037\336W;F." "\337$\356\030\0165\241\374N\210`\273j " "\257<\361\276`4,q[M\260-\320\214loB\221&\363\227\327-\2678\\\220/" "\233\360\314r\301\250\205E\205p+\321\276\020\rgx\270\223k|" "\215\307x\001\016\264~\262\336Q\337\214\035Ti\257q\336\344c&" "\231\326psf\250\254jh9\213k\217\n$\362\006#\310\322\000\000w\003," "\273\355\361o\330\031\322\035\273\323\030E\016&\203\337WL?P$" "\264a\f\0254\335\254x\221<" "\227\023\253\342\335\n\023\031\271U\n\265\266\377BQ\200\346\346\257" "\006\315/" "\207\021\361\271\276&,c\3753\304\352P\233\3425\314\244RDx\255\300\217|" "\343u\276\036\325\246\314\270\206\2130\'\314\001\233Q/" "\371\247vfa\337!\032xt\321\r\331&MC\314," "2\316\322kCJ\020\210\000\000\000\000\000\000\000\000\301b\274\\l$+" "ne\212\243\314\210\332\352\237\304\027{=2{2\371i\006\006u\346&" "\220\bu\000\000\000\000\000\000\n\3607~\250\305\005\245\003\300\265r$" "q@\344\307\241B>" "\376\003s\a\0334k\200\036\341\207\260\233\267aS\233\004x\262\037\242" "\000\037\200R\362b\311+\346\210\365\377\210#\320\344\365z\247#c\344!" "4N\277\212r\216\034\021=\213\370G\374 " ")\r\276\036\256\024@" "\251\224\2515i\221\207\020\030\222UMW\306\324n\241\032\337\346H\033" "\256\002S\v\271A\323\356\237\323{\321v\006\252\252." "\b\357\206\027\034\200\244\v\364\346:" "\364\253\037\261\371\337\253\305I " "\311v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0004\347" "\266\302>\303\244@\273\263\355\272\rr\3605\324\376p{" "\3058\225\337\006v\330\352\254{Q\217\251\016\022\323%u\037;" "\266\210\350\366\344$%\213\000Uw\213\355\277\273)\260\373k\225\352g{" "\251\202\r\303\364&\306\202\322\032\247\216\377\0344\220\323\352\262!" "m\230\225x>\313\351\245\222\204g\n\357$" "\\\347Y\202B\314h\006\027\202\021A\252b\366h\336\207O\362w\224\2731" "\260\351\200\360\205\270\353\031v\340\313\366\315@%" "I\003n\343\365\246\214\035\361\301\261\177=\'\323\354;|\004>z\366}" "\001\250\330k\355\325\b\331i\313\022\226}" "\324\262\320\310\361\364\304\260(\320\363\t#e\321\r:" "\357\354\n\303\255<\"\250\016\230\311\227\"\261\324G\305~" "C\230\004\342\354\230\364\021\201\ag`\210^6i}" "\304\275uI\371\273\314\254\315\032\302\276$\2658\303v|" "\277\rx\364\341\2457P\2624\241}" "\216\252C\323\333\223\356\261y\301\373\233\002\335\"\337\262P\0171\317" "\363/" "cl\205K\242\310om\"\200vh~\324\n\242\002\352+B\212+#" "n\217GP\250Vj\251\000\317\254\027\340]" "\\\233\313iU\210\357\230\272\260xLb\022\2234\017\230\"o\035\240J\207y8" "oW\356E\361\3370U\255\256\236\\f\327\213\024\2271Q\304\327\026\234ZD" "\374\364y\376<" "\260\272n\336\240\257\002eC\255\317\267x\020T\232\312\022\267\350J@" "\315\357\352\210\214\322\025N\030UK\345i\331\213\342\306\3600\337d\375" "7\263\331\323l\000\000\000\000\000\000\000\000\000\000\000\000", 1057); syscall(__NR_bpf, 0x14ul, 0x20000040ul, 0x30ul); break; case 17: syscall(__NR_recvmsg, -1, 0ul, 0ul, 0); break; case 18: syscall(__NR_openat, -1, 0ul, 0ul, 0ul); break; case 19: memcpy((void*)0x20000140, "memory.events\000", 14); res = syscall(__NR_openat, 0xffffff9c, 0x20000140ul, 0x7a05ul, 0x1700ul); if (res != -1) r[5] = res; break; case 20: *(uint64_t*)0x20000300 = 0x20000280; memcpy((void*)0x20000280, "xprtrdma_dma_maperr\000", 20); *(uint32_t*)0x20000308 = r[3]; syscall(__NR_bpf, 0x11ul, 0x20000300ul, 0x10ul); break; case 21: syscall(__NR_recvmsg, -1, 0ul, 0x100ul, 0); break; case 22: *(uint32_t*)0x20000200 = 0; *(uint32_t*)0x20000204 = 0x80; *(uint8_t*)0x20000208 = 0; *(uint8_t*)0x20000209 = 0; *(uint8_t*)0x2000020a = 8; *(uint8_t*)0x2000020b = 0x2f; *(uint32_t*)0x2000020c = 0; *(uint64_t*)0x20000210 = 0; *(uint64_t*)0x20000218 = 0x80; *(uint64_t*)0x20000220 = 0x19; STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 0, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 1, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 2, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 3, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 4, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 5, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 6, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 7, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 8, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 9, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 10, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 11, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 12, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 13, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 14, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 15, 2); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 17, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 18, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 19, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 20, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 21, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 22, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 23, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 24, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 25, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 26, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 27, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 28, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 29, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 30, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 1, 31, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 32, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 33, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 34, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 35, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 36, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 37, 1); STORE_BY_BITMASK(uint64_t, , 0x20000228, 0, 38, 26); *(uint32_t*)0x20000230 = 0; *(uint32_t*)0x20000234 = 4; *(uint64_t*)0x20000238 = 0xfff; *(uint64_t*)0x20000240 = 8; *(uint64_t*)0x20000248 = 0; *(uint64_t*)0x20000250 = 0; *(uint32_t*)0x20000258 = 0x80; *(uint32_t*)0x2000025c = 0; *(uint64_t*)0x20000260 = 0; *(uint32_t*)0x20000268 = 0; *(uint16_t*)0x2000026c = 0x67d; *(uint16_t*)0x2000026e = 0; *(uint32_t*)0x20000270 = 0xfffffff8; *(uint32_t*)0x20000274 = 0; *(uint64_t*)0x20000278 = 3; syscall(__NR_perf_event_open, 0x20000200ul, -1, 0ul, r[5], 0xbul); break; case 23: syscall(__NR_perf_event_open, 0ul, 0, 0xcul, -1, 0xbul); break; case 24: memcpy((void*)0x20000400, "cpuacct.stat\000", 13); res = syscall(__NR_openat, r[3], 0x20000400ul, 0ul, 0ul); if (res != -1) r[6] = res; break; case 25: *(uint32_t*)0x20000380 = 0; *(uint32_t*)0x20000384 = 0x80; *(uint8_t*)0x20000388 = 1; *(uint8_t*)0x20000389 = 5; *(uint8_t*)0x2000038a = 6; *(uint8_t*)0x2000038b = 0x64; *(uint32_t*)0x2000038c = 0; *(uint64_t*)0x20000390 = 0x80000000; *(uint64_t*)0x20000398 = 0x8000; *(uint64_t*)0x200003a0 = 1; STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 0, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 1, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 2, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 3, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 4, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 5, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 6, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 7, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 8, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 9, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 10, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 11, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 12, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 13, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 14, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 15, 2); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 17, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 18, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 19, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 20, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 21, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 22, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 23, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 24, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 25, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 26, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 27, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 28, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 29, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 30, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 31, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 32, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 33, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 34, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 35, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 1, 36, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 37, 1); STORE_BY_BITMASK(uint64_t, , 0x200003a8, 0, 38, 26); *(uint32_t*)0x200003b0 = 1; *(uint32_t*)0x200003b4 = 0; *(uint64_t*)0x200003b8 = 0x20000340; *(uint64_t*)0x200003c0 = 4; *(uint64_t*)0x200003c8 = 0x500; *(uint64_t*)0x200003d0 = 0x201c; *(uint32_t*)0x200003d8 = 0x10001; *(uint32_t*)0x200003dc = 6; *(uint64_t*)0x200003e0 = 5; *(uint32_t*)0x200003e8 = 0; *(uint16_t*)0x200003ec = 0x400; *(uint16_t*)0x200003ee = 0; *(uint32_t*)0x200003f0 = 0x10000; *(uint32_t*)0x200003f4 = 0; *(uint64_t*)0x200003f8 = -1; syscall(__NR_perf_event_open, 0x20000380ul, -1, 0xful, r[6], 0ul); break; case 26: memcpy((void*)0x20000140, "memory.events\000", 14); res = syscall(__NR_openat, 0xffffff9c, 0x20000140ul, 0x7a05ul, 0x1700ul); if (res != -1) r[7] = res; break; case 27: syscall(__NR_perf_event_open, 0ul, 0, -1ul, -1, 0ul); break; case 28: *(uint64_t*)0x20000040 = 0x600000000000010; syscall(__NR_ioctl, r[7], 0x4030582a, 0x20000040ul); break; case 29: res = syscall(__NR_perf_event_open, 0ul, 0, -1ul, -1, 3ul); if (res != -1) r[8] = res; break; case 30: syscall(__NR_openat, 0xffffff9c, 0ul, 0x26e1ul, 0ul); break; case 31: res = syscall(__NR_openat, 0xffffff9c, 0ul, 0x7a05ul, 0x1700ul); if (res != -1) r[9] = res; break; case 32: syscall(__NR_ioctl, r[9], 0x40086602, 0ul); break; case 33: res = syscall(__NR_openat, -1, 0ul, 0x7a05ul, 0x1700ul); if (res != -1) r[10] = res; break; case 34: res = syscall(__NR_openat, 0xffffff9c, 0ul, 0x7a05ul, 0x1700ul); if (res != -1) r[11] = res; break; case 35: syscall(__NR_write, r[11], 0ul, 0x32600ul); break; case 36: syscall(__NR_openat, 0xffffff9c, 0ul, 0x7a05ul, 0x1700ul); break; case 37: syscall(__NR_write, r[11], 0ul, 0xda00ul); break; case 38: syscall(__NR_perf_event_open, 0ul, 0, 3ul, -1, 0ul); break; case 39: res = syscall(__NR_openat, 0xffffffffffffff9cul, 0ul, 0x200002ul, 0ul); if (res != -1) r[12] = res; break; case 40: syscall(__NR_openat, r[12], 0ul, 0ul, 0ul); break; case 41: syscall(__NR_perf_event_open, 0ul, 0, 8ul, -1, 0xaul); break; case 42: syscall(__NR_ioctl, -1, 0x4030582a, 0ul); break; case 43: syscall(__NR_perf_event_open, 0ul, 0, -1ul, -1, 0ul); break; case 44: res = syscall(__NR_getpid); if (res != -1) r[13] = res; break; case 45: syscall(__NR_perf_event_open, 0ul, r[13], 7ul, r[8], 2ul); break; case 46: syscall(__NR_write, r[10], 0ul, 0ul); break; case 47: syscall(__NR_close, -1); break; case 48: res = syscall(__NR_perf_event_open, 0ul, 0, -1ul, -1, 3ul); if (res != -1) r[14] = res; break; case 49: res = syscall(__NR_openat, 0xffffff9c, 0ul, 0x7a05ul, 0x1700ul); if (res != -1) r[15] = res; break; case 50: syscall(__NR_ioctl, r[15], 0x40086602, 0ul); break; case 51: res = syscall(__NR_openat, -1, 0ul, 0x7a05ul, 0x1700ul); if (res != -1) r[16] = res; break; case 52: res = syscall(__NR_openat, 0xffffff9c, 0ul, 0x7a05ul, 0x1700ul); if (res != -1) r[17] = res; break; case 53: syscall(__NR_write, r[17], 0ul, 0x32600ul); break; case 54: res = syscall(__NR_openat, 0xffffff9c, 0ul, 0x7a05ul, 0x1700ul); if (res != -1) r[18] = res; break; case 55: syscall(__NR_write, r[17], 0ul, 0xda00ul); break; case 56: syscall(__NR_perf_event_open, 0ul, 0, 3ul, -1, 0ul); break; case 57: res = syscall(__NR_openat, 0xffffffffffffff9cul, 0ul, 0x200002ul, 0ul); if (res != -1) r[19] = res; break; case 58: syscall(__NR_openat, r[19], 0ul, 0ul, 0ul); break; case 59: syscall(__NR_write, r[18], 0ul, 0ul); break; case 60: syscall(__NR_perf_event_open, 0ul, 0, 8ul, -1, 0xaul); break; case 61: syscall(__NR_ioctl, -1, 0x4030582a, 0ul); break; case 62: syscall(__NR_perf_event_open, 0ul, 0, -1ul, -1, 0ul); break; case 63: res = syscall(__NR_getpid); if (res != -1) r[20] = res; break; case 64: syscall(__NR_perf_event_open, 0ul, r[20], 7ul, r[14], 2ul); break; case 65: syscall(__NR_write, r[16], 0ul, 0ul); break; case 66: syscall(__NR_close, -1); break; case 67: syscall(__NR_perf_event_open, 0ul, 0, 0xeul, -1, 0xbd65d81bbc9f98ful); break; case 68: res = syscall(__NR_openat, 0xffffffffffffff9cul, 0ul, 0x200002ul, 0ul); if (res != -1) r[21] = res; break; case 69: res = syscall(__NR_openat, r[21], 0ul, 2ul, 0ul); if (res != -1) r[22] = res; break; case 70: syscall(__NR_bpf, 0xdul, 0ul, 0ul); break; case 71: syscall(__NR_write, r[22], 0ul, 0ul); break; case 72: syscall(__NR_bpf, 0xful, 0ul, 0ul); break; case 73: res = syscall(__NR_openat, 0xffffff9c, 0ul, 0x26e1ul, 0ul); if (res != -1) r[23] = res; break; case 74: syscall(__NR_close, r[23]); break; case 75: res = syscall(__NR_openat, 0xffffff9c, 0ul, 0x26e1ul, 0ul); if (res != -1) r[24] = res; break; case 76: syscall(__NR_close, r[24]); break; case 77: syscall(__NR_sendmsg, -1, 0ul, 0ul); break; case 78: res = syscall(__NR_bpf, 0x21ul, 0ul, 0ul); if (res != -1) r[25] = res; break; case 79: syscall(__NR_sendmsg, r[25], 0ul, 0x44ul); break; case 80: res = syscall(__NR_openat, r[25], 0ul, 0x200002ul, 0ul); if (res != -1) r[26] = res; break; case 81: syscall(__NR_perf_event_open, 0ul, r[26], 0xeul, -1, 4ul); break; case 82: syscall(__NR_sendmsg, -1, 0ul, 0ul); break; case 83: syscall(__NR_sendmsg, -1, 0ul, 0x404c004ul); break; } } int main(void) { syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul); syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul); syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul); for (procid = 0; procid < 6; procid++) { if (fork() == 0) { use_temporary_dir(); do_sandbox_none(); } } sleep(1000000); return 0; }