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