/* * This routine seizes task putting it into a special * state where we can manipulate the task via ptrace * interface, and finally we can detach ptrace out of * of it so the task would not know if it was saddled * up with someone else. */ int compel_wait_task(int pid, int ppid, int (*get_status)(int pid, struct seize_task_status *, void *), void (*free_status)(int pid, struct seize_task_status *, void *), struct seize_task_status *ss, void *data) { siginfo_t si; int status, nr_sigstop; int ret = 0, ret2, wait_errno = 0; /* * It's ugly, but the ptrace API doesn't allow to distinguish * attaching to zombie from other errors. Thus we have to parse * the target's /proc/pid/stat. Sad, but parse whatever else * we might need at that early point. */ try_again: ret = wait4(pid, &status, __WALL, NULL); if (ret < 0) { /* * wait4() can expectedly fail only in a first time * if a task is zombie. If we are here from try_again, * this means that we are tracing this task. * * So here we can be only once in this function. */ wait_errno = errno; } ret2 = get_status(pid, ss, data); if (ret2) goto err; if (ret < 0 || WIFEXITED(status) || WIFSIGNALED(status)) { if (ss->state != 'Z') { if (pid == getpid()) pr_err("The criu itself is within dumped tree.\n"); else pr_err("Unseizable non-zombie %d found, state %c, err %d/%d\n", pid, ss->state, ret, wait_errno); return -1; } if (ret < 0) return COMPEL_TASK_ZOMBIE; else return COMPEL_TASK_DEAD; } if ((ppid != -1) && (ss->ppid != ppid)) { pr_err("Task pid reused while suspending (%d: %d -> %d)\n", pid, ppid, ss->ppid); goto err; } if (!WIFSTOPPED(status)) { pr_err("SEIZE %d: task not stopped after seize\n", pid); goto err; } ret = ptrace(PTRACE_GETSIGINFO, pid, NULL, &si); if (ret < 0) { pr_perror("SEIZE %d: can't read signfo", pid); goto err; } if (PTRACE_SI_EVENT(si.si_code) != PTRACE_EVENT_STOP) { /* * Kernel notifies us about the task being seized received some * event other than the STOP, i.e. -- a signal. Let the task * handle one and repeat. */ if (ptrace(PTRACE_CONT, pid, NULL, (void *)(unsigned long)si.si_signo)) { pr_perror("Can't continue signal handling, aborting"); goto err; } ret = 0; if (free_status) free_status(pid, ss, data); goto try_again; } if (ss->seccomp_mode != SECCOMP_MODE_DISABLED && ptrace_suspend_seccomp(pid) < 0) goto err; nr_sigstop = 0; if (ss->sigpnd & (1 << (SIGSTOP - 1))) nr_sigstop++; if (ss->shdpnd & (1 << (SIGSTOP - 1))) nr_sigstop++; if (si.si_signo == SIGSTOP) nr_sigstop++; if (nr_sigstop) { if (skip_sigstop(pid, nr_sigstop)) goto err_stop; return COMPEL_TASK_STOPPED; } if (si.si_signo == SIGTRAP) return COMPEL_TASK_ALIVE; else { pr_err("SEIZE %d: unsupported stop signal %d\n", pid, si.si_signo); goto err; } err_stop: kill(pid, SIGSTOP); err: if (ptrace(PTRACE_DETACH, pid, NULL, NULL)) pr_perror("Unable to detach from %d", pid); return -1; }
/* * This routine seizes task putting it into a special * state where we can manipulate the task via ptrace * interface, and finally we can detach ptrace out of * of it so the task would not know if it was saddled * up with someone else. */ int seize_wait_task(pid_t pid, pid_t ppid, struct proc_status_creds **creds) { siginfo_t si; int status, nr_sigstop; int ret = 0, ret2, wait_errno = 0; struct proc_status_creds cr; /* * For the comparison below, let's zero out any padding. */ memzero(&cr, sizeof(struct proc_status_creds)); /* * It's ugly, but the ptrace API doesn't allow to distinguish * attaching to zombie from other errors. Thus we have to parse * the target's /proc/pid/stat. Sad, but parse whatever else * we might need at that early point. */ processes_to_wait--; try_again: ret = wait4(pid, &status, __WALL, NULL); if (ret < 0) { /* * wait4() can expectedly fail only in a first time * if a task is zombie. If we are here from try_again, * this means that we are tracing this task. * * processes_to_wait should be descrimented only once in this * function if a first wait was success. */ processes_to_wait++; wait_errno = errno; } ret2 = parse_pid_status(pid, &cr); if (ret2) goto err; if (ret < 0 || WIFEXITED(status) || WIFSIGNALED(status)) { if (cr.state != 'Z') { if (pid == getpid()) pr_err("The criu itself is within dumped tree.\n"); else pr_err("Unseizable non-zombie %d found, state %c, err %d/%d\n", pid, cr.state, ret, wait_errno); return -1; } return TASK_DEAD; } if ((ppid != -1) && (cr.ppid != ppid)) { pr_err("Task pid reused while suspending (%d: %d -> %d)\n", pid, ppid, cr.ppid); goto err; } if (!WIFSTOPPED(status)) { pr_err("SEIZE %d: task not stopped after seize\n", pid); goto err; } ret = ptrace(PTRACE_GETSIGINFO, pid, NULL, &si); if (ret < 0) { pr_perror("SEIZE %d: can't read signfo", pid); goto err; } if (SI_EVENT(si.si_code) != PTRACE_EVENT_STOP) { /* * Kernel notifies us about the task being seized received some * event other than the STOP, i.e. -- a signal. Let the task * handle one and repeat. */ if (ptrace(PTRACE_CONT, pid, NULL, (void *)(unsigned long)si.si_signo)) { pr_perror("Can't continue signal handling, aborting"); goto err; } ret = 0; goto try_again; } if (*creds == NULL) { *creds = xzalloc(sizeof(struct proc_status_creds)); if (!*creds) goto err; **creds = cr; } else if (!proc_status_creds_dumpable(*creds, &cr)) { pr_err("creds don't match %d %d\n", pid, ppid); goto err; } if (cr.seccomp_mode != SECCOMP_MODE_DISABLED && suspend_seccomp(pid) < 0) goto err; nr_sigstop = 0; if (cr.sigpnd & (1 << (SIGSTOP - 1))) nr_sigstop++; if (cr.shdpnd & (1 << (SIGSTOP - 1))) nr_sigstop++; if (si.si_signo == SIGSTOP) nr_sigstop++; if (nr_sigstop) { if (skip_sigstop(pid, nr_sigstop)) goto err_stop; return TASK_STOPPED; } if (si.si_signo == SIGTRAP) return TASK_ALIVE; else { pr_err("SEIZE %d: unsupported stop signal %d\n", pid, si.si_signo); goto err; } err_stop: kill(pid, SIGSTOP); err: if (ptrace(PTRACE_DETACH, pid, NULL, NULL)) pr_perror("Unable to detach from %d", pid); return -1; }