[4/4] compel: add prefix to TASK_ defines

Submitted by Kir Kolyshkin on Feb. 8, 2017, 2:36 p.m.

Details

Message ID 20170208143613.21171-5-kir@openvz.org
State New
Series "compel uapi cleanups"
Headers show

Commit Message

Kir Kolyshkin Feb. 8, 2017, 2:36 p.m.
This patch adds COMPEL_ prefix to TASK_* defines used by compel
and criu, and also removes their duplicated definitions from
criu/include/pid.h

Signed-off-by: Kir Kolyshkin <kir@openvz.org>
---
 compel/include/uapi/infect.h | 24 +++++++++++++++---------
 compel/src/lib/infect.c      | 20 ++++++++++----------
 criu/cr-dump.c               | 26 +++++++++++++-------------
 criu/cr-restore.c            | 34 +++++++++++++++++-----------------
 criu/cr-service.c            |  2 +-
 criu/crtools.c               | 10 +++++-----
 criu/files-reg.c             |  8 ++++----
 criu/image.c                 |  2 +-
 criu/include/pid.h           | 10 +---------
 criu/include/pstree.h        |  3 ++-
 criu/proc_parse.c            |  2 +-
 criu/pstree.c                | 22 +++++++++++-----------
 criu/seccomp.c               |  2 +-
 criu/seize.c                 | 30 +++++++++++++++---------------
 criu/tty.c                   |  2 +-
 15 files changed, 98 insertions(+), 99 deletions(-)

Patch hide | download patch | download mbox

diff --git a/compel/include/uapi/infect.h b/compel/include/uapi/infect.h
index 5c47555..910e7a2 100644
--- a/compel/include/uapi/infect.h
+++ b/compel/include/uapi/infect.h
@@ -22,6 +22,21 @@  struct seize_task_status {
 	int			seccomp_mode;
 };
 
+/*
+ * Task state, as returned by compel_wait_task().
+ * Also used in other functions.
+ */
+enum
+{
+	COMPEL_TASK_UNDEF	= 0x0,
+	COMPEL_TASK_ALIVE	= 0x1,
+	COMPEL_TASK_DEAD	= 0x2,
+	COMPEL_TASK_STOPPED	= 0x3,
+	COMPEL_TASK_HELPER	= 0x4,
+	COMPEL_TASK_THREAD	= 0x5,
+	COMPEL_TASK_ZOMBIE	= 0x6,
+};
+
 extern int compel_wait_task(int pid, int ppid,
 		int (*get_status)(int pid, struct seize_task_status *),
 		struct seize_task_status *st);
@@ -29,15 +44,6 @@  extern int compel_wait_task(int pid, int ppid,
 extern int compel_stop_task(int pid);
 extern int compel_resume_task(pid_t pid, int orig_state, int state);
 
-/*
- * FIXME -- these should be mapped to pid.h's
- */
-
-#define TASK_ALIVE		0x1
-#define TASK_DEAD		0x2
-#define TASK_STOPPED		0x3
-#define TASK_ZOMBIE		0x6
-
 struct parasite_ctl;
 struct parasite_thread_ctl;
 
diff --git a/compel/src/lib/infect.c b/compel/src/lib/infect.c
index 8f36379..f6d4a44 100644
--- a/compel/src/lib/infect.c
+++ b/compel/src/lib/infect.c
@@ -235,9 +235,9 @@  try_again:
 		}
 
 		if (ret < 0)
-			return TASK_ZOMBIE;
+			return COMPEL_TASK_ZOMBIE;
 		else
-			return TASK_DEAD;
+			return COMPEL_TASK_DEAD;
 	}
 
 	if ((ppid != -1) && (ss->ppid != ppid)) {
@@ -289,11 +289,11 @@  try_again:
 		if (skip_sigstop(pid, nr_sigstop))
 			goto err_stop;
 
-		return TASK_STOPPED;
+		return COMPEL_TASK_STOPPED;
 	}
 
 	if (si.si_signo == SIGTRAP)
