1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/anon_inodes.h>
  3#include <linux/file.h>
  4#include <linux/fs.h>
  5#include <linux/magic.h>
  6#include <linux/mount.h>
  7#include <linux/pid.h>
  8#include <linux/pidfs.h>
  9#include <linux/pid_namespace.h>
 10#include <linux/poll.h>
 11#include <linux/proc_fs.h>
 12#include <linux/proc_ns.h>
 13#include <linux/pseudo_fs.h>
 14#include <linux/seq_file.h>
 15#include <uapi/linux/pidfd.h>
 16
 17#include "internal.h"
 18
 19#ifdef CONFIG_PROC_FS
 20/**
 21 * pidfd_show_fdinfo - print information about a pidfd
 22 * @m: proc fdinfo file
 23 * @f: file referencing a pidfd
 24 *
 25 * Pid:
 26 * This function will print the pid that a given pidfd refers to in the
 27 * pid namespace of the procfs instance.
 28 * If the pid namespace of the process is not a descendant of the pid
 29 * namespace of the procfs instance 0 will be shown as its pid. This is
 30 * similar to calling getppid() on a process whose parent is outside of
 31 * its pid namespace.
 32 *
 33 * NSpid:
 34 * If pid namespaces are supported then this function will also print
 35 * the pid of a given pidfd refers to for all descendant pid namespaces
 36 * starting from the current pid namespace of the instance, i.e. the
 37 * Pid field and the first entry in the NSpid field will be identical.
 38 * If the pid namespace of the process is not a descendant of the pid
 39 * namespace of the procfs instance 0 will be shown as its first NSpid
 40 * entry and no others will be shown.
 41 * Note that this differs from the Pid and NSpid fields in
 42 * /proc/<pid>/status where Pid and NSpid are always shown relative to
 43 * the  pid namespace of the procfs instance. The difference becomes
 44 * obvious when sending around a pidfd between pid namespaces from a
 45 * different branch of the tree, i.e. where no ancestral relation is
 46 * present between the pid namespaces:
 47 * - create two new pid namespaces ns1 and ns2 in the initial pid
 48 *   namespace (also take care to create new mount namespaces in the
 49 *   new pid namespace and mount procfs)
 50 * - create a process with a pidfd in ns1
 51 * - send pidfd from ns1 to ns2
 52 * - read /proc/self/fdinfo/<pidfd> and observe that both Pid and NSpid
 53 *   have exactly one entry, which is 0
 54 */
 55static void pidfd_show_fdinfo(struct seq_file *m, struct file *f)
 56{
 57	struct pid *pid = pidfd_pid(f);
 58	struct pid_namespace *ns;
 59	pid_t nr = -1;
 60
 61	if (likely(pid_has_task(pid, PIDTYPE_PID))) {
 62		ns = proc_pid_ns(file_inode(m->file)->i_sb);
 63		nr = pid_nr_ns(pid, ns);
 64	}
 65
 66	seq_put_decimal_ll(m, "Pid:\t", nr);
 67
 68#ifdef CONFIG_PID_NS
 69	seq_put_decimal_ll(m, "\nNSpid:\t", nr);
 70	if (nr > 0) {
 71		int i;
 72
 73		/* If nr is non-zero it means that 'pid' is valid and that
 74		 * ns, i.e. the pid namespace associated with the procfs
 75		 * instance, is in the pid namespace hierarchy of pid.
 76		 * Start at one below the already printed level.
 77		 */
 78		for (i = ns->level + 1; i <= pid->level; i++)
 79			seq_put_decimal_ll(m, "\t", pid->numbers[i].nr);
 80	}
 81#endif
 82	seq_putc(m, '\n');
 83}
 84#endif
 85
 86/*
 87 * Poll support for process exit notification.
 88 */
 89static __poll_t pidfd_poll(struct file *file, struct poll_table_struct *pts)
 90{
 91	struct pid *pid = pidfd_pid(file);
 92	bool thread = file->f_flags & PIDFD_THREAD;
 93	struct task_struct *task;
 94	__poll_t poll_flags = 0;
 95
 96	poll_wait(file, &pid->wait_pidfd, pts);
 97	/*
 98	 * Depending on PIDFD_THREAD, inform pollers when the thread
 99	 * or the whole thread-group exits.
100	 */
101	guard(rcu)();
102	task = pid_task(pid, PIDTYPE_PID);
103	if (!task)
104		poll_flags = EPOLLIN | EPOLLRDNORM | EPOLLHUP;
105	else if (task->exit_state && (thread || thread_group_empty(task)))
106		poll_flags = EPOLLIN | EPOLLRDNORM;
107
108	return poll_flags;
109}
110
111static const struct file_operations pidfs_file_operations = {
112	.poll		= pidfd_poll,
113#ifdef CONFIG_PROC_FS
114	.show_fdinfo	= pidfd_show_fdinfo,
115#endif
116};
117
118struct pid *pidfd_pid(const struct file *file)
119{
120	if (file->f_op != &pidfs_file_operations)
121		return ERR_PTR(-EBADF);
122	return file_inode(file)->i_private;
123}
124
125static struct vfsmount *pidfs_mnt __ro_after_init;
126
127#if BITS_PER_LONG == 32
128/*
129 * Provide a fallback mechanism for 32-bit systems so processes remain
130 * reliably comparable by inode number even on those systems.
131 */
132static DEFINE_IDA(pidfd_inum_ida);
133
134static int pidfs_inum(struct pid *pid, unsigned long *ino)
135{
136	int ret;
137
138	ret = ida_alloc_range(&pidfd_inum_ida, RESERVED_PIDS + 1,
139			      UINT_MAX, GFP_ATOMIC);
140	if (ret < 0)
141		return -ENOSPC;
142
143	*ino = ret;
144	return 0;
145}
146
147static inline void pidfs_free_inum(unsigned long ino)
148{
149	if (ino > 0)
150		ida_free(&pidfd_inum_ida, ino);
151}
152#else
153static inline int pidfs_inum(struct pid *pid, unsigned long *ino)
154{
155	*ino = pid->ino;
156	return 0;
157}
158#define pidfs_free_inum(ino) ((void)(ino))
159#endif
160
161/*
162 * The vfs falls back to simple_setattr() if i_op->setattr() isn't
163 * implemented. Let's reject it completely until we have a clean
164 * permission concept for pidfds.
165 */
166static int pidfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
167			 struct iattr *attr)
168{
169	return -EOPNOTSUPP;
170}
171
172static int pidfs_getattr(struct mnt_idmap *idmap, const struct path *path,
173			 struct kstat *stat, u32 request_mask,
174			 unsigned int query_flags)
175{
176	struct inode *inode = d_inode(path->dentry);
177
178	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
179	return 0;
180}
181
182static const struct inode_operations pidfs_inode_operations = {
183	.getattr = pidfs_getattr,
184	.setattr = pidfs_setattr,
185};
186
187static void pidfs_evict_inode(struct inode *inode)
188{
189	struct pid *pid = inode->i_private;
190
191	clear_inode(inode);
192	put_pid(pid);
193	pidfs_free_inum(inode->i_ino);
194}
195
196static const struct super_operations pidfs_sops = {
197	.drop_inode	= generic_delete_inode,
198	.evict_inode	= pidfs_evict_inode,
199	.statfs		= simple_statfs,
200};
201
202static char *pidfs_dname(struct dentry *dentry, char *buffer, int buflen)
203{
204	struct inode *inode = d_inode(dentry);
205	struct pid *pid = inode->i_private;
206
207	return dynamic_dname(buffer, buflen, "pidfd:[%llu]", pid->ino);
208}
209
210static const struct dentry_operations pidfs_dentry_operations = {
211	.d_delete	= always_delete_dentry,
212	.d_dname	= pidfs_dname,
213	.d_prune	= stashed_dentry_prune,
214};
215
216static int pidfs_init_inode(struct inode *inode, void *data)
217{
218	inode->i_private = data;
219	inode->i_flags |= S_PRIVATE;
220	inode->i_mode |= S_IRWXU;
221	inode->i_op = &pidfs_inode_operations;
222	inode->i_fop = &pidfs_file_operations;
223	/*
224	 * Inode numbering for pidfs start at RESERVED_PIDS + 1. This
225	 * avoids collisions with the root inode which is 1 for pseudo
226	 * filesystems.
227	 */
228	return pidfs_inum(data, &inode->i_ino);
229}
230
231static void pidfs_put_data(void *data)
232{
233	struct pid *pid = data;
234	put_pid(pid);
235}
236
237static const struct stashed_operations pidfs_stashed_ops = {
238	.init_inode = pidfs_init_inode,
239	.put_data = pidfs_put_data,
240};
241
242static int pidfs_init_fs_context(struct fs_context *fc)
243{
244	struct pseudo_fs_context *ctx;
245
246	ctx = init_pseudo(fc, PID_FS_MAGIC);
247	if (!ctx)
248		return -ENOMEM;
249
250	ctx->ops = &pidfs_sops;
251	ctx->dops = &pidfs_dentry_operations;
252	fc->s_fs_info = (void *)&pidfs_stashed_ops;
253	return 0;
254}
255
256static struct file_system_type pidfs_type = {
257	.name			= "pidfs",
258	.init_fs_context	= pidfs_init_fs_context,
259	.kill_sb		= kill_anon_super,
260};
261
262struct file *pidfs_alloc_file(struct pid *pid, unsigned int flags)
263{
264
265	struct file *pidfd_file;
266	struct path path;
267	int ret;
268
269	ret = path_from_stashed(&pid->stashed, pidfs_mnt, get_pid(pid), &path);
270	if (ret < 0)
271		return ERR_PTR(ret);
272
273	pidfd_file = dentry_open(&path, flags, current_cred());
274	path_put(&path);
275	return pidfd_file;
276}
277
278void __init pidfs_init(void)
279{
280	pidfs_mnt = kern_mount(&pidfs_type);
281	if (IS_ERR(pidfs_mnt))
282		panic("Failed to mount pidfs pseudo filesystem");
283}