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 int getname_statx_lookup_flags(int flags)
 188 {
 189         int lookup_flags = 0;
 190
 191         if (!(flags & AT_SYMLINK_NOFOLLOW))
 192                 lookup_flags |= LOOKUP_FOLLOW;
 193         if (!(flags & AT_NO_AUTOMOUNT))
 194                 lookup_flags |= LOOKUP_AUTOMOUNT;
 195         if (flags & AT_EMPTY_PATH)
 196                 lookup_flags |= LOOKUP_EMPTY;
 197
 198         return lookup_flags;
 199 }
 200
 201 /**
 202  * vfs_statx - Get basic and extra attributes by filename
 203  * @dfd: A file descriptor representing the base dir for a relative filename
 204  * @filename: The name of the file of interest
 205  * @flags: Flags to control the query
 206  * @stat: The result structure to fill in.
 207  * @request_mask: STATX_xxx flags indicating what the caller wants
 208  *
 209  * This function is a wrapper around vfs_getattr().  The main difference is
 210  * that it uses a filename and base directory to determine the file location.
 211  * Additionally, the use of AT_SYMLINK_NOFOLLOW in flags will prevent a symlink
 212  * at the given name from being referenced.
 213  *
 214  * 0 will be returned on success, and a -ve error code if unsuccessful.
 215  */
 216 static int vfs_statx(int dfd, struct filename *filename, int flags,
 217               struct kstat *stat, u32 request_mask)
 218 {
 219         struct path path;
 220         unsigned int lookup_flags = getname_statx_lookup_flags(flags);
 221         int error;
 222
 223         if (flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT | AT_EMPTY_PATH |
 224                       AT_STATX_SYNC_TYPE))
 225                 return -EINVAL;
 226
 227 retry:
 228         error = filename_lookup(dfd, filename, lookup_flags, &path, NULL);
 229         if (error)
 230                 goto out;
 231
 232         error = vfs_getattr(&path, stat, request_mask, flags);
 233         stat->mnt_id = real_mount(path.mnt)->mnt_id;
 234         stat->result_mask |= STATX_MNT_ID;
 235         if (path.mnt->mnt_root == path.dentry)
 236                 stat->attributes |= STATX_ATTR_MOUNT_ROOT;
 237         stat->attributes_mask |= STATX_ATTR_MOUNT_ROOT;
 238         path_put(&path);
 239         if (retry_estale(error, lookup_flags)) {
 240                 lookup_flags |= LOOKUP_REVAL;
 241                 goto retry;
 242         }
 243 out:
 244         return error;
 245 }
 246
 247 int vfs_fstatat(int dfd, const char __user *filename,
 248                               struct kstat *stat, int flags)
 249 {
 250         int ret;
 251         int statx_flags = flags | AT_NO_AUTOMOUNT;
 252         struct filename *name;
 253
 254         name = getname_flags(filename, getname_statx_lookup_flags(statx_flags), NULL);
 255         ret = vfs_statx(dfd, name, statx_flags, stat, STATX_BASIC_STATS);
 256         putname(name);
 257
 258         return ret;
 259 }
 260
 261 #ifdef __ARCH_WANT_OLD_STAT
 262
 263 /*
 264  * For backward compatibility?  Maybe this should be moved
 265  * into arch/i386 instead?
 266  */
 267 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
 268 {
 269         static int warncount = 5;
 270         struct __old_kernel_stat tmp;
 271
 272         if (warncount > 0) {
 273                 warncount--;
 274                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
 275                         current->comm);
 276         } else if (warncount < 0) {
 277                 /* it's laughable, but... */
 278                 warncount = 0;
 279         }
 280
 281         memset(&tmp, 0, sizeof(struct __old_kernel_stat));
 282         tmp.st_dev = old_encode_dev(stat->dev);
 283         tmp.st_ino = stat->ino;
 284         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 285                 return -EOVERFLOW;
 286         tmp.st_mode = stat->mode;
 287         tmp.st_nlink = stat->nlink;
 288         if (tmp.st_nlink != stat->nlink)
 289                 return -EOVERFLOW;
 290         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
 291         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
 292         tmp.st_rdev = old_encode_dev(stat->rdev);
 293 #if BITS_PER_LONG == 32
 294         if (stat->size > MAX_NON_LFS)
 295                 return -EOVERFLOW;
 296 #endif
 297         tmp.st_size = stat->size;
 298         tmp.st_atime = stat->atime.tv_sec;
 299         tmp.st_mtime = stat->mtime.tv_sec;
 300         tmp.st_ctime = stat->ctime.tv_sec;
 301         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 302 }
 303
 304 SYSCALL_DEFINE2(stat, const char __user *, filename,
 305                 struct __old_kernel_stat __user *, statbuf)
 306 {
 307         struct kstat stat;
 308         int error;
 309
 310         error = vfs_stat(filename, &stat);
 311         if (error)
 312                 return error;
 313
 314         return cp_old_stat(&stat, statbuf);
 315 }
 316
 317 SYSCALL_DEFINE2(lstat, const char __user *, filename,
 318                 struct __old_kernel_stat __user *, statbuf)
 319 {
 320         struct kstat stat;
 321         int error;
 322
 323         error = vfs_lstat(filename, &stat);
 324         if (error)
 325                 return error;
 326
 327         return cp_old_stat(&stat, statbuf);
 328 }
 329
 330 SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
 331 {
 332         struct kstat stat;
 333         int error = vfs_fstat(fd, &stat);
 334
 335         if (!error)
 336                 error = cp_old_stat(&stat, statbuf);
 337
 338         return error;
 339 }
 340
 341 #endif /* __ARCH_WANT_OLD_STAT */
 342
 343 #ifdef __ARCH_WANT_NEW_STAT
 344
 345 #if BITS_PER_LONG == 32
 346 #  define choose_32_64(a,b) a
 347 #else
 348 #  define choose_32_64(a,b) b
 349 #endif
 350
 351 #define valid_dev(x)  choose_32_64(old_valid_dev(x),true)
 352 #define encode_dev(x) choose_32_64(old_encode_dev,new_encode_dev)(x)
 353
 354 #ifndef INIT_STRUCT_STAT_PADDING
 355 #  define INIT_STRUCT_STAT_PADDING(st) memset(&st, 0, sizeof(st))
 356 #endif
 357
 358 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
 359 {
 360         struct stat tmp;
 361
 362         if (!valid_dev(stat->dev) || !valid_dev(stat->rdev))
 363                 return -EOVERFLOW;
 364 #if BITS_PER_LONG == 32
 365         if (stat->size > MAX_NON_LFS)
 366                 return -EOVERFLOW;
 367 #endif
 368
 369         INIT_STRUCT_STAT_PADDING(tmp);
 370         tmp.st_dev = encode_dev(stat->dev);
 371         tmp.st_ino = stat->ino;
 372         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 373                 return -EOVERFLOW;
 374         tmp.st_mode = stat->mode;
 375         tmp.st_nlink = stat->nlink;
 376         if (tmp.st_nlink != stat->nlink)
 377                 return -EOVERFLOW;
 378         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
 379         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
 380         tmp.st_rdev = encode_dev(stat->rdev);
 381         tmp.st_size = stat->size;
 382         tmp.st_atime = stat->atime.tv_sec;
 383         tmp.st_mtime = stat->mtime.tv_sec;
 384         tmp.st_ctime = stat->ctime.tv_sec;
 385 #ifdef STAT_HAVE_NSEC
 386         tmp.st_atime_nsec = stat->atime.tv_nsec;
 387         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 388         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 389 #endif
 390         tmp.st_blocks = stat->blocks;
 391         tmp.st_blksize = stat->blksize;
 392         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 393 }
 394
 395 SYSCALL_DEFINE2(newstat, const char __user *, filename,
 396                 struct stat __user *, statbuf)
 397 {
 398         struct kstat stat;
 399         int error = vfs_stat(filename, &stat);
 400
 401         if (error)
 402                 return error;
 403         return cp_new_stat(&stat, statbuf);
 404 }
 405
 406 SYSCALL_DEFINE2(newlstat, const char __user *, filename,
 407                 struct stat __user *, statbuf)
 408 {
 409         struct kstat stat;
 410         int error;
 411
 412         error = vfs_lstat(filename, &stat);
 413         if (error)
 414                 return error;
 415
 416         return cp_new_stat(&stat, statbuf);
 417 }
 418
 419 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
 420 SYSCALL_DEFINE4(newfstatat, int, dfd, const char __user *, filename,
 421                 struct stat __user *, statbuf, int, flag)
 422 {
 423         struct kstat stat;
 424         int error;
 425
 426         error = vfs_fstatat(dfd, filename, &stat, flag);
 427         if (error)
 428                 return error;
 429         return cp_new_stat(&stat, statbuf);
 430 }
 431 #endif
 432
 433 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
 434 {
 435         struct kstat stat;
 436         int error = vfs_fstat(fd, &stat);
 437
 438         if (!error)
 439                 error = cp_new_stat(&stat, statbuf);
 440
 441         return error;
 442 }
 443 #endif
 444
 445 static int do_readlinkat(int dfd, const char __user *pathname,
 446                          char __user *buf, int bufsiz)
 447 {
 448         struct path path;
 449         int error;
 450         int empty = 0;
 451         unsigned int lookup_flags = LOOKUP_EMPTY;
 452
 453         if (bufsiz <= 0)
 454                 return -EINVAL;
 455
 456 retry:
 457         error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty);
 458         if (!error) {
 459                 struct inode *inode = d_backing_inode(path.dentry);
 460
 461                 error = empty ? -ENOENT : -EINVAL;
 462                 /*
 463                  * AFS mountpoints allow readlink(2) but are not symlinks
 464                  */
 465                 if (d_is_symlink(path.dentry) || inode->i_op->readlink) {
 466                         error = security_inode_readlink(path.dentry);
 467                         if (!error) {
 468                                 touch_atime(&path);
 469                                 error = vfs_readlink(path.dentry, buf, bufsiz);
 470                         }
 471                 }
 472                 path_put(&path);
 473                 if (retry_estale(error, lookup_flags)) {
 474                         lookup_flags |= LOOKUP_REVAL;
 475                         goto retry;
 476                 }
 477         }
 478         return error;
 479 }
 480
 481 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
 482                 char __user *, buf, int, bufsiz)
 483 {
 484         return do_readlinkat(dfd, pathname, buf, bufsiz);
 485 }
 486
 487 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
 488                 int, bufsiz)
 489 {
 490         return do_readlinkat(AT_FDCWD, path, buf, bufsiz);
 491 }
 492
 493
 494 /* ---------- LFS-64 ----------- */
 495 #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64)
 496
 497 #ifndef INIT_STRUCT_STAT64_PADDING
 498 #  define INIT_STRUCT_STAT64_PADDING(st) memset(&st, 0, sizeof(st))
 499 #endif
 500
 501 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
 502 {
 503         struct stat64 tmp;
 504
 505         INIT_STRUCT_STAT64_PADDING(tmp);
 506 #ifdef CONFIG_MIPS
 507         /* mips has weird padding, so we don't get 64 bits there */
 508         tmp.st_dev = new_encode_dev(stat->dev);
 509         tmp.st_rdev = new_encode_dev(stat->rdev);
 510 #else
 511         tmp.st_dev = huge_encode_dev(stat->dev);
 512         tmp.st_rdev = huge_encode_dev(stat->rdev);
 513 #endif
 514         tmp.st_ino = stat->ino;
 515         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 516                 return -EOVERFLOW;
 517 #ifdef STAT64_HAS_BROKEN_ST_INO
 518         tmp.__st_ino = stat->ino;
 519 #endif
 520         tmp.st_mode = stat->mode;
 521         tmp.st_nlink = stat->nlink;
 522         tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
 523         tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
 524         tmp.st_atime = stat->atime.tv_sec;
 525         tmp.st_atime_nsec = stat->atime.tv_nsec;
 526         tmp.st_mtime = stat->mtime.tv_sec;
 527         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 528         tmp.st_ctime = stat->ctime.tv_sec;
 529         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 530         tmp.st_size = stat->size;
 531         tmp.st_blocks = stat->blocks;
 532         tmp.st_blksize = stat->blksize;
 533         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
 534 }
 535
 536 SYSCALL_DEFINE2(stat64, const char __user *, filename,
 537                 struct stat64 __user *, statbuf)
 538 {
 539         struct kstat stat;
 540         int error = vfs_stat(filename, &stat);
 541
 542         if (!error)
 543                 error = cp_new_stat64(&stat, statbuf);
 544
 545         return error;
 546 }
 547
 548 SYSCALL_DEFINE2(lstat64, const char __user *, filename,
 549                 struct stat64 __user *, statbuf)
 550 {
 551         struct kstat stat;
 552         int error = vfs_lstat(filename, &stat);
 553
 554         if (!error)
 555                 error = cp_new_stat64(&stat, statbuf);
 556
 557         return error;
 558 }
 559
 560 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
 561 {
 562         struct kstat stat;
 563         int error = vfs_fstat(fd, &stat);
 564
 565         if (!error)
 566                 error = cp_new_stat64(&stat, statbuf);
 567
 568         return error;
 569 }
 570
 571 SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
 572                 struct stat64 __user *, statbuf, int, flag)
 573 {
 574         struct kstat stat;
 575         int error;
 576
 577         error = vfs_fstatat(dfd, filename, &stat, flag);
 578         if (error)
 579                 return error;
 580         return cp_new_stat64(&stat, statbuf);
 581 }
 582 #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */
 583
 584 static noinline_for_stack int
 585 cp_statx(const struct kstat *stat, struct statx __user *buffer)
 586 {
 587         struct statx tmp;
 588
 589         memset(&tmp, 0, sizeof(tmp));
 590
 591         tmp.stx_mask = stat->result_mask;
 592         tmp.stx_blksize = stat->blksize;
 593         tmp.stx_attributes = stat->attributes;
 594         tmp.stx_nlink = stat->nlink;
 595         tmp.stx_uid = from_kuid_munged(current_user_ns(), stat->uid);
 596         tmp.stx_gid = from_kgid_munged(current_user_ns(), stat->gid);
 597         tmp.stx_mode = stat->mode;
 598         tmp.stx_ino = stat->ino;
 599         tmp.stx_size = stat->size;
 600         tmp.stx_blocks = stat->blocks;
 601         tmp.stx_attributes_mask = stat->attributes_mask;
 602         tmp.stx_atime.tv_sec = stat->atime.tv_sec;
 603         tmp.stx_atime.tv_nsec = stat->atime.tv_nsec;
 604         tmp.stx_btime.tv_sec = stat->btime.tv_sec;
 605         tmp.stx_btime.tv_nsec = stat->btime.tv_nsec;
 606         tmp.stx_ctime.tv_sec = stat->ctime.tv_sec;
 607         tmp.stx_ctime.tv_nsec = stat->ctime.tv_nsec;
 608         tmp.stx_mtime.tv_sec = stat->mtime.tv_sec;
 609         tmp.stx_mtime.tv_nsec = stat->mtime.tv_nsec;
 610         tmp.stx_rdev_major = MAJOR(stat->rdev);
 611         tmp.stx_rdev_minor = MINOR(stat->rdev);
 612         tmp.stx_dev_major = MAJOR(stat->dev);
 613         tmp.stx_dev_minor = MINOR(stat->dev);
 614         tmp.stx_mnt_id = stat->mnt_id;
 615
 616         return copy_to_user(buffer, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 617 }
 618
 619 int do_statx(int dfd, struct filename *filename, unsigned int flags,
 620              unsigned int mask, struct statx __user *buffer)
 621 {
 622         struct kstat stat;
 623         int error;
 624
 625         if (mask & STATX__RESERVED)
 626                 return -EINVAL;
 627         if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_SYNC_TYPE)
 628                 return -EINVAL;
 629
 630         error = vfs_statx(dfd, filename, flags, &stat, mask);
 631         if (error)
 632                 return error;
 633
 634         return cp_statx(&stat, buffer);
 635 }
 636
 637 /**
 638  * sys_statx - System call to get enhanced stats
 639  * @dfd: Base directory to pathwalk from *or* fd to stat.
 640  * @filename: File to stat or "" with AT_EMPTY_PATH
 641  * @flags: AT_* flags to control pathwalk.
 642  * @mask: Parts of statx struct actually required.
 643  * @buffer: Result buffer.
 644  *
 645  * Note that fstat() can be emulated by setting dfd to the fd of interest,
 646  * supplying "" as the filename and setting AT_EMPTY_PATH in the flags.
 647  */
 648 SYSCALL_DEFINE5(statx,
 649                 int, dfd, const char __user *, filename, unsigned, flags,
 650                 unsigned int, mask,
 651                 struct statx __user *, buffer)
 652 {
 653         int ret;
 654         struct filename *name;
 655
 656         name = getname_flags(filename, getname_statx_lookup_flags(flags), NULL);
 657         ret = do_statx(dfd, name, flags, mask, buffer);
 658         putname(name);
 659
 660         return ret;
 661 }
 662
 663 #ifdef CONFIG_COMPAT
 664 static int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf)
 665 {
 666         struct compat_stat tmp;
 667
 668         if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
 669                 return -EOVERFLOW;
 670
 671         memset(&tmp, 0, sizeof(tmp));
 672         tmp.st_dev = old_encode_dev(stat->dev);
 673         tmp.st_ino = stat->ino;
 674         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
 675                 return -EOVERFLOW;
 676         tmp.st_mode = stat->mode;
 677         tmp.st_nlink = stat->nlink;
 678         if (tmp.st_nlink != stat->nlink)
 679                 return -EOVERFLOW;
 680         SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid));
 681         SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid));
 682         tmp.st_rdev = old_encode_dev(stat->rdev);
 683         if ((u64) stat->size > MAX_NON_LFS)
 684                 return -EOVERFLOW;
 685         tmp.st_size = stat->size;
 686         tmp.st_atime = stat->atime.tv_sec;
 687         tmp.st_atime_nsec = stat->atime.tv_nsec;
 688         tmp.st_mtime = stat->mtime.tv_sec;
 689         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
 690         tmp.st_ctime = stat->ctime.tv_sec;
 691         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
 692         tmp.st_blocks = stat->blocks;
 693         tmp.st_blksize = stat->blksize;
 694         return copy_to_user(ubuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 695 }
 696
 697 COMPAT_SYSCALL_DEFINE2(newstat, const char __user *, filename,
 698                        struct compat_stat __user *, statbuf)
 699 {
 700         struct kstat stat;
 701         int error;
 702
 703         error = vfs_stat(filename, &stat);
 704         if (error)
 705                 return error;
 706         return cp_compat_stat(&stat, statbuf);
 707 }
 708
 709 COMPAT_SYSCALL_DEFINE2(newlstat, const char __user *, filename,
 710                        struct compat_stat __user *, statbuf)
 711 {
 712         struct kstat stat;
 713         int error;
 714
 715         error = vfs_lstat(filename, &stat);
 716         if (error)
 717                 return error;
 718         return cp_compat_stat(&stat, statbuf);
 719 }
 720
 721 #ifndef __ARCH_WANT_STAT64
 722 COMPAT_SYSCALL_DEFINE4(newfstatat, unsigned int, dfd,
 723                        const char __user *, filename,
 724                        struct compat_stat __user *, statbuf, int, flag)
 725 {
 726         struct kstat stat;
 727         int error;
 728
 729         error = vfs_fstatat(dfd, filename, &stat, flag);
 730         if (error)
 731                 return error;
 732         return cp_compat_stat(&stat, statbuf);
 733 }
 734 #endif
 735
 736 COMPAT_SYSCALL_DEFINE2(newfstat, unsigned int, fd,
 737                        struct compat_stat __user *, statbuf)
 738 {
 739         struct kstat stat;
 740         int error = vfs_fstat(fd, &stat);
 741
 742         if (!error)
 743                 error = cp_compat_stat(&stat, statbuf);
 744         return error;
 745 }
 746 #endif
 747
 748 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */
 749 void __inode_add_bytes(struct inode *inode, loff_t bytes)
 750 {
 751         inode->i_blocks += bytes >> 9;
 752         bytes &= 511;
 753         inode->i_bytes += bytes;
 754         if (inode->i_bytes >= 512) {
 755                 inode->i_blocks++;
 756                 inode->i_bytes -= 512;
 757         }
 758 }
 759 EXPORT_SYMBOL(__inode_add_bytes);
 760
 761 void inode_add_bytes(struct inode *inode, loff_t bytes)
 762 {
 763         spin_lock(&inode->i_lock);
 764         __inode_add_bytes(inode, bytes);
 765         spin_unlock(&inode->i_lock);
 766 }
 767
 768 EXPORT_SYMBOL(inode_add_bytes);
 769
 770 void __inode_sub_bytes(struct inode *inode, loff_t bytes)
 771 {
 772         inode->i_blocks -= bytes >> 9;
 773         bytes &= 511;
 774         if (inode->i_bytes < bytes) {
 775                 inode->i_blocks--;
 776                 inode->i_bytes += 512;
 777         }
 778         inode->i_bytes -= bytes;
 779 }
 780
 781 EXPORT_SYMBOL(__inode_sub_bytes);
 782
 783 void inode_sub_bytes(struct inode *inode, loff_t bytes)
 784 {
 785         spin_lock(&inode->i_lock);
 786         __inode_sub_bytes(inode, bytes);
 787         spin_unlock(&inode->i_lock);
 788 }
 789
 790 EXPORT_SYMBOL(inode_sub_bytes);
 791
 792 loff_t inode_get_bytes(struct inode *inode)
 793 {
 794         loff_t ret;
 795
 796         spin_lock(&inode->i_lock);
 797         ret = __inode_get_bytes(inode);
 798         spin_unlock(&inode->i_lock);
 799         return ret;
 800 }
 801
 802 EXPORT_SYMBOL(inode_get_bytes);
 803
 804 void inode_set_bytes(struct inode *inode, loff_t bytes)
 805 {
 806         /* Caller is here responsible for sufficient locking
 807          * (ie. inode->i_lock) */
 808         inode->i_blocks = bytes >> 9;
 809         inode->i_bytes = bytes & 511;
 810 }
 811
 812 EXPORT_SYMBOL(inode_set_bytes);