~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/proc/fd.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/security.h>
 10 #include <linux/file.h>
 11 #include <linux/seq_file.h>
 12 #include <linux/fs.h>
 13 
 14 #include <linux/proc_fs.h>
 15 
 16 #include "../mount.h"
 17 #include "internal.h"
 18 #include "fd.h"
 19 
 20 static int seq_show(struct seq_file *m, void *v)
 21 {
 22         struct files_struct *files = NULL;
 23         int f_flags = 0, ret = -ENOENT;
 24         struct file *file = NULL;
 25         struct task_struct *task;
 26 
 27         task = get_proc_task(m->private);
 28         if (!task)
 29                 return -ENOENT;
 30 
 31         files = get_files_struct(task);
 32         put_task_struct(task);
 33 
 34         if (files) {
 35                 unsigned int fd = proc_fd(m->private);
 36 
 37                 spin_lock(&files->file_lock);
 38                 file = fcheck_files(files, fd);
 39                 if (file) {
 40                         struct fdtable *fdt = files_fdtable(files);
 41 
 42                         f_flags = file->f_flags;
 43                         if (close_on_exec(fd, fdt))
 44                                 f_flags |= O_CLOEXEC;
 45 
 46                         get_file(file);
 47                         ret = 0;
 48                 }
 49                 spin_unlock(&files->file_lock);
 50                 put_files_struct(files);
 51         }
 52 
 53         if (ret)
 54                 return ret;
 55 
 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);
 59 
 60         show_fd_locks(m, file, files);
 61         if (seq_has_overflowed(m))
 62                 goto out;
 63 
 64         if (file->f_op->show_fdinfo)
 65                 file->f_op->show_fdinfo(m, file);
 66 
 67 out:
 68         fput(file);
 69         return 0;
 70 }
 71 
 72 static int seq_fdinfo_open(struct inode *inode, struct file *file)
 73 {
 74         return single_open(file, seq_show, inode);
 75 }
 76 
 77 static const struct file_operations proc_fdinfo_file_operations = {
 78         .open           = seq_fdinfo_open,
 79         .read           = seq_read,
 80         .llseek         = seq_lseek,
 81         .release        = single_release,
 82 };
 83 
 84 static bool tid_fd_mode(struct task_struct *task, unsigned fd, fmode_t *mode)
 85 {
 86         struct files_struct *files = get_files_struct(task);
 87         struct file *file;
 88 
 89         if (!files)
 90                 return false;
 91 
 92         rcu_read_lock();
 93         file = fcheck_files(files, fd);
 94         if (file)
 95                 *mode = file->f_mode;
 96         rcu_read_unlock();
 97         put_files_struct(files);
 98         return !!file;
 99 }
