fs/readdir.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/readdir.c
   4  *
   5  *  Copyright (C) 1995  Linus Torvalds
   6  */
   7
   8 #include <linux/stddef.h>
   9 #include <linux/kernel.h>
  10 #include <linux/export.h>
  11 #include <linux/time.h>
  12 #include <linux/mm.h>
  13 #include <linux/errno.h>
  14 #include <linux/stat.h>
  15 #include <linux/file.h>
  16 #include <linux/fs.h>
  17 #include <linux/fsnotify.h>
  18 #include <linux/dirent.h>
  19 #include <linux/security.h>
  20 #include <linux/syscalls.h>
  21 #include <linux/unistd.h>
  22 #include <linux/compat.h>
  23 #include <linux/uaccess.h>
  24
  25 #include <asm/unaligned.h>
  26
  27 /*
  28  * Note the "unsafe_put_user() semantics: we goto a
  29  * label for errors.
  30  *
  31  * Also note how we use a "while()" loop here, even though
  32  * only the biggest size needs to loop. The compiler (well,
  33  * at least gcc) is smart enough to turn the smaller sizes
  34  * into just if-statements, and this way we don't need to
  35  * care whether 'u64' or 'u32' is the biggest size.
  36  */
  37 #define unsafe_copy_loop(dst, src, len, type, label)            \
  38         while (len >= sizeof(type)) {                           \
  39                 unsafe_put_user(get_unaligned((type *)src),     \
  40                         (type __user *)dst, label);             \
  41                 dst += sizeof(type);                            \
  42                 src += sizeof(type);                            \
  43                 len -= sizeof(type);                            \
  44         }
  45
  46 /*
  47  * We avoid doing 64-bit copies on 32-bit architectures. They
  48  * might be better, but the component names are mostly small,
  49  * and the 64-bit cases can end up being much more complex and
  50  * put much more register pressure on the code, so it's likely
  51  * not worth the pain of unaligned accesses etc.
  52  *
  53  * So limit the copies to "unsigned long" size. I did verify
  54  * that at least the x86-32 case is ok without this limiting,
  55  * but I worry about random other legacy 32-bit cases that
  56  * might not do as well.
  57  */
  58 #define unsafe_copy_type(dst, src, len, type, label) do {       \
  59         if (sizeof(type) <= sizeof(unsigned long))              \
  60                 unsafe_copy_loop(dst, src, len, type, label);   \
  61 } while (0)
  62
  63 /*
  64  * Copy the dirent name to user space, and NUL-terminate
  65  * it. This should not be a function call, since we're doing
  66  * the copy inside a "user_access_begin/end()" section.
  67  */
  68 #define unsafe_copy_dirent_name(_dst, _src, _len, label) do {   \
  69         char __user *dst = (_dst);                              \
  70         const char *src = (_src);                               \
  71         size_t len = (_len);                                    \
  72         unsafe_copy_type(dst, src, len, u64, label);            \
  73         unsafe_copy_type(dst, src, len, u32, label);            \
  74         unsafe_copy_type(dst, src, len, u16, label);            \
  75         unsafe_copy_type(dst, src, len, u8,  label);            \
  76         unsafe_put_user(0, dst, label);                         \
  77 } while (0)
  78
  79
  80 int iterate_dir(struct file *file, struct dir_context *ctx)
  81 {
  82         struct inode *inode = file_inode(file);
  83         bool shared = false;
  84         int res = -ENOTDIR;
  85         if (file->f_op->iterate_shared)
  86                 shared = true;
  87         else if (!file->f_op->iterate)
  88                 goto out;
  89
  90         res = security_file_permission(file, MAY_READ);
  91         if (res)
  92                 goto out;
  93
  94         if (shared)
  95                 res = down_read_killable(&inode->i_rwsem);
  96         else
  97                 res = down_write_killable(&inode->i_rwsem);
  98         if (res)
  99                 goto out;
 100
 101         res = -ENOENT;
 102         if (!IS_DEADDIR(inode)) {
 103                 ctx->pos = file->f_pos;
 104                 if (shared)
 105                         res = file->f_op->iterate_shared(file, ctx);
 106                 else
 107                         res = file->f_op->iterate(file, ctx);
 108                 file->f_pos = ctx->pos;
 109                 fsnotify_access(file);
 110                 file_accessed(file);
 111         }
 112         if (shared)
 113                 inode_unlock_shared(inode);
 114         else
 115                 inode_unlock(inode);
 116 out:
 117         return res;
 118 }
 119 EXPORT_SYMBOL(iterate_dir);
 120
 121 /*
 122  * POSIX says that a dirent name cannot contain NULL or a '/'.
 123  *
 124  * It's not 100% clear what we should really do in this case.
 125  * The filesystem is clearly corrupted, but returning a hard
 126  * error means that you now don't see any of the other names
 127  * either, so that isn't a perfect alternative.
 128  *
 129  * And if you return an error, what error do you use? Several
 130  * filesystems seem to have decided on EUCLEAN being the error
 131  * code for EFSCORRUPTED, and that may be the error to use. Or
 132  * just EIO, which is perhaps more obvious to users.
 133  *
 134  * In order to see the other file names in the directory, the
 135  * caller might want to make this a "soft" error: skip the
 136  * entry, and return the error at the end instead.
 137  *
 138  * Note that this should likely do a "memchr(name, 0, len)"
 139  * check too, since that would be filesystem corruption as
 140  * well. However, that case can't actually confuse user space,
 141  * which has to do a strlen() on the name anyway to find the
 142  * filename length, and the above "soft error" worry means
 143  * that it's probably better left alone until we have that
 144  * issue clarified.
 145  */
 146 static int verify_dirent_name(const char *name, int len)
 147 {
 148         if (WARN_ON_ONCE(!len))
 149                 return -EIO;
 150         if (WARN_ON_ONCE(memchr(name, '/', len)))
 151                 return -EIO;
 152         return 0;
 153 }
 154
 155 /*
 156  * Traditional linux readdir() handling..
 157  *
 158  * "count=1" is a special case, meaning that the buffer is one
 159  * dirent-structure in size and that the code can't handle more
 160  * anyway. Thus the special "fillonedir()" function for that
 161  * case (the low-level handlers don't need to care about this).
 162  */
 163
 164 #ifdef __ARCH_WANT_OLD_READDIR
 165
 166 struct old_linux_dirent {
 167         unsigned long   d_ino;
 168         unsigned long   d_offset;
 169         unsigned short  d_namlen;
 170         char            d_name[1];
 171 };
 172
 173 struct readdir_callback {
 174         struct dir_context ctx;
 175         struct old_linux_dirent __user * dirent;
 176         int result;
 177 };
 178
 179 static int fillonedir(struct dir_context *ctx, const char *name, int namlen,
 180                       loff_t offset, u64 ino, unsigned int d_type)
 181 {
 182         struct readdir_callback *buf =
 183                 container_of(ctx, struct readdir_callback, ctx);
 184         struct old_linux_dirent __user * dirent;
 185         unsigned long d_ino;
 186
 187         if (buf->result)
 188                 return -EINVAL;
 189         d_ino = ino;
 190         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
 191                 buf->result = -EOVERFLOW;
 192                 return -EOVERFLOW;
 193         }
 194         buf->result++;
 195         dirent = buf->dirent;
 196         if (!access_ok(dirent,
 197                         (unsigned long)(dirent->d_name + namlen + 1) -
 198                                 (unsigned long)dirent))
 199                 goto efault;
 200         if (    __put_user(d_ino, &dirent->d_ino) ||
 201                 __put_user(offset, &dirent->d_offset) ||
 202                 __put_user(namlen, &dirent->d_namlen) ||
 203                 __copy_to_user(dirent->d_name, name, namlen) ||
 204                 __put_user(0, dirent->d_name + namlen))
 205                 goto efault;
 206         return 0;
 207 efault:
 208         buf->result = -EFAULT;
 209         return -EFAULT;
 210 }
 211
 212 SYSCALL_DEFINE3(old_readdir, unsigned int, fd,
 213                 struct old_linux_dirent __user *, dirent, unsigned int, count)
 214 {
 215         int error;
 216         struct fd f = fdget_pos(fd);
 217         struct readdir_callback buf = {
 218                 .ctx.actor = fillonedir,
 219                 .dirent = dirent
 220         };
 221
 222         if (!f.file)
 223                 return -EBADF;
 224
 225         error = iterate_dir(f.file, &buf.ctx);
 226         if (buf.result)
 227                 error = buf.result;
 228
 229         fdput_pos(f);
 230         return error;
 231 }
 232
 233 #endif /* __ARCH_WANT_OLD_READDIR */
 234
 235 /*
 236  * New, all-improved, singing, dancing, iBCS2-compliant getdents()
 237  * interface.
 238  */
 239 struct linux_dirent {
 240         unsigned long   d_ino;
 241         unsigned long   d_off;
 242         unsigned short  d_reclen;
 243         char            d_name[1];
 244 };
 245
 246 struct getdents_callback {
 247         struct dir_context ctx;
 248         struct linux_dirent __user * current_dir;
 249         struct linux_dirent __user * previous;
 250         int count;
 251         int error;
 252 };
 253
 254 static int filldir(struct dir_context *ctx, const char *name, int namlen,
 255                    loff_t offset, u64 ino, unsigned int d_type)
 256 {
 257         struct linux_dirent __user * dirent;
 258         struct getdents_callback *buf =
 259                 container_of(ctx, struct getdents_callback, ctx);
 260         unsigned long d_ino;
 261         int reclen = ALIGN(offsetof(struct linux_dirent, d_name) + namlen + 2,
 262                 sizeof(long));
 263
 264         buf->error = verify_dirent_name(name, namlen);
 265         if (unlikely(buf->error))
 266                 return buf->error;
 267         buf->error = -EINVAL;   /* only used if we fail.. */
 268         if (reclen > buf->count)
 269                 return -EINVAL;
 270         d_ino = ino;
 271         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
 272                 buf->error = -EOVERFLOW;
 273                 return -EOVERFLOW;
 274         }
 275         dirent = buf->previous;
 276         if (dirent && signal_pending(current))
 277                 return -EINTR;
 278
 279         /*
 280          * Note! This range-checks 'previous' (which may be NULL).
 281          * The real range was checked in getdents
 282          */
 283         if (!user_access_begin(dirent, sizeof(*dirent)))
 284                 goto efault;
 285         if (dirent)
 286                 unsafe_put_user(offset, &dirent->d_off, efault_end);
 287         dirent = buf->current_dir;
 288         unsafe_put_user(d_ino, &dirent->d_ino, efault_end);
 289         unsafe_put_user(reclen, &dirent->d_reclen, efault_end);
 290         unsafe_put_user(d_type, (char __user *) dirent + reclen - 1, efault_end);
 291         unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
 292         user_access_end();
 293
 294         buf->previous = dirent;
 295         dirent = (void __user *)dirent + reclen;
 296         buf->current_dir = dirent;
 297         buf->count -= reclen;
 298         return 0;
 299 efault_end:
 300         user_access_end();
 301 efault:
 302         buf->error = -EFAULT;
 303         return -EFAULT;
 304 }
 305
 306 SYSCALL_DEFINE3(getdents, unsigned int, fd,
 307                 struct linux_dirent __user *, dirent, unsigned int, count)
 308 {
 309         struct fd f;
 310         struct linux_dirent __user * lastdirent;
 311         struct getdents_callback buf = {
 312                 .ctx.actor = filldir,
 313                 .count = count,
 314                 .current_dir = dirent
 315         };
 316         int error;
 317
 318         if (!access_ok(dirent, count))
 319                 return -EFAULT;
 320
 321         f = fdget_pos(fd);
 322         if (!f.file)
 323                 return -EBADF;
 324
 325         error = iterate_dir(f.file, &buf.ctx);
 326         if (error >= 0)
 327                 error = buf.error;
 328         lastdirent = buf.previous;
 329         if (lastdirent) {
 330                 if (put_user(buf.ctx.pos, &lastdirent->d_off))
 331                         error = -EFAULT;
 332                 else
 333                         error = count - buf.count;
 334         }
 335         fdput_pos(f);
 336         return error;
 337 }
 338
 339 struct getdents_callback64 {
 340         struct dir_context ctx;
 341         struct linux_dirent64 __user * current_dir;
 342         struct linux_dirent64 __user * previous;
 343         int count;
 344         int error;
 345 };
 346
 347 static int filldir64(struct dir_context *ctx, const char *name, int namlen,
 348                      loff_t offset, u64 ino, unsigned int d_type)
 349 {
 350         struct linux_dirent64 __user *dirent;
 351         struct getdents_callback64 *buf =
 352                 container_of(ctx, struct getdents_callback64, ctx);
 353         int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
 354                 sizeof(u64));
 355
 356         buf->error = verify_dirent_name(name, namlen);
 357         if (unlikely(buf->error))
 358                 return buf->error;
 359         buf->error = -EINVAL;   /* only used if we fail.. */
 360         if (reclen > buf->count)
 361                 return -EINVAL;
 362         dirent = buf->previous;
 363         if (dirent && signal_pending(current))
 364                 return -EINTR;
 365
 366         /*
 367          * Note! This range-checks 'previous' (which may be NULL).
 368          * The real range was checked in getdents
 369          */
 370         if (!user_access_begin(dirent, sizeof(*dirent)))
 371                 goto efault;
 372         if (dirent)
 373                 unsafe_put_user(offset, &dirent->d_off, efault_end);
 374         dirent = buf->current_dir;
 375         unsafe_put_user(ino, &dirent->d_ino, efault_end);
 376         unsafe_put_user(reclen, &dirent->d_reclen, efault_end);
 377         unsafe_put_user(d_type, &dirent->d_type, efault_end);
 378         unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
 379         user_access_end();
 380
 381         buf->previous = dirent;
 382         dirent = (void __user *)dirent + reclen;
 383         buf->current_dir = dirent;
 384         buf->count -= reclen;
 385         return 0;
 386 efault_end:
 387         user_access_end();
 388 efault:
 389         buf->error = -EFAULT;
 390         return -EFAULT;
 391 }
 392
 393 int ksys_getdents64(unsigned int fd, struct linux_dirent64 __user *dirent,
 394                     unsigned int count)
 395 {
 396         struct fd f;
 397         struct linux_dirent64 __user * lastdirent;
 398         struct getdents_callback64 buf = {
 399                 .ctx.actor = filldir64,
 400                 .count = count,
 401                 .current_dir = dirent
 402         };
 403         int error;
 404
 405         if (!access_ok(dirent, count))
 406                 return -EFAULT;
 407
 408         f = fdget_pos(fd);
 409         if (!f.file)
 410                 return -EBADF;
 411
 412         error = iterate_dir(f.file, &buf.ctx);
 413         if (error >= 0)
 414                 error = buf.error;
 415         lastdirent = buf.previous;
 416         if (lastdirent) {
 417                 typeof(lastdirent->d_off) d_off = buf.ctx.pos;
 418                 if (__put_user(d_off, &lastdirent->d_off))
 419                         error = -EFAULT;
 420                 else
 421                         error = count - buf.count;
 422         }
 423         fdput_pos(f);
 424         return error;
 425 }
 426
 427
 428 SYSCALL_DEFINE3(getdents64, unsigned int, fd,
 429                 struct linux_dirent64 __user *, dirent, unsigned int, count)
 430 {
 431         return ksys_getdents64(fd, dirent, count);
 432 }
 433
 434 #ifdef CONFIG_COMPAT
 435 struct compat_old_linux_dirent {
 436         compat_ulong_t  d_ino;
 437         compat_ulong_t  d_offset;
 438         unsigned short  d_namlen;
 439         char            d_name[1];
 440 };
 441
 442 struct compat_readdir_callback {
 443         struct dir_context ctx;
 444         struct compat_old_linux_dirent __user *dirent;
 445         int result;
 446 };
 447
 448 static int compat_fillonedir(struct dir_context *ctx, const char *name,
 449                              int namlen, loff_t offset, u64 ino,
 450                              unsigned int d_type)
 451 {
 452         struct compat_readdir_callback *buf =
 453                 container_of(ctx, struct compat_readdir_callback, ctx);
 454         struct compat_old_linux_dirent __user *dirent;
 455         compat_ulong_t d_ino;
 456
 457         if (buf->result)
 458                 return -EINVAL;
 459         d_ino = ino;
 460         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
 461                 buf->result = -EOVERFLOW;
 462                 return -EOVERFLOW;
 463         }
 464         buf->result++;
 465         dirent = buf->dirent;
 466         if (!access_ok(dirent,
 467                         (unsigned long)(dirent->d_name + namlen + 1) -
 468                                 (unsigned long)dirent))
 469                 goto efault;
 470         if (    __put_user(d_ino, &dirent->d_ino) ||
 471                 __put_user(offset, &dirent->d_offset) ||
 472                 __put_user(namlen, &dirent->d_namlen) ||
 473                 __copy_to_user(dirent->d_name, name, namlen) ||
 474                 __put_user(0, dirent->d_name + namlen))
 475                 goto efault;
 476         return 0;
 477 efault:
 478         buf->result = -EFAULT;
 479         return -EFAULT;
 480 }
 481
 482 COMPAT_SYSCALL_DEFINE3(old_readdir, unsigned int, fd,
 483                 struct compat_old_linux_dirent __user *, dirent, unsigned int, count)
 484 {
 485         int error;
 486         struct fd f = fdget_pos(fd);
 487         struct compat_readdir_callback buf = {
 488                 .ctx.actor = compat_fillonedir,
 489                 .dirent = dirent
 490         };
 491
 492         if (!f.file)
 493                 return -EBADF;
 494
 495         error = iterate_dir(f.file, &buf.ctx);
 496         if (buf.result)
 497                 error = buf.result;
 498
 499         fdput_pos(f);
 500         return error;
 501 }
 502
 503 struct compat_linux_dirent {
 504         compat_ulong_t  d_ino;
 505         compat_ulong_t  d_off;
 506         unsigned short  d_reclen;
 507         char            d_name[1];
 508 };
 509
 510 struct compat_getdents_callback {
 511         struct dir_context ctx;
 512         struct compat_linux_dirent __user *current_dir;
 513         struct compat_linux_dirent __user *previous;
 514         int count;
 515         int error;
 516 };
 517
 518 static int compat_filldir(struct dir_context *ctx, const char *name, int namlen,
 519                 loff_t offset, u64 ino, unsigned int d_type)
 520 {
 521         struct compat_linux_dirent __user * dirent;
 522         struct compat_getdents_callback *buf =
 523                 container_of(ctx, struct compat_getdents_callback, ctx);
 524         compat_ulong_t d_ino;
 525         int reclen = ALIGN(offsetof(struct compat_linux_dirent, d_name) +
 526                 namlen + 2, sizeof(compat_long_t));
 527
 528         buf->error = -EINVAL;   /* only used if we fail.. */
 529         if (reclen > buf->count)
 530                 return -EINVAL;
 531         d_ino = ino;
 532         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
 533                 buf->error = -EOVERFLOW;
 534                 return -EOVERFLOW;
 535         }
 536         dirent = buf->previous;
 537         if (dirent) {
 538                 if (signal_pending(current))
 539                         return -EINTR;
 540                 if (__put_user(offset, &dirent->d_off))
 541                         goto efault;
 542         }
 543         dirent = buf->current_dir;
 544         if (__put_user(d_ino, &dirent->d_ino))
 545                 goto efault;
 546         if (__put_user(reclen, &dirent->d_reclen))
 547                 goto efault;
 548         if (copy_to_user(dirent->d_name, name, namlen))
 549                 goto efault;
 550         if (__put_user(0, dirent->d_name + namlen))
 551                 goto efault;
 552         if (__put_user(d_type, (char  __user *) dirent + reclen - 1))
 553                 goto efault;
 554         buf->previous = dirent;
 555         dirent = (void __user *)dirent + reclen;
 556         buf->current_dir = dirent;
 557         buf->count -= reclen;
 558         return 0;
 559 efault:
 560         buf->error = -EFAULT;
 561         return -EFAULT;
 562 }
 563
 564 COMPAT_SYSCALL_DEFINE3(getdents, unsigned int, fd,
 565                 struct compat_linux_dirent __user *, dirent, unsigned int, count)
 566 {
 567         struct fd f;
 568         struct compat_linux_dirent __user * lastdirent;
 569         struct compat_getdents_callback buf = {
 570                 .ctx.actor = compat_filldir,
 571                 .current_dir = dirent,
 572                 .count = count
 573         };
 574         int error;
 575
 576         if (!access_ok(dirent, count))
 577                 return -EFAULT;
 578
 579         f = fdget_pos(fd);
 580         if (!f.file)
 581                 return -EBADF;
 582
 583         error = iterate_dir(f.file, &buf.ctx);
 584         if (error >= 0)
 585                 error = buf.error;
 586         lastdirent = buf.previous;
 587         if (lastdirent) {
 588                 if (put_user(buf.ctx.pos, &lastdirent->d_off))
 589                         error = -EFAULT;
 590                 else
 591                         error = count - buf.count;
 592         }
 593         fdput_pos(f);
 594         return error;
 595 }
 596 #endif