1 /* 2 * linux/fs/stat.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 #include <linux/export.h> 8 #include <linux/mm.h> 9 #include <linux/errno.h> 10 #include <linux/file.h> 11 #include <linux/highuid.h> 12 #include <linux/fs.h> 13 #include <linux/namei.h> 14 #include <linux/security.h> 15 #include <linux/cred.h> 16 #include <linux/syscalls.h> 17 #include <linux/pagemap.h> 18 19 #include <linux/uaccess.h> 20 #include <asm/unistd.h> 21 22 /** 23 * generic_fillattr - Fill in the basic attributes from the inode struct 24 * @inode: Inode to use as the source 25 * @stat: Where to fill in the attributes 26 * 27 * Fill in the basic attributes in the kstat structure from data that's to be 28 * found on the VFS inode structure. This is the default if no getattr inode 29 * operation is supplied. 30 */ 31 void generic_fillattr(struct inode *inode, struct kstat *stat) 32 { 33 stat->dev = inode->i_sb->s_dev; 34 stat->ino = inode->i_ino; 35 stat->mode = inode->i_mode; 36 stat->nlink = inode->i_nlink; 37 stat->uid = inode->i_uid; 38 stat->gid = inode->i_gid; 39 stat->rdev = inode->i_rdev; 40 stat->size = i_size_read(inode); 41 stat->atime = inode->i_atime; 42 stat->mtime = inode->i_mtime; 43 stat->ctime = inode->i_ctime; 44 stat->blksize = i_blocksize(inode); 45 stat->blocks = inode->i_blocks; 46 47 if (IS_NOATIME(inode)) 48 stat->result_mask &= ~STATX_ATIME; 49 if (IS_AUTOMOUNT(inode)) 50 stat->attributes |= STATX_ATTR_AUTOMOUNT; 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 request_mask &= STATX_ALL; 75 query_flags &= KSTAT_QUERY_FLAGS; 76 if (inode->i_op->getattr) 77 return inode->i_op->getattr(path, stat, request_mask, 78 query_flags); 79 80 generic_fillattr(inode, stat); 81 return 0; 82 } 83 EXPORT_SYMBOL(vfs_getattr_nosec); 84 85 /* 86 * vfs_getattr - Get the enhanced basic attributes of a file 87 * @path: The file of interest 88 * @stat: Where to return the statistics 89 * @request_mask: STATX_xxx flags indicating what the caller wants 90 * @query_flags: Query mode (KSTAT_QUERY_FLAGS) 91 * 92 * Ask the filesystem for a file's attributes. The caller must indicate in 93 * request_mask and query_flags to indicate what they want. 94 * 95 * If the file is remote, the filesystem can be forced to update the attributes 96 * from the backing store by passing AT_STATX_FORCE_SYNC in query_flags or can 97 * suppress the update by passing AT_STATX_DONT_SYNC. 98 * 99 * Bits must have been set in request_mask to indicate which attributes the 100 * caller wants retrieving. Any such attribute not requested may be returned 101 * anyway, but the value may be approximate, and, if remote, may not have been 102 * synchronised with the server. 103 * 104 * 0 will be returned on success, and a -ve error code if unsuccessful. 105 */ 106 int vfs_getattr(const struct path *path, struct kstat *stat, 107 u32 request_mask, unsigned int query_flags) 108 { 109 int retval; 110 111 retval = security_inode_getattr(path); 112 if (retval) 113 return retval; 114 return vfs_getattr_nosec(path, stat, request_mask, query_flags); 115 } 116 EXPORT_SYMBOL(vfs_getattr); 117 118 /** 119 * vfs_statx_fd - Get the enhanced basic attributes by file descriptor 120 * @fd: The file descriptor referring to the file of interest 121 * @stat: The result structure to fill in. 122 * @request_mask: STATX_xxx flags indicating what the caller wants 123 * @query_flags: Query mode (KSTAT_QUERY_FLAGS) 124 * 125 * This function is a wrapper around vfs_getattr(). The main difference is 126 * that it uses a file descriptor to determine the file location. 127 * 128 * 0 will be returned on success, and a -ve error code if unsuccessful. 129 */ 130 int vfs_statx_fd(unsigned int fd, struct kstat *stat, 131 u32 request_mask, unsigned int query_flags) 132 { 133 struct fd f; 134 int error = -EBADF; 135 136 if (query_flags & ~KSTAT_QUERY_FLAGS) 137 return -EINVAL; 138 139 f = fdget_raw(fd); 140 if (f.file) { 141 error = vfs_getattr(&f.file->f_path, stat, 142 request_mask, query_flags); 143 fdput(f); 144 } 145 return error; 146 } 147 EXPORT_SYMBOL(vfs_statx_fd); 148 149 /** 150 * vfs_statx - Get basic and extra attributes by filename 151 * @dfd: A file descriptor representing the base dir for a relative filename 152 * @filename: The name of the file of interest 153 * @flags: Flags to control the query 154 * @stat: The result structure to fill in. 155 * @request_mask: STATX_xxx flags indicating what the caller wants 156 * 157 * This function is a wrapper around vfs_getattr(). The main difference is 158 * that it uses a filename and base directory to determine the file location. 159 * Additionally, the use of AT_SYMLINK_NOFOLLOW in flags will prevent a symlink 160 * at the given name from being referenced. 161 * 162 * 0 will be returned on success, and a -ve error code if unsuccessful. 163 */ 164 int vfs_statx(int dfd, const char __user *filename, int flags, 165 struct kstat *stat, u32 request_mask) 166 { 167 struct path path; 168 int error = -EINVAL; 169 unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT; 170 171 if ((flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT | 172 AT_EMPTY_PATH | KSTAT_QUERY_FLAGS)) != 0) 173 return -EINVAL; 174 175 if (flags & AT_SYMLINK_NOFOLLOW) 176 lookup_flags &= ~LOOKUP_FOLLOW; 177 if (flags & AT_NO_AUTOMOUNT) 178 lookup_flags &= ~LOOKUP_AUTOMOUNT; 179 if (flags & AT_EMPTY_PATH) 180 lookup_flags |= LOOKUP_EMPTY; 181 182 retry: 183 error = user_path_at(dfd, filename, lookup_flags, &path); 184 if (error) 185 goto out; 186 187 error = vfs_getattr(&path, stat, request_mask, flags); 188 path_put(&path); 189 if (retry_estale(error, lookup_flags)) { 190 lookup_flags |= LOOKUP_REVAL; 191 goto retry; 192 } 193 out: 194 return error; 195 } 196 EXPORT_SYMBOL(vfs_statx); 197 198 199 #ifdef __ARCH_WANT_OLD_STAT 200 201 /* 202 * For backward compatibility? Maybe this should be moved 203 * into arch/i386 instead? 204 */ 205 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf) 206 { 207 static int warncount = 5; 208 struct __old_kernel_stat tmp; 209 210 if (warncount > 0) { 211 warncount--; 212 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n", 213 current->comm); 214 } else if (warncount < 0) { 215 /* it's laughable, but... */ 216 warncount = 0; 217 } 218 219 memset(&tmp, 0, sizeof(struct __old_kernel_stat)); 220 tmp.st_dev = old_encode_dev(stat->dev); 221 tmp.st_ino = stat->ino; 222 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino) 223 return -EOVERFLOW; 224 tmp.st_mode = stat->mode; 225 tmp.st_nlink = stat->nlink; 226 if (tmp.st_nlink != stat->nlink) 227 return -EOVERFLOW; 228 SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid)); 229 SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid)); 230 tmp.st_rdev = old_encode_dev(stat->rdev); 231 #if BITS_PER_LONG == 32 232 if (stat->size > MAX_NON_LFS) 233 return -EOVERFLOW; 234 #endif 235 tmp.st_size = stat->size; 236 tmp.st_atime = stat->atime.tv_sec; 237 tmp.st_mtime = stat->mtime.tv_sec; 238 tmp.st_ctime = stat->ctime.tv_sec; 239 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 240 } 241 242 SYSCALL_DEFINE2(stat, const char __user *, filename, 243 struct __old_kernel_stat __user *, statbuf) 244 { 245 struct kstat stat; 246 int error; 247 248 error = vfs_stat(filename, &stat); 249 if (error) 250 return error; 251 252 return cp_old_stat(&stat, statbuf); 253 } 254 255 SYSCALL_DEFINE2(lstat, const char __user *, filename, 256 struct __old_kernel_stat __user *, statbuf) 257 { 258 struct kstat stat; 259 int error; 260 261 error = vfs_lstat(filename, &stat); 262 if (error) 263 return error; 264 265 return cp_old_stat(&stat, statbuf); 266 } 267 268 SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf) 269 { 270 struct kstat stat; 271 int error = vfs_fstat(fd, &stat); 272 273 if (!error) 274 error = cp_old_stat(&stat, statbuf); 275 276 return error; 277 } 278 279 #endif /* __ARCH_WANT_OLD_STAT */ 280 281 #if BITS_PER_LONG == 32 282 # define choose_32_64(a,b) a 283 #else 284 # define choose_32_64(a,b) b 285 #endif 286 287 #define valid_dev(x) choose_32_64(old_valid_dev(x),true) 288 #define encode_dev(x) choose_32_64(old_encode_dev,new_encode_dev)(x) 289 290 #ifndef INIT_STRUCT_STAT_PADDING 291 # define INIT_STRUCT_STAT_PADDING(st) memset(&st, 0, sizeof(st)) 292 #endif 293 294 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf) 295 { 296 struct stat tmp; 297 298 if (!valid_dev(stat->dev) || !valid_dev(stat->rdev)) 299 return -EOVERFLOW; 300 #if BITS_PER_LONG == 32 301 if (stat->size > MAX_NON_LFS) 302 return -EOVERFLOW; 303 #endif 304 305 INIT_STRUCT_STAT_PADDING(tmp); 306 tmp.st_dev = encode_dev(stat->dev); 307 tmp.st_ino = stat->ino; 308 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino) 309 return -EOVERFLOW; 310 tmp.st_mode = stat->mode; 311 tmp.st_nlink = stat->nlink; 312 if (tmp.st_nlink != stat->nlink) 313 return -EOVERFLOW; 314 SET_UID(tmp.st_uid, from_kuid_munged(current_user_ns(), stat->uid)); 315 SET_GID(tmp.st_gid, from_kgid_munged(current_user_ns(), stat->gid)); 316 tmp.st_rdev = encode_dev(stat->rdev); 317 tmp.st_size = stat->size; 318 tmp.st_atime = stat->atime.tv_sec; 319 tmp.st_mtime = stat->mtime.tv_sec; 320 tmp.st_ctime = stat->ctime.tv_sec; 321 #ifdef STAT_HAVE_NSEC 322 tmp.st_atime_nsec = stat->atime.tv_nsec; 323 tmp.st_mtime_nsec = stat->mtime.tv_nsec; 324 tmp.st_ctime_nsec = stat->ctime.tv_nsec; 325 #endif 326 tmp.st_blocks = stat->blocks; 327 tmp.st_blksize = stat->blksize; 328 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 329 } 330 331 SYSCALL_DEFINE2(newstat, const char __user *, filename, 332 struct stat __user *, statbuf) 333 { 334 struct kstat stat; 335 int error = vfs_stat(filename, &stat); 336 337 if (error) 338 return error; 339 return cp_new_stat(&stat, statbuf); 340 } 341 342 SYSCALL_DEFINE2(newlstat, const char __user *, filename, 343 struct stat __user *, statbuf) 344 { 345 struct kstat stat; 346 int error; 347 348 error = vfs_lstat(filename, &stat); 349 if (error) 350 return error; 351 352 return cp_new_stat(&stat, statbuf); 353 } 354 355 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT) 356 SYSCALL_DEFINE4(newfstatat, int, dfd, const char __user *, filename, 357 struct stat __user *, statbuf, int, flag) 358 { 359 struct kstat stat; 360 int error; 361 362 error = vfs_fstatat(dfd, filename, &stat, flag); 363 if (error) 364 return error; 365 return cp_new_stat(&stat, statbuf); 366 } 367 #endif 368 369 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf) 370 { 371 struct kstat stat; 372 int error = vfs_fstat(fd, &stat); 373 374 if (!error) 375 error = cp_new_stat(&stat, statbuf); 376 377 return error; 378 } 379 380 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname, 381 char __user *, buf, int, bufsiz) 382 { 383 struct path path; 384 int error; 385 int empty = 0; 386 unsigned int lookup_flags = LOOKUP_EMPTY; 387 388 if (bufsiz <= 0) 389 return -EINVAL; 390 391 retry: 392 error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty); 393 if (!error) { 394 struct inode *inode = d_backing_inode(path.dentry); 395 396 error = empty ? -ENOENT : -EINVAL; 397 /* 398 * AFS mountpoints allow readlink(2) but are not symlinks 399 */ 400 if (d_is_symlink(path.dentry) || inode->i_op->readlink) { 401 error = security_inode_readlink(path.dentry); 402 if (!error) { 403 touch_atime(&path); 404 error = vfs_readlink(path.dentry, buf, bufsiz); 405 } 406 } 407 path_put(&path); 408 if (retry_estale(error, lookup_flags)) { 409 lookup_flags |= LOOKUP_REVAL; 410 goto retry; 411 } 412 } 413 return error; 414 } 415 416 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf, 417 int, bufsiz) 418 { 419 return sys_readlinkat(AT_FDCWD, path, buf, bufsiz); 420 } 421 422 423 /* ---------- LFS-64 ----------- */ 424 #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64) 425 426 #ifndef INIT_STRUCT_STAT64_PADDING 427 # define INIT_STRUCT_STAT64_PADDING(st) memset(&st, 0, sizeof(st)) 428 #endif 429 430 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf) 431 { 432 struct stat64 tmp; 433 434 INIT_STRUCT_STAT64_PADDING(tmp); 435 #ifdef CONFIG_MIPS 436 /* mips has weird padding, so we don't get 64 bits there */ 437 tmp.st_dev = new_encode_dev(stat->dev); 438 tmp.st_rdev = new_encode_dev(stat->rdev); 439 #else 440 tmp.st_dev = huge_encode_dev(stat->dev); 441 tmp.st_rdev = huge_encode_dev(stat->rdev); 442 #endif 443 tmp.st_ino = stat->ino; 444 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino) 445 return -EOVERFLOW; 446 #ifdef STAT64_HAS_BROKEN_ST_INO 447 tmp.__st_ino = stat->ino; 448 #endif 449 tmp.st_mode = stat->mode; 450 tmp.st_nlink = stat->nlink; 451 tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid); 452 tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid); 453 tmp.st_atime = stat->atime.tv_sec; 454 tmp.st_atime_nsec = stat->atime.tv_nsec; 455 tmp.st_mtime = stat->mtime.tv_sec; 456 tmp.st_mtime_nsec = stat->mtime.tv_nsec; 457 tmp.st_ctime = stat->ctime.tv_sec; 458 tmp.st_ctime_nsec = stat->ctime.tv_nsec; 459 tmp.st_size = stat->size; 460 tmp.st_blocks = stat->blocks; 461 tmp.st_blksize = stat->blksize; 462 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 463 } 464 465 SYSCALL_DEFINE2(stat64, const char __user *, filename, 466 struct stat64 __user *, statbuf) 467 { 468 struct kstat stat; 469 int error = vfs_stat(filename, &stat); 470 471 if (!error) 472 error = cp_new_stat64(&stat, statbuf); 473 474 return error; 475 } 476 477 SYSCALL_DEFINE2(lstat64, const char __user *, filename, 478 struct stat64 __user *, statbuf) 479 { 480 struct kstat stat; 481 int error = vfs_lstat(filename, &stat); 482 483 if (!error) 484 error = cp_new_stat64(&stat, statbuf); 485 486 return error; 487 } 488 489 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf) 490 { 491 struct kstat stat; 492 int error = vfs_fstat(fd, &stat); 493 494 if (!error) 495 error = cp_new_stat64(&stat, statbuf); 496 497 return error; 498 } 499 500 SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename, 501 struct stat64 __user *, statbuf, int, flag) 502 { 503 struct kstat stat; 504 int error; 505 506 error = vfs_fstatat(dfd, filename, &stat, flag); 507 if (error) 508 return error; 509 return cp_new_stat64(&stat, statbuf); 510 } 511 #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */ 512 513 static noinline_for_stack int 514 cp_statx(const struct kstat *stat, struct statx __user *buffer) 515 { 516 struct statx tmp; 517 518 memset(&tmp, 0, sizeof(tmp)); 519 520 tmp.stx_mask = stat->result_mask; 521 tmp.stx_blksize = stat->blksize; 522 tmp.stx_attributes = stat->attributes; 523 tmp.stx_nlink = stat->nlink; 524 tmp.stx_uid = from_kuid_munged(current_user_ns(), stat->uid); 525 tmp.stx_gid = from_kgid_munged(current_user_ns(), stat->gid); 526 tmp.stx_mode = stat->mode; 527 tmp.stx_ino = stat->ino; 528 tmp.stx_size = stat->size; 529 tmp.stx_blocks = stat->blocks; 530 tmp.stx_attributes_mask = stat->attributes_mask; 531 tmp.stx_atime.tv_sec = stat->atime.tv_sec; 532 tmp.stx_atime.tv_nsec = stat->atime.tv_nsec; 533 tmp.stx_btime.tv_sec = stat->btime.tv_sec; 534 tmp.stx_btime.tv_nsec = stat->btime.tv_nsec; 535 tmp.stx_ctime.tv_sec = stat->ctime.tv_sec; 536 tmp.stx_ctime.tv_nsec = stat->ctime.tv_nsec; 537 tmp.stx_mtime.tv_sec = stat->mtime.tv_sec; 538 tmp.stx_mtime.tv_nsec = stat->mtime.tv_nsec; 539 tmp.stx_rdev_major = MAJOR(stat->rdev); 540 tmp.stx_rdev_minor = MINOR(stat->rdev); 541 tmp.stx_dev_major = MAJOR(stat->dev); 542 tmp.stx_dev_minor = MINOR(stat->dev); 543 544 return copy_to_user(buffer, &tmp, sizeof(tmp)) ? -EFAULT : 0; 545 } 546 547 /** 548 * sys_statx - System call to get enhanced stats 549 * @dfd: Base directory to pathwalk from *or* fd to stat. 550 * @filename: File to stat or "" with AT_EMPTY_PATH 551 * @flags: AT_* flags to control pathwalk. 552 * @mask: Parts of statx struct actually required. 553 * @buffer: Result buffer. 554 * 555 * Note that fstat() can be emulated by setting dfd to the fd of interest, 556 * supplying "" as the filename and setting AT_EMPTY_PATH in the flags. 557 */ 558 SYSCALL_DEFINE5(statx, 559 int, dfd, const char __user *, filename, unsigned, flags, 560 unsigned int, mask, 561 struct statx __user *, buffer) 562 { 563 struct kstat stat; 564 int error; 565 566 if (mask & STATX__RESERVED) 567 return -EINVAL; 568 if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_SYNC_TYPE) 569 return -EINVAL; 570 571 error = vfs_statx(dfd, filename, flags, &stat, mask); 572 if (error) 573 return error; 574 575 return cp_statx(&stat, buffer); 576 } 577 578 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */ 579 void __inode_add_bytes(struct inode *inode, loff_t bytes) 580 { 581 inode->i_blocks += bytes >> 9; 582 bytes &= 511; 583 inode->i_bytes += bytes; 584 if (inode->i_bytes >= 512) { 585 inode->i_blocks++; 586 inode->i_bytes -= 512; 587 } 588 } 589 590 void inode_add_bytes(struct inode *inode, loff_t bytes) 591 { 592 spin_lock(&inode->i_lock); 593 __inode_add_bytes(inode, bytes); 594 spin_unlock(&inode->i_lock); 595 } 596 597 EXPORT_SYMBOL(inode_add_bytes); 598 599 void __inode_sub_bytes(struct inode *inode, loff_t bytes) 600 { 601 inode->i_blocks -= bytes >> 9; 602 bytes &= 511; 603 if (inode->i_bytes < bytes) { 604 inode->i_blocks--; 605 inode->i_bytes += 512; 606 } 607 inode->i_bytes -= bytes; 608 } 609 610 EXPORT_SYMBOL(__inode_sub_bytes); 611 612 void inode_sub_bytes(struct inode *inode, loff_t bytes) 613 { 614 spin_lock(&inode->i_lock); 615 __inode_sub_bytes(inode, bytes); 616 spin_unlock(&inode->i_lock); 617 } 618 619 EXPORT_SYMBOL(inode_sub_bytes); 620 621 loff_t inode_get_bytes(struct inode *inode) 622 { 623 loff_t ret; 624 625 spin_lock(&inode->i_lock); 626 ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes; 627 spin_unlock(&inode->i_lock); 628 return ret; 629 } 630 631 EXPORT_SYMBOL(inode_get_bytes); 632 633 void inode_set_bytes(struct inode *inode, loff_t bytes) 634 { 635 /* Caller is here responsible for sufficient locking 636 * (ie. inode->i_lock) */ 637 inode->i_blocks = bytes >> 9; 638 inode->i_bytes = bytes & 511; 639 } 640 641 EXPORT_SYMBOL(inode_set_bytes); 642