projects/linux·blob master · refs

407 lines · 8.9 KiB

1// SPDX-License-Identifier: GPL-2.0
2#include <linux/sched/signal.h>
3#include <linux/errno.h>
4#include <linux/dcache.h>
5#include <linux/path.h>
6#include <linux/fdtable.h>
7#include <linux/namei.h>
8#include <linux/pid.h>
9#include <linux/ptrace.h>
10#include <linux/bitmap.h>
11#include <linux/security.h>
12#include <linux/file.h>
13#include <linux/seq_file.h>
14#include <linux/fs.h>
15#include <linux/filelock.h>
16
17#include <linux/proc_fs.h>
18
19#include "../mount.h"
20#include "internal.h"
21#include "fd.h"
22
23static int seq_show(struct seq_file *m, void *v)
24{
25 struct files_struct *files = NULL;
26 int f_flags = 0, ret = -ENOENT;
27 struct file *file = NULL;
28 struct task_struct *task;
29
30 task = get_proc_task(m->private);
31 if (!task)
32 return -ENOENT;
33
34 task_lock(task);
35 files = task->files;
36 if (files) {
37 unsigned int fd = proc_fd(m->private);
38
39 spin_lock(&files->file_lock);
40 file = files_lookup_fd_locked(files, fd);
41 if (file) {
42 f_flags = file->f_flags;
43 if (close_on_exec(fd, files))
44 f_flags |= O_CLOEXEC;
45
46 get_file(file);
47 ret = 0;
48 }
49 spin_unlock(&files->file_lock);
50 }
51 task_unlock(task);
52 put_task_struct(task);
53
54 if (ret)
55 return ret;
56
57 seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\nino:\t%llu\n",
58 (long long)file->f_pos, f_flags,
59 real_mount(file->f_path.mnt)->mnt_id,
60 file_inode(file)->i_ino);
61
62 /* show_fd_locks() never dereferences files, so a stale value is safe */
63 show_fd_locks(m, file, files);
64 if (seq_has_overflowed(m))
65 goto out;
66
67 if (file->f_op->show_fdinfo)
68 file->f_op->show_fdinfo(m, file);
69
70out:
71 fput(file);
72 return 0;
73}
74
75static int seq_fdinfo_open(struct inode *inode, struct file *file)
76{
77 return single_open(file, seq_show, inode);
78}
79
80/*
81 * Shared /proc/pid/fdinfo and /proc/pid/fdinfo/fd permission helper to ensure
82 * that the current task has PTRACE_MODE_READ in addition to the normal
83 * POSIX-like checks.
84 */
85static int proc_fdinfo_permission(const struct mnt_idmap *idmap, struct inode *inode,
86 int mask)
87{
88 bool allowed = false;
89 struct task_struct *task = get_proc_task(inode);
90
91 if (!task)
92 return -ESRCH;
93
94 allowed = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);
95 put_task_struct(task);
96
97 if (!allowed)
98 return -EACCES;
99
100 return generic_permission(idmap, inode, mask);
101}
102
103static const struct inode_operations proc_fdinfo_file_inode_operations = {
104 .permission = proc_fdinfo_permission,
105 .setattr = proc_nochmod_setattr,
106};
107
108static const struct file_operations proc_fdinfo_file_operations = {
109 .open = seq_fdinfo_open,
110 .read = seq_read,
111 .llseek = seq_lseek,
112 .release = single_release,
113};
114
115static bool tid_fd_mode(struct task_struct *task, unsigned fd, fmode_t *mode)
116{
117 struct file *file;
118
119 file = fget_task(task, fd);
120 if (file) {
121 *mode = file->f_mode;
122 fput(file);
123 }
124 return !!file;
125}
126
127static void tid_fd_update_inode(struct task_struct *task, struct inode *inode,
128 fmode_t f_mode)
129{
130 task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid);
131
132 if (S_ISLNK(inode->i_mode)) {
133 unsigned i_mode = S_IFLNK;
134 if (f_mode & FMODE_READ)
135 i_mode |= S_IRUSR | S_IXUSR;
136 if (f_mode & FMODE_WRITE)
137 i_mode |= S_IWUSR | S_IXUSR;
138 inode->i_mode = i_mode;
139 }
140 security_task_to_inode(task, inode);
141}
142
143static int tid_fd_revalidate(struct inode *dir, const struct qstr *name,
144 struct dentry *dentry, unsigned int flags)
145{
146 struct task_struct *task;
147 struct inode *inode;
148 unsigned int fd;
149
150 if (flags & LOOKUP_RCU)
151 return -ECHILD;
152
153 inode = d_inode(dentry);
154 task = get_proc_task(inode);
155 fd = proc_fd(inode);
156
157 if (task) {
158 fmode_t f_mode;
159 if (tid_fd_mode(task, fd, &f_mode)) {
160 tid_fd_update_inode(task, inode, f_mode);
161 put_task_struct(task);
162 return 1;
163 }
164 put_task_struct(task);
165 }
166 return 0;
167}
168
169static const struct dentry_operations tid_fd_dentry_operations = {
170 .d_revalidate = tid_fd_revalidate,
171 .d_delete = pid_delete_dentry,
172};
173
174static int proc_fd_link(struct dentry *dentry, struct path *path,
175 struct task_struct *task)
176{
177 int ret = -ENOENT;
178 unsigned int fd = proc_fd(d_inode(dentry));
179 struct file *fd_file;
180
181 fd_file = fget_task(task, fd);
182 if (fd_file) {
183 *path = fd_file->f_path;
184 path_get(&fd_file->f_path);
185 ret = 0;
186 fput(fd_file);
187 }
188
189 return ret;
190}
191
192struct fd_data {
193 fmode_t mode;
194 unsigned fd;
195};
196
197static struct dentry *proc_fd_instantiate(struct dentry *dentry,
198 struct task_struct *task, const void *ptr)
199{
200 const struct fd_data *data = ptr;
201 struct proc_inode *ei;
202 struct inode *inode;
203
204 inode = proc_pid_make_inode(dentry->d_sb, task, S_IFLNK);
205 if (!inode)
206 return ERR_PTR(-ENOENT);
207
208 ei = PROC_I(inode);
209 ei->fd = data->fd;
210
211 inode->i_op = &proc_pid_link_inode_operations;
212 inode->i_size = 64;
213
214 ei->op.proc_get_link = proc_fd_link;
215 tid_fd_update_inode(task, inode, data->mode);
216
217 return proc_splice_unmountable(inode, dentry,
218 &tid_fd_dentry_operations);
219}
220
221static struct dentry *proc_lookupfd_common(struct inode *dir,
222 struct dentry *dentry,
223 instantiate_t instantiate)
224{
225 struct task_struct *task = get_proc_task(dir);
226 struct fd_data data = {.fd = name_to_int(&dentry->d_name)};
227 struct dentry *result = ERR_PTR(-ENOENT);
228
229 if (!task)
230 goto out_no_task;
231 if (data.fd == ~0U)
232 goto out;
233 if (!tid_fd_mode(task, data.fd, &data.mode))
234 goto out;
235
236 result = instantiate(dentry, task, &data);
237out:
238 put_task_struct(task);
239out_no_task:
240 return result;
241}
242
243static int proc_readfd_common(struct file *file, struct dir_context *ctx,
244 instantiate_t instantiate)
245{
246 struct task_struct *p = get_proc_task(file_inode(file));
247 unsigned int fd;
248
249 if (!p)
250 return -ENOENT;
251
252 if (!dir_emit_dots(file, ctx))
253 goto out;
254
255 for (fd = ctx->pos - 2;; fd++) {
256 struct file *f;
257 struct fd_data data;
258 char name[10 + 1];
259 unsigned int len;
260
261 f = fget_task_next(p, &fd);
262 ctx->pos = fd + 2LL;
263 if (!f)
264 break;
265 data.mode = f->f_mode;
266 fput(f);
267 data.fd = fd;
268
269 len = snprintf(name, sizeof(name), "%u", fd);
270 if (!proc_fill_cache(file, ctx,
271 name, len, instantiate, p,
272 &data))
273 break;
274 cond_resched();
275 }
276out:
277 put_task_struct(p);
278 return 0;
279}
280
281static int proc_readfd_count(struct inode *inode, loff_t *count)
282{
283 struct task_struct *p = get_proc_task(inode);
284 struct fdtable *fdt;
285
286 if (!p)
287 return -ENOENT;
288
289 task_lock(p);
290 if (p->files) {
291 rcu_read_lock();
292
293 fdt = files_fdtable(p->files);
294 *count = bitmap_weight(fdt->open_fds, fdt->max_fds);
295
296 rcu_read_unlock();
297 }
298 task_unlock(p);
299
300 put_task_struct(p);
301
302 return 0;
303}
304
305static int proc_fd_iterate(struct file *file, struct dir_context *ctx)
306{
307 return proc_readfd_common(file, ctx, proc_fd_instantiate);
308}
309
310const struct file_operations proc_fd_operations = {
311 .read = generic_read_dir,
312 .iterate_shared = proc_fd_iterate,
313 .llseek = generic_file_llseek,
314};
315
316static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
317 unsigned int flags)
318{
319 return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
320}
321
322/*
323 * /proc/pid/fd needs a special permission handler so that a process can still
324 * access /proc/self/fd after it has executed a setuid().
325 */
326int proc_fd_permission(const struct mnt_idmap *idmap,
327 struct inode *inode, int mask)
328{
329 struct task_struct *p;
330 int rv;
331
332 rv = generic_permission(&nop_mnt_idmap, inode, mask);
333 if (rv == 0)
334 return rv;
335
336 rcu_read_lock();
337 p = pid_task(proc_pid(inode), PIDTYPE_PID);
338 if (p && same_thread_group(p, current))
339 rv = 0;
340 rcu_read_unlock();
341
342 return rv;
343}
344
345static int proc_fd_getattr(const struct mnt_idmap *idmap,
346 const struct path *path, struct kstat *stat,
347 u32 request_mask, unsigned int query_flags)
348{
349 struct inode *inode = d_inode(path->dentry);
350
351 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
352 return proc_readfd_count(inode, &stat->size);
353}
354
355const struct inode_operations proc_fd_inode_operations = {
356 .lookup = proc_lookupfd,
357 .permission = proc_fd_permission,
358 .getattr = proc_fd_getattr,
359 .setattr = proc_nochmod_setattr,
360};
361
362static struct dentry *proc_fdinfo_instantiate(struct dentry *dentry,
363 struct task_struct *task, const void *ptr)
364{
365 const struct fd_data *data = ptr;
366 struct proc_inode *ei;
367 struct inode *inode;
368
369 inode = proc_pid_make_inode(dentry->d_sb, task, S_IFREG | S_IRUGO);
370 if (!inode)
371 return ERR_PTR(-ENOENT);
372
373 ei = PROC_I(inode);
374 ei->fd = data->fd;
375
376 inode->i_op = &proc_fdinfo_file_inode_operations;
377
378 inode->i_fop = &proc_fdinfo_file_operations;
379 tid_fd_update_inode(task, inode, 0);
380
381 return proc_splice_unmountable(inode, dentry,
382 &tid_fd_dentry_operations);
383}
384
385static struct dentry *
386proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags)
387{
388 return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
389}
390
391static int proc_fdinfo_iterate(struct file *file, struct dir_context *ctx)
392{
393 return proc_readfd_common(file, ctx,
394 proc_fdinfo_instantiate);
395}
396
397const struct inode_operations proc_fdinfo_inode_operations = {
398 .lookup = proc_lookupfdinfo,
399 .permission = proc_fdinfo_permission,
400 .setattr = proc_nochmod_setattr,
401};
402
403const struct file_operations proc_fdinfo_operations = {
404 .read = generic_read_dir,
405 .iterate_shared = proc_fdinfo_iterate,
406 .llseek = generic_file_llseek,
407};