fs: change return values from -EACCES to -EPERM
[linux-3.10.git] / fs / proc / fd.c
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 struct dentry *
171 proc_fd_instantiate(struct inode *dir, struct dentry *dentry,
172                     struct task_struct *task, const void *ptr)
173 {
174         struct dentry *error = ERR_PTR(-ENOENT);
175         unsigned fd = (unsigned long)ptr;
176         struct proc_inode *ei;
177         struct inode *inode;
178
179         inode = proc_pid_make_inode(dir->i_sb, task);
180         if (!inode)
181                 goto out;
182
183         ei = PROC_I(inode);
184         ei->fd = fd;
185
186         inode->i_mode = S_IFLNK;
187         inode->i_op = &proc_pid_link_inode_operations;
188         inode->i_size = 64;
189
190         ei->op.proc_get_link = proc_fd_link;
191
192         d_set_d_op(dentry, &tid_fd_dentry_operations);
193         d_add(dentry, inode);
194
195         /* Close the race of the process dying before we return the dentry */
196         if (tid_fd_revalidate(dentry, 0))
197                 error = NULL;
198  out:
199         return error;
200 }
201
202 static struct dentry *proc_lookupfd_common(struct inode *dir,
203                                            struct dentry *dentry,
204                                            instantiate_t instantiate)
205 {
206         struct task_struct *task = get_proc_task(dir);
207         struct dentry *result = ERR_PTR(-ENOENT);
208         unsigned fd = name_to_int(dentry);
209
210         if (!task)
211                 goto out_no_task;
212         if (fd == ~0U)
213                 goto out;
214
215         result = instantiate(dir, dentry, task, (void *)(unsigned long)fd);
216 out:
217         put_task_struct(task);
218 out_no_task:
219         return result;
220 }
221
222 static int proc_readfd_common(struct file * filp, void * dirent,
223                               filldir_t filldir, instantiate_t instantiate)
224 {
225         struct dentry *dentry = filp->f_path.dentry;
226         struct inode *inode = dentry->d_inode;
227         struct task_struct *p = get_proc_task(inode);
228         struct files_struct *files;
229         unsigned int fd, ino;
230         int retval;
231
232         retval = -ENOENT;
233         if (!p)
234                 goto out_no_task;
235         retval = 0;
236
237         fd = filp->f_pos;
238         switch (fd) {
239                 case 0:
240                         if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
241                                 goto out;
242                         filp->f_pos++;
243                 case 1:
244                         ino = parent_ino(dentry);
245                         if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
246                                 goto out;
247                         filp->f_pos++;
248                 default:
249                         files = get_files_struct(p);
250                         if (!files)
251                                 goto out;
252                         rcu_read_lock();
253                         for (fd = filp->f_pos - 2;
254                              fd < files_fdtable(files)->max_fds;
255                              fd++, filp->f_pos++) {
256                                 char name[PROC_NUMBUF];
257                                 int len;
258                                 int rv;
259
260                                 if (!fcheck_files(files, fd))
261                                         continue;
262                                 rcu_read_unlock();
263
264                                 len = snprintf(name, sizeof(name), "%d", fd);
265                                 rv = proc_fill_cache(filp, dirent, filldir,
266                                                      name, len, instantiate, p,
267                                                      (void *)(unsigned long)fd);
268                                 if (rv < 0)
269                                         goto out_fd_loop;
270                                 rcu_read_lock();
271                         }
272                         rcu_read_unlock();
273 out_fd_loop:
274                         put_files_struct(files);
275         }
276 out:
277         put_task_struct(p);
278 out_no_task:
279         return retval;
280 }
281
282 static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir)
283 {
284         return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate);
285 }
286
287 const struct file_operations proc_fd_operations = {
288         .read           = generic_read_dir,
289         .readdir        = proc_readfd,
290         .llseek         = default_llseek,
291 };
292
293 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
294                                     unsigned int flags)
295 {
296         return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
297 }
298
299 /*
300  * /proc/pid/fd needs a special permission handler so that a process can still
301  * access /proc/self/fd after it has executed a setuid().
302  */
303 int proc_fd_permission(struct inode *inode, int mask)
304 {
305         int rv = generic_permission(inode, mask);
306         if (rv == 0)
307                 return 0;
308         if (task_pid(current) == proc_pid(inode))
309                 rv = 0;
310         return rv;
311 }
312
313 const struct inode_operations proc_fd_inode_operations = {
314         .lookup         = proc_lookupfd,
315         .permission     = proc_fd_permission,
316         .setattr        = proc_setattr,
317 };
318
319 static struct dentry *
320 proc_fdinfo_instantiate(struct inode *dir, struct dentry *dentry,
321                         struct task_struct *task, const void *ptr)
322 {
323         struct dentry *error = ERR_PTR(-ENOENT);
324         unsigned fd = (unsigned long)ptr;
325         struct proc_inode *ei;
326         struct inode *inode;
327
328         inode = proc_pid_make_inode(dir->i_sb, task);
329         if (!inode)
330                 goto out;
331
332         ei = PROC_I(inode);
333         ei->fd = fd;
334
335         inode->i_mode = S_IFREG | S_IRUSR;
336         inode->i_fop = &proc_fdinfo_file_operations;
337
338         d_set_d_op(dentry, &tid_fd_dentry_operations);
339         d_add(dentry, inode);
340
341         /* Close the race of the process dying before we return the dentry */
342         if (tid_fd_revalidate(dentry, 0))
343                 error = NULL;
344  out:
345         return error;
346 }
347
348 static struct dentry *
349 proc_lookupfdinfo(struct inode *dir, struct dentry *dentry, unsigned int flags)
350 {
351         return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
352 }
353
354 static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir)
355 {
356         return proc_readfd_common(filp, dirent, filldir,
357                                   proc_fdinfo_instantiate);
358 }
359
360 const struct inode_operations proc_fdinfo_inode_operations = {
361         .lookup         = proc_lookupfdinfo,
362         .setattr        = proc_setattr,
363 };
364
365 const struct file_operations proc_fdinfo_operations = {
366         .read           = generic_read_dir,
367         .readdir        = proc_readfdinfo,
368         .llseek         = default_llseek,
369 };