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