GeezerVison

GeezerVison is showing codebrowser.dev (truncated) — fs.h source code [linux/include/linux/fs.h] - Codebrowser

1	/ SPDX-License-Identifier: GPL-2.0 /
2	#ifndef _LINUX_FS_H
3	#define _LINUX_FS_H
4
5	#include <linux/fs/super.h>
6	#include <linux/vfsdebug.h>
7	#include <linux/linkage.h>
8	#include <linux/wait_bit.h>
9	#include <linux/kdev_t.h>
10	#include <linux/dcache.h>
11	#include <linux/path.h>
12	#include <linux/stat.h>
13	#include <linux/cache.h>
14	#include <linux/list.h>
15	#include <linux/llist.h>
16	#include <linux/radix-tree.h>
17	#include <linux/xarray.h>
18	#include <linux/rbtree.h>
19	#include <linux/init.h>
20	#include <linux/pid.h>
21	#include <linux/bug.h>
22	#include <linux/mutex.h>
23	#include <linux/rwsem.h>
24	#include <linux/mm_types.h>
25	#include <linux/capability.h>
26	#include <linux/semaphore.h>
27	#include <linux/fcntl.h>
28	#include <linux/rculist_bl.h>
29	#include <linux/atomic.h>
30	#include <linux/shrinker.h>
31	#include <linux/migrate_mode.h>
32	#include <linux/uidgid.h>
33	#include <linux/lockdep.h>
34	#include <linux/percpu-rwsem.h>
35	#include <linux/workqueue.h>
36	#include <linux/delayed_call.h>
37	#include <linux/uuid.h>
38	#include <linux/errseq.h>
39	#include <linux/ioprio.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	#include <linux/maple_tree.h>
47	#include <linux/rw_hint.h>
48	#include <linux/file_ref.h>
49	#include <linux/unicode.h>
50
51	#include <asm/byteorder.h>
52	#include <uapi/linux/fs.h>
53
54	struct bdi_writeback;
55	struct bio;
56	struct io_comp_batch;
57	struct fiemap_extent_info;
58	struct hd_geometry;
59	struct iovec;
60	struct kiocb;
61	struct kobject;
62	struct pipe_inode_info;
63	struct poll_table_struct;
64	struct kstatfs;
65	struct vm_area_struct;
66	struct vfsmount;
67	struct cred;
68	struct swap_info_struct;
69	struct seq_file;
70	struct iov_iter;
71	struct fsnotify_mark_connector;
72	struct fs_context;
73	struct fs_parameter_spec;
74	struct file_kattr;
75	struct iomap_ops;
76	struct delegated_inode;
77
78	extern void __init inode_init(void);
79	extern void __init inode_init_early(void);
80	extern void __init files_init(void);
81	extern void __init files_maxfiles_init(void);
82
83	extern unsigned long get_max_files(void);
84	extern unsigned int sysctl_nr_open;
85
86	typedef __kernel_rwf_t rwf_t;
87
88	struct buffer_head;
89	typedef int (get_block_t)(struct inode *inode, sector_t iblock,
90	struct buffer_head bh_result, int* create);
91	typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
92	ssize_t bytes, void *private);
93
94	#define MAY_EXEC 0x00000001
95	#define MAY_WRITE 0x00000002
96	#define MAY_READ 0x00000004
97	#define MAY_APPEND 0x00000008
98	#define MAY_ACCESS 0x00000010
99	#define MAY_OPEN 0x00000020
100	#define MAY_CHDIR 0x00000040
101	/ called from RCU mode, don't block /
102	#define MAY_NOT_BLOCK 0x00000080
103
104	/*
105	* flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
106	* to O_WRONLY and O_RDWR via the strange trick in do_dentry_open()
107	*/
108
109	/ file is open for reading /
110	#define FMODE_READ ((__force fmode_t)(1 << 0))
111	/ file is open for writing /
112	#define FMODE_WRITE ((__force fmode_t)(1 << 1))
113	/ file is seekable /
114	#define FMODE_LSEEK ((__force fmode_t)(1 << 2))
115	/ file can be accessed using pread /
116	#define FMODE_PREAD ((__force fmode_t)(1 << 3))
117	/ file can be accessed using pwrite /
118	#define FMODE_PWRITE ((__force fmode_t)(1 << 4))
119	/ File is opened for execution with sys_execve / sys_uselib /
120	#define FMODE_EXEC ((__force fmode_t)(1 << 5))
121	/ File writes are restricted (block device specific) /
122	#define FMODE_WRITE_RESTRICTED ((__force fmode_t)(1 << 6))
123	/ File supports atomic writes /
124	#define FMODE_CAN_ATOMIC_WRITE ((__force fmode_t)(1 << 7))
125
126	/ FMODE_* bit 8 /
127
128	/ 32bit hashes as llseek() offset (for directories) /
129	#define FMODE_32BITHASH ((__force fmode_t)(1 << 9))
130	/ 64bit hashes as llseek() offset (for directories) /
131	#define FMODE_64BITHASH ((__force fmode_t)(1 << 10))
132
133	/*
134	* Don't update ctime and mtime.
135	*
136	* Currently a special hack for the XFS open_by_handle ioctl, but we'll
137	* hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
138	*/
139	#define FMODE_NOCMTIME ((__force fmode_t)(1 << 11))
140
141	/ Expect random access pattern /
142	#define FMODE_RANDOM ((__force fmode_t)(1 << 12))
143
144	/ Supports IOCB_HAS_METADATA /
145	#define FMODE_HAS_METADATA ((__force fmode_t)(1 << 13))
146
147	/ File is opened with O_PATH; almost nothing can be done with it /
148	#define FMODE_PATH ((__force fmode_t)(1 << 14))
149
150	/ File needs atomic accesses to f_pos /
151	#define FMODE_ATOMIC_POS ((__force fmode_t)(1 << 15))
152	/ Write access to underlying fs /
153	#define FMODE_WRITER ((__force fmode_t)(1 << 16))
154	/ Has read method(s) /
155	#define FMODE_CAN_READ ((__force fmode_t)(1 << 17))
156	/ Has write method(s) /
157	#define FMODE_CAN_WRITE ((__force fmode_t)(1 << 18))
158
159	#define FMODE_OPENED ((__force fmode_t)(1 << 19))
160	#define FMODE_CREATED ((__force fmode_t)(1 << 20))
161
162	/ File is stream-like /
163	#define FMODE_STREAM ((__force fmode_t)(1 << 21))
164
165	/ File supports DIRECT IO /
166	#define FMODE_CAN_ODIRECT ((__force fmode_t)(1 << 22))
167
168	#define FMODE_NOREUSE ((__force fmode_t)(1 << 23))
169
170	/ File is embedded in backing_file object /
171	#define FMODE_BACKING ((__force fmode_t)(1 << 24))
172
173	/*
174	* Together with FMODE_NONOTIFY_PERM defines which fsnotify events shouldn't be
175	* generated (see below)
176	*/
177	#define FMODE_NONOTIFY ((__force fmode_t)(1 << 25))
178
179	/*
180	* Together with FMODE_NONOTIFY defines which fsnotify events shouldn't be
181	* generated (see below)
182	*/
183	#define FMODE_NONOTIFY_PERM ((__force fmode_t)(1 << 26))
184
185	/ File is capable of returning -EAGAIN if I/O will block /
186	#define FMODE_NOWAIT ((__force fmode_t)(1 << 27))
187
188	/ File represents mount that needs unmounting /
189	#define FMODE_NEED_UNMOUNT ((__force fmode_t)(1 << 28))
190
191	/ File does not contribute to nr_files count /
192	#define FMODE_NOACCOUNT ((__force fmode_t)(1 << 29))
193
194	/*
195	* The two FMODE_NONOTIFY* define which fsnotify events should not be generated
196	* for an open file. These are the possible values of
197	* (f->f_mode & FMODE_FSNOTIFY_MASK) and their meaning:
198	*
199	* FMODE_NONOTIFY - suppress all (incl. non-permission) events.
200	* FMODE_NONOTIFY_PERM - suppress permission (incl. pre-content) events.
201	* FMODE_NONOTIFY \| FMODE_NONOTIFY_PERM - suppress only FAN_ACCESS_PERM.
202	*/
203	#define FMODE_FSNOTIFY_MASK \
204	(FMODE_NONOTIFY \| FMODE_NONOTIFY_PERM)
205
206	#define FMODE_FSNOTIFY_NONE(mode) \
207	((mode & FMODE_FSNOTIFY_MASK) == FMODE_NONOTIFY)
208	#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
209	#define FMODE_FSNOTIFY_HSM(mode) \
210	((mode & FMODE_FSNOTIFY_MASK) == 0 \|\| \
211	(mode & FMODE_FSNOTIFY_MASK) == (FMODE_NONOTIFY \| FMODE_NONOTIFY_PERM))
212	#define FMODE_FSNOTIFY_ACCESS_PERM(mode) \
213	((mode & FMODE_FSNOTIFY_MASK) == 0)
214	#else
215	#define FMODE_FSNOTIFY_ACCESS_PERM(mode) 0
216	#define FMODE_FSNOTIFY_HSM(mode) 0
217	#endif
218
219	/*
220	* Attribute flags. These should be or-ed together to figure out what
221	* has been changed!
222	*/
223	#define ATTR_MODE (1 << 0)
224	#define ATTR_UID (1 << 1)
225	#define ATTR_GID (1 << 2)
226	#define ATTR_SIZE (1 << 3)
227	#define ATTR_ATIME (1 << 4)
228	#define ATTR_MTIME (1 << 5)
229	#define ATTR_CTIME (1 << 6)
230	#define ATTR_ATIME_SET (1 << 7)
231	#define ATTR_MTIME_SET (1 << 8)
232	#define ATTR_FORCE (1 << 9) /* Not a change, but a change it */
233	#define ATTR_CTIME_SET (1 << 10)
234	#define ATTR_KILL_SUID (1 << 11)
235	#define ATTR_KILL_SGID (1 << 12)
236	#define ATTR_FILE (1 << 13)
237	#define ATTR_KILL_PRIV (1 << 14)
238	#define ATTR_OPEN (1 << 15) /* Truncating from open(O_TRUNC) */
239	#define ATTR_TIMES_SET (1 << 16)
240	#define ATTR_TOUCH (1 << 17)
241	#define ATTR_DELEG (1 << 18) /* Delegated attrs. Don't break write delegations */
242
243	/*
244	* Whiteout is represented by a char device. The following constants define the
245	* mode and device number to use.
246	*/
247	#define WHITEOUT_MODE 0
248	#define WHITEOUT_DEV 0
249
250	/*
251	* This is the Inode Attributes structure, used for notify_change(). It
252	* uses the above definitions as flags, to know which values have changed.
253	* Also, in this manner, a Filesystem can look at only the values it cares
254	* about. Basically, these are the attributes that the VFS layer can
255	* request to change from the FS layer.
256	*
257	* Derek Atkins <[email protected]> 94-10-20
258	*/
259	struct iattr {
260	unsigned int ia_valid;
261	umode_t ia_mode;
262	/*
263	* The two anonymous unions wrap structures with the same member.
264	*
265	* Filesystems raising FS_ALLOW_IDMAP need to use ia_vfs{g,u}id which
266	* are a dedicated type requiring the filesystem to use the dedicated
267	* helpers. Other filesystem can continue to use ia_{g,u}id until they
268	* have been ported.
269	*
270	* They always contain the same value. In other words FS_ALLOW_IDMAP
271	* pass down the same value on idmapped mounts as they would on regular
272	* mounts.
273	*/
274	union {
275	kuid_t ia_uid;
276	vfsuid_t ia_vfsuid;
277	};
278	union {
279	kgid_t ia_gid;
280	vfsgid_t ia_vfsgid;
281	};
282	loff_t ia_size;
283	struct timespec64 ia_atime;
284	struct timespec64 ia_mtime;
285	struct timespec64 ia_ctime;
286
287	/*
288	* Not an attribute, but an auxiliary info for filesystems wanting to
289	* implement an ftruncate() like method. NOTE: filesystem should
290	* check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
291	*/
292	struct file *ia_file;
293	};
294
295	/*
296	* Maximum number of layers of fs stack. Needs to be limited to
297	* prevent kernel stack overflow
298	*/
299	#define FILESYSTEM_MAX_STACK_DEPTH 2
300
301	/**
302	* enum positive_aop_returns - aop return codes with specific semantics
303	*
304	* @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
305	* completed, that the page is still locked, and
306	* should be considered active. The VM uses this hint
307	* to return the page to the active list -- it won't
308	* be a candidate for writeback again in the near
309	* future. Other callers must be careful to unlock
310	* the page if they get this return. Returned by
311	* writepage();
312	*
313	* @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
314	* unlocked it and the page might have been truncated.
315	* The caller should back up to acquiring a new page and
316	* trying again. The aop will be taking reasonable
317	* precautions not to livelock. If the caller held a page
318	* reference, it should drop it before retrying. Returned
319	* by read_folio().
320	*
321	* address_space_operation functions return these large constants to indicate
322	* special semantics to the caller. These are much larger than the bytes in a
323	* page to allow for functions that return the number of bytes operated on in a
324	* given page.
325	*/
326
327	enum positive_aop_returns {
328	AOP_WRITEPAGE_ACTIVATE = `0x80000`,
329	AOP_TRUNCATED_PAGE = `0x80001`,
330	};
331
332	/*
333	* oh the beauties of C type declarations.
334	*/
335	struct page;
336	struct address_space;
337	struct writeback_control;
338	struct readahead_control;
339
340	/ Match RWF_* bits to IOCB bits /
341	#define IOCB_HIPRI (__force int) RWF_HIPRI
342	#define IOCB_DSYNC (__force int) RWF_DSYNC
343	#define IOCB_SYNC (__force int) RWF_SYNC
344	#define IOCB_NOWAIT (__force int) RWF_NOWAIT
345	#define IOCB_APPEND (__force int) RWF_APPEND
346	#define IOCB_ATOMIC (__force int) RWF_ATOMIC
347	#define IOCB_DONTCACHE (__force int) RWF_DONTCACHE
348	#define IOCB_NOSIGNAL (__force int) RWF_NOSIGNAL
349
350	/ non-RWF related bits - start at 16 /
351	#define IOCB_EVENTFD (1 << 16)
352	#define IOCB_DIRECT (1 << 17)
353	#define IOCB_WRITE (1 << 18)
354	/ iocb->ki_waitq is valid /
355	#define IOCB_WAITQ (1 << 19)
356	#define IOCB_NOIO (1 << 20)
357	/ can use bio alloc cache /
358	#define IOCB_ALLOC_CACHE (1 << 21)
359	/ kiocb is a read or write operation submitted by fs/aio.c. /
360	#define IOCB_AIO_RW (1 << 22)
361	#define IOCB_HAS_METADATA (1 << 23)
362
363	/ for use in trace events /
364	#define TRACE_IOCB_STRINGS \
365	{ IOCB_HIPRI, "HIPRI" }, \
366	{ IOCB_DSYNC, "DSYNC" }, \
367	{ IOCB_SYNC, "SYNC" }, \
368	{ IOCB_NOWAIT, "NOWAIT" }, \
369	{ IOCB_APPEND, "APPEND" }, \
370	{ IOCB_ATOMIC, "ATOMIC" }, \
371	{ IOCB_DONTCACHE, "DONTCACHE" }, \
372	{ IOCB_EVENTFD, "EVENTFD"}, \
373	{ IOCB_DIRECT, "DIRECT" }, \
374	{ IOCB_WRITE, "WRITE" }, \
375	{ IOCB_WAITQ, "WAITQ" }, \
376	{ IOCB_NOIO, "NOIO" }, \
377	{ IOCB_ALLOC_CACHE, "ALLOC_CACHE" }, \
378	{ IOCB_AIO_RW, "AIO_RW" }, \
379	{ IOCB_HAS_METADATA, "AIO_HAS_METADATA" }
380
381	struct kiocb {
382	struct file *ki_filp;
383	loff_t ki_pos;
384	void (ki_complete)(struct* kiocb iocb, long* ret);
385	void *private;
386	int ki_flags;
387	u16 ki_ioprio; / See linux/ioprio.h /
388	u8 ki_write_stream;
389
390	/*
391	* Only used for async buffered reads, where it denotes the page
392	* waitqueue associated with completing the read.
393	* Valid IFF IOCB_WAITQ is set.
394	*/
395	struct wait_page_queue *ki_waitq;
396	};
397
398	static inline bool is_sync_kiocb(struct kiocb *kiocb)
399	{
400	return kiocb->ki_complete == NULL;
401	}
402
403	struct address_space_operations {
404	int (read_folio)(struct* file , struct* folio *);
405
406	/ Write back some dirty pages from this mapping. /
407	int (writepages)(struct* address_space , struct* writeback_control *);
408
409	/ Mark a folio dirty. Return true if this dirtied it /
410	bool (dirty_folio)(struct* address_space , struct* folio *);
411
412	void (readahead)(struct* readahead_control *);
413
414	int (write_begin)(const* struct kiocb , struct* address_space *mapping,
415	loff_t pos, unsigned len,
416	struct folio *foliop, void* **fsdata);
417	int (write_end)(const* struct kiocb , struct* address_space *mapping,
418	loff_t pos, unsigned len, unsigned copied,
419	struct folio folio, void* *fsdata);
420
421	/ Unfortunately this kludge is needed for FIBMAP. Don't use it /
422	sector_t (bmap)(struct* address_space *, sector_t);
423	void (invalidate_folio) (struct* folio *, size_t offset, size_t len);
424	bool (release_folio)(struct* folio *, gfp_t);
425	void (free_folio)(struct* folio *folio);
426	ssize_t (direct_IO)(struct* kiocb , struct* iov_iter *iter);
427	/*
428	* migrate the contents of a folio to the specified target. If
429	* migrate_mode is MIGRATE_ASYNC, it must not block.
430	*/
431	int (migrate_folio)(struct* address_space , struct* folio *dst,
432	struct folio src, enum* migrate_mode);
433	int (launder_folio)(struct* folio *);
434	bool (is_partially_uptodate) (struct* folio *, size_t from,
435	size_t count);
436	void (is_dirty_writeback) (struct* folio , bool dirty, bool *wb);
437	int (error_remove_folio)(struct* address_space , struct* folio *);
438
439	/ swapfile support /
440	int (swap_activate)(struct* swap_info_struct sis, struct* file *file,
441	sector_t *span);
442	void (swap_deactivate)(struct* file *file);
443	int (swap_rw)(struct* kiocb iocb, struct* iov_iter *iter);
444	};
445
446	extern const struct address_space_operations empty_aops;
447
448	/**
449	* struct address_space - Contents of a cacheable, mappable object.
450	* @host: Owner, either the inode or the block_device.
451	* @i_pages: Cached pages.
452	* @invalidate_lock: Guards coherency between page cache contents and
453	* file offset->disk block mappings in the filesystem during invalidates.
454	* It is also used to block modification of page cache contents through
455	* memory mappings.
456	* @gfp_mask: Memory allocation flags to use for allocating pages.
457	* @i_mmap_writable: Number of VM_SHARED, VM_MAYWRITE mappings.
458	* @nr_thps: Number of THPs in the pagecache (non-shmem only).
459	* @i_mmap: Tree of private and shared mappings.
460	* @i_mmap_rwsem: Protects @i_mmap and @i_mmap_writable.
461	* @nrpages: Number of page entries, protected by the i_pages lock.
462	* @writeback_index: Writeback starts here.
463	* @a_ops: Methods.
464	* @flags: Error bits and flags (AS_*).
465	* @wb_err: The most recent error which has occurred.
466	* @i_private_lock: For use by the owner of the address_space.
467	* @i_private_list: For use by the owner of the address_space.
468	* @i_private_data: For use by the owner of the address_space.
469	*/
470	struct address_space {
471	struct inode *host;
472	struct xarray i_pages;
473	struct rw_semaphore invalidate_lock;
474	gfp_t gfp_mask;
475	atomic_t i_mmap_writable;
476	#ifdef CONFIG_READ_ONLY_THP_FOR_FS
477	/ number of thp, only for non-shmem files /
478	atomic_t nr_thps;
479	#endif
480	struct rb_root_cached i_mmap;
481	unsigned long nrpages;
482	pgoff_t writeback_index;
483	const struct address_space_operations *a_ops;
484	unsigned long flags;
485	errseq_t wb_err;
486	spinlock_t i_private_lock;
487	struct list_head i_private_list;
488	struct rw_semaphore i_mmap_rwsem;
489	void * i_private_data;
490	} __attribute__((aligned(sizeof(long)))) __randomize_layout;
491	/*
492	* On most architectures that alignment is already the case; but
493	* must be enforced here for CRIS, to let the least significant bit
494	* of struct folio's "mapping" pointer be used for FOLIO_MAPPING_ANON.
495	*/
496
497	/ XArray tags, for tagging dirty and writeback pages in the pagecache. /
498	#define PAGECACHE_TAG_DIRTY XA_MARK_0
499	#define PAGECACHE_TAG_WRITEBACK XA_MARK_1
500	#define PAGECACHE_TAG_TOWRITE XA_MARK_2
501
502	/*
503	* Returns true if any of the pages in the mapping are marked with the tag.
504	*/
505	static inline bool mapping_tagged(const struct address_space *mapping, xa_mark_t tag)
506	{
507	return xa_marked(xa: &mapping->i_pages, mark: tag);
508	}
509
510	static inline void i_mmap_lock_write(struct address_space *mapping)
511	{
512	down_write(sem: &mapping->i_mmap_rwsem);
513	}
514
515	static inline int i_mmap_trylock_write(struct address_space *mapping)
516	{
517	return down_write_trylock(sem: &mapping->i_mmap_rwsem);
518	}
519
520	static inline void i_mmap_unlock_write(struct address_space *mapping)
521	{
522	up_write(sem: &mapping->i_mmap_rwsem);
523	}
524
525	static inline int i_mmap_trylock_read(struct address_space *mapping)
526	{
527	return down_read_trylock(sem: &mapping->i_mmap_rwsem);
528	}
529
530	static inline void i_mmap_lock_read(struct address_space *mapping)
531	{
532	down_read(sem: &mapping->i_mmap_rwsem);
533	}
534
535	static inline void i_mmap_unlock_read(struct address_space *mapping)
536	{
537	up_read(sem: &mapping->i_mmap_rwsem);
538	}
539
540	static inline void i_mmap_assert_locked(struct address_space *mapping)
541	{
542	lockdep_assert_held(&mapping->i_mmap_rwsem);
543	}
544
545	static inline void i_mmap_assert_write_locked(struct address_space *mapping)
546	{
547	lockdep_assert_held_write(&mapping->i_mmap_rwsem);
548	}
549
550	/*
551	* Might pages of this file be mapped into userspace?
552	*/
553	static inline int mapping_mapped(const struct address_space *mapping)
554	{
555	return !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root);
556	}
557
558	/*
559	* Might pages of this file have been modified in userspace?
560	* Note that i_mmap_writable counts all VM_SHARED, VM_MAYWRITE vmas: do_mmap
561	* marks vma as VM_SHARED if it is shared, and the file was opened for
562	* writing i.e. vma may be mprotected writable even if now readonly.
563	*
564	* If i_mmap_writable is negative, no new writable mappings are allowed. You
565	* can only deny writable mappings, if none exists right now.
566	*/
567	static inline int mapping_writably_mapped(const struct address_space *mapping)
568	{
569	return atomic_read(v: &mapping->i_mmap_writable) > `0`;
570	}
571
572	static inline int mapping_map_writable(struct address_space *mapping)
573	{
574	return atomic_inc_unless_negative(v: &mapping->i_mmap_writable) ?
575	`0` : -EPERM;
576	}
577
578	static inline void mapping_unmap_writable(struct address_space *mapping)
579	{
580	atomic_dec(v: &mapping->i_mmap_writable);
581	}
582
583	static inline int mapping_deny_writable(struct address_space *mapping)
584	{
585	return atomic_dec_unless_positive(v: &mapping->i_mmap_writable) ?
586	`0` : -EBUSY;
587	}
588
589	static inline void mapping_allow_writable(struct address_space *mapping)
590	{
591	atomic_inc(v: &mapping->i_mmap_writable);
592	}
593
594	/*
595	* Use sequence counter to get consistent i_size on 32-bit processors.
596	*/
597	#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
598	#include <linux/seqlock.h>
599	#define __NEED_I_SIZE_ORDERED
600	#define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
601	#else
602	#define i_size_ordered_init(inode) do { } while (0)
603	#endif
604
605	struct posix_acl;
606	#define ACL_NOT_CACHED ((void *)(-1))
607	/*
608	* ACL_DONT_CACHE is for stacked filesystems, that rely on underlying fs to
609	* cache the ACL. This also means that ->get_inode_acl() can be called in RCU
610	* mode with the LOOKUP_RCU flag.
611	*/
612	#define ACL_DONT_CACHE ((void *)(-3))
613
614	static inline struct posix_acl *
615	uncached_acl_sentinel(struct task_struct *task)
616	{
617	return (void *)task + `1`;
618	}
619
620	static inline bool
621	is_uncached_acl(struct posix_acl *acl)
622	{
623	return (long)acl & `1`;
624	}
625
626	#define IOP_FASTPERM 0x0001
627	#define IOP_LOOKUP 0x0002
628	#define IOP_NOFOLLOW 0x0004
629	#define IOP_XATTR 0x0008
630	#define IOP_DEFAULT_READLINK 0x0010
631	#define IOP_MGTIME 0x0020
632	#define IOP_CACHED_LINK 0x0040
633	#define IOP_FASTPERM_MAY_EXEC 0x0080
634
635	/*
636	* Inode state bits. Protected by inode->i_lock
637	*
638	* Four bits determine the dirty state of the inode: I_DIRTY_SYNC,
639	* I_DIRTY_DATASYNC, I_DIRTY_PAGES, and I_DIRTY_TIME.
640	*
641	* Four bits define the lifetime of an inode. Initially, inodes are I_NEW,
642	* until that flag is cleared. I_WILL_FREE, I_FREEING and I_CLEAR are set at
643	* various stages of removing an inode.
644	*
645	* Two bits are used for locking and completion notification, I_NEW and I_SYNC.
646	*
647	* I_DIRTY_SYNC Inode is dirty, but doesn't have to be written on
648	* fdatasync() (unless I_DIRTY_DATASYNC is also set).
649	* Timestamp updates are the usual cause.
650	* I_DIRTY_DATASYNC Data-related inode changes pending. We keep track of
651	* these changes separately from I_DIRTY_SYNC so that we
652	* don't have to write inode on fdatasync() when only
653	* e.g. the timestamps have changed.
654	* I_DIRTY_PAGES Inode has dirty pages. Inode itself may be clean.
655	* I_DIRTY_TIME The inode itself has dirty timestamps, and the
656	* lazytime mount option is enabled. We keep track of this
657	* separately from I_DIRTY_SYNC in order to implement
658	* lazytime. This gets cleared if I_DIRTY_INODE
659	* (I_DIRTY_SYNC and/or I_DIRTY_DATASYNC) gets set. But
660	* I_DIRTY_TIME can still be set if I_DIRTY_SYNC is already
661	* in place because writeback might already be in progress
662	* and we don't want to lose the time update
663	* I_NEW Serves as both a mutex and completion notification.
664	* New inodes set I_NEW. If two processes both create
665	* the same inode, one of them will release its inode and
666	* wait for I_NEW to be released before returning.
667	* Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
668	* also cause waiting on I_NEW, without I_NEW actually
669	* being set. find_inode() uses this to prevent returning
670	* nearly-dead inodes.
671	* I_WILL_FREE Must be set when calling write_inode_now() if i_count
672	* is zero. I_FREEING must be set when I_WILL_FREE is
673	* cleared.
674	* I_FREEING Set when inode is about to be freed but still has dirty
675	* pages or buffers attached or the inode itself is still
676	* dirty.
677	* I_CLEAR Added by clear_inode(). In this state the inode is
678	* clean and can be destroyed. Inode keeps I_FREEING.
679	*
680	* Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
681	* prohibited for many purposes. iget() must wait for
682	* the inode to be completely released, then create it
683	* anew. Other functions will just ignore such inodes,
684	* if appropriate. I_NEW is used for waiting.
685	*
686	* I_SYNC Writeback of inode is running. The bit is set during
687	* data writeback, and cleared with a wakeup on the bit
688	* address once it is done. The bit is also used to pin
689	* the inode in memory for flusher thread.
690	*
691	* I_REFERENCED Marks the inode as recently references on the LRU list.
692	*
693	* I_WB_SWITCH Cgroup bdi_writeback switching in progress. Used to
694	* synchronize competing switching instances and to tell
695	* wb stat updates to grab the i_pages lock. See
696	* inode_switch_wbs_work_fn() for details.
697	*
698	* I_OVL_INUSE Used by overlayfs to get exclusive ownership on upper
699	* and work dirs among overlayfs mounts.
700	*
701	* I_CREATING New object's inode in the middle of setting up.
702	*
703	* I_DONTCACHE Evict inode as soon as it is not used anymore.
704	*
705	* I_SYNC_QUEUED Inode is queued in b_io or b_more_io writeback lists.
706	* Used to detect that mark_inode_dirty() should not move
707	* inode between dirty lists.
708	*
709	* I_PINNING_FSCACHE_WB Inode is pinning an fscache object for writeback.
710	*
711	* I_LRU_ISOLATING Inode is pinned being isolated from LRU without holding
712	* i_count.
713	*
714	* Q: What is the difference between I_WILL_FREE and I_FREEING?
715	*
716	* __I_{SYNC,NEW,LRU_ISOLATING} are used to derive unique addresses to wait
717	* upon. There's one free address left.
718	*/
719
720	enum inode_state_bits {
721	__I_NEW = `0U`,
722	__I_SYNC = `1U`,
723	__I_LRU_ISOLATING = `2U`
724	/ reserved wait address bit 3 /
725	};
726
727	enum inode_state_flags_enum {
728	I_NEW = (`1U` << __I_NEW),
729	I_SYNC = (`1U` << __I_SYNC),
730	I_LRU_ISOLATING = (`1U` << __I_LRU_ISOLATING),
731	/ reserved flag bit 3 /
732	I_DIRTY_SYNC = (`1U` << `4`),
733	I_DIRTY_DATASYNC = (`1U` << `5`),
734	I_DIRTY_PAGES = (`1U` << `6`),
735	I_WILL_FREE = (`1U` << `7`),
736	I_FREEING = (`1U` << `8`),
737	I_CLEAR = (`1U` << `9`),
738	I_REFERENCED = (`1U` << `10`),
739	I_LINKABLE = (`1U` << `11`),
740	I_DIRTY_TIME = (`1U` << `12`),
741	I_WB_SWITCH = (`1U` << `13`),
742	I_OVL_INUSE = (`1U` << `14`),
743	I_CREATING = (`1U` << `15`),
744	I_DONTCACHE = (`1U` << `16`),
745	I_SYNC_QUEUED = (`1U` << `17`),
746	I_PINNING_NETFS_WB = (`1U` << `18`)
747	};
748
749	#define I_DIRTY_INODE (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)
750	#define I_DIRTY (I_DIRTY_INODE \| I_DIRTY_PAGES)
751	#define I_DIRTY_ALL (I_DIRTY \| I_DIRTY_TIME)
752
753	/*
754	* Use inode_state_read() & friends to access.
755	*/
756	struct inode_state_flags {
757	enum inode_state_flags_enum __state;
758	};
759
760	/*
761	* Keep mostly read-only and often accessed (especially for
762	* the RCU path lookup and 'stat' data) fields at the beginning
763	* of the 'struct inode'
764	*/
765	struct inode {
766	umode_t i_mode;
767	unsigned short i_opflags;
768	unsigned int i_flags;
769	#ifdef CONFIG_FS_POSIX_ACL
770	struct posix_acl *i_acl;
771	struct posix_acl *i_default_acl;
772	#endif
773	kuid_t i_uid;
774	kgid_t i_gid;
775
776	const struct inode_operations *i_op;
777	struct super_block *i_sb;
778	struct address_space *i_mapping;
779
780	#ifdef CONFIG_SECURITY
781	void *i_security;
782	#endif
783
784	/ Stat data, not accessed from path walking /
785	unsigned long i_ino;
786	/*
787	* Filesystems may only read i_nlink directly. They shall use the
788	* following functions for modification:
789	*
790	* (set\|clear\|inc\|drop)_nlink
791	* inode_(inc\|dec)_link_count
792	*/
793	union {
794	const unsigned int i_nlink;
795	unsigned int __i_nlink;
796	};
797	dev_t i_rdev;
798	loff_t i_size;
799	time64_t i_atime_sec;
800	time64_t i_mtime_sec;
801	time64_t i_ctime_sec;
802	u32 i_atime_nsec;
803	u32 i_mtime_nsec;
804	u32 i_ctime_nsec;
805	u32 i_generation;
806	spinlock_t i_lock; / i_blocks, i_bytes, maybe i_size /
807	unsigned short i_bytes;
808	u8 i_blkbits;
809	enum rw_hint i_write_hint;
810	blkcnt_t i_blocks;
811
812	#ifdef __NEED_I_SIZE_ORDERED
813	seqcount_t i_size_seqcount;
814	#endif
815
816	/ Misc /
817	struct inode_state_flags i_state;
818	/ 32-bit hole /
819	struct rw_semaphore i_rwsem;
820
821	unsigned long dirtied_when; / jiffies of first dirtying /
822	unsigned long dirtied_time_when;
823
824	struct hlist_node i_hash;
825	struct list_head i_io_list; / backing dev IO list /
826	#ifdef CONFIG_CGROUP_WRITEBACK
827	struct bdi_writeback i_wb; /* the associated cgroup wb /
828
829	/ foreign inode detection, see wbc_detach_inode() /
830	int i_wb_frn_winner;
831	u16 i_wb_frn_avg_time;
832	u16 i_wb_frn_history;
833	#endif
834	struct list_head i_lru; / inode LRU list /
835	struct list_head i_sb_list;
836	struct list_head i_wb_list; / backing dev writeback list /
837	union {
838	struct hlist_head i_dentry;
839	struct rcu_head i_rcu;
840	};
841	atomic64_t i_version;
842	atomic64_t i_sequence; / see futex /
843	atomic_t i_count;
844	atomic_t i_dio_count;
845	atomic_t i_writecount;
846	#if defined(CONFIG_IMA) \|\| defined(CONFIG_FILE_LOCKING)
847	atomic_t i_readcount; / struct files open RO /
848	#endif
849	union {
850	const struct file_operations i_fop; /* former ->i_op->default_file_ops /
851	void (free_inode)(struct* inode *);
852	};
853	struct file_lock_context *i_flctx;
854	struct address_space i_data;
855	union {
856	struct list_head i_devices;
857	int i_linklen;
858	};
859	union {
860	struct pipe_inode_info *i_pipe;
861	struct cdev *i_cdev;
862	char *i_link;
863	unsigned i_dir_seq;
864	};
865
866
867	#ifdef CONFIG_FSNOTIFY
868	__u32 i_fsnotify_mask; / all events this inode cares about /
869	/ 32-bit hole reserved for expanding i_fsnotify_mask /
870	struct fsnotify_mark_connector __rcu *i_fsnotify_marks;
871	#endif
872
873	void i_private; /* fs or device private pointer /
874	} __randomize_layout;
875
876	/*
877	* i_state handling
878	*
879	* We hide all of it behind helpers so that we can validate consumers.
880	*/
881	static inline enum inode_state_flags_enum inode_state_read_once(struct inode *inode)
882	{
883	return READ_ONCE(inode->i_state.__state);
884	}
885
886	static inline enum inode_state_flags_enum inode_state_read(struct inode *inode)
887	{
888	lockdep_assert_held(&inode->i_lock);
889	return inode->i_state.__state;
890	}
891
892	static inline void inode_state_set_raw(struct inode *inode,
893	enum inode_state_flags_enum flags)
894	{
895	WRITE_ONCE(inode->i_state.__state, inode->i_state.__state \| flags);
896	}
897
898	static inline void inode_state_set(struct inode *inode,
899	enum inode_state_flags_enum flags)
900	{
901	lockdep_assert_held(&inode->i_lock);
902	inode_state_set_raw(inode, flags);
903	}
904
905	static inline void inode_state_clear_raw(struct inode *inode,
906	enum inode_state_flags_enum flags)
907	{
908	WRITE_ONCE(inode->i_state.__state, inode->i_state.__state & ~flags);
909	}
910
911	static inline void inode_state_clear(struct inode *inode,
912	enum inode_state_flags_enum flags)
913	{
914	lockdep_assert_held(&inode->i_lock);
915	inode_state_clear_raw(inode, flags);
916	}
917
918	static inline void inode_state_assign_raw(struct inode *inode,
919	enum inode_state_flags_enum flags)
920	{
921	WRITE_ONCE(inode->i_state.__state, flags);
922	}
923
924	static inline void inode_state_assign(struct inode *inode,
925	enum inode_state_flags_enum flags)
926	{
927	lockdep_assert_held(&inode->i_lock);
928	inode_state_assign_raw(inode, flags);
929	}
930
931	static inline void inode_state_replace_raw(struct inode *inode,
932	enum inode_state_flags_enum clearflags,
933	enum inode_state_flags_enum setflags)
934	{
935	enum inode_state_flags_enum flags;
936	flags = inode->i_state.__state;
937	flags &= ~clearflags;
938	flags \|= setflags;
939	inode_state_assign_raw(inode, flags);
940	}
941
942	static inline void inode_state_replace(struct inode *inode,
943	enum inode_state_flags_enum clearflags,
944	enum inode_state_flags_enum setflags)
945	{
946	lockdep_assert_held(&inode->i_lock);
947	inode_state_replace_raw(inode, clearflags, setflags);
948	}
949
950	static inline void inode_set_cached_link(struct inode inode, char* link, int* linklen)
951	{
952	VFS_WARN_ON_INODE(strlen(link) != linklen, inode);
953	VFS_WARN_ON_INODE(inode->i_opflags & IOP_CACHED_LINK, inode);
954	inode->i_link = link;
955	inode->i_linklen = linklen;
956	inode->i_opflags \|= IOP_CACHED_LINK;
957	}
958
959	/*
960	* Get bit address from inode->i_state to use with wait_var_event()
961	* infrastructre.
962	*/
963	#define inode_state_wait_address(inode, bit) ((char *)&(inode)->i_state + (bit))
964
965	struct wait_queue_head inode_bit_waitqueue(struct* wait_bit_queue_entry *wqe,
966	struct inode *inode, u32 bit);
967
968	static inline void inode_wake_up_bit(struct inode *inode, u32 bit)
969	{
970	/ Caller is responsible for correct memory barriers. /
971	wake_up_var(inode_state_wait_address(inode, bit));
972	}
973
974	struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
975
976	static inline unsigned int i_blocksize(const struct inode *node)
977	{
978	return (`1` << node->i_blkbits);
979	}
980
981	static inline int inode_unhashed(struct inode *inode)
982	{
983	return hlist_unhashed(h: &inode->i_hash);
984	}
985
986	/*
987	* __mark_inode_dirty expects inodes to be hashed. Since we don't
988	* want special inodes in the fileset inode space, we make them
989	* appear hashed, but do not put on any lists. hlist_del()
990	* will work fine and require no locking.
991	*/
992	static inline void inode_fake_hash(struct inode *inode)
993	{
994	hlist_add_fake(n: &inode->i_hash);
995	}
996
997	void wait_on_new_inode(struct inode *inode);
998
999	/*
1000	* inode->i_rwsem nesting subclasses for the lock validator:
1001	*
1002	* 0: the object of the current VFS operation
1003	* 1: parent
1004	* 2: child/target
1005	* 3: xattr
1006	* 4: second non-directory
1007	* 5: second parent (when locking independent directories in rename)
1008	*
1009	* I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two
1010	* non-directories at once.
1011	*
1012	* The locking order between these classes is
1013	* parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory
1014	*/
1015	enum inode_i_mutex_lock_class
1016	{
1017	I_MUTEX_NORMAL,
1018	I_MUTEX_PARENT,
1019	I_MUTEX_CHILD,
1020	I_MUTEX_XATTR,
1021	I_MUTEX_NONDIR2,
1022	I_MUTEX_PARENT2,
1023	};
1024
1025	static inline void inode_lock(struct inode *inode)
1026	{
1027	down_write(sem: &inode->i_rwsem);
1028	}
1029
1030	static inline __must_check int inode_lock_killable(struct inode *inode)
1031	{
1032	return down_write_killable(sem: &inode->i_rwsem);
1033	}
1034
1035	static inline void inode_unlock(struct inode *inode)
1036	{
1037	up_write(sem: &inode->i_rwsem);
1038	}
1039
1040	static inline void inode_lock_shared(struct inode *inode)
1041	{
1042	down_read(sem: &inode->i_rwsem);
1043	}
1044
1045	static inline __must_check int inode_lock_shared_killable(struct inode *inode)
1046	{
1047	return down_read_killable(sem: &inode->i_rwsem);
1048	}
1049
1050	static inline void inode_unlock_shared(struct inode *inode)
1051	{
1052	up_read(sem: &inode->i_rwsem);
1053	}
1054
1055	static inline int inode_trylock(struct inode *inode)
1056	{
1057	return down_write_trylock(sem: &inode->i_rwsem);
1058	}
1059
1060	static inline int inode_trylock_shared(struct inode *inode)
1061	{
1062	return down_read_trylock(sem: &inode->i_rwsem);
1063	}
1064
1065	static inline int inode_is_locked(struct inode *inode)
1066	{
1067	return rwsem_is_locked(sem: &inode->i_rwsem);
1068	}
1069
1070	static inline void inode_lock_nested(struct inode inode, unsigned* subclass)
1071	{
1072	down_write_nested(sem: &inode->i_rwsem, subclass);
1073	}
1074
1075	static inline void inode_lock_shared_nested(struct inode inode, unsigned* subclass)
1076	{
1077	down_read_nested(sem: &inode->i_rwsem, subclass);
1078	}
1079
1080	static inline void filemap_invalidate_lock(struct address_space *mapping)
1081	{
1082	down_write(sem: &mapping->invalidate_lock);
1083	}
1084
1085	static inline void filemap_invalidate_unlock(struct address_space *mapping)
1086	{
1087	up_write(sem: &mapping->invalidate_lock);
1088	}
1089
1090	static inline void filemap_invalidate_lock_shared(struct address_space *mapping)
1091	{
1092	down_read(sem: &mapping->invalidate_lock);
1093	}
1094
1095	static inline int filemap_invalidate_trylock_shared(
1096	struct address_space *mapping)
1097	{
1098	return down_read_trylock(sem: &mapping->invalidate_lock);
1099	}
1100
1101	static inline void filemap_invalidate_unlock_shared(
1102	struct address_space *mapping)
1103	{
1104	up_read(sem: &mapping->invalidate_lock);
1105	}
1106
1107	void lock_two_nondirectories(struct inode , struct* inode*);
1108	void unlock_two_nondirectories(struct inode , struct* inode*);
1109
1110	void filemap_invalidate_lock_two(struct address_space *mapping1,
1111	struct address_space *mapping2);
1112	void filemap_invalidate_unlock_two(struct address_space *mapping1,
1113	struct address_space *mapping2);
1114
1115
1116	/*
1117	* NOTE: in a 32bit arch with a preemptable kernel and
1118	* an UP compile the i_size_read/write must be atomic
1119	* with respect to the local cpu (unlike with preempt disabled),
1120	* but they don't need to be atomic with respect to other cpus like in
1121	* true SMP (so they need either to either locally disable irq around
1122	* the read or for example on x86 they can be still implemented as a
1123	* cmpxchg8b without the need of the lock prefix). For SMP compiles
1124	* and 64bit archs it makes no difference if preempt is enabled or not.
1125	*/
1126	static inline loff_t i_size_read(const struct inode *inode)
1127	{
1128	#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
1129	loff_t i_size;
1130	unsigned int seq;
1131
1132	do {
1133	seq = read_seqcount_begin(&inode->i_size_seqcount);
1134	i_size = inode->i_size;
1135	} while (read_seqcount_retry(&inode->i_size_seqcount, seq));
1136	return i_size;
1137	#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
1138	loff_t i_size;
1139
1140	preempt_disable();
1141	i_size = inode->i_size;
1142	preempt_enable();
1143	return i_size;
1144	#else
1145	/ Pairs with smp_store_release() in i_size_write() /
1146	return smp_load_acquire(&inode->i_size);
1147	#endif
1148	}
1149
1150	/*
1151	* NOTE: unlike i_size_read(), i_size_write() does need locking around it
1152	* (normally i_rwsem), otherwise on 32bit/SMP an update of i_size_seqcount
1153	* can be lost, resulting in subsequent i_size_read() calls spinning forever.
1154	*/
1155	static inline void i_size_write(struct inode *inode, loff_t i_size)
1156	{
1157	#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
1158	preempt_disable();
1159	write_seqcount_begin(&inode->i_size_seqcount);
1160	inode->i_size = i_size;
1161	write_seqcount_end(&inode->i_size_seqcount);
1162	preempt_enable();
1163	#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
1164	preempt_disable();
1165	inode->i_size = i_size;
1166	preempt_enable();
1167	#else
1168	/*
1169	* Pairs with smp_load_acquire() in i_size_read() to ensure
1170	* changes related to inode size (such as page contents) are
1171	* visible before we see the changed inode size.
1172	*/
1173	smp_store_release(&inode->i_size, i_size);
1174	#endif
1175	}
1176
1177	static inline unsigned iminor(const struct inode *inode)
1178	{
1179	return MINOR(inode->i_rdev);
1180	}
1181
1182	static inline unsigned imajor(const struct inode *inode)
1183	{
1184	return MAJOR(inode->i_rdev);
1185	}
1186
1187	struct fown_struct {
1188	struct file file; /* backpointer for security modules /
1189	rwlock_t lock; / protects pid, uid, euid fields /
1190	struct pid pid; /* pid or -pgrp where SIGIO should be sent /
1191	enum pid_type pid_type; / Kind of process group SIGIO should be sent to /
1192	kuid_t uid, euid; / uid/euid of process setting the owner /
1193	int signum; / posix.1b rt signal to be delivered on IO /
1194	};
1195
1196	/**
1197	* struct file_ra_state - Track a file's readahead state.
1198	* @start: Where the most recent readahead started.
1199	* @size: Number of pages read in the most recent readahead.
1200	* @async_size: Numer of pages that were/are not needed immediately
1201	* and so were/are genuinely "ahead". Start next readahead when
1202	* the first of these pages is accessed.
1203	* @ra_pages: Maximum size of a readahead request, copied from the bdi.
1204	* @order: Preferred folio order used for most recent readahead.
1205	* @mmap_miss: How many mmap accesses missed in the page cache.
1206	* @prev_pos: The last byte in the most recent read request.
1207	*
1208	* When this structure is passed to ->readahead(), the "most recent"
1209	* readahead means the current readahead.
1210	*/
1211	struct file_ra_state {
1212	pgoff_t start;
1213	unsigned int size;
1214	unsigned int async_size;
1215	unsigned int ra_pages;
1216	unsigned short order;
1217	unsigned short mmap_miss;
1218	loff_t prev_pos;
1219	};
1220
1221	/*
1222	* Check if @index falls in the readahead windows.
1223	*/
1224	static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
1225	{
1226	return (index >= ra->start &&
1227	index < ra->start + ra->size);
1228	}
1229
1230	/**
1231	* struct file - Represents a file
1232	* @f_lock: Protects f_ep, f_flags. Must not be taken from IRQ context.
1233	* @f_mode: FMODE_* flags often used in hotpaths
1234	* @f_op: file operations
1235	* @f_mapping: Contents of a cacheable, mappable object.
1236	* @private_data: filesystem or driver specific data
1237	* @f_inode: cached inode
1238	* @f_flags: file flags
1239	* @f_iocb_flags: iocb flags
1240	* @f_cred: stashed credentials of creator/opener
1241	* @f_owner: file owner
1242	* @f_path: path of the file
1243	* @__f_path: writable alias for @f_path; ONLY for core VFS and only before
1244	* the file gets open
1245	* @f_pos_lock: lock protecting file position
1246	* @f_pipe: specific to pipes
1247	* @f_pos: file position
1248	* @f_security: LSM security context of this file
1249	* @f_wb_err: writeback error
1250	* @f_sb_err: per sb writeback errors
1251	* @f_ep: link of all epoll hooks for this file
1252	* @f_task_work: task work entry point
1253	* @f_llist: work queue entrypoint
1254	* @f_ra: file's readahead state
1255	* @f_freeptr: Pointer used by SLAB_TYPESAFE_BY_RCU file cache (don't touch.)
1256	* @f_ref: reference count
1257	*/
1258	struct file {
1259	spinlock_t f_lock;
1260	fmode_t f_mode;
1261	const struct file_operations *f_op;
1262	struct address_space *f_mapping;
1263	void *private_data;
1264	struct inode *f_inode;
1265	unsigned int f_flags;
1266	unsigned int f_iocb_flags;
1267	const struct cred *f_cred;
1268	struct fown_struct *f_owner;
1269	/ --- cacheline 1 boundary (64 bytes) --- /
1270	union {
1271	const struct path f_path;
1272	struct path __f_path;
1273	};
1274	union {
1275	/ regular files (with FMODE_ATOMIC_POS) and directories /
1276	struct mutex f_pos_lock;
1277	/ pipes /
1278	u64 f_pipe;
1279	};
1280	loff_t f_pos;
1281	#ifdef CONFIG_SECURITY
1282	void *f_security;
1283	#endif
1284	/ --- cacheline 2 boundary (128 bytes) --- /
1285	errseq_t f_wb_err;
1286	errseq_t f_sb_err;
1287	#ifdef CONFIG_EPOLL
1288	struct hlist_head *f_ep;
1289	#endif
1290	union {
1291	struct callback_head f_task_work;
1292	struct llist_node f_llist;
1293	struct file_ra_state f_ra;
1294	freeptr_t f_freeptr;
1295	};
1296	file_ref_t f_ref;
1297	/ --- cacheline 3 boundary (192 bytes) --- /
1298	} __randomize_layout
1299	__attribute__((aligned(`4`))); / lest something weird decides that 2 is OK /
1300
1301	struct file_handle {
1302	__u32 handle_bytes;
1303	int handle_type;
1304	/ file identifier /
1305	unsigned char f_handle[] __counted_by(handle_bytes);
1306	};
1307
1308	static inline struct file get_file(struct* file *f)
1309	{
1310	file_ref_inc(ref: &f->f_ref);
1311	return f;
1312	}
1313
1314	struct file get_file_rcu(struct* file __rcu **f);
1315	struct file get_file_active(struct* file **f);
1316
1317	#define file_count(f) file_ref_read(&(f)->f_ref)
1318
1319	#define MAX_NON_LFS ((1UL<<31) - 1)
1320
1321	/ Page cache limit. The filesystems should put that into their s_maxbytes*
1322	limits, otherwise bad things can happen in VM. /*
1323	#if BITS_PER_LONG==32
1324	#define MAX_LFS_FILESIZE ((loff_t)ULONG_MAX << PAGE_SHIFT)
1325	#elif BITS_PER_LONG==64
1326	#define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX)
1327	#endif
1328
1329	/ legacy typedef, should eventually be removed /
1330	typedef void *fl_owner_t;
1331
1332	struct file_lock;
1333	struct file_lease;
1334
1335	/ The following constant reflects the upper bound of the file/locking space /
1336	#ifndef OFFSET_MAX
1337	#define OFFSET_MAX type_max(loff_t)
1338	#define OFFT_OFFSET_MAX type_max(off_t)
1339	#endif
1340
1341	int file_f_owner_allocate(struct file *file);
1342	static inline struct fown_struct file_f_owner(const* struct file *file)
1343	{
1344	return READ_ONCE(file->f_owner);
1345	}
1346
1347	extern void send_sigio(struct fown_struct fown, int* fd, int band);
1348
1349	static inline struct inode file_inode(const* struct file *f)
1350	{
1351	return f->f_inode;
1352	}
1353
1354	/*
1355	* file_dentry() is a relic from the days that overlayfs was using files with a
1356	* "fake" path, meaning, f_path on overlayfs and f_inode on underlying fs.
1357	* In those days, file_dentry() was needed to get the underlying fs dentry that
1358	* matches f_inode.
1359	* Files with "fake" path should not exist nowadays, so use an assertion to make
1360	* sure that file_dentry() was not papering over filesystem bugs.
1361	*/
1362	static inline struct dentry file_dentry(const* struct file *file)
1363	{
1364	struct dentry *dentry = file->f_path.dentry;
1365
1366	WARN_ON_ONCE(d_inode(dentry) != file_inode(file));
1367	return dentry;
1368	}
1369
1370	struct fasync_struct {
1371	rwlock_t fa_lock;
1372	int magic;
1373	int fa_fd;
1374	struct fasync_struct fa_next; /* singly linked list /
1375	struct file *fa_file;
1376	struct rcu_head fa_rcu;
1377	};
1378
1379	#define FASYNC_MAGIC 0x4601
1380
1381	/ SMP safe fasync helpers: /
1382	extern int fasync_helper(int, struct file , int, struct* fasync_struct **);
1383	extern struct fasync_struct fasync_insert_entry(int, struct* file , struct* fasync_struct , struct** fasync_struct *);
1384	extern int fasync_remove_entry(struct file , struct* fasync_struct **);
1385	extern struct fasync_struct fasync_alloc(void*);
1386	extern void fasync_free(struct fasync_struct *);
1387
1388	/ can be called from interrupts /
1389	extern void kill_fasync(struct fasync_struct *, int, int*);
1390
1391	extern void __f_setown(struct file filp, struct* pid , enum* pid_type, int force);
1392	extern int f_setown(struct file filp, int* who, int force);
1393	extern void f_delown(struct file *filp);
1394	extern pid_t f_getown(struct file *filp);
1395	extern int send_sigurg(struct file *file);
1396
1397	/*
1398	* Umount options
1399	*/
1400
1401	#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
1402	#define MNT_DETACH 0x00000002 /* Just detach from the tree */
1403	#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
1404	#define UMOUNT_NOFOLLOW 0x00000008 /* Don't follow symlink on umount */
1405	#define UMOUNT_UNUSED 0x80000000 /* Flag guaranteed to be unused */
1406
1407	static inline struct user_namespace i_user_ns(const* struct inode *inode)
1408	{
1409	return inode->i_sb->s_user_ns;
1410	}
1411
1412	/ Helper functions so that in most cases filesystems will*
1413	* not need to deal directly with kuid_t and kgid_t and can
1414	* instead deal with the raw numeric values that are stored
1415	* in the filesystem.
1416	*/
1417	static inline uid_t i_uid_read(const struct inode *inode)
1418	{
1419	return from_kuid(to: i_user_ns(inode), uid: inode->i_uid);
1420	}
1421
1422	static inline gid_t i_gid_read(const struct inode *inode)
1423	{
1424	return from_kgid(to: i_user_ns(inode), gid: inode->i_gid);
1425	}
1426
1427	static inline void i_uid_write(struct inode *inode, uid_t uid)
1428	{
1429	inode->i_uid = make_kuid(from: i_user_ns(inode), uid);
1430	}
1431
1432	static inline void i_gid_write(struct inode *inode, gid_t gid)
1433	{
1434	inode->i_gid = make_kgid(from: i_user_ns(inode), gid);
1435	}
1436
1437	/**
1438	* i_uid_into_vfsuid - map an inode's i_uid down according to an idmapping
1439	* @idmap: idmap of the mount the inode was found from
1440	* @inode: inode to map
1441	*
1442	* Return: whe inode's i_uid mapped down according to @idmap.
1443	* If the inode's i_uid has no mapping INVALID_VFSUID is returned.
1444	*/
1445	static inline vfsuid_t i_uid_into_vfsuid(struct mnt_idmap *idmap,
1446	const struct inode *inode)
1447	{
1448	return make_vfsuid(idmap, fs_userns: i_user_ns(inode), kuid: inode->i_uid);
1449	}
1450
1451	/**
1452	* i_uid_needs_update - check whether inode's i_uid needs to be updated
1453	* @idmap: idmap of the mount the inode was found from
1454	* @attr: the new attributes of @inode
1455	* @inode: the inode to update
1456	*
1457	* Check whether the $inode's i_uid field needs to be updated taking idmapped
1458	* mounts into account if the filesystem supports it.
1459	*
1460	* Return: true if @inode's i_uid field needs to be updated, false if not.
1461	*/
1462	static inline bool i_uid_needs_update(struct mnt_idmap *idmap,
1463	const struct iattr *attr,
1464	const struct inode *inode)
1465	{
1466	return ((attr->ia_valid & ATTR_UID) &&
1467	!vfsuid_eq(left: attr->ia_vfsuid,
1468	right: i_uid_into_vfsuid(idmap, inode)));
1469	}
1470
1471	/**
1472	* i_uid_update - update @inode's i_uid field
1473	* @idmap: idmap of the mount the inode was found from
1474	* @attr: the new attributes of @inode
1475	* @inode: the inode to update
1476	*
1477	* Safely update @inode's i_uid field translating the vfsuid of any idmapped
1478	* mount into the filesystem kuid.
1479	*/
1480	static inline void i_uid_update(struct mnt_idmap *idmap,
1481	const struct iattr *attr,
1482	struct inode *inode)
1483	{
1484	if (attr->ia_valid & ATTR_UID)
1485	inode->i_uid = from_vfsuid(idmap, fs_userns: i_user_ns(inode),
1486	vfsuid: attr->ia_vfsuid);
1487	}
1488
1489	/**
1490	* i_gid_into_vfsgid - map an inode's i_gid down according to an idmapping
1491	* @idmap: idmap of the mount the inode was found from
1492	* @inode: inode to map
1493	*
1494	* Return: the inode's i_gid mapped down according to @idmap.
1495	* If the inode's i_gid has no mapping INVALID_VFSGID is returned.
1496	*/
1497	static inline vfsgid_t i_gid_into_vfsgid(struct mnt_idmap *idmap,
1498	const struct inode *inode)
1499	{
1500	return make_vfsgid(idmap, fs_userns: i_user_ns(inode), kgid: inode->i_gid);
1501	}
1502
1503	/**
1504	* i_gid_needs_update - check whether inode's i_gid needs to be updated
1505	* @idmap: idmap of the mount the inode was found from
1506	* @attr: the new attributes of @inode
1507	* @inode: the inode to update
1508	*
1509	* Check whether the $inode's i_gid field needs to be updated taking idmapped
1510	* mounts into account if the filesystem supports it.
1511	*
1512	* Return: true if @inode's i_gid field needs to be updated, false if not.
1513	*/
1514	static inline bool i_gid_needs_update(struct mnt_idmap *idmap,
1515	const struct iattr *attr,
1516	const struct inode *inode)
1517	{
1518	return ((attr->ia_valid & ATTR_GID) &&
1519	!vfsgid_eq(left: attr->ia_vfsgid,
1520	right: i_gid_into_vfsgid(idmap, inode)));
1521	}
1522
1523	/**
1524	* i_gid_update - update @inode's i_gid field
1525	* @idmap: idmap of the mount the inode was found from
1526	* @attr: the new attributes of @inode
1527	* @inode: the inode to update
1528	*
1529	* Safely update @inode's i_gid field translating the vfsgid of any idmapped
1530	* mount into the filesystem kgid.
1531	*/
1532	static inline void i_gid_update(struct mnt_idmap *idmap,
1533	const struct iattr *attr,
1534	struct inode *inode)
1535	{
1536	if (attr->ia_valid & ATTR_GID)
1537	inode->i_gid = from_vfsgid(idmap, fs_userns: i_user_ns(inode),
1538	vfsgid: attr->ia_vfsgid);
1539	}
1540
1541	/**
1542	* inode_fsuid_set - initialize inode's i_uid field with callers fsuid
1543	* @inode: inode to initialize
1544	* @idmap: idmap of the mount the inode was found from
1545	*
1546	* Initialize the i_uid field of @inode. If the inode was found/created via
1547	* an idmapped mount map the caller's fsuid according to @idmap.
1548	*/
1549	static inline void inode_fsuid_set(struct inode *inode,
1550	struct mnt_idmap *idmap)
1551	{
1552	inode->i_uid = mapped_fsuid(idmap, fs_userns: i_user_ns(inode));
1553	}
1554
1555	/**
1556	* inode_fsgid_set - initialize inode's i_gid field with callers fsgid
1557	* @inode: inode to initialize
1558	* @idmap: idmap of the mount the inode was found from
1559	*
1560	* Initialize the i_gid field of @inode. If the inode was found/created via
1561	* an idmapped mount map the caller's fsgid according to @idmap.
1562	*/
1563	static inline void inode_fsgid_set(struct inode *inode,
1564	struct mnt_idmap *idmap)
1565	{
1566	inode->i_gid = mapped_fsgid(idmap, fs_userns: i_user_ns(inode));
1567	}
1568
1569	/**
1570	* fsuidgid_has_mapping() - check whether caller's fsuid/fsgid is mapped
1571	* @sb: the superblock we want a mapping in
1572	* @idmap: idmap of the relevant mount
1573	*
1574	* Check whether the caller's fsuid and fsgid have a valid mapping in the
1575	* s_user_ns of the superblock @sb. If the caller is on an idmapped mount map
1576	* the caller's fsuid and fsgid according to the @idmap first.
1577	*
1578	* Return: true if fsuid and fsgid is mapped, false if not.
1579	*/
1580	static inline bool fsuidgid_has_mapping(struct super_block *sb,
1581	struct mnt_idmap *idmap)
1582	{
1583	struct user_namespace *fs_userns = sb->s_user_ns;
1584	kuid_t kuid;
1585	kgid_t kgid;
1586
1587	kuid = mapped_fsuid(idmap, fs_userns);
1588	if (!uid_valid(uid: kuid))
1589	return false;
1590	kgid = mapped_fsgid(idmap, fs_userns);
1591	if (!gid_valid(gid: kgid))
1592	return false;
1593	return kuid_has_mapping(ns: fs_userns, uid: kuid) &&
1594	kgid_has_mapping(ns: fs_userns, gid: kgid);
1595	}
1596
1597	struct timespec64 current_time(struct inode *inode);
1598	struct timespec64 inode_set_ctime_current(struct inode *inode);
1599	struct timespec64 inode_set_ctime_deleg(struct inode *inode,
1600	struct timespec64 update);
1601
1602	static inline time64_t inode_get_atime_sec(const struct inode *inode)
1603	{
1604	return inode->i_atime_sec;
1605	}
1606
1607	static inline long inode_get_atime_nsec(const struct inode *inode)
1608	{
1609	return inode->i_atime_nsec;
1610	}
1611
1612	static inline struct timespec64 inode_get_atime(const struct inode *inode)
1613	{
1614	struct timespec64 ts = { .tv_sec = inode_get_atime_sec(inode),
1615	.tv_nsec = inode_get_atime_nsec(inode) };
1616
1617	return ts;
1618	}
1619
1620	static inline struct timespec64 inode_set_atime_to_ts(struct inode *inode,
1621	struct timespec64 ts)
1622	{
1623	inode->i_atime_sec = ts.tv_sec;
1624	inode->i_atime_nsec = ts.tv_nsec;
1625	return ts;
1626	}
1627
1628	static inline struct timespec64 inode_set_atime(struct inode *inode,
1629	time64_t sec, long nsec)
1630	{
1631	struct timespec64 ts = { .tv_sec = sec,
1632	.tv_nsec = nsec };
1633
1634	return inode_set_atime_to_ts(inode, ts);
1635	}
1636
1637	static inline time64_t inode_get_mtime_sec(const struct inode *inode)
1638	{
1639	return inode->i_mtime_sec;
1640	}
1641
1642	static inline long inode_get_mtime_nsec(const struct inode *inode)
1643	{
1644	return inode->i_mtime_nsec;
1645	}
1646
1647	static inline struct timespec64 inode_get_mtime(const struct inode *inode)
1648	{
1649	struct timespec64 ts = { .tv_sec = inode_get_mtime_sec(inode),
1650	.tv_nsec = inode_get_mtime_nsec(inode) };
1651	return ts;
1652	}
1653
1654	static inline struct timespec64 inode_set_mtime_to_ts(struct inode *inode,
1655	struct timespec64 ts)
1656	{
1657	inode->i_mtime_sec = ts.tv_sec;
1658	inode->i_mtime_nsec = ts.tv_nsec;
1659	return ts;
1660	}
1661
1662	static inline struct timespec64 inode_set_mtime(struct inode *inode,
1663	time64_t sec, long nsec)
1664	{
1665	struct timespec64 ts = { .tv_sec = sec,
1666	.tv_nsec = nsec };
1667	return inode_set_mtime_to_ts(inode, ts);
1668	}
1669
1670	/*
1671	* Multigrain timestamps
1672	*
1673	* Conditionally use fine-grained ctime and mtime timestamps when there
1674	* are users actively observing them via getattr. The primary use-case
1675	* for this is NFS clients that use the ctime to distinguish between
1676	* different states of the file, and that are often fooled by multiple
1677	* operations that occur in the same coarse-grained timer tick.
1678	*/
1679	#define I_CTIME_QUERIED ((u32)BIT(31))
1680
1681	static inline time64_t inode_get_ctime_sec(const struct inode *inode)
1682	{
1683	return inode->i_ctime_sec;
1684	}
1685
1686	static inline long inode_get_ctime_nsec(const struct inode *inode)
1687	{
1688	return inode->i_ctime_nsec & ~I_CTIME_QUERIED;
1689	}
1690
1691	static inline struct timespec64 inode_get_ctime(const struct inode *inode)
1692	{
1693	struct timespec64 ts = { .tv_sec = inode_get_ctime_sec(inode),
1694	.tv_nsec = inode_get_ctime_nsec(inode) };
1695
1696	return ts;
1697	}
1698
1699	struct timespec64 inode_set_ctime_to_ts(struct inode inode, struct* timespec64 ts);
1700
1701	/**
1702	* inode_set_ctime - set the ctime in the inode
1703	* @inode: inode in which to set the ctime
1704	* @sec: tv_sec value to set
1705	* @nsec: tv_nsec value to set
1706	*
1707	* Set the ctime in @inode to { @sec, @nsec }
1708	*/
1709	static inline struct timespec64 inode_set_ctime(struct inode *inode,
1710	time64_t sec, long nsec)
1711	{
1712	struct timespec64 ts = { .tv_sec = sec,
1713	.tv_nsec = nsec };
1714
1715	return inode_set_ctime_to_ts(inode, ts);
1716	}
1717
1718	struct timespec64 simple_inode_init_ts(struct inode *inode);
1719
1720	/*
1721	* Snapshotting support.
1722	*/
1723
1724	/**
1725	* file_write_started - check if SB_FREEZE_WRITE is held
1726	* @file: the file we write to
1727	*
1728	* May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN.
1729	* May be false positive with !S_ISREG, because file_start_write() has
1730	* no effect on !S_ISREG.
1731	*/
1732	static inline bool file_write_started(const struct file *file)
1733	{
1734	if (!S_ISREG(file_inode(file)->i_mode))
1735	return true;
1736	return sb_write_started(sb: file_inode(f: file)->i_sb);
1737	}
1738
1739	/**
1740	* file_write_not_started - check if SB_FREEZE_WRITE is not held
1741	* @file: the file we write to
1742	*
1743	* May be false positive with !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN.
1744	* May be false positive with !S_ISREG, because file_start_write() has
1745	* no effect on !S_ISREG.
1746	*/
1747	static inline bool file_write_not_started(const struct file *file)
1748	{
1749	if (!S_ISREG(file_inode(file)->i_mode))
1750	return true;
1751	return sb_write_not_started(sb: file_inode(f: file)->i_sb);
1752	}
1753
1754	bool inode_owner_or_capable(struct mnt_idmap *idmap,
1755	const struct inode *inode);
1756
1757	/*
1758	* VFS helper functions..
1759	*/
1760	int vfs_create(struct mnt_idmap , struct* dentry *, umode_t,
1761	struct delegated_inode *);
1762	struct dentry vfs_mkdir(struct* mnt_idmap , struct* inode *,
1763	struct dentry , umode_t, struct* delegated_inode *);
1764	int vfs_mknod(struct mnt_idmap , struct* inode , struct* dentry *,
1765	umode_t, dev_t, struct delegated_inode *);
1766	int vfs_symlink(struct mnt_idmap , struct* inode *,
1767	struct dentry , const* char , struct* delegated_inode *);
1768	int vfs_link(struct dentry , struct* mnt_idmap , struct* inode *,
1769	struct dentry , struct* delegated_inode *);
1770	int vfs_rmdir(struct mnt_idmap , struct* inode , struct* dentry *,
1771	struct delegated_inode *);
1772	int vfs_unlink(struct mnt_idmap , struct* inode , struct* dentry *,
1773	struct delegated_inode *);
1774
1775	/**
1776	* struct renamedata - contains all information required for renaming
1777	* @mnt_idmap: idmap of the mount in which the rename is happening.
1778	* @old_parent: parent of source
1779	* @old_dentry: source
1780	* @new_parent: parent of destination
1781	* @new_dentry: destination
1782	* @delegated_inode: returns an inode needing a delegation break
1783	* @flags: rename flags
1784	*/
1785	struct renamedata {
1786	struct mnt_idmap *mnt_idmap;
1787	struct dentry *old_parent;
1788	struct dentry *old_dentry;
1789	struct dentry *new_parent;
1790	struct dentry *new_dentry;
1791	struct delegated_inode *delegated_inode;
1792	unsigned int flags;
1793	} __randomize_layout;
1794
1795	int vfs_rename(struct renamedata *);
1796
1797	static inline int vfs_whiteout(struct mnt_idmap *idmap,
1798	struct inode dir, struct* dentry *dentry)
1799	{
1800	return vfs_mknod(idmap, dir, dentry, S_IFCHR \| WHITEOUT_MODE,
1801	WHITEOUT_DEV, NULL);
1802	}
1803
1804	struct file kernel_tmpfile_open(struct* mnt_idmap *idmap,
1805	const struct path *parentpath,
1806	umode_t mode, int open_flag,
1807	const struct cred *cred);
1808	struct file kernel_file_open(const* struct path path, int* flags,
1809	const struct cred *cred);
1810
1811	int vfs_mkobj(struct dentry *, umode_t,
1812	int (f)(struct* dentry , umode_t, void* *),
1813	void *);
1814
1815	int vfs_fchown(struct file *file, uid_t user, gid_t group);
1816	int vfs_fchmod(struct file *file, umode_t mode);
1817	int vfs_utimes(const struct path path, struct* timespec64 *times);
1818
1819	#ifdef CONFIG_COMPAT
1820	extern long compat_ptr_ioctl(struct file file, unsigned* int cmd,
1821	unsigned long arg);
1822	#else
1823	#define compat_ptr_ioctl NULL
1824	#endif
1825
1826	/*
1827	* VFS file helper functions.
1828	*/
1829	void inode_init_owner(struct mnt_idmap idmap, struct* inode *inode,
1830	const struct inode *dir, umode_t mode);
1831	extern bool may_open_dev(const struct path *path);
1832	umode_t mode_strip_sgid(struct mnt_idmap *idmap,
1833	const struct inode *dir, umode_t mode);
1834	bool in_group_or_capable(struct mnt_idmap *idmap,
1835	const struct inode *inode, vfsgid_t vfsgid);
1836
1837	/*
1838	* This is the "filldir" function type, used by readdir() to let
1839	* the kernel specify what kind of dirent layout it wants to have.
1840	* This allows the kernel to read directories into kernel space or
1841	* to have different dirent layouts depending on the binary type.
1842	* Return 'true' to keep going and 'false' if there are no more entries.
1843	*/
1844	struct dir_context;
1845	typedef bool (filldir_t)(struct* dir_context , const* char , int*, loff_t, u64,
1846	unsigned);
1847
1848	struct dir_context {
1849	filldir_t actor;
1850	loff_t pos;
1851	/*
1852	* Filesystems MUST NOT MODIFY count, but may use as a hint:
1853	* 0 unknown
1854	* > 0 space in buffer (assume at least one entry)
1855	* INT_MAX unlimited
1856	*/
1857	int count;
1858	/ @actor supports these flags in d_type high bits /
1859	unsigned int dt_flags_mask;
1860	};
1861
1862	/ If OR-ed with d_type, pending signals are not checked /
1863	#define FILLDIR_FLAG_NOINTR 0x1000
1864
1865	/*
1866	* These flags let !MMU mmap() govern direct device mapping vs immediate
1867	* copying more easily for MAP_PRIVATE, especially for ROM filesystems.
1868	*
1869	* NOMMU_MAP_COPY: Copy can be mapped (MAP_PRIVATE)
1870	* NOMMU_MAP_DIRECT: Can be mapped directly (MAP_SHARED)
1871	* NOMMU_MAP_READ: Can be mapped for reading
1872	* NOMMU_MAP_WRITE: Can be mapped for writing
1873	* NOMMU_MAP_EXEC: Can be mapped for execution
1874	*/
1875	#define NOMMU_MAP_COPY 0x00000001
1876	#define NOMMU_MAP_DIRECT 0x00000008
1877	#define NOMMU_MAP_READ VM_MAYREAD
1878	#define NOMMU_MAP_WRITE VM_MAYWRITE
1879	#define NOMMU_MAP_EXEC VM_MAYEXEC
1880
1881	#define NOMMU_VMFLAGS \
1882	(NOMMU_MAP_READ \| NOMMU_MAP_WRITE \| NOMMU_MAP_EXEC)
1883
1884	/*
1885	* These flags control the behavior of the remap_file_range function pointer.
1886	* If it is called with len == 0 that means "remap to end of source file".
1887	* See Documentation/filesystems/vfs.rst for more details about this call.
1888	*
1889	* REMAP_FILE_DEDUP: only remap if contents identical (i.e. deduplicate)
1890	* REMAP_FILE_CAN_SHORTEN: caller can handle a shortened request
1891	*/
1892	#define REMAP_FILE_DEDUP (1 << 0)
1893	#define REMAP_FILE_CAN_SHORTEN (1 << 1)
1894
1895	/*
1896	* These flags signal that the caller is ok with altering various aspects of
1897	* the behavior of the remap operation. The changes must be made by the
1898	* implementation; the vfs remap helper functions can take advantage of them.
1899	* Flags in this category exist to preserve the quirky behavior of the hoisted
1900	* btrfs clone/dedupe ioctls.
1901	*/
1902	#define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN)
1903
1904	/*
1905	* These flags control the behavior of vfs_copy_file_range().
1906	* They are not available to the user via syscall.
1907	*
1908	* COPY_FILE_SPLICE: call splice direct instead of fs clone/copy ops
1909	*/
1910	#define COPY_FILE_SPLICE (1 << 0)
1911
1912	struct iov_iter;
1913	struct io_uring_cmd;
1914	struct offset_ctx;
1915
1916	typedef unsigned int __bitwise fop_flags_t;
1917
1918	struct file_operations {
1919	struct module *owner;
1920	fop_flags_t fop_flags;
1921	loff_t (llseek) (struct* file , loff_t, int*);
1922	ssize_t (read) (struct* file , char* __user , size_t, loff_t );
1923	ssize_t (write) (struct* file , const* char __user , size_t, loff_t );
1924	ssize_t (read_iter) (struct* kiocb , struct* iov_iter *);
1925	ssize_t (write_iter) (struct* kiocb , struct* iov_iter *);
1926	int (iopoll)(struct* kiocb kiocb, struct* io_comp_batch *,
1927	unsigned int flags);
1928	int (iterate_shared) (struct* file , struct* dir_context *);
1929	__poll_t (poll) (struct* file , struct* poll_table_struct *);
1930	long (unlocked_ioctl) (struct* file , unsigned* int, unsigned long);
1931	long (compat_ioctl) (struct* file , unsigned* int, unsigned long);
1932	int (mmap) (struct* file , struct* vm_area_struct *);
1933	int (open) (struct* inode , struct* file *);
1934	int (flush) (struct* file *, fl_owner_t id);
1935	int (release) (struct* inode , struct* file *);
1936	int (fsync) (struct* file , loff_t, loff_t, int* datasync);
1937	int (fasync) (int, struct* file , int*);
1938	int (lock) (struct* file , int, struct* file_lock *);
1939	unsigned long (get_unmapped_area)(struct* file , unsigned* long, unsigned long, unsigned long, unsigned long);
1940	int (check_flags)(int*);
1941	int (flock) (struct* file , int, struct* file_lock *);
1942	ssize_t (splice_write)(struct* pipe_inode_info , struct* file , loff_t , size_t, unsigned int);
1943	ssize_t (splice_read)(struct* file , loff_t , struct pipe_inode_info , size_t, unsigned* int);
1944	void (splice_eof)(struct* file *file);
1945	int (setlease)(struct* file , int, struct* file_lease *, void* **);
1946	long (fallocate)(struct* file file, int* mode, loff_t offset,
1947	loff_t len);
1948	void (show_fdinfo)(struct* seq_file m, struct* file *f);
1949	#ifndef CONFIG_MMU
1950	unsigned (mmap_capabilities)(struct* file *);
1951	#endif
1952	ssize_t (copy_file_range)(struct* file , loff_t, struct* file *,
1953	loff_t, size_t, unsigned int);
1954	loff_t (remap_file_range)(struct* file *file_in, loff_t pos_in,
1955	struct file *file_out, loff_t pos_out,
1956	loff_t len, unsigned int remap_flags);
1957	int (fadvise)(struct* file , loff_t, loff_t, int*);
1958	int (uring_cmd)(struct* io_uring_cmd ioucmd, unsigned* int issue_flags);
1959	int (uring_cmd_iopoll)(struct* io_uring_cmd , struct* io_comp_batch *,
1960	unsigned int poll_flags);
1961	int (mmap_prepare)(struct* vm_area_desc *);
1962	} __randomize_layout;
1963
1964	/ Supports async buffered reads /
1965	#define FOP_BUFFER_RASYNC ((__force fop_flags_t)(1 << 0))
1966	/ Supports async buffered writes /
1967	#define FOP_BUFFER_WASYNC ((__force fop_flags_t)(1 << 1))
1968	/ Supports synchronous page faults for mappings /
1969	#define FOP_MMAP_SYNC ((__force fop_flags_t)(1 << 2))
1970	/ Supports non-exclusive O_DIRECT writes from multiple threads /
1971	#define FOP_DIO_PARALLEL_WRITE ((__force fop_flags_t)(1 << 3))
1972	/ Contains huge pages /
1973	#define FOP_HUGE_PAGES ((__force fop_flags_t)(1 << 4))
1974	/ Treat loff_t as unsigned (e.g., /dev/mem) /
1975	#define FOP_UNSIGNED_OFFSET ((__force fop_flags_t)(1 << 5))
1976	/ Supports asynchronous lock callbacks /
1977	#define FOP_ASYNC_LOCK ((__force fop_flags_t)(1 << 6))
1978	/ File system supports uncached read/write buffered IO /
1979	#define FOP_DONTCACHE ((__force fop_flags_t)(1 << 7))
1980
1981	/ Wrap a directory iterator that needs exclusive inode access /
1982	int wrap_directory_iterator(struct file , struct* dir_context *,
1983	int () (struct* file , struct* dir_context *));
1984	#define WRAP_DIR_ITER(x) \
1985	static int shared_##x(struct file file , struct dir_context ctx) \
1986	{ return wrap_directory_iterator(file, ctx, x); }
1987
1988	struct inode_operations {
1989	struct dentry * (lookup) (struct* inode ,struct* dentry , unsigned* int);
1990	const char * (get_link) (struct* dentry , struct* inode , struct* delayed_call *);
1991	int (permission) (struct* mnt_idmap , struct* inode , int*);
1992	struct posix_acl * (get_inode_acl)(struct* inode , int*, bool);
1993
1994	int (readlink) (struct* dentry , char* __user ,int*);
1995
1996	int (create) (struct* mnt_idmap , struct* inode ,struct* dentry *,
1997	umode_t, bool);
1998	int (link) (struct* dentry ,struct* inode ,struct* dentry *);
1999	int (unlink) (struct* inode ,struct* dentry *);
2000	int (symlink) (struct* mnt_idmap , struct* inode ,struct* dentry *,
2001	const char *);
2002	struct dentry (mkdir) (struct mnt_idmap , struct* inode *,
2003	struct dentry *, umode_t);
2004	int (rmdir) (struct* inode ,struct* dentry *);
2005	int (mknod) (struct* mnt_idmap , struct* inode ,struct* dentry *,
2006	umode_t,dev_t);
2007	int (rename) (struct* mnt_idmap , struct* inode , struct* dentry *,
2008	struct inode , struct* dentry , unsigned* int);
2009	int (setattr) (struct* mnt_idmap , struct* dentry , struct* iattr *);
2010	int (getattr) (struct* mnt_idmap , const* struct path *,
2011	struct kstat , u32, unsigned* int);
2012	ssize_t (listxattr) (struct* dentry , char* *, size_t);
2013	int (fiemap)(struct* inode , struct* fiemap_extent_info *, u64 start,
2014	u64 len);
2015	int (update_time)(struct* inode , int*);
2016	int (atomic_open)(struct* inode , struct* dentry *,
2017	struct file , unsigned* open_flag,
2018	umode_t create_mode);
2019	int (tmpfile) (struct* mnt_idmap , struct* inode *,
2020	struct file *, umode_t);
2021	struct posix_acl (get_acl)(struct mnt_idmap , struct* dentry *,
2022	int);
2023	int (set_acl)(struct* mnt_idmap , struct* dentry *,
2024	struct posix_acl , int*);
2025	int (fileattr_set)(struct* mnt_idmap *idmap,
2026	struct dentry dentry, struct* file_kattr *fa);
2027	int (fileattr_get)(struct* dentry dentry, struct* file_kattr *fa);
2028	struct offset_ctx (get_offset_ctx)(struct inode *inode);
2029	} ____cacheline_aligned;
2030
2031	/ Did the driver provide valid mmap hook configuration? /
2032	static inline bool can_mmap_file(struct file *file)
2033	{
2034	bool has_mmap = file->f_op->mmap;
2035	bool has_mmap_prepare = file->f_op->mmap_prepare;
2036
2037	/ Hooks are mutually exclusive. /
2038	if (WARN_ON_ONCE(has_mmap && has_mmap_prepare))
2039	return false;
2040	if (!has_mmap && !has_mmap_prepare)
2041	return false;
2042
2043	return true;
2044	}
2045
2046	int __compat_vma_mmap(const struct file_operations *f_op,
2047	struct file file, struct* vm_area_struct *vma);
2048	int compat_vma_mmap(struct file file, struct* vm_area_struct *vma);
2049
2050	static inline int vfs_mmap(struct file file, struct* vm_area_struct *vma)
2051	{
2052	if (file->f_op->mmap_prepare)
2053	return compat_vma_mmap(file, vma);
2054
2055	return file->f_op->mmap(file, vma);
2056	}
2057
2058	static inline int vfs_mmap_prepare(struct file file, struct* vm_area_desc *desc)
2059	{
2060	return file->f_op->mmap_prepare(desc);
2061	}
2062
2063	extern ssize_t vfs_read(struct file , char* __user , size_t, loff_t );
2064	extern ssize_t vfs_write(struct file , const* char __user , size_t, loff_t );
2065	extern ssize_t vfs_copy_file_range(struct file , loff_t , struct* file *,
2066	loff_t, size_t, unsigned int);
2067	int remap_verify_area(struct file *file, loff_t pos, loff_t len, bool write);
2068	int __generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
2069	struct file *file_out, loff_t pos_out,
2070	loff_t len, unsigned* int remap_flags,
2071	const struct iomap_ops *dax_read_ops);
2072	int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
2073	struct file *file_out, loff_t pos_out,
2074	loff_t count, unsigned* int remap_flags);
2075	extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
2076	struct file *file_out, loff_t pos_out,
2077	loff_t len, unsigned int remap_flags);
2078	extern int vfs_dedupe_file_range(struct file *file,
2079	struct file_dedupe_range *same);
2080	extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
2081	struct file *dst_file, loff_t dst_pos,
2082	loff_t len, unsigned int remap_flags);
2083
2084	/*
2085	* Inode flags - they have no relation to superblock flags now
2086	*/
2087	#define S_SYNC (1 << 0) /* Writes are synced at once */
2088	#define S_NOATIME (1 << 1) /* Do not update access times */
2089	#define S_APPEND (1 << 2) /* Append-only file */
2090	#define S_IMMUTABLE (1 << 3) /* Immutable file */
2091	#define S_DEAD (1 << 4) /* removed, but still open directory */
2092	#define S_NOQUOTA (1 << 5) /* Inode is not counted to quota */
2093	#define S_DIRSYNC (1 << 6) /* Directory modifications are synchronous */
2094	#define S_NOCMTIME (1 << 7) /* Do not update file c/mtime */
2095	#define S_SWAPFILE (1 << 8) /* Do not truncate: swapon got its bmaps */
2096	#define S_PRIVATE (1 << 9) /* Inode is fs-internal */
2097	#define S_IMA (1 << 10) /* Inode has an associated IMA struct */
2098	#define S_AUTOMOUNT (1 << 11) /* Automount/referral quasi-directory */
2099	#define S_NOSEC (1 << 12) /* no suid or xattr security attributes */
2100	#ifdef CONFIG_FS_DAX
2101	#define S_DAX (1 << 13) /* Direct Access, avoiding the page cache */
2102	#else
2103	#define S_DAX 0 /* Make all the DAX code disappear */
2104	#endif
2105	#define S_ENCRYPTED (1 << 14) /* Encrypted file (using fs/crypto/) */
2106	#define S_CASEFOLD (1 << 15) /* Casefolded file */
2107	#define S_VERITY (1 << 16) /* Verity file (using fs/verity/) */
2108	#define S_KERNEL_FILE (1 << 17) /* File is in use by the kernel (eg. fs/cachefiles) */
2109	#define S_ANON_INODE (1 << 19) /* Inode is an anonymous inode */
2110
2111	/*
2112	* Note that nosuid etc flags are inode-specific: setting some file-system
2113	* flags just means all the inodes inherit those flags by default. It might be
2114	* possible to override it selectively if you really wanted to with some
2115	* ioctl() that is not currently implemented.
2116	*
2117	* Exception: SB_RDONLY is always applied to the entire file system.
2118	*
2119	* Unfortunately, it is possible to change a filesystems flags with it mounted
2120	* with files in use. This means that all of the inodes will not have their
2121	* i_flags updated. Hence, i_flags no longer inherit the superblock mount
2122	* flags, so these have to be checked separately. -- [email protected]
2123	*/
2124	#define __IS_FLG(inode, flg) ((inode)->i_sb->s_flags & (flg))
2125
2126	#define IS_RDONLY(inode) sb_rdonly((inode)->i_sb)
2127	#define IS_SYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS) \|\| \
2128	((inode)->i_flags & S_SYNC))
2129	#define IS_DIRSYNC(inode) (__IS_FLG(inode, SB_SYNCHRONOUS\|SB_DIRSYNC) \|\| \
2130	((inode)->i_flags & (S_SYNC\|S_DIRSYNC)))
2131	#define IS_MANDLOCK(inode) __IS_FLG(inode, SB_MANDLOCK)
2132	#define IS_NOATIME(inode) __IS_FLG(inode, SB_RDONLY\|SB_NOATIME)
2133	#define IS_I_VERSION(inode) __IS_FLG(inode, SB_I_VERSION)
2134
2135	#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
2136	#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
2137	#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
2138
2139	#ifdef CONFIG_FS_POSIX_ACL
2140	#define IS_POSIXACL(inode) __IS_FLG(inode, SB_POSIXACL)
2141	#else
2142	#define IS_POSIXACL(inode) 0
2143	#endif
2144
2145	#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
2146	#define IS_NOCMTIME(inode) ((inode)->i_flags & S_NOCMTIME)
2147
2148	#ifdef CONFIG_SWAP
2149	#define IS_SWAPFILE(inode) ((inode)->i_flags & S_SWAPFILE)
2150	#else
2151	#define IS_SWAPFILE(inode) ((void)(inode), 0U)
2152	#endif
2153
2154	#define IS_PRIVATE(inode) ((inode)->i_flags & S_PRIVATE)
2155	#define IS_IMA(inode) ((inode)->i_flags & S_IMA)
2156	#define IS_AUTOMOUNT(inode) ((inode)->i_flags & S_AUTOMOUNT)
2157	#define IS_NOSEC(inode) ((inode)->i_flags & S_NOSEC)
2158	#define IS_DAX(inode) ((inode)->i_flags & S_DAX)
2159	#define IS_ENCRYPTED(inode) ((inode)->i_flags & S_ENCRYPTED)
2160	#define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD)
2161	#define IS_VERITY(inode) ((inode)->i_flags & S_VERITY)
2162
2163	#define IS_WHITEOUT(inode) (S_ISCHR(inode->i_mode) && \
2164	(inode)->i_rdev == WHITEOUT_DEV)
2165	#define IS_ANON_FILE(inode) ((inode)->i_flags & S_ANON_INODE)
2166
2167	static inline bool HAS_UNMAPPED_ID(struct mnt_idmap *idmap,
2168	struct inode *inode)
2169	{
2170	return !vfsuid_valid(uid: i_uid_into_vfsuid(idmap, inode)) \|\|
2171	!vfsgid_valid(gid: i_gid_into_vfsgid(idmap, inode));
2172	}
2173
2174	static inline void init_sync_kiocb(struct kiocb kiocb, struct* file *filp)
2175	{
2176	kiocb = (struct* kiocb) {
2177	.ki_filp = filp,
2178	.ki_flags = filp->f_iocb_flags,
2179	.ki_ioprio = get_current_ioprio(),
2180	};
2181	}
2182
2183	static inline void kiocb_clone(struct kiocb kiocb, struct* kiocb *kiocb_src,
2184	struct file *filp)
2185	{
2186	kiocb = (struct* kiocb) {
2187	.ki_filp = filp,
2188	.ki_flags = kiocb_src->ki_flags,
2189	.ki_ioprio = kiocb_src->ki_ioprio,
2190	.ki_pos = kiocb_src->ki_pos,
2191	};
2192	}
2193
2194	extern void __mark_inode_dirty(struct inode , int*);
2195	static inline void mark_inode_dirty(struct inode *inode)
2196	{
2197	__mark_inode_dirty(inode, I_DIRTY);
2198	}
2199
2200	static inline void mark_inode_dirty_sync(struct inode *inode)
2201	{
2202	__mark_inode_dirty(inode, I_DIRTY_SYNC);
2203	}
2204
2205	static inline int icount_read(const struct inode *inode)
2206	{
2207	return atomic_read(v: &inode->i_count);
2208	}
2209
2210	/*
2211	* Returns true if the given inode itself only has dirty timestamps (its pages
2212	* may still be dirty) and isn't currently being allocated or freed.
2213	* Filesystems should call this if when writing an inode when lazytime is
2214	* enabled, they want to opportunistically write the timestamps of other inodes
2215	* located very nearby on-disk, e.g. in the same inode block. This returns true
2216	* if the given inode is in need of such an opportunistic update. Requires
2217	* i_lock, or at least later re-checking under i_lock.
2218	*/
2219	static inline bool inode_is_dirtytime_only(struct inode *inode)
2220	{
2221	return (inode_state_read_once(inode) &
2222	(I_DIRTY_TIME \| I_NEW \| I_FREEING \| I_WILL_FREE)) == I_DIRTY_TIME;
2223	}
2224
2225	extern void inc_nlink(struct inode *inode);
2226	extern void drop_nlink(struct inode *inode);
2227	extern void clear_nlink(struct inode *inode);
2228	extern void set_nlink(struct inode inode, unsigned* int nlink);
2229
2230	static inline void inode_inc_link_count(struct inode *inode)
2231	{
2232	inc_nlink(inode);
2233	mark_inode_dirty(inode);
2234	}
2235
2236	static inline void inode_dec_link_count(struct inode *inode)
2237	{
2238	drop_nlink(inode);
2239	mark_inode_dirty(inode);
2240	}
2241
2242	enum file_time_flags {
2243	S_ATIME = `1`,
2244	S_MTIME = `2`,
2245	S_CTIME = `4`,
2246	S_VERSION = `8`,
2247	};
2248
2249	extern bool atime_needs_update(const struct path , struct* inode *);
2250	extern void touch_atime(const struct path *);
2251	int inode_update_time(struct inode inode, int* flags);
2252
2253	static inline void file_accessed(struct file *file)
2254	{
2255	if (!(file->f_flags & O_NOATIME))
2256	touch_atime(&file->f_path);
2257	}
2258
2259	extern int file_modified(struct file *file);
2260	int kiocb_modified(struct kiocb *iocb);
2261
2262	int sync_inode_metadata(struct inode inode, int* wait);
2263
2264	struct file_system_type {
2265	const char *name;
2266	int fs_flags;
2267	#define FS_REQUIRES_DEV 1
2268	#define FS_BINARY_MOUNTDATA 2
2269	#define FS_HAS_SUBTYPE 4
2270	#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
2271	#define FS_DISALLOW_NOTIFY_PERM 16 /* Disable fanotify permission events */
2272	#define FS_ALLOW_IDMAP 32 /* FS has been updated to handle vfs idmappings. */
2273	#define FS_MGTIME 64 /* FS uses multigrain timestamps */
2274	#define FS_LBS 128 /* FS supports LBS */
2275	#define FS_POWER_FREEZE 256 /* Always freeze on suspend/hibernate */
2276	#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
2277	int (init_fs_context)(struct* fs_context *);
2278	const struct fs_parameter_spec *parameters;
2279	struct dentry (mount) (struct file_system_type , int*,
2280	const char , void* *);
2281	void (kill_sb) (struct* super_block *);
2282	struct module *owner;
2283	struct file_system_type * next;
2284	struct hlist_head fs_supers;
2285
2286	struct lock_class_key s_lock_key;
2287	struct lock_class_key s_umount_key;
2288	struct lock_class_key s_vfs_rename_key;
2289	struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
2290
2291	struct lock_class_key i_lock_key;
2292	struct lock_class_key i_mutex_key;
2293	struct lock_class_key invalidate_lock_key;
2294	struct lock_class_key i_mutex_dir_key;
2295	};
2296
2297	#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)
2298
2299	/**
2300	* is_mgtime: is this inode using multigrain timestamps
2301	* @inode: inode to test for multigrain timestamps
2302	*
2303	* Return true if the inode uses multigrain timestamps, false otherwise.
2304	*/
2305	static inline bool is_mgtime(const struct inode *inode)
2306	{
2307	return inode->i_opflags & IOP_MGTIME;
2308	}
2309
2310	extern struct dentry mount_subtree(struct* vfsmount mnt, const* char *path);
2311	void retire_super(struct super_block *sb);
2312	void generic_shutdown_super(struct super_block *sb);
2313	void kill_block_super(struct super_block *sb);
2314	void kill_anon_super(struct super_block *sb);
2315	void deactivate_super(struct super_block *sb);
2316	void deactivate_locked_super(struct super_block *sb);
2317	int set_anon_super(struct super_block s, void* *data);
2318	int set_anon_super_fc(struct super_block s, struct* fs_context *fc);
2319	int get_anon_bdev(dev_t *);
2320	void free_anon_bdev(dev_t);
2321	struct super_block sget_fc(struct* fs_context *fc,
2322	int (test)(struct* super_block , struct* fs_context *),
2323	int (set)(struct* super_block , struct* fs_context *));
2324	struct super_block sget(struct* file_system_type *type,
2325	int (test)(struct* super_block ,void* *),
2326	int (set)(struct* super_block ,void* *),
2327	int flags, void *data);
2328	struct super_block sget_dev(struct* fs_context *fc, dev_t dev);
2329
2330	/ Alas, no aliases. Too much hassle with bringing module.h everywhere /
2331	#define fops_get(fops) ({ \
2332	const struct file_operations *_fops = (fops); \
2333	(((_fops) && try_module_get((_fops)->owner) ? (_fops) : NULL)); \
2334	})
2335
2336	#define fops_put(fops) ({ \
2337	const struct file_operations *_fops = (fops); \
2338	if (_fops) \
2339	module_put((_fops)->owner); \
2340	})
2341
2342	/*
2343	* This one is to be used ONLY from ->open() instances.
2344	* fops must be non-NULL, pinned down and module dependencies
2345	* should be sufficient to pin the caller down as well.
2346	*/
2347	#define replace_fops(f, fops) \
2348	do { \
2349	struct file *__file = (f); \
2350	fops_put(__file->f_op); \
2351	BUG_ON(!(__file->f_op = (fops))); \
2352	} while(0)
2353
2354	extern int register_filesystem(struct file_system_type *);
2355	extern int unregister_filesystem(struct file_system_type *);
2356	extern int vfs_statfs(const struct path , struct* kstatfs *);
2357	extern int user_statfs(const char __user , struct* kstatfs *);
2358	extern int fd_statfs(int, struct kstatfs *);
2359	extern __printf(`2`, `3`)
2360	int super_setup_bdi_name(struct super_block sb, char* *fmt, ...);
2361	extern int super_setup_bdi(struct super_block *sb);
2362
2363	static inline void super_set_uuid(struct super_block sb, const* u8 uuid, unsigned* len)
2364	{
2365	if (WARN_ON(len > sizeof(sb->s_uuid)))
2366	len = sizeof(sb->s_uuid);
2367	sb->s_uuid_len = len;
2368	memcpy(&sb->s_uuid, uuid, len);
2369	}
2370
2371	/ set sb sysfs name based on sb->s_bdev /
2372	static inline void super_set_sysfs_name_bdev(struct super_block *sb)
2373	{
2374	snprintf(buf: sb->s_sysfs_name, size: sizeof(sb->s_sysfs_name), fmt: "%pg", sb->s_bdev);
2375	}
2376
2377	/ set sb sysfs name based on sb->s_uuid /
2378	static inline void super_set_sysfs_name_uuid(struct super_block *sb)
2379	{
2380	WARN_ON(sb->s_uuid_len != sizeof(sb->s_uuid));
2381	snprintf(buf: sb->s_sysfs_name, size: sizeof(sb->s_sysfs_name), fmt: "%pU", sb->s_uuid.b);
2382	}
2383
2384	/ set sb sysfs name based on sb->s_id /
2385	static inline void super_set_sysfs_name_id(struct super_block *sb)
2386	{
2387	strscpy(sb->s_sysfs_name, sb->s_id, sizeof(sb->s_sysfs_name));
2388	}
2389
2390	/ try to use something standard before you use this /
2391	__printf(`2`, `3`)
2392	static inline void super_set_sysfs_name_generic(struct super_block sb, const* char *fmt, ...)
2393	{
2394	va_list args;
2395
2396	va_start(args, fmt);
2397	vsnprintf(buf: sb->s_sysfs_name, size: sizeof(sb->s_sysfs_name), fmt, args);
2398	va_end(args);
2399	}
2400
2401	extern void ihold(struct inode * inode);
2402	extern void iput(struct inode *);
2403	void iput_not_last(struct inode *);
2404	int inode_update_timestamps(struct inode inode, int* flags);
2405	int generic_update_time(struct inode , int*);
2406
2407	/ /sys/fs /
2408	extern struct kobject *fs_kobj;
2409
2410	#define MAX_RW_COUNT (INT_MAX & PAGE_MASK)
2411
2412	/ fs/open.c /
2413	struct audit_names;
2414	struct filename {
2415	const char name; /* pointer to actual string /
2416	const __user char uptr; /* original userland pointer /
2417	atomic_t refcnt;
2418	struct audit_names *aname;
2419	const char iname[];
2420	};
2421	static_assert(offsetof(struct filename, iname) % sizeof(long) == `0`);
2422
2423	static inline struct mnt_idmap file_mnt_idmap(const* struct file *file)
2424	{
2425	return mnt_idmap(mnt: file->f_path.mnt);
2426	}
2427
2428	/**
2429	* is_idmapped_mnt - check whether a mount is mapped
2430	* @mnt: the mount to check
2431	*
2432	* If @mnt has an non @nop_mnt_idmap attached to it then @mnt is mapped.
2433	*
2434	* Return: true if mount is mapped, false if not.
2435	*/
2436	static inline bool is_idmapped_mnt(const struct vfsmount *mnt)
2437	{
2438	return mnt_idmap(mnt) != &nop_mnt_idmap;
2439	}
2440
2441	int vfs_truncate(const struct path *, loff_t);
2442	int do_truncate(struct mnt_idmap , struct* dentry *, loff_t start,
2443	unsigned int time_attrs, struct file *filp);
2444	extern int vfs_fallocate(struct file file, int* mode, loff_t offset,
2445	loff_t len);
2446	int do_sys_open(int dfd, const char __user filename, int* flags,
2447	umode_t mode);
2448	extern struct file file_open_name(struct* filename , int*, umode_t);
2449	extern struct file filp_open(const* char , int*, umode_t);
2450	extern struct file file_open_root(const* struct path *,
2451	const char , int*, umode_t);
2452	static inline struct file file_open_root_mnt(struct* vfsmount *mnt,
2453	const char name, int* flags, umode_t mode)
2454	{
2455	return file_open_root(&(struct path){.mnt = mnt, .dentry = mnt->mnt_root},
2456	name, flags, mode);
2457	}
2458	struct file dentry_open(const* struct path path, int* flags,
2459	const struct cred *creds);
2460	struct file dentry_open_nonotify(const* struct path path, int* flags,
2461	const struct cred *cred);
2462	struct file dentry_create(const* struct path path, int* flags, umode_t mode,
2463	const struct cred *cred);
2464	const struct path backing_file_user_path(const* struct file *f);
2465
2466	/*
2467	* When mmapping a file on a stackable filesystem (e.g., overlayfs), the file
2468	* stored in ->vm_file is a backing file whose f_inode is on the underlying
2469	* filesystem. When the mapped file path and inode number are displayed to
2470	* user (e.g. via /proc/<pid>/maps), these helpers should be used to get the
2471	* path and inode number to display to the user, which is the path of the fd
2472	* that user has requested to map and the inode number that would be returned
2473	* by fstat() on that same fd.
2474	*/
2475	/ Get the path to display in /proc/<pid>/maps /
2476	static inline const struct path file_user_path(const* struct file *f)
2477	{
2478	if (unlikely(f->f_mode & FMODE_BACKING))
2479	return backing_file_user_path(f);
2480	return &f->f_path;
2481	}
2482	/ Get the inode whose inode number to display in /proc/<pid>/maps /
2483	static inline const struct inode file_user_inode(const* struct file *f)
2484	{
2485	if (unlikely(f->f_mode & FMODE_BACKING))
2486	return d_inode(dentry: backing_file_user_path(f)->dentry);
2487	return file_inode(f);
2488	}
2489
2490	static inline struct file file_clone_open(struct* file *file)
2491	{
2492	return dentry_open(path: &file->f_path, flags: file->f_flags, creds: file->f_cred);
2493	}
2494	extern int filp_close(struct file *, fl_owner_t id);
2495
2496	extern struct filename getname_flags(const* char __user , int*);
2497	extern struct filename getname_uflags(const* char __user , int*);
2498	static inline struct filename getname(const* char __user *name)
2499	{
2500	return getname_flags(name, `0`);
2501	}
2502	extern struct filename getname_kernel(const* char *);
2503	extern struct filename __getname_maybe_null(const* char __user *);
2504	static inline struct filename getname_maybe_null(const* char __user name, int* flags)
2505	{
2506	if (!(flags & AT_EMPTY_PATH))
2507	return getname(name);
2508
2509	if (!name)
2510	return NULL;
2511	return __getname_maybe_null(name);
2512	}
2513	extern void putname(struct filename *name);
2514	DEFINE_FREE(putname, struct filename *, if (!IS_ERR_OR_NULL(_T)) putname(_T))
2515
2516	static inline struct filename refname(struct* filename *name)
2517	{
2518	atomic_inc(v: &name->refcnt);
2519	return name;
2520	}
2521
2522	extern int finish_open(struct file file, struct* dentry *dentry,
2523	int (open)(struct* inode , struct* file *));
2524	extern int finish_no_open(struct file file, struct* dentry *dentry);
2525
2526	/ Helper for the simple case when original dentry is used /
2527	static inline int finish_open_simple(struct file file, int* error)
2528	{
2529	if (error)
2530	return error;
2531
2532	return finish_open(file, dentry: file->f_path.dentry, NULL);
2533	}
2534
2535	/ fs/dcache.c /
2536	extern void __init vfs_caches_init_early(void);
2537	extern void __init vfs_caches_init(void);
2538
2539	extern struct kmem_cache *names_cachep;
2540
2541	#define __getname() kmem_cache_alloc(names_cachep, GFP_KERNEL)
2542	#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
2543
2544	void emergency_thaw_all(void);
2545	extern int sync_filesystem(struct super_block *);
2546	extern const struct file_operations def_blk_fops;
2547	extern const struct file_operations def_chr_fops;
2548
2549	/ fs/char_dev.c /
2550	#define CHRDEV_MAJOR_MAX 512
2551	/ Marks the bottom of the first segment of free char majors /
2552	#define CHRDEV_MAJOR_DYN_END 234
2553	/ Marks the top and bottom of the second segment of free char majors /
2554	#define CHRDEV_MAJOR_DYN_EXT_START 511
2555	#define CHRDEV_MAJOR_DYN_EXT_END 384
2556
2557	extern int alloc_chrdev_region(dev_t , unsigned, unsigned, const* char *);
2558	extern int register_chrdev_region(dev_t, unsigned, const char *);
2559	extern int __register_chrdev(unsigned int major, unsigned int baseminor,
2560	unsigned int count, const char *name,
2561	const struct file_operations *fops);
2562	extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
2563	unsigned int count, const char *name);
2564	extern void unregister_chrdev_region(dev_t, unsigned);
2565	extern void chrdev_show(struct seq_file *,off_t);
2566
2567	static inline int register_chrdev(unsigned int major, const char *name,
2568	const struct file_operations *fops)
2569	{
2570	return __register_chrdev(major, baseminor: `0`, count: `256`, name, fops);
2571	}
2572
2573	static inline void unregister_chrdev(unsigned int major, const char *name)
2574	{
2575	__unregister_chrdev(major, baseminor: `0`, count: `256`, name);
2576	}
2577
2578	extern void init_special_inode(struct inode *, umode_t, dev_t);
2579
2580	/ Invalid inode operations -- fs/bad_inode.c /
2581	extern void make_bad_inode(struct inode *);
2582	extern bool is_bad_inode(struct inode *);
2583
2584	extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
2585	loff_t lend);
2586	extern int __must_check file_check_and_advance_wb_err(struct file *file);
2587	extern int __must_check file_write_and_wait_range(struct file *file,
2588	loff_t start, loff_t end);
2589	int filemap_flush_range(struct address_space *mapping, loff_t start,
2590	loff_t end);
2591
2592	static inline int file_write_and_wait(struct file *file)
2593	{
2594	return file_write_and_wait_range(file, start: `0`, LLONG_MAX);
2595	}
2596
2597	extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
2598	int datasync);
2599	extern int vfs_fsync(struct file file, int* datasync);
2600
2601	extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
2602	unsigned int flags);
2603
2604	static inline bool iocb_is_dsync(const struct kiocb *iocb)
2605	{
2606	return (iocb->ki_flags & IOCB_DSYNC) \|\|
2607	IS_SYNC(iocb->ki_filp->f_mapping->host);
2608	}
2609
2610	/*
2611	* Sync the bytes written if this was a synchronous write. Expect ki_pos
2612	* to already be updated for the write, and will return either the amount
2613	* of bytes passed in, or an error if syncing the file failed.
2614	*/
2615	static inline ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count)
2616	{
2617	if (iocb_is_dsync(iocb)) {
2618	int ret = vfs_fsync_range(file: iocb->ki_filp,
2619	start: iocb->ki_pos - count, end: iocb->ki_pos - `1`,
2620	datasync: (iocb->ki_flags & IOCB_SYNC) ? `0` : `1`);
2621	if (ret)
2622	return ret;
2623	} else if (iocb->ki_flags & IOCB_DONTCACHE) {
2624	struct address_space *mapping = iocb->ki_filp->f_mapping;
2625
2626	filemap_flush_range(mapping, start: iocb->ki_pos - count,
2627	end: iocb->ki_pos - `1`);
2628	}
2629
2630	return count;
2631	}
2632
2633	extern void emergency_sync(void);
2634	extern void emergency_remount(void);
2635
2636	#ifdef CONFIG_BLOCK
2637	extern int bmap(struct inode inode, sector_t block);
2638	#else
2639	static inline int bmap(struct inode inode, sector_t block)
2640	{
2641	return -EINVAL;
2642	}
2643	#endif
2644
2645	int notify_change(struct mnt_idmap , struct* dentry *,
2646	struct iattr , struct* delegated_inode *);
2647	int inode_permission(struct mnt_idmap , struct* inode , int*);
2648	int generic_permission(struct mnt_idmap , struct* inode , int*);
2649	static inline int file_permission(struct file file, int* mask)
2650	{
2651	return inode_permission(file_mnt_idmap(file),
2652	file_inode(f: file), mask);
2653	}
2654	static inline int path_permission(const struct path path, int* mask)
2655	{
2656	return inode_permission(mnt_idmap(mnt: path->mnt),
2657	d_inode(dentry: path->dentry), mask);
2658	}
2659	int __check_sticky(struct mnt_idmap idmap, struct* inode *dir,
2660	struct inode *inode);
2661
2662	static inline bool execute_ok(struct inode *inode)
2663	{
2664	return (inode->i_mode & S_IXUGO) \|\| S_ISDIR(inode->i_mode);
2665	}
2666
2667	static inline bool inode_wrong_type(const struct inode *inode, umode_t mode)
2668	{
2669	return (inode->i_mode ^ mode) & S_IFMT;
2670	}
2671
2672	/**
2673	* file_start_write - get write access to a superblock for regular file io
2674	* @file: the file we want to write to
2675	*
2676	* This is a variant of sb_start_write() which is a noop on non-regular file.
2677	* Should be matched with a call to file_end_write().
2678	*/
2679	static inline void file_start_write(struct file *file)
2680	{
2681	if (!S_ISREG(file_inode(file)->i_mode))
2682	return;
2683	sb_start_write(sb: file_inode(f: file)->i_sb);
2684	}
2685
2686	static inline bool file_start_write_trylock(struct file *file)
2687	{
2688	if (!S_ISREG(file_inode(file)->i_mode))
2689	return true;
2690	return sb_start_write_trylock(sb: file_inode(f: file)->i_sb);
2691	}
2692
2693	/**
2694	* file_end_write - drop write access to a superblock of a regular file
2695	* @file: the file we wrote to
2696	*
2697	* Should be matched with a call to file_start_write().
2698	*/
2699	static inline void file_end_write(struct file *file)
2700	{
2701	if (!S_ISREG(file_inode(file)->i_mode))
2702	return;
2703	sb_end_write(sb: file_inode(f: file)->i_sb);
2704	}
2705
2706	/**
2707	* kiocb_start_write - get write access to a superblock for async file io
2708	* @iocb: the io context we want to submit the write with
2709	*
2710	* This is a variant of sb_start_write() for async io submission.
2711	* Should be matched with a call to kiocb_end_write().
2712	*/
2713	static inline void kiocb_start_write(struct kiocb *iocb)
2714	{
2715	struct inode *inode = file_inode(f: iocb->ki_filp);
2716
2717	sb_start_write(sb: inode->i_sb);
2718	/*
2719	* Fool lockdep by telling it the lock got released so that it
2720	* doesn't complain about the held lock when we return to userspace.
2721	*/
2722	__sb_writers_release(inode->i_sb, SB_FREEZE_WRITE);
2723	}
2724
2725	/**
2726	* kiocb_end_write - drop write access to a superblock after async file io
2727	* @iocb: the io context we sumbitted the write with
2728	*
2729	* Should be matched with a call to kiocb_start_write().
2730	*/
2731	static inline void kiocb_end_write(struct kiocb *iocb)
2732	{
2733	struct inode *inode = file_inode(f: iocb->ki_filp);
2734
2735	/*
2736	* Tell lockdep we inherited freeze protection from submission thread.
2737	*/
2738	__sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE);
2739	sb_end_write(sb: inode->i_sb);
2740	}
2741
2742	/*
2743	* This is used for regular files where some users -- especially the
2744	* currently executed binary in a process, previously handled via
2745	* VM_DENYWRITE -- cannot handle concurrent write (and maybe mmap
2746	* read-write shared) accesses.
2747	*
2748	* get_write_access() gets write permission for a file.
2749	* put_write_access() releases this write permission.
2750	* deny_write_access() denies write access to a file.
2751	* allow_write_access() re-enables write access to a file.
2752	*
2753	* The i_writecount field of an inode can have the following values:
2754	* 0: no write access, no denied write access
2755	* < 0: (-i_writecount) users that denied write access to the file.
2756	* > 0: (i_writecount) users that have write access to the file.
2757	*
2758	* Normally we operate on that counter with atomic_{inc,dec} and it's safe
2759	* except for the cases where we don't hold i_writecount yet. Then we need to
2760	* use {get,deny}_write_access() - these functions check the sign and refuse
2761	* to do the change if sign is wrong.
2762	*/
2763	static inline int get_write_access(struct inode *inode)
2764	{
2765	return atomic_inc_unless_negative(v: &inode->i_writecount) ? `0` : -ETXTBSY;
2766	}
2767	static inline int deny_write_access(struct file *file)
2768	{
2769	struct inode *inode = file_inode(f: file);
2770	return atomic_dec_unless_positive(v: &inode->i_writecount) ? `0` : -ETXTBSY;
2771	}
2772	static inline void put_write_access(struct inode * inode)
2773	{
2774	atomic_dec(v: &inode->i_writecount);
2775	}
2776	static inline void allow_write_access(struct file *file)
2777	{
2778	if (file)
2779	atomic_inc(v: &file_inode(f: file)->i_writecount);
2780	}
2781
2782	/*
2783	* Do not prevent write to executable file when watched by pre-content events.
2784	*
2785	* Note that FMODE_FSNOTIFY_HSM mode is set depending on pre-content watches at
2786	* the time of file open and remains constant for entire lifetime of the file,
2787	* so if pre-content watches are added post execution or removed before the end
2788	* of the execution, it will not cause i_writecount reference leak.
2789	*/
2790	static inline int exe_file_deny_write_access(struct file *exe_file)
2791	{
2792	if (unlikely(FMODE_FSNOTIFY_HSM(exe_file->f_mode)))
2793	return `0`;
2794	return deny_write_access(file: exe_file);
2795	}
2796	static inline void exe_file_allow_write_access(struct file *exe_file)
2797	{
2798	if (You are visitor 01402520 — GeezerVison does not store the pages you look up. Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.