All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
@ 2026-11-17 15:23 Jiwoo Kim
  2026-11-17 16:20 ` Bradley Morgan
                   ` (2 more replies)
  0 siblings, 3 replies; 6+ messages in thread
From: Jiwoo Kim @ 2026-11-17 15:23 UTC (permalink / raw)
  To: Christian Brauner
  Cc: Sargun Dhillon, Arnd Bergmann, Jann Horn, Chen Linxuan,
	linux-fsdevel, linux-api, linux-kernel

pidfds can cross pid namespace boundaries: a task can obtain one for a
process outside of its own pid namespace hierarchy through SO_PASSPIDFD
or SO_PEERPIDFD, via SCM_RIGHTS, or through file descriptor
inheritance.

Commit ee8323fdc827 ("pidfd: restrict task access ioctls to the caller's
pid namespace") made the pidfs namespace ioctls fail with -EREMOTE
unless the target is visible in the caller's active pid namespace, as
PIDFD_GET_INFO already does, following the rule that operations which
grant access to additional resources of the target require this [1].

pidfd_getfd() grants access to the target's open files, but it only
performs the ptrace access check, which does not take the pid namespace
relationship between the caller and the target into account. With the
caller in a child pid namespace and in the same user namespace as the
target, PIDFD_GET_INFO and PIDFD_GET_UTS_NAMESPACE fail with -EREMOTE
for such a pidfd, while pidfd_getfd() on the same pidfd returns a
duplicate of the target's file descriptor.

Apply the same rule to pidfd_getfd() and fail with -EREMOTE unless the
target is visible in the caller's active pid namespace. Callers in
ancestor pid namespaces are unaffected.

This was found with an AI coding assistant, which also drafted this
patch and its changelog. The problem was reproduced in a QEMU guest,
and the fix was tested there.

Link: https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/ [1]
Fixes: 8649c322f75c ("pid: Implement pidfd_getfd syscall")
Cc: stable@vger.kernel.org
Signed-off-by: Jiwoo Kim <arpe1618@gmail.com>
---
-EREMOTE is a new error for pidfd_getfd(). The check is done before the
task lookup, so, as with PIDFD_GET_INFO, a reaped target outside of the
caller's pid namespace hierarchy gives -EREMOTE rather than -ESRCH, and
the check comes before the ptrace access check.

setns() also accepts such pidfds without this check, but it requires
CAP_SYS_ADMIN over the namespaces being joined, so it is left alone
here.

A reproducer is available on request.

 kernel/pid.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/kernel/pid.c b/kernel/pid.c
index adf721606768..4f9a29eb29de 100644
--- a/kernel/pid.c
+++ b/kernel/pid.c
@@ -893,6 +893,13 @@ static int pidfd_getfd(struct pid *pid, int fd)
 	struct file *file;
 	int ret;
 
+	/*
+	 * Require the target to be visible in the caller's pid namespace,
+	 * like the pidfs ioctls that grant access to its resources.
+	 */
+	if (!pid_vnr(pid))
+		return -EREMOTE;
+
 	task = get_pid_task(pid, PIDTYPE_PID);
 	if (!task)
 		return -ESRCH;
@@ -917,9 +924,10 @@ static int pidfd_getfd(struct pid *pid, int fd)
  *
  * This syscall gets a copy of a file descriptor from another process
  * based on the pidfd, and file descriptor number. It requires that
- * the calling process has the ability to ptrace the process represented
- * by the pidfd. The process which is having its file descriptor copied
- * is otherwise unaffected.
+ * the process represented by the pidfd is visible in the caller's pid
+ * namespace and that the calling process has the ability to ptrace it.
+ * The process which is having its file descriptor copied is otherwise
+ * unaffected.
  *
  * Return: On success, a cloexec file descriptor is returned.
  *         On error, a negative errno number will be returned.

base-commit: 44cc27050381e92de64cc3d7836376eda4d92a5f
-- 
2.43.0


^ permalink raw reply related	[flat|nested] 6+ messages in thread

* Re: [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
  2026-11-17 15:23 [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace Jiwoo Kim
@ 2026-11-17 16:20 ` Bradley Morgan
  2026-11-19 13:42 ` Alexander Mikhalitsyn
  2026-11-20 12:46 ` Christian Brauner
  2 siblings, 0 replies; 6+ messages in thread
From: Bradley Morgan @ 2026-11-17 16:20 UTC (permalink / raw)
  To: arpe1618
  Cc: arnd, brauner, jannh, linux-api, linux-fsdevel, linux-kernel, me,
	sargun

On 17 November 2026 15:23:32 GMT, Jiwoo Kim <arpe1618@gmail.com> wrote:
>pidfds can cross pid namespace boundaries: a task can obtain one for a
>process outside of its own pid namespace hierarchy through SO_PASSPIDFD
>or SO_PEERPIDFD, via SCM_RIGHTS, or through file descriptor
>inheritance.
>
>Commit ee8323fdc827 ("pidfd: restrict task access ioctls to the caller's
>pid namespace") made the pidfs namespace ioctls fail with -EREMOTE
>unless the target is visible in the caller's active pid namespace, as
>PIDFD_GET_INFO already does, following the rule that operations which
>grant access to additional resources of the target require this [1].
>
>pidfd_getfd() grants access to the target's open files, but it only
>performs the ptrace access check, which does not take the pid namespace
>relationship between the caller and the target into account. With the
>caller in a child pid namespace and in the same user namespace as the
>target, PIDFD_GET_INFO and PIDFD_GET_UTS_NAMESPACE fail with -EREMOTE
>for such a pidfd, while pidfd_getfd() on the same pidfd returns a
>duplicate of the target's file descriptor.
>
>Apply the same rule to pidfd_getfd() and fail with -EREMOTE unless the
>target is visible in the caller's active pid namespace. Callers in
>ancestor pid namespaces are unaffected.
>
>This was found with an AI coding assistant, which also drafted this
>patch and its changelog. The problem was reproduced in a QEMU guest,
>and the fix was tested there.
>
>Link: https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/ [1]
>Fixes: 8649c322f75c ("pid: Implement pidfd_getfd syscall")
>Cc: stable@vger.kernel.org

Reviewed-by: Bradley Morgan <bradley.morgan@linux.dev>

>Signed-off-by: Jiwoo Kim <arpe1618@gmail.com>
>---
>-EREMOTE is a new error for pidfd_getfd(). The check is done before the
>task lookup, so, as with PIDFD_GET_INFO, a reaped target outside of the
>caller's pid namespace hierarchy gives -EREMOTE rather than -ESRCH, and
>the check comes before the ptrace access check.
>
>setns() also accepts such pidfds without this check, but it requires
>CAP_SYS_ADMIN over the namespaces being joined, so it is left alone
>here.
>
>A reproducer is available on request.
>
> kernel/pid.c | 14 +++++++++++---
> 1 file changed, 11 insertions(+), 3 deletions(-)
>
>diff --git a/kernel/pid.c b/kernel/pid.c
>index adf721606768..4f9a29eb29de 100644
>--- a/kernel/pid.c
>+++ b/kernel/pid.c
>@@ -893,6 +893,13 @@ static int pidfd_getfd(struct pid *pid, int fd)
> 	struct file *file;
> 	int ret;
> 
>+	/*
>+	 * Require the target to be visible in the caller's pid namespace,
>+	 * like the pidfs ioctls that grant access to its resources.
>+	 */
>+	if (!pid_vnr(pid))
>+		return -EREMOTE;
>+
> 	task = get_pid_task(pid, PIDTYPE_PID);
> 	if (!task)
> 		return -ESRCH;
>@@ -917,9 +924,10 @@ static int pidfd_getfd(struct pid *pid, int fd)
>  *
>  * This syscall gets a copy of a file descriptor from another process
>  * based on the pidfd, and file descriptor number. It requires that
>- * the calling process has the ability to ptrace the process represented
>- * by the pidfd. The process which is having its file descriptor copied
>- * is otherwise unaffected.
>+ * the process represented by the pidfd is visible in the caller's pid
>+ * namespace and that the calling process has the ability to ptrace it.
>+ * The process which is having its file descriptor copied is otherwise
>+ * unaffected.
>  *
>  * Return: On success, a cloexec file descriptor is returned.
>  *         On error, a negative errno number will be returned.
>
>base-commit: 44cc27050381e92de64cc3d7836376eda4d92a5f
>


--- Thanks!

^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
  2026-11-17 15:23 [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace Jiwoo Kim
  2026-11-17 16:20 ` Bradley Morgan
@ 2026-11-19 13:42 ` Alexander Mikhalitsyn
  2026-11-19 13:54   ` Jiwoo Kim
  2026-11-20 12:46 ` Christian Brauner
  2 siblings, 1 reply; 6+ messages in thread
From: Alexander Mikhalitsyn @ 2026-11-19 13:42 UTC (permalink / raw)
  To: Jiwoo Kim, Christian Brauner
  Cc: Sargun Dhillon, Arnd Bergmann, Jann Horn, Chen Linxuan,
	linux-fsdevel, linux-api, linux-kernel

On Wed, 2026-11-18 at 00:23 +0900, Jiwoo Kim wrote:
> pidfds can cross pid namespace boundaries: a task can obtain one for
> a
> process outside of its own pid namespace hierarchy through
> SO_PASSPIDFD
> or SO_PEERPIDFD, via SCM_RIGHTS, or through file descriptor
> inheritance.
> 
> Commit ee8323fdc827 ("pidfd: restrict task access ioctls to the
> caller's
> pid namespace") made the pidfs namespace ioctls fail with -EREMOTE
> unless the target is visible in the caller's active pid namespace, as
> PIDFD_GET_INFO already does, following the rule that operations which
> grant access to additional resources of the target require this [1].
> 

Hi Jiwoo,

> pidfd_getfd() grants access to the target's open files, but it only
> performs the ptrace access check, which does not take the pid
> namespace
> relationship between the caller and the target into account. With the
> caller in a child pid namespace and in the same user namespace as the
> target, PIDFD_GET_INFO and PIDFD_GET_UTS_NAMESPACE fail with -EREMOTE
> for such a pidfd, while pidfd_getfd() on the same pidfd returns a
> duplicate of the target's file descriptor.

It it an interesting point, because pid namespace itself it not a
security boundary. While user namespace and capabilities are mechanisms
to manage permissions.

Currently, you can do something like this on your machine:

# Terminal 0

echo $$ # note this PID we will use it in "Terminal 1"

# Terminal 1

sudo unshare -f -p 
echo hello > /proc/<PID>/fd/0

and this will actually print hello in the Terminal 0, while the process
doing that lives in nested pid namespace. But this is not a problem
because this guy is a root:

# Terminal 1
cat /proc/self/status | grep CapEff

So please understand me right, I'm not saying that your point is not
valid, but I'm not sure what was the intention behind pid_getfd() API
in the first place and we might want to have semantics and model close
to the one procfs has.

Speaking about other cases, where we *do* have this check:
- for exportfs operations it completely makes sense, because filehandle
  contains an inode number and user space may accidentally (due to the
memory corruption or purposefully craft it). When I call
open_by_handle_at I *do* expect to get something from my own PID
namespace.

- pidfd_ioctl since ee8323fdc827c580425644db605a4be776cace57 ("pidfd:
restrict task access ioctls to the caller's pid namespace") doesn't
allow to open namespace files, while procfs has no problem with this
(it works you can try)

- pidfd_info() also forbids cross pidns information retrieval and for
part of it functionallity we can do it through procfs, but for exit
info or coredump we can't

To conclude, it looks like we have a little bit of inconsistencies
around here :-) [ But please, don't go and change anything in procfs as
we might break some tricky use-cases like CRIU and SCM_RIGHTS users. ]

IMHO.

Kind regards,
Alex

> 
> Apply the same rule to pidfd_getfd() and fail with -EREMOTE unless
> the
> target is visible in the caller's active pid namespace. Callers in
> ancestor pid namespaces are unaffected.
> 
> This was found with an AI coding assistant, which also drafted this
> patch and its changelog. The problem was reproduced in a QEMU guest,
> and the fix was tested there.
> 
> Link:
> https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/
>  [1]
> Fixes: 8649c322f75c ("pid: Implement pidfd_getfd syscall")
> Cc: stable@vger.kernel.org
> Signed-off-by: Jiwoo Kim <arpe1618@gmail.com>
> ---
> -EREMOTE is a new error for pidfd_getfd(). The check is done before
> the
> task lookup, so, as with PIDFD_GET_INFO, a reaped target outside of
> the
> caller's pid namespace hierarchy gives -EREMOTE rather than -ESRCH,
> and
> the check comes before the ptrace access check.
> 
> setns() also accepts such pidfds without this check, but it requires
> CAP_SYS_ADMIN over the namespaces being joined, so it is left alone
> here.
> 
> A reproducer is available on request.
> 
>  kernel/pid.c | 14 +++++++++++---
>  1 file changed, 11 insertions(+), 3 deletions(-)
> 
> diff --git a/kernel/pid.c b/kernel/pid.c
> index adf721606768..4f9a29eb29de 100644
> --- a/kernel/pid.c
> +++ b/kernel/pid.c
> @@ -893,6 +893,13 @@ static int pidfd_getfd(struct pid *pid, int fd)
>  	struct file *file;
>  	int ret;
>  
> +	/*
> +	 * Require the target to be visible in the caller's pid
> namespace,
> +	 * like the pidfs ioctls that grant access to its resources.
> +	 */
> +	if (!pid_vnr(pid))
> +		return -EREMOTE;
> +
>  	task = get_pid_task(pid, PIDTYPE_PID);
>  	if (!task)
>  		return -ESRCH;
> @@ -917,9 +924,10 @@ static int pidfd_getfd(struct pid *pid, int fd)
>   *
>   * This syscall gets a copy of a file descriptor from another
> process
>   * based on the pidfd, and file descriptor number. It requires that
> - * the calling process has the ability to ptrace the process
> represented
> - * by the pidfd. The process which is having its file descriptor
> copied
> - * is otherwise unaffected.
> + * the process represented by the pidfd is visible in the caller's
> pid
> + * namespace and that the calling process has the ability to ptrace
> it.
> + * The process which is having its file descriptor copied is
> otherwise
> + * unaffected.
>   *
>   * Return: On success, a cloexec file descriptor is returned.
>   *         On error, a negative errno number will be returned.
> 
> base-commit: 44cc27050381e92de64cc3d7836376eda4d92a5f

^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
  2026-11-19 13:42 ` Alexander Mikhalitsyn
@ 2026-11-19 13:54   ` Jiwoo Kim
  2026-11-20  9:48     ` Chen Linxuan
  0 siblings, 1 reply; 6+ messages in thread
From: Jiwoo Kim @ 2026-11-19 13:54 UTC (permalink / raw)
  To: Alexander Mikhalitsyn
  Cc: Christian Brauner, Sargun Dhillon, Arnd Bergmann, Jann Horn,
	Chen Linxuan, linux-fsdevel, linux-api, linux-kernel

On Thu, 2026-11-19 at 14:42 +0100, Alexander Mikhalitsyn wrote:
> It it an interesting point, because pid namespace itself it not a
> security boundary. While user namespace and capabilities are mechanisms
> to manage permissions.

Hi Alex,

thanks for looking at this.

Agreed, and the patch does not try to make it one. I followed the rule
Christian suggested in [1], requiring pid_vnr(pid) != 0 for operations
that grant access to additional resources of the target, which
ee8323fdc827 then applied to the namespace ioctls. pidfd_getfd() hands
out one of the target's open files, so it looked like it belongs to the
same group.

> Currently, you can do something like this on your machine:
[...]
> and this will actually print hello in the Terminal 0, while the process
> doing that lives in nested pid namespace. But this is not a problem
> because this guy is a root:

Right. As far as I can see this also works for an unprivileged task of
the same uid, as long as it can reach the outer task through a procfs
instance of the outer pid namespace. So pidfd_getfd() currently behaves
like procfs here, and the patch would make it stricter than procfs, in
line with the pidfd ioctls and PIDFD_GET_INFO instead.

The case I had in mind is the one Jann described in [2]: a task in a
child pid namespace that gets a pidfd for an outer task over a socket.
When it has no procfs view of the outer task, as in a container with its
own procfs, that pidfd is its only handle to it. There, the ioctls refuse
the pidfd with -EREMOTE, while pidfd_getfd() returns the target's file.

> So please understand me right, I'm not saying that your point is not
> valid, but I'm not sure what was the intention behind pid_getfd() API
> in the first place and we might want to have semantics and model close
> to the one procfs has.

Understood. If pidfd_getfd() should keep following the procfs model, I'm
fine with dropping this patch; the inconsistency would then be on the
ioctl side. I'll leave that to Christian.

> To conclude, it looks like we have a little bit of inconsistencies
> around here :-) [ But please, don't go and change anything in procfs as
> we might break some tricky use-cases like CRIU and SCM_RIGHTS users. ]

No plans to touch procfs.

[1] https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/
[2] https://lore.kernel.org/all/CAG48ez1T5-tUHVK_iHsgUtWa-inVdrZxA3E-ZCW0iENJvasKfg@mail.gmail.com/

Thanks,
Jiwoo Kim

^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
  2026-11-19 13:54   ` Jiwoo Kim
@ 2026-11-20  9:48     ` Chen Linxuan
  0 siblings, 0 replies; 6+ messages in thread
From: Chen Linxuan @ 2026-11-20  9:48 UTC (permalink / raw)
  To: Jiwoo Kim, Alexander Mikhalitsyn
  Cc: Christian Brauner, Sargun Dhillon, Arnd Bergmann, Jann Horn,
	Chen Linxuan, linux-fsdevel, linux-api, linux-kernel

On Thu Nov 19, 2026 at 9:54 PM CST, Jiwoo Kim wrote:
> On Thu, 2026-11-19 at 14:42 +0100, Alexander Mikhalitsyn wrote:
>> It it an interesting point, because pid namespace itself it not a
>> security boundary. While user namespace and capabilities are mechanisms
>> to manage permissions.
>
> Hi Alex,
>
> thanks for looking at this.
>
> Agreed, and the patch does not try to make it one. I followed the rule
> Christian suggested in [1], requiring pid_vnr(pid) != 0 for operations
> that grant access to additional resources of the target, which
> ee8323fdc827 then applied to the namespace ioctls. pidfd_getfd() hands
> out one of the target's open files, so it looked like it belongs to the
> same group.
>
>> Currently, you can do something like this on your machine:
> [...]
>> and this will actually print hello in the Terminal 0, while the process
>> doing that lives in nested pid namespace. But this is not a problem
>> because this guy is a root:
>
> Right. As far as I can see this also works for an unprivileged task of
> the same uid, as long as it can reach the outer task through a procfs
> instance of the outer pid namespace. So pidfd_getfd() currently behaves
> like procfs here, and the patch would make it stricter than procfs, in
> line with the pidfd ioctls and PIDFD_GET_INFO instead.
>
> The case I had in mind is the one Jann described in [2]: a task in a
> child pid namespace that gets a pidfd for an outer task over a socket.
> When it has no procfs view of the outer task, as in a container with its
> own procfs, that pidfd is its only handle to it. There, the ioctls refuse
> the pidfd with -EREMOTE, while pidfd_getfd() returns the target's file.
>
>> So please understand me right, I'm not saying that your point is not
>> valid, but I'm not sure what was the intention behind pid_getfd() API
>> in the first place and we might want to have semantics and model close
>> to the one procfs has.
>
> Understood. If pidfd_getfd() should keep following the procfs model, I'm
> fine with dropping this patch; the inconsistency would then be on the
> ioctl side. I'll leave that to Christian.
>
>> To conclude, it looks like we have a little bit of inconsistencies
>> around here :-) [ But please, don't go and change anything in procfs as
>> we might break some tricky use-cases like CRIU and SCM_RIGHTS users. ]
>
> No plans to touch procfs.
>
> [1] https://lore.kernel.org/all/20260925-gewischt-auftrag-tierzucht-c153cb3f9f74@brauner/
> [2] https://lore.kernel.org/all/CAG48ez1T5-tUHVK_iHsgUtWa-inVdrZxA3E-ZCW0iENJvasKfg@mail.gmail.com/
>
> Thanks,
> Jiwoo Kim

pidfds provide process access without requiring procfs to be mounted, but that
does not mean they must expose every capability that procfs may expose in a
particular mount configuration. It is reasonable for pidfd operations to apply
stricter checks.

The existing handling of the pidfd namespace ioctls follows this principle. Even
when procfs may be able to access a target, PIDFD_GET_INFO and the namespace
ioctls require the target to be visible in the caller's active pid namespace.
This does not treat pid namespaces as independent security boundaries. It is a
conservative restriction to ensure that pidfd interfaces do not gain additional
access merely by bypassing procfs.

The original pidfd_getfd() commit, 8649c322f75c, used the following rationale:

> This syscall allows for the retrieval of file descriptors from other
> processes, based on their pidfd. This is possible using ptrace, and injection
> of parasitic code to inject code which leverages SCM_RIGHTS to move file
> descriptors between a tracee and a tracer.

The syscall documentation in the same commit says:

> This syscall gets a copy of a file descriptor from another process based on
> the pidfd, and file descriptor number. It requires that the calling process
> has the ability to ptrace the process represented by the pidfd.

That rationale assumes that the caller can actually ptrace the target, rather
than merely pass ptrace_may_access() for a task referenced by a pidfd. If the
target is outside the caller's pid namespace, the caller generally cannot
address and ptrace it through the ordinary pid-based interface. Allowing
pidfd_getfd() solely because a pidfd was transferred through SCM_RIGHTS,
SO_PASSPIDFD, SO_PEERPIDFD, or fd inheritance would therefore give pidfd an
operation beyond the ptrace-based justification in the original commit.

^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace
  2026-11-17 15:23 [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace Jiwoo Kim
  2026-11-17 16:20 ` Bradley Morgan
  2026-11-19 13:42 ` Alexander Mikhalitsyn
@ 2026-11-20 12:46 ` Christian Brauner
  2 siblings, 0 replies; 6+ messages in thread
From: Christian Brauner @ 2026-11-20 12:46 UTC (permalink / raw)
  To: Jiwoo Kim
  Cc: Christian Brauner, Sargun Dhillon, Arnd Bergmann, Jann Horn,
	Chen Linxuan, linux-fsdevel, linux-api, linux-kernel

On Wed, 18 Nov 2026 00:23:32 +0900, Jiwoo Kim wrote:
> pidfds can cross pid namespace boundaries: a task can obtain one for a
> process outside of its own pid namespace hierarchy through SO_PASSPIDFD
> or SO_PEERPIDFD, via SCM_RIGHTS, or through file descriptor
> inheritance.
> 
> Commit ee8323fdc827 ("pidfd: restrict task access ioctls to the caller's
> pid namespace") made the pidfs namespace ioctls fail with -EREMOTE
> unless the target is visible in the caller's active pid namespace, as
> PIDFD_GET_INFO already does, following the rule that operations which
> grant access to additional resources of the target require this [1].
> 
> [...]

Seems fine.

---

Applied to the vfs-7.5.pidfd branch of the vfs/vfs.git tree.
Patches in the vfs-7.5.pidfd branch should appear in linux-next soon.

Please report any outstanding bugs that were missed during review in a
new review to the original patch series allowing us to drop it.

It's encouraged to provide Acked-bys and Reviewed-bys even though the
patch has now been applied. If possible patch trailers will be updated.

Note that commit hashes shown below are subject to change due to rebase,
trailer updates or similar. If in doubt, please check the listed branch.

tree:   https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git
branch: vfs-7.5.pidfd

[1/1] pidfd: restrict pidfd_getfd() to the caller's pid namespace
      https://git.kernel.org/vfs/vfs/c/0a5864ad213c

^ permalink raw reply	[flat|nested] 6+ messages in thread

end of thread, other threads:[~2026-11-20 12:47 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-17 15:23 [PATCH] pidfd: restrict pidfd_getfd() to the caller's pid namespace Jiwoo Kim
2026-11-17 16:20 ` Bradley Morgan
2026-11-19 13:42 ` Alexander Mikhalitsyn
2026-11-19 13:54   ` Jiwoo Kim
2026-11-20  9:48     ` Chen Linxuan
2026-11-20 12:46 ` Christian Brauner

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.