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

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

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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 #include <linux/sched.h>
  2 #include <linux/errno.h>
  3 #include <linux/dcache.h>
  4 #include <linux/path.h>
  5 #include <linux/fdtable.h>
  6 #include <linux/namei.h>
  7 #include <linux/pid.h>
  8 #include <linux/security.h>
  9 #include <linux/file.h>
 10 #include <linux/seq_file.h>
 11 #include <linux/fs.h>
 12 
 13 #include <linux/proc_fs.h>
 14 
 15 #include "../mount.h"
 16 #include "internal.h"
 17 #include "fd.h"
 18 
 19 static int seq_show(struct seq_file *m, void *v)
 20 {
 21         struct files_struct *files = NULL;
 22         int f_flags = 0, ret = -ENOENT;
 23         struct file *file = NULL;
 24         struct task_struct *task;
 25 
 26         task = get_proc_task(m->private);
 27         if (!task)
 28                 return -ENOENT;
 29 
 30         files = get_files_struct(task);
 31         put_task_struct(task);
 32 
 33         if (files) {
 34                 int fd = proc_fd(m->private);
 35 
 36                 spin_lock(&files->file_lock);
 37                 file = fcheck_files(files, fd);
 38                 if (file) {
 39                         struct fdtable *fdt = files_fdtable(files);
 40 
 41                         f_flags = file->f_flags;
 42                         if (close_on_exec(fd, fdt))
 43                                 f_flags |= O_CLOEXEC;
 44 
 45                         get_file(file);
 46                         ret = 0;
 47                 }
 48                 spin_unlock(&files->file_lock);
 49                 put_files_struct(files);
 50         }
 51 
 52         if (ret)
 53                 return ret;
 54 
 55         seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\n",
 56                    (long long)file->f_pos, f_flags,
 57                    real_mount(file->f_path.mnt)->mnt_id);
 58 
 59         show_fd_locks(m, file, files);
 60         if (seq_has_overflowed(m))
 61                 goto out;
 62 
 63         if (file->f_op->show_fdinfo)
 64                 file->f_op->show_fdinfo(m, file);
 65 
 66 out:
 67         fput(file);
 68         return 0;
 69 }
 70 
 71 static int seq_fdinfo_open(struct inode *inode, struct file *file)
 72 {
 73         return single_open(file, seq_show, inode);
 74 }
 75 
 76 static const struct file_operations proc_fdinfo_file_operations = {
 77         .open           = seq_fdinfo_open,
 78         .read           = seq_read,
 79         .llseek         = seq_lseek,
 80         .release        = single_release,
 81 };
 82 
 83 static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
 84 {
 85         struct files_struct *files;
 86         struct task_struct *task;
 87         const struct cred *cred;
 88         struct inode *inode;
 89         int fd;
 90 
 91         if (flags & LOOKUP_RCU)
 92                 return -ECHILD;
 93 
 94         inode = d_inode(dentry);
 95         task = get_proc_task(inode);
 96         fd = proc_fd(inode);
 97 
 98         if (task) {
 99                 files = get_files_struct(task);
100                 if (files) {
101                         struct file *file;
102 
103                         rcu_read_lock();
104                         file = fcheck_files(files, fd);
105                         if (file) {
106                                 unsigned f_mode = file->f_mode;
107 
108                                 rcu_read_unlock();
109                                 put_files_struct(files);
110 
111                                 if (task_dumpable(task)) {
112                                         rcu_read_lock();
113                                         cred = __task_cred(task);
114                                         inode->i_uid = cred->euid;
115                                         inode->i_gid = cred->egid;
116                                         rcu_read_unlock();
117                                 } else {
118                                         inode->i_uid = GLOBAL_ROOT_UID;
119                                         inode->i_gid = GLOBAL_ROOT_GID;
120                                 }
121 
122                                 if (S_ISLNK(inode->i_mode)) {
123                                         unsigned i_mode = S_IFLNK;
124                                         if (f_mode & FMODE_READ)
125                                                 i_mode |= S_IRUSR | S_IXUSR;
126                                         if (f_mode & FMODE_WRITE)
127                                                 i_mode |= S_IWUSR | S_IXUSR;
128                                         inode->i_mode = i_mode;
129                                 }
130 
131                                 security_task_to_inode(task, inode);
132                                 put_task_struct(task);
133                                 return 1;
134                         }
135                         rcu_read_unlock();
136                         put_files_struct(files);
137                 }
138                 put_task_struct(task);
139         }
140         return 0;
141 }
142 
143 static const struct dentry_operations tid_fd_dentry_operations = {
144         .d_revalidate   = tid_fd_revalidate,
145         .d_delete       = pid_delete_dentry,
146 };
147 
148 static int proc_fd_link(struct dentry *dentry, struct path *path)
149 {
150         struct files_struct *files = NULL;
151         struct task_struct *task;
152         int ret = -ENOENT;
153 
154         task = get_proc_task(d_inode(dentry));
155         if (task) {
156                 files = get_files_struct(task);
157                 put_task_struct(task);
158         }
159 
160         if (files) {
161                 int fd = proc_fd(d_inode(dentry));
162                 struct file *fd_file;
163 
164                 spin_lock(&files->file_lock);
165                 fd_file = fcheck_files(files, fd);
166                 if (fd_file) {
167                         *path = fd_file->f_path;
168                         path_get(&fd_file->f_path);
169                         ret = 0;
170                 }
171                 spin_unlock(&files->file_lock);
172                 put_files_struct(files);
173         }
174 
175         return ret;
176 }
177 
178 static int
179 proc_fd_instantiate(struct inode *dir, struct dentry *dentry,
180                     struct task_struct *task, const void *ptr)
181 {
182         unsigned fd = (unsigned long)ptr;
183         struct proc_inode *ei;
184         struct inode *inode;
185 
186         inode = proc_pid_make_inode(dir->i_sb, task);
187         if (!inode)
188                 goto out;
189 
190         ei = PROC_I(inode);
191         ei->fd = fd;
192 
193         inode->i_mode = S_IFLNK;
194         inode->i_op = &proc_pid_link_inode_operations;
195         inode->i_size = 64;
196 
197         ei->op.proc_get_link = proc_fd_link;
198 
199         d_set_d_op(dentry, &tid_fd_dentry_operations);
200         d_add(dentry, inode);
201 
202         /* Close the race of the process dying before we return the dentry */
203         if (tid_fd_revalidate(dentry, 0))
204                 return 0;
205  out:
206         return -ENOENT;
207 }
208 
209 static struct dentry *proc_lookupfd_common(struct inode *dir,
210                                            struct dentry *dentry,
211                                            instantiate_t instantiate)
212 {
213         struct task_struct *task = get_proc_task(dir);
214         int result = -ENOENT;
215         unsigned fd = name_to_int(&dentry->d_name);
216 
217         if (!task)
218                 goto out_no_task;
219         if (fd == ~0U)
220                 goto out;
221 
222         result = instantiate(dir, dentry, task, (void *)(unsigned long)fd);
223 out:
224         put_task_struct(task);
225 out_no_task:
226         return ERR_PTR(result);
227 }
228 
229 static int proc_readfd_common(struct file *file, struct dir_context *ctx,
230                               instantiate_t instantiate)
231 {
232         struct task_struct *p = get_proc_task(file_inode(file));
233         struct files_struct *files;
234         unsigned int fd;
235 
236         if (!p)
237                 return -ENOENT;
238 
239         if (!dir_emit_dots(file, ctx))
240                 goto out;
241         files = get_files_struct(p);
242         if (!files)
243                 goto out;
244 
245         rcu_read_lock();
246         for (fd = ctx->pos - 2;
247              fd < files_fdtable(files)->max_fds;
248              fd++, ctx->pos++) {
249                 char name[PROC_NUMBUF];
250                 int len;
251 
252                 if (!fcheck_files(files, fd))
253                         continue;
254                 rcu_read_unlock();
255 
256                 len = snprintf(name, sizeof(name), "%d", fd);
257                 if (!proc_fill_cache(file, ctx,
258                                      name, len, instantiate, p,
259                                      (void *)(unsigned long)fd))
260                         goto out_fd_loop;
261                 rcu_read_lock();
262         }
263         rcu_read_unlock();
264 out_fd_loop:
265         put_files_struct(files);
266 out:
267         put_task_struct(p);
268         return 0;
269 }
270 
271 static int proc_readfd(struct file *file, struct dir_context *ctx)
272 {
273         return proc_readfd_common(file, ctx, proc_fd_instantiate);
274 }
275 
276 const struct file_operations proc_fd_operations = {
277         .read           = generic_read_dir,
278         .iterate        = proc_readfd,
279         .llseek         = default_llseek,
280 };
281 
282 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
283                                     unsigned int flags)
284 {
285         return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
286 }
287 
288 /*
289  * /proc/pid/fd needs a special permission handler so that a process can still
290  * access /proc/self/fd after it has executed a setuid().
291  */
292 int proc_fd_permission(struct inode *inode, int mask)
293 {
294         int rv = generic_permission(inode, mask);
295         if (rv == 0)
296                 return 0;
297         if (task_tgid(current) == proc_pid(inode))
298                 rv = 0;
299         return rv;
300 }
301 
302 const struct inode_operations proc_fd_inode_operations = {
303         .lookup         = proc_lookupfd,
304         .permission     = proc_fd_permission,
305         .setattr        = proc_setattr,
306 };
307 
308 static int
309 proc_fdinfo_instantiate(struct inode *dir, struct dentry *dentry,
310                         struct task_struct *task, const void *ptr)
311 {
312         unsigned fd = (unsigned long)ptr;
313         struct proc_inode *ei;
314         struct inode *inode;
315 
316         inode = proc_pid_make_inode(dir->i_sb, task);
317         if (!inode)
318                 goto out;
319 
320         ei = PROC_I(inode);
321         ei->fd = fd;
322 
323         inode->i_mode = S_IFREG | S_IRUSR;
324         inode->i_fop = &proc_fdinfo_file_operations;
325 
326         d_set_d_op(dentry, &tid_fd_dentry_operations);
327         d_add(dentry, inode);
328 
329         /* Close the race of the process dying before we return the dentry */
330         if (tid_fd_revalidate(dentry, 0))
331                 return 0;
332  out:
333         return -ENOENT;
334 }
335 
336 static struct dentry *
337 proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags)
338 {
339         return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
340 }
341 
342 static int proc_readfdinfo(struct file *file, struct dir_context *ctx)
343 {
344         return proc_readfd_common(file, ctx,
345                                   proc_fdinfo_instantiate);
346 }
347 
348 const struct inode_operations proc_fdinfo_inode_operations = {
349         .lookup         = proc_lookupfdinfo,
350         .setattr        = proc_setattr,
351 };
352 
353 const struct file_operations proc_fdinfo_operations = {
354         .read           = generic_read_dir,
355         .iterate        = proc_readfdinfo,
356         .llseek         = default_llseek,
357 };
358 

~ [ 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