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