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