blob: f39f5b3132527243a5eb08979d7bf5aebaaa9f15 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/readdir.c
3 *
4 * Copyright (C) 1995 Linus Torvalds
5 */
6
7#include <linux/module.h>
8#include <linux/time.h>
9#include <linux/mm.h>
10#include <linux/errno.h>
11#include <linux/stat.h>
12#include <linux/file.h>
13#include <linux/smp_lock.h>
14#include <linux/fs.h>
15#include <linux/dirent.h>
16#include <linux/security.h>
17#include <linux/syscalls.h>
18#include <linux/unistd.h>
19
20#include <asm/uaccess.h>
21
22int vfs_readdir(struct file *file, filldir_t filler, void *buf)
23{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -080024 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 int res = -ENOTDIR;
26 if (!file->f_op || !file->f_op->readdir)
27 goto out;
28
29 res = security_file_permission(file, MAY_READ);
30 if (res)
31 goto out;
32
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080033 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 res = -ENOENT;
35 if (!IS_DEADDIR(inode)) {
36 res = file->f_op->readdir(file, buf, filler);
37 file_accessed(file);
38 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080039 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040out:
41 return res;
42}
43
44EXPORT_SYMBOL(vfs_readdir);
45
46/*
47 * Traditional linux readdir() handling..
48 *
49 * "count=1" is a special case, meaning that the buffer is one
50 * dirent-structure in size and that the code can't handle more
51 * anyway. Thus the special "fillonedir()" function for that
52 * case (the low-level handlers don't need to care about this).
53 */
54#define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
55#define ROUND_UP(x) (((x)+sizeof(long)-1) & ~(sizeof(long)-1))
56
57#ifdef __ARCH_WANT_OLD_READDIR
58
59struct old_linux_dirent {
60 unsigned long d_ino;
61 unsigned long d_offset;
62 unsigned short d_namlen;
63 char d_name[1];
64};
65
66struct readdir_callback {
67 struct old_linux_dirent __user * dirent;
68 int result;
69};
70
71static int fillonedir(void * __buf, const char * name, int namlen, loff_t offset,
David Howellsafefdbb2006-10-03 01:13:46 -070072 u64 ino, unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -070073{
74 struct readdir_callback * buf = (struct readdir_callback *) __buf;
75 struct old_linux_dirent __user * dirent;
David Howellsafefdbb2006-10-03 01:13:46 -070076 unsigned long d_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78 if (buf->result)
79 return -EINVAL;
David Howellsafefdbb2006-10-03 01:13:46 -070080 d_ino = ino;
81 if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
82 return -EOVERFLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 buf->result++;
84 dirent = buf->dirent;
85 if (!access_ok(VERIFY_WRITE, dirent,
86 (unsigned long)(dirent->d_name + namlen + 1) -
87 (unsigned long)dirent))
88 goto efault;
David Howellsafefdbb2006-10-03 01:13:46 -070089 if ( __put_user(d_ino, &dirent->d_ino) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 __put_user(offset, &dirent->d_offset) ||
91 __put_user(namlen, &dirent->d_namlen) ||
92 __copy_to_user(dirent->d_name, name, namlen) ||
93 __put_user(0, dirent->d_name + namlen))
94 goto efault;
95 return 0;
96efault:
97 buf->result = -EFAULT;
98 return -EFAULT;
99}
100
101asmlinkage long old_readdir(unsigned int fd, struct old_linux_dirent __user * dirent, unsigned int count)
102{
103 int error;
104 struct file * file;
105 struct readdir_callback buf;
106
107 error = -EBADF;
108 file = fget(fd);
109 if (!file)
110 goto out;
111
112 buf.result = 0;
113 buf.dirent = dirent;
114
115 error = vfs_readdir(file, fillonedir, &buf);
116 if (error >= 0)
117 error = buf.result;
118
119 fput(file);
120out:
121 return error;
122}
123
124#endif /* __ARCH_WANT_OLD_READDIR */
125
126/*
127 * New, all-improved, singing, dancing, iBCS2-compliant getdents()
128 * interface.
129 */
130struct linux_dirent {
131 unsigned long d_ino;
132 unsigned long d_off;
133 unsigned short d_reclen;
134 char d_name[1];
135};
136
137struct getdents_callback {
138 struct linux_dirent __user * current_dir;
139 struct linux_dirent __user * previous;
140 int count;
141 int error;
142};
143
144static int filldir(void * __buf, const char * name, int namlen, loff_t offset,
David Howellsafefdbb2006-10-03 01:13:46 -0700145 u64 ino, unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
147 struct linux_dirent __user * dirent;
148 struct getdents_callback * buf = (struct getdents_callback *) __buf;
David Howellsafefdbb2006-10-03 01:13:46 -0700149 unsigned long d_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
151
152 buf->error = -EINVAL; /* only used if we fail.. */
153 if (reclen > buf->count)
154 return -EINVAL;
David Howellsafefdbb2006-10-03 01:13:46 -0700155 d_ino = ino;
156 if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
157 return -EOVERFLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 dirent = buf->previous;
159 if (dirent) {
160 if (__put_user(offset, &dirent->d_off))
161 goto efault;
162 }
163 dirent = buf->current_dir;
David Howellsafefdbb2006-10-03 01:13:46 -0700164 if (__put_user(d_ino, &dirent->d_ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 goto efault;
166 if (__put_user(reclen, &dirent->d_reclen))
167 goto efault;
168 if (copy_to_user(dirent->d_name, name, namlen))
169 goto efault;
170 if (__put_user(0, dirent->d_name + namlen))
171 goto efault;
172 if (__put_user(d_type, (char __user *) dirent + reclen - 1))
173 goto efault;
174 buf->previous = dirent;
175 dirent = (void __user *)dirent + reclen;
176 buf->current_dir = dirent;
177 buf->count -= reclen;
178 return 0;
179efault:
180 buf->error = -EFAULT;
181 return -EFAULT;
182}
183
184asmlinkage long sys_getdents(unsigned int fd, struct linux_dirent __user * dirent, unsigned int count)
185{
186 struct file * file;
187 struct linux_dirent __user * lastdirent;
188 struct getdents_callback buf;
189 int error;
190
191 error = -EFAULT;
192 if (!access_ok(VERIFY_WRITE, dirent, count))
193 goto out;
194
195 error = -EBADF;
196 file = fget(fd);
197 if (!file)
198 goto out;
199
200 buf.current_dir = dirent;
201 buf.previous = NULL;
202 buf.count = count;
203 buf.error = 0;
204
205 error = vfs_readdir(file, filldir, &buf);
206 if (error < 0)
207 goto out_putf;
208 error = buf.error;
209 lastdirent = buf.previous;
210 if (lastdirent) {
211 if (put_user(file->f_pos, &lastdirent->d_off))
212 error = -EFAULT;
213 else
214 error = count - buf.count;
215 }
216
217out_putf:
218 fput(file);
219out:
220 return error;
221}
222
223#define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
224
225struct getdents_callback64 {
226 struct linux_dirent64 __user * current_dir;
227 struct linux_dirent64 __user * previous;
228 int count;
229 int error;
230};
231
232static int filldir64(void * __buf, const char * name, int namlen, loff_t offset,
David Howellsafefdbb2006-10-03 01:13:46 -0700233 u64 ino, unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
235 struct linux_dirent64 __user *dirent;
236 struct getdents_callback64 * buf = (struct getdents_callback64 *) __buf;
237 int reclen = ROUND_UP64(NAME_OFFSET(dirent) + namlen + 1);
238
239 buf->error = -EINVAL; /* only used if we fail.. */
240 if (reclen > buf->count)
241 return -EINVAL;
242 dirent = buf->previous;
243 if (dirent) {
244 if (__put_user(offset, &dirent->d_off))
245 goto efault;
246 }
247 dirent = buf->current_dir;
248 if (__put_user(ino, &dirent->d_ino))
249 goto efault;
250 if (__put_user(0, &dirent->d_off))
251 goto efault;
252 if (__put_user(reclen, &dirent->d_reclen))
253 goto efault;
254 if (__put_user(d_type, &dirent->d_type))
255 goto efault;
256 if (copy_to_user(dirent->d_name, name, namlen))
257 goto efault;
258 if (__put_user(0, dirent->d_name + namlen))
259 goto efault;
260 buf->previous = dirent;
261 dirent = (void __user *)dirent + reclen;
262 buf->current_dir = dirent;
263 buf->count -= reclen;
264 return 0;
265efault:
266 buf->error = -EFAULT;
267 return -EFAULT;
268}
269
270asmlinkage long sys_getdents64(unsigned int fd, struct linux_dirent64 __user * dirent, unsigned int count)
271{
272 struct file * file;
273 struct linux_dirent64 __user * lastdirent;
274 struct getdents_callback64 buf;
275 int error;
276
277 error = -EFAULT;
278 if (!access_ok(VERIFY_WRITE, dirent, count))
279 goto out;
280
281 error = -EBADF;
282 file = fget(fd);
283 if (!file)
284 goto out;
285
286 buf.current_dir = dirent;
287 buf.previous = NULL;
288 buf.count = count;
289 buf.error = 0;
290
291 error = vfs_readdir(file, filldir64, &buf);
292 if (error < 0)
293 goto out_putf;
294 error = buf.error;
295 lastdirent = buf.previous;
296 if (lastdirent) {
297 typeof(lastdirent->d_off) d_off = file->f_pos;
298 error = -EFAULT;
299 if (__put_user(d_off, &lastdirent->d_off))
300 goto out_putf;
301 error = count - buf.count;
302 }
303
304out_putf:
305 fput(file);
306out:
307 return error;
308}