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