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  * Some filesystems were never converted to '->iterate_shared()'
  29  * and their directory iterators want the inode lock held for
  30  * writing. This wrapper allows for converting from the shared
  31  * semantics to the exclusive inode use.
  32  */
  33 int wrap_directory_iterator(struct file *file,
  34                             struct dir_context *ctx,
  35                             int (*iter)(struct file *, struct dir_context *))
  36 {
  37         struct inode *inode = file_inode(file);
  38         int ret;
  39
  40         /*
  41          * We'd love to have an 'inode_upgrade_trylock()' operation,
  42          * see the comment in mmap_upgrade_trylock() in mm/memory.c.
  43          *
  44          * But considering this is for "filesystems that never got
  45          * converted", it really doesn't matter.
  46          *
  47          * Also note that since we have to return with the lock held
  48          * for reading, we can't use the "killable()" locking here,
  49          * since we do need to get the lock even if we're dying.
  50          *
  51          * We could do the write part killably and then get the read
  52          * lock unconditionally if it mattered, but see above on why
  53          * this does the very simplistic conversion.
  54          */
  55         up_read(&inode->i_rwsem);
  56         down_write(&inode->i_rwsem);
  57
  58         /*
  59          * Since we dropped the inode lock, we should do the
  60          * DEADDIR test again. See 'iterate_dir()' below.
  61          *
  62          * Note that we don't need to re-do the f_pos games,
  63          * since the file must be locked wrt f_pos anyway.
  64          */
  65         ret = -ENOENT;
  66         if (!IS_DEADDIR(inode))
  67                 ret = iter(file, ctx);
  68
  69         downgrade_write(&inode->i_rwsem);
  70         return ret;
  71 }
  72 EXPORT_SYMBOL(wrap_directory_iterator);
  73
  74 /*
  75  * Note the "unsafe_put_user() semantics: we goto a
  76  * label for errors.
  77  */
  78 #define unsafe_copy_dirent_name(_dst, _src, _len, label) do {   \
  79         char __user *dst = (_dst);                              \
  80         const char *src = (_src);                               \
  81         size_t len = (_len);                                    \
  82         unsafe_put_user(0, dst+len, label);                     \
  83         unsafe_copy_to_user(dst, src, len, label);              \
  84 } while (0)
  85
  86
  87 int iterate_dir(struct file *file, struct dir_context *ctx)
  88 {
  89         struct inode *inode = file_inode(file);
  90         int res = -ENOTDIR;
  91
  92         if (!file->f_op->iterate_shared)
  93                 goto out;
  94
  95         res = security_file_permission(file, MAY_READ);
  96         if (res)
  97                 goto out;
  98
  99         res = down_read_killable(&inode->i_rwsem);
 100         if (res)
 101                 goto out;
 102
 103         res = -ENOENT;
 104         if (!IS_DEADDIR(inode)) {
 105                 ctx->pos = file->f_pos;
 106                 res = file->f_op->iterate_shared(file, ctx);
 107                 file->f_pos = ctx->pos;
 108                 fsnotify_access(file);
 109                 file_accessed(file);
 110         }
 111         inode_unlock_shared(inode);
 112 out:
 113         return res;
 114 }
 115 EXPORT_SYMBOL(iterate_dir);
 116
 117 /*
 118  * POSIX says that a dirent name cannot contain NULL or a '/'.
 119  *
 120  * It's not 100% clear what we should really do in this case.
 121  * The filesystem is clearly corrupted, but returning a hard
 122  * error means that you now don't see any of the other names
 123  * either, so that isn't a perfect alternative.
 124  *
 125  * And if you return an error, what error do you use? Several
 126  * filesystems seem to have decided on EUCLEAN being the error
 127  * code for EFSCORRUPTED, and that may be the error to use. Or
 128  * just EIO, which is perhaps more obvious to users.
 129  *
 130  * In order to see the other file names in the directory, the
 131  * caller might want to make this a "soft" error: skip the
 132  * entry, and return the error at the end instead.
 133  *
 134  * Note that this should likely do a "memchr(name, 0, len)"
 135  * check too, since that would be filesystem corruption as
 136  * well. However, that case can't actually confuse user space,
 137  * which has to do a strlen() on the name anyway to find the
 138  * filename length, and the above "soft error" worry means
 139  * that it's probably better left alone until we have that
 140  * issue clarified.
 141  *
 142  * Note the PATH_MAX check - it's arbitrary but the real
 143  * kernel limit on a possible path component, not NAME_MAX,
 144  * which is the technical standard limit.
 145  */
 146 static int verify_dirent_name(const char *name, int len)
 147 {
 148         if (len <= 0 || len >= PATH_MAX)
 149                 return -EIO;
 150         if (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[];
 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 bool 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 false;
 189         buf->result = verify_dirent_name(name, namlen);
 190         if (buf->result)
 191                 return false;
 192         d_ino = ino;
 193         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
 194                 buf->result = -EOVERFLOW;
 195                 return false;
 196         }
 197         buf->result++;
 198         dirent = buf->dirent;
 199         if (!user_write_access_begin(dirent,
 200                         (unsigned long)(dirent->d_name + namlen + 1) -
 201                                 (unsigned long)dirent))
 202                 goto efault;
 203         unsafe_put_user(d_ino, &dirent->d_ino, efault_end);
 204         unsafe_put_user(offset, &dirent->d_offset, efault_end);
 205         unsafe_put_user(namlen, &dirent->d_namlen, efault_end);
 206         unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
 207         user_write_access_end();
 208         return true;
 209 efault_end:
 210         user_write_access_end();
 211 efault:
 212         buf->result = -EFAULT;
 213         return false;
 214 }
 215
 216 SYSCALL_DEFINE3(old_readdir, unsigned int, fd,
 217                 struct old_linux_dirent __user *, dirent, unsigned int, count)
 218 {
 219         int error;
 220         struct fd f = fdget_pos(fd);
 221         struct readdir_callback buf = {
 222                 .ctx.actor = fillonedir,
 223                 .dirent = dirent
 224         };
 225
 226         if (!f.file)
 227                 return -EBADF;
 228
 229         error = iterate_dir(f.file, &buf.ctx);
 230         if (buf.result)
 231                 error = buf.result;
 232
 233         fdput_pos(f);
 234         return error;
 235 }
 236
 237 #endif /* __ARCH_WANT_OLD_READDIR */
 238
 239 /*
 240  * New, all-improved, singing, dancing, iBCS2-compliant getdents()
 241  * interface.
 242  */
 243 struct linux_dirent {
 244         unsigned long   d_ino;
 245         unsigned long   d_off;
 246         unsigned short  d_reclen;
 247         char            d_name[];
 248 };
 249
 250 struct getdents_callback {
 251         struct dir_context ctx;
 252         struct linux_dirent __user * current_dir;
 253         int prev_reclen;
 254         int count;
 255         int error;
 256 };
 257
 258 static bool filldir(struct dir_context *ctx, const char *name, int namlen,
 259                    loff_t offset, u64 ino, unsigned int d_type)
 260 {
 261         struct linux_dirent __user *dirent, *prev;
 262         struct getdents_callback *buf =
 263                 container_of(ctx, struct getdents_callback, ctx);
 264         unsigned long d_ino;
 265         int reclen = ALIGN(offsetof(struct linux_dirent, d_name) + namlen + 2,
 266                 sizeof(long));
 267         int prev_reclen;
 268
 269         buf->error = verify_dirent_name(name, namlen);
 270         if (unlikely(buf->error))
 271                 return false;
 272         buf->error = -EINVAL;   /* only used if we fail.. */
 273         if (reclen > buf->count)
 274                 return false;
 275         d_ino = ino;
 276         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
 277                 buf->error = -EOVERFLOW;
 278                 return false;
 279         }
 280         prev_reclen = buf->prev_reclen;
 281         if (prev_reclen && signal_pending(current))
 282                 return false;
 283         dirent = buf->current_dir;
 284         prev = (void __user *) dirent - prev_reclen;
 285         if (!user_write_access_begin(prev, reclen + prev_reclen))
 286                 goto efault;
 287
 288         /* This might be 'dirent->d_off', but if so it will get overwritten */
 289         unsafe_put_user(offset, &prev->d_off, efault_end);
 290         unsafe_put_user(d_ino, &dirent->d_ino, efault_end);
 291         unsafe_put_user(reclen, &dirent->d_reclen, efault_end);
 292         unsafe_put_user(d_type, (char __user *) dirent + reclen - 1, efault_end);
 293         unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
 294         user_write_access_end();
 295
 296         buf->current_dir = (void __user *)dirent + reclen;
 297         buf->prev_reclen = reclen;
 298         buf->count -= reclen;
 299         return true;
 300 efault_end:
 301         user_write_access_end();
 302 efault:
 303         buf->error = -EFAULT;
 304         return false;
 305 }
 306
 307 SYSCALL_DEFINE3(getdents, unsigned int, fd,
 308                 struct linux_dirent __user *, dirent, unsigned int, count)
 309 {
 310         struct fd f;
 311         struct getdents_callback buf = {
 312                 .ctx.actor = filldir,
 313                 .count = count,
 314                 .current_dir = dirent
 315         };
 316         int error;
 317
 318         f = fdget_pos(fd);
 319         if (!f.file)
 320                 return -EBADF;
 321
 322         error = iterate_dir(f.file, &buf.ctx);
 323         if (error >= 0)
 324                 error = buf.error;
 325         if (buf.prev_reclen) {
 326                 struct linux_dirent __user * lastdirent;
 327                 lastdirent = (void __user *)buf.current_dir - buf.prev_reclen;
 328
 329                 if (put_user(buf.ctx.pos, &lastdirent->d_off))
 330                         error = -EFAULT;
 331                 else
 332                         error = count - buf.count;
 333         }
 334         fdput_pos(f);
 335         return error;
 336 }
 337
 338 struct getdents_callback64 {
 339         struct dir_context ctx;
 340         struct linux_dirent64 __user * current_dir;
 341         int prev_reclen;
 342         int count;
 343         int error;
 344 };
 345
 346 static bool filldir64(struct dir_context *ctx, const char *name, int namlen,
 347                      loff_t offset, u64 ino, unsigned int d_type)
 348 {
 349         struct linux_dirent64 __user *dirent, *prev;
 350         struct getdents_callback64 *buf =
 351                 container_of(ctx, struct getdents_callback64, ctx);
 352         int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
 353                 sizeof(u64));
 354         int prev_reclen;
 355
 356         buf->error = verify_dirent_name(name, namlen);
 357         if (unlikely(buf->error))
 358                 return false;
 359         buf->error = -EINVAL;   /* only used if we fail.. */
 360         if (reclen > buf->count)
 361                 return false;
 362         prev_reclen = buf->prev_reclen;
 363         if (prev_reclen && signal_pending(current))
 364                 return false;
 365         dirent = buf->current_dir;
 366         prev = (void __user *)dirent - prev_reclen;
 367         if (!user_write_access_begin(prev, reclen + prev_reclen))
 368                 goto efault;
 369
 370         /* This might be 'dirent->d_off', but if so it will get overwritten */
 371         unsafe_put_user(offset, &prev->d_off, efault_end);
 372         unsafe_put_user(ino, &dirent->d_ino, efault_end);
 373         unsafe_put_user(reclen, &dirent->d_reclen, efault_end);
 374         unsafe_put_user(d_type, &dirent->d_type, efault_end);
 375         unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
 376         user_write_access_end();
 377
 378         buf->prev_reclen = reclen;
 379         buf->current_dir = (void __user *)dirent + reclen;
 380         buf->count -= reclen;
 381         return true;
 382
 383 efault_end:
 384         user_write_access_end();
 385 efault:
 386         buf->error = -EFAULT;
 387         return false;
 388 }
 389
 390 SYSCALL_DEFINE3(getdents64, unsigned int, fd,
 391                 struct linux_dirent64 __user *, dirent, unsigned int, count)
 392 {
 393         struct fd f;
 394         struct getdents_callback64 buf = {
 395                 .ctx.actor = filldir64,
 396                 .count = count,
 397                 .current_dir = dirent
 398         };
 399         int error;
 400
 401         f = fdget_pos(fd);
 402         if (!f.file)
 403                 return -EBADF;
 404
 405         error = iterate_dir(f.file, &buf.ctx);
 406         if (error >= 0)
 407                 error = buf.error;
 408         if (buf.prev_reclen) {
 409                 struct linux_dirent64 __user * lastdirent;
 410                 typeof(lastdirent->d_off) d_off = buf.ctx.pos;
 411
 412                 lastdirent = (void __user *) buf.current_dir - buf.prev_reclen;
 413                 if (put_user(d_off, &lastdirent->d_off))
 414                         error = -EFAULT;
 415                 else
 416                         error = count - buf.count;
 417         }
 418         fdput_pos(f);
 419         return error;
 420 }
 421
 422 #ifdef CONFIG_COMPAT
 423 struct compat_old_linux_dirent {
 424         compat_ulong_t  d_ino;
 425         compat_ulong_t  d_offset;
 426         unsigned short  d_namlen;
 427         char            d_name[];
 428 };
 429
 430 struct compat_readdir_callback {
 431         struct dir_context ctx;
 432         struct compat_old_linux_dirent __user *dirent;
 433         int result;
 434 };
 435
 436 static bool compat_fillonedir(struct dir_context *ctx, const char *name,
 437                              int namlen, loff_t offset, u64 ino,
 438                              unsigned int d_type)
 439 {
 440         struct compat_readdir_callback *buf =
 441                 container_of(ctx, struct compat_readdir_callback, ctx);
 442         struct compat_old_linux_dirent __user *dirent;
 443         compat_ulong_t d_ino;
 444
 445         if (buf->result)
 446                 return false;
 447         buf->result = verify_dirent_name(name, namlen);
 448         if (buf->result)
 449                 return false;
 450         d_ino = ino;
 451         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
 452                 buf->result = -EOVERFLOW;
 453                 return false;
 454         }
 455         buf->result++;
 456         dirent = buf->dirent;
 457         if (!user_write_access_begin(dirent,
 458                         (unsigned long)(dirent->d_name + namlen + 1) -
 459                                 (unsigned long)dirent))
 460                 goto efault;
 461         unsafe_put_user(d_ino, &dirent->d_ino, efault_end);
 462         unsafe_put_user(offset, &dirent->d_offset, efault_end);
 463         unsafe_put_user(namlen, &dirent->d_namlen, efault_end);
 464         unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
 465         user_write_access_end();
 466         return true;
 467 efault_end:
 468         user_write_access_end();
 469 efault:
 470         buf->result = -EFAULT;
 471         return false;
 472 }
 473
 474 COMPAT_SYSCALL_DEFINE3(old_readdir, unsigned int, fd,
 475                 struct compat_old_linux_dirent __user *, dirent, unsigned int, count)
 476 {
 477         int error;
 478         struct fd f = fdget_pos(fd);
 479         struct compat_readdir_callback buf = {
 480                 .ctx.actor = compat_fillonedir,
 481                 .dirent = dirent
 482         };
 483
 484         if (!f.file)
 485                 return -EBADF;
 486
 487         error = iterate_dir(f.file, &buf.ctx);
 488         if (buf.result)
 489                 error = buf.result;
 490
 491         fdput_pos(f);
 492         return error;
 493 }
 494
 495 struct compat_linux_dirent {
 496         compat_ulong_t  d_ino;
 497         compat_ulong_t  d_off;
 498         unsigned short  d_reclen;
 499         char            d_name[];
 500 };
 501
 502 struct compat_getdents_callback {
 503         struct dir_context ctx;
 504         struct compat_linux_dirent __user *current_dir;
 505         int prev_reclen;
 506         int count;
 507         int error;
 508 };
 509
 510 static bool compat_filldir(struct dir_context *ctx, const char *name, int namlen,
 511                 loff_t offset, u64 ino, unsigned int d_type)
 512 {
 513         struct compat_linux_dirent __user *dirent, *prev;
 514         struct compat_getdents_callback *buf =
 515                 container_of(ctx, struct compat_getdents_callback, ctx);
 516         compat_ulong_t d_ino;
 517         int reclen = ALIGN(offsetof(struct compat_linux_dirent, d_name) +
 518                 namlen + 2, sizeof(compat_long_t));
 519         int prev_reclen;
 520
 521         buf->error = verify_dirent_name(name, namlen);
 522         if (unlikely(buf->error))
 523                 return false;
 524         buf->error = -EINVAL;   /* only used if we fail.. */
 525         if (reclen > buf->count)
 526                 return false;
 527         d_ino = ino;
 528         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
 529                 buf->error = -EOVERFLOW;
 530                 return false;
 531         }
 532         prev_reclen = buf->prev_reclen;
 533         if (prev_reclen && signal_pending(current))
 534                 return false;
 535         dirent = buf->current_dir;
 536         prev = (void __user *) dirent - prev_reclen;
 537         if (!user_write_access_begin(prev, reclen + prev_reclen))
 538                 goto efault;
 539
 540         unsafe_put_user(offset, &prev->d_off, efault_end);
 541         unsafe_put_user(d_ino, &dirent->d_ino, efault_end);
 542         unsafe_put_user(reclen, &dirent->d_reclen, efault_end);
 543         unsafe_put_user(d_type, (char __user *) dirent + reclen - 1, efault_end);
 544         unsafe_copy_dirent_name(dirent->d_name, name, namlen, efault_end);
 545         user_write_access_end();
 546
 547         buf->prev_reclen = reclen;
 548         buf->current_dir = (void __user *)dirent + reclen;
 549         buf->count -= reclen;
 550         return true;
 551 efault_end:
 552         user_write_access_end();
 553 efault:
 554         buf->error = -EFAULT;
 555         return false;
 556 }
 557
 558 COMPAT_SYSCALL_DEFINE3(getdents, unsigned int, fd,
 559                 struct compat_linux_dirent __user *, dirent, unsigned int, count)
 560 {
 561         struct fd f;
 562         struct compat_getdents_callback buf = {
 563                 .ctx.actor = compat_filldir,
 564                 .current_dir = dirent,
 565                 .count = count
 566         };
 567         int error;
 568
 569         f = fdget_pos(fd);
 570         if (!f.file)
 571                 return -EBADF;
 572
 573         error = iterate_dir(f.file, &buf.ctx);
 574         if (error >= 0)
 575                 error = buf.error;
 576         if (buf.prev_reclen) {
 577                 struct compat_linux_dirent __user * lastdirent;
 578                 lastdirent = (void __user *)buf.current_dir - buf.prev_reclen;
 579
 580                 if (put_user(buf.ctx.pos, &lastdirent->d_off))
 581                         error = -EFAULT;
 582                 else
 583                         error = count - buf.count;
 584         }
 585         fdput_pos(f);
 586         return error;
 587 }
 588 #endif