// https://syzkaller.appspot.com/bug?id=237d5a6aaebb1887e6cb69e6af51196a4e3814e8 #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef IPPROTO_MPTCP #define IPPROTO_MPTCP 262 #endif #ifndef NBD_MAJOR #define NBD_MAJOR 43 #endif #ifndef SOL_NETLINK #define SOL_NETLINK 270 #endif #ifndef NETLINK_ADD_MEMBERSHIP #define NETLINK_ADD_MEMBERSHIP 1 #endif #ifndef MPTCP_PM_NAME #define MPTCP_PM_NAME "mptcp_pm" #endif #ifndef MPTCP_PM_EV_GRP_NAME #define MPTCP_PM_EV_GRP_NAME "mptcp_pm_events" #endif #ifndef NBD_FLAG_CAN_MULTI_CONN #define NBD_FLAG_CAN_MULTI_CONN (1 << 8) #endif #ifndef NBD_REQUEST_MAGIC #define NBD_REQUEST_MAGIC 0x25609513 #endif #ifndef NBD_REPLY_MAGIC #define NBD_REPLY_MAGIC 0x67446698 #endif static void nla_put(char *buf, int *offset, uint16_t type, const void *data, uint16_t len) { struct nlattr *nla = (struct nlattr *)(buf + *offset); nla->nla_type = type; nla->nla_len = NLA_HDRLEN + len; memcpy(buf + *offset + NLA_HDRLEN, data, len); *offset += NLA_ALIGN(nla->nla_len); } static void nla_put_u32(char *buf, int *offset, uint16_t type, uint32_t val) { nla_put(buf, offset, type, &val, sizeof(val)); } static void nla_put_u64(char *buf, int *offset, uint16_t type, uint64_t val) { nla_put(buf, offset, type, &val, sizeof(val)); } static void nla_put_string(char *buf, int *offset, uint16_t type, const char *str) { nla_put(buf, offset, type, str, strlen(str) + 1); } static struct nlattr *nla_nest_start(char *buf, int *offset, uint16_t type) { struct nlattr *nla = (struct nlattr *)(buf + *offset); nla->nla_type = type | NLA_F_NESTED; *offset += NLA_HDRLEN; return nla; } static void nla_nest_end(char *buf, int *offset, struct nlattr *nla) { nla->nla_len = (char *)(buf + *offset) - (char *)nla; *offset = NLA_ALIGN(*offset); } static int genl_query_family(int nl_fd, const char *family_name, uint16_t *fam_id, const char *mcast_grp_name, uint32_t *mcast_grp_id) { static uint32_t seq = 1; char buf[4096]; memset(buf, 0, sizeof(buf)); struct nlmsghdr *nlh = (struct nlmsghdr *)buf; struct genlmsghdr *gh = (struct genlmsghdr *)(buf + NLMSG_HDRLEN); int offset = NLMSG_HDRLEN + GENL_HDRLEN; nlh->nlmsg_type = GENL_ID_CTRL; nlh->nlmsg_flags = NLM_F_REQUEST; nlh->nlmsg_seq = ++seq; gh->cmd = CTRL_CMD_GETFAMILY; gh->version = 1; nla_put_string(buf, &offset, CTRL_ATTR_FAMILY_NAME, family_name); nlh->nlmsg_len = offset; ssize_t sres = send(nl_fd, buf, nlh->nlmsg_len, 0); if (sres < 0) { printf("[-] Failed to send getfamily request for %s: %s\n", family_name, strerror(errno)); return -1; } ssize_t len = recv(nl_fd, buf, sizeof(buf), 0); if (len < 0) { printf("[-] Failed to recv getfamily reply for %s: %s\n", family_name, strerror(errno)); return -1; } nlh = (struct nlmsghdr *)buf; if (!NLMSG_OK(nlh, (unsigned int)len)) { printf("[-] Invalid netlink message received for %s\n", family_name); return -1; } if (nlh->nlmsg_type == NLMSG_ERROR) { struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(nlh); printf("[-] NLMSG_ERROR received for %s: error=%d\n", family_name, err->error); return -1; } struct nlattr *nla = (struct nlattr *)(buf + NLMSG_HDRLEN + GENL_HDRLEN); int rem = nlh->nlmsg_len - (NLMSG_HDRLEN + GENL_HDRLEN); *fam_id = 0; if (mcast_grp_id) *mcast_grp_id = 0; while (rem >= (int)sizeof(*nla) && nla->nla_len >= sizeof(*nla) && nla->nla_len <= rem) { if ((nla->nla_type & NLA_TYPE_MASK) == CTRL_ATTR_FAMILY_ID) { *fam_id = *(uint16_t *)((char *)nla + NLA_HDRLEN); } else if ((nla->nla_type & NLA_TYPE_MASK) == CTRL_ATTR_MCAST_GROUPS && mcast_grp_name && mcast_grp_id) { struct nlattr *grp = (struct nlattr *)((char *)nla + NLA_HDRLEN); int grp_rem = nla->nla_len - NLA_HDRLEN; while (grp_rem >= (int)sizeof(*grp) && grp->nla_len >= sizeof(*grp) && grp->nla_len <= grp_rem) { struct nlattr *attr = (struct nlattr *)((char *)grp + NLA_HDRLEN); int attr_rem = grp->nla_len - NLA_HDRLEN; char name[GENL_NAMSIZ] = {0}; uint32_t id = 0; while (attr_rem >= (int)sizeof(*attr) && attr->nla_len >= sizeof(*attr) && attr->nla_len <= attr_rem) { if ((attr->nla_type & NLA_TYPE_MASK) == CTRL_ATTR_MCAST_GRP_NAME) { strncpy(name, (char *)attr + NLA_HDRLEN, sizeof(name) - 1); } else if ((attr->nla_type & NLA_TYPE_MASK) == CTRL_ATTR_MCAST_GRP_ID) { id = *(uint32_t *)((char *)attr + NLA_HDRLEN); } attr_rem -= NLA_ALIGN(attr->nla_len); attr = (struct nlattr *)((char *)attr + NLA_ALIGN(attr->nla_len)); } if (strcmp(name, mcast_grp_name) == 0) { *mcast_grp_id = id; } grp_rem -= NLA_ALIGN(grp->nla_len); grp = (struct nlattr *)((char *)grp + NLA_ALIGN(grp->nla_len)); } } rem -= NLA_ALIGN(nla->nla_len); nla = (struct nlattr *)((char *)nla + NLA_ALIGN(nla->nla_len)); } if (*fam_id == 0) { printf("[-] Family ID not found for %s\n", family_name); return -1; } return 0; } static int create_tcp_pair(int *client_fd, int *server_fd) { int srv = socket(AF_INET, SOCK_STREAM, 0); if (srv < 0) { printf("[-] socket(AF_INET, SOCK_STREAM) failed: %s\n", strerror(errno)); return -1; } int opt = 1; if (setsockopt(srv, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) { printf("[-] setsockopt(srv, SO_REUSEADDR) failed: %s\n", strerror(errno)); close(srv); return -1; } struct sockaddr_in addr; socklen_t addr_len = sizeof(addr); memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); addr.sin_port = 0; if (bind(srv, (struct sockaddr *)&addr, sizeof(addr)) < 0) { printf("[-] bind(srv) failed: %s\n", strerror(errno)); close(srv); return -1; } if (listen(srv, 1) < 0) { printf("[-] listen(srv) failed: %s\n", strerror(errno)); close(srv); return -1; } if (getsockname(srv, (struct sockaddr *)&addr, &addr_len) < 0) { printf("[-] getsockname(srv) failed: %s\n", strerror(errno)); close(srv); return -1; } int cli = socket(AF_INET, SOCK_STREAM, 0); if (cli < 0) { printf("[-] socket(cli) failed: %s\n", strerror(errno)); close(srv); return -1; } if (connect(cli, (struct sockaddr *)&addr, sizeof(addr)) < 0) { printf("[-] connect(cli) failed: %s\n", strerror(errno)); close(srv); close(cli); return -1; } int conn = accept(srv, NULL, NULL); close(srv); if (conn < 0) { printf("[-] accept(srv) failed: %s\n", strerror(errno)); close(cli); return -1; } setsockopt(cli, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)); setsockopt(conn, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)); *client_fd = cli; *server_fd = conn; return 0; } static int send_nbd_connect_multi(int nl_fd, uint16_t nbd_fam_id, uint32_t index, int fd1, int fd2) { static uint32_t seq = 100; char buf[1024]; memset(buf, 0, sizeof(buf)); struct nlmsghdr *nlh = (struct nlmsghdr *)buf; struct genlmsghdr *gh = (struct genlmsghdr *)(buf + NLMSG_HDRLEN); int offset = NLMSG_HDRLEN + GENL_HDRLEN; seq++; nlh->nlmsg_type = nbd_fam_id; nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; nlh->nlmsg_seq = seq; gh->cmd = NBD_CMD_CONNECT; gh->version = 1; nla_put_u32(buf, &offset, NBD_ATTR_INDEX, index); nla_put_u64(buf, &offset, NBD_ATTR_SIZE_BYTES, 1024 * 1024); nla_put_u64(buf, &offset, NBD_ATTR_SERVER_FLAGS, NBD_FLAG_CAN_MULTI_CONN); struct nlattr *socks_nest = nla_nest_start(buf, &offset, NBD_ATTR_SOCKETS); struct nlattr *item1 = nla_nest_start(buf, &offset, NBD_SOCK_ITEM); nla_put_u32(buf, &offset, NBD_SOCK_FD, (uint32_t)fd1); nla_nest_end(buf, &offset, item1); struct nlattr *item2 = nla_nest_start(buf, &offset, NBD_SOCK_ITEM); nla_put_u32(buf, &offset, NBD_SOCK_FD, (uint32_t)fd2); nla_nest_end(buf, &offset, item2); nla_nest_end(buf, &offset, socks_nest); nlh->nlmsg_len = offset; ssize_t sres = send(nl_fd, buf, nlh->nlmsg_len, 0); if (sres < 0) { printf("[-] Failed to send NBD_CMD_CONNECT: %s\n", strerror(errno)); return -1; } char rbuf[4096]; while (1) { ssize_t len = recv(nl_fd, rbuf, sizeof(rbuf), 0); if (len < 0) { printf("[-] Failed to recv netlink reply for NBD_CMD_CONNECT: %s\n", strerror(errno)); return -1; } if (len == 0) { printf("[-] Netlink socket closed unexpectedly\n"); return -1; } struct nlmsghdr *r_nlh = (struct nlmsghdr *)rbuf; for (; NLMSG_OK(r_nlh, (unsigned int)len); r_nlh = NLMSG_NEXT(r_nlh, len)) { if (r_nlh->nlmsg_type == NLMSG_ERROR) { struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(r_nlh); if (err->error != 0) { printf("[-] NBD_CMD_CONNECT returned error: %d (%s)\n", err->error, strerror(-err->error)); return err->error; } return 0; } } } } static int send_nbd_reconfigure(int nl_fd, uint16_t nbd_fam_id, uint32_t index, int sock_fd) { static uint32_t seq = 200; char buf[1024]; memset(buf, 0, sizeof(buf)); struct nlmsghdr *nlh = (struct nlmsghdr *)buf; struct genlmsghdr *gh = (struct genlmsghdr *)(buf + NLMSG_HDRLEN); int offset = NLMSG_HDRLEN + GENL_HDRLEN; seq++; nlh->nlmsg_type = nbd_fam_id; nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; nlh->nlmsg_seq = seq; gh->cmd = NBD_CMD_RECONFIGURE; gh->version = 1; nla_put_u32(buf, &offset, NBD_ATTR_INDEX, index); struct nlattr *socks_nest = nla_nest_start(buf, &offset, NBD_ATTR_SOCKETS); struct nlattr *item = nla_nest_start(buf, &offset, NBD_SOCK_ITEM); nla_put_u32(buf, &offset, NBD_SOCK_FD, (uint32_t)sock_fd); nla_nest_end(buf, &offset, item); nla_nest_end(buf, &offset, socks_nest); nlh->nlmsg_len = offset; ssize_t sres = send(nl_fd, buf, nlh->nlmsg_len, 0); if (sres < 0) { printf("[-] Failed to send NBD_CMD_RECONFIGURE: %s\n", strerror(errno)); return -1; } char rbuf[4096]; while (1) { ssize_t len = recv(nl_fd, rbuf, sizeof(rbuf), 0); if (len < 0) { printf("[-] Failed to recv netlink reply for NBD_CMD_RECONFIGURE: %s\n", strerror(errno)); return -1; } if (len == 0) { printf("[-] Netlink socket closed unexpectedly\n"); return -1; } struct nlmsghdr *r_nlh = (struct nlmsghdr *)rbuf; for (; NLMSG_OK(r_nlh, (unsigned int)len); r_nlh = NLMSG_NEXT(r_nlh, len)) { if (r_nlh->nlmsg_type == NLMSG_ERROR) { struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(r_nlh); if (err->error != 0) { printf("[-] NBD_CMD_RECONFIGURE returned error: %d (%s)\n", err->error, strerror(-err->error)); return err->error; } return 0; } } } } int main(void) { setvbuf(stdout, NULL, _IONBF, 0); printf("[*] Starting reproducer for possible deadlock in mptcp_close...\n"); /* 1. Ensure /dev/nbd0 exists */ struct stat st; if (stat("/dev/nbd0", &st) < 0) { printf("[*] /dev/nbd0 not found, attempting to create node...\n"); int res = mknod("/dev/nbd0", S_IFBLK | 0660, makedev(NBD_MAJOR, 0)); if (res < 0 && errno != EEXIST) { printf("[-] Failed to create /dev/nbd0: %s\n", strerror(errno)); exit(1); } printf("[+] /dev/nbd0 node created successfully.\n"); } else { printf("[+] /dev/nbd0 exists.\n"); } /* 2. Open Generic Netlink sockets */ int nl_mptcp = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); if (nl_mptcp < 0) { printf("[-] Failed to create nl_mptcp socket: %s\n", strerror(errno)); exit(1); } printf("[+] Generic Netlink socket for MPTCP created successfully.\n"); int nl_nbd = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); if (nl_nbd < 0) { printf("[-] Failed to create nl_nbd socket: %s\n", strerror(errno)); exit(1); } printf("[+] Generic Netlink socket for NBD created successfully.\n"); /* 3. Query family IDs and multicast group */ uint16_t nbd_fam_id = 0; int res = genl_query_family(nl_nbd, NBD_GENL_FAMILY_NAME, &nbd_fam_id, NULL, NULL); if (res < 0) { printf("[-] Failed to resolve NBD generic netlink family.\n"); exit(1); } printf("[+] NBD generic netlink family resolved (id=%u).\n", nbd_fam_id); uint16_t mptcp_fam_id = 0; uint32_t mptcp_ev_grp = 0; res = genl_query_family(nl_mptcp, MPTCP_PM_NAME, &mptcp_fam_id, MPTCP_PM_EV_GRP_NAME, &mptcp_ev_grp); if (res < 0 || mptcp_ev_grp == 0) { printf("[-] Failed to resolve MPTCP PM events multicast group.\n"); exit(1); } printf("[+] MPTCP PM family resolved (id=%u), events multicast group id=%u.\n", mptcp_fam_id, mptcp_ev_grp); /* 4. Join MPTCP PM events multicast group so genl_has_listeners() returns true */ res = setsockopt(nl_mptcp, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &mptcp_ev_grp, sizeof(mptcp_ev_grp)); if (res < 0) { printf("[-] Failed to join MPTCP PM events multicast group: %s\n", strerror(errno)); exit(1); } printf("[+] Joined MPTCP PM events multicast group (genl_has_listeners is now true).\n"); /* 5. Establish multi-connection NBD setup: * Passing 2 sockets + NBD_FLAG_CAN_MULTI_CONN forces blk_mq_update_nr_hw_queues() * to transition hardware queues 1 -> 2, calling elevator_change() and taking &q->elevator_lock. */ printf("[*] Setting up TCP pairs 1 and 2 for multi-conn NBD...\n"); int c1 = -1, s1 = -1, c2 = -1, s2 = -1; res = create_tcp_pair(&c1, &s1); if (res < 0) { printf("[-] Failed to create TCP pair 1: %s\n", strerror(errno)); exit(1); } res = create_tcp_pair(&c2, &s2); if (res < 0) { printf("[-] Failed to create TCP pair 2: %s\n", strerror(errno)); exit(1); } printf("[+] TCP pairs 1 and 2 created successfully.\n"); res = send_nbd_connect_multi(nl_nbd, nbd_fam_id, 0, c1, c2); if (res < 0) { printf("[-] send_nbd_connect_multi failed: %d\n", res); exit(1); } printf("[+] NBD_CMD_CONNECT multi-connection successful on /dev/nbd0 (&q->elevator_lock acquired).\n"); /* Fork child to perform a read on /dev/nbd0: * Triggers blk_mq_run_dispatch_ops under set->srcu -> nbd_queue_rq (&cmd->lock) -> nbd_handle_cmd (&nsock->tx_lock). */ pid_t pid = fork(); if (pid < 0) { printf("[-] Failed to fork child reader: %s\n", strerror(errno)); exit(1); } if (pid == 0) { int bdev = open("/dev/nbd0", O_RDONLY); if (bdev >= 0) { char tmp[512]; (void)read(bdev, tmp, sizeof(tmp)); close(bdev); } _exit(0); } /* Wait briefly for request on s1 or s2 and reply with error to complete I/O cleanly */ struct pollfd pfds[2] = { { .fd = s1, .events = POLLIN }, { .fd = s2, .events = POLLIN } }; int pr = poll(pfds, 2, 200); if (pr > 0) { for (int i = 0; i < 2; i++) { if (pfds[i].revents & POLLIN) { struct nbd_request req; ssize_t r = recv(pfds[i].fd, &req, sizeof(req), 0); if (r == sizeof(req)) { printf("[+] Received NBD request (magic=0x%x) on socket %d, replying with error.\n", ntohl(req.magic), i); struct nbd_reply rep; memset(&rep, 0, sizeof(rep)); rep.magic = htonl(NBD_REPLY_MAGIC); rep.error = htonl(1); rep.cookie = req.cookie; send(pfds[i].fd, &rep, sizeof(rep), 0); } } } } /* Tear down initial connections: recv_work marks both nsock->dead = true */ shutdown(s1, SHUT_RDWR); close(s1); close(c1); shutdown(s2, SHUT_RDWR); close(s2); close(c2); int status = 0; res = waitpid(pid, &status, 0); if (res < 0) { printf("[-] waitpid failed: %s\n", strerror(errno)); exit(1); } printf("[+] Child reader reaped (status=0x%x).\n", status); /* Allow kernel recv_work to complete marking nsock->dead = true */ usleep(100000); /* 6. Reconnect with TCP pair 3 via NBD_CMD_RECONFIGURE: * nbd_genl_reconnect_sock_cb() attaches the socket without calling nbd_reclassify_socket(), * so it retains the default lockdep class sk_lock-AF_INET. */ printf("[*] Reconnecting /dev/nbd0 with TCP pair 3 (NBD_CMD_RECONFIGURE)...\n"); int c3 = -1, s3 = -1; res = create_tcp_pair(&c3, &s3); if (res < 0) { printf("[-] Failed to create TCP pair 3: %s\n", strerror(errno)); exit(1); } printf("[+] TCP pair 3 created (c3=%d, s3=%d).\n", c3, s3); res = send_nbd_reconfigure(nl_nbd, nbd_fam_id, 0, c3); if (res < 0) { printf("[-] send_nbd_reconfigure failed: %d\n", res); exit(1); } printf("[+] NBD_CMD_RECONFIGURE successful.\n"); /* Allow kernel to spawn recv_work on c3 */ usleep(50000); /* Close s3 and c3: kernel recv_work breaks, acquires &nsock->tx_lock, and calls * inet_shutdown() which takes sk_lock-AF_INET. */ printf("[*] Closing TCP pair 3 to establish &nsock->tx_lock -> sk_lock-AF_INET...\n"); shutdown(s3, SHUT_RDWR); close(s3); close(c3); /* Allow kernel workqueue to complete */ usleep(100000); printf("[+] TCP pair 3 closed, kernel recv_work completed.\n"); /* 7. Establish loopback MPTCP connection */ printf("[*] Setting up MPTCP listener...\n"); int lsk = socket(AF_INET, SOCK_STREAM, IPPROTO_MPTCP); if (lsk < 0) { printf("[-] socket(IPPROTO_MPTCP listener) failed: %s\n", strerror(errno)); exit(1); } int opt = 1; res = setsockopt(lsk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); if (res < 0) { printf("[-] setsockopt(lsk, SO_REUSEADDR) failed: %s\n", strerror(errno)); exit(1); } struct sockaddr_in srv_addr; socklen_t addr_len = sizeof(srv_addr); memset(&srv_addr, 0, sizeof(srv_addr)); srv_addr.sin_family = AF_INET; srv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); srv_addr.sin_port = 0; res = bind(lsk, (struct sockaddr *)&srv_addr, sizeof(srv_addr)); if (res < 0) { printf("[-] bind(lsk) failed: %s\n", strerror(errno)); exit(1); } res = listen(lsk, 1); if (res < 0) { printf("[-] listen(lsk) failed: %s\n", strerror(errno)); exit(1); } res = getsockname(lsk, (struct sockaddr *)&srv_addr, &addr_len); if (res < 0) { printf("[-] getsockname(lsk) failed: %s\n", strerror(errno)); exit(1); } printf("[+] MPTCP listener bound to port %u.\n", ntohs(srv_addr.sin_port)); printf("[*] Connecting MPTCP client...\n"); int csk = socket(AF_INET, SOCK_STREAM, IPPROTO_MPTCP); if (csk < 0) { printf("[-] socket(IPPROTO_MPTCP client) failed: %s\n", strerror(errno)); exit(1); } res = connect(csk, (struct sockaddr *)&srv_addr, sizeof(srv_addr)); if (res < 0) { printf("[-] connect(csk) failed: %s\n", strerror(errno)); exit(1); } printf("[+] MPTCP client connected.\n"); int ask = accept(lsk, NULL, NULL); if (ask < 0) { printf("[-] accept(lsk) failed: %s\n", strerror(errno)); exit(1); } printf("[+] MPTCP connection accepted (ask=%d).\n", ask); /* Exchange 1 byte to ensure connection is fully established and tokens are active */ res = send(csk, "X", 1, 0); if (res < 0) { printf("[-] send(csk) failed: %s\n", strerror(errno)); exit(1); } char ch = 0; res = recv(ask, &ch, 1, 0); if (res < 0) { printf("[-] recv(ask) failed: %s\n", strerror(errno)); exit(1); } printf("[+] Data exchanged across MPTCP connection.\n"); /* 8. Trigger circular deadlock warning: * mptcp_close() acquires sk_lock-AF_INET, and calls mptcp_event() -> nlmsg_new(..., GFP_KERNEL) * which invokes fs_reclaim, closing the circular dependency against the NBD lock chain. */ printf("[*] Triggering circular lockdep warning via close(csk)...\n"); res = close(csk); if (res < 0) { printf("[-] close(csk) failed: %s\n", strerror(errno)); exit(1); } printf("[+] MPTCP client socket closed successfully.\n"); res = close(ask); if (res < 0) { printf("[-] close(ask) failed: %s\n", strerror(errno)); exit(1); } printf("[+] Accepted socket closed successfully.\n"); res = close(lsk); if (res < 0) { printf("[-] close(lsk) failed: %s\n", strerror(errno)); exit(1); } printf("[+] MPTCP listener closed successfully.\n"); res = close(nl_mptcp); if (res < 0) { printf("[-] close(nl_mptcp) failed: %s\n", strerror(errno)); exit(1); } res = close(nl_nbd); if (res < 0) { printf("[-] close(nl_nbd) failed: %s\n", strerror(errno)); exit(1); } printf("[+] Netlink sockets closed successfully.\n"); /* Delay to allow lockdep warning to trigger and flush before exit */ printf("[*] Waiting 2 seconds for kernel lockdep warning...\n"); sleep(2); printf("[+] Reproducer run completed.\n"); return 0; }