[CRIU] [PATCH v2 15/57] pid: Alloc threads dynamically
Kirill Tkhai
ktkhai at virtuozzo.com
Fri Apr 7 02:34:22 PDT 2017
On 07.04.2017 03:42, Andrei Vagin wrote:
> On Tue, Mar 28, 2017 at 06:36:25PM +0300, Kirill Tkhai wrote:
>> Threads pid values also may be multi-level, so allocate
>> them dynamically.
>
> Can a thread leave in another pid namespace? Maybe it is enough to know
> pid in the a process pidns?
No, they don't leave in another pid_ns, but they have mappings in the whole
ns hierarhy.
kirill:~$ cat /proc/28851/task/28851/status | grep NS
NStgid: 28851 20
NSpid: 28851 20
NSpgid: 28851 20
NSsid: 28851 20
kirill:~$ cat /proc/28851/task/28852/status | grep NS
NStgid: 28851 20
NSpid: 28852 21
NSpgid: 28851 20
NSsid: 28851 20
>>
>> Signed-off-by: Kirill Tkhai <ktkhai at virtuozzo.com>
>> ---
>> criu/cr-dump.c | 10 +++++-----
>> criu/cr-restore.c | 14 +++++++-------
>> criu/files-reg.c | 4 ++--
>> criu/include/proc_parse.h | 2 +-
>> criu/include/pstree.h | 2 +-
>> criu/parasite-syscall.c | 2 +-
>> criu/proc_parse.c | 23 ++++++++++++++++-------
>> criu/pstree.c | 23 +++++++++++++----------
>> criu/seize.c | 32 ++++++++++++++++++++++----------
>> 9 files changed, 68 insertions(+), 44 deletions(-)
>>
>> diff --git a/criu/cr-dump.c b/criu/cr-dump.c
>> index c61bb263..018c61d1 100644
>> --- a/criu/cr-dump.c
>> +++ b/criu/cr-dump.c
>> @@ -821,7 +821,7 @@ static int collect_file_locks(void)
>> static int dump_task_thread(struct parasite_ctl *parasite_ctl,
>> const struct pstree_item *item, int id)
>> {
>> - struct pid *tid = &item->threads[id];
>> + struct pid *tid = item->threads[id];
>> CoreEntry *core = item->core[id];
>> pid_t pid = tid->real;
>> int ret = -1;
>> @@ -963,9 +963,9 @@ static int dump_task_signals(pid_t pid, struct pstree_item *item)
>>
>> /* Dump private signals for each thread */
>> for (i = 0; i < item->nr_threads; i++) {
>> - ret = dump_signal_queue(item->threads[i].real, &item->core[i]->thread_core->signals_p, false);
>> + ret = dump_signal_queue(item->threads[i]->real, &item->core[i]->thread_core->signals_p, false);
>> if (ret) {
>> - pr_err("Can't dump private signals for thread %d\n", item->threads[i].real);
>> + pr_err("Can't dump private signals for thread %d\n", item->threads[i]->real);
>> return -1;
>> }
>> }
>> @@ -989,8 +989,8 @@ static int dump_task_threads(struct parasite_ctl *parasite_ctl,
>>
>> for (i = 0; i < item->nr_threads; i++) {
>> /* Leader is already dumped */
>> - if (item->pid->real == item->threads[i].real) {
>> - item->threads[i].ns[0].virt = vpid(item);
>> + if (item->pid->real == item->threads[i]->real) {
>> + item->threads[i]->ns[0].virt = vpid(item);
>> continue;
>> }
>> if (dump_task_thread(parasite_ctl, item, i))
>> diff --git a/criu/cr-restore.c b/criu/cr-restore.c
>> index 5795f645..1434971a 100644
>> --- a/criu/cr-restore.c
>> +++ b/criu/cr-restore.c
>> @@ -578,7 +578,7 @@ static int open_cores(int pid, CoreEntry *leader_core)
>> goto err;
>>
>> for (i = 0; i < current->nr_threads; i++) {
>> - tpid = current->threads[i].ns[0].virt;
>> + tpid = current->threads[i]->ns[0].virt;
>>
>> if (tpid == pid)
>> cores[i] = leader_core;
>> @@ -1571,7 +1571,7 @@ static int attach_to_tasks(bool root_seized)
>> return -1;
>>
>> for (i = 0; i < item->nr_threads; i++) {
>> - pid_t pid = item->threads[i].real;
>> + pid_t pid = item->threads[i]->real;
>>
>> if (item != root_item || !root_seized || i != 0) {
>> if (ptrace(PTRACE_SEIZE, pid, 0, 0)) {
>> @@ -1624,7 +1624,7 @@ static int catch_tasks(bool root_seized, enum trace_flags *flag)
>> return -1;
>>
>> for (i = 0; i < item->nr_threads; i++) {
>> - pid_t pid = item->threads[i].real;
>> + pid_t pid = item->threads[i]->real;
>>
>> if (ptrace(PTRACE_INTERRUPT, pid, 0, 0)) {
>> pr_perror("Can't interrupt the %d task", pid);
>> @@ -1658,7 +1658,7 @@ static int clear_breakpoints()
>> if (!task_alive(item))
>> continue;
>> for (i = 0; i < item->nr_threads; i++)
>> - ret |= ptrace_flush_breakpoints(item->threads[i].real);
>> + ret |= ptrace_flush_breakpoints(item->threads[i]->real);
>> }
>>
>> return ret;
>> @@ -1702,7 +1702,7 @@ static void finalize_restore_detach(int status)
>> continue;
>>
>> for (i = 0; i < item->nr_threads; i++) {
>> - pid = item->threads[i].real;
>> + pid = item->threads[i]->real;
>> if (pid < 0) {
>> BUG_ON(status >= 0);
>> break;
>> @@ -2727,7 +2727,7 @@ static int prepare_signals(int pid, struct task_restore_args *ta, CoreEntry *lea
>> for (i = 0; i < current->nr_threads; i++) {
>> if (!current->core[i]->thread_core->signals_p)/*backward compatibility*/
>> ret = open_signal_image(CR_FD_PSIGNAL,
>> - current->threads[i].ns[0].virt, &siginfo_priv_nr[i]);
>> + current->threads[i]->ns[0].virt, &siginfo_priv_nr[i]);
>> else
>> ret = prepare_one_signal_queue(current->core[i]->thread_core->signals_p,
>> &siginfo_priv_nr[i]);
>> @@ -3186,7 +3186,7 @@ static int sigreturn_restore(pid_t pid, struct task_restore_args *task_args, uns
>> struct rt_sigframe *sigframe;
>> k_rtsigset_t *blkset = NULL;
>>
>> - thread_args[i].pid = current->threads[i].ns[0].virt;
>> + thread_args[i].pid = current->threads[i]->ns[0].virt;
>> thread_args[i].siginfo_n = siginfo_priv_nr[i];
>> thread_args[i].siginfo = task_args->siginfo;
>> thread_args[i].siginfo += siginfo_n;
>> diff --git a/criu/files-reg.c b/criu/files-reg.c
>> index ede2744e..48f068d2 100644
>> --- a/criu/files-reg.c
>> +++ b/criu/files-reg.c
>> @@ -824,8 +824,8 @@ int dead_pid_conflict(void)
>> * process, this is handled during restore.
>> */
>> item = node->item;
>> - if (item->pid->real == item->threads[i].real ||
>> - item->threads[i].ns[0].virt != pid)
>> + if (item->pid->real == item->threads[i]->real ||
>> + item->threads[i]->ns[0].virt != pid)
>> continue;
>> }
>>
>> diff --git a/criu/include/proc_parse.h b/criu/include/proc_parse.h
>> index d67ac5e5..13b71092 100644
>> --- a/criu/include/proc_parse.h
>> +++ b/criu/include/proc_parse.h
>> @@ -101,7 +101,7 @@ extern int parse_file_locks(void);
>> extern int get_fd_mntid(int fd, int *mnt_id);
>>
>> struct pid;
>> -extern int parse_threads(int pid, struct pid **_t, int *_n);
>> +extern int parse_threads(int pid, struct pid ***_t, int *_n);
>>
>> int parse_children(pid_t pid, pid_t **_c, int *_n);
>>
>> diff --git a/criu/include/pstree.h b/criu/include/pstree.h
>> index 6edd04d7..0a62bfde 100644
>> --- a/criu/include/pstree.h
>> +++ b/criu/include/pstree.h
>> @@ -22,7 +22,7 @@ struct pstree_item {
>> pid_t born_sid;
>>
>> int nr_threads; /* number of threads */
>> - struct pid *threads; /* array of threads */
>> + struct pid **threads; /* array of threads */
>> CoreEntry **core;
>> TaskKobjIdsEntry *ids;
>> union {
>> diff --git a/criu/parasite-syscall.c b/criu/parasite-syscall.c
>> index 30b0a5ed..8ec3b727 100644
>> --- a/criu/parasite-syscall.c
>> +++ b/criu/parasite-syscall.c
>> @@ -481,7 +481,7 @@ struct parasite_ctl *parasite_infect_seized(pid_t pid, struct pstree_item *item,
>> struct infect_ctx *ictx;
>> unsigned long p;
>>
>> - BUG_ON(item->threads[0].real != pid);
>> + BUG_ON(item->threads[0]->real != pid);
>>
>> p = get_exec_start(vma_area_list);
>> if (!p) {
>> diff --git a/criu/proc_parse.c b/criu/proc_parse.c
>> index 5e9780a4..84a8f9ea 100644
>> --- a/criu/proc_parse.c
>> +++ b/criu/proc_parse.c
>> @@ -2196,11 +2196,11 @@ int parse_posix_timers(pid_t pid, struct proc_posix_timers_stat *args)
>> goto out;
>> }
>>
>> -int parse_threads(int pid, struct pid **_t, int *_n)
>> +int parse_threads(int pid, struct pid ***_t, int *_n)
>> {
>> struct dirent *de;
>> DIR *dir;
>> - struct pid *t = NULL;
>> + struct pid **t = NULL;
>> int nr = 1;
>>
>> if (*_t)
>> @@ -2211,23 +2211,32 @@ int parse_threads(int pid, struct pid **_t, int *_n)
>> return -1;
>>
>> while ((de = readdir(dir))) {
>> - struct pid *tmp;
>> + struct pid **tmp;
>>
>> /* We expect numbers only here */
>> if (de->d_name[0] == '.')
>> continue;
>>
>> if (*_t == NULL) {
>> - tmp = xrealloc(t, nr * sizeof(struct pid));
>> + tmp = xrealloc(t, nr * sizeof(struct pid *));
>> if (!tmp) {
>> + while (--nr > 0)
>> + xfree(t[nr-1]);
>> xfree(t);
>> return -1;
>> }
>> t = tmp;
>> - t[nr - 1].ns[0].virt = -1;
>> + t[nr - 1] = xmalloc(sizeof(struct pid));
>> + if (!t[nr - 1]) {
>> + while (--nr > 0)
>> + xfree(t[nr-1]);
>> + xfree(t);
>> + }
>> + t[nr - 1]->ns[0].virt = -1;
>> }
>> - t[nr - 1].real = atoi(de->d_name);
>> - t[nr - 1].state = TASK_THREAD;
>> + t[nr - 1]->real = atoi(de->d_name);
>> + t[nr - 1]->state = TASK_THREAD;
>> + t[nr - 1]->level = 1;
>> nr++;
>> }
>>
>> diff --git a/criu/pstree.c b/criu/pstree.c
>> index 0dffabcf..46c2096b 100644
>> --- a/criu/pstree.c
>> +++ b/criu/pstree.c
>> @@ -149,7 +149,7 @@ int pstree_alloc_cores(struct pstree_item *item)
>> return -1;
>>
>> for (i = 0; i < item->nr_threads; i++) {
>> - if (item->threads[i].real == item->pid->real)
>> + if (item->threads[i]->real == item->pid->real)
>> item->core[i] = core_entry_alloc(1, 1);
>> else
>> item->core[i] = core_entry_alloc(1, 0);
>> @@ -336,7 +336,7 @@ int dump_pstree(struct pstree_item *root_item)
>> goto err;
>>
>> for (i = 0; i < item->nr_threads; i++)
>> - e.threads[i] = item->threads[i].ns[0].virt;
>> + e.threads[i] = item->threads[i]->ns[0].virt;
>>
>> ret = pb_write_one(img, &e, PB_PSTREE);
>> xfree(e.threads);
>> @@ -602,23 +602,26 @@ static int read_pstree_image(pid_t *pid_max)
>> }
>>
>> pi->nr_threads = e->n_threads;
>> - pi->threads = xmalloc(e->n_threads * sizeof(struct pid));
>> + pi->threads = xzalloc(e->n_threads * sizeof(struct pid *));
>> if (!pi->threads)
>> break;
>>
>> for (i = 0; i < e->n_threads; i++) {
>> struct pid *node;
>> - pi->threads[i].real = -1;
>> - pi->threads[i].level = pi->pid->level;
>> - pi->threads[i].ns[0].virt = e->threads[i];
>> - pi->threads[i].state = TASK_THREAD;
>> - pi->threads[i].item = NULL;
>> + pi->threads[i] = xmalloc(sizeof(struct pid) + (pi->pid->level-1) * sizeof(node->ns[0]));
>> + if (!pi->threads)
>> + goto err;
>> + pi->threads[i]->real = -1;
>> + pi->threads[i]->level = pi->pid->level;
>> + pi->threads[i]->ns[0].virt = e->threads[i];
>> + pi->threads[i]->state = TASK_THREAD;
>> + pi->threads[i]->item = NULL;
>> if (i == 0)
>> continue; /* A thread leader is in a tree already */
>> - node = lookup_create_pid(pi->threads[i].ns[0].virt, &pi->threads[i]);
>> + node = lookup_create_pid(pi->threads[i]->ns[0].virt, pi->threads[i]);
>>
>> BUG_ON(node == NULL);
>> - if (node != &pi->threads[i]) {
>> + if (node != pi->threads[i]) {
>> pr_err("Unexpected task %d in a tree %d\n", e->threads[i], i);
>> return -1;
>> }
>> diff --git a/criu/seize.c b/criu/seize.c
>> index d5079ca6..7e44d136 100644
>> --- a/criu/seize.c
>> +++ b/criu/seize.c
>> @@ -544,8 +544,8 @@ static void unseize_task_and_threads(const struct pstree_item *item, int st)
>> return;
>>
>> for (i = 1; i < item->nr_threads; i++)
>> - if (ptrace(PTRACE_DETACH, item->threads[i].real, NULL, NULL))
>> - pr_perror("Unable to detach from %d", item->threads[i].real);
>> + if (ptrace(PTRACE_DETACH, item->threads[i]->real, NULL, NULL))
>> + pr_perror("Unable to detach from %d", item->threads[i]->real);
>> }
>>
>> static void pstree_wait(struct pstree_item *root_item)
>> @@ -620,7 +620,7 @@ static inline bool thread_collected(struct pstree_item *i, pid_t tid)
>> return true;
>>
>> for (t = 0; t < i->nr_threads; t++)
>> - if (tid == i->threads[t].real)
>> + if (tid == i->threads[t]->real)
>> return true;
>>
>> return false;
>> @@ -677,7 +677,7 @@ static bool creds_dumpable(struct proc_status_creds *parent,
>>
>> static int collect_threads(struct pstree_item *item)
>> {
>> - struct pid *threads = NULL;
>> + struct pid **threads = NULL;
>> int nr_threads = 0, i = 0, ret, nr_inprogress, nr_stopped = 0;
>>
>> ret = parse_threads(item->pid->real, &threads, &nr_threads);
>> @@ -690,19 +690,23 @@ static int collect_threads(struct pstree_item *item)
>> }
>>
>> /* The number of threads can't be less than already frozen */
>> - item->threads = xrealloc(item->threads, nr_threads * sizeof(struct pid));
>> + item->threads = xrealloc(item->threads, nr_threads * sizeof(struct pid *));
>> if (item->threads == NULL)
>> return -1;
>>
>> if (item->nr_threads == 0) {
>> - item->threads[0].real = item->pid->real;
>> + item->threads[0] = xmalloc(sizeof(struct pid));
>> + if (!item->threads[0])
>> + return -1;
>> + item->threads[0]->real = item->pid->real;
>> item->nr_threads = 1;
>> - item->threads[0].item = NULL;
>> + item->threads[0]->item = NULL;
>> + item->threads[0]->level = 1;
>> }
>>
>> nr_inprogress = 0;
>> for (i = 0; i < nr_threads; i++) {
>> - pid_t pid = threads[i].real;
>> + pid_t pid = threads[i]->real;
>> struct proc_status_creds t_creds = {};
>>
>> if (thread_collected(item, pid))
>> @@ -734,8 +738,12 @@ static int collect_threads(struct pstree_item *item)
>> processes_to_wait--;
>>
>> BUG_ON(item->nr_threads + 1 > nr_threads);
>> - item->threads[item->nr_threads].real = pid;
>> - item->threads[item->nr_threads].item = NULL;
>> + item->threads[item->nr_threads] = xmalloc(sizeof(struct pid));
>> + if (!item->threads[item->nr_threads])
>> + goto err;
>> + item->threads[item->nr_threads]->real = pid;
>> + item->threads[item->nr_threads]->item = NULL;
>> + item->threads[item->nr_threads]->level = 1;
>> item->nr_threads++;
>>
>> if (ret == TASK_DEAD) {
>> @@ -756,10 +764,14 @@ static int collect_threads(struct pstree_item *item)
>> goto err;
>> }
>>
>> + while (nr_threads-- > 0)
>> + xfree(threads[nr_threads]);
>> xfree(threads);
>> return nr_inprogress;
>>
>> err:
>> + while (nr_threads-- > 0)
>> + xfree(threads[nr_threads]);
>> xfree(threads);
>> return -1;
>> }
>>
More information about the CRIU
mailing list