Unverified Commit 45135229 authored by Christian Brauner's avatar Christian Brauner
Browse files

pidfs: record exit code and cgroupid at exit 

Record the exit code and cgroupid in release_task() and stash in struct
pidfs_exit_info so it can be retrieved even after the task has been
reaped.

Link: https://lore.kernel.org/r/20250305-work-pidfs-kill_on_last_close-v3-5-c8c3d8361705@kernel.org


Reviewed-by: default avatarJeff Layton <jlayton@kernel.org>
Reviewed-by: default avatarOleg Nesterov <oleg@redhat.com>
Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent 0b420038

fs/internal.h

+1 −0
Original line number Diff line number Diff line
@@ -325,6 +325,7 @@ struct stashed_operations { 
int path_from_stashed(struct dentry **stashed, struct vfsmount *mnt, void *data,

		      struct path *path);

void stashed_dentry_prune(struct dentry *dentry);

struct dentry *stashed_dentry_get(struct dentry **stashed);

/**

 * path_mounted - check whether path is mounted

 * @path: path to check

fs/libfs.c

+2 −2
Original line number Diff line number Diff line
@@ -2113,7 +2113,7 @@ struct timespec64 simple_inode_init_ts(struct inode *inode) 
}

EXPORT_SYMBOL(simple_inode_init_ts);



static inline struct dentry *get_stashed_dentry(struct dentry **stashed)

struct dentry *stashed_dentry_get(struct dentry **stashed)

{

	struct dentry *dentry;
@@ -2215,7 +2215,7 @@ int path_from_stashed(struct dentry **stashed, struct vfsmount *mnt, void *data, 
	const struct stashed_operations *sops = mnt->mnt_sb->s_fs_info;



	/* See if dentry can be reused. */

	path->dentry = get_stashed_dentry(stashed);

	path->dentry = stashed_dentry_get(stashed);

	if (path->dentry) {

		sops->put_data(data);

		goto out_path;

fs/pidfs.c

+41 −0
Original line number Diff line number Diff line
@@ -458,6 +458,47 @@ struct pid *pidfd_pid(const struct file *file) 
	return file_inode(file)->i_private;

}



/*

 * We're called from release_task(). We know there's at least one

 * reference to struct pid being held that won't be released until the

 * task has been reaped which cannot happen until we're out of

 * release_task().

 *

 * If this struct pid is referred to by a pidfd then

 * stashed_dentry_get() will return the dentry and inode for that struct

 * pid. Since we've taken a reference on it there's now an additional

 * reference from the exit path on it. Which is fine. We're going to put

 * it again in a second and we know that the pid is kept alive anyway.

 *

 * Worst case is that we've filled in the info and immediately free the

 * dentry and inode afterwards since the pidfd has been closed. Since

 * pidfs_exit() currently is placed after exit_task_work() we know that

 * it cannot be us aka the exiting task holding a pidfd to ourselves.

 */

void pidfs_exit(struct task_struct *tsk)

{

	struct dentry *dentry;



	might_sleep();



	dentry = stashed_dentry_get(&task_pid(tsk)->stashed);

	if (dentry) {

		struct inode *inode = d_inode(dentry);

		struct pidfs_exit_info *exit_info = &pidfs_i(inode)->exit_info;

#ifdef CONFIG_CGROUPS

		struct cgroup *cgrp;



		rcu_read_lock();

		cgrp = task_dfl_cgroup(tsk);

		exit_info->cgroupid = cgroup_id(cgrp);

		rcu_read_unlock();

#endif

		exit_info->exit_code = tsk->exit_code;



		dput(dentry);

	}

}



static struct vfsmount *pidfs_mnt __ro_after_init;



/*

include/linux/pidfs.h

+1 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ struct file *pidfs_alloc_file(struct pid *pid, unsigned int flags); 
void __init pidfs_init(void);

void pidfs_add_pid(struct pid *pid);

void pidfs_remove_pid(struct pid *pid);

void pidfs_exit(struct task_struct *tsk);

extern const struct dentry_operations pidfs_dentry_operations;



#endif /* _LINUX_PID_FS_H */

kernel/exit.c

+2 −0
Original line number Diff line number Diff line
@@ -69,6 +69,7 @@ 
#include <linux/sysfs.h>

#include <linux/user_events.h>

#include <linux/uaccess.h>

#include <linux/pidfs.h>



#include <uapi/linux/wait.h>
@@ -249,6 +250,7 @@ void release_task(struct task_struct *p) 
	dec_rlimit_ucounts(task_ucounts(p), UCOUNT_RLIMIT_NPROC, 1);

	rcu_read_unlock();



	pidfs_exit(p);

	cgroup_release(p);



	write_lock_irq(&tasklist_lock);