fs/stat.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/stat.c
   4  *
   5  *  Copyright (C) 1991, 1992  Linus Torvalds
   6  */
   7
   8 #include <linux/export.h>
   9 #include <linux/mm.h>
  10 #include <linux/errno.h>
  11 #include <linux/file.h>
  12 #include <linux/highuid.h>
  13 #include <linux/fs.h>
  14 #include <linux/namei.h>
  15 #include <linux/security.h>
  16 #include <linux/cred.h>
  17 #include <linux/syscalls.h>
  18 #include <linux/pagemap.h>
  19 #include <linux/compat.h>
  20
  21 #include <linux/uaccess.h>
  22 #include <asm/unistd.h>
  23
  24 #include "internal.h"
  25 #include "mount.h"
  26
  27 /**
  28  * generic_fillattr - Fill in the basic attributes from the inode struct
  29  * @inode: Inode to use as the source
  30  * @stat: Where to fill in the attributes
  31  *
  32  * Fill in the basic attributes in the kstat structure from data that's to be
  33  * found on the VFS inode structure.  This is the default if no getattr inode
  34  * operation is supplied.
  35  */
  36 void generic_fillattr(struct inode *inode, struct kstat *stat)
  37 {
  38         stat->dev = inode->i_sb->s_dev;
  39         stat->ino = inode->i_ino;
  40         stat->mode = inode->i_mode;
  41         stat->nlink = inode->i_nlink;
  42         stat->uid = inode->i_uid;
  43         stat->gid = inode->i_gid;
  44         stat->rdev = inode->i_rdev;
  45         stat->size = i_size_read(inode);
  46         stat->atime = inode->i_atime;
  47         stat->mtime = inode->i_mtime;
  48         stat->ctime = inode->i_ctime;
  49         stat->blksize = i_blocksize(inode);
  50         stat->blocks = inode->i_blocks;
  51 }
  52 EXPORT_SYMBOL(generic_fillattr);
  53
  54 /**
  55  * vfs_getattr_nosec - getattr without security checks
  56  * @path: file to get attributes from
  57  * @stat: structure to return attributes in
  58  * @request_mask: STATX_xxx flags indicating what the caller wants
  59  * @query_flags: Query mode (AT_STATX_SYNC_TYPE)
  60  *
  61  * Get attributes without calling security_inode_getattr.
  62  *
  63  * Currently the only caller other than vfs_getattr is internal to the
  64  * filehandle lookup code, which uses only the inode number and returns no
  65  * attributes to any user.  Any other code probably wants vfs_getattr.
  66  */
  67 int vfs_getattr_nosec(const struct path *path, struct kstat *stat,
  68                       u32 request_mask, unsigned int query_flags)
  69 {
  70         struct inode *inode = d_backing_inode(path->dentry);
  71
  72         memset(stat, 0, sizeof(*stat));
  73         stat->result_mask |= STATX_BASIC_STATS;
  74         query_flags &= AT_STATX_SYNC_TYPE;
  75
  76         /* allow the fs to override these if it really wants to */
  77         /* SB_NOATIME means filesystem supplies dummy atime value */
  78         if (inode->i_sb->s_flags & SB_NOATIME)
  79                 stat->result_mask &= ~STATX_ATIME;
  80         if (IS_AUTOMOUNT(inode))
  81                 stat->attributes |= STATX_ATTR_AUTOMOUNT;
  82
  83         if (IS_DAX(inode))
  84                 stat->attributes |= STATX_ATTR_DAX;
  85
  86         if (inode->i_op->getattr)
  87                 return inode->i_op->getattr(path, stat, request_mask,
  88                                             query_flags);
  89
  90         generic_fillattr(inode, stat);
  91         return 0;
  92 }
  93 EXPORT_SYMBOL(vfs_getattr_nosec);
  94
  95 /*
  96  * vfs_getattr - Get the enhanced basic attributes of a file
  97  * @path: The file of interest
  98  * @stat: Where to return the statistics
  99  * @request_mask: STATX_xxx flags indicating what the caller wants
 100  * @query_flags: Query mode (AT_STATX_SYNC_TYPE)
 101  *
 102  * Ask the filesystem for a file's attributes.  The caller must indicate in
 103  * request_mask and query_flags to indicate what they want.
 104  *
 105  * If the file is remote, the filesystem can be forced to update the attributes
 106  * from the backing store by passing AT_STATX_FORCE_SYNC in query_flags or can
 107  * suppress the update by passing AT_STATX_DONT_SYNC.
 108  *
 109  * Bits must have been set in request_mask to indicate which attributes the
 110  * caller wants retrieving.  Any such attribute not requested may be returned
 111  * anyway, but the value may be approximate, and, if remote, may not have been
 112  * synchronised with the server.
 113  *
 114  * 0 will be returned on success, and a -ve error code if unsuccessful.
 115  */
 116 int vfs_getattr(const struct path *path, struct kstat *stat,
 117                 u32 request_mask, unsigned int query_flags)
 118 {
 119         int retval;
 120
 121         retval = security_inode_getattr(path);
 122         if (retval)
 123                 return retval;
 124         return vfs_getattr_nosec(path, stat, request_mask, query_flags);
 125 }
 126 EXPORT_SYMBOL(vfs_getattr);
 127
 128 /**
 129  * vfs_fstat - Get the basic attributes by file descriptor
 130  * @fd: The file descriptor referring to the file of interest
 131  * @stat: The result structure to fill in.
 132  *
 133  * This function is a wrapper around vfs_getattr().  The main difference is
 134  * that it uses a file descriptor to determine the file location.
 135  *
 136  * 0 will be returned on success, and a -ve error code if unsuccessful.
 137  */
 138 int vfs_fstat(int fd, struct kstat *stat)
 139 {
 140         struct fd f;
 141         int error;
 142
 143         f = fdget_raw(fd);
 144         if (!f.file)
 145                 return -EBADF;
 146         error = vfs_getattr(&f.file->f_path, stat, STATX_BASIC_STATS, 0);
 147         fdput(f);
 148         return error;
 149 }
 150
 151 /**
 152  * vfs_statx - Get basic and extra attributes by filename
 153  * @dfd: A file descriptor representing the base dir for a relative filename
 154  * @filename: The name of the file of interest
 155  * @flags: Flags to control the query
 156  * @stat: The result structure to fill in.
 157  * @request_mask: STATX_xxx flags indicating what the caller wants
 158  *
 159  * This function is a wrapper around vfs_getattr().  The main difference is
 160  * that it uses a filename and base directory to determine the file location.
 161  * Additionally, the use of AT_SYMLINK_NOFOLLOW in flags will prevent a symlink
 162  * at the given name from being referenced.
 163  *
 164  * 0 will be returned on success, and a -ve error code if unsuccessful.
 165  */
 166 static int vfs_statx(int dfd, const char __user *filename, int flags,
 167               struct kstat *stat, u32 request_mask)
 168 {
 169         struct path path;
 170         unsigned lookup_flags = 0;
 171         int error;
 172
 173         if (flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT | AT_EMPTY_PATH |
 174                       AT_STATX_SYNC_TYPE))
 175                 return -EINVAL;
 176
 177         if (!(flags & AT_SYMLINK_NOFOLLOW))
 178                 lookup_flags |= LOOKUP_FOLLOW;
 179         if (!(flags & AT_NO_AUTOMOUNT))
 180                 lookup_flags |= LOOKUP_AUTOMOUNT;
 181         if (flags & AT_EMPTY_PATH)
 182                 lookup_flags |= LOOKUP_EMPTY;
 183
 184 retry:
 185         error = user_path_at(dfd, filename, lookup_flags, &path);
 186         if (error)
 187                 goto out;
 188
 189         error = vfs_getattr(&path, stat, request_mask, flags);
 190         stat->mnt_id = real_mount(path.mnt)->mnt_id;
 191         stat->result_mask |= STATX_MNT_ID;
 192         if (path.mnt->mnt_root == path.dentry)
 193                 stat->attributes |= STATX_ATTR_MOUNT_ROOT;
 194         stat->attributes_mask |= STATX_ATTR_MOUNT_ROOT;
 195         path_put(&path);
 196         if (retry_estale(error, lookup_flags)) {
 197                 lookup_flags |= LOOKUP_REVAL;
 198                 goto retry;
 199         }
 200 out:
 201         return error;
 202 }
 203
 204 int vfs_fstatat(int dfd, const char __user *filename,
 205                               struct kstat *stat, int flags)
 206 {
 207         return vfs_statx(dfd, filename, flags | AT_NO_AUTOMOUNT,
 208                          stat, STATX_BASIC_STATS);
 209 }
 210
 211 #ifdef __ARCH_WANT_OLD_STAT
 212
 213 /*
 214  * For backward compatibility?  Maybe this should be moved
 215  * into arch/i386 instead?
 216  */
 217 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
 218 {
 219         static int warncount = 5;
 220         struct __old_kernel_stat tmp;
 221
 222         if (warncount > 0) {
 223                 warncount--;
 224                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
 225                         current->comm);
 226         } else if (warncount < 0) {
 227                 /* it's laughable, but... */
 228                 warncount = 0;
 229         }
 230
 231         memset(&tmp, 0, sizeof(struct __old_kernel_stat));
 232         tmp.st_dev = old_encode_dev(stat->dev);
 233         tmp.st_ino = stat->ino;
 234         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 235                 return -EOVERFLOW;
 236         tmp.st_mode = stat->mode;
 237         tmp.st_nlink = stat->nlink;
 238         if (tmp.st_nlink != stat->nlink)
 239                 return -EOVERFLOW;
 240         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
 241         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
 242         tmp.st_rdev = old_encode_dev(stat->rdev);
 243 #if BITS_PER_LONG == 32
 244         if (stat->size > MAX_NON_LFS)
 245                 return -EOVERFLOW;
 246 #endif
 247         tmp.st_size = stat->size;
 248         tmp.st_atime = stat->atime.tv_sec;
 249         tmp.st_mtime = stat->mtime.tv_sec;
 250         tmp.st_ctime = stat->ctime.tv_sec;
 251         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 252 }
 253
 254 SYSCALL_DEFINE2(stat, const char __user *, filename,
 255                 struct __old_kernel_stat __user *, statbuf)
 256 {
 257         struct kstat stat;
 258         int error;
 259
 260         error = vfs_stat(filename, &stat);
 261         if (error)
 262                 return error;
 263
 264         return cp_old_stat(&stat, statbuf);
 265 }
 266
 267 SYSCALL_DEFINE2(lstat, const char __user *, filename,
 268                 struct __old_kernel_stat __user *, statbuf)
 269 {
 270         struct kstat stat;
 271         int error;
 272
 273         error = vfs_lstat(filename, &stat);
 274         if (error)
 275                 return error;
 276
 277         return cp_old_stat(&stat, statbuf);
 278 }
 279
 280 SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
 281 {
 282         struct kstat stat;
 283         int error = vfs_fstat(fd, &stat);
 284
 285         if (!error)
 286                 error = cp_old_stat(&stat, statbuf);
 287
 288         return error;
 289 }
 290
 291 #endif /* __ARCH_WANT_OLD_STAT */
 292
 293 #ifdef __ARCH_WANT_NEW_STAT
 294
 295 #if BITS_PER_LONG == 32
 296 #  define choose_32_64(a,b) a
 297 #else
 298 #  define choose_32_64(a,b) b
 299 #endif
 300
 301 #define valid_dev(x)  choose_32_64(old_valid_dev(x),true)
 302 #define encode_dev(x) choose_32_64(old_encode_dev,new_encode_dev)(x)
 303
 304 #ifndef INIT_STRUCT_STAT_PADDING
 305 #  define INIT_STRUCT_STAT_PADDING(st) memset(&st, 0, sizeof(st))
 306 #endif
 307
 308 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
 309 {
 310         struct stat tmp;
 311
 312         if (!valid_dev(stat->dev) || !valid_dev(stat->rdev))
 313                 return -EOVERFLOW;
 314 #if BITS_PER_LONG == 32
 315         if (stat->size > MAX_NON_LFS)
 316                 return -EOVERFLOW;
 317 #endif
 318
 319         INIT_STRUCT_STAT_PADDING(tmp);
 320         tmp.st_dev = encode_dev(stat->dev);
 321         tmp.st_ino = stat->ino;
 322         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 323                 return -EOVERFLOW;
 324         tmp.st_mode = stat->mode;
 325         tmp.st_nlink = stat->nlink;
 326         if (tmp.st_nlink != stat->nlink)
 327                 return -EOVERFLOW;
 328         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
 329         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
 330         tmp.st_rdev = encode_dev(stat->rdev);
 331         tmp.st_size = stat->size;
 332         tmp.st_atime = stat->atime.tv_sec;
 333         tmp.st_mtime = stat->mtime.tv_sec;
 334         tmp.st_ctime = stat->ctime.tv_sec;
 335 #ifdef STAT_HAVE_NSEC
 336         tmp.st_atime_nsec = stat->atime.tv_nsec;
 337         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 338         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 339 #endif
 340         tmp.st_blocks = stat->blocks;
 341         tmp.st_blksize = stat->blksize;
 342         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 343 }
 344
 345 SYSCALL_DEFINE2(newstat, const char __user *, filename,
 346                 struct stat __user *, statbuf)
 347 {
 348         struct kstat stat;
 349         int error = vfs_stat(filename, &stat);
 350
 351         if (error)
 352                 return error;
 353         return cp_new_stat(&stat, statbuf);
 354 }
 355
 356 SYSCALL_DEFINE2(newlstat, const char __user *, filename,
 357                 struct stat __user *, statbuf)
 358 {
 359         struct kstat stat;
 360         int error;
 361
 362         error = vfs_lstat(filename, &stat);
 363         if (error)
 364                 return error;
 365
 366         return cp_new_stat(&stat, statbuf);
 367 }
 368
 369 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
 370 SYSCALL_DEFINE4(newfstatat, int, dfd, const char __user *, filename,
 371                 struct stat __user *, statbuf, int, flag)
 372 {
 373         struct kstat stat;
 374         int error;
 375
 376         error = vfs_fstatat(dfd, filename, &stat, flag);
 377         if (error)
 378                 return error;
 379         return cp_new_stat(&stat, statbuf);
 380 }
 381 #endif
 382
 383 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
 384 {
 385         struct kstat stat;
 386         int error = vfs_fstat(fd, &stat);
 387
 388         if (!error)
 389                 error = cp_new_stat(&stat, statbuf);
 390
 391         return error;
 392 }
 393 #endif
 394
 395 static int do_readlinkat(int dfd, const char __user *pathname,
 396                          char __user *buf, int bufsiz)
 397 {
 398         struct path path;
 399         int error;
 400         int empty = 0;
 401         unsigned int lookup_flags = LOOKUP_EMPTY;
 402
 403         if (bufsiz <= 0)
 404                 return -EINVAL;
 405
 406 retry:
 407         error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty);
 408         if (!error) {
 409                 struct inode *inode = d_backing_inode(path.dentry);
 410
 411                 error = empty ? -ENOENT : -EINVAL;
 412                 /*
 413                  * AFS mountpoints allow readlink(2) but are not symlinks
 414                  */
 415                 if (d_is_symlink(path.dentry) || inode->i_op->readlink) {
 416                         error = security_inode_readlink(path.dentry);
 417                         if (!error) {
 418                                 touch_atime(&path);
 419                                 error = vfs_readlink(path.dentry, buf, bufsiz);
 420                         }
 421                 }
 422                 path_put(&path);
 423                 if (retry_estale(error, lookup_flags)) {
 424                         lookup_flags |= LOOKUP_REVAL;
 425                         goto retry;
 426                 }
 427         }
 428         return error;
 429 }
 430
 431 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
 432                 char __user *, buf, int, bufsiz)
 433 {
 434         return do_readlinkat(dfd, pathname, buf, bufsiz);
 435 }
 436
 437 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
 438                 int, bufsiz)
 439 {
 440         return do_readlinkat(AT_FDCWD, path, buf, bufsiz);
 441 }
 442
 443
 444 /* ---------- LFS-64 ----------- */
 445 #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64)
 446
 447 #ifndef INIT_STRUCT_STAT64_PADDING
 448 #  define INIT_STRUCT_STAT64_PADDING(st) memset(&st, 0, sizeof(st))
 449 #endif
 450
 451 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
 452 {
 453         struct stat64 tmp;
 454
 455         INIT_STRUCT_STAT64_PADDING(tmp);
 456 #ifdef CONFIG_MIPS
 457         /* mips has weird padding, so we don't get 64 bits there */
 458         tmp.st_dev = new_encode_dev(stat->dev);
 459         tmp.st_rdev = new_encode_dev(stat->rdev);
 460 #else
 461         tmp.st_dev = huge_encode_dev(stat->dev);
 462         tmp.st_rdev = huge_encode_dev(stat->rdev);
 463 #endif
 464         tmp.st_ino = stat->ino;
 465         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 466                 return -EOVERFLOW;
 467 #ifdef STAT64_HAS_BROKEN_ST_INO
 468         tmp.__st_ino = stat->ino;
 469 #endif
 470         tmp.st_mode = stat->mode;
 471         tmp.st_nlink = stat->nlink;
 472         tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
 473         tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
 474         tmp.st_atime = stat->atime.tv_sec;
 475         tmp.st_atime_nsec = stat->atime.tv_nsec;
 476         tmp.st_mtime = stat->mtime.tv_sec;
 477         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 478         tmp.st_ctime = stat->ctime.tv_sec;
 479         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 480         tmp.st_size = stat->size;
 481         tmp.st_blocks = stat->blocks;
 482         tmp.st_blksize = stat->blksize;
 483         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 484 }
 485
 486 SYSCALL_DEFINE2(stat64, const char __user *, filename,
 487                 struct stat64 __user *, statbuf)
 488 {
 489         struct kstat stat;
 490         int error = vfs_stat(filename, &stat);
 491
 492         if (!error)
 493                 error = cp_new_stat64(&stat, statbuf);
 494
 495         return error;
 496 }
 497
 498 SYSCALL_DEFINE2(lstat64, const char __user *, filename,
 499                 struct stat64 __user *, statbuf)
 500 {
 501         struct kstat stat;
 502         int error = vfs_lstat(filename, &stat);
 503
 504         if (!error)
 505                 error = cp_new_stat64(&stat, statbuf);
 506
 507         return error;
 508 }
 509
 510 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
 511 {
 512         struct kstat stat;
 513         int error = vfs_fstat(fd, &stat);
 514
 515         if (!error)
 516                 error = cp_new_stat64(&stat, statbuf);
 517
 518         return error;
 519 }
 520
 521 SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
 522                 struct stat64 __user *, statbuf, int, flag)
 523 {
 524         struct kstat stat;
 525         int error;
 526
 527         error = vfs_fstatat(dfd, filename, &stat, flag);
 528         if (error)
 529                 return error;
 530         return cp_new_stat64(&stat, statbuf);
 531 }
 532 #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */
 533
 534 static noinline_for_stack int
 535 cp_statx(const struct kstat *stat, struct statx __user *buffer)
 536 {
 537         struct statx tmp;
 538
 539         memset(&tmp, 0, sizeof(tmp));
 540
 541         tmp.stx_mask = stat->result_mask;
 542         tmp.stx_blksize = stat->blksize;
 543         tmp.stx_attributes = stat->attributes;
 544         tmp.stx_nlink = stat->nlink;
 545         tmp.stx_uid = from_kuid_munged(current_user_ns(), stat->uid);
 546         tmp.stx_gid = from_kgid_munged(current_user_ns(), stat->gid);
 547         tmp.stx_mode = stat->mode;
 548         tmp.stx_ino = stat->ino;
 549         tmp.stx_size = stat->size;
 550         tmp.stx_blocks = stat->blocks;
 551         tmp.stx_attributes_mask = stat->attributes_mask;
 552         tmp.stx_atime.tv_sec = stat->atime.tv_sec;
 553         tmp.stx_atime.tv_nsec = stat->atime.tv_nsec;
 554         tmp.stx_btime.tv_sec = stat->btime.tv_sec;
 555         tmp.stx_btime.tv_nsec = stat->btime.tv_nsec;
 556         tmp.stx_ctime.tv_sec = stat->ctime.tv_sec;
 557         tmp.stx_ctime.tv_nsec = stat->ctime.tv_nsec;
 558         tmp.stx_mtime.tv_sec = stat->mtime.tv_sec;
 559         tmp.stx_mtime.tv_nsec = stat->mtime.tv_nsec;
 560         tmp.stx_rdev_major = MAJOR(stat->rdev);
 561         tmp.stx_rdev_minor = MINOR(stat->rdev);
 562         tmp.stx_dev_major = MAJOR(stat->dev);
 563         tmp.stx_dev_minor = MINOR(stat->dev);
 564         tmp.stx_mnt_id = stat->mnt_id;
 565
 566         return copy_to_user(buffer, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 567 }
 568
 569 int do_statx(int dfd, const char __user *filename, unsigned flags,
 570              unsigned int mask, struct statx __user *buffer)
 571 {
 572         struct kstat stat;
 573         int error;
 574
 575         if (mask & STATX__RESERVED)
 576                 return -EINVAL;
 577         if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_SYNC_TYPE)
 578                 return -EINVAL;
 579
 580         error = vfs_statx(dfd, filename, flags, &stat, mask);
 581         if (error)
 582                 return error;
 583
 584         return cp_statx(&stat, buffer);
 585 }
 586
 587 /**
 588  * sys_statx - System call to get enhanced stats
 589  * @dfd: Base directory to pathwalk from *or* fd to stat.
 590  * @filename: File to stat or "" with AT_EMPTY_PATH
 591  * @flags: AT_* flags to control pathwalk.
 592  * @mask: Parts of statx struct actually required.
 593  * @buffer: Result buffer.
 594  *
 595  * Note that fstat() can be emulated by setting dfd to the fd of interest,
 596  * supplying "" as the filename and setting AT_EMPTY_PATH in the flags.
 597  */
 598 SYSCALL_DEFINE5(statx,
 599                 int, dfd, const char __user *, filename, unsigned, flags,
 600                 unsigned int, mask,
 601                 struct statx __user *, buffer)
 602 {
 603         return do_statx(dfd, filename, flags, mask, buffer);
 604 }
 605
 606 #ifdef CONFIG_COMPAT
 607 static int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf)
 608 {
 609         struct compat_stat tmp;
 610
 611         if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
 612                 return -EOVERFLOW;
 613
 614         memset(&tmp, 0, sizeof(tmp));
 615         tmp.st_dev = old_encode_dev(stat->dev);
 616         tmp.st_ino = stat->ino;
 617         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 618                 return -EOVERFLOW;
 619         tmp.st_mode = stat->mode;
 620         tmp.st_nlink = stat->nlink;
 621         if (tmp.st_nlink != stat->nlink)
 622                 return -EOVERFLOW;
 623         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
 624         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
 625         tmp.st_rdev = old_encode_dev(stat->rdev);
 626         if ((u64) stat->size > MAX_NON_LFS)
 627                 return -EOVERFLOW;
 628         tmp.st_size = stat->size;
 629         tmp.st_atime = stat->atime.tv_sec;
 630         tmp.st_atime_nsec = stat->atime.tv_nsec;
 631         tmp.st_mtime = stat->mtime.tv_sec;
 632         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 633         tmp.st_ctime = stat->ctime.tv_sec;
 634         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 635         tmp.st_blocks = stat->blocks;
 636         tmp.st_blksize = stat->blksize;
 637         return copy_to_user(ubuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 638 }
 639
 640 COMPAT_SYSCALL_DEFINE2(newstat, const char __user *, filename,
 641                        struct compat_stat __user *, statbuf)
 642 {
 643         struct kstat stat;
 644         int error;
 645
 646         error = vfs_stat(filename, &stat);
 647         if (error)
 648                 return error;
 649         return cp_compat_stat(&stat, statbuf);
 650 }
 651
 652 COMPAT_SYSCALL_DEFINE2(newlstat, const char __user *, filename,
 653                        struct compat_stat __user *, statbuf)
 654 {
 655         struct kstat stat;
 656         int error;
 657
 658         error = vfs_lstat(filename, &stat);
 659         if (error)
 660                 return error;
 661         return cp_compat_stat(&stat, statbuf);
 662 }
 663
 664 #ifndef __ARCH_WANT_STAT64
 665 COMPAT_SYSCALL_DEFINE4(newfstatat, unsigned int, dfd,
 666                        const char __user *, filename,
 667                        struct compat_stat __user *, statbuf, int, flag)
 668 {
 669         struct kstat stat;
 670         int error;
 671
 672         error = vfs_fstatat(dfd, filename, &stat, flag);
 673         if (error)
 674                 return error;
 675         return cp_compat_stat(&stat, statbuf);
 676 }
 677 #endif
 678
 679 COMPAT_SYSCALL_DEFINE2(newfstat, unsigned int, fd,
 680                        struct compat_stat __user *, statbuf)
 681 {
 682         struct kstat stat;
 683         int error = vfs_fstat(fd, &stat);
 684
 685         if (!error)
 686                 error = cp_compat_stat(&stat, statbuf);
 687         return error;
 688 }
 689 #endif
 690
 691 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */
 692 void __inode_add_bytes(struct inode *inode, loff_t bytes)
 693 {
 694         inode->i_blocks += bytes >> 9;
 695         bytes &= 511;
 696         inode->i_bytes += bytes;
 697         if (inode->i_bytes >= 512) {
 698                 inode->i_blocks++;
 699                 inode->i_bytes -= 512;
 700         }
 701 }
 702 EXPORT_SYMBOL(__inode_add_bytes);
 703
 704 void inode_add_bytes(struct inode *inode, loff_t bytes)
 705 {
 706         spin_lock(&inode->i_lock);
 707         __inode_add_bytes(inode, bytes);
 708         spin_unlock(&inode->i_lock);
 709 }
 710
 711 EXPORT_SYMBOL(inode_add_bytes);
 712
 713 void __inode_sub_bytes(struct inode *inode, loff_t bytes)
 714 {
 715         inode->i_blocks -= bytes >> 9;
 716         bytes &= 511;
 717         if (inode->i_bytes < bytes) {
 718                 inode->i_blocks--;
 719                 inode->i_bytes += 512;
 720         }
 721         inode->i_bytes -= bytes;
 722 }
 723
 724 EXPORT_SYMBOL(__inode_sub_bytes);
 725
 726 void inode_sub_bytes(struct inode *inode, loff_t bytes)
 727 {
 728         spin_lock(&inode->i_lock);
 729         __inode_sub_bytes(inode, bytes);
 730         spin_unlock(&inode->i_lock);
 731 }
 732
 733 EXPORT_SYMBOL(inode_sub_bytes);
 734
 735 loff_t inode_get_bytes(struct inode *inode)
 736 {
 737         loff_t ret;
 738
 739         spin_lock(&inode->i_lock);
 740         ret = __inode_get_bytes(inode);
 741         spin_unlock(&inode->i_lock);
 742         return ret;
 743 }
 744
 745 EXPORT_SYMBOL(inode_get_bytes);
 746
 747 void inode_set_bytes(struct inode *inode, loff_t bytes)
 748 {
 749         /* Caller is here responsible for sufficient locking
 750          * (ie. inode->i_lock) */
 751         inode->i_blocks = bytes >> 9;
 752         inode->i_bytes = bytes & 511;
 753 }
 754
 755 EXPORT_SYMBOL(inode_set_bytes);