4 * Copyright (C) 1995 Linus Torvalds
7 #include <linux/stddef.h>
8 #include <linux/kernel.h>
9 #include <linux/export.h>
10 #include <linux/time.h>
12 #include <linux/errno.h>
13 #include <linux/stat.h>
14 #include <linux/file.h>
16 #include <linux/fsnotify.h>
17 #include <linux/dirent.h>
18 #include <linux/security.h>
19 #include <linux/syscalls.h>
20 #include <linux/unistd.h>
22 #include <asm/uaccess.h>
24 int iterate_dir(struct file *file, struct dir_context *ctx)
26 struct inode *inode = file_inode(file);
29 if (file->f_op->iterate_shared)
31 else if (!file->f_op->iterate)
34 res = security_file_permission(file, MAY_READ);
39 inode_lock_shared(inode);
42 // res = mutex_lock_killable(&inode->i_mutex);
47 if (!IS_DEADDIR(inode)) {
48 ctx->pos = file->f_pos;
50 res = file->f_op->iterate_shared(file, ctx);
52 res = file->f_op->iterate(file, ctx);
53 file->f_pos = ctx->pos;
54 fsnotify_access(file);
58 inode_unlock_shared(inode);
64 EXPORT_SYMBOL(iterate_dir);
67 * Traditional linux readdir() handling..
69 * "count=1" is a special case, meaning that the buffer is one
70 * dirent-structure in size and that the code can't handle more
71 * anyway. Thus the special "fillonedir()" function for that
72 * case (the low-level handlers don't need to care about this).
75 #ifdef __ARCH_WANT_OLD_READDIR
77 struct old_linux_dirent {
79 unsigned long d_offset;
80 unsigned short d_namlen;
84 struct readdir_callback {
85 struct dir_context ctx;
86 struct old_linux_dirent __user * dirent;
90 static int fillonedir(struct dir_context *ctx, const char *name, int namlen,
91 loff_t offset, u64 ino, unsigned int d_type)
93 struct readdir_callback *buf =
94 container_of(ctx, struct readdir_callback, ctx);
95 struct old_linux_dirent __user * dirent;
101 if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
102 buf->result = -EOVERFLOW;
106 dirent = buf->dirent;
107 if (!access_ok(VERIFY_WRITE, dirent,
108 (unsigned long)(dirent->d_name + namlen + 1) -
109 (unsigned long)dirent))
111 if ( __put_user(d_ino, &dirent->d_ino) ||
112 __put_user(offset, &dirent->d_offset) ||
113 __put_user(namlen, &dirent->d_namlen) ||
114 __copy_to_user(dirent->d_name, name, namlen) ||
115 __put_user(0, dirent->d_name + namlen))
119 buf->result = -EFAULT;
123 SYSCALL_DEFINE3(old_readdir, unsigned int, fd,
124 struct old_linux_dirent __user *, dirent, unsigned int, count)
127 struct fd f = fdget_pos(fd);
128 struct readdir_callback buf = {
129 .ctx.actor = fillonedir,
136 error = iterate_dir(f.file, &buf.ctx);
144 #endif /* __ARCH_WANT_OLD_READDIR */
147 * New, all-improved, singing, dancing, iBCS2-compliant getdents()
150 struct linux_dirent {
153 unsigned short d_reclen;
157 struct getdents_callback {
158 struct dir_context ctx;
159 struct linux_dirent __user * current_dir;
160 struct linux_dirent __user * previous;
165 static int filldir(struct dir_context *ctx, const char *name, int namlen,
166 loff_t offset, u64 ino, unsigned int d_type)
168 struct linux_dirent __user * dirent;
169 struct getdents_callback *buf =
170 container_of(ctx, struct getdents_callback, ctx);
172 int reclen = ALIGN(offsetof(struct linux_dirent, d_name) + namlen + 2,
175 buf->error = -EINVAL; /* only used if we fail.. */
176 if (reclen > buf->count)
179 if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
180 buf->error = -EOVERFLOW;
183 dirent = buf->previous;
185 if (__put_user(offset, &dirent->d_off))
188 dirent = buf->current_dir;
189 if (__put_user(d_ino, &dirent->d_ino))
191 if (__put_user(reclen, &dirent->d_reclen))
193 if (copy_to_user(dirent->d_name, name, namlen))
195 if (__put_user(0, dirent->d_name + namlen))
197 if (__put_user(d_type, (char __user *) dirent + reclen - 1))
199 buf->previous = dirent;
200 dirent = (void __user *)dirent + reclen;
201 buf->current_dir = dirent;
202 buf->count -= reclen;
205 buf->error = -EFAULT;
209 SYSCALL_DEFINE3(getdents, unsigned int, fd,
210 struct linux_dirent __user *, dirent, unsigned int, count)
213 struct linux_dirent __user * lastdirent;
214 struct getdents_callback buf = {
215 .ctx.actor = filldir,
217 .current_dir = dirent
221 if (!access_ok(VERIFY_WRITE, dirent, count))
228 error = iterate_dir(f.file, &buf.ctx);
231 lastdirent = buf.previous;
233 if (put_user(buf.ctx.pos, &lastdirent->d_off))
236 error = count - buf.count;
242 struct getdents_callback64 {
243 struct dir_context ctx;
244 struct linux_dirent64 __user * current_dir;
245 struct linux_dirent64 __user * previous;
250 static int filldir64(struct dir_context *ctx, const char *name, int namlen,
251 loff_t offset, u64 ino, unsigned int d_type)
253 struct linux_dirent64 __user *dirent;
254 struct getdents_callback64 *buf =
255 container_of(ctx, struct getdents_callback64, ctx);
256 int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
259 buf->error = -EINVAL; /* only used if we fail.. */
260 if (reclen > buf->count)
262 dirent = buf->previous;
264 if (__put_user(offset, &dirent->d_off))
267 dirent = buf->current_dir;
268 if (__put_user(ino, &dirent->d_ino))
270 if (__put_user(0, &dirent->d_off))
272 if (__put_user(reclen, &dirent->d_reclen))
274 if (__put_user(d_type, &dirent->d_type))
276 if (copy_to_user(dirent->d_name, name, namlen))
278 if (__put_user(0, dirent->d_name + namlen))
280 buf->previous = dirent;
281 dirent = (void __user *)dirent + reclen;
282 buf->current_dir = dirent;
283 buf->count -= reclen;
286 buf->error = -EFAULT;
290 SYSCALL_DEFINE3(getdents64, unsigned int, fd,
291 struct linux_dirent64 __user *, dirent, unsigned int, count)
294 struct linux_dirent64 __user * lastdirent;
295 struct getdents_callback64 buf = {
296 .ctx.actor = filldir64,
298 .current_dir = dirent
302 if (!access_ok(VERIFY_WRITE, dirent, count))
309 error = iterate_dir(f.file, &buf.ctx);
312 lastdirent = buf.previous;
314 typeof(lastdirent->d_off) d_off = buf.ctx.pos;
315 if (__put_user(d_off, &lastdirent->d_off))
318 error = count - buf.count;