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
50struct backing_dev_info;
51struct bdi_writeback;
52struct bio;
53struct io_comp_batch;
54struct export_operations;
55struct fiemap_extent_info;
56struct hd_geometry;
57struct iovec;
58struct kiocb;
59struct kobject;
60struct pipe_inode_info;
61struct poll_table_struct;
62struct kstatfs;
63struct vm_area_struct;
64struct vfsmount;
65struct cred;
66struct swap_info_struct;
67struct seq_file;
68struct workqueue_struct;
69struct iov_iter;
70struct fscrypt_info;
71struct fscrypt_operations;
72struct fsverity_info;
73struct fsverity_operations;
74struct fs_context;
75struct fs_parameter_spec;
76struct fileattr;
77struct iomap_ops;
78
79extern void __init inode_init(void);
80extern void __init inode_init_early(void);
81extern void __init files_init(void);
82extern void __init files_maxfiles_init(void);
83
84extern unsigned long get_max_files(void);
85extern unsigned int sysctl_nr_open;
86
87typedef __kernel_rwf_t rwf_t;
88
89struct buffer_head;
90typedef int (get_block_t)(struct inode *inode, sector_t iblock,
91			struct buffer_head *bh_result, int create);
92typedef 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 */
225struct 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
298enum 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 */
306struct page;
307struct address_space;
308struct writeback_control;
309struct readahead_control;
310
311/*
312 * Write life time hint values.
313 * Stored in struct inode as u8.
314 */
315enum 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
341struct 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
351static inline bool is_sync_kiocb(struct kiocb *kiocb)
352{
353	return kiocb->ki_complete == NULL;
354}
355
356struct 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
400extern 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 */
424struct 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 */
459static inline bool mapping_tagged(struct address_space *mapping, xa_mark_t tag)
460{
461	return xa_marked(&mapping->i_pages, tag);
462}
463
464static inline void i_mmap_lock_write(struct address_space *mapping)
465{
466	down_write(&mapping->i_mmap_rwsem);
467}
468
469static inline int i_mmap_trylock_write(struct address_space *mapping)
470{
471	return down_write_trylock(&mapping->i_mmap_rwsem);
472}
473
474static inline void i_mmap_unlock_write(struct address_space *mapping)
475{
476	up_write(&mapping->i_mmap_rwsem);
477}
478
479static inline int i_mmap_trylock_read(struct address_space *mapping)
480{
481	return down_read_trylock(&mapping->i_mmap_rwsem);
482}
483
484static inline void i_mmap_lock_read(struct address_space *mapping)
485{
486	down_read(&mapping->i_mmap_rwsem);
487}
488
489static inline void i_mmap_unlock_read(struct address_space *mapping)
490{
491	up_read(&mapping->i_mmap_rwsem);
492}
493
494static inline void i_mmap_assert_locked(struct address_space *mapping)
495{
496	lockdep_assert_held(&mapping->i_mmap_rwsem);
497}
498
499static 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 */
507static 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 */
521static inline int mapping_writably_mapped(struct address_space *mapping)
522{
523	return atomic_read(&mapping->i_mmap_writable) > 0;
524}
525
526static 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
532static inline void mapping_unmap_writable(struct address_space *mapping)
533{
534	atomic_dec(&mapping->i_mmap_writable);
535}
536
537static 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
543static 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
559struct 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
568static inline struct posix_acl *
569uncached_acl_sentinel(struct task_struct *task)
570{
571	return (void *)task + 1;
572}
573
574static inline bool
575is_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
586struct 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 */
593struct 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
705struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
706
707static inline unsigned int i_blocksize(const struct inode *node)
708{
709	return (1 << node->i_blkbits);
710}
711
712static 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 */
723static 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 */
744enum 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
754static inline void inode_lock(struct inode *inode)
755{
756	down_write(&inode->i_rwsem);
757}
758
759static inline void inode_unlock(struct inode *inode)
760{
761	up_write(&inode->i_rwsem);
762}
763
764static inline void inode_lock_shared(struct inode *inode)
765{
766	down_read(&inode->i_rwsem);
767}
768
769static inline void inode_unlock_shared(struct inode *inode)
770{
771	up_read(&inode->i_rwsem);
772}
773
774static inline int inode_trylock(struct inode *inode)
775{
776	return down_write_trylock(&inode->i_rwsem);
777}
778
779static inline int inode_trylock_shared(struct inode *inode)
780{
781	return down_read_trylock(&inode->i_rwsem);
782}
783
784static inline int inode_is_locked(struct inode *inode)
785{
786	return rwsem_is_locked(&inode->i_rwsem);
787}
788
789static inline void inode_lock_nested(struct inode *inode, unsigned subclass)
790{
791	down_write_nested(&inode->i_rwsem, subclass);
792}
793
794static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass)
795{
796	down_read_nested(&inode->i_rwsem, subclass);
797}
798
799static inline void filemap_invalidate_lock(struct address_space *mapping)
800{
801	down_write(&mapping->invalidate_lock);
802}
803
804static inline void filemap_invalidate_unlock(struct address_space *mapping)
805{
806	up_write(&mapping->invalidate_lock);
807}
808
809static inline void filemap_invalidate_lock_shared(struct address_space *mapping)
810{
811	down_read(&mapping->invalidate_lock);
812}
813
814static inline int filemap_invalidate_trylock_shared(
815					struct address_space *mapping)
816{
817	return down_read_trylock(&mapping->invalidate_lock);
818}
819
820static inline void filemap_invalidate_unlock_shared(
821					struct address_space *mapping)
822{
823	up_read(&mapping->invalidate_lock);
824}
825
826void lock_two_nondirectories(struct inode *, struct inode*);
827void unlock_two_nondirectories(struct inode *, struct inode*);
828
829void filemap_invalidate_lock_two(struct address_space *mapping1,
830				 struct address_space *mapping2);
831void 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 */
845static 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 */
873static 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
890static inline unsigned iminor(const struct inode *inode)
891{
892	return MINOR(inode->i_rdev);
893}
894
895static inline unsigned imajor(const struct inode *inode)
896{
897	return MAJOR(inode->i_rdev);
898}
899
900struct 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 */
922struct 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 */
934static 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
940struct 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
981struct file_handle {
982	__u32 handle_bytes;
983	int handle_type;
984	/* file identifier */
985	unsigned char f_handle[];
986};
987
988static 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 */
1029typedef void *fl_owner_t;
1030
1031struct file_lock;
1032
1033struct file_lock_operations {
1034	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
1035	void (*fl_release_private)(struct file_lock *);
1036};
1037
1038struct 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
1052struct 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
1061struct net;
1062void locks_start_grace(struct net *, struct lock_manager *);
1063void locks_end_grace(struct lock_manager *);
1064bool locks_in_grace(struct net *);
1065bool 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 */
1087struct 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
1125struct 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
1139extern 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
1144extern int fcntl_getlk(struct file *, unsigned int, struct flock *);
1145extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
1146			struct flock *);
1147
1148#if BITS_PER_LONG == 32
1149extern int fcntl_getlk64(struct file *, unsigned int, struct flock64 *);
1150extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
1151			struct flock64 *);
1152#endif
1153
1154extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
1155extern int fcntl_getlease(struct file *filp);
1156
1157/* fs/locks.c */
1158void locks_free_lock_context(struct inode *inode);
1159void locks_free_lock(struct file_lock *fl);
1160extern void locks_init_lock(struct file_lock *);
1161extern struct file_lock * locks_alloc_lock(void);
1162extern void locks_copy_lock(struct file_lock *, struct file_lock *);
1163extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
1164extern void locks_remove_posix(struct file *, fl_owner_t);
1165extern void locks_remove_file(struct file *);
1166extern void locks_release_private(struct file_lock *);
1167extern void posix_test_lock(struct file *, struct file_lock *);
1168extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
1169extern int locks_delete_block(struct file_lock *);
1170extern int vfs_test_lock(struct file *, struct file_lock *);
1171extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
1172extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
1173extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
1174extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
1175extern void lease_get_mtime(struct inode *, struct timespec64 *time);
1176extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
1177extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
1178extern int lease_modify(struct file_lock *, int, struct list_head *);
1179
1180struct notifier_block;
1181extern int lease_register_notifier(struct notifier_block *);
1182extern void lease_unregister_notifier(struct notifier_block *);
1183
1184struct files_struct;
1185extern void show_fd_locks(struct seq_file *f,
1186			 struct file *filp, struct files_struct *files);
1187extern bool locks_owner_has_blockers(struct file_lock_context *flctx,
1188			fl_owner_t owner);
1189#else /* !CONFIG_FILE_LOCKING */
1190static inline int fcntl_getlk(struct file *file, unsigned int cmd,
1191			      struct flock __user *user)
1192{
1193	return -EINVAL;
1194}
1195
1196static 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
1203static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
1204				struct flock64 *user)
1205{
1206	return -EINVAL;
1207}
1208
1209static inline int fcntl_setlk64(unsigned int fd, struct file *file,
1210				unsigned int cmd, struct flock64 *user)
1211{
1212	return -EACCES;
1213}
1214#endif
1215static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1216{
1217	return -EINVAL;
1218}
1219
1220static inline int fcntl_getlease(struct file *filp)
1221{
1222	return F_UNLCK;
1223}
1224
1225static inline void
1226locks_free_lock_context(struct inode *inode)
1227{
1228}
1229
1230static inline void locks_init_lock(struct file_lock *fl)
1231{
1232	return;
1233}
1234
1235static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
1236{
1237	return;
1238}
1239
1240static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
1241{
1242	return;
1243}
1244
1245static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
1246{
1247	return;
1248}
1249
1250static inline void locks_remove_file(struct file *filp)
1251{
1252	return;
1253}
1254
1255static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
1256{
1257	return;
1258}
1259
1260static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
1261				  struct file_lock *conflock)
1262{
1263	return -ENOLCK;
1264}
1265
1266static inline int locks_delete_block(struct file_lock *waiter)
1267{
1268	return -ENOENT;
1269}
1270
1271static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
1272{
1273	return 0;
1274}
1275
1276static 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
1282static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
1283{
1284	return 0;
1285}
1286
1287static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
1288{
1289	return -ENOLCK;
1290}
1291
1292static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1293{
1294	return 0;
1295}
1296
1297static inline void lease_get_mtime(struct inode *inode,
1298				   struct timespec64 *time)
1299{
1300	return;
1301}
1302
1303static inline int generic_setlease(struct file *filp, long arg,
1304				    struct file_lock **flp, void **priv)
1305{
1306	return -EINVAL;
1307}
1308
1309static inline int vfs_setlease(struct file *filp, long arg,
1310			       struct file_lock **lease, void **priv)
1311{
1312	return -EINVAL;
1313}
1314
1315static inline int lease_modify(struct file_lock *fl, int arg,
1316			       struct list_head *dispose)
1317{
1318	return -EINVAL;
1319}
1320
1321struct files_struct;
1322static inline void show_fd_locks(struct seq_file *f,
1323			struct file *filp, struct files_struct *files) {}
1324static 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
1331static inline struct inode *file_inode(const struct file *f)
1332{
1333	return f->f_inode;
1334}
1335
1336static inline struct dentry *file_dentry(const struct file *file)
1337{
1338	return d_real(file->f_path.dentry, file_inode(file));
1339}
1340
1341static 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
1346struct 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: */
1358extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
1359extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
1360extern int fasync_remove_entry(struct file *, struct fasync_struct **);
1361extern struct fasync_struct *fasync_alloc(void);
1362extern void fasync_free(struct fasync_struct *);
1363
1364/* can be called from interrupts */
1365extern void kill_fasync(struct fasync_struct **, int, int);
1366
1367extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
1368extern int f_setown(struct file *filp, unsigned long arg, int force);
1369extern void f_delown(struct file *filp);
1370extern pid_t f_getown(struct file *filp);
1371extern 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 */
1434enum {
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
1445struct 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
1451struct 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
1585static 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 */
1595static inline uid_t i_uid_read(const struct inode *inode)
1596{
1597	return from_kuid(i_user_ns(inode), inode->i_uid);
1598}
1599
1600static inline gid_t i_gid_read(const struct inode *inode)
1601{
1602	return from_kgid(i_user_ns(inode), inode->i_gid);
1603}
1604
1605static 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
1610static 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 */
1626static 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 */
1640static 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 */
1657static 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 */
1675static 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 */
1695static 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 */
1709static 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 */
1726static 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 */
1744static 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 */
1761static 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 */
1775static 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 */
1792static 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
1809extern 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 */
1819static 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
1824static 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
1829static 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
1839static 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 */
1851static 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 */
1863static 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 */
1875static 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 */
1899static inline void sb_start_write(struct super_block *sb)
1900{
1901	__sb_start_write(sb, SB_FREEZE_WRITE);
1902}
1903
1904static 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 */
1928static 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 */
1946static inline void sb_start_intwrite(struct super_block *sb)
1947{
1948	__sb_start_write(sb, SB_FREEZE_FS);
1949}
1950
1951static inline bool sb_start_intwrite_trylock(struct super_block *sb)
1952{
1953	return __sb_start_write_trylock(sb, SB_FREEZE_FS);
1954}
1955
1956bool inode_owner_or_capable(struct user_namespace *mnt_userns,
1957			    const struct inode *inode);
1958
1959/*
1960 * VFS helper functions..
1961 */
1962int vfs_create(struct user_namespace *, struct inode *,
1963	       struct dentry *, umode_t, bool);
1964int vfs_mkdir(struct user_namespace *, struct inode *,
1965	      struct dentry *, umode_t);
1966int vfs_mknod(struct user_namespace *, struct inode *, struct dentry *,
1967              umode_t, dev_t);
1968int vfs_symlink(struct user_namespace *, struct inode *,
1969		struct dentry *, const char *);
1970int vfs_link(struct dentry *, struct user_namespace *, struct inode *,
1971	     struct dentry *, struct inode **);
1972int vfs_rmdir(struct user_namespace *, struct inode *, struct dentry *);
1973int 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 */
1987struct 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
1998int vfs_rename(struct renamedata *);
1999
2000static 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
2007struct dentry *vfs_tmpfile(struct user_namespace *mnt_userns,
2008			   struct dentry *dentry, umode_t mode, int open_flag);
2009
2010int vfs_mkobj(struct dentry *, umode_t,
2011		int (*f)(struct dentry *, umode_t, void *),
2012		void *);
2013
2014int vfs_fchown(struct file *file, uid_t user, gid_t group);
2015int vfs_fchmod(struct file *file, umode_t mode);
2016int vfs_utimes(const struct path *path, struct timespec64 *times);
2017
2018extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
2019
2020#ifdef CONFIG_COMPAT
2021extern 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 */
2030void inode_init_owner(struct user_namespace *mnt_userns, struct inode *inode,
2031		      const struct inode *dir, umode_t mode);
2032extern bool may_open_dev(const struct path *path);
2033umode_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 */
2042struct dir_context;
2043typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
2044			 unsigned);
2045
2046struct 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
2090struct iov_iter;
2091struct io_uring_cmd;
2092
2093struct 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
2137struct 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
2178static 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
2184static 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
2190static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
2191{
2192	return file->f_op->mmap(file, vma);
2193}
2194
2195extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
2196extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
2197extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
2198				   loff_t, size_t, unsigned int);
2199extern 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);
2202int __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);
2206int 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);
2209extern 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);
2212extern 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);
2215extern int vfs_dedupe_file_range(struct file *file,
2216				 struct file_dedupe_range *same);
2217extern 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
2222struct 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
2297static 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
2327static 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
2334static 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
2343static 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
2459extern void __mark_inode_dirty(struct inode *, int);
2460static inline void mark_inode_dirty(struct inode *inode)
2461{
2462	__mark_inode_dirty(inode, I_DIRTY);
2463}
2464
2465static 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 */
2479static 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
2485extern void inc_nlink(struct inode *inode);
2486extern void drop_nlink(struct inode *inode);
2487extern void clear_nlink(struct inode *inode);
2488extern void set_nlink(struct inode *inode, unsigned int nlink);
2489
2490static inline void inode_inc_link_count(struct inode *inode)
2491{
2492	inc_nlink(inode);
2493	mark_inode_dirty(inode);
2494}
2495
2496static inline void inode_dec_link_count(struct inode *inode)
2497{
2498	drop_nlink(inode);
2499	mark_inode_dirty(inode);
2500}
2501
2502enum file_time_flags {
2503	S_ATIME = 1,
2504	S_MTIME = 2,
2505	S_CTIME = 4,
2506	S_VERSION = 8,
2507};
2508
2509extern bool atime_needs_update(const struct path *, struct inode *);
2510extern void touch_atime(const struct path *);
2511int inode_update_time(struct inode *inode, struct timespec64 *time, int flags);
2512
2513static inline void file_accessed(struct file *file)
2514{
2515	if (!(file->f_flags & O_NOATIME))
2516		touch_atime(&file->f_path);
2517}
2518
2519extern int file_modified(struct file *file);
2520int kiocb_modified(struct kiocb *iocb);
2521
2522int sync_inode_metadata(struct inode *inode, int wait);
2523
2524struct 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
2556extern 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));
2559extern struct dentry *mount_single(struct file_system_type *fs_type,
2560	int flags, void *data,
2561	int (*fill_super)(struct super_block *, void *, int));
2562extern struct dentry *mount_nodev(struct file_system_type *fs_type,
2563	int flags, void *data,
2564	int (*fill_super)(struct super_block *, void *, int));
2565extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
2566void retire_super(struct super_block *sb);
2567void generic_shutdown_super(struct super_block *sb);
2568void kill_block_super(struct super_block *sb);
2569void kill_anon_super(struct super_block *sb);
2570void kill_litter_super(struct super_block *sb);
2571void deactivate_super(struct super_block *sb);
2572void deactivate_locked_super(struct super_block *sb);
2573int set_anon_super(struct super_block *s, void *data);
2574int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
2575int get_anon_bdev(dev_t *);
2576void free_anon_bdev(dev_t);
2577struct 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 *));
2580struct 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
2602extern int register_filesystem(struct file_system_type *);
2603extern int unregister_filesystem(struct file_system_type *);
2604extern int vfs_statfs(const struct path *, struct kstatfs *);
2605extern int user_statfs(const char __user *, struct kstatfs *);
2606extern int fd_statfs(int, struct kstatfs *);
2607extern int freeze_super(struct super_block *super);
2608extern int thaw_super(struct super_block *super);
2609extern __printf(2, 3)
2610int super_setup_bdi_name(struct super_block *sb, char *fmt, ...);
2611extern int super_setup_bdi(struct super_block *sb);
2612
2613extern int current_umask(void);
2614
2615extern void ihold(struct inode * inode);
2616extern void iput(struct inode *);
2617extern int generic_update_time(struct inode *, struct timespec64 *, int);
2618
2619/* /sys/fs */
2620extern struct kobject *fs_kobj;
2621
2622#define MAX_RW_COUNT (INT_MAX & PAGE_MASK)
2623
2624#ifdef CONFIG_FILE_LOCKING
2625static 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
2639static 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
2653static 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
2665static 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
2675static 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 */
2686static inline int break_lease(struct inode *inode, unsigned int mode)
2687{
2688	return 0;
2689}
2690
2691static inline int break_deleg(struct inode *inode, unsigned int mode)
2692{
2693	return 0;
2694}
2695
2696static inline int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
2697{
2698	return 0;
2699}
2700
2701static inline int break_deleg_wait(struct inode **delegated_inode)
2702{
2703	BUG();
2704	return 0;
2705}
2706
2707static 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 */
2715struct audit_names;
2716struct 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};
2723static_assert(offsetof(struct filename, iname) % sizeof(long) == 0);
2724
2725static 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 */
2739static inline bool is_idmapped_mnt(const struct vfsmount *mnt)
2740{
2741	return mnt_user_ns(mnt) != mnt->mnt_sb->s_user_ns;
2742}
2743
2744extern long vfs_truncate(const struct path *, loff_t);
2745int do_truncate(struct user_namespace *, struct dentry *, loff_t start,
2746		unsigned int time_attrs, struct file *filp);
2747extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
2748			loff_t len);
2749extern long do_sys_open(int dfd, const char __user *filename, int flags,
2750			umode_t mode);
2751extern struct file *file_open_name(struct filename *, int, umode_t);
2752extern struct file *filp_open(const char *, int, umode_t);
2753extern struct file *file_open_root(const struct path *,
2754				   const char *, int, umode_t);
2755static 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}
2761extern struct file * dentry_open(const struct path *, int, const struct cred *);
2762extern struct file *dentry_create(const struct path *path, int flags,
2763				  umode_t mode, const struct cred *cred);
2764extern struct file * open_with_fake_path(const struct path *, int,
2765					 struct inode*, const struct cred *);
2766static inline struct file *file_clone_open(struct file *file)
2767{
2768	return dentry_open(&file->f_path, file->f_flags, file->f_cred);
2769}
2770extern int filp_close(struct file *, fl_owner_t id);
2771
2772extern struct filename *getname_flags(const char __user *, int, int *);
2773extern struct filename *getname_uflags(const char __user *, int);
2774extern struct filename *getname(const char __user *);
2775extern struct filename *getname_kernel(const char *);
2776extern void putname(struct filename *name);
2777
2778extern int finish_open(struct file *file, struct dentry *dentry,
2779			int (*open)(struct inode *, struct file *));
2780extern int finish_no_open(struct file *file, struct dentry *dentry);
2781
2782/* fs/dcache.c */
2783extern void __init vfs_caches_init_early(void);
2784extern void __init vfs_caches_init(void);
2785
2786extern 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
2791extern struct super_block *blockdev_superblock;
2792static inline bool sb_is_blkdev_sb(struct super_block *sb)
2793{
2794	return IS_ENABLED(CONFIG_BLOCK) && sb == blockdev_superblock;
2795}
2796
2797void emergency_thaw_all(void);
2798extern int sync_filesystem(struct super_block *);
2799extern const struct file_operations def_blk_fops;
2800extern 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
2810extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
2811extern int register_chrdev_region(dev_t, unsigned, const char *);
2812extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2813			     unsigned int count, const char *name,
2814			     const struct file_operations *fops);
2815extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2816				unsigned int count, const char *name);
2817extern void unregister_chrdev_region(dev_t, unsigned);
2818extern void chrdev_show(struct seq_file *,off_t);
2819
2820static 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
2826static inline void unregister_chrdev(unsigned int major, const char *name)
2827{
2828	__unregister_chrdev(major, 0, 256, name);
2829}
2830
2831extern void init_special_inode(struct inode *, umode_t, dev_t);
2832
2833/* Invalid inode operations -- fs/bad_inode.c */
2834extern void make_bad_inode(struct inode *);
2835extern bool is_bad_inode(struct inode *);
2836
2837extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
2838						loff_t lend);
2839extern int __must_check file_check_and_advance_wb_err(struct file *file);
2840extern int __must_check file_write_and_wait_range(struct file *file,
2841						loff_t start, loff_t end);
2842
2843static inline int file_write_and_wait(struct file *file)
2844{
2845	return file_write_and_wait_range(file, 0, LLONG_MAX);
2846}
2847
2848extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
2849			   int datasync);
2850extern int vfs_fsync(struct file *file, int datasync);
2851
2852extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
2853				unsigned int flags);
2854
2855static 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 */
2866static 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
2879extern void emergency_sync(void);
2880extern void emergency_remount(void);
2881
2882#ifdef CONFIG_BLOCK
2883extern int bmap(struct inode *inode, sector_t *block);
2884#else
2885static inline int bmap(struct inode *inode,  sector_t *block)
2886{
2887	return -EINVAL;
2888}
2889#endif
2890
2891int notify_change(struct user_namespace *, struct dentry *,
2892		  struct iattr *, struct inode **);
2893int inode_permission(struct user_namespace *, struct inode *, int);
2894int generic_permission(struct user_namespace *, struct inode *, int);
2895static 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}
2900static 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}
2905int __check_sticky(struct user_namespace *mnt_userns, struct inode *dir,
2906		   struct inode *inode);
2907
2908static inline bool execute_ok(struct inode *inode)
2909{
2910	return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
2911}
2912
2913static inline bool inode_wrong_type(const struct inode *inode, umode_t mode)
2914{
2915	return (inode->i_mode ^ mode) & S_IFMT;
2916}
2917
2918static 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
2925static 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
2932static 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 */
2960static inline int get_write_access(struct inode *inode)
2961{
2962	return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
2963}
2964static 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}
2969static inline void put_write_access(struct inode * inode)
2970{
2971	atomic_dec(&inode->i_writecount);
2972}
2973static inline void allow_write_access(struct file *file)
2974{
2975	if (file)
2976		atomic_inc(&file_inode(file)->i_writecount);
2977}
2978static 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)
2984static inline void i_readcount_dec(struct inode *inode)
2985{
2986	BUG_ON(!atomic_read(&inode->i_readcount));
2987	atomic_dec(&inode->i_readcount);
2988}
2989static inline void i_readcount_inc(struct inode *inode)
2990{
2991	atomic_inc(&inode->i_readcount);
2992}
2993#else
2994static inline void i_readcount_dec(struct inode *inode)
2995{
2996	return;
2997}
2998static inline void i_readcount_inc(struct inode *inode)
2999{
3000	return;
3001}
3002#endif
3003extern int do_pipe_flags(int *, int);
3004
3005extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *);
3006ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos);
3007extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *);
3008extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *);
3009extern struct file * open_exec(const char *);
3010
3011/* fs/dcache.c -- generic fs support functions */
3012extern bool is_subdir(struct dentry *, struct dentry *);
3013extern bool path_is_under(const struct path *, const struct path *);
3014
3015extern char *file_path(struct file *, char *, int);
3016
3017#include <linux/err.h>
3018
3019/* needed for stackable file system support */
3020extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
3021
3022extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
3023
3024extern int inode_init_always(struct super_block *, struct inode *);
3025extern void inode_init_once(struct inode *);
3026extern void address_space_init_once(struct address_space *mapping);
3027extern struct inode * igrab(struct inode *);
3028extern ino_t iunique(struct super_block *, ino_t);
3029extern int inode_needs_sync(struct inode *inode);
3030extern int generic_delete_inode(struct inode *inode);
3031static inline int generic_drop_inode(struct inode *inode)
3032{
3033	return !inode->i_nlink || inode_unhashed(inode);
3034}
3035extern void d_mark_dontcache(struct inode *inode);
3036
3037extern struct inode *ilookup5_nowait(struct super_block *sb,
3038		unsigned long hashval, int (*test)(struct inode *, void *),
3039		void *data);
3040extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
3041		int (*test)(struct inode *, void *), void *data);
3042extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
3043
3044extern 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);
3048extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
3049extern struct inode * iget_locked(struct super_block *, unsigned long);
3050extern struct inode *find_inode_nowait(struct super_block *,
3051				       unsigned long,
3052				       int (*match)(struct inode *,
3053						    unsigned long, void *),
3054				       void *data);
3055extern struct inode *find_inode_rcu(struct super_block *, unsigned long,
3056				    int (*)(struct inode *, void *), void *);
3057extern struct inode *find_inode_by_ino_rcu(struct super_block *, unsigned long);
3058extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
3059extern int insert_inode_locked(struct inode *);
3060#ifdef CONFIG_DEBUG_LOCK_ALLOC
3061extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
3062#else
3063static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
3064#endif
3065extern void unlock_new_inode(struct inode *);
3066extern void discard_new_inode(struct inode *);
3067extern unsigned int get_next_ino(void);
3068extern void evict_inodes(struct super_block *sb);
3069void 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 */
3081static inline bool is_zero_ino(ino_t ino)
3082{
3083	return (u32)ino == 0;
3084}
3085
3086extern void __iget(struct inode * inode);
3087extern void iget_failed(struct inode *);
3088extern void clear_inode(struct inode *);
3089extern void __destroy_inode(struct inode *);
3090extern struct inode *new_inode_pseudo(struct super_block *sb);
3091extern struct inode *new_inode(struct super_block *sb);
3092extern void free_inode_nonrcu(struct inode *inode);
3093extern int should_remove_suid(struct dentry *);
3094extern 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 */
3100static inline void *
3101alloc_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
3106extern void __insert_inode_hash(struct inode *, unsigned long hashval);
3107static inline void insert_inode_hash(struct inode *inode)
3108{
3109	__insert_inode_hash(inode, inode->i_ino);
3110}
3111
3112extern void __remove_inode_hash(struct inode *);
3113static 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
3119extern void inode_sb_list_add(struct inode *inode);
3120extern void inode_add_lru(struct inode *inode);
3121
3122extern int sb_set_blocksize(struct super_block *, int);
3123extern int sb_min_blocksize(struct super_block *, int);
3124
3125extern int generic_file_mmap(struct file *, struct vm_area_struct *);
3126extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
3127extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
3128int generic_write_checks_count(struct kiocb *iocb, loff_t *count);
3129extern int generic_write_check_limits(struct file *file, loff_t pos,
3130		loff_t *count);
3131extern int generic_file_rw_checks(struct file *file_in, struct file *file_out);
3132ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *to,
3133		ssize_t already_read);
3134extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
3135extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
3136extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
3137extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
3138ssize_t generic_perform_write(struct kiocb *, struct iov_iter *);
3139
3140ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
3141		rwf_t flags);
3142ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
3143		rwf_t flags);
3144ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,
3145			   struct iov_iter *iter);
3146ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,
3147			    struct iov_iter *iter);
3148
3149/* fs/splice.c */
3150extern ssize_t generic_file_splice_read(struct file *, loff_t *,
3151		struct pipe_inode_info *, size_t, unsigned int);
3152extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
3153		struct file *, loff_t *, size_t, unsigned int);
3154extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
3155		struct file *out, loff_t *, size_t len, unsigned int flags);
3156extern 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
3160extern void
3161file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
3162extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
3163#define no_llseek NULL
3164extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
3165extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
3166extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
3167		int whence, loff_t maxsize, loff_t eof);
3168extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
3169		int whence, loff_t size);
3170extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
3171extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
3172int rw_verify_area(int, struct file *, const loff_t *, size_t);
3173extern int generic_file_open(struct inode * inode, struct file * filp);
3174extern int nonseekable_open(struct inode * inode, struct file * filp);
3175extern int stream_open(struct inode * inode, struct file * filp);
3176
3177#ifdef CONFIG_BLOCK
3178typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
3179			    loff_t file_offset);
3180
3181enum {
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
3189ssize_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
3195static 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
3205void 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 */
3214static 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 */
3226static 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 */
3235void dio_warn_stale_pagecache(struct file *filp);
3236
3237extern void inode_set_flags(struct inode *inode, unsigned int flags,
3238			    unsigned int mask);
3239
3240extern 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
3244extern int readlink_copy(char __user *, int, const char *);
3245extern int page_readlink(struct dentry *, char __user *, int);
3246extern const char *page_get_link(struct dentry *, struct inode *,
3247				 struct delayed_call *);
3248extern void page_put_link(void *);
3249extern int page_symlink(struct inode *inode, const char *symname, int len);
3250extern const struct inode_operations page_symlink_inode_operations;
3251extern void kfree_link(void *);
3252void generic_fillattr(struct user_namespace *, struct inode *, struct kstat *);
3253void generic_fill_statx_attr(struct inode *inode, struct kstat *stat);
3254extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
3255extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
3256void __inode_add_bytes(struct inode *inode, loff_t bytes);
3257void inode_add_bytes(struct inode *inode, loff_t bytes);
3258void __inode_sub_bytes(struct inode *inode, loff_t bytes);
3259void inode_sub_bytes(struct inode *inode, loff_t bytes);
3260static inline loff_t __inode_get_bytes(struct inode *inode)
3261{
3262	return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
3263}
3264loff_t inode_get_bytes(struct inode *inode);
3265void inode_set_bytes(struct inode *inode, loff_t bytes);
3266const char *simple_get_link(struct dentry *, struct inode *,
3267			    struct delayed_call *);
3268extern const struct inode_operations simple_symlink_inode_operations;
3269
3270extern int iterate_dir(struct file *, struct dir_context *);
3271
3272int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
3273		int flags);
3274int vfs_fstat(int fd, struct kstat *stat);
3275
3276static inline int vfs_stat(const char __user *filename, struct kstat *stat)
3277{
3278	return vfs_fstatat(AT_FDCWD, filename, stat, 0);
3279}
3280static 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
3285extern const char *vfs_get_link(struct dentry *, struct delayed_call *);
3286extern int vfs_readlink(struct dentry *, char __user *, int);
3287
3288extern struct file_system_type *get_filesystem(struct file_system_type *fs);
3289extern void put_filesystem(struct file_system_type *fs);
3290extern struct file_system_type *get_fs_type(const char *name);
3291extern struct super_block *get_super(struct block_device *);
3292extern struct super_block *get_active_super(struct block_device *bdev);
3293extern void drop_super(struct super_block *sb);
3294extern void drop_super_exclusive(struct super_block *sb);
3295extern void iterate_supers(void (*)(struct super_block *, void *), void *);
3296extern void iterate_supers_type(struct file_system_type *,
3297			        void (*)(struct super_block *, void *), void *);
3298
3299extern int dcache_dir_open(struct inode *, struct file *);
3300extern int dcache_dir_close(struct inode *, struct file *);
3301extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
3302extern int dcache_readdir(struct file *, struct dir_context *);
3303extern int simple_setattr(struct user_namespace *, struct dentry *,
3304			  struct iattr *);
3305extern int simple_getattr(struct user_namespace *, const struct path *,
3306			  struct kstat *, u32, unsigned int);
3307extern int simple_statfs(struct dentry *, struct kstatfs *);
3308extern int simple_open(struct inode *inode, struct file *file);
3309extern int simple_link(struct dentry *, struct inode *, struct dentry *);
3310extern int simple_unlink(struct inode *, struct dentry *);
3311extern int simple_rmdir(struct inode *, struct dentry *);
3312extern int simple_rename_exchange(struct inode *old_dir, struct dentry *old_dentry,
3313				  struct inode *new_dir, struct dentry *new_dentry);
3314extern int simple_rename(struct user_namespace *, struct inode *,
3315			 struct dentry *, struct inode *, struct dentry *,
3316			 unsigned int);
3317extern void simple_recursive_removal(struct dentry *,
3318                              void (*callback)(struct dentry *));
3319extern int noop_fsync(struct file *, loff_t, loff_t, int);
3320extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
3321extern int simple_empty(struct dentry *);
3322extern int simple_write_begin(struct file *file, struct address_space *mapping,
3323			loff_t pos, unsigned len,
3324			struct page **pagep, void **fsdata);
3325extern const struct address_space_operations ram_aops;
3326extern int always_delete_dentry(const struct dentry *);
3327extern struct inode *alloc_anon_inode(struct super_block *);
3328extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
3329extern const struct dentry_operations simple_dentry_operations;
3330
3331extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
3332extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
3333extern const struct file_operations simple_dir_operations;
3334extern const struct inode_operations simple_dir_inode_operations;
3335extern void make_empty_dir_inode(struct inode *inode);
3336extern bool is_empty_dir_inode(struct inode *inode);
3337struct tree_descr { const char *name; const struct file_operations *ops; int mode; };
3338struct dentry *d_alloc_name(struct dentry *, const char *);
3339extern int simple_fill_super(struct super_block *, unsigned long,
3340			     const struct tree_descr *);
3341extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
3342extern void simple_release_fs(struct vfsmount **mount, int *count);
3343
3344extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
3345			loff_t *ppos, const void *from, size_t available);
3346extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
3347		const void __user *from, size_t count);
3348
3349extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
3350extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
3351
3352extern int generic_check_addressable(unsigned, u64);
3353
3354extern void generic_set_encrypted_ci_d_ops(struct dentry *dentry);
3355
3356int may_setattr(struct user_namespace *mnt_userns, struct inode *inode,
3357		unsigned int ia_valid);
3358int setattr_prepare(struct user_namespace *, struct dentry *, struct iattr *);
3359extern int inode_newsize_ok(const struct inode *, loff_t offset);
3360void setattr_copy(struct user_namespace *, struct inode *inode,
3361		  const struct iattr *attr);
3362
3363extern int file_update_time(struct file *file);
3364
3365static 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
3370static 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
3384static 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
3398static 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
3423static 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 */
3443struct 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
3450char *simple_transaction_get(struct file *file, const char __user *buf,
3451				size_t size);
3452ssize_t simple_transaction_read(struct file *file, char __user *buf,
3453				size_t size, loff_t *pos);
3454int simple_transaction_release(struct inode *inode, struct file *file);
3455
3456void 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)		\
3475static 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}									\
3480static 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
3489static inline __printf(1, 2)
3490void __simple_attr_check_format(const char *fmt, ...)
3491{
3492	/* don't do anything, just let the compiler check the arguments; */
3493}
3494
3495int simple_attr_open(struct inode *inode, struct file *file,
3496		     int (*get)(void *, u64 *), int (*set)(void *, u64),
3497		     const char *fmt);
3498int simple_attr_release(struct inode *inode, struct file *file);
3499ssize_t simple_attr_read(struct file *file, char __user *buf,
3500			 size_t len, loff_t *ppos);
3501ssize_t simple_attr_write(struct file *file, const char __user *buf,
3502			  size_t len, loff_t *ppos);
3503
3504struct ctl_table;
3505int __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
3514static inline bool is_sxid(umode_t mode)
3515{
3516	return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
3517}
3518
3519static 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
3528static 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
3534static inline bool is_root_inode(struct inode *inode)
3535{
3536	return inode == inode->i_sb->s_root->d_inode;
3537}
3538
3539static 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}
3545static 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}
3550static 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}
3555static 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}
3569static inline bool dir_relax(struct inode *inode)
3570{
3571	inode_unlock(inode);
3572	inode_lock(inode);
3573	return !IS_DEADDIR(inode);
3574}
3575
3576static 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
3583extern bool path_noexec(const struct path *path);
3584extern void inode_nohighmem(struct inode *inode);
3585
3586/* mm/fadvise.c */
3587extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
3588		       int advice);
3589extern int generic_fadvise(struct file *file, loff_t offset, loff_t len,
3590			   int advice);
3591
3592#endif /* _LINUX_FS_H */
3593