1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _LINUX_FS_H
3	#define _LINUX_FS_H
4
5	#include <linux/linkage.h>
6	#include <linux/wait_bit.h>
7	#include <linux/kdev_t.h>
8	#include <linux/dcache.h>
9	#include <linux/path.h>
10	#include <linux/stat.h>
11	#include <linux/cache.h>
12	#include <linux/list.h>
13	#include <linux/list_lru.h>
14	#include <linux/llist.h>
15	#include <linux/radix-tree.h>
16	#include <linux/xarray.h>
17	#include <linux/rbtree.h>
18	#include <linux/init.h>
19	#include <linux/pid.h>
20	#include <linux/bug.h>
21	#include <linux/mutex.h>
22	#include <linux/rwsem.h>
23	#include <linux/mm_types.h>
24	#include <linux/capability.h>
25	#include <linux/semaphore.h>
26	#include <linux/fcntl.h>
27	#include <linux/rculist_bl.h>
28	#include <linux/atomic.h>
29	#include <linux/shrinker.h>
30	#include <linux/migrate_mode.h>
31	#include <linux/uidgid.h>
32	#include <linux/lockdep.h>
33	#include <linux/percpu-rwsem.h>
34	#include <linux/workqueue.h>
35	#include <linux/delayed_call.h>
36	#include <linux/uuid.h>
37	#include <linux/errseq.h>
38	#include <linux/ioprio.h>
39	#include <linux/fs_types.h>
40	#include <linux/build_bug.h>
41	#include <linux/stddef.h>
42	#include <linux/mount.h>
43	#include <linux/cred.h>
44	#include <linux/mnt_idmapping.h>
45	#include <linux/slab.h>
46
47	#include <asm/byteorder.h>
48	#include <uapi/linux/fs.h>
49
50	struct backing_dev_info;
51	struct bdi_writeback;
52	struct bio;
53	struct io_comp_batch;
54	struct export_operations;
55	struct fiemap_extent_info;
56	struct hd_geometry;
57	struct iovec;
58	struct kiocb;
59	struct kobject;
60	struct pipe_inode_info;
61	struct poll_table_struct;
62	struct kstatfs;
63	struct vm_area_struct;
64	struct vfsmount;
65	struct cred;
66	struct swap_info_struct;
67	struct seq_file;
68	struct workqueue_struct;
69	struct iov_iter;
70	struct fscrypt_info;
71	struct fscrypt_operations;
72	struct fsverity_info;
73	struct fsverity_operations;
74	struct fs_context;
75	struct fs_parameter_spec;
76	struct fileattr;
77	struct iomap_ops;
78
79	extern void __init inode_init(void);
80	extern void __init inode_init_early(void);
81	extern void __init files_init(void);
82	extern void __init files_maxfiles_init(void);
83
84	extern unsigned long get_max_files(void);
85	extern unsigned int sysctl_nr_open;
86
87	typedef __kernel_rwf_t rwf_t;
88
89	struct buffer_head;
90	typedef int (get_block_t)(struct inode *inode, sector_t iblock,
91	struct buffer_head *bh_result, int create);
92	typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
93	ssize_t bytes, void *private);
94
95	#define MAY_EXEC 0x00000001
96	#define MAY_WRITE 0x00000002
97	#define MAY_READ 0x00000004
98	#define MAY_APPEND 0x00000008
99	#define MAY_ACCESS 0x00000010
100	#define MAY_OPEN 0x00000020
101	#define MAY_CHDIR 0x00000040
102	/* called from RCU mode, don't block */
103	#define MAY_NOT_BLOCK 0x00000080
104
105	/*
106	* flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
107	* to O_WRONLY and O_RDWR via the strange trick in do_dentry_open()
108	*/
109
110	/* file is open for reading */
111	#define FMODE_READ ((__force fmode_t)0x1)
112	/* file is open for writing */
113	#define FMODE_WRITE ((__force fmode_t)0x2)
114	/* file is seekable */
115	#define FMODE_LSEEK ((__force fmode_t)0x4)
116	/* file can be accessed using pread */
117	#define FMODE_PREAD ((__force fmode_t)0x8)
118	/* file can be accessed using pwrite */
119	#define FMODE_PWRITE ((__force fmode_t)0x10)
120	/* File is opened for execution with sys_execve / sys_uselib */
121	#define FMODE_EXEC ((__force fmode_t)0x20)
122	/* File is opened with O_NDELAY (only set for block devices) */
123	#define FMODE_NDELAY ((__force fmode_t)0x40)
124	/* File is opened with O_EXCL (only set for block devices) */
125	#define FMODE_EXCL ((__force fmode_t)0x80)
126	/* File is opened using open(.., 3, ..) and is writeable only for ioctls
127	(specialy hack for floppy.c) */
128	#define FMODE_WRITE_IOCTL ((__force fmode_t)0x100)
129	/* 32bit hashes as llseek() offset (for directories) */
130	#define FMODE_32BITHASH ((__force fmode_t)0x200)
131	/* 64bit hashes as llseek() offset (for directories) */
132	#define FMODE_64BITHASH ((__force fmode_t)0x400)
133
134	/*
135	* Don't update ctime and mtime.
136	*
137	* Currently a special hack for the XFS open_by_handle ioctl, but we'll
138	* hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
139	*/
140	#define FMODE_NOCMTIME ((__force fmode_t)0x800)
141
142	/* Expect random access pattern */
143	#define FMODE_RANDOM ((__force fmode_t)0x1000)
144
145	/* File is huge (eg. /dev/mem): treat loff_t as unsigned */
146	#define FMODE_UNSIGNED_OFFSET ((__force fmode_t)0x2000)
147
148	/* File is opened with O_PATH; almost nothing can be done with it */
149	#define FMODE_PATH ((__force fmode_t)0x4000)
150
151	/* File needs atomic accesses to f_pos */
152	#define FMODE_ATOMIC_POS ((__force fmode_t)0x8000)
153	/* Write access to underlying fs */
154	#define FMODE_WRITER ((__force fmode_t)0x10000)
155	/* Has read method(s) */
156	#define FMODE_CAN_READ ((__force fmode_t)0x20000)
157	/* Has write method(s) */
158	#define FMODE_CAN_WRITE ((__force fmode_t)0x40000)
159
160	#define FMODE_OPENED ((__force fmode_t)0x80000)
161	#define FMODE_CREATED ((__force fmode_t)0x100000)
162
163	/* File is stream-like */
164	#define FMODE_STREAM ((__force fmode_t)0x200000)
165
166	/* File supports DIRECT IO */
167	#define FMODE_CAN_ODIRECT ((__force fmode_t)0x400000)
168
169	/* File was opened by fanotify and shouldn't generate fanotify events */
170	#define FMODE_NONOTIFY ((__force fmode_t)0x4000000)
171
172	/* File is capable of returning -EAGAIN if I/O will block */
173	#define FMODE_NOWAIT ((__force fmode_t)0x8000000)
174
175	/* File represents mount that needs unmounting */
176	#define FMODE_NEED_UNMOUNT ((__force fmode_t)0x10000000)
177
178	/* File does not contribute to nr_files count */
179	#define FMODE_NOACCOUNT ((__force fmode_t)0x20000000)
180
181	/* File supports async buffered reads */
182	#define FMODE_BUF_RASYNC ((__force fmode_t)0x40000000)
183
184	/* File supports async nowait buffered writes */
185	#define FMODE_BUF_WASYNC ((__force fmode_t)0x80000000)
186
187	/*
188	* Attribute flags. These should be or-ed together to figure out what
189	* has been changed!
190	*/
191	#define ATTR_MODE (1 << 0)
192	#define ATTR_UID (1 << 1)
193	#define ATTR_GID (1 << 2)
194	#define ATTR_SIZE (1 << 3)
195	#define ATTR_ATIME (1 << 4)
196	#define ATTR_MTIME (1 << 5)
197	#define ATTR_CTIME (1 << 6)
198	#define ATTR_ATIME_SET (1 << 7)
199	#define ATTR_MTIME_SET (1 << 8)
200	#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
201	#define ATTR_KILL_SUID (1 << 11)
202	#define ATTR_KILL_SGID (1 << 12)
203	#define ATTR_FILE (1 << 13)
204	#define ATTR_KILL_PRIV (1 << 14)
205	#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
206	#define ATTR_TIMES_SET (1 << 16)
207	#define ATTR_TOUCH (1 << 17)
208
209	/*
210	* Whiteout is represented by a char device. The following constants define the
211	* mode and device number to use.
212	*/
213	#define WHITEOUT_MODE 0
214	#define WHITEOUT_DEV 0
215
216	/*
217	* This is the Inode Attributes structure, used for notify_change(). It
218	* uses the above definitions as flags, to know which values have changed.
219	* Also, in this manner, a Filesystem can look at only the values it cares
220	* about. Basically, these are the attributes that the VFS layer can
221	* request to change from the FS layer.
222	*
223	* Derek Atkins <warlord@MIT.EDU> 94-10-20
224	*/
225	struct iattr {
226	unsigned int ia_valid;
227	umode_t ia_mode;
228	/*
229	* The two anonymous unions wrap structures with the same member.
230	*
231	* Filesystems raising FS_ALLOW_IDMAP need to use ia_vfs{g,u}id which
232	* are a dedicated type requiring the filesystem to use the dedicated
233	* helpers. Other filesystem can continue to use ia_{g,u}id until they
234	* have been ported.
235	*
236	* They always contain the same value. In other words FS_ALLOW_IDMAP
237	* pass down the same value on idmapped mounts as they would on regular
238	* mounts.
239	*/
240	union {
241	kuid_t ia_uid;
242	vfsuid_t ia_vfsuid;
243	};
244	union {
245	kgid_t ia_gid;
246	vfsgid_t ia_vfsgid;
247	};
248	loff_t ia_size;
249	struct timespec64 ia_atime;
250	struct timespec64 ia_mtime;
251	struct timespec64 ia_ctime;
252
253	/*
254	* Not an attribute, but an auxiliary info for filesystems wanting to
255	* implement an ftruncate() like method. NOTE: filesystem should
256	* check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
257	*/
258	struct file *ia_file;
259	};
260
261	/*
262	* Includes for diskquotas.
263	*/
264	#include <linux/quota.h>
265
266	/*
267	* Maximum number of layers of fs stack. Needs to be limited to
268	* prevent kernel stack overflow
269	*/
270	#define FILESYSTEM_MAX_STACK_DEPTH 2
271
272	/**
273	* enum positive_aop_returns - aop return codes with specific semantics
274	*
275	* @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
276	* completed, that the page is still locked, and
277	* should be considered active. The VM uses this hint
278	* to return the page to the active list -- it won't
279	* be a candidate for writeback again in the near
280	* future. Other callers must be careful to unlock
281	* the page if they get this return. Returned by
282	* writepage();
283	*
284	* @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
285	* unlocked it and the page might have been truncated.
286	* The caller should back up to acquiring a new page and
287	* trying again. The aop will be taking reasonable
288	* precautions not to livelock. If the caller held a page
289	* reference, it should drop it before retrying. Returned
290	* by read_folio().
291	*
292	* address_space_operation functions return these large constants to indicate
293	* special semantics to the caller. These are much larger than the bytes in a
294	* page to allow for functions that return the number of bytes operated on in a
295	* given page.
296	*/
297
298	enum positive_aop_returns {
299	AOP_WRITEPAGE_ACTIVATE = 0x80000,
300	AOP_TRUNCATED_PAGE = 0x80001,
301	};
302
303	/*
304	* oh the beauties of C type declarations.
305	*/
306	struct page;
307	struct address_space;
308	struct writeback_control;
309	struct readahead_control;
310
311	/*
312	* Write life time hint values.
313	* Stored in struct inode as u8.
314	*/
315	enum rw_hint {
316	WRITE_LIFE_NOT_SET = 0,
317	WRITE_LIFE_NONE = RWH_WRITE_LIFE_NONE,
318	WRITE_LIFE_SHORT = RWH_WRITE_LIFE_SHORT,
319	WRITE_LIFE_MEDIUM = RWH_WRITE_LIFE_MEDIUM,
320	WRITE_LIFE_LONG = RWH_WRITE_LIFE_LONG,
321	WRITE_LIFE_EXTREME = RWH_WRITE_LIFE_EXTREME,
322	};
323
324	/* Match RWF_* bits to IOCB bits */
325	#define IOCB_HIPRI (__force int) RWF_HIPRI
326	#define IOCB_DSYNC (__force int) RWF_DSYNC
327	#define IOCB_SYNC (__force int) RWF_SYNC
328	#define IOCB_NOWAIT (__force int) RWF_NOWAIT
329	#define IOCB_APPEND (__force int) RWF_APPEND
330
331	/* non-RWF related bits - start at 16 */
332	#define IOCB_EVENTFD (1 << 16)
333	#define IOCB_DIRECT (1 << 17)
334	#define IOCB_WRITE (1 << 18)
335	/* iocb->ki_waitq is valid */
336	#define IOCB_WAITQ (1 << 19)
337	#define IOCB_NOIO (1 << 20)
338	/* can use bio alloc cache */
339	#define IOCB_ALLOC_CACHE (1 << 21)
340
341	struct kiocb {
342	struct file *ki_filp;
343	loff_t ki_pos;
344	void (*ki_complete)(struct kiocb *iocb, long ret);
345	void *private;
346	int ki_flags;
347	u16 ki_ioprio; /* See linux/ioprio.h */
348	struct wait_page_queue *ki_waitq; /* for async buffered IO */
349	};
350
351	static inline bool is_sync_kiocb(struct kiocb *kiocb)
352	{
353	return kiocb->ki_complete == NULL;
354	}
355
356	struct address_space_operations {
357	int (*writepage)(struct page *page, struct writeback_control *wbc);
358	int (*read_folio)(struct file *, struct folio *);
359
360	/* Write back some dirty pages from this mapping. */
361	int (*writepages)(struct address_space *, struct writeback_control *);
362
363	/* Mark a folio dirty. Return true if this dirtied it */
364	bool (*dirty_folio)(struct address_space *, struct folio *);
365
366	void (*readahead)(struct readahead_control *);
367
368	int (*write_begin)(struct file *, struct address_space *mapping,
369	loff_t pos, unsigned len,
370	struct page **pagep, void **fsdata);
371	int (*write_end)(struct file *, struct address_space *mapping,
372	loff_t pos, unsigned len, unsigned copied,
373	struct page *page, void *fsdata);
374
375	/* Unfortunately this kludge is needed for FIBMAP. Don't use it */
376	sector_t (*bmap)(struct address_space *, sector_t);
377	void (*invalidate_folio) (struct folio *, size_t offset, size_t len);
378	bool (*release_folio)(struct folio *, gfp_t);
379	void (*free_folio)(struct folio *folio);
380	ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter);
381	/*
382	* migrate the contents of a folio to the specified target. If
383	* migrate_mode is MIGRATE_ASYNC, it must not block.
384	*/
385	int (*migrate_folio)(struct address_space *, struct folio *dst,
386	struct folio *src, enum migrate_mode);
387	int (*launder_folio)(struct folio *);
388	bool (*is_partially_uptodate) (struct folio *, size_t from,
389	size_t count);
390	void (*is_dirty_writeback) (struct folio *, bool *dirty, bool *wb);
391	int (*error_remove_page)(struct address_space *, struct page *);
392
393	/* swapfile support */
394	int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
395	sector_t *span);
396	void (*swap_deactivate)(struct file *file);
397	int (*swap_rw)(struct kiocb *iocb, struct iov_iter *iter);
398	};
399
400	extern const struct address_space_operations empty_aops;
401
402	/**
403	* struct address_space - Contents of a cacheable, mappable object.
404	* @host: Owner, either the inode or the block_device.
405	* @i_pages: Cached pages.
406	* @invalidate_lock: Guards coherency between page cache contents and
407	* file offset->disk block mappings in the filesystem during invalidates.
408	* It is also used to block modification of page cache contents through
409	* memory mappings.
410	* @gfp_mask: Memory allocation flags to use for allocating pages.
411	* @i_mmap_writable: Number of VM_SHARED mappings.
412	* @nr_thps: Number of THPs in the pagecache (non-shmem only).
413	* @i_mmap: Tree of private and shared mappings.
414	* @i_mmap_rwsem: Protects @i_mmap and @i_mmap_writable.
415	* @nrpages: Number of page entries, protected by the i_pages lock.
416	* @writeback_index: Writeback starts here.
417	* @a_ops: Methods.
418	* @flags: Error bits and flags (AS_*).
419	* @wb_err: The most recent error which has occurred.
420	* @private_lock: For use by the owner of the address_space.
421	* @private_list: For use by the owner of the address_space.
422	* @private_data: For use by the owner of the address_space.
423	*/
424	struct address_space {
425	struct inode *host;
426	struct xarray i_pages;
427	struct rw_semaphore invalidate_lock;
428	gfp_t gfp_mask;
429	atomic_t i_mmap_writable;
430	#ifdef CONFIG_READ_ONLY_THP_FOR_FS
431	/* number of thp, only for non-shmem files */
432	atomic_t nr_thps;
433	#endif
434	struct rb_root_cached i_mmap;
435	struct rw_semaphore i_mmap_rwsem;
436	unsigned long nrpages;
437	pgoff_t writeback_index;
438	const struct address_space_operations *a_ops;
439	unsigned long flags;
440	errseq_t wb_err;
441	spinlock_t private_lock;
442	struct list_head private_list;
443	void *private_data;
444	} __attribute__((aligned(sizeof(long)))) __randomize_layout;
445	/*
446	* On most architectures that alignment is already the case; but
447	* must be enforced here for CRIS, to let the least significant bit
448	* of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
449	*/
450
451	/* XArray tags, for tagging dirty and writeback pages in the pagecache. */
452	#define PAGECACHE_TAG_DIRTY XA_MARK_0
453	#define PAGECACHE_TAG_WRITEBACK XA_MARK_1
454	#define PAGECACHE_TAG_TOWRITE XA_MARK_2
455
456	/*
457	* Returns true if any of the pages in the mapping are marked with the tag.
458	*/
459	static inline bool mapping_tagged(struct address_space *mapping, xa_mark_t tag)
460	{
461	return xa_marked(&mapping->i_pages, tag);
462	}
463
464	static inline void i_mmap_lock_write(struct address_space *mapping)
465	{
466	down_write(&mapping->i_mmap_rwsem);
467	}
468
469	static inline int i_mmap_trylock_write(struct address_space *mapping)
470	{
471	return down_write_trylock(&mapping->i_mmap_rwsem);
472	}
473
474	static inline void i_mmap_unlock_write(struct address_space *mapping)
475	{
476	up_write(&mapping->i_mmap_rwsem);
477	}
478
479	static inline int i_mmap_trylock_read(struct address_space *mapping)
480	{
481	return down_read_trylock(&mapping->i_mmap_rwsem);
482	}
483
484	static inline void i_mmap_lock_read(struct address_space *mapping)
485	{
486	down_read(&mapping->i_mmap_rwsem);
487	}
488
489	static inline void i_mmap_unlock_read(struct address_space *mapping)
490	{
491	up_read(&mapping->i_mmap_rwsem);
492	}
493
494	static inline void i_mmap_assert_locked(struct address_space *mapping)
495	{
496	lockdep_assert_held(&mapping->i_mmap_rwsem);
497	}
498
499	static inline void i_mmap_assert_write_locked(struct address_space *mapping)
500	{
501	lockdep_assert_held_write(&mapping->i_mmap_rwsem);
502	}
503
504	/*
505	* Might pages of this file be mapped into userspace?
506	*/
507	static inline int mapping_mapped(struct address_space *mapping)
508	{
509	return !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root);
510	}
511
512	/*
513	* Might pages of this file have been modified in userspace?
514	* Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap
515	* marks vma as VM_SHARED if it is shared, and the file was opened for
516	* writing i.e. vma may be mprotected writable even if now readonly.
517	*
518	* If i_mmap_writable is negative, no new writable mappings are allowed. You
519	* can only deny writable mappings, if none exists right now.
520	*/
521	static inline int mapping_writably_mapped(struct address_space *mapping)
522	{
523	return atomic_read(&mapping->i_mmap_writable) > 0;
524	}
525
526	static inline int mapping_map_writable(struct address_space *mapping)
527	{
528	return atomic_inc_unless_negative(&mapping->i_mmap_writable) ?
529	0 : -EPERM;
530	}
531
532	static inline void mapping_unmap_writable(struct address_space *mapping)
533	{
534	atomic_dec(&mapping->i_mmap_writable);
535	}
536
537	static inline int mapping_deny_writable(struct address_space *mapping)
538	{
539	return atomic_dec_unless_positive(&mapping->i_mmap_writable) ?
540	0 : -EBUSY;
541	}
542
543	static inline void mapping_allow_writable(struct address_space *mapping)
544	{
545	atomic_inc(&mapping->i_mmap_writable);
546	}
547
548	/*
549	* Use sequence counter to get consistent i_size on 32-bit processors.
550	*/
551	#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
552	#include <linux/seqlock.h>
553	#define __NEED_I_SIZE_ORDERED
554	#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
555	#else
556	#define i_size_ordered_init(inode) do { } while (0)
557	#endif
558
559	struct posix_acl;
560	#define ACL_NOT_CACHED ((void *)(-1))
561	/*
562	* ACL_DONT_CACHE is for stacked filesystems, that rely on underlying fs to
563	* cache the ACL. This also means that ->get_acl() can be called in RCU mode
564	* with the LOOKUP_RCU flag.
565	*/
566	#define ACL_DONT_CACHE ((void *)(-3))
567
568	static inline struct posix_acl *
569	uncached_acl_sentinel(struct task_struct *task)
570	{
571	return (void *)task + 1;
572	}
573
574	static inline bool
575	is_uncached_acl(struct posix_acl *acl)
576	{
577	return (long)acl & 1;
578	}
579
580	#define IOP_FASTPERM 0x0001
581	#define IOP_LOOKUP 0x0002
582	#define IOP_NOFOLLOW 0x0004
583	#define IOP_XATTR 0x0008
584	#define IOP_DEFAULT_READLINK 0x0010
585
586	struct fsnotify_mark_connector;
587
588	/*
589	* Keep mostly read-only and often accessed (especially for
590	* the RCU path lookup and 'stat' data) fields at the beginning
591	* of the 'struct inode'
592	*/
593	struct inode {
594	umode_t i_mode;
595	unsigned short i_opflags;
596	kuid_t i_uid;
597	kgid_t i_gid;
598	unsigned int i_flags;
599
600	#ifdef CONFIG_FS_POSIX_ACL
601	struct posix_acl *i_acl;
602	struct posix_acl *i_default_acl;
603	#endif
604
605	const struct inode_operations *i_op;
606	struct super_block *i_sb;
607	struct address_space *i_mapping;
608
609	#ifdef CONFIG_SECURITY
610	void *i_security;
611	#endif
612
613	/* Stat data, not accessed from path walking */
614	unsigned long i_ino;
615	/*
616	* Filesystems may only read i_nlink directly. They shall use the
617	* following functions for modification:
618	*
619	* (set|clear|inc|drop)_nlink
620	* inode_(inc|dec)_link_count
621	*/
622	union {
623	const unsigned int i_nlink;
624	unsigned int __i_nlink;
625	};
626	dev_t i_rdev;
627	loff_t i_size;
628	struct timespec64 i_atime;
629	struct timespec64 i_mtime;
630	struct timespec64 i_ctime;
631	spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
632	unsigned short i_bytes;
633	u8 i_blkbits;
634	u8 i_write_hint;
635	blkcnt_t i_blocks;
636
637	#ifdef __NEED_I_SIZE_ORDERED
638	seqcount_t i_size_seqcount;
639	#endif
640
641	/* Misc */
642	unsigned long i_state;
643	struct rw_semaphore i_rwsem;
644
645	unsigned long dirtied_when; /* jiffies of first dirtying */
646	unsigned long dirtied_time_when;
647
648	struct hlist_node i_hash;
649	struct list_head i_io_list; /* backing dev IO list */
650	#ifdef CONFIG_CGROUP_WRITEBACK
651	struct bdi_writeback *i_wb; /* the associated cgroup wb */
652
653	/* foreign inode detection, see wbc_detach_inode() */
654	int i_wb_frn_winner;
655	u16 i_wb_frn_avg_time;
656	u16 i_wb_frn_history;
657	#endif
658	struct list_head i_lru; /* inode LRU list */
659	struct list_head i_sb_list;
660	struct list_head i_wb_list; /* backing dev writeback list */
661	union {
662	struct hlist_head i_dentry;
663	struct rcu_head i_rcu;
664	};
665	atomic64_t i_version;
666	atomic64_t i_sequence; /* see futex */
667	atomic_t i_count;
668	atomic_t i_dio_count;
669	atomic_t i_writecount;
670	#if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
671	atomic_t i_readcount; /* struct files open RO */
672	#endif
673	union {
674	const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
675	void (*free_inode)(struct inode *);
676	};
677	struct file_lock_context *i_flctx;
678	struct address_space i_data;
679	struct list_head i_devices;
680	union {
681	struct pipe_inode_info *i_pipe;
682	struct cdev *i_cdev;
683	char *i_link;
684	unsigned i_dir_seq;
685	};
686
687	__u32 i_generation;
688
689	#ifdef CONFIG_FSNOTIFY
690	__u32 i_fsnotify_mask; /* all events this inode cares about */
691	struct fsnotify_mark_connector __rcu *i_fsnotify_marks;
692	#endif
693
694	#ifdef CONFIG_FS_ENCRYPTION
695	struct fscrypt_info *i_crypt_info;
696	#endif
697
698	#ifdef CONFIG_FS_VERITY
699	struct fsverity_info *i_verity_info;
700	#endif
701
702	void *i_private; /* fs or device private pointer */
703	} __randomize_layout;
704
705	struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
706
707	static inline unsigned int i_blocksize(const struct inode *node)
708	{
709	return (1 << node->i_blkbits);
710	}
711
712	static inline int inode_unhashed(struct inode *inode)
713	{
714	return hlist_unhashed(&inode->i_hash);
715	}
716
717	/*
718	* __mark_inode_dirty expects inodes to be hashed. Since we don't
719	* want special inodes in the fileset inode space, we make them
720	* appear hashed, but do not put on any lists. hlist_del()
721	* will work fine and require no locking.
722	*/
723	static inline void inode_fake_hash(struct inode *inode)
724	{
725	hlist_add_fake(&inode->i_hash);
726	}
727
728	/*
729	* inode->i_mutex nesting subclasses for the lock validator:
730	*
731	* 0: the object of the current VFS operation
732	* 1: parent
733	* 2: child/target
734	* 3: xattr
735	* 4: second non-directory
736	* 5: second parent (when locking independent directories in rename)
737	*
738	* I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two
739	* non-directories at once.
740	*
741	* The locking order between these classes is
742	* parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory
743	*/
744	enum inode_i_mutex_lock_class
745	{
746	I_MUTEX_NORMAL,
747	I_MUTEX_PARENT,
748	I_MUTEX_CHILD,
749	I_MUTEX_XATTR,
750	I_MUTEX_NONDIR2,
751	I_MUTEX_PARENT2,
752	};
753
754	static inline void inode_lock(struct inode *inode)
755	{
756	down_write(&inode->i_rwsem);
757	}
758
759	static inline void inode_unlock(struct inode *inode)
760	{
761	up_write(&inode->i_rwsem);
762	}
763
764	static inline void inode_lock_shared(struct inode *inode)
765	{
766	down_read(&inode->i_rwsem);
767	}
768
769	static inline void inode_unlock_shared(struct inode *inode)
770	{
771	up_read(&inode->i_rwsem);
772	}
773
774	static inline int inode_trylock(struct inode *inode)
775	{
776	return down_write_trylock(&inode->i_rwsem);
777	}
778
779	static inline int inode_trylock_shared(struct inode *inode)
780	{
781	return down_read_trylock(&inode->i_rwsem);
782	}
783
784	static inline int inode_is_locked(struct inode *inode)
785	{
786	return rwsem_is_locked(&inode->i_rwsem);
787	}
788
789	static inline void inode_lock_nested(struct inode *inode, unsigned subclass)
790	{
791	down_write_nested(&inode->i_rwsem, subclass);
792	}
793
794	static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass)
795	{
796	down_read_nested(&inode->i_rwsem, subclass);
797	}
798
799	static inline void filemap_invalidate_lock(struct address_space *mapping)
800	{
801	down_write(&mapping->invalidate_lock);
802	}
803
804	static inline void filemap_invalidate_unlock(struct address_space *mapping)
805	{
806	up_write(&mapping->invalidate_lock);
807	}
808
809	static inline void filemap_invalidate_lock_shared(struct address_space *mapping)
810	{
811	down_read(&mapping->invalidate_lock);
812	}
813
814	static inline int filemap_invalidate_trylock_shared(
815	struct address_space *mapping)
816	{
817	return down_read_trylock(&mapping->invalidate_lock);
818	}
819
820	static inline void filemap_invalidate_unlock_shared(
821	struct address_space *mapping)
822	{
823	up_read(&mapping->invalidate_lock);
824	}
825
826	void lock_two_nondirectories(struct inode *, struct inode*);
827	void unlock_two_nondirectories(struct inode *, struct inode*);
828
829	void filemap_invalidate_lock_two(struct address_space *mapping1,
830	struct address_space *mapping2);
831	void filemap_invalidate_unlock_two(struct address_space *mapping1,
832	struct address_space *mapping2);
833
834
835	/*
836	* NOTE: in a 32bit arch with a preemptable kernel and
837	* an UP compile the i_size_read/write must be atomic
838	* with respect to the local cpu (unlike with preempt disabled),
839	* but they don't need to be atomic with respect to other cpus like in
840	* true SMP (so they need either to either locally disable irq around
841	* the read or for example on x86 they can be still implemented as a
842	* cmpxchg8b without the need of the lock prefix). For SMP compiles
843	* and 64bit archs it makes no difference if preempt is enabled or not.
844	*/
845	static inline loff_t i_size_read(const struct inode *inode)
846	{
847	#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
848	loff_t i_size;
849	unsigned int seq;
850
851	do {
852	seq = read_seqcount_begin(&inode->i_size_seqcount);
853	i_size = inode->i_size;
854	} while (read_seqcount_retry(&inode->i_size_seqcount, seq));
855	return i_size;
856	#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
857	loff_t i_size;
858
859	preempt_disable();
860	i_size = inode->i_size;
861	preempt_enable();
862	return i_size;
863	#else
864	return inode->i_size;
865	#endif
866	}
867
868	/*
869	* NOTE: unlike i_size_read(), i_size_write() does need locking around it
870	* (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
871	* can be lost, resulting in subsequent i_size_read() calls spinning forever.
872	*/
873	static inline void i_size_write(struct inode *inode, loff_t i_size)
874	{
875	#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
876	preempt_disable();
877	write_seqcount_begin(&inode->i_size_seqcount);
878	inode->i_size = i_size;
879	write_seqcount_end(&inode->i_size_seqcount);
880	preempt_enable();
881	#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
882	preempt_disable();
883	inode->i_size = i_size;
884	preempt_enable();
885	#else
886	inode->i_size = i_size;
887	#endif
888	}
889
890	static inline unsigned iminor(const struct inode *inode)
891	{
892	return MINOR(inode->i_rdev);
893	}
894
895	static inline unsigned imajor(const struct inode *inode)
896	{
897	return MAJOR(inode->i_rdev);
898	}
899
900	struct fown_struct {
901	rwlock_t lock; /* protects pid, uid, euid fields */
902	struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
903	enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
904	kuid_t uid, euid; /* uid/euid of process setting the owner */
905	int signum; /* posix.1b rt signal to be delivered on IO */
906	};
907
908	/**
909	* struct file_ra_state - Track a file's readahead state.
910	* @start: Where the most recent readahead started.
911	* @size: Number of pages read in the most recent readahead.
912	* @async_size: Numer of pages that were/are not needed immediately
913	* and so were/are genuinely "ahead". Start next readahead when
914	* the first of these pages is accessed.
915	* @ra_pages: Maximum size of a readahead request, copied from the bdi.
916	* @mmap_miss: How many mmap accesses missed in the page cache.
917	* @prev_pos: The last byte in the most recent read request.
918	*
919	* When this structure is passed to ->readahead(), the "most recent"
920	* readahead means the current readahead.
921	*/
922	struct file_ra_state {
923	pgoff_t start;
924	unsigned int size;
925	unsigned int async_size;
926	unsigned int ra_pages;
927	unsigned int mmap_miss;
928	loff_t prev_pos;
929	};
930
931	/*
932	* Check if @index falls in the readahead windows.
933	*/
934	static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
935	{
936	return (index >= ra->start &&
937	index < ra->start + ra->size);
938	}
939
940	struct file {
941	union {
942	struct llist_node f_llist;
943	struct rcu_head f_rcuhead;
944	unsigned int f_iocb_flags;
945	};
946	struct path f_path;
947	struct inode *f_inode; /* cached value */
948	const struct file_operations *f_op;
949
950	/*
951	* Protects f_ep, f_flags.
952	* Must not be taken from IRQ context.
953	*/
954	spinlock_t f_lock;
955	atomic_long_t f_count;
956	unsigned int f_flags;
957	fmode_t f_mode;
958	struct mutex f_pos_lock;
959	loff_t f_pos;
960	struct fown_struct f_owner;
961	const struct cred *f_cred;
962	struct file_ra_state f_ra;
963
964	u64 f_version;
965	#ifdef CONFIG_SECURITY
966	void *f_security;
967	#endif
968	/* needed for tty driver, and maybe others */
969	void *private_data;
970
971	#ifdef CONFIG_EPOLL
972	/* Used by fs/eventpoll.c to link all the hooks to this file */
973	struct hlist_head *f_ep;
974	#endif /* #ifdef CONFIG_EPOLL */
975	struct address_space *f_mapping;
976	errseq_t f_wb_err;
977	errseq_t f_sb_err; /* for syncfs */
978	} __randomize_layout
979	__attribute__((aligned(4))); /* lest something weird decides that 2 is OK */
980
981	struct file_handle {
982	__u32 handle_bytes;
983	int handle_type;
984	/* file identifier */
985	unsigned char f_handle[];
986	};
987
988	static inline struct file *get_file(struct file *f)
989	{
990	atomic_long_inc(&f->f_count);
991	return f;
992	}
993	#define get_file_rcu(x) atomic_long_inc_not_zero(&(x)->f_count)
994	#define file_count(x) atomic_long_read(&(x)->f_count)
995
996	#define MAX_NON_LFS ((1UL<<31) - 1)
997
998	/* Page cache limit. The filesystems should put that into their s_maxbytes
999	limits, otherwise bad things can happen in VM. */
1000	#if BITS_PER_LONG==32
1001	#define MAX_LFS_FILESIZE ((loff_t)ULONG_MAX << PAGE_SHIFT)
1002	#elif BITS_PER_LONG==64
1003	#define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX)
1004	#endif
1005
1006	#define FL_POSIX 1
1007	#define FL_FLOCK 2
1008	#define FL_DELEG 4 /* NFSv4 delegation */
1009	#define FL_ACCESS 8 /* not trying to lock, just looking */
1010	#define FL_EXISTS 16 /* when unlocking, test for existence */
1011	#define FL_LEASE 32 /* lease held on this file */
1012	#define FL_CLOSE 64 /* unlock on close */
1013	#define FL_SLEEP 128 /* A blocking lock */
1014	#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */
1015	#define FL_UNLOCK_PENDING 512 /* Lease is being broken */
1016	#define FL_OFDLCK 1024 /* lock is "owned" by struct file */
1017	#define FL_LAYOUT 2048 /* outstanding pNFS layout */
1018	#define FL_RECLAIM 4096 /* reclaiming from a reboot server */
1019
1020	#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE)
1021
1022	/*
1023	* Special return value from posix_lock_file() and vfs_lock_file() for
1024	* asynchronous locking.
1025	*/
1026	#define FILE_LOCK_DEFERRED 1
1027
1028	/* legacy typedef, should eventually be removed */
1029	typedef void *fl_owner_t;
1030
1031	struct file_lock;
1032
1033	struct file_lock_operations {
1034	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
1035	void (*fl_release_private)(struct file_lock *);
1036	};
1037
1038	struct lock_manager_operations {
1039	void *lm_mod_owner;
1040	fl_owner_t (*lm_get_owner)(fl_owner_t);
1041	void (*lm_put_owner)(fl_owner_t);
1042	void (*lm_notify)(struct file_lock *); /* unblock callback */
1043	int (*lm_grant)(struct file_lock *, int);
1044	bool (*lm_break)(struct file_lock *);
1045	int (*lm_change)(struct file_lock *, int, struct list_head *);
1046	void (*lm_setup)(struct file_lock *, void **);
1047	bool (*lm_breaker_owns_lease)(struct file_lock *);
1048	bool (*lm_lock_expirable)(struct file_lock *cfl);
1049	void (*lm_expire_lock)(void);
1050	};
1051
1052	struct lock_manager {
1053	struct list_head list;
1054	/*
1055	* NFSv4 and up also want opens blocked during the grace period;
1056	* NLM doesn't care:
1057	*/
1058	bool block_opens;
1059	};
1060
1061	struct net;
1062	void locks_start_grace(struct net *, struct lock_manager *);
1063	void locks_end_grace(struct lock_manager *);
1064	bool locks_in_grace(struct net *);
1065	bool opens_in_grace(struct net *);
1066
1067	/* that will die - we need it for nfs_lock_info */
1068	#include <linux/nfs_fs_i.h>
1069
1070	/*
1071	* struct file_lock represents a generic "file lock". It's used to represent
1072	* POSIX byte range locks, BSD (flock) locks, and leases. It's important to
1073	* note that the same struct is used to represent both a request for a lock and
1074	* the lock itself, but the same object is never used for both.
1075	*
1076	* FIXME: should we create a separate "struct lock_request" to help distinguish
1077	* these two uses?
1078	*
1079	* The varous i_flctx lists are ordered by:
1080	*
1081	* 1) lock owner
1082	* 2) lock range start
1083	* 3) lock range end
1084	*
1085	* Obviously, the last two criteria only matter for POSIX locks.
1086	*/
1087	struct file_lock {
1088	struct file_lock *fl_blocker; /* The lock, that is blocking us */
1089	struct list_head fl_list; /* link into file_lock_context */
1090	struct hlist_node fl_link; /* node in global lists */
1091	struct list_head fl_blocked_requests; /* list of requests with
1092	* ->fl_blocker pointing here
1093	*/
1094	struct list_head fl_blocked_member; /* node in
1095	* ->fl_blocker->fl_blocked_requests
1096	*/
1097	fl_owner_t fl_owner;
1098	unsigned int fl_flags;
1099	unsigned char fl_type;
1100	unsigned int fl_pid;
1101	int fl_link_cpu; /* what cpu's list is this on? */
1102	wait_queue_head_t fl_wait;
1103	struct file *fl_file;
1104	loff_t fl_start;
1105	loff_t fl_end;
1106
1107	struct fasync_struct * fl_fasync; /* for lease break notifications */
1108	/* for lease breaks: */
1109	unsigned long fl_break_time;
1110	unsigned long fl_downgrade_time;
1111
1112	const struct file_lock_operations *fl_ops; /* Callbacks for filesystems */
1113	const struct lock_manager_operations *fl_lmops; /* Callbacks for lockmanagers */
1114	union {
1115	struct nfs_lock_info nfs_fl;
1116	struct nfs4_lock_info nfs4_fl;
1117	struct {
1118	struct list_head link; /* link in AFS vnode's pending_locks list */
1119	int state; /* state of grant or error if -ve */
1120	unsigned int debug_id;
1121	} afs;
1122	} fl_u;
1123	} __randomize_layout;
1124
1125	struct file_lock_context {
1126	spinlock_t flc_lock;
1127	struct list_head flc_flock;
1128	struct list_head flc_posix;
1129	struct list_head flc_lease;
1130	};
1131
1132	/* The following constant reflects the upper bound of the file/locking space */
1133	#ifndef OFFSET_MAX
1134	#define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
1135	#define OFFSET_MAX INT_LIMIT(loff_t)
1136	#define OFFT_OFFSET_MAX INT_LIMIT(off_t)
1137	#endif
1138
1139	extern void send_sigio(struct fown_struct *fown, int fd, int band);
1140
1141	#define locks_inode(f) file_inode(f)
1142
1143	#ifdef CONFIG_FILE_LOCKING
1144	extern int fcntl_getlk(struct file *, unsigned int, struct flock *);
1145	extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
1146	struct flock *);
1147
1148	#if BITS_PER_LONG == 32
1149	extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);
1150	extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
1151	struct flock64 *);
1152	#endif
1153
1154	extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
1155	extern int fcntl_getlease(struct file *filp);
1156
1157	/* fs/locks.c */
1158	void locks_free_lock_context(struct inode *inode);
1159	void locks_free_lock(struct file_lock *fl);
1160	extern void locks_init_lock(struct file_lock *);
1161	extern struct file_lock * locks_alloc_lock(void);
1162	extern void locks_copy_lock(struct file_lock *, struct file_lock *);
1163	extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
1164	extern void locks_remove_posix(struct file *, fl_owner_t);
1165	extern void locks_remove_file(struct file *);
1166	extern void locks_release_private(struct file_lock *);
1167	extern void posix_test_lock(struct file *, struct file_lock *);
1168	extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
1169	extern int locks_delete_block(struct file_lock *);
1170	extern int vfs_test_lock(struct file *, struct file_lock *);
1171	extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
1172	extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
1173	extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
1174	extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
1175	extern void lease_get_mtime(struct inode *, struct timespec64 *time);
1176	extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
1177	extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
1178	extern int lease_modify(struct file_lock *, int, struct list_head *);
1179
1180	struct notifier_block;
1181	extern int lease_register_notifier(struct notifier_block *);
1182	extern void lease_unregister_notifier(struct notifier_block *);
1183
1184	struct files_struct;
1185	extern void show_fd_locks(struct seq_file *f,
1186	struct file *filp, struct files_struct *files);
1187	extern bool locks_owner_has_blockers(struct file_lock_context *flctx,
1188	fl_owner_t owner);
1189	#else /* !CONFIG_FILE_LOCKING */
1190	static inline int fcntl_getlk(struct file *file, unsigned int cmd,
1191	struct flock __user *user)
1192	{
1193	return -EINVAL;
1194	}
1195
1196	static inline int fcntl_setlk(unsigned int fd, struct file *file,
1197	unsigned int cmd, struct flock __user *user)
1198	{
1199	return -EACCES;
1200	}
1201
1202	#if BITS_PER_LONG == 32
1203	static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
1204	struct flock64 *user)
1205	{
1206	return -EINVAL;
1207	}
1208
1209	static inline int fcntl_setlk64(unsigned int fd, struct file *file,
1210	unsigned int cmd, struct flock64 *user)
1211	{
1212	return -EACCES;
1213	}
1214	#endif
1215	static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1216	{
1217	return -EINVAL;
1218	}
1219
1220	static inline int fcntl_getlease(struct file *filp)
1221	{
1222	return F_UNLCK;
1223	}
1224
1225	static inline void
1226	locks_free_lock_context(struct inode *inode)
1227	{
1228	}
1229
1230	static inline void locks_init_lock(struct file_lock *fl)
1231	{
1232	return;
1233	}
1234
1235	static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
1236	{
1237	return;
1238	}
1239
1240	static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1241	{
1242	return;
1243	}
1244
1245	static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
1246	{
1247	return;
1248	}
1249
1250	static inline void locks_remove_file(struct file *filp)
1251	{
1252	return;
1253	}
1254
1255	static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
1256	{
1257	return;
1258	}
1259
1260	static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
1261	struct file_lock *conflock)
1262	{
1263	return -ENOLCK;
1264	}
1265
1266	static inline int locks_delete_block(struct file_lock *waiter)
1267	{
1268	return -ENOENT;
1269	}
1270
1271	static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
1272	{
1273	return 0;
1274	}
1275
1276	static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
1277	struct file_lock *fl, struct file_lock *conf)
1278	{
1279	return -ENOLCK;
1280	}
1281
1282	static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
1283	{
1284	return 0;
1285	}
1286
1287	static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
1288	{
1289	return -ENOLCK;
1290	}
1291
1292	static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1293	{
1294	return 0;
1295	}
1296
1297	static inline void lease_get_mtime(struct inode *inode,
1298	struct timespec64 *time)
1299	{
1300	return;
1301	}
1302
1303	static inline int generic_setlease(struct file *filp, long arg,
1304	struct file_lock **flp, void **priv)
1305	{
1306	return -EINVAL;
1307	}
1308
1309	static inline int vfs_setlease(struct file *filp, long arg,
1310	struct file_lock **lease, void **priv)
1311	{
1312	return -EINVAL;
1313	}
1314
1315	static inline int lease_modify(struct file_lock *fl, int arg,
1316	struct list_head *dispose)
1317	{
1318	return -EINVAL;
1319	}
1320
1321	struct files_struct;
1322	static inline void show_fd_locks(struct seq_file *f,
1323	struct file *filp, struct files_struct *files) {}
1324	static inline bool locks_owner_has_blockers(struct file_lock_context *flctx,
1325	fl_owner_t owner)
1326	{
1327	return false;
1328	}
1329	#endif /* !CONFIG_FILE_LOCKING */
1330
1331	static inline struct inode *file_inode(const struct file *f)
1332	{
1333	return f->f_inode;
1334	}
1335
1336	static inline struct dentry *file_dentry(const struct file *file)
1337	{
1338	return d_real(file->f_path.dentry, file_inode(file));
1339	}
1340
1341	static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
1342	{
1343	return locks_lock_inode_wait(locks_inode(filp), fl);
1344	}
1345
1346	struct fasync_struct {
1347	rwlock_t fa_lock;
1348	int magic;
1349	int fa_fd;
1350	struct fasync_struct *fa_next; /* singly linked list */
1351	struct file *fa_file;
1352	struct rcu_head fa_rcu;
1353	};
1354
1355	#define FASYNC_MAGIC 0x4601
1356
1357	/* SMP safe fasync helpers: */
1358	extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
1359	extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
1360	extern int fasync_remove_entry(struct file *, struct fasync_struct **);
1361	extern struct fasync_struct *fasync_alloc(void);
1362	extern void fasync_free(struct fasync_struct *);
1363
1364	/* can be called from interrupts */
1365	extern void kill_fasync(struct fasync_struct **, int, int);
1366
1367	extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
1368	extern int f_setown(struct file *filp, unsigned long arg, int force);
1369	extern void f_delown(struct file *filp);
1370	extern pid_t f_getown(struct file *filp);
1371	extern int send_sigurg(struct fown_struct *fown);
1372
1373	/*
1374	* sb->s_flags. Note that these mirror the equivalent MS_* flags where
1375	* represented in both.
1376	*/
1377	#define SB_RDONLY 1 /* Mount read-only */
1378	#define SB_NOSUID 2 /* Ignore suid and sgid bits */
1379	#define SB_NODEV 4 /* Disallow access to device special files */
1380	#define SB_NOEXEC 8 /* Disallow program execution */
1381	#define SB_SYNCHRONOUS 16 /* Writes are synced at once */
1382	#define SB_MANDLOCK 64 /* Allow mandatory locks on an FS */
1383	#define SB_DIRSYNC 128 /* Directory modifications are synchronous */
1384	#define SB_NOATIME 1024 /* Do not update access times. */
1385	#define SB_NODIRATIME 2048 /* Do not update directory access times */
1386	#define SB_SILENT 32768
1387	#define SB_POSIXACL (1<<16) /* VFS does not apply the umask */
1388	#define SB_INLINECRYPT (1<<17) /* Use blk-crypto for encrypted files */
1389	#define SB_KERNMOUNT (1<<22) /* this is a kern_mount call */
1390	#define SB_I_VERSION (1<<23) /* Update inode I_version field */
1391	#define SB_LAZYTIME (1<<25) /* Update the on-disk [acm]times lazily */
1392
1393	/* These sb flags are internal to the kernel */
1394	#define SB_SUBMOUNT (1<<26)
1395	#define SB_FORCE (1<<27)
1396	#define SB_NOSEC (1<<28)
1397	#define SB_BORN (1<<29)
1398	#define SB_ACTIVE (1<<30)
1399	#define SB_NOUSER (1<<31)
1400
1401	/* These flags relate to encoding and casefolding */
1402	#define SB_ENC_STRICT_MODE_FL (1 << 0)
1403
1404	#define sb_has_strict_encoding(sb) \
1405	(sb->s_encoding_flags & SB_ENC_STRICT_MODE_FL)
1406
1407	/*
1408	* Umount options
1409	*/
1410
1411	#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
1412	#define MNT_DETACH 0x00000002 /* Just detach from the tree */
1413	#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
1414	#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
1415	#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */
1416
1417	/* sb->s_iflags */
1418	#define SB_I_CGROUPWB 0x00000001 /* cgroup-aware writeback enabled */
1419	#define SB_I_NOEXEC 0x00000002 /* Ignore executables on this fs */
1420	#define SB_I_NODEV 0x00000004 /* Ignore devices on this fs */
1421	#define SB_I_STABLE_WRITES 0x00000008 /* don't modify blks until WB is done */
1422
1423	/* sb->s_iflags to limit user namespace mounts */
1424	#define SB_I_USERNS_VISIBLE 0x00000010 /* fstype already mounted */
1425	#define SB_I_IMA_UNVERIFIABLE_SIGNATURE 0x00000020
1426	#define SB_I_UNTRUSTED_MOUNTER 0x00000040
1427
1428	#define SB_I_SKIP_SYNC 0x00000100 /* Skip superblock at global sync */
1429	#define SB_I_PERSB_BDI 0x00000200 /* has a per-sb bdi */
1430	#define SB_I_TS_EXPIRY_WARNED 0x00000400 /* warned about timestamp range expiry */
1431	#define SB_I_RETIRED 0x00000800 /* superblock shouldn't be reused */
1432
1433	/* Possible states of 'frozen' field */
1434	enum {
1435	SB_UNFROZEN = 0, /* FS is unfrozen */
1436	SB_FREEZE_WRITE = 1, /* Writes, dir ops, ioctls frozen */
1437	SB_FREEZE_PAGEFAULT = 2, /* Page faults stopped as well */
1438	SB_FREEZE_FS = 3, /* For internal FS use (e.g. to stop
1439	* internal threads if needed) */
1440	SB_FREEZE_COMPLETE = 4, /* ->freeze_fs finished successfully */
1441	};
1442
1443	#define SB_FREEZE_LEVELS (SB_FREEZE_COMPLETE - 1)
1444
1445	struct sb_writers {
1446	int frozen; /* Is sb frozen? */
1447	wait_queue_head_t wait_unfrozen; /* wait for thaw */
1448	struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
1449	};
1450
1451	struct super_block {
1452	struct list_head s_list; /* Keep this first */
1453	dev_t s_dev; /* search index; _not_ kdev_t */
1454	unsigned char s_blocksize_bits;
1455	unsigned long s_blocksize;
1456	loff_t s_maxbytes; /* Max file size */
1457	struct file_system_type *s_type;
1458	const struct super_operations *s_op;
1459	const struct dquot_operations *dq_op;
1460	const struct quotactl_ops *s_qcop;
1461	const struct export_operations *s_export_op;
1462	unsigned long s_flags;
1463	unsigned long s_iflags; /* internal SB_I_* flags */
1464	unsigned long s_magic;
1465	struct dentry *s_root;
1466	struct rw_semaphore s_umount;
1467	int s_count;
1468	atomic_t s_active;
1469	#ifdef CONFIG_SECURITY
1470	void *s_security;
1471	#endif
1472	const struct xattr_handler **s_xattr;
1473	#ifdef CONFIG_FS_ENCRYPTION
1474	const struct fscrypt_operations *s_cop;
1475	struct key *s_master_keys; /* master crypto keys in use */
1476	#endif
1477	#ifdef CONFIG_FS_VERITY
1478	const struct fsverity_operations *s_vop;
1479	#endif
1480	#if IS_ENABLED(CONFIG_UNICODE)
1481	struct unicode_map *s_encoding;
1482	__u16 s_encoding_flags;
1483	#endif
1484	struct hlist_bl_head s_roots; /* alternate root dentries for NFS */
1485	struct list_head s_mounts; /* list of mounts; _not_ for fs use */
1486	struct block_device *s_bdev;
1487	struct backing_dev_info *s_bdi;
1488	struct mtd_info *s_mtd;
1489	struct hlist_node s_instances;
1490	unsigned int s_quota_types; /* Bitmask of supported quota types */
1491	struct quota_info s_dquot; /* Diskquota specific options */
1492
1493	struct sb_writers s_writers;
1494
1495	/*
1496	* Keep s_fs_info, s_time_gran, s_fsnotify_mask, and
1497	* s_fsnotify_marks together for cache efficiency. They are frequently
1498	* accessed and rarely modified.
1499	*/
1500	void *s_fs_info; /* Filesystem private info */
1501
1502	/* Granularity of c/m/atime in ns (cannot be worse than a second) */
1503	u32 s_time_gran;
1504	/* Time limits for c/m/atime in seconds */
1505	time64_t s_time_min;
1506	time64_t s_time_max;
1507	#ifdef CONFIG_FSNOTIFY
1508	__u32 s_fsnotify_mask;
1509	struct fsnotify_mark_connector __rcu *s_fsnotify_marks;
1510	#endif
1511
1512	char s_id[32]; /* Informational name */
1513	uuid_t s_uuid; /* UUID */
1514
1515	unsigned int s_max_links;
1516	fmode_t s_mode;
1517
1518	/*
1519	* The next field is for VFS *only*. No filesystems have any business
1520	* even looking at it. You had been warned.
1521	*/
1522	struct mutex s_vfs_rename_mutex; /* Kludge */
1523
1524	/*
1525	* Filesystem subtype. If non-empty the filesystem type field
1526	* in /proc/mounts will be "type.subtype"
1527	*/
1528	const char *s_subtype;
1529
1530	const struct dentry_operations *s_d_op; /* default d_op for dentries */
1531
1532	struct shrinker s_shrink; /* per-sb shrinker handle */
1533
1534	/* Number of inodes with nlink == 0 but still referenced */
1535	atomic_long_t s_remove_count;
1536
1537	/*
1538	* Number of inode/mount/sb objects that are being watched, note that
1539	* inodes objects are currently double-accounted.
1540	*/
1541	atomic_long_t s_fsnotify_connectors;
1542
1543	/* Being remounted read-only */
1544	int s_readonly_remount;
1545
1546	/* per-sb errseq_t for reporting writeback errors via syncfs */
1547	errseq_t s_wb_err;
1548
1549	/* AIO completions deferred from interrupt context */
1550	struct workqueue_struct *s_dio_done_wq;
1551	struct hlist_head s_pins;
1552
1553	/*
1554	* Owning user namespace and default context in which to
1555	* interpret filesystem uids, gids, quotas, device nodes,
1556	* xattrs and security labels.
1557	*/
1558	struct user_namespace *s_user_ns;
1559
1560	/*
1561	* The list_lru structure is essentially just a pointer to a table
1562	* of per-node lru lists, each of which has its own spinlock.
1563	* There is no need to put them into separate cachelines.
1564	*/
1565	struct list_lru s_dentry_lru;
1566	struct list_lru s_inode_lru;
1567	struct rcu_head rcu;
1568	struct work_struct destroy_work;
1569
1570	struct mutex s_sync_lock; /* sync serialisation lock */
1571
1572	/*
1573	* Indicates how deep in a filesystem stack this SB is
1574	*/
1575	int s_stack_depth;
1576
1577	/* s_inode_list_lock protects s_inodes */
1578	spinlock_t s_inode_list_lock ____cacheline_aligned_in_smp;
1579	struct list_head s_inodes; /* all inodes */
1580
1581	spinlock_t s_inode_wblist_lock;
1582	struct list_head s_inodes_wb; /* writeback inodes */
1583	} __randomize_layout;
1584
1585	static inline struct user_namespace *i_user_ns(const struct inode *inode)
1586	{
1587	return inode->i_sb->s_user_ns;
1588	}
1589
1590	/* Helper functions so that in most cases filesystems will
1591	* not need to deal directly with kuid_t and kgid_t and can
1592	* instead deal with the raw numeric values that are stored
1593	* in the filesystem.
1594	*/
1595	static inline uid_t i_uid_read(const struct inode *inode)
1596	{
1597	return from_kuid(i_user_ns(inode), inode->i_uid);
1598	}
1599
1600	static inline gid_t i_gid_read(const struct inode *inode)
1601	{
1602	return from_kgid(i_user_ns(inode), inode->i_gid);
1603	}
1604
1605	static inline void i_uid_write(struct inode *inode, uid_t uid)
1606	{
1607	inode->i_uid = make_kuid(i_user_ns(inode), uid);
1608	}
1609
1610	static inline void i_gid_write(struct inode *inode, gid_t gid)
1611	{
1612	inode->i_gid = make_kgid(i_user_ns(inode), gid);
1613	}
1614
1615	/**
1616	* i_uid_into_mnt - map an inode's i_uid down into a mnt_userns
1617	* @mnt_userns: user namespace of the mount the inode was found from
1618	* @inode: inode to map
1619	*
1620	* Note, this will eventually be removed completely in favor of the type-safe
1621	* i_uid_into_vfsuid().
1622	*
1623	* Return: the inode's i_uid mapped down according to @mnt_userns.
1624	* If the inode's i_uid has no mapping INVALID_UID is returned.
1625	*/
1626	static inline kuid_t i_uid_into_mnt(struct user_namespace *mnt_userns,
1627	const struct inode *inode)
1628	{
1629	return AS_KUIDT(make_vfsuid(mnt_userns, i_user_ns(inode), inode->i_uid));
1630	}
1631
1632	/**
1633	* i_uid_into_vfsuid - map an inode's i_uid down into a mnt_userns
1634	* @mnt_userns: user namespace of the mount the inode was found from
1635	* @inode: inode to map
1636	*
1637	* Return: whe inode's i_uid mapped down according to @mnt_userns.
1638	* If the inode's i_uid has no mapping INVALID_VFSUID is returned.
1639	*/
1640	static inline vfsuid_t i_uid_into_vfsuid(struct user_namespace *mnt_userns,
1641	const struct inode *inode)
1642	{
1643	return make_vfsuid(mnt_userns, i_user_ns(inode), inode->i_uid);
1644	}
1645
1646	/**
1647	* i_uid_needs_update - check whether inode's i_uid needs to be updated
1648	* @mnt_userns: user namespace of the mount the inode was found from
1649	* @attr: the new attributes of @inode
1650	* @inode: the inode to update
1651	*
1652	* Check whether the $inode's i_uid field needs to be updated taking idmapped
1653	* mounts into account if the filesystem supports it.
1654	*
1655	* Return: true if @inode's i_uid field needs to be updated, false if not.
1656	*/
1657	static inline bool i_uid_needs_update(struct user_namespace *mnt_userns,
1658	const struct iattr *attr,
1659	const struct inode *inode)
1660	{
1661	return ((attr->ia_valid & ATTR_UID) &&
1662	!vfsuid_eq(attr->ia_vfsuid,
1663	i_uid_into_vfsuid(mnt_userns, inode)));
1664	}
1665
1666	/**
1667	* i_uid_update - update @inode's i_uid field
1668	* @mnt_userns: user namespace of the mount the inode was found from
1669	* @attr: the new attributes of @inode
1670	* @inode: the inode to update
1671	*
1672	* Safely update @inode's i_uid field translating the vfsuid of any idmapped
1673	* mount into the filesystem kuid.
1674	*/
1675	static inline void i_uid_update(struct user_namespace *mnt_userns,
1676	const struct iattr *attr,
1677	struct inode *inode)
1678	{
1679	if (attr->ia_valid & ATTR_UID)
1680	inode->i_uid = from_vfsuid(mnt_userns, i_user_ns(inode),
1681	attr->ia_vfsuid);
1682	}
1683
1684	/**
1685	* i_gid_into_mnt - map an inode's i_gid down into a mnt_userns
1686	* @mnt_userns: user namespace of the mount the inode was found from
1687	* @inode: inode to map
1688	*
1689	* Note, this will eventually be removed completely in favor of the type-safe
1690	* i_gid_into_vfsgid().
1691	*
1692	* Return: the inode's i_gid mapped down according to @mnt_userns.
1693	* If the inode's i_gid has no mapping INVALID_GID is returned.
1694	*/
1695	static inline kgid_t i_gid_into_mnt(struct user_namespace *mnt_userns,
1696	const struct inode *inode)
1697	{
1698	return AS_KGIDT(make_vfsgid(mnt_userns, i_user_ns(inode), inode->i_gid));
1699	}
1700
1701	/**
1702	* i_gid_into_vfsgid - map an inode's i_gid down into a mnt_userns
1703	* @mnt_userns: user namespace of the mount the inode was found from
1704	* @inode: inode to map
1705	*
1706	* Return: the inode's i_gid mapped down according to @mnt_userns.
1707	* If the inode's i_gid has no mapping INVALID_VFSGID is returned.
1708	*/
1709	static inline vfsgid_t i_gid_into_vfsgid(struct user_namespace *mnt_userns,
1710	const struct inode *inode)
1711	{
1712	return make_vfsgid(mnt_userns, i_user_ns(inode), inode->i_gid);
1713	}
1714
1715	/**
1716	* i_gid_needs_update - check whether inode's i_gid needs to be updated
1717	* @mnt_userns: user namespace of the mount the inode was found from
1718	* @attr: the new attributes of @inode
1719	* @inode: the inode to update
1720	*
1721	* Check whether the $inode's i_gid field needs to be updated taking idmapped
1722	* mounts into account if the filesystem supports it.
1723	*
1724	* Return: true if @inode's i_gid field needs to be updated, false if not.
1725	*/
1726	static inline bool i_gid_needs_update(struct user_namespace *mnt_userns,
1727	const struct iattr *attr,
1728	const struct inode *inode)
1729	{
1730	return ((attr->ia_valid & ATTR_GID) &&
1731	!vfsgid_eq(attr->ia_vfsgid,
1732	i_gid_into_vfsgid(mnt_userns, inode)));
1733	}
1734
1735	/**
1736	* i_gid_update - update @inode's i_gid field
1737	* @mnt_userns: user namespace of the mount the inode was found from
1738	* @attr: the new attributes of @inode
1739	* @inode: the inode to update
1740	*
1741	* Safely update @inode's i_gid field translating the vfsgid of any idmapped
1742	* mount into the filesystem kgid.
1743	*/
1744	static inline void i_gid_update(struct user_namespace *mnt_userns,
1745	const struct iattr *attr,
1746	struct inode *inode)
1747	{
1748	if (attr->ia_valid & ATTR_GID)
1749	inode->i_gid = from_vfsgid(mnt_userns, i_user_ns(inode),
1750	attr->ia_vfsgid);
1751	}
1752
1753	/**
1754	* inode_fsuid_set - initialize inode's i_uid field with callers fsuid
1755	* @inode: inode to initialize
1756	* @mnt_userns: user namespace of the mount the inode was found from
1757	*
1758	* Initialize the i_uid field of @inode. If the inode was found/created via
1759	* an idmapped mount map the caller's fsuid according to @mnt_users.
1760	*/
1761	static inline void inode_fsuid_set(struct inode *inode,
1762	struct user_namespace *mnt_userns)
1763	{
1764	inode->i_uid = mapped_fsuid(mnt_userns, i_user_ns(inode));
1765	}
1766
1767	/**
1768	* inode_fsgid_set - initialize inode's i_gid field with callers fsgid
1769	* @inode: inode to initialize
1770	* @mnt_userns: user namespace of the mount the inode was found from
1771	*
1772	* Initialize the i_gid field of @inode. If the inode was found/created via
1773	* an idmapped mount map the caller's fsgid according to @mnt_users.
1774	*/
1775	static inline void inode_fsgid_set(struct inode *inode,
1776	struct user_namespace *mnt_userns)
1777	{
1778	inode->i_gid = mapped_fsgid(mnt_userns, i_user_ns(inode));
1779	}
1780
1781	/**
1782	* fsuidgid_has_mapping() - check whether caller's fsuid/fsgid is mapped
1783	* @sb: the superblock we want a mapping in
1784	* @mnt_userns: user namespace of the relevant mount
1785	*
1786	* Check whether the caller's fsuid and fsgid have a valid mapping in the
1787	* s_user_ns of the superblock @sb. If the caller is on an idmapped mount map
1788	* the caller's fsuid and fsgid according to the @mnt_userns first.
1789	*
1790	* Return: true if fsuid and fsgid is mapped, false if not.
1791	*/
1792	static inline bool fsuidgid_has_mapping(struct super_block *sb,
1793	struct user_namespace *mnt_userns)
1794	{
1795	struct user_namespace *fs_userns = sb->s_user_ns;
1796	kuid_t kuid;
1797	kgid_t kgid;
1798
1799	kuid = mapped_fsuid(mnt_userns, fs_userns);
1800	if (!uid_valid(kuid))
1801	return false;
1802	kgid = mapped_fsgid(mnt_userns, fs_userns);
1803	if (!gid_valid(kgid))
1804	return false;
1805	return kuid_has_mapping(fs_userns, kuid) &&
1806	kgid_has_mapping(fs_userns, kgid);
1807	}
1808
1809	extern struct timespec64 current_time(struct inode *inode);
1810
1811	/*
1812	* Snapshotting support.
1813	*/
1814
1815	/*
1816	* These are internal functions, please use sb_start_{write,pagefault,intwrite}
1817	* instead.
1818	*/
1819	static inline void __sb_end_write(struct super_block *sb, int level)
1820	{
1821	percpu_up_read(sb->s_writers.rw_sem + level-1);
1822	}
1823
1824	static inline void __sb_start_write(struct super_block *sb, int level)
1825	{
1826	percpu_down_read(sb->s_writers.rw_sem + level - 1);
1827	}
1828
1829	static inline bool __sb_start_write_trylock(struct super_block *sb, int level)
1830	{
1831	return percpu_down_read_trylock(sb->s_writers.rw_sem + level - 1);
1832	}
1833
1834	#define __sb_writers_acquired(sb, lev) \
1835	percpu_rwsem_acquire(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1836	#define __sb_writers_release(sb, lev) \
1837	percpu_rwsem_release(&(sb)->s_writers.rw_sem[(lev)-1], 1, _THIS_IP_)
1838
1839	static inline bool sb_write_started(const struct super_block *sb)
1840	{
1841	return lockdep_is_held_type(sb->s_writers.rw_sem + SB_FREEZE_WRITE - 1, 1);
1842	}
1843
1844	/**
1845	* sb_end_write - drop write access to a superblock
1846	* @sb: the super we wrote to
1847	*
1848	* Decrement number of writers to the filesystem. Wake up possible waiters
1849	* wanting to freeze the filesystem.
1850	*/
1851	static inline void sb_end_write(struct super_block *sb)
1852	{
1853	__sb_end_write(sb, SB_FREEZE_WRITE);
1854	}
1855
1856	/**
1857	* sb_end_pagefault - drop write access to a superblock from a page fault
1858	* @sb: the super we wrote to
1859	*
1860	* Decrement number of processes handling write page fault to the filesystem.
1861	* Wake up possible waiters wanting to freeze the filesystem.
1862	*/
1863	static inline void sb_end_pagefault(struct super_block *sb)
1864	{
1865	__sb_end_write(sb, SB_FREEZE_PAGEFAULT);
1866	}
1867
1868	/**
1869	* sb_end_intwrite - drop write access to a superblock for internal fs purposes
1870	* @sb: the super we wrote to
1871	*
1872	* Decrement fs-internal number of writers to the filesystem. Wake up possible
1873	* waiters wanting to freeze the filesystem.
1874	*/
1875	static inline void sb_end_intwrite(struct super_block *sb)
1876	{
1877	__sb_end_write(sb, SB_FREEZE_FS);
1878	}
1879
1880	/**
1881	* sb_start_write - get write access to a superblock
1882	* @sb: the super we write to
1883	*
1884	* When a process wants to write data or metadata to a file system (i.e. dirty
1885	* a page or an inode), it should embed the operation in a sb_start_write() -
1886	* sb_end_write() pair to get exclusion against file system freezing. This
1887	* function increments number of writers preventing freezing. If the file
1888	* system is already frozen, the function waits until the file system is
1889	* thawed.
1890	*
1891	* Since freeze protection behaves as a lock, users have to preserve
1892	* ordering of freeze protection and other filesystem locks. Generally,
1893	* freeze protection should be the outermost lock. In particular, we have:
1894	*
1895	* sb_start_write
1896	* -> i_mutex (write path, truncate, directory ops, ...)
1897	* -> s_umount (freeze_super, thaw_super)
1898	*/
1899	static inline void sb_start_write(struct super_block *sb)
1900	{
1901	__sb_start_write(sb, SB_FREEZE_WRITE);
1902	}
1903
1904	static inline bool sb_start_write_trylock(struct super_block *sb)
1905	{
1906	return __sb_start_write_trylock(sb, SB_FREEZE_WRITE);
1907	}
1908
1909	/**
1910	* sb_start_pagefault - get write access to a superblock from a page fault
1911	* @sb: the super we write to
1912	*
1913	* When a process starts handling write page fault, it should embed the
1914	* operation into sb_start_pagefault() - sb_end_pagefault() pair to get
1915	* exclusion against file system freezing. This is needed since the page fault
1916	* is going to dirty a page. This function increments number of running page
1917	* faults preventing freezing. If the file system is already frozen, the
1918	* function waits until the file system is thawed.
1919	*
1920	* Since page fault freeze protection behaves as a lock, users have to preserve
1921	* ordering of freeze protection and other filesystem locks. It is advised to
1922	* put sb_start_pagefault() close to mmap_lock in lock ordering. Page fault
1923	* handling code implies lock dependency:
1924	*
1925	* mmap_lock
1926	* -> sb_start_pagefault
1927	*/
1928	static inline void sb_start_pagefault(struct super_block *sb)
1929	{
1930	__sb_start_write(sb, SB_FREEZE_PAGEFAULT);
1931	}
1932
1933	/**
1934	* sb_start_intwrite - get write access to a superblock for internal fs purposes
1935	* @sb: the super we write to
1936	*
1937	* This is the third level of protection against filesystem freezing. It is
1938	* free for use by a filesystem. The only requirement is that it must rank
1939	* below sb_start_pagefault.
1940	*
1941	* For example filesystem can call sb_start_intwrite() when starting a
1942	* transaction which somewhat eases handling of freezing for internal sources
1943	* of filesystem changes (internal fs threads, discarding preallocation on file
1944	* close, etc.).
1945	*/
1946	static inline void sb_start_intwrite(struct super_block *sb)
1947	{
1948	__sb_start_write(sb, SB_FREEZE_FS);
1949	}
1950
1951	static inline bool sb_start_intwrite_trylock(struct super_block *sb)
1952	{
1953	return __sb_start_write_trylock(sb, SB_FREEZE_FS);
1954	}
1955
1956	bool inode_owner_or_capable(struct user_namespace *mnt_userns,
1957	const struct inode *inode);
1958
1959	/*
1960	* VFS helper functions..
1961	*/
1962	int vfs_create(struct user_namespace *, struct inode *,
1963	struct dentry *, umode_t, bool);
1964	int vfs_mkdir(struct user_namespace *, struct inode *,
1965	struct dentry *, umode_t);
1966	int vfs_mknod(struct user_namespace *, struct inode *, struct dentry *,
1967	umode_t, dev_t);
1968	int vfs_symlink(struct user_namespace *, struct inode *,
1969	struct dentry *, const char *);
1970	int vfs_link(struct dentry *, struct user_namespace *, struct inode *,
1971	struct dentry *, struct inode **);
1972	int vfs_rmdir(struct user_namespace *, struct inode *, struct dentry *);
1973	int vfs_unlink(struct user_namespace *, struct inode *, struct dentry *,
1974	struct inode **);
1975
1976	/**
1977	* struct renamedata - contains all information required for renaming
1978	* @old_mnt_userns: old user namespace of the mount the inode was found from
1979	* @old_dir: parent of source
1980	* @old_dentry: source
1981	* @new_mnt_userns: new user namespace of the mount the inode was found from
1982	* @new_dir: parent of destination
1983	* @new_dentry: destination
1984	* @delegated_inode: returns an inode needing a delegation break
1985	* @flags: rename flags
1986	*/
1987	struct renamedata {
1988	struct user_namespace *old_mnt_userns;
1989	struct inode *old_dir;
1990	struct dentry *old_dentry;
1991	struct user_namespace *new_mnt_userns;
1992	struct inode *new_dir;
1993	struct dentry *new_dentry;
1994	struct inode **delegated_inode;
1995	unsigned int flags;
1996	} __randomize_layout;
1997
1998	int vfs_rename(struct renamedata *);
1999
2000	static inline int vfs_whiteout(struct user_namespace *mnt_userns,
2001	struct inode *dir, struct dentry *dentry)
2002	{
2003	return vfs_mknod(mnt_userns, dir, dentry, S_IFCHR | WHITEOUT_MODE,
2004	WHITEOUT_DEV);
2005	}
2006
2007	struct dentry *vfs_tmpfile(struct user_namespace *mnt_userns,
2008	struct dentry *dentry, umode_t mode, int open_flag);
2009
2010	int vfs_mkobj(struct dentry *, umode_t,
2011	int (*f)(struct dentry *, umode_t, void *),
2012	void *);
2013
2014	int vfs_fchown(struct file *file, uid_t user, gid_t group);
2015	int vfs_fchmod(struct file *file, umode_t mode);
2016	int vfs_utimes(const struct path *path, struct timespec64 *times);
2017
2018	extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
2019
2020	#ifdef CONFIG_COMPAT
2021	extern long compat_ptr_ioctl(struct file *file, unsigned int cmd,
2022	unsigned long arg);
2023	#else
2024	#define compat_ptr_ioctl NULL
2025	#endif
2026
2027	/*
2028	* VFS file helper functions.
2029	*/
2030	void inode_init_owner(struct user_namespace *mnt_userns, struct inode *inode,
2031	const struct inode *dir, umode_t mode);
2032	extern bool may_open_dev(const struct path *path);
2033	umode_t mode_strip_sgid(struct user_namespace *mnt_userns,
2034	const struct inode *dir, umode_t mode);
2035
2036	/*
2037	* This is the "filldir" function type, used by readdir() to let
2038	* the kernel specify what kind of dirent layout it wants to have.
2039	* This allows the kernel to read directories into kernel space or
2040	* to have different dirent layouts depending on the binary type.
2041	*/
2042	struct dir_context;
2043	typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
2044	unsigned);
2045
2046	struct dir_context {
2047	filldir_t actor;
2048	loff_t pos;
2049	};
2050
2051	/*
2052	* These flags let !MMU mmap() govern direct device mapping vs immediate
2053	* copying more easily for MAP_PRIVATE, especially for ROM filesystems.
2054	*
2055	* NOMMU_MAP_COPY: Copy can be mapped (MAP_PRIVATE)
2056	* NOMMU_MAP_DIRECT: Can be mapped directly (MAP_SHARED)
2057	* NOMMU_MAP_READ: Can be mapped for reading
2058	* NOMMU_MAP_WRITE: Can be mapped for writing
2059	* NOMMU_MAP_EXEC: Can be mapped for execution
2060	*/
2061	#define NOMMU_MAP_COPY 0x00000001
2062	#define NOMMU_MAP_DIRECT 0x00000008
2063	#define NOMMU_MAP_READ VM_MAYREAD
2064	#define NOMMU_MAP_WRITE VM_MAYWRITE
2065	#define NOMMU_MAP_EXEC VM_MAYEXEC
2066
2067	#define NOMMU_VMFLAGS \
2068	(NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
2069
2070	/*
2071	* These flags control the behavior of the remap_file_range function pointer.
2072	* If it is called with len == 0 that means "remap to end of source file".
2073	* See Documentation/filesystems/vfs.rst for more details about this call.
2074	*
2075	* REMAP_FILE_DEDUP: only remap if contents identical (i.e. deduplicate)
2076	* REMAP_FILE_CAN_SHORTEN: caller can handle a shortened request
2077	*/
2078	#define REMAP_FILE_DEDUP (1 << 0)
2079	#define REMAP_FILE_CAN_SHORTEN (1 << 1)
2080
2081	/*
2082	* These flags signal that the caller is ok with altering various aspects of
2083	* the behavior of the remap operation. The changes must be made by the
2084	* implementation; the vfs remap helper functions can take advantage of them.
2085	* Flags in this category exist to preserve the quirky behavior of the hoisted
2086	* btrfs clone/dedupe ioctls.
2087	*/
2088	#define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN)
2089
2090	struct iov_iter;
2091	struct io_uring_cmd;
2092
2093	struct file_operations {
2094	struct module *owner;
2095	loff_t (*llseek) (struct file *, loff_t, int);
2096	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
2097	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
2098	ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
2099	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
2100	int (*iopoll)(struct kiocb *kiocb, struct io_comp_batch *,
2101	unsigned int flags);
2102	int (*iterate) (struct file *, struct dir_context *);
2103	int (*iterate_shared) (struct file *, struct dir_context *);
2104	__poll_t (*poll) (struct file *, struct poll_table_struct *);
2105	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
2106	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
2107	int (*mmap) (struct file *, struct vm_area_struct *);
2108	unsigned long mmap_supported_flags;
2109	int (*open) (struct inode *, struct file *);
2110	int (*flush) (struct file *, fl_owner_t id);
2111	int (*release) (struct inode *, struct file *);
2112	int (*fsync) (struct file *, loff_t, loff_t, int datasync);
2113	int (*fasync) (int, struct file *, int);
2114	int (*lock) (struct file *, int, struct file_lock *);
2115	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
2116	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
2117	int (*check_flags)(int);
2118	int (*flock) (struct file *, int, struct file_lock *);
2119	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
2120	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
2121	int (*setlease)(struct file *, long, struct file_lock **, void **);
2122	long (*fallocate)(struct file *file, int mode, loff_t offset,
2123	loff_t len);
2124	void (*show_fdinfo)(struct seq_file *m, struct file *f);
2125	#ifndef CONFIG_MMU
2126	unsigned (*mmap_capabilities)(struct file *);
2127	#endif
2128	ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
2129	loff_t, size_t, unsigned int);
2130	loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
2131	struct file *file_out, loff_t pos_out,
2132	loff_t len, unsigned int remap_flags);
2133	int (*fadvise)(struct file *, loff_t, loff_t, int);
2134	int (*uring_cmd)(struct io_uring_cmd *ioucmd, unsigned int issue_flags);
2135	} __randomize_layout;
2136
2137	struct inode_operations {
2138	struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
2139	const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
2140	int (*permission) (struct user_namespace *, struct inode *, int);
2141	struct posix_acl * (*get_acl)(struct inode *, int, bool);
2142
2143	int (*readlink) (struct dentry *, char __user *,int);
2144
2145	int (*create) (struct user_namespace *, struct inode *,struct dentry *,
2146	umode_t, bool);
2147	int (*link) (struct dentry *,struct inode *,struct dentry *);
2148	int (*unlink) (struct inode *,struct dentry *);
2149	int (*symlink) (struct user_namespace *, struct inode *,struct dentry *,
2150	const char *);
2151	int (*mkdir) (struct user_namespace *, struct inode *,struct dentry *,
2152	umode_t);
2153	int (*rmdir) (struct inode *,struct dentry *);
2154	int (*mknod) (struct user_namespace *, struct inode *,struct dentry *,
2155	umode_t,dev_t);
2156	int (*rename) (struct user_namespace *, struct inode *, struct dentry *,
2157	struct inode *, struct dentry *, unsigned int);
2158	int (*setattr) (struct user_namespace *, struct dentry *,
2159	struct iattr *);
2160	int (*getattr) (struct user_namespace *, const struct path *,
2161	struct kstat *, u32, unsigned int);
2162	ssize_t (*listxattr) (struct dentry *, char *, size_t);
2163	int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
2164	u64 len);
2165	int (*update_time)(struct inode *, struct timespec64 *, int);
2166	int (*atomic_open)(struct inode *, struct dentry *,
2167	struct file *, unsigned open_flag,
2168	umode_t create_mode);
2169	int (*tmpfile) (struct user_namespace *, struct inode *,
2170	struct dentry *, umode_t);
2171	int (*set_acl)(struct user_namespace *, struct inode *,
2172	struct posix_acl *, int);
2173	int (*fileattr_set)(struct user_namespace *mnt_userns,
2174	struct dentry *dentry, struct fileattr *fa);
2175	int (*fileattr_get)(struct dentry *dentry, struct fileattr *fa);
2176	} ____cacheline_aligned;
2177
2178	static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
2179	struct iov_iter *iter)
2180	{
2181	return file->f_op->read_iter(kio, iter);
2182	}
2183
2184	static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio,
2185	struct iov_iter *iter)
2186	{
2187	return file->f_op->write_iter(kio, iter);
2188	}
2189
2190	static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
2191	{
2192	return file->f_op->mmap(file, vma);
2193	}
2194
2195	extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
2196	extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
2197	extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
2198	loff_t, size_t, unsigned int);
2199	extern ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in,
2200	struct file *file_out, loff_t pos_out,
2201	size_t len, unsigned int flags);
2202	int __generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
2203	struct file *file_out, loff_t pos_out,
2204	loff_t *len, unsigned int remap_flags,
2205	const struct iomap_ops *dax_read_ops);
2206	int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
2207	struct file *file_out, loff_t pos_out,
2208	loff_t *count, unsigned int remap_flags);
2209	extern loff_t do_clone_file_range(struct file *file_in, loff_t pos_in,
2210	struct file *file_out, loff_t pos_out,
2211	loff_t len, unsigned int remap_flags);
2212	extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
2213	struct file *file_out, loff_t pos_out,
2214	loff_t len, unsigned int remap_flags);
2215	extern int vfs_dedupe_file_range(struct file *file,
2216	struct file_dedupe_range *same);
2217	extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
2218	struct file *dst_file, loff_t dst_pos,
2219	loff_t len, unsigned int remap_flags);
2220
2221
2222	struct super_operations {
2223	struct inode *(*alloc_inode)(struct super_block *sb);
2224	void (*destroy_inode)(struct inode *);
2225	void (*free_inode)(struct inode *);
2226
2227	void (*dirty_inode) (struct inode *, int flags);
2228	int (*write_inode) (struct inode *, struct writeback_control *wbc);
2229	int (*drop_inode) (struct inode *);
2230	void (*evict_inode) (struct inode *);
2231	void (*put_super) (struct super_block *);
2232	int (*sync_fs)(struct super_block *sb, int wait);
2233	int (*freeze_super) (struct super_block *);
2234	int (*freeze_fs) (struct super_block *);
2235	int (*thaw_super) (struct super_block *);
2236	int (*unfreeze_fs) (struct super_block *);
2237	int (*statfs) (struct dentry *, struct kstatfs *);
2238	int (*remount_fs) (struct super_block *, int *, char *);
2239	void (*umount_begin) (struct super_block *);
2240
2241	int (*show_options)(struct seq_file *, struct dentry *);
2242	int (*show_devname)(struct seq_file *, struct dentry *);
2243	int (*show_path)(struct seq_file *, struct dentry *);
2244	int (*show_stats)(struct seq_file *, struct dentry *);
2245	#ifdef CONFIG_QUOTA
2246	ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
2247	ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
2248	struct dquot **(*get_dquots)(struct inode *);
2249	#endif
2250	long (*nr_cached_objects)(struct super_block *,
2251	struct shrink_control *);
2252	long (*free_cached_objects)(struct super_block *,
2253	struct shrink_control *);
2254	};
2255
2256	/*
2257	* Inode flags - they have no relation to superblock flags now
2258	*/
2259	#define S_SYNC (1 << 0) /* Writes are synced at once */
2260	#define S_NOATIME (1 << 1) /* Do not update access times */
2261	#define S_APPEND (1 << 2) /* Append-only file */
2262	#define S_IMMUTABLE (1 << 3) /* Immutable file */
2263	#define S_DEAD (1 << 4) /* removed, but still open directory */
2264	#define S_NOQUOTA (1 << 5) /* Inode is not counted to quota */
2265	#define S_DIRSYNC (1 << 6) /* Directory modifications are synchronous */
2266	#define S_NOCMTIME (1 << 7) /* Do not update file c/mtime */
2267	#define S_SWAPFILE (1 << 8) /* Do not truncate: swapon got its bmaps */
2268	#define S_PRIVATE (1 << 9) /* Inode is fs-internal */
2269	#define S_IMA (1 << 10) /* Inode has an associated IMA struct */
2270	#define S_AUTOMOUNT (1 << 11) /* Automount/referral quasi-directory */
2271	#define S_NOSEC (1 << 12) /* no suid or xattr security attributes */
2272	#ifdef CONFIG_FS_DAX
2273	#define S_DAX (1 << 13) /* Direct Access, avoiding the page cache */
2274	#else
2275	#define S_DAX 0 /* Make all the DAX code disappear */
2276	#endif
2277	#define S_ENCRYPTED (1 << 14) /* Encrypted file (using fs/crypto/) */
2278	#define S_CASEFOLD (1 << 15) /* Casefolded file */
2279	#define S_VERITY (1 << 16) /* Verity file (using fs/verity/) */
2280	#define S_KERNEL_FILE (1 << 17) /* File is in use by the kernel (eg. fs/cachefiles) */
2281
2282	/*
2283	* Note that nosuid etc flags are inode-specific: setting some file-system
2284	* flags just means all the inodes inherit those flags by default. It might be
2285	* possible to override it selectively if you really wanted to with some
2286	* ioctl() that is not currently implemented.
2287	*
2288	* Exception: SB_RDONLY is always applied to the entire file system.
2289	*
2290	* Unfortunately, it is possible to change a filesystems flags with it mounted
2291	* with files in use. This means that all of the inodes will not have their
2292	* i_flags updated. Hence, i_flags no longer inherit the superblock mount
2293	* flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
2294	*/
2295	#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
2296
2297	static inline bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & SB_RDONLY; }
2298	#define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
2299	#define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) || \
2300	((inode)->i_flags & S_SYNC))
2301	#define IS_DIRSYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS|SB_DIRSYNC) || \
2302	((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
2303	#define IS_MANDLOCK(inode) __IS_FLG(inode, SB_MANDLOCK)
2304	#define IS_NOATIME(inode) __IS_FLG(inode, SB_RDONLY|SB_NOATIME)
2305	#define IS_I_VERSION(inode) __IS_FLG(inode, SB_I_VERSION)
2306
2307	#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
2308	#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
2309	#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
2310	#define IS_POSIXACL(inode) __IS_FLG(inode, SB_POSIXACL)
2311
2312	#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
2313	#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
2314	#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
2315	#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
2316	#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
2317	#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
2318	#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
2319	#define IS_DAX(inode) ((inode)->i_flags & S_DAX)
2320	#define IS_ENCRYPTED(inode) ((inode)->i_flags & S_ENCRYPTED)
2321	#define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD)
2322	#define IS_VERITY(inode) ((inode)->i_flags & S_VERITY)
2323
2324	#define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \
2325	(inode)->i_rdev == WHITEOUT_DEV)
2326
2327	static inline bool HAS_UNMAPPED_ID(struct user_namespace *mnt_userns,
2328	struct inode *inode)
2329	{
2330	return !vfsuid_valid(i_uid_into_vfsuid(mnt_userns, inode)) ||
2331	!vfsgid_valid(i_gid_into_vfsgid(mnt_userns, inode));
2332	}
2333
2334	static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
2335	{
2336	*kiocb = (struct kiocb) {
2337	.ki_filp = filp,
2338	.ki_flags = filp->f_iocb_flags,
2339	.ki_ioprio = get_current_ioprio(),
2340	};
2341	}
2342
2343	static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
2344	struct file *filp)
2345	{
2346	*kiocb = (struct kiocb) {
2347	.ki_filp = filp,
2348	.ki_flags = kiocb_src->ki_flags,
2349	.ki_ioprio = kiocb_src->ki_ioprio,
2350	.ki_pos = kiocb_src->ki_pos,
2351	};
2352	}
2353
2354	/*
2355	* Inode state bits. Protected by inode->i_lock
2356	*
2357	* Four bits determine the dirty state of the inode: I_DIRTY_SYNC,
2358	* I_DIRTY_DATASYNC, I_DIRTY_PAGES, and I_DIRTY_TIME.
2359	*
2360	* Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
2361	* until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
2362	* various stages of removing an inode.
2363	*
2364	* Two bits are used for locking and completion notification, I_NEW and I_SYNC.
2365	*
2366	* I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on
2367	* fdatasync() (unless I_DIRTY_DATASYNC is also set).
2368	* Timestamp updates are the usual cause.
2369	* I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
2370	* these changes separately from I_DIRTY_SYNC so that we
2371	* don't have to write inode on fdatasync() when only
2372	* e.g. the timestamps have changed.
2373	* I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean.
2374	* I_DIRTY_TIME The inode itself only has dirty timestamps, and the
2375	* lazytime mount option is enabled. We keep track of this
2376	* separately from I_DIRTY_SYNC in order to implement
2377	* lazytime. This gets cleared if I_DIRTY_INODE
2378	* (I_DIRTY_SYNC and/or I_DIRTY_DATASYNC) gets set. I.e.
2379	* either I_DIRTY_TIME *or* I_DIRTY_INODE can be set in
2380	* i_state, but not both. I_DIRTY_PAGES may still be set.
2381	* I_NEW Serves as both a mutex and completion notification.
2382	* New inodes set I_NEW. If two processes both create
2383	* the same inode, one of them will release its inode and
2384	* wait for I_NEW to be released before returning.
2385	* Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
2386	* also cause waiting on I_NEW, without I_NEW actually
2387	* being set. find_inode() uses this to prevent returning
2388	* nearly-dead inodes.
2389	* I_WILL_FREE Must be set when calling write_inode_now() if i_count
2390	* is zero. I_FREEING must be set when I_WILL_FREE is
2391	* cleared.
2392	* I_FREEING Set when inode is about to be freed but still has dirty
2393	* pages or buffers attached or the inode itself is still
2394	* dirty.
2395	* I_CLEAR Added by clear_inode(). In this state the inode is
2396	* clean and can be destroyed. Inode keeps I_FREEING.
2397	*
2398	* Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
2399	* prohibited for many purposes. iget() must wait for
2400	* the inode to be completely released, then create it
2401	* anew. Other functions will just ignore such inodes,
2402	* if appropriate. I_NEW is used for waiting.
2403	*
2404	* I_SYNC Writeback of inode is running. The bit is set during
2405	* data writeback, and cleared with a wakeup on the bit
2406	* address once it is done. The bit is also used to pin
2407	* the inode in memory for flusher thread.
2408	*
2409	* I_REFERENCED Marks the inode as recently references on the LRU list.
2410	*
2411	* I_DIO_WAKEUP Never set. Only used as a key for wait_on_bit().
2412	*
2413	* I_WB_SWITCH Cgroup bdi_writeback switching in progress. Used to
2414	* synchronize competing switching instances and to tell
2415	* wb stat updates to grab the i_pages lock. See
2416	* inode_switch_wbs_work_fn() for details.
2417	*
2418	* I_OVL_INUSE Used by overlayfs to get exclusive ownership on upper
2419	* and work dirs among overlayfs mounts.
2420	*
2421	* I_CREATING New object's inode in the middle of setting up.
2422	*
2423	* I_DONTCACHE Evict inode as soon as it is not used anymore.
2424	*
2425	* I_SYNC_QUEUED Inode is queued in b_io or b_more_io writeback lists.
2426	* Used to detect that mark_inode_dirty() should not move
2427	* inode between dirty lists.
2428	*
2429	* I_PINNING_FSCACHE_WB Inode is pinning an fscache object for writeback.
2430	*
2431	* Q: What is the difference between I_WILL_FREE and I_FREEING?
2432	*/
2433	#define I_DIRTY_SYNC (1 << 0)
2434	#define I_DIRTY_DATASYNC (1 << 1)
2435	#define I_DIRTY_PAGES (1 << 2)
2436	#define __I_NEW 3
2437	#define I_NEW (1 << __I_NEW)
2438	#define I_WILL_FREE (1 << 4)
2439	#define I_FREEING (1 << 5)
2440	#define I_CLEAR (1 << 6)
2441	#define __I_SYNC 7
2442	#define I_SYNC (1 << __I_SYNC)
2443	#define I_REFERENCED (1 << 8)
2444	#define __I_DIO_WAKEUP 9
2445	#define I_DIO_WAKEUP (1 << __I_DIO_WAKEUP)
2446	#define I_LINKABLE (1 << 10)
2447	#define I_DIRTY_TIME (1 << 11)
2448	#define I_WB_SWITCH (1 << 13)
2449	#define I_OVL_INUSE (1 << 14)
2450	#define I_CREATING (1 << 15)
2451	#define I_DONTCACHE (1 << 16)
2452	#define I_SYNC_QUEUED (1 << 17)
2453	#define I_PINNING_FSCACHE_WB (1 << 18)
2454
2455	#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
2456	#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
2457	#define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
2458
2459	extern void __mark_inode_dirty(struct inode *, int);
2460	static inline void mark_inode_dirty(struct inode *inode)
2461	{
2462	__mark_inode_dirty(inode, I_DIRTY);
2463	}
2464
2465	static inline void mark_inode_dirty_sync(struct inode *inode)
2466	{
2467	__mark_inode_dirty(inode, I_DIRTY_SYNC);
2468	}
2469
2470	/*
2471	* Returns true if the given inode itself only has dirty timestamps (its pages
2472	* may still be dirty) and isn't currently being allocated or freed.
2473	* Filesystems should call this if when writing an inode when lazytime is
2474	* enabled, they want to opportunistically write the timestamps of other inodes
2475	* located very nearby on-disk, e.g. in the same inode block. This returns true
2476	* if the given inode is in need of such an opportunistic update. Requires
2477	* i_lock, or at least later re-checking under i_lock.
2478	*/
2479	static inline bool inode_is_dirtytime_only(struct inode *inode)
2480	{
2481	return (inode->i_state & (I_DIRTY_TIME | I_NEW |
2482	I_FREEING | I_WILL_FREE)) == I_DIRTY_TIME;
2483	}
2484
2485	extern void inc_nlink(struct inode *inode);
2486	extern void drop_nlink(struct inode *inode);
2487	extern void clear_nlink(struct inode *inode);
2488	extern void set_nlink(struct inode *inode, unsigned int nlink);
2489
2490	static inline void inode_inc_link_count(struct inode *inode)
2491	{
2492	inc_nlink(inode);
2493	mark_inode_dirty(inode);
2494	}
2495
2496	static inline void inode_dec_link_count(struct inode *inode)
2497	{
2498	drop_nlink(inode);
2499	mark_inode_dirty(inode);
2500	}
2501
2502	enum file_time_flags {
2503	S_ATIME = 1,
2504	S_MTIME = 2,
2505	S_CTIME = 4,
2506	S_VERSION = 8,
2507	};
2508
2509	extern bool atime_needs_update(const struct path *, struct inode *);
2510	extern void touch_atime(const struct path *);
2511	int inode_update_time(struct inode *inode, struct timespec64 *time, int flags);
2512
2513	static inline void file_accessed(struct file *file)
2514	{
2515	if (!(file->f_flags & O_NOATIME))
2516	touch_atime(&file->f_path);
2517	}
2518
2519	extern int file_modified(struct file *file);
2520	int kiocb_modified(struct kiocb *iocb);
2521
2522	int sync_inode_metadata(struct inode *inode, int wait);
2523
2524	struct file_system_type {
2525	const char *name;
2526	int fs_flags;
2527	#define FS_REQUIRES_DEV 1
2528	#define FS_BINARY_MOUNTDATA 2
2529	#define FS_HAS_SUBTYPE 4
2530	#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
2531	#define FS_DISALLOW_NOTIFY_PERM 16 /* Disable fanotify permission events */
2532	#define FS_ALLOW_IDMAP 32 /* FS has been updated to handle vfs idmappings. */
2533	#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
2534	int (*init_fs_context)(struct fs_context *);
2535	const struct fs_parameter_spec *parameters;
2536	struct dentry *(*mount) (struct file_system_type *, int,
2537	const char *, void *);
2538	void (*kill_sb) (struct super_block *);
2539	struct module *owner;
2540	struct file_system_type * next;
2541	struct hlist_head fs_supers;
2542
2543	struct lock_class_key s_lock_key;
2544	struct lock_class_key s_umount_key;
2545	struct lock_class_key s_vfs_rename_key;
2546	struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
2547
2548	struct lock_class_key i_lock_key;
2549	struct lock_class_key i_mutex_key;
2550	struct lock_class_key invalidate_lock_key;
2551	struct lock_class_key i_mutex_dir_key;
2552	};
2553
2554	#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
2555
2556	extern struct dentry *mount_bdev(struct file_system_type *fs_type,
2557	int flags, const char *dev_name, void *data,
2558	int (*fill_super)(struct super_block *, void *, int));
2559	extern struct dentry *mount_single(struct file_system_type *fs_type,
2560	int flags, void *data,
2561	int (*fill_super)(struct super_block *, void *, int));
2562	extern struct dentry *mount_nodev(struct file_system_type *fs_type,
2563	int flags, void *data,
2564	int (*fill_super)(struct super_block *, void *, int));
2565	extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
2566	void retire_super(struct super_block *sb);
2567	void generic_shutdown_super(struct super_block *sb);
2568	void kill_block_super(struct super_block *sb);
2569	void kill_anon_super(struct super_block *sb);
2570	void kill_litter_super(struct super_block *sb);
2571	void deactivate_super(struct super_block *sb);
2572	void deactivate_locked_super(struct super_block *sb);
2573	int set_anon_super(struct super_block *s, void *data);
2574	int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
2575	int get_anon_bdev(dev_t *);
2576	void free_anon_bdev(dev_t);
2577	struct super_block *sget_fc(struct fs_context *fc,
2578	int (*test)(struct super_block *, struct fs_context *),
2579	int (*set)(struct super_block *, struct fs_context *));
2580	struct super_block *sget(struct file_system_type *type,
2581	int (*test)(struct super_block *,void *),
2582	int (*set)(struct super_block *,void *),
2583	int flags, void *data);
2584
2585	/* Alas, no aliases. Too much hassle with bringing module.h everywhere */
2586	#define fops_get(fops) \
2587	(((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
2588	#define fops_put(fops) \
2589	do { if (fops) module_put((fops)->owner); } while(0)
2590	/*
2591	* This one is to be used *ONLY* from ->open() instances.
2592	* fops must be non-NULL, pinned down *and* module dependencies
2593	* should be sufficient to pin the caller down as well.
2594	*/
2595	#define replace_fops(f, fops) \
2596	do { \
2597	struct file *__file = (f); \
2598	fops_put(__file->f_op); \
2599	BUG_ON(!(__file->f_op = (fops))); \
2600	} while(0)
2601
2602	extern int register_filesystem(struct file_system_type *);
2603	extern int unregister_filesystem(struct file_system_type *);
2604	extern int vfs_statfs(const struct path *, struct kstatfs *);
2605	extern int user_statfs(const char __user *, struct kstatfs *);
2606	extern int fd_statfs(int, struct kstatfs *);
2607	extern int freeze_super(struct super_block *super);
2608	extern int thaw_super(struct super_block *super);
2609	extern __printf(2, 3)
2610	int super_setup_bdi_name(struct super_block *sb, char *fmt, ...);
2611	extern int super_setup_bdi(struct super_block *sb);
2612
2613	extern int current_umask(void);
2614
2615	extern void ihold(struct inode * inode);
2616	extern void iput(struct inode *);
2617	extern int generic_update_time(struct inode *, struct timespec64 *, int);
2618
2619	/* /sys/fs */
2620	extern struct kobject *fs_kobj;
2621
2622	#define MAX_RW_COUNT (INT_MAX & PAGE_MASK)
2623
2624	#ifdef CONFIG_FILE_LOCKING
2625	static inline int break_lease(struct inode *inode, unsigned int mode)
2626	{
2627	/*
2628	* Since this check is lockless, we must ensure that any refcounts
2629	* taken are done before checking i_flctx->flc_lease. Otherwise, we
2630	* could end up racing with tasks trying to set a new lease on this
2631	* file.
2632	*/
2633	smp_mb();
2634	if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2635	return __break_lease(inode, mode, FL_LEASE);
2636	return 0;
2637	}
2638
2639	static inline int break_deleg(struct inode *inode, unsigned int mode)
2640	{
2641	/*
2642	* Since this check is lockless, we must ensure that any refcounts
2643	* taken are done before checking i_flctx->flc_lease. Otherwise, we
2644	* could end up racing with tasks trying to set a new lease on this
2645	* file.
2646	*/
2647	smp_mb();
2648	if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2649	return __break_lease(inode, mode, FL_DELEG);
2650	return 0;
2651	}
2652
2653	static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2654	{
2655	int ret;
2656
2657	ret = break_deleg(inode, O_WRONLY|O_NONBLOCK);
2658	if (ret == -EWOULDBLOCK && delegated_inode) {
2659	*delegated_inode = inode;
2660	ihold(inode);
2661	}
2662	return ret;
2663	}
2664
2665	static inline int break_deleg_wait(struct inode **delegated_inode)
2666	{
2667	int ret;
2668
2669	ret = break_deleg(*delegated_inode, O_WRONLY);
2670	iput(*delegated_inode);
2671	*delegated_inode = NULL;
2672	return ret;
2673	}
2674
2675	static inline int break_layout(struct inode *inode, bool wait)
2676	{
2677	smp_mb();
2678	if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
2679	return __break_lease(inode,
2680	wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
2681	FL_LAYOUT);
2682	return 0;
2683	}
2684
2685	#else /* !CONFIG_FILE_LOCKING */
2686	static inline int break_lease(struct inode *inode, unsigned int mode)
2687	{
2688	return 0;
2689	}
2690
2691	static inline int break_deleg(struct inode *inode, unsigned int mode)
2692	{
2693	return 0;
2694	}
2695
2696	static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2697	{
2698	return 0;
2699	}
2700
2701	static inline int break_deleg_wait(struct inode **delegated_inode)
2702	{
2703	BUG();
2704	return 0;
2705	}
2706
2707	static inline int break_layout(struct inode *inode, bool wait)
2708	{
2709	return 0;
2710	}
2711
2712	#endif /* CONFIG_FILE_LOCKING */
2713
2714	/* fs/open.c */
2715	struct audit_names;
2716	struct filename {
2717	const char *name; /* pointer to actual string */
2718	const __user char *uptr; /* original userland pointer */
2719	int refcnt;
2720	struct audit_names *aname;
2721	const char iname[];
2722	};
2723	static_assert(offsetof(struct filename, iname) % sizeof(long) == 0);
2724
2725	static inline struct user_namespace *file_mnt_user_ns(struct file *file)
2726	{
2727	return mnt_user_ns(file->f_path.mnt);
2728	}
2729
2730	/**
2731	* is_idmapped_mnt - check whether a mount is mapped
2732	* @mnt: the mount to check
2733	*
2734	* If @mnt has an idmapping attached different from the
2735	* filesystem's idmapping then @mnt is mapped.
2736	*
2737	* Return: true if mount is mapped, false if not.
2738	*/
2739	static inline bool is_idmapped_mnt(const struct vfsmount *mnt)
2740	{
2741	return mnt_user_ns(mnt) != mnt->mnt_sb->s_user_ns;
2742	}
2743
2744	extern long vfs_truncate(const struct path *, loff_t);
2745	int do_truncate(struct user_namespace *, struct dentry *, loff_t start,
2746	unsigned int time_attrs, struct file *filp);
2747	extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
2748	loff_t len);
2749	extern long do_sys_open(int dfd, const char __user *filename, int flags,
2750	umode_t mode);
2751	extern struct file *file_open_name(struct filename *, int, umode_t);
2752	extern struct file *filp_open(const char *, int, umode_t);
2753	extern struct file *file_open_root(const struct path *,
2754	const char *, int, umode_t);
2755	static inline struct file *file_open_root_mnt(struct vfsmount *mnt,
2756	const char *name, int flags, umode_t mode)
2757	{
2758	return file_open_root(&(struct path){.mnt = mnt, .dentry = mnt->mnt_root},
2759	name, flags, mode);
2760	}
2761	extern struct file * dentry_open(const struct path *, int, const struct cred *);
2762	extern struct file *dentry_create(const struct path *path, int flags,
2763	umode_t mode, const struct cred *cred);
2764	extern struct file * open_with_fake_path(const struct path *, int,
2765	struct inode*, const struct cred *);
2766	static inline struct file *file_clone_open(struct file *file)
2767	{
2768	return dentry_open(&file->f_path, file->f_flags, file->f_cred);
2769	}
2770	extern int filp_close(struct file *, fl_owner_t id);
2771
2772	extern struct filename *getname_flags(const char __user *, int, int *);
2773	extern struct filename *getname_uflags(const char __user *, int);
2774	extern struct filename *getname(const char __user *);
2775	extern struct filename *getname_kernel(const char *);
2776	extern void putname(struct filename *name);
2777
2778	extern int finish_open(struct file *file, struct dentry *dentry,
2779	int (*open)(struct inode *, struct file *));
2780	extern int finish_no_open(struct file *file, struct dentry *dentry);
2781
2782	/* fs/dcache.c */
2783	extern void __init vfs_caches_init_early(void);
2784	extern void __init vfs_caches_init(void);
2785
2786	extern struct kmem_cache *names_cachep;
2787
2788	#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
2789	#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
2790
2791	extern struct super_block *blockdev_superblock;
2792	static inline bool sb_is_blkdev_sb(struct super_block *sb)
2793	{
2794	return IS_ENABLED(CONFIG_BLOCK) && sb == blockdev_superblock;
2795	}
2796
2797	void emergency_thaw_all(void);
2798	extern int sync_filesystem(struct super_block *);
2799	extern const struct file_operations def_blk_fops;
2800	extern const struct file_operations def_chr_fops;
2801
2802	/* fs/char_dev.c */
2803	#define CHRDEV_MAJOR_MAX 512
2804	/* Marks the bottom of the first segment of free char majors */
2805	#define CHRDEV_MAJOR_DYN_END 234
2806	/* Marks the top and bottom of the second segment of free char majors */
2807	#define CHRDEV_MAJOR_DYN_EXT_START 511
2808	#define CHRDEV_MAJOR_DYN_EXT_END 384
2809
2810	extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
2811	extern int register_chrdev_region(dev_t, unsigned, const char *);
2812	extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2813	unsigned int count, const char *name,
2814	const struct file_operations *fops);
2815	extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2816	unsigned int count, const char *name);
2817	extern void unregister_chrdev_region(dev_t, unsigned);
2818	extern void chrdev_show(struct seq_file *,off_t);
2819
2820	static inline int register_chrdev(unsigned int major, const char *name,
2821	const struct file_operations *fops)
2822	{
2823	return __register_chrdev(major, 0, 256, name, fops);
2824	}
2825
2826	static inline void unregister_chrdev(unsigned int major, const char *name)
2827	{
2828	__unregister_chrdev(major, 0, 256, name);
2829	}
2830
2831	extern void init_special_inode(struct inode *, umode_t, dev_t);
2832
2833	/* Invalid inode operations -- fs/bad_inode.c */
2834	extern void make_bad_inode(struct inode *);
2835	extern bool is_bad_inode(struct inode *);
2836
2837	extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
2838	loff_t lend);
2839	extern int __must_check file_check_and_advance_wb_err(struct file *file);
2840	extern int __must_check file_write_and_wait_range(struct file *file,
2841	loff_t start, loff_t end);
2842
2843	static inline int file_write_and_wait(struct file *file)
2844	{
2845	return file_write_and_wait_range(file, 0, LLONG_MAX);
2846	}
2847
2848	extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
2849	int datasync);
2850	extern int vfs_fsync(struct file *file, int datasync);
2851
2852	extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
2853	unsigned int flags);
2854
2855	static inline bool iocb_is_dsync(const struct kiocb *iocb)
2856	{
2857	return (iocb->ki_flags & IOCB_DSYNC) ||
2858	IS_SYNC(iocb->ki_filp->f_mapping->host);
2859	}
2860
2861	/*
2862	* Sync the bytes written if this was a synchronous write. Expect ki_pos
2863	* to already be updated for the write, and will return either the amount
2864	* of bytes passed in, or an error if syncing the file failed.
2865	*/
2866	static inline ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count)
2867	{
2868	if (iocb_is_dsync(iocb)) {
2869	int ret = vfs_fsync_range(iocb->ki_filp,
2870	iocb->ki_pos - count, iocb->ki_pos - 1,
2871	(iocb->ki_flags & IOCB_SYNC) ? 0 : 1);
2872	if (ret)
2873	return ret;
2874	}
2875
2876	return count;
2877	}
2878
2879	extern void emergency_sync(void);
2880	extern void emergency_remount(void);
2881
2882	#ifdef CONFIG_BLOCK
2883	extern int bmap(struct inode *inode, sector_t *block);
2884	#else
2885	static inline int bmap(struct inode *inode, sector_t *block)
2886	{
2887	return -EINVAL;
2888	}
2889	#endif
2890
2891	int notify_change(struct user_namespace *, struct dentry *,
2892	struct iattr *, struct inode **);
2893	int inode_permission(struct user_namespace *, struct inode *, int);
2894	int generic_permission(struct user_namespace *, struct inode *, int);
2895	static inline int file_permission(struct file *file, int mask)
2896	{
2897	return inode_permission(file_mnt_user_ns(file),
2898	file_inode(file), mask);
2899	}
2900	static inline int path_permission(const struct path *path, int mask)
2901	{
2902	return inode_permission(mnt_user_ns(path->mnt),
2903	d_inode(path->dentry), mask);
2904	}
2905	int __check_sticky(struct user_namespace *mnt_userns, struct inode *dir,
2906	struct inode *inode);
2907
2908	static inline bool execute_ok(struct inode *inode)
2909	{
2910	return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
2911	}
2912
2913	static inline bool inode_wrong_type(const struct inode *inode, umode_t mode)
2914	{
2915	return (inode->i_mode ^ mode) & S_IFMT;
2916	}
2917
2918	static inline void file_start_write(struct file *file)
2919	{
2920	if (!S_ISREG(file_inode(file)->i_mode))
2921	return;
2922	sb_start_write(file_inode(file)->i_sb);
2923	}
2924
2925	static inline bool file_start_write_trylock(struct file *file)
2926	{
2927	if (!S_ISREG(file_inode(file)->i_mode))
2928	return true;
2929	return sb_start_write_trylock(file_inode(file)->i_sb);
2930	}
2931
2932	static inline void file_end_write(struct file *file)
2933	{
2934	if (!S_ISREG(file_inode(file)->i_mode))
2935	return;
2936	__sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
2937	}
2938
2939	/*
2940	* This is used for regular files where some users -- especially the
2941	* currently executed binary in a process, previously handled via
2942	* VM_DENYWRITE -- cannot handle concurrent write (and maybe mmap
2943	* read-write shared) accesses.
2944	*
2945	* get_write_access() gets write permission for a file.
2946	* put_write_access() releases this write permission.
2947	* deny_write_access() denies write access to a file.
2948	* allow_write_access() re-enables write access to a file.
2949	*
2950	* The i_writecount field of an inode can have the following values:
2951	* 0: no write access, no denied write access
2952	* < 0: (-i_writecount) users that denied write access to the file.
2953	* > 0: (i_writecount) users that have write access to the file.
2954	*
2955	* Normally we operate on that counter with atomic_{inc,dec} and it's safe
2956	* except for the cases where we don't hold i_writecount yet. Then we need to
2957	* use {get,deny}_write_access() - these functions check the sign and refuse
2958	* to do the change if sign is wrong.
2959	*/
2960	static inline int get_write_access(struct inode *inode)
2961	{
2962	return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
2963	}
2964	static inline int deny_write_access(struct file *file)
2965	{
2966	struct inode *inode = file_inode(file);
2967	return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
2968	}
2969	static inline void put_write_access(struct inode * inode)
2970	{
2971	atomic_dec(&inode->i_writecount);
2972	}
2973	static inline void allow_write_access(struct file *file)
2974	{
2975	if (file)
2976	atomic_inc(&file_inode(file)->i_writecount);
2977	}
2978	static inline bool inode_is_open_for_write(const struct inode *inode)
2979	{
2980	return atomic_read(&inode->i_writecount) > 0;
2981	}
2982
2983	#if defined(CONFIG_IMA) || defined(CONFIG_FILE_LOCKING)
2984	static inline void i_readcount_dec(struct inode *inode)
2985	{
2986	BUG_ON(!atomic_read(&inode->i_readcount));
2987	atomic_dec(&inode->i_readcount);
2988	}
2989	static inline void i_readcount_inc(struct inode *inode)
2990	{
2991	atomic_inc(&inode->i_readcount);
2992	}
2993	#else
2994	static inline void i_readcount_dec(struct inode *inode)
2995	{
2996	return;
2997	}
2998	static inline void i_readcount_inc(struct inode *inode)
2999	{
3000	return;
3001	}
3002	#endif
3003	extern int do_pipe_flags(int *, int);
3004
3005	extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *);
3006	ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos);
3007	extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *);
3008	extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *);
3009	extern struct file * open_exec(const char *);
3010
3011	/* fs/dcache.c -- generic fs support functions */
3012	extern bool is_subdir(struct dentry *, struct dentry *);
3013	extern bool path_is_under(const struct path *, const struct path *);
3014
3015	extern char *file_path(struct file *, char *, int);
3016
3017	#include <linux/err.h>
3018
3019	/* needed for stackable file system support */
3020	extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
3021
3022	extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
3023
3024	extern int inode_init_always(struct super_block *, struct inode *);
3025	extern void inode_init_once(struct inode *);
3026	extern void address_space_init_once(struct address_space *mapping);
3027	extern struct inode * igrab(struct inode *);
3028	extern ino_t iunique(struct super_block *, ino_t);
3029	extern int inode_needs_sync(struct inode *inode);
3030	extern int generic_delete_inode(struct inode *inode);
3031	static inline int generic_drop_inode(struct inode *inode)
3032	{
3033	return !inode->i_nlink || inode_unhashed(inode);
3034	}
3035	extern void d_mark_dontcache(struct inode *inode);
3036
3037	extern struct inode *ilookup5_nowait(struct super_block *sb,
3038	unsigned long hashval, int (*test)(struct inode *, void *),
3039	void *data);
3040	extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
3041	int (*test)(struct inode *, void *), void *data);
3042	extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
3043
3044	extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
3045	int (*test)(struct inode *, void *),
3046	int (*set)(struct inode *, void *),
3047	void *data);
3048	extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
3049	extern struct inode * iget_locked(struct super_block *, unsigned long);
3050	extern struct inode *find_inode_nowait(struct super_block *,
3051	unsigned long,
3052	int (*match)(struct inode *,
3053	unsigned long, void *),
3054	void *data);
3055	extern struct inode *find_inode_rcu(struct super_block *, unsigned long,
3056	int (*)(struct inode *, void *), void *);
3057	extern struct inode *find_inode_by_ino_rcu(struct super_block *, unsigned long);
3058	extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
3059	extern int insert_inode_locked(struct inode *);
3060	#ifdef CONFIG_DEBUG_LOCK_ALLOC
3061	extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
3062	#else
3063	static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
3064	#endif
3065	extern void unlock_new_inode(struct inode *);
3066	extern void discard_new_inode(struct inode *);
3067	extern unsigned int get_next_ino(void);
3068	extern void evict_inodes(struct super_block *sb);
3069	void dump_mapping(const struct address_space *);
3070
3071	/*
3072	* Userspace may rely on the the inode number being non-zero. For example, glibc
3073	* simply ignores files with zero i_ino in unlink() and other places.
3074	*
3075	* As an additional complication, if userspace was compiled with
3076	* _FILE_OFFSET_BITS=32 on a 64-bit kernel we'll only end up reading out the
3077	* lower 32 bits, so we need to check that those aren't zero explicitly. With
3078	* _FILE_OFFSET_BITS=64, this may cause some harmless false-negatives, but
3079	* better safe than sorry.
3080	*/
3081	static inline bool is_zero_ino(ino_t ino)
3082	{
3083	return (u32)ino == 0;
3084	}
3085
3086	extern void __iget(struct inode * inode);
3087	extern void iget_failed(struct inode *);
3088	extern void clear_inode(struct inode *);
3089	extern void __destroy_inode(struct inode *);
3090	extern struct inode *new_inode_pseudo(struct super_block *sb);
3091	extern struct inode *new_inode(struct super_block *sb);
3092	extern void free_inode_nonrcu(struct inode *inode);
3093	extern int should_remove_suid(struct dentry *);
3094	extern int file_remove_privs(struct file *);
3095
3096	/*
3097	* This must be used for allocating filesystems specific inodes to set
3098	* up the inode reclaim context correctly.
3099	*/
3100	static inline void *
3101	alloc_inode_sb(struct super_block *sb, struct kmem_cache *cache, gfp_t gfp)
3102	{
3103	return kmem_cache_alloc_lru(cache, &sb->s_inode_lru, gfp);
3104	}
3105
3106	extern void __insert_inode_hash(struct inode *, unsigned long hashval);
3107	static inline void insert_inode_hash(struct inode *inode)
3108	{
3109	__insert_inode_hash(inode, inode->i_ino);
3110	}
3111
3112	extern void __remove_inode_hash(struct inode *);
3113	static inline void remove_inode_hash(struct inode *inode)
3114	{
3115	if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash))
3116	__remove_inode_hash(inode);
3117	}
3118
3119	extern void inode_sb_list_add(struct inode *inode);
3120	extern void inode_add_lru(struct inode *inode);
3121
3122	extern int sb_set_blocksize(struct super_block *, int);
3123	extern int sb_min_blocksize(struct super_block *, int);
3124
3125	extern int generic_file_mmap(struct file *, struct vm_area_struct *);
3126	extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
3127	extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
3128	int generic_write_checks_count(struct kiocb *iocb, loff_t *count);
3129	extern int generic_write_check_limits(struct file *file, loff_t pos,
3130	loff_t *count);
3131	extern int generic_file_rw_checks(struct file *file_in, struct file *file_out);
3132	ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *to,
3133	ssize_t already_read);
3134	extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
3135	extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
3136	extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
3137	extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
3138	ssize_t generic_perform_write(struct kiocb *, struct iov_iter *);
3139
3140	ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
3141	rwf_t flags);
3142	ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
3143	rwf_t flags);
3144	ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,
3145	struct iov_iter *iter);
3146	ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,
3147	struct iov_iter *iter);
3148
3149	/* fs/splice.c */
3150	extern ssize_t generic_file_splice_read(struct file *, loff_t *,
3151	struct pipe_inode_info *, size_t, unsigned int);
3152	extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
3153	struct file *, loff_t *, size_t, unsigned int);
3154	extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
3155	struct file *out, loff_t *, size_t len, unsigned int flags);
3156	extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
3157	loff_t *opos, size_t len, unsigned int flags);
3158
3159
3160	extern void
3161	file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
3162	extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
3163	#define no_llseek NULL
3164	extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
3165	extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
3166	extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
3167	int whence, loff_t maxsize, loff_t eof);
3168	extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
3169	int whence, loff_t size);
3170	extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
3171	extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
3172	int rw_verify_area(int, struct file *, const loff_t *, size_t);
3173	extern int generic_file_open(struct inode * inode, struct file * filp);
3174	extern int nonseekable_open(struct inode * inode, struct file * filp);
3175	extern int stream_open(struct inode * inode, struct file * filp);
3176
3177	#ifdef CONFIG_BLOCK
3178	typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
3179	loff_t file_offset);
3180
3181	enum {
3182	/* need locking between buffered and direct access */
3183	DIO_LOCKING = 0x01,
3184
3185	/* filesystem does not support filling holes */
3186	DIO_SKIP_HOLES = 0x02,
3187	};
3188
3189	ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
3190	struct block_device *bdev, struct iov_iter *iter,
3191	get_block_t get_block,
3192	dio_iodone_t end_io, dio_submit_t submit_io,
3193	int flags);
3194
3195	static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
3196	struct inode *inode,
3197	struct iov_iter *iter,
3198	get_block_t get_block)
3199	{
3200	return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
3201	get_block, NULL, NULL, DIO_LOCKING | DIO_SKIP_HOLES);
3202	}
3203	#endif
3204
3205	void inode_dio_wait(struct inode *inode);
3206
3207	/**
3208	* inode_dio_begin - signal start of a direct I/O requests
3209	* @inode: inode the direct I/O happens on
3210	*
3211	* This is called once we've finished processing a direct I/O request,
3212	* and is used to wake up callers waiting for direct I/O to be quiesced.
3213	*/
3214	static inline void inode_dio_begin(struct inode *inode)
3215	{
3216	atomic_inc(&inode->i_dio_count);
3217	}
3218
3219	/**
3220	* inode_dio_end - signal finish of a direct I/O requests
3221	* @inode: inode the direct I/O happens on
3222	*
3223	* This is called once we've finished processing a direct I/O request,
3224	* and is used to wake up callers waiting for direct I/O to be quiesced.
3225	*/
3226	static inline void inode_dio_end(struct inode *inode)
3227	{
3228	if (atomic_dec_and_test(&inode->i_dio_count))
3229	wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
3230	}
3231
3232	/*
3233	* Warn about a page cache invalidation failure diring a direct I/O write.
3234	*/
3235	void dio_warn_stale_pagecache(struct file *filp);
3236
3237	extern void inode_set_flags(struct inode *inode, unsigned int flags,
3238	unsigned int mask);
3239
3240	extern const struct file_operations generic_ro_fops;
3241
3242	#define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
3243
3244	extern int readlink_copy(char __user *, int, const char *);
3245	extern int page_readlink(struct dentry *, char __user *, int);
3246	extern const char *page_get_link(struct dentry *, struct inode *,
3247	struct delayed_call *);
3248	extern void page_put_link(void *);
3249	extern int page_symlink(struct inode *inode, const char *symname, int len);
3250	extern const struct inode_operations page_symlink_inode_operations;
3251	extern void kfree_link(void *);
3252	void generic_fillattr(struct user_namespace *, struct inode *, struct kstat *);
3253	void generic_fill_statx_attr(struct inode *inode, struct kstat *stat);
3254	extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
3255	extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
3256	void __inode_add_bytes(struct inode *inode, loff_t bytes);
3257	void inode_add_bytes(struct inode *inode, loff_t bytes);
3258	void __inode_sub_bytes(struct inode *inode, loff_t bytes);
3259	void inode_sub_bytes(struct inode *inode, loff_t bytes);
3260	static inline loff_t __inode_get_bytes(struct inode *inode)
3261	{
3262	return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
3263	}
3264	loff_t inode_get_bytes(struct inode *inode);
3265	void inode_set_bytes(struct inode *inode, loff_t bytes);
3266	const char *simple_get_link(struct dentry *, struct inode *,
3267	struct delayed_call *);
3268	extern const struct inode_operations simple_symlink_inode_operations;
3269
3270	extern int iterate_dir(struct file *, struct dir_context *);
3271
3272	int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
3273	int flags);
3274	int vfs_fstat(int fd, struct kstat *stat);
3275
3276	static inline int vfs_stat(const char __user *filename, struct kstat *stat)
3277	{
3278	return vfs_fstatat(AT_FDCWD, filename, stat, 0);
3279	}
3280	static inline int vfs_lstat(const char __user *name, struct kstat *stat)
3281	{
3282	return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
3283	}
3284
3285	extern const char *vfs_get_link(struct dentry *, struct delayed_call *);
3286	extern int vfs_readlink(struct dentry *, char __user *, int);
3287
3288	extern struct file_system_type *get_filesystem(struct file_system_type *fs);
3289	extern void put_filesystem(struct file_system_type *fs);
3290	extern struct file_system_type *get_fs_type(const char *name);
3291	extern struct super_block *get_super(struct block_device *);
3292	extern struct super_block *get_active_super(struct block_device *bdev);
3293	extern void drop_super(struct super_block *sb);
3294	extern void drop_super_exclusive(struct super_block *sb);
3295	extern void iterate_supers(void (*)(struct super_block *, void *), void *);
3296	extern void iterate_supers_type(struct file_system_type *,
3297	void (*)(struct super_block *, void *), void *);
3298
3299	extern int dcache_dir_open(struct inode *, struct file *);
3300	extern int dcache_dir_close(struct inode *, struct file *);
3301	extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
3302	extern int dcache_readdir(struct file *, struct dir_context *);
3303	extern int simple_setattr(struct user_namespace *, struct dentry *,
3304	struct iattr *);
3305	extern int simple_getattr(struct user_namespace *, const struct path *,
3306	struct kstat *, u32, unsigned int);
3307	extern int simple_statfs(struct dentry *, struct kstatfs *);
3308	extern int simple_open(struct inode *inode, struct file *file);
3309	extern int simple_link(struct dentry *, struct inode *, struct dentry *);
3310	extern int simple_unlink(struct inode *, struct dentry *);
3311	extern int simple_rmdir(struct inode *, struct dentry *);
3312	extern int simple_rename_exchange(struct inode *old_dir, struct dentry *old_dentry,
3313	struct inode *new_dir, struct dentry *new_dentry);
3314	extern int simple_rename(struct user_namespace *, struct inode *,
3315	struct dentry *, struct inode *, struct dentry *,
3316	unsigned int);
3317	extern void simple_recursive_removal(struct dentry *,
3318	void (*callback)(struct dentry *));
3319	extern int noop_fsync(struct file *, loff_t, loff_t, int);
3320	extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
3321	extern int simple_empty(struct dentry *);
3322	extern int simple_write_begin(struct file *file, struct address_space *mapping,
3323	loff_t pos, unsigned len,
3324	struct page **pagep, void **fsdata);
3325	extern const struct address_space_operations ram_aops;
3326	extern int always_delete_dentry(const struct dentry *);
3327	extern struct inode *alloc_anon_inode(struct super_block *);
3328	extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
3329	extern const struct dentry_operations simple_dentry_operations;
3330
3331	extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
3332	extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
3333	extern const struct file_operations simple_dir_operations;
3334	extern const struct inode_operations simple_dir_inode_operations;
3335	extern void make_empty_dir_inode(struct inode *inode);
3336	extern bool is_empty_dir_inode(struct inode *inode);
3337	struct tree_descr { const char *name; const struct file_operations *ops; int mode; };
3338	struct dentry *d_alloc_name(struct dentry *, const char *);
3339	extern int simple_fill_super(struct super_block *, unsigned long,
3340	const struct tree_descr *);
3341	extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
3342	extern void simple_release_fs(struct vfsmount **mount, int *count);
3343
3344	extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
3345	loff_t *ppos, const void *from, size_t available);
3346	extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
3347	const void __user *from, size_t count);
3348
3349	extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
3350	extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
3351
3352	extern int generic_check_addressable(unsigned, u64);
3353
3354	extern void generic_set_encrypted_ci_d_ops(struct dentry *dentry);
3355
3356	int may_setattr(struct user_namespace *mnt_userns, struct inode *inode,
3357	unsigned int ia_valid);
3358	int setattr_prepare(struct user_namespace *, struct dentry *, struct iattr *);
3359	extern int inode_newsize_ok(const struct inode *, loff_t offset);
3360	void setattr_copy(struct user_namespace *, struct inode *inode,
3361	const struct iattr *attr);
3362
3363	extern int file_update_time(struct file *file);
3364
3365	static inline bool vma_is_dax(const struct vm_area_struct *vma)
3366	{
3367	return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host);
3368	}
3369
3370	static inline bool vma_is_fsdax(struct vm_area_struct *vma)
3371	{
3372	struct inode *inode;
3373
3374	if (!IS_ENABLED(CONFIG_FS_DAX) || !vma->vm_file)
3375	return false;
3376	if (!vma_is_dax(vma))
3377	return false;
3378	inode = file_inode(vma->vm_file);
3379	if (S_ISCHR(inode->i_mode))
3380	return false; /* device-dax */
3381	return true;
3382	}
3383
3384	static inline int iocb_flags(struct file *file)
3385	{
3386	int res = 0;
3387	if (file->f_flags & O_APPEND)
3388	res |= IOCB_APPEND;
3389	if (file->f_flags & O_DIRECT)
3390	res |= IOCB_DIRECT;
3391	if (file->f_flags & O_DSYNC)
3392	res |= IOCB_DSYNC;
3393	if (file->f_flags & __O_SYNC)
3394	res |= IOCB_SYNC;
3395	return res;
3396	}
3397
3398	static inline int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags)
3399	{
3400	int kiocb_flags = 0;
3401
3402	/* make sure there's no overlap between RWF and private IOCB flags */
3403	BUILD_BUG_ON((__force int) RWF_SUPPORTED & IOCB_EVENTFD);
3404
3405	if (!flags)
3406	return 0;
3407	if (unlikely(flags & ~RWF_SUPPORTED))
3408	return -EOPNOTSUPP;
3409
3410	if (flags & RWF_NOWAIT) {
3411	if (!(ki->ki_filp->f_mode & FMODE_NOWAIT))
3412	return -EOPNOTSUPP;
3413	kiocb_flags |= IOCB_NOIO;
3414	}
3415	kiocb_flags |= (__force int) (flags & RWF_SUPPORTED);
3416	if (flags & RWF_SYNC)
3417	kiocb_flags |= IOCB_DSYNC;
3418
3419	ki->ki_flags |= kiocb_flags;
3420	return 0;
3421	}
3422
3423	static inline ino_t parent_ino(struct dentry *dentry)
3424	{
3425	ino_t res;
3426
3427	/*
3428	* Don't strictly need d_lock here? If the parent ino could change
3429	* then surely we'd have a deeper race in the caller?
3430	*/
3431	spin_lock(&dentry->d_lock);
3432	res = dentry->d_parent->d_inode->i_ino;
3433	spin_unlock(&dentry->d_lock);
3434	return res;
3435	}
3436
3437	/* Transaction based IO helpers */
3438
3439	/*
3440	* An argresp is stored in an allocated page and holds the
3441	* size of the argument or response, along with its content
3442	*/
3443	struct simple_transaction_argresp {
3444	ssize_t size;
3445	char data[];
3446	};
3447
3448	#define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
3449
3450	char *simple_transaction_get(struct file *file, const char __user *buf,
3451	size_t size);
3452	ssize_t simple_transaction_read(struct file *file, char __user *buf,
3453	size_t size, loff_t *pos);
3454	int simple_transaction_release(struct inode *inode, struct file *file);
3455
3456	void simple_transaction_set(struct file *file, size_t n);
3457
3458	/*
3459	* simple attribute files
3460	*
3461	* These attributes behave similar to those in sysfs:
3462	*
3463	* Writing to an attribute immediately sets a value, an open file can be
3464	* written to multiple times.
3465	*
3466	* Reading from an attribute creates a buffer from the value that might get
3467	* read with multiple read calls. When the attribute has been read
3468	* completely, no further read calls are possible until the file is opened
3469	* again.
3470	*
3471	* All attributes contain a text representation of a numeric value
3472	* that are accessed with the get() and set() functions.
3473	*/
3474	#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
3475	static int __fops ## _open(struct inode *inode, struct file *file) \
3476	{ \
3477	__simple_attr_check_format(__fmt, 0ull); \
3478	return simple_attr_open(inode, file, __get, __set, __fmt); \
3479	} \
3480	static const struct file_operations __fops = { \
3481	.owner = THIS_MODULE, \
3482	.open = __fops ## _open, \
3483	.release = simple_attr_release, \
3484	.read = simple_attr_read, \
3485	.write = simple_attr_write, \
3486	.llseek = generic_file_llseek, \
3487	}
3488
3489	static inline __printf(1, 2)
3490	void __simple_attr_check_format(const char *fmt, ...)
3491	{
3492	/* don't do anything, just let the compiler check the arguments; */
3493	}
3494
3495	int simple_attr_open(struct inode *inode, struct file *file,
3496	int (*get)(void *, u64 *), int (*set)(void *, u64),
3497	const char *fmt);
3498	int simple_attr_release(struct inode *inode, struct file *file);
3499	ssize_t simple_attr_read(struct file *file, char __user *buf,
3500	size_t len, loff_t *ppos);
3501	ssize_t simple_attr_write(struct file *file, const char __user *buf,
3502	size_t len, loff_t *ppos);
3503
3504	struct ctl_table;
3505	int __init list_bdev_fs_names(char *buf, size_t size);
3506
3507	#define __FMODE_EXEC ((__force int) FMODE_EXEC)
3508	#define __FMODE_NONOTIFY ((__force int) FMODE_NONOTIFY)
3509
3510	#define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
3511	#define OPEN_FMODE(flag) ((__force fmode_t)(((flag + 1) & O_ACCMODE) | \
3512	(flag & __FMODE_NONOTIFY)))
3513
3514	static inline bool is_sxid(umode_t mode)
3515	{
3516	return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
3517	}
3518
3519	static inline int check_sticky(struct user_namespace *mnt_userns,
3520	struct inode *dir, struct inode *inode)
3521	{
3522	if (!(dir->i_mode & S_ISVTX))
3523	return 0;
3524
3525	return __check_sticky(mnt_userns, dir, inode);
3526	}
3527
3528	static inline void inode_has_no_xattr(struct inode *inode)
3529	{
3530	if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & SB_NOSEC))
3531	inode->i_flags |= S_NOSEC;
3532	}
3533
3534	static inline bool is_root_inode(struct inode *inode)
3535	{
3536	return inode == inode->i_sb->s_root->d_inode;
3537	}
3538
3539	static inline bool dir_emit(struct dir_context *ctx,
3540	const char *name, int namelen,
3541	u64 ino, unsigned type)
3542	{
3543	return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
3544	}
3545	static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
3546	{
3547	return ctx->actor(ctx, ".", 1, ctx->pos,
3548	file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
3549	}
3550	static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
3551	{
3552	return ctx->actor(ctx, "..", 2, ctx->pos,
3553	parent_ino(file->f_path.dentry), DT_DIR) == 0;
3554	}
3555	static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
3556	{
3557	if (ctx->pos == 0) {
3558	if (!dir_emit_dot(file, ctx))
3559	return false;
3560	ctx->pos = 1;
3561	}
3562	if (ctx->pos == 1) {
3563	if (!dir_emit_dotdot(file, ctx))
3564	return false;
3565	ctx->pos = 2;
3566	}
3567	return true;
3568	}
3569	static inline bool dir_relax(struct inode *inode)
3570	{
3571	inode_unlock(inode);
3572	inode_lock(inode);
3573	return !IS_DEADDIR(inode);
3574	}
3575
3576	static inline bool dir_relax_shared(struct inode *inode)
3577	{
3578	inode_unlock_shared(inode);
3579	inode_lock_shared(inode);
3580	return !IS_DEADDIR(inode);
3581	}
3582
3583	extern bool path_noexec(const struct path *path);
3584	extern void inode_nohighmem(struct inode *inode);
3585
3586	/* mm/fadvise.c */
3587	extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
3588	int advice);
3589	extern int generic_fadvise(struct file *file, loff_t offset, loff_t len,
3590	int advice);
3591
3592	#endif /* _LINUX_FS_H */
3593