100 
101 static void tid_fd_update_inode(struct task_struct *task, struct inode *inode,
102                                 fmode_t f_mode)
103 {
104         task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid);
105 
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;
113         }
114         security_task_to_inode(task, inode);
115 }
116 
117 static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
118 {
119         struct task_struct *task;
120         struct inode *inode;
121         unsigned int fd;
122 
123         if (flags & LOOKUP_RCU)
124                 return -ECHILD;
125 
126         inode = d_inode(dentry);
127         task = get_proc_task(inode);
128         fd = proc_fd(inode);
129 
130         if (task) {
131                 fmode_t f_mode;
132                 if (tid_fd_mode(task, fd, &f_mode)) {
133                         tid_fd_update_inode(task, inode, f_mode);
134                         put_task_struct(task);
135                         return 1;
136                 }
137                 put_task_struct(task);
138         }
139         return 0;
140 }
141 
142 static const struct dentry_operations tid_fd_dentry_operations = {
143         .d_revalidate   = tid_fd_revalidate,
144         .d_delete       = pid_delete_dentry,
145 };
146 
147 static int proc_fd_link(struct dentry *dentry, struct path *path)
148 {
149         struct files_struct *files = NULL;
150         struct task_struct *task;
151         int ret = -ENOENT;
152 
153         task = get_proc_task(d_inode(dentry));
154         if (task) {
155                 files = get_files_struct(task);
156                 put_task_struct(task);
157         }
158 
159         if (files) {
160                 unsigned int fd = proc_fd(d_inode(dentry));
161                 struct file *fd_file;
162 
163                 spin_lock(&files->file_lock);
164                 fd_file = fcheck_files(files, fd);
165                 if (fd_file) {
166                         *path = fd_file->f_path;
167                         path_get(&fd_file->f_path);
168                         ret = 0;
169                 }
170                 spin_unlock(&files->file_lock);
171                 put_files_struct(files);
172         }
173 
174         return ret;
175 }
176 
177 struct fd_data {
178         fmode_t mode;
179         unsigned fd;
180 };
181 
182 static struct dentry *proc_fd_instantiate(struct dentry *dentry,
183         struct task_struct *task, const void *ptr)
184 {
185         const struct fd_data *data = ptr;
186         struct proc_inode *ei;
187         struct inode *inode;
188 
189         inode = proc_pid_make_inode(dentry->d_sb, task, S_IFLNK);
190         if (!inode)
191                 return ERR_PTR(-ENOENT);
192 
193         ei = PROC_I(inode);
194         ei->fd = data->fd;
195 
196         inode->i_op = &proc_pid_link_inode_operations;
197         inode->i_size = 64;
198 
199         ei->op.proc_get_link = proc_fd_link;
200         tid_fd_update_inode(task, inode, data->mode);
201 
202         d_set_d_op(dentry, &tid_fd_dentry_operations);
203         return d_splice_alias(inode, dentry);
204 }
205 
206 static struct dentry *proc_lookupfd_common(struct inode *dir,
207                                            struct dentry *dentry,
208                                            instantiate_t instantiate)
209 {
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);
213 
214         if (!task)
215                 goto out_no_task;
216         if (data.fd == ~0U)
217                 goto out;
218         if (!tid_fd_mode(task, data.fd, &data.mode))
219                 goto out;
220 
221         result = instantiate(dentry, task, &data);
222 out:
223         put_task_struct(task);
224 out_no_task:
225         return result;
226 }
227 
228 static int proc_readfd_common(struct file *file, struct dir_context *ctx,
229                               instantiate_t instantiate)
230 {
231         struct task_struct *p = get_proc_task(file_inode(file));
232         struct files_struct *files;
233         unsigned int fd;
234 
235         if (!p)
236                 return -ENOENT;
237 
238         if (!dir_emit_dots(file, ctx))
239                 goto out;
240         files = get_files_struct(p);
241         if (!files)
242                 goto out;
243 
244         rcu_read_lock();
245         for (fd = ctx->pos - 2;
246              fd < files_fdtable(files)->max_fds;
247              fd++, ctx->pos++) {
248                 struct file *f;
249                 struct fd_data data;
250                 char name[10 + 1];
251                 unsigned int len;
252 
253                 f = fcheck_files(files, fd);
254                 if (!f)
255                         continue;
256                 data.mode = f->f_mode;
257                 rcu_read_unlock();
258                 data.fd = fd;
259 
260                 len = snprintf(name, sizeof(name), "%u", fd);
261                 if (!proc_fill_cache(file, ctx,
262                                      name, len, instantiate, p,
263                                      &data))
264                         goto out_fd_loop;
265                 cond_resched();
266                 rcu_read_lock();
267         }
268         rcu_read_unlock();
269 out_fd_loop:
270         put_files_struct(files);
271 out:
272         put_task_struct(p);
273         return 0;
274 }
275 
276 static int proc_readfd(struct file *file, struct dir_context *ctx)
277 {
278         return proc_readfd_common(file, ctx, proc_fd_instantiate);
279 }
280 
281 const struct file_operations proc_fd_operations = {
282         .read           = generic_read_dir,
283         .iterate_shared = proc_readfd,
284         .llseek         = generic_file_llseek,
285 };
286 
287 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
288                                     unsigned int flags)
289 {
290         return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
291 }
292 
293 /*
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().
296  */
297 int proc_fd_permission(struct inode *inode, int mask)
298 {
299         struct task_struct *p;
300         int rv;
301 
302         rv = generic_permission(inode, mask);
303         if (rv == 0)
304                 return rv;
305 
306         rcu_read_lock();
307         p = pid_task(proc_pid(inode), PIDTYPE_PID);
308         if (p && same_thread_group(p, current))
309                 rv = 0;
310         rcu_read_unlock();
311 
312         return rv;
313 }
314 
315 const struct inode_operations proc_fd_inode_operations = {
316         .lookup         = proc_lookupfd,
317         .permission     = proc_fd_permission,
318         .setattr        = proc_setattr,
319 };
320 
321 static struct dentry *proc_fdinfo_instantiate(struct dentry *dentry,
322         struct task_struct *task, const void *ptr)
323 {
324         const struct fd_data *data = ptr;
325         struct proc_inode *ei;
326         struct inode *inode;
327 
328         inode = proc_pid_make_inode(dentry->d_sb, task, S_IFREG | S_IRUSR);
329         if (!inode)
330                 return ERR_PTR(-ENOENT);
331 
332         ei = PROC_I(inode);
333         ei->fd = data->fd;
334 
335         inode->i_fop = &proc_fdinfo_file_operations;
336         tid_fd_update_inode(task, inode, 0);
337 
338         d_set_d_op(dentry, &tid_fd_dentry_operations);
339         return d_splice_alias(inode, dentry);
340 }
341 
342 static struct dentry *
343 proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags)
344 {
345         return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
346 }
347 
348 static int proc_readfdinfo(struct file *file, struct dir_context *ctx)
349 {
350         return proc_readfd_common(file, ctx,
351                                   proc_fdinfo_instantiate);
352 }
353 
354 const struct inode_operations proc_fdinfo_inode_operations = {
355         .lookup         = proc_lookupfdinfo,
356         .setattr        = proc_setattr,
357 };
358 
359 const struct file_operations proc_fdinfo_operations = {
360         .read           = generic_read_dir,
361         .iterate_shared = proc_readfdinfo,
362         .llseek         = generic_file_llseek,
363 };
364 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp