rpms/criu
7
0
Fork 0
Code Issues Pull Requests Releases Activity

Handle rseq in generic compel code (checkpoint-restore/criu#3097)

Browse Source 
Resolves: RHEL-213241

Signed-off-by: Adrian Reber <areber@redhat.com>
This commit is contained in:
Adrian Reber 2026-07-20 15:31:51 +00:00
parent cf882f3b4b
commit db6693c7d5
3 changed files with 951 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

941
compel-handle-rseq-in-generic-compel-code.patch Normal file
View File

@ -0,0 +1,941 @@
diff --git a/Documentation/compel.txt b/Documentation/compel.txt
index 506228f592..cdca1e6229 100644
--- a/Documentation/compel.txt
+++ b/Documentation/compel.txt
@@ -93,7 +93,7 @@ The parasitic code is compiled and converted to a header using *compel*, and inc
Following steps are performed to infect the victim process:
- stop the task: *int compel_stop_task(int pid);*
- - prepare infection handler: *struct parasite_ctl *compel_prepare(int pid);*
+ - prepare infection handler: *struct parasite_ctl *compel_prepare(int pid, bool handle_rseq);*
- execute system call: *int compel_syscall(ctl, int syscall_nr, long *ret, int arg ...);*
- infect victim: *int compel_infect(ctl, nr_thread, size_of_args_area);*
- cure the victim: *int compel_cure(ctl);* //ctl pointer is freed by this call
diff --git a/compel/include/uapi/infect.h b/compel/include/uapi/infect.h
index 4bbf57c4db..f88d91b1e0 100644
--- a/compel/include/uapi/infect.h
+++ b/compel/include/uapi/infect.h
@@ -47,12 +47,12 @@ extern int compel_resume_task_sig(pid_t pid, int orig_state, int state, int stop
struct parasite_ctl;
struct parasite_thread_ctl;
-extern struct parasite_ctl __must_check *compel_prepare(int pid);
-extern struct parasite_ctl __must_check *compel_prepare_noctx(int pid);
+extern struct parasite_ctl __must_check *compel_prepare(int pid, bool handle_rseq);
+extern struct parasite_ctl __must_check *compel_prepare_noctx(int pid, bool handle_rseq);
extern int __must_check compel_infect(struct parasite_ctl *ctl, unsigned long nr_threads, unsigned long args_size);
extern int __must_check compel_infect_no_daemon(struct parasite_ctl *ctl, unsigned long nr_threads,
unsigned long args_size);
-extern struct parasite_thread_ctl __must_check *compel_prepare_thread(struct parasite_ctl *ctl, int pid);
+extern struct parasite_thread_ctl __must_check *compel_prepare_thread(struct parasite_ctl *ctl, int pid, bool handle_rseq);
extern void compel_release_thread(struct parasite_thread_ctl *);
extern int __must_check compel_start_daemon(struct parasite_ctl *ctl);
diff --git a/compel/src/lib/infect.c b/compel/src/lib/infect.c
index 8f44dbfc3e..b4764ce836 100644
--- a/compel/src/lib/infect.c
+++ b/compel/src/lib/infect.c
@@ -14,6 +14,7 @@
#include "common/xmalloc.h"
#include "common/lock.h"
#include "common/page.h"
+#include "linux/rseq.h"
#include <compel/plugins/std/syscall-codes.h>
#include <compel/plugins/std/asm/syscall-types.h>
@@ -42,7 +43,7 @@
#define SECCOMP_MODE_DISABLED 0
#endif
-static int prepare_thread(int pid, struct thread_ctx *ctx);
+static int prepare_thread(int pid, struct thread_ctx *ctx, bool handle_rseq);
static inline void close_safe(int *pfd)
{
@@ -1111,13 +1112,13 @@ int compel_infect(struct parasite_ctl *ctl, unsigned long nr_threads, unsigned l
return 0;
}
-struct parasite_thread_ctl *compel_prepare_thread(struct parasite_ctl *ctl, int pid)
+struct parasite_thread_ctl *compel_prepare_thread(struct parasite_ctl *ctl, int pid, bool handle_rseq)
{
struct parasite_thread_ctl *tctl;
tctl = xmalloc(sizeof(*tctl));
if (tctl) {
- if (prepare_thread(pid, &tctl->th)) {
+ if (prepare_thread(pid, &tctl->th, handle_rseq)) {
xfree(tctl);
tctl = NULL;
} else {
@@ -1129,7 +1130,117 @@ struct parasite_thread_ctl *compel_prepare_thread(struct parasite_ctl *ctl, int
return tctl;
}
-static int prepare_thread(int pid, struct thread_ctx *ctx)
+#define decode_pointer(x) ((void *)(unsigned long)(x))
+
+static bool task_in_rseq(struct criu_rseq_cs *rseq_cs, uint64_t addr)
+{
+ return addr - rseq_cs->start_ip < rseq_cs->post_commit_offset;
+}
+
+static int read_rseq_cs(pid_t tid, struct __ptrace_rseq_configuration *rseqc, struct criu_rseq_cs *rseq_cs,
+ struct criu_rseq *rseq)
+{
+ int ret;
+
+ if (!rseqc->rseq_abi_pointer)
+ return 0;
+
+ ret = ptrace_peek_area(tid, rseq,
+ decode_pointer(rseqc->rseq_abi_pointer),
+ sizeof(struct criu_rseq));
+ if (ret) {
+ pr_err("ptrace_peek_area(%d, %lx, %lx, %lx): fail to read rseq struct\n",
+ tid, (unsigned long)rseq, (unsigned long)rseqc->rseq_abi_pointer,
+ (unsigned long)sizeof(struct criu_rseq));
+ return -1;
+ }
+
+ if (!rseq->rseq_cs)
+ return 0;
+
+ ret = ptrace_peek_area(tid, rseq_cs,
+ decode_pointer(rseq->rseq_cs),
+ sizeof(struct criu_rseq_cs));
+ if (ret) {
+ pr_err("ptrace_peek_area(%d, %lx, %lx, %lx): fail to read rseq_cs struct\n",
+ tid, (unsigned long)rseq_cs, (unsigned long)rseq->rseq_cs,
+ (unsigned long)sizeof(struct criu_rseq_cs));
+ return -1;
+ }
+
+ return 0;
+}
+
+/*
+ * parasite_thread_rseq checks if the victim process is in an rseq critical
+ * section and, if so, aborts it.
+ */
+static int parasite_thread_rseq(int pid, struct thread_ctx *ctx)
+{
+ struct criu_rseq_cs _rseq_cs = {}, *rseq_cs = &_rseq_cs;
+ struct __ptrace_rseq_configuration rseqc;
+ int ret;
+ struct criu_rseq rseq = {};
+
+ ret = ptrace(PTRACE_GET_RSEQ_CONFIGURATION, pid, sizeof(rseqc), &rseqc);
+ if (ret < 0) {
+ pr_perror("ptrace(PTRACE_GET_RSEQ_CONFIGURATION, %d) = %d", pid, ret);
+ return -1;
+ } else if (ret != sizeof(rseqc)) {
+ pr_err("ptrace(PTRACE_GET_RSEQ_CONFIGURATION, %d) returned unexpected size %d\n", pid, ret);
+ return -1;
+ }
+
+ if (rseqc.flags != 0) {
+ pr_err("something wrong with ptrace(PTRACE_GET_RSEQ_CONFIGURATION, %d) flags = 0x%x\n", pid,
+ rseqc.flags);
+ return -1;
+ }
+
+ pr_debug("rseq of %d: ptr = 0x%lx sign = 0x%x\n", pid, (unsigned long)rseqc.rseq_abi_pointer,
+ rseqc.signature);
+
+ if (read_rseq_cs(pid, &rseqc, rseq_cs, &rseq))
+ return -1;
+
+ if (rseq.rseq_cs) {
+ uint64_t zero_addr = 0;
+
+ pr_debug(
+ "fixup_thread_rseq for %d: rseq_cs start_ip = %llx abort_ip = %llx post_commit_offset = %llx flags = %x version = %x; IP = %lx\n",
+ pid, rseq_cs->start_ip, rseq_cs->abort_ip, rseq_cs->post_commit_offset, rseq_cs->flags,
+ rseq_cs->version, (unsigned long)REG_IP(ctx->regs));
+
+ if (rseq_cs->version != 0) {
+ pr_err("unsupported RSEQ ABI version = %d\n", rseq_cs->version);
+ return -1;
+ }
+
+ if (rseq.flags || rseq_cs->flags)
+ pr_warn("deprecated rseq flags are ignored for %d: rseq.flags = %#x rseq_cs.flags = %#x\n",
+ pid, rseq.flags, rseq_cs->flags);
+
+ if (task_in_rseq(rseq_cs, REG_IP(ctx->regs))) {
+ SET_REG_IP(ctx->regs, rseq_cs->abort_ip);
+ if (ptrace_set_regs(pid, &ctx->regs)) {
+ pr_perror("Can't apply rseq abort registers (pid: %d)", pid);
+ return -1;
+ }
+ }
+
+ if (ptrace_poke_area(pid, &zero_addr,
+ decode_pointer(rseqc.rseq_abi_pointer) +
+ offsetof(struct criu_rseq, rseq_cs),
+ sizeof(zero_addr))) {
+ pr_err("ptrace_poke_area(%d) failed to zero out rseq_cs\n", pid);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int prepare_thread(int pid, struct thread_ctx *ctx, bool handle_rseq)
{
if (ptrace(PTRACE_GETSIGMASK, pid, sizeof(k_rtsigset_t), &ctx->sigmask)) {
pr_perror("can't get signal blocking mask for %d", pid);
@@ -1141,6 +1252,11 @@ static int prepare_thread(int pid, struct thread_ctx *ctx)
return -1;
}
+ if (handle_rseq && parasite_thread_rseq(pid, ctx)) {
+ pr_err("Can't handle rseq (pid: %d)\n", pid);
+ return -1;
+ }
+
return 0;
}
@@ -1153,7 +1269,7 @@ void compel_release_thread(struct parasite_thread_ctl *tctl)
xfree(tctl);
}
-struct parasite_ctl *compel_prepare_noctx(int pid)
+struct parasite_ctl *compel_prepare_noctx(int pid, bool handle_rseq)
{
struct parasite_ctl *ctl = NULL;
@@ -1170,7 +1286,7 @@ struct parasite_ctl *compel_prepare_noctx(int pid)
ctl->tsock = -1;
ctl->ictx.log_fd = -1;
- if (prepare_thread(pid, &ctl->orig))
+ if (prepare_thread(pid, &ctl->orig, handle_rseq))
goto err;
ctl->rpid = pid;
@@ -1346,12 +1462,12 @@ static int make_sigframe_plain(void *from, struct rt_sigframe *f, struct rt_sigf
return 0;
}
-struct parasite_ctl *compel_prepare(int pid)
+struct parasite_ctl *compel_prepare(int pid, bool handle_rseq)
{
struct parasite_ctl *ctl;
struct infect_ctx *ictx;
- ctl = compel_prepare_noctx(pid);
+ ctl = compel_prepare_noctx(pid, handle_rseq);
if (ctl == NULL)
goto out;
diff --git a/compel/test/fdspy/spy.c b/compel/test/fdspy/spy.c
index 41de99e200..35a6805715 100644
--- a/compel/test/fdspy/spy.c
+++ b/compel/test/fdspy/spy.c
@@ -39,7 +39,7 @@ static int do_infection(int pid, int *stolen_fd)
err_and_ret("Can't stop task");
printf("Preparing parasite ctl\n");
- ctl = compel_prepare(pid);
+ ctl = compel_prepare(pid, false);
if (!ctl)
err_and_ret("Can't prepare for infection");
diff --git a/compel/test/infect/spy.c b/compel/test/infect/spy.c
index 143946941e..da9b2d729a 100644
--- a/compel/test/infect/spy.c
+++ b/compel/test/infect/spy.c
@@ -38,7 +38,7 @@ static int do_infection(int pid)
err_and_ret("Can't stop task");
printf("Preparing parasite ctl\n");
- ctl = compel_prepare(pid);
+ ctl = compel_prepare(pid, false);
if (!ctl)
err_and_ret("Can't prepare for infection");
diff --git a/compel/test/rsys/spy.c b/compel/test/rsys/spy.c
index 4a6fcef29c..ca5630332f 100644
--- a/compel/test/rsys/spy.c
+++ b/compel/test/rsys/spy.c
@@ -33,7 +33,7 @@ static int do_rsetsid(int pid)
err_and_ret("Can't stop task");
printf("Preparing parasite ctl\n");
- ctl = compel_prepare(pid);
+ ctl = compel_prepare(pid, false);
if (!ctl)
err_and_ret("Can't prepare for infection");
diff --git a/compel/test/stack/spy.c b/compel/test/stack/spy.c
index 184c8ab318..d0ac16e718 100644
--- a/compel/test/stack/spy.c
+++ b/compel/test/stack/spy.c
@@ -123,7 +123,7 @@ static int do_infection(int pid)
err_and_ret("Can't stop task\n");
printf("Preparing parasite ctl\n");
- ctl = compel_prepare(pid);
+ ctl = compel_prepare(pid, false);
if (!ctl)
err_and_ret("Can't prepare for infection\n");
diff --git a/criu/cr-dump.c b/criu/cr-dump.c
index 6fe7c42e4e..fe3a3edd38 100644
--- a/criu/cr-dump.c
+++ b/criu/cr-dump.c
@@ -30,6 +30,7 @@
#include "images/siginfo.pb-c.h"
#include "common/list.h"
+#include "linux/rseq.h"
#include "imgset.h"
#include "file-ids.h"
#include "kcmp-ids.h"
@@ -908,72 +909,6 @@ static int collect_file_locks(void)
return parse_file_locks();
}
-static bool task_in_rseq(struct criu_rseq_cs *rseq_cs, uint64_t addr)
-{
- return addr >= rseq_cs->start_ip && addr < rseq_cs->start_ip + rseq_cs->post_commit_offset;
-}
-
-static int fixup_thread_rseq(const struct pstree_item *item, int i)
-{
- CoreEntry *core = item->core[i];
- struct criu_rseq_cs *rseq_cs = &dmpi(item)->thread_rseq_cs[i];
- pid_t tid = item->threads[i].real;
-
- if (!kdat.has_ptrace_get_rseq_conf)
- return 0;
-
- /* equivalent to (struct rseq)->rseq_cs is NULL */
- if (!rseq_cs->start_ip)
- return 0;
-
- pr_debug(
- "fixup_thread_rseq for %d: rseq_cs start_ip = %llx abort_ip = %llx post_commit_offset = %llx flags = %x version = %x; IP = %lx\n",
- tid, rseq_cs->start_ip, rseq_cs->abort_ip, rseq_cs->post_commit_offset, rseq_cs->flags,
- rseq_cs->version, (unsigned long)TI_IP(core));
-
- if (rseq_cs->version != 0) {
- pr_err("unsupported RSEQ ABI version = %d\n", rseq_cs->version);
- return -1;
- }
-
- if (task_in_rseq(rseq_cs, TI_IP(core))) {
- struct pid *tid = &item->threads[i];
-
- /*
- * We need to fixup task instruction pointer from
- * the original one (which lays inside rseq critical section)
- * to rseq abort handler address. But we need to look on rseq_cs->flags
- * (please refer to struct rseq -> flags field description).
- * Naive idea of flags support may be like... let's change instruction pointer (IP)
- * to rseq_cs->abort_ip if !(rseq_cs->flags & RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL).
- * But unfortunately, it doesn't work properly, because the kernel does
- * clean up of rseq_cs field in the struct rseq (modifies userspace memory).
- * So, we need to preserve original value of (struct rseq)->rseq_cs field in the
- * image and restore it's value before releasing threads (see restore_rseq_cs()).
- *
- * It's worth to mention that we need to fixup IP in CoreEntry
- * (used when full dump/restore is performed) and also in
- * the parasite regs storage (used if --leave-running option is used,
- * or if dump error occurred and process execution is resumed).
- */
-
- if (!(rseq_cs->flags & RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL)) {
- pr_warn("The %d task is in rseq critical section. IP will be set to rseq abort handler addr\n",
- tid->real);
-
- TI_IP(core) = rseq_cs->abort_ip;
-
- if (item->pid->real == tid->real) {
- compel_set_leader_ip(dmpi(item)->parasite_ctl, rseq_cs->abort_ip);
- } else {
- compel_set_thread_ip(dmpi(item)->thread_ctls[i], rseq_cs->abort_ip);
- }
- }
- }
-
- return 0;
-}
-
static int dump_task_thread(struct parasite_ctl *parasite_ctl, const struct pstree_item *item, int id)
{
struct parasite_thread_ctl *tctl = dmpi(item)->thread_ctls[id];
@@ -997,12 +932,6 @@ static int dump_task_thread(struct parasite_ctl *parasite_ctl, const struct pstr
core->thread_core->creds->lsm_profile = dmpi(item)->thread_lsms[id]->profile;
core->thread_core->creds->lsm_sockcreate = dmpi(item)->thread_lsms[0]->sockcreate;
- ret = fixup_thread_rseq(item, id);
- if (ret) {
- pr_err("Can't fixup rseq for pid %d\n", pid);
- goto err;
- }
-
img = open_image(CR_FD_CORE, O_DUMP, tid->ns[0].virt);
if (!img)
goto err;
@@ -1148,48 +1077,6 @@ static int dump_task_signals(pid_t pid, struct pstree_item *item)
return 0;
}
-static int read_rseq_cs(pid_t tid, struct __ptrace_rseq_configuration *rseqc, struct criu_rseq_cs *rseq_cs,
- struct criu_rseq *rseq)
-{
- int ret;
-
- /* rseq is not registered */
- if (!rseqc->rseq_abi_pointer)
- return 0;
-
- /*
- * We need to cover the case when victim process was inside rseq critical section
- * at the moment when CRIU comes and seized it. We need to determine the borders
- * of rseq critical section at first. To achieve that we need to access thread
- * memory and read pointer to struct rseq_cs.
- *
- * We have two ways to access thread memory: from the parasite and using ptrace().
- * But it this case we can't use parasite, because if victim process returns to the
- * execution, on the kernel side __rseq_handle_notify_resume hook will be called,
- * then rseq_ip_fixup() -> clear_rseq_cs() and user space memory with struct rseq
- * will be cleared. So, let's use ptrace(PTRACE_PEEKDATA).
- */
- ret = ptrace_peek_area(tid, rseq, decode_pointer(rseqc->rseq_abi_pointer), sizeof(struct criu_rseq));
- if (ret) {
- pr_err("ptrace_peek_area(%d, %lx, %lx, %lx): fail to read rseq struct\n", tid, (unsigned long)rseq,
- (unsigned long)(rseqc->rseq_abi_pointer), (unsigned long)sizeof(uint64_t));
- return -1;
- }
-
- if (!rseq->rseq_cs)
- return 0;
-
- ret = ptrace_peek_area(tid, rseq_cs, decode_pointer(rseq->rseq_cs), sizeof(struct criu_rseq_cs));
- if (ret) {
- pr_err("ptrace_peek_area(%d, %lx, %lx, %lx): fail to read rseq_cs struct\n", tid,
- (unsigned long)rseq_cs, (unsigned long)rseq->rseq_cs,
- (unsigned long)sizeof(struct criu_rseq_cs));
- return -1;
- }
-
- return 0;
-}
-
static int dump_thread_rseq(struct pstree_item *item, int i)
{
struct __ptrace_rseq_configuration rseqc;
@@ -1197,8 +1084,6 @@ static int dump_thread_rseq(struct pstree_item *item, int i)
int ret;
CoreEntry *core = item->core[i];
RseqEntry **rseqep = &core->thread_core->rseq_entry;
- struct criu_rseq rseq = {};
- struct criu_rseq_cs *rseq_cs = &dmpi(item)->thread_rseq_cs[i];
pid_t tid = item->threads[i].real;
/*
@@ -1237,56 +1122,26 @@ static int dump_thread_rseq(struct pstree_item *item, int i)
rseqe->rseq_abi_size = rseqc.rseq_abi_size;
rseqe->signature = rseqc.signature;
- if (read_rseq_cs(tid, &rseqc, rseq_cs, &rseq))
- goto err;
-
- /* we won't save rseq_cs to the image (only pointer),
- * so let's combine flags from both struct rseq and struct rseq_cs
- * (kernel does the same when interpreting RSEQ_CS_FLAG_*)
- */
- rseq_cs->flags |= rseq.flags;
-
- if (rseq_cs->flags & RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL) {
- rseqe->has_rseq_cs_pointer = true;
- rseqe->rseq_cs_pointer = rseq.rseq_cs;
- }
-
/* save rseq entry to the image */
*rseqep = rseqe;
return 0;
-
-err:
- xfree(rseqe);
- return -1;
}
static int dump_task_rseq(pid_t pid, struct pstree_item *item)
{
int i;
- struct criu_rseq_cs *thread_rseq_cs;
/* if rseq() syscall isn't supported then nothing to dump */
if (!kdat.has_rseq)
return 0;
- thread_rseq_cs = xzalloc(sizeof(*thread_rseq_cs) * item->nr_threads);
- if (!thread_rseq_cs)
- return -1;
-
- dmpi(item)->thread_rseq_cs = thread_rseq_cs;
-
for (i = 0; i < item->nr_threads; i++) {
if (dump_thread_rseq(item, i))
- goto free_rseq;
+ return -1;
}
return 0;
-
-free_rseq:
- xfree(thread_rseq_cs);
- dmpi(item)->thread_rseq_cs = NULL;
- return -1;
}
static struct proc_pid_stat pps_buf;
@@ -1306,8 +1161,6 @@ static int dump_task_threads(struct parasite_ctl *parasite_ctl, const struct pst
break;
}
- xfree(dmpi(item)->thread_rseq_cs);
- dmpi(item)->thread_rseq_cs = NULL;
return ret;
}
@@ -1632,12 +1485,6 @@ static int dump_one_task(struct pstree_item *item, InventoryEntry *parent_ie)
goto err;
}
- ret = fixup_thread_rseq(item, 0);
- if (ret) {
- pr_err("Fixup rseq for %d failed %d\n", pid, ret);
- goto err;
- }
-
if (fault_injected(FI_DUMP_EARLY)) {
pr_info("fault: CRIU sudden detach\n");
kill(getpid(), SIGKILL);
diff --git a/criu/cr-restore.c b/criu/cr-restore.c
index 7579639a20..d8164366a0 100644
--- a/criu/cr-restore.c
+++ b/criu/cr-restore.c
@@ -25,6 +25,13 @@
#include "linux/rseq.h"
+#ifdef __has_include
+#if __has_include("sys/rseq.h")
+#include <sys/rseq.h>
+#include "asm/thread_pointer.h"
+#endif
+#endif
+
#include "clone-noasan.h"
#include "cr_options.h"
#include "servicefd.h"
@@ -1922,7 +1929,7 @@ static void finalize_restore(void)
continue;
/* Unmap the restorer blob */
- ctl = compel_prepare_noctx(pid);
+ ctl = compel_prepare_noctx(pid, false);
if (ctl == NULL)
continue;
diff --git a/criu/include/pstree.h b/criu/include/pstree.h
index b750a919e6..b501ded721 100644
--- a/criu/include/pstree.h
+++ b/criu/include/pstree.h
@@ -63,7 +63,6 @@ struct dmp_info {
struct parasite_ctl *parasite_ctl;
struct parasite_thread_ctl **thread_ctls;
uint64_t *thread_sp;
- struct criu_rseq_cs *thread_rseq_cs;
/*
* Although we don't support dumping different struct creds in general,
diff --git a/criu/parasite-syscall.c b/criu/parasite-syscall.c
index c2d9ad976b..1d8a388c85 100644
--- a/criu/parasite-syscall.c
+++ b/criu/parasite-syscall.c
@@ -339,6 +339,7 @@ static int make_sigframe(void *arg, struct rt_sigframe *sf, struct rt_sigframe *
static int parasite_prepare_threads(struct parasite_ctl *ctl, struct pstree_item *item)
{
+ bool handle_rseq = kdat.has_ptrace_get_rseq_conf;
struct parasite_thread_ctl **thread_ctls;
uint64_t *thread_sp;
int i;
@@ -359,7 +360,7 @@ static int parasite_prepare_threads(struct parasite_ctl *ctl, struct pstree_item
continue;
}
- thread_ctls[i] = compel_prepare_thread(ctl, tid->real);
+ thread_ctls[i] = compel_prepare_thread(ctl, tid->real, handle_rseq);
if (!thread_ctls[i])
goto free_sp;
@@ -380,6 +381,7 @@ static int parasite_prepare_threads(struct parasite_ctl *ctl, struct pstree_item
struct parasite_ctl *parasite_infect_seized(pid_t pid, struct pstree_item *item, struct vm_area_list *vma_area_list)
{
+ bool handle_rseq = kdat.has_ptrace_get_rseq_conf;
struct parasite_ctl *ctl;
struct infect_ctx *ictx;
unsigned long p;
@@ -393,7 +395,7 @@ struct parasite_ctl *parasite_infect_seized(pid_t pid, struct pstree_item *item,
return NULL;
}
- ctl = compel_prepare_noctx(pid);
+ ctl = compel_prepare_noctx(pid, handle_rseq);
if (!ctl)
return NULL;
diff --git a/criu/include/linux/rseq.h b/include/linux/rseq.h
similarity index 98%
rename from criu/include/linux/rseq.h
rename to include/linux/rseq.h
index 5ceefbf8e1..4ffc1a4f37 100644
--- a/criu/include/linux/rseq.h
+++ b/include/linux/rseq.h
@@ -2,13 +2,6 @@
#ifndef _UAPI_LINUX_RSEQ_H
#define _UAPI_LINUX_RSEQ_H
-#ifdef __has_include
-#if __has_include("sys/rseq.h")
-#include <sys/rseq.h>
-#include "asm/thread_pointer.h"
-#endif
-#endif
-
#include <linux/types.h>
#include <asm/byteorder.h>
@@ -43,6 +36,8 @@ enum rseq_cs_flags {
RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL = (1U << RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT),
RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE = (1U << RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT),
};
+#else
+#include <sys/rseq.h>
#endif /* CONFIG_HAS_NO_LIBC_RSEQ_DEFS */
/*
diff --git a/test/zdtm/transition/Makefile b/test/zdtm/transition/Makefile
index ddf2faaad1..8ed9248c7e 100644
--- a/test/zdtm/transition/Makefile
+++ b/test/zdtm/transition/Makefile
@@ -25,6 +25,7 @@ TST_NOFILE = \
pidfd_store_sk \
rseq01 \
rseq02 \
+ rseq03 \
stack \
diff --git a/test/zdtm/transition/rseq03.c b/test/zdtm/transition/rseq03.c
new file mode 100644
index 0000000000..5f3633b71b
--- /dev/null
+++ b/test/zdtm/transition/rseq03.c
@@ -0,0 +1,287 @@
+/*
+ * test for rseq() syscall
+ * See also https://www.efficios.com/blog/2019/02/08/linux-restartable-sequences/
+ * https://github.com/torvalds/linux/commit/d7822b1e24f2df5df98c76f0e94a5416349ff759
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <syscall.h>
+
+#include "zdtmtst.h"
+#include "lock.h"
+
+#ifdef __has_include
+#if __has_include("sys/rseq.h")
+#include <sys/rseq.h>
+#endif
+#endif
+
+#if defined(__x86_64__)
+
+#if defined(RSEQ_SIG)
+static inline void *__criu_thread_pointer(void)
+{
+#if __GNUC_PREREQ(11, 1)
+ return __builtin_thread_pointer();
+#else
+ void *__result;
+#ifdef __x86_64__
+ __asm__("mov %%fs:0, %0" : "=r"(__result));
+#else
+ __asm__("mov %%gs:0, %0" : "=r"(__result));
+#endif /* __x86_64__ */
+ return __result;
+#endif /* !GCC 11 */
+}
+
+static inline void unregister_glibc_rseq(void)
+{
+ struct rseq *rseq = (struct rseq *)((char *)__criu_thread_pointer() + __rseq_offset);
+ unsigned int size = __rseq_size;
+
+ /* hack: mark glibc rseq structure as failed to register */
+ rseq->cpu_id = RSEQ_CPU_ID_REGISTRATION_FAILED;
+
+ /* unregister rseq */
+ if (__rseq_size < 32)
+ size = 32;
+ syscall(__NR_rseq, (void *)rseq, size, 1, RSEQ_SIG);
+}
+#else
+static inline void unregister_glibc_rseq(void)
+{
+}
+#endif /* defined(RSEQ_SIG) */
+
+const char *test_doc = "Check rseq() critical section abort during C/R";
+const char *test_author = "Alexander Mikhalitsyn <alexander.mikhalitsyn@virtuozzo.com>";
+
+#ifndef RSEQ_SIG
+
+enum rseq_flags {
+ RSEQ_FLAG_UNREGISTER = (1 << 0),
+};
+
+struct rseq {
+ uint32_t cpu_id_start;
+ uint32_t cpu_id;
+ uint64_t rseq_cs;
+ uint32_t flags;
+} __attribute__((aligned(4 * sizeof(uint64_t))));
+
+struct rseq_cs {
+ /* Version of this structure. */
+ uint32_t version;
+ /* enum rseq_cs_flags */
+ uint32_t flags;
+ uint64_t start_ip;
+ /* Offset from start_ip. */
+ uint64_t post_commit_offset;
+ uint64_t abort_ip;
+} __attribute__((aligned(4 * sizeof(__u64))));
+
+#define RSEQ_SIG 0x53053053
+
+#endif /* RSEQ_SIG */
+
+#ifndef __NR_rseq
+#define __NR_rseq 334
+#endif
+/* EOF */
+
+extern futex_t sig_received;
+
+static __thread volatile struct rseq __rseq_abi __attribute__((aligned(64)));
+static __thread volatile struct rseq_cs __rseq_cs __attribute__((aligned(64)));
+
+static __thread volatile int rseq_state = 0;
+
+static int sys_rseq(volatile struct rseq *rseq_abi, uint32_t rseq_len, int flags, uint32_t sig)
+{
+ return syscall(__NR_rseq, rseq_abi, rseq_len, flags, sig);
+}
+
+/*
+ * Return the rseq registration size. Starting with Linux 7.0,
+ * AT_RSEQ_ALIGN is 64 but the feature size is 33, so sizeof(struct rseq)
+ * (padded to alignment) no longer matches the registration size the kernel
+ * expects. Use __rseq_size when available, clamped to a minimum of 32
+ * for older kernels.
+ */
+static uint32_t rseq_reg_size(void)
+{
+#if defined(RSEQ_SIG) && defined(__rseq_size)
+ if (__rseq_size)
+ return (__rseq_size < 32) ? 32 : __rseq_size;
+#endif
+ return sizeof(struct rseq);
+}
+
+static unsigned long mmap_min_addr = 0x10000UL;
+
+/*
+ * Machine code for x86_64 that emulates:
+ * __rseq_abi.rseq_cs = &__rseq_cs;
+ * rseq_state = 1;
+ * while (futex_get(f) == 0) {
+ * if (__rseq_abi.rseq_cs != &__rseq_cs)
+ * return;
+ * }
+ * __rseq_abi.rseq_cs = 0;
+ * rseq_state = 0;
+ *
+ * Disassembly:
+ * 0x0: 48 89 37 mov %rsi,(%rdi) // set __rseq_abi.rseq_cs = &__rseq_cs
+ * 0x3: c7 01 01 00 00 00 movl $1,(%rcx) // set rseq_state = 1
+ * 0x9: 48 39 37 cmp %rsi,(%rdi) // check if __rseq_abi.rseq_cs == &__rseq_cs
+ * 0xc: 75 13 jne 0x21 // if not equal, break out (jump to ret)
+ * 0xe: 8b 02 mov (%rdx),%eax // load *f
+ * 0x10: 85 c0 test %eax,%eax // check if 0
+ * 0x12: 74 f5 je 0x9 // spin while *f == 0
+ * 0x14: 48 c7 07 00 00 00 00 movq $0,(%rdi) // clear __rseq_abi.rseq_cs on exit
+ * 0x1b: c7 01 00 00 00 00 movl $0,(%rcx) // set rseq_state = 0
+ * 0x21: c3 ret // return
+ */
+static const uint8_t test_go_rseq_code[] = {
+ 0x48, 0x89, 0x37,
+ 0xc7, 0x01, 0x01, 0x00, 0x00, 0x00,
+ 0x48, 0x39, 0x37,
+ 0x75, 0x13,
+ 0x8b, 0x02,
+ 0x85, 0xc0,
+ 0x74, 0xf5,
+ 0x48, 0xc7, 0x07, 0x00, 0x00, 0x00, 0x00,
+ 0xc7, 0x01, 0x00, 0x00, 0x00, 0x00,
+ 0xc3,
+};
+
+/*
+ * Machine code for the rseq abort section:
+ * rseq_state = 0;
+ * return;
+ *
+ * Disassembly:
+ * 0: c7 01 00 00 00 00 movl $0,(%rcx) // set rseq_state = 0
+ * 6: c3 ret // return
+ */
+static const uint8_t test_go_rseq_abort_code[] = {
+ 0xc7, 0x01, 0x00, 0x00, 0x00, 0x00,
+ 0xc3,
+};
+
+static void register_thread(void)
+{
+ int rc;
+ void *addr;
+
+ addr = mmap((void *)mmap_min_addr, 4096, PROT_READ | PROT_WRITE | PROT_EXEC,
+ MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+ if (addr == MAP_FAILED)
+ addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE | PROT_EXEC,
+ MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+ if (addr == MAP_FAILED) {
+ fail("Failed to mmap rseq critical section area");
+ exit(1);
+ }
+
+ memcpy(addr, test_go_rseq_code, sizeof(test_go_rseq_code));
+
+ __rseq_cs.start_ip = (uint64_t)addr;
+ __rseq_cs.post_commit_offset = 2048;
+ __rseq_cs.abort_ip = __rseq_cs.start_ip + 2048;
+ *((uint32_t *)__rseq_cs.abort_ip - 1) = RSEQ_SIG;
+ memcpy((void *)__rseq_cs.abort_ip, test_go_rseq_abort_code,
+ sizeof(test_go_rseq_abort_code));
+
+ unregister_glibc_rseq();
+ rc = sys_rseq(&__rseq_abi, rseq_reg_size(), 0, RSEQ_SIG);
+ if (rc) {
+ fail("Failed to register rseq");
+ exit(1);
+ }
+}
+
+static void check_thread(void)
+{
+ int rc;
+ rc = sys_rseq(&__rseq_abi, rseq_reg_size(), 0, RSEQ_SIG);
+ if (!(rc && errno == EBUSY)) {
+ fail("Failed to check rseq %d", rc);
+ exit(1);
+ }
+}
+
+static void test_go_rseq(futex_t *f)
+{
+ void (*fn)(void *, volatile struct rseq_cs *, futex_t *, volatile int *) =
+ (void (*)(void *, volatile struct rseq_cs *, futex_t *, volatile int *))__rseq_cs.start_ip;
+
+ while (futex_get(f) == 0) {
+ fn((void *)&__rseq_abi.rseq_cs, &__rseq_cs, f, &rseq_state);
+ if (rseq_state != 0) {
+ fail("rseq_state is %d (expected 0)", rseq_state);
+ exit(1);
+ }
+ }
+}
+
+static void *tfunc(void *args)
+{
+ register_thread();
+ test_go_rseq(&sig_received);
+ check_thread();
+ return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+ pthread_t th;
+ int ret;
+
+ test_init(argc, argv);
+
+ ret = pthread_create(&th, NULL, tfunc, NULL);
+ if (ret) {
+ pr_err("pthread_create -> %d\n", ret);
+ return 1;
+ }
+
+ register_thread();
+
+ test_daemon();
+ test_go_rseq(&sig_received);
+
+ ret = pthread_join(th, NULL);
+ if (ret) {
+ pr_err("pthread_join -> %d\n", ret);
+ return 1;
+ }
+ check_thread();
+
+ pass();
+ return 0;
+}
+
+#else /* #if defined(__x86_64__) */
+
+int main(int argc, char *argv[])
+{
+ test_init(argc, argv);
+ skip("Unsupported arch");
+ test_daemon();
+ test_waitsig();
+ pass();
+ return 0;
+}
+
+#endif /* #if defined(__x86_64__) */
diff --git a/test/zdtm/transition/rseq03.desc b/test/zdtm/transition/rseq03.desc
new file mode 100644
index 0000000000..113feaee18
--- /dev/null
+++ b/test/zdtm/transition/rseq03.desc
@@ -0,0 +1 @@
+{'arch': 'x86_64', 'feature': 'get_rseq_conf'}

11
criu.spec
View File

@ -7,7 +7,7 @@
Name: criu
Version: 3.19
Release: 5%{?dist}
Release: 6%{?dist}
Provides: crtools = %{version}-%{release}
Obsoletes: crtools <= 1.0-2
Summary: Tool for Checkpoint/Restore in User-space
@ -38,6 +38,9 @@ Patch2: https://github.com/checkpoint-restore/criu/pull/2587.patch
# Update restartable sequences to latest upstream code
Patch3: https://github.com/checkpoint-restore/criu/commit/089345f77a34d1bc7ef146d650636afcd3cdda21.patch
# Based on https://github.com/checkpoint-restore/criu/pull/3097
Patch4: compel-handle-rseq-in-generic-compel-code.patch
# user-space and kernel changes are only available for x86_64, arm,
# ppc64le, aarch64 and s390x
# https://bugzilla.redhat.com/show_bug.cgi?id=902875
@ -86,6 +89,7 @@ their content in human-readable form.
%patch -P 1 -p1
%patch -P 2 -p1
%patch -P 3 -p1
%patch -P 4 -p1
%build
# CRIU's parasite/restorer code (criu/pie/) is compiled with its own CFLAGS
@ -160,7 +164,10 @@ rm $RPM_BUILD_ROOT%{_mandir}/man1/criu-ns.1*
%doc %{_mandir}/man1/crit.1*
%changelog
* Wed Mar 05 2026 Adrian Reber <areber@redhat.com> - 3.19-5
* Mon Jul 20 2026 Adrian Reber <areber@redhat.com> - 3.19-6
- Handle rseq in generic compel code (checkpoint-restore/criu#3097)
* Thu Mar 05 2026 Adrian Reber <areber@redhat.com> - 3.19-5
- Recommends: iptables
* Mon Mar 02 2026 Christopher Lusk <clusk@redhat.com> - 3.19-4

1
tests/tests.yml
View File

@ -9,6 +9,7 @@
- classic
required_packages:
- podman
- nftables
- curl
- jq
- checkpolicy