-		return TASK_ALIVE;
+		return COMPEL_TASK_ALIVE;
 	else {
 		pr_err("SEIZE %d: unsupported stop signal %d\n", pid, si.si_signo);
 		goto err;
@@ -311,25 +311,25 @@  int compel_resume_task(pid_t pid, int orig_st, int st)
 {
 	pr_debug("\tUnseizing %d into %d\n", pid, st);
 
-	if (st == TASK_DEAD) {
+	if (st == COMPEL_TASK_DEAD) {
 		kill(pid, SIGKILL);
 		return 0;
-	} else if (st == TASK_STOPPED) {
+	} else if (st == COMPEL_TASK_STOPPED) {
 		/*
 		 * Task might have had STOP in queue. We detected such
-		 * guy as TASK_STOPPED, but cleared signal to run the
-		 * parasite code. hus after detach the task will become
+		 * guy as COMPEL_TASK_STOPPED, but cleared signal to run
+		 * the parasite code. Thus after detach the task will be
 		 * running. That said -- STOP everyone regardless of
 		 * the initial state.
 		 */
 		kill(pid, SIGSTOP);
-	} else if (st == TASK_ALIVE) {
+	} else if (st == COMPEL_TASK_ALIVE) {
 		/*
 		 * Same as in the comment above -- there might be a
 		 * task with STOP in queue that would get lost after
 		 * detach, so stop it again.
 		 */
-		if (orig_st == TASK_STOPPED)
+		if (orig_st == COMPEL_TASK_STOPPED)
 			kill(pid, SIGSTOP);
 	} else
 		pr_err("Unknown final state %d\n", st);
diff --git a/criu/cr-dump.c b/criu/cr-dump.c
index 8ccb5cb..b9e6ab6 100644
--- a/criu/cr-dump.c
+++ b/criu/cr-dump.c
@@ -642,7 +642,7 @@  int get_task_ids(struct pstree_item *item)
 
 	task_kobj_ids_entry__init(item->ids);
 
-	if (item->pid->state != TASK_DEAD) {
+	if (item->pid->state != COMPEL_TASK_DEAD) {
 		ret = dump_task_kobj_ids(item);
 		if (ret)
 			goto err_free;
@@ -784,14 +784,14 @@  static int collect_pstree_ids_predump(void)
 	 * write_img_inventory().
 	 */
 
-	crt.i.pid->state = TASK_ALIVE;
+	crt.i.pid->state = COMPEL_TASK_ALIVE;
 	crt.i.pid->real = getpid();
 
 	if (predump_task_ns_ids(&crt.i))
 		return -1;
 
 	for_each_pstree_item(item) {
-		if (item->pid->state == TASK_DEAD)
+		if (item->pid->state == COMPEL_TASK_DEAD)
 			continue;
 
 		if (predump_task_ns_ids(item))
@@ -861,7 +861,7 @@  static int dump_one_zombie(const struct pstree_item *item,
 		return -1;
 
 	strlcpy((char *)core->tc->comm, pps->comm, TASK_COMM_LEN);
-	core->tc->task_state = TASK_DEAD;
+	core->tc->task_state = COMPEL_TASK_DEAD;
 	core->tc->exit_code = pps->exit_code;
 
 	img = open_image(CR_FD_CORE, O_DUMP, item->pid->ns[0].virt);
@@ -1077,7 +1077,7 @@  static int dump_zombies(void)
 	 */
 
 	for_each_pstree_item(item) {
-		if (item->pid->state != TASK_DEAD)
+		if (item->pid->state != COMPEL_TASK_DEAD)
 			continue;
 
 		if (item->pid->ns[0].virt < 0) {
@@ -1126,12 +1126,12 @@  static int pre_dump_one_task(struct pstree_item *item)
 	pr_info("Pre-dumping task (pid: %d)\n", pid);
 	pr_info("========================================\n");
 
-	if (item->pid->state == TASK_STOPPED) {
+	if (item->pid->state == COMPEL_TASK_STOPPED) {
 		pr_warn("Stopped tasks are not supported\n");
 		return 0;
 	}
 
-	if (item->pid->state == TASK_DEAD)
+	if (item->pid->state == COMPEL_TASK_DEAD)
 		return 0;
 
 	ret = collect_mappings(pid, &vmas, NULL);
@@ -1206,7 +1206,7 @@  static int dump_one_task(struct pstree_item *item)
 	pr_info("Dumping task (pid: %d)\n", pid);
 	pr_info("========================================\n");
 
-	if (item->pid->state == TASK_DEAD)
+	if (item->pid->state == COMPEL_TASK_DEAD)
 		/*
 		 * zombies are dumped separately in dump_zombies()
 		 */
@@ -1446,7 +1446,7 @@  static int cr_pre_dump_finish(int ret)
 {
 	struct pstree_item *item;
 
-	pstree_switch_state(root_item, TASK_ALIVE);
+	pstree_switch_state(root_item, COMPEL_TASK_ALIVE);
 
 	timing_stop(TIME_FROZEN);
 
@@ -1520,9 +1520,9 @@  int cr_pre_dump_tasks(pid_t pid)
 		opts.track_mem = true;
 	}
 
-	if (opts.final_state == TASK_DEAD) {
+	if (opts.final_state == COMPEL_TASK_DEAD) {
 		pr_info("Enforcing tasks run after pre-dump.\n");
-		opts.final_state = TASK_ALIVE;
+		opts.final_state = COMPEL_TASK_ALIVE;
 	}
 
 	if (init_stats(DUMP_STATS))
@@ -1649,7 +1649,7 @@  static int cr_dump_finish(int ret)
 	 *    consistency of the FS and other resources, we simply
 	 *    start rollback procedure and cleanup everyhting.
 	 */
-	if (ret || post_dump_ret || opts.final_state == TASK_ALIVE) {
+	if (ret || post_dump_ret || opts.final_state == COMPEL_TASK_ALIVE) {
 		network_unlock();
 		delete_link_remaps();
 		clean_cr_time_mounts();
@@ -1660,7 +1660,7 @@  static int cr_dump_finish(int ret)
 
 	pstree_switch_state(root_item,
 			    (ret || post_dump_ret) ?
-			    TASK_ALIVE : opts.final_state);
+			    COMPEL_TASK_ALIVE : opts.final_state);
 	timing_stop(TIME_FROZEN);
 	free_pstree(root_item);
 	free_file_locks();
diff --git a/criu/cr-restore.c b/criu/cr-restore.c
index 9acde67..3175690 100644
--- a/criu/cr-restore.c
+++ b/criu/cr-restore.c
@@ -245,7 +245,7 @@  static int root_prepare_shared(void)
 	}
 
 	for_each_pstree_item(pi) {
-		if (pi->pid->state == TASK_HELPER)
+		if (pi->pid->state == COMPEL_TASK_HELPER)
 			continue;
 
 		ret = prepare_mm_pid(pi);
@@ -523,8 +523,8 @@  static int collect_child_pids(int state, unsigned int *n)
 
 	if (current == root_item) {
 		for_each_pstree_item(pi) {
-			if (pi->pid->state != TASK_HELPER &&
-			    pi->pid->state != TASK_DEAD)
+			if (pi->pid->state != COMPEL_TASK_HELPER &&
+			    pi->pid->state != COMPEL_TASK_DEAD)
 				continue;
 			if (__collect_child_pids(pi, state, n))
 				return -1;
@@ -537,13 +537,13 @@  static int collect_child_pids(int state, unsigned int *n)
 static int collect_helper_pids(struct task_restore_args *ta)
 {
 	ta->helpers = (pid_t *)rst_mem_align_cpos(RM_PRIVATE);
-	return collect_child_pids(TASK_HELPER, &ta->helpers_n);
+	return collect_child_pids(COMPEL_TASK_HELPER, &ta->helpers_n);
 }
 
 static int collect_zombie_pids(struct task_restore_args *ta)
 {
 	ta->zombies = (pid_t *)rst_mem_align_cpos(RM_PRIVATE);
-	return collect_child_pids(TASK_DEAD, &ta->zombies_n);
+	return collect_child_pids(COMPEL_TASK_DEAD, &ta->zombies_n);
 }
 
 static int open_core(int pid, CoreEntry **pcore)
@@ -780,13 +780,13 @@  static int wait_on_helpers_zombies(void)
 		int status;
 
 		switch (pi->pid->state) {
-		case TASK_DEAD:
+		case COMPEL_TASK_DEAD:
 			if (waitid(P_PID, pid, NULL, WNOWAIT | WEXITED) < 0) {
 				pr_perror("Wait on %d zombie failed", pid);
 				return -1;
 			}
 			break;
-		case TASK_HELPER:
+		case COMPEL_TASK_HELPER:
 			if (waitpid(pid, &status, 0) != pid) {
 				pr_perror("waitpid for helper %d failed", pid);
 				return -1;
@@ -857,7 +857,7 @@  static int check_core(CoreEntry *core, struct pstree_item *me)
 		goto out;
 	}
 
-	if (core->tc->task_state != TASK_DEAD) {
+	if (core->tc->task_state != COMPEL_TASK_DEAD) {
 		if (!core->ids && !me->ids) {
 			pr_err("Core IDS data missed for non-zombie\n");
 			goto out;
@@ -882,9 +882,9 @@  static int restore_one_task(int pid, CoreEntry *core)
 
 	if (task_alive(current))
 		ret = restore_one_alive_task(pid, core);
-	else if (current->pid->state == TASK_DEAD)
+	else if (current->pid->state == COMPEL_TASK_DEAD)
 		ret = restore_one_zombie(core);
-	else if (current->pid->state == TASK_HELPER) {
+	else if (current->pid->state == COMPEL_TASK_HELPER) {
 		sigset_t blockmask, oldmask;
 
 		sigemptyset(&blockmask);
@@ -969,7 +969,7 @@  static inline int fork_with_pid(struct pstree_item *item)
 	int ret = -1;
 	pid_t pid = item->pid->ns[0].virt;
 
-	if (item->pid->state != TASK_HELPER) {
+	if (item->pid->state != COMPEL_TASK_HELPER) {
 		if (open_core(pid, &ca.core))
 			return -1;
 
@@ -981,7 +981,7 @@  static inline int fork_with_pid(struct pstree_item *item)
 
 		rsti(item)->has_seccomp = ca.core->tc->seccomp_mode != SECCOMP_MODE_DISABLED;
 
-		if (item->pid->state != TASK_DEAD && !task_alive(item)) {
+		if (item->pid->state != COMPEL_TASK_DEAD && !task_alive(item)) {
 			pr_err("Unknown task state %d\n", item->pid->state);
 			return -1;
 		}
@@ -1115,7 +1115,7 @@  static void sigchld_handler(int signal, siginfo_t *siginfo, void *data)
 				break;
 
 		BUG_ON(&pi->sibling == &current->children);
-		if (pi->pid->state != TASK_HELPER)
+		if (pi->pid->state != COMPEL_TASK_HELPER)
 			break;
 	}
 
@@ -1352,7 +1352,7 @@  static int restore_task_with_children(void *_arg)
 	if ( !(ca->clone_flags & CLONE_FILES))
 		close_safe(&ca->fd);
 
-	if (current->pid->state != TASK_HELPER) {
+	if (current->pid->state != COMPEL_TASK_HELPER) {
 		ret = clone_service_fd(rsti(current)->service_fd_id);
 		if (ret)
 			goto err;
@@ -1652,8 +1652,8 @@  static void finalize_restore(void)
 
 		xfree(ctl);
 
-		if ((item->pid->state == TASK_STOPPED) ||
-				(opts.final_state == TASK_STOPPED))
+		if ((item->pid->state == COMPEL_TASK_STOPPED) ||
+				(opts.final_state == COMPEL_TASK_STOPPED))
 			kill(item->pid->real, SIGSTOP);
 	}
 }
@@ -1881,7 +1881,7 @@  static int restore_root_task(struct pstree_item *init)
 
 	/* Zombies die after CR_STATE_RESTORE */
 	for_each_pstree_item(item) {
-		if (item->pid->state == TASK_DEAD)
+		if (item->pid->state == COMPEL_TASK_DEAD)
 			task_entries->nr_threads--;
 	}
 
diff --git a/criu/cr-service.c b/criu/cr-service.c
index 4bac50d..d53478b 100644
--- a/criu/cr-service.c
+++ b/criu/cr-service.c
@@ -294,7 +294,7 @@  static int setup_opts_from_req(int sk, CriuOpts *req)
 
 	/* checking flags from client */
 	if (req->has_leave_running && req->leave_running)
-		opts.final_state = TASK_ALIVE;
+		opts.final_state = COMPEL_TASK_ALIVE;
 
 	if (!req->has_pid) {
 		req->has_pid = true;
diff --git a/criu/crtools.c b/criu/crtools.c
index cce8073..d457f70 100644
--- a/criu/crtools.c
+++ b/criu/crtools.c
@@ -62,7 +62,7 @@  void init_opts(void)
 	memset(&opts, 0, sizeof(opts));
 
 	/* Default options */
-	opts.final_state = TASK_DEAD;
+	opts.final_state = COMPEL_TASK_DEAD;
 	INIT_LIST_HEAD(&opts.ext_mounts);
 	INIT_LIST_HEAD(&opts.inherit_fds);
 	INIT_LIST_HEAD(&opts.external);
@@ -331,10 +331,10 @@  int main(int argc, char *argv[], char *envp[])
 
 		switch (opt) {
 		case 's':
-			opts.final_state = TASK_STOPPED;
+			opts.final_state = COMPEL_TASK_STOPPED;
 			break;
 		case 'R':
-			opts.final_state = TASK_ALIVE;
+			opts.final_state = COMPEL_TASK_ALIVE;
 			break;
 		case 'x':
 			if (optarg && unix_sk_ids_parse(optarg) < 0)
@@ -607,7 +607,7 @@  int main(int argc, char *argv[], char *envp[])
 		case 1085:
 			pr_msg("Only checking if requested operation will succeed\n");
 			opts.check_only = true;
-			opts.final_state = TASK_ALIVE;
+			opts.final_state = COMPEL_TASK_ALIVE;
 			break;
 		case 1086:
 			opts.display_stats = true;
@@ -703,7 +703,7 @@  int main(int argc, char *argv[], char *envp[])
 	 */
 	if (!strcmp(argv[optind], "restore") &&
 			opts.restore_detach &&
-			opts.final_state == TASK_STOPPED &&
+			opts.final_state == COMPEL_TASK_STOPPED &&
 			opts.shell_job)
 		pr_warn("Stopped and detached shell job will get SIGHUP from OS.");
 
diff --git a/criu/files-reg.c b/criu/files-reg.c
index df270a6..308ab5c 100644
--- a/criu/files-reg.c
+++ b/criu/files-reg.c
@@ -383,7 +383,7 @@  static int open_remap_dead_process(struct reg_file_info *rfi,
 	if (!helper)
 		return -1;
 
-	if (helper->pid->state != TASK_UNDEF) {
+	if (helper->pid->state != COMPEL_TASK_UNDEF) {
 		pr_info("Skipping helper for restoring /proc/%d; pid exists\n", rfe->remap_id);
 		return 0;
 	}
@@ -816,7 +816,7 @@  int dead_pid_conflict(void)
 		if (!node)
 			continue;
 
-		if (node->state != TASK_THREAD) {
+		if (node->state != COMPEL_TASK_THREAD) {
 			struct pstree_item *item;
 
 			/*
@@ -955,8 +955,8 @@  static int check_path_remap(struct fd_link *link, const struct fd_parms *parms,
 	if (parms->fs_type == PROC_SUPER_MAGIC) {
 		/* The file points to /proc/pid/<foo> where pid is a dead
 		 * process. We remap this file by adding this pid to be
-		 * fork()ed into a TASK_HELPER state so that we can point to it
-		 * on restore.
+		 * fork()ed into a COMPEL_TASK_HELPER state so that we
+		 * can point to it on restore.
 		 */
 		pid_t pid;
 		char *start, *end;
diff --git a/criu/image.c b/criu/image.c
index 898a580..50ce6c7 100644
--- a/criu/image.c
+++ b/criu/image.c
@@ -133,7 +133,7 @@  int prepare_inventory(InventoryEntry *he)
 		he->check_only = true;
 	}
 
-	crt.i.pid->state = TASK_ALIVE;
+	crt.i.pid->state = COMPEL_TASK_ALIVE;
 	crt.i.pid->real = getpid();
 	if (get_task_ids(&crt.i))
 		return -1;
diff --git a/criu/include/pid.h b/criu/include/pid.h
index 9ac583f..4c0a47b 100644
--- a/criu/include/pid.h
+++ b/criu/include/pid.h
@@ -13,7 +13,7 @@  struct pid {
 	 */
 	pid_t real;
 
-	int state;	/* TASK_XXX constants */
+	int state;	/* COMPEL_TASK_XXX constants */
 
 	/*
 	 * The @virt pid is one which used in the image itself and keeps
@@ -26,14 +26,6 @@  struct pid {
 	} ns[1]; /* Must be at the end of struct pid */
 };
 
-#define TASK_UNDEF		0x0
-#define TASK_ALIVE		0x1
-#define TASK_DEAD		0x2
-#define TASK_STOPPED		0x3
-#define TASK_HELPER		0x4
-#define TASK_THREAD		0x5
-#define TASK_ZOMBIE		0x6
-
 /*
  * When we have to restore a shared resource, we mush select which
  * task should do it, and make other(s) wait for it. In order to
diff --git a/criu/include/pstree.h b/criu/include/pstree.h
index f441d53..06dfa39 100644
--- a/criu/include/pstree.h
+++ b/criu/include/pstree.h
@@ -5,6 +5,7 @@ 
 #include "common/lock.h"
 #include "pid.h"
 #include "images/core.pb-c.h"
+#include <compel/infect.h>
 
 /*
  * That's the init process which usually inherit
@@ -71,7 +72,7 @@  static inline int shared_fdtable(struct pstree_item *item)
 
 static inline bool is_alive_state(int state)
 {
-	return (state == TASK_ALIVE) || (state == TASK_STOPPED);
+	return (state == COMPEL_TASK_ALIVE) || (state == COMPEL_TASK_STOPPED);
 }
 
 static inline bool task_alive(struct pstree_item *i)
diff --git a/criu/proc_parse.c b/criu/proc_parse.c
index b52135e..3569715 100644
--- a/criu/proc_parse.c
+++ b/criu/proc_parse.c
@@ -2224,7 +2224,7 @@  int parse_threads(int pid, struct pid **_t, int *_n)
 			t[nr - 1].ns[0].virt = -1;
 		}
 		t[nr - 1].real = atoi(de->d_name);
-		t[nr - 1].state = TASK_THREAD;
+		t[nr - 1].state = COMPEL_TASK_THREAD;
 		nr++;
 	}
 
diff --git a/criu/pstree.c b/criu/pstree.c
index 833b3d0..13fb7ed 100644
--- a/criu/pstree.c
+++ b/criu/pstree.c
@@ -227,7 +227,7 @@  struct pstree_item *__alloc_pstree_item(bool rst)
 
 void init_pstree_helper(struct pstree_item *ret)
 {
-	ret->pid->state = TASK_HELPER;
+	ret->pid->state = COMPEL_TASK_HELPER;
 	rsti(ret)->clone_flags = CLONE_FILES | CLONE_FS;
 	task_entries->nr_helpers++;
 }
@@ -432,7 +432,7 @@  struct pstree_item *lookup_create_item(pid_t pid)
 	node = lookup_create_pid(pid, NULL);
 	if (!node)
 		return NULL;
-	BUG_ON(node->state == TASK_THREAD);
+	BUG_ON(node->state == COMPEL_TASK_THREAD);
 
 	return node->item;
 }
@@ -500,7 +500,7 @@  static int read_pstree_image(pid_t *pid_max)
 		pi = lookup_create_item(e->pid);
 		if (pi == NULL)
 			break;
-		BUG_ON(pi->pid->state != TASK_UNDEF);
+		BUG_ON(pi->pid->state != COMPEL_TASK_UNDEF);
 
 		/*
 		 * All pids should be added in the tree to be able to find
@@ -522,7 +522,7 @@  static int read_pstree_image(pid_t *pid_max)
 		pi->sid = e->sid;
 		if (e->sid > *pid_max)
 			*pid_max = e->sid;
-		pi->pid->state = TASK_ALIVE;
+		pi->pid->state = COMPEL_TASK_ALIVE;
 
 		if (e->ppid == 0) {
 			if (root_item) {
@@ -537,7 +537,7 @@  static int read_pstree_image(pid_t *pid_max)
 			struct pstree_item *parent;
 
 			pid = pstree_pid_by_virt(e->ppid);
-			if (!pid || pid->state == TASK_UNDEF || pid->state == TASK_THREAD) {
+			if (!pid || pid->state == COMPEL_TASK_UNDEF || pid->state == COMPEL_TASK_THREAD) {
 				pr_err("Can't find a parent for %d\n", pi->pid->ns[0].virt);
 				pstree_entry__free_unpacked(e, NULL);
 				xfree(pi);
@@ -558,7 +558,7 @@  static int read_pstree_image(pid_t *pid_max)
 			struct pid *node;
 			pi->threads[i].real = -1;
 			pi->threads[i].ns[0].virt = e->threads[i];
-			pi->threads[i].state = TASK_THREAD;
+			pi->threads[i].state = COMPEL_TASK_THREAD;
 			pi->threads[i].item = NULL;
 			if (i == 0)
 				continue; /* A thread leader is in a tree already */
@@ -639,7 +639,7 @@  static int prepare_pstree_ids(void)
 
 		leader = pstree_item_by_virt(item->sid);
 		BUG_ON(leader == NULL);
-		if (leader->pid->state != TASK_UNDEF) {
+		if (leader->pid->state != COMPEL_TASK_UNDEF) {
 			pid_t pid;
 
 			pid = get_free_pid();
@@ -697,7 +697,7 @@  static int prepare_pstree_ids(void)
 		if (!item->parent) /* skip the root task */
 			continue;
 
-		if (item->pid->state == TASK_HELPER)
+		if (item->pid->state == COMPEL_TASK_HELPER)
 			continue;
 
 		if (item->sid != item->pid->ns[0].virt) {
@@ -740,8 +740,8 @@  static int prepare_pstree_ids(void)
 			continue;
 
 		pid = pstree_pid_by_virt(item->pgid);
-		if (pid->state != TASK_UNDEF) {
-			BUG_ON(pid->state == TASK_THREAD);
+		if (pid->state != COMPEL_TASK_UNDEF) {
+			BUG_ON(pid->state == COMPEL_TASK_THREAD);
 			rsti(item)->pgrp_leader = pid->item;
 			continue;
 		}
@@ -982,7 +982,7 @@  struct pstree_item *pstree_item_by_virt(pid_t virt)
 	pid = pstree_pid_by_virt(virt);
 	if (pid == NULL)
 		return NULL;
-	BUG_ON(pid->state == TASK_THREAD);
+	BUG_ON(pid->state == COMPEL_TASK_THREAD);
 
 	return pid->item;
 }
diff --git a/criu/seccomp.c b/criu/seccomp.c
index c5e7a7d..cf10351 100644
--- a/criu/seccomp.c
+++ b/criu/seccomp.c
@@ -49,7 +49,7 @@  static int collect_filter_for_pstree(struct pstree_item *item)
 	struct sock_filter buf[BPF_MAXINSNS];
 	void *m;
 
-	if (item->pid->state == TASK_DEAD ||
+	if (item->pid->state == COMPEL_TASK_DEAD ||
 	    dmpi(item)->pi_creds->s.seccomp_mode != SECCOMP_MODE_FILTER)
 		return 0;
 
diff --git a/criu/seize.c b/criu/seize.c
index d5079ca..7908e67 100644
--- a/criu/seize.c
+++ b/criu/seize.c
@@ -505,8 +505,8 @@  static int collect_children(struct pstree_item *item)
 			continue;
 		}
 
-		if (ret == TASK_ZOMBIE)
-			ret = TASK_DEAD;
+		if (ret == COMPEL_TASK_ZOMBIE)
+			ret = COMPEL_TASK_DEAD;
 		else
 			processes_to_wait--;
 
@@ -530,7 +530,7 @@  static void unseize_task_and_threads(const struct pstree_item *item, int st)
 {
 	int i;
 
-	if (item->pid->state == TASK_DEAD)
+	if (item->pid->state == COMPEL_TASK_DEAD)
 		return;
 
 	/*
@@ -540,7 +540,7 @@  static void unseize_task_and_threads(const struct pstree_item *item, int st)
 
 	compel_resume_task(item->pid->real, item->pid->state, st);
 
-	if (st == TASK_DEAD)
+	if (st == COMPEL_TASK_DEAD)
 		return;
 
 	for (i = 1; i < item->nr_threads; i++)
@@ -555,7 +555,7 @@  static void pstree_wait(struct pstree_item *root_item)
 
 	for_each_pstree_item(item) {
 
-		if (item->pid->state == TASK_DEAD)
+		if (item->pid->state == COMPEL_TASK_DEAD)
 			continue;
 
 		for (i = 0; i < item->nr_threads; i++) {
@@ -587,7 +587,7 @@  void pstree_switch_state(struct pstree_item *root_item, int st)
 	if (!root_item)
 		return;
 
-	if (st != TASK_DEAD)
+	if (st != COMPEL_TASK_DEAD)
 		freezer_restore_state();
 
 	/*
@@ -602,7 +602,7 @@  void pstree_switch_state(struct pstree_item *root_item, int st)
 	for_each_pstree_item(item)
 		unseize_task_and_threads(item, st);
 
-	if (st == TASK_DEAD)
+	if (st == COMPEL_TASK_DEAD)
 		pstree_wait(root_item);
 }
 
@@ -684,7 +684,7 @@  static int collect_threads(struct pstree_item *item)
 	if (ret < 0)
 		goto err;
 
-	if ((item->pid->state == TASK_DEAD) && (nr_threads > 1)) {
+	if ((item->pid->state == COMPEL_TASK_DEAD) && (nr_threads > 1)) {
 		pr_err("Zombies with threads are not supported\n");
 		goto err;
 	}
@@ -728,8 +728,8 @@  static int collect_threads(struct pstree_item *item)
 			continue;
 		}
 
-		if (ret == TASK_ZOMBIE)
-			ret = TASK_DEAD;
+		if (ret == COMPEL_TASK_ZOMBIE)
+			ret = COMPEL_TASK_DEAD;
 		else
 			processes_to_wait--;
 
@@ -738,7 +738,7 @@  static int collect_threads(struct pstree_item *item)
 		item->threads[item->nr_threads].item = NULL;
 		item->nr_threads++;
 
-		if (ret == TASK_DEAD) {
+		if (ret == COMPEL_TASK_DEAD) {
 			pr_err("Zombie thread not supported\n");
 			goto err;
 		}
@@ -746,7 +746,7 @@  static int collect_threads(struct pstree_item *item)
 		if (!creds_dumpable(dmpi(item)->pi_creds, &t_creds))
 			goto err;
 
-		if (ret == TASK_STOPPED) {
+		if (ret == COMPEL_TASK_STOPPED) {
 			nr_stopped++;
 		}
 	}
@@ -812,7 +812,7 @@  static int collect_task(struct pstree_item *item)
 	if (ret < 0)
 		goto err_close;
 
-	if ((item->pid->state == TASK_DEAD) && !list_empty(&item->children)) {
+	if ((item->pid->state == COMPEL_TASK_DEAD) && !list_empty(&item->children)) {
 		pr_err("Zombie with children?! O_o Run, run, run!\n");
 		goto err_close;
 	}
@@ -859,8 +859,8 @@  int collect_pstree(void)
 	if (ret < 0)
 		goto err;
 
-	if (ret == TASK_ZOMBIE)
-		ret = TASK_DEAD;
+	if (ret == COMPEL_TASK_ZOMBIE)
+		ret = COMPEL_TASK_DEAD;
 	else
 		processes_to_wait--;
 
diff --git a/criu/tty.c b/criu/tty.c
index 17d19f4..b361f3a 100644
--- a/criu/tty.c
+++ b/criu/tty.c
@@ -2066,7 +2066,7 @@  static int tty_dump_queued_data(void)
 			break;
 	}
 
-	if (ret || opts.final_state != TASK_DEAD) {
+	if (ret || opts.final_state != COMPEL_TASK_DEAD) {
 		list_for_each_entry(dinfo, &all_ptys, list)
 			tty_do_writeback_queued_data(dinfo);
 	}

Comments

Pavel Emelianov Feb. 8, 2017, 3:34 p.m.
On 02/08/2017 05:36 PM, Kir Kolyshkin wrote:
> This patch adds COMPEL_ prefix to TASK_* defines used by compel
> and criu, and also removes their duplicated definitions from
> criu/include/pid.h
> 
> Signed-off-by: Kir Kolyshkin <kir@openvz.org>
> ---
>  compel/include/uapi/infect.h | 24 +++++++++++++++---------
>  compel/src/lib/infect.c      | 20 ++++++++++----------
>  criu/cr-dump.c               | 26 +++++++++++++-------------
>  criu/cr-restore.c            | 34 +++++++++++++++++-----------------
>  criu/cr-service.c            |  2 +-
>  criu/crtools.c               | 10 +++++-----
>  criu/files-reg.c             |  8 ++++----
>  criu/image.c                 |  2 +-
>  criu/include/pid.h           | 10 +---------
>  criu/include/pstree.h        |  3 ++-
>  criu/proc_parse.c            |  2 +-
>  criu/pstree.c                | 22 +++++++++++-----------
>  criu/seccomp.c               |  2 +-
>  criu/seize.c                 | 30 +++++++++++++++---------------
>  criu/tty.c                   |  2 +-
>  15 files changed, 98 insertions(+), 99 deletions(-)
> 
> diff --git a/compel/include/uapi/infect.h b/compel/include/uapi/infect.h
> index 5c47555..910e7a2 100644
> --- a/compel/include/uapi/infect.h
> +++ b/compel/include/uapi/infect.h
> @@ -22,6 +22,21 @@ struct seize_task_status {
>  	int			seccomp_mode;
>  };
>  
> +/*
> + * Task state, as returned by compel_wait_task().
> + * Also used in other functions.
> + */
> +enum
> +{
> +	COMPEL_TASK_UNDEF	= 0x0,
> +	COMPEL_TASK_ALIVE	= 0x1,
> +	COMPEL_TASK_DEAD	= 0x2,
> +	COMPEL_TASK_STOPPED	= 0x3,
> +	COMPEL_TASK_HELPER	= 0x4,
> +	COMPEL_TASK_THREAD	= 0x5,
> +	COMPEL_TASK_ZOMBIE	= 0x6,

The thing is that compel itself only works with alive, dead, zombie
and stopped states, while all the others are criu-specific.

So COMPEL_TASK_XXX numbers should be only those 4 above and criu
should map those to its internal bits.

> +};
> +
>  extern int compel_wait_task(int pid, int ppid,
>  		int (*get_status)(int pid, struct seize_task_status *),
>  		struct seize_task_status *st);
> @@ -29,15 +44,6 @@ extern int compel_wait_task(int pid, int ppid,
>  extern int compel_stop_task(int pid);
>  extern int compel_resume_task(pid_t pid, int orig_state, int state);
>  
> -/*
> - * FIXME -- these should be mapped to pid.h's
> - */
> -
> -#define TASK_ALIVE		0x1
> -#define TASK_DEAD		0x2
> -#define TASK_STOPPED		0x3
> -#define TASK_ZOMBIE		0x6
> -
>  struct parasite_ctl;
>  struct parasite_thread_ctl;
>  
> diff --git a/compel/src/lib/infect.c b/compel/src/lib/infect.c
> index 8f36379..f6d4a44 100644
> --- a/compel/src/lib/infect.c
> +++ b/compel/src/lib/infect.c
> @@ -235,9 +235,9 @@ try_again:
>  		}
>  
>  		if (ret < 0)
> -			return TASK_ZOMBIE;
> +			return COMPEL_TASK_ZOMBIE;
>  		else
> -			return TASK_DEAD;
> +			return COMPEL_TASK_DEAD;
>  	}
>  
>  	if ((ppid != -1) && (ss->ppid != ppid)) {
> @@ -289,11 +289,11 @@ try_again:
>  		if (skip_sigstop(pid, nr_sigstop))
>  			goto err_stop;
>  
> -		return TASK_STOPPED;
> +		return COMPEL_TASK_STOPPED;
>  	}
>  
>  	if (si.si_signo == SIGTRAP)
> -		return TASK_ALIVE;
> +		return COMPEL_TASK_ALIVE;
>  	else {
>  		pr_err("SEIZE %d: unsupported stop signal %d\n", pid, si.si_signo);
>  		goto err;
> @@ -311,25 +311,25 @@ int compel_resume_task(pid_t pid, int orig_st, int st)
>  {
>  	pr_debug("\tUnseizing %d into %d\n", pid, st);
>  
> -	if (st == TASK_DEAD) {
> +	if (st == COMPEL_TASK_DEAD) {
>  		kill(pid, SIGKILL);
>  		return 0;
> -	} else if (st == TASK_STOPPED) {
> +	} else if (st == COMPEL_TASK_STOPPED) {
>  		/*
>  		 * Task might have had STOP in queue. We detected such
> -		 * guy as TASK_STOPPED, but cleared signal to run the
> -		 * parasite code. hus after detach the task will become
> +		 * guy as COMPEL_TASK_STOPPED, but cleared signal to run
> +		 * the parasite code. Thus after detach the task will be
>  		 * running. That said -- STOP everyone regardless of
>  		 * the initial state.
>  		 */
>  		kill(pid, SIGSTOP);
> -	} else if (st == TASK_ALIVE) {
> +	} else if (st == COMPEL_TASK_ALIVE) {
>  		/*
>  		 * Same as in the comment above -- there might be a
>  		 * task with STOP in queue that would get lost after
>  		 * detach, so stop it again.
>  		 */
> -		if (orig_st == TASK_STOPPED)
> +		if (orig_st == COMPEL_TASK_STOPPED)
>  			kill(pid, SIGSTOP);
>  	} else
>  		pr_err("Unknown final state %d\n", st);
> diff --git a/criu/cr-dump.c b/criu/cr-dump.c
> index 8ccb5cb..b9e6ab6 100644
> --- a/criu/cr-dump.c
> +++ b/criu/cr-dump.c
> @@ -642,7 +642,7 @@ int get_task_ids(struct pstree_item *item)
>  
>  	task_kobj_ids_entry__init(item->ids);
>  
> -	if (item->pid->state != TASK_DEAD) {
> +	if (item->pid->state != COMPEL_TASK_DEAD) {
>  		ret = dump_task_kobj_ids(item);
>  		if (ret)
>  			goto err_free;
> @@ -784,14 +784,14 @@ static int collect_pstree_ids_predump(void)
>  	 * write_img_inventory().
>  	 */
>  
> -	crt.i.pid->state = TASK_ALIVE;
> +	crt.i.pid->state = COMPEL_TASK_ALIVE;
>  	crt.i.pid->real = getpid();
>  
>  	if (predump_task_ns_ids(&crt.i))
>  		return -1;
>  
>  	for_each_pstree_item(item) {
> -		if (item->pid->state == TASK_DEAD)
> +		if (item->pid->state == COMPEL_TASK_DEAD)
>  			continue;
>  
>  		if (predump_task_ns_ids(item))
> @@ -861,7 +861,7 @@ static int dump_one_zombie(const struct pstree_item *item,
>  		return -1;
>  
>  	strlcpy((char *)core->tc->comm, pps->comm, TASK_COMM_LEN);
> -	core->tc->task_state = TASK_DEAD;
> +	core->tc->task_state = COMPEL_TASK_DEAD;
>  	core->tc->exit_code = pps->exit_code;
>  
>  	img = open_image(CR_FD_CORE, O_DUMP, item->pid->ns[0].virt);
> @@ -1077,7 +1077,7 @@ static int dump_zombies(void)
>  	 */
>  
>  	for_each_pstree_item(item) {
> -		if (item->pid->state != TASK_DEAD)
> +		if (item->pid->state != COMPEL_TASK_DEAD)
>  			continue;
>  
>  		if (item->pid->ns[0].virt < 0) {
> @@ -1126,12 +1126,12 @@ static int pre_dump_one_task(struct pstree_item *item)
>  	pr_info("Pre-dumping task (pid: %d)\n", pid);
>  	pr_info("========================================\n");
>  
> -	if (item->pid->state == TASK_STOPPED) {
> +	if (item->pid->state == COMPEL_TASK_STOPPED) {
>  		pr_warn("Stopped tasks are not supported\n");
>  		return 0;
>  	}
>  
> -	if (item->pid->state == TASK_DEAD)
> +	if (item->pid->state == COMPEL_TASK_DEAD)
>  		return 0;
>  
>  	ret = collect_mappings(pid, &vmas, NULL);
> @@ -1206,7 +1206,7 @@ static int dump_one_task(struct pstree_item *item)
>  	pr_info("Dumping task (pid: %d)\n", pid);
>  	pr_info("========================================\n");
>  
> -	if (item->pid->state == TASK_DEAD)
> +	if (item->pid->state == COMPEL_TASK_DEAD)
>  		/*
>  		 * zombies are dumped separately in dump_zombies()
>  		 */
> @@ -1446,7 +1446,7 @@ static int cr_pre_dump_finish(int ret)
>  {
>  	struct pstree_item *item;
>  
> -	pstree_switch_state(root_item, TASK_ALIVE);
> +	pstree_switch_state(root_item, COMPEL_TASK_ALIVE);
>  
>  	timing_stop(TIME_FROZEN);
>  
> @@ -1520,9 +1520,9 @@ int cr_pre_dump_tasks(pid_t pid)
>  		opts.track_mem = true;
>  	}
>  
> -	if (opts.final_state == TASK_DEAD) {
> +	if (opts.final_state == COMPEL_TASK_DEAD) {
>  		pr_info("Enforcing tasks run after pre-dump.\n");
> -		opts.final_state = TASK_ALIVE;
> +		opts.final_state = COMPEL_TASK_ALIVE;
>  	}
>  
>  	if (init_stats(DUMP_STATS))
> @@ -1649,7 +1649,7 @@ static int cr_dump_finish(int ret)
>  	 *    consistency of the FS and other resources, we simply
>  	 *    start rollback procedure and cleanup everyhting.
>  	 */
> -	if (ret || post_dump_ret || opts.final_state == TASK_ALIVE) {
> +	if (ret || post_dump_ret || opts.final_state == COMPEL_TASK_ALIVE) {
>  		network_unlock();
>  		delete_link_remaps();
>  		clean_cr_time_mounts();
> @@ -1660,7 +1660,7 @@ static int cr_dump_finish(int ret)
>  
>  	pstree_switch_state(root_item,
>  			    (ret || post_dump_ret) ?
> -			    TASK_ALIVE : opts.final_state);
> +			    COMPEL_TASK_ALIVE : opts.final_state);
>  	timing_stop(TIME_FROZEN);
>  	free_pstree(root_item);
>  	free_file_locks();
> diff --git a/criu/cr-restore.c b/criu/cr-restore.c
> index 9acde67..3175690 100644
> --- a/criu/cr-restore.c
> +++ b/criu/cr-restore.c
> @@ -245,7 +245,7 @@ static int root_prepare_shared(void)
>  	}
>  
>  	for_each_pstree_item(pi) {
> -		if (pi->pid->state == TASK_HELPER)
> +		if (pi->pid->state == COMPEL_TASK_HELPER)
>  			continue;
>  
>  		ret = prepare_mm_pid(pi);
> @@ -523,8 +523,8 @@ static int collect_child_pids(int state, unsigned int *n)
>  
>  	if (current == root_item) {
>  		for_each_pstree_item(pi) {
> -			if (pi->pid->state != TASK_HELPER &&
> -			    pi->pid->state != TASK_DEAD)
> +			if (pi->pid->state != COMPEL_TASK_HELPER &&
> +			    pi->pid->state != COMPEL_TASK_DEAD)
>  				continue;
>  			if (__collect_child_pids(pi, state, n))
>  				return -1;
> @@ -537,13 +537,13 @@ static int collect_child_pids(int state, unsigned int *n)
>  static int collect_helper_pids(struct task_restore_args *ta)
>  {
>  	ta->helpers = (pid_t *)rst_mem_align_cpos(RM_PRIVATE);
> -	return collect_child_pids(TASK_HELPER, &ta->helpers_n);
> +	return collect_child_pids(COMPEL_TASK_HELPER, &ta->helpers_n);
>  }
>  
>  static int collect_zombie_pids(struct task_restore_args *ta)
>  {
>  	ta->zombies = (pid_t *)rst_mem_align_cpos(RM_PRIVATE);
> -	return collect_child_pids(TASK_DEAD, &ta->zombies_n);
> +	return collect_child_pids(COMPEL_TASK_DEAD, &ta->zombies_n);
>  }
>  
>  static int open_core(int pid, CoreEntry **pcore)
> @@ -780,13 +780,13 @@ static int wait_on_helpers_zombies(void)
>  		int status;
>  
>  		switch (pi->pid->state) {
> -		case TASK_DEAD:
> +		case COMPEL_TASK_DEAD:
>  			if (waitid(P_PID, pid, NULL, WNOWAIT | WEXITED) < 0) {
>  				pr_perror("Wait on %d zombie failed", pid);
>  				return -1;
>  			}
>  			break;
> -		case TASK_HELPER:
> +		case COMPEL_TASK_HELPER:
>  			if (waitpid(pid, &status, 0) != pid) {
>  				pr_perror("waitpid for helper %d failed", pid);
>  				return -1;
> @@ -857,7 +857,7 @@ static int check_core(CoreEntry *core, struct pstree_item *me)
>  		goto out;
>  	}
>  
> -	if (core->tc->task_state != TASK_DEAD) {
> +	if (core->tc->task_state != COMPEL_TASK_DEAD) {
>  		if (!core->ids && !me->ids) {
>  			pr_err("Core IDS data missed for non-zombie\n");
>  			goto out;
> @@ -882,9 +882,9 @@ static int restore_one_task(int pid, CoreEntry *core)
>  
>  	if (task_alive(current))
>  		ret = restore_one_alive_task(pid, core);
> -	else if (current->pid->state == TASK_DEAD)
> +	else if (current->pid->state == COMPEL_TASK_DEAD)
>  		ret = restore_one_zombie(core);
> -	else if (current->pid->state == TASK_HELPER) {
> +	else if (current->pid->state == COMPEL_TASK_HELPER) {
>  		sigset_t blockmask, oldmask;
>  
>  		sigemptyset(&blockmask);
> @@ -969,7 +969,7 @@ static inline int fork_with_pid(struct pstree_item *item)
>  	int ret = -1;
>  	pid_t pid = item->pid->ns[0].virt;
>  
> -	if (item->pid->state != TASK_HELPER) {
> +	if (item->pid->state != COMPEL_TASK_HELPER) {
>  		if (open_core(pid, &ca.core))
>  			return -1;
>  
> @@ -981,7 +981,7 @@ static inline int fork_with_pid(struct pstree_item *item)
>  
>  		rsti(item)->has_seccomp = ca.core->tc->seccomp_mode != SECCOMP_MODE_DISABLED;
>  
> -		if (item->pid->state != TASK_DEAD && !task_alive(item)) {
> +		if (item->pid->state != COMPEL_TASK_DEAD && !task_alive(item)) {
>  			pr_err("Unknown task state %d\n", item->pid->state);
>  			return -1;
>  		}
> @@ -1115,7 +1115,7 @@ static void sigchld_handler(int signal, siginfo_t *siginfo, void *data)
>  				break;
>  
>  		BUG_ON(&pi->sibling == &current->children);
> -		if (pi->pid->state != TASK_HELPER)
> +		if (pi->pid->state != COMPEL_TASK_HELPER)
>  			break;
>  	}
>  
> @@ -1352,7 +1352,7 @@ static int restore_task_with_children(void *_arg)
>  	if ( !(ca->clone_flags & CLONE_FILES))
>  		close_safe(&ca->fd);
>  
> -	if (current->pid->state != TASK_HELPER) {
> +	if (current->pid->state != COMPEL_TASK_HELPER) {
>  		ret = clone_service_fd(rsti(current)->service_fd_id);
>  		if (ret)
>  			goto err;
> @@ -1652,8 +1652,8 @@ static void finalize_restore(void)
>  
>  		xfree(ctl);
>  
> -		if ((item->pid->state == TASK_STOPPED) ||
> -				(opts.final_state == TASK_STOPPED))
> +		if ((item->pid->state == COMPEL_TASK_STOPPED) ||
> +				(opts.final_state == COMPEL_TASK_STOPPED))
>  			kill(item->pid->real, SIGSTOP);
>  	}
>  }
> @@ -1881,7 +1881,7 @@ static int restore_root_task(struct pstree_item *init)
>  
>  	/* Zombies die after CR_STATE_RESTORE */
>  	for_each_pstree_item(item) {
> -		if (item->pid->state == TASK_DEAD)
> +		if (item->pid->state == COMPEL_TASK_DEAD)
>  			task_entries->nr_threads--;
>  	}
>  
> diff --git a/criu/cr-service.c b/criu/cr-service.c
> index 4bac50d..d53478b 100644
> --- a/criu/cr-service.c
> +++ b/criu/cr-service.c
> @@ -294,7 +294,7 @@ static int setup_opts_from_req(int sk, CriuOpts *req)
>  
>  	/* checking flags from client */
>  	if (req->has_leave_running && req->leave_running)
> -		opts.final_state = TASK_ALIVE;
> +		opts.final_state = COMPEL_TASK_ALIVE;
>  
>  	if (!req->has_pid) {
>  		req->has_pid = true;
> diff --git a/criu/crtools.c b/criu/crtools.c
> index cce8073..d457f70 100644
> --- a/criu/crtools.c
> +++ b/criu/crtools.c
> @@ -62,7 +62,7 @@ void init_opts(void)
>  	memset(&opts, 0, sizeof(opts));
>  
>  	/* Default options */
> -	opts.final_state = TASK_DEAD;
> +	opts.final_state = COMPEL_TASK_DEAD;
>  	INIT_LIST_HEAD(&opts.ext_mounts);
>  	INIT_LIST_HEAD(&opts.inherit_fds);
>  	INIT_LIST_HEAD(&opts.external);
> @@ -331,10 +331,10 @@ int main(int argc, char *argv[], char *envp[])
>  
>  		switch (opt) {
>  		case 's':
> -			opts.final_state = TASK_STOPPED;
> +			opts.final_state = COMPEL_TASK_STOPPED;
>  			break;
>  		case 'R':
> -			opts.final_state = TASK_ALIVE;
> +			opts.final_state = COMPEL_TASK_ALIVE;
>  			break;
>  		case 'x':
>  			if (optarg && unix_sk_ids_parse(optarg) < 0)
> @@ -607,7 +607,7 @@ int main(int argc, char *argv[], char *envp[])
>  		case 1085:
>  			pr_msg("Only checking if requested operation will succeed\n");
>  			opts.check_only = true;
> -			opts.final_state = TASK_ALIVE;
> +			opts.final_state = COMPEL_TASK_ALIVE;
>  			break;
>  		case 1086:
>  			opts.display_stats = true;
> @@ -703,7 +703,7 @@ int main(int argc, char *argv[], char *envp[])
>  	 */
>  	if (!strcmp(argv[optind], "restore") &&
>  			opts.restore_detach &&
> -			opts.final_state == TASK_STOPPED &&
> +			opts.final_state == COMPEL_TASK_STOPPED &&
>  			opts.shell_job)
>  		pr_warn("Stopped and detached shell job will get SIGHUP from OS.");
>  
> diff --git a/criu/files-reg.c b/criu/files-reg.c
> index df270a6..308ab5c 100644
> --- a/criu/files-reg.c
> +++ b/criu/files-reg.c
> @@ -383,7 +383,7 @@ static int open_remap_dead_process(struct reg_file_info *rfi,
>  	if (!helper)
>  		return -1;
>  
> -	if (helper->pid->state != TASK_UNDEF) {
> +	if (helper->pid->state != COMPEL_TASK_UNDEF) {
>  		pr_info("Skipping helper for restoring /proc/%d; pid exists\n", rfe->remap_id);
>  		return 0;
>  	}
> @@ -816,7 +816,7 @@ int dead_pid_conflict(void)
>  		if (!node)
>  			continue;
>  
> -		if (node->state != TASK_THREAD) {
> +		if (node->state != COMPEL_TASK_THREAD) {
>  			struct pstree_item *item;
>  
>  			/*
> @@ -955,8 +955,8 @@ static int check_path_remap(struct fd_link *link, const struct fd_parms *parms,
>  	if (parms->fs_type == PROC_SUPER_MAGIC) {
>  		/* The file points to /proc/pid/<foo> where pid is a dead
>  		 * process. We remap this file by adding this pid to be
> -		 * fork()ed into a TASK_HELPER state so that we can point to it
> -		 * on restore.
> +		 * fork()ed into a COMPEL_TASK_HELPER state so that we
> +		 * can point to it on restore.
>  		 */
>  		pid_t pid;
>  		char *start, *end;
> diff --git a/criu/image.c b/criu/image.c
> index 898a580..50ce6c7 100644
> --- a/criu/image.c
> +++ b/criu/image.c
> @@ -133,7 +133,7 @@ int prepare_inventory(InventoryEntry *he)
>  		he->check_only = true;
>  	}
>  
> -	crt.i.pid->state = TASK_ALIVE;
> +	crt.i.pid->state = COMPEL_TASK_ALIVE;
>  	crt.i.pid->real = getpid();
>  	if (get_task_ids(&crt.i))
>  		return -1;
> diff --git a/criu/include/pid.h b/criu/include/pid.h
> index 9ac583f..4c0a47b 100644
> --- a/criu/include/pid.h
> +++ b/criu/include/pid.h
> @@ -13,7 +13,7 @@ struct pid {
>  	 */
>  	pid_t real;
>  
> -	int state;	/* TASK_XXX constants */
> +	int state;	/* COMPEL_TASK_XXX constants */
>  
>  	/*
>  	 * The @virt pid is one which used in the image itself and keeps
> @@ -26,14 +26,6 @@ struct pid {
>  	} ns[1]; /* Must be at the end of struct pid */
>  };
>  
> -#define TASK_UNDEF		0x0
> -#define TASK_ALIVE		0x1
> -#define TASK_DEAD		0x2
> -#define TASK_STOPPED		0x3
> -#define TASK_HELPER		0x4
> -#define TASK_THREAD		0x5
> -#define TASK_ZOMBIE		0x6
> -
>  /*
>   * When we have to restore a shared resource, we mush select which
>   * task should do it, and make other(s) wait for it. In order to
> diff --git a/criu/include/pstree.h b/criu/include/pstree.h
> index f441d53..06dfa39 100644
> --- a/criu/include/pstree.h
> +++ b/criu/include/pstree.h
> @@ -5,6 +5,7 @@
>  #include "common/lock.h"
>  #include "pid.h"
>  #include "images/core.pb-c.h"
> +#include <compel/infect.h>
>  
>  /*
>   * That's the init process which usually inherit
> @@ -71,7 +72,7 @@ static inline int shared_fdtable(struct pstree_item *item)
>  
>  static inline bool is_alive_state(int state)
>  {
> -	return (state == TASK_ALIVE) || (state == TASK_STOPPED);
> +	return (state == COMPEL_TASK_ALIVE) || (state == COMPEL_TASK_STOPPED);
>  }
>  
>  static inline bool task_alive(struct pstree_item *i)
> diff --git a/criu/proc_parse.c b/criu/proc_parse.c
> index b52135e..3569715 100644
> --- a/criu/proc_parse.c
> +++ b/criu/proc_parse.c
> @@ -2224,7 +2224,7 @@ int parse_threads(int pid, struct pid **_t, int *_n)
>  			t[nr - 1].ns[0].virt = -1;
>  		}
>  		t[nr - 1].real = atoi(de->d_name);
> -		t[nr - 1].state = TASK_THREAD;
> +		t[nr - 1].state = COMPEL_TASK_THREAD;
>  		nr++;
>  	}
>  
> diff --git a/criu/pstree.c b/criu/pstree.c
> index 833b3d0..13fb7ed 100644
> --- a/criu/pstree.c
> +++ b/criu/pstree.c
> @@ -227,7 +227,7 @@ struct pstree_item *__alloc_pstree_item(bool rst)
>  
>  void init_pstree_helper(struct pstree_item *ret)
>  {
> -	ret->pid->state = TASK_HELPER;
> +	ret->pid->state = COMPEL_TASK_HELPER;
>  	rsti(ret)->clone_flags = CLONE_FILES | CLONE_FS;
>  	task_entries->nr_helpers++;
>  }
> @@ -432,7 +432,7 @@ struct pstree_item *lookup_create_item(pid_t pid)
>  	node = lookup_create_pid(pid, NULL);
>  	if (!node)
>  		return NULL;
> -	BUG_ON(node->state == TASK_THREAD);
> +	BUG_ON(node->state == COMPEL_TASK_THREAD);
>  
>  	return node->item;
>  }
> @@ -500,7 +500,7 @@ static int read_pstree_image(pid_t *pid_max)
>  		pi = lookup_create_item(e->pid);
>  		if (pi == NULL)
>  			break;
> -		BUG_ON(pi->pid->state != TASK_UNDEF);
> +		BUG_ON(pi->pid->state != COMPEL_TASK_UNDEF);
>  
>  		/*
>  		 * All pids should be added in the tree to be able to find
> @@ -522,7 +522,7 @@ static int read_pstree_image(pid_t *pid_max)
>  		pi->sid = e->sid;
>  		if (e->sid > *pid_max)
>  			*pid_max = e->sid;
> -		pi->pid->state = TASK_ALIVE;
> +		pi->pid->state = COMPEL_TASK_ALIVE;
>  
>  		if (e->ppid == 0) {
>  			if (root_item) {
> @@ -537,7 +537,7 @@ static int read_pstree_image(pid_t *pid_max)
>  			struct pstree_item *parent;
>  
>  			pid = pstree_pid_by_virt(e->ppid);
> -			if (!pid || pid->state == TASK_UNDEF || pid->state == TASK_THREAD) {
> +			if (!pid || pid->state == COMPEL_TASK_UNDEF || pid->state == COMPEL_TASK_THREAD) {
>  				pr_err("Can't find a parent for %d\n", pi->pid->ns[0].virt);
>  				pstree_entry__free_unpacked(e, NULL);
>  				xfree(pi);
> @@ -558,7 +558,7 @@ static int read_pstree_image(pid_t *pid_max)
>  			struct pid *node;
>  			pi->threads[i].real = -1;
>  			pi->threads[i].ns[0].virt = e->threads[i];
> -			pi->threads[i].state = TASK_THREAD;
> +			pi->threads[i].state = COMPEL_TASK_THREAD;
>  			pi->threads[i].item = NULL;
>  			if (i == 0)
>  				continue; /* A thread leader is in a tree already */
> @@ -639,7 +639,7 @@ static int prepare_pstree_ids(void)
>  
>  		leader = pstree_item_by_virt(item->sid);
>  		BUG_ON(leader == NULL);
> -		if (leader->pid->state != TASK_UNDEF) {
> +		if (leader->pid->state != COMPEL_TASK_UNDEF) {
>  			pid_t pid;
>  
>  			pid = get_free_pid();
> @@ -697,7 +697,7 @@ static int prepare_pstree_ids(void)
>  		if (!item->parent) /* skip the root task */
>  			continue;
>  
> -		if (item->pid->state == TASK_HELPER)
> +		if (item->pid->state == COMPEL_TASK_HELPER)
>  			continue;
>  
>  		if (item->sid != item->pid->ns[0].virt) {
> @@ -740,8 +740,8 @@ static int prepare_pstree_ids(void)
>  			continue;
>  
>  		pid = pstree_pid_by_virt(item->pgid);
> -		if (pid->state != TASK_UNDEF) {
> -			BUG_ON(pid->state == TASK_THREAD);
> +		if (pid->state != COMPEL_TASK_UNDEF) {
> +			BUG_ON(pid->state == COMPEL_TASK_THREAD);
>  			rsti(item)->pgrp_leader = pid->item;
>  			continue;
>  		}
> @@ -982,7 +982,7 @@ struct pstree_item *pstree_item_by_virt(pid_t virt)
>  	pid = pstree_pid_by_virt(virt);
>  	if (pid == NULL)
>  		return NULL;
> -	BUG_ON(pid->state == TASK_THREAD);
> +	BUG_ON(pid->state == COMPEL_TASK_THREAD);
>  
>  	return pid->item;
>  }
> diff --git a/criu/seccomp.c b/criu/seccomp.c
> index c5e7a7d..cf10351 100644
> --- a/criu/seccomp.c
> +++ b/criu/seccomp.c
> @@ -49,7 +49,7 @@ static int collect_filter_for_pstree(struct pstree_item *item)
>  	struct sock_filter buf[BPF_MAXINSNS];
>  	void *m;
>  
> -	if (item->pid->state == TASK_DEAD ||
> +	if (item->pid->state == COMPEL_TASK_DEAD ||
>  	    dmpi(item)->pi_creds->s.seccomp_mode != SECCOMP_MODE_FILTER)
>  		return 0;
>  
> diff --git a/criu/seize.c b/criu/seize.c
> index d5079ca..7908e67 100644
> --- a/criu/seize.c
> +++ b/criu/seize.c
> @@ -505,8 +505,8 @@ static int collect_children(struct pstree_item *item)
>  			continue;
>  		}
>  
> -		if (ret == TASK_ZOMBIE)
> -			ret = TASK_DEAD;
> +		if (ret == COMPEL_TASK_ZOMBIE)
> +			ret = COMPEL_TASK_DEAD;
>  		else
>  			processes_to_wait--;
>  
> @@ -530,7 +530,7 @@ static void unseize_task_and_threads(const struct pstree_item *item, int st)
>  {
>  	int i;
>  
> -	if (item->pid->state == TASK_DEAD)
> +	if (item->pid->state == COMPEL_TASK_DEAD)
>  		return;
>  
>  	/*
> @@ -540,7 +540,7 @@ static void unseize_task_and_threads(const struct pstree_item *item, int st)
>  
>  	compel_resume_task(item->pid->real, item->pid->state, st);
>  
> -	if (st == TASK_DEAD)
> +	if (st == COMPEL_TASK_DEAD)
>  		return;
>  
>  	for (i = 1; i < item->nr_threads; i++)
> @@ -555,7 +555,7 @@ static void pstree_wait(struct pstree_item *root_item)
>  
>  	for_each_pstree_item(item) {
>  
> -		if (item->pid->state == TASK_DEAD)
> +		if (item->pid->state == COMPEL_TASK_DEAD)
>  			continue;
>  
>  		for (i = 0; i < item->nr_threads; i++) {
> @@ -587,7 +587,7 @@ void pstree_switch_state(struct pstree_item *root_item, int st)
>  	if (!root_item)
>  		return;
>  
> -	if (st != TASK_DEAD)
> +	if (st != COMPEL_TASK_DEAD)
>  		freezer_restore_state();
>  
>  	/*
> @@ -602,7 +602,7 @@ void pstree_switch_state(struct pstree_item *root_item, int st)
>  	for_each_pstree_item(item)
>  		unseize_task_and_threads(item, st);
>  
> -	if (st == TASK_DEAD)
> +	if (st == COMPEL_TASK_DEAD)
>  		pstree_wait(root_item);
>  }
>  
> @@ -684,7 +684,7 @@ static int collect_threads(struct pstree_item *item)
>  	if (ret < 0)
>  		goto err;
>  
> -	if ((item->pid->state == TASK_DEAD) && (nr_threads > 1)) {
> +	if ((item->pid->state == COMPEL_TASK_DEAD) && (nr_threads > 1)) {
>  		pr_err("Zombies with threads are not supported\n");
>  		goto err;
>  	}
> @@ -728,8 +728,8 @@ static int collect_threads(struct pstree_item *item)
>  			continue;
>  		}
>  
> -		if (ret == TASK_ZOMBIE)
> -			ret = TASK_DEAD;
> +		if (ret == COMPEL_TASK_ZOMBIE)
> +			ret = COMPEL_TASK_DEAD;
>  		else
>  			processes_to_wait--;
>  
> @@ -738,7 +738,7 @@ static int collect_threads(struct pstree_item *item)
>  		item->threads[item->nr_threads].item = NULL;
>  		item->nr_threads++;
>  
> -		if (ret == TASK_DEAD) {
> +		if (ret == COMPEL_TASK_DEAD) {
>  			pr_err("Zombie thread not supported\n");
>  			goto err;
>  		}
> @@ -746,7 +746,7 @@ static int collect_threads(struct pstree_item *item)
>  		if (!creds_dumpable(dmpi(item)->pi_creds, &t_creds))
>  			goto err;
>  
> -		if (ret == TASK_STOPPED) {
> +		if (ret == COMPEL_TASK_STOPPED) {
>  			nr_stopped++;
>  		}
>  	}
> @@ -812,7 +812,7 @@ static int collect_task(struct pstree_item *item)
>  	if (ret < 0)
>  		goto err_close;
>  
> -	if ((item->pid->state == TASK_DEAD) && !list_empty(&item->children)) {
> +	if ((item->pid->state == COMPEL_TASK_DEAD) && !list_empty(&item->children)) {
>  		pr_err("Zombie with children?! O_o Run, run, run!\n");
>  		goto err_close;
>  	}
> @@ -859,8 +859,8 @@ int collect_pstree(void)
>  	if (ret < 0)
>  		goto err;
>  
> -	if (ret == TASK_ZOMBIE)
> -		ret = TASK_DEAD;
> +	if (ret == COMPEL_TASK_ZOMBIE)
> +		ret = COMPEL_TASK_DEAD;
>  	else
>  		processes_to_wait--;
>  
> diff --git a/criu/tty.c b/criu/tty.c
> index 17d19f4..b361f3a 100644
> --- a/criu/tty.c
> +++ b/criu/tty.c
> @@ -2066,7 +2066,7 @@ static int tty_dump_queued_data(void)
>  			break;
>  	}
>  
> -	if (ret || opts.final_state != TASK_DEAD) {
> +	if (ret || opts.final_state != COMPEL_TASK_DEAD) {
>  		list_for_each_entry(dinfo, &all_ptys, list)
>  			tty_do_writeback_queued_data(dinfo);
>  	}
>