[RHEL7,COMMIT] ms/prctl: propagate has_child_subreaper flag to every descendant

Submitted by Konstantin Khorenko on Sept. 30, 2019, 12:47 p.m.

Details

Message ID 201909301247.x8UCl19S006913@finist-ce7.sw.ru
State New
Series "Series without cover letter"
Headers show

Commit Message

Konstantin Khorenko Sept. 30, 2019, 12:47 p.m.
The commit is pushed to "branch-rh7-3.10.0-957.27.2.vz7.107.x-ovz" and will appear at https://src.openvz.org/scm/ovz/vzkernel.git
after rh7-3.10.0-957.27.2.vz7.107.10
------>
commit e7091eee62c0d7a92732467a0e2c86d32ba180d1
Author: Pavel Tikhomirov <ptikhomirov@virtuozzo.com>
Date:   Mon Sep 30 15:47:01 2019 +0300

    ms/prctl: propagate has_child_subreaper flag to every descendant
    
    If process forks some children when it has is_child_subreaper
    flag enabled they will inherit has_child_subreaper flag - first
    group, when is_child_subreaper is disabled forked children will
    not inherit it - second group. So child-subreaper does not reparent
    all his descendants when their parents die. Having these two
    differently behaving groups can lead to confusion. Also it is
    a problem for CRIU, as when we restore process tree we need to
    somehow determine which descendants belong to which group and
    much harder - to put them exactly to these group.
    
    To simplify these we can add a propagation of has_child_subreaper
    flag on PR_SET_CHILD_SUBREAPER, walking all descendants of child-
    subreaper to setup has_child_subreaper flag.
    
    In common cases when process like systemd first sets itself to
    be a child-subreaper and only after that forks its services, we will
    have zero-length list of descendants to walk. Testing with binary
    subtree of 2^15 processes prctl took < 0.007 sec and has shown close
    to linear dependency(~0.2 * n * usec) on lower numbers of processes.
    
    Moreover, I doubt someone intentionaly pre-forks the children whitch
    should reparent to init before becoming subreaper, because some our
    ancestor migh have had is_child_subreaper flag while forking our
    sub-tree and our childs will all inherit has_child_subreaper flag,
    and we have no way to influence it. And only way to check if we have
    no has_child_subreaper flag is to create some childs, kill them and
    see where they will reparent to.
    
    Using walk_process_tree helper to walk subtree, thanks to Oleg! Timing
    seems to be the same.
    
    Optimize:
    
    a) When descendant already has has_child_subreaper flag all his subtree
    has it too already.
    
    * for a) to be true need to move has_child_subreaper inheritance under
    the same tasklist_lock with adding task to its ->real_parent->children
    as without it process can inherit zero has_child_subreaper, then we
    set 1 to it's parent flag, check that parent has no more children, and
    only after child with wrong flag is added to the tree.
    
    * Also make these inheritance more clear by using real_parent instead of
    current, as on clone(CLONE_PARENT) if current has is_child_subreaper
    and real_parent has no is_child_subreaper or has_child_subreaper, child
    will have has_child_subreaper flag set without actually having a
    subreaper in it's ancestors.
    
    b) When some descendant is child_reaper, it's subtree is in different
    pidns from us(original child-subreaper) and processes from other pidns
    will never reparent to us.
    
    So we can skip their(a,b) subtree from walk.
    
    v2: switch to walk_process_tree() general helper, move
    has_child_subreaper inheritance
    v3: remove csr_descendant leftover, change current to real_parent
    in has_child_subreaper inheritance
    v4: small commit message fix
    
    mFixes: ebec18a6d3aa ("prctl: add PR_{SET,GET}_CHILD_SUBREAPER to allow simple process supervision")
    Signed-off-by: Pavel Tikhomirov <ptikhomirov@virtuozzo.com>
    
    Reviewed-by: Oleg Nesterov <oleg@redhat.com>
    Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
    
    https://jira.sw.ru/browse/PSBM-96263
    
    (cherry picked from commit 749860ce242798fb090557a5a7868dee40af9268)
    Signed-off-by: Pavel Tikhomirov <ptikhomirov@virtuozzo.com>
---
 kernel/fork.c | 10 +++++++---
 kernel/sys.c  | 22 ++++++++++++++++++++++
 2 files changed, 29 insertions(+), 3 deletions(-)

Patch hide | download patch | download mbox

diff --git a/kernel/fork.c b/kernel/fork.c
index 9c1c675f1f74..281f8063a328 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1240,9 +1240,6 @@  static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
 	sig->oom_score_adj = current->signal->oom_score_adj;
 	sig->oom_score_adj_min = current->signal->oom_score_adj_min;
 
-	sig->has_child_subreaper = current->signal->has_child_subreaper ||
-				   current->signal->is_child_subreaper;
-
 	mutex_init(&sig->cred_guard_mutex);
 
 	return 0;
@@ -1696,6 +1693,13 @@  static struct task_struct *copy_process(unsigned long clone_flags,
 
 			p->signal->leader_pid = pid;
 			p->signal->tty = tty_kref_get(current->signal->tty);
+			/*
+			 * Inherit has_child_subreaper flag under the same
+			 * tasklist_lock with adding child to the process tree
+			 * for propagate_has_child_subreaper optimization.
+			 */
+			p->signal->has_child_subreaper = p->real_parent->signal->has_child_subreaper ||
+							 p->real_parent->signal->is_child_subreaper;
 			list_add_tail(&p->sibling, &p->real_parent->children);
 			list_add_tail_rcu(&p->tasks, &init_task.tasks);
 			attach_pid(p, PIDTYPE_PGID);
diff --git a/kernel/sys.c b/kernel/sys.c
index 48e69514b466..c4d633efe44c 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -2468,6 +2468,24 @@  int __weak arch_prctl_spec_ctrl_set(struct task_struct *t, unsigned long which,
 	return -EINVAL;
 }
 
+static int propagate_has_child_subreaper(struct task_struct *p, void *data)
+{
+	/*
+	 * If task has has_child_subreaper - all its decendants
+	 * already have these flag too and new decendants will
+	 * inherit it on fork, skip them.
+	 *
+	 * If we've found child_reaper - skip descendants in
+	 * it's subtree as they will never get out pidns.
+	 */
+	if (p->signal->has_child_subreaper ||
+	    is_child_reaper(task_pid(p)))
+		return 0;
+
+	p->signal->has_child_subreaper = 1;
+	return 1;
+}
+
 SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
 		unsigned long, arg4, unsigned long, arg5)
 {
@@ -2616,6 +2634,10 @@  SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
 		break;
 	case PR_SET_CHILD_SUBREAPER:
 		me->signal->is_child_subreaper = !!arg2;
+		if (!arg2)
+			break;
+
+		walk_process_tree(me, propagate_has_child_subreaper, NULL);
 		break;
 	case PR_GET_CHILD_SUBREAPER:
 		error = put_user(me->signal->is_child_subreaper,