]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - fs/inode.c
Merge tag 'arm-soc-fixes-for-5.7' of git://git.kernel.org/pub/scm/linux/kernel/git...
[mirror_ubuntu-jammy-kernel.git] / fs / inode.c
CommitLineData
457c8996 1// SPDX-License-Identifier: GPL-2.0-only
1da177e4 2/*
1da177e4 3 * (C) 1997 Linus Torvalds
4b4563dc 4 * (C) 1999 Andrea Arcangeli <andrea@suse.de> (dynamic inode allocation)
1da177e4 5 */
e59cc473 6#include <linux/export.h>
1da177e4
LT
7#include <linux/fs.h>
8#include <linux/mm.h>
1da177e4 9#include <linux/backing-dev.h>
1da177e4
LT
10#include <linux/hash.h>
11#include <linux/swap.h>
12#include <linux/security.h>
1da177e4 13#include <linux/cdev.h>
57c8a661 14#include <linux/memblock.h>
6e1918cf 15#include <linux/fscrypt.h>
3be25f49 16#include <linux/fsnotify.h>
fc33a7bb 17#include <linux/mount.h>
f19d4a8f 18#include <linux/posix_acl.h>
9ce6e0be 19#include <linux/prefetch.h>
4b4563dc 20#include <linux/buffer_head.h> /* for inode_has_buffers */
7ada4db8 21#include <linux/ratelimit.h>
bc3b14cb 22#include <linux/list_lru.h>
ae5e165d 23#include <linux/iversion.h>
0ae45f63 24#include <trace/events/writeback.h>
a66979ab 25#include "internal.h"
1da177e4 26
250df6ed 27/*
4b4563dc 28 * Inode locking rules:
250df6ed
DC
29 *
30 * inode->i_lock protects:
31 * inode->i_state, inode->i_hash, __iget()
bc3b14cb 32 * Inode LRU list locks protect:
98b745c6 33 * inode->i_sb->s_inode_lru, inode->i_lru
74278da9
DC
34 * inode->i_sb->s_inode_list_lock protects:
35 * inode->i_sb->s_inodes, inode->i_sb_list
f758eeab 36 * bdi->wb.list_lock protects:
c7f54084 37 * bdi->wb.b_{dirty,io,more_io,dirty_time}, inode->i_io_list
67a23c49
DC
38 * inode_hash_lock protects:
39 * inode_hashtable, inode->i_hash
250df6ed
DC
40 *
41 * Lock ordering:
55fa6091 42 *
74278da9 43 * inode->i_sb->s_inode_list_lock
55fa6091 44 * inode->i_lock
bc3b14cb 45 * Inode LRU list locks
a66979ab 46 *
f758eeab 47 * bdi->wb.list_lock
a66979ab 48 * inode->i_lock
67a23c49
DC
49 *
50 * inode_hash_lock
74278da9 51 * inode->i_sb->s_inode_list_lock
67a23c49
DC
52 * inode->i_lock
53 *
54 * iunique_lock
55 * inode_hash_lock
250df6ed
DC
56 */
57
fa3536cc
ED
58static unsigned int i_hash_mask __read_mostly;
59static unsigned int i_hash_shift __read_mostly;
67a23c49
DC
60static struct hlist_head *inode_hashtable __read_mostly;
61static __cacheline_aligned_in_smp DEFINE_SPINLOCK(inode_hash_lock);
1da177e4 62
7dcda1c9
JA
63/*
64 * Empty aops. Can be used for the cases where the user does not
65 * define any of the address_space operations.
66 */
67const struct address_space_operations empty_aops = {
68};
69EXPORT_SYMBOL(empty_aops);
70
1da177e4
LT
71/*
72 * Statistics gathering..
73 */
74struct inodes_stat_t inodes_stat;
75
3942c07c
GC
76static DEFINE_PER_CPU(unsigned long, nr_inodes);
77static DEFINE_PER_CPU(unsigned long, nr_unused);
cffbc8aa 78
6b3304b5 79static struct kmem_cache *inode_cachep __read_mostly;
1da177e4 80
3942c07c 81static long get_nr_inodes(void)
cffbc8aa 82{
3e880fb5 83 int i;
3942c07c 84 long sum = 0;
3e880fb5
NP
85 for_each_possible_cpu(i)
86 sum += per_cpu(nr_inodes, i);
87 return sum < 0 ? 0 : sum;
cffbc8aa
DC
88}
89
3942c07c 90static inline long get_nr_inodes_unused(void)
cffbc8aa 91{
fcb94f72 92 int i;
3942c07c 93 long sum = 0;
fcb94f72
DC
94 for_each_possible_cpu(i)
95 sum += per_cpu(nr_unused, i);
96 return sum < 0 ? 0 : sum;
cffbc8aa
DC
97}
98
3942c07c 99long get_nr_dirty_inodes(void)
cffbc8aa 100{
3e880fb5 101 /* not actually dirty inodes, but a wild approximation */
3942c07c 102 long nr_dirty = get_nr_inodes() - get_nr_inodes_unused();
cffbc8aa 103 return nr_dirty > 0 ? nr_dirty : 0;
cffbc8aa
DC
104}
105
106/*
107 * Handle nr_inode sysctl
108 */
109#ifdef CONFIG_SYSCTL
1f7e0616 110int proc_nr_inodes(struct ctl_table *table, int write,
cffbc8aa
DC
111 void __user *buffer, size_t *lenp, loff_t *ppos)
112{
113 inodes_stat.nr_inodes = get_nr_inodes();
fcb94f72 114 inodes_stat.nr_unused = get_nr_inodes_unused();
3942c07c 115 return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
cffbc8aa
DC
116}
117#endif
118
bd9b51e7
AV
119static int no_open(struct inode *inode, struct file *file)
120{
121 return -ENXIO;
122}
123
2cb1599f 124/**
6e7c2b4d 125 * inode_init_always - perform inode structure initialisation
0bc02f3f
RD
126 * @sb: superblock inode belongs to
127 * @inode: inode to initialise
2cb1599f
DC
128 *
129 * These are initializations that need to be done on every inode
130 * allocation as the fields are not initialised by slab allocation.
131 */
54e34621 132int inode_init_always(struct super_block *sb, struct inode *inode)
1da177e4 133{
6e1d5dcc 134 static const struct inode_operations empty_iops;
bd9b51e7 135 static const struct file_operations no_open_fops = {.open = no_open};
6b3304b5 136 struct address_space *const mapping = &inode->i_data;
2cb1599f
DC
137
138 inode->i_sb = sb;
139 inode->i_blkbits = sb->s_blocksize_bits;
140 inode->i_flags = 0;
8019ad13 141 atomic64_set(&inode->i_sequence, 0);
2cb1599f
DC
142 atomic_set(&inode->i_count, 1);
143 inode->i_op = &empty_iops;
bd9b51e7 144 inode->i_fop = &no_open_fops;
a78ef704 145 inode->__i_nlink = 1;
3ddcd056 146 inode->i_opflags = 0;
d0a5b995
AG
147 if (sb->s_xattr)
148 inode->i_opflags |= IOP_XATTR;
92361636
EB
149 i_uid_write(inode, 0);
150 i_gid_write(inode, 0);
2cb1599f
DC
151 atomic_set(&inode->i_writecount, 0);
152 inode->i_size = 0;
c75b1d94 153 inode->i_write_hint = WRITE_LIFE_NOT_SET;
2cb1599f
DC
154 inode->i_blocks = 0;
155 inode->i_bytes = 0;
156 inode->i_generation = 0;
2cb1599f
DC
157 inode->i_pipe = NULL;
158 inode->i_bdev = NULL;
159 inode->i_cdev = NULL;
61ba64fc 160 inode->i_link = NULL;
84e710da 161 inode->i_dir_seq = 0;
2cb1599f
DC
162 inode->i_rdev = 0;
163 inode->dirtied_when = 0;
6146f0d5 164
3d65ae46
TE
165#ifdef CONFIG_CGROUP_WRITEBACK
166 inode->i_wb_frn_winner = 0;
167 inode->i_wb_frn_avg_time = 0;
168 inode->i_wb_frn_history = 0;
169#endif
170
6146f0d5 171 if (security_inode_alloc(inode))
54e34621 172 goto out;
2cb1599f
DC
173 spin_lock_init(&inode->i_lock);
174 lockdep_set_class(&inode->i_lock, &sb->s_type->i_lock_key);
175
9902af79
AV
176 init_rwsem(&inode->i_rwsem);
177 lockdep_set_class(&inode->i_rwsem, &sb->s_type->i_mutex_key);
2cb1599f 178
bd5fe6c5 179 atomic_set(&inode->i_dio_count, 0);
2cb1599f
DC
180
181 mapping->a_ops = &empty_aops;
182 mapping->host = inode;
183 mapping->flags = 0;
829bc787 184 mapping->wb_err = 0;
4bb5f5d9 185 atomic_set(&mapping->i_mmap_writable, 0);
09d91cda
SL
186#ifdef CONFIG_READ_ONLY_THP_FOR_FS
187 atomic_set(&mapping->nr_thps, 0);
188#endif
3c1d4378 189 mapping_set_gfp_mask(mapping, GFP_HIGHUSER_MOVABLE);
252aa6f5 190 mapping->private_data = NULL;
2cb1599f 191 mapping->writeback_index = 0;
2cb1599f
DC
192 inode->i_private = NULL;
193 inode->i_mapping = mapping;
b3d9b7a3 194 INIT_HLIST_HEAD(&inode->i_dentry); /* buggered by rcu freeing */
f19d4a8f
AV
195#ifdef CONFIG_FS_POSIX_ACL
196 inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
197#endif
2cb1599f 198
3be25f49
EP
199#ifdef CONFIG_FSNOTIFY
200 inode->i_fsnotify_mask = 0;
201#endif
4a075e39 202 inode->i_flctx = NULL;
3e880fb5 203 this_cpu_inc(nr_inodes);
cffbc8aa 204
54e34621 205 return 0;
54e34621
CH
206out:
207 return -ENOMEM;
1da177e4 208}
2cb1599f
DC
209EXPORT_SYMBOL(inode_init_always);
210
fdb0da89
AV
211void free_inode_nonrcu(struct inode *inode)
212{
213 kmem_cache_free(inode_cachep, inode);
214}
215EXPORT_SYMBOL(free_inode_nonrcu);
216
217static void i_callback(struct rcu_head *head)
218{
219 struct inode *inode = container_of(head, struct inode, i_rcu);
220 if (inode->free_inode)
221 inode->free_inode(inode);
222 else
223 free_inode_nonrcu(inode);
224}
225
2cb1599f
DC
226static struct inode *alloc_inode(struct super_block *sb)
227{
fdb0da89 228 const struct super_operations *ops = sb->s_op;
2cb1599f
DC
229 struct inode *inode;
230
fdb0da89
AV
231 if (ops->alloc_inode)
232 inode = ops->alloc_inode(sb);
2cb1599f
DC
233 else
234 inode = kmem_cache_alloc(inode_cachep, GFP_KERNEL);
235
54e34621
CH
236 if (!inode)
237 return NULL;
238
239 if (unlikely(inode_init_always(sb, inode))) {
fdb0da89
AV
240 if (ops->destroy_inode) {
241 ops->destroy_inode(inode);
242 if (!ops->free_inode)
243 return NULL;
244 }
245 inode->free_inode = ops->free_inode;
246 i_callback(&inode->i_rcu);
54e34621
CH
247 return NULL;
248 }
249
250 return inode;
2cb1599f 251}
1da177e4 252
2e00c97e 253void __destroy_inode(struct inode *inode)
1da177e4 254{
b7542f8c 255 BUG_ON(inode_has_buffers(inode));
52ebea74 256 inode_detach_wb(inode);
1da177e4 257 security_inode_free(inode);
3be25f49 258 fsnotify_inode_delete(inode);
f27a0fe0 259 locks_free_lock_context(inode);
7ada4db8
MS
260 if (!inode->i_nlink) {
261 WARN_ON(atomic_long_read(&inode->i_sb->s_remove_count) == 0);
262 atomic_long_dec(&inode->i_sb->s_remove_count);
263 }
264
f19d4a8f 265#ifdef CONFIG_FS_POSIX_ACL
b8a7a3a6 266 if (inode->i_acl && !is_uncached_acl(inode->i_acl))
f19d4a8f 267 posix_acl_release(inode->i_acl);
b8a7a3a6 268 if (inode->i_default_acl && !is_uncached_acl(inode->i_default_acl))
f19d4a8f
AV
269 posix_acl_release(inode->i_default_acl);
270#endif
3e880fb5 271 this_cpu_dec(nr_inodes);
2e00c97e
CH
272}
273EXPORT_SYMBOL(__destroy_inode);
274
56b0dacf 275static void destroy_inode(struct inode *inode)
2e00c97e 276{
fdb0da89
AV
277 const struct super_operations *ops = inode->i_sb->s_op;
278
7ccf19a8 279 BUG_ON(!list_empty(&inode->i_lru));
2e00c97e 280 __destroy_inode(inode);
fdb0da89
AV
281 if (ops->destroy_inode) {
282 ops->destroy_inode(inode);
283 if (!ops->free_inode)
284 return;
285 }
286 inode->free_inode = ops->free_inode;
287 call_rcu(&inode->i_rcu, i_callback);
1da177e4 288}
1da177e4 289
7ada4db8
MS
290/**
291 * drop_nlink - directly drop an inode's link count
292 * @inode: inode
293 *
294 * This is a low-level filesystem helper to replace any
295 * direct filesystem manipulation of i_nlink. In cases
296 * where we are attempting to track writes to the
297 * filesystem, a decrement to zero means an imminent
298 * write when the file is truncated and actually unlinked
299 * on the filesystem.
300 */
301void drop_nlink(struct inode *inode)
302{
303 WARN_ON(inode->i_nlink == 0);
304 inode->__i_nlink--;
305 if (!inode->i_nlink)
306 atomic_long_inc(&inode->i_sb->s_remove_count);
307}
308EXPORT_SYMBOL(drop_nlink);
309
310/**
311 * clear_nlink - directly zero an inode's link count
312 * @inode: inode
313 *
314 * This is a low-level filesystem helper to replace any
315 * direct filesystem manipulation of i_nlink. See
316 * drop_nlink() for why we care about i_nlink hitting zero.
317 */
318void clear_nlink(struct inode *inode)
319{
320 if (inode->i_nlink) {
321 inode->__i_nlink = 0;
322 atomic_long_inc(&inode->i_sb->s_remove_count);
323 }
324}
325EXPORT_SYMBOL(clear_nlink);
326
327/**
328 * set_nlink - directly set an inode's link count
329 * @inode: inode
330 * @nlink: new nlink (should be non-zero)
331 *
332 * This is a low-level filesystem helper to replace any
333 * direct filesystem manipulation of i_nlink.
334 */
335void set_nlink(struct inode *inode, unsigned int nlink)
336{
337 if (!nlink) {
7ada4db8
MS
338 clear_nlink(inode);
339 } else {
340 /* Yes, some filesystems do change nlink from zero to one */
341 if (inode->i_nlink == 0)
342 atomic_long_dec(&inode->i_sb->s_remove_count);
343
344 inode->__i_nlink = nlink;
345 }
346}
347EXPORT_SYMBOL(set_nlink);
348
349/**
350 * inc_nlink - directly increment an inode's link count
351 * @inode: inode
352 *
353 * This is a low-level filesystem helper to replace any
354 * direct filesystem manipulation of i_nlink. Currently,
355 * it is only here for parity with dec_nlink().
356 */
357void inc_nlink(struct inode *inode)
358{
f4e0c30c
AV
359 if (unlikely(inode->i_nlink == 0)) {
360 WARN_ON(!(inode->i_state & I_LINKABLE));
7ada4db8 361 atomic_long_dec(&inode->i_sb->s_remove_count);
f4e0c30c 362 }
7ada4db8
MS
363
364 inode->__i_nlink++;
365}
366EXPORT_SYMBOL(inc_nlink);
367
ae23395d 368static void __address_space_init_once(struct address_space *mapping)
2aa15890 369{
7b785645 370 xa_init_flags(&mapping->i_pages, XA_FLAGS_LOCK_IRQ | XA_FLAGS_ACCOUNT);
c8c06efa 371 init_rwsem(&mapping->i_mmap_rwsem);
2aa15890
MS
372 INIT_LIST_HEAD(&mapping->private_list);
373 spin_lock_init(&mapping->private_lock);
f808c13f 374 mapping->i_mmap = RB_ROOT_CACHED;
2aa15890 375}
ae23395d
DC
376
377void address_space_init_once(struct address_space *mapping)
378{
379 memset(mapping, 0, sizeof(*mapping));
380 __address_space_init_once(mapping);
381}
2aa15890
MS
382EXPORT_SYMBOL(address_space_init_once);
383
1da177e4
LT
384/*
385 * These are initializations that only need to be done
386 * once, because the fields are idempotent across use
387 * of the inode, so let the slab aware of that.
388 */
389void inode_init_once(struct inode *inode)
390{
391 memset(inode, 0, sizeof(*inode));
392 INIT_HLIST_NODE(&inode->i_hash);
1da177e4 393 INIT_LIST_HEAD(&inode->i_devices);
c7f54084 394 INIT_LIST_HEAD(&inode->i_io_list);
6c60d2b5 395 INIT_LIST_HEAD(&inode->i_wb_list);
7ccf19a8 396 INIT_LIST_HEAD(&inode->i_lru);
ae23395d 397 __address_space_init_once(&inode->i_data);
1da177e4
LT
398 i_size_ordered_init(inode);
399}
1da177e4
LT
400EXPORT_SYMBOL(inode_init_once);
401
51cc5068 402static void init_once(void *foo)
1da177e4 403{
6b3304b5 404 struct inode *inode = (struct inode *) foo;
1da177e4 405
a35afb83 406 inode_init_once(inode);
1da177e4
LT
407}
408
409/*
250df6ed 410 * inode->i_lock must be held
1da177e4 411 */
6b3304b5 412void __iget(struct inode *inode)
1da177e4 413{
9e38d86f
NP
414 atomic_inc(&inode->i_count);
415}
2e147f1e 416
7de9c6ee
AV
417/*
418 * get additional reference to inode; caller must already hold one.
419 */
420void ihold(struct inode *inode)
421{
422 WARN_ON(atomic_inc_return(&inode->i_count) < 2);
423}
424EXPORT_SYMBOL(ihold);
425
9e38d86f
NP
426static void inode_lru_list_add(struct inode *inode)
427{
bc3b14cb 428 if (list_lru_add(&inode->i_sb->s_inode_lru, &inode->i_lru))
fcb94f72 429 this_cpu_inc(nr_unused);
563f4001
JB
430 else
431 inode->i_state |= I_REFERENCED;
9e38d86f 432}
2e147f1e 433
4eff96dd
JK
434/*
435 * Add inode to LRU if needed (inode is unused and clean).
436 *
437 * Needs inode->i_lock held.
438 */
439void inode_add_lru(struct inode *inode)
440{
0ae45f63
TT
441 if (!(inode->i_state & (I_DIRTY_ALL | I_SYNC |
442 I_FREEING | I_WILL_FREE)) &&
1751e8a6 443 !atomic_read(&inode->i_count) && inode->i_sb->s_flags & SB_ACTIVE)
4eff96dd
JK
444 inode_lru_list_add(inode);
445}
446
447
9e38d86f
NP
448static void inode_lru_list_del(struct inode *inode)
449{
bc3b14cb
DC
450
451 if (list_lru_del(&inode->i_sb->s_inode_lru, &inode->i_lru))
fcb94f72 452 this_cpu_dec(nr_unused);
1da177e4
LT
453}
454
646ec461
CH
455/**
456 * inode_sb_list_add - add inode to the superblock list of inodes
457 * @inode: inode to add
458 */
459void inode_sb_list_add(struct inode *inode)
460{
74278da9 461 spin_lock(&inode->i_sb->s_inode_list_lock);
55fa6091 462 list_add(&inode->i_sb_list, &inode->i_sb->s_inodes);
74278da9 463 spin_unlock(&inode->i_sb->s_inode_list_lock);
646ec461
CH
464}
465EXPORT_SYMBOL_GPL(inode_sb_list_add);
466
55fa6091 467static inline void inode_sb_list_del(struct inode *inode)
646ec461 468{
a209dfc7 469 if (!list_empty(&inode->i_sb_list)) {
74278da9 470 spin_lock(&inode->i_sb->s_inode_list_lock);
a209dfc7 471 list_del_init(&inode->i_sb_list);
74278da9 472 spin_unlock(&inode->i_sb->s_inode_list_lock);
a209dfc7 473 }
646ec461
CH
474}
475
4c51acbc
DC
476static unsigned long hash(struct super_block *sb, unsigned long hashval)
477{
478 unsigned long tmp;
479
480 tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) /
481 L1_CACHE_BYTES;
4b4563dc
CH
482 tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> i_hash_shift);
483 return tmp & i_hash_mask;
4c51acbc
DC
484}
485
486/**
487 * __insert_inode_hash - hash an inode
488 * @inode: unhashed inode
489 * @hashval: unsigned long value used to locate this object in the
490 * inode_hashtable.
491 *
492 * Add an inode to the inode hash for this superblock.
493 */
494void __insert_inode_hash(struct inode *inode, unsigned long hashval)
495{
646ec461
CH
496 struct hlist_head *b = inode_hashtable + hash(inode->i_sb, hashval);
497
67a23c49 498 spin_lock(&inode_hash_lock);
250df6ed 499 spin_lock(&inode->i_lock);
646ec461 500 hlist_add_head(&inode->i_hash, b);
250df6ed 501 spin_unlock(&inode->i_lock);
67a23c49 502 spin_unlock(&inode_hash_lock);
4c51acbc
DC
503}
504EXPORT_SYMBOL(__insert_inode_hash);
505
4c51acbc 506/**
f2ee7abf 507 * __remove_inode_hash - remove an inode from the hash
4c51acbc
DC
508 * @inode: inode to unhash
509 *
510 * Remove an inode from the superblock.
511 */
f2ee7abf 512void __remove_inode_hash(struct inode *inode)
4c51acbc 513{
67a23c49 514 spin_lock(&inode_hash_lock);
250df6ed 515 spin_lock(&inode->i_lock);
4c51acbc 516 hlist_del_init(&inode->i_hash);
250df6ed 517 spin_unlock(&inode->i_lock);
67a23c49 518 spin_unlock(&inode_hash_lock);
4c51acbc 519}
f2ee7abf 520EXPORT_SYMBOL(__remove_inode_hash);
4c51acbc 521
dbd5768f 522void clear_inode(struct inode *inode)
b0683aa6 523{
08142579 524 /*
b93b0163 525 * We have to cycle the i_pages lock here because reclaim can be in the
08142579 526 * process of removing the last page (in __delete_from_page_cache())
b93b0163 527 * and we must not free the mapping under it.
08142579 528 */
b93b0163 529 xa_lock_irq(&inode->i_data.i_pages);
b0683aa6 530 BUG_ON(inode->i_data.nrpages);
f9fe48be 531 BUG_ON(inode->i_data.nrexceptional);
b93b0163 532 xa_unlock_irq(&inode->i_data.i_pages);
b0683aa6
AV
533 BUG_ON(!list_empty(&inode->i_data.private_list));
534 BUG_ON(!(inode->i_state & I_FREEING));
535 BUG_ON(inode->i_state & I_CLEAR);
6c60d2b5 536 BUG_ON(!list_empty(&inode->i_wb_list));
fa0d7e3d 537 /* don't need i_lock here, no concurrent mods to i_state */
b0683aa6
AV
538 inode->i_state = I_FREEING | I_CLEAR;
539}
dbd5768f 540EXPORT_SYMBOL(clear_inode);
b0683aa6 541
b2b2af8e
DC
542/*
543 * Free the inode passed in, removing it from the lists it is still connected
544 * to. We remove any pages still attached to the inode and wait for any IO that
545 * is still in progress before finally destroying the inode.
546 *
547 * An inode must already be marked I_FREEING so that we avoid the inode being
548 * moved back onto lists if we race with other code that manipulates the lists
549 * (e.g. writeback_single_inode). The caller is responsible for setting this.
550 *
551 * An inode must already be removed from the LRU list before being evicted from
552 * the cache. This should occur atomically with setting the I_FREEING state
553 * flag, so no inodes here should ever be on the LRU when being evicted.
554 */
644da596 555static void evict(struct inode *inode)
b4272d4c
AV
556{
557 const struct super_operations *op = inode->i_sb->s_op;
558
b2b2af8e
DC
559 BUG_ON(!(inode->i_state & I_FREEING));
560 BUG_ON(!list_empty(&inode->i_lru));
561
c7f54084
DC
562 if (!list_empty(&inode->i_io_list))
563 inode_io_list_del(inode);
b12362bd 564
55fa6091
DC
565 inode_sb_list_del(inode);
566
169ebd90
JK
567 /*
568 * Wait for flusher thread to be done with the inode so that filesystem
569 * does not start destroying it while writeback is still running. Since
570 * the inode has I_FREEING set, flusher thread won't start new work on
571 * the inode. We just have to wait for running writeback to finish.
572 */
573 inode_wait_for_writeback(inode);
7994e6f7 574
be7ce416
AV
575 if (op->evict_inode) {
576 op->evict_inode(inode);
b4272d4c 577 } else {
91b0abe3 578 truncate_inode_pages_final(&inode->i_data);
dbd5768f 579 clear_inode(inode);
b4272d4c 580 }
661074e9
AV
581 if (S_ISBLK(inode->i_mode) && inode->i_bdev)
582 bd_forget(inode);
583 if (S_ISCHR(inode->i_mode) && inode->i_cdev)
584 cd_forget(inode);
b2b2af8e
DC
585
586 remove_inode_hash(inode);
587
588 spin_lock(&inode->i_lock);
589 wake_up_bit(&inode->i_state, __I_NEW);
590 BUG_ON(inode->i_state != (I_FREEING | I_CLEAR));
591 spin_unlock(&inode->i_lock);
592
593 destroy_inode(inode);
b4272d4c
AV
594}
595
1da177e4
LT
596/*
597 * dispose_list - dispose of the contents of a local list
598 * @head: the head of the list to free
599 *
600 * Dispose-list gets a local list with local inodes in it, so it doesn't
601 * need to worry about list corruption and SMP locks.
602 */
603static void dispose_list(struct list_head *head)
604{
1da177e4
LT
605 while (!list_empty(head)) {
606 struct inode *inode;
607
7ccf19a8
NP
608 inode = list_first_entry(head, struct inode, i_lru);
609 list_del_init(&inode->i_lru);
1da177e4 610
644da596 611 evict(inode);
ac05fbb4 612 cond_resched();
1da177e4 613 }
1da177e4
LT
614}
615
63997e98
AV
616/**
617 * evict_inodes - evict all evictable inodes for a superblock
618 * @sb: superblock to operate on
619 *
620 * Make sure that no inodes with zero refcount are retained. This is
1751e8a6 621 * called by superblock shutdown after having SB_ACTIVE flag removed,
63997e98
AV
622 * so any inode reaching zero refcount during or after that call will
623 * be immediately evicted.
1da177e4 624 */
63997e98 625void evict_inodes(struct super_block *sb)
1da177e4 626{
63997e98
AV
627 struct inode *inode, *next;
628 LIST_HEAD(dispose);
1da177e4 629
ac05fbb4 630again:
74278da9 631 spin_lock(&sb->s_inode_list_lock);
63997e98
AV
632 list_for_each_entry_safe(inode, next, &sb->s_inodes, i_sb_list) {
633 if (atomic_read(&inode->i_count))
aabb8fdb 634 continue;
250df6ed
DC
635
636 spin_lock(&inode->i_lock);
637 if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
638 spin_unlock(&inode->i_lock);
1da177e4 639 continue;
250df6ed 640 }
63997e98
AV
641
642 inode->i_state |= I_FREEING;
02afc410 643 inode_lru_list_del(inode);
250df6ed 644 spin_unlock(&inode->i_lock);
02afc410 645 list_add(&inode->i_lru, &dispose);
ac05fbb4
JB
646
647 /*
648 * We can have a ton of inodes to evict at unmount time given
649 * enough memory, check to see if we need to go to sleep for a
650 * bit so we don't livelock.
651 */
652 if (need_resched()) {
653 spin_unlock(&sb->s_inode_list_lock);
654 cond_resched();
655 dispose_list(&dispose);
656 goto again;
657 }
1da177e4 658 }
74278da9 659 spin_unlock(&sb->s_inode_list_lock);
63997e98
AV
660
661 dispose_list(&dispose);
1da177e4 662}
799ea9e9 663EXPORT_SYMBOL_GPL(evict_inodes);
1da177e4 664
1da177e4 665/**
a0318786
CH
666 * invalidate_inodes - attempt to free all inodes on a superblock
667 * @sb: superblock to operate on
93b270f7 668 * @kill_dirty: flag to guide handling of dirty inodes
1da177e4 669 *
a0318786
CH
670 * Attempts to free all inodes for a given superblock. If there were any
671 * busy inodes return a non-zero value, else zero.
93b270f7
N
672 * If @kill_dirty is set, discard dirty inodes too, otherwise treat
673 * them as busy.
1da177e4 674 */
93b270f7 675int invalidate_inodes(struct super_block *sb, bool kill_dirty)
1da177e4 676{
cffbc8aa 677 int busy = 0;
a0318786
CH
678 struct inode *inode, *next;
679 LIST_HEAD(dispose);
1da177e4 680
04646aeb 681again:
74278da9 682 spin_lock(&sb->s_inode_list_lock);
a0318786 683 list_for_each_entry_safe(inode, next, &sb->s_inodes, i_sb_list) {
250df6ed
DC
684 spin_lock(&inode->i_lock);
685 if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
686 spin_unlock(&inode->i_lock);
aabb8fdb 687 continue;
250df6ed 688 }
0ae45f63 689 if (inode->i_state & I_DIRTY_ALL && !kill_dirty) {
250df6ed 690 spin_unlock(&inode->i_lock);
93b270f7
N
691 busy = 1;
692 continue;
693 }
99a38919 694 if (atomic_read(&inode->i_count)) {
250df6ed 695 spin_unlock(&inode->i_lock);
99a38919 696 busy = 1;
1da177e4
LT
697 continue;
698 }
99a38919 699
99a38919 700 inode->i_state |= I_FREEING;
02afc410 701 inode_lru_list_del(inode);
250df6ed 702 spin_unlock(&inode->i_lock);
02afc410 703 list_add(&inode->i_lru, &dispose);
04646aeb
ES
704 if (need_resched()) {
705 spin_unlock(&sb->s_inode_list_lock);
706 cond_resched();
707 dispose_list(&dispose);
708 goto again;
709 }
1da177e4 710 }
74278da9 711 spin_unlock(&sb->s_inode_list_lock);
1da177e4 712
a0318786 713 dispose_list(&dispose);
1da177e4
LT
714
715 return busy;
716}
1da177e4 717
1da177e4 718/*
bc3b14cb 719 * Isolate the inode from the LRU in preparation for freeing it.
1da177e4
LT
720 *
721 * Any inodes which are pinned purely because of attached pagecache have their
9e38d86f
NP
722 * pagecache removed. If the inode has metadata buffers attached to
723 * mapping->private_list then try to remove them.
1da177e4 724 *
9e38d86f
NP
725 * If the inode has the I_REFERENCED flag set, then it means that it has been
726 * used recently - the flag is set in iput_final(). When we encounter such an
727 * inode, clear the flag and move it to the back of the LRU so it gets another
728 * pass through the LRU before it gets reclaimed. This is necessary because of
729 * the fact we are doing lazy LRU updates to minimise lock contention so the
730 * LRU does not have strict ordering. Hence we don't want to reclaim inodes
731 * with this flag set because they are the inodes that are out of order.
1da177e4 732 */
3f97b163
VD
733static enum lru_status inode_lru_isolate(struct list_head *item,
734 struct list_lru_one *lru, spinlock_t *lru_lock, void *arg)
1da177e4 735{
bc3b14cb
DC
736 struct list_head *freeable = arg;
737 struct inode *inode = container_of(item, struct inode, i_lru);
1da177e4 738
bc3b14cb
DC
739 /*
740 * we are inverting the lru lock/inode->i_lock here, so use a trylock.
741 * If we fail to get the lock, just skip it.
742 */
743 if (!spin_trylock(&inode->i_lock))
744 return LRU_SKIP;
1da177e4 745
bc3b14cb
DC
746 /*
747 * Referenced or dirty inodes are still in use. Give them another pass
748 * through the LRU as we canot reclaim them now.
749 */
750 if (atomic_read(&inode->i_count) ||
751 (inode->i_state & ~I_REFERENCED)) {
3f97b163 752 list_lru_isolate(lru, &inode->i_lru);
bc3b14cb
DC
753 spin_unlock(&inode->i_lock);
754 this_cpu_dec(nr_unused);
755 return LRU_REMOVED;
756 }
1da177e4 757
69056ee6
DC
758 /* recently referenced inodes get one more pass */
759 if (inode->i_state & I_REFERENCED) {
bc3b14cb
DC
760 inode->i_state &= ~I_REFERENCED;
761 spin_unlock(&inode->i_lock);
762 return LRU_ROTATE;
763 }
1da177e4 764
bc3b14cb
DC
765 if (inode_has_buffers(inode) || inode->i_data.nrpages) {
766 __iget(inode);
767 spin_unlock(&inode->i_lock);
768 spin_unlock(lru_lock);
769 if (remove_inode_buffers(inode)) {
770 unsigned long reap;
771 reap = invalidate_mapping_pages(&inode->i_data, 0, -1);
772 if (current_is_kswapd())
773 __count_vm_events(KSWAPD_INODESTEAL, reap);
774 else
775 __count_vm_events(PGINODESTEAL, reap);
776 if (current->reclaim_state)
777 current->reclaim_state->reclaimed_slab += reap;
02afc410 778 }
bc3b14cb
DC
779 iput(inode);
780 spin_lock(lru_lock);
781 return LRU_RETRY;
782 }
02afc410 783
bc3b14cb
DC
784 WARN_ON(inode->i_state & I_NEW);
785 inode->i_state |= I_FREEING;
3f97b163 786 list_lru_isolate_move(lru, &inode->i_lru, freeable);
bc3b14cb 787 spin_unlock(&inode->i_lock);
9e38d86f 788
bc3b14cb
DC
789 this_cpu_dec(nr_unused);
790 return LRU_REMOVED;
791}
7ccf19a8 792
bc3b14cb
DC
793/*
794 * Walk the superblock inode LRU for freeable inodes and attempt to free them.
795 * This is called from the superblock shrinker function with a number of inodes
796 * to trim from the LRU. Inodes to be freed are moved to a temporary list and
797 * then are freed outside inode_lock by dispose_list().
798 */
503c358c 799long prune_icache_sb(struct super_block *sb, struct shrink_control *sc)
bc3b14cb
DC
800{
801 LIST_HEAD(freeable);
802 long freed;
1da177e4 803
503c358c
VD
804 freed = list_lru_shrink_walk(&sb->s_inode_lru, sc,
805 inode_lru_isolate, &freeable);
1da177e4 806 dispose_list(&freeable);
0a234c6d 807 return freed;
1da177e4
LT
808}
809
1da177e4
LT
810static void __wait_on_freeing_inode(struct inode *inode);
811/*
812 * Called with the inode lock held.
1da177e4 813 */
6b3304b5
MK
814static struct inode *find_inode(struct super_block *sb,
815 struct hlist_head *head,
816 int (*test)(struct inode *, void *),
817 void *data)
1da177e4 818{
6b3304b5 819 struct inode *inode = NULL;
1da177e4
LT
820
821repeat:
b67bfe0d 822 hlist_for_each_entry(inode, head, i_hash) {
5a3cd992 823 if (inode->i_sb != sb)
1da177e4 824 continue;
5a3cd992 825 if (!test(inode, data))
1da177e4 826 continue;
5a3cd992 827 spin_lock(&inode->i_lock);
a4ffdde6 828 if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
1da177e4
LT
829 __wait_on_freeing_inode(inode);
830 goto repeat;
831 }
c2b6d621
AV
832 if (unlikely(inode->i_state & I_CREATING)) {
833 spin_unlock(&inode->i_lock);
834 return ERR_PTR(-ESTALE);
835 }
f7899bd5 836 __iget(inode);
250df6ed 837 spin_unlock(&inode->i_lock);
f7899bd5 838 return inode;
1da177e4 839 }
f7899bd5 840 return NULL;
1da177e4
LT
841}
842
843/*
844 * find_inode_fast is the fast path version of find_inode, see the comment at
845 * iget_locked for details.
846 */
6b3304b5
MK
847static struct inode *find_inode_fast(struct super_block *sb,
848 struct hlist_head *head, unsigned long ino)
1da177e4 849{
6b3304b5 850 struct inode *inode = NULL;
1da177e4
LT
851
852repeat:
b67bfe0d 853 hlist_for_each_entry(inode, head, i_hash) {
5a3cd992 854 if (inode->i_ino != ino)
1da177e4 855 continue;
5a3cd992 856 if (inode->i_sb != sb)
1da177e4 857 continue;
5a3cd992 858 spin_lock(&inode->i_lock);
a4ffdde6 859 if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
1da177e4
LT
860 __wait_on_freeing_inode(inode);
861 goto repeat;
862 }
c2b6d621
AV
863 if (unlikely(inode->i_state & I_CREATING)) {
864 spin_unlock(&inode->i_lock);
865 return ERR_PTR(-ESTALE);
866 }
f7899bd5 867 __iget(inode);
250df6ed 868 spin_unlock(&inode->i_lock);
f7899bd5 869 return inode;
1da177e4 870 }
f7899bd5 871 return NULL;
8290c35f
DC
872}
873
f991bd2e
ED
874/*
875 * Each cpu owns a range of LAST_INO_BATCH numbers.
876 * 'shared_last_ino' is dirtied only once out of LAST_INO_BATCH allocations,
877 * to renew the exhausted range.
8290c35f 878 *
f991bd2e
ED
879 * This does not significantly increase overflow rate because every CPU can
880 * consume at most LAST_INO_BATCH-1 unused inode numbers. So there is
881 * NR_CPUS*(LAST_INO_BATCH-1) wastage. At 4096 and 1024, this is ~0.1% of the
882 * 2^32 range, and is a worst-case. Even a 50% wastage would only increase
883 * overflow rate by 2x, which does not seem too significant.
884 *
885 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
886 * error if st_ino won't fit in target struct field. Use 32bit counter
887 * here to attempt to avoid that.
8290c35f 888 */
f991bd2e
ED
889#define LAST_INO_BATCH 1024
890static DEFINE_PER_CPU(unsigned int, last_ino);
891
85fe4025 892unsigned int get_next_ino(void)
8290c35f 893{
f991bd2e
ED
894 unsigned int *p = &get_cpu_var(last_ino);
895 unsigned int res = *p;
8290c35f 896
f991bd2e
ED
897#ifdef CONFIG_SMP
898 if (unlikely((res & (LAST_INO_BATCH-1)) == 0)) {
899 static atomic_t shared_last_ino;
900 int next = atomic_add_return(LAST_INO_BATCH, &shared_last_ino);
901
902 res = next - LAST_INO_BATCH;
903 }
904#endif
905
2adc376c
CM
906 res++;
907 /* get_next_ino should not provide a 0 inode number */
908 if (unlikely(!res))
909 res++;
910 *p = res;
f991bd2e
ED
911 put_cpu_var(last_ino);
912 return res;
8290c35f 913}
85fe4025 914EXPORT_SYMBOL(get_next_ino);
8290c35f 915
a209dfc7
ED
916/**
917 * new_inode_pseudo - obtain an inode
918 * @sb: superblock
919 *
920 * Allocates a new inode for given superblock.
921 * Inode wont be chained in superblock s_inodes list
922 * This means :
923 * - fs can't be unmount
924 * - quotas, fsnotify, writeback can't work
925 */
926struct inode *new_inode_pseudo(struct super_block *sb)
927{
928 struct inode *inode = alloc_inode(sb);
929
930 if (inode) {
931 spin_lock(&inode->i_lock);
932 inode->i_state = 0;
933 spin_unlock(&inode->i_lock);
934 INIT_LIST_HEAD(&inode->i_sb_list);
935 }
936 return inode;
937}
938
1da177e4
LT
939/**
940 * new_inode - obtain an inode
941 * @sb: superblock
942 *
769848c0 943 * Allocates a new inode for given superblock. The default gfp_mask
3c1d4378 944 * for allocations related to inode->i_mapping is GFP_HIGHUSER_MOVABLE.
769848c0
MG
945 * If HIGHMEM pages are unsuitable or it is known that pages allocated
946 * for the page cache are not reclaimable or migratable,
947 * mapping_set_gfp_mask() must be called with suitable flags on the
948 * newly created inode's mapping
949 *
1da177e4
LT
950 */
951struct inode *new_inode(struct super_block *sb)
952{
6b3304b5 953 struct inode *inode;
1da177e4 954
74278da9 955 spin_lock_prefetch(&sb->s_inode_list_lock);
6b3304b5 956
a209dfc7
ED
957 inode = new_inode_pseudo(sb);
958 if (inode)
55fa6091 959 inode_sb_list_add(inode);
1da177e4
LT
960 return inode;
961}
1da177e4
LT
962EXPORT_SYMBOL(new_inode);
963
14358e6d 964#ifdef CONFIG_DEBUG_LOCK_ALLOC
e096d0c7
JB
965void lockdep_annotate_inode_mutex_key(struct inode *inode)
966{
a3314a0e 967 if (S_ISDIR(inode->i_mode)) {
1e89a5e1
PZ
968 struct file_system_type *type = inode->i_sb->s_type;
969
9a7aa12f 970 /* Set new key only if filesystem hasn't already changed it */
9902af79 971 if (lockdep_match_class(&inode->i_rwsem, &type->i_mutex_key)) {
9a7aa12f
JK
972 /*
973 * ensure nobody is actually holding i_mutex
974 */
9902af79
AV
975 // mutex_destroy(&inode->i_mutex);
976 init_rwsem(&inode->i_rwsem);
977 lockdep_set_class(&inode->i_rwsem,
9a7aa12f
JK
978 &type->i_mutex_dir_key);
979 }
1e89a5e1 980 }
e096d0c7
JB
981}
982EXPORT_SYMBOL(lockdep_annotate_inode_mutex_key);
14358e6d 983#endif
e096d0c7
JB
984
985/**
986 * unlock_new_inode - clear the I_NEW state and wake up any waiters
987 * @inode: new inode to unlock
988 *
989 * Called when the inode is fully initialised to clear the new state of the
990 * inode and wake up anyone waiting for the inode to finish initialisation.
991 */
992void unlock_new_inode(struct inode *inode)
993{
994 lockdep_annotate_inode_mutex_key(inode);
250df6ed 995 spin_lock(&inode->i_lock);
eaff8079 996 WARN_ON(!(inode->i_state & I_NEW));
c2b6d621 997 inode->i_state &= ~I_NEW & ~I_CREATING;
310fa7a3 998 smp_mb();
250df6ed
DC
999 wake_up_bit(&inode->i_state, __I_NEW);
1000 spin_unlock(&inode->i_lock);
1da177e4 1001}
1da177e4
LT
1002EXPORT_SYMBOL(unlock_new_inode);
1003
c2b6d621
AV
1004void discard_new_inode(struct inode *inode)
1005{
1006 lockdep_annotate_inode_mutex_key(inode);
1007 spin_lock(&inode->i_lock);
1008 WARN_ON(!(inode->i_state & I_NEW));
1009 inode->i_state &= ~I_NEW;
1010 smp_mb();
1011 wake_up_bit(&inode->i_state, __I_NEW);
1012 spin_unlock(&inode->i_lock);
1013 iput(inode);
1014}
1015EXPORT_SYMBOL(discard_new_inode);
1016
375e289e
BF
1017/**
1018 * lock_two_nondirectories - take two i_mutexes on non-directory objects
4fd699ae
BF
1019 *
1020 * Lock any non-NULL argument that is not a directory.
1021 * Zero, one or two objects may be locked by this function.
1022 *
375e289e
BF
1023 * @inode1: first inode to lock
1024 * @inode2: second inode to lock
1025 */
1026void lock_two_nondirectories(struct inode *inode1, struct inode *inode2)
1027{
4fd699ae
BF
1028 if (inode1 > inode2)
1029 swap(inode1, inode2);
1030
1031 if (inode1 && !S_ISDIR(inode1->i_mode))
5955102c 1032 inode_lock(inode1);
4fd699ae 1033 if (inode2 && !S_ISDIR(inode2->i_mode) && inode2 != inode1)
5955102c 1034 inode_lock_nested(inode2, I_MUTEX_NONDIR2);
375e289e
BF
1035}
1036EXPORT_SYMBOL(lock_two_nondirectories);
1037
1038/**
1039 * unlock_two_nondirectories - release locks from lock_two_nondirectories()
1040 * @inode1: first inode to unlock
1041 * @inode2: second inode to unlock
1042 */
1043void unlock_two_nondirectories(struct inode *inode1, struct inode *inode2)
1044{
4fd699ae 1045 if (inode1 && !S_ISDIR(inode1->i_mode))
5955102c 1046 inode_unlock(inode1);
4fd699ae 1047 if (inode2 && !S_ISDIR(inode2->i_mode) && inode2 != inode1)
5955102c 1048 inode_unlock(inode2);
375e289e
BF
1049}
1050EXPORT_SYMBOL(unlock_two_nondirectories);
1051
80ea09a0
MS
1052/**
1053 * inode_insert5 - obtain an inode from a mounted file system
1054 * @inode: pre-allocated inode to use for insert to cache
1055 * @hashval: hash value (usually inode number) to get
1056 * @test: callback used for comparisons between inodes
1057 * @set: callback used to initialize a new struct inode
1058 * @data: opaque data pointer to pass to @test and @set
1059 *
1060 * Search for the inode specified by @hashval and @data in the inode cache,
1061 * and if present it is return it with an increased reference count. This is
1062 * a variant of iget5_locked() for callers that don't want to fail on memory
1063 * allocation of inode.
1064 *
1065 * If the inode is not in cache, insert the pre-allocated inode to cache and
1066 * return it locked, hashed, and with the I_NEW flag set. The file system gets
1067 * to fill it in before unlocking it via unlock_new_inode().
1068 *
1069 * Note both @test and @set are called with the inode_hash_lock held, so can't
1070 * sleep.
1071 */
1072struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
1073 int (*test)(struct inode *, void *),
1074 int (*set)(struct inode *, void *), void *data)
1075{
1076 struct hlist_head *head = inode_hashtable + hash(inode->i_sb, hashval);
1077 struct inode *old;
e950564b 1078 bool creating = inode->i_state & I_CREATING;
80ea09a0
MS
1079
1080again:
1081 spin_lock(&inode_hash_lock);
1082 old = find_inode(inode->i_sb, head, test, data);
1083 if (unlikely(old)) {
1084 /*
1085 * Uhhuh, somebody else created the same inode under us.
1086 * Use the old inode instead of the preallocated one.
1087 */
1088 spin_unlock(&inode_hash_lock);
c2b6d621
AV
1089 if (IS_ERR(old))
1090 return NULL;
80ea09a0
MS
1091 wait_on_inode(old);
1092 if (unlikely(inode_unhashed(old))) {
1093 iput(old);
1094 goto again;
1095 }
1096 return old;
1097 }
1098
1099 if (set && unlikely(set(inode, data))) {
1100 inode = NULL;
1101 goto unlock;
1102 }
1103
1104 /*
1105 * Return the locked inode with I_NEW set, the
1106 * caller is responsible for filling in the contents
1107 */
1108 spin_lock(&inode->i_lock);
1109 inode->i_state |= I_NEW;
1110 hlist_add_head(&inode->i_hash, head);
1111 spin_unlock(&inode->i_lock);
e950564b
MS
1112 if (!creating)
1113 inode_sb_list_add(inode);
80ea09a0
MS
1114unlock:
1115 spin_unlock(&inode_hash_lock);
1116
1117 return inode;
1118}
1119EXPORT_SYMBOL(inode_insert5);
1120
0b2d0724
CH
1121/**
1122 * iget5_locked - obtain an inode from a mounted file system
1123 * @sb: super block of file system
1124 * @hashval: hash value (usually inode number) to get
1125 * @test: callback used for comparisons between inodes
1126 * @set: callback used to initialize a new struct inode
1127 * @data: opaque data pointer to pass to @test and @set
1128 *
1129 * Search for the inode specified by @hashval and @data in the inode cache,
1130 * and if present it is return it with an increased reference count. This is
1131 * a generalized version of iget_locked() for file systems where the inode
1132 * number is not sufficient for unique identification of an inode.
1133 *
1134 * If the inode is not in cache, allocate a new inode and return it locked,
1135 * hashed, and with the I_NEW flag set. The file system gets to fill it in
1136 * before unlocking it via unlock_new_inode().
1da177e4 1137 *
0b2d0724
CH
1138 * Note both @test and @set are called with the inode_hash_lock held, so can't
1139 * sleep.
1da177e4 1140 */
0b2d0724
CH
1141struct inode *iget5_locked(struct super_block *sb, unsigned long hashval,
1142 int (*test)(struct inode *, void *),
1143 int (*set)(struct inode *, void *), void *data)
1da177e4 1144{
80ea09a0 1145 struct inode *inode = ilookup5(sb, hashval, test, data);
0b2d0724 1146
80ea09a0 1147 if (!inode) {
e950564b 1148 struct inode *new = alloc_inode(sb);
0b2d0724 1149
80ea09a0 1150 if (new) {
e950564b 1151 new->i_state = 0;
80ea09a0
MS
1152 inode = inode_insert5(new, hashval, test, set, data);
1153 if (unlikely(inode != new))
e950564b 1154 destroy_inode(new);
2864f301 1155 }
1da177e4
LT
1156 }
1157 return inode;
1da177e4 1158}
0b2d0724 1159EXPORT_SYMBOL(iget5_locked);
1da177e4 1160
0b2d0724
CH
1161/**
1162 * iget_locked - obtain an inode from a mounted file system
1163 * @sb: super block of file system
1164 * @ino: inode number to get
1165 *
1166 * Search for the inode specified by @ino in the inode cache and if present
1167 * return it with an increased reference count. This is for file systems
1168 * where the inode number is sufficient for unique identification of an inode.
1169 *
1170 * If the inode is not in cache, allocate a new inode and return it locked,
1171 * hashed, and with the I_NEW flag set. The file system gets to fill it in
1172 * before unlocking it via unlock_new_inode().
1da177e4 1173 */
0b2d0724 1174struct inode *iget_locked(struct super_block *sb, unsigned long ino)
1da177e4 1175{
0b2d0724 1176 struct hlist_head *head = inode_hashtable + hash(sb, ino);
6b3304b5 1177 struct inode *inode;
2864f301 1178again:
0b2d0724
CH
1179 spin_lock(&inode_hash_lock);
1180 inode = find_inode_fast(sb, head, ino);
1181 spin_unlock(&inode_hash_lock);
1182 if (inode) {
c2b6d621
AV
1183 if (IS_ERR(inode))
1184 return NULL;
0b2d0724 1185 wait_on_inode(inode);
2864f301
AV
1186 if (unlikely(inode_unhashed(inode))) {
1187 iput(inode);
1188 goto again;
1189 }
0b2d0724
CH
1190 return inode;
1191 }
1192
1da177e4
LT
1193 inode = alloc_inode(sb);
1194 if (inode) {
6b3304b5 1195 struct inode *old;
1da177e4 1196
67a23c49 1197 spin_lock(&inode_hash_lock);
1da177e4
LT
1198 /* We released the lock, so.. */
1199 old = find_inode_fast(sb, head, ino);
1200 if (!old) {
1201 inode->i_ino = ino;
250df6ed
DC
1202 spin_lock(&inode->i_lock);
1203 inode->i_state = I_NEW;
646ec461 1204 hlist_add_head(&inode->i_hash, head);
250df6ed 1205 spin_unlock(&inode->i_lock);
55fa6091 1206 inode_sb_list_add(inode);
67a23c49 1207 spin_unlock(&inode_hash_lock);
1da177e4
LT
1208
1209 /* Return the locked inode with I_NEW set, the
1210 * caller is responsible for filling in the contents
1211 */
1212 return inode;
1213 }
1214
1215 /*
1216 * Uhhuh, somebody else created the same inode under
1217 * us. Use the old inode instead of the one we just
1218 * allocated.
1219 */
67a23c49 1220 spin_unlock(&inode_hash_lock);
1da177e4 1221 destroy_inode(inode);
c2b6d621
AV
1222 if (IS_ERR(old))
1223 return NULL;
1da177e4
LT
1224 inode = old;
1225 wait_on_inode(inode);
2864f301
AV
1226 if (unlikely(inode_unhashed(inode))) {
1227 iput(inode);
1228 goto again;
1229 }
1da177e4
LT
1230 }
1231 return inode;
1232}
0b2d0724 1233EXPORT_SYMBOL(iget_locked);
1da177e4 1234
ad5e195a
CH
1235/*
1236 * search the inode cache for a matching inode number.
1237 * If we find one, then the inode number we are trying to
1238 * allocate is not unique and so we should not use it.
1239 *
1240 * Returns 1 if the inode number is unique, 0 if it is not.
1241 */
1242static int test_inode_iunique(struct super_block *sb, unsigned long ino)
1243{
1244 struct hlist_head *b = inode_hashtable + hash(sb, ino);
ad5e195a
CH
1245 struct inode *inode;
1246
67a23c49 1247 spin_lock(&inode_hash_lock);
b67bfe0d 1248 hlist_for_each_entry(inode, b, i_hash) {
67a23c49
DC
1249 if (inode->i_ino == ino && inode->i_sb == sb) {
1250 spin_unlock(&inode_hash_lock);
ad5e195a 1251 return 0;
67a23c49 1252 }
ad5e195a 1253 }
67a23c49 1254 spin_unlock(&inode_hash_lock);
ad5e195a
CH
1255
1256 return 1;
1257}
1258
1da177e4
LT
1259/**
1260 * iunique - get a unique inode number
1261 * @sb: superblock
1262 * @max_reserved: highest reserved inode number
1263 *
1264 * Obtain an inode number that is unique on the system for a given
1265 * superblock. This is used by file systems that have no natural
1266 * permanent inode numbering system. An inode number is returned that
1267 * is higher than the reserved limit but unique.
1268 *
1269 * BUGS:
1270 * With a large number of inodes live on the file system this function
1271 * currently becomes quite slow.
1272 */
1273ino_t iunique(struct super_block *sb, ino_t max_reserved)
1274{
866b04fc
JL
1275 /*
1276 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
1277 * error if st_ino won't fit in target struct field. Use 32bit counter
1278 * here to attempt to avoid that.
1279 */
ad5e195a 1280 static DEFINE_SPINLOCK(iunique_lock);
866b04fc 1281 static unsigned int counter;
1da177e4 1282 ino_t res;
3361c7be 1283
ad5e195a 1284 spin_lock(&iunique_lock);
3361c7be
JL
1285 do {
1286 if (counter <= max_reserved)
1287 counter = max_reserved + 1;
1da177e4 1288 res = counter++;
ad5e195a
CH
1289 } while (!test_inode_iunique(sb, res));
1290 spin_unlock(&iunique_lock);
1da177e4 1291
3361c7be
JL
1292 return res;
1293}
1da177e4
LT
1294EXPORT_SYMBOL(iunique);
1295
1296struct inode *igrab(struct inode *inode)
1297{
250df6ed
DC
1298 spin_lock(&inode->i_lock);
1299 if (!(inode->i_state & (I_FREEING|I_WILL_FREE))) {
1da177e4 1300 __iget(inode);
250df6ed
DC
1301 spin_unlock(&inode->i_lock);
1302 } else {
1303 spin_unlock(&inode->i_lock);
1da177e4
LT
1304 /*
1305 * Handle the case where s_op->clear_inode is not been
1306 * called yet, and somebody is calling igrab
1307 * while the inode is getting freed.
1308 */
1309 inode = NULL;
250df6ed 1310 }
1da177e4
LT
1311 return inode;
1312}
1da177e4
LT
1313EXPORT_SYMBOL(igrab);
1314
1315/**
0b2d0724 1316 * ilookup5_nowait - search for an inode in the inode cache
1da177e4 1317 * @sb: super block of file system to search
0b2d0724 1318 * @hashval: hash value (usually inode number) to search for
1da177e4
LT
1319 * @test: callback used for comparisons between inodes
1320 * @data: opaque data pointer to pass to @test
1da177e4 1321 *
0b2d0724 1322 * Search for the inode specified by @hashval and @data in the inode cache.
1da177e4
LT
1323 * If the inode is in the cache, the inode is returned with an incremented
1324 * reference count.
1325 *
0b2d0724
CH
1326 * Note: I_NEW is not waited upon so you have to be very careful what you do
1327 * with the returned inode. You probably should be using ilookup5() instead.
1da177e4 1328 *
b6d0ad68 1329 * Note2: @test is called with the inode_hash_lock held, so can't sleep.
1da177e4 1330 */
0b2d0724
CH
1331struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval,
1332 int (*test)(struct inode *, void *), void *data)
1da177e4 1333{
0b2d0724 1334 struct hlist_head *head = inode_hashtable + hash(sb, hashval);
1da177e4
LT
1335 struct inode *inode;
1336
67a23c49 1337 spin_lock(&inode_hash_lock);
1da177e4 1338 inode = find_inode(sb, head, test, data);
67a23c49 1339 spin_unlock(&inode_hash_lock);
88bd5121 1340
c2b6d621 1341 return IS_ERR(inode) ? NULL : inode;
88bd5121 1342}
88bd5121
AA
1343EXPORT_SYMBOL(ilookup5_nowait);
1344
1345/**
1346 * ilookup5 - search for an inode in the inode cache
1347 * @sb: super block of file system to search
1348 * @hashval: hash value (usually inode number) to search for
1349 * @test: callback used for comparisons between inodes
1350 * @data: opaque data pointer to pass to @test
1351 *
0b2d0724
CH
1352 * Search for the inode specified by @hashval and @data in the inode cache,
1353 * and if the inode is in the cache, return the inode with an incremented
1354 * reference count. Waits on I_NEW before returning the inode.
88bd5121 1355 * returned with an incremented reference count.
1da177e4 1356 *
0b2d0724
CH
1357 * This is a generalized version of ilookup() for file systems where the
1358 * inode number is not sufficient for unique identification of an inode.
1da177e4 1359 *
0b2d0724 1360 * Note: @test is called with the inode_hash_lock held, so can't sleep.
1da177e4
LT
1361 */
1362struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
1363 int (*test)(struct inode *, void *), void *data)
1364{
2864f301
AV
1365 struct inode *inode;
1366again:
1367 inode = ilookup5_nowait(sb, hashval, test, data);
1368 if (inode) {
0b2d0724 1369 wait_on_inode(inode);
2864f301
AV
1370 if (unlikely(inode_unhashed(inode))) {
1371 iput(inode);
1372 goto again;
1373 }
1374 }
0b2d0724 1375 return inode;
1da177e4 1376}
1da177e4
LT
1377EXPORT_SYMBOL(ilookup5);
1378
1379/**
1380 * ilookup - search for an inode in the inode cache
1381 * @sb: super block of file system to search
1382 * @ino: inode number to search for
1383 *
0b2d0724
CH
1384 * Search for the inode @ino in the inode cache, and if the inode is in the
1385 * cache, the inode is returned with an incremented reference count.
1da177e4
LT
1386 */
1387struct inode *ilookup(struct super_block *sb, unsigned long ino)
1388{
1389 struct hlist_head *head = inode_hashtable + hash(sb, ino);
1da177e4 1390 struct inode *inode;
2864f301 1391again:
0b2d0724
CH
1392 spin_lock(&inode_hash_lock);
1393 inode = find_inode_fast(sb, head, ino);
1394 spin_unlock(&inode_hash_lock);
1da177e4 1395
2864f301 1396 if (inode) {
c2b6d621
AV
1397 if (IS_ERR(inode))
1398 return NULL;
0b2d0724 1399 wait_on_inode(inode);
2864f301
AV
1400 if (unlikely(inode_unhashed(inode))) {
1401 iput(inode);
1402 goto again;
1403 }
1404 }
0b2d0724 1405 return inode;
1da177e4 1406}
0b2d0724 1407EXPORT_SYMBOL(ilookup);
1da177e4 1408
fe032c42
TT
1409/**
1410 * find_inode_nowait - find an inode in the inode cache
1411 * @sb: super block of file system to search
1412 * @hashval: hash value (usually inode number) to search for
1413 * @match: callback used for comparisons between inodes
1414 * @data: opaque data pointer to pass to @match
1415 *
1416 * Search for the inode specified by @hashval and @data in the inode
1417 * cache, where the helper function @match will return 0 if the inode
1418 * does not match, 1 if the inode does match, and -1 if the search
1419 * should be stopped. The @match function must be responsible for
1420 * taking the i_lock spin_lock and checking i_state for an inode being
1421 * freed or being initialized, and incrementing the reference count
1422 * before returning 1. It also must not sleep, since it is called with
1423 * the inode_hash_lock spinlock held.
1424 *
1425 * This is a even more generalized version of ilookup5() when the
1426 * function must never block --- find_inode() can block in
1427 * __wait_on_freeing_inode() --- or when the caller can not increment
1428 * the reference count because the resulting iput() might cause an
1429 * inode eviction. The tradeoff is that the @match funtion must be
1430 * very carefully implemented.
1431 */
1432struct inode *find_inode_nowait(struct super_block *sb,
1433 unsigned long hashval,
1434 int (*match)(struct inode *, unsigned long,
1435 void *),
1436 void *data)
1437{
1438 struct hlist_head *head = inode_hashtable + hash(sb, hashval);
1439 struct inode *inode, *ret_inode = NULL;
1440 int mval;
1441
1442 spin_lock(&inode_hash_lock);
1443 hlist_for_each_entry(inode, head, i_hash) {
1444 if (inode->i_sb != sb)
1445 continue;
1446 mval = match(inode, hashval, data);
1447 if (mval == 0)
1448 continue;
1449 if (mval == 1)
1450 ret_inode = inode;
1451 goto out;
1452 }
1453out:
1454 spin_unlock(&inode_hash_lock);
1455 return ret_inode;
1456}
1457EXPORT_SYMBOL(find_inode_nowait);
1458
261bca86
AV
1459int insert_inode_locked(struct inode *inode)
1460{
1461 struct super_block *sb = inode->i_sb;
1462 ino_t ino = inode->i_ino;
1463 struct hlist_head *head = inode_hashtable + hash(sb, ino);
261bca86 1464
261bca86 1465 while (1) {
72a43d63 1466 struct inode *old = NULL;
67a23c49 1467 spin_lock(&inode_hash_lock);
b67bfe0d 1468 hlist_for_each_entry(old, head, i_hash) {
72a43d63
AV
1469 if (old->i_ino != ino)
1470 continue;
1471 if (old->i_sb != sb)
1472 continue;
250df6ed
DC
1473 spin_lock(&old->i_lock);
1474 if (old->i_state & (I_FREEING|I_WILL_FREE)) {
1475 spin_unlock(&old->i_lock);
72a43d63 1476 continue;
250df6ed 1477 }
72a43d63
AV
1478 break;
1479 }
b67bfe0d 1480 if (likely(!old)) {
250df6ed 1481 spin_lock(&inode->i_lock);
c2b6d621 1482 inode->i_state |= I_NEW | I_CREATING;
261bca86 1483 hlist_add_head(&inode->i_hash, head);
250df6ed 1484 spin_unlock(&inode->i_lock);
67a23c49 1485 spin_unlock(&inode_hash_lock);
261bca86
AV
1486 return 0;
1487 }
c2b6d621
AV
1488 if (unlikely(old->i_state & I_CREATING)) {
1489 spin_unlock(&old->i_lock);
1490 spin_unlock(&inode_hash_lock);
1491 return -EBUSY;
1492 }
261bca86 1493 __iget(old);
250df6ed 1494 spin_unlock(&old->i_lock);
67a23c49 1495 spin_unlock(&inode_hash_lock);
261bca86 1496 wait_on_inode(old);
1d3382cb 1497 if (unlikely(!inode_unhashed(old))) {
261bca86
AV
1498 iput(old);
1499 return -EBUSY;
1500 }
1501 iput(old);
1502 }
1503}
261bca86
AV
1504EXPORT_SYMBOL(insert_inode_locked);
1505
1506int insert_inode_locked4(struct inode *inode, unsigned long hashval,
1507 int (*test)(struct inode *, void *), void *data)
1508{
c2b6d621
AV
1509 struct inode *old;
1510
1511 inode->i_state |= I_CREATING;
1512 old = inode_insert5(inode, hashval, test, NULL, data);
261bca86 1513
80ea09a0 1514 if (old != inode) {
261bca86 1515 iput(old);
80ea09a0 1516 return -EBUSY;
261bca86 1517 }
80ea09a0 1518 return 0;
261bca86 1519}
261bca86
AV
1520EXPORT_SYMBOL(insert_inode_locked4);
1521
1da177e4 1522
45321ac5
AV
1523int generic_delete_inode(struct inode *inode)
1524{
1525 return 1;
1526}
1527EXPORT_SYMBOL(generic_delete_inode);
1528
45321ac5
AV
1529/*
1530 * Called when we're dropping the last reference
1531 * to an inode.
22fe4042 1532 *
45321ac5
AV
1533 * Call the FS "drop_inode()" function, defaulting to
1534 * the legacy UNIX filesystem behaviour. If it tells
1535 * us to evict inode, do so. Otherwise, retain inode
1536 * in cache if fs is alive, sync and evict if fs is
1537 * shutting down.
22fe4042 1538 */
45321ac5 1539static void iput_final(struct inode *inode)
1da177e4
LT
1540{
1541 struct super_block *sb = inode->i_sb;
45321ac5
AV
1542 const struct super_operations *op = inode->i_sb->s_op;
1543 int drop;
1544
250df6ed
DC
1545 WARN_ON(inode->i_state & I_NEW);
1546
e7f59097 1547 if (op->drop_inode)
45321ac5
AV
1548 drop = op->drop_inode(inode);
1549 else
1550 drop = generic_drop_inode(inode);
1da177e4 1551
1751e8a6 1552 if (!drop && (sb->s_flags & SB_ACTIVE)) {
4eff96dd 1553 inode_add_lru(inode);
b2b2af8e 1554 spin_unlock(&inode->i_lock);
b2b2af8e
DC
1555 return;
1556 }
1557
45321ac5 1558 if (!drop) {
991114c6 1559 inode->i_state |= I_WILL_FREE;
250df6ed 1560 spin_unlock(&inode->i_lock);
1da177e4 1561 write_inode_now(inode, 1);
250df6ed 1562 spin_lock(&inode->i_lock);
7ef0d737 1563 WARN_ON(inode->i_state & I_NEW);
991114c6 1564 inode->i_state &= ~I_WILL_FREE;
1da177e4 1565 }
7ccf19a8 1566
991114c6 1567 inode->i_state |= I_FREEING;
c4ae0c65
ED
1568 if (!list_empty(&inode->i_lru))
1569 inode_lru_list_del(inode);
b2b2af8e 1570 spin_unlock(&inode->i_lock);
b2b2af8e 1571
644da596 1572 evict(inode);
1da177e4
LT
1573}
1574
1da177e4 1575/**
6b3304b5 1576 * iput - put an inode
1da177e4
LT
1577 * @inode: inode to put
1578 *
1579 * Puts an inode, dropping its usage count. If the inode use count hits
1580 * zero, the inode is then freed and may also be destroyed.
1581 *
1582 * Consequently, iput() can sleep.
1583 */
1584void iput(struct inode *inode)
1585{
0ae45f63
TT
1586 if (!inode)
1587 return;
1588 BUG_ON(inode->i_state & I_CLEAR);
1589retry:
1590 if (atomic_dec_and_lock(&inode->i_count, &inode->i_lock)) {
1591 if (inode->i_nlink && (inode->i_state & I_DIRTY_TIME)) {
1592 atomic_inc(&inode->i_count);
0ae45f63
TT
1593 spin_unlock(&inode->i_lock);
1594 trace_writeback_lazytime_iput(inode);
1595 mark_inode_dirty_sync(inode);
1596 goto retry;
1597 }
1598 iput_final(inode);
1da177e4
LT
1599 }
1600}
1da177e4
LT
1601EXPORT_SYMBOL(iput);
1602
30460e1e 1603#ifdef CONFIG_BLOCK
1da177e4
LT
1604/**
1605 * bmap - find a block number in a file
30460e1e
CM
1606 * @inode: inode owning the block number being requested
1607 * @block: pointer containing the block to find
1da177e4 1608 *
30460e1e
CM
1609 * Replaces the value in *block with the block number on the device holding
1610 * corresponding to the requested block number in the file.
1611 * That is, asked for block 4 of inode 1 the function will replace the
1612 * 4 in *block, with disk block relative to the disk start that holds that
1613 * block of the file.
1614 *
1615 * Returns -EINVAL in case of error, 0 otherwise. If mapping falls into a
1616 * hole, returns 0 and *block is also set to 0.
1da177e4 1617 */
30460e1e 1618int bmap(struct inode *inode, sector_t *block)
1da177e4 1619{
30460e1e
CM
1620 if (!inode->i_mapping->a_ops->bmap)
1621 return -EINVAL;
1622
1623 *block = inode->i_mapping->a_ops->bmap(inode->i_mapping, *block);
1624 return 0;
1da177e4 1625}
1da177e4 1626EXPORT_SYMBOL(bmap);
30460e1e 1627#endif
1da177e4 1628
11ff6f05
MG
1629/*
1630 * With relative atime, only update atime if the previous atime is
1631 * earlier than either the ctime or mtime or if at least a day has
1632 * passed since the last atime update.
1633 */
c6718543 1634static int relatime_need_update(struct vfsmount *mnt, struct inode *inode,
6f22b664 1635 struct timespec64 now)
11ff6f05
MG
1636{
1637
c6718543 1638 if (!(mnt->mnt_flags & MNT_RELATIME))
11ff6f05
MG
1639 return 1;
1640 /*
1641 * Is mtime younger than atime? If yes, update atime:
1642 */
95582b00 1643 if (timespec64_compare(&inode->i_mtime, &inode->i_atime) >= 0)
11ff6f05
MG
1644 return 1;
1645 /*
1646 * Is ctime younger than atime? If yes, update atime:
1647 */
95582b00 1648 if (timespec64_compare(&inode->i_ctime, &inode->i_atime) >= 0)
11ff6f05
MG
1649 return 1;
1650
1651 /*
1652 * Is the previous atime value older than a day? If yes,
1653 * update atime:
1654 */
1655 if ((long)(now.tv_sec - inode->i_atime.tv_sec) >= 24*60*60)
1656 return 1;
1657 /*
1658 * Good, we can skip the atime update:
1659 */
1660 return 0;
1661}
1662
95582b00 1663int generic_update_time(struct inode *inode, struct timespec64 *time, int flags)
c3b2da31 1664{
0ae45f63 1665 int iflags = I_DIRTY_TIME;
e38cf302 1666 bool dirty = false;
c3b2da31
JB
1667
1668 if (flags & S_ATIME)
1669 inode->i_atime = *time;
1670 if (flags & S_VERSION)
e38cf302 1671 dirty = inode_maybe_inc_iversion(inode, false);
c3b2da31
JB
1672 if (flags & S_CTIME)
1673 inode->i_ctime = *time;
1674 if (flags & S_MTIME)
1675 inode->i_mtime = *time;
e38cf302
JL
1676 if ((flags & (S_ATIME | S_CTIME | S_MTIME)) &&
1677 !(inode->i_sb->s_flags & SB_LAZYTIME))
1678 dirty = true;
0ae45f63 1679
e38cf302 1680 if (dirty)
0ae45f63
TT
1681 iflags |= I_DIRTY_SYNC;
1682 __mark_inode_dirty(inode, iflags);
c3b2da31
JB
1683 return 0;
1684}
0ae45f63
TT
1685EXPORT_SYMBOL(generic_update_time);
1686
1687/*
1688 * This does the actual work of updating an inodes time or version. Must have
1689 * had called mnt_want_write() before calling this.
1690 */
95582b00 1691static int update_time(struct inode *inode, struct timespec64 *time, int flags)
0ae45f63 1692{
23b424d9
DD
1693 if (inode->i_op->update_time)
1694 return inode->i_op->update_time(inode, time, flags);
1695 return generic_update_time(inode, time, flags);
0ae45f63 1696}
c3b2da31 1697
1da177e4 1698/**
869243a0 1699 * touch_atime - update the access time
185553b2 1700 * @path: the &struct path to update
30fdc8ee 1701 * @inode: inode to update
1da177e4
LT
1702 *
1703 * Update the accessed time on an inode and mark it for writeback.
1704 * This function automatically handles read only file systems and media,
1705 * as well as the "noatime" flag and inode specific "noatime" markers.
1706 */
c6718543 1707bool atime_needs_update(const struct path *path, struct inode *inode)
1da177e4 1708{
68ac1234 1709 struct vfsmount *mnt = path->mnt;
95582b00 1710 struct timespec64 now;
1da177e4 1711
cdb70f3f 1712 if (inode->i_flags & S_NOATIME)
8fa9dd24 1713 return false;
0bd23d09
EB
1714
1715 /* Atime updates will likely cause i_uid and i_gid to be written
1716 * back improprely if their true value is unknown to the vfs.
1717 */
1718 if (HAS_UNMAPPED_ID(inode))
1719 return false;
1720
37756ced 1721 if (IS_NOATIME(inode))
8fa9dd24 1722 return false;
1751e8a6 1723 if ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode))
8fa9dd24 1724 return false;
47ae32d6 1725
cdb70f3f 1726 if (mnt->mnt_flags & MNT_NOATIME)
8fa9dd24 1727 return false;
cdb70f3f 1728 if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
8fa9dd24 1729 return false;
1da177e4 1730
c2050a45 1731 now = current_time(inode);
11ff6f05 1732
6f22b664 1733 if (!relatime_need_update(mnt, inode, now))
8fa9dd24 1734 return false;
11ff6f05 1735
95582b00 1736 if (timespec64_equal(&inode->i_atime, &now))
8fa9dd24
N
1737 return false;
1738
1739 return true;
1740}
1741
1742void touch_atime(const struct path *path)
1743{
1744 struct vfsmount *mnt = path->mnt;
1745 struct inode *inode = d_inode(path->dentry);
95582b00 1746 struct timespec64 now;
8fa9dd24 1747
c6718543 1748 if (!atime_needs_update(path, inode))
b12536c2
AK
1749 return;
1750
5d37e9e6 1751 if (!sb_start_write_trylock(inode->i_sb))
b12536c2 1752 return;
47ae32d6 1753
8fa9dd24 1754 if (__mnt_want_write(mnt) != 0)
5d37e9e6 1755 goto skip_update;
c3b2da31
JB
1756 /*
1757 * File systems can error out when updating inodes if they need to
1758 * allocate new space to modify an inode (such is the case for
1759 * Btrfs), but since we touch atime while walking down the path we
1760 * really don't care if we failed to update the atime of the file,
1761 * so just ignore the return value.
2bc55652
AB
1762 * We may also fail on filesystems that have the ability to make parts
1763 * of the fs read only, e.g. subvolumes in Btrfs.
c3b2da31 1764 */
c2050a45 1765 now = current_time(inode);
c3b2da31 1766 update_time(inode, &now, S_ATIME);
5d37e9e6
JK
1767 __mnt_drop_write(mnt);
1768skip_update:
1769 sb_end_write(inode->i_sb);
1da177e4 1770}
869243a0 1771EXPORT_SYMBOL(touch_atime);
1da177e4 1772
3ed37648
CW
1773/*
1774 * The logic we want is
1775 *
1776 * if suid or (sgid and xgrp)
1777 * remove privs
1778 */
1779int should_remove_suid(struct dentry *dentry)
1780{
df2b1afd 1781 umode_t mode = d_inode(dentry)->i_mode;
3ed37648
CW
1782 int kill = 0;
1783
1784 /* suid always must be killed */
1785 if (unlikely(mode & S_ISUID))
1786 kill = ATTR_KILL_SUID;
1787
1788 /*
1789 * sgid without any exec bits is just a mandatory locking mark; leave
1790 * it alone. If some exec bits are set, it's a real sgid; kill it.
1791 */
1792 if (unlikely((mode & S_ISGID) && (mode & S_IXGRP)))
1793 kill |= ATTR_KILL_SGID;
1794
1795 if (unlikely(kill && !capable(CAP_FSETID) && S_ISREG(mode)))
1796 return kill;
1797
1798 return 0;
1799}
1800EXPORT_SYMBOL(should_remove_suid);
1801
dbfae0cd
JK
1802/*
1803 * Return mask of changes for notify_change() that need to be done as a
1804 * response to write or truncate. Return 0 if nothing has to be changed.
1805 * Negative value on error (change should be denied).
1806 */
45f147a1 1807int dentry_needs_remove_privs(struct dentry *dentry)
dbfae0cd 1808{
dbfae0cd
JK
1809 struct inode *inode = d_inode(dentry);
1810 int mask = 0;
1811 int ret;
1812
1813 if (IS_NOSEC(inode))
1814 return 0;
1815
1816 mask = should_remove_suid(dentry);
1817 ret = security_inode_need_killpriv(dentry);
1818 if (ret < 0)
1819 return ret;
1820 if (ret)
1821 mask |= ATTR_KILL_PRIV;
1822 return mask;
1823}
dbfae0cd
JK
1824
1825static int __remove_privs(struct dentry *dentry, int kill)
3ed37648
CW
1826{
1827 struct iattr newattrs;
1828
1829 newattrs.ia_valid = ATTR_FORCE | kill;
27ac0ffe
BF
1830 /*
1831 * Note we call this on write, so notify_change will not
1832 * encounter any conflicting delegations:
1833 */
1834 return notify_change(dentry, &newattrs, NULL);
3ed37648
CW
1835}
1836
5fa8e0a1
JK
1837/*
1838 * Remove special file priviledges (suid, capabilities) when file is written
1839 * to or truncated.
1840 */
1841int file_remove_privs(struct file *file)
3ed37648 1842{
c1892c37
MS
1843 struct dentry *dentry = file_dentry(file);
1844 struct inode *inode = file_inode(file);
dbfae0cd 1845 int kill;
3ed37648
CW
1846 int error = 0;
1847
f69e749a
AL
1848 /*
1849 * Fast path for nothing security related.
1850 * As well for non-regular files, e.g. blkdev inodes.
1851 * For example, blkdev_write_iter() might get here
1852 * trying to remove privs which it is not allowed to.
1853 */
1854 if (IS_NOSEC(inode) || !S_ISREG(inode->i_mode))
3ed37648
CW
1855 return 0;
1856
c1892c37 1857 kill = dentry_needs_remove_privs(dentry);
dbfae0cd
JK
1858 if (kill < 0)
1859 return kill;
1860 if (kill)
1861 error = __remove_privs(dentry, kill);
2426f391
JK
1862 if (!error)
1863 inode_has_no_xattr(inode);
3ed37648
CW
1864
1865 return error;
1866}
5fa8e0a1 1867EXPORT_SYMBOL(file_remove_privs);
3ed37648 1868
1da177e4 1869/**
870f4817
CH
1870 * file_update_time - update mtime and ctime time
1871 * @file: file accessed
1da177e4 1872 *
870f4817
CH
1873 * Update the mtime and ctime members of an inode and mark the inode
1874 * for writeback. Note that this function is meant exclusively for
1875 * usage in the file write path of filesystems, and filesystems may
1876 * choose to explicitly ignore update via this function with the
2eadfc0e 1877 * S_NOCMTIME inode flag, e.g. for network filesystem where these
c3b2da31
JB
1878 * timestamps are handled by the server. This can return an error for
1879 * file systems who need to allocate space in order to update an inode.
1da177e4
LT
1880 */
1881
c3b2da31 1882int file_update_time(struct file *file)
1da177e4 1883{
496ad9aa 1884 struct inode *inode = file_inode(file);
95582b00 1885 struct timespec64 now;
c3b2da31
JB
1886 int sync_it = 0;
1887 int ret;
1da177e4 1888
ce06e0b2 1889 /* First try to exhaust all avenues to not sync */
1da177e4 1890 if (IS_NOCMTIME(inode))
c3b2da31 1891 return 0;
20ddee2c 1892
c2050a45 1893 now = current_time(inode);
95582b00 1894 if (!timespec64_equal(&inode->i_mtime, &now))
ce06e0b2 1895 sync_it = S_MTIME;
1da177e4 1896
95582b00 1897 if (!timespec64_equal(&inode->i_ctime, &now))
ce06e0b2 1898 sync_it |= S_CTIME;
870f4817 1899
e38cf302 1900 if (IS_I_VERSION(inode) && inode_iversion_need_inc(inode))
ce06e0b2 1901 sync_it |= S_VERSION;
7a224228 1902
ce06e0b2 1903 if (!sync_it)
c3b2da31 1904 return 0;
ce06e0b2
AK
1905
1906 /* Finally allowed to write? Takes lock. */
eb04c282 1907 if (__mnt_want_write_file(file))
c3b2da31 1908 return 0;
ce06e0b2 1909
c3b2da31 1910 ret = update_time(inode, &now, sync_it);
eb04c282 1911 __mnt_drop_write_file(file);
c3b2da31
JB
1912
1913 return ret;
1da177e4 1914}
870f4817 1915EXPORT_SYMBOL(file_update_time);
1da177e4 1916
e38f7f53
AG
1917/* Caller must hold the file's inode lock */
1918int file_modified(struct file *file)
1919{
1920 int err;
1921
1922 /*
1923 * Clear the security bits if the process is not being run by root.
1924 * This keeps people from modifying setuid and setgid binaries.
1925 */
1926 err = file_remove_privs(file);
1927 if (err)
1928 return err;
1929
1930 if (unlikely(file->f_mode & FMODE_NOCMTIME))
1931 return 0;
1932
1933 return file_update_time(file);
1934}
1935EXPORT_SYMBOL(file_modified);
1936
1da177e4
LT
1937int inode_needs_sync(struct inode *inode)
1938{
1939 if (IS_SYNC(inode))
1940 return 1;
1941 if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
1942 return 1;
1943 return 0;
1944}
1da177e4
LT
1945EXPORT_SYMBOL(inode_needs_sync);
1946
1da177e4 1947/*
168a9fd6
MS
1948 * If we try to find an inode in the inode hash while it is being
1949 * deleted, we have to wait until the filesystem completes its
1950 * deletion before reporting that it isn't found. This function waits
1951 * until the deletion _might_ have completed. Callers are responsible
1952 * to recheck inode state.
1953 *
eaff8079 1954 * It doesn't matter if I_NEW is not set initially, a call to
250df6ed
DC
1955 * wake_up_bit(&inode->i_state, __I_NEW) after removing from the hash list
1956 * will DTRT.
1da177e4
LT
1957 */
1958static void __wait_on_freeing_inode(struct inode *inode)
1959{
1960 wait_queue_head_t *wq;
eaff8079
CH
1961 DEFINE_WAIT_BIT(wait, &inode->i_state, __I_NEW);
1962 wq = bit_waitqueue(&inode->i_state, __I_NEW);
21417136 1963 prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
250df6ed 1964 spin_unlock(&inode->i_lock);
67a23c49 1965 spin_unlock(&inode_hash_lock);
1da177e4 1966 schedule();
21417136 1967 finish_wait(wq, &wait.wq_entry);
67a23c49 1968 spin_lock(&inode_hash_lock);
1da177e4
LT
1969}
1970
1da177e4
LT
1971static __initdata unsigned long ihash_entries;
1972static int __init set_ihash_entries(char *str)
1973{
1974 if (!str)
1975 return 0;
1976 ihash_entries = simple_strtoul(str, &str, 0);
1977 return 1;
1978}
1979__setup("ihash_entries=", set_ihash_entries);
1980
1981/*
1982 * Initialize the waitqueues and inode hash table.
1983 */
1984void __init inode_init_early(void)
1985{
1da177e4
LT
1986 /* If hashes are distributed across NUMA nodes, defer
1987 * hash allocation until vmalloc space is available.
1988 */
1989 if (hashdist)
1990 return;
1991
1992 inode_hashtable =
1993 alloc_large_system_hash("Inode-cache",
1994 sizeof(struct hlist_head),
1995 ihash_entries,
1996 14,
3d375d78 1997 HASH_EARLY | HASH_ZERO,
1da177e4
LT
1998 &i_hash_shift,
1999 &i_hash_mask,
31fe62b9 2000 0,
1da177e4 2001 0);
1da177e4
LT
2002}
2003
74bf17cf 2004void __init inode_init(void)
1da177e4 2005{
1da177e4 2006 /* inode slab cache */
b0196009
PJ
2007 inode_cachep = kmem_cache_create("inode_cache",
2008 sizeof(struct inode),
2009 0,
2010 (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|
5d097056 2011 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
20c2df83 2012 init_once);
1da177e4
LT
2013
2014 /* Hash may have been set up in inode_init_early */
2015 if (!hashdist)
2016 return;
2017
2018 inode_hashtable =
2019 alloc_large_system_hash("Inode-cache",
2020 sizeof(struct hlist_head),
2021 ihash_entries,
2022 14,
3d375d78 2023 HASH_ZERO,
1da177e4
LT
2024 &i_hash_shift,
2025 &i_hash_mask,
31fe62b9 2026 0,
1da177e4 2027 0);
1da177e4
LT
2028}
2029
2030void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
2031{
2032 inode->i_mode = mode;
2033 if (S_ISCHR(mode)) {
2034 inode->i_fop = &def_chr_fops;
2035 inode->i_rdev = rdev;
2036 } else if (S_ISBLK(mode)) {
2037 inode->i_fop = &def_blk_fops;
2038 inode->i_rdev = rdev;
2039 } else if (S_ISFIFO(mode))
599a0ac1 2040 inode->i_fop = &pipefifo_fops;
1da177e4 2041 else if (S_ISSOCK(mode))
bd9b51e7 2042 ; /* leave it no_open_fops */
1da177e4 2043 else
af0d9ae8
MK
2044 printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o) for"
2045 " inode %s:%lu\n", mode, inode->i_sb->s_id,
2046 inode->i_ino);
1da177e4
LT
2047}
2048EXPORT_SYMBOL(init_special_inode);
a1bd120d
DM
2049
2050/**
eaae668d 2051 * inode_init_owner - Init uid,gid,mode for new inode according to posix standards
a1bd120d
DM
2052 * @inode: New inode
2053 * @dir: Directory inode
2054 * @mode: mode of the new inode
2055 */
2056void inode_init_owner(struct inode *inode, const struct inode *dir,
62bb1091 2057 umode_t mode)
a1bd120d
DM
2058{
2059 inode->i_uid = current_fsuid();
2060 if (dir && dir->i_mode & S_ISGID) {
2061 inode->i_gid = dir->i_gid;
0fa3ecd8
LT
2062
2063 /* Directories are special, and always inherit S_ISGID */
a1bd120d
DM
2064 if (S_ISDIR(mode))
2065 mode |= S_ISGID;
0fa3ecd8
LT
2066 else if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP) &&
2067 !in_group_p(inode->i_gid) &&
2068 !capable_wrt_inode_uidgid(dir, CAP_FSETID))
2069 mode &= ~S_ISGID;
a1bd120d
DM
2070 } else
2071 inode->i_gid = current_fsgid();
2072 inode->i_mode = mode;
2073}
2074EXPORT_SYMBOL(inode_init_owner);
e795b717 2075
2e149670
SH
2076/**
2077 * inode_owner_or_capable - check current task permissions to inode
2078 * @inode: inode being checked
2079 *
23adbe12
AL
2080 * Return true if current either has CAP_FOWNER in a namespace with the
2081 * inode owner uid mapped, or owns the file.
e795b717 2082 */
2e149670 2083bool inode_owner_or_capable(const struct inode *inode)
e795b717 2084{
23adbe12
AL
2085 struct user_namespace *ns;
2086
92361636 2087 if (uid_eq(current_fsuid(), inode->i_uid))
e795b717 2088 return true;
23adbe12
AL
2089
2090 ns = current_user_ns();
cc658db4 2091 if (kuid_has_mapping(ns, inode->i_uid) && ns_capable(ns, CAP_FOWNER))
e795b717
SH
2092 return true;
2093 return false;
2094}
2e149670 2095EXPORT_SYMBOL(inode_owner_or_capable);
1d59d61f
TM
2096
2097/*
2098 * Direct i/o helper functions
2099 */
2100static void __inode_dio_wait(struct inode *inode)
2101{
2102 wait_queue_head_t *wq = bit_waitqueue(&inode->i_state, __I_DIO_WAKEUP);
2103 DEFINE_WAIT_BIT(q, &inode->i_state, __I_DIO_WAKEUP);
2104
2105 do {
21417136 2106 prepare_to_wait(wq, &q.wq_entry, TASK_UNINTERRUPTIBLE);
1d59d61f
TM
2107 if (atomic_read(&inode->i_dio_count))
2108 schedule();
2109 } while (atomic_read(&inode->i_dio_count));
21417136 2110 finish_wait(wq, &q.wq_entry);
1d59d61f
TM
2111}
2112
2113/**
2114 * inode_dio_wait - wait for outstanding DIO requests to finish
2115 * @inode: inode to wait for
2116 *
2117 * Waits for all pending direct I/O requests to finish so that we can
2118 * proceed with a truncate or equivalent operation.
2119 *
2120 * Must be called under a lock that serializes taking new references
2121 * to i_dio_count, usually by inode->i_mutex.
2122 */
2123void inode_dio_wait(struct inode *inode)
2124{
2125 if (atomic_read(&inode->i_dio_count))
2126 __inode_dio_wait(inode);
2127}
2128EXPORT_SYMBOL(inode_dio_wait);
2129
5f16f322
TT
2130/*
2131 * inode_set_flags - atomically set some inode flags
2132 *
2133 * Note: the caller should be holding i_mutex, or else be sure that
2134 * they have exclusive access to the inode structure (i.e., while the
2135 * inode is being instantiated). The reason for the cmpxchg() loop
2136 * --- which wouldn't be necessary if all code paths which modify
2137 * i_flags actually followed this rule, is that there is at least one
5fa8e0a1
JK
2138 * code path which doesn't today so we use cmpxchg() out of an abundance
2139 * of caution.
5f16f322
TT
2140 *
2141 * In the long run, i_mutex is overkill, and we should probably look
2142 * at using the i_lock spinlock to protect i_flags, and then make sure
2143 * it is so documented in include/linux/fs.h and that all code follows
2144 * the locking convention!!
2145 */
2146void inode_set_flags(struct inode *inode, unsigned int flags,
2147 unsigned int mask)
2148{
5f16f322 2149 WARN_ON_ONCE(flags & ~mask);
a905737f 2150 set_mask_bits(&inode->i_flags, mask, flags);
5f16f322
TT
2151}
2152EXPORT_SYMBOL(inode_set_flags);
21fc61c7
AV
2153
2154void inode_nohighmem(struct inode *inode)
2155{
2156 mapping_set_gfp_mask(inode->i_mapping, GFP_USER);
2157}
2158EXPORT_SYMBOL(inode_nohighmem);
3cd88666 2159
50e17c00
DD
2160/**
2161 * timestamp_truncate - Truncate timespec to a granularity
2162 * @t: Timespec
2163 * @inode: inode being updated
2164 *
2165 * Truncate a timespec to the granularity supported by the fs
2166 * containing the inode. Always rounds down. gran must
2167 * not be 0 nor greater than a second (NSEC_PER_SEC, or 10^9 ns).
2168 */
2169struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode)
2170{
2171 struct super_block *sb = inode->i_sb;
2172 unsigned int gran = sb->s_time_gran;
2173
2174 t.tv_sec = clamp(t.tv_sec, sb->s_time_min, sb->s_time_max);
2175 if (unlikely(t.tv_sec == sb->s_time_max || t.tv_sec == sb->s_time_min))
2176 t.tv_nsec = 0;
2177
2178 /* Avoid division in the common cases 1 ns and 1 s. */
2179 if (gran == 1)
2180 ; /* nothing */
2181 else if (gran == NSEC_PER_SEC)
2182 t.tv_nsec = 0;
2183 else if (gran > 1 && gran < NSEC_PER_SEC)
2184 t.tv_nsec -= t.tv_nsec % gran;
2185 else
2186 WARN(1, "invalid file time granularity: %u", gran);
2187 return t;
2188}
2189EXPORT_SYMBOL(timestamp_truncate);
2190
3cd88666
DD
2191/**
2192 * current_time - Return FS time
2193 * @inode: inode.
2194 *
2195 * Return the current time truncated to the time granularity supported by
2196 * the fs.
2197 *
2198 * Note that inode and inode->sb cannot be NULL.
2199 * Otherwise, the function warns and returns time without truncation.
2200 */
95582b00 2201struct timespec64 current_time(struct inode *inode)
3cd88666 2202{
d651d160
AB
2203 struct timespec64 now;
2204
2205 ktime_get_coarse_real_ts64(&now);
3cd88666
DD
2206
2207 if (unlikely(!inode->i_sb)) {
2208 WARN(1, "current_time() called with uninitialized super_block in the inode");
2209 return now;
2210 }
2211
50e17c00 2212 return timestamp_truncate(now, inode);
3cd88666
DD
2213}
2214EXPORT_SYMBOL(current_time);
5aca2842
DW
2215
2216/*
2217 * Generic function to check FS_IOC_SETFLAGS values and reject any invalid
2218 * configurations.
2219 *
2220 * Note: the caller should be holding i_mutex, or else be sure that they have
2221 * exclusive access to the inode structure.
2222 */
2223int vfs_ioc_setflags_prepare(struct inode *inode, unsigned int oldflags,
2224 unsigned int flags)
2225{
2226 /*
2227 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
2228 * the relevant capability.
2229 *
2230 * This test looks nicer. Thanks to Pauline Middelink
2231 */
2232 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL) &&
2233 !capable(CAP_LINUX_IMMUTABLE))
2234 return -EPERM;
2235
6e1918cf 2236 return fscrypt_prepare_setflags(inode, oldflags, flags);
5aca2842
DW
2237}
2238EXPORT_SYMBOL(vfs_ioc_setflags_prepare);
7b0e492e
DW
2239
2240/*
2241 * Generic function to check FS_IOC_FSSETXATTR values and reject any invalid
2242 * configurations.
2243 *
2244 * Note: the caller should be holding i_mutex, or else be sure that they have
2245 * exclusive access to the inode structure.
2246 */
2247int vfs_ioc_fssetxattr_check(struct inode *inode, const struct fsxattr *old_fa,
2248 struct fsxattr *fa)
2249{
2250 /*
2251 * Can't modify an immutable/append-only file unless we have
2252 * appropriate permission.
2253 */
2254 if ((old_fa->fsx_xflags ^ fa->fsx_xflags) &
2255 (FS_XFLAG_IMMUTABLE | FS_XFLAG_APPEND) &&
2256 !capable(CAP_LINUX_IMMUTABLE))
2257 return -EPERM;
2258
f991492e
DW
2259 /*
2260 * Project Quota ID state is only allowed to change from within the init
2261 * namespace. Enforce that restriction only if we are trying to change
2262 * the quota ID state. Everything else is allowed in user namespaces.
2263 */
2264 if (current_user_ns() != &init_user_ns) {
2265 if (old_fa->fsx_projid != fa->fsx_projid)
2266 return -EINVAL;
2267 if ((old_fa->fsx_xflags ^ fa->fsx_xflags) &
2268 FS_XFLAG_PROJINHERIT)
2269 return -EINVAL;
2270 }
2271
ca29be75
DW
2272 /* Check extent size hints. */
2273 if ((fa->fsx_xflags & FS_XFLAG_EXTSIZE) && !S_ISREG(inode->i_mode))
2274 return -EINVAL;
2275
2276 if ((fa->fsx_xflags & FS_XFLAG_EXTSZINHERIT) &&
2277 !S_ISDIR(inode->i_mode))
2278 return -EINVAL;
2279
2280 if ((fa->fsx_xflags & FS_XFLAG_COWEXTSIZE) &&
2281 !S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
2282 return -EINVAL;
2283
dbc77f31
DW
2284 /*
2285 * It is only valid to set the DAX flag on regular files and
2286 * directories on filesystems.
2287 */
2288 if ((fa->fsx_xflags & FS_XFLAG_DAX) &&
2289 !(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
2290 return -EINVAL;
2291
ca29be75
DW
2292 /* Extent size hints of zero turn off the flags. */
2293 if (fa->fsx_extsize == 0)
2294 fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE | FS_XFLAG_EXTSZINHERIT);
2295 if (fa->fsx_cowextsize == 0)
2296 fa->fsx_xflags &= ~FS_XFLAG_COWEXTSIZE;
2297
7b0e492e
DW
2298 return 0;
2299}
2300EXPORT_SYMBOL(vfs_ioc_fssetxattr_check);