upload the test case in the criu crtool to test the kernel change in the QEMU

Signed-off-by: dong sunchao <dongsunchao@gmail.com>

Author: DongSunchao

criu/cr-dump.c

@@ -14,6 +14,7 @@
 #include <sys/vfs.h>
 #include <sys/time.h>
 #include <sys/wait.h>
+#include <sys/ioctl.h>
 
 #include <sched.h>
 #include <sys/resource.h>
@@ -89,6 +90,29 @@
 #include "timer.h"
 #include "sigact.h"
 
+/* ================= GSOC HACK ================= */
+/* this need to be tested in the full env 
+* I have reuse this code in the crtool.c main() to test in the QEMU
+*/
+struct mq_peek_msg_hdr {
+    uint32_t msg_len;
+    uint32_t msg_prio;
+    uint8_t  payload[0];
+};
+
+struct mq_bulk_peek_args {
+    uint32_t start_idx;
+    uint32_t max_count;
+    uint64_t buf_ptr;
+    uint64_t buf_size;
+    uint32_t out_count;
+    uint32_t next_idx;
+    uint64_t reserved[2];
+};
+
+#define MQ_IOC_BULK_PEEK _IOWR('M', 1, struct mq_bulk_peek_args)
+/* ============================================= */
+
 /*
  * Architectures can overwrite this function to restore register sets that
  * are not covered by ptrace_set/get_regs().
@@ -2141,12 +2165,43 @@ int cr_dump_tasks(pid_t pid)
 	int ret;
 	int exit_code = -1;
 
+	int mq_fd = open("/dev/mqueue/test_queue", O_RDONLY); 
+	size_t offset = 0;
+
 	kerndat_warn_about_madv_guards();
 
 	pr_info("========================================\n");
 	pr_info("Dumping processes (pid: %d comm: %s)\n", pid, __task_comm_info(pid));
 	pr_info("========================================\n");
 
+	/* ================= GSOC HACK TEST ================= */
+    pr_info(">>> [GSoC PoC] Attempting to peek POSIX mqueue directly from CRIU...\n");
+    
+    if (mq_fd >= 0) {
+        char peek_buf[4096];
+        struct mq_bulk_peek_args args = {0};
+        args.max_count = 10;
+        args.buf_ptr = (uint64_t)(uintptr_t)peek_buf;
+        args.buf_size = sizeof(peek_buf);
+
+        if (ioctl(mq_fd, MQ_IOC_BULK_PEEK, &args) == 0) {
+            pr_info(">>> QEMU TEST [GSoC PoC] SUCCESS! CRIU peeked %u messages!\n", args.out_count);
+
+            for (uint32_t i = 0; i < args.out_count; i++) {
+                struct mq_peek_msg_hdr *hdr = (struct mq_peek_msg_hdr *)(peek_buf + offset);
+                pr_info(">>> QEMU TEST [GSoC PoC] Msg %u | Prio: %u | Payload: '%s'\n", 
+                        i, hdr->msg_prio, hdr->payload);
+                offset += sizeof(struct mq_peek_msg_hdr) + hdr->msg_len;
+            }
+        } else {
+            pr_err(">>> QEMU TEST [GSoC PoC] ioctl failed!\n");
+        }
+        close(mq_fd);
+    } else {
+        pr_info(">>> QEMU TEST [GSoC PoC] Could not open /dev/mqueue/test_queue (maybe victim is not running?)\n");
+    }
+    /* ================================================== */
+
 	/*
 	 *  We will fetch all file descriptors for each task, their number can
 	 *  be bigger than a default file limit, so we need to raise it to the

criu/crtools.c

@@ -11,6 +11,9 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/ioctl.h>
+
+#include <linux/ioctl.h>
 
 #include <sys/socket.h>
 #include <netinet/in.h>
@@ -47,6 +50,24 @@
 #include "setproctitle.h"
 #include "sysctl.h"
 
+struct mq_peek_msg_hdr {
+    uint32_t msg_len;
+    uint32_t msg_prio;
+    uint8_t  payload[0];
+};
+
+struct mq_bulk_peek_args {
+    uint32_t start_idx;
+    uint32_t max_count;
+    uint64_t buf_ptr;
+    uint64_t buf_size;
+    uint32_t out_count;
+    uint32_t next_idx;
+    uint64_t reserved[2];
+};
+
+#define MQ_IOC_BULK_PEEK _IOWR('M', 1, struct mq_bulk_peek_args)
+
 void flush_early_log_to_stderr(void) __attribute__((destructor));
 
 void flush_early_log_to_stderr(void)
@@ -134,6 +155,39 @@ int main(int argc, char *argv[], char *envp[])
 	int state = PARSING_GLOBAL_CONF;
 	char *cmd;
 
+	/* ================= GSOC HACK TEST ================= */
+
+	size_t offset = 0;
+	char peek_buf[4096];
+	struct mq_bulk_peek_args args = {0};
+	int mq_fd = open("/dev/mqueue/test_queue", O_RDONLY); 
+
+	printf(">>> [GSoC PoC] Attempting to peek POSIX mqueue directly from CRIU main()...\n");
+
+    if (mq_fd >= 0) {
+        
+        args.max_count = 10;
+        args.buf_ptr = (uint64_t)(unsigned long)peek_buf;
+        args.buf_size = sizeof(peek_buf);
+
+        if (ioctl(mq_fd, MQ_IOC_BULK_PEEK, &args) == 0) {
+            printf(">>> [GSoC PoC] SUCCESS! CRIU peeked %u messages!\n", args.out_count);
+            
+            for (uint32_t i = 0; i < args.out_count; i++) {
+                struct mq_peek_msg_hdr *hdr = (struct mq_peek_msg_hdr *)(peek_buf + offset);
+                printf(">>> [GSoC PoC] Msg %u | Prio: %u | Payload: '%s'\n", 
+                        i, hdr->msg_prio, hdr->payload);
+                offset += sizeof(struct mq_peek_msg_hdr) + hdr->msg_len;
+            }
+        } else {
+            printf(">>> [GSoC PoC] ioctl failed!\n");
+        }
+        close(mq_fd);
+    } else {
+        printf(">>> [GSoC PoC] Could not open mqueue! (Did you run victim in chroot?)\n");
+    }
+    /* ================================================== */
+
 	BUILD_BUG_ON(CTL_32 != SYSCTL_TYPE__CTL_32);
 	BUILD_BUG_ON(__CTL_STR != SYSCTL_TYPE__CTL_STR);
 	/* We use it for fd overlap handling in clone_service_fd() */

