pid: allow pidfds for reaped tasks
Subsystems (3)
PATCH 1/1 pid: allow pidfds for reaped tasks
A pidfd can currently only be created for tasks that are thread-group leaders and not reaped. This patch changes the pidfd-core to allow for pidfds on reapead thread-group leaders as well.
A pidfd can outlive the task it refers to, and thus user-space must already be prepared that the task underlying a pidfd is gone at the time they get their hands on the pidfd. For instance, resolving the pidfd to a PID via the fdinfo must be prepared to read -1.
Despite user-space knowing that a pidfd might be stale, several kernel APIs currently add another layer that checks for this. In particular, SO_PEERPIDFD returns EINVAL if the peer-task was already reaped, but returns a stale pidfd if the task is reaped immediately after the respective alive-check.
This has the unfortunate effect that user-space now has two ways to check for the exact same scenario: A syscall might return EINVAL/ESRCH/... *or* the pidfd might be stale, even though there is no particular reason to distinguish both cases. This also propagates through user-space APIs, which pass on pidfds. They must be prepared to pass on -1 *or* the pidfd, because there is no guaranteed way to get a stale pidfd from the kernel.
This patch changes the core pidfd helpers to allow creation of pidfds even if the PID is no longer linked to any task. This only affects one of the three pidfd users that currently exist:
1) fanotify already tests for a linked TGID-task manually before creating the PIDFD, thus it is not directly affected by this change. However, note that the current fanotify code fails with an error if the target process is reaped exactly between the TGID-check in fanotify and the test in pidfd_prepare(). With this patch, this will no longer be the case.
2) pidfd_open(2) calls find_get_pid() before creating the pidfd, thus it is also not directly affected by this change.
Again, similar to fanotify, there is a race between the find_get_pid() call and pidfd_prepare(), which currently causes pidfd_open(2) to return EINVAL rather than ESRCH if the process is reaped just between those two checks. With this patch, this will no longer be the case.
3) SO_PEERPIDFD will be affected by this change and from now on return stale pidfds rather than EINVAL if the respective peer task is reaped already.
Given that users of SO_PEERPIDFD must already deal with stale pidfds, this change hopefully simplifies the API of SO_PEERPIDFD, and all dependent user-space APIs (e.g., GetConnectionCredentials() on D-Bus driver APIs). Also note that SO_PEERPIDFD is still pending to be released with linux-6.5.
--- kernel/fork.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
kernel/fork.c +9 -2
@@ -2161,7 +2161,7 @@ static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re* Allocate a new file that stashes @pid and reserve a new pidfd number in the * caller's file descriptor table. The pidfd is reserved but not installed yet. * -* The helper verifies that @pid is used as a thread group leader. +* The helper verifies that @pid is/was used as a thread group leader. * * If this function returns successfully the caller is responsible to either * call fd_install() passing the returned pidfd and pidfd file as arguments in
@@ -2180,7 +2180,14 @@ static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re*/ int pidfd_prepare (struct pid *pid,unsigned int flags,struct file **ret) { -if (!pid || !pid_has_task (pid,PIDTYPE_TGID )) +if (!pid) +return -EINVAL ; + +/* +* Non thread-group leaders cannot have pidfds, but we allow them for +* reaped thread-group leaders. +*/ +if (pid_has_task (pid,PIDTYPE_PID ) && !pid_has_task (pid,PIDTYPE_TGID ))return -EINVAL ;return __pidfd_prepare (pid, flags, ret);
Signature · 1 line
2.41.0
Quoted 75 lines · David Rheinsberg
A pidfd can currently only be created for tasks that are thread-group leaders and not reaped. This patch changes the pidfd-core to allow for pidfds on reapead thread-group leaders as well.
A pidfd can outlive the task it refers to, and thus user-space must already be prepared that the task underlying a pidfd is gone at the time they get their hands on the pidfd. For instance, resolving the pidfd to a PID via the fdinfo must be prepared to read
-1.Despite user-space knowing that a pidfd might be stale, several kernel APIs currently add another layer that checks for this. In particular,
SO_PEERPIDFDreturnsEINVALif the peer-task was already reaped, but returns a stale pidfd if the task is reaped immediately after the respective alive-check.This has the unfortunate effect that user-space now has two ways to check for the exact same scenario: A syscall might return EINVAL/ESRCH/... *or* the pidfd might be stale, even though there is no particular reason to distinguish both cases. This also propagates through user-space APIs, which pass on pidfds. They must be prepared to pass on
-1*or* the pidfd, because there is no guaranteed way to get a stale pidfd from the kernel.This patch changes the core pidfd helpers to allow creation of pidfds even if the PID is no longer linked to any task. This only affects one of the three pidfd users that currently exist:
1) fanotify already tests for a linked TGID-task manually before creating the PIDFD, thus it is not directly affected by this change. However, note that the current fanotify code fails with an error if the target process is reaped exactly between the TGID-check in fanotify and the test in
pidfd_prepare(). With this patch, this will no longer be the case.2)
pidfd_open(2)callsfind_get_pid()before creating the pidfd, thus it is also not directly affected by this change.
Again, similar to fanotify, there is a race between thefind_get_pid()call andpidfd_prepare(), which currently causespidfd_open(2)to return EINVAL rather than ESRCH if the process is reaped just between those two checks. With this patch, this will no longer be the case.3)
SO_PEERPIDFDwill be affected by this change and from now on return stale pidfds rather than EINVAL if the respective peer task is reaped already.Given that users of
SO_PEERPIDFDmust already deal with stale pidfds, this change hopefully simplifies the API ofSO_PEERPIDFD, and all dependent user-space APIs (e.g.,GetConnectionCredentials()on D-Bus driver APIs). Also note thatSO_PEERPIDFDis still pending to be released with linux-6.5.Signed-off-by David Rheinsberg <[email protected]>--- kernel/fork.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)kernel/fork.c +1
-1@@ -2161,7 +2161,7 @@ static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re* Allocate a new file that stashes @pid and reserve a new pidfd number in the * caller's file descriptor table. The pidfd is reserved but not installed yet. * -* The helper verifies that @pid is used as a thread group leader. +* The helper verifies that @pid is/was used as a thread group leader. * * If this function returns successfully the caller is responsible to either * call fd_install() passing the returned pidfd and pidfd file as arguments in @@ -2180,7 +2180,14 @@ static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re*/ int pidfd_prepare (struct pid *pid,unsigned int flags,struct file **ret) {
kernel/fork.c static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re · line 2191
Quoted 10 lines
kernel/fork.c +8
-1-if (!pid || !pid_has_task (pid,PIDTYPE_TGID )) +if (!pid) +return -EINVAL ; + +/* +* Non thread-group leaders cannot have pidfds, but we allow them for +* reaped thread-group leaders. +*/ +if (pid_has_task (pid,PIDTYPE_PID ) && !pid_has_task (pid,PIDTYPE_TGID ))return -EINVAL ;
Hi David!
As far as I understand, __unhash_process is always called with a tasklist_lock held for writing.
Don't we need to take tasklist_lock for reading here to guarantee consistency betweenpid_has_task(pid, PIDTYPE_PID) and pid_has_task(pid, PIDTYPE_TGID) return values?
Kind regards,
Alex
Quoted 5 lines
kernel/fork.c +0
-1return __pidfd_prepare (pid, flags, ret); --2.41.0
Hi
Quoted 1 line · Alexander Mikhalitsyn
On Mon, Aug 7, 2023 at 10:52 AM David Rheinsberg <[email protected]> wrote:
[...]
Quoted 13 lines
kernel/fork.c static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re · line 2191
Quoted 12 lines
int
pidfd_prepare(struct pid *pid, unsigned int flags, struct file **ret){kernel/fork.c +8
-1-if (!pid || !pid_has_task (pid,PIDTYPE_TGID )) +if (!pid) +return -EINVAL ; + +/* +* Non thread-group leaders cannot have pidfds, but we allow them for +* reaped thread-group leaders. +*/ +if (pid_has_task (pid,PIDTYPE_PID ) && !pid_has_task (pid,PIDTYPE_TGID ))return -EINVAL ;
Quoted 8 lines
Hi David!
As far as I understand,
__unhash_processis always called with atasklist_lockheld for writing.
Don't we need to taketasklist_lockfor reading here to guarantee consistency betweenpid_has_task(pid, PIDTYPE_PID)andpid_has_task(pid, PIDTYPE_TGID)return values?
You mean PIDTYPE_TGID being cleared before PIDTYPE_PID (at least from the perspective of the unlocked reader)? I don't think it is a compatibility issue, because the same issue existed before the patch. But it might indeed be required to avoid spurious EINVAL _while_ the target process is reaped.
It would be unfortunate if we need that. Because it is really not required for AF_UNIX or fanotify (they guarantee that they always deal with TGIDs). So maybe the correct call is to just drop pidfd_prepare() and always use __pidfd_prepare()? So far the safety-measures of pidfd_prepare() introduced two races I already mentioned in the commit-message. So maybe it is just better to document that the caller of __pidfd_prepare() needs to ensure the source is/was a TGID?
Thanks
David
Quoted 21 lines · David Rheinsberg
Hi
Quoted 1 line · Alexander Mikhalitsyn
On Mon, Aug 7, 2023 at 10:52 AM David Rheinsberg <[email protected]> wrote:
[...]
Quoted 15 lines
kernel/fork.c static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re · line 2191
Quoted 12 lines
int
pidfd_prepare(struct pid *pid, unsigned int flags, struct file **ret){kernel/fork.c +8
-1-if (!pid || !pid_has_task (pid,PIDTYPE_TGID )) +if (!pid) +return -EINVAL ; + +/* +* Non thread-group leaders cannot have pidfds, but we allow them for +* reaped thread-group leaders. +*/ +if (pid_has_task (pid,PIDTYPE_PID ) && !pid_has_task (pid,PIDTYPE_TGID ))return -EINVAL ;Hi David!
Quoted 8 lines
Quoted 6 lines
As far as I understand,
__unhash_processis always called with atasklist_lockheld for writing.
Don't we need to taketasklist_lockfor reading here to guarantee consistency betweenpid_has_task(pid, PIDTYPE_PID)andpid_has_task(pid, PIDTYPE_TGID)return values?You mean
PIDTYPE_TGIDbeing cleared beforePIDTYPE_PID(at least from the perspective of the unlocked reader)? I don't think it is a compatibility issue, because the same issue existed before the patch. But it might indeed be required to avoid spurious EINVAL _while_ the target process is reaped.
Yes, that was my thought. At the same time we can see that __unhash_process() function at first detaches PIDTYPE_PID and then PIDTYPE_TGID.
But without having any kind of memory barrier (and locks are also implicit memory barriers) we can't be sure that inconsistency won't happen here.
Quoted 2 lines
It would be unfortunate if we need that. Because it is really not required for
AF_UNIXor fanotify (they guarantee that they always deal with TGIDs). So maybe the correct call is to just droppidfd_prepare()and always use__pidfd_prepare()? So far the safety-measures ofpidfd_prepare()introduced two races I already mentioned in the commit-message. So maybe it is just better to document that the caller of__pidfd_prepare()needs to ensure the source is/was a TGID?
Do you think that taking read_lock(&tasklist_lock) can cause any issues with contention on it?
IMHO, read_lock should be safe as we are taking it for a short period of time.
But anyways, I'm not insisting on that. I've just wanted to point this out to discuss with you and folks.
Kind regards,
Alex
Quoted 3 lines
Thanks
David
Hey Oleg,
A question for you below.
Quoted 74 lines · David Rheinsberg
A pidfd can currently only be created for tasks that are thread-group leaders and not reaped. This patch changes the pidfd-core to allow for pidfds on reapead thread-group leaders as well.
A pidfd can outlive the task it refers to, and thus user-space must already be prepared that the task underlying a pidfd is gone at the time they get their hands on the pidfd. For instance, resolving the pidfd to a PID via the fdinfo must be prepared to read
-1.Despite user-space knowing that a pidfd might be stale, several kernel APIs currently add another layer that checks for this. In particular,
SO_PEERPIDFDreturnsEINVALif the peer-task was already reaped, but returns a stale pidfd if the task is reaped immediately after the respective alive-check.This has the unfortunate effect that user-space now has two ways to check for the exact same scenario: A syscall might return EINVAL/ESRCH/... *or* the pidfd might be stale, even though there is no particular reason to distinguish both cases. This also propagates through user-space APIs, which pass on pidfds. They must be prepared to pass on
-1*or* the pidfd, because there is no guaranteed way to get a stale pidfd from the kernel.This patch changes the core pidfd helpers to allow creation of pidfds even if the PID is no longer linked to any task. This only affects one of the three pidfd users that currently exist:
1) fanotify already tests for a linked TGID-task manually before creating the PIDFD, thus it is not directly affected by this change. However, note that the current fanotify code fails with an error if the target process is reaped exactly between the TGID-check in fanotify and the test in
pidfd_prepare(). With this patch, this will no longer be the case.2)
pidfd_open(2)callsfind_get_pid()before creating the pidfd, thus it is also not directly affected by this change.
Again, similar to fanotify, there is a race between thefind_get_pid()call andpidfd_prepare(), which currently causespidfd_open(2)to return EINVAL rather than ESRCH if the process is reaped just between those two checks. With this patch, this will no longer be the case.3)
SO_PEERPIDFDwill be affected by this change and from now on return stale pidfds rather than EINVAL if the respective peer task is reaped already.Given that users of
SO_PEERPIDFDmust already deal with stale pidfds, this change hopefully simplifies the API ofSO_PEERPIDFD, and all dependent user-space APIs (e.g.,GetConnectionCredentials()on D-Bus driver APIs). Also note thatSO_PEERPIDFDis still pending to be released with linux-6.5.Signed-off-by David Rheinsberg <[email protected]>--- kernel/fork.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)kernel/fork.c +1
-1@@ -2161,7 +2161,7 @@ static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re* Allocate a new file that stashes @pid and reserve a new pidfd number in the * caller's file descriptor table. The pidfd is reserved but not installed yet. * -* The helper verifies that @pid is used as a thread group leader. +* The helper verifies that @pid is/was used as a thread group leader. * * If this function returns successfully the caller is responsible to either * call fd_install() passing the returned pidfd and pidfd file as arguments in @@ -2180,7 +2180,14 @@ static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re*/ int pidfd_prepare (struct pid *pid,unsigned int flags,struct file **ret) {
kernel/fork.c static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re · line 2191
Quoted 10 lines
kernel/fork.c +8
-1-if (!pid || !pid_has_task (pid,PIDTYPE_TGID )) +if (!pid) +return -EINVAL ; + +/* +* Non thread-group leaders cannot have pidfds, but we allow them for +* reaped thread-group leaders. +*/ +if (pid_has_task (pid,PIDTYPE_PID ) && !pid_has_task (pid,PIDTYPE_TGID ))return -EINVAL ;
TL;DR userspace wants to be able to get a pidfd to an already reaped thread-group leader. I don't see any issues with this.
But I'm not entirely clear how to make it safe so that we can distinguish between @pid not being used as a thread-group leader and PIDTYPE_TGID having already been detached from @pid. IOW, we need a snapshot of PIDTYPE_PID and PIDTYPE_TGID so that we can compare the returned tasks (Or another way to achieve a similar result.).
Any thoughts?
Hi Christian,
Sorry for delay, I've just returned from vacation and I am slowly crawling my email backlog.
Quoted 16 lines · Christian Brauner
kernel/fork.c static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re · line 2191
Quoted 13 lines
int
pidfd_prepare(struct pid *pid, unsigned int flags, struct file **ret){kernel/fork.c +8
-1-if (!pid || !pid_has_task (pid,PIDTYPE_TGID )) +if (!pid) +return -EINVAL ; + +/* +* Non thread-group leaders cannot have pidfds, but we allow them for +* reaped thread-group leaders. +*/ +if (pid_has_task (pid,PIDTYPE_PID ) && !pid_has_task (pid,PIDTYPE_TGID ))return -EINVAL ;TL;DR userspace wants to be able to get a pidfd to an already reaped thread-group leader. I don't see any issues with this.
I guess I need to read the whole thread carefully, but right now I don't understand this patch and the problem...
OK, suppose we have a group leader L with pid 100 and its sub-thread T with pid 101.
With this patch pidfd_open(101) can succeed if T exits right after find_get_pid(101) because pid_has_task(pid, PIDTYPE_PID) above will fail, right?
This looks wrong, 101 was never a leader pid...
Oleg.
Quoted 3 lines · Oleg Nesterov
Hi Christian,
Sorry for delay, I've just returned from vacation and I am slowly
Absolutely no problem! Thanks for getting back to us.
Quoted 25 lines
crawling my email backlog.
Quoted 16 lines · Christian Brauner
kernel/fork.c static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re · line 2191
Quoted 13 lines
int
pidfd_prepare(struct pid *pid, unsigned int flags, struct file **ret){kernel/fork.c +8
-1-if (!pid || !pid_has_task (pid,PIDTYPE_TGID )) +if (!pid) +return -EINVAL ; + +/* +* Non thread-group leaders cannot have pidfds, but we allow them for +* reaped thread-group leaders. +*/ +if (pid_has_task (pid,PIDTYPE_PID ) && !pid_has_task (pid,PIDTYPE_TGID ))return -EINVAL ;TL;DR userspace wants to be able to get a pidfd to an already reaped thread-group leader. I don't see any issues with this.
I guess I need to read the whole thread carefully, but right now I don't understand this patch and the problem...
Quoted 8 lines
OK, suppose we have a group leader L with pid 100 and its sub-thread T with pid 101.
With this patch
pidfd_open(101)can succeed if T exits right afterfind_get_pid(101)becausepid_has_task(pid, PIDTYPE_PID)above will fail, right?This looks wrong, 101 was never a leader pid...
Well, let me simplify the question:
What code do we need to allow userspace to open a pidfd to a leader pid even if it has already been exited and reaped (without also accidently allowing to open non-lead pid pidfds)?
I hope that clarifies?
Quoted 23 lines · Christian Brauner
Quoted 23 lines
Quoted 16 lines
kernel/fork.c static int __pidfd_prepare(struct pid *pid, unsigned int flags, struct file **re · line 2191
Quoted 13 lines
int
pidfd_prepare(struct pid *pid, unsigned int flags, struct file **ret){kernel/fork.c +8
-1-if (!pid || !pid_has_task (pid,PIDTYPE_TGID )) +if (!pid) +return -EINVAL ; + +/* +* Non thread-group leaders cannot have pidfds, but we allow them for +* reaped thread-group leaders. +*/ +if (pid_has_task (pid,PIDTYPE_PID ) && !pid_has_task (pid,PIDTYPE_TGID ))return -EINVAL ;TL;DR userspace wants to be able to get a pidfd to an already reaped thread-group leader. I don't see any issues with this.
I guess I need to read the whole thread carefully, but right now I don't understand this patch and the problem...
OK, suppose we have a group leader L with pid 100 and its sub-thread T with pid 101.
Quoted 7 lines
Quoted 5 lines
With this patch
pidfd_open(101)can succeed if T exits right afterfind_get_pid(101)becausepid_has_task(pid, PIDTYPE_PID)above will fail, right?This looks wrong, 101 was never a leader pid...
Well, let me simplify the question:
Thanks,
Quoted 3 lines
What code do we need to allow userspace to open a pidfd to a leader pid even if it has already been exited and reaped (without also accidently allowing to open non-lead pid pidfds)?
I'll try to think more, but can you also explain why do we need this?
See my another email. Can't we simply shift the pid_has_task(PIDTYPE_TGID) check from pidfd_prepare() to pidfd_create() ? (and then we can kill pidfd_prepare and rename __pidfd_prepare to pidfd_prepare).
Oleg.
Hi Oleg,
Quoted 9 lines · Oleg Nesterov
Quoted 3 lines
What code do we need to allow userspace to open a pidfd to a leader pid even if it has already been exited and reaped (without also accidently allowing to open non-lead pid pidfds)?
I'll try to think more, but can you also explain why do we need this?
See my another email. Can't we simply shift the
pid_has_task(PIDTYPE_TGID)check frompidfd_prepare()topidfd_create()? (and then we can killpidfd_prepareand rename__pidfd_preparetopidfd_prepare).
Yes, the easiest solution would be to use __pidfd_prepare() and ensure that the caller only ever calls this on tg-leaders. This would work just fine, imo. And this was my initial approach.
I think Christian preferred an explicit assertion that ensures we do not accidentally hand out pidfds for non-tg-leaders. The question is thus whether there is an easy way to assert this even for reaped tasks? Or whether there is a simple way to flag a pid that was used as tg-leader? Or, ultimately, whether this has limited use and we should just use __pidfd_prepare()?
Thanks a lot!
David
Quoted 10 lines · David Rheinsberg
Hi Oleg,
Quoted 6 lines · Oleg Nesterov
Quoted 3 lines
What code do we need to allow userspace to open a pidfd to a leader pid even if it has already been exited and reaped (without also accidently allowing to open non-lead pid pidfds)?
I'll try to think more, but can you also explain why do we need this?
Quoted 7 lines
Quoted 3 lines
See my another email. Can't we simply shift the
pid_has_task(PIDTYPE_TGID)check frompidfd_prepare()topidfd_create()? (and then we can killpidfd_prepareand rename__pidfd_preparetopidfd_prepare).Yes, the easiest solution would be to use
__pidfd_prepare()and ensure that the caller only ever calls this on tg-leaders. This would work just fine, imo. And this was my initial approach.
Great,
Quoted 4 lines
I think Christian preferred an explicit assertion that ensures we do not accidentally hand out pidfds for non-tg-leaders. The question is thus whether there is an easy way to assert this even for reaped tasks?
Or whether there is a simple way to flag a pid that was used as tg-leader?
I do not see how can we check if a detached pid was a leader pid, and I don't think it makes sense to add a new member into struct pid...
Quoted 2 lines
Or, ultimately, whether this has limited use and we should just use
__pidfd_prepare()?
Well, if you confirm that sk->sk_peer_pid and scm->pid are always initialized with task_tgid(current), I'd certainly prefer this approach unless Christian objects.
Oleg.
Quoted 27 lines · Oleg Nesterov
Quoted 10 lines · David Rheinsberg
Hi Oleg,
Quoted 6 lines · Oleg Nesterov
Quoted 3 lines
What code do we need to allow userspace to open a pidfd to a leader pid even if it has already been exited and reaped (without also accidently allowing to open non-lead pid pidfds)?
I'll try to think more, but can you also explain why do we need this?
Quoted 7 lines
Quoted 3 lines
See my another email. Can't we simply shift the
pid_has_task(PIDTYPE_TGID)check frompidfd_prepare()topidfd_create()? (and then we can killpidfd_prepareand rename__pidfd_preparetopidfd_prepare).Yes, the easiest solution would be to use
__pidfd_prepare()and ensure that the caller only ever calls this on tg-leaders. This would work just fine, imo. And this was my initial approach.Great,
Quoted 4 lines
I think Christian preferred an explicit assertion that ensures we do not accidentally hand out pidfds for non-tg-leaders. The question is thus whether there is an easy way to assert this even for reaped tasks?
Or whether there is a simple way to flag a pid that was used as tg-leader?
Quoted 8 lines
I do not see how can we check if a detached pid was a leader pid, and I don't think it makes sense to add a new member into struct pid...
Quoted 2 lines
Or, ultimately, whether this has limited use and we should just use
__pidfd_prepare()?Well, if you confirm that
sk->sk_peer_pidandscm->pidare always initialized withtask_tgid(current), I'd certainly prefer this approach unless Christian objects.
Dear colleagues,
I can confirm that sk->sk_peer_pid and scm->pid are always thread-group leaders.
Kind regards,
Alex
Quoted 3 lines
Oleg.
Quoted 26 lines · Oleg Nesterov
Quoted 10 lines · David Rheinsberg
Hi Oleg,
Quoted 6 lines · Oleg Nesterov
Quoted 3 lines
What code do we need to allow userspace to open a pidfd to a leader pid even if it has already been exited and reaped (without also accidently allowing to open non-lead pid pidfds)?
I'll try to think more, but can you also explain why do we need this?
Quoted 7 lines
Quoted 3 lines
See my another email. Can't we simply shift the
pid_has_task(PIDTYPE_TGID)check frompidfd_prepare()topidfd_create()? (and then we can killpidfd_prepareand rename__pidfd_preparetopidfd_prepare).Yes, the easiest solution would be to use
__pidfd_prepare()and ensure that the caller only ever calls this on tg-leaders. This would work just fine, imo. And this was my initial approach.Great,
Quoted 4 lines
I think Christian preferred an explicit assertion that ensures we do not accidentally hand out pidfds for non-tg-leaders. The question is thus whether there is an easy way to assert this even for reaped tasks?
Or whether there is a simple way to flag a pid that was used as tg-leader?
Quoted 8 lines
I do not see how can we check if a detached pid was a leader pid, and I don't think it makes sense to add a new member into struct pid...
Quoted 2 lines
Or, ultimately, whether this has limited use and we should just use
__pidfd_prepare()?Well, if you confirm that
sk->sk_peer_pidandscm->pidare always initialized withtask_tgid(current), I'd certainly prefer this approach unless Christian objects.
No no, I'm absolutely not objecting. I specifically want you to take the opinionated lead here. :) Thanks for chiming in!
As I said, I am not sure I understand the problem. And I know nothing about net/ but...
Quoted 4 lines · Christian Brauner
Quoted 4 lines
SO_PEERPIDFDreturnsEINVALif the peer-task was already reaped, but returns a stale pidfd if the task is reaped immediately after the respective alive-check.
after the quick grep it seems that SO_PEERPIDFD can simply use __pidfd_prepare() ? We know that sk->sk_peer_pid was initialized with task_tgid(current) and thus we know it is (was) a valid TGID pid.
The same is probably true for scm->pid and scm_pidfd_recv()...
But again, I am not familiar with this code, I can be wrong.
Oleg.