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

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

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

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