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