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