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