[CRIU] [PATCH 4/4] compel: add prefix to TASK_ defines
Pavel Emelyanov
xemul at virtuozzo.com
Wed Feb 8 07:34:47 PST 2017
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 at 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 == ¤t->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);
> }
>
More information about the CRIU
mailing list