test/zdtm/static/Makefile

@@ -288,6 +288,7 @@ TST_NOFILE	:=				\
 		change_mnt_context		\
 		fd_offset			\
 		massive_groups			\
+		mqueue_peek			\
 #		jobctl00			\
 
 PKG_CONFIG ?= pkg-config
@@ -739,6 +740,8 @@ uprobes:		LDLIBS += $(call pkg-libs, libtracefs libelf)
 
 massive_groups:	LDLIBS += -lrt -pthread
 
+mqueue_peek:	LDLIBS += -lrt -pthread
+
 $(LIB):	force
 	$(Q) $(MAKE) -C $(LIBDIR)
 

test/zdtm/static/mqueue_peek.c

@@ -0,0 +1,85 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <mqueue.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include "zdtmtst.h"
+
+/*
+* This test is just a tempory test to verify that mqueue messages and priorities are retained across C/R. 
+* It sends 3 messages with different priorities, waits for C/R, then receives them back in priority order to verify correct behavior.
+*/
+
+const char *test_doc = "Test that POSIX mqueue retains messages and priorities across C/R.";
+const char *test_author = "SunChao Dong";
+
+int main(int argc, char **argv){
+    mqd_t mq;
+    struct mq_attr attr;
+    
+    char *msg2 = "Hello CRIU, priority 2!";
+    char *msg1 = "Message with priority 1";
+    char *msg0 = "Message with priority 0";
+
+    char buf[1024];
+    unsigned int prio;
+    ssize_t bytes_read;
+
+    test_init(argc, argv);
+
+    attr.mq_flags = 0;
+    attr.mq_maxmsg = 10;
+    attr.mq_msgsize = 1024;
+    attr.mq_curmsgs = 0;
+
+    mq_unlink("/test_queue_zdtm");
+
+    mq = mq_open("/test_queue_zdtm", O_CREAT | O_RDWR, 0644, &attr);
+    if (mq == (mqd_t)-1) {
+        pr_perror("mq_open failed");
+        return 1;
+    }
+    test_msg("Successfully opened /test_queue_zdtm\n");
+
+    if (mq_send(mq, msg1, strlen(msg1) + 1, 1) ||
+        mq_send(mq, msg2, strlen(msg2) + 1, 2) ||
+        mq_send(mq, msg0, strlen(msg0) + 1, 0)) {
+        pr_perror("mq_send failed");
+        return 1;
+    }
+    test_msg("Sent 3 messages with different priorities (1, 2, 0)\n");
+
+    test_daemon();
+    test_msg("Waiting for checkpoint/restore...\n");
+    test_waitsig();
+
+    test_msg("Restored! Verifying mqueue state via standard mq_receive...\n");
+
+    bytes_read = mq_receive(mq, buf, sizeof(buf), &prio);
+    if (bytes_read < 0 || prio != 2 || strcmp(buf, msg2) != 0) {
+        fail("Msg 1 verification failed! expected prio: 2, got prio: %u", prio);
+        return 1;
+    }
+
+    bytes_read = mq_receive(mq, buf, sizeof(buf), &prio);
+    if (bytes_read < 0 || prio != 1 || strcmp(buf, msg1) != 0) {
+        fail("Msg 2 verification failed! expected prio: 1, got prio: %u", prio);
+        return 1;
+    }
+
+    bytes_read = mq_receive(mq, buf, sizeof(buf), &prio);
+    if (bytes_read < 0 || prio != 0 || strcmp(buf, msg0) != 0) {
+        fail("Msg 3 verification failed! expected prio: 0, got prio: %u", prio);
+        return 1;
+    }
+
+    test_msg("All messages received correctly in exact priority order!\n");
+
+    mq_close(mq);
+    mq_unlink("/test_queue_zdtm");
+    pass();
+    return 0;
+}