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