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