1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* ext4.h
4	*
5	* Copyright (C) 1992, 1993, 1994, 1995
6	* Remy Card (card@masi.ibp.fr)
7	* Laboratoire MASI - Institut Blaise Pascal
8	* Universite Pierre et Marie Curie (Paris VI)
9	*
10	* from
11	*
12	* linux/include/linux/minix_fs.h
13	*
14	* Copyright (C) 1991, 1992 Linus Torvalds
15	*/
16
17	#ifndef _EXT4_H
18	#define _EXT4_H
19
20	#include <linux/refcount.h>
21	#include <linux/types.h>
22	#include <linux/blkdev.h>
23	#include <linux/magic.h>
24	#include <linux/jbd2.h>
25	#include <linux/quota.h>
26	#include <linux/rwsem.h>
27	#include <linux/rbtree.h>
28	#include <linux/seqlock.h>
29	#include <linux/mutex.h>
30	#include <linux/timer.h>
31	#include <linux/wait.h>
32	#include <linux/sched/signal.h>
33	#include <linux/blockgroup_lock.h>
34	#include <linux/percpu_counter.h>
35	#include <linux/ratelimit.h>
36	#include <linux/crc32c.h>
37	#include <linux/falloc.h>
38	#include <linux/percpu-rwsem.h>
39	#include <linux/fiemap.h>
40	#ifdef __KERNEL__
41	#include <linux/compat.h>
42	#endif
43	#include <uapi/linux/ext4.h>
44
45	#include <linux/fscrypt.h>
46	#include <linux/fsverity.h>
47
48	#include <linux/compiler.h>
49
50	/*
51	* The fourth extended filesystem constants/structures
52	*/
53
54	/*
55	* with AGGRESSIVE_CHECK allocator runs consistency checks over
56	* structures. these checks slow things down a lot
57	*/
58	#define AGGRESSIVE_CHECK__
59
60	/*
61	* with DOUBLE_CHECK defined mballoc creates persistent in-core
62	* bitmaps, maintains and uses them to check for double allocations
63	*/
64	#define DOUBLE_CHECK__
65
66	/*
67	* Define EXT4FS_DEBUG to produce debug messages
68	*/
69	#undef EXT4FS_DEBUG
70
71	/*
72	* Debug code
73	*/
74	#ifdef EXT4FS_DEBUG
75	#define ext4_debug(f, a...) \
76	do { \
77	printk(KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:", \
78	__FILE__, __LINE__, __func__); \
79	printk(KERN_DEBUG f, ## a); \
80	} while (0)
81	#else
82	#define ext4_debug(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
83	#endif
84
85	/*
86	* Turn on EXT_DEBUG to enable ext4_ext_show_path/leaf/move in extents.c
87	*/
88	#define EXT_DEBUG__
89
90	/*
91	* Dynamic printk for controlled extents debugging.
92	*/
93	#ifdef CONFIG_EXT4_DEBUG
94	#define ext_debug(ino, fmt, ...) \
95	pr_debug("[%s/%d] EXT4-fs (%s): ino %lu: (%s, %d): %s:" fmt, \
96	current->comm, task_pid_nr(current), \
97	ino->i_sb->s_id, ino->i_ino, __FILE__, __LINE__, \
98	__func__, ##__VA_ARGS__)
99	#else
100	#define ext_debug(ino, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
101	#endif
102
103	#define ASSERT(assert) \
104	do { \
105	if (unlikely(!(assert))) { \
106	printk(KERN_EMERG \
107	"Assertion failure in %s() at %s:%d: '%s'\n", \
108	__func__, __FILE__, __LINE__, #assert); \
109	BUG(); \
110	} \
111	} while (0)
112
113	/* data type for block offset of block group */
114	typedef int ext4_grpblk_t;
115
116	/* data type for filesystem-wide blocks number */
117	typedef unsigned long long ext4_fsblk_t;
118
119	/* data type for file logical block number */
120	typedef __u32 ext4_lblk_t;
121
122	/* data type for block group number */
123	typedef unsigned int ext4_group_t;
124
125	enum SHIFT_DIRECTION {
126	SHIFT_LEFT = 0,
127	SHIFT_RIGHT,
128	};
129
130	/*
131	* For each criteria, mballoc has slightly different way of finding
132	* the required blocks nad usually, higher the criteria the slower the
133	* allocation. We start at lower criterias and keep falling back to
134	* higher ones if we are not able to find any blocks. Lower (earlier)
135	* criteria are faster.
136	*/
137	enum criteria {
138	/*
139	* Used when number of blocks needed is a power of 2. This
140	* doesn't trigger any disk IO except prefetch and is the
141	* fastest criteria.
142	*/
143	CR_POWER2_ALIGNED,
144
145	/*
146	* Tries to lookup in-memory data structures to find the most
147	* suitable group that satisfies goal request. No disk IO
148	* except block prefetch.
149	*/
150	CR_GOAL_LEN_FAST,
151
152	/*
153	* Same as CR_GOAL_LEN_FAST but is allowed to reduce the goal
154	* length to the best available length for faster allocation.
155	*/
156	CR_BEST_AVAIL_LEN,
157
158	/*
159	* Reads each block group sequentially, performing disk IO if
160	* necessary, to find find_suitable block group. Tries to
161	* allocate goal length but might trim the request if nothing
162	* is found after enough tries.
163	*/
164	CR_GOAL_LEN_SLOW,
165
166	/*
167	* Finds the first free set of blocks and allocates
168	* those. This is only used in rare cases when
169	* CR_GOAL_LEN_SLOW also fails to allocate anything.
170	*/
171	CR_ANY_FREE,
172
173	/*
174	* Number of criterias defined.
175	*/
176	EXT4_MB_NUM_CRS
177	};
178
179	/*
180	* Flags used in mballoc's allocation_context flags field.
181	*
182	* Also used to show what's going on for debugging purposes when the
183	* flag field is exported via the traceport interface
184	*/
185
186	/* prefer goal again. length */
187	#define EXT4_MB_HINT_MERGE 0x0001
188	/* blocks already reserved */
189	#define EXT4_MB_HINT_RESERVED 0x0002
190	/* metadata is being allocated */
191	#define EXT4_MB_HINT_METADATA 0x0004
192	/* first blocks in the file */
193	#define EXT4_MB_HINT_FIRST 0x0008
194	/* search for the best chunk */
195	#define EXT4_MB_HINT_BEST 0x0010
196	/* data is being allocated */
197	#define EXT4_MB_HINT_DATA 0x0020
198	/* don't preallocate (for tails) */
199	#define EXT4_MB_HINT_NOPREALLOC 0x0040
200	/* allocate for locality group */
201	#define EXT4_MB_HINT_GROUP_ALLOC 0x0080
202	/* allocate goal blocks or none */
203	#define EXT4_MB_HINT_GOAL_ONLY 0x0100
204	/* goal is meaningful */
205	#define EXT4_MB_HINT_TRY_GOAL 0x0200
206	/* blocks already pre-reserved by delayed allocation */
207	#define EXT4_MB_DELALLOC_RESERVED 0x0400
208	/* We are doing stream allocation */
209	#define EXT4_MB_STREAM_ALLOC 0x0800
210	/* Use reserved root blocks if needed */
211	#define EXT4_MB_USE_ROOT_BLOCKS 0x1000
212	/* Use blocks from reserved pool */
213	#define EXT4_MB_USE_RESERVED 0x2000
214	/* Do strict check for free blocks while retrying block allocation */
215	#define EXT4_MB_STRICT_CHECK 0x4000
216	/* Large fragment size list lookup succeeded at least once for
217	* CR_POWER2_ALIGNED */
218	#define EXT4_MB_CR_POWER2_ALIGNED_OPTIMIZED 0x8000
219	/* Avg fragment size rb tree lookup succeeded at least once for
220	* CR_GOAL_LEN_FAST */
221	#define EXT4_MB_CR_GOAL_LEN_FAST_OPTIMIZED 0x00010000
222	/* Avg fragment size rb tree lookup succeeded at least once for
223	* CR_BEST_AVAIL_LEN */
224	#define EXT4_MB_CR_BEST_AVAIL_LEN_OPTIMIZED 0x00020000
225
226	struct ext4_allocation_request {
227	/* target inode for block we're allocating */
228	struct inode *inode;
229	/* how many blocks we want to allocate */
230	unsigned int len;
231	/* logical block in target inode */
232	ext4_lblk_t logical;
233	/* the closest logical allocated block to the left */
234	ext4_lblk_t lleft;
235	/* the closest logical allocated block to the right */
236	ext4_lblk_t lright;
237	/* phys. target (a hint) */
238	ext4_fsblk_t goal;
239	/* phys. block for the closest logical allocated block to the left */
240	ext4_fsblk_t pleft;
241	/* phys. block for the closest logical allocated block to the right */
242	ext4_fsblk_t pright;
243	/* flags. see above EXT4_MB_HINT_* */
244	unsigned int flags;
245	};
246
247	/*
248	* Logical to physical block mapping, used by ext4_map_blocks()
249	*
250	* This structure is used to pass requests into ext4_map_blocks() as
251	* well as to store the information returned by ext4_map_blocks(). It
252	* takes less room on the stack than a struct buffer_head.
253	*/
254	#define EXT4_MAP_NEW BIT(BH_New)
255	#define EXT4_MAP_MAPPED BIT(BH_Mapped)
256	#define EXT4_MAP_UNWRITTEN BIT(BH_Unwritten)
257	#define EXT4_MAP_BOUNDARY BIT(BH_Boundary)
258	#define EXT4_MAP_DELAYED BIT(BH_Delay)
259	/*
260	* This is for use in ext4_map_query_blocks() for a special case where we can
261	* have a physically and logically contiguous blocks split across two leaf
262	* nodes instead of a single extent. This is required in case of atomic writes
263	* to know whether the returned extent is last in leaf. If yes, then lookup for
264	* next in leaf block in ext4_map_query_blocks_next_in_leaf().
265	* - This is never going to be added to any buffer head state.
266	* - We use the next available bit after BH_BITMAP_UPTODATE.
267	*/
268	#define EXT4_MAP_QUERY_LAST_IN_LEAF BIT(BH_BITMAP_UPTODATE + 1)
269	#define EXT4_MAP_FLAGS (EXT4_MAP_NEW | EXT4_MAP_MAPPED |\
270	EXT4_MAP_UNWRITTEN | EXT4_MAP_BOUNDARY |\
271	EXT4_MAP_DELAYED | EXT4_MAP_QUERY_LAST_IN_LEAF)
272
273	struct ext4_map_blocks {
274	ext4_fsblk_t m_pblk;
275	ext4_lblk_t m_lblk;
276	unsigned int m_len;
277	unsigned int m_flags;
278	};
279
280	/*
281	* Block validity checking, system zone rbtree.
282	*/
283	struct ext4_system_blocks {
284	struct rb_root root;
285	struct rcu_head rcu;
286	};
287
288	/*
289	* Flags for ext4_io_end->flags
290	*/
291	#define EXT4_IO_END_UNWRITTEN 0x0001
292	#define EXT4_IO_END_FAILED 0x0002
293
294	#define EXT4_IO_END_DEFER_COMPLETION (EXT4_IO_END_UNWRITTEN | EXT4_IO_END_FAILED)
295
296	struct ext4_io_end_vec {
297	struct list_head list; /* list of io_end_vec */
298	loff_t offset; /* offset in the file */
299	ssize_t size; /* size of the extent */
300	};
301
302	/*
303	* For converting unwritten extents on a work queue. 'handle' is used for
304	* buffered writeback.
305	*/
306	typedef struct ext4_io_end {
307	struct list_head list; /* per-file finished IO list */
308	handle_t *handle; /* handle reserved for extent
309	* conversion */
310	struct inode *inode; /* file being written to */
311	struct bio *bio; /* Linked list of completed
312	* bios covering the extent */
313	unsigned int flag; /* unwritten or not */
314	refcount_t count; /* reference counter */
315	struct list_head list_vec; /* list of ext4_io_end_vec */
316	} ext4_io_end_t;
317
318	struct ext4_io_submit {
319	struct writeback_control *io_wbc;
320	struct bio *io_bio;
321	ext4_io_end_t *io_end;
322	sector_t io_next_block;
323	};
324
325	/*
326	* Special inodes numbers
327	*/
328	#define EXT4_BAD_INO 1 /* Bad blocks inode */
329	#define EXT4_ROOT_INO 2 /* Root inode */
330	#define EXT4_USR_QUOTA_INO 3 /* User quota inode */
331	#define EXT4_GRP_QUOTA_INO 4 /* Group quota inode */
332	#define EXT4_BOOT_LOADER_INO 5 /* Boot loader inode */
333	#define EXT4_UNDEL_DIR_INO 6 /* Undelete directory inode */
334	#define EXT4_RESIZE_INO 7 /* Reserved group descriptors inode */
335	#define EXT4_JOURNAL_INO 8 /* Journal inode */
336
337	/* First non-reserved inode for old ext4 filesystems */
338	#define EXT4_GOOD_OLD_FIRST_INO 11
339
340	/*
341	* Maximal count of links to a file
342	*/
343	#define EXT4_LINK_MAX 65000
344
345	/*
346	* Macro-instructions used to manage several block sizes
347	*/
348	#define EXT4_MIN_BLOCK_SIZE 1024
349	#define EXT4_MAX_BLOCK_SIZE 65536
350	#define EXT4_MIN_BLOCK_LOG_SIZE 10
351	#define EXT4_MAX_BLOCK_LOG_SIZE 16
352	#define EXT4_MAX_CLUSTER_LOG_SIZE 30
353	#ifdef __KERNEL__
354	# define EXT4_BLOCK_SIZE(s) ((s)->s_blocksize)
355	#else
356	# define EXT4_BLOCK_SIZE(s) (EXT4_MIN_BLOCK_SIZE << (s)->s_log_block_size)
357	#endif
358	#define EXT4_ADDR_PER_BLOCK(s) (EXT4_BLOCK_SIZE(s) / sizeof(__u32))
359	#define EXT4_CLUSTER_SIZE(s) (EXT4_BLOCK_SIZE(s) << \
360	EXT4_SB(s)->s_cluster_bits)
361	#ifdef __KERNEL__
362	# define EXT4_BLOCK_SIZE_BITS(s) ((s)->s_blocksize_bits)
363	# define EXT4_CLUSTER_BITS(s) (EXT4_SB(s)->s_cluster_bits)
364	#else
365	# define EXT4_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10)
366	#endif
367	#ifdef __KERNEL__
368	#define EXT4_ADDR_PER_BLOCK_BITS(s) (EXT4_SB(s)->s_addr_per_block_bits)
369	#define EXT4_INODE_SIZE(s) (EXT4_SB(s)->s_inode_size)
370	#define EXT4_FIRST_INO(s) (EXT4_SB(s)->s_first_ino)
371	#else
372	#define EXT4_INODE_SIZE(s) (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \
373	EXT4_GOOD_OLD_INODE_SIZE : \
374	(s)->s_inode_size)
375	#define EXT4_FIRST_INO(s) (((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \
376	EXT4_GOOD_OLD_FIRST_INO : \
377	(s)->s_first_ino)
378	#endif
379	#define EXT4_BLOCK_ALIGN(size, blkbits) ALIGN((size), (1 << (blkbits)))
380	#define EXT4_MAX_BLOCKS(size, offset, blkbits) \
381	((EXT4_BLOCK_ALIGN(size + offset, blkbits) >> blkbits) - (offset >> \
382	blkbits))
383	#define EXT4_B_TO_LBLK(inode, offset) \
384	(round_up((offset), i_blocksize(inode)) >> (inode)->i_blkbits)
385
386	/* Translate a block number to a cluster number */
387	#define EXT4_B2C(sbi, blk) ((blk) >> (sbi)->s_cluster_bits)
388	/* Translate a cluster number to a block number */
389	#define EXT4_C2B(sbi, cluster) ((cluster) << (sbi)->s_cluster_bits)
390	/* Translate # of blks to # of clusters */
391	#define EXT4_NUM_B2C(sbi, blks) (((blks) + (sbi)->s_cluster_ratio - 1) >> \
392	(sbi)->s_cluster_bits)
393	/* Mask out the low bits to get the starting block of the cluster */
394	#define EXT4_PBLK_CMASK(s, pblk) ((pblk) & \
395	~((ext4_fsblk_t) (s)->s_cluster_ratio - 1))
396	#define EXT4_LBLK_CMASK(s, lblk) ((lblk) & \
397	~((ext4_lblk_t) (s)->s_cluster_ratio - 1))
398	/* Fill in the low bits to get the last block of the cluster */
399	#define EXT4_LBLK_CFILL(sbi, lblk) ((lblk) | \
400	((ext4_lblk_t) (sbi)->s_cluster_ratio - 1))
401	/* Get the cluster offset */
402	#define EXT4_PBLK_COFF(s, pblk) ((pblk) & \
403	((ext4_fsblk_t) (s)->s_cluster_ratio - 1))
404	#define EXT4_LBLK_COFF(s, lblk) ((lblk) & \
405	((ext4_lblk_t) (s)->s_cluster_ratio - 1))
406
407	/*
408	* Structure of a blocks group descriptor
409	*/
410	struct ext4_group_desc
411	{
412	__le32 bg_block_bitmap_lo; /* Blocks bitmap block */
413	__le32 bg_inode_bitmap_lo; /* Inodes bitmap block */
414	__le32 bg_inode_table_lo; /* Inodes table block */
415	__le16 bg_free_blocks_count_lo;/* Free blocks count */
416	__le16 bg_free_inodes_count_lo;/* Free inodes count */
417	__le16 bg_used_dirs_count_lo; /* Directories count */
418	__le16 bg_flags; /* EXT4_BG_flags (INODE_UNINIT, etc) */
419	__le32 bg_exclude_bitmap_lo; /* Exclude bitmap for snapshots */
420	__le16 bg_block_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bbitmap) LE */
421	__le16 bg_inode_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+ibitmap) LE */
422	__le16 bg_itable_unused_lo; /* Unused inodes count */
423	__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
424	__le32 bg_block_bitmap_hi; /* Blocks bitmap block MSB */
425	__le32 bg_inode_bitmap_hi; /* Inodes bitmap block MSB */
426	__le32 bg_inode_table_hi; /* Inodes table block MSB */
427	__le16 bg_free_blocks_count_hi;/* Free blocks count MSB */
428	__le16 bg_free_inodes_count_hi;/* Free inodes count MSB */
429	__le16 bg_used_dirs_count_hi; /* Directories count MSB */
430	__le16 bg_itable_unused_hi; /* Unused inodes count MSB */
431	__le32 bg_exclude_bitmap_hi; /* Exclude bitmap block MSB */
432	__le16 bg_block_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+bbitmap) BE */
433	__le16 bg_inode_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+ibitmap) BE */
434	__u32 bg_reserved;
435	};
436
437	#define EXT4_BG_INODE_BITMAP_CSUM_HI_END \
438	(offsetof(struct ext4_group_desc, bg_inode_bitmap_csum_hi) + \
439	sizeof(__le16))
440	#define EXT4_BG_BLOCK_BITMAP_CSUM_HI_END \
441	(offsetof(struct ext4_group_desc, bg_block_bitmap_csum_hi) + \
442	sizeof(__le16))
443
444	/*
445	* Structure of a flex block group info
446	*/
447
448	struct flex_groups {
449	atomic64_t free_clusters;
450	atomic_t free_inodes;
451	atomic_t used_dirs;
452	};
453
454	#define EXT4_BG_INODE_UNINIT 0x0001 /* Inode table/bitmap not in use */
455	#define EXT4_BG_BLOCK_UNINIT 0x0002 /* Block bitmap not in use */
456	#define EXT4_BG_INODE_ZEROED 0x0004 /* On-disk itable initialized to zero */
457
458	/*
459	* Macro-instructions used to manage group descriptors
460	*/
461	#define EXT4_MIN_DESC_SIZE 32
462	#define EXT4_MIN_DESC_SIZE_64BIT 64
463	#define EXT4_MAX_DESC_SIZE EXT4_MIN_BLOCK_SIZE
464	#define EXT4_DESC_SIZE(s) (EXT4_SB(s)->s_desc_size)
465	#ifdef __KERNEL__
466	# define EXT4_BLOCKS_PER_GROUP(s) (EXT4_SB(s)->s_blocks_per_group)
467	# define EXT4_CLUSTERS_PER_GROUP(s) (EXT4_SB(s)->s_clusters_per_group)
468	# define EXT4_DESC_PER_BLOCK(s) (EXT4_SB(s)->s_desc_per_block)
469	# define EXT4_INODES_PER_GROUP(s) (EXT4_SB(s)->s_inodes_per_group)
470	# define EXT4_DESC_PER_BLOCK_BITS(s) (EXT4_SB(s)->s_desc_per_block_bits)
471	#else
472	# define EXT4_BLOCKS_PER_GROUP(s) ((s)->s_blocks_per_group)
473	# define EXT4_DESC_PER_BLOCK(s) (EXT4_BLOCK_SIZE(s) / EXT4_DESC_SIZE(s))
474	# define EXT4_INODES_PER_GROUP(s) ((s)->s_inodes_per_group)
475	#endif
476
477	/*
478	* Constants relative to the data blocks
479	*/
480	#define EXT4_NDIR_BLOCKS 12
481	#define EXT4_IND_BLOCK EXT4_NDIR_BLOCKS
482	#define EXT4_DIND_BLOCK (EXT4_IND_BLOCK + 1)
483	#define EXT4_TIND_BLOCK (EXT4_DIND_BLOCK + 1)
484	#define EXT4_N_BLOCKS (EXT4_TIND_BLOCK + 1)
485
486	/*
487	* Inode flags
488	*/
489	#define EXT4_SECRM_FL 0x00000001 /* Secure deletion */
490	#define EXT4_UNRM_FL 0x00000002 /* Undelete */
491	#define EXT4_COMPR_FL 0x00000004 /* Compress file */
492	#define EXT4_SYNC_FL 0x00000008 /* Synchronous updates */
493	#define EXT4_IMMUTABLE_FL 0x00000010 /* Immutable file */
494	#define EXT4_APPEND_FL 0x00000020 /* writes to file may only append */
495	#define EXT4_NODUMP_FL 0x00000040 /* do not dump file */
496	#define EXT4_NOATIME_FL 0x00000080 /* do not update atime */
497	/* Reserved for compression usage... */
498	#define EXT4_DIRTY_FL 0x00000100
499	#define EXT4_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
500	#define EXT4_NOCOMPR_FL 0x00000400 /* Don't compress */
501	/* nb: was previously EXT2_ECOMPR_FL */
502	#define EXT4_ENCRYPT_FL 0x00000800 /* encrypted file */
503	/* End compression flags --- maybe not all used */
504	#define EXT4_INDEX_FL 0x00001000 /* hash-indexed directory */
505	#define EXT4_IMAGIC_FL 0x00002000 /* AFS directory */
506	#define EXT4_JOURNAL_DATA_FL 0x00004000 /* file data should be journaled */
507	#define EXT4_NOTAIL_FL 0x00008000 /* file tail should not be merged */
508	#define EXT4_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
509	#define EXT4_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
510	#define EXT4_HUGE_FILE_FL 0x00040000 /* Set to each huge file */
511	#define EXT4_EXTENTS_FL 0x00080000 /* Inode uses extents */
512	#define EXT4_VERITY_FL 0x00100000 /* Verity protected inode */
513	#define EXT4_EA_INODE_FL 0x00200000 /* Inode used for large EA */
514	/* 0x00400000 was formerly EXT4_EOFBLOCKS_FL */
515
516	#define EXT4_DAX_FL 0x02000000 /* Inode is DAX */
517
518	#define EXT4_INLINE_DATA_FL 0x10000000 /* Inode has inline data. */
519	#define EXT4_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
520	#define EXT4_CASEFOLD_FL 0x40000000 /* Casefolded directory */
521	#define EXT4_RESERVED_FL 0x80000000 /* reserved for ext4 lib */
522
523	/* User modifiable flags */
524	#define EXT4_FL_USER_MODIFIABLE (EXT4_SECRM_FL | \
525	EXT4_UNRM_FL | \
526	EXT4_COMPR_FL | \
527	EXT4_SYNC_FL | \
528	EXT4_IMMUTABLE_FL | \
529	EXT4_APPEND_FL | \
530	EXT4_NODUMP_FL | \
531	EXT4_NOATIME_FL | \
532	EXT4_JOURNAL_DATA_FL | \
533	EXT4_NOTAIL_FL | \
534	EXT4_DIRSYNC_FL | \
535	EXT4_TOPDIR_FL | \
536	EXT4_EXTENTS_FL | \
537	0x00400000 /* EXT4_EOFBLOCKS_FL */ | \
538	EXT4_DAX_FL | \
539	EXT4_PROJINHERIT_FL | \
540	EXT4_CASEFOLD_FL)
541
542	/* User visible flags */
543	#define EXT4_FL_USER_VISIBLE (EXT4_FL_USER_MODIFIABLE | \
544	EXT4_DIRTY_FL | \
545	EXT4_COMPRBLK_FL | \
546	EXT4_NOCOMPR_FL | \
547	EXT4_ENCRYPT_FL | \
548	EXT4_INDEX_FL | \
549	EXT4_VERITY_FL | \
550	EXT4_INLINE_DATA_FL)
551
552	/* Flags that should be inherited by new inodes from their parent. */
553	#define EXT4_FL_INHERITED (EXT4_SECRM_FL | EXT4_UNRM_FL | EXT4_COMPR_FL |\
554	EXT4_SYNC_FL | EXT4_NODUMP_FL | EXT4_NOATIME_FL |\
555	EXT4_NOCOMPR_FL | EXT4_JOURNAL_DATA_FL |\
556	EXT4_NOTAIL_FL | EXT4_DIRSYNC_FL |\
557	EXT4_PROJINHERIT_FL | EXT4_CASEFOLD_FL |\
558	EXT4_DAX_FL)
559
560	/* Flags that are appropriate for regular files (all but dir-specific ones). */
561	#define EXT4_REG_FLMASK (~(EXT4_DIRSYNC_FL | EXT4_TOPDIR_FL | EXT4_CASEFOLD_FL |\
562	EXT4_PROJINHERIT_FL))
563
564	/* Flags that are appropriate for non-directories/regular files. */
565	#define EXT4_OTHER_FLMASK (EXT4_NODUMP_FL | EXT4_NOATIME_FL)
566
567	/* The only flags that should be swapped */
568	#define EXT4_FL_SHOULD_SWAP (EXT4_HUGE_FILE_FL | EXT4_EXTENTS_FL)
569
570	/* Flags which are mutually exclusive to DAX */
571	#define EXT4_DAX_MUT_EXCL (EXT4_VERITY_FL | EXT4_ENCRYPT_FL |\
572	EXT4_JOURNAL_DATA_FL | EXT4_INLINE_DATA_FL)
573
574	/* Mask out flags that are inappropriate for the given type of inode. */
575	static inline __u32 ext4_mask_flags(umode_t mode, __u32 flags)
576	{
577	if (S_ISDIR(mode))
578	return flags;
579	else if (S_ISREG(mode))
580	return flags & EXT4_REG_FLMASK;
581	else
582	return flags & EXT4_OTHER_FLMASK;
583	}
584
585	/*
586	* Inode flags used for atomic set/get
587	*/
588	enum {
589	EXT4_INODE_SECRM = 0, /* Secure deletion */
590	EXT4_INODE_UNRM = 1, /* Undelete */
591	EXT4_INODE_COMPR = 2, /* Compress file */
592	EXT4_INODE_SYNC = 3, /* Synchronous updates */
593	EXT4_INODE_IMMUTABLE = 4, /* Immutable file */
594	EXT4_INODE_APPEND = 5, /* writes to file may only append */
595	EXT4_INODE_NODUMP = 6, /* do not dump file */
596	EXT4_INODE_NOATIME = 7, /* do not update atime */
597	/* Reserved for compression usage... */
598	EXT4_INODE_DIRTY = 8,
599	EXT4_INODE_COMPRBLK = 9, /* One or more compressed clusters */
600	EXT4_INODE_NOCOMPR = 10, /* Don't compress */
601	EXT4_INODE_ENCRYPT = 11, /* Encrypted file */
602	/* End compression flags --- maybe not all used */
603	EXT4_INODE_INDEX = 12, /* hash-indexed directory */
604	EXT4_INODE_IMAGIC = 13, /* AFS directory */
605	EXT4_INODE_JOURNAL_DATA = 14, /* file data should be journaled */
606	EXT4_INODE_NOTAIL = 15, /* file tail should not be merged */
607	EXT4_INODE_DIRSYNC = 16, /* dirsync behaviour (directories only) */
608	EXT4_INODE_TOPDIR = 17, /* Top of directory hierarchies*/
609	EXT4_INODE_HUGE_FILE = 18, /* Set to each huge file */
610	EXT4_INODE_EXTENTS = 19, /* Inode uses extents */
611	EXT4_INODE_VERITY = 20, /* Verity protected inode */
612	EXT4_INODE_EA_INODE = 21, /* Inode used for large EA */
613	/* 22 was formerly EXT4_INODE_EOFBLOCKS */
614	EXT4_INODE_DAX = 25, /* Inode is DAX */
615	EXT4_INODE_INLINE_DATA = 28, /* Data in inode. */
616	EXT4_INODE_PROJINHERIT = 29, /* Create with parents projid */
617	EXT4_INODE_CASEFOLD = 30, /* Casefolded directory */
618	EXT4_INODE_RESERVED = 31, /* reserved for ext4 lib */
619	};
620
621	/*
622	* Since it's pretty easy to mix up bit numbers and hex values, we use a
623	* build-time check to make sure that EXT4_XXX_FL is consistent with respect to
624	* EXT4_INODE_XXX. If all is well, the macros will be dropped, so, it won't cost
625	* any extra space in the compiled kernel image, otherwise, the build will fail.
626	* It's important that these values are the same, since we are using
627	* EXT4_INODE_XXX to test for flag values, but EXT4_XXX_FL must be consistent
628	* with the values of FS_XXX_FL defined in include/linux/fs.h and the on-disk
629	* values found in ext2, ext3 and ext4 filesystems, and of course the values
630	* defined in e2fsprogs.
631	*
632	* It's not paranoia if the Murphy's Law really *is* out to get you. :-)
633	*/
634	#define TEST_FLAG_VALUE(FLAG) (EXT4_##FLAG##_FL == (1U << EXT4_INODE_##FLAG))
635	#define CHECK_FLAG_VALUE(FLAG) BUILD_BUG_ON(!TEST_FLAG_VALUE(FLAG))
636
637	static inline void ext4_check_flag_values(void)
638	{
639	CHECK_FLAG_VALUE(SECRM);
640	CHECK_FLAG_VALUE(UNRM);
641	CHECK_FLAG_VALUE(COMPR);
642	CHECK_FLAG_VALUE(SYNC);
643	CHECK_FLAG_VALUE(IMMUTABLE);
644	CHECK_FLAG_VALUE(APPEND);
645	CHECK_FLAG_VALUE(NODUMP);
646	CHECK_FLAG_VALUE(NOATIME);
647	CHECK_FLAG_VALUE(DIRTY);
648	CHECK_FLAG_VALUE(COMPRBLK);
649	CHECK_FLAG_VALUE(NOCOMPR);
650	CHECK_FLAG_VALUE(ENCRYPT);
651	CHECK_FLAG_VALUE(INDEX);
652	CHECK_FLAG_VALUE(IMAGIC);
653	CHECK_FLAG_VALUE(JOURNAL_DATA);
654	CHECK_FLAG_VALUE(NOTAIL);
655	CHECK_FLAG_VALUE(DIRSYNC);
656	CHECK_FLAG_VALUE(TOPDIR);
657	CHECK_FLAG_VALUE(HUGE_FILE);
658	CHECK_FLAG_VALUE(EXTENTS);
659	CHECK_FLAG_VALUE(VERITY);
660	CHECK_FLAG_VALUE(EA_INODE);
661	CHECK_FLAG_VALUE(INLINE_DATA);
662	CHECK_FLAG_VALUE(PROJINHERIT);
663	CHECK_FLAG_VALUE(CASEFOLD);
664	CHECK_FLAG_VALUE(RESERVED);
665	}
666
667	#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
668	struct compat_ext4_new_group_input {
669	u32 group;
670	compat_u64 block_bitmap;
671	compat_u64 inode_bitmap;
672	compat_u64 inode_table;
673	u32 blocks_count;
674	u16 reserved_blocks;
675	u16 unused;
676	};
677	#endif
678
679	/* The struct ext4_new_group_input in kernel space, with free_blocks_count */
680	struct ext4_new_group_data {
681	__u32 group;
682	__u64 block_bitmap;
683	__u64 inode_bitmap;
684	__u64 inode_table;
685	__u32 blocks_count;
686	__u16 reserved_blocks;
687	__u16 mdata_blocks;
688	__u32 free_clusters_count;
689	};
690
691	/* Indexes used to index group tables in ext4_new_group_data */
692	enum {
693	BLOCK_BITMAP = 0, /* block bitmap */
694	INODE_BITMAP, /* inode bitmap */
695	INODE_TABLE, /* inode tables */
696	GROUP_TABLE_COUNT,
697	};
698
699	/*
700	* Flags used by ext4_map_blocks()
701	*/
702	/* Allocate any needed blocks and/or convert an unwritten
703	extent to be an initialized ext4 */
704	#define EXT4_GET_BLOCKS_CREATE 0x0001
705	/* Request the creation of an unwritten extent */
706	#define EXT4_GET_BLOCKS_UNWRIT_EXT 0x0002
707	#define EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT (EXT4_GET_BLOCKS_UNWRIT_EXT|\
708	EXT4_GET_BLOCKS_CREATE)
709	/* Caller is from the delayed allocation writeout path
710	* finally doing the actual allocation of delayed blocks */
711	#define EXT4_GET_BLOCKS_DELALLOC_RESERVE 0x0004
712	/* caller is from the direct IO path, request to creation of an
713	unwritten extents if not allocated, split the unwritten
714	extent if blocks has been preallocated already*/
715	#define EXT4_GET_BLOCKS_PRE_IO 0x0008
716	#define EXT4_GET_BLOCKS_CONVERT 0x0010
717	#define EXT4_GET_BLOCKS_IO_CREATE_EXT (EXT4_GET_BLOCKS_PRE_IO|\
718	EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT)
719	/* Eventual metadata allocation (due to growing extent tree)
720	* should not fail, so try to use reserved blocks for that.*/
721	#define EXT4_GET_BLOCKS_METADATA_NOFAIL 0x0020
722	/* Don't normalize allocation size (used for fallocate) */
723	#define EXT4_GET_BLOCKS_NO_NORMALIZE 0x0040
724	/* Convert written extents to unwritten */
725	#define EXT4_GET_BLOCKS_CONVERT_UNWRITTEN 0x0100
726	/* Write zeros to newly created written extents */
727	#define EXT4_GET_BLOCKS_ZERO 0x0200
728	#define EXT4_GET_BLOCKS_CREATE_ZERO (EXT4_GET_BLOCKS_CREATE |\
729	EXT4_GET_BLOCKS_ZERO)
730	/* Caller is in the context of data submission, such as writeback,
731	* fsync, etc. Especially, in the generic writeback path, caller will
732	* submit data before dropping transaction handle. This allows jbd2
733	* to avoid submitting data before commit. */
734	#define EXT4_GET_BLOCKS_IO_SUBMIT 0x0400
735	/* Convert extent to initialized after IO complete */
736	#define EXT4_GET_BLOCKS_IO_CONVERT_EXT (EXT4_GET_BLOCKS_CONVERT |\
737	EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT |\
738	EXT4_GET_BLOCKS_IO_SUBMIT)
739	/* Caller is in the atomic contex, find extent if it has been cached */
740	#define EXT4_GET_BLOCKS_CACHED_NOWAIT 0x0800
741	/*
742	* Atomic write caller needs this to query in the slow path of mixed mapping
743	* case, when a contiguous extent can be split across two adjacent leaf nodes.
744	* Look EXT4_MAP_QUERY_LAST_IN_LEAF.
745	*/
746	#define EXT4_GET_BLOCKS_QUERY_LAST_IN_LEAF 0x1000
747
748	/*
749	* The bit position of these flags must not overlap with any of the
750	* EXT4_GET_BLOCKS_*. They are used by ext4_find_extent(),
751	* read_extent_tree_block(), ext4_split_extent_at(),
752	* ext4_ext_insert_extent(), and ext4_ext_create_new_leaf().
753	* EXT4_EX_NOCACHE is used to indicate that the we shouldn't be
754	* caching the extents when reading from the extent tree while a
755	* truncate or punch hole operation is in progress.
756	*/
757	#define EXT4_EX_NOCACHE 0x40000000
758	#define EXT4_EX_FORCE_CACHE 0x20000000
759	#define EXT4_EX_NOFAIL 0x10000000
760	/*
761	* ext4_map_query_blocks() uses this filter mask to filter the flags needed to
762	* pass while lookup/querying of on disk extent tree.
763	*/
764	#define EXT4_EX_QUERY_FILTER (EXT4_EX_NOCACHE | EXT4_EX_FORCE_CACHE |\
765	EXT4_EX_NOFAIL |\
766	EXT4_GET_BLOCKS_QUERY_LAST_IN_LEAF)
767
768	/*
769	* Flags used by ext4_free_blocks
770	*/
771	#define EXT4_FREE_BLOCKS_METADATA 0x0001
772	#define EXT4_FREE_BLOCKS_FORGET 0x0002
773	#define EXT4_FREE_BLOCKS_VALIDATED 0x0004
774	#define EXT4_FREE_BLOCKS_NO_QUOT_UPDATE 0x0008
775	#define EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER 0x0010
776	#define EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER 0x0020
777	#define EXT4_FREE_BLOCKS_RERESERVE_CLUSTER 0x0040
778
779	#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
780	/*
781	* ioctl commands in 32 bit emulation
782	*/
783	#define EXT4_IOC32_GETVERSION _IOR('f', 3, int)
784	#define EXT4_IOC32_SETVERSION _IOW('f', 4, int)
785	#define EXT4_IOC32_GETRSVSZ _IOR('f', 5, int)
786	#define EXT4_IOC32_SETRSVSZ _IOW('f', 6, int)
787	#define EXT4_IOC32_GROUP_EXTEND _IOW('f', 7, unsigned int)
788	#define EXT4_IOC32_GROUP_ADD _IOW('f', 8, struct compat_ext4_new_group_input)
789	#define EXT4_IOC32_GETVERSION_OLD FS_IOC32_GETVERSION
790	#define EXT4_IOC32_SETVERSION_OLD FS_IOC32_SETVERSION
791	#endif
792
793	/* Max physical block we can address w/o extents */
794	#define EXT4_MAX_BLOCK_FILE_PHYS 0xFFFFFFFF
795
796	/* Max logical block we can support */
797	#define EXT4_MAX_LOGICAL_BLOCK 0xFFFFFFFE
798
799	/*
800	* Structure of an inode on the disk
801	*/
802	struct ext4_inode {
803	__le16 i_mode; /* File mode */
804	__le16 i_uid; /* Low 16 bits of Owner Uid */
805	__le32 i_size_lo; /* Size in bytes */
806	__le32 i_atime; /* Access time */
807	__le32 i_ctime; /* Inode Change time */
808	__le32 i_mtime; /* Modification time */
809	__le32 i_dtime; /* Deletion Time */
810	__le16 i_gid; /* Low 16 bits of Group Id */
811	__le16 i_links_count; /* Links count */
812	__le32 i_blocks_lo; /* Blocks count */
813	__le32 i_flags; /* File flags */
814	union {
815	struct {
816	__le32 l_i_version;
817	} linux1;
818	struct {
819	__u32 h_i_translator;
820	} hurd1;
821	struct {
822	__u32 m_i_reserved1;
823	} masix1;
824	} osd1; /* OS dependent 1 */
825	__le32 i_block[EXT4_N_BLOCKS];/* Pointers to blocks */
826	__le32 i_generation; /* File version (for NFS) */
827	__le32 i_file_acl_lo; /* File ACL */
828	__le32 i_size_high;
829	__le32 i_obso_faddr; /* Obsoleted fragment address */
830	union {
831	struct {
832	__le16 l_i_blocks_high; /* were l_i_reserved1 */
833	__le16 l_i_file_acl_high;
834	__le16 l_i_uid_high; /* these 2 fields */
835	__le16 l_i_gid_high; /* were reserved2[0] */
836	__le16 l_i_checksum_lo;/* crc32c(uuid+inum+inode) LE */
837	__le16 l_i_reserved;
838	} linux2;
839	struct {
840	__le16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */
841	__u16 h_i_mode_high;
842	__u16 h_i_uid_high;
843	__u16 h_i_gid_high;
844	__u32 h_i_author;
845	} hurd2;
846	struct {
847	__le16 h_i_reserved1; /* Obsoleted fragment number/size which are removed in ext4 */
848	__le16 m_i_file_acl_high;
849	__u32 m_i_reserved2[2];
850	} masix2;
851	} osd2; /* OS dependent 2 */
852	__le16 i_extra_isize;
853	__le16 i_checksum_hi; /* crc32c(uuid+inum+inode) BE */
854	__le32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */
855	__le32 i_mtime_extra; /* extra Modification time(nsec << 2 | epoch) */
856	__le32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
857	__le32 i_crtime; /* File Creation time */
858	__le32 i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
859	__le32 i_version_hi; /* high 32 bits for 64-bit version */
860	__le32 i_projid; /* Project ID */
861	};
862
863	#define EXT4_EPOCH_BITS 2
864	#define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
865	#define EXT4_NSEC_MASK (~0UL << EXT4_EPOCH_BITS)
866
867	/*
868	* Extended fields will fit into an inode if the filesystem was formatted
869	* with large inodes (-I 256 or larger) and there are not currently any EAs
870	* consuming all of the available space. For new inodes we always reserve
871	* enough space for the kernel's known extended fields, but for inodes
872	* created with an old kernel this might not have been the case. None of
873	* the extended inode fields is critical for correct filesystem operation.
874	* This macro checks if a certain field fits in the inode. Note that
875	* inode-size = GOOD_OLD_INODE_SIZE + i_extra_isize
876	*/
877	#define EXT4_FITS_IN_INODE(ext4_inode, einode, field) \
878	((offsetof(typeof(*ext4_inode), field) + \
879	sizeof((ext4_inode)->field)) \
880	<= (EXT4_GOOD_OLD_INODE_SIZE + \
881	(einode)->i_extra_isize)) \
882
883	/*
884	* We use an encoding that preserves the times for extra epoch "00":
885	*
886	* extra msb of adjust for signed
887	* epoch 32-bit 32-bit tv_sec to
888	* bits time decoded 64-bit tv_sec 64-bit tv_sec valid time range
889	* 0 0 1 -0x80000000..-0x00000001 0x000000000 1901-12-13..1969-12-31
890	* 0 0 0 0x000000000..0x07fffffff 0x000000000 1970-01-01..2038-01-19
891	* 0 1 1 0x080000000..0x0ffffffff 0x100000000 2038-01-19..2106-02-07
892	* 0 1 0 0x100000000..0x17fffffff 0x100000000 2106-02-07..2174-02-25
893	* 1 0 1 0x180000000..0x1ffffffff 0x200000000 2174-02-25..2242-03-16
894	* 1 0 0 0x200000000..0x27fffffff 0x200000000 2242-03-16..2310-04-04
895	* 1 1 1 0x280000000..0x2ffffffff 0x300000000 2310-04-04..2378-04-22
896	* 1 1 0 0x300000000..0x37fffffff 0x300000000 2378-04-22..2446-05-10
897	*
898	* Note that previous versions of the kernel on 64-bit systems would
899	* incorrectly use extra epoch bits 1,1 for dates between 1901 and
900	* 1970. e2fsck will correct this, assuming that it is run on the
901	* affected filesystem before 2242.
902	*/
903
904	static inline __le32 ext4_encode_extra_time(struct timespec64 ts)
905	{
906	u32 extra = ((ts.tv_sec - (s32)ts.tv_sec) >> 32) & EXT4_EPOCH_MASK;
907	return cpu_to_le32(extra | (ts.tv_nsec << EXT4_EPOCH_BITS));
908	}
909
910	static inline struct timespec64 ext4_decode_extra_time(__le32 base,
911	__le32 extra)
912	{
913	struct timespec64 ts = { .tv_sec = (signed)le32_to_cpu(base) };
914
915	if (unlikely(extra & cpu_to_le32(EXT4_EPOCH_MASK)))
916	ts.tv_sec += (u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK) << 32;
917	ts.tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
918	return ts;
919	}
920
921	#define EXT4_INODE_SET_XTIME_VAL(xtime, inode, raw_inode, ts) \
922	do { \
923	if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra)) { \
924	(raw_inode)->xtime = cpu_to_le32((ts).tv_sec); \
925	(raw_inode)->xtime ## _extra = ext4_encode_extra_time(ts); \
926	} else \
927	(raw_inode)->xtime = cpu_to_le32(clamp_t(int32_t, (ts).tv_sec, S32_MIN, S32_MAX)); \
928	} while (0)
929
930	#define EXT4_INODE_SET_ATIME(inode, raw_inode) \
931	EXT4_INODE_SET_XTIME_VAL(i_atime, inode, raw_inode, inode_get_atime(inode))
932
933	#define EXT4_INODE_SET_MTIME(inode, raw_inode) \
934	EXT4_INODE_SET_XTIME_VAL(i_mtime, inode, raw_inode, inode_get_mtime(inode))
935
936	#define EXT4_INODE_SET_CTIME(inode, raw_inode) \
937	EXT4_INODE_SET_XTIME_VAL(i_ctime, inode, raw_inode, inode_get_ctime(inode))
938
939	#define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode) \
940	if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime)) \
941	EXT4_INODE_SET_XTIME_VAL(xtime, &((einode)->vfs_inode), \
942	raw_inode, (einode)->xtime)
943
944	#define EXT4_INODE_GET_XTIME_VAL(xtime, inode, raw_inode) \
945	(EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra) ? \
946	ext4_decode_extra_time((raw_inode)->xtime, \
947	(raw_inode)->xtime ## _extra) : \
948	(struct timespec64) { \
949	.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime) \
950	})
951
952	#define EXT4_INODE_GET_ATIME(inode, raw_inode) \
953	do { \
954	inode_set_atime_to_ts(inode, \
955	EXT4_INODE_GET_XTIME_VAL(i_atime, inode, raw_inode)); \
956	} while (0)
957
958	#define EXT4_INODE_GET_MTIME(inode, raw_inode) \
959	do { \
960	inode_set_mtime_to_ts(inode, \
961	EXT4_INODE_GET_XTIME_VAL(i_mtime, inode, raw_inode)); \
962	} while (0)
963
964	#define EXT4_INODE_GET_CTIME(inode, raw_inode) \
965	do { \
966	inode_set_ctime_to_ts(inode, \
967	EXT4_INODE_GET_XTIME_VAL(i_ctime, inode, raw_inode)); \
968	} while (0)
969
970	#define EXT4_EINODE_GET_XTIME(xtime, einode, raw_inode) \
971	do { \
972	if (EXT4_FITS_IN_INODE(raw_inode, einode, xtime)) \
973	(einode)->xtime = \
974	EXT4_INODE_GET_XTIME_VAL(xtime, &(einode->vfs_inode), \
975	raw_inode); \
976	else \
977	(einode)->xtime = (struct timespec64){0, 0}; \
978	} while (0)
979
980	#define i_disk_version osd1.linux1.l_i_version
981
982	#if defined(__KERNEL__) || defined(__linux__)
983	#define i_reserved1 osd1.linux1.l_i_reserved1
984	#define i_file_acl_high osd2.linux2.l_i_file_acl_high
985	#define i_blocks_high osd2.linux2.l_i_blocks_high
986	#define i_uid_low i_uid
987	#define i_gid_low i_gid
988	#define i_uid_high osd2.linux2.l_i_uid_high
989	#define i_gid_high osd2.linux2.l_i_gid_high
990	#define i_checksum_lo osd2.linux2.l_i_checksum_lo
991
992	#elif defined(__GNU__)
993
994	#define i_translator osd1.hurd1.h_i_translator
995	#define i_uid_high osd2.hurd2.h_i_uid_high
996	#define i_gid_high osd2.hurd2.h_i_gid_high
997	#define i_author osd2.hurd2.h_i_author
998
999	#elif defined(__masix__)
1000
1001	#define i_reserved1 osd1.masix1.m_i_reserved1
1002	#define i_file_acl_high osd2.masix2.m_i_file_acl_high
1003	#define i_reserved2 osd2.masix2.m_i_reserved2
1004
1005	#endif /* defined(__KERNEL__) || defined(__linux__) */
1006
1007	#include "extents_status.h"
1008	#include "fast_commit.h"
1009
1010	/*
1011	* Lock subclasses for i_data_sem in the ext4_inode_info structure.
1012	*
1013	* These are needed to avoid lockdep false positives when we need to
1014	* allocate blocks to the quota inode during ext4_map_blocks(), while
1015	* holding i_data_sem for a normal (non-quota) inode. Since we don't
1016	* do quota tracking for the quota inode, this avoids deadlock (as
1017	* well as infinite recursion, since it isn't turtles all the way
1018	* down...)
1019	*
1020	* I_DATA_SEM_NORMAL - Used for most inodes
1021	* I_DATA_SEM_OTHER - Used by move_inode.c for the second normal inode
1022	* where the second inode has larger inode number
1023	* than the first
1024	* I_DATA_SEM_QUOTA - Used for quota inodes only
1025	* I_DATA_SEM_EA - Used for ea_inodes only
1026	*/
1027	enum {
1028	I_DATA_SEM_NORMAL = 0,
1029	I_DATA_SEM_OTHER,
1030	I_DATA_SEM_QUOTA,
1031	I_DATA_SEM_EA
1032	};
1033
1034
1035	/*
1036	* fourth extended file system inode data in memory
1037	*/
1038	struct ext4_inode_info {
1039	__le32 i_data[15]; /* unconverted */
1040	__u32 i_dtime;
1041	ext4_fsblk_t i_file_acl;
1042
1043	/*
1044	* i_block_group is the number of the block group which contains
1045	* this file's inode. Constant across the lifetime of the inode,
1046	* it is used for making block allocation decisions - we try to
1047	* place a file's data blocks near its inode block, and new inodes
1048	* near to their parent directory's inode.
1049	*/
1050	ext4_group_t i_block_group;
1051	ext4_lblk_t i_dir_start_lookup;
1052	#if (BITS_PER_LONG < 64)
1053	unsigned long i_state_flags; /* Dynamic state flags */
1054	#endif
1055	unsigned long i_flags;
1056
1057	/*
1058	* Extended attributes can be read independently of the main file
1059	* data. Taking i_rwsem even when reading would cause contention
1060	* between readers of EAs and writers of regular file data, so
1061	* instead we synchronize on xattr_sem when reading or changing
1062	* EAs.
1063	*/
1064	struct rw_semaphore xattr_sem;
1065
1066	/*
1067	* Inodes with EXT4_STATE_ORPHAN_FILE use i_orphan_idx. Otherwise
1068	* i_orphan is used.
1069	*/
1070	union {
1071	struct list_head i_orphan; /* unlinked but open inodes */
1072	unsigned int i_orphan_idx; /* Index in orphan file */
1073	};
1074
1075	/* Fast commit related info */
1076
1077	/* For tracking dentry create updates */
1078	struct list_head i_fc_dilist;
1079	struct list_head i_fc_list; /*
1080	* inodes that need fast commit
1081	* protected by sbi->s_fc_lock.
1082	*/
1083
1084	/* Start of lblk range that needs to be committed in this fast commit */
1085	ext4_lblk_t i_fc_lblk_start;
1086
1087	/* End of lblk range that needs to be committed in this fast commit */
1088	ext4_lblk_t i_fc_lblk_len;
1089
1090	spinlock_t i_raw_lock; /* protects updates to the raw inode */
1091
1092	/* Fast commit wait queue for this inode */
1093	wait_queue_head_t i_fc_wait;
1094
1095	/*
1096	* Protect concurrent accesses on i_fc_lblk_start, i_fc_lblk_len
1097	* and inode's EXT4_FC_STATE_COMMITTING state bit.
1098	*/
1099	spinlock_t i_fc_lock;
1100
1101	/*
1102	* i_disksize keeps track of what the inode size is ON DISK, not
1103	* in memory. During truncate, i_size is set to the new size by
1104	* the VFS prior to calling ext4_truncate(), but the filesystem won't
1105	* set i_disksize to 0 until the truncate is actually under way.
1106	*
1107	* The intent is that i_disksize always represents the blocks which
1108	* are used by this file. This allows recovery to restart truncate
1109	* on orphans if we crash during truncate. We actually write i_disksize
1110	* into the on-disk inode when writing inodes out, instead of i_size.
1111	*
1112	* The only time when i_disksize and i_size may be different is when
1113	* a truncate is in progress. The only things which change i_disksize
1114	* are ext4_get_block (growth) and ext4_truncate (shrinkth).
1115	*/
1116	loff_t i_disksize;
1117
1118	/*
1119	* i_data_sem is for serialising ext4_truncate() against
1120	* ext4_getblock(). In the 2.4 ext2 design, great chunks of inode's
1121	* data tree are chopped off during truncate. We can't do that in
1122	* ext4 because whenever we perform intermediate commits during
1123	* truncate, the inode and all the metadata blocks *must* be in a
1124	* consistent state which allows truncation of the orphans to restart
1125	* during recovery. Hence we must fix the get_block-vs-truncate race
1126	* by other means, so we have i_data_sem.
1127	*/
1128	struct rw_semaphore i_data_sem;
1129	struct inode vfs_inode;
1130	struct jbd2_inode *jinode;
1131
1132	/*
1133	* File creation time. Its function is same as that of
1134	* struct timespec64 i_{a,c,m}time in the generic inode.
1135	*/
1136	struct timespec64 i_crtime;
1137
1138	/* mballoc */
1139	atomic_t i_prealloc_active;
1140
1141	/* allocation reservation info for delalloc */
1142	/* In case of bigalloc, this refer to clusters rather than blocks */
1143	unsigned int i_reserved_data_blocks;
1144	struct rb_root i_prealloc_node;
1145	rwlock_t i_prealloc_lock;
1146
1147	/* extents status tree */
1148	struct ext4_es_tree i_es_tree;
1149	rwlock_t i_es_lock;
1150	struct list_head i_es_list;
1151	unsigned int i_es_all_nr; /* protected by i_es_lock */
1152	unsigned int i_es_shk_nr; /* protected by i_es_lock */
1153	ext4_lblk_t i_es_shrink_lblk; /* Offset where we start searching for
1154	extents to shrink. Protected by
1155	i_es_lock */
1156
1157	/* ialloc */
1158	ext4_group_t i_last_alloc_group;
1159
1160	/* pending cluster reservations for bigalloc file systems */
1161	struct ext4_pending_tree i_pending_tree;
1162
1163	/* on-disk additional length */
1164	__u16 i_extra_isize;
1165
1166	/* Indicate the inline data space. */
1167	u16 i_inline_off;
1168	u16 i_inline_size;
1169
1170	#ifdef CONFIG_QUOTA
1171	/* quota space reservation, managed internally by quota code */
1172	qsize_t i_reserved_quota;
1173	#endif
1174	spinlock_t i_block_reservation_lock;
1175
1176	/* Lock protecting lists below */
1177	spinlock_t i_completed_io_lock;
1178	/*
1179	* Completed IOs that need unwritten extents handling and have
1180	* transaction reserved
1181	*/
1182	struct list_head i_rsv_conversion_list;
1183	struct work_struct i_rsv_conversion_work;
1184
1185	/*
1186	* Transactions that contain inode's metadata needed to complete
1187	* fsync and fdatasync, respectively.
1188	*/
1189	tid_t i_sync_tid;
1190	tid_t i_datasync_tid;
1191
1192	#ifdef CONFIG_QUOTA
1193	struct dquot __rcu *i_dquot[MAXQUOTAS];
1194	#endif
1195
1196	/* Precomputed uuid+inum+igen checksum for seeding inode checksums */
1197	__u32 i_csum_seed;
1198
1199	kprojid_t i_projid;
1200	};
1201
1202	/*
1203	* File system states
1204	*/
1205	#define EXT4_VALID_FS 0x0001 /* Unmounted cleanly */
1206	#define EXT4_ERROR_FS 0x0002 /* Errors detected */
1207	#define EXT4_ORPHAN_FS 0x0004 /* Orphans being recovered */
1208	#define EXT4_FC_REPLAY 0x0020 /* Fast commit replay ongoing */
1209
1210	/*
1211	* Misc. filesystem flags
1212	*/
1213	#define EXT2_FLAGS_SIGNED_HASH 0x0001 /* Signed dirhash in use */
1214	#define EXT2_FLAGS_UNSIGNED_HASH 0x0002 /* Unsigned dirhash in use */
1215	#define EXT2_FLAGS_TEST_FILESYS 0x0004 /* to test development code */
1216
1217	/*
1218	* Mount flags set via mount options or defaults
1219	*/
1220	#define EXT4_MOUNT_NO_MBCACHE 0x00001 /* Do not use mbcache */
1221	#define EXT4_MOUNT_GRPID 0x00004 /* Create files with directory's group */
1222	#define EXT4_MOUNT_DEBUG 0x00008 /* Some debugging messages */
1223	#define EXT4_MOUNT_ERRORS_CONT 0x00010 /* Continue on errors */
1224	#define EXT4_MOUNT_ERRORS_RO 0x00020 /* Remount fs ro on errors */
1225	#define EXT4_MOUNT_ERRORS_PANIC 0x00040 /* Panic on errors */
1226	#define EXT4_MOUNT_ERRORS_MASK 0x00070
1227	#define EXT4_MOUNT_MINIX_DF 0x00080 /* Mimics the Minix statfs */
1228	#define EXT4_MOUNT_NOLOAD 0x00100 /* Don't use existing journal*/
1229	#ifdef CONFIG_FS_DAX
1230	#define EXT4_MOUNT_DAX_ALWAYS 0x00200 /* Direct Access */
1231	#else
1232	#define EXT4_MOUNT_DAX_ALWAYS 0
1233	#endif
1234	#define EXT4_MOUNT_DATA_FLAGS 0x00C00 /* Mode for data writes: */
1235	#define EXT4_MOUNT_JOURNAL_DATA 0x00400 /* Write data to journal */
1236	#define EXT4_MOUNT_ORDERED_DATA 0x00800 /* Flush data before commit */
1237	#define EXT4_MOUNT_WRITEBACK_DATA 0x00C00 /* No data ordering */
1238	#define EXT4_MOUNT_UPDATE_JOURNAL 0x01000 /* Update the journal format */
1239	#define EXT4_MOUNT_NO_UID32 0x02000 /* Disable 32-bit UIDs */
1240	#define EXT4_MOUNT_XATTR_USER 0x04000 /* Extended user attributes */
1241	#define EXT4_MOUNT_POSIX_ACL 0x08000 /* POSIX Access Control Lists */
1242	#define EXT4_MOUNT_NO_AUTO_DA_ALLOC 0x10000 /* No auto delalloc mapping */
1243	#define EXT4_MOUNT_BARRIER 0x20000 /* Use block barriers */
1244	#define EXT4_MOUNT_QUOTA 0x40000 /* Some quota option set */
1245	#define EXT4_MOUNT_USRQUOTA 0x80000 /* "old" user quota,
1246	* enable enforcement for hidden
1247	* quota files */
1248	#define EXT4_MOUNT_GRPQUOTA 0x100000 /* "old" group quota, enable
1249	* enforcement for hidden quota
1250	* files */
1251	#define EXT4_MOUNT_PRJQUOTA 0x200000 /* Enable project quota
1252	* enforcement */
1253	#define EXT4_MOUNT_DIOREAD_NOLOCK 0x400000 /* Enable support for dio read nolocking */
1254	#define EXT4_MOUNT_JOURNAL_CHECKSUM 0x800000 /* Journal checksums */
1255	#define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT 0x1000000 /* Journal Async Commit */
1256	#define EXT4_MOUNT_WARN_ON_ERROR 0x2000000 /* Trigger WARN_ON on error */
1257	#define EXT4_MOUNT_NO_PREFETCH_BLOCK_BITMAPS 0x4000000
1258	#define EXT4_MOUNT_DELALLOC 0x8000000 /* Delalloc support */
1259	#define EXT4_MOUNT_DATA_ERR_ABORT 0x10000000 /* Abort on file data write */
1260	#define EXT4_MOUNT_BLOCK_VALIDITY 0x20000000 /* Block validity checking */
1261	#define EXT4_MOUNT_DISCARD 0x40000000 /* Issue DISCARD requests */
1262	#define EXT4_MOUNT_INIT_INODE_TABLE 0x80000000 /* Initialize uninitialized itables */
1263
1264	/*
1265	* Mount flags set either automatically (could not be set by mount option)
1266	* based on per file system feature or property or in special cases such as
1267	* distinguishing between explicit mount option definition and default.
1268	*/
1269	#define EXT4_MOUNT2_EXPLICIT_DELALLOC 0x00000001 /* User explicitly
1270	specified delalloc */
1271	#define EXT4_MOUNT2_STD_GROUP_SIZE 0x00000002 /* We have standard group
1272	size of blocksize * 8
1273	blocks */
1274	#define EXT4_MOUNT2_HURD_COMPAT 0x00000004 /* Support HURD-castrated
1275	file systems */
1276	#define EXT4_MOUNT2_EXPLICIT_JOURNAL_CHECKSUM 0x00000008 /* User explicitly
1277	specified journal checksum */
1278
1279	#define EXT4_MOUNT2_JOURNAL_FAST_COMMIT 0x00000010 /* Journal fast commit */
1280	#define EXT4_MOUNT2_DAX_NEVER 0x00000020 /* Do not allow Direct Access */
1281	#define EXT4_MOUNT2_DAX_INODE 0x00000040 /* For printing options only */
1282	#define EXT4_MOUNT2_MB_OPTIMIZE_SCAN 0x00000080 /* Optimize group
1283	* scanning in mballoc
1284	*/
1285	#define EXT4_MOUNT2_ABORT 0x00000100 /* Abort filesystem */
1286
1287	#define clear_opt(sb, opt) EXT4_SB(sb)->s_mount_opt &= \
1288	~EXT4_MOUNT_##opt
1289	#define set_opt(sb, opt) EXT4_SB(sb)->s_mount_opt |= \
1290	EXT4_MOUNT_##opt
1291	#define test_opt(sb, opt) (EXT4_SB(sb)->s_mount_opt & \
1292	EXT4_MOUNT_##opt)
1293
1294	#define clear_opt2(sb, opt) EXT4_SB(sb)->s_mount_opt2 &= \
1295	~EXT4_MOUNT2_##opt
1296	#define set_opt2(sb, opt) EXT4_SB(sb)->s_mount_opt2 |= \
1297	EXT4_MOUNT2_##opt
1298	#define test_opt2(sb, opt) (EXT4_SB(sb)->s_mount_opt2 & \
1299	EXT4_MOUNT2_##opt)
1300
1301	#define ext4_test_and_set_bit __test_and_set_bit_le
1302	#define ext4_set_bit __set_bit_le
1303	#define ext4_test_and_clear_bit __test_and_clear_bit_le
1304	#define ext4_clear_bit __clear_bit_le
1305	#define ext4_test_bit test_bit_le
1306	#define ext4_find_next_zero_bit find_next_zero_bit_le
1307	#define ext4_find_next_bit find_next_bit_le
1308
1309	extern void mb_set_bits(void *bm, int cur, int len);
1310
1311	/*
1312	* Maximal mount counts between two filesystem checks
1313	*/
1314	#define EXT4_DFL_MAX_MNT_COUNT 20 /* Allow 20 mounts */
1315	#define EXT4_DFL_CHECKINTERVAL 0 /* Don't use interval check */
1316
1317	/*
1318	* Behaviour when detecting errors
1319	*/
1320	#define EXT4_ERRORS_CONTINUE 1 /* Continue execution */
1321	#define EXT4_ERRORS_RO 2 /* Remount fs read-only */
1322	#define EXT4_ERRORS_PANIC 3 /* Panic */
1323	#define EXT4_ERRORS_DEFAULT EXT4_ERRORS_CONTINUE
1324
1325	/* Metadata checksum algorithm codes */
1326	#define EXT4_CRC32C_CHKSUM 1
1327
1328	#define EXT4_LABEL_MAX 16
1329
1330	/*
1331	* Structure of the super block
1332	*/
1333	struct ext4_super_block {
1334	/*00*/ __le32 s_inodes_count; /* Inodes count */
1335	__le32 s_blocks_count_lo; /* Blocks count */
1336	__le32 s_r_blocks_count_lo; /* Reserved blocks count */
1337	__le32 s_free_blocks_count_lo; /* Free blocks count */
1338	/*10*/ __le32 s_free_inodes_count; /* Free inodes count */
1339	__le32 s_first_data_block; /* First Data Block */
1340	__le32 s_log_block_size; /* Block size */
1341	__le32 s_log_cluster_size; /* Allocation cluster size */
1342	/*20*/ __le32 s_blocks_per_group; /* # Blocks per group */
1343	__le32 s_clusters_per_group; /* # Clusters per group */
1344	__le32 s_inodes_per_group; /* # Inodes per group */
1345	__le32 s_mtime; /* Mount time */
1346	/*30*/ __le32 s_wtime; /* Write time */
1347	__le16 s_mnt_count; /* Mount count */
1348	__le16 s_max_mnt_count; /* Maximal mount count */
1349	__le16 s_magic; /* Magic signature */
1350	__le16 s_state; /* File system state */
1351	__le16 s_errors; /* Behaviour when detecting errors */
1352	__le16 s_minor_rev_level; /* minor revision level */
1353	/*40*/ __le32 s_lastcheck; /* time of last check */
1354	__le32 s_checkinterval; /* max. time between checks */
1355	__le32 s_creator_os; /* OS */
1356	__le32 s_rev_level; /* Revision level */
1357	/*50*/ __le16 s_def_resuid; /* Default uid for reserved blocks */
1358	__le16 s_def_resgid; /* Default gid for reserved blocks */
1359	/*
1360	* These fields are for EXT4_DYNAMIC_REV superblocks only.
1361	*
1362	* Note: the difference between the compatible feature set and
1363	* the incompatible feature set is that if there is a bit set
1364	* in the incompatible feature set that the kernel doesn't
1365	* know about, it should refuse to mount the filesystem.
1366	*
1367	* e2fsck's requirements are more strict; if it doesn't know
1368	* about a feature in either the compatible or incompatible
1369	* feature set, it must abort and not try to meddle with
1370	* things it doesn't understand...
1371	*/
1372	__le32 s_first_ino; /* First non-reserved inode */
1373	__le16 s_inode_size; /* size of inode structure */
1374	__le16 s_block_group_nr; /* block group # of this superblock */
1375	__le32 s_feature_compat; /* compatible feature set */
1376	/*60*/ __le32 s_feature_incompat; /* incompatible feature set */
1377	__le32 s_feature_ro_compat; /* readonly-compatible feature set */
1378	/*68*/ __u8 s_uuid[16]; /* 128-bit uuid for volume */
1379	/*78*/ char s_volume_name[EXT4_LABEL_MAX] __nonstring; /* volume name */
1380	/*88*/ char s_last_mounted[64] __nonstring; /* directory where last mounted */
1381	/*C8*/ __le32 s_algorithm_usage_bitmap; /* For compression */
1382	/*
1383	* Performance hints. Directory preallocation should only
1384	* happen if the EXT4_FEATURE_COMPAT_DIR_PREALLOC flag is on.
1385	*/
1386	__u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/
1387	__u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */
1388	__le16 s_reserved_gdt_blocks; /* Per group desc for online growth */
1389	/*
1390	* Journaling support valid if EXT4_FEATURE_COMPAT_HAS_JOURNAL set.
1391	*/
1392	/*D0*/ __u8 s_journal_uuid[16]; /* uuid of journal superblock */
1393	/*E0*/ __le32 s_journal_inum; /* inode number of journal file */
1394	__le32 s_journal_dev; /* device number of journal file */
1395	__le32 s_last_orphan; /* start of list of inodes to delete */
1396	__le32 s_hash_seed[4]; /* HTREE hash seed */
1397	__u8 s_def_hash_version; /* Default hash version to use */
1398	__u8 s_jnl_backup_type;
1399	__le16 s_desc_size; /* size of group descriptor */
1400	/*100*/ __le32 s_default_mount_opts;
1401	__le32 s_first_meta_bg; /* First metablock block group */
1402	__le32 s_mkfs_time; /* When the filesystem was created */
1403	__le32 s_jnl_blocks[17]; /* Backup of the journal inode */
1404	/* 64bit support valid if EXT4_FEATURE_INCOMPAT_64BIT */
1405	/*150*/ __le32 s_blocks_count_hi; /* Blocks count */
1406	__le32 s_r_blocks_count_hi; /* Reserved blocks count */
1407	__le32 s_free_blocks_count_hi; /* Free blocks count */
1408	__le16 s_min_extra_isize; /* All inodes have at least # bytes */
1409	__le16 s_want_extra_isize; /* New inodes should reserve # bytes */
1410	__le32 s_flags; /* Miscellaneous flags */
1411	__le16 s_raid_stride; /* RAID stride */
1412	__le16 s_mmp_update_interval; /* # seconds to wait in MMP checking */
1413	__le64 s_mmp_block; /* Block for multi-mount protection */
1414	__le32 s_raid_stripe_width; /* blocks on all data disks (N*stride)*/
1415	__u8 s_log_groups_per_flex; /* FLEX_BG group size */
1416	__u8 s_checksum_type; /* metadata checksum algorithm used */
1417	__u8 s_encryption_level; /* versioning level for encryption */
1418	__u8 s_reserved_pad; /* Padding to next 32bits */
1419	__le64 s_kbytes_written; /* nr of lifetime kilobytes written */
1420	__le32 s_snapshot_inum; /* Inode number of active snapshot */
1421	__le32 s_snapshot_id; /* sequential ID of active snapshot */
1422	__le64 s_snapshot_r_blocks_count; /* reserved blocks for active
1423	snapshot's future use */
1424	__le32 s_snapshot_list; /* inode number of the head of the
1425	on-disk snapshot list */
1426	#define EXT4_S_ERR_START offsetof(struct ext4_super_block, s_error_count)
1427	__le32 s_error_count; /* number of fs errors */
1428	__le32 s_first_error_time; /* first time an error happened */
1429	__le32 s_first_error_ino; /* inode involved in first error */
1430	__le64 s_first_error_block; /* block involved of first error */
1431	__u8 s_first_error_func[32] __nonstring; /* function where the error happened */
1432	__le32 s_first_error_line; /* line number where error happened */
1433	__le32 s_last_error_time; /* most recent time of an error */
1434	__le32 s_last_error_ino; /* inode involved in last error */
1435	__le32 s_last_error_line; /* line number where error happened */
1436	__le64 s_last_error_block; /* block involved of last error */
1437	__u8 s_last_error_func[32] __nonstring; /* function where the error happened */
1438	#define EXT4_S_ERR_END offsetof(struct ext4_super_block, s_mount_opts)
1439	__u8 s_mount_opts[64];
1440	__le32 s_usr_quota_inum; /* inode for tracking user quota */
1441	__le32 s_grp_quota_inum; /* inode for tracking group quota */
1442	__le32 s_overhead_clusters; /* overhead blocks/clusters in fs */
1443	__le32 s_backup_bgs[2]; /* groups with sparse_super2 SBs */
1444	__u8 s_encrypt_algos[4]; /* Encryption algorithms in use */
1445	__u8 s_encrypt_pw_salt[16]; /* Salt used for string2key algorithm */
1446	__le32 s_lpf_ino; /* Location of the lost+found inode */
1447	__le32 s_prj_quota_inum; /* inode for tracking project quota */
1448	__le32 s_checksum_seed; /* crc32c(uuid) if csum_seed set */
1449	__u8 s_wtime_hi;
1450	__u8 s_mtime_hi;
1451	__u8 s_mkfs_time_hi;
1452	__u8 s_lastcheck_hi;
1453	__u8 s_first_error_time_hi;
1454	__u8 s_last_error_time_hi;
1455	__u8 s_first_error_errcode;
1456	__u8 s_last_error_errcode;
1457	__le16 s_encoding; /* Filename charset encoding */
1458	__le16 s_encoding_flags; /* Filename charset encoding flags */
1459	__le32 s_orphan_file_inum; /* Inode for tracking orphan inodes */
1460	__le32 s_reserved[94]; /* Padding to the end of the block */
1461	__le32 s_checksum; /* crc32c(superblock) */
1462	};
1463
1464	#define EXT4_S_ERR_LEN (EXT4_S_ERR_END - EXT4_S_ERR_START)
1465
1466	#ifdef __KERNEL__
1467
1468	/* Number of quota types we support */
1469	#define EXT4_MAXQUOTAS 3
1470
1471	#define EXT4_ENC_UTF8_12_1 1
1472
1473	/* Types of ext4 journal triggers */
1474	enum ext4_journal_trigger_type {
1475	EXT4_JTR_ORPHAN_FILE,
1476	EXT4_JTR_NONE /* This must be the last entry for indexing to work! */
1477	};
1478
1479	#define EXT4_JOURNAL_TRIGGER_COUNT EXT4_JTR_NONE
1480
1481	struct ext4_journal_trigger {
1482	struct jbd2_buffer_trigger_type tr_triggers;
1483	struct super_block *sb;
1484	};
1485
1486	static inline struct ext4_journal_trigger *EXT4_TRIGGER(
1487	struct jbd2_buffer_trigger_type *trigger)
1488	{
1489	return container_of(trigger, struct ext4_journal_trigger, tr_triggers);
1490	}
1491
1492	#define EXT4_ORPHAN_BLOCK_MAGIC 0x0b10ca04
1493
1494	/* Structure at the tail of orphan block */
1495	struct ext4_orphan_block_tail {
1496	__le32 ob_magic;
1497	__le32 ob_checksum;
1498	};
1499
1500	static inline int ext4_inodes_per_orphan_block(struct super_block *sb)
1501	{
1502	return (sb->s_blocksize - sizeof(struct ext4_orphan_block_tail)) /
1503	sizeof(u32);
1504	}
1505
1506	struct ext4_orphan_block {
1507	atomic_t ob_free_entries; /* Number of free orphan entries in block */
1508	struct buffer_head *ob_bh; /* Buffer for orphan block */
1509	};
1510
1511	/*
1512	* Info about orphan file.
1513	*/
1514	struct ext4_orphan_info {
1515	int of_blocks; /* Number of orphan blocks in a file */
1516	__u32 of_csum_seed; /* Checksum seed for orphan file */
1517	struct ext4_orphan_block *of_binfo; /* Array with info about orphan
1518	* file blocks */
1519	};
1520
1521	/*
1522	* fourth extended-fs super-block data in memory
1523	*/
1524	struct ext4_sb_info {
1525	unsigned long s_desc_size; /* Size of a group descriptor in bytes */
1526	unsigned long s_inodes_per_block;/* Number of inodes per block */
1527	unsigned long s_blocks_per_group;/* Number of blocks in a group */
1528	unsigned long s_clusters_per_group; /* Number of clusters in a group */
1529	unsigned long s_inodes_per_group;/* Number of inodes in a group */
1530	unsigned long s_itb_per_group; /* Number of inode table blocks per group */
1531	unsigned long s_gdb_count; /* Number of group descriptor blocks */
1532	unsigned long s_desc_per_block; /* Number of group descriptors per block */
1533	ext4_group_t s_groups_count; /* Number of groups in the fs */
1534	ext4_group_t s_blockfile_groups;/* Groups acceptable for non-extent files */
1535	unsigned long s_overhead; /* # of fs overhead clusters */
1536	unsigned int s_cluster_ratio; /* Number of blocks per cluster */
1537	unsigned int s_cluster_bits; /* log2 of s_cluster_ratio */
1538	loff_t s_bitmap_maxbytes; /* max bytes for bitmap files */
1539	struct buffer_head * s_sbh; /* Buffer containing the super block */
1540	struct ext4_super_block *s_es; /* Pointer to the super block in the buffer */
1541	/* Array of bh's for the block group descriptors */
1542	struct buffer_head * __rcu *s_group_desc;
1543	unsigned int s_mount_opt;
1544	unsigned int s_mount_opt2;
1545	unsigned long s_mount_flags;
1546	unsigned int s_def_mount_opt;
1547	unsigned int s_def_mount_opt2;
1548	ext4_fsblk_t s_sb_block;
1549	atomic64_t s_resv_clusters;
1550	kuid_t s_resuid;
1551	kgid_t s_resgid;
1552	unsigned short s_mount_state;
1553	unsigned short s_pad;
1554	int s_addr_per_block_bits;
1555	int s_desc_per_block_bits;
1556	int s_inode_size;
1557	int s_first_ino;
1558	unsigned int s_inode_readahead_blks;
1559	unsigned int s_inode_goal;
1560	u32 s_hash_seed[4];
1561	int s_def_hash_version;
1562	int s_hash_unsigned; /* 3 if hash should be unsigned, 0 if not */
1563	struct percpu_counter s_freeclusters_counter;
1564	struct percpu_counter s_freeinodes_counter;
1565	struct percpu_counter s_dirs_counter;
1566	struct percpu_counter s_dirtyclusters_counter;
1567	struct percpu_counter s_sra_exceeded_retry_limit;
1568	struct blockgroup_lock *s_blockgroup_lock;
1569	struct proc_dir_entry *s_proc;
1570	struct kobject s_kobj;
1571	struct completion s_kobj_unregister;
1572	struct super_block *s_sb;
1573	struct buffer_head *s_mmp_bh;
1574
1575	/* Journaling */
1576	struct journal_s *s_journal;
1577	unsigned long s_ext4_flags; /* Ext4 superblock flags */
1578	struct mutex s_orphan_lock; /* Protects on disk list changes */
1579	struct list_head s_orphan; /* List of orphaned inodes in on disk
1580	list */
1581	struct ext4_orphan_info s_orphan_info;
1582	unsigned long s_commit_interval;
1583	u32 s_max_batch_time;
1584	u32 s_min_batch_time;
1585	struct file *s_journal_bdev_file;
1586	#ifdef CONFIG_QUOTA
1587	/* Names of quota files with journalled quota */
1588	char __rcu *s_qf_names[EXT4_MAXQUOTAS];
1589	int s_jquota_fmt; /* Format of quota to use */
1590	#endif
1591	unsigned int s_want_extra_isize; /* New inodes should reserve # bytes */
1592	struct ext4_system_blocks __rcu *s_system_blks;
1593
1594	#ifdef EXTENTS_STATS
1595	/* ext4 extents stats */
1596	unsigned long s_ext_min;
1597	unsigned long s_ext_max;
1598	unsigned long s_depth_max;
1599	spinlock_t s_ext_stats_lock;
1600	unsigned long s_ext_blocks;
1601	unsigned long s_ext_extents;
1602	#endif
1603
1604	/* for buddy allocator */
1605	struct ext4_group_info ** __rcu *s_group_info;
1606	struct inode *s_buddy_cache;
1607	spinlock_t s_md_lock;
1608	unsigned short *s_mb_offsets;
1609	unsigned int *s_mb_maxs;
1610	unsigned int s_group_info_size;
1611	unsigned int s_mb_free_pending;
1612	struct list_head s_freed_data_list[2]; /* List of blocks to be freed
1613	after commit completed */
1614	struct list_head s_discard_list;
1615	struct work_struct s_discard_work;
1616	atomic_t s_retry_alloc_pending;
1617	struct list_head *s_mb_avg_fragment_size;
1618	rwlock_t *s_mb_avg_fragment_size_locks;
1619	struct list_head *s_mb_largest_free_orders;
1620	rwlock_t *s_mb_largest_free_orders_locks;
1621
1622	/* tunables */
1623	unsigned long s_stripe;
1624	unsigned int s_mb_max_linear_groups;
1625	unsigned int s_mb_stream_request;
1626	unsigned int s_mb_max_to_scan;
1627	unsigned int s_mb_min_to_scan;
1628	unsigned int s_mb_stats;
1629	unsigned int s_mb_order2_reqs;
1630	unsigned int s_mb_group_prealloc;
1631	unsigned int s_max_dir_size_kb;
1632	/* where last allocation was done - for stream allocation */
1633	unsigned long s_mb_last_group;
1634	unsigned long s_mb_last_start;
1635	unsigned int s_mb_prefetch;
1636	unsigned int s_mb_prefetch_limit;
1637	unsigned int s_mb_best_avail_max_trim_order;
1638	unsigned int s_sb_update_sec;
1639	unsigned int s_sb_update_kb;
1640
1641	/* stats for buddy allocator */
1642	atomic_t s_bal_reqs; /* number of reqs with len > 1 */
1643	atomic_t s_bal_success; /* we found long enough chunks */
1644	atomic_t s_bal_allocated; /* in blocks */
1645	atomic_t s_bal_ex_scanned; /* total extents scanned */
1646	atomic_t s_bal_cX_ex_scanned[EXT4_MB_NUM_CRS]; /* total extents scanned */
1647	atomic_t s_bal_groups_scanned; /* number of groups scanned */
1648	atomic_t s_bal_goals; /* goal hits */
1649	atomic_t s_bal_len_goals; /* len goal hits */
1650	atomic_t s_bal_breaks; /* too long searches */
1651	atomic_t s_bal_2orders; /* 2^order hits */
1652	atomic_t s_bal_p2_aligned_bad_suggestions;
1653	atomic_t s_bal_goal_fast_bad_suggestions;
1654	atomic_t s_bal_best_avail_bad_suggestions;
1655	atomic64_t s_bal_cX_groups_considered[EXT4_MB_NUM_CRS];
1656	atomic64_t s_bal_cX_hits[EXT4_MB_NUM_CRS];
1657	atomic64_t s_bal_cX_failed[EXT4_MB_NUM_CRS]; /* cX loop didn't find blocks */
1658	atomic_t s_mb_buddies_generated; /* number of buddies generated */
1659	atomic64_t s_mb_generation_time;
1660	atomic_t s_mb_lost_chunks;
1661	atomic_t s_mb_preallocated;
1662	atomic_t s_mb_discarded;
1663	atomic_t s_lock_busy;
1664
1665	/* locality groups */
1666	struct ext4_locality_group __percpu *s_locality_groups;
1667
1668	/* for write statistics */
1669	unsigned long s_sectors_written_start;
1670	u64 s_kbytes_written;
1671
1672	/* the size of zero-out chunk */
1673	unsigned int s_extent_max_zeroout_kb;
1674
1675	unsigned int s_log_groups_per_flex;
1676	struct flex_groups * __rcu *s_flex_groups;
1677	ext4_group_t s_flex_groups_allocated;
1678
1679	/* workqueue for reserved extent conversions (buffered io) */
1680	struct workqueue_struct *rsv_conversion_wq;
1681
1682	/* timer for periodic error stats printing */
1683	struct timer_list s_err_report;
1684
1685	/* Lazy inode table initialization info */
1686	struct ext4_li_request *s_li_request;
1687	/* Wait multiplier for lazy initialization thread */
1688	unsigned int s_li_wait_mult;
1689
1690	/* Kernel thread for multiple mount protection */
1691	struct task_struct *s_mmp_tsk;
1692
1693	/* record the last minlen when FITRIM is called. */
1694	unsigned long s_last_trim_minblks;
1695
1696	/* Precomputed FS UUID checksum for seeding other checksums */
1697	__u32 s_csum_seed;
1698
1699	/* Reclaim extents from extent status tree */
1700	struct shrinker *s_es_shrinker;
1701	struct list_head s_es_list; /* List of inodes with reclaimable extents */
1702	long s_es_nr_inode;
1703	struct ext4_es_stats s_es_stats;
1704	struct mb_cache *s_ea_block_cache;
1705	struct mb_cache *s_ea_inode_cache;
1706	spinlock_t s_es_lock ____cacheline_aligned_in_smp;
1707
1708	/* Journal triggers for checksum computation */
1709	struct ext4_journal_trigger s_journal_triggers[EXT4_JOURNAL_TRIGGER_COUNT];
1710
1711	/* Ratelimit ext4 messages. */
1712	struct ratelimit_state s_err_ratelimit_state;
1713	struct ratelimit_state s_warning_ratelimit_state;
1714	struct ratelimit_state s_msg_ratelimit_state;
1715	atomic_t s_warning_count;
1716	atomic_t s_msg_count;
1717
1718	/* Encryption policy for '-o test_dummy_encryption' */
1719	struct fscrypt_dummy_policy s_dummy_enc_policy;
1720
1721	/*
1722	* Barrier between writepages ops and changing any inode's JOURNAL_DATA
1723	* or EXTENTS flag or between writepages ops and changing DELALLOC or
1724	* DIOREAD_NOLOCK mount options on remount.
1725	*/
1726	struct percpu_rw_semaphore s_writepages_rwsem;
1727	struct dax_device *s_daxdev;
1728	u64 s_dax_part_off;
1729	#ifdef CONFIG_EXT4_DEBUG
1730	unsigned long s_simulate_fail;
1731	#endif
1732	/* Record the errseq of the backing block device */
1733	errseq_t s_bdev_wb_err;
1734	spinlock_t s_bdev_wb_lock;
1735
1736	/* Information about errors that happened during this mount */
1737	spinlock_t s_error_lock;
1738	int s_add_error_count;
1739	int s_first_error_code;
1740	__u32 s_first_error_line;
1741	__u32 s_first_error_ino;
1742	__u64 s_first_error_block;
1743	const char *s_first_error_func;
1744	time64_t s_first_error_time;
1745	int s_last_error_code;
1746	__u32 s_last_error_line;
1747	__u32 s_last_error_ino;
1748	__u64 s_last_error_block;
1749	const char *s_last_error_func;
1750	time64_t s_last_error_time;
1751	/*
1752	* If we are in a context where we cannot update the on-disk
1753	* superblock, we queue the work here. This is used to update
1754	* the error information in the superblock, and for periodic
1755	* updates of the superblock called from the commit callback
1756	* function.
1757	*/
1758	struct work_struct s_sb_upd_work;
1759
1760	/* Atomic write unit values in bytes */
1761	unsigned int s_awu_min;
1762	unsigned int s_awu_max;
1763
1764	/* Ext4 fast commit sub transaction ID */
1765	atomic_t s_fc_subtid;
1766
1767	/*
1768	* After commit starts, the main queue gets locked, and the further
1769	* updates get added in the staging queue.
1770	*/
1771	#define FC_Q_MAIN 0
1772	#define FC_Q_STAGING 1
1773	struct list_head s_fc_q[2]; /* Inodes staged for fast commit
1774	* that have data changes in them.
1775	*/
1776	struct list_head s_fc_dentry_q[2]; /* directory entry updates */
1777	unsigned int s_fc_bytes;
1778	/*
1779	* Main fast commit lock. This lock protects accesses to the
1780	* following fields:
1781	* ei->i_fc_list, s_fc_dentry_q, s_fc_q, s_fc_bytes, s_fc_bh.
1782	*/
1783	struct mutex s_fc_lock;
1784	struct buffer_head *s_fc_bh;
1785	struct ext4_fc_stats s_fc_stats;
1786	tid_t s_fc_ineligible_tid;
1787	#ifdef CONFIG_EXT4_DEBUG
1788	int s_fc_debug_max_replay;
1789	#endif
1790	struct ext4_fc_replay_state s_fc_replay_state;
1791	};
1792
1793	static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
1794	{
1795	return sb->s_fs_info;
1796	}
1797	static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
1798	{
1799	return container_of(inode, struct ext4_inode_info, vfs_inode);
1800	}
1801
1802	static inline int ext4_writepages_down_read(struct super_block *sb)
1803	{
1804	percpu_down_read(sem: &EXT4_SB(sb)->s_writepages_rwsem);
1805	return memalloc_nofs_save();
1806	}
1807
1808	static inline void ext4_writepages_up_read(struct super_block *sb, int ctx)
1809	{
1810	memalloc_nofs_restore(flags: ctx);
1811	percpu_up_read(sem: &EXT4_SB(sb)->s_writepages_rwsem);
1812	}
1813
1814	static inline int ext4_writepages_down_write(struct super_block *sb)
1815	{
1816	percpu_down_write(&EXT4_SB(sb)->s_writepages_rwsem);
1817	return memalloc_nofs_save();
1818	}
1819
1820	static inline void ext4_writepages_up_write(struct super_block *sb, int ctx)
1821	{
1822	memalloc_nofs_restore(flags: ctx);
1823	percpu_up_write(&EXT4_SB(sb)->s_writepages_rwsem);
1824	}
1825
1826	static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
1827	{
1828	return ino == EXT4_ROOT_INO ||
1829	(ino >= EXT4_FIRST_INO(sb) &&
1830	ino <= le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count));
1831	}
1832
1833	/*
1834	* Returns: sbi->field[index]
1835	* Used to access an array element from the following sbi fields which require
1836	* rcu protection to avoid dereferencing an invalid pointer due to reassignment
1837	* - s_group_desc
1838	* - s_group_info
1839	* - s_flex_group
1840	*/
1841	#define sbi_array_rcu_deref(sbi, field, index) \
1842	({ \
1843	typeof(*((sbi)->field)) _v; \
1844	rcu_read_lock(); \
1845	_v = ((typeof(_v)*)rcu_dereference((sbi)->field))[index]; \
1846	rcu_read_unlock(); \
1847	_v; \
1848	})
1849
1850	/*
1851	* run-time mount flags
1852	*/
1853	enum {
1854	EXT4_MF_MNTDIR_SAMPLED,
1855	EXT4_MF_FC_INELIGIBLE, /* Fast commit ineligible */
1856	EXT4_MF_JOURNAL_DESTROY /* Journal is in process of destroying */
1857	};
1858
1859	static inline void ext4_set_mount_flag(struct super_block *sb, int bit)
1860	{
1861	set_bit(nr: bit, addr: &EXT4_SB(sb)->s_mount_flags);
1862	}
1863
1864	static inline void ext4_clear_mount_flag(struct super_block *sb, int bit)
1865	{
1866	clear_bit(nr: bit, addr: &EXT4_SB(sb)->s_mount_flags);
1867	}
1868
1869	static inline int ext4_test_mount_flag(struct super_block *sb, int bit)
1870	{
1871	return test_bit(bit, &EXT4_SB(sb)->s_mount_flags);
1872	}
1873
1874
1875	/*
1876	* Simulate_fail codes
1877	*/
1878	#define EXT4_SIM_BBITMAP_EIO 1
1879	#define EXT4_SIM_BBITMAP_CRC 2
1880	#define EXT4_SIM_IBITMAP_EIO 3
1881	#define EXT4_SIM_IBITMAP_CRC 4
1882	#define EXT4_SIM_INODE_EIO 5
1883	#define EXT4_SIM_INODE_CRC 6
1884	#define EXT4_SIM_DIRBLOCK_EIO 7
1885	#define EXT4_SIM_DIRBLOCK_CRC 8
1886
1887	static inline bool ext4_simulate_fail(struct super_block *sb,
1888	unsigned long code)
1889	{
1890	#ifdef CONFIG_EXT4_DEBUG
1891	struct ext4_sb_info *sbi = EXT4_SB(sb);
1892
1893	if (unlikely(sbi->s_simulate_fail == code)) {
1894	sbi->s_simulate_fail = 0;
1895	return true;
1896	}
1897	#endif
1898	return false;
1899	}
1900
1901	/*
1902	* Error number codes for s_{first,last}_error_errno
1903	*
1904	* Linux errno numbers are architecture specific, so we need to translate
1905	* them into something which is architecture independent. We don't define
1906	* codes for all errno's; just the ones which are most likely to be the cause
1907	* of an ext4_error() call.
1908	*/
1909	#define EXT4_ERR_UNKNOWN 1
1910	#define EXT4_ERR_EIO 2
1911	#define EXT4_ERR_ENOMEM 3
1912	#define EXT4_ERR_EFSBADCRC 4
1913	#define EXT4_ERR_EFSCORRUPTED 5
1914	#define EXT4_ERR_ENOSPC 6
1915	#define EXT4_ERR_ENOKEY 7
1916	#define EXT4_ERR_EROFS 8
1917	#define EXT4_ERR_EFBIG 9
1918	#define EXT4_ERR_EEXIST 10
1919	#define EXT4_ERR_ERANGE 11
1920	#define EXT4_ERR_EOVERFLOW 12
1921	#define EXT4_ERR_EBUSY 13
1922	#define EXT4_ERR_ENOTDIR 14
1923	#define EXT4_ERR_ENOTEMPTY 15
1924	#define EXT4_ERR_ESHUTDOWN 16
1925	#define EXT4_ERR_EFAULT 17
1926
1927	/*
1928	* Inode dynamic state flags
1929	*/
1930	enum {
1931	EXT4_STATE_NEW, /* inode is newly created */
1932	EXT4_STATE_XATTR, /* has in-inode xattrs */
1933	EXT4_STATE_NO_EXPAND, /* No space for expansion */
1934	EXT4_STATE_DA_ALLOC_CLOSE, /* Alloc DA blks on close */
1935	EXT4_STATE_EXT_MIGRATE, /* Inode is migrating */
1936	EXT4_STATE_NEWENTRY, /* File just added to dir */
1937	EXT4_STATE_MAY_INLINE_DATA, /* may have in-inode data */
1938	EXT4_STATE_EXT_PRECACHED, /* extents have been precached */
1939	EXT4_STATE_LUSTRE_EA_INODE, /* Lustre-style ea_inode */
1940	EXT4_STATE_VERITY_IN_PROGRESS, /* building fs-verity Merkle tree */
1941	EXT4_STATE_FC_COMMITTING, /* Fast commit ongoing */
1942	EXT4_STATE_FC_FLUSHING_DATA, /* Fast commit flushing data */
1943	EXT4_STATE_ORPHAN_FILE, /* Inode orphaned in orphan file */
1944	};
1945
1946	#define EXT4_INODE_BIT_FNS(name, field, offset) \
1947	static inline int ext4_test_inode_##name(struct inode *inode, int bit) \
1948	{ \
1949	return test_bit(bit + (offset), &EXT4_I(inode)->i_##field); \
1950	} \
1951	static inline void ext4_set_inode_##name(struct inode *inode, int bit) \
1952	{ \
1953	set_bit(bit + (offset), &EXT4_I(inode)->i_##field); \
1954	} \
1955	static inline void ext4_clear_inode_##name(struct inode *inode, int bit) \
1956	{ \
1957	clear_bit(bit + (offset), &EXT4_I(inode)->i_##field); \
1958	}
1959
1960	/* Add these declarations here only so that these functions can be
1961	* found by name. Otherwise, they are very hard to locate. */
1962	static inline int ext4_test_inode_flag(struct inode *inode, int bit);
1963	static inline void ext4_set_inode_flag(struct inode *inode, int bit);
1964	static inline void ext4_clear_inode_flag(struct inode *inode, int bit);
1965	EXT4_INODE_BIT_FNS(flag, flags, 0)
1966
1967	/* Add these declarations here only so that these functions can be
1968	* found by name. Otherwise, they are very hard to locate. */
1969	static inline int ext4_test_inode_state(struct inode *inode, int bit);
1970	static inline void ext4_set_inode_state(struct inode *inode, int bit);
1971	static inline void ext4_clear_inode_state(struct inode *inode, int bit);
1972	#if (BITS_PER_LONG < 64)
1973	EXT4_INODE_BIT_FNS(state, state_flags, 0)
1974
1975	static inline void ext4_clear_state_flags(struct ext4_inode_info *ei)
1976	{
1977	(ei)->i_state_flags = 0;
1978	}
1979	#else
1980	EXT4_INODE_BIT_FNS(state, flags, 32)
1981
1982	static inline void ext4_clear_state_flags(struct ext4_inode_info *ei)
1983	{
1984	/* We depend on the fact that callers will set i_flags */
1985	}
1986	#endif
1987	#else
1988	/* Assume that user mode programs are passing in an ext4fs superblock, not
1989	* a kernel struct super_block. This will allow us to call the feature-test
1990	* macros from user land. */
1991	#define EXT4_SB(sb) (sb)
1992	#endif
1993
1994	static inline bool ext4_verity_in_progress(struct inode *inode)
1995	{
1996	return IS_ENABLED(CONFIG_FS_VERITY) &&
1997	ext4_test_inode_state(inode, bit: EXT4_STATE_VERITY_IN_PROGRESS);
1998	}
1999
2000	#define NEXT_ORPHAN(inode) EXT4_I(inode)->i_dtime
2001
2002	/*
2003	* Codes for operating systems
2004	*/
2005	#define EXT4_OS_LINUX 0
2006	#define EXT4_OS_HURD 1
2007	#define EXT4_OS_MASIX 2
2008	#define EXT4_OS_FREEBSD 3
2009	#define EXT4_OS_LITES 4
2010
2011	/*
2012	* Revision levels
2013	*/
2014	#define EXT4_GOOD_OLD_REV 0 /* The good old (original) format */
2015	#define EXT4_DYNAMIC_REV 1 /* V2 format w/ dynamic inode sizes */
2016
2017	#define EXT4_MAX_SUPP_REV EXT4_DYNAMIC_REV
2018
2019	#define EXT4_GOOD_OLD_INODE_SIZE 128
2020
2021	#define EXT4_EXTRA_TIMESTAMP_MAX (((s64)1 << 34) - 1 + S32_MIN)
2022	#define EXT4_NON_EXTRA_TIMESTAMP_MAX S32_MAX
2023	#define EXT4_TIMESTAMP_MIN S32_MIN
2024
2025	/*
2026	* Feature set definitions
2027	*/
2028
2029	#define EXT4_FEATURE_COMPAT_DIR_PREALLOC 0x0001
2030	#define EXT4_FEATURE_COMPAT_IMAGIC_INODES 0x0002
2031	#define EXT4_FEATURE_COMPAT_HAS_JOURNAL 0x0004
2032	#define EXT4_FEATURE_COMPAT_EXT_ATTR 0x0008
2033	#define EXT4_FEATURE_COMPAT_RESIZE_INODE 0x0010
2034	#define EXT4_FEATURE_COMPAT_DIR_INDEX 0x0020
2035	#define EXT4_FEATURE_COMPAT_SPARSE_SUPER2 0x0200
2036	/*
2037	* The reason why "FAST_COMMIT" is a compat feature is that, FS becomes
2038	* incompatible only if fast commit blocks are present in the FS. Since we
2039	* clear the journal (and thus the fast commit blocks), we don't mark FS as
2040	* incompatible. We also have a JBD2 incompat feature, which gets set when
2041	* there are fast commit blocks present in the journal.
2042	*/
2043	#define EXT4_FEATURE_COMPAT_FAST_COMMIT 0x0400
2044	#define EXT4_FEATURE_COMPAT_STABLE_INODES 0x0800
2045	#define EXT4_FEATURE_COMPAT_ORPHAN_FILE 0x1000 /* Orphan file exists */
2046
2047	#define EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001
2048	#define EXT4_FEATURE_RO_COMPAT_LARGE_FILE 0x0002
2049	#define EXT4_FEATURE_RO_COMPAT_BTREE_DIR 0x0004
2050	#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008
2051	#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010
2052	#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020
2053	#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040
2054	#define EXT4_FEATURE_RO_COMPAT_QUOTA 0x0100
2055	#define EXT4_FEATURE_RO_COMPAT_BIGALLOC 0x0200
2056	/*
2057	* METADATA_CSUM also enables group descriptor checksums (GDT_CSUM). When
2058	* METADATA_CSUM is set, group descriptor checksums use the same algorithm as
2059	* all other data structures' checksums. However, the METADATA_CSUM and
2060	* GDT_CSUM bits are mutually exclusive.
2061	*/
2062	#define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400
2063	#define EXT4_FEATURE_RO_COMPAT_READONLY 0x1000
2064	#define EXT4_FEATURE_RO_COMPAT_PROJECT 0x2000
2065	#define EXT4_FEATURE_RO_COMPAT_VERITY 0x8000
2066	#define EXT4_FEATURE_RO_COMPAT_ORPHAN_PRESENT 0x10000 /* Orphan file may be
2067	non-empty */
2068
2069	#define EXT4_FEATURE_INCOMPAT_COMPRESSION 0x0001
2070	#define EXT4_FEATURE_INCOMPAT_FILETYPE 0x0002
2071	#define EXT4_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */
2072	#define EXT4_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Journal device */
2073	#define EXT4_FEATURE_INCOMPAT_META_BG 0x0010
2074	#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 /* extents support */
2075	#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080
2076	#define EXT4_FEATURE_INCOMPAT_MMP 0x0100
2077	#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200
2078	#define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400 /* EA in inode */
2079	#define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000 /* data in dirent */
2080	#define EXT4_FEATURE_INCOMPAT_CSUM_SEED 0x2000
2081	#define EXT4_FEATURE_INCOMPAT_LARGEDIR 0x4000 /* >2GB or 3-lvl htree */
2082	#define EXT4_FEATURE_INCOMPAT_INLINE_DATA 0x8000 /* data in inode */
2083	#define EXT4_FEATURE_INCOMPAT_ENCRYPT 0x10000
2084	#define EXT4_FEATURE_INCOMPAT_CASEFOLD 0x20000
2085
2086	extern void ext4_update_dynamic_rev(struct super_block *sb);
2087
2088	#define EXT4_FEATURE_COMPAT_FUNCS(name, flagname) \
2089	static inline bool ext4_has_feature_##name(struct super_block *sb) \
2090	{ \
2091	return ((EXT4_SB(sb)->s_es->s_feature_compat & \
2092	cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname)) != 0); \
2093	} \
2094	static inline void ext4_set_feature_##name(struct super_block *sb) \
2095	{ \
2096	ext4_update_dynamic_rev(sb); \
2097	EXT4_SB(sb)->s_es->s_feature_compat |= \
2098	cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname); \
2099	} \
2100	static inline void ext4_clear_feature_##name(struct super_block *sb) \
2101	{ \
2102	EXT4_SB(sb)->s_es->s_feature_compat &= \
2103	~cpu_to_le32(EXT4_FEATURE_COMPAT_##flagname); \
2104	}
2105
2106	#define EXT4_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
2107	static inline bool ext4_has_feature_##name(struct super_block *sb) \
2108	{ \
2109	return ((EXT4_SB(sb)->s_es->s_feature_ro_compat & \
2110	cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname)) != 0); \
2111	} \
2112	static inline void ext4_set_feature_##name(struct super_block *sb) \
2113	{ \
2114	ext4_update_dynamic_rev(sb); \
2115	EXT4_SB(sb)->s_es->s_feature_ro_compat |= \
2116	cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname); \
2117	} \
2118	static inline void ext4_clear_feature_##name(struct super_block *sb) \
2119	{ \
2120	EXT4_SB(sb)->s_es->s_feature_ro_compat &= \
2121	~cpu_to_le32(EXT4_FEATURE_RO_COMPAT_##flagname); \
2122	}
2123
2124	#define EXT4_FEATURE_INCOMPAT_FUNCS(name, flagname) \
2125	static inline bool ext4_has_feature_##name(struct super_block *sb) \
2126	{ \
2127	return ((EXT4_SB(sb)->s_es->s_feature_incompat & \
2128	cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname)) != 0); \
2129	} \
2130	static inline void ext4_set_feature_##name(struct super_block *sb) \
2131	{ \
2132	ext4_update_dynamic_rev(sb); \
2133	EXT4_SB(sb)->s_es->s_feature_incompat |= \
2134	cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname); \
2135	} \
2136	static inline void ext4_clear_feature_##name(struct super_block *sb) \
2137	{ \
2138	EXT4_SB(sb)->s_es->s_feature_incompat &= \
2139	~cpu_to_le32(EXT4_FEATURE_INCOMPAT_##flagname); \
2140	}
2141
2142	EXT4_FEATURE_COMPAT_FUNCS(dir_prealloc, DIR_PREALLOC)
2143	EXT4_FEATURE_COMPAT_FUNCS(imagic_inodes, IMAGIC_INODES)
2144	EXT4_FEATURE_COMPAT_FUNCS(journal, HAS_JOURNAL)
2145	EXT4_FEATURE_COMPAT_FUNCS(xattr, EXT_ATTR)
2146	EXT4_FEATURE_COMPAT_FUNCS(resize_inode, RESIZE_INODE)
2147	EXT4_FEATURE_COMPAT_FUNCS(dir_index, DIR_INDEX)
2148	EXT4_FEATURE_COMPAT_FUNCS(sparse_super2, SPARSE_SUPER2)
2149	EXT4_FEATURE_COMPAT_FUNCS(fast_commit, FAST_COMMIT)
2150	EXT4_FEATURE_COMPAT_FUNCS(stable_inodes, STABLE_INODES)
2151	EXT4_FEATURE_COMPAT_FUNCS(orphan_file, ORPHAN_FILE)
2152
2153	EXT4_FEATURE_RO_COMPAT_FUNCS(sparse_super, SPARSE_SUPER)
2154	EXT4_FEATURE_RO_COMPAT_FUNCS(large_file, LARGE_FILE)
2155	EXT4_FEATURE_RO_COMPAT_FUNCS(btree_dir, BTREE_DIR)
2156	EXT4_FEATURE_RO_COMPAT_FUNCS(huge_file, HUGE_FILE)
2157	EXT4_FEATURE_RO_COMPAT_FUNCS(gdt_csum, GDT_CSUM)
2158	EXT4_FEATURE_RO_COMPAT_FUNCS(dir_nlink, DIR_NLINK)
2159	EXT4_FEATURE_RO_COMPAT_FUNCS(extra_isize, EXTRA_ISIZE)
2160	EXT4_FEATURE_RO_COMPAT_FUNCS(quota, QUOTA)
2161	EXT4_FEATURE_RO_COMPAT_FUNCS(bigalloc, BIGALLOC)
2162	EXT4_FEATURE_RO_COMPAT_FUNCS(metadata_csum, METADATA_CSUM)
2163	EXT4_FEATURE_RO_COMPAT_FUNCS(readonly, READONLY)
2164	EXT4_FEATURE_RO_COMPAT_FUNCS(project, PROJECT)
2165	EXT4_FEATURE_RO_COMPAT_FUNCS(verity, VERITY)
2166	EXT4_FEATURE_RO_COMPAT_FUNCS(orphan_present, ORPHAN_PRESENT)
2167
2168	EXT4_FEATURE_INCOMPAT_FUNCS(compression, COMPRESSION)
2169	EXT4_FEATURE_INCOMPAT_FUNCS(filetype, FILETYPE)
2170	EXT4_FEATURE_INCOMPAT_FUNCS(journal_needs_recovery, RECOVER)
2171	EXT4_FEATURE_INCOMPAT_FUNCS(journal_dev, JOURNAL_DEV)
2172	EXT4_FEATURE_INCOMPAT_FUNCS(meta_bg, META_BG)
2173	EXT4_FEATURE_INCOMPAT_FUNCS(extents, EXTENTS)
2174	EXT4_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
2175	EXT4_FEATURE_INCOMPAT_FUNCS(mmp, MMP)
2176	EXT4_FEATURE_INCOMPAT_FUNCS(flex_bg, FLEX_BG)
2177	EXT4_FEATURE_INCOMPAT_FUNCS(ea_inode, EA_INODE)
2178	EXT4_FEATURE_INCOMPAT_FUNCS(dirdata, DIRDATA)
2179	EXT4_FEATURE_INCOMPAT_FUNCS(csum_seed, CSUM_SEED)
2180	EXT4_FEATURE_INCOMPAT_FUNCS(largedir, LARGEDIR)
2181	EXT4_FEATURE_INCOMPAT_FUNCS(inline_data, INLINE_DATA)
2182	EXT4_FEATURE_INCOMPAT_FUNCS(encrypt, ENCRYPT)
2183	EXT4_FEATURE_INCOMPAT_FUNCS(casefold, CASEFOLD)
2184
2185	#define EXT2_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR
2186	#define EXT2_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \
2187	EXT4_FEATURE_INCOMPAT_META_BG)
2188	#define EXT2_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
2189	EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
2190	EXT4_FEATURE_RO_COMPAT_BTREE_DIR)
2191
2192	#define EXT3_FEATURE_COMPAT_SUPP EXT4_FEATURE_COMPAT_EXT_ATTR
2193	#define EXT3_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \
2194	EXT4_FEATURE_INCOMPAT_RECOVER| \
2195	EXT4_FEATURE_INCOMPAT_META_BG)
2196	#define EXT3_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
2197	EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
2198	EXT4_FEATURE_RO_COMPAT_BTREE_DIR)
2199
2200	#define EXT4_FEATURE_COMPAT_SUPP (EXT4_FEATURE_COMPAT_EXT_ATTR| \
2201	EXT4_FEATURE_COMPAT_ORPHAN_FILE)
2202	#define EXT4_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE| \
2203	EXT4_FEATURE_INCOMPAT_RECOVER| \
2204	EXT4_FEATURE_INCOMPAT_META_BG| \
2205	EXT4_FEATURE_INCOMPAT_EXTENTS| \
2206	EXT4_FEATURE_INCOMPAT_64BIT| \
2207	EXT4_FEATURE_INCOMPAT_FLEX_BG| \
2208	EXT4_FEATURE_INCOMPAT_EA_INODE| \
2209	EXT4_FEATURE_INCOMPAT_MMP | \
2210	EXT4_FEATURE_INCOMPAT_INLINE_DATA | \
2211	EXT4_FEATURE_INCOMPAT_ENCRYPT | \
2212	EXT4_FEATURE_INCOMPAT_CASEFOLD | \
2213	EXT4_FEATURE_INCOMPAT_CSUM_SEED | \
2214	EXT4_FEATURE_INCOMPAT_LARGEDIR)
2215	#define EXT4_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER| \
2216	EXT4_FEATURE_RO_COMPAT_LARGE_FILE| \
2217	EXT4_FEATURE_RO_COMPAT_GDT_CSUM| \
2218	EXT4_FEATURE_RO_COMPAT_DIR_NLINK | \
2219	EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE | \
2220	EXT4_FEATURE_RO_COMPAT_BTREE_DIR |\
2221	EXT4_FEATURE_RO_COMPAT_HUGE_FILE |\
2222	EXT4_FEATURE_RO_COMPAT_BIGALLOC |\
2223	EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|\
2224	EXT4_FEATURE_RO_COMPAT_QUOTA |\
2225	EXT4_FEATURE_RO_COMPAT_PROJECT |\
2226	EXT4_FEATURE_RO_COMPAT_VERITY |\
2227	EXT4_FEATURE_RO_COMPAT_ORPHAN_PRESENT)
2228
2229	#define EXTN_FEATURE_FUNCS(ver) \
2230	static inline bool ext4_has_unknown_ext##ver##_compat_features(struct super_block *sb) \
2231	{ \
2232	return ((EXT4_SB(sb)->s_es->s_feature_compat & \
2233	cpu_to_le32(~EXT##ver##_FEATURE_COMPAT_SUPP)) != 0); \
2234	} \
2235	static inline bool ext4_has_unknown_ext##ver##_ro_compat_features(struct super_block *sb) \
2236	{ \
2237	return ((EXT4_SB(sb)->s_es->s_feature_ro_compat & \
2238	cpu_to_le32(~EXT##ver##_FEATURE_RO_COMPAT_SUPP)) != 0); \
2239	} \
2240	static inline bool ext4_has_unknown_ext##ver##_incompat_features(struct super_block *sb) \
2241	{ \
2242	return ((EXT4_SB(sb)->s_es->s_feature_incompat & \
2243	cpu_to_le32(~EXT##ver##_FEATURE_INCOMPAT_SUPP)) != 0); \
2244	}
2245
2246	EXTN_FEATURE_FUNCS(2)
2247	EXTN_FEATURE_FUNCS(3)
2248	EXTN_FEATURE_FUNCS(4)
2249
2250	static inline bool ext4_has_compat_features(struct super_block *sb)
2251	{
2252	return (EXT4_SB(sb)->s_es->s_feature_compat != 0);
2253	}
2254	static inline bool ext4_has_ro_compat_features(struct super_block *sb)
2255	{
2256	return (EXT4_SB(sb)->s_es->s_feature_ro_compat != 0);
2257	}
2258	static inline bool ext4_has_incompat_features(struct super_block *sb)
2259	{
2260	return (EXT4_SB(sb)->s_es->s_feature_incompat != 0);
2261	}
2262
2263	extern int ext4_feature_set_ok(struct super_block *sb, int readonly);
2264
2265	/*
2266	* Superblock flags
2267	*/
2268	enum {
2269	EXT4_FLAGS_RESIZING, /* Avoid superblock update and resize race */
2270	EXT4_FLAGS_SHUTDOWN, /* Prevent access to the file system */
2271	EXT4_FLAGS_BDEV_IS_DAX, /* Current block device support DAX */
2272	EXT4_FLAGS_EMERGENCY_RO,/* Emergency read-only due to fs errors */
2273	};
2274
2275	static inline int ext4_forced_shutdown(struct super_block *sb)
2276	{
2277	return test_bit(EXT4_FLAGS_SHUTDOWN, &EXT4_SB(sb)->s_ext4_flags);
2278	}
2279
2280	static inline int ext4_emergency_ro(struct super_block *sb)
2281	{
2282	return test_bit(EXT4_FLAGS_EMERGENCY_RO, &EXT4_SB(sb)->s_ext4_flags);
2283	}
2284
2285	static inline int ext4_emergency_state(struct super_block *sb)
2286	{
2287	if (unlikely(ext4_forced_shutdown(sb)))
2288	return -EIO;
2289	if (unlikely(ext4_emergency_ro(sb)))
2290	return -EROFS;
2291	return 0;
2292	}
2293
2294	/*
2295	* Default values for user and/or group using reserved blocks
2296	*/
2297	#define EXT4_DEF_RESUID 0
2298	#define EXT4_DEF_RESGID 0
2299
2300	/*
2301	* Default project ID
2302	*/
2303	#define EXT4_DEF_PROJID 0
2304
2305	#define EXT4_DEF_INODE_READAHEAD_BLKS 32
2306
2307	/*
2308	* Default mount options
2309	*/
2310	#define EXT4_DEFM_DEBUG 0x0001
2311	#define EXT4_DEFM_BSDGROUPS 0x0002
2312	#define EXT4_DEFM_XATTR_USER 0x0004
2313	#define EXT4_DEFM_ACL 0x0008
2314	#define EXT4_DEFM_UID16 0x0010
2315	#define EXT4_DEFM_JMODE 0x0060
2316	#define EXT4_DEFM_JMODE_DATA 0x0020
2317	#define EXT4_DEFM_JMODE_ORDERED 0x0040
2318	#define EXT4_DEFM_JMODE_WBACK 0x0060
2319	#define EXT4_DEFM_NOBARRIER 0x0100
2320	#define EXT4_DEFM_BLOCK_VALIDITY 0x0200
2321	#define EXT4_DEFM_DISCARD 0x0400
2322	#define EXT4_DEFM_NODELALLOC 0x0800
2323
2324	/*
2325	* Default journal batch times and ioprio.
2326	*/
2327	#define EXT4_DEF_MIN_BATCH_TIME 0
2328	#define EXT4_DEF_MAX_BATCH_TIME 15000 /* 15ms */
2329	#define EXT4_DEF_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3))
2330
2331
2332	/*
2333	* Default values for superblock update
2334	*/
2335	#define EXT4_DEF_SB_UPDATE_INTERVAL_SEC (3600) /* seconds (1 hour) */
2336	#define EXT4_DEF_SB_UPDATE_INTERVAL_KB (16384) /* kilobytes (16MB) */
2337
2338
2339	/*
2340	* Minimum number of groups in a flexgroup before we separate out
2341	* directories into the first block group of a flexgroup
2342	*/
2343	#define EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME 4
2344
2345	/*
2346	* Structure of a directory entry
2347	*/
2348	#define EXT4_NAME_LEN 255
2349	/*
2350	* Base length of the ext4 directory entry excluding the name length
2351	*/
2352	#define EXT4_BASE_DIR_LEN (sizeof(struct ext4_dir_entry_2) - EXT4_NAME_LEN)
2353
2354	struct ext4_dir_entry {
2355	__le32 inode; /* Inode number */
2356	__le16 rec_len; /* Directory entry length */
2357	__le16 name_len; /* Name length */
2358	char name[EXT4_NAME_LEN]; /* File name */
2359	};
2360
2361
2362	/*
2363	* Encrypted Casefolded entries require saving the hash on disk. This structure
2364	* followed ext4_dir_entry_2's name[name_len] at the next 4 byte aligned
2365	* boundary.
2366	*/
2367	struct ext4_dir_entry_hash {
2368	__le32 hash;
2369	__le32 minor_hash;
2370	};
2371
2372	/*
2373	* The new version of the directory entry. Since EXT4 structures are
2374	* stored in intel byte order, and the name_len field could never be
2375	* bigger than 255 chars, it's safe to reclaim the extra byte for the
2376	* file_type field.
2377	*/
2378	struct ext4_dir_entry_2 {
2379	__le32 inode; /* Inode number */
2380	__le16 rec_len; /* Directory entry length */
2381	__u8 name_len; /* Name length */
2382	__u8 file_type; /* See file type macros EXT4_FT_* below */
2383	char name[EXT4_NAME_LEN]; /* File name */
2384	};
2385
2386	/*
2387	* Access the hashes at the end of ext4_dir_entry_2
2388	*/
2389	#define EXT4_DIRENT_HASHES(entry) \
2390	((struct ext4_dir_entry_hash *) \
2391	(((void *)(entry)) + \
2392	((8 + (entry)->name_len + EXT4_DIR_ROUND) & ~EXT4_DIR_ROUND)))
2393	#define EXT4_DIRENT_HASH(entry) le32_to_cpu(EXT4_DIRENT_HASHES(entry)->hash)
2394	#define EXT4_DIRENT_MINOR_HASH(entry) \
2395	le32_to_cpu(EXT4_DIRENT_HASHES(entry)->minor_hash)
2396
2397	static inline bool ext4_hash_in_dirent(const struct inode *inode)
2398	{
2399	return IS_CASEFOLDED(inode) && IS_ENCRYPTED(inode);
2400	}
2401
2402	/*
2403	* This is a bogus directory entry at the end of each leaf block that
2404	* records checksums.
2405	*/
2406	struct ext4_dir_entry_tail {
2407	__le32 det_reserved_zero1; /* Pretend to be unused */
2408	__le16 det_rec_len; /* 12 */
2409	__u8 det_reserved_zero2; /* Zero name length */
2410	__u8 det_reserved_ft; /* 0xDE, fake file type */
2411	__le32 det_checksum; /* crc32c(uuid+inum+dirblock) */
2412	};
2413
2414	#define EXT4_DIRENT_TAIL(block, blocksize) \
2415	((struct ext4_dir_entry_tail *)(((void *)(block)) + \
2416	((blocksize) - \
2417	sizeof(struct ext4_dir_entry_tail))))
2418
2419	/*
2420	* Ext4 directory file types. Only the low 3 bits are used. The
2421	* other bits are reserved for now.
2422	*/
2423	#define EXT4_FT_UNKNOWN 0
2424	#define EXT4_FT_REG_FILE 1
2425	#define EXT4_FT_DIR 2
2426	#define EXT4_FT_CHRDEV 3
2427	#define EXT4_FT_BLKDEV 4
2428	#define EXT4_FT_FIFO 5
2429	#define EXT4_FT_SOCK 6
2430	#define EXT4_FT_SYMLINK 7
2431
2432	#define EXT4_FT_MAX 8
2433
2434	#define EXT4_FT_DIR_CSUM 0xDE
2435
2436	/*
2437	* EXT4_DIR_PAD defines the directory entries boundaries
2438	*
2439	* NOTE: It must be a multiple of 4
2440	*/
2441	#define EXT4_DIR_PAD 4
2442	#define EXT4_DIR_ROUND (EXT4_DIR_PAD - 1)
2443	#define EXT4_MAX_REC_LEN ((1<<16)-1)
2444
2445	/*
2446	* The rec_len is dependent on the type of directory. Directories that are
2447	* casefolded and encrypted need to store the hash as well, so we add room for
2448	* ext4_extended_dir_entry_2. For all entries related to '.' or '..' you should
2449	* pass NULL for dir, as those entries do not use the extra fields.
2450	*/
2451	static inline unsigned int ext4_dir_rec_len(__u8 name_len,
2452	const struct inode *dir)
2453	{
2454	int rec_len = (name_len + 8 + EXT4_DIR_ROUND);
2455
2456	if (dir && ext4_hash_in_dirent(inode: dir))
2457	rec_len += sizeof(struct ext4_dir_entry_hash);
2458	return (rec_len & ~EXT4_DIR_ROUND);
2459	}
2460
2461	/*
2462	* If we ever get support for fs block sizes > page_size, we'll need
2463	* to remove the #if statements in the next two functions...
2464	*/
2465	static inline unsigned int
2466	ext4_rec_len_from_disk(__le16 dlen, unsigned blocksize)
2467	{
2468	unsigned len = le16_to_cpu(dlen);
2469
2470	#if (PAGE_SIZE >= 65536)
2471	if (len == EXT4_MAX_REC_LEN || len == 0)
2472	return blocksize;
2473	return (len & 65532) | ((len & 3) << 16);
2474	#else
2475	return len;
2476	#endif
2477	}
2478
2479	static inline __le16 ext4_rec_len_to_disk(unsigned len, unsigned blocksize)
2480	{
2481	BUG_ON((len > blocksize) || (blocksize > (1 << 18)) || (len & 3));
2482	#if (PAGE_SIZE >= 65536)
2483	if (len < 65536)
2484	return cpu_to_le16(len);
2485	if (len == blocksize) {
2486	if (blocksize == 65536)
2487	return cpu_to_le16(EXT4_MAX_REC_LEN);
2488	else
2489	return cpu_to_le16(0);
2490	}
2491	return cpu_to_le16((len & 65532) | ((len >> 16) & 3));
2492	#else
2493	return cpu_to_le16(len);
2494	#endif
2495	}
2496
2497	/*
2498	* Hash Tree Directory indexing
2499	* (c) Daniel Phillips, 2001
2500	*/
2501
2502	#define is_dx(dir) (ext4_has_feature_dir_index((dir)->i_sb) && \
2503	ext4_test_inode_flag((dir), EXT4_INODE_INDEX))
2504	#define EXT4_DIR_LINK_MAX(dir) unlikely((dir)->i_nlink >= EXT4_LINK_MAX && \
2505	!(ext4_has_feature_dir_nlink((dir)->i_sb) && is_dx(dir)))
2506	#define EXT4_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1)
2507
2508	/* Legal values for the dx_root hash_version field: */
2509
2510	#define DX_HASH_LEGACY 0
2511	#define DX_HASH_HALF_MD4 1
2512	#define DX_HASH_TEA 2
2513	#define DX_HASH_LEGACY_UNSIGNED 3
2514	#define DX_HASH_HALF_MD4_UNSIGNED 4
2515	#define DX_HASH_TEA_UNSIGNED 5
2516	#define DX_HASH_SIPHASH 6
2517	#define DX_HASH_LAST DX_HASH_SIPHASH
2518
2519	static inline u32 ext4_chksum(u32 crc, const void *address, unsigned int length)
2520	{
2521	return crc32c(crc, p: address, len: length);
2522	}
2523
2524	#ifdef __KERNEL__
2525
2526	/* hash info structure used by the directory hash */
2527	struct dx_hash_info
2528	{
2529	u32 hash;
2530	u32 minor_hash;
2531	int hash_version;
2532	u32 *seed;
2533	};
2534
2535
2536	/* 32 and 64 bit signed EOF for dx directories */
2537	#define EXT4_HTREE_EOF_32BIT ((1UL << (32 - 1)) - 1)
2538	#define EXT4_HTREE_EOF_64BIT ((1ULL << (64 - 1)) - 1)
2539
2540
2541	/*
2542	* Control parameters used by ext4_htree_next_block
2543	*/
2544	#define HASH_NB_ALWAYS 1
2545
2546	struct ext4_filename {
2547	const struct qstr *usr_fname;
2548	struct fscrypt_str disk_name;
2549	struct dx_hash_info hinfo;
2550	#ifdef CONFIG_FS_ENCRYPTION
2551	struct fscrypt_str crypto_buf;
2552	#endif
2553	#if IS_ENABLED(CONFIG_UNICODE)
2554	struct qstr cf_name;
2555	#endif
2556	};
2557
2558	#define fname_name(p) ((p)->disk_name.name)
2559	#define fname_usr_name(p) ((p)->usr_fname->name)
2560	#define fname_len(p) ((p)->disk_name.len)
2561
2562	/*
2563	* Describe an inode's exact location on disk and in memory
2564	*/
2565	struct ext4_iloc
2566	{
2567	struct buffer_head *bh;
2568	unsigned long offset;
2569	ext4_group_t block_group;
2570	};
2571
2572	static inline struct ext4_inode *ext4_raw_inode(struct ext4_iloc *iloc)
2573	{
2574	return (struct ext4_inode *) (iloc->bh->b_data + iloc->offset);
2575	}
2576
2577	static inline bool ext4_is_quota_file(struct inode *inode)
2578	{
2579	return IS_NOQUOTA(inode) &&
2580	!(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL);
2581	}
2582
2583	/*
2584	* This structure is stuffed into the struct file's private_data field
2585	* for directories. It is where we put information so that we can do
2586	* readdir operations in hash tree order.
2587	*/
2588	struct dir_private_info {
2589	struct rb_root root;
2590	struct rb_node *curr_node;
2591	struct fname *extra_fname;
2592	loff_t last_pos;
2593	__u32 curr_hash;
2594	__u32 curr_minor_hash;
2595	__u32 next_hash;
2596	u64 cookie;
2597	bool initialized;
2598	};
2599
2600	/* calculate the first block number of the group */
2601	static inline ext4_fsblk_t
2602	ext4_group_first_block_no(struct super_block *sb, ext4_group_t group_no)
2603	{
2604	return group_no * (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
2605	le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
2606	}
2607
2608	/*
2609	* Special error return code only used by dx_probe() and its callers.
2610	*/
2611	#define ERR_BAD_DX_DIR (-(MAX_ERRNO - 1))
2612
2613	/* htree levels for ext4 */
2614	#define EXT4_HTREE_LEVEL_COMPAT 2
2615	#define EXT4_HTREE_LEVEL 3
2616
2617	static inline int ext4_dir_htree_level(struct super_block *sb)
2618	{
2619	return ext4_has_feature_largedir(sb) ?
2620	EXT4_HTREE_LEVEL : EXT4_HTREE_LEVEL_COMPAT;
2621	}
2622
2623	/*
2624	* Timeout and state flag for lazy initialization inode thread.
2625	*/
2626	#define EXT4_DEF_LI_WAIT_MULT 10
2627	#define EXT4_DEF_LI_MAX_START_DELAY 5
2628	#define EXT4_LAZYINIT_QUIT 0x0001
2629	#define EXT4_LAZYINIT_RUNNING 0x0002
2630
2631	/*
2632	* Lazy inode table initialization info
2633	*/
2634	struct ext4_lazy_init {
2635	unsigned long li_state;
2636	struct list_head li_request_list;
2637	struct mutex li_list_mtx;
2638	};
2639
2640	enum ext4_li_mode {
2641	EXT4_LI_MODE_PREFETCH_BBITMAP,
2642	EXT4_LI_MODE_ITABLE,
2643	};
2644
2645	struct ext4_li_request {
2646	struct super_block *lr_super;
2647	enum ext4_li_mode lr_mode;
2648	ext4_group_t lr_first_not_zeroed;
2649	ext4_group_t lr_next_group;
2650	struct list_head lr_request;
2651	unsigned long lr_next_sched;
2652	unsigned long lr_timeout;
2653	};
2654
2655	struct ext4_features {
2656	struct kobject f_kobj;
2657	struct completion f_kobj_unregister;
2658	};
2659
2660	/*
2661	* This structure will be used for multiple mount protection. It will be
2662	* written into the block number saved in the s_mmp_block field in the
2663	* superblock. Programs that check MMP should assume that if
2664	* SEQ_FSCK (or any unknown code above SEQ_MAX) is present then it is NOT safe
2665	* to use the filesystem, regardless of how old the timestamp is.
2666	*/
2667	#define EXT4_MMP_MAGIC 0x004D4D50U /* ASCII for MMP */
2668	#define EXT4_MMP_SEQ_CLEAN 0xFF4D4D50U /* mmp_seq value for clean unmount */
2669	#define EXT4_MMP_SEQ_FSCK 0xE24D4D50U /* mmp_seq value when being fscked */
2670	#define EXT4_MMP_SEQ_MAX 0xE24D4D4FU /* maximum valid mmp_seq value */
2671
2672	struct mmp_struct {
2673	__le32 mmp_magic; /* Magic number for MMP */
2674	__le32 mmp_seq; /* Sequence no. updated periodically */
2675
2676	/*
2677	* mmp_time, mmp_nodename & mmp_bdevname are only used for information
2678	* purposes and do not affect the correctness of the algorithm
2679	*/
2680	__le64 mmp_time; /* Time last updated */
2681	char mmp_nodename[64]; /* Node which last updated MMP block */
2682	char mmp_bdevname[32]; /* Bdev which last updated MMP block */
2683
2684	/*
2685	* mmp_check_interval is used to verify if the MMP block has been
2686	* updated on the block device. The value is updated based on the
2687	* maximum time to write the MMP block during an update cycle.
2688	*/
2689	__le16 mmp_check_interval;
2690
2691	__le16 mmp_pad1;
2692	__le32 mmp_pad2[226];
2693	__le32 mmp_checksum; /* crc32c(uuid+mmp_block) */
2694	};
2695
2696	/* arguments passed to the mmp thread */
2697	struct mmpd_data {
2698	struct buffer_head *bh; /* bh from initial read_mmp_block() */
2699	struct super_block *sb; /* super block of the fs */
2700	};
2701
2702	/*
2703	* Check interval multiplier
2704	* The MMP block is written every update interval and initially checked every
2705	* update interval x the multiplier (the value is then adapted based on the
2706	* write latency). The reason is that writes can be delayed under load and we
2707	* don't want readers to incorrectly assume that the filesystem is no longer
2708	* in use.
2709	*/
2710	#define EXT4_MMP_CHECK_MULT 2UL
2711
2712	/*
2713	* Minimum interval for MMP checking in seconds.
2714	*/
2715	#define EXT4_MMP_MIN_CHECK_INTERVAL 5UL
2716
2717	/*
2718	* Maximum interval for MMP checking in seconds.
2719	*/
2720	#define EXT4_MMP_MAX_CHECK_INTERVAL 300UL
2721
2722	/*
2723	* Function prototypes
2724	*/
2725
2726	/*
2727	* Ok, these declarations are also in <linux/kernel.h> but none of the
2728	* ext4 source programs needs to include it so they are duplicated here.
2729	*/
2730	# define NORET_TYPE /**/
2731	# define ATTRIB_NORET __attribute__((noreturn))
2732	# define NORET_AND noreturn,
2733
2734	/* bitmap.c */
2735	extern unsigned int ext4_count_free(char *bitmap, unsigned numchars);
2736	void ext4_inode_bitmap_csum_set(struct super_block *sb,
2737	struct ext4_group_desc *gdp,
2738	struct buffer_head *bh);
2739	int ext4_inode_bitmap_csum_verify(struct super_block *sb,
2740	struct ext4_group_desc *gdp,
2741	struct buffer_head *bh);
2742	void ext4_block_bitmap_csum_set(struct super_block *sb,
2743	struct ext4_group_desc *gdp,
2744	struct buffer_head *bh);
2745	int ext4_block_bitmap_csum_verify(struct super_block *sb,
2746	struct ext4_group_desc *gdp,
2747	struct buffer_head *bh);
2748
2749	/* balloc.c */
2750	extern void ext4_get_group_no_and_offset(struct super_block *sb,
2751	ext4_fsblk_t blocknr,
2752	ext4_group_t *blockgrpp,
2753	ext4_grpblk_t *offsetp);
2754	extern ext4_group_t ext4_get_group_number(struct super_block *sb,
2755	ext4_fsblk_t block);
2756
2757	extern int ext4_bg_has_super(struct super_block *sb, ext4_group_t group);
2758	extern unsigned long ext4_bg_num_gdb(struct super_block *sb,
2759	ext4_group_t group);
2760	extern ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
2761	ext4_fsblk_t goal,
2762	unsigned int flags,
2763	unsigned long *count,
2764	int *errp);
2765	extern int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
2766	s64 nclusters, unsigned int flags);
2767	extern ext4_fsblk_t ext4_count_free_clusters(struct super_block *);
2768	extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
2769	ext4_group_t block_group,
2770	struct buffer_head ** bh);
2771	extern struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
2772	ext4_group_t group);
2773	extern int ext4_should_retry_alloc(struct super_block *sb, int *retries);
2774
2775	extern struct buffer_head *ext4_read_block_bitmap_nowait(struct super_block *sb,
2776	ext4_group_t block_group,
2777	bool ignore_locked);
2778	extern int ext4_wait_block_bitmap(struct super_block *sb,
2779	ext4_group_t block_group,
2780	struct buffer_head *bh);
2781	extern struct buffer_head *ext4_read_block_bitmap(struct super_block *sb,
2782	ext4_group_t block_group);
2783	extern unsigned ext4_free_clusters_after_init(struct super_block *sb,
2784	ext4_group_t block_group,
2785	struct ext4_group_desc *gdp);
2786	ext4_fsblk_t ext4_inode_to_goal_block(struct inode *);
2787
2788	#if IS_ENABLED(CONFIG_UNICODE)
2789	extern int ext4_fname_setup_ci_filename(struct inode *dir,
2790	const struct qstr *iname,
2791	struct ext4_filename *fname);
2792
2793	static inline void ext4_fname_free_ci_filename(struct ext4_filename *fname)
2794	{
2795	kfree(objp: fname->cf_name.name);
2796	fname->cf_name.name = NULL;
2797	}
2798	#else
2799	static inline int ext4_fname_setup_ci_filename(struct inode *dir,
2800	const struct qstr *iname,
2801	struct ext4_filename *fname)
2802	{
2803	return 0;
2804	}
2805
2806	static inline void ext4_fname_free_ci_filename(struct ext4_filename *fname)
2807	{
2808	}
2809	#endif
2810
2811	/* ext4 encryption related stuff goes here crypto.c */
2812	#ifdef CONFIG_FS_ENCRYPTION
2813	extern const struct fscrypt_operations ext4_cryptops;
2814
2815	int ext4_fname_setup_filename(struct inode *dir, const struct qstr *iname,
2816	int lookup, struct ext4_filename *fname);
2817
2818	int ext4_fname_prepare_lookup(struct inode *dir, struct dentry *dentry,
2819	struct ext4_filename *fname);
2820
2821	void ext4_fname_free_filename(struct ext4_filename *fname);
2822
2823	int ext4_ioctl_get_encryption_pwsalt(struct file *filp, void __user *arg);
2824
2825	#else /* !CONFIG_FS_ENCRYPTION */
2826	static inline int ext4_fname_setup_filename(struct inode *dir,
2827	const struct qstr *iname,
2828	int lookup,
2829	struct ext4_filename *fname)
2830	{
2831	fname->usr_fname = iname;
2832	fname->disk_name.name = (unsigned char *) iname->name;
2833	fname->disk_name.len = iname->len;
2834
2835	return ext4_fname_setup_ci_filename(dir, iname, fname);
2836	}
2837
2838	static inline int ext4_fname_prepare_lookup(struct inode *dir,
2839	struct dentry *dentry,
2840	struct ext4_filename *fname)
2841	{
2842	return ext4_fname_setup_filename(dir, &dentry->d_name, 1, fname);
2843	}
2844
2845	static inline void ext4_fname_free_filename(struct ext4_filename *fname)
2846	{
2847	ext4_fname_free_ci_filename(fname);
2848	}
2849
2850	static inline int ext4_ioctl_get_encryption_pwsalt(struct file *filp,
2851	void __user *arg)
2852	{
2853	return -EOPNOTSUPP;
2854	}
2855	#endif /* !CONFIG_FS_ENCRYPTION */
2856
2857	/* dir.c */
2858	extern int __ext4_check_dir_entry(const char *, unsigned int, struct inode *,
2859	struct file *,
2860	struct ext4_dir_entry_2 *,
2861	struct buffer_head *, char *, int,
2862	unsigned int);
2863	#define ext4_check_dir_entry(dir, filp, de, bh, buf, size, offset) \
2864	unlikely(__ext4_check_dir_entry(__func__, __LINE__, (dir), (filp), \
2865	(de), (bh), (buf), (size), (offset)))
2866	extern int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
2867	__u32 minor_hash,
2868	struct ext4_dir_entry_2 *dirent,
2869	struct fscrypt_str *ent_name);
2870	extern void ext4_htree_free_dir_info(struct dir_private_info *p);
2871	extern int ext4_find_dest_de(struct inode *dir, struct buffer_head *bh,
2872	void *buf, int buf_size,
2873	struct ext4_filename *fname,
2874	struct ext4_dir_entry_2 **dest_de);
2875	void ext4_insert_dentry(struct inode *dir, struct inode *inode,
2876	struct ext4_dir_entry_2 *de,
2877	int buf_size,
2878	struct ext4_filename *fname);
2879	static inline void ext4_update_dx_flag(struct inode *inode)
2880	{
2881	if (!ext4_has_feature_dir_index(sb: inode->i_sb) &&
2882	ext4_test_inode_flag(inode, bit: EXT4_INODE_INDEX)) {
2883	/* ext4_iget() should have caught this... */
2884	WARN_ON_ONCE(ext4_has_feature_metadata_csum(inode->i_sb));
2885	ext4_clear_inode_flag(inode, bit: EXT4_INODE_INDEX);
2886	}
2887	}
2888	static const unsigned char ext4_filetype_table[] = {
2889	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
2890	};
2891
2892	static inline unsigned char get_dtype(struct super_block *sb, int filetype)
2893	{
2894	if (!ext4_has_feature_filetype(sb) || filetype >= EXT4_FT_MAX)
2895	return DT_UNKNOWN;
2896
2897	return ext4_filetype_table[filetype];
2898	}
2899	extern int ext4_check_all_de(struct inode *dir, struct buffer_head *bh,
2900	void *buf, int buf_size);
2901
2902	/* fsync.c */
2903	extern int ext4_sync_file(struct file *, loff_t, loff_t, int);
2904
2905	/* hash.c */
2906	extern int ext4fs_dirhash(const struct inode *dir, const char *name, int len,
2907	struct dx_hash_info *hinfo);
2908
2909	/* ialloc.c */
2910	extern int ext4_mark_inode_used(struct super_block *sb, int ino);
2911	extern struct inode *__ext4_new_inode(struct mnt_idmap *, handle_t *,
2912	struct inode *, umode_t,
2913	const struct qstr *qstr, __u32 goal,
2914	uid_t *owner, __u32 i_flags,
2915	int handle_type, unsigned int line_no,
2916	int nblocks);
2917
2918	#define ext4_new_inode(handle, dir, mode, qstr, goal, owner, i_flags) \
2919	__ext4_new_inode(&nop_mnt_idmap, (handle), (dir), (mode), (qstr), \
2920	(goal), (owner), i_flags, 0, 0, 0)
2921	#define ext4_new_inode_start_handle(idmap, dir, mode, qstr, goal, owner, \
2922	type, nblocks) \
2923	__ext4_new_inode((idmap), NULL, (dir), (mode), (qstr), (goal), (owner), \
2924	0, (type), __LINE__, (nblocks))
2925
2926
2927	extern void ext4_free_inode(handle_t *, struct inode *);
2928	extern struct inode * ext4_orphan_get(struct super_block *, unsigned long);
2929	extern unsigned long ext4_count_free_inodes(struct super_block *);
2930	extern unsigned long ext4_count_dirs(struct super_block *);
2931	extern void ext4_mark_bitmap_end(int start_bit, int end_bit, char *bitmap);
2932	extern int ext4_init_inode_table(struct super_block *sb,
2933	ext4_group_t group, int barrier);
2934	extern void ext4_end_bitmap_read(struct buffer_head *bh, int uptodate);
2935
2936	/* fast_commit.c */
2937	int ext4_fc_info_show(struct seq_file *seq, void *v);
2938	void ext4_fc_init(struct super_block *sb, journal_t *journal);
2939	void ext4_fc_init_inode(struct inode *inode);
2940	void ext4_fc_track_range(handle_t *handle, struct inode *inode, ext4_lblk_t start,
2941	ext4_lblk_t end);
2942	void __ext4_fc_track_unlink(handle_t *handle, struct inode *inode,
2943	struct dentry *dentry);
2944	void __ext4_fc_track_link(handle_t *handle, struct inode *inode,
2945	struct dentry *dentry);
2946	void ext4_fc_track_unlink(handle_t *handle, struct dentry *dentry);
2947	void ext4_fc_track_link(handle_t *handle, struct dentry *dentry);
2948	void __ext4_fc_track_create(handle_t *handle, struct inode *inode,
2949	struct dentry *dentry);
2950	void ext4_fc_track_create(handle_t *handle, struct dentry *dentry);
2951	void ext4_fc_track_inode(handle_t *handle, struct inode *inode);
2952	void ext4_fc_mark_ineligible(struct super_block *sb, int reason, handle_t *handle);
2953	void ext4_fc_del(struct inode *inode);
2954	bool ext4_fc_replay_check_excluded(struct super_block *sb, ext4_fsblk_t block);
2955	void ext4_fc_replay_cleanup(struct super_block *sb);
2956	int ext4_fc_commit(journal_t *journal, tid_t commit_tid);
2957	int __init ext4_fc_init_dentry_cache(void);
2958	void ext4_fc_destroy_dentry_cache(void);
2959	int ext4_fc_record_regions(struct super_block *sb, int ino,
2960	ext4_lblk_t lblk, ext4_fsblk_t pblk,
2961	int len, int replay);
2962
2963	/* mballoc.c */
2964	extern const struct seq_operations ext4_mb_seq_groups_ops;
2965	extern const struct seq_operations ext4_mb_seq_structs_summary_ops;
2966	extern int ext4_seq_mb_stats_show(struct seq_file *seq, void *offset);
2967	extern int ext4_mb_init(struct super_block *);
2968	extern void ext4_mb_release(struct super_block *);
2969	extern ext4_fsblk_t ext4_mb_new_blocks(handle_t *,
2970	struct ext4_allocation_request *, int *);
2971	extern void ext4_discard_preallocations(struct inode *);
2972	extern int __init ext4_init_mballoc(void);
2973	extern void ext4_exit_mballoc(void);
2974	extern ext4_group_t ext4_mb_prefetch(struct super_block *sb,
2975	ext4_group_t group,
2976	unsigned int nr, int *cnt);
2977	extern void ext4_mb_prefetch_fini(struct super_block *sb, ext4_group_t group,
2978	unsigned int nr);
2979
2980	extern void ext4_free_blocks(handle_t *handle, struct inode *inode,
2981	struct buffer_head *bh, ext4_fsblk_t block,
2982	unsigned long count, int flags);
2983	extern int ext4_mb_alloc_groupinfo(struct super_block *sb,
2984	ext4_group_t ngroups);
2985	extern int ext4_mb_add_groupinfo(struct super_block *sb,
2986	ext4_group_t i, struct ext4_group_desc *desc);
2987	extern int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
2988	ext4_fsblk_t block, unsigned long count);
2989	extern int ext4_trim_fs(struct super_block *, struct fstrim_range *);
2990	extern void ext4_process_freed_data(struct super_block *sb, tid_t commit_tid);
2991	extern void ext4_mb_mark_bb(struct super_block *sb, ext4_fsblk_t block,
2992	int len, bool state);
2993	static inline bool ext4_mb_cr_expensive(enum criteria cr)
2994	{
2995	return cr >= CR_GOAL_LEN_SLOW;
2996	}
2997
2998	/* inode.c */
2999	void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw,
3000	struct ext4_inode_info *ei);
3001	int ext4_inode_is_fast_symlink(struct inode *inode);
3002	void ext4_check_map_extents_env(struct inode *inode);
3003	struct buffer_head *ext4_getblk(handle_t *, struct inode *, ext4_lblk_t, int);
3004	struct buffer_head *ext4_bread(handle_t *, struct inode *, ext4_lblk_t, int);
3005	int ext4_bread_batch(struct inode *inode, ext4_lblk_t block, int bh_count,
3006	bool wait, struct buffer_head **bhs);
3007	int ext4_get_block_unwritten(struct inode *inode, sector_t iblock,
3008	struct buffer_head *bh_result, int create);
3009	int ext4_get_block(struct inode *inode, sector_t iblock,
3010	struct buffer_head *bh_result, int create);
3011	int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
3012	struct buffer_head *bh, int create);
3013	int ext4_walk_page_buffers(handle_t *handle,
3014	struct inode *inode,
3015	struct buffer_head *head,
3016	unsigned from,
3017	unsigned to,
3018	int *partial,
3019	int (*fn)(handle_t *handle, struct inode *inode,
3020	struct buffer_head *bh));
3021	int do_journal_get_write_access(handle_t *handle, struct inode *inode,
3022	struct buffer_head *bh);
3023	bool ext4_should_enable_large_folio(struct inode *inode);
3024	#define FALL_BACK_TO_NONDELALLOC 1
3025	#define CONVERT_INLINE_DATA 2
3026
3027	typedef enum {
3028	EXT4_IGET_NORMAL = 0,
3029	EXT4_IGET_SPECIAL = 0x0001, /* OK to iget a system inode */
3030	EXT4_IGET_HANDLE = 0x0002, /* Inode # is from a handle */
3031	EXT4_IGET_BAD = 0x0004, /* Allow to iget a bad inode */
3032	EXT4_IGET_EA_INODE = 0x0008 /* Inode should contain an EA value */
3033	} ext4_iget_flags;
3034
3035	extern struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
3036	ext4_iget_flags flags, const char *function,
3037	unsigned int line);
3038
3039	#define ext4_iget(sb, ino, flags) \
3040	__ext4_iget((sb), (ino), (flags), __func__, __LINE__)
3041
3042	extern int ext4_write_inode(struct inode *, struct writeback_control *);
3043	extern int ext4_setattr(struct mnt_idmap *, struct dentry *,
3044	struct iattr *);
3045	extern u32 ext4_dio_alignment(struct inode *inode);
3046	extern int ext4_getattr(struct mnt_idmap *, const struct path *,
3047	struct kstat *, u32, unsigned int);
3048	extern void ext4_evict_inode(struct inode *);
3049	extern void ext4_clear_inode(struct inode *);
3050	extern int ext4_file_getattr(struct mnt_idmap *, const struct path *,
3051	struct kstat *, u32, unsigned int);
3052	extern void ext4_dirty_inode(struct inode *, int);
3053	extern int ext4_change_inode_journal_flag(struct inode *, int);
3054	extern int ext4_get_inode_loc(struct inode *, struct ext4_iloc *);
3055	extern int ext4_get_fc_inode_loc(struct super_block *sb, unsigned long ino,
3056	struct ext4_iloc *iloc);
3057	extern int ext4_inode_attach_jinode(struct inode *inode);
3058	extern int ext4_can_truncate(struct inode *inode);
3059	extern int ext4_truncate(struct inode *);
3060	extern int ext4_break_layouts(struct inode *);
3061	extern int ext4_truncate_page_cache_block_range(struct inode *inode,
3062	loff_t start, loff_t end);
3063	extern int ext4_punch_hole(struct file *file, loff_t offset, loff_t length);
3064	extern void ext4_set_inode_flags(struct inode *, bool init);
3065	extern int ext4_alloc_da_blocks(struct inode *inode);
3066	extern void ext4_set_aops(struct inode *inode);
3067	extern int ext4_writepage_trans_blocks(struct inode *);
3068	extern int ext4_normal_submit_inode_data_buffers(struct jbd2_inode *jinode);
3069	extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
3070	extern int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
3071	int pextents);
3072	extern int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
3073	loff_t lstart, loff_t lend);
3074	extern vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf);
3075	extern qsize_t *ext4_get_reserved_space(struct inode *inode);
3076	extern int ext4_get_projid(struct inode *inode, kprojid_t *projid);
3077	extern void ext4_da_release_space(struct inode *inode, int to_free);
3078	extern void ext4_da_update_reserve_space(struct inode *inode,
3079	int used, int quota_claim);
3080	extern int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk,
3081	ext4_fsblk_t pblk, ext4_lblk_t len);
3082
3083	static inline bool is_special_ino(struct super_block *sb, unsigned long ino)
3084	{
3085	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
3086
3087	return (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO) ||
3088	ino == le32_to_cpu(es->s_usr_quota_inum) ||
3089	ino == le32_to_cpu(es->s_grp_quota_inum) ||
3090	ino == le32_to_cpu(es->s_prj_quota_inum) ||
3091	ino == le32_to_cpu(es->s_orphan_file_inum);
3092	}
3093
3094	/* indirect.c */
3095	extern int ext4_ind_map_blocks(handle_t *handle, struct inode *inode,
3096	struct ext4_map_blocks *map, int flags);
3097	extern int ext4_ind_trans_blocks(struct inode *inode, int nrblocks);
3098	extern void ext4_ind_truncate(handle_t *, struct inode *inode);
3099	extern int ext4_ind_remove_space(handle_t *handle, struct inode *inode,
3100	ext4_lblk_t start, ext4_lblk_t end);
3101
3102	/* ioctl.c */
3103	extern long ext4_ioctl(struct file *, unsigned int, unsigned long);
3104	extern long ext4_compat_ioctl(struct file *, unsigned int, unsigned long);
3105	int ext4_fileattr_set(struct mnt_idmap *idmap,
3106	struct dentry *dentry, struct fileattr *fa);
3107	int ext4_fileattr_get(struct dentry *dentry, struct fileattr *fa);
3108	extern void ext4_reset_inode_seed(struct inode *inode);
3109	int ext4_update_overhead(struct super_block *sb, bool force);
3110	int ext4_force_shutdown(struct super_block *sb, u32 flags);
3111
3112	/* migrate.c */
3113	extern int ext4_ext_migrate(struct inode *);
3114	extern int ext4_ind_migrate(struct inode *inode);
3115
3116	/* namei.c */
3117	extern int ext4_init_new_dir(handle_t *handle, struct inode *dir,
3118	struct inode *inode);
3119	extern int ext4_dirblock_csum_verify(struct inode *inode,
3120	struct buffer_head *bh);
3121	extern int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
3122	__u32 start_minor_hash, __u32 *next_hash);
3123	extern int ext4_search_dir(struct buffer_head *bh,
3124	char *search_buf,
3125	int buf_size,
3126	struct inode *dir,
3127	struct ext4_filename *fname,
3128	unsigned int offset,
3129	struct ext4_dir_entry_2 **res_dir);
3130	extern int ext4_generic_delete_entry(struct inode *dir,
3131	struct ext4_dir_entry_2 *de_del,
3132	struct buffer_head *bh,
3133	void *entry_buf,
3134	int buf_size,
3135	int csum_size);
3136	extern bool ext4_empty_dir(struct inode *inode);
3137
3138	/* resize.c */
3139	extern void ext4_kvfree_array_rcu(void *to_free);
3140	extern int ext4_group_add(struct super_block *sb,
3141	struct ext4_new_group_data *input);
3142	extern int ext4_group_extend(struct super_block *sb,
3143	struct ext4_super_block *es,
3144	ext4_fsblk_t n_blocks_count);
3145	extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count);
3146	extern unsigned int ext4_list_backups(struct super_block *sb,
3147	unsigned int *three, unsigned int *five,
3148	unsigned int *seven);
3149
3150	/* super.c */
3151	extern struct buffer_head *ext4_sb_bread(struct super_block *sb,
3152	sector_t block, blk_opf_t op_flags);
3153	extern struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,
3154	sector_t block);
3155	extern void ext4_read_bh_nowait(struct buffer_head *bh, blk_opf_t op_flags,
3156	bh_end_io_t *end_io, bool simu_fail);
3157	extern int ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags,
3158	bh_end_io_t *end_io, bool simu_fail);
3159	extern int ext4_read_bh_lock(struct buffer_head *bh, blk_opf_t op_flags, bool wait);
3160	extern void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block);
3161	extern int ext4_seq_options_show(struct seq_file *seq, void *offset);
3162	extern int ext4_calculate_overhead(struct super_block *sb);
3163	extern __le32 ext4_superblock_csum(struct ext4_super_block *es);
3164	extern void ext4_superblock_csum_set(struct super_block *sb);
3165	extern int ext4_alloc_flex_bg_array(struct super_block *sb,
3166	ext4_group_t ngroup);
3167	extern const char *ext4_decode_error(struct super_block *sb, int errno,
3168	char nbuf[16]);
3169	extern void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
3170	ext4_group_t block_group,
3171	unsigned int flags);
3172	extern unsigned int ext4_num_base_meta_blocks(struct super_block *sb,
3173	ext4_group_t block_group);
3174
3175	extern __printf(7, 8)
3176	void __ext4_error(struct super_block *, const char *, unsigned int, bool,
3177	int, __u64, const char *, ...);
3178	extern __printf(6, 7)
3179	void __ext4_error_inode(struct inode *, const char *, unsigned int,
3180	ext4_fsblk_t, int, const char *, ...);
3181	extern __printf(5, 6)
3182	void __ext4_error_file(struct file *, const char *, unsigned int, ext4_fsblk_t,
3183	const char *, ...);
3184	extern void __ext4_std_error(struct super_block *, const char *,
3185	unsigned int, int);
3186	extern __printf(4, 5)
3187	void __ext4_warning(struct super_block *, const char *, unsigned int,
3188	const char *, ...);
3189	extern __printf(4, 5)
3190	void __ext4_warning_inode(const struct inode *inode, const char *function,
3191	unsigned int line, const char *fmt, ...);
3192	extern __printf(3, 4)
3193	void __ext4_msg(struct super_block *, const char *, const char *, ...);
3194	extern void __dump_mmp_msg(struct super_block *, struct mmp_struct *mmp,
3195	const char *, unsigned int, const char *);
3196	extern __printf(7, 8)
3197	void __ext4_grp_locked_error(const char *, unsigned int,
3198	struct super_block *, ext4_group_t,
3199	unsigned long, ext4_fsblk_t,
3200	const char *, ...);
3201
3202	#define EXT4_ERROR_INODE(inode, fmt, a...) \
3203	ext4_error_inode((inode), __func__, __LINE__, 0, (fmt), ## a)
3204
3205	#define EXT4_ERROR_INODE_ERR(inode, err, fmt, a...) \
3206	__ext4_error_inode((inode), __func__, __LINE__, 0, (err), (fmt), ## a)
3207
3208	#define ext4_error_inode_block(inode, block, err, fmt, a...) \
3209	__ext4_error_inode((inode), __func__, __LINE__, (block), (err), \
3210	(fmt), ## a)
3211
3212	#define EXT4_ERROR_FILE(file, block, fmt, a...) \
3213	ext4_error_file((file), __func__, __LINE__, (block), (fmt), ## a)
3214
3215	#define ext4_abort(sb, err, fmt, a...) \
3216	__ext4_error((sb), __func__, __LINE__, true, (err), 0, (fmt), ## a)
3217
3218	#ifdef CONFIG_PRINTK
3219
3220	#define ext4_error_inode(inode, func, line, block, fmt, ...) \
3221	__ext4_error_inode(inode, func, line, block, 0, fmt, ##__VA_ARGS__)
3222	#define ext4_error_inode_err(inode, func, line, block, err, fmt, ...) \
3223	__ext4_error_inode((inode), (func), (line), (block), \
3224	(err), (fmt), ##__VA_ARGS__)
3225	#define ext4_error_file(file, func, line, block, fmt, ...) \
3226	__ext4_error_file(file, func, line, block, fmt, ##__VA_ARGS__)
3227	#define ext4_error(sb, fmt, ...) \
3228	__ext4_error((sb), __func__, __LINE__, false, 0, 0, (fmt), \
3229	##__VA_ARGS__)
3230	#define ext4_error_err(sb, err, fmt, ...) \
3231	__ext4_error((sb), __func__, __LINE__, false, (err), 0, (fmt), \
3232	##__VA_ARGS__)
3233	#define ext4_warning(sb, fmt, ...) \
3234	__ext4_warning(sb, __func__, __LINE__, fmt, ##__VA_ARGS__)
3235	#define ext4_warning_inode(inode, fmt, ...) \
3236	__ext4_warning_inode(inode, __func__, __LINE__, fmt, ##__VA_ARGS__)
3237	#define ext4_msg(sb, level, fmt, ...) \
3238	__ext4_msg(sb, level, fmt, ##__VA_ARGS__)
3239	#define dump_mmp_msg(sb, mmp, msg) \
3240	__dump_mmp_msg(sb, mmp, __func__, __LINE__, msg)
3241	#define ext4_grp_locked_error(sb, grp, ino, block, fmt, ...) \
3242	__ext4_grp_locked_error(__func__, __LINE__, sb, grp, ino, block, \
3243	fmt, ##__VA_ARGS__)
3244
3245	#else
3246
3247	#define ext4_error_inode(inode, func, line, block, fmt, ...) \
3248	do { \
3249	no_printk(fmt, ##__VA_ARGS__); \
3250	__ext4_error_inode(inode, "", 0, block, 0, " "); \
3251	} while (0)
3252	#define ext4_error_inode_err(inode, func, line, block, err, fmt, ...) \
3253	do { \
3254	no_printk(fmt, ##__VA_ARGS__); \
3255	__ext4_error_inode(inode, "", 0, block, err, " "); \
3256	} while (0)
3257	#define ext4_error_file(file, func, line, block, fmt, ...) \
3258	do { \
3259	no_printk(fmt, ##__VA_ARGS__); \
3260	__ext4_error_file(file, "", 0, block, " "); \
3261	} while (0)
3262	#define ext4_error(sb, fmt, ...) \
3263	do { \
3264	no_printk(fmt, ##__VA_ARGS__); \
3265	__ext4_error(sb, "", 0, false, 0, 0, " "); \
3266	} while (0)
3267	#define ext4_error_err(sb, err, fmt, ...) \
3268	do { \
3269	no_printk(fmt, ##__VA_ARGS__); \
3270	__ext4_error(sb, "", 0, false, err, 0, " "); \
3271	} while (0)
3272	#define ext4_warning(sb, fmt, ...) \
3273	do { \
3274	no_printk(fmt, ##__VA_ARGS__); \
3275	__ext4_warning(sb, "", 0, " "); \
3276	} while (0)
3277	#define ext4_warning_inode(inode, fmt, ...) \
3278	do { \
3279	no_printk(fmt, ##__VA_ARGS__); \
3280	__ext4_warning_inode(inode, "", 0, " "); \
3281	} while (0)
3282	#define ext4_msg(sb, level, fmt, ...) \
3283	do { \
3284	no_printk(fmt, ##__VA_ARGS__); \
3285	__ext4_msg(sb, "", " "); \
3286	} while (0)
3287	#define dump_mmp_msg(sb, mmp, msg) \
3288	__dump_mmp_msg(sb, mmp, "", 0, "")
3289	#define ext4_grp_locked_error(sb, grp, ino, block, fmt, ...) \
3290	do { \
3291	no_printk(fmt, ##__VA_ARGS__); \
3292	__ext4_grp_locked_error("", 0, sb, grp, ino, block, " "); \
3293	} while (0)
3294
3295	#endif
3296
3297	extern ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
3298	struct ext4_group_desc *bg);
3299	extern ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
3300	struct ext4_group_desc *bg);
3301	extern ext4_fsblk_t ext4_inode_table(struct super_block *sb,
3302	struct ext4_group_desc *bg);
3303	extern __u32 ext4_free_group_clusters(struct super_block *sb,
3304	struct ext4_group_desc *bg);
3305	extern __u32 ext4_free_inodes_count(struct super_block *sb,
3306	struct ext4_group_desc *bg);
3307	extern __u32 ext4_used_dirs_count(struct super_block *sb,
3308	struct ext4_group_desc *bg);
3309	extern __u32 ext4_itable_unused_count(struct super_block *sb,
3310	struct ext4_group_desc *bg);
3311	extern void ext4_block_bitmap_set(struct super_block *sb,
3312	struct ext4_group_desc *bg, ext4_fsblk_t blk);
3313	extern void ext4_inode_bitmap_set(struct super_block *sb,
3314	struct ext4_group_desc *bg, ext4_fsblk_t blk);
3315	extern void ext4_inode_table_set(struct super_block *sb,
3316	struct ext4_group_desc *bg, ext4_fsblk_t blk);
3317	extern void ext4_free_group_clusters_set(struct super_block *sb,
3318	struct ext4_group_desc *bg,
3319	__u32 count);
3320	extern void ext4_free_inodes_set(struct super_block *sb,
3321	struct ext4_group_desc *bg, __u32 count);
3322	extern void ext4_used_dirs_set(struct super_block *sb,
3323	struct ext4_group_desc *bg, __u32 count);
3324	extern void ext4_itable_unused_set(struct super_block *sb,
3325	struct ext4_group_desc *bg, __u32 count);
3326	extern int ext4_group_desc_csum_verify(struct super_block *sb, __u32 group,
3327	struct ext4_group_desc *gdp);
3328	extern void ext4_group_desc_csum_set(struct super_block *sb, __u32 group,
3329	struct ext4_group_desc *gdp);
3330	extern int ext4_register_li_request(struct super_block *sb,
3331	ext4_group_t first_not_zeroed);
3332
3333	static inline int ext4_has_group_desc_csum(struct super_block *sb)
3334	{
3335	return ext4_has_feature_gdt_csum(sb) ||
3336	ext4_has_feature_metadata_csum(sb);
3337	}
3338
3339	#define ext4_read_incompat_64bit_val(es, name) \
3340	(((es)->s_feature_incompat & cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT) \
3341	? (ext4_fsblk_t)le32_to_cpu(es->name##_hi) << 32 : 0) | \
3342	le32_to_cpu(es->name##_lo))
3343
3344	static inline ext4_fsblk_t ext4_blocks_count(struct ext4_super_block *es)
3345	{
3346	return ext4_read_incompat_64bit_val(es, s_blocks_count);
3347	}
3348
3349	static inline ext4_fsblk_t ext4_r_blocks_count(struct ext4_super_block *es)
3350	{
3351	return ext4_read_incompat_64bit_val(es, s_r_blocks_count);
3352	}
3353
3354	static inline ext4_fsblk_t ext4_free_blocks_count(struct ext4_super_block *es)
3355	{
3356	return ext4_read_incompat_64bit_val(es, s_free_blocks_count);
3357	}
3358
3359	static inline void ext4_blocks_count_set(struct ext4_super_block *es,
3360	ext4_fsblk_t blk)
3361	{
3362	es->s_blocks_count_lo = cpu_to_le32((u32)blk);
3363	es->s_blocks_count_hi = cpu_to_le32(blk >> 32);
3364	}
3365
3366	static inline void ext4_free_blocks_count_set(struct ext4_super_block *es,
3367	ext4_fsblk_t blk)
3368	{
3369	es->s_free_blocks_count_lo = cpu_to_le32((u32)blk);
3370	es->s_free_blocks_count_hi = cpu_to_le32(blk >> 32);
3371	}
3372
3373	static inline void ext4_r_blocks_count_set(struct ext4_super_block *es,
3374	ext4_fsblk_t blk)
3375	{
3376	es->s_r_blocks_count_lo = cpu_to_le32((u32)blk);
3377	es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32);
3378	}
3379
3380	static inline loff_t ext4_isize(struct super_block *sb,
3381	struct ext4_inode *raw_inode)
3382	{
3383	if (ext4_has_feature_largedir(sb) ||
3384	S_ISREG(le16_to_cpu(raw_inode->i_mode)))
3385	return ((loff_t)le32_to_cpu(raw_inode->i_size_high) << 32) |
3386	le32_to_cpu(raw_inode->i_size_lo);
3387
3388	return (loff_t) le32_to_cpu(raw_inode->i_size_lo);
3389	}
3390
3391	static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size)
3392	{
3393	raw_inode->i_size_lo = cpu_to_le32(i_size);
3394	raw_inode->i_size_high = cpu_to_le32(i_size >> 32);
3395	}
3396
3397	/*
3398	* Reading s_groups_count requires using smp_rmb() afterwards. See
3399	* the locking protocol documented in the comments of ext4_group_add()
3400	* in resize.c
3401	*/
3402	static inline ext4_group_t ext4_get_groups_count(struct super_block *sb)
3403	{
3404	ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
3405
3406	smp_rmb();
3407	return ngroups;
3408	}
3409
3410	static inline ext4_group_t ext4_flex_group(struct ext4_sb_info *sbi,
3411	ext4_group_t block_group)
3412	{
3413	return block_group >> sbi->s_log_groups_per_flex;
3414	}
3415
3416	static inline unsigned int ext4_flex_bg_size(struct ext4_sb_info *sbi)
3417	{
3418	return 1 << sbi->s_log_groups_per_flex;
3419	}
3420
3421	static inline loff_t ext4_get_maxbytes(struct inode *inode)
3422	{
3423	if (ext4_test_inode_flag(inode, bit: EXT4_INODE_EXTENTS))
3424	return inode->i_sb->s_maxbytes;
3425	return EXT4_SB(sb: inode->i_sb)->s_bitmap_maxbytes;
3426	}
3427
3428	#define ext4_std_error(sb, errno) \
3429	do { \
3430	if ((errno)) \
3431	__ext4_std_error((sb), __func__, __LINE__, (errno)); \
3432	} while (0)
3433
3434	#ifdef CONFIG_SMP
3435	/* Each CPU can accumulate percpu_counter_batch clusters in their local
3436	* counters. So we need to make sure we have free clusters more
3437	* than percpu_counter_batch * nr_cpu_ids. Also add a window of 4 times.
3438	*/
3439	#define EXT4_FREECLUSTERS_WATERMARK (4 * (percpu_counter_batch * nr_cpu_ids))
3440	#else
3441	#define EXT4_FREECLUSTERS_WATERMARK 0
3442	#endif
3443
3444	/* Update i_disksize. Requires i_rwsem to avoid races with truncate */
3445	static inline void ext4_update_i_disksize(struct inode *inode, loff_t newsize)
3446	{
3447	WARN_ON_ONCE(S_ISREG(inode->i_mode) &&
3448	!inode_is_locked(inode));
3449	down_write(sem: &EXT4_I(inode)->i_data_sem);
3450	if (newsize > EXT4_I(inode)->i_disksize)
3451	WRITE_ONCE(EXT4_I(inode)->i_disksize, newsize);
3452	up_write(sem: &EXT4_I(inode)->i_data_sem);
3453	}
3454
3455	/* Update i_size, i_disksize. Requires i_rwsem to avoid races with truncate */
3456	static inline int ext4_update_inode_size(struct inode *inode, loff_t newsize)
3457	{
3458	int changed = 0;
3459
3460	if (newsize > inode->i_size) {
3461	i_size_write(inode, i_size: newsize);
3462	changed = 1;
3463	}
3464	if (newsize > EXT4_I(inode)->i_disksize) {
3465	ext4_update_i_disksize(inode, newsize);
3466	changed |= 2;
3467	}
3468	return changed;
3469	}
3470
3471	int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset,
3472	loff_t len);
3473
3474	struct ext4_group_info {
3475	unsigned long bb_state;
3476	#ifdef AGGRESSIVE_CHECK
3477	unsigned long bb_check_counter;
3478	#endif
3479	struct rb_root bb_free_root;
3480	ext4_grpblk_t bb_first_free; /* first free block */
3481	ext4_grpblk_t bb_free; /* total free blocks */
3482	ext4_grpblk_t bb_fragments; /* nr of freespace fragments */
3483	int bb_avg_fragment_size_order; /* order of average
3484	fragment in BG */
3485	ext4_grpblk_t bb_largest_free_order;/* order of largest frag in BG */
3486	ext4_group_t bb_group; /* Group number */
3487	struct list_head bb_prealloc_list;
3488	#ifdef DOUBLE_CHECK
3489	void *bb_bitmap;
3490	#endif
3491	struct rw_semaphore alloc_sem;
3492	struct list_head bb_avg_fragment_size_node;
3493	struct list_head bb_largest_free_order_node;
3494	ext4_grpblk_t bb_counters[]; /* Nr of free power-of-two-block
3495	* regions, index is order.
3496	* bb_counters[3] = 5 means
3497	* 5 free 8-block regions. */
3498	};
3499
3500	#define EXT4_GROUP_INFO_NEED_INIT_BIT 0
3501	#define EXT4_GROUP_INFO_WAS_TRIMMED_BIT 1
3502	#define EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT 2
3503	#define EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT 3
3504	#define EXT4_GROUP_INFO_BBITMAP_CORRUPT \
3505	(1 << EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT)
3506	#define EXT4_GROUP_INFO_IBITMAP_CORRUPT \
3507	(1 << EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT)
3508	#define EXT4_GROUP_INFO_BBITMAP_READ_BIT 4
3509
3510	#define EXT4_MB_GRP_NEED_INIT(grp) \
3511	(test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state)))
3512	#define EXT4_MB_GRP_BBITMAP_CORRUPT(grp) \
3513	(test_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &((grp)->bb_state)))
3514	#define EXT4_MB_GRP_IBITMAP_CORRUPT(grp) \
3515	(test_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &((grp)->bb_state)))
3516
3517	#define EXT4_MB_GRP_WAS_TRIMMED(grp) \
3518	(test_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
3519	#define EXT4_MB_GRP_SET_TRIMMED(grp) \
3520	(set_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
3521	#define EXT4_MB_GRP_CLEAR_TRIMMED(grp) \
3522	(clear_bit(EXT4_GROUP_INFO_WAS_TRIMMED_BIT, &((grp)->bb_state)))
3523	#define EXT4_MB_GRP_TEST_AND_SET_READ(grp) \
3524	(test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_READ_BIT, &((grp)->bb_state)))
3525
3526	#define EXT4_MAX_CONTENTION 8
3527	#define EXT4_CONTENTION_THRESHOLD 2
3528
3529	static inline spinlock_t *ext4_group_lock_ptr(struct super_block *sb,
3530	ext4_group_t group)
3531	{
3532	return bgl_lock_ptr(bgl: EXT4_SB(sb)->s_blockgroup_lock, block_group: group);
3533	}
3534
3535	/*
3536	* Returns true if the filesystem is busy enough that attempts to
3537	* access the block group locks has run into contention.
3538	*/
3539	static inline int ext4_fs_is_busy(struct ext4_sb_info *sbi)
3540	{
3541	return (atomic_read(v: &sbi->s_lock_busy) > EXT4_CONTENTION_THRESHOLD);
3542	}
3543
3544	static inline void ext4_lock_group(struct super_block *sb, ext4_group_t group)
3545	{
3546	spinlock_t *lock = ext4_group_lock_ptr(sb, group);
3547	if (spin_trylock(lock))
3548	/*
3549	* We're able to grab the lock right away, so drop the
3550	* lock contention counter.
3551	*/
3552	atomic_add_unless(v: &EXT4_SB(sb)->s_lock_busy, a: -1, u: 0);
3553	else {
3554	/*
3555	* The lock is busy, so bump the contention counter,
3556	* and then wait on the spin lock.
3557	*/
3558	atomic_add_unless(v: &EXT4_SB(sb)->s_lock_busy, a: 1,
3559	EXT4_MAX_CONTENTION);
3560	spin_lock(lock);
3561	}
3562	}
3563
3564	static inline void ext4_unlock_group(struct super_block *sb,
3565	ext4_group_t group)
3566	{
3567	spin_unlock(lock: ext4_group_lock_ptr(sb, group));
3568	}
3569
3570	#ifdef CONFIG_QUOTA
3571	static inline bool ext4_quota_capable(struct super_block *sb)
3572	{
3573	return (test_opt(sb, QUOTA) || ext4_has_feature_quota(sb));
3574	}
3575
3576	static inline bool ext4_is_quota_journalled(struct super_block *sb)
3577	{
3578	struct ext4_sb_info *sbi = EXT4_SB(sb);
3579
3580	return (ext4_has_feature_quota(sb) ||
3581	sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]);
3582	}
3583	int ext4_enable_quotas(struct super_block *sb);
3584	#endif
3585
3586	/*
3587	* Block validity checking
3588	*/
3589	#define ext4_check_indirect_blockref(inode, bh) \
3590	ext4_check_blockref(__func__, __LINE__, inode, \
3591	(__le32 *)(bh)->b_data, \
3592	EXT4_ADDR_PER_BLOCK((inode)->i_sb))
3593
3594	#define ext4_ind_check_inode(inode) \
3595	ext4_check_blockref(__func__, __LINE__, inode, \
3596	EXT4_I(inode)->i_data, \
3597	EXT4_NDIR_BLOCKS)
3598
3599	/*
3600	* Inodes and files operations
3601	*/
3602
3603	/* dir.c */
3604	extern const struct file_operations ext4_dir_operations;
3605
3606	/* file.c */
3607	extern const struct inode_operations ext4_file_inode_operations;
3608	extern const struct file_operations ext4_file_operations;
3609	extern loff_t ext4_llseek(struct file *file, loff_t offset, int origin);
3610
3611	/* inline.c */
3612	extern int ext4_get_max_inline_size(struct inode *inode);
3613	extern int ext4_find_inline_data_nolock(struct inode *inode);
3614	extern int ext4_destroy_inline_data(handle_t *handle, struct inode *inode);
3615
3616	int ext4_readpage_inline(struct inode *inode, struct folio *folio);
3617	extern int ext4_try_to_write_inline_data(struct address_space *mapping,
3618	struct inode *inode,
3619	loff_t pos, unsigned len,
3620	struct folio **foliop);
3621	int ext4_write_inline_data_end(struct inode *inode, loff_t pos, unsigned len,
3622	unsigned copied, struct folio *folio);
3623	extern int ext4_generic_write_inline_data(struct address_space *mapping,
3624	struct inode *inode,
3625	loff_t pos, unsigned len,
3626	struct folio **foliop,
3627	void **fsdata, bool da);
3628	extern int ext4_try_add_inline_entry(handle_t *handle,
3629	struct ext4_filename *fname,
3630	struct inode *dir, struct inode *inode);
3631	extern int ext4_try_create_inline_dir(handle_t *handle,
3632	struct inode *parent,
3633	struct inode *inode);
3634	extern int ext4_read_inline_dir(struct file *filp,
3635	struct dir_context *ctx,
3636	int *has_inline_data);
3637	extern int ext4_inlinedir_to_tree(struct file *dir_file,
3638	struct inode *dir, ext4_lblk_t block,
3639	struct dx_hash_info *hinfo,
3640	__u32 start_hash, __u32 start_minor_hash,
3641	int *has_inline_data);
3642	extern struct buffer_head *ext4_find_inline_entry(struct inode *dir,
3643	struct ext4_filename *fname,
3644	struct ext4_dir_entry_2 **res_dir,
3645	int *has_inline_data);
3646	extern int ext4_delete_inline_entry(handle_t *handle,
3647	struct inode *dir,
3648	struct ext4_dir_entry_2 *de_del,
3649	struct buffer_head *bh,
3650	int *has_inline_data);
3651	extern bool empty_inline_dir(struct inode *dir, int *has_inline_data);
3652	extern struct buffer_head *ext4_get_first_inline_block(struct inode *inode,
3653	struct ext4_dir_entry_2 **parent_de,
3654	int *retval);
3655	extern void *ext4_read_inline_link(struct inode *inode);
3656
3657	struct iomap;
3658	extern int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap);
3659
3660	extern int ext4_inline_data_truncate(struct inode *inode, int *has_inline);
3661
3662	extern int ext4_convert_inline_data(struct inode *inode);
3663
3664	static inline int ext4_has_inline_data(struct inode *inode)
3665	{
3666	return ext4_test_inode_flag(inode, bit: EXT4_INODE_INLINE_DATA) &&
3667	EXT4_I(inode)->i_inline_off;
3668	}
3669
3670	/* namei.c */
3671	extern const struct inode_operations ext4_dir_inode_operations;
3672	extern const struct inode_operations ext4_special_inode_operations;
3673	extern struct dentry *ext4_get_parent(struct dentry *child);
3674	extern struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode,
3675	struct ext4_dir_entry_2 *de,
3676	int blocksize, int csum_size,
3677	unsigned int parent_ino, int dotdot_real_len);
3678	extern void ext4_initialize_dirent_tail(struct buffer_head *bh,
3679	unsigned int blocksize);
3680	extern int ext4_handle_dirty_dirblock(handle_t *handle, struct inode *inode,
3681	struct buffer_head *bh);
3682	extern int __ext4_unlink(struct inode *dir, const struct qstr *d_name,
3683	struct inode *inode, struct dentry *dentry);
3684	extern int __ext4_link(struct inode *dir, struct inode *inode,
3685	struct dentry *dentry);
3686
3687	#define S_SHIFT 12
3688	static const unsigned char ext4_type_by_mode[(S_IFMT >> S_SHIFT) + 1] = {
3689	[S_IFREG >> S_SHIFT] = EXT4_FT_REG_FILE,
3690	[S_IFDIR >> S_SHIFT] = EXT4_FT_DIR,
3691	[S_IFCHR >> S_SHIFT] = EXT4_FT_CHRDEV,
3692	[S_IFBLK >> S_SHIFT] = EXT4_FT_BLKDEV,
3693	[S_IFIFO >> S_SHIFT] = EXT4_FT_FIFO,
3694	[S_IFSOCK >> S_SHIFT] = EXT4_FT_SOCK,
3695	[S_IFLNK >> S_SHIFT] = EXT4_FT_SYMLINK,
3696	};
3697
3698	static inline void ext4_set_de_type(struct super_block *sb,
3699	struct ext4_dir_entry_2 *de,
3700	umode_t mode) {
3701	if (ext4_has_feature_filetype(sb))
3702	de->file_type = ext4_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
3703	}
3704
3705	/* readpages.c */
3706	extern int ext4_mpage_readpages(struct inode *inode,
3707	struct readahead_control *rac, struct folio *folio);
3708	extern int __init ext4_init_post_read_processing(void);
3709	extern void ext4_exit_post_read_processing(void);
3710
3711	/* symlink.c */
3712	extern const struct inode_operations ext4_encrypted_symlink_inode_operations;
3713	extern const struct inode_operations ext4_symlink_inode_operations;
3714	extern const struct inode_operations ext4_fast_symlink_inode_operations;
3715
3716	/* sysfs.c */
3717	extern void ext4_notify_error_sysfs(struct ext4_sb_info *sbi);
3718	extern int ext4_register_sysfs(struct super_block *sb);
3719	extern void ext4_unregister_sysfs(struct super_block *sb);
3720	extern int __init ext4_init_sysfs(void);
3721	extern void ext4_exit_sysfs(void);
3722
3723	/* block_validity */
3724	extern void ext4_release_system_zone(struct super_block *sb);
3725	extern int ext4_setup_system_zone(struct super_block *sb);
3726	extern int __init ext4_init_system_zone(void);
3727	extern void ext4_exit_system_zone(void);
3728	extern int ext4_inode_block_valid(struct inode *inode,
3729	ext4_fsblk_t start_blk,
3730	unsigned int count);
3731	extern int ext4_check_blockref(const char *, unsigned int,
3732	struct inode *, __le32 *, unsigned int);
3733	extern int ext4_sb_block_valid(struct super_block *sb, struct inode *inode,
3734	ext4_fsblk_t start_blk, unsigned int count);
3735
3736
3737	/* extents.c */
3738	struct ext4_ext_path;
3739	struct ext4_extent;
3740
3741	/*
3742	* Maximum number of logical blocks in a file; ext4_extent's ee_block is
3743	* __le32.
3744	*/
3745	#define EXT_MAX_BLOCKS 0xffffffff
3746
3747	extern void ext4_ext_tree_init(handle_t *handle, struct inode *inode);
3748	extern int ext4_ext_index_trans_blocks(struct inode *inode, int extents);
3749	extern int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
3750	struct ext4_map_blocks *map, int flags);
3751	extern int ext4_ext_truncate(handle_t *, struct inode *);
3752	extern int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
3753	ext4_lblk_t end);
3754	extern void ext4_ext_init(struct super_block *);
3755	extern void ext4_ext_release(struct super_block *);
3756	extern long ext4_fallocate(struct file *file, int mode, loff_t offset,
3757	loff_t len);
3758	extern int ext4_convert_unwritten_extents(handle_t *handle, struct inode *inode,
3759	loff_t offset, ssize_t len);
3760	extern int ext4_convert_unwritten_extents_atomic(handle_t *handle,
3761	struct inode *inode, loff_t offset, ssize_t len);
3762	extern int ext4_convert_unwritten_io_end_vec(handle_t *handle,
3763	ext4_io_end_t *io_end);
3764	extern int ext4_map_blocks(handle_t *handle, struct inode *inode,
3765	struct ext4_map_blocks *map, int flags);
3766	extern int ext4_ext_calc_credits_for_single_extent(struct inode *inode,
3767	int num,
3768	struct ext4_ext_path *path);
3769	extern struct ext4_ext_path *ext4_ext_insert_extent(
3770	handle_t *handle, struct inode *inode,
3771	struct ext4_ext_path *path,
3772	struct ext4_extent *newext, int gb_flags);
3773	extern struct ext4_ext_path *ext4_find_extent(struct inode *, ext4_lblk_t,
3774	struct ext4_ext_path *,
3775	int flags);
3776	extern void ext4_free_ext_path(struct ext4_ext_path *);
3777	extern int ext4_ext_check_inode(struct inode *inode);
3778	extern ext4_lblk_t ext4_ext_next_allocated_block(struct ext4_ext_path *path);
3779	extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3780	__u64 start, __u64 len);
3781	extern int ext4_get_es_cache(struct inode *inode,
3782	struct fiemap_extent_info *fieinfo,
3783	__u64 start, __u64 len);
3784	extern int ext4_ext_precache(struct inode *inode);
3785	extern int ext4_swap_extents(handle_t *handle, struct inode *inode1,
3786	struct inode *inode2, ext4_lblk_t lblk1,
3787	ext4_lblk_t lblk2, ext4_lblk_t count,
3788	int mark_unwritten,int *err);
3789	extern int ext4_clu_mapped(struct inode *inode, ext4_lblk_t lclu);
3790	extern int ext4_datasem_ensure_credits(handle_t *handle, struct inode *inode,
3791	int check_cred, int restart_cred,
3792	int revoke_cred);
3793	extern void ext4_ext_replay_shrink_inode(struct inode *inode, ext4_lblk_t end);
3794	extern int ext4_ext_replay_set_iblocks(struct inode *inode);
3795	extern int ext4_ext_replay_update_ex(struct inode *inode, ext4_lblk_t start,
3796	int len, int unwritten, ext4_fsblk_t pblk);
3797	extern int ext4_ext_clear_bb(struct inode *inode);
3798
3799
3800	/* move_extent.c */
3801	extern void ext4_double_down_write_data_sem(struct inode *first,
3802	struct inode *second);
3803	extern void ext4_double_up_write_data_sem(struct inode *orig_inode,
3804	struct inode *donor_inode);
3805	extern int ext4_move_extents(struct file *o_filp, struct file *d_filp,
3806	__u64 start_orig, __u64 start_donor,
3807	__u64 len, __u64 *moved_len);
3808
3809	/* page-io.c */
3810	extern int __init ext4_init_pageio(void);
3811	extern void ext4_exit_pageio(void);
3812	extern ext4_io_end_t *ext4_init_io_end(struct inode *inode, gfp_t flags);
3813	extern ext4_io_end_t *ext4_get_io_end(ext4_io_end_t *io_end);
3814	extern int ext4_put_io_end(ext4_io_end_t *io_end);
3815	extern void ext4_put_io_end_defer(ext4_io_end_t *io_end);
3816	extern void ext4_io_submit_init(struct ext4_io_submit *io,
3817	struct writeback_control *wbc);
3818	extern void ext4_end_io_rsv_work(struct work_struct *work);
3819	extern void ext4_io_submit(struct ext4_io_submit *io);
3820	int ext4_bio_write_folio(struct ext4_io_submit *io, struct folio *page,
3821	size_t len);
3822	extern struct ext4_io_end_vec *ext4_alloc_io_end_vec(ext4_io_end_t *io_end);
3823	extern struct ext4_io_end_vec *ext4_last_io_end_vec(ext4_io_end_t *io_end);
3824
3825	/* mmp.c */
3826	extern int ext4_multi_mount_protect(struct super_block *, ext4_fsblk_t);
3827
3828	/* mmp.c */
3829	extern void ext4_stop_mmpd(struct ext4_sb_info *sbi);
3830
3831	/* verity.c */
3832	extern const struct fsverity_operations ext4_verityops;
3833
3834	/* orphan.c */
3835	extern int ext4_orphan_add(handle_t *, struct inode *);
3836	extern int ext4_orphan_del(handle_t *, struct inode *);
3837	extern void ext4_orphan_cleanup(struct super_block *sb,
3838	struct ext4_super_block *es);
3839	extern void ext4_release_orphan_info(struct super_block *sb);
3840	extern int ext4_init_orphan_info(struct super_block *sb);
3841	extern int ext4_orphan_file_empty(struct super_block *sb);
3842	extern void ext4_orphan_file_block_trigger(
3843	struct jbd2_buffer_trigger_type *triggers,
3844	struct buffer_head *bh,
3845	void *data, size_t size);
3846
3847	/*
3848	* Add new method to test whether block and inode bitmaps are properly
3849	* initialized. With uninit_bg reading the block from disk is not enough
3850	* to mark the bitmap uptodate. We need to also zero-out the bitmap
3851	*/
3852	#define BH_BITMAP_UPTODATE BH_JBDPrivateStart
3853
3854	static inline int bitmap_uptodate(struct buffer_head *bh)
3855	{
3856	return (buffer_uptodate(bh) &&
3857	test_bit(BH_BITMAP_UPTODATE, &(bh)->b_state));
3858	}
3859	static inline void set_bitmap_uptodate(struct buffer_head *bh)
3860	{
3861	set_bit(BH_BITMAP_UPTODATE, addr: &(bh)->b_state);
3862	}
3863
3864	extern int ext4_resize_begin(struct super_block *sb);
3865	extern int ext4_resize_end(struct super_block *sb, bool update_backups);
3866
3867	static inline void ext4_set_io_unwritten_flag(struct ext4_io_end *io_end)
3868	{
3869	if (!(io_end->flag & EXT4_IO_END_UNWRITTEN))
3870	io_end->flag |= EXT4_IO_END_UNWRITTEN;
3871	}
3872
3873	static inline void ext4_clear_io_unwritten_flag(ext4_io_end_t *io_end)
3874	{
3875	if (io_end->flag & EXT4_IO_END_UNWRITTEN)
3876	io_end->flag &= ~EXT4_IO_END_UNWRITTEN;
3877	}
3878
3879	extern const struct iomap_ops ext4_iomap_ops;
3880	extern const struct iomap_ops ext4_iomap_overwrite_ops;
3881	extern const struct iomap_ops ext4_iomap_report_ops;
3882
3883	static inline int ext4_buffer_uptodate(struct buffer_head *bh)
3884	{
3885	/*
3886	* If the buffer has the write error flag, we have failed
3887	* to write out data in the block. In this case, we don't
3888	* have to read the block because we may read the old data
3889	* successfully.
3890	*/
3891	if (buffer_write_io_error(bh))
3892	set_buffer_uptodate(bh);
3893	return buffer_uptodate(bh);
3894	}
3895
3896	static inline bool ext4_inode_can_atomic_write(struct inode *inode)
3897	{
3898
3899	return S_ISREG(inode->i_mode) &&
3900	ext4_test_inode_flag(inode, bit: EXT4_INODE_EXTENTS) &&
3901	EXT4_SB(sb: inode->i_sb)->s_awu_min > 0;
3902	}
3903
3904	extern int ext4_block_write_begin(handle_t *handle, struct folio *folio,
3905	loff_t pos, unsigned len,
3906	get_block_t *get_block);
3907	#endif /* __KERNEL__ */
3908
3909	#define EFSBADCRC EBADMSG /* Bad CRC detected */
3910	#define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */
3911
3912	#endif /* _EXT4_H */
3913