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 #ifndef INIT_STRUCT_STAT_PADDING 352 # define INIT_STRUCT_STAT_PADDING(st) memset(&st, 0, sizeof(st)) 353 #endif 354 355 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf) 356 { 357 struct stat tmp; 358 359 if (sizeof(tmp.st_dev) < 4 && !old_valid_dev(stat->dev)) 360 return -EOVERFLOW; 361 if (sizeof(tmp.st_rdev) < 4 && !old_valid_dev(stat->rdev)) 362 return -EOVERFLOW; 363 #if BITS_PER_LONG == 32 364 if (stat->size > MAX_NON_LFS) 365 return -EOVERFLOW; 366 #endif 367 368 INIT_STRUCT_STAT_PADDING(tmp); 369 tmp.st_dev = new_encode_dev(stat->dev); 370 tmp.st_ino = stat->ino; 371 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino) 372 return -EOVERFLOW; 373 tmp.st_mode = stat->mode; 374 tmp.st_nlink = stat->nlink; 375 if (tmp.st_nlink != stat->nlink) 376 return -EOVERFLOW; 377 SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid)); 378 SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid)); 379 tmp.st_rdev = new_encode_dev(stat->rdev); 380 tmp.st_size = stat->size; 381 tmp.st_atime = stat->atime.tv_sec; 382 tmp.st_mtime = stat->mtime.tv_sec; 383 tmp.st_ctime = stat->ctime.tv_sec; 384 #ifdef STAT_HAVE_NSEC 385 tmp.st_atime_nsec = stat->atime.tv_nsec; 386 tmp.st_mtime_nsec = stat->mtime.tv_nsec; 387 tmp.st_ctime_nsec = stat->ctime.tv_nsec; 388 #endif 389 tmp.st_blocks = stat->blocks; 390 tmp.st_blksize = stat->blksize; 391 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 392 } 393 394 SYSCALL_DEFINE2(newstat, const char __user *, filename, 395 struct stat __user *, statbuf) 396 { 397 struct kstat stat; 398 int error = vfs_stat(filename, &stat); 399 400 if (error) 401 return error; 402 return cp_new_stat(&stat, statbuf); 403 } 404 405 SYSCALL_DEFINE2(newlstat, const char __user *, filename, 406 struct stat __user *, statbuf) 407 { 408 struct kstat stat; 409 int error; 410 411 error = vfs_lstat(filename, &stat); 412 if (error) 413 return error; 414 415 return cp_new_stat(&stat, statbuf); 416 } 417 418 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT) 419 SYSCALL_DEFINE4(newfstatat, int, dfd, const char __user *, filename, 420 struct stat __user *, statbuf, int, flag) 421 { 422 struct kstat stat; 423 int error; 424 425 error = vfs_fstatat(dfd, filename, &stat, flag); 426 if (error) 427 return error; 428 return cp_new_stat(&stat, statbuf); 429 } 430 #endif 431 432 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf) 433 { 434 struct kstat stat; 435 int error = vfs_fstat(fd, &stat); 436 437 if (!error) 438 error = cp_new_stat(&stat, statbuf); 439 440 return error; 441 } 442 #endif 443 444 static int do_readlinkat(int dfd, const char __user *pathname, 445 char __user *buf, int bufsiz) 446 { 447 struct path path; 448 int error; 449 int empty = 0; 450 unsigned int lookup_flags = LOOKUP_EMPTY; 451 452 if (bufsiz <= 0) 453 return -EINVAL; 454 455 retry: 456 error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty); 457 if (!error) { 458 struct inode *inode = d_backing_inode(path.dentry); 459 460 error = empty ? -ENOENT : -EINVAL; 461 /* 462 * AFS mountpoints allow readlink(2) but are not symlinks 463 */ 464 if (d_is_symlink(path.dentry) || inode->i_op->readlink) { 465 error = security_inode_readlink(path.dentry); 466 if (!error) { 467 touch_atime(&path); 468 error = vfs_readlink(path.dentry, buf, bufsiz); 469 } 470 } 471 path_put(&path); 472 if (retry_estale(error, lookup_flags)) { 473 lookup_flags |= LOOKUP_REVAL; 474 goto retry; 475 } 476 } 477 return error; 478 } 479 480 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname, 481 char __user *, buf, int, bufsiz) 482 { 483 return do_readlinkat(dfd, pathname, buf, bufsiz); 484 } 485 486 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf, 487 int, bufsiz) 488 { 489 return do_readlinkat(AT_FDCWD, path, buf, bufsiz); 490 } 491 492 493 /* ---------- LFS-64 ----------- */ 494 #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64) 495 496 #ifndef INIT_STRUCT_STAT64_PADDING 497 # define INIT_STRUCT_STAT64_PADDING(st) memset(&st, 0, sizeof(st)) 498 #endif 499 500 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf) 501 { 502 struct stat64 tmp; 503 504 INIT_STRUCT_STAT64_PADDING(tmp); 505 #ifdef CONFIG_MIPS 506 /* mips has weird padding, so we don't get 64 bits there */ 507 tmp.st_dev = new_encode_dev(stat->dev); 508 tmp.st_rdev = new_encode_dev(stat->rdev); 509 #else 510 tmp.st_dev = huge_encode_dev(stat->dev); 511 tmp.st_rdev = huge_encode_dev(stat->rdev); 512 #endif 513 tmp.st_ino = stat->ino; 514 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino) 515 return -EOVERFLOW; 516 #ifdef STAT64_HAS_BROKEN_ST_INO 517 tmp.__st_ino = stat->ino; 518 #endif 519 tmp.st_mode = stat->mode; 520 tmp.st_nlink = stat->nlink; 521 tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid); 522 tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid); 523 tmp.st_atime = stat->atime.tv_sec; 524 tmp.st_atime_nsec = stat->atime.tv_nsec; 525 tmp.st_mtime = stat->mtime.tv_sec; 526 tmp.st_mtime_nsec = stat->mtime.tv_nsec; 527 tmp.st_ctime = stat->ctime.tv_sec; 528 tmp.st_ctime_nsec = stat->ctime.tv_nsec; 529 tmp.st_size = stat->size; 530 tmp.st_blocks = stat->blocks; 531 tmp.st_blksize = stat->blksize; 532 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 533 } 534 535 SYSCALL_DEFINE2(stat64, const char __user *, filename, 536 struct stat64 __user *, statbuf) 537 { 538 struct kstat stat; 539 int error = vfs_stat(filename, &stat); 540 541 if (!error) 542 error = cp_new_stat64(&stat, statbuf); 543 544 return error; 545 } 546 547 SYSCALL_DEFINE2(lstat64, const char __user *, filename, 548 struct stat64 __user *, statbuf) 549 { 550 struct kstat stat; 551 int error = vfs_lstat(filename, &stat); 552 553 if (!error) 554 error = cp_new_stat64(&stat, statbuf); 555 556 return error; 557 } 558 559 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf) 560 { 561 struct kstat stat; 562 int error = vfs_fstat(fd, &stat); 563 564 if (!error) 565 error = cp_new_stat64(&stat, statbuf); 566 567 return error; 568 } 569 570 SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename, 571 struct stat64 __user *, statbuf, int, flag) 572 { 573 struct kstat stat; 574 int error; 575 576 error = vfs_fstatat(dfd, filename, &stat, flag); 577 if (error) 578 return error; 579 return cp_new_stat64(&stat, statbuf); 580 } 581 #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */ 582 583 static noinline_for_stack int 584 cp_statx(const struct kstat *stat, struct statx __user *buffer) 585 { 586 struct statx tmp; 587 588 memset(&tmp, 0, sizeof(tmp)); 589 590 tmp.stx_mask = stat->result_mask; 591 tmp.stx_blksize = stat->blksize; 592 tmp.stx_attributes = stat->attributes; 593 tmp.stx_nlink = stat->nlink; 594 tmp.stx_uid = from_kuid_munged(current_user_ns(), stat->uid); 595 tmp.stx_gid = from_kgid_munged(current_user_ns(), stat->gid); 596 tmp.stx_mode = stat->mode; 597 tmp.stx_ino = stat->ino; 598 tmp.stx_size = stat->size; 599 tmp.stx_blocks = stat->blocks; 600 tmp.stx_attributes_mask = stat->attributes_mask; 601 tmp.stx_atime.tv_sec = stat->atime.tv_sec; 602 tmp.stx_atime.tv_nsec = stat->atime.tv_nsec; 603 tmp.stx_btime.tv_sec = stat->btime.tv_sec; 604 tmp.stx_btime.tv_nsec = stat->btime.tv_nsec; 605 tmp.stx_ctime.tv_sec = stat->ctime.tv_sec; 606 tmp.stx_ctime.tv_nsec = stat->ctime.tv_nsec; 607 tmp.stx_mtime.tv_sec = stat->mtime.tv_sec; 608 tmp.stx_mtime.tv_nsec = stat->mtime.tv_nsec; 609 tmp.stx_rdev_major = MAJOR(stat->rdev); 610 tmp.stx_rdev_minor = MINOR(stat->rdev); 611 tmp.stx_dev_major = MAJOR(stat->dev); 612 tmp.stx_dev_minor = MINOR(stat->dev); 613 tmp.stx_mnt_id = stat->mnt_id; 614 615 return copy_to_user(buffer, &tmp, sizeof(tmp)) ? -EFAULT : 0; 616 } 617 618 int do_statx(int dfd, struct filename *filename, unsigned int flags, 619 unsigned int mask, struct statx __user *buffer) 620 { 621 struct kstat stat; 622 int error; 623 624 if (mask & STATX__RESERVED) 625 return -EINVAL; 626 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_SYNC_TYPE) 627 return -EINVAL; 628 629 error = vfs_statx(dfd, filename, flags, &stat, mask); 630 if (error) 631 return error; 632 633 return cp_statx(&stat, buffer); 634 } 635 636 /** 637 * sys_statx - System call to get enhanced stats 638 * @dfd: Base directory to pathwalk from *or* fd to stat. 639 * @filename: File to stat or "" with AT_EMPTY_PATH 640 * @flags: AT_* flags to control pathwalk. 641 * @mask: Parts of statx struct actually required. 642 * @buffer: Result buffer. 643 * 644 * Note that fstat() can be emulated by setting dfd to the fd of interest, 645 * supplying "" as the filename and setting AT_EMPTY_PATH in the flags. 646 */ 647 SYSCALL_DEFINE5(statx, 648 int, dfd, const char __user *, filename, unsigned, flags, 649 unsigned int, mask, 650 struct statx __user *, buffer) 651 { 652 int ret; 653 struct filename *name; 654 655 name = getname_flags(filename, getname_statx_lookup_flags(flags), NULL); 656 ret = do_statx(dfd, name, flags, mask, buffer); 657 putname(name); 658 659 return ret; 660 } 661 662 #if defined(CONFIG_COMPAT) && defined(__ARCH_WANT_COMPAT_STAT) 663 static int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf) 664 { 665 struct compat_stat tmp; 666 667 if (sizeof(tmp.st_dev) < 4 && !old_valid_dev(stat->dev)) 668 return -EOVERFLOW; 669 if (sizeof(tmp.st_rdev) < 4 && !old_valid_dev(stat->rdev)) 670 return -EOVERFLOW; 671 672 memset(&tmp, 0, sizeof(tmp)); 673 tmp.st_dev = new_encode_dev(stat->dev); 674 tmp.st_ino = stat->ino; 675 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino) 676 return -EOVERFLOW; 677 tmp.st_mode = stat->mode; 678 tmp.st_nlink = stat->nlink; 679 if (tmp.st_nlink != stat->nlink) 680 return -EOVERFLOW; 681 SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid)); 682 SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid)); 683 tmp.st_rdev = new_encode_dev(stat->rdev); 684 if ((u64) stat->size > MAX_NON_LFS) 685 return -EOVERFLOW; 686 tmp.st_size = stat->size; 687 tmp.st_atime = stat->atime.tv_sec; 688 tmp.st_atime_nsec = stat->atime.tv_nsec; 689 tmp.st_mtime = stat->mtime.tv_sec; 690 tmp.st_mtime_nsec = stat->mtime.tv_nsec; 691 tmp.st_ctime = stat->ctime.tv_sec; 692 tmp.st_ctime_nsec = stat->ctime.tv_nsec; 693 tmp.st_blocks = stat->blocks; 694 tmp.st_blksize = stat->blksize; 695 return copy_to_user(ubuf, &tmp, sizeof(tmp)) ? -EFAULT : 0; 696 } 697 698 COMPAT_SYSCALL_DEFINE2(newstat, const char __user *, filename, 699 struct compat_stat __user *, statbuf) 700 { 701 struct kstat stat; 702 int error; 703 704 error = vfs_stat(filename, &stat); 705 if (error) 706 return error; 707 return cp_compat_stat(&stat, statbuf); 708 } 709 710 COMPAT_SYSCALL_DEFINE2(newlstat, const char __user *, filename, 711 struct compat_stat __user *, statbuf) 712 { 713 struct kstat stat; 714 int error; 715 716 error = vfs_lstat(filename, &stat); 717 if (error) 718 return error; 719 return cp_compat_stat(&stat, statbuf); 720 } 721 722 #ifndef __ARCH_WANT_STAT64 723 COMPAT_SYSCALL_DEFINE4(newfstatat, unsigned int, dfd, 724 const char __user *, filename, 725 struct compat_stat __user *, statbuf, int, flag) 726 { 727 struct kstat stat; 728 int error; 729 730 error = vfs_fstatat(dfd, filename, &stat, flag); 731 if (error) 732 return error; 733 return cp_compat_stat(&stat, statbuf); 734 } 735 #endif 736 737 COMPAT_SYSCALL_DEFINE2(newfstat, unsigned int, fd, 738 struct compat_stat __user *, statbuf) 739 { 740 struct kstat stat; 741 int error = vfs_fstat(fd, &stat); 742 743 if (!error) 744 error = cp_compat_stat(&stat, statbuf); 745 return error; 746 } 747 #endif 748 749 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */ 750 void __inode_add_bytes(struct inode *inode, loff_t bytes) 751 { 752 inode->i_blocks += bytes >> 9; 753 bytes &= 511; 754 inode->i_bytes += bytes; 755 if (inode->i_bytes >= 512) { 756 inode->i_blocks++; 757 inode->i_bytes -= 512; 758 } 759 } 760 EXPORT_SYMBOL(__inode_add_bytes); 761 762 void inode_add_bytes(struct inode *inode, loff_t bytes) 763 { 764 spin_lock(&inode->i_lock); 765 __inode_add_bytes(inode, bytes); 766 spin_unlock(&inode->i_lock); 767 } 768 769 EXPORT_SYMBOL(inode_add_bytes); 770 771 void __inode_sub_bytes(struct inode *inode, loff_t bytes) 772 { 773 inode->i_blocks -= bytes >> 9; 774 bytes &= 511; 775 if (inode->i_bytes < bytes) { 776 inode->i_blocks--; 777 inode->i_bytes += 512; 778 } 779 inode->i_bytes -= bytes; 780 } 781 782 EXPORT_SYMBOL(__inode_sub_bytes); 783 784 void inode_sub_bytes(struct inode *inode, loff_t bytes) 785 { 786 spin_lock(&inode->i_lock); 787 __inode_sub_bytes(inode, bytes); 788 spin_unlock(&inode->i_lock); 789 } 790 791 EXPORT_SYMBOL(inode_sub_bytes); 792 793 loff_t inode_get_bytes(struct inode *inode) 794 { 795 loff_t ret; 796 797 spin_lock(&inode->i_lock); 798 ret = __inode_get_bytes(inode); 799 spin_unlock(&inode->i_lock); 800 return ret; 801 } 802 803 EXPORT_SYMBOL(inode_get_bytes); 804 805 void inode_set_bytes(struct inode *inode, loff_t bytes) 806 { 807 /* Caller is here responsible for sufficient locking 808 * (ie. inode->i_lock) */ 809 inode->i_blocks = bytes >> 9; 810 inode->i_bytes = bytes & 511; 811 } 812 813 EXPORT_SYMBOL(inode_set_bytes); 814