Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
fd.c
Go to the documentation of this file.
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  fput(file);
54  }
55 
56  return ret;
57 }
58 
59 static int seq_fdinfo_open(struct inode *inode, struct file *file)
60 {
61  return single_open(file, seq_show, inode);
62 }
63 
64 static const struct file_operations proc_fdinfo_file_operations = {
65  .open = seq_fdinfo_open,
66  .read = seq_read,
67  .llseek = seq_lseek,
68  .release = single_release,
69 };
70 
71 static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
72 {
73  struct files_struct *files;
74  struct task_struct *task;
75  const struct cred *cred;
76  struct inode *inode;
77  int fd;
78 
79  if (flags & LOOKUP_RCU)
80  return -ECHILD;
81 
82  inode = dentry->d_inode;
83  task = get_proc_task(inode);
84  fd = proc_fd(inode);
85 
86  if (task) {
87  files = get_files_struct(task);
88  if (files) {
89  struct file *file;
90 
91  rcu_read_lock();
92  file = fcheck_files(files, fd);
93  if (file) {
94  unsigned f_mode = file->f_mode;
95 
96  rcu_read_unlock();
97  put_files_struct(files);
98 
99  if (task_dumpable(task)) {
100  rcu_read_lock();
101  cred = __task_cred(task);
102  inode->i_uid = cred->euid;
103  inode->i_gid = cred->egid;
104  rcu_read_unlock();
105  } else {
106  inode->i_uid = GLOBAL_ROOT_UID;
107  inode->i_gid = GLOBAL_ROOT_GID;
108  }
109 
110  if (S_ISLNK(inode->i_mode)) {
111  unsigned i_mode = S_IFLNK;
112  if (f_mode & FMODE_READ)
113  i_mode |= S_IRUSR | S_IXUSR;
114  if (f_mode & FMODE_WRITE)
115  i_mode |= S_IWUSR | S_IXUSR;
116  inode->i_mode = i_mode;
117  }
118 
119  security_task_to_inode(task, inode);
120  put_task_struct(task);
121  return 1;
122  }
123  rcu_read_unlock();
124  put_files_struct(files);
125  }
126  put_task_struct(task);
127  }
128 
129  d_drop(dentry);
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(dentry->d_inode);
145  if (task) {
146  files = get_files_struct(task);
147  put_task_struct(task);
148  }
149 
150  if (files) {
151  int fd = proc_fd(dentry->d_inode);
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 struct dentry *
169 proc_fd_instantiate(struct inode *dir, struct dentry *dentry,
170  struct task_struct *task, const void *ptr)
171 {
172  struct dentry *error = ERR_PTR(-ENOENT);
173  unsigned fd = (unsigned long)ptr;
174  struct proc_inode *ei;
175  struct inode *inode;
176 
177  inode = proc_pid_make_inode(dir->i_sb, task);
178  if (!inode)
179  goto out;
180 
181  ei = PROC_I(inode);
182  ei->fd = fd;
183 
184  inode->i_mode = S_IFLNK;
186  inode->i_size = 64;
187 
188  ei->op.proc_get_link = proc_fd_link;
189 
190  d_set_d_op(dentry, &tid_fd_dentry_operations);
191  d_add(dentry, inode);
192 
193  /* Close the race of the process dying before we return the dentry */
194  if (tid_fd_revalidate(dentry, 0))
195  error = NULL;
196  out:
197  return error;
198 }
199 
200 static struct dentry *proc_lookupfd_common(struct inode *dir,
201  struct dentry *dentry,
202  instantiate_t instantiate)
203 {
204  struct task_struct *task = get_proc_task(dir);
205  struct dentry *result = ERR_PTR(-ENOENT);
206  unsigned fd = name_to_int(dentry);
207 
208  if (!task)
209  goto out_no_task;
210  if (fd == ~0U)
211  goto out;
212 
213  result = instantiate(dir, dentry, task, (void *)(unsigned long)fd);
214 out:
215  put_task_struct(task);
216 out_no_task:
217  return result;
218 }
219 
220 static int proc_readfd_common(struct file * filp, void * dirent,
221  filldir_t filldir, instantiate_t instantiate)
222 {
223  struct dentry *dentry = filp->f_path.dentry;
224  struct inode *inode = dentry->d_inode;
225  struct task_struct *p = get_proc_task(inode);
226  struct files_struct *files;
227  unsigned int fd, ino;
228  int retval;
229 
230  retval = -ENOENT;
231  if (!p)
232  goto out_no_task;
233  retval = 0;
234 
235  fd = filp->f_pos;
236  switch (fd) {
237  case 0:
238  if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
239  goto out;
240  filp->f_pos++;
241  case 1:
242  ino = parent_ino(dentry);
243  if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
244  goto out;
245  filp->f_pos++;
246  default:
247  files = get_files_struct(p);
248  if (!files)
249  goto out;
250  rcu_read_lock();
251  for (fd = filp->f_pos - 2;
252  fd < files_fdtable(files)->max_fds;
253  fd++, filp->f_pos++) {
254  char name[PROC_NUMBUF];
255  int len;
256  int rv;
257 
258  if (!fcheck_files(files, fd))
259  continue;
260  rcu_read_unlock();
261 
262  len = snprintf(name, sizeof(name), "%d", fd);
263  rv = proc_fill_cache(filp, dirent, filldir,
264  name, len, instantiate, p,
265  (void *)(unsigned long)fd);
266  if (rv < 0)
267  goto out_fd_loop;
268  rcu_read_lock();
269  }
270  rcu_read_unlock();
271 out_fd_loop:
272  put_files_struct(files);
273  }
274 out:
275  put_task_struct(p);
276 out_no_task:
277  return retval;
278 }
279 
280 static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir)
281 {
282  return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate);
283 }
284 
286  .read = generic_read_dir,
287  .readdir = proc_readfd,
288  .llseek = default_llseek,
289 };
290 
291 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
292  unsigned int flags)
293 {
294  return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
295 }
296 
297 /*
298  * /proc/pid/fd needs a special permission handler so that a process can still
299  * access /proc/self/fd after it has executed a setuid().
300  */
301 int proc_fd_permission(struct inode *inode, int mask)
302 {
303  int rv = generic_permission(inode, mask);
304  if (rv == 0)
305  return 0;
306  if (task_pid(current) == proc_pid(inode))
307  rv = 0;
308  return rv;
309 }
310 
312  .lookup = proc_lookupfd,
313  .permission = proc_fd_permission,
314  .setattr = proc_setattr,
315 };
316 
317 static struct dentry *
318 proc_fdinfo_instantiate(struct inode *dir, struct dentry *dentry,
319  struct task_struct *task, const void *ptr)
320 {
321  struct dentry *error = ERR_PTR(-ENOENT);
322  unsigned fd = (unsigned long)ptr;
323  struct proc_inode *ei;
324  struct inode *inode;
325 
326  inode = proc_pid_make_inode(dir->i_sb, task);
327  if (!inode)
328  goto out;
329 
330  ei = PROC_I(inode);
331  ei->fd = fd;
332 
333  inode->i_mode = S_IFREG | S_IRUSR;
334  inode->i_fop = &proc_fdinfo_file_operations;
335 
336  d_set_d_op(dentry, &tid_fd_dentry_operations);
337  d_add(dentry, inode);
338 
339  /* Close the race of the process dying before we return the dentry */
340  if (tid_fd_revalidate(dentry, 0))
341  error = NULL;
342  out:
343  return error;
344 }
345 
346 static struct dentry *
347 proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags)
348 {
349  return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
350 }
351 
352 static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir)
353 {
354  return proc_readfd_common(filp, dirent, filldir,
355  proc_fdinfo_instantiate);
356 }
357 
359  .lookup = proc_lookupfdinfo,
360  .setattr = proc_setattr,
361 };
362 
364  .read = generic_read_dir,
365  .readdir = proc_readfdinfo,
366  .llseek = default_llseek,
367 };