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>
9 #include <linux/security.h>
10 #include <linux/file.h>
11 #include <linux/seq_file.h>
14 #include <linux/proc_fs.h>
20 static int seq_show(struct seq_file
*m
, void *v
)
22 struct files_struct
*files
= NULL
;
23 int f_flags
= 0, ret
= -ENOENT
;
24 struct file
*file
= NULL
;
25 struct task_struct
*task
;
27 task
= get_proc_task(m
->private);
31 files
= get_files_struct(task
);
32 put_task_struct(task
);
35 unsigned int fd
= proc_fd(m
->private);
37 spin_lock(&files
->file_lock
);
38 file
= fcheck_files(files
, fd
);
40 struct fdtable
*fdt
= files_fdtable(files
);
42 f_flags
= file
->f_flags
;
43 if (close_on_exec(fd
, fdt
))
49 spin_unlock(&files
->file_lock
);
50 put_files_struct(files
);
56 seq_printf(m
, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\n",
57 (long long)file
->f_pos
, f_flags
,
58 real_mount(file
->f_path
.mnt
)->mnt_id
);
60 show_fd_locks(m
, file
, files
);
61 if (seq_has_overflowed(m
))
64 if (file
->f_op
->show_fdinfo
)
65 file
->f_op
->show_fdinfo(m
, file
);
72 static int seq_fdinfo_open(struct inode
*inode
, struct file
*file
)
74 return single_open(file
, seq_show
, inode
);
77 static const struct file_operations proc_fdinfo_file_operations
= {
78 .open
= seq_fdinfo_open
,
81 .release
= single_release
,
84 static bool tid_fd_mode(struct task_struct
*task
, unsigned fd
, fmode_t
*mode
)
86 struct files_struct
*files
= get_files_struct(task
);
93 file
= fcheck_files(files
, fd
);
97 put_files_struct(files
);
101 static void tid_fd_update_inode(struct task_struct
*task
, struct inode
*inode
,
104 task_dump_owner(task
, 0, &inode
->i_uid
, &inode
->i_gid
);
106 if (S_ISLNK(inode
->i_mode
)) {
107 unsigned i_mode
= S_IFLNK
;
108 if (f_mode
& FMODE_READ
)
109 i_mode
|= S_IRUSR
| S_IXUSR
;
110 if (f_mode
& FMODE_WRITE
)
111 i_mode
|= S_IWUSR
| S_IXUSR
;
112 inode
->i_mode
= i_mode
;
114 security_task_to_inode(task
, inode
);
117 static int tid_fd_revalidate(struct dentry
*dentry
, unsigned int flags
)
119 struct task_struct
*task
;
123 if (flags
& LOOKUP_RCU
)
126 inode
= d_inode(dentry
);
127 task
= get_proc_task(inode
);
132 if (tid_fd_mode(task
, fd
, &f_mode
)) {
133 tid_fd_update_inode(task
, inode
, f_mode
);
134 put_task_struct(task
);
137 put_task_struct(task
);
142 static const struct dentry_operations tid_fd_dentry_operations
= {
143 .d_revalidate
= tid_fd_revalidate
,
144 .d_delete
= pid_delete_dentry
,
147 static int proc_fd_link(struct dentry
*dentry
, struct path
*path
)
149 struct files_struct
*files
= NULL
;
150 struct task_struct
*task
;
153 task
= get_proc_task(d_inode(dentry
));
155 files
= get_files_struct(task
);
156 put_task_struct(task
);
160 unsigned int fd
= proc_fd(d_inode(dentry
));
161 struct file
*fd_file
;
163 spin_lock(&files
->file_lock
);
164 fd_file
= fcheck_files(files
, fd
);
166 *path
= fd_file
->f_path
;
167 path_get(&fd_file
->f_path
);
170 spin_unlock(&files
->file_lock
);
171 put_files_struct(files
);
182 static struct dentry
*proc_fd_instantiate(struct dentry
*dentry
,
183 struct task_struct
*task
, const void *ptr
)
185 const struct fd_data
*data
= ptr
;
186 struct proc_inode
*ei
;
189 inode
= proc_pid_make_inode(dentry
->d_sb
, task
, S_IFLNK
);
191 return ERR_PTR(-ENOENT
);
196 inode
->i_op
= &proc_pid_link_inode_operations
;
199 ei
->op
.proc_get_link
= proc_fd_link
;
200 tid_fd_update_inode(task
, inode
, data
->mode
);
202 d_set_d_op(dentry
, &tid_fd_dentry_operations
);
203 return d_splice_alias(inode
, dentry
);
206 static struct dentry
*proc_lookupfd_common(struct inode
*dir
,
207 struct dentry
*dentry
,
208 instantiate_t instantiate
)
210 struct task_struct
*task
= get_proc_task(dir
);
211 struct fd_data data
= {.fd
= name_to_int(&dentry
->d_name
)};
212 struct dentry
*result
= ERR_PTR(-ENOENT
);
218 if (!tid_fd_mode(task
, data
.fd
, &data
.mode
))
221 result
= instantiate(dentry
, task
, &data
);
223 put_task_struct(task
);
228 static int proc_readfd_common(struct file
*file
, struct dir_context
*ctx
,
229 instantiate_t instantiate
)
231 struct task_struct
*p
= get_proc_task(file_inode(file
));
232 struct files_struct
*files
;
238 if (!dir_emit_dots(file
, ctx
))
240 files
= get_files_struct(p
);
245 for (fd
= ctx
->pos
- 2;
246 fd
< files_fdtable(files
)->max_fds
;
253 f
= fcheck_files(files
, fd
);
256 data
.mode
= f
->f_mode
;
260 len
= snprintf(name
, sizeof(name
), "%u", fd
);
261 if (!proc_fill_cache(file
, ctx
,
262 name
, len
, instantiate
, p
,
270 put_files_struct(files
);
276 static int proc_readfd(struct file
*file
, struct dir_context
*ctx
)
278 return proc_readfd_common(file
, ctx
, proc_fd_instantiate
);
281 const struct file_operations proc_fd_operations
= {
282 .read
= generic_read_dir
,
283 .iterate_shared
= proc_readfd
,
284 .llseek
= generic_file_llseek
,
287 static struct dentry
*proc_lookupfd(struct inode
*dir
, struct dentry
*dentry
,
290 return proc_lookupfd_common(dir
, dentry
, proc_fd_instantiate
);
294 * /proc/pid/fd needs a special permission handler so that a process can still
295 * access /proc/self/fd after it has executed a setuid().
297 int proc_fd_permission(struct inode
*inode
, int mask
)
299 struct task_struct
*p
;
302 rv
= generic_permission(inode
, mask
);
307 p
= pid_task(proc_pid(inode
), PIDTYPE_PID
);
308 if (p
&& same_thread_group(p
, current
))
315 const struct inode_operations proc_fd_inode_operations
= {
316 .lookup
= proc_lookupfd
,
317 .permission
= proc_fd_permission
,
318 .setattr
= proc_setattr
,
321 static struct dentry
*proc_fdinfo_instantiate(struct dentry
*dentry
,
322 struct task_struct
*task
, const void *ptr
)
324 const struct fd_data
*data
= ptr
;
325 struct proc_inode
*ei
;
328 inode
= proc_pid_make_inode(dentry
->d_sb
, task
, S_IFREG
| S_IRUSR
);
330 return ERR_PTR(-ENOENT
);
335 inode
->i_fop
= &proc_fdinfo_file_operations
;
336 tid_fd_update_inode(task
, inode
, 0);
338 d_set_d_op(dentry
, &tid_fd_dentry_operations
);
339 return d_splice_alias(inode
, dentry
);
342 static struct dentry
*
343 proc_lookupfdinfo(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
345 return proc_lookupfd_common(dir
, dentry
, proc_fdinfo_instantiate
);
348 static int proc_readfdinfo(struct file
*file
, struct dir_context
*ctx
)
350 return proc_readfd_common(file
, ctx
,
351 proc_fdinfo_instantiate
);
354 const struct inode_operations proc_fdinfo_inode_operations
= {
355 .lookup
= proc_lookupfdinfo
,
356 .setattr
= proc_setattr
,
359 const struct file_operations proc_fdinfo_operations
= {
360 .read
= generic_read_dir
,
361 .iterate_shared
= proc_readfdinfo
,
362 .llseek
= generic_file_llseek
,