| 1 | |
| 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 |
|
| 22 | int vfs_readdir(struct file *file, filldir_t filler, void *buf)
|
| 23 | {
|
| 24 | struct inode *inode = file->f_path.dentry->d_inode;
|
| 25 | 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 |
|
| 33 | mutex_lock(&inode->i_mutex);
|
| 34 | res = -ENOENT;
|
| 35 | if (!IS_DEADDIR(inode)) {
|
| 36 | res = file->f_op->readdir(file, buf, filler);
|
| 37 | file_accessed(file);
|
| 38 | }
|
| 39 | mutex_unlock(&inode->i_mutex);
|
| 40 | out:
|
| 41 | return res;
|
| 42 | }
|
| 43 |
|
| 44 | EXPORT_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 |
|
| 59 | struct 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 |
|
| 66 | struct readdir_callback {
|
| 67 | struct old_linux_dirent __user * dirent;
|
| 68 | int result;
|
| 69 | };
|
| 70 |
|
| 71 | static int fillonedir(void * __buf, const char * name, int namlen, loff_t offset,
|
| 72 | u64 ino, unsigned int d_type)
|
| 73 | {
|
| 74 | struct readdir_callback * buf = (struct readdir_callback *) __buf;
|
| 75 | struct old_linux_dirent __user * dirent;
|
| 76 | unsigned long d_ino;
|
| 77 |
|
| 78 | if (buf->result)
|
| 79 | return -EINVAL;
|
| 80 | d_ino = ino;
|
| 81 | if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
|
| 82 | return -EOVERFLOW;
|
| 83 | 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;
|
| 89 | if ( __put_user(d_ino, &dirent->d_ino) ||
|
| 90 | __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;
|
| 96 | efault:
|
| 97 | buf->result = -EFAULT;
|
| 98 | return -EFAULT;
|
| 99 | }
|
| 100 |
|
| 101 | asmlinkage 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);
|
| 120 | out:
|
| 121 | return error;
|
| 122 | }
|
| 123 |
|
| 124 | #endif
|
| 125 |
|
| 126 | |
| 127 | * New, all-improved, singing, dancing, iBCS2-compliant getdents()
|
| 128 | * interface.
|
| 129 |
|
| 130 | struct linux_dirent {
|
| 131 | unsigned long d_ino;
|
| 132 | unsigned long d_off;
|
| 133 | unsigned short d_reclen;
|
| 134 | char d_name[1];
|
| 135 | };
|
| 136 |
|
| 137 | struct getdents_callback {
|
| 138 | struct linux_dirent __user * current_dir;
|
| 139 | struct linux_dirent __user * previous;
|
| 140 | int count;
|
| 141 | int error;
|
| 142 | };
|
| 143 |
|
| 144 | static int filldir(void * __buf, const char * name, int namlen, loff_t offset,
|
| 145 | u64 ino, unsigned int d_type)
|
| 146 | {
|
| 147 | struct linux_dirent __user * dirent;
|
| 148 | struct getdents_callback * buf = (struct getdents_callback *) __buf;
|
| 149 | unsigned long d_ino;
|
| 150 | int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
|
| 151 |
|
| 152 | buf->error = -EINVAL;
|
| 153 | if (reclen > buf->count)
|
| 154 | return -EINVAL;
|
| 155 | d_ino = ino;
|
| 156 | if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
|
| 157 | return -EOVERFLOW;
|
| 158 | dirent = buf->previous;
|
| 159 | if (dirent) {
|
| 160 | if (__put_user(offset, &dirent->d_off))
|
| 161 | goto efault;
|
| 162 | }
|
| 163 | dirent = buf->current_dir;
|
| 164 | if (__put_user(d_ino, &dirent->d_ino))
|
| 165 | 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;
|
| 179 | efault:
|
| 180 | buf->error = -EFAULT;
|
| 181 | return -EFAULT;
|
| 182 | }
|
| 183 |
|
| 184 | asmlinkage 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 |
|
| 217 | out_putf:
|
| 218 | fput(file);
|
| 219 | out:
|
| 220 | return error;
|
| 221 | }
|
| 222 |
|
| 223 | #define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
|
| 224 |
|
| 225 | struct getdents_callback64 {
|
| 226 | struct linux_dirent64 __user * current_dir;
|
| 227 | struct linux_dirent64 __user * previous;
|
| 228 | int count;
|
| 229 | int error;
|
| 230 | };
|
| 231 |
|
| 232 | static int filldir64(void * __buf, const char * name, int namlen, loff_t offset,
|
| 233 | u64 ino, unsigned int d_type)
|
| 234 | {
|
| 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;
|
| 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;
|
| 265 | efault:
|
| 266 | buf->error = -EFAULT;
|
| 267 | return -EFAULT;
|
| 268 | }
|
| 269 |
|
| 270 | asmlinkage 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 |
|
| 304 | out_putf:
|
| 305 | fput(file);
|
| 306 | out:
|
| 307 | return error;
|
| 308 | }
|