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

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

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ 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 #include <linux/sched/signal.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                 unsigned 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         struct inode *inode;
 88         unsigned int fd;
 89 
 90         if (flags & LOOKUP_RCU)
 91                 return -ECHILD;
 92 
 93         inode = d_inode(dentry);
 94         task = get_proc_task(inode);
 95         fd = proc_fd(inode);
 96 
 97         if (task) {
 98                 files = get_files_struct(task);
 99                 if (files) {
100                         struct file *file;
101 
102                         rcu_read_lock();
103                         file = fcheck_files(files, fd);
104                         if (file) {
105                                 unsigned f_mode = file->f_mode;
106 
107                                 rcu_read_unlock();
108                                 put_files_struct(files);
109 
110                                 task_dump_owner(task, 0, &inode->i_uid, &inode->i_gid);
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         return 0;
131 }
132 
133 static const struct dentry_operations tid_fd_dentry_operations = {
134         .d_revalidate   = tid_fd_revalidate,
135         .d_delete       = pid_delete_dentry,
136 };
137 
138 static int proc_fd_link(struct dentry *dentry, struct path *path)
139 {
140         struct files_struct *files = NULL;
141         struct task_struct *task;
142         int ret = -ENOENT;
143 
144         task = get_proc_task(d_inode(dentry));
145         if (task) {
146                 files = get_files_struct(task);
147                 put_task_struct(task);
148         }
149 
150         if (files) {
151                 unsigned int fd = proc_fd(d_inode(dentry));
152                 struct file *fd_file;
153 
154                 spin_lock(&files->file_lock);
155                 fd_file = fcheck_files(files, fd);
156                 if (fd_file) {
157                         *path = fd_file->f_path;
158                         path_get(&fd_file->f_path);
159                         ret = 0;
160                 }
161                 spin_unlock(&files->file_lock);
162                 put_files_struct(files);
163         }
164 
165         return ret;
166 }
167 
168 static int
169 proc_fd_instantiate(struct inode *dir, struct dentry *dentry,
170                     struct task_struct *task, const void *ptr)
171 {
172         unsigned fd = (unsigned long)ptr;
173         struct proc_inode *ei;
174         struct inode *inode;
175 
176         inode = proc_pid_make_inode(dir->i_sb, task, S_IFLNK);
177         if (!inode)
178                 goto out;
179 
180         ei = PROC_I(inode);
181         ei->fd = fd;
182 
183         inode->i_op = &proc_pid_link_inode_operations;
184         inode->i_size = 64;
185 
186         ei->op.proc_get_link = proc_fd_link;
187 
188         d_set_d_op(dentry, &tid_fd_dentry_operations);
189         d_add(dentry, inode);
190 
191         /* Close the race of the process dying before we return the dentry */
192         if (tid_fd_revalidate(dentry, 0))
193                 return 0;
194  out:
195         return -ENOENT;
196 }
197 
198 static struct dentry *proc_lookupfd_common(struct inode *dir,
199                                            struct dentry *dentry,
200                                            instantiate_t instantiate)
201 {
202         struct task_struct *task = get_proc_task(dir);
203         int result = -ENOENT;
204         unsigned fd = name_to_int(&dentry->d_name);
205 
206         if (!task)
207                 goto out_no_task;
208         if (fd == ~0U)
209                 goto out;
210 
211         result = instantiate(dir, dentry, task, (void *)(unsigned long)fd);
212 out:
213         put_task_struct(task);
214 out_no_task:
215         return ERR_PTR(result);
216 }
217 
218 static int proc_readfd_common(struct file *file, struct dir_context *ctx,
219                               instantiate_t instantiate)
220 {
221         struct task_struct *p = get_proc_task(file_inode(file));
222         struct files_struct *files;
223         unsigned int fd;
224 
225         if (!p)
226                 return -ENOENT;
227 
228         if (!dir_emit_dots(file, ctx))
229                 goto out;
230         files = get_files_struct(p);
231         if (!files)
232                 goto out;
233 
234         rcu_read_lock();
235         for (fd = ctx->pos - 2;
236              fd < files_fdtable(files)->max_fds;
237              fd++, ctx->pos++) {
238                 char name[PROC_NUMBUF];
239                 int len;
240 
241                 if (!fcheck_files(files, fd))
242                         continue;
243                 rcu_read_unlock();
244 
245                 len = snprintf(name, sizeof(name), "%u", fd);
246                 if (!proc_fill_cache(file, ctx,
247                                      name, len, instantiate, p,
248                                      (void *)(unsigned long)fd))
249                         goto out_fd_loop;
250                 cond_resched();
251                 rcu_read_lock();
252         }
253         rcu_read_unlock();
254 out_fd_loop:
255         put_files_struct(files);
256 out:
257         put_task_struct(p);
258         return 0;
259 }
260 
261 static int proc_readfd(struct file *file, struct dir_context *ctx)
262 {
263         return proc_readfd_common(file, ctx, proc_fd_instantiate);
264 }
265 
266 const struct file_operations proc_fd_operations = {
267         .read           = generic_read_dir,
268         .iterate_shared = proc_readfd,
269         .llseek         = generic_file_llseek,
270 };
271 
272 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
273                                     unsigned int flags)
274 {
275         return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
276 }
277 
278 /*
279  * /proc/pid/fd needs a special permission handler so that a process can still
280  * access /proc/self/fd after it has executed a setuid().
281  */
282 int proc_fd_permission(struct inode *inode, int mask)
283 {
284         struct task_struct *p;
285         int rv;
286 
287         rv = generic_permission(inode, mask);
288         if (rv == 0)
289                 return rv;
290 
291         rcu_read_lock();
292         p = pid_task(proc_pid(inode), PIDTYPE_PID);
293         if (p && same_thread_group(p, current))
294                 rv = 0;
295         rcu_read_unlock();
296 
297         return rv;
298 }
299 
300 const struct inode_operations proc_fd_inode_operations = {
301         .lookup         = proc_lookupfd,
302         .permission     = proc_fd_permission,
303         .setattr        = proc_setattr,
304 };
305 
306 static int
307 proc_fdinfo_instantiate(struct inode *dir, struct dentry *dentry,
308                         struct task_struct *task, const void *ptr)
309 {
310         unsigned fd = (unsigned long)ptr;
311         struct proc_inode *ei;
312         struct inode *inode;
313 
314         inode = proc_pid_make_inode(dir->i_sb, task, S_IFREG | S_IRUSR);
315         if (!inode)
316                 goto out;
317 
318         ei = PROC_I(inode);
319         ei->fd = fd;
320 
321         inode->i_fop = &proc_fdinfo_file_operations;
322 
323         d_set_d_op(dentry, &tid_fd_dentry_operations);
324         d_add(dentry, inode);
325 
326         /* Close the race of the process dying before we return the dentry */
327         if (tid_fd_revalidate(dentry, 0))
328                 return 0;
329  out:
330         return -ENOENT;
331 }
332 
333 static struct dentry *
334 proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags)
335 {
336         return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
337 }
338 
339 static int proc_readfdinfo(struct file *file, struct dir_context *ctx)
340 {
341         return proc_readfd_common(file, ctx,
342                                   proc_fdinfo_instantiate);
343 }
344 
345 const struct inode_operations proc_fdinfo_inode_operations = {
346         .lookup         = proc_lookupfdinfo,
347         .setattr        = proc_setattr,
348 };
349 
350 const struct file_operations proc_fdinfo_operations = {
351         .read           = generic_read_dir,
352         .iterate_shared = proc_readfdinfo,
353         .llseek         = generic_file_llseek,
354 };
355 

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