FILE
inode.c
File preview with syntax highlighting.
linux-6.19.14/fs/inode.c
1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * (C) 1997 Linus Torvalds 4 * (C) 1999 Andrea Arcangeli <andrea@suse.de> (dynamic inode allocation) 5 */ 6#include <linux/export.h> 7#include <linux/fs.h> 8#include <linux/filelock.h> 9#include <linux/mm.h> 10#include <linux/backing-dev.h> 11#include <linux/hash.h> 12#include <linux/swap.h> 13#include <linux/security.h> 14#include <linux/cdev.h> 15#include <linux/memblock.h> 16#include <linux/fsnotify.h> 17#include <linux/mount.h> 18#include <linux/posix_acl.h> 19#include <linux/buffer_head.h> /* for inode_has_buffers */ 20#include <linux/ratelimit.h> 21#include <linux/list_lru.h> 22#include <linux/iversion.h> 23#include <linux/rw_hint.h> 24#include <linux/seq_file.h> 25#include <linux/debugfs.h> 26#include <trace/events/writeback.h> 27#define CREATE_TRACE_POINTS 28#include <trace/events/timestamp.h> 29 30#include "internal.h" 31 32/* 33 * Inode locking rules: 34 * 35 * inode->i_lock protects: 36 * inode->i_state, inode->i_hash, __iget(), inode->i_io_list 37 * Inode LRU list locks protect: 38 * inode->i_sb->s_inode_lru, inode->i_lru 39 * inode->i_sb->s_inode_list_lock protects: 40 * inode->i_sb->s_inodes, inode->i_sb_list 41 * bdi->wb.list_lock protects: 42 * bdi->wb.b_{dirty,io,more_io,dirty_time}, inode->i_io_list 43 * inode_hash_lock protects: 44 * inode_hashtable, inode->i_hash 45 * 46 * Lock ordering: 47 * 48 * inode->i_sb->s_inode_list_lock 49 * inode->i_lock 50 * Inode LRU list locks 51 * 52 * bdi->wb.list_lock 53 * inode->i_lock 54 * 55 * inode_hash_lock 56 * inode->i_sb->s_inode_list_lock 57 * inode->i_lock 58 * 59 * iunique_lock 60 * inode_hash_lock 61 */ 62 63static unsigned int i_hash_mask __ro_after_init; 64static unsigned int i_hash_shift __ro_after_init; 65static struct hlist_head *inode_hashtable __ro_after_init; 66static __cacheline_aligned_in_smp DEFINE_SPINLOCK(inode_hash_lock); 67 68/* 69 * Empty aops. Can be used for the cases where the user does not 70 * define any of the address_space operations. 71 */ 72const struct address_space_operations empty_aops = { 73}; 74EXPORT_SYMBOL(empty_aops); 75 76static DEFINE_PER_CPU(unsigned long, nr_inodes); 77static DEFINE_PER_CPU(unsigned long, nr_unused); 78 79static struct kmem_cache *inode_cachep __ro_after_init; 80 81static long get_nr_inodes(void) 82{ 83 int i; 84 long sum = 0; 85 for_each_possible_cpu(i) 86 sum += per_cpu(nr_inodes, i); 87 return sum < 0 ? 0 : sum; 88} 89 90static inline long get_nr_inodes_unused(void) 91{ 92 int i; 93 long sum = 0; 94 for_each_possible_cpu(i) 95 sum += per_cpu(nr_unused, i); 96 return sum < 0 ? 0 : sum; 97} 98 99long get_nr_dirty_inodes(void) 100{ 101 /* not actually dirty inodes, but a wild approximation */ 102 long nr_dirty = get_nr_inodes() - get_nr_inodes_unused(); 103 return nr_dirty > 0 ? nr_dirty : 0; 104} 105 106#ifdef CONFIG_DEBUG_FS 107static DEFINE_PER_CPU(long, mg_ctime_updates); 108static DEFINE_PER_CPU(long, mg_fine_stamps); 109static DEFINE_PER_CPU(long, mg_ctime_swaps); 110 111static unsigned long get_mg_ctime_updates(void) 112{ 113 unsigned long sum = 0; 114 int i; 115 116 for_each_possible_cpu(i) 117 sum += data_race(per_cpu(mg_ctime_updates, i)); 118 return sum; 119} 120 121static unsigned long get_mg_fine_stamps(void) 122{ 123 unsigned long sum = 0; 124 int i; 125 126 for_each_possible_cpu(i) 127 sum += data_race(per_cpu(mg_fine_stamps, i)); 128 return sum; 129} 130 131static unsigned long get_mg_ctime_swaps(void) 132{ 133 unsigned long sum = 0; 134 int i; 135 136 for_each_possible_cpu(i) 137 sum += data_race(per_cpu(mg_ctime_swaps, i)); 138 return sum; 139} 140 141#define mgtime_counter_inc(__var) this_cpu_inc(__var) 142 143static int mgts_show(struct seq_file *s, void *p) 144{ 145 unsigned long ctime_updates = get_mg_ctime_updates(); 146 unsigned long ctime_swaps = get_mg_ctime_swaps(); 147 unsigned long fine_stamps = get_mg_fine_stamps(); 148 unsigned long floor_swaps = timekeeping_get_mg_floor_swaps(); 149 150 seq_printf(s, "%lu %lu %lu %lu\n", 151 ctime_updates, ctime_swaps, fine_stamps, floor_swaps); 152 return 0; 153} 154 155DEFINE_SHOW_ATTRIBUTE(mgts); 156 157static int __init mg_debugfs_init(void) 158{ 159 debugfs_create_file("multigrain_timestamps", S_IFREG | S_IRUGO, NULL, NULL, &mgts_fops); 160 return 0; 161} 162late_initcall(mg_debugfs_init); 163 164#else /* ! CONFIG_DEBUG_FS */ 165 166#define mgtime_counter_inc(__var) do { } while (0) 167 168#endif /* CONFIG_DEBUG_FS */ 169 170/* 171 * Handle nr_inode sysctl 172 */ 173#ifdef CONFIG_SYSCTL 174/* 175 * Statistics gathering.. 176 */ 177static struct inodes_stat_t inodes_stat; 178 179static int proc_nr_inodes(const struct ctl_table *table, int write, void *buffer, 180 size_t *lenp, loff_t *ppos) 181{ 182 inodes_stat.nr_inodes = get_nr_inodes(); 183 inodes_stat.nr_unused = get_nr_inodes_unused(); 184 return proc_doulongvec_minmax(table, write, buffer, lenp, ppos); 185} 186 187static const struct ctl_table inodes_sysctls[] = { 188 { 189 .procname = "inode-nr", 190 .data = &inodes_stat, 191 .maxlen = 2*sizeof(long), 192 .mode = 0444, 193 .proc_handler = proc_nr_inodes, 194 }, 195 { 196 .procname = "inode-state", 197 .data = &inodes_stat, 198 .maxlen = 7*sizeof(long), 199 .mode = 0444, 200 .proc_handler = proc_nr_inodes, 201 }, 202}; 203 204static int __init init_fs_inode_sysctls(void) 205{ 206 register_sysctl_init("fs", inodes_sysctls); 207 return 0; 208} 209early_initcall(init_fs_inode_sysctls); 210#endif 211 212static int no_open(struct inode *inode, struct file *file) 213{ 214 return -ENXIO; 215} 216 217/** 218 * inode_init_always_gfp - perform inode structure initialisation 219 * @sb: superblock inode belongs to 220 * @inode: inode to initialise 221 * @gfp: allocation flags 222 * 223 * These are initializations that need to be done on every inode 224 * allocation as the fields are not initialised by slab allocation. 225 * If there are additional allocations required @gfp is used. 226 */ 227int inode_init_always_gfp(struct super_block *sb, struct inode *inode, gfp_t gfp) 228{ 229 static const struct inode_operations empty_iops; 230 static const struct file_operations no_open_fops = {.open = no_open}; 231 struct address_space *const mapping = &inode->i_data; 232 233 inode->i_sb = sb; 234 inode->i_blkbits = sb->s_blocksize_bits; 235 inode->i_flags = 0; 236 inode_state_assign_raw(inode, 0); 237 atomic64_set(&inode->i_sequence, 0); 238 atomic_set(&inode->i_count, 1); 239 inode->i_op = &empty_iops; 240 inode->i_fop = &no_open_fops; 241 inode->i_ino = 0; 242 inode->__i_nlink = 1; 243 inode->i_opflags = 0; 244 if (sb->s_xattr) 245 inode->i_opflags |= IOP_XATTR; 246 if (sb->s_type->fs_flags & FS_MGTIME) 247 inode->i_opflags |= IOP_MGTIME; 248 i_uid_write(inode, 0); 249 i_gid_write(inode, 0); 250 atomic_set(&inode->i_writecount, 0); 251 inode->i_size = 0; 252 inode->i_write_hint = WRITE_LIFE_NOT_SET; 253 inode->i_blocks = 0; 254 inode->i_bytes = 0; 255 inode->i_generation = 0; 256 inode->i_pipe = NULL; 257 inode->i_cdev = NULL; 258 inode->i_link = NULL; 259 inode->i_dir_seq = 0; 260 inode->i_rdev = 0; 261 inode->dirtied_when = 0; 262 263#ifdef CONFIG_CGROUP_WRITEBACK 264 inode->i_wb_frn_winner = 0; 265 inode->i_wb_frn_avg_time = 0; 266 inode->i_wb_frn_history = 0; 267#endif 268 269 spin_lock_init(&inode->i_lock); 270 lockdep_set_class(&inode->i_lock, &sb->s_type->i_lock_key); 271 272 init_rwsem(&inode->i_rwsem); 273 lockdep_set_class(&inode->i_rwsem, &sb->s_type->i_mutex_key); 274 275 atomic_set(&inode->i_dio_count, 0); 276 277 mapping->a_ops = &empty_aops; 278 mapping->host = inode; 279 mapping->flags = 0; 280 mapping->wb_err = 0; 281 atomic_set(&mapping->i_mmap_writable, 0); 282#ifdef CONFIG_READ_ONLY_THP_FOR_FS 283 atomic_set(&mapping->nr_thps, 0); 284#endif 285 mapping_set_gfp_mask(mapping, GFP_HIGHUSER_MOVABLE); 286 mapping->i_private_data = NULL; 287 mapping->writeback_index = 0; 288 init_rwsem(&mapping->invalidate_lock); 289 lockdep_set_class_and_name(&mapping->invalidate_lock, 290 &sb->s_type->invalidate_lock_key, 291 "mapping.invalidate_lock"); 292 if (sb->s_iflags & SB_I_STABLE_WRITES) 293 mapping_set_stable_writes(mapping); 294 inode->i_private = NULL; 295 inode->i_mapping = mapping; 296 INIT_HLIST_HEAD(&inode->i_dentry); /* buggered by rcu freeing */ 297#ifdef CONFIG_FS_POSIX_ACL 298 inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED; 299#endif 300 301#ifdef CONFIG_FSNOTIFY 302 inode->i_fsnotify_mask = 0; 303#endif 304 inode->i_flctx = NULL; 305 306 if (unlikely(security_inode_alloc(inode, gfp))) 307 return -ENOMEM; 308 309 this_cpu_inc(nr_inodes); 310 311 return 0; 312} 313EXPORT_SYMBOL(inode_init_always_gfp); 314 315void free_inode_nonrcu(struct inode *inode) 316{ 317 kmem_cache_free(inode_cachep, inode); 318} 319EXPORT_SYMBOL(free_inode_nonrcu); 320 321static void i_callback(struct rcu_head *head) 322{ 323 struct inode *inode = container_of(head, struct inode, i_rcu); 324 if (inode->free_inode) 325 inode->free_inode(inode); 326 else 327 free_inode_nonrcu(inode); 328} 329 330/** 331 * alloc_inode - obtain an inode 332 * @sb: superblock 333 * 334 * Allocates a new inode for given superblock. 335 * Inode wont be chained in superblock s_inodes list 336 * This means : 337 * - fs can't be unmount 338 * - quotas, fsnotify, writeback can't work 339 */ 340struct inode *alloc_inode(struct super_block *sb) 341{ 342 const struct super_operations *ops = sb->s_op; 343 struct inode *inode; 344 345 if (ops->alloc_inode) 346 inode = ops->alloc_inode(sb); 347 else 348 inode = alloc_inode_sb(sb, inode_cachep, GFP_KERNEL); 349 350 if (!inode) 351 return NULL; 352 353 if (unlikely(inode_init_always(sb, inode))) { 354 if (ops->destroy_inode) { 355 ops->destroy_inode(inode); 356 if (!ops->free_inode) 357 return NULL; 358 } 359 inode->free_inode = ops->free_inode; 360 i_callback(&inode->i_rcu); 361 return NULL; 362 } 363 364 return inode; 365} 366 367void __destroy_inode(struct inode *inode) 368{ 369 BUG_ON(inode_has_buffers(inode)); 370 inode_detach_wb(inode); 371 security_inode_free(inode); 372 fsnotify_inode_delete(inode); 373 locks_free_lock_context(inode); 374 if (!inode->i_nlink) { 375 WARN_ON(atomic_long_read(&inode->i_sb->s_remove_count) == 0); 376 atomic_long_dec(&inode->i_sb->s_remove_count); 377 } 378 379#ifdef CONFIG_FS_POSIX_ACL 380 if (inode->i_acl && !is_uncached_acl(inode->i_acl)) 381 posix_acl_release(inode->i_acl); 382 if (inode->i_default_acl && !is_uncached_acl(inode->i_default_acl)) 383 posix_acl_release(inode->i_default_acl); 384#endif 385 this_cpu_dec(nr_inodes); 386} 387EXPORT_SYMBOL(__destroy_inode); 388 389static void destroy_inode(struct inode *inode) 390{ 391 const struct super_operations *ops = inode->i_sb->s_op; 392 393 BUG_ON(!list_empty(&inode->i_lru)); 394 __destroy_inode(inode); 395 if (ops->destroy_inode) { 396 ops->destroy_inode(inode); 397 if (!ops->free_inode) 398 return; 399 } 400 inode->free_inode = ops->free_inode; 401 call_rcu(&inode->i_rcu, i_callback); 402} 403 404/** 405 * drop_nlink - directly drop an inode's link count 406 * @inode: inode 407 * 408 * This is a low-level filesystem helper to replace any 409 * direct filesystem manipulation of i_nlink. In cases 410 * where we are attempting to track writes to the 411 * filesystem, a decrement to zero means an imminent 412 * write when the file is truncated and actually unlinked 413 * on the filesystem. 414 */ 415void drop_nlink(struct inode *inode) 416{ 417 WARN_ON(inode->i_nlink == 0); 418 inode->__i_nlink--; 419 if (!inode->i_nlink) 420 atomic_long_inc(&inode->i_sb->s_remove_count); 421} 422EXPORT_SYMBOL(drop_nlink); 423 424/** 425 * clear_nlink - directly zero an inode's link count 426 * @inode: inode 427 * 428 * This is a low-level filesystem helper to replace any 429 * direct filesystem manipulation of i_nlink. See 430 * drop_nlink() for why we care about i_nlink hitting zero. 431 */ 432void clear_nlink(struct inode *inode) 433{ 434 if (inode->i_nlink) { 435 inode->__i_nlink = 0; 436 atomic_long_inc(&inode->i_sb->s_remove_count); 437 } 438} 439EXPORT_SYMBOL(clear_nlink); 440 441/** 442 * set_nlink - directly set an inode's link count 443 * @inode: inode 444 * @nlink: new nlink (should be non-zero) 445 * 446 * This is a low-level filesystem helper to replace any 447 * direct filesystem manipulation of i_nlink. 448 */ 449void set_nlink(struct inode *inode, unsigned int nlink) 450{ 451 if (!nlink) { 452 clear_nlink(inode); 453 } else { 454 /* Yes, some filesystems do change nlink from zero to one */ 455 if (inode->i_nlink == 0) 456 atomic_long_dec(&inode->i_sb->s_remove_count); 457 458 inode->__i_nlink = nlink; 459 } 460} 461EXPORT_SYMBOL(set_nlink); 462 463/** 464 * inc_nlink - directly increment an inode's link count 465 * @inode: inode 466 * 467 * This is a low-level filesystem helper to replace any 468 * direct filesystem manipulation of i_nlink. Currently, 469 * it is only here for parity with dec_nlink(). 470 */ 471void inc_nlink(struct inode *inode) 472{ 473 if (unlikely(inode->i_nlink == 0)) { 474 WARN_ON(!(inode_state_read_once(inode) & I_LINKABLE)); 475 atomic_long_dec(&inode->i_sb->s_remove_count); 476 } 477 478 inode->__i_nlink++; 479} 480EXPORT_SYMBOL(inc_nlink); 481 482static void __address_space_init_once(struct address_space *mapping) 483{ 484 xa_init_flags(&mapping->i_pages, XA_FLAGS_LOCK_IRQ | XA_FLAGS_ACCOUNT); 485 init_rwsem(&mapping->i_mmap_rwsem); 486 INIT_LIST_HEAD(&mapping->i_private_list); 487 spin_lock_init(&mapping->i_private_lock); 488 mapping->i_mmap = RB_ROOT_CACHED; 489} 490 491void address_space_init_once(struct address_space *mapping) 492{ 493 memset(mapping, 0, sizeof(*mapping)); 494 __address_space_init_once(mapping); 495} 496EXPORT_SYMBOL(address_space_init_once); 497 498/* 499 * These are initializations that only need to be done 500 * once, because the fields are idempotent across use 501 * of the inode, so let the slab aware of that. 502 */ 503void inode_init_once(struct inode *inode) 504{ 505 memset(inode, 0, sizeof(*inode)); 506 INIT_HLIST_NODE(&inode->i_hash); 507 INIT_LIST_HEAD(&inode->i_devices); 508 INIT_LIST_HEAD(&inode->i_io_list); 509 INIT_LIST_HEAD(&inode->i_wb_list); 510 INIT_LIST_HEAD(&inode->i_lru); 511 INIT_LIST_HEAD(&inode->i_sb_list); 512 __address_space_init_once(&inode->i_data); 513 i_size_ordered_init(inode); 514} 515EXPORT_SYMBOL(inode_init_once); 516 517static void init_once(void *foo) 518{ 519 struct inode *inode = (struct inode *) foo; 520 521 inode_init_once(inode); 522} 523 524/* 525 * get additional reference to inode; caller must already hold one. 526 */ 527void ihold(struct inode *inode) 528{ 529 WARN_ON(atomic_inc_return(&inode->i_count) < 2); 530} 531EXPORT_SYMBOL(ihold); 532 533struct wait_queue_head *inode_bit_waitqueue(struct wait_bit_queue_entry *wqe, 534 struct inode *inode, u32 bit) 535{ 536 void *bit_address; 537 538 bit_address = inode_state_wait_address(inode, bit); 539 init_wait_var_entry(wqe, bit_address, 0); 540 return __var_waitqueue(bit_address); 541} 542EXPORT_SYMBOL(inode_bit_waitqueue); 543 544void wait_on_new_inode(struct inode *inode) 545{ 546 struct wait_bit_queue_entry wqe; 547 struct wait_queue_head *wq_head; 548 549 spin_lock(&inode->i_lock); 550 if (!(inode_state_read(inode) & I_NEW)) { 551 spin_unlock(&inode->i_lock); 552 return; 553 } 554 555 wq_head = inode_bit_waitqueue(&wqe, inode, __I_NEW); 556 for (;;) { 557 prepare_to_wait_event(wq_head, &wqe.wq_entry, TASK_UNINTERRUPTIBLE); 558 if (!(inode_state_read(inode) & I_NEW)) 559 break; 560 spin_unlock(&inode->i_lock); 561 schedule(); 562 spin_lock(&inode->i_lock); 563 } 564 finish_wait(wq_head, &wqe.wq_entry); 565 WARN_ON(inode_state_read(inode) & I_NEW); 566 spin_unlock(&inode->i_lock); 567} 568EXPORT_SYMBOL(wait_on_new_inode); 569 570static void __inode_lru_list_add(struct inode *inode, bool rotate) 571{ 572 lockdep_assert_held(&inode->i_lock); 573 574 if (inode_state_read(inode) & (I_DIRTY_ALL | I_SYNC | I_FREEING | I_WILL_FREE)) 575 return; 576 if (icount_read(inode)) 577 return; 578 if (!(inode->i_sb->s_flags & SB_ACTIVE)) 579 return; 580 if (!mapping_shrinkable(&inode->i_data)) 581 return; 582 583 if (list_lru_add_obj(&inode->i_sb->s_inode_lru, &inode->i_lru)) 584 this_cpu_inc(nr_unused); 585 else if (rotate) 586 inode_state_set(inode, I_REFERENCED); 587} 588 589/* 590 * Add inode to LRU if needed (inode is unused and clean). 591 */ 592void inode_lru_list_add(struct inode *inode) 593{ 594 __inode_lru_list_add(inode, false); 595} 596 597static void inode_lru_list_del(struct inode *inode) 598{ 599 if (list_empty(&inode->i_lru)) 600 return; 601 602 if (list_lru_del_obj(&inode->i_sb->s_inode_lru, &inode->i_lru)) 603 this_cpu_dec(nr_unused); 604} 605 606static void inode_pin_lru_isolating(struct inode *inode) 607{ 608 lockdep_assert_held(&inode->i_lock); 609 WARN_ON(inode_state_read(inode) & (I_LRU_ISOLATING | I_FREEING | I_WILL_FREE)); 610 inode_state_set(inode, I_LRU_ISOLATING); 611} 612 613static void inode_unpin_lru_isolating(struct inode *inode) 614{ 615 spin_lock(&inode->i_lock); 616 WARN_ON(!(inode_state_read(inode) & I_LRU_ISOLATING)); 617 inode_state_clear(inode, I_LRU_ISOLATING); 618 /* Called with inode->i_lock which ensures memory ordering. */ 619 inode_wake_up_bit(inode, __I_LRU_ISOLATING); 620 spin_unlock(&inode->i_lock); 621} 622 623static void inode_wait_for_lru_isolating(struct inode *inode) 624{ 625 struct wait_bit_queue_entry wqe; 626 struct wait_queue_head *wq_head; 627 628 lockdep_assert_held(&inode->i_lock); 629 if (!(inode_state_read(inode) & I_LRU_ISOLATING)) 630 return; 631 632 wq_head = inode_bit_waitqueue(&wqe, inode, __I_LRU_ISOLATING); 633 for (;;) { 634 prepare_to_wait_event(wq_head, &wqe.wq_entry, TASK_UNINTERRUPTIBLE); 635 /* 636 * Checking I_LRU_ISOLATING with inode->i_lock guarantees 637 * memory ordering. 638 */ 639 if (!(inode_state_read(inode) & I_LRU_ISOLATING)) 640 break; 641 spin_unlock(&inode->i_lock); 642 schedule(); 643 spin_lock(&inode->i_lock); 644 } 645 finish_wait(wq_head, &wqe.wq_entry); 646 WARN_ON(inode_state_read(inode) & I_LRU_ISOLATING); 647} 648 649/** 650 * inode_sb_list_add - add inode to the superblock list of inodes 651 * @inode: inode to add 652 */ 653void inode_sb_list_add(struct inode *inode) 654{ 655 struct super_block *sb = inode->i_sb; 656 657 spin_lock(&sb->s_inode_list_lock); 658 list_add(&inode->i_sb_list, &sb->s_inodes); 659 spin_unlock(&sb->s_inode_list_lock); 660} 661EXPORT_SYMBOL_GPL(inode_sb_list_add); 662 663static inline void inode_sb_list_del(struct inode *inode) 664{ 665 struct super_block *sb = inode->i_sb; 666 667 if (!list_empty(&inode->i_sb_list)) { 668 spin_lock(&sb->s_inode_list_lock); 669 list_del_init(&inode->i_sb_list); 670 spin_unlock(&sb->s_inode_list_lock); 671 } 672} 673 674static unsigned long hash(struct super_block *sb, unsigned long hashval) 675{ 676 unsigned long tmp; 677 678 tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) / 679 L1_CACHE_BYTES; 680 tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> i_hash_shift); 681 return tmp & i_hash_mask; 682} 683 684/** 685 * __insert_inode_hash - hash an inode 686 * @inode: unhashed inode 687 * @hashval: unsigned long value used to locate this object in the 688 * inode_hashtable. 689 * 690 * Add an inode to the inode hash for this superblock. 691 */ 692void __insert_inode_hash(struct inode *inode, unsigned long hashval) 693{ 694 struct hlist_head *b = inode_hashtable + hash(inode->i_sb, hashval); 695 696 spin_lock(&inode_hash_lock); 697 spin_lock(&inode->i_lock); 698 hlist_add_head_rcu(&inode->i_hash, b); 699 spin_unlock(&inode->i_lock); 700 spin_unlock(&inode_hash_lock); 701} 702EXPORT_SYMBOL(__insert_inode_hash); 703 704/** 705 * __remove_inode_hash - remove an inode from the hash 706 * @inode: inode to unhash 707 * 708 * Remove an inode from the superblock. 709 */ 710void __remove_inode_hash(struct inode *inode) 711{ 712 spin_lock(&inode_hash_lock); 713 spin_lock(&inode->i_lock); 714 hlist_del_init_rcu(&inode->i_hash); 715 spin_unlock(&inode->i_lock); 716 spin_unlock(&inode_hash_lock); 717} 718EXPORT_SYMBOL(__remove_inode_hash); 719 720void dump_mapping(const struct address_space *mapping) 721{ 722 struct inode *host; 723 const struct address_space_operations *a_ops; 724 struct hlist_node *dentry_first; 725 struct dentry *dentry_ptr; 726 struct dentry dentry; 727 char fname[64] = {}; 728 unsigned long ino; 729 730 /* 731 * If mapping is an invalid pointer, we don't want to crash 732 * accessing it, so probe everything depending on it carefully. 733 */ 734 if (get_kernel_nofault(host, &mapping->host) || 735 get_kernel_nofault(a_ops, &mapping->a_ops)) { 736 pr_warn("invalid mapping:%px\n", mapping); 737 return; 738 } 739 740 if (!host) { 741 pr_warn("aops:%ps\n", a_ops); 742 return; 743 } 744 745 if (get_kernel_nofault(dentry_first, &host->i_dentry.first) || 746 get_kernel_nofault(ino, &host->i_ino)) { 747 pr_warn("aops:%ps invalid inode:%px\n", a_ops, host); 748 return; 749 } 750 751 if (!dentry_first) { 752 pr_warn("aops:%ps ino:%lx\n", a_ops, ino); 753 return; 754 } 755 756 dentry_ptr = container_of(dentry_first, struct dentry, d_u.d_alias); 757 if (get_kernel_nofault(dentry, dentry_ptr) || 758 !dentry.d_parent || !dentry.d_name.name) { 759 pr_warn("aops:%ps ino:%lx invalid dentry:%px\n", 760 a_ops, ino, dentry_ptr); 761 return; 762 } 763 764 if (strncpy_from_kernel_nofault(fname, dentry.d_name.name, 63) < 0) 765 strscpy(fname, "<invalid>"); 766 /* 767 * Even if strncpy_from_kernel_nofault() succeeded, 768 * the fname could be unreliable 769 */ 770 pr_warn("aops:%ps ino:%lx dentry name(?):\"%s\"\n", 771 a_ops, ino, fname); 772} 773 774void clear_inode(struct inode *inode) 775{ 776 /* 777 * We have to cycle the i_pages lock here because reclaim can be in the 778 * process of removing the last page (in __filemap_remove_folio()) 779 * and we must not free the mapping under it. 780 */ 781 xa_lock_irq(&inode->i_data.i_pages); 782 BUG_ON(inode->i_data.nrpages); 783 /* 784 * Almost always, mapping_empty(&inode->i_data) here; but there are 785 * two known and long-standing ways in which nodes may get left behind 786 * (when deep radix-tree node allocation failed partway; or when THP 787 * collapse_file() failed). Until those two known cases are cleaned up, 788 * or a cleanup function is called here, do not BUG_ON(!mapping_empty), 789 * nor even WARN_ON(!mapping_empty). 790 */ 791 xa_unlock_irq(&inode->i_data.i_pages); 792 BUG_ON(!list_empty(&inode->i_data.i_private_list)); 793 BUG_ON(!(inode_state_read_once(inode) & I_FREEING)); 794 BUG_ON(inode_state_read_once(inode) & I_CLEAR); 795 BUG_ON(!list_empty(&inode->i_wb_list)); 796 /* don't need i_lock here, no concurrent mods to i_state */ 797 inode_state_assign_raw(inode, I_FREEING | I_CLEAR); 798} 799EXPORT_SYMBOL(clear_inode); 800 801/* 802 * Free the inode passed in, removing it from the lists it is still connected 803 * to. We remove any pages still attached to the inode and wait for any IO that 804 * is still in progress before finally destroying the inode. 805 * 806 * An inode must already be marked I_FREEING so that we avoid the inode being 807 * moved back onto lists if we race with other code that manipulates the lists 808 * (e.g. writeback_single_inode). The caller is responsible for setting this. 809 * 810 * An inode must already be removed from the LRU list before being evicted from 811 * the cache. This should occur atomically with setting the I_FREEING state 812 * flag, so no inodes here should ever be on the LRU when being evicted. 813 */ 814static void evict(struct inode *inode) 815{ 816 const struct super_operations *op = inode->i_sb->s_op; 817 818 BUG_ON(!(inode_state_read_once(inode) & I_FREEING)); 819 BUG_ON(!list_empty(&inode->i_lru)); 820 821 inode_io_list_del(inode); 822 inode_sb_list_del(inode); 823 824 spin_lock(&inode->i_lock); 825 inode_wait_for_lru_isolating(inode); 826 827 /* 828 * Wait for flusher thread to be done with the inode so that filesystem 829 * does not start destroying it while writeback is still running. Since 830 * the inode has I_FREEING set, flusher thread won't start new work on 831 * the inode. We just have to wait for running writeback to finish. 832 */ 833 inode_wait_for_writeback(inode); 834 spin_unlock(&inode->i_lock); 835 836 if (op->evict_inode) { 837 op->evict_inode(inode); 838 } else { 839 truncate_inode_pages_final(&inode->i_data); 840 clear_inode(inode); 841 } 842 if (S_ISCHR(inode->i_mode) && inode->i_cdev) 843 cd_forget(inode); 844 845 remove_inode_hash(inode); 846 847 /* 848 * Wake up waiters in __wait_on_freeing_inode(). 849 * 850 * It is an invariant that any thread we need to wake up is already 851 * accounted for before remove_inode_hash() acquires ->i_lock -- both 852 * sides take the lock and sleep is aborted if the inode is found 853 * unhashed. Thus either the sleeper wins and goes off CPU, or removal 854 * wins and the sleeper aborts after testing with the lock. 855 * 856 * This also means we don't need any fences for the call below. 857 */ 858 inode_wake_up_bit(inode, __I_NEW); 859 BUG_ON(inode_state_read_once(inode) != (I_FREEING | I_CLEAR)); 860 861 destroy_inode(inode); 862} 863 864/* 865 * dispose_list - dispose of the contents of a local list 866 * @head: the head of the list to free 867 * 868 * Dispose-list gets a local list with local inodes in it, so it doesn't 869 * need to worry about list corruption and SMP locks. 870 */ 871static void dispose_list(struct list_head *head) 872{ 873 while (!list_empty(head)) { 874 struct inode *inode; 875 876 inode = list_first_entry(head, struct inode, i_lru); 877 list_del_init(&inode->i_lru); 878 879 evict(inode); 880 cond_resched(); 881 } 882} 883 884/** 885 * evict_inodes - evict all evictable inodes for a superblock 886 * @sb: superblock to operate on 887 * 888 * Make sure that no inodes with zero refcount are retained. This is 889 * called by superblock shutdown after having SB_ACTIVE flag removed, 890 * so any inode reaching zero refcount during or after that call will 891 * be immediately evicted. 892 */ 893void evict_inodes(struct super_block *sb) 894{ 895 struct inode *inode; 896 LIST_HEAD(dispose); 897 898again: 899 spin_lock(&sb->s_inode_list_lock); 900 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 901 if (icount_read(inode)) 902 continue; 903 904 spin_lock(&inode->i_lock); 905 if (icount_read(inode)) { 906 spin_unlock(&inode->i_lock); 907 continue; 908 } 909 if (inode_state_read(inode) & (I_NEW | I_FREEING | I_WILL_FREE)) { 910 spin_unlock(&inode->i_lock); 911 continue; 912 } 913 914 inode_state_set(inode, I_FREEING); 915 inode_lru_list_del(inode); 916 spin_unlock(&inode->i_lock); 917 list_add(&inode->i_lru, &dispose); 918 919 /* 920 * We can have a ton of inodes to evict at unmount time given 921 * enough memory, check to see if we need to go to sleep for a 922 * bit so we don't livelock. 923 */ 924 if (need_resched()) { 925 spin_unlock(&sb->s_inode_list_lock); 926 cond_resched(); 927 dispose_list(&dispose); 928 goto again; 929 } 930 } 931 spin_unlock(&sb->s_inode_list_lock); 932 933 dispose_list(&dispose); 934} 935EXPORT_SYMBOL_GPL(evict_inodes); 936 937/* 938 * Isolate the inode from the LRU in preparation for freeing it. 939 * 940 * If the inode has the I_REFERENCED flag set, then it means that it has been 941 * used recently - the flag is set in iput_final(). When we encounter such an 942 * inode, clear the flag and move it to the back of the LRU so it gets another 943 * pass through the LRU before it gets reclaimed. This is necessary because of 944 * the fact we are doing lazy LRU updates to minimise lock contention so the 945 * LRU does not have strict ordering. Hence we don't want to reclaim inodes 946 * with this flag set because they are the inodes that are out of order. 947 */ 948static enum lru_status inode_lru_isolate(struct list_head *item, 949 struct list_lru_one *lru, void *arg) 950{ 951 struct list_head *freeable = arg; 952 struct inode *inode = container_of(item, struct inode, i_lru); 953 954 /* 955 * We are inverting the lru lock/inode->i_lock here, so use a 956 * trylock. If we fail to get the lock, just skip it. 957 */ 958 if (!spin_trylock(&inode->i_lock)) 959 return LRU_SKIP; 960 961 /* 962 * Inodes can get referenced, redirtied, or repopulated while 963 * they're already on the LRU, and this can make them 964 * unreclaimable for a while. Remove them lazily here; iput, 965 * sync, or the last page cache deletion will requeue them. 966 */ 967 if (icount_read(inode) || 968 (inode_state_read(inode) & ~I_REFERENCED) || 969 !mapping_shrinkable(&inode->i_data)) { 970 list_lru_isolate(lru, &inode->i_lru); 971 spin_unlock(&inode->i_lock); 972 this_cpu_dec(nr_unused); 973 return LRU_REMOVED; 974 } 975 976 /* Recently referenced inodes get one more pass */ 977 if (inode_state_read(inode) & I_REFERENCED) { 978 inode_state_clear(inode, I_REFERENCED); 979 spin_unlock(&inode->i_lock); 980 return LRU_ROTATE; 981 } 982 983 /* 984 * On highmem systems, mapping_shrinkable() permits dropping 985 * page cache in order to free up struct inodes: lowmem might 986 * be under pressure before the cache inside the highmem zone. 987 */ 988 if (inode_has_buffers(inode) || !mapping_empty(&inode->i_data)) { 989 inode_pin_lru_isolating(inode); 990 spin_unlock(&inode->i_lock); 991 spin_unlock(&lru->lock); 992 if (remove_inode_buffers(inode)) { 993 unsigned long reap; 994 reap = invalidate_mapping_pages(&inode->i_data, 0, -1); 995 if (current_is_kswapd()) 996 __count_vm_events(KSWAPD_INODESTEAL, reap); 997 else 998 __count_vm_events(PGINODESTEAL, reap); 999 mm_account_reclaimed_pages(reap); 1000 } 1001 inode_unpin_lru_isolating(inode); 1002 return LRU_RETRY; 1003 } 1004 1005 WARN_ON(inode_state_read(inode) & I_NEW); 1006 inode_state_set(inode, I_FREEING); 1007 list_lru_isolate_move(lru, &inode->i_lru, freeable); 1008 spin_unlock(&inode->i_lock); 1009 1010 this_cpu_dec(nr_unused); 1011 return LRU_REMOVED; 1012} 1013 1014/* 1015 * Walk the superblock inode LRU for freeable inodes and attempt to free them. 1016 * This is called from the superblock shrinker function with a number of inodes 1017 * to trim from the LRU. Inodes to be freed are moved to a temporary list and 1018 * then are freed outside inode_lock by dispose_list(). 1019 */ 1020long prune_icache_sb(struct super_block *sb, struct shrink_control *sc) 1021{ 1022 LIST_HEAD(freeable); 1023 long freed; 1024 1025 freed = list_lru_shrink_walk(&sb->s_inode_lru, sc, 1026 inode_lru_isolate, &freeable); 1027 dispose_list(&freeable); 1028 return freed; 1029} 1030 1031static void __wait_on_freeing_inode(struct inode *inode, bool is_inode_hash_locked); 1032/* 1033 * Called with the inode lock held. 1034 */ 1035static struct inode *find_inode(struct super_block *sb, 1036 struct hlist_head *head, 1037 int (*test)(struct inode *, void *), 1038 void *data, bool is_inode_hash_locked, 1039 bool *isnew) 1040{ 1041 struct inode *inode = NULL; 1042 1043 if (is_inode_hash_locked) 1044 lockdep_assert_held(&inode_hash_lock); 1045 else 1046 lockdep_assert_not_held(&inode_hash_lock); 1047 1048 rcu_read_lock(); 1049repeat: 1050 hlist_for_each_entry_rcu(inode, head, i_hash) { 1051 if (inode->i_sb != sb) 1052 continue; 1053 if (!test(inode, data)) 1054 continue; 1055 spin_lock(&inode->i_lock); 1056 if (inode_state_read(inode) & (I_FREEING | I_WILL_FREE)) { 1057 __wait_on_freeing_inode(inode, is_inode_hash_locked); 1058 goto repeat; 1059 } 1060 if (unlikely(inode_state_read(inode) & I_CREATING)) { 1061 spin_unlock(&inode->i_lock); 1062 rcu_read_unlock(); 1063 return ERR_PTR(-ESTALE); 1064 } 1065 __iget(inode); 1066 *isnew = !!(inode_state_read(inode) & I_NEW); 1067 spin_unlock(&inode->i_lock); 1068 rcu_read_unlock(); 1069 return inode; 1070 } 1071 rcu_read_unlock(); 1072 return NULL; 1073} 1074 1075/* 1076 * find_inode_fast is the fast path version of find_inode, see the comment at 1077 * iget_locked for details. 1078 */ 1079static struct inode *find_inode_fast(struct super_block *sb, 1080 struct hlist_head *head, unsigned long ino, 1081 bool is_inode_hash_locked, bool *isnew) 1082{ 1083 struct inode *inode = NULL; 1084 1085 if (is_inode_hash_locked) 1086 lockdep_assert_held(&inode_hash_lock); 1087 else 1088 lockdep_assert_not_held(&inode_hash_lock); 1089 1090 rcu_read_lock(); 1091repeat: 1092 hlist_for_each_entry_rcu(inode, head, i_hash) { 1093 if (inode->i_ino != ino) 1094 continue; 1095 if (inode->i_sb != sb) 1096 continue; 1097 spin_lock(&inode->i_lock); 1098 if (inode_state_read(inode) & (I_FREEING | I_WILL_FREE)) { 1099 __wait_on_freeing_inode(inode, is_inode_hash_locked); 1100 goto repeat; 1101 } 1102 if (unlikely(inode_state_read(inode) & I_CREATING)) { 1103 spin_unlock(&inode->i_lock); 1104 rcu_read_unlock(); 1105 return ERR_PTR(-ESTALE); 1106 } 1107 __iget(inode); 1108 *isnew = !!(inode_state_read(inode) & I_NEW); 1109 spin_unlock(&inode->i_lock); 1110 rcu_read_unlock(); 1111 return inode; 1112 } 1113 rcu_read_unlock(); 1114 return NULL; 1115} 1116 1117/* 1118 * Each cpu owns a range of LAST_INO_BATCH numbers. 1119 * 'shared_last_ino' is dirtied only once out of LAST_INO_BATCH allocations, 1120 * to renew the exhausted range. 1121 * 1122 * This does not significantly increase overflow rate because every CPU can 1123 * consume at most LAST_INO_BATCH-1 unused inode numbers. So there is 1124 * NR_CPUS*(LAST_INO_BATCH-1) wastage. At 4096 and 1024, this is ~0.1% of the 1125 * 2^32 range, and is a worst-case. Even a 50% wastage would only increase 1126 * overflow rate by 2x, which does not seem too significant. 1127 * 1128 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW 1129 * error if st_ino won't fit in target struct field. Use 32bit counter 1130 * here to attempt to avoid that. 1131 */ 1132#define LAST_INO_BATCH 1024 1133static DEFINE_PER_CPU(unsigned int, last_ino); 1134 1135unsigned int get_next_ino(void) 1136{ 1137 unsigned int *p = &get_cpu_var(last_ino); 1138 unsigned int res = *p; 1139 1140#ifdef CONFIG_SMP 1141 if (unlikely((res & (LAST_INO_BATCH-1)) == 0)) { 1142 static atomic_t shared_last_ino; 1143 int next = atomic_add_return(LAST_INO_BATCH, &shared_last_ino); 1144 1145 res = next - LAST_INO_BATCH; 1146 } 1147#endif 1148 1149 res++; 1150 /* get_next_ino should not provide a 0 inode number */ 1151 if (unlikely(!res)) 1152 res++; 1153 *p = res; 1154 put_cpu_var(last_ino); 1155 return res; 1156} 1157EXPORT_SYMBOL(get_next_ino); 1158 1159/** 1160 * new_inode - obtain an inode 1161 * @sb: superblock 1162 * 1163 * Allocates a new inode for given superblock. The default gfp_mask 1164 * for allocations related to inode->i_mapping is GFP_HIGHUSER_MOVABLE. 1165 * If HIGHMEM pages are unsuitable or it is known that pages allocated 1166 * for the page cache are not reclaimable or migratable, 1167 * mapping_set_gfp_mask() must be called with suitable flags on the 1168 * newly created inode's mapping 1169 * 1170 */ 1171struct inode *new_inode(struct super_block *sb) 1172{ 1173 struct inode *inode; 1174 1175 inode = alloc_inode(sb); 1176 if (inode) 1177 inode_sb_list_add(inode); 1178 return inode; 1179} 1180EXPORT_SYMBOL(new_inode); 1181 1182#ifdef CONFIG_DEBUG_LOCK_ALLOC 1183void lockdep_annotate_inode_mutex_key(struct inode *inode) 1184{ 1185 if (S_ISDIR(inode->i_mode)) { 1186 struct file_system_type *type = inode->i_sb->s_type; 1187 1188 /* Set new key only if filesystem hasn't already changed it */ 1189 if (lockdep_match_class(&inode->i_rwsem, &type->i_mutex_key)) { 1190 /* 1191 * ensure nobody is actually holding i_rwsem 1192 */ 1193 init_rwsem(&inode->i_rwsem); 1194 lockdep_set_class(&inode->i_rwsem, 1195 &type->i_mutex_dir_key); 1196 } 1197 } 1198} 1199EXPORT_SYMBOL(lockdep_annotate_inode_mutex_key); 1200#endif 1201 1202/** 1203 * unlock_new_inode - clear the I_NEW state and wake up any waiters 1204 * @inode: new inode to unlock 1205 * 1206 * Called when the inode is fully initialised to clear the new state of the 1207 * inode and wake up anyone waiting for the inode to finish initialisation. 1208 */ 1209void unlock_new_inode(struct inode *inode) 1210{ 1211 lockdep_annotate_inode_mutex_key(inode); 1212 spin_lock(&inode->i_lock); 1213 WARN_ON(!(inode_state_read(inode) & I_NEW)); 1214 inode_state_clear(inode, I_NEW | I_CREATING); 1215 inode_wake_up_bit(inode, __I_NEW); 1216 spin_unlock(&inode->i_lock); 1217} 1218EXPORT_SYMBOL(unlock_new_inode); 1219 1220void discard_new_inode(struct inode *inode) 1221{ 1222 lockdep_annotate_inode_mutex_key(inode); 1223 spin_lock(&inode->i_lock); 1224 WARN_ON(!(inode_state_read(inode) & I_NEW)); 1225 inode_state_clear(inode, I_NEW); 1226 inode_wake_up_bit(inode, __I_NEW); 1227 spin_unlock(&inode->i_lock); 1228 iput(inode); 1229} 1230EXPORT_SYMBOL(discard_new_inode); 1231 1232/** 1233 * lock_two_nondirectories - take two i_mutexes on non-directory objects 1234 * 1235 * Lock any non-NULL argument. Passed objects must not be directories. 1236 * Zero, one or two objects may be locked by this function. 1237 * 1238 * @inode1: first inode to lock 1239 * @inode2: second inode to lock 1240 */ 1241void lock_two_nondirectories(struct inode *inode1, struct inode *inode2) 1242{ 1243 if (inode1) 1244 WARN_ON_ONCE(S_ISDIR(inode1->i_mode)); 1245 if (inode2) 1246 WARN_ON_ONCE(S_ISDIR(inode2->i_mode)); 1247 if (inode1 > inode2) 1248 swap(inode1, inode2); 1249 if (inode1) 1250 inode_lock(inode1); 1251 if (inode2 && inode2 != inode1) 1252 inode_lock_nested(inode2, I_MUTEX_NONDIR2); 1253} 1254EXPORT_SYMBOL(lock_two_nondirectories); 1255 1256/** 1257 * unlock_two_nondirectories - release locks from lock_two_nondirectories() 1258 * @inode1: first inode to unlock 1259 * @inode2: second inode to unlock 1260 */ 1261void unlock_two_nondirectories(struct inode *inode1, struct inode *inode2) 1262{ 1263 if (inode1) { 1264 WARN_ON_ONCE(S_ISDIR(inode1->i_mode)); 1265 inode_unlock(inode1); 1266 } 1267 if (inode2 && inode2 != inode1) { 1268 WARN_ON_ONCE(S_ISDIR(inode2->i_mode)); 1269 inode_unlock(inode2); 1270 } 1271} 1272EXPORT_SYMBOL(unlock_two_nondirectories); 1273 1274/** 1275 * inode_insert5 - obtain an inode from a mounted file system 1276 * @inode: pre-allocated inode to use for insert to cache 1277 * @hashval: hash value (usually inode number) to get 1278 * @test: callback used for comparisons between inodes 1279 * @set: callback used to initialize a new struct inode 1280 * @data: opaque data pointer to pass to @test and @set 1281 * @isnew: pointer to a bool which will indicate whether I_NEW is set 1282 * 1283 * Search for the inode specified by @hashval and @data in the inode cache, 1284 * and if present return it with an increased reference count. This is a 1285 * variant of iget5_locked() that doesn't allocate an inode. 1286 * 1287 * If the inode is not present in the cache, insert the pre-allocated inode and 1288 * return it locked, hashed, and with the I_NEW flag set. The file system gets 1289 * to fill it in before unlocking it via unlock_new_inode(). 1290 * 1291 * Note that both @test and @set are called with the inode_hash_lock held, so 1292 * they can't sleep. 1293 */ 1294struct inode *inode_insert5(struct inode *inode, unsigned long hashval, 1295 int (*test)(struct inode *, void *), 1296 int (*set)(struct inode *, void *), void *data) 1297{ 1298 struct hlist_head *head = inode_hashtable + hash(inode->i_sb, hashval); 1299 struct inode *old; 1300 bool isnew; 1301 1302 might_sleep(); 1303 1304again: 1305 spin_lock(&inode_hash_lock); 1306 old = find_inode(inode->i_sb, head, test, data, true, &isnew); 1307 if (unlikely(old)) { 1308 /* 1309 * Uhhuh, somebody else created the same inode under us. 1310 * Use the old inode instead of the preallocated one. 1311 */ 1312 spin_unlock(&inode_hash_lock); 1313 if (IS_ERR(old)) 1314 return NULL; 1315 if (unlikely(isnew)) 1316 wait_on_new_inode(old); 1317 if (unlikely(inode_unhashed(old))) { 1318 iput(old); 1319 goto again; 1320 } 1321 return old; 1322 } 1323 1324 if (set && unlikely(set(inode, data))) { 1325 spin_unlock(&inode_hash_lock); 1326 return NULL; 1327 } 1328 1329 /* 1330 * Return the locked inode with I_NEW set, the 1331 * caller is responsible for filling in the contents 1332 */ 1333 spin_lock(&inode->i_lock); 1334 inode_state_set(inode, I_NEW); 1335 hlist_add_head_rcu(&inode->i_hash, head); 1336 spin_unlock(&inode->i_lock); 1337 1338 spin_unlock(&inode_hash_lock); 1339 1340 /* 1341 * Add inode to the sb list if it's not already. It has I_NEW at this 1342 * point, so it should be safe to test i_sb_list locklessly. 1343 */ 1344 if (list_empty(&inode->i_sb_list)) 1345 inode_sb_list_add(inode); 1346 1347 return inode; 1348} 1349EXPORT_SYMBOL(inode_insert5); 1350 1351/** 1352 * iget5_locked - obtain an inode from a mounted file system 1353 * @sb: super block of file system 1354 * @hashval: hash value (usually inode number) to get 1355 * @test: callback used for comparisons between inodes 1356 * @set: callback used to initialize a new struct inode 1357 * @data: opaque data pointer to pass to @test and @set 1358 * 1359 * Search for the inode specified by @hashval and @data in the inode cache, 1360 * and if present return it with an increased reference count. This is a 1361 * generalized version of iget_locked() for file systems where the inode 1362 * number is not sufficient for unique identification of an inode. 1363 * 1364 * If the inode is not present in the cache, allocate and insert a new inode 1365 * and return it locked, hashed, and with the I_NEW flag set. The file system 1366 * gets to fill it in before unlocking it via unlock_new_inode(). 1367 * 1368 * Note that both @test and @set are called with the inode_hash_lock held, so 1369 * they can't sleep. 1370 */ 1371struct inode *iget5_locked(struct super_block *sb, unsigned long hashval, 1372 int (*test)(struct inode *, void *), 1373 int (*set)(struct inode *, void *), void *data) 1374{ 1375 struct inode *inode = ilookup5(sb, hashval, test, data); 1376 1377 if (!inode) { 1378 struct inode *new = alloc_inode(sb); 1379 1380 if (new) { 1381 inode = inode_insert5(new, hashval, test, set, data); 1382 if (unlikely(inode != new)) 1383 destroy_inode(new); 1384 } 1385 } 1386 return inode; 1387} 1388EXPORT_SYMBOL(iget5_locked); 1389 1390/** 1391 * iget5_locked_rcu - obtain an inode from a mounted file system 1392 * @sb: super block of file system 1393 * @hashval: hash value (usually inode number) to get 1394 * @test: callback used for comparisons between inodes 1395 * @set: callback used to initialize a new struct inode 1396 * @data: opaque data pointer to pass to @test and @set 1397 * 1398 * This is equivalent to iget5_locked, except the @test callback must 1399 * tolerate the inode not being stable, including being mid-teardown. 1400 */ 1401struct inode *iget5_locked_rcu(struct super_block *sb, unsigned long hashval, 1402 int (*test)(struct inode *, void *), 1403 int (*set)(struct inode *, void *), void *data) 1404{ 1405 struct hlist_head *head = inode_hashtable + hash(sb, hashval); 1406 struct inode *inode, *new; 1407 bool isnew; 1408 1409 might_sleep(); 1410 1411again: 1412 inode = find_inode(sb, head, test, data, false, &isnew); 1413 if (inode) { 1414 if (IS_ERR(inode)) 1415 return NULL; 1416 if (unlikely(isnew)) 1417 wait_on_new_inode(inode); 1418 if (unlikely(inode_unhashed(inode))) { 1419 iput(inode); 1420 goto again; 1421 } 1422 return inode; 1423 } 1424 1425 new = alloc_inode(sb); 1426 if (new) { 1427 inode = inode_insert5(new, hashval, test, set, data); 1428 if (unlikely(inode != new)) 1429 destroy_inode(new); 1430 } 1431 return inode; 1432} 1433EXPORT_SYMBOL_GPL(iget5_locked_rcu); 1434 1435/** 1436 * iget_locked - obtain an inode from a mounted file system 1437 * @sb: super block of file system 1438 * @ino: inode number to get 1439 * 1440 * Search for the inode specified by @ino in the inode cache and if present 1441 * return it with an increased reference count. This is for file systems 1442 * where the inode number is sufficient for unique identification of an inode. 1443 * 1444 * If the inode is not in cache, allocate a new inode and return it locked, 1445 * hashed, and with the I_NEW flag set. The file system gets to fill it in 1446 * before unlocking it via unlock_new_inode(). 1447 */ 1448struct inode *iget_locked(struct super_block *sb, unsigned long ino) 1449{ 1450 struct hlist_head *head = inode_hashtable + hash(sb, ino); 1451 struct inode *inode; 1452 bool isnew; 1453 1454 might_sleep(); 1455 1456again: 1457 inode = find_inode_fast(sb, head, ino, false, &isnew); 1458 if (inode) { 1459 if (IS_ERR(inode)) 1460 return NULL; 1461 if (unlikely(isnew)) 1462 wait_on_new_inode(inode); 1463 if (unlikely(inode_unhashed(inode))) { 1464 iput(inode); 1465 goto again; 1466 } 1467 return inode; 1468 } 1469 1470 inode = alloc_inode(sb); 1471 if (inode) { 1472 struct inode *old; 1473 1474 spin_lock(&inode_hash_lock); 1475 /* We released the lock, so.. */ 1476 old = find_inode_fast(sb, head, ino, true, &isnew); 1477 if (!old) { 1478 inode->i_ino = ino; 1479 spin_lock(&inode->i_lock); 1480 inode_state_assign(inode, I_NEW); 1481 hlist_add_head_rcu(&inode->i_hash, head); 1482 spin_unlock(&inode->i_lock); 1483 spin_unlock(&inode_hash_lock); 1484 inode_sb_list_add(inode); 1485 1486 /* Return the locked inode with I_NEW set, the 1487 * caller is responsible for filling in the contents 1488 */ 1489 return inode; 1490 } 1491 1492 /* 1493 * Uhhuh, somebody else created the same inode under 1494 * us. Use the old inode instead of the one we just 1495 * allocated. 1496 */ 1497 spin_unlock(&inode_hash_lock); 1498 destroy_inode(inode); 1499 if (IS_ERR(old)) 1500 return NULL; 1501 inode = old; 1502 if (unlikely(isnew)) 1503 wait_on_new_inode(inode); 1504 if (unlikely(inode_unhashed(inode))) { 1505 iput(inode); 1506 goto again; 1507 } 1508 } 1509 return inode; 1510} 1511EXPORT_SYMBOL(iget_locked); 1512 1513/* 1514 * search the inode cache for a matching inode number. 1515 * If we find one, then the inode number we are trying to 1516 * allocate is not unique and so we should not use it. 1517 * 1518 * Returns 1 if the inode number is unique, 0 if it is not. 1519 */ 1520static int test_inode_iunique(struct super_block *sb, unsigned long ino) 1521{ 1522 struct hlist_head *b = inode_hashtable + hash(sb, ino); 1523 struct inode *inode; 1524 1525 hlist_for_each_entry_rcu(inode, b, i_hash) { 1526 if (inode->i_ino == ino && inode->i_sb == sb) 1527 return 0; 1528 } 1529 return 1; 1530} 1531 1532/** 1533 * iunique - get a unique inode number 1534 * @sb: superblock 1535 * @max_reserved: highest reserved inode number 1536 * 1537 * Obtain an inode number that is unique on the system for a given 1538 * superblock. This is used by file systems that have no natural 1539 * permanent inode numbering system. An inode number is returned that 1540 * is higher than the reserved limit but unique. 1541 * 1542 * BUGS: 1543 * With a large number of inodes live on the file system this function 1544 * currently becomes quite slow. 1545 */ 1546ino_t iunique(struct super_block *sb, ino_t max_reserved) 1547{ 1548 /* 1549 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW 1550 * error if st_ino won't fit in target struct field. Use 32bit counter 1551 * here to attempt to avoid that. 1552 */ 1553 static DEFINE_SPINLOCK(iunique_lock); 1554 static unsigned int counter; 1555 ino_t res; 1556 1557 rcu_read_lock(); 1558 spin_lock(&iunique_lock); 1559 do { 1560 if (counter <= max_reserved) 1561 counter = max_reserved + 1; 1562 res = counter++; 1563 } while (!test_inode_iunique(sb, res)); 1564 spin_unlock(&iunique_lock); 1565 rcu_read_unlock(); 1566 1567 return res; 1568} 1569EXPORT_SYMBOL(iunique); 1570 1571struct inode *igrab(struct inode *inode) 1572{ 1573 spin_lock(&inode->i_lock); 1574 if (!(inode_state_read(inode) & (I_FREEING | I_WILL_FREE))) { 1575 __iget(inode); 1576 spin_unlock(&inode->i_lock); 1577 } else { 1578 spin_unlock(&inode->i_lock); 1579 /* 1580 * Handle the case where s_op->clear_inode is not been 1581 * called yet, and somebody is calling igrab 1582 * while the inode is getting freed. 1583 */ 1584 inode = NULL; 1585 } 1586 return inode; 1587} 1588EXPORT_SYMBOL(igrab); 1589 1590/** 1591 * ilookup5_nowait - search for an inode in the inode cache 1592 * @sb: super block of file system to search 1593 * @hashval: hash value (usually inode number) to search for 1594 * @test: callback used for comparisons between inodes 1595 * @data: opaque data pointer to pass to @test 1596 * @isnew: return argument telling whether I_NEW was set when 1597 * the inode was found in hash (the caller needs to 1598 * wait for I_NEW to clear) 1599 * 1600 * Search for the inode specified by @hashval and @data in the inode cache. 1601 * If the inode is in the cache, the inode is returned with an incremented 1602 * reference count. 1603 * 1604 * Note: I_NEW is not waited upon so you have to be very careful what you do 1605 * with the returned inode. You probably should be using ilookup5() instead. 1606 * 1607 * Note2: @test is called with the inode_hash_lock held, so can't sleep. 1608 */ 1609struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval, 1610 int (*test)(struct inode *, void *), void *data, bool *isnew) 1611{ 1612 struct hlist_head *head = inode_hashtable + hash(sb, hashval); 1613 struct inode *inode; 1614 1615 spin_lock(&inode_hash_lock); 1616 inode = find_inode(sb, head, test, data, true, isnew); 1617 spin_unlock(&inode_hash_lock); 1618 1619 return IS_ERR(inode) ? NULL : inode; 1620} 1621EXPORT_SYMBOL(ilookup5_nowait); 1622 1623/** 1624 * ilookup5 - search for an inode in the inode cache 1625 * @sb: super block of file system to search 1626 * @hashval: hash value (usually inode number) to search for 1627 * @test: callback used for comparisons between inodes 1628 * @data: opaque data pointer to pass to @test 1629 * 1630 * Search for the inode specified by @hashval and @data in the inode cache, 1631 * and if the inode is in the cache, return the inode with an incremented 1632 * reference count. Waits on I_NEW before returning the inode. 1633 * returned with an incremented reference count. 1634 * 1635 * This is a generalized version of ilookup() for file systems where the 1636 * inode number is not sufficient for unique identification of an inode. 1637 * 1638 * Note: @test is called with the inode_hash_lock held, so can't sleep. 1639 */ 1640struct inode *ilookup5(struct super_block *sb, unsigned long hashval, 1641 int (*test)(struct inode *, void *), void *data) 1642{ 1643 struct inode *inode; 1644 bool isnew; 1645 1646 might_sleep(); 1647 1648again: 1649 inode = ilookup5_nowait(sb, hashval, test, data, &isnew); 1650 if (inode) { 1651 if (unlikely(isnew)) 1652 wait_on_new_inode(inode); 1653 if (unlikely(inode_unhashed(inode))) { 1654 iput(inode); 1655 goto again; 1656 } 1657 } 1658 return inode; 1659} 1660EXPORT_SYMBOL(ilookup5); 1661 1662/** 1663 * ilookup - search for an inode in the inode cache 1664 * @sb: super block of file system to search 1665 * @ino: inode number to search for 1666 * 1667 * Search for the inode @ino in the inode cache, and if the inode is in the 1668 * cache, the inode is returned with an incremented reference count. 1669 */ 1670struct inode *ilookup(struct super_block *sb, unsigned long ino) 1671{ 1672 struct hlist_head *head = inode_hashtable + hash(sb, ino); 1673 struct inode *inode; 1674 bool isnew; 1675 1676 might_sleep(); 1677 1678again: 1679 inode = find_inode_fast(sb, head, ino, false, &isnew); 1680 1681 if (inode) { 1682 if (IS_ERR(inode)) 1683 return NULL; 1684 if (unlikely(isnew)) 1685 wait_on_new_inode(inode); 1686 if (unlikely(inode_unhashed(inode))) { 1687 iput(inode); 1688 goto again; 1689 } 1690 } 1691 return inode; 1692} 1693EXPORT_SYMBOL(ilookup); 1694 1695/** 1696 * find_inode_nowait - find an inode in the inode cache 1697 * @sb: super block of file system to search 1698 * @hashval: hash value (usually inode number) to search for 1699 * @match: callback used for comparisons between inodes 1700 * @data: opaque data pointer to pass to @match 1701 * 1702 * Search for the inode specified by @hashval and @data in the inode 1703 * cache, where the helper function @match will return 0 if the inode 1704 * does not match, 1 if the inode does match, and -1 if the search 1705 * should be stopped. The @match function must be responsible for 1706 * taking the i_lock spin_lock and checking i_state for an inode being 1707 * freed or being initialized, and incrementing the reference count 1708 * before returning 1. It also must not sleep, since it is called with 1709 * the inode_hash_lock spinlock held. 1710 * 1711 * This is a even more generalized version of ilookup5() when the 1712 * function must never block --- find_inode() can block in 1713 * __wait_on_freeing_inode() --- or when the caller can not increment 1714 * the reference count because the resulting iput() might cause an 1715 * inode eviction. The tradeoff is that the @match funtion must be 1716 * very carefully implemented. 1717 */ 1718struct inode *find_inode_nowait(struct super_block *sb, 1719 unsigned long hashval, 1720 int (*match)(struct inode *, unsigned long, 1721 void *), 1722 void *data) 1723{ 1724 struct hlist_head *head = inode_hashtable + hash(sb, hashval); 1725 struct inode *inode, *ret_inode = NULL; 1726 int mval; 1727 1728 spin_lock(&inode_hash_lock); 1729 hlist_for_each_entry(inode, head, i_hash) { 1730 if (inode->i_sb != sb) 1731 continue; 1732 mval = match(inode, hashval, data); 1733 if (mval == 0) 1734 continue; 1735 if (mval == 1) 1736 ret_inode = inode; 1737 goto out; 1738 } 1739out: 1740 spin_unlock(&inode_hash_lock); 1741 return ret_inode; 1742} 1743EXPORT_SYMBOL(find_inode_nowait); 1744 1745/** 1746 * find_inode_rcu - find an inode in the inode cache 1747 * @sb: Super block of file system to search 1748 * @hashval: Key to hash 1749 * @test: Function to test match on an inode 1750 * @data: Data for test function 1751 * 1752 * Search for the inode specified by @hashval and @data in the inode cache, 1753 * where the helper function @test will return 0 if the inode does not match 1754 * and 1 if it does. The @test function must be responsible for taking the 1755 * i_lock spin_lock and checking i_state for an inode being freed or being 1756 * initialized. 1757 * 1758 * If successful, this will return the inode for which the @test function 1759 * returned 1 and NULL otherwise. 1760 * 1761 * The @test function is not permitted to take a ref on any inode presented. 1762 * It is also not permitted to sleep. 1763 * 1764 * The caller must hold the RCU read lock. 1765 */ 1766struct inode *find_inode_rcu(struct super_block *sb, unsigned long hashval, 1767 int (*test)(struct inode *, void *), void *data) 1768{ 1769 struct hlist_head *head = inode_hashtable + hash(sb, hashval); 1770 struct inode *inode; 1771 1772 RCU_LOCKDEP_WARN(!rcu_read_lock_held(), 1773 "suspicious find_inode_rcu() usage"); 1774 1775 hlist_for_each_entry_rcu(inode, head, i_hash) { 1776 if (inode->i_sb == sb && 1777 !(inode_state_read_once(inode) & (I_FREEING | I_WILL_FREE)) && 1778 test(inode, data)) 1779 return inode; 1780 } 1781 return NULL; 1782} 1783EXPORT_SYMBOL(find_inode_rcu); 1784 1785/** 1786 * find_inode_by_ino_rcu - Find an inode in the inode cache 1787 * @sb: Super block of file system to search 1788 * @ino: The inode number to match 1789 * 1790 * Search for the inode specified by @hashval and @data in the inode cache, 1791 * where the helper function @test will return 0 if the inode does not match 1792 * and 1 if it does. The @test function must be responsible for taking the 1793 * i_lock spin_lock and checking i_state for an inode being freed or being 1794 * initialized. 1795 * 1796 * If successful, this will return the inode for which the @test function 1797 * returned 1 and NULL otherwise. 1798 * 1799 * The @test function is not permitted to take a ref on any inode presented. 1800 * It is also not permitted to sleep. 1801 * 1802 * The caller must hold the RCU read lock. 1803 */ 1804struct inode *find_inode_by_ino_rcu(struct super_block *sb, 1805 unsigned long ino) 1806{ 1807 struct hlist_head *head = inode_hashtable + hash(sb, ino); 1808 struct inode *inode; 1809 1810 RCU_LOCKDEP_WARN(!rcu_read_lock_held(), 1811 "suspicious find_inode_by_ino_rcu() usage"); 1812 1813 hlist_for_each_entry_rcu(inode, head, i_hash) { 1814 if (inode->i_ino == ino && 1815 inode->i_sb == sb && 1816 !(inode_state_read_once(inode) & (I_FREEING | I_WILL_FREE))) 1817 return inode; 1818 } 1819 return NULL; 1820} 1821EXPORT_SYMBOL(find_inode_by_ino_rcu); 1822 1823int insert_inode_locked(struct inode *inode) 1824{ 1825 struct super_block *sb = inode->i_sb; 1826 ino_t ino = inode->i_ino; 1827 struct hlist_head *head = inode_hashtable + hash(sb, ino); 1828 bool isnew; 1829 1830 might_sleep(); 1831 1832 while (1) { 1833 struct inode *old = NULL; 1834 spin_lock(&inode_hash_lock); 1835 hlist_for_each_entry(old, head, i_hash) { 1836 if (old->i_ino != ino) 1837 continue; 1838 if (old->i_sb != sb) 1839 continue; 1840 spin_lock(&old->i_lock); 1841 if (inode_state_read(old) & (I_FREEING | I_WILL_FREE)) { 1842 spin_unlock(&old->i_lock); 1843 continue; 1844 } 1845 break; 1846 } 1847 if (likely(!old)) { 1848 spin_lock(&inode->i_lock); 1849 inode_state_set(inode, I_NEW | I_CREATING); 1850 hlist_add_head_rcu(&inode->i_hash, head); 1851 spin_unlock(&inode->i_lock); 1852 spin_unlock(&inode_hash_lock); 1853 return 0; 1854 } 1855 if (unlikely(inode_state_read(old) & I_CREATING)) { 1856 spin_unlock(&old->i_lock); 1857 spin_unlock(&inode_hash_lock); 1858 return -EBUSY; 1859 } 1860 __iget(old); 1861 isnew = !!(inode_state_read(old) & I_NEW); 1862 spin_unlock(&old->i_lock); 1863 spin_unlock(&inode_hash_lock); 1864 if (isnew) 1865 wait_on_new_inode(old); 1866 if (unlikely(!inode_unhashed(old))) { 1867 iput(old); 1868 return -EBUSY; 1869 } 1870 iput(old); 1871 } 1872} 1873EXPORT_SYMBOL(insert_inode_locked); 1874 1875int insert_inode_locked4(struct inode *inode, unsigned long hashval, 1876 int (*test)(struct inode *, void *), void *data) 1877{ 1878 struct inode *old; 1879 1880 might_sleep(); 1881 1882 inode_state_set_raw(inode, I_CREATING); 1883 old = inode_insert5(inode, hashval, test, NULL, data); 1884 1885 if (old != inode) { 1886 iput(old); 1887 return -EBUSY; 1888 } 1889 return 0; 1890} 1891EXPORT_SYMBOL(insert_inode_locked4); 1892 1893 1894int inode_just_drop(struct inode *inode) 1895{ 1896 return 1; 1897} 1898EXPORT_SYMBOL(inode_just_drop); 1899 1900/* 1901 * Called when we're dropping the last reference 1902 * to an inode. 1903 * 1904 * Call the FS "drop_inode()" function, defaulting to 1905 * the legacy UNIX filesystem behaviour. If it tells 1906 * us to evict inode, do so. Otherwise, retain inode 1907 * in cache if fs is alive, sync and evict if fs is 1908 * shutting down. 1909 */ 1910static void iput_final(struct inode *inode) 1911{ 1912 struct super_block *sb = inode->i_sb; 1913 const struct super_operations *op = inode->i_sb->s_op; 1914 int drop; 1915 1916 WARN_ON(inode_state_read(inode) & I_NEW); 1917 VFS_BUG_ON_INODE(atomic_read(&inode->i_count) != 0, inode); 1918 1919 if (op->drop_inode) 1920 drop = op->drop_inode(inode); 1921 else 1922 drop = inode_generic_drop(inode); 1923 1924 if (!drop && 1925 !(inode_state_read(inode) & I_DONTCACHE) && 1926 (sb->s_flags & SB_ACTIVE)) { 1927 __inode_lru_list_add(inode, true); 1928 spin_unlock(&inode->i_lock); 1929 return; 1930 } 1931 1932 /* 1933 * Re-check ->i_count in case the ->drop_inode() hooks played games. 1934 * Note we only execute this if the verdict was to drop the inode. 1935 */ 1936 VFS_BUG_ON_INODE(atomic_read(&inode->i_count) != 0, inode); 1937 1938 if (drop) { 1939 inode_state_set(inode, I_FREEING); 1940 } else { 1941 inode_state_set(inode, I_WILL_FREE); 1942 spin_unlock(&inode->i_lock); 1943 1944 write_inode_now(inode, 1); 1945 1946 spin_lock(&inode->i_lock); 1947 WARN_ON(inode_state_read(inode) & I_NEW); 1948 inode_state_replace(inode, I_WILL_FREE, I_FREEING); 1949 } 1950 1951 inode_lru_list_del(inode); 1952 spin_unlock(&inode->i_lock); 1953 1954 evict(inode); 1955} 1956 1957/** 1958 * iput - put an inode 1959 * @inode: inode to put 1960 * 1961 * Puts an inode, dropping its usage count. If the inode use count hits 1962 * zero, the inode is then freed and may also be destroyed. 1963 * 1964 * Consequently, iput() can sleep. 1965 */ 1966void iput(struct inode *inode) 1967{ 1968 might_sleep(); 1969 if (unlikely(!inode)) 1970 return; 1971 1972retry: 1973 lockdep_assert_not_held(&inode->i_lock); 1974 VFS_BUG_ON_INODE(inode_state_read_once(inode) & (I_FREEING | I_CLEAR), inode); 1975 /* 1976 * Note this assert is technically racy as if the count is bogusly 1977 * equal to one, then two CPUs racing to further drop it can both 1978 * conclude it's fine. 1979 */ 1980 VFS_BUG_ON_INODE(atomic_read(&inode->i_count) < 1, inode); 1981 1982 if (atomic_add_unless(&inode->i_count, -1, 1)) 1983 return; 1984 1985 if ((inode_state_read_once(inode) & I_DIRTY_TIME) && inode->i_nlink) { 1986 trace_writeback_lazytime_iput(inode); 1987 mark_inode_dirty_sync(inode); 1988 goto retry; 1989 } 1990 1991 spin_lock(&inode->i_lock); 1992 if (unlikely((inode_state_read(inode) & I_DIRTY_TIME) && inode->i_nlink)) { 1993 spin_unlock(&inode->i_lock); 1994 goto retry; 1995 } 1996 1997 if (!atomic_dec_and_test(&inode->i_count)) { 1998 spin_unlock(&inode->i_lock); 1999 return; 2000 } 2001 2002 /* 2003 * iput_final() drops ->i_lock, we can't assert on it as the inode may 2004 * be deallocated by the time the call returns. 2005 */ 2006 iput_final(inode); 2007} 2008EXPORT_SYMBOL(iput); 2009 2010/** 2011 * iput_not_last - put an inode assuming this is not the last reference 2012 * @inode: inode to put 2013 */ 2014void iput_not_last(struct inode *inode) 2015{ 2016 VFS_BUG_ON_INODE(inode_state_read_once(inode) & (I_FREEING | I_CLEAR), inode); 2017 VFS_BUG_ON_INODE(atomic_read(&inode->i_count) < 2, inode); 2018 2019 WARN_ON(atomic_sub_return(1, &inode->i_count) == 0); 2020} 2021EXPORT_SYMBOL(iput_not_last); 2022 2023#ifdef CONFIG_BLOCK 2024/** 2025 * bmap - find a block number in a file 2026 * @inode: inode owning the block number being requested 2027 * @block: pointer containing the block to find 2028 * 2029 * Replaces the value in ``*block`` with the block number on the device holding 2030 * corresponding to the requested block number in the file. 2031 * That is, asked for block 4 of inode 1 the function will replace the 2032 * 4 in ``*block``, with disk block relative to the disk start that holds that 2033 * block of the file. 2034 * 2035 * Returns -EINVAL in case of error, 0 otherwise. If mapping falls into a 2036 * hole, returns 0 and ``*block`` is also set to 0. 2037 */ 2038int bmap(struct inode *inode, sector_t *block) 2039{ 2040 if (!inode->i_mapping->a_ops->bmap) 2041 return -EINVAL; 2042 2043 *block = inode->i_mapping->a_ops->bmap(inode->i_mapping, *block); 2044 return 0; 2045} 2046EXPORT_SYMBOL(bmap); 2047#endif 2048 2049/* 2050 * With relative atime, only update atime if the previous atime is 2051 * earlier than or equal to either the ctime or mtime, 2052 * or if at least a day has passed since the last atime update. 2053 */ 2054static bool relatime_need_update(struct vfsmount *mnt, struct inode *inode, 2055 struct timespec64 now) 2056{ 2057 struct timespec64 atime, mtime, ctime; 2058 2059 if (!(mnt->mnt_flags & MNT_RELATIME)) 2060 return true; 2061 /* 2062 * Is mtime younger than or equal to atime? If yes, update atime: 2063 */ 2064 atime = inode_get_atime(inode); 2065 mtime = inode_get_mtime(inode); 2066 if (timespec64_compare(&mtime, &atime) >= 0) 2067 return true; 2068 /* 2069 * Is ctime younger than or equal to atime? If yes, update atime: 2070 */ 2071 ctime = inode_get_ctime(inode); 2072 if (timespec64_compare(&ctime, &atime) >= 0) 2073 return true; 2074 2075 /* 2076 * Is the previous atime value older than a day? If yes, 2077 * update atime: 2078 */ 2079 if ((long)(now.tv_sec - atime.tv_sec) >= 24*60*60) 2080 return true; 2081 /* 2082 * Good, we can skip the atime update: 2083 */ 2084 return false; 2085} 2086 2087/** 2088 * inode_update_timestamps - update the timestamps on the inode 2089 * @inode: inode to be updated 2090 * @flags: S_* flags that needed to be updated 2091 * 2092 * The update_time function is called when an inode's timestamps need to be 2093 * updated for a read or write operation. This function handles updating the 2094 * actual timestamps. It's up to the caller to ensure that the inode is marked 2095 * dirty appropriately. 2096 * 2097 * In the case where any of S_MTIME, S_CTIME, or S_VERSION need to be updated, 2098 * attempt to update all three of them. S_ATIME updates can be handled 2099 * independently of the rest. 2100 * 2101 * Returns a set of S_* flags indicating which values changed. 2102 */ 2103int inode_update_timestamps(struct inode *inode, int flags) 2104{ 2105 int updated = 0; 2106 struct timespec64 now; 2107 2108 if (flags & (S_MTIME|S_CTIME|S_VERSION)) { 2109 struct timespec64 ctime = inode_get_ctime(inode); 2110 struct timespec64 mtime = inode_get_mtime(inode); 2111 2112 now = inode_set_ctime_current(inode); 2113 if (!timespec64_equal(&now, &ctime)) 2114 updated |= S_CTIME; 2115 if (!timespec64_equal(&now, &mtime)) { 2116 inode_set_mtime_to_ts(inode, now); 2117 updated |= S_MTIME; 2118 } 2119 if (IS_I_VERSION(inode) && inode_maybe_inc_iversion(inode, updated)) 2120 updated |= S_VERSION; 2121 } else { 2122 now = current_time(inode); 2123 } 2124 2125 if (flags & S_ATIME) { 2126 struct timespec64 atime = inode_get_atime(inode); 2127 2128 if (!timespec64_equal(&now, &atime)) { 2129 inode_set_atime_to_ts(inode, now); 2130 updated |= S_ATIME; 2131 } 2132 } 2133 return updated; 2134} 2135EXPORT_SYMBOL(inode_update_timestamps); 2136 2137/** 2138 * generic_update_time - update the timestamps on the inode 2139 * @inode: inode to be updated 2140 * @flags: S_* flags that needed to be updated 2141 * 2142 * The update_time function is called when an inode's timestamps need to be 2143 * updated for a read or write operation. In the case where any of S_MTIME, S_CTIME, 2144 * or S_VERSION need to be updated we attempt to update all three of them. S_ATIME 2145 * updates can be handled done independently of the rest. 2146 * 2147 * Returns a S_* mask indicating which fields were updated. 2148 */ 2149int generic_update_time(struct inode *inode, int flags) 2150{ 2151 int updated = inode_update_timestamps(inode, flags); 2152 int dirty_flags = 0; 2153 2154 if (updated & (S_ATIME|S_MTIME|S_CTIME)) 2155 dirty_flags = inode->i_sb->s_flags & SB_LAZYTIME ? I_DIRTY_TIME : I_DIRTY_SYNC; 2156 if (updated & S_VERSION) 2157 dirty_flags |= I_DIRTY_SYNC; 2158 __mark_inode_dirty(inode, dirty_flags); 2159 return updated; 2160} 2161EXPORT_SYMBOL(generic_update_time); 2162 2163/* 2164 * This does the actual work of updating an inodes time or version. Must have 2165 * had called mnt_want_write() before calling this. 2166 */ 2167int inode_update_time(struct inode *inode, int flags) 2168{ 2169 if (inode->i_op->update_time) 2170 return inode->i_op->update_time(inode, flags); 2171 generic_update_time(inode, flags); 2172 return 0; 2173} 2174EXPORT_SYMBOL(inode_update_time); 2175 2176/** 2177 * atime_needs_update - update the access time 2178 * @path: the &struct path to update 2179 * @inode: inode to update 2180 * 2181 * Update the accessed time on an inode and mark it for writeback. 2182 * This function automatically handles read only file systems and media, 2183 * as well as the "noatime" flag and inode specific "noatime" markers. 2184 */ 2185bool atime_needs_update(const struct path *path, struct inode *inode) 2186{ 2187 struct vfsmount *mnt = path->mnt; 2188 struct timespec64 now, atime; 2189 2190 if (inode->i_flags & S_NOATIME) 2191 return false; 2192 2193 /* Atime updates will likely cause i_uid and i_gid to be written 2194 * back improprely if their true value is unknown to the vfs. 2195 */ 2196 if (HAS_UNMAPPED_ID(mnt_idmap(mnt), inode)) 2197 return false; 2198 2199 if (IS_NOATIME(inode)) 2200 return false; 2201 if ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode)) 2202 return false; 2203 2204 if (mnt->mnt_flags & MNT_NOATIME) 2205 return false; 2206 if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)) 2207 return false; 2208 2209 now = current_time(inode); 2210 2211 if (!relatime_need_update(mnt, inode, now)) 2212 return false; 2213 2214 atime = inode_get_atime(inode); 2215 if (timespec64_equal(&atime, &now)) 2216 return false; 2217 2218 return true; 2219} 2220 2221void touch_atime(const struct path *path) 2222{ 2223 struct vfsmount *mnt = path->mnt; 2224 struct inode *inode = d_inode(path->dentry); 2225 2226 if (!atime_needs_update(path, inode)) 2227 return; 2228 2229 if (!sb_start_write_trylock(inode->i_sb)) 2230 return; 2231 2232 if (mnt_get_write_access(mnt) != 0) 2233 goto skip_update; 2234 /* 2235 * File systems can error out when updating inodes if they need to 2236 * allocate new space to modify an inode (such is the case for 2237 * Btrfs), but since we touch atime while walking down the path we 2238 * really don't care if we failed to update the atime of the file, 2239 * so just ignore the return value. 2240 * We may also fail on filesystems that have the ability to make parts 2241 * of the fs read only, e.g. subvolumes in Btrfs. 2242 */ 2243 inode_update_time(inode, S_ATIME); 2244 mnt_put_write_access(mnt); 2245skip_update: 2246 sb_end_write(inode->i_sb); 2247} 2248EXPORT_SYMBOL(touch_atime); 2249 2250/* 2251 * Return mask of changes for notify_change() that need to be done as a 2252 * response to write or truncate. Return 0 if nothing has to be changed. 2253 * Negative value on error (change should be denied). 2254 */ 2255int dentry_needs_remove_privs(struct mnt_idmap *idmap, 2256 struct dentry *dentry) 2257{ 2258 struct inode *inode = d_inode(dentry); 2259 int mask = 0; 2260 int ret; 2261 2262 if (IS_NOSEC(inode)) 2263 return 0; 2264 2265 mask = setattr_should_drop_suidgid(idmap, inode); 2266 ret = security_inode_need_killpriv(dentry); 2267 if (ret < 0) 2268 return ret; 2269 if (ret) 2270 mask |= ATTR_KILL_PRIV; 2271 return mask; 2272} 2273 2274static int __remove_privs(struct mnt_idmap *idmap, 2275 struct dentry *dentry, int kill) 2276{ 2277 struct iattr newattrs; 2278 2279 newattrs.ia_valid = ATTR_FORCE | kill; 2280 /* 2281 * Note we call this on write, so notify_change will not 2282 * encounter any conflicting delegations: 2283 */ 2284 return notify_change(idmap, dentry, &newattrs, NULL); 2285} 2286 2287static int file_remove_privs_flags(struct file *file, unsigned int flags) 2288{ 2289 struct dentry *dentry = file_dentry(file); 2290 struct inode *inode = file_inode(file); 2291 int error = 0; 2292 int kill; 2293 2294 if (IS_NOSEC(inode) || !S_ISREG(inode->i_mode)) 2295 return 0; 2296 2297 kill = dentry_needs_remove_privs(file_mnt_idmap(file), dentry); 2298 if (kill < 0) 2299 return kill; 2300 2301 if (kill) { 2302 if (flags & IOCB_NOWAIT) 2303 return -EAGAIN; 2304 2305 error = __remove_privs(file_mnt_idmap(file), dentry, kill); 2306 } 2307 2308 if (!error) 2309 inode_has_no_xattr(inode); 2310 return error; 2311} 2312 2313/** 2314 * file_remove_privs - remove special file privileges (suid, capabilities) 2315 * @file: file to remove privileges from 2316 * 2317 * When file is modified by a write or truncation ensure that special 2318 * file privileges are removed. 2319 * 2320 * Return: 0 on success, negative errno on failure. 2321 */ 2322int file_remove_privs(struct file *file) 2323{ 2324 return file_remove_privs_flags(file, 0); 2325} 2326EXPORT_SYMBOL(file_remove_privs); 2327 2328/** 2329 * current_time - Return FS time (possibly fine-grained) 2330 * @inode: inode. 2331 * 2332 * Return the current time truncated to the time granularity supported by 2333 * the fs, as suitable for a ctime/mtime change. If the ctime is flagged 2334 * as having been QUERIED, get a fine-grained timestamp, but don't update 2335 * the floor. 2336 * 2337 * For a multigrain inode, this is effectively an estimate of the timestamp 2338 * that a file would receive. An actual update must go through 2339 * inode_set_ctime_current(). 2340 */ 2341struct timespec64 current_time(struct inode *inode) 2342{ 2343 struct timespec64 now; 2344 u32 cns; 2345 2346 ktime_get_coarse_real_ts64_mg(&now); 2347 2348 if (!is_mgtime(inode)) 2349 goto out; 2350 2351 /* If nothing has queried it, then coarse time is fine */ 2352 cns = smp_load_acquire(&inode->i_ctime_nsec); 2353 if (cns & I_CTIME_QUERIED) { 2354 /* 2355 * If there is no apparent change, then get a fine-grained 2356 * timestamp. 2357 */ 2358 if (now.tv_nsec == (cns & ~I_CTIME_QUERIED)) 2359 ktime_get_real_ts64(&now); 2360 } 2361out: 2362 return timestamp_truncate(now, inode); 2363} 2364EXPORT_SYMBOL(current_time); 2365 2366static int file_update_time_flags(struct file *file, unsigned int flags) 2367{ 2368 struct inode *inode = file_inode(file); 2369 struct timespec64 now, ts; 2370 int sync_mode = 0; 2371 int ret = 0; 2372 2373 /* First try to exhaust all avenues to not sync */ 2374 if (IS_NOCMTIME(inode)) 2375 return 0; 2376 if (unlikely(file->f_mode & FMODE_NOCMTIME)) 2377 return 0; 2378 2379 now = current_time(inode); 2380 2381 ts = inode_get_mtime(inode); 2382 if (!timespec64_equal(&ts, &now)) 2383 sync_mode |= S_MTIME; 2384 ts = inode_get_ctime(inode); 2385 if (!timespec64_equal(&ts, &now)) 2386 sync_mode |= S_CTIME; 2387 if (IS_I_VERSION(inode) && inode_iversion_need_inc(inode)) 2388 sync_mode |= S_VERSION; 2389 2390 if (!sync_mode) 2391 return 0; 2392 2393 if (flags & IOCB_NOWAIT) 2394 return -EAGAIN; 2395 2396 if (mnt_get_write_access_file(file)) 2397 return 0; 2398 ret = inode_update_time(inode, sync_mode); 2399 mnt_put_write_access_file(file); 2400 return ret; 2401} 2402 2403/** 2404 * file_update_time - update mtime and ctime time 2405 * @file: file accessed 2406 * 2407 * Update the mtime and ctime members of an inode and mark the inode for 2408 * writeback. Note that this function is meant exclusively for usage in 2409 * the file write path of filesystems, and filesystems may choose to 2410 * explicitly ignore updates via this function with the _NOCMTIME inode 2411 * flag, e.g. for network filesystem where these imestamps are handled 2412 * by the server. This can return an error for file systems who need to 2413 * allocate space in order to update an inode. 2414 * 2415 * Return: 0 on success, negative errno on failure. 2416 */ 2417int file_update_time(struct file *file) 2418{ 2419 return file_update_time_flags(file, 0); 2420} 2421EXPORT_SYMBOL(file_update_time); 2422 2423/** 2424 * file_modified_flags - handle mandated vfs changes when modifying a file 2425 * @file: file that was modified 2426 * @flags: kiocb flags 2427 * 2428 * When file has been modified ensure that special 2429 * file privileges are removed and time settings are updated. 2430 * 2431 * If IOCB_NOWAIT is set, special file privileges will not be removed and 2432 * time settings will not be updated. It will return -EAGAIN. 2433 * 2434 * Context: Caller must hold the file's inode lock. 2435 * 2436 * Return: 0 on success, negative errno on failure. 2437 */ 2438static int file_modified_flags(struct file *file, int flags) 2439{ 2440 int ret; 2441 2442 /* 2443 * Clear the security bits if the process is not being run by root. 2444 * This keeps people from modifying setuid and setgid binaries. 2445 */ 2446 ret = file_remove_privs_flags(file, flags); 2447 if (ret) 2448 return ret; 2449 return file_update_time_flags(file, flags); 2450} 2451 2452/** 2453 * file_modified - handle mandated vfs changes when modifying a file 2454 * @file: file that was modified 2455 * 2456 * When file has been modified ensure that special 2457 * file privileges are removed and time settings are updated. 2458 * 2459 * Context: Caller must hold the file's inode lock. 2460 * 2461 * Return: 0 on success, negative errno on failure. 2462 */ 2463int file_modified(struct file *file) 2464{ 2465 return file_modified_flags(file, 0); 2466} 2467EXPORT_SYMBOL(file_modified); 2468 2469/** 2470 * kiocb_modified - handle mandated vfs changes when modifying a file 2471 * @iocb: iocb that was modified 2472 * 2473 * When file has been modified ensure that special 2474 * file privileges are removed and time settings are updated. 2475 * 2476 * Context: Caller must hold the file's inode lock. 2477 * 2478 * Return: 0 on success, negative errno on failure. 2479 */ 2480int kiocb_modified(struct kiocb *iocb) 2481{ 2482 return file_modified_flags(iocb->ki_filp, iocb->ki_flags); 2483} 2484EXPORT_SYMBOL_GPL(kiocb_modified); 2485 2486int inode_needs_sync(struct inode *inode) 2487{ 2488 if (IS_SYNC(inode)) 2489 return 1; 2490 if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode)) 2491 return 1; 2492 return 0; 2493} 2494EXPORT_SYMBOL(inode_needs_sync); 2495 2496/* 2497 * If we try to find an inode in the inode hash while it is being 2498 * deleted, we have to wait until the filesystem completes its 2499 * deletion before reporting that it isn't found. This function waits 2500 * until the deletion _might_ have completed. Callers are responsible 2501 * to recheck inode state. 2502 * 2503 * It doesn't matter if I_NEW is not set initially, a call to 2504 * wake_up_bit(&inode->i_state, __I_NEW) after removing from the hash list 2505 * will DTRT. 2506 */ 2507static void __wait_on_freeing_inode(struct inode *inode, bool is_inode_hash_locked) 2508{ 2509 struct wait_bit_queue_entry wqe; 2510 struct wait_queue_head *wq_head; 2511 2512 /* 2513 * Handle racing against evict(), see that routine for more details. 2514 */ 2515 if (unlikely(inode_unhashed(inode))) { 2516 WARN_ON(is_inode_hash_locked); 2517 spin_unlock(&inode->i_lock); 2518 return; 2519 } 2520 2521 wq_head = inode_bit_waitqueue(&wqe, inode, __I_NEW); 2522 prepare_to_wait_event(wq_head, &wqe.wq_entry, TASK_UNINTERRUPTIBLE); 2523 spin_unlock(&inode->i_lock); 2524 rcu_read_unlock(); 2525 if (is_inode_hash_locked) 2526 spin_unlock(&inode_hash_lock); 2527 schedule(); 2528 finish_wait(wq_head, &wqe.wq_entry); 2529 if (is_inode_hash_locked) 2530 spin_lock(&inode_hash_lock); 2531 rcu_read_lock(); 2532} 2533 2534static __initdata unsigned long ihash_entries; 2535static int __init set_ihash_entries(char *str) 2536{ 2537 if (!str) 2538 return 0; 2539 ihash_entries = simple_strtoul(str, &str, 0); 2540 return 1; 2541} 2542__setup("ihash_entries=", set_ihash_entries); 2543 2544/* 2545 * Initialize the waitqueues and inode hash table. 2546 */ 2547void __init inode_init_early(void) 2548{ 2549 /* If hashes are distributed across NUMA nodes, defer 2550 * hash allocation until vmalloc space is available. 2551 */ 2552 if (hashdist) 2553 return; 2554 2555 inode_hashtable = 2556 alloc_large_system_hash("Inode-cache", 2557 sizeof(struct hlist_head), 2558 ihash_entries, 2559 14, 2560 HASH_EARLY | HASH_ZERO, 2561 &i_hash_shift, 2562 &i_hash_mask, 2563 0, 2564 0); 2565} 2566 2567void __init inode_init(void) 2568{ 2569 /* inode slab cache */ 2570 inode_cachep = kmem_cache_create("inode_cache", 2571 sizeof(struct inode), 2572 0, 2573 (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC| 2574 SLAB_ACCOUNT), 2575 init_once); 2576 2577 /* Hash may have been set up in inode_init_early */ 2578 if (!hashdist) 2579 return; 2580 2581 inode_hashtable = 2582 alloc_large_system_hash("Inode-cache", 2583 sizeof(struct hlist_head), 2584 ihash_entries, 2585 14, 2586 HASH_ZERO, 2587 &i_hash_shift, 2588 &i_hash_mask, 2589 0, 2590 0); 2591} 2592 2593void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev) 2594{ 2595 inode->i_mode = mode; 2596 switch (inode->i_mode & S_IFMT) { 2597 case S_IFCHR: 2598 inode->i_fop = &def_chr_fops; 2599 inode->i_rdev = rdev; 2600 break; 2601 case S_IFBLK: 2602 if (IS_ENABLED(CONFIG_BLOCK)) 2603 inode->i_fop = &def_blk_fops; 2604 inode->i_rdev = rdev; 2605 break; 2606 case S_IFIFO: 2607 inode->i_fop = &pipefifo_fops; 2608 break; 2609 case S_IFSOCK: 2610 /* leave it no_open_fops */ 2611 break; 2612 default: 2613 printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o) for" 2614 " inode %s:%lu\n", mode, inode->i_sb->s_id, 2615 inode->i_ino); 2616 break; 2617 } 2618} 2619EXPORT_SYMBOL(init_special_inode); 2620 2621/** 2622 * inode_init_owner - Init uid,gid,mode for new inode according to posix standards 2623 * @idmap: idmap of the mount the inode was created from 2624 * @inode: New inode 2625 * @dir: Directory inode 2626 * @mode: mode of the new inode 2627 * 2628 * If the inode has been created through an idmapped mount the idmap of 2629 * the vfsmount must be passed through @idmap. This function will then take 2630 * care to map the inode according to @idmap before checking permissions 2631 * and initializing i_uid and i_gid. On non-idmapped mounts or if permission 2632 * checking is to be performed on the raw inode simply pass @nop_mnt_idmap. 2633 */ 2634void inode_init_owner(struct mnt_idmap *idmap, struct inode *inode, 2635 const struct inode *dir, umode_t mode) 2636{ 2637 inode_fsuid_set(inode, idmap); 2638 if (dir && dir->i_mode & S_ISGID) { 2639 inode->i_gid = dir->i_gid; 2640 2641 /* Directories are special, and always inherit S_ISGID */ 2642 if (S_ISDIR(mode)) 2643 mode |= S_ISGID; 2644 } else 2645 inode_fsgid_set(inode, idmap); 2646 inode->i_mode = mode; 2647} 2648EXPORT_SYMBOL(inode_init_owner); 2649 2650/** 2651 * inode_owner_or_capable - check current task permissions to inode 2652 * @idmap: idmap of the mount the inode was found from 2653 * @inode: inode being checked 2654 * 2655 * Return true if current either has CAP_FOWNER in a namespace with the 2656 * inode owner uid mapped, or owns the file. 2657 * 2658 * If the inode has been found through an idmapped mount the idmap of 2659 * the vfsmount must be passed through @idmap. This function will then take 2660 * care to map the inode according to @idmap before checking permissions. 2661 * On non-idmapped mounts or if permission checking is to be performed on the 2662 * raw inode simply pass @nop_mnt_idmap. 2663 */ 2664bool inode_owner_or_capable(struct mnt_idmap *idmap, 2665 const struct inode *inode) 2666{ 2667 vfsuid_t vfsuid; 2668 struct user_namespace *ns; 2669 2670 vfsuid = i_uid_into_vfsuid(idmap, inode); 2671 if (vfsuid_eq_kuid(vfsuid, current_fsuid())) 2672 return true; 2673 2674 ns = current_user_ns(); 2675 if (vfsuid_has_mapping(ns, vfsuid) && ns_capable(ns, CAP_FOWNER)) 2676 return true; 2677 return false; 2678} 2679EXPORT_SYMBOL(inode_owner_or_capable); 2680 2681/* 2682 * Direct i/o helper functions 2683 */ 2684bool inode_dio_finished(const struct inode *inode) 2685{ 2686 return atomic_read(&inode->i_dio_count) == 0; 2687} 2688EXPORT_SYMBOL(inode_dio_finished); 2689 2690/** 2691 * inode_dio_wait - wait for outstanding DIO requests to finish 2692 * @inode: inode to wait for 2693 * 2694 * Waits for all pending direct I/O requests to finish so that we can 2695 * proceed with a truncate or equivalent operation. 2696 * 2697 * Must be called under a lock that serializes taking new references 2698 * to i_dio_count, usually by inode->i_rwsem. 2699 */ 2700void inode_dio_wait(struct inode *inode) 2701{ 2702 wait_var_event(&inode->i_dio_count, inode_dio_finished(inode)); 2703} 2704EXPORT_SYMBOL(inode_dio_wait); 2705 2706void inode_dio_wait_interruptible(struct inode *inode) 2707{ 2708 wait_var_event_interruptible(&inode->i_dio_count, 2709 inode_dio_finished(inode)); 2710} 2711EXPORT_SYMBOL(inode_dio_wait_interruptible); 2712 2713/* 2714 * inode_set_flags - atomically set some inode flags 2715 * 2716 * Note: the caller should be holding i_rwsem exclusively, or else be sure that 2717 * they have exclusive access to the inode structure (i.e., while the 2718 * inode is being instantiated). The reason for the cmpxchg() loop 2719 * --- which wouldn't be necessary if all code paths which modify 2720 * i_flags actually followed this rule, is that there is at least one 2721 * code path which doesn't today so we use cmpxchg() out of an abundance 2722 * of caution. 2723 * 2724 * In the long run, i_rwsem is overkill, and we should probably look 2725 * at using the i_lock spinlock to protect i_flags, and then make sure 2726 * it is so documented in include/linux/fs.h and that all code follows 2727 * the locking convention!! 2728 */ 2729void inode_set_flags(struct inode *inode, unsigned int flags, 2730 unsigned int mask) 2731{ 2732 WARN_ON_ONCE(flags & ~mask); 2733 set_mask_bits(&inode->i_flags, mask, flags); 2734} 2735EXPORT_SYMBOL(inode_set_flags); 2736 2737void inode_nohighmem(struct inode *inode) 2738{ 2739 mapping_set_gfp_mask(inode->i_mapping, GFP_USER); 2740} 2741EXPORT_SYMBOL(inode_nohighmem); 2742 2743struct timespec64 inode_set_ctime_to_ts(struct inode *inode, struct timespec64 ts) 2744{ 2745 trace_inode_set_ctime_to_ts(inode, &ts); 2746 set_normalized_timespec64(&ts, ts.tv_sec, ts.tv_nsec); 2747 inode->i_ctime_sec = ts.tv_sec; 2748 inode->i_ctime_nsec = ts.tv_nsec; 2749 return ts; 2750} 2751EXPORT_SYMBOL(inode_set_ctime_to_ts); 2752 2753/** 2754 * timestamp_truncate - Truncate timespec to a granularity 2755 * @t: Timespec 2756 * @inode: inode being updated 2757 * 2758 * Truncate a timespec to the granularity supported by the fs 2759 * containing the inode. Always rounds down. gran must 2760 * not be 0 nor greater than a second (NSEC_PER_SEC, or 10^9 ns). 2761 */ 2762struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode) 2763{ 2764 struct super_block *sb = inode->i_sb; 2765 unsigned int gran = sb->s_time_gran; 2766 2767 t.tv_sec = clamp(t.tv_sec, sb->s_time_min, sb->s_time_max); 2768 if (unlikely(t.tv_sec == sb->s_time_max || t.tv_sec == sb->s_time_min)) 2769 t.tv_nsec = 0; 2770 2771 /* Avoid division in the common cases 1 ns and 1 s. */ 2772 if (gran == 1) 2773 ; /* nothing */ 2774 else if (gran == NSEC_PER_SEC) 2775 t.tv_nsec = 0; 2776 else if (gran > 1 && gran < NSEC_PER_SEC) 2777 t.tv_nsec -= t.tv_nsec % gran; 2778 else 2779 WARN(1, "invalid file time granularity: %u", gran); 2780 return t; 2781} 2782EXPORT_SYMBOL(timestamp_truncate); 2783 2784/** 2785 * inode_set_ctime_current - set the ctime to current_time 2786 * @inode: inode 2787 * 2788 * Set the inode's ctime to the current value for the inode. Returns the 2789 * current value that was assigned. If this is not a multigrain inode, then we 2790 * set it to the later of the coarse time and floor value. 2791 * 2792 * If it is multigrain, then we first see if the coarse-grained timestamp is 2793 * distinct from what is already there. If so, then use that. Otherwise, get a 2794 * fine-grained timestamp. 2795 * 2796 * After that, try to swap the new value into i_ctime_nsec. Accept the 2797 * resulting ctime, regardless of the outcome of the swap. If it has 2798 * already been replaced, then that timestamp is later than the earlier 2799 * unacceptable one, and is thus acceptable. 2800 */ 2801struct timespec64 inode_set_ctime_current(struct inode *inode) 2802{ 2803 struct timespec64 now; 2804 u32 cns, cur; 2805 2806 ktime_get_coarse_real_ts64_mg(&now); 2807 now = timestamp_truncate(now, inode); 2808 2809 /* Just return that if this is not a multigrain fs */ 2810 if (!is_mgtime(inode)) { 2811 inode_set_ctime_to_ts(inode, now); 2812 goto out; 2813 } 2814 2815 /* 2816 * A fine-grained time is only needed if someone has queried 2817 * for timestamps, and the current coarse grained time isn't 2818 * later than what's already there. 2819 */ 2820 cns = smp_load_acquire(&inode->i_ctime_nsec); 2821 if (cns & I_CTIME_QUERIED) { 2822 struct timespec64 ctime = { .tv_sec = inode->i_ctime_sec, 2823 .tv_nsec = cns & ~I_CTIME_QUERIED }; 2824 2825 if (timespec64_compare(&now, &ctime) <= 0) { 2826 ktime_get_real_ts64_mg(&now); 2827 now = timestamp_truncate(now, inode); 2828 mgtime_counter_inc(mg_fine_stamps); 2829 } 2830 } 2831 mgtime_counter_inc(mg_ctime_updates); 2832 2833 /* No need to cmpxchg if it's exactly the same */ 2834 if (cns == now.tv_nsec && inode->i_ctime_sec == now.tv_sec) { 2835 trace_ctime_xchg_skip(inode, &now); 2836 goto out; 2837 } 2838 cur = cns; 2839retry: 2840 /* Try to swap the nsec value into place. */ 2841 if (try_cmpxchg(&inode->i_ctime_nsec, &cur, now.tv_nsec)) { 2842 /* If swap occurred, then we're (mostly) done */ 2843 inode->i_ctime_sec = now.tv_sec; 2844 trace_ctime_ns_xchg(inode, cns, now.tv_nsec, cur); 2845 mgtime_counter_inc(mg_ctime_swaps); 2846 } else { 2847 /* 2848 * Was the change due to someone marking the old ctime QUERIED? 2849 * If so then retry the swap. This can only happen once since 2850 * the only way to clear I_CTIME_QUERIED is to stamp the inode 2851 * with a new ctime. 2852 */ 2853 if (!(cns & I_CTIME_QUERIED) && (cns | I_CTIME_QUERIED) == cur) { 2854 cns = cur; 2855 goto retry; 2856 } 2857 /* Otherwise, keep the existing ctime */ 2858 now.tv_sec = inode->i_ctime_sec; 2859 now.tv_nsec = cur & ~I_CTIME_QUERIED; 2860 } 2861out: 2862 return now; 2863} 2864EXPORT_SYMBOL(inode_set_ctime_current); 2865 2866/** 2867 * inode_set_ctime_deleg - try to update the ctime on a delegated inode 2868 * @inode: inode to update 2869 * @update: timespec64 to set the ctime 2870 * 2871 * Attempt to atomically update the ctime on behalf of a delegation holder. 2872 * 2873 * The nfs server can call back the holder of a delegation to get updated 2874 * inode attributes, including the mtime. When updating the mtime, update 2875 * the ctime to a value at least equal to that. 2876 * 2877 * This can race with concurrent updates to the inode, in which 2878 * case the update is skipped. 2879 * 2880 * Note that this works even when multigrain timestamps are not enabled, 2881 * so it is used in either case. 2882 */ 2883struct timespec64 inode_set_ctime_deleg(struct inode *inode, struct timespec64 update) 2884{ 2885 struct timespec64 now, cur_ts; 2886 u32 cur, old; 2887 2888 /* pairs with try_cmpxchg below */ 2889 cur = smp_load_acquire(&inode->i_ctime_nsec); 2890 cur_ts.tv_nsec = cur & ~I_CTIME_QUERIED; 2891 cur_ts.tv_sec = inode->i_ctime_sec; 2892 2893 /* If the update is older than the existing value, skip it. */ 2894 if (timespec64_compare(&update, &cur_ts) <= 0) 2895 return cur_ts; 2896 2897 ktime_get_coarse_real_ts64_mg(&now); 2898 2899 /* Clamp the update to "now" if it's in the future */ 2900 if (timespec64_compare(&update, &now) > 0) 2901 update = now; 2902 2903 update = timestamp_truncate(update, inode); 2904 2905 /* No need to update if the values are already the same */ 2906 if (timespec64_equal(&update, &cur_ts)) 2907 return cur_ts; 2908 2909 /* 2910 * Try to swap the nsec value into place. If it fails, that means 2911 * it raced with an update due to a write or similar activity. That 2912 * stamp takes precedence, so just skip the update. 2913 */ 2914retry: 2915 old = cur; 2916 if (try_cmpxchg(&inode->i_ctime_nsec, &cur, update.tv_nsec)) { 2917 inode->i_ctime_sec = update.tv_sec; 2918 mgtime_counter_inc(mg_ctime_swaps); 2919 return update; 2920 } 2921 2922 /* 2923 * Was the change due to another task marking the old ctime QUERIED? 2924 * 2925 * If so, then retry the swap. This can only happen once since 2926 * the only way to clear I_CTIME_QUERIED is to stamp the inode 2927 * with a new ctime. 2928 */ 2929 if (!(old & I_CTIME_QUERIED) && (cur == (old | I_CTIME_QUERIED))) 2930 goto retry; 2931 2932 /* Otherwise, it was a new timestamp. */ 2933 cur_ts.tv_sec = inode->i_ctime_sec; 2934 cur_ts.tv_nsec = cur & ~I_CTIME_QUERIED; 2935 return cur_ts; 2936} 2937EXPORT_SYMBOL(inode_set_ctime_deleg); 2938 2939/** 2940 * in_group_or_capable - check whether caller is CAP_FSETID privileged 2941 * @idmap: idmap of the mount @inode was found from 2942 * @inode: inode to check 2943 * @vfsgid: the new/current vfsgid of @inode 2944 * 2945 * Check whether @vfsgid is in the caller's group list or if the caller is 2946 * privileged with CAP_FSETID over @inode. This can be used to determine 2947 * whether the setgid bit can be kept or must be dropped. 2948 * 2949 * Return: true if the caller is sufficiently privileged, false if not. 2950 */ 2951bool in_group_or_capable(struct mnt_idmap *idmap, 2952 const struct inode *inode, vfsgid_t vfsgid) 2953{ 2954 if (vfsgid_in_group_p(vfsgid)) 2955 return true; 2956 if (capable_wrt_inode_uidgid(idmap, inode, CAP_FSETID)) 2957 return true; 2958 return false; 2959} 2960EXPORT_SYMBOL(in_group_or_capable); 2961 2962/** 2963 * mode_strip_sgid - handle the sgid bit for non-directories 2964 * @idmap: idmap of the mount the inode was created from 2965 * @dir: parent directory inode 2966 * @mode: mode of the file to be created in @dir 2967 * 2968 * If the @mode of the new file has both the S_ISGID and S_IXGRP bit 2969 * raised and @dir has the S_ISGID bit raised ensure that the caller is 2970 * either in the group of the parent directory or they have CAP_FSETID 2971 * in their user namespace and are privileged over the parent directory. 2972 * In all other cases, strip the S_ISGID bit from @mode. 2973 * 2974 * Return: the new mode to use for the file 2975 */ 2976umode_t mode_strip_sgid(struct mnt_idmap *idmap, 2977 const struct inode *dir, umode_t mode) 2978{ 2979 if ((mode & (S_ISGID | S_IXGRP)) != (S_ISGID | S_IXGRP)) 2980 return mode; 2981 if (S_ISDIR(mode) || !dir || !(dir->i_mode & S_ISGID)) 2982 return mode; 2983 if (in_group_or_capable(idmap, dir, i_gid_into_vfsgid(idmap, dir))) 2984 return mode; 2985 return mode & ~S_ISGID; 2986} 2987EXPORT_SYMBOL(mode_strip_sgid); 2988 2989#ifdef CONFIG_DEBUG_VFS 2990/* 2991 * Dump an inode. 2992 * 2993 * TODO: add a proper inode dumping routine, this is a stub to get debug off the 2994 * ground. 2995 * 2996 * TODO: handle getting to fs type with get_kernel_nofault()? 2997 * See dump_mapping() above. 2998 */ 2999void dump_inode(struct inode *inode, const char *reason) 3000{ 3001 struct super_block *sb = inode->i_sb; 3002 3003 pr_warn("%s encountered for inode %px\n" 3004 "fs %s mode %ho opflags 0x%hx flags 0x%x state 0x%x count %d\n", 3005 reason, inode, sb->s_type->name, inode->i_mode, inode->i_opflags, 3006 inode->i_flags, inode_state_read_once(inode), atomic_read(&inode->i_count)); 3007} 3008 3009EXPORT_SYMBOL(dump_inode); 3010#endif
~/
Read-only file preview.