1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* linux/fs/ext4/super.c
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/fs/minix/inode.c
13	*
14	* Copyright (C) 1991, 1992 Linus Torvalds
15	*
16	* Big-endian to little-endian byte-swapping/bitmaps by
17	* David S. Miller (davem@caip.rutgers.edu), 1995
18	*/
19
20	#include <linux/module.h>
21	#include <linux/string.h>
22	#include <linux/fs.h>
23	#include <linux/time.h>
24	#include <linux/vmalloc.h>
25	#include <linux/slab.h>
26	#include <linux/init.h>
27	#include <linux/blkdev.h>
28	#include <linux/backing-dev.h>
29	#include <linux/parser.h>
30	#include <linux/buffer_head.h>
31	#include <linux/exportfs.h>
32	#include <linux/vfs.h>
33	#include <linux/random.h>
34	#include <linux/mount.h>
35	#include <linux/namei.h>
36	#include <linux/quotaops.h>
37	#include <linux/seq_file.h>
38	#include <linux/ctype.h>
39	#include <linux/log2.h>
40	#include <linux/crc16.h>
41	#include <linux/dax.h>
42	#include <linux/uaccess.h>
43	#include <linux/iversion.h>
44	#include <linux/unicode.h>
45	#include <linux/part_stat.h>
46	#include <linux/kthread.h>
47	#include <linux/freezer.h>
48	#include <linux/fsnotify.h>
49	#include <linux/fs_context.h>
50	#include <linux/fs_parser.h>
51
52	#include "ext4.h"
53	#include "ext4_extents.h" /* Needed for trace points definition */
54	#include "ext4_jbd2.h"
55	#include "xattr.h"
56	#include "acl.h"
57	#include "mballoc.h"
58	#include "fsmap.h"
59
60	#define CREATE_TRACE_POINTS
61	#include <trace/events/ext4.h>
62
63	static struct ext4_lazy_init *ext4_li_info;
64	static DEFINE_MUTEX(ext4_li_mtx);
65	static struct ratelimit_state ext4_mount_msg_ratelimit;
66
67	static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
68	unsigned long journal_devnum);
69	static int ext4_show_options(struct seq_file *seq, struct dentry *root);
70	static void ext4_update_super(struct super_block *sb);
71	static int ext4_commit_super(struct super_block *sb);
72	static int ext4_mark_recovery_complete(struct super_block *sb,
73	struct ext4_super_block *es);
74	static int ext4_clear_journal_err(struct super_block *sb,
75	struct ext4_super_block *es);
76	static int ext4_sync_fs(struct super_block *sb, int wait);
77	static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
78	static int ext4_unfreeze(struct super_block *sb);
79	static int ext4_freeze(struct super_block *sb);
80	static inline int ext2_feature_set_ok(struct super_block *sb);
81	static inline int ext3_feature_set_ok(struct super_block *sb);
82	static void ext4_destroy_lazyinit_thread(void);
83	static void ext4_unregister_li_request(struct super_block *sb);
84	static void ext4_clear_request_list(void);
85	static struct inode *ext4_get_journal_inode(struct super_block *sb,
86	unsigned int journal_inum);
87	static int ext4_validate_options(struct fs_context *fc);
88	static int ext4_check_opt_consistency(struct fs_context *fc,
89	struct super_block *sb);
90	static void ext4_apply_options(struct fs_context *fc, struct super_block *sb);
91	static int ext4_parse_param(struct fs_context *fc, struct fs_parameter *param);
92	static int ext4_get_tree(struct fs_context *fc);
93	static int ext4_reconfigure(struct fs_context *fc);
94	static void ext4_fc_free(struct fs_context *fc);
95	static int ext4_init_fs_context(struct fs_context *fc);
96	static void ext4_kill_sb(struct super_block *sb);
97	static const struct fs_parameter_spec ext4_param_specs[];
98
99	/*
100	* Lock ordering
101	*
102	* page fault path:
103	* mmap_lock -> sb_start_pagefault -> invalidate_lock (r) -> transaction start
104	* -> page lock -> i_data_sem (rw)
105	*
106	* buffered write path:
107	* sb_start_write -> i_mutex -> mmap_lock
108	* sb_start_write -> i_mutex -> transaction start -> page lock ->
109	* i_data_sem (rw)
110	*
111	* truncate:
112	* sb_start_write -> i_mutex -> invalidate_lock (w) -> i_mmap_rwsem (w) ->
113	* page lock
114	* sb_start_write -> i_mutex -> invalidate_lock (w) -> transaction start ->
115	* i_data_sem (rw)
116	*
117	* direct IO:
118	* sb_start_write -> i_mutex -> mmap_lock
119	* sb_start_write -> i_mutex -> transaction start -> i_data_sem (rw)
120	*
121	* writepages:
122	* transaction start -> page lock(s) -> i_data_sem (rw)
123	*/
124
125	static const struct fs_context_operations ext4_context_ops = {
126	.parse_param = ext4_parse_param,
127	.get_tree = ext4_get_tree,
128	.reconfigure = ext4_reconfigure,
129	.free = ext4_fc_free,
130	};
131
132
133	#if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
134	static struct file_system_type ext2_fs_type = {
135	.owner = THIS_MODULE,
136	.name = "ext2",
137	.init_fs_context = ext4_init_fs_context,
138	.parameters = ext4_param_specs,
139	.kill_sb = ext4_kill_sb,
140	.fs_flags = FS_REQUIRES_DEV,
141	};
142	MODULE_ALIAS_FS("ext2");
143	MODULE_ALIAS("ext2");
144	#define IS_EXT2_SB(sb) ((sb)->s_type == &ext2_fs_type)
145	#else
146	#define IS_EXT2_SB(sb) (0)
147	#endif
148
149
150	static struct file_system_type ext3_fs_type = {
151	.owner = THIS_MODULE,
152	.name = "ext3",
153	.init_fs_context = ext4_init_fs_context,
154	.parameters = ext4_param_specs,
155	.kill_sb = ext4_kill_sb,
156	.fs_flags = FS_REQUIRES_DEV,
157	};
158	MODULE_ALIAS_FS("ext3");
159	MODULE_ALIAS("ext3");
160	#define IS_EXT3_SB(sb) ((sb)->s_type == &ext3_fs_type)
161
162
163	static inline void __ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags,
164	bh_end_io_t *end_io)
165	{
166	/*
167	* buffer's verified bit is no longer valid after reading from
168	* disk again due to write out error, clear it to make sure we
169	* recheck the buffer contents.
170	*/
171	clear_buffer_verified(bh);
172
173	bh->b_end_io = end_io ? end_io : end_buffer_read_sync;
174	get_bh(bh);
175	submit_bh(REQ_OP_READ | op_flags, bh);
176	}
177
178	void ext4_read_bh_nowait(struct buffer_head *bh, blk_opf_t op_flags,
179	bh_end_io_t *end_io)
180	{
181	BUG_ON(!buffer_locked(bh));
182
183	if (ext4_buffer_uptodate(bh)) {
184	unlock_buffer(bh);
185	return;
186	}
187	__ext4_read_bh(bh, op_flags, end_io);
188	}
189
190	int ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags, bh_end_io_t *end_io)
191	{
192	BUG_ON(!buffer_locked(bh));
193
194	if (ext4_buffer_uptodate(bh)) {
195	unlock_buffer(bh);
196	return 0;
197	}
198
199	__ext4_read_bh(bh, op_flags, end_io);
200
201	wait_on_buffer(bh);
202	if (buffer_uptodate(bh))
203	return 0;
204	return -EIO;
205	}
206
207	int ext4_read_bh_lock(struct buffer_head *bh, blk_opf_t op_flags, bool wait)
208	{
209	lock_buffer(bh);
210	if (!wait) {
211	ext4_read_bh_nowait(bh, op_flags, NULL);
212	return 0;
213	}
214	return ext4_read_bh(bh, op_flags, NULL);
215	}
216
217	/*
218	* This works like __bread_gfp() except it uses ERR_PTR for error
219	* returns. Currently with sb_bread it's impossible to distinguish
220	* between ENOMEM and EIO situations (since both result in a NULL
221	* return.
222	*/
223	static struct buffer_head *__ext4_sb_bread_gfp(struct super_block *sb,
224	sector_t block,
225	blk_opf_t op_flags, gfp_t gfp)
226	{
227	struct buffer_head *bh;
228	int ret;
229
230	bh = sb_getblk_gfp(sb, block, gfp);
231	if (bh == NULL)
232	return ERR_PTR(error: -ENOMEM);
233	if (ext4_buffer_uptodate(bh))
234	return bh;
235
236	ret = ext4_read_bh_lock(bh, REQ_META | op_flags, wait: true);
237	if (ret) {
238	put_bh(bh);
239	return ERR_PTR(error: ret);
240	}
241	return bh;
242	}
243
244	struct buffer_head *ext4_sb_bread(struct super_block *sb, sector_t block,
245	blk_opf_t op_flags)
246	{
247	gfp_t gfp = mapping_gfp_constraint(mapping: sb->s_bdev->bd_inode->i_mapping,
248	gfp_mask: ~__GFP_FS) | __GFP_MOVABLE;
249
250	return __ext4_sb_bread_gfp(sb, block, op_flags, gfp);
251	}
252
253	struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,
254	sector_t block)
255	{
256	gfp_t gfp = mapping_gfp_constraint(mapping: sb->s_bdev->bd_inode->i_mapping,
257	gfp_mask: ~__GFP_FS);
258
259	return __ext4_sb_bread_gfp(sb, block, op_flags: 0, gfp);
260	}
261
262	void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block)
263	{
264	struct buffer_head *bh = bdev_getblk(bdev: sb->s_bdev, block,
265	size: sb->s_blocksize, GFP_NOWAIT | __GFP_NOWARN);
266
267	if (likely(bh)) {
268	if (trylock_buffer(bh))
269	ext4_read_bh_nowait(bh, REQ_RAHEAD, NULL);
270	brelse(bh);
271	}
272	}
273
274	static int ext4_verify_csum_type(struct super_block *sb,
275	struct ext4_super_block *es)
276	{
277	if (!ext4_has_feature_metadata_csum(sb))
278	return 1;
279
280	return es->s_checksum_type == EXT4_CRC32C_CHKSUM;
281	}
282
283	__le32 ext4_superblock_csum(struct super_block *sb,
284	struct ext4_super_block *es)
285	{
286	struct ext4_sb_info *sbi = EXT4_SB(sb);
287	int offset = offsetof(struct ext4_super_block, s_checksum);
288	__u32 csum;
289
290	csum = ext4_chksum(sbi, crc: ~0, address: (char *)es, length: offset);
291
292	return cpu_to_le32(csum);
293	}
294
295	static int ext4_superblock_csum_verify(struct super_block *sb,
296	struct ext4_super_block *es)
297	{
298	if (!ext4_has_metadata_csum(sb))
299	return 1;
300
301	return es->s_checksum == ext4_superblock_csum(sb, es);
302	}
303
304	void ext4_superblock_csum_set(struct super_block *sb)
305	{
306	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
307
308	if (!ext4_has_metadata_csum(sb))
309	return;
310
311	es->s_checksum = ext4_superblock_csum(sb, es);
312	}
313
314	ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
315	struct ext4_group_desc *bg)
316	{
317	return le32_to_cpu(bg->bg_block_bitmap_lo) |
318	(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
319	(ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
320	}
321
322	ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
323	struct ext4_group_desc *bg)
324	{
325	return le32_to_cpu(bg->bg_inode_bitmap_lo) |
326	(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
327	(ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
328	}
329
330	ext4_fsblk_t ext4_inode_table(struct super_block *sb,
331	struct ext4_group_desc *bg)
332	{
333	return le32_to_cpu(bg->bg_inode_table_lo) |
334	(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
335	(ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
336	}
337
338	__u32 ext4_free_group_clusters(struct super_block *sb,
339	struct ext4_group_desc *bg)
340	{
341	return le16_to_cpu(bg->bg_free_blocks_count_lo) |
342	(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
343	(__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
344	}
345
346	__u32 ext4_free_inodes_count(struct super_block *sb,
347	struct ext4_group_desc *bg)
348	{
349	return le16_to_cpu(bg->bg_free_inodes_count_lo) |
350	(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
351	(__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
352	}
353
354	__u32 ext4_used_dirs_count(struct super_block *sb,
355	struct ext4_group_desc *bg)
356	{
357	return le16_to_cpu(bg->bg_used_dirs_count_lo) |
358	(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
359	(__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
360	}
361
362	__u32 ext4_itable_unused_count(struct super_block *sb,
363	struct ext4_group_desc *bg)
364	{
365	return le16_to_cpu(bg->bg_itable_unused_lo) |
366	(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
367	(__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
368	}
369
370	void ext4_block_bitmap_set(struct super_block *sb,
371	struct ext4_group_desc *bg, ext4_fsblk_t blk)
372	{
373	bg->bg_block_bitmap_lo = cpu_to_le32((u32)blk);
374	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
375	bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
376	}
377
378	void ext4_inode_bitmap_set(struct super_block *sb,
379	struct ext4_group_desc *bg, ext4_fsblk_t blk)
380	{
381	bg->bg_inode_bitmap_lo = cpu_to_le32((u32)blk);
382	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
383	bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
384	}
385
386	void ext4_inode_table_set(struct super_block *sb,
387	struct ext4_group_desc *bg, ext4_fsblk_t blk)
388	{
389	bg->bg_inode_table_lo = cpu_to_le32((u32)blk);
390	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
391	bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
392	}
393
394	void ext4_free_group_clusters_set(struct super_block *sb,
395	struct ext4_group_desc *bg, __u32 count)
396	{
397	bg->bg_free_blocks_count_lo = cpu_to_le16((__u16)count);
398	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
399	bg->bg_free_blocks_count_hi = cpu_to_le16(count >> 16);
400	}
401
402	void ext4_free_inodes_set(struct super_block *sb,
403	struct ext4_group_desc *bg, __u32 count)
404	{
405	bg->bg_free_inodes_count_lo = cpu_to_le16((__u16)count);
406	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
407	bg->bg_free_inodes_count_hi = cpu_to_le16(count >> 16);
408	}
409
410	void ext4_used_dirs_set(struct super_block *sb,
411	struct ext4_group_desc *bg, __u32 count)
412	{
413	bg->bg_used_dirs_count_lo = cpu_to_le16((__u16)count);
414	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
415	bg->bg_used_dirs_count_hi = cpu_to_le16(count >> 16);
416	}
417
418	void ext4_itable_unused_set(struct super_block *sb,
419	struct ext4_group_desc *bg, __u32 count)
420	{
421	bg->bg_itable_unused_lo = cpu_to_le16((__u16)count);
422	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
423	bg->bg_itable_unused_hi = cpu_to_le16(count >> 16);
424	}
425
426	static void __ext4_update_tstamp(__le32 *lo, __u8 *hi, time64_t now)
427	{
428	now = clamp_val(now, 0, (1ull << 40) - 1);
429
430	*lo = cpu_to_le32(lower_32_bits(now));
431	*hi = upper_32_bits(now);
432	}
433
434	static time64_t __ext4_get_tstamp(__le32 *lo, __u8 *hi)
435	{
436	return ((time64_t)(*hi) << 32) + le32_to_cpu(*lo);
437	}
438	#define ext4_update_tstamp(es, tstamp) \
439	__ext4_update_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi, \
440	ktime_get_real_seconds())
441	#define ext4_get_tstamp(es, tstamp) \
442	__ext4_get_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi)
443
444	#define EXT4_SB_REFRESH_INTERVAL_SEC (3600) /* seconds (1 hour) */
445	#define EXT4_SB_REFRESH_INTERVAL_KB (16384) /* kilobytes (16MB) */
446
447	/*
448	* The ext4_maybe_update_superblock() function checks and updates the
449	* superblock if needed.
450	*
451	* This function is designed to update the on-disk superblock only under
452	* certain conditions to prevent excessive disk writes and unnecessary
453	* waking of the disk from sleep. The superblock will be updated if:
454	* 1. More than an hour has passed since the last superblock update, and
455	* 2. More than 16MB have been written since the last superblock update.
456	*
457	* @sb: The superblock
458	*/
459	static void ext4_maybe_update_superblock(struct super_block *sb)
460	{
461	struct ext4_sb_info *sbi = EXT4_SB(sb);
462	struct ext4_super_block *es = sbi->s_es;
463	journal_t *journal = sbi->s_journal;
464	time64_t now;
465	__u64 last_update;
466	__u64 lifetime_write_kbytes;
467	__u64 diff_size;
468
469	if (sb_rdonly(sb) || !(sb->s_flags & SB_ACTIVE) ||
470	!journal || (journal->j_flags & JBD2_UNMOUNT))
471	return;
472
473	now = ktime_get_real_seconds();
474	last_update = ext4_get_tstamp(es, s_wtime);
475
476	if (likely(now - last_update < EXT4_SB_REFRESH_INTERVAL_SEC))
477	return;
478
479	lifetime_write_kbytes = sbi->s_kbytes_written +
480	((part_stat_read(sb->s_bdev, sectors[STAT_WRITE]) -
481	sbi->s_sectors_written_start) >> 1);
482
483	/* Get the number of kilobytes not written to disk to account
484	* for statistics and compare with a multiple of 16 MB. This
485	* is used to determine when the next superblock commit should
486	* occur (i.e. not more often than once per 16MB if there was
487	* less written in an hour).
488	*/
489	diff_size = lifetime_write_kbytes - le64_to_cpu(es->s_kbytes_written);
490
491	if (diff_size > EXT4_SB_REFRESH_INTERVAL_KB)
492	schedule_work(work: &EXT4_SB(sb)->s_sb_upd_work);
493	}
494
495	/*
496	* The del_gendisk() function uninitializes the disk-specific data
497	* structures, including the bdi structure, without telling anyone
498	* else. Once this happens, any attempt to call mark_buffer_dirty()
499	* (for example, by ext4_commit_super), will cause a kernel OOPS.
500	* This is a kludge to prevent these oops until we can put in a proper
501	* hook in del_gendisk() to inform the VFS and file system layers.
502	*/
503	static int block_device_ejected(struct super_block *sb)
504	{
505	struct inode *bd_inode = sb->s_bdev->bd_inode;
506	struct backing_dev_info *bdi = inode_to_bdi(inode: bd_inode);
507
508	return bdi->dev == NULL;
509	}
510
511	static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn)
512	{
513	struct super_block *sb = journal->j_private;
514	struct ext4_sb_info *sbi = EXT4_SB(sb);
515	int error = is_journal_aborted(journal);
516	struct ext4_journal_cb_entry *jce;
517
518	BUG_ON(txn->t_state == T_FINISHED);
519
520	ext4_process_freed_data(sb, commit_tid: txn->t_tid);
521	ext4_maybe_update_superblock(sb);
522
523	spin_lock(lock: &sbi->s_md_lock);
524	while (!list_empty(head: &txn->t_private_list)) {
525	jce = list_entry(txn->t_private_list.next,
526	struct ext4_journal_cb_entry, jce_list);
527	list_del_init(entry: &jce->jce_list);
528	spin_unlock(lock: &sbi->s_md_lock);
529	jce->jce_func(sb, jce, error);
530	spin_lock(lock: &sbi->s_md_lock);
531	}
532	spin_unlock(lock: &sbi->s_md_lock);
533	}
534
535	/*
536	* This writepage callback for write_cache_pages()
537	* takes care of a few cases after page cleaning.
538	*
539	* write_cache_pages() already checks for dirty pages
540	* and calls clear_page_dirty_for_io(), which we want,
541	* to write protect the pages.
542	*
543	* However, we may have to redirty a page (see below.)
544	*/
545	static int ext4_journalled_writepage_callback(struct folio *folio,
546	struct writeback_control *wbc,
547	void *data)
548	{
549	transaction_t *transaction = (transaction_t *) data;
550	struct buffer_head *bh, *head;
551	struct journal_head *jh;
552
553	bh = head = folio_buffers(folio);
554	do {
555	/*
556	* We have to redirty a page in these cases:
557	* 1) If buffer is dirty, it means the page was dirty because it
558	* contains a buffer that needs checkpointing. So the dirty bit
559	* needs to be preserved so that checkpointing writes the buffer
560	* properly.
561	* 2) If buffer is not part of the committing transaction
562	* (we may have just accidentally come across this buffer because
563	* inode range tracking is not exact) or if the currently running
564	* transaction already contains this buffer as well, dirty bit
565	* needs to be preserved so that the buffer gets writeprotected
566	* properly on running transaction's commit.
567	*/
568	jh = bh2jh(bh);
569	if (buffer_dirty(bh) ||
570	(jh && (jh->b_transaction != transaction ||
571	jh->b_next_transaction))) {
572	folio_redirty_for_writepage(wbc, folio);
573	goto out;
574	}
575	} while ((bh = bh->b_this_page) != head);
576
577	out:
578	return AOP_WRITEPAGE_ACTIVATE;
579	}
580
581	static int ext4_journalled_submit_inode_data_buffers(struct jbd2_inode *jinode)
582	{
583	struct address_space *mapping = jinode->i_vfs_inode->i_mapping;
584	struct writeback_control wbc = {
585	.sync_mode = WB_SYNC_ALL,
586	.nr_to_write = LONG_MAX,
587	.range_start = jinode->i_dirty_start,
588	.range_end = jinode->i_dirty_end,
589	};
590
591	return write_cache_pages(mapping, wbc: &wbc,
592	writepage: ext4_journalled_writepage_callback,
593	data: jinode->i_transaction);
594	}
595
596	static int ext4_journal_submit_inode_data_buffers(struct jbd2_inode *jinode)
597	{
598	int ret;
599
600	if (ext4_should_journal_data(inode: jinode->i_vfs_inode))
601	ret = ext4_journalled_submit_inode_data_buffers(jinode);
602	else
603	ret = ext4_normal_submit_inode_data_buffers(jinode);
604	return ret;
605	}
606
607	static int ext4_journal_finish_inode_data_buffers(struct jbd2_inode *jinode)
608	{
609	int ret = 0;
610
611	if (!ext4_should_journal_data(inode: jinode->i_vfs_inode))
612	ret = jbd2_journal_finish_inode_data_buffers(jinode);
613
614	return ret;
615	}
616
617	static bool system_going_down(void)
618	{
619	return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF
620	|| system_state == SYSTEM_RESTART;
621	}
622
623	struct ext4_err_translation {
624	int code;
625	int errno;
626	};
627
628	#define EXT4_ERR_TRANSLATE(err) { .code = EXT4_ERR_##err, .errno = err }
629
630	static struct ext4_err_translation err_translation[] = {
631	EXT4_ERR_TRANSLATE(EIO),
632	EXT4_ERR_TRANSLATE(ENOMEM),
633	EXT4_ERR_TRANSLATE(EFSBADCRC),
634	EXT4_ERR_TRANSLATE(EFSCORRUPTED),
635	EXT4_ERR_TRANSLATE(ENOSPC),
636	EXT4_ERR_TRANSLATE(ENOKEY),
637	EXT4_ERR_TRANSLATE(EROFS),
638	EXT4_ERR_TRANSLATE(EFBIG),
639	EXT4_ERR_TRANSLATE(EEXIST),
640	EXT4_ERR_TRANSLATE(ERANGE),
641	EXT4_ERR_TRANSLATE(EOVERFLOW),
642	EXT4_ERR_TRANSLATE(EBUSY),
643	EXT4_ERR_TRANSLATE(ENOTDIR),
644	EXT4_ERR_TRANSLATE(ENOTEMPTY),
645	EXT4_ERR_TRANSLATE(ESHUTDOWN),
646	EXT4_ERR_TRANSLATE(EFAULT),
647	};
648
649	static int ext4_errno_to_code(int errno)
650	{
651	int i;
652
653	for (i = 0; i < ARRAY_SIZE(err_translation); i++)
654	if (err_translation[i].errno == errno)
655	return err_translation[i].code;
656	return EXT4_ERR_UNKNOWN;
657	}
658
659	static void save_error_info(struct super_block *sb, int error,
660	__u32 ino, __u64 block,
661	const char *func, unsigned int line)
662	{
663	struct ext4_sb_info *sbi = EXT4_SB(sb);
664
665	/* We default to EFSCORRUPTED error... */
666	if (error == 0)
667	error = EFSCORRUPTED;
668
669	spin_lock(lock: &sbi->s_error_lock);
670	sbi->s_add_error_count++;
671	sbi->s_last_error_code = error;
672	sbi->s_last_error_line = line;
673	sbi->s_last_error_ino = ino;
674	sbi->s_last_error_block = block;
675	sbi->s_last_error_func = func;
676	sbi->s_last_error_time = ktime_get_real_seconds();
677	if (!sbi->s_first_error_time) {
678	sbi->s_first_error_code = error;
679	sbi->s_first_error_line = line;
680	sbi->s_first_error_ino = ino;
681	sbi->s_first_error_block = block;
682	sbi->s_first_error_func = func;
683	sbi->s_first_error_time = sbi->s_last_error_time;
684	}
685	spin_unlock(lock: &sbi->s_error_lock);
686	}
687
688	/* Deal with the reporting of failure conditions on a filesystem such as
689	* inconsistencies detected or read IO failures.
690	*
691	* On ext2, we can store the error state of the filesystem in the
692	* superblock. That is not possible on ext4, because we may have other
693	* write ordering constraints on the superblock which prevent us from
694	* writing it out straight away; and given that the journal is about to
695	* be aborted, we can't rely on the current, or future, transactions to
696	* write out the superblock safely.
697	*
698	* We'll just use the jbd2_journal_abort() error code to record an error in
699	* the journal instead. On recovery, the journal will complain about
700	* that error until we've noted it down and cleared it.
701	*
702	* If force_ro is set, we unconditionally force the filesystem into an
703	* ABORT|READONLY state, unless the error response on the fs has been set to
704	* panic in which case we take the easy way out and panic immediately. This is
705	* used to deal with unrecoverable failures such as journal IO errors or ENOMEM
706	* at a critical moment in log management.
707	*/
708	static void ext4_handle_error(struct super_block *sb, bool force_ro, int error,
709	__u32 ino, __u64 block,
710	const char *func, unsigned int line)
711	{
712	journal_t *journal = EXT4_SB(sb)->s_journal;
713	bool continue_fs = !force_ro && test_opt(sb, ERRORS_CONT);
714
715	EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
716	if (test_opt(sb, WARN_ON_ERROR))
717	WARN_ON_ONCE(1);
718
719	if (!continue_fs && !sb_rdonly(sb)) {
720	set_bit(EXT4_FLAGS_SHUTDOWN, addr: &EXT4_SB(sb)->s_ext4_flags);
721	if (journal)
722	jbd2_journal_abort(journal, -EIO);
723	}
724
725	if (!bdev_read_only(bdev: sb->s_bdev)) {
726	save_error_info(sb, error, ino, block, func, line);
727	/*
728	* In case the fs should keep running, we need to writeout
729	* superblock through the journal. Due to lock ordering
730	* constraints, it may not be safe to do it right here so we
731	* defer superblock flushing to a workqueue.
732	*/
733	if (continue_fs && journal)
734	schedule_work(work: &EXT4_SB(sb)->s_sb_upd_work);
735	else
736	ext4_commit_super(sb);
737	}
738
739	/*
740	* We force ERRORS_RO behavior when system is rebooting. Otherwise we
741	* could panic during 'reboot -f' as the underlying device got already
742	* disabled.
743	*/
744	if (test_opt(sb, ERRORS_PANIC) && !system_going_down()) {
745	panic(fmt: "EXT4-fs (device %s): panic forced after error\n",
746	sb->s_id);
747	}
748
749	if (sb_rdonly(sb) || continue_fs)
750	return;
751
752	ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
753	/*
754	* Make sure updated value of ->s_mount_flags will be visible before
755	* ->s_flags update
756	*/
757	smp_wmb();
758	sb->s_flags |= SB_RDONLY;
759	}
760
761	static void update_super_work(struct work_struct *work)
762	{
763	struct ext4_sb_info *sbi = container_of(work, struct ext4_sb_info,
764	s_sb_upd_work);
765	journal_t *journal = sbi->s_journal;
766	handle_t *handle;
767
768	/*
769	* If the journal is still running, we have to write out superblock
770	* through the journal to avoid collisions of other journalled sb
771	* updates.
772	*
773	* We use directly jbd2 functions here to avoid recursing back into
774	* ext4 error handling code during handling of previous errors.
775	*/
776	if (!sb_rdonly(sb: sbi->s_sb) && journal) {
777	struct buffer_head *sbh = sbi->s_sbh;
778	bool call_notify_err = false;
779
780	handle = jbd2_journal_start(journal, nblocks: 1);
781	if (IS_ERR(ptr: handle))
782	goto write_directly;
783	if (jbd2_journal_get_write_access(handle, sbh)) {
784	jbd2_journal_stop(handle);
785	goto write_directly;
786	}
787
788	if (sbi->s_add_error_count > 0)
789	call_notify_err = true;
790
791	ext4_update_super(sb: sbi->s_sb);
792	if (buffer_write_io_error(bh: sbh) || !buffer_uptodate(bh: sbh)) {
793	ext4_msg(sbi->s_sb, KERN_ERR, "previous I/O error to "
794	"superblock detected");
795	clear_buffer_write_io_error(bh: sbh);
796	set_buffer_uptodate(sbh);
797	}
798
799	if (jbd2_journal_dirty_metadata(handle, sbh)) {
800	jbd2_journal_stop(handle);
801	goto write_directly;
802	}
803	jbd2_journal_stop(handle);
804
805	if (call_notify_err)
806	ext4_notify_error_sysfs(sbi);
807
808	return;
809	}
810	write_directly:
811	/*
812	* Write through journal failed. Write sb directly to get error info
813	* out and hope for the best.
814	*/
815	ext4_commit_super(sb: sbi->s_sb);
816	ext4_notify_error_sysfs(sbi);
817	}
818
819	#define ext4_error_ratelimit(sb) \
820	___ratelimit(&(EXT4_SB(sb)->s_err_ratelimit_state), \
821	"EXT4-fs error")
822
823	void __ext4_error(struct super_block *sb, const char *function,
824	unsigned int line, bool force_ro, int error, __u64 block,
825	const char *fmt, ...)
826	{
827	struct va_format vaf;
828	va_list args;
829
830	if (unlikely(ext4_forced_shutdown(sb)))
831	return;
832
833	trace_ext4_error(sb, function, line);
834	if (ext4_error_ratelimit(sb)) {
835	va_start(args, fmt);
836	vaf.fmt = fmt;
837	vaf.va = &args;
838	printk(KERN_CRIT
839	"EXT4-fs error (device %s): %s:%d: comm %s: %pV\n",
840	sb->s_id, function, line, current->comm, &vaf);
841	va_end(args);
842	}
843	fsnotify_sb_error(sb, NULL, error: error ? error : EFSCORRUPTED);
844
845	ext4_handle_error(sb, force_ro, error, ino: 0, block, func: function, line);
846	}
847
848	void __ext4_error_inode(struct inode *inode, const char *function,
849	unsigned int line, ext4_fsblk_t block, int error,
850	const char *fmt, ...)
851	{
852	va_list args;
853	struct va_format vaf;
854
855	if (unlikely(ext4_forced_shutdown(inode->i_sb)))
856	return;
857
858	trace_ext4_error(sb: inode->i_sb, function, line);
859	if (ext4_error_ratelimit(inode->i_sb)) {
860	va_start(args, fmt);
861	vaf.fmt = fmt;
862	vaf.va = &args;
863	if (block)
864	printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
865	"inode #%lu: block %llu: comm %s: %pV\n",
866	inode->i_sb->s_id, function, line, inode->i_ino,
867	block, current->comm, &vaf);
868	else
869	printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
870	"inode #%lu: comm %s: %pV\n",
871	inode->i_sb->s_id, function, line, inode->i_ino,
872	current->comm, &vaf);
873	va_end(args);
874	}
875	fsnotify_sb_error(sb: inode->i_sb, inode, error: error ? error : EFSCORRUPTED);
876
877	ext4_handle_error(sb: inode->i_sb, force_ro: false, error, ino: inode->i_ino, block,
878	func: function, line);
879	}
880
881	void __ext4_error_file(struct file *file, const char *function,
882	unsigned int line, ext4_fsblk_t block,
883	const char *fmt, ...)
884	{
885	va_list args;
886	struct va_format vaf;
887	struct inode *inode = file_inode(f: file);
888	char pathname[80], *path;
889
890	if (unlikely(ext4_forced_shutdown(inode->i_sb)))
891	return;
892
893	trace_ext4_error(sb: inode->i_sb, function, line);
894	if (ext4_error_ratelimit(inode->i_sb)) {
895	path = file_path(file, pathname, sizeof(pathname));
896	if (IS_ERR(ptr: path))
897	path = "(unknown)";
898	va_start(args, fmt);
899	vaf.fmt = fmt;
900	vaf.va = &args;
901	if (block)
902	printk(KERN_CRIT
903	"EXT4-fs error (device %s): %s:%d: inode #%lu: "
904	"block %llu: comm %s: path %s: %pV\n",
905	inode->i_sb->s_id, function, line, inode->i_ino,
906	block, current->comm, path, &vaf);
907	else
908	printk(KERN_CRIT
909	"EXT4-fs error (device %s): %s:%d: inode #%lu: "
910	"comm %s: path %s: %pV\n",
911	inode->i_sb->s_id, function, line, inode->i_ino,
912	current->comm, path, &vaf);
913	va_end(args);
914	}
915	fsnotify_sb_error(sb: inode->i_sb, inode, EFSCORRUPTED);
916
917	ext4_handle_error(sb: inode->i_sb, force_ro: false, EFSCORRUPTED, ino: inode->i_ino, block,
918	func: function, line);
919	}
920
921	const char *ext4_decode_error(struct super_block *sb, int errno,
922	char nbuf[16])
923	{
924	char *errstr = NULL;
925
926	switch (errno) {
927	case -EFSCORRUPTED:
928	errstr = "Corrupt filesystem";
929	break;
930	case -EFSBADCRC:
931	errstr = "Filesystem failed CRC";
932	break;
933	case -EIO:
934	errstr = "IO failure";
935	break;
936	case -ENOMEM:
937	errstr = "Out of memory";
938	break;
939	case -EROFS:
940	if (!sb || (EXT4_SB(sb)->s_journal &&
941	EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT))
942	errstr = "Journal has aborted";
943	else
944	errstr = "Readonly filesystem";
945	break;
946	default:
947	/* If the caller passed in an extra buffer for unknown
948	* errors, textualise them now. Else we just return
949	* NULL. */
950	if (nbuf) {
951	/* Check for truncated error codes... */
952	if (snprintf(buf: nbuf, size: 16, fmt: "error %d", -errno) >= 0)
953	errstr = nbuf;
954	}
955	break;
956	}
957
958	return errstr;
959	}
960
961	/* __ext4_std_error decodes expected errors from journaling functions
962	* automatically and invokes the appropriate error response. */
963
964	void __ext4_std_error(struct super_block *sb, const char *function,
965	unsigned int line, int errno)
966	{
967	char nbuf[16];
968	const char *errstr;
969
970	if (unlikely(ext4_forced_shutdown(sb)))
971	return;
972
973	/* Special case: if the error is EROFS, and we're not already
974	* inside a transaction, then there's really no point in logging
975	* an error. */
976	if (errno == -EROFS && journal_current_handle() == NULL && sb_rdonly(sb))
977	return;
978
979	if (ext4_error_ratelimit(sb)) {
980	errstr = ext4_decode_error(sb, errno, nbuf);
981	printk(KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n",
982	sb->s_id, function, line, errstr);
983	}
984	fsnotify_sb_error(sb, NULL, error: errno ? errno : EFSCORRUPTED);
985
986	ext4_handle_error(sb, force_ro: false, error: -errno, ino: 0, block: 0, func: function, line);
987	}
988
989	void __ext4_msg(struct super_block *sb,
990	const char *prefix, const char *fmt, ...)
991	{
992	struct va_format vaf;
993	va_list args;
994
995	if (sb) {
996	atomic_inc(v: &EXT4_SB(sb)->s_msg_count);
997	if (!___ratelimit(rs: &(EXT4_SB(sb)->s_msg_ratelimit_state),
998	func: "EXT4-fs"))
999	return;
1000	}
1001
1002	va_start(args, fmt);
1003	vaf.fmt = fmt;
1004	vaf.va = &args;
1005	if (sb)
1006	printk("%sEXT4-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
1007	else
1008	printk("%sEXT4-fs: %pV\n", prefix, &vaf);
1009	va_end(args);
1010	}
1011
1012	static int ext4_warning_ratelimit(struct super_block *sb)
1013	{
1014	atomic_inc(v: &EXT4_SB(sb)->s_warning_count);
1015	return ___ratelimit(rs: &(EXT4_SB(sb)->s_warning_ratelimit_state),
1016	func: "EXT4-fs warning");
1017	}
1018
1019	void __ext4_warning(struct super_block *sb, const char *function,
1020	unsigned int line, const char *fmt, ...)
1021	{
1022	struct va_format vaf;
1023	va_list args;
1024
1025	if (!ext4_warning_ratelimit(sb))
1026	return;
1027
1028	va_start(args, fmt);
1029	vaf.fmt = fmt;
1030	vaf.va = &args;
1031	printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: %pV\n",
1032	sb->s_id, function, line, &vaf);
1033	va_end(args);
1034	}
1035
1036	void __ext4_warning_inode(const struct inode *inode, const char *function,
1037	unsigned int line, const char *fmt, ...)
1038	{
1039	struct va_format vaf;
1040	va_list args;
1041
1042	if (!ext4_warning_ratelimit(sb: inode->i_sb))
1043	return;
1044
1045	va_start(args, fmt);
1046	vaf.fmt = fmt;
1047	vaf.va = &args;
1048	printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: "
1049	"inode #%lu: comm %s: %pV\n", inode->i_sb->s_id,
1050	function, line, inode->i_ino, current->comm, &vaf);
1051	va_end(args);
1052	}
1053
1054	void __ext4_grp_locked_error(const char *function, unsigned int line,
1055	struct super_block *sb, ext4_group_t grp,
1056	unsigned long ino, ext4_fsblk_t block,
1057	const char *fmt, ...)
1058	__releases(bitlock)
1059	__acquires(bitlock)
1060	{
1061	struct va_format vaf;
1062	va_list args;
1063
1064	if (unlikely(ext4_forced_shutdown(sb)))
1065	return;
1066
1067	trace_ext4_error(sb, function, line);
1068	if (ext4_error_ratelimit(sb)) {
1069	va_start(args, fmt);
1070	vaf.fmt = fmt;
1071	vaf.va = &args;
1072	printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u, ",
1073	sb->s_id, function, line, grp);
1074	if (ino)
1075	printk(KERN_CONT "inode %lu: ", ino);
1076	if (block)
1077	printk(KERN_CONT "block %llu:",
1078	(unsigned long long) block);
1079	printk(KERN_CONT "%pV\n", &vaf);
1080	va_end(args);
1081	}
1082
1083	if (test_opt(sb, ERRORS_CONT)) {
1084	if (test_opt(sb, WARN_ON_ERROR))
1085	WARN_ON_ONCE(1);
1086	EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
1087	if (!bdev_read_only(bdev: sb->s_bdev)) {
1088	save_error_info(sb, EFSCORRUPTED, ino, block, func: function,
1089	line);
1090	schedule_work(work: &EXT4_SB(sb)->s_sb_upd_work);
1091	}
1092	return;
1093	}
1094	ext4_unlock_group(sb, group: grp);
1095	ext4_handle_error(sb, force_ro: false, EFSCORRUPTED, ino, block, func: function, line);
1096	/*
1097	* We only get here in the ERRORS_RO case; relocking the group
1098	* may be dangerous, but nothing bad will happen since the
1099	* filesystem will have already been marked read/only and the
1100	* journal has been aborted. We return 1 as a hint to callers
1101	* who might what to use the return value from
1102	* ext4_grp_locked_error() to distinguish between the
1103	* ERRORS_CONT and ERRORS_RO case, and perhaps return more
1104	* aggressively from the ext4 function in question, with a
1105	* more appropriate error code.
1106	*/
1107	ext4_lock_group(sb, group: grp);
1108	return;
1109	}
1110
1111	void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
1112	ext4_group_t group,
1113	unsigned int flags)
1114	{
1115	struct ext4_sb_info *sbi = EXT4_SB(sb);
1116	struct ext4_group_info *grp = ext4_get_group_info(sb, group);
1117	struct ext4_group_desc *gdp = ext4_get_group_desc(sb, block_group: group, NULL);
1118	int ret;
1119
1120	if (!grp || !gdp)
1121	return;
1122	if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT) {
1123	ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
1124	addr: &grp->bb_state);
1125	if (!ret)
1126	percpu_counter_sub(fbc: &sbi->s_freeclusters_counter,
1127	amount: grp->bb_free);
1128	}
1129
1130	if (flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT) {
1131	ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT,
1132	addr: &grp->bb_state);
1133	if (!ret && gdp) {
1134	int count;
1135
1136	count = ext4_free_inodes_count(sb, bg: gdp);
1137	percpu_counter_sub(fbc: &sbi->s_freeinodes_counter,
1138	amount: count);
1139	}
1140	}
1141	}
1142
1143	void ext4_update_dynamic_rev(struct super_block *sb)
1144	{
1145	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
1146
1147	if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
1148	return;
1149
1150	ext4_warning(sb,
1151	"updating to rev %d because of new feature flag, "
1152	"running e2fsck is recommended",
1153	EXT4_DYNAMIC_REV);
1154
1155	es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
1156	es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
1157	es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
1158	/* leave es->s_feature_*compat flags alone */
1159	/* es->s_uuid will be set by e2fsck if empty */
1160
1161	/*
1162	* The rest of the superblock fields should be zero, and if not it
1163	* means they are likely already in use, so leave them alone. We
1164	* can leave it up to e2fsck to clean up any inconsistencies there.
1165	*/
1166	}
1167
1168	static inline struct inode *orphan_list_entry(struct list_head *l)
1169	{
1170	return &list_entry(l, struct ext4_inode_info, i_orphan)->vfs_inode;
1171	}
1172
1173	static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
1174	{
1175	struct list_head *l;
1176
1177	ext4_msg(sb, KERN_ERR, "sb orphan head is %d",
1178	le32_to_cpu(sbi->s_es->s_last_orphan));
1179
1180	printk(KERN_ERR "sb_info orphan list:\n");
1181	list_for_each(l, &sbi->s_orphan) {
1182	struct inode *inode = orphan_list_entry(l);
1183	printk(KERN_ERR " "
1184	"inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
1185	inode->i_sb->s_id, inode->i_ino, inode,
1186	inode->i_mode, inode->i_nlink,
1187	NEXT_ORPHAN(inode));
1188	}
1189	}
1190
1191	#ifdef CONFIG_QUOTA
1192	static int ext4_quota_off(struct super_block *sb, int type);
1193
1194	static inline void ext4_quotas_off(struct super_block *sb, int type)
1195	{
1196	BUG_ON(type > EXT4_MAXQUOTAS);
1197
1198	/* Use our quota_off function to clear inode flags etc. */
1199	for (type--; type >= 0; type--)
1200	ext4_quota_off(sb, type);
1201	}
1202
1203	/*
1204	* This is a helper function which is used in the mount/remount
1205	* codepaths (which holds s_umount) to fetch the quota file name.
1206	*/
1207	static inline char *get_qf_name(struct super_block *sb,
1208	struct ext4_sb_info *sbi,
1209	int type)
1210	{
1211	return rcu_dereference_protected(sbi->s_qf_names[type],
1212	lockdep_is_held(&sb->s_umount));
1213	}
1214	#else
1215	static inline void ext4_quotas_off(struct super_block *sb, int type)
1216	{
1217	}
1218	#endif
1219
1220	static int ext4_percpu_param_init(struct ext4_sb_info *sbi)
1221	{
1222	ext4_fsblk_t block;
1223	int err;
1224
1225	block = ext4_count_free_clusters(sbi->s_sb);
1226	ext4_free_blocks_count_set(es: sbi->s_es, EXT4_C2B(sbi, block));
1227	err = percpu_counter_init(&sbi->s_freeclusters_counter, block,
1228	GFP_KERNEL);
1229	if (!err) {
1230	unsigned long freei = ext4_count_free_inodes(sbi->s_sb);
1231	sbi->s_es->s_free_inodes_count = cpu_to_le32(freei);
1232	err = percpu_counter_init(&sbi->s_freeinodes_counter, freei,
1233	GFP_KERNEL);
1234	}
1235	if (!err)
1236	err = percpu_counter_init(&sbi->s_dirs_counter,
1237	ext4_count_dirs(sbi->s_sb), GFP_KERNEL);
1238	if (!err)
1239	err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
1240	GFP_KERNEL);
1241	if (!err)
1242	err = percpu_counter_init(&sbi->s_sra_exceeded_retry_limit, 0,
1243	GFP_KERNEL);
1244	if (!err)
1245	err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
1246
1247	if (err)
1248	ext4_msg(sbi->s_sb, KERN_ERR, "insufficient memory");
1249
1250	return err;
1251	}
1252
1253	static void ext4_percpu_param_destroy(struct ext4_sb_info *sbi)
1254	{
1255	percpu_counter_destroy(fbc: &sbi->s_freeclusters_counter);
1256	percpu_counter_destroy(fbc: &sbi->s_freeinodes_counter);
1257	percpu_counter_destroy(fbc: &sbi->s_dirs_counter);
1258	percpu_counter_destroy(fbc: &sbi->s_dirtyclusters_counter);
1259	percpu_counter_destroy(fbc: &sbi->s_sra_exceeded_retry_limit);
1260	percpu_free_rwsem(&sbi->s_writepages_rwsem);
1261	}
1262
1263	static void ext4_group_desc_free(struct ext4_sb_info *sbi)
1264	{
1265	struct buffer_head **group_desc;
1266	int i;
1267
1268	rcu_read_lock();
1269	group_desc = rcu_dereference(sbi->s_group_desc);
1270	for (i = 0; i < sbi->s_gdb_count; i++)
1271	brelse(bh: group_desc[i]);
1272	kvfree(addr: group_desc);
1273	rcu_read_unlock();
1274	}
1275
1276	static void ext4_flex_groups_free(struct ext4_sb_info *sbi)
1277	{
1278	struct flex_groups **flex_groups;
1279	int i;
1280
1281	rcu_read_lock();
1282	flex_groups = rcu_dereference(sbi->s_flex_groups);
1283	if (flex_groups) {
1284	for (i = 0; i < sbi->s_flex_groups_allocated; i++)
1285	kvfree(addr: flex_groups[i]);
1286	kvfree(addr: flex_groups);
1287	}
1288	rcu_read_unlock();
1289	}
1290
1291	static void ext4_put_super(struct super_block *sb)
1292	{
1293	struct ext4_sb_info *sbi = EXT4_SB(sb);
1294	struct ext4_super_block *es = sbi->s_es;
1295	int aborted = 0;
1296	int err;
1297
1298	/*
1299	* Unregister sysfs before destroying jbd2 journal.
1300	* Since we could still access attr_journal_task attribute via sysfs
1301	* path which could have sbi->s_journal->j_task as NULL
1302	* Unregister sysfs before flush sbi->s_sb_upd_work.
1303	* Since user may read /proc/fs/ext4/xx/mb_groups during umount, If
1304	* read metadata verify failed then will queue error work.
1305	* update_super_work will call start_this_handle may trigger
1306	* BUG_ON.
1307	*/
1308	ext4_unregister_sysfs(sb);
1309
1310	if (___ratelimit(rs: &ext4_mount_msg_ratelimit, func: "EXT4-fs unmount"))
1311	ext4_msg(sb, KERN_INFO, "unmounting filesystem %pU.",
1312	&sb->s_uuid);
1313
1314	ext4_unregister_li_request(sb);
1315	ext4_quotas_off(sb, EXT4_MAXQUOTAS);
1316
1317	flush_work(work: &sbi->s_sb_upd_work);
1318	destroy_workqueue(wq: sbi->rsv_conversion_wq);
1319	ext4_release_orphan_info(sb);
1320
1321	if (sbi->s_journal) {
1322	aborted = is_journal_aborted(journal: sbi->s_journal);
1323	err = jbd2_journal_destroy(sbi->s_journal);
1324	sbi->s_journal = NULL;
1325	if ((err < 0) && !aborted) {
1326	ext4_abort(sb, -err, "Couldn't clean up the journal");
1327	}
1328	}
1329
1330	ext4_es_unregister_shrinker(sbi);
1331	timer_shutdown_sync(timer: &sbi->s_err_report);
1332	ext4_release_system_zone(sb);
1333	ext4_mb_release(sb);
1334	ext4_ext_release(sb);
1335
1336	if (!sb_rdonly(sb) && !aborted) {
1337	ext4_clear_feature_journal_needs_recovery(sb);
1338	ext4_clear_feature_orphan_present(sb);
1339	es->s_state = cpu_to_le16(sbi->s_mount_state);
1340	}
1341	if (!sb_rdonly(sb))
1342	ext4_commit_super(sb);
1343
1344	ext4_group_desc_free(sbi);
1345	ext4_flex_groups_free(sbi);
1346	ext4_percpu_param_destroy(sbi);
1347	#ifdef CONFIG_QUOTA
1348	for (int i = 0; i < EXT4_MAXQUOTAS; i++)
1349	kfree(objp: get_qf_name(sb, sbi, type: i));
1350	#endif
1351
1352	/* Debugging code just in case the in-memory inode orphan list
1353	* isn't empty. The on-disk one can be non-empty if we've
1354	* detected an error and taken the fs readonly, but the
1355	* in-memory list had better be clean by this point. */
1356	if (!list_empty(head: &sbi->s_orphan))
1357	dump_orphan_list(sb, sbi);
1358	ASSERT(list_empty(&sbi->s_orphan));
1359
1360	sync_blockdev(bdev: sb->s_bdev);
1361	invalidate_bdev(bdev: sb->s_bdev);
1362	if (sbi->s_journal_bdev_file) {
1363	/*
1364	* Invalidate the journal device's buffers. We don't want them
1365	* floating about in memory - the physical journal device may
1366	* hotswapped, and it breaks the `ro-after' testing code.
1367	*/
1368	sync_blockdev(bdev: file_bdev(bdev_file: sbi->s_journal_bdev_file));
1369	invalidate_bdev(bdev: file_bdev(bdev_file: sbi->s_journal_bdev_file));
1370	}
1371
1372	ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
1373	sbi->s_ea_inode_cache = NULL;
1374
1375	ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
1376	sbi->s_ea_block_cache = NULL;
1377
1378	ext4_stop_mmpd(sbi);
1379
1380	brelse(bh: sbi->s_sbh);
1381	sb->s_fs_info = NULL;
1382	/*
1383	* Now that we are completely done shutting down the
1384	* superblock, we need to actually destroy the kobject.
1385	*/
1386	kobject_put(kobj: &sbi->s_kobj);
1387	wait_for_completion(&sbi->s_kobj_unregister);
1388	if (sbi->s_chksum_driver)
1389	crypto_free_shash(tfm: sbi->s_chksum_driver);
1390	kfree(objp: sbi->s_blockgroup_lock);
1391	fs_put_dax(dax_dev: sbi->s_daxdev, NULL);
1392	fscrypt_free_dummy_policy(dummy_policy: &sbi->s_dummy_enc_policy);
1393	#if IS_ENABLED(CONFIG_UNICODE)
1394	utf8_unload(um: sb->s_encoding);
1395	#endif
1396	kfree(objp: sbi);
1397	}
1398
1399	static struct kmem_cache *ext4_inode_cachep;
1400
1401	/*
1402	* Called inside transaction, so use GFP_NOFS
1403	*/
1404	static struct inode *ext4_alloc_inode(struct super_block *sb)
1405	{
1406	struct ext4_inode_info *ei;
1407
1408	ei = alloc_inode_sb(sb, cache: ext4_inode_cachep, GFP_NOFS);
1409	if (!ei)
1410	return NULL;
1411
1412	inode_set_iversion(inode: &ei->vfs_inode, val: 1);
1413	ei->i_flags = 0;
1414	spin_lock_init(&ei->i_raw_lock);
1415	ei->i_prealloc_node = RB_ROOT;
1416	atomic_set(v: &ei->i_prealloc_active, i: 0);
1417	rwlock_init(&ei->i_prealloc_lock);
1418	ext4_es_init_tree(tree: &ei->i_es_tree);
1419	rwlock_init(&ei->i_es_lock);
1420	INIT_LIST_HEAD(list: &ei->i_es_list);
1421	ei->i_es_all_nr = 0;
1422	ei->i_es_shk_nr = 0;
1423	ei->i_es_shrink_lblk = 0;
1424	ei->i_reserved_data_blocks = 0;
1425	spin_lock_init(&(ei->i_block_reservation_lock));
1426	ext4_init_pending_tree(tree: &ei->i_pending_tree);
1427	#ifdef CONFIG_QUOTA
1428	ei->i_reserved_quota = 0;
1429	memset(&ei->i_dquot, 0, sizeof(ei->i_dquot));
1430	#endif
1431	ei->jinode = NULL;
1432	INIT_LIST_HEAD(list: &ei->i_rsv_conversion_list);
1433	spin_lock_init(&ei->i_completed_io_lock);
1434	ei->i_sync_tid = 0;
1435	ei->i_datasync_tid = 0;
1436	atomic_set(v: &ei->i_unwritten, i: 0);
1437	INIT_WORK(&ei->i_rsv_conversion_work, ext4_end_io_rsv_work);
1438	ext4_fc_init_inode(inode: &ei->vfs_inode);
1439	mutex_init(&ei->i_fc_lock);
1440	return &ei->vfs_inode;
1441	}
1442
1443	static int ext4_drop_inode(struct inode *inode)
1444	{
1445	int drop = generic_drop_inode(inode);
1446
1447	if (!drop)
1448	drop = fscrypt_drop_inode(inode);
1449
1450	trace_ext4_drop_inode(inode, drop);
1451	return drop;
1452	}
1453
1454	static void ext4_free_in_core_inode(struct inode *inode)
1455	{
1456	fscrypt_free_inode(inode);
1457	if (!list_empty(head: &(EXT4_I(inode)->i_fc_list))) {
1458	pr_warn("%s: inode %ld still in fc list",
1459	__func__, inode->i_ino);
1460	}
1461	kmem_cache_free(s: ext4_inode_cachep, EXT4_I(inode));
1462	}
1463
1464	static void ext4_destroy_inode(struct inode *inode)
1465	{
1466	if (!list_empty(head: &(EXT4_I(inode)->i_orphan))) {
1467	ext4_msg(inode->i_sb, KERN_ERR,
1468	"Inode %lu (%p): orphan list check failed!",
1469	inode->i_ino, EXT4_I(inode));
1470	print_hex_dump(KERN_INFO, prefix_str: "", prefix_type: DUMP_PREFIX_ADDRESS, rowsize: 16, groupsize: 4,
1471	EXT4_I(inode), len: sizeof(struct ext4_inode_info),
1472	ascii: true);
1473	dump_stack();
1474	}
1475
1476	if (EXT4_I(inode)->i_reserved_data_blocks)
1477	ext4_msg(inode->i_sb, KERN_ERR,
1478	"Inode %lu (%p): i_reserved_data_blocks (%u) not cleared!",
1479	inode->i_ino, EXT4_I(inode),
1480	EXT4_I(inode)->i_reserved_data_blocks);
1481	}
1482
1483	static void ext4_shutdown(struct super_block *sb)
1484	{
1485	ext4_force_shutdown(sb, EXT4_GOING_FLAGS_NOLOGFLUSH);
1486	}
1487
1488	static void init_once(void *foo)
1489	{
1490	struct ext4_inode_info *ei = foo;
1491
1492	INIT_LIST_HEAD(list: &ei->i_orphan);
1493	init_rwsem(&ei->xattr_sem);
1494	init_rwsem(&ei->i_data_sem);
1495	inode_init_once(&ei->vfs_inode);
1496	ext4_fc_init_inode(inode: &ei->vfs_inode);
1497	}
1498
1499	static int __init init_inodecache(void)
1500	{
1501	ext4_inode_cachep = kmem_cache_create_usercopy(name: "ext4_inode_cache",
1502	size: sizeof(struct ext4_inode_info), align: 0,
1503	SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
1504	offsetof(struct ext4_inode_info, i_data),
1505	sizeof_field(struct ext4_inode_info, i_data),
1506	ctor: init_once);
1507	if (ext4_inode_cachep == NULL)
1508	return -ENOMEM;
1509	return 0;
1510	}
1511
1512	static void destroy_inodecache(void)
1513	{
1514	/*
1515	* Make sure all delayed rcu free inodes are flushed before we
1516	* destroy cache.
1517	*/
1518	rcu_barrier();
1519	kmem_cache_destroy(s: ext4_inode_cachep);
1520	}
1521
1522	void ext4_clear_inode(struct inode *inode)
1523	{
1524	ext4_fc_del(inode);
1525	invalidate_inode_buffers(inode);
1526	clear_inode(inode);
1527	ext4_discard_preallocations(inode);
1528	ext4_es_remove_extent(inode, lblk: 0, EXT_MAX_BLOCKS);
1529	dquot_drop(inode);
1530	if (EXT4_I(inode)->jinode) {
1531	jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
1532	EXT4_I(inode)->jinode);
1533	jbd2_free_inode(EXT4_I(inode)->jinode);
1534	EXT4_I(inode)->jinode = NULL;
1535	}
1536	fscrypt_put_encryption_info(inode);
1537	fsverity_cleanup_inode(inode);
1538	}
1539
1540	static struct inode *ext4_nfs_get_inode(struct super_block *sb,
1541	u64 ino, u32 generation)
1542	{
1543	struct inode *inode;
1544
1545	/*
1546	* Currently we don't know the generation for parent directory, so
1547	* a generation of 0 means "accept any"
1548	*/
1549	inode = ext4_iget(sb, ino, EXT4_IGET_HANDLE);
1550	if (IS_ERR(ptr: inode))
1551	return ERR_CAST(ptr: inode);
1552	if (generation && inode->i_generation != generation) {
1553	iput(inode);
1554	return ERR_PTR(error: -ESTALE);
1555	}
1556
1557	return inode;
1558	}
1559
1560	static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
1561	int fh_len, int fh_type)
1562	{
1563	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
1564	get_inode: ext4_nfs_get_inode);
1565	}
1566
1567	static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
1568	int fh_len, int fh_type)
1569	{
1570	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
1571	get_inode: ext4_nfs_get_inode);
1572	}
1573
1574	static int ext4_nfs_commit_metadata(struct inode *inode)
1575	{
1576	struct writeback_control wbc = {
1577	.sync_mode = WB_SYNC_ALL
1578	};
1579
1580	trace_ext4_nfs_commit_metadata(inode);
1581	return ext4_write_inode(inode, &wbc);
1582	}
1583
1584	#ifdef CONFIG_QUOTA
1585	static const char * const quotatypes[] = INITQFNAMES;
1586	#define QTYPE2NAME(t) (quotatypes[t])
1587
1588	static int ext4_write_dquot(struct dquot *dquot);
1589	static int ext4_acquire_dquot(struct dquot *dquot);
1590	static int ext4_release_dquot(struct dquot *dquot);
1591	static int ext4_mark_dquot_dirty(struct dquot *dquot);
1592	static int ext4_write_info(struct super_block *sb, int type);
1593	static int ext4_quota_on(struct super_block *sb, int type, int format_id,
1594	const struct path *path);
1595	static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
1596	size_t len, loff_t off);
1597	static ssize_t ext4_quota_write(struct super_block *sb, int type,
1598	const char *data, size_t len, loff_t off);
1599	static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
1600	unsigned int flags);
1601
1602	static struct dquot __rcu **ext4_get_dquots(struct inode *inode)
1603	{
1604	return EXT4_I(inode)->i_dquot;
1605	}
1606
1607	static const struct dquot_operations ext4_quota_operations = {
1608	.get_reserved_space = ext4_get_reserved_space,
1609	.write_dquot = ext4_write_dquot,
1610	.acquire_dquot = ext4_acquire_dquot,
1611	.release_dquot = ext4_release_dquot,
1612	.mark_dirty = ext4_mark_dquot_dirty,
1613	.write_info = ext4_write_info,
1614	.alloc_dquot = dquot_alloc,
1615	.destroy_dquot = dquot_destroy,
1616	.get_projid = ext4_get_projid,
1617	.get_inode_usage = ext4_get_inode_usage,
1618	.get_next_id = dquot_get_next_id,
1619	};
1620
1621	static const struct quotactl_ops ext4_qctl_operations = {
1622	.quota_on = ext4_quota_on,
1623	.quota_off = ext4_quota_off,
1624	.quota_sync = dquot_quota_sync,
1625	.get_state = dquot_get_state,
1626	.set_info = dquot_set_dqinfo,
1627	.get_dqblk = dquot_get_dqblk,
1628	.set_dqblk = dquot_set_dqblk,
1629	.get_nextdqblk = dquot_get_next_dqblk,
1630	};
1631	#endif
1632
1633	static const struct super_operations ext4_sops = {
1634	.alloc_inode = ext4_alloc_inode,
1635	.free_inode = ext4_free_in_core_inode,
1636	.destroy_inode = ext4_destroy_inode,
1637	.write_inode = ext4_write_inode,
1638	.dirty_inode = ext4_dirty_inode,
1639	.drop_inode = ext4_drop_inode,
1640	.evict_inode = ext4_evict_inode,
1641	.put_super = ext4_put_super,
1642	.sync_fs = ext4_sync_fs,
1643	.freeze_fs = ext4_freeze,
1644	.unfreeze_fs = ext4_unfreeze,
1645	.statfs = ext4_statfs,
1646	.show_options = ext4_show_options,
1647	.shutdown = ext4_shutdown,
1648	#ifdef CONFIG_QUOTA
1649	.quota_read = ext4_quota_read,
1650	.quota_write = ext4_quota_write,
1651	.get_dquots = ext4_get_dquots,
1652	#endif
1653	};
1654
1655	static const struct export_operations ext4_export_ops = {
1656	.encode_fh = generic_encode_ino32_fh,
1657	.fh_to_dentry = ext4_fh_to_dentry,
1658	.fh_to_parent = ext4_fh_to_parent,
1659	.get_parent = ext4_get_parent,
1660	.commit_metadata = ext4_nfs_commit_metadata,
1661	};
1662
1663	enum {
1664	Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
1665	Opt_resgid, Opt_resuid, Opt_sb,
1666	Opt_nouid32, Opt_debug, Opt_removed,
1667	Opt_user_xattr, Opt_acl,
1668	Opt_auto_da_alloc, Opt_noauto_da_alloc, Opt_noload,
1669	Opt_commit, Opt_min_batch_time, Opt_max_batch_time, Opt_journal_dev,
1670	Opt_journal_path, Opt_journal_checksum, Opt_journal_async_commit,
1671	Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
1672	Opt_data_err_abort, Opt_data_err_ignore, Opt_test_dummy_encryption,
1673	Opt_inlinecrypt,
1674	Opt_usrjquota, Opt_grpjquota, Opt_quota,
1675	Opt_noquota, Opt_barrier, Opt_nobarrier, Opt_err,
1676	Opt_usrquota, Opt_grpquota, Opt_prjquota,
1677	Opt_dax, Opt_dax_always, Opt_dax_inode, Opt_dax_never,
1678	Opt_stripe, Opt_delalloc, Opt_nodelalloc, Opt_warn_on_error,
1679	Opt_nowarn_on_error, Opt_mblk_io_submit, Opt_debug_want_extra_isize,
1680	Opt_nomblk_io_submit, Opt_block_validity, Opt_noblock_validity,
1681	Opt_inode_readahead_blks, Opt_journal_ioprio,
1682	Opt_dioread_nolock, Opt_dioread_lock,
1683	Opt_discard, Opt_nodiscard, Opt_init_itable, Opt_noinit_itable,
1684	Opt_max_dir_size_kb, Opt_nojournal_checksum, Opt_nombcache,
1685	Opt_no_prefetch_block_bitmaps, Opt_mb_optimize_scan,
1686	Opt_errors, Opt_data, Opt_data_err, Opt_jqfmt, Opt_dax_type,
1687	#ifdef CONFIG_EXT4_DEBUG
1688	Opt_fc_debug_max_replay, Opt_fc_debug_force
1689	#endif
1690	};
1691
1692	static const struct constant_table ext4_param_errors[] = {
1693	{"continue", EXT4_MOUNT_ERRORS_CONT},
1694	{"panic", EXT4_MOUNT_ERRORS_PANIC},
1695	{"remount-ro", EXT4_MOUNT_ERRORS_RO},
1696	{}
1697	};
1698
1699	static const struct constant_table ext4_param_data[] = {
1700	{"journal", EXT4_MOUNT_JOURNAL_DATA},
1701	{"ordered", EXT4_MOUNT_ORDERED_DATA},
1702	{"writeback", EXT4_MOUNT_WRITEBACK_DATA},
1703	{}
1704	};
1705
1706	static const struct constant_table ext4_param_data_err[] = {
1707	{"abort", Opt_data_err_abort},
1708	{"ignore", Opt_data_err_ignore},
1709	{}
1710	};
1711
1712	static const struct constant_table ext4_param_jqfmt[] = {
1713	{"vfsold", QFMT_VFS_OLD},
1714	{"vfsv0", QFMT_VFS_V0},
1715	{"vfsv1", QFMT_VFS_V1},
1716	{}
1717	};
1718
1719	static const struct constant_table ext4_param_dax[] = {
1720	{"always", Opt_dax_always},
1721	{"inode", Opt_dax_inode},
1722	{"never", Opt_dax_never},
1723	{}
1724	};
1725
1726	/* String parameter that allows empty argument */
1727	#define fsparam_string_empty(NAME, OPT) \
1728	__fsparam(fs_param_is_string, NAME, OPT, fs_param_can_be_empty, NULL)
1729
1730	/*
1731	* Mount option specification
1732	* We don't use fsparam_flag_no because of the way we set the
1733	* options and the way we show them in _ext4_show_options(). To
1734	* keep the changes to a minimum, let's keep the negative options
1735	* separate for now.
1736	*/
1737	static const struct fs_parameter_spec ext4_param_specs[] = {
1738	fsparam_flag ("bsddf", Opt_bsd_df),
1739	fsparam_flag ("minixdf", Opt_minix_df),
1740	fsparam_flag ("grpid", Opt_grpid),
1741	fsparam_flag ("bsdgroups", Opt_grpid),
1742	fsparam_flag ("nogrpid", Opt_nogrpid),
1743	fsparam_flag ("sysvgroups", Opt_nogrpid),
1744	fsparam_u32 ("resgid", Opt_resgid),
1745	fsparam_u32 ("resuid", Opt_resuid),
1746	fsparam_u32 ("sb", Opt_sb),
1747	fsparam_enum ("errors", Opt_errors, ext4_param_errors),
1748	fsparam_flag ("nouid32", Opt_nouid32),
1749	fsparam_flag ("debug", Opt_debug),
1750	fsparam_flag ("oldalloc", Opt_removed),
1751	fsparam_flag ("orlov", Opt_removed),
1752	fsparam_flag ("user_xattr", Opt_user_xattr),
1753	fsparam_flag ("acl", Opt_acl),
1754	fsparam_flag ("norecovery", Opt_noload),
1755	fsparam_flag ("noload", Opt_noload),
1756	fsparam_flag ("bh", Opt_removed),
1757	fsparam_flag ("nobh", Opt_removed),
1758	fsparam_u32 ("commit", Opt_commit),
1759	fsparam_u32 ("min_batch_time", Opt_min_batch_time),
1760	fsparam_u32 ("max_batch_time", Opt_max_batch_time),
1761	fsparam_u32 ("journal_dev", Opt_journal_dev),
1762	fsparam_bdev ("journal_path", Opt_journal_path),
1763	fsparam_flag ("journal_checksum", Opt_journal_checksum),
1764	fsparam_flag ("nojournal_checksum", Opt_nojournal_checksum),
1765	fsparam_flag ("journal_async_commit",Opt_journal_async_commit),
1766	fsparam_flag ("abort", Opt_abort),
1767	fsparam_enum ("data", Opt_data, ext4_param_data),
1768	fsparam_enum ("data_err", Opt_data_err,
1769	ext4_param_data_err),
1770	fsparam_string_empty
1771	("usrjquota", Opt_usrjquota),
1772	fsparam_string_empty
1773	("grpjquota", Opt_grpjquota),
1774	fsparam_enum ("jqfmt", Opt_jqfmt, ext4_param_jqfmt),
1775	fsparam_flag ("grpquota", Opt_grpquota),
1776	fsparam_flag ("quota", Opt_quota),
1777	fsparam_flag ("noquota", Opt_noquota),
1778	fsparam_flag ("usrquota", Opt_usrquota),
1779	fsparam_flag ("prjquota", Opt_prjquota),
1780	fsparam_flag ("barrier", Opt_barrier),
1781	fsparam_u32 ("barrier", Opt_barrier),
1782	fsparam_flag ("nobarrier", Opt_nobarrier),
1783	fsparam_flag ("i_version", Opt_removed),
1784	fsparam_flag ("dax", Opt_dax),
1785	fsparam_enum ("dax", Opt_dax_type, ext4_param_dax),
1786	fsparam_u32 ("stripe", Opt_stripe),
1787	fsparam_flag ("delalloc", Opt_delalloc),
1788	fsparam_flag ("nodelalloc", Opt_nodelalloc),
1789	fsparam_flag ("warn_on_error", Opt_warn_on_error),
1790	fsparam_flag ("nowarn_on_error", Opt_nowarn_on_error),
1791	fsparam_u32 ("debug_want_extra_isize",
1792	Opt_debug_want_extra_isize),
1793	fsparam_flag ("mblk_io_submit", Opt_removed),
1794	fsparam_flag ("nomblk_io_submit", Opt_removed),
1795	fsparam_flag ("block_validity", Opt_block_validity),
1796	fsparam_flag ("noblock_validity", Opt_noblock_validity),
1797	fsparam_u32 ("inode_readahead_blks",
1798	Opt_inode_readahead_blks),
1799	fsparam_u32 ("journal_ioprio", Opt_journal_ioprio),
1800	fsparam_u32 ("auto_da_alloc", Opt_auto_da_alloc),
1801	fsparam_flag ("auto_da_alloc", Opt_auto_da_alloc),
1802	fsparam_flag ("noauto_da_alloc", Opt_noauto_da_alloc),
1803	fsparam_flag ("dioread_nolock", Opt_dioread_nolock),
1804	fsparam_flag ("nodioread_nolock", Opt_dioread_lock),
1805	fsparam_flag ("dioread_lock", Opt_dioread_lock),
1806	fsparam_flag ("discard", Opt_discard),
1807	fsparam_flag ("nodiscard", Opt_nodiscard),
1808	fsparam_u32 ("init_itable", Opt_init_itable),
1809	fsparam_flag ("init_itable", Opt_init_itable),
1810	fsparam_flag ("noinit_itable", Opt_noinit_itable),
1811	#ifdef CONFIG_EXT4_DEBUG
1812	fsparam_flag ("fc_debug_force", Opt_fc_debug_force),
1813	fsparam_u32 ("fc_debug_max_replay", Opt_fc_debug_max_replay),
1814	#endif
1815	fsparam_u32 ("max_dir_size_kb", Opt_max_dir_size_kb),
1816	fsparam_flag ("test_dummy_encryption",
1817	Opt_test_dummy_encryption),
1818	fsparam_string ("test_dummy_encryption",
1819	Opt_test_dummy_encryption),
1820	fsparam_flag ("inlinecrypt", Opt_inlinecrypt),
1821	fsparam_flag ("nombcache", Opt_nombcache),
1822	fsparam_flag ("no_mbcache", Opt_nombcache), /* for backward compatibility */
1823	fsparam_flag ("prefetch_block_bitmaps",
1824	Opt_removed),
1825	fsparam_flag ("no_prefetch_block_bitmaps",
1826	Opt_no_prefetch_block_bitmaps),
1827	fsparam_s32 ("mb_optimize_scan", Opt_mb_optimize_scan),
1828	fsparam_string ("check", Opt_removed), /* mount option from ext2/3 */
1829	fsparam_flag ("nocheck", Opt_removed), /* mount option from ext2/3 */
1830	fsparam_flag ("reservation", Opt_removed), /* mount option from ext2/3 */
1831	fsparam_flag ("noreservation", Opt_removed), /* mount option from ext2/3 */
1832	fsparam_u32 ("journal", Opt_removed), /* mount option from ext2/3 */
1833	{}
1834	};
1835
1836	#define DEFAULT_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3))
1837
1838	#define MOPT_SET 0x0001
1839	#define MOPT_CLEAR 0x0002
1840	#define MOPT_NOSUPPORT 0x0004
1841	#define MOPT_EXPLICIT 0x0008
1842	#ifdef CONFIG_QUOTA
1843	#define MOPT_Q 0
1844	#define MOPT_QFMT 0x0010
1845	#else
1846	#define MOPT_Q MOPT_NOSUPPORT
1847	#define MOPT_QFMT MOPT_NOSUPPORT
1848	#endif
1849	#define MOPT_NO_EXT2 0x0020
1850	#define MOPT_NO_EXT3 0x0040
1851	#define MOPT_EXT4_ONLY (MOPT_NO_EXT2 | MOPT_NO_EXT3)
1852	#define MOPT_SKIP 0x0080
1853	#define MOPT_2 0x0100
1854
1855	static const struct mount_opts {
1856	int token;
1857	int mount_opt;
1858	int flags;
1859	} ext4_mount_opts[] = {
1860	{Opt_minix_df, EXT4_MOUNT_MINIX_DF, MOPT_SET},
1861	{Opt_bsd_df, EXT4_MOUNT_MINIX_DF, MOPT_CLEAR},
1862	{Opt_grpid, EXT4_MOUNT_GRPID, MOPT_SET},
1863	{Opt_nogrpid, EXT4_MOUNT_GRPID, MOPT_CLEAR},
1864	{Opt_block_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_SET},
1865	{Opt_noblock_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_CLEAR},
1866	{Opt_dioread_nolock, EXT4_MOUNT_DIOREAD_NOLOCK,
1867	MOPT_EXT4_ONLY | MOPT_SET},
1868	{Opt_dioread_lock, EXT4_MOUNT_DIOREAD_NOLOCK,
1869	MOPT_EXT4_ONLY | MOPT_CLEAR},
1870	{Opt_discard, EXT4_MOUNT_DISCARD, MOPT_SET},
1871	{Opt_nodiscard, EXT4_MOUNT_DISCARD, MOPT_CLEAR},
1872	{Opt_delalloc, EXT4_MOUNT_DELALLOC,
1873	MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1874	{Opt_nodelalloc, EXT4_MOUNT_DELALLOC,
1875	MOPT_EXT4_ONLY | MOPT_CLEAR},
1876	{Opt_warn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_SET},
1877	{Opt_nowarn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_CLEAR},
1878	{Opt_commit, 0, MOPT_NO_EXT2},
1879	{Opt_nojournal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1880	MOPT_EXT4_ONLY | MOPT_CLEAR},
1881	{Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1882	MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1883	{Opt_journal_async_commit, (EXT4_MOUNT_JOURNAL_ASYNC_COMMIT |
1884	EXT4_MOUNT_JOURNAL_CHECKSUM),
1885	MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1886	{Opt_noload, EXT4_MOUNT_NOLOAD, MOPT_NO_EXT2 | MOPT_SET},
1887	{Opt_data_err, EXT4_MOUNT_DATA_ERR_ABORT, MOPT_NO_EXT2},
1888	{Opt_barrier, EXT4_MOUNT_BARRIER, MOPT_SET},
1889	{Opt_nobarrier, EXT4_MOUNT_BARRIER, MOPT_CLEAR},
1890	{Opt_noauto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_SET},
1891	{Opt_auto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_CLEAR},
1892	{Opt_noinit_itable, EXT4_MOUNT_INIT_INODE_TABLE, MOPT_CLEAR},
1893	{Opt_dax_type, 0, MOPT_EXT4_ONLY},
1894	{Opt_journal_dev, 0, MOPT_NO_EXT2},
1895	{Opt_journal_path, 0, MOPT_NO_EXT2},
1896	{Opt_journal_ioprio, 0, MOPT_NO_EXT2},
1897	{Opt_data, 0, MOPT_NO_EXT2},
1898	{Opt_user_xattr, EXT4_MOUNT_XATTR_USER, MOPT_SET},
1899	#ifdef CONFIG_EXT4_FS_POSIX_ACL
1900	{Opt_acl, EXT4_MOUNT_POSIX_ACL, MOPT_SET},
1901	#else
1902	{Opt_acl, 0, MOPT_NOSUPPORT},
1903	#endif
1904	{Opt_nouid32, EXT4_MOUNT_NO_UID32, MOPT_SET},
1905	{Opt_debug, EXT4_MOUNT_DEBUG, MOPT_SET},
1906	{Opt_quota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA, MOPT_SET | MOPT_Q},
1907	{Opt_usrquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA,
1908	MOPT_SET | MOPT_Q},
1909	{Opt_grpquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_GRPQUOTA,
1910	MOPT_SET | MOPT_Q},
1911	{Opt_prjquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_PRJQUOTA,
1912	MOPT_SET | MOPT_Q},
1913	{Opt_noquota, (EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA |
1914	EXT4_MOUNT_GRPQUOTA | EXT4_MOUNT_PRJQUOTA),
1915	MOPT_CLEAR | MOPT_Q},
1916	{Opt_usrjquota, 0, MOPT_Q},
1917	{Opt_grpjquota, 0, MOPT_Q},
1918	{Opt_jqfmt, 0, MOPT_QFMT},
1919	{Opt_nombcache, EXT4_MOUNT_NO_MBCACHE, MOPT_SET},
1920	{Opt_no_prefetch_block_bitmaps, EXT4_MOUNT_NO_PREFETCH_BLOCK_BITMAPS,
1921	MOPT_SET},
1922	#ifdef CONFIG_EXT4_DEBUG
1923	{Opt_fc_debug_force, EXT4_MOUNT2_JOURNAL_FAST_COMMIT,
1924	MOPT_SET | MOPT_2 | MOPT_EXT4_ONLY},
1925	#endif
1926	{Opt_abort, EXT4_MOUNT2_ABORT, MOPT_SET | MOPT_2},
1927	{Opt_err, 0, 0}
1928	};
1929
1930	#if IS_ENABLED(CONFIG_UNICODE)
1931	static const struct ext4_sb_encodings {
1932	__u16 magic;
1933	char *name;
1934	unsigned int version;
1935	} ext4_sb_encoding_map[] = {
1936	{EXT4_ENC_UTF8_12_1, "utf8", UNICODE_AGE(12, 1, 0)},
1937	};
1938
1939	static const struct ext4_sb_encodings *
1940	ext4_sb_read_encoding(const struct ext4_super_block *es)
1941	{
1942	__u16 magic = le16_to_cpu(es->s_encoding);
1943	int i;
1944
1945	for (i = 0; i < ARRAY_SIZE(ext4_sb_encoding_map); i++)
1946	if (magic == ext4_sb_encoding_map[i].magic)
1947	return &ext4_sb_encoding_map[i];
1948
1949	return NULL;
1950	}
1951	#endif
1952
1953	#define EXT4_SPEC_JQUOTA (1 << 0)
1954	#define EXT4_SPEC_JQFMT (1 << 1)
1955	#define EXT4_SPEC_DATAJ (1 << 2)
1956	#define EXT4_SPEC_SB_BLOCK (1 << 3)
1957	#define EXT4_SPEC_JOURNAL_DEV (1 << 4)
1958	#define EXT4_SPEC_JOURNAL_IOPRIO (1 << 5)
1959	#define EXT4_SPEC_s_want_extra_isize (1 << 7)
1960	#define EXT4_SPEC_s_max_batch_time (1 << 8)
1961	#define EXT4_SPEC_s_min_batch_time (1 << 9)
1962	#define EXT4_SPEC_s_inode_readahead_blks (1 << 10)
1963	#define EXT4_SPEC_s_li_wait_mult (1 << 11)
1964	#define EXT4_SPEC_s_max_dir_size_kb (1 << 12)
1965	#define EXT4_SPEC_s_stripe (1 << 13)
1966	#define EXT4_SPEC_s_resuid (1 << 14)
1967	#define EXT4_SPEC_s_resgid (1 << 15)
1968	#define EXT4_SPEC_s_commit_interval (1 << 16)
1969	#define EXT4_SPEC_s_fc_debug_max_replay (1 << 17)
1970	#define EXT4_SPEC_s_sb_block (1 << 18)
1971	#define EXT4_SPEC_mb_optimize_scan (1 << 19)
1972
1973	struct ext4_fs_context {
1974	char *s_qf_names[EXT4_MAXQUOTAS];
1975	struct fscrypt_dummy_policy dummy_enc_policy;
1976	int s_jquota_fmt; /* Format of quota to use */
1977	#ifdef CONFIG_EXT4_DEBUG
1978	int s_fc_debug_max_replay;
1979	#endif
1980	unsigned short qname_spec;
1981	unsigned long vals_s_flags; /* Bits to set in s_flags */
1982	unsigned long mask_s_flags; /* Bits changed in s_flags */
1983	unsigned long journal_devnum;
1984	unsigned long s_commit_interval;
1985	unsigned long s_stripe;
1986	unsigned int s_inode_readahead_blks;
1987	unsigned int s_want_extra_isize;
1988	unsigned int s_li_wait_mult;
1989	unsigned int s_max_dir_size_kb;
1990	unsigned int journal_ioprio;
1991	unsigned int vals_s_mount_opt;
1992	unsigned int mask_s_mount_opt;
1993	unsigned int vals_s_mount_opt2;
1994	unsigned int mask_s_mount_opt2;
1995	unsigned int opt_flags; /* MOPT flags */
1996	unsigned int spec;
1997	u32 s_max_batch_time;
1998	u32 s_min_batch_time;
1999	kuid_t s_resuid;
2000	kgid_t s_resgid;
2001	ext4_fsblk_t s_sb_block;
2002	};
2003
2004	static void ext4_fc_free(struct fs_context *fc)
2005	{
2006	struct ext4_fs_context *ctx = fc->fs_private;
2007	int i;
2008
2009	if (!ctx)
2010	return;
2011
2012	for (i = 0; i < EXT4_MAXQUOTAS; i++)
2013	kfree(objp: ctx->s_qf_names[i]);
2014
2015	fscrypt_free_dummy_policy(dummy_policy: &ctx->dummy_enc_policy);
2016	kfree(objp: ctx);
2017	}
2018
2019	int ext4_init_fs_context(struct fs_context *fc)
2020	{
2021	struct ext4_fs_context *ctx;
2022
2023	ctx = kzalloc(size: sizeof(struct ext4_fs_context), GFP_KERNEL);
2024	if (!ctx)
2025	return -ENOMEM;
2026
2027	fc->fs_private = ctx;
2028	fc->ops = &ext4_context_ops;
2029
2030	return 0;
2031	}
2032
2033	#ifdef CONFIG_QUOTA
2034	/*
2035	* Note the name of the specified quota file.
2036	*/
2037	static int note_qf_name(struct fs_context *fc, int qtype,
2038	struct fs_parameter *param)
2039	{
2040	struct ext4_fs_context *ctx = fc->fs_private;
2041	char *qname;
2042
2043	if (param->size < 1) {
2044	ext4_msg(NULL, KERN_ERR, "Missing quota name");
2045	return -EINVAL;
2046	}
2047	if (strchr(param->string, '/')) {
2048	ext4_msg(NULL, KERN_ERR,
2049	"quotafile must be on filesystem root");
2050	return -EINVAL;
2051	}
2052	if (ctx->s_qf_names[qtype]) {
2053	if (strcmp(ctx->s_qf_names[qtype], param->string) != 0) {
2054	ext4_msg(NULL, KERN_ERR,
2055	"%s quota file already specified",
2056	QTYPE2NAME(qtype));
2057	return -EINVAL;
2058	}
2059	return 0;
2060	}
2061
2062	qname = kmemdup_nul(s: param->string, len: param->size, GFP_KERNEL);
2063	if (!qname) {
2064	ext4_msg(NULL, KERN_ERR,
2065	"Not enough memory for storing quotafile name");
2066	return -ENOMEM;
2067	}
2068	ctx->s_qf_names[qtype] = qname;
2069	ctx->qname_spec |= 1 << qtype;
2070	ctx->spec |= EXT4_SPEC_JQUOTA;
2071	return 0;
2072	}
2073
2074	/*
2075	* Clear the name of the specified quota file.
2076	*/
2077	static int unnote_qf_name(struct fs_context *fc, int qtype)
2078	{
2079	struct ext4_fs_context *ctx = fc->fs_private;
2080
2081	if (ctx->s_qf_names[qtype])
2082	kfree(objp: ctx->s_qf_names[qtype]);
2083
2084	ctx->s_qf_names[qtype] = NULL;
2085	ctx->qname_spec |= 1 << qtype;
2086	ctx->spec |= EXT4_SPEC_JQUOTA;
2087	return 0;
2088	}
2089	#endif
2090
2091	static int ext4_parse_test_dummy_encryption(const struct fs_parameter *param,
2092	struct ext4_fs_context *ctx)
2093	{
2094	int err;
2095
2096	if (!IS_ENABLED(CONFIG_FS_ENCRYPTION)) {
2097	ext4_msg(NULL, KERN_WARNING,
2098	"test_dummy_encryption option not supported");
2099	return -EINVAL;
2100	}
2101	err = fscrypt_parse_test_dummy_encryption(param,
2102	dummy_policy: &ctx->dummy_enc_policy);
2103	if (err == -EINVAL) {
2104	ext4_msg(NULL, KERN_WARNING,
2105	"Value of option \"%s\" is unrecognized", param->key);
2106	} else if (err == -EEXIST) {
2107	ext4_msg(NULL, KERN_WARNING,
2108	"Conflicting test_dummy_encryption options");
2109	return -EINVAL;
2110	}
2111	return err;
2112	}
2113
2114	#define EXT4_SET_CTX(name) \
2115	static inline void ctx_set_##name(struct ext4_fs_context *ctx, \
2116	unsigned long flag) \
2117	{ \
2118	ctx->mask_s_##name |= flag; \
2119	ctx->vals_s_##name |= flag; \
2120	}
2121
2122	#define EXT4_CLEAR_CTX(name) \
2123	static inline void ctx_clear_##name(struct ext4_fs_context *ctx, \
2124	unsigned long flag) \
2125	{ \
2126	ctx->mask_s_##name |= flag; \
2127	ctx->vals_s_##name &= ~flag; \
2128	}
2129
2130	#define EXT4_TEST_CTX(name) \
2131	static inline unsigned long \
2132	ctx_test_##name(struct ext4_fs_context *ctx, unsigned long flag) \
2133	{ \
2134	return (ctx->vals_s_##name & flag); \
2135	}
2136
2137	EXT4_SET_CTX(flags); /* set only */
2138	EXT4_SET_CTX(mount_opt);
2139	EXT4_CLEAR_CTX(mount_opt);
2140	EXT4_TEST_CTX(mount_opt);
2141	EXT4_SET_CTX(mount_opt2);
2142	EXT4_CLEAR_CTX(mount_opt2);
2143	EXT4_TEST_CTX(mount_opt2);
2144
2145	static int ext4_parse_param(struct fs_context *fc, struct fs_parameter *param)
2146	{
2147	struct ext4_fs_context *ctx = fc->fs_private;
2148	struct fs_parse_result result;
2149	const struct mount_opts *m;
2150	int is_remount;
2151	kuid_t uid;
2152	kgid_t gid;
2153	int token;
2154
2155	token = fs_parse(fc, desc: ext4_param_specs, param, result: &result);
2156	if (token < 0)
2157	return token;
2158	is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
2159
2160	for (m = ext4_mount_opts; m->token != Opt_err; m++)
2161	if (token == m->token)
2162	break;
2163
2164	ctx->opt_flags |= m->flags;
2165
2166	if (m->flags & MOPT_EXPLICIT) {
2167	if (m->mount_opt & EXT4_MOUNT_DELALLOC) {
2168	ctx_set_mount_opt2(ctx, EXT4_MOUNT2_EXPLICIT_DELALLOC);
2169	} else if (m->mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) {
2170	ctx_set_mount_opt2(ctx,
2171	EXT4_MOUNT2_EXPLICIT_JOURNAL_CHECKSUM);
2172	} else
2173	return -EINVAL;
2174	}
2175
2176	if (m->flags & MOPT_NOSUPPORT) {
2177	ext4_msg(NULL, KERN_ERR, "%s option not supported",
2178	param->key);
2179	return 0;
2180	}
2181
2182	switch (token) {
2183	#ifdef CONFIG_QUOTA
2184	case Opt_usrjquota:
2185	if (!*param->string)
2186	return unnote_qf_name(fc, qtype: USRQUOTA);
2187	else
2188	return note_qf_name(fc, qtype: USRQUOTA, param);
2189	case Opt_grpjquota:
2190	if (!*param->string)
2191	return unnote_qf_name(fc, qtype: GRPQUOTA);
2192	else
2193	return note_qf_name(fc, qtype: GRPQUOTA, param);
2194	#endif
2195	case Opt_sb:
2196	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
2197	ext4_msg(NULL, KERN_WARNING,
2198	"Ignoring %s option on remount", param->key);
2199	} else {
2200	ctx->s_sb_block = result.uint_32;
2201	ctx->spec |= EXT4_SPEC_s_sb_block;
2202	}
2203	return 0;
2204	case Opt_removed:
2205	ext4_msg(NULL, KERN_WARNING, "Ignoring removed %s option",
2206	param->key);
2207	return 0;
2208	case Opt_inlinecrypt:
2209	#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
2210	ctx_set_flags(ctx, SB_INLINECRYPT);
2211	#else
2212	ext4_msg(NULL, KERN_ERR, "inline encryption not supported");
2213	#endif
2214	return 0;
2215	case Opt_errors:
2216	ctx_clear_mount_opt(ctx, EXT4_MOUNT_ERRORS_MASK);
2217	ctx_set_mount_opt(ctx, flag: result.uint_32);
2218	return 0;
2219	#ifdef CONFIG_QUOTA
2220	case Opt_jqfmt:
2221	ctx->s_jquota_fmt = result.uint_32;
2222	ctx->spec |= EXT4_SPEC_JQFMT;
2223	return 0;
2224	#endif
2225	case Opt_data:
2226	ctx_clear_mount_opt(ctx, EXT4_MOUNT_DATA_FLAGS);
2227	ctx_set_mount_opt(ctx, flag: result.uint_32);
2228	ctx->spec |= EXT4_SPEC_DATAJ;
2229	return 0;
2230	case Opt_commit:
2231	if (result.uint_32 == 0)
2232	result.uint_32 = JBD2_DEFAULT_MAX_COMMIT_AGE;
2233	else if (result.uint_32 > INT_MAX / HZ) {
2234	ext4_msg(NULL, KERN_ERR,
2235	"Invalid commit interval %d, "
2236	"must be smaller than %d",
2237	result.uint_32, INT_MAX / HZ);
2238	return -EINVAL;
2239	}
2240	ctx->s_commit_interval = HZ * result.uint_32;
2241	ctx->spec |= EXT4_SPEC_s_commit_interval;
2242	return 0;
2243	case Opt_debug_want_extra_isize:
2244	if ((result.uint_32 & 1) || (result.uint_32 < 4)) {
2245	ext4_msg(NULL, KERN_ERR,
2246	"Invalid want_extra_isize %d", result.uint_32);
2247	return -EINVAL;
2248	}
2249	ctx->s_want_extra_isize = result.uint_32;
2250	ctx->spec |= EXT4_SPEC_s_want_extra_isize;
2251	return 0;
2252	case Opt_max_batch_time:
2253	ctx->s_max_batch_time = result.uint_32;
2254	ctx->spec |= EXT4_SPEC_s_max_batch_time;
2255	return 0;
2256	case Opt_min_batch_time:
2257	ctx->s_min_batch_time = result.uint_32;
2258	ctx->spec |= EXT4_SPEC_s_min_batch_time;
2259	return 0;
2260	case Opt_inode_readahead_blks:
2261	if (result.uint_32 &&
2262	(result.uint_32 > (1 << 30) ||
2263	!is_power_of_2(n: result.uint_32))) {
2264	ext4_msg(NULL, KERN_ERR,
2265	"EXT4-fs: inode_readahead_blks must be "
2266	"0 or a power of 2 smaller than 2^31");
2267	return -EINVAL;
2268	}
2269	ctx->s_inode_readahead_blks = result.uint_32;
2270	ctx->spec |= EXT4_SPEC_s_inode_readahead_blks;
2271	return 0;
2272	case Opt_init_itable:
2273	ctx_set_mount_opt(ctx, EXT4_MOUNT_INIT_INODE_TABLE);
2274	ctx->s_li_wait_mult = EXT4_DEF_LI_WAIT_MULT;
2275	if (param->type == fs_value_is_string)
2276	ctx->s_li_wait_mult = result.uint_32;
2277	ctx->spec |= EXT4_SPEC_s_li_wait_mult;
2278	return 0;
2279	case Opt_max_dir_size_kb:
2280	ctx->s_max_dir_size_kb = result.uint_32;
2281	ctx->spec |= EXT4_SPEC_s_max_dir_size_kb;
2282	return 0;
2283	#ifdef CONFIG_EXT4_DEBUG
2284	case Opt_fc_debug_max_replay:
2285	ctx->s_fc_debug_max_replay = result.uint_32;
2286	ctx->spec |= EXT4_SPEC_s_fc_debug_max_replay;
2287	return 0;
2288	#endif
2289	case Opt_stripe:
2290	ctx->s_stripe = result.uint_32;
2291	ctx->spec |= EXT4_SPEC_s_stripe;
2292	return 0;
2293	case Opt_resuid:
2294	uid = make_kuid(current_user_ns(), uid: result.uint_32);
2295	if (!uid_valid(uid)) {
2296	ext4_msg(NULL, KERN_ERR, "Invalid uid value %d",
2297	result.uint_32);
2298	return -EINVAL;
2299	}
2300	ctx->s_resuid = uid;
2301	ctx->spec |= EXT4_SPEC_s_resuid;
2302	return 0;
2303	case Opt_resgid:
2304	gid = make_kgid(current_user_ns(), gid: result.uint_32);
2305	if (!gid_valid(gid)) {
2306	ext4_msg(NULL, KERN_ERR, "Invalid gid value %d",
2307	result.uint_32);
2308	return -EINVAL;
2309	}
2310	ctx->s_resgid = gid;
2311	ctx->spec |= EXT4_SPEC_s_resgid;
2312	return 0;
2313	case Opt_journal_dev:
2314	if (is_remount) {
2315	ext4_msg(NULL, KERN_ERR,
2316	"Cannot specify journal on remount");
2317	return -EINVAL;
2318	}
2319	ctx->journal_devnum = result.uint_32;
2320	ctx->spec |= EXT4_SPEC_JOURNAL_DEV;
2321	return 0;
2322	case Opt_journal_path:
2323	{
2324	struct inode *journal_inode;
2325	struct path path;
2326	int error;
2327
2328	if (is_remount) {
2329	ext4_msg(NULL, KERN_ERR,
2330	"Cannot specify journal on remount");
2331	return -EINVAL;
2332	}
2333
2334	error = fs_lookup_param(fc, param, want_bdev: 1, LOOKUP_FOLLOW, path: &path);
2335	if (error) {
2336	ext4_msg(NULL, KERN_ERR, "error: could not find "
2337	"journal device path");
2338	return -EINVAL;
2339	}
2340
2341	journal_inode = d_inode(dentry: path.dentry);
2342	ctx->journal_devnum = new_encode_dev(dev: journal_inode->i_rdev);
2343	ctx->spec |= EXT4_SPEC_JOURNAL_DEV;
2344	path_put(&path);
2345	return 0;
2346	}
2347	case Opt_journal_ioprio:
2348	if (result.uint_32 > 7) {
2349	ext4_msg(NULL, KERN_ERR, "Invalid journal IO priority"
2350	" (must be 0-7)");
2351	return -EINVAL;
2352	}
2353	ctx->journal_ioprio =
2354	IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, result.uint_32);
2355	ctx->spec |= EXT4_SPEC_JOURNAL_IOPRIO;
2356	return 0;
2357	case Opt_test_dummy_encryption:
2358	return ext4_parse_test_dummy_encryption(param, ctx);
2359	case Opt_dax:
2360	case Opt_dax_type:
2361	#ifdef CONFIG_FS_DAX
2362	{
2363	int type = (token == Opt_dax) ?
2364	Opt_dax : result.uint_32;
2365
2366	switch (type) {
2367	case Opt_dax:
2368	case Opt_dax_always:
2369	ctx_set_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS);
2370	ctx_clear_mount_opt2(ctx, EXT4_MOUNT2_DAX_NEVER);
2371	break;
2372	case Opt_dax_never:
2373	ctx_set_mount_opt2(ctx, EXT4_MOUNT2_DAX_NEVER);
2374	ctx_clear_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS);
2375	break;
2376	case Opt_dax_inode:
2377	ctx_clear_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS);
2378	ctx_clear_mount_opt2(ctx, EXT4_MOUNT2_DAX_NEVER);
2379	/* Strictly for printing options */
2380	ctx_set_mount_opt2(ctx, EXT4_MOUNT2_DAX_INODE);
2381	break;
2382	}
2383	return 0;
2384	}
2385	#else
2386	ext4_msg(NULL, KERN_INFO, "dax option not supported");
2387	return -EINVAL;
2388	#endif
2389	case Opt_data_err:
2390	if (result.uint_32 == Opt_data_err_abort)
2391	ctx_set_mount_opt(ctx, flag: m->mount_opt);
2392	else if (result.uint_32 == Opt_data_err_ignore)
2393	ctx_clear_mount_opt(ctx, flag: m->mount_opt);
2394	return 0;
2395	case Opt_mb_optimize_scan:
2396	if (result.int_32 == 1) {
2397	ctx_set_mount_opt2(ctx, EXT4_MOUNT2_MB_OPTIMIZE_SCAN);
2398	ctx->spec |= EXT4_SPEC_mb_optimize_scan;
2399	} else if (result.int_32 == 0) {
2400	ctx_clear_mount_opt2(ctx, EXT4_MOUNT2_MB_OPTIMIZE_SCAN);
2401	ctx->spec |= EXT4_SPEC_mb_optimize_scan;
2402	} else {
2403	ext4_msg(NULL, KERN_WARNING,
2404	"mb_optimize_scan should be set to 0 or 1.");
2405	return -EINVAL;
2406	}
2407	return 0;
2408	}
2409
2410	/*
2411	* At this point we should only be getting options requiring MOPT_SET,
2412	* or MOPT_CLEAR. Anything else is a bug
2413	*/
2414	if (m->token == Opt_err) {
2415	ext4_msg(NULL, KERN_WARNING, "buggy handling of option %s",
2416	param->key);
2417	WARN_ON(1);
2418	return -EINVAL;
2419	}
2420
2421	else {
2422	unsigned int set = 0;
2423
2424	if ((param->type == fs_value_is_flag) ||
2425	result.uint_32 > 0)
2426	set = 1;
2427
2428	if (m->flags & MOPT_CLEAR)
2429	set = !set;
2430	else if (unlikely(!(m->flags & MOPT_SET))) {
2431	ext4_msg(NULL, KERN_WARNING,
2432	"buggy handling of option %s",
2433	param->key);
2434	WARN_ON(1);
2435	return -EINVAL;
2436	}
2437	if (m->flags & MOPT_2) {
2438	if (set != 0)
2439	ctx_set_mount_opt2(ctx, flag: m->mount_opt);
2440	else
2441	ctx_clear_mount_opt2(ctx, flag: m->mount_opt);
2442	} else {
2443	if (set != 0)
2444	ctx_set_mount_opt(ctx, flag: m->mount_opt);
2445	else
2446	ctx_clear_mount_opt(ctx, flag: m->mount_opt);
2447	}
2448	}
2449
2450	return 0;
2451	}
2452
2453	static int parse_options(struct fs_context *fc, char *options)
2454	{
2455	struct fs_parameter param;
2456	int ret;
2457	char *key;
2458
2459	if (!options)
2460	return 0;
2461
2462	while ((key = strsep(&options, ",")) != NULL) {
2463	if (*key) {
2464	size_t v_len = 0;
2465	char *value = strchr(key, '=');
2466
2467	param.type = fs_value_is_flag;
2468	param.string = NULL;
2469
2470	if (value) {
2471	if (value == key)
2472	continue;
2473
2474	*value++ = 0;
2475	v_len = strlen(value);
2476	param.string = kmemdup_nul(s: value, len: v_len,
2477	GFP_KERNEL);
2478	if (!param.string)
2479	return -ENOMEM;
2480	param.type = fs_value_is_string;
2481	}
2482
2483	param.key = key;
2484	param.size = v_len;
2485
2486	ret = ext4_parse_param(fc, param: &param);
2487	if (param.string)
2488	kfree(objp: param.string);
2489	if (ret < 0)
2490	return ret;
2491	}
2492	}
2493
2494	ret = ext4_validate_options(fc);
2495	if (ret < 0)
2496	return ret;
2497
2498	return 0;
2499	}
2500
2501	static int parse_apply_sb_mount_options(struct super_block *sb,
2502	struct ext4_fs_context *m_ctx)
2503	{
2504	struct ext4_sb_info *sbi = EXT4_SB(sb);
2505	char *s_mount_opts = NULL;
2506	struct ext4_fs_context *s_ctx = NULL;
2507	struct fs_context *fc = NULL;
2508	int ret = -ENOMEM;
2509
2510	if (!sbi->s_es->s_mount_opts[0])
2511	return 0;
2512
2513	s_mount_opts = kstrndup(s: sbi->s_es->s_mount_opts,
2514	len: sizeof(sbi->s_es->s_mount_opts),
2515	GFP_KERNEL);
2516	if (!s_mount_opts)
2517	return ret;
2518
2519	fc = kzalloc(size: sizeof(struct fs_context), GFP_KERNEL);
2520	if (!fc)
2521	goto out_free;
2522
2523	s_ctx = kzalloc(size: sizeof(struct ext4_fs_context), GFP_KERNEL);
2524	if (!s_ctx)
2525	goto out_free;
2526
2527	fc->fs_private = s_ctx;
2528	fc->s_fs_info = sbi;
2529
2530	ret = parse_options(fc, options: s_mount_opts);
2531	if (ret < 0)
2532	goto parse_failed;
2533
2534	ret = ext4_check_opt_consistency(fc, sb);
2535	if (ret < 0) {
2536	parse_failed:
2537	ext4_msg(sb, KERN_WARNING,
2538	"failed to parse options in superblock: %s",
2539	s_mount_opts);
2540	ret = 0;
2541	goto out_free;
2542	}
2543
2544	if (s_ctx->spec & EXT4_SPEC_JOURNAL_DEV)
2545	m_ctx->journal_devnum = s_ctx->journal_devnum;
2546	if (s_ctx->spec & EXT4_SPEC_JOURNAL_IOPRIO)
2547	m_ctx->journal_ioprio = s_ctx->journal_ioprio;
2548
2549	ext4_apply_options(fc, sb);
2550	ret = 0;
2551
2552	out_free:
2553	if (fc) {
2554	ext4_fc_free(fc);
2555	kfree(objp: fc);
2556	}
2557	kfree(objp: s_mount_opts);
2558	return ret;
2559	}
2560
2561	static void ext4_apply_quota_options(struct fs_context *fc,
2562	struct super_block *sb)
2563	{
2564	#ifdef CONFIG_QUOTA
2565	bool quota_feature = ext4_has_feature_quota(sb);
2566	struct ext4_fs_context *ctx = fc->fs_private;
2567	struct ext4_sb_info *sbi = EXT4_SB(sb);
2568	char *qname;
2569	int i;
2570
2571	if (quota_feature)
2572	return;
2573
2574	if (ctx->spec & EXT4_SPEC_JQUOTA) {
2575	for (i = 0; i < EXT4_MAXQUOTAS; i++) {
2576	if (!(ctx->qname_spec & (1 << i)))
2577	continue;
2578
2579	qname = ctx->s_qf_names[i]; /* May be NULL */
2580	if (qname)
2581	set_opt(sb, QUOTA);
2582	ctx->s_qf_names[i] = NULL;
2583	qname = rcu_replace_pointer(sbi->s_qf_names[i], qname,
2584	lockdep_is_held(&sb->s_umount));
2585	if (qname)
2586	kfree_rcu_mightsleep(qname);
2587	}
2588	}
2589
2590	if (ctx->spec & EXT4_SPEC_JQFMT)
2591	sbi->s_jquota_fmt = ctx->s_jquota_fmt;
2592	#endif
2593	}
2594
2595	/*
2596	* Check quota settings consistency.
2597	*/
2598	static int ext4_check_quota_consistency(struct fs_context *fc,
2599	struct super_block *sb)
2600	{
2601	#ifdef CONFIG_QUOTA
2602	struct ext4_fs_context *ctx = fc->fs_private;
2603	struct ext4_sb_info *sbi = EXT4_SB(sb);
2604	bool quota_feature = ext4_has_feature_quota(sb);
2605	bool quota_loaded = sb_any_quota_loaded(sb);
2606	bool usr_qf_name, grp_qf_name, usrquota, grpquota;
2607	int quota_flags, i;
2608
2609	/*
2610	* We do the test below only for project quotas. 'usrquota' and
2611	* 'grpquota' mount options are allowed even without quota feature
2612	* to support legacy quotas in quota files.
2613	*/
2614	if (ctx_test_mount_opt(ctx, EXT4_MOUNT_PRJQUOTA) &&
2615	!ext4_has_feature_project(sb)) {
2616	ext4_msg(NULL, KERN_ERR, "Project quota feature not enabled. "
2617	"Cannot enable project quota enforcement.");
2618	return -EINVAL;
2619	}
2620
2621	quota_flags = EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA |
2622	EXT4_MOUNT_GRPQUOTA | EXT4_MOUNT_PRJQUOTA;
2623	if (quota_loaded &&
2624	ctx->mask_s_mount_opt & quota_flags &&
2625	!ctx_test_mount_opt(ctx, flag: quota_flags))
2626	goto err_quota_change;
2627
2628	if (ctx->spec & EXT4_SPEC_JQUOTA) {
2629
2630	for (i = 0; i < EXT4_MAXQUOTAS; i++) {
2631	if (!(ctx->qname_spec & (1 << i)))
2632	continue;
2633
2634	if (quota_loaded &&
2635	!!sbi->s_qf_names[i] != !!ctx->s_qf_names[i])
2636	goto err_jquota_change;
2637
2638	if (sbi->s_qf_names[i] && ctx->s_qf_names[i] &&
2639	strcmp(get_qf_name(sb, sbi, type: i),
2640	ctx->s_qf_names[i]) != 0)
2641	goto err_jquota_specified;
2642	}
2643
2644	if (quota_feature) {
2645	ext4_msg(NULL, KERN_INFO,
2646	"Journaled quota options ignored when "
2647	"QUOTA feature is enabled");
2648	return 0;
2649	}
2650	}
2651
2652	if (ctx->spec & EXT4_SPEC_JQFMT) {
2653	if (sbi->s_jquota_fmt != ctx->s_jquota_fmt && quota_loaded)
2654	goto err_jquota_change;
2655	if (quota_feature) {
2656	ext4_msg(NULL, KERN_INFO, "Quota format mount options "
2657	"ignored when QUOTA feature is enabled");
2658	return 0;
2659	}
2660	}
2661
2662	/* Make sure we don't mix old and new quota format */
2663	usr_qf_name = (get_qf_name(sb, sbi, type: USRQUOTA) ||
2664	ctx->s_qf_names[USRQUOTA]);
2665	grp_qf_name = (get_qf_name(sb, sbi, type: GRPQUOTA) ||
2666	ctx->s_qf_names[GRPQUOTA]);
2667
2668	usrquota = (ctx_test_mount_opt(ctx, EXT4_MOUNT_USRQUOTA) ||
2669	test_opt(sb, USRQUOTA));
2670
2671	grpquota = (ctx_test_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA) ||
2672	test_opt(sb, GRPQUOTA));
2673
2674	if (usr_qf_name) {
2675	ctx_clear_mount_opt(ctx, EXT4_MOUNT_USRQUOTA);
2676	usrquota = false;
2677	}
2678	if (grp_qf_name) {
2679	ctx_clear_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA);
2680	grpquota = false;
2681	}
2682
2683	if (usr_qf_name || grp_qf_name) {
2684	if (usrquota || grpquota) {
2685	ext4_msg(NULL, KERN_ERR, "old and new quota "
2686	"format mixing");
2687	return -EINVAL;
2688	}
2689
2690	if (!(ctx->spec & EXT4_SPEC_JQFMT || sbi->s_jquota_fmt)) {
2691	ext4_msg(NULL, KERN_ERR, "journaled quota format "
2692	"not specified");
2693	return -EINVAL;
2694	}
2695	}
2696
2697	return 0;
2698
2699	err_quota_change:
2700	ext4_msg(NULL, KERN_ERR,
2701	"Cannot change quota options when quota turned on");
2702	return -EINVAL;
2703	err_jquota_change:
2704	ext4_msg(NULL, KERN_ERR, "Cannot change journaled quota "
2705	"options when quota turned on");
2706	return -EINVAL;
2707	err_jquota_specified:
2708	ext4_msg(NULL, KERN_ERR, "%s quota file already specified",
2709	QTYPE2NAME(i));
2710	return -EINVAL;
2711	#else
2712	return 0;
2713	#endif
2714	}
2715
2716	static int ext4_check_test_dummy_encryption(const struct fs_context *fc,
2717	struct super_block *sb)
2718	{
2719	const struct ext4_fs_context *ctx = fc->fs_private;
2720	const struct ext4_sb_info *sbi = EXT4_SB(sb);
2721
2722	if (!fscrypt_is_dummy_policy_set(dummy_policy: &ctx->dummy_enc_policy))
2723	return 0;
2724
2725	if (!ext4_has_feature_encrypt(sb)) {
2726	ext4_msg(NULL, KERN_WARNING,
2727	"test_dummy_encryption requires encrypt feature");
2728	return -EINVAL;
2729	}
2730	/*
2731	* This mount option is just for testing, and it's not worthwhile to
2732	* implement the extra complexity (e.g. RCU protection) that would be
2733	* needed to allow it to be set or changed during remount. We do allow
2734	* it to be specified during remount, but only if there is no change.
2735	*/
2736	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
2737	if (fscrypt_dummy_policies_equal(p1: &sbi->s_dummy_enc_policy,
2738	p2: &ctx->dummy_enc_policy))
2739	return 0;
2740	ext4_msg(NULL, KERN_WARNING,
2741	"Can't set or change test_dummy_encryption on remount");
2742	return -EINVAL;
2743	}
2744	/* Also make sure s_mount_opts didn't contain a conflicting value. */
2745	if (fscrypt_is_dummy_policy_set(dummy_policy: &sbi->s_dummy_enc_policy)) {
2746	if (fscrypt_dummy_policies_equal(p1: &sbi->s_dummy_enc_policy,
2747	p2: &ctx->dummy_enc_policy))
2748	return 0;
2749	ext4_msg(NULL, KERN_WARNING,
2750	"Conflicting test_dummy_encryption options");
2751	return -EINVAL;
2752	}
2753	return 0;
2754	}
2755
2756	static void ext4_apply_test_dummy_encryption(struct ext4_fs_context *ctx,
2757	struct super_block *sb)
2758	{
2759	if (!fscrypt_is_dummy_policy_set(dummy_policy: &ctx->dummy_enc_policy) ||
2760	/* if already set, it was already verified to be the same */
2761	fscrypt_is_dummy_policy_set(dummy_policy: &EXT4_SB(sb)->s_dummy_enc_policy))
2762	return;
2763	EXT4_SB(sb)->s_dummy_enc_policy = ctx->dummy_enc_policy;
2764	memset(&ctx->dummy_enc_policy, 0, sizeof(ctx->dummy_enc_policy));
2765	ext4_msg(sb, KERN_WARNING, "Test dummy encryption mode enabled");
2766	}
2767
2768	static int ext4_check_opt_consistency(struct fs_context *fc,
2769	struct super_block *sb)
2770	{
2771	struct ext4_fs_context *ctx = fc->fs_private;
2772	struct ext4_sb_info *sbi = fc->s_fs_info;
2773	int is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
2774	int err;
2775
2776	if ((ctx->opt_flags & MOPT_NO_EXT2) && IS_EXT2_SB(sb)) {
2777	ext4_msg(NULL, KERN_ERR,
2778	"Mount option(s) incompatible with ext2");
2779	return -EINVAL;
2780	}
2781	if ((ctx->opt_flags & MOPT_NO_EXT3) && IS_EXT3_SB(sb)) {
2782	ext4_msg(NULL, KERN_ERR,
2783	"Mount option(s) incompatible with ext3");
2784	return -EINVAL;
2785	}
2786
2787	if (ctx->s_want_extra_isize >
2788	(sbi->s_inode_size - EXT4_GOOD_OLD_INODE_SIZE)) {
2789	ext4_msg(NULL, KERN_ERR,
2790	"Invalid want_extra_isize %d",
2791	ctx->s_want_extra_isize);
2792	return -EINVAL;
2793	}
2794
2795	err = ext4_check_test_dummy_encryption(fc, sb);
2796	if (err)
2797	return err;
2798
2799	if ((ctx->spec & EXT4_SPEC_DATAJ) && is_remount) {
2800	if (!sbi->s_journal) {
2801	ext4_msg(NULL, KERN_WARNING,
2802	"Remounting file system with no journal "
2803	"so ignoring journalled data option");
2804	ctx_clear_mount_opt(ctx, EXT4_MOUNT_DATA_FLAGS);
2805	} else if (ctx_test_mount_opt(ctx, EXT4_MOUNT_DATA_FLAGS) !=
2806	test_opt(sb, DATA_FLAGS)) {
2807	ext4_msg(NULL, KERN_ERR, "Cannot change data mode "
2808	"on remount");
2809	return -EINVAL;
2810	}
2811	}
2812
2813	if (is_remount) {
2814	if (ctx_test_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS) &&
2815	(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)) {
2816	ext4_msg(NULL, KERN_ERR, "can't mount with "
2817	"both data=journal and dax");
2818	return -EINVAL;
2819	}
2820
2821	if (ctx_test_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS) &&
2822	(!(sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) ||
2823	(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER))) {
2824	fail_dax_change_remount:
2825	ext4_msg(NULL, KERN_ERR, "can't change "
2826	"dax mount option while remounting");
2827	return -EINVAL;
2828	} else if (ctx_test_mount_opt2(ctx, EXT4_MOUNT2_DAX_NEVER) &&
2829	(!(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) ||
2830	(sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS))) {
2831	goto fail_dax_change_remount;
2832	} else if (ctx_test_mount_opt2(ctx, EXT4_MOUNT2_DAX_INODE) &&
2833	((sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) ||
2834	(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) ||
2835	!(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_INODE))) {
2836	goto fail_dax_change_remount;
2837	}
2838	}
2839
2840	return ext4_check_quota_consistency(fc, sb);
2841	}
2842
2843	static void ext4_apply_options(struct fs_context *fc, struct super_block *sb)
2844	{
2845	struct ext4_fs_context *ctx = fc->fs_private;
2846	struct ext4_sb_info *sbi = fc->s_fs_info;
2847
2848	sbi->s_mount_opt &= ~ctx->mask_s_mount_opt;
2849	sbi->s_mount_opt |= ctx->vals_s_mount_opt;
2850	sbi->s_mount_opt2 &= ~ctx->mask_s_mount_opt2;
2851	sbi->s_mount_opt2 |= ctx->vals_s_mount_opt2;
2852	sb->s_flags &= ~ctx->mask_s_flags;
2853	sb->s_flags |= ctx->vals_s_flags;
2854
2855	#define APPLY(X) ({ if (ctx->spec & EXT4_SPEC_##X) sbi->X = ctx->X; })
2856	APPLY(s_commit_interval);
2857	APPLY(s_stripe);
2858	APPLY(s_max_batch_time);
2859	APPLY(s_min_batch_time);
2860	APPLY(s_want_extra_isize);
2861	APPLY(s_inode_readahead_blks);
2862	APPLY(s_max_dir_size_kb);
2863	APPLY(s_li_wait_mult);
2864	APPLY(s_resgid);
2865	APPLY(s_resuid);
2866
2867	#ifdef CONFIG_EXT4_DEBUG
2868	APPLY(s_fc_debug_max_replay);
2869	#endif
2870
2871	ext4_apply_quota_options(fc, sb);
2872	ext4_apply_test_dummy_encryption(ctx, sb);
2873	}
2874
2875
2876	static int ext4_validate_options(struct fs_context *fc)
2877	{
2878	#ifdef CONFIG_QUOTA
2879	struct ext4_fs_context *ctx = fc->fs_private;
2880	char *usr_qf_name, *grp_qf_name;
2881
2882	usr_qf_name = ctx->s_qf_names[USRQUOTA];
2883	grp_qf_name = ctx->s_qf_names[GRPQUOTA];
2884
2885	if (usr_qf_name || grp_qf_name) {
2886	if (ctx_test_mount_opt(ctx, EXT4_MOUNT_USRQUOTA) && usr_qf_name)
2887	ctx_clear_mount_opt(ctx, EXT4_MOUNT_USRQUOTA);
2888
2889	if (ctx_test_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA) && grp_qf_name)
2890	ctx_clear_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA);
2891
2892	if (ctx_test_mount_opt(ctx, EXT4_MOUNT_USRQUOTA) ||
2893	ctx_test_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA)) {
2894	ext4_msg(NULL, KERN_ERR, "old and new quota "
2895	"format mixing");
2896	return -EINVAL;
2897	}
2898	}
2899	#endif
2900	return 1;
2901	}
2902
2903	static inline void ext4_show_quota_options(struct seq_file *seq,
2904	struct super_block *sb)
2905	{
2906	#if defined(CONFIG_QUOTA)
2907	struct ext4_sb_info *sbi = EXT4_SB(sb);
2908	char *usr_qf_name, *grp_qf_name;
2909
2910	if (sbi->s_jquota_fmt) {
2911	char *fmtname = "";
2912
2913	switch (sbi->s_jquota_fmt) {
2914	case QFMT_VFS_OLD:
2915	fmtname = "vfsold";
2916	break;
2917	case QFMT_VFS_V0:
2918	fmtname = "vfsv0";
2919	break;
2920	case QFMT_VFS_V1:
2921	fmtname = "vfsv1";
2922	break;
2923	}
2924	seq_printf(m: seq, fmt: ",jqfmt=%s", fmtname);
2925	}
2926
2927	rcu_read_lock();
2928	usr_qf_name = rcu_dereference(sbi->s_qf_names[USRQUOTA]);
2929	grp_qf_name = rcu_dereference(sbi->s_qf_names[GRPQUOTA]);
2930	if (usr_qf_name)
2931	seq_show_option(m: seq, name: "usrjquota", value: usr_qf_name);
2932	if (grp_qf_name)
2933	seq_show_option(m: seq, name: "grpjquota", value: grp_qf_name);
2934	rcu_read_unlock();
2935	#endif
2936	}
2937
2938	static const char *token2str(int token)
2939	{
2940	const struct fs_parameter_spec *spec;
2941
2942	for (spec = ext4_param_specs; spec->name != NULL; spec++)
2943	if (spec->opt == token && !spec->type)
2944	break;
2945	return spec->name;
2946	}
2947
2948	/*
2949	* Show an option if
2950	* - it's set to a non-default value OR
2951	* - if the per-sb default is different from the global default
2952	*/
2953	static int _ext4_show_options(struct seq_file *seq, struct super_block *sb,
2954	int nodefs)
2955	{
2956	struct ext4_sb_info *sbi = EXT4_SB(sb);
2957	struct ext4_super_block *es = sbi->s_es;
2958	int def_errors;
2959	const struct mount_opts *m;
2960	char sep = nodefs ? '\n' : ',';
2961
2962	#define SEQ_OPTS_PUTS(str) seq_printf(seq, "%c" str, sep)
2963	#define SEQ_OPTS_PRINT(str, arg) seq_printf(seq, "%c" str, sep, arg)
2964
2965	if (sbi->s_sb_block != 1)
2966	SEQ_OPTS_PRINT("sb=%llu", sbi->s_sb_block);
2967
2968	for (m = ext4_mount_opts; m->token != Opt_err; m++) {
2969	int want_set = m->flags & MOPT_SET;
2970	int opt_2 = m->flags & MOPT_2;
2971	unsigned int mount_opt, def_mount_opt;
2972
2973	if (((m->flags & (MOPT_SET|MOPT_CLEAR)) == 0) ||
2974	m->flags & MOPT_SKIP)
2975	continue;
2976
2977	if (opt_2) {
2978	mount_opt = sbi->s_mount_opt2;
2979	def_mount_opt = sbi->s_def_mount_opt2;
2980	} else {
2981	mount_opt = sbi->s_mount_opt;
2982	def_mount_opt = sbi->s_def_mount_opt;
2983	}
2984	/* skip if same as the default */
2985	if (!nodefs && !(m->mount_opt & (mount_opt ^ def_mount_opt)))
2986	continue;
2987	/* select Opt_noFoo vs Opt_Foo */
2988	if ((want_set &&
2989	(mount_opt & m->mount_opt) != m->mount_opt) ||
2990	(!want_set && (mount_opt & m->mount_opt)))
2991	continue;
2992	SEQ_OPTS_PRINT("%s", token2str(m->token));
2993	}
2994
2995	if (nodefs || !uid_eq(left: sbi->s_resuid, right: make_kuid(from: &init_user_ns, EXT4_DEF_RESUID)) ||
2996	le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID)
2997	SEQ_OPTS_PRINT("resuid=%u",
2998	from_kuid_munged(&init_user_ns, sbi->s_resuid));
2999	if (nodefs || !gid_eq(left: sbi->s_resgid, right: make_kgid(from: &init_user_ns, EXT4_DEF_RESGID)) ||
3000	le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID)
3001	SEQ_OPTS_PRINT("resgid=%u",
3002	from_kgid_munged(&init_user_ns, sbi->s_resgid));
3003	def_errors = nodefs ? -1 : le16_to_cpu(es->s_errors);
3004	if (test_opt(sb, ERRORS_RO) && def_errors != EXT4_ERRORS_RO)
3005	SEQ_OPTS_PUTS("errors=remount-ro");
3006	if (test_opt(sb, ERRORS_CONT) && def_errors != EXT4_ERRORS_CONTINUE)
3007	SEQ_OPTS_PUTS("errors=continue");
3008	if (test_opt(sb, ERRORS_PANIC) && def_errors != EXT4_ERRORS_PANIC)
3009	SEQ_OPTS_PUTS("errors=panic");
3010	if (nodefs || sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ)
3011	SEQ_OPTS_PRINT("commit=%lu", sbi->s_commit_interval / HZ);
3012	if (nodefs || sbi->s_min_batch_time != EXT4_DEF_MIN_BATCH_TIME)
3013	SEQ_OPTS_PRINT("min_batch_time=%u", sbi->s_min_batch_time);
3014	if (nodefs || sbi->s_max_batch_time != EXT4_DEF_MAX_BATCH_TIME)
3015	SEQ_OPTS_PRINT("max_batch_time=%u", sbi->s_max_batch_time);
3016	if (nodefs || sbi->s_stripe)
3017	SEQ_OPTS_PRINT("stripe=%lu", sbi->s_stripe);
3018	if (nodefs || EXT4_MOUNT_DATA_FLAGS &
3019	(sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
3020	if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
3021	SEQ_OPTS_PUTS("data=journal");
3022	else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
3023	SEQ_OPTS_PUTS("data=ordered");
3024	else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
3025	SEQ_OPTS_PUTS("data=writeback");
3026	}
3027	if (nodefs ||
3028	sbi->s_inode_readahead_blks != EXT4_DEF_INODE_READAHEAD_BLKS)
3029	SEQ_OPTS_PRINT("inode_readahead_blks=%u",
3030	sbi->s_inode_readahead_blks);
3031
3032	if (test_opt(sb, INIT_INODE_TABLE) && (nodefs ||
3033	(sbi->s_li_wait_mult != EXT4_DEF_LI_WAIT_MULT)))
3034	SEQ_OPTS_PRINT("init_itable=%u", sbi->s_li_wait_mult);
3035	if (nodefs || sbi->s_max_dir_size_kb)
3036	SEQ_OPTS_PRINT("max_dir_size_kb=%u", sbi->s_max_dir_size_kb);
3037	if (test_opt(sb, DATA_ERR_ABORT))
3038	SEQ_OPTS_PUTS("data_err=abort");
3039
3040	fscrypt_show_test_dummy_encryption(seq, sep, sb);
3041
3042	if (sb->s_flags & SB_INLINECRYPT)
3043	SEQ_OPTS_PUTS("inlinecrypt");
3044
3045	if (test_opt(sb, DAX_ALWAYS)) {
3046	if (IS_EXT2_SB(sb))
3047	SEQ_OPTS_PUTS("dax");
3048	else
3049	SEQ_OPTS_PUTS("dax=always");
3050	} else if (test_opt2(sb, DAX_NEVER)) {
3051	SEQ_OPTS_PUTS("dax=never");
3052	} else if (test_opt2(sb, DAX_INODE)) {
3053	SEQ_OPTS_PUTS("dax=inode");
3054	}
3055
3056	if (sbi->s_groups_count >= MB_DEFAULT_LINEAR_SCAN_THRESHOLD &&
3057	!test_opt2(sb, MB_OPTIMIZE_SCAN)) {
3058	SEQ_OPTS_PUTS("mb_optimize_scan=0");
3059	} else if (sbi->s_groups_count < MB_DEFAULT_LINEAR_SCAN_THRESHOLD &&
3060	test_opt2(sb, MB_OPTIMIZE_SCAN)) {
3061	SEQ_OPTS_PUTS("mb_optimize_scan=1");
3062	}
3063
3064	ext4_show_quota_options(seq, sb);
3065	return 0;
3066	}
3067
3068	static int ext4_show_options(struct seq_file *seq, struct dentry *root)
3069	{
3070	return _ext4_show_options(seq, sb: root->d_sb, nodefs: 0);
3071	}
3072
3073	int ext4_seq_options_show(struct seq_file *seq, void *offset)
3074	{
3075	struct super_block *sb = seq->private;
3076	int rc;
3077
3078	seq_puts(m: seq, s: sb_rdonly(sb) ? "ro" : "rw");
3079	rc = _ext4_show_options(seq, sb, nodefs: 1);
3080	seq_puts(m: seq, s: "\n");
3081	return rc;
3082	}
3083
3084	static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
3085	int read_only)
3086	{
3087	struct ext4_sb_info *sbi = EXT4_SB(sb);
3088	int err = 0;
3089
3090	if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
3091	ext4_msg(sb, KERN_ERR, "revision level too high, "
3092	"forcing read-only mode");
3093	err = -EROFS;
3094	goto done;
3095	}
3096	if (read_only)
3097	goto done;
3098	if (!(sbi->s_mount_state & EXT4_VALID_FS))
3099	ext4_msg(sb, KERN_WARNING, "warning: mounting unchecked fs, "
3100	"running e2fsck is recommended");
3101	else if (sbi->s_mount_state & EXT4_ERROR_FS)
3102	ext4_msg(sb, KERN_WARNING,
3103	"warning: mounting fs with errors, "
3104	"running e2fsck is recommended");
3105	else if ((__s16) le16_to_cpu(es->s_max_mnt_count) > 0 &&
3106	le16_to_cpu(es->s_mnt_count) >=
3107	(unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
3108	ext4_msg(sb, KERN_WARNING,
3109	"warning: maximal mount count reached, "
3110	"running e2fsck is recommended");
3111	else if (le32_to_cpu(es->s_checkinterval) &&
3112	(ext4_get_tstamp(es, s_lastcheck) +
3113	le32_to_cpu(es->s_checkinterval) <= ktime_get_real_seconds()))
3114	ext4_msg(sb, KERN_WARNING,
3115	"warning: checktime reached, "
3116	"running e2fsck is recommended");
3117	if (!sbi->s_journal)
3118	es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
3119	if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
3120	es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
3121	le16_add_cpu(var: &es->s_mnt_count, val: 1);
3122	ext4_update_tstamp(es, s_mtime);
3123	if (sbi->s_journal) {
3124	ext4_set_feature_journal_needs_recovery(sb);
3125	if (ext4_has_feature_orphan_file(sb))
3126	ext4_set_feature_orphan_present(sb);
3127	}
3128
3129	err = ext4_commit_super(sb);
3130	done:
3131	if (test_opt(sb, DEBUG))
3132	printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, "
3133	"bpg=%lu, ipg=%lu, mo=%04x, mo2=%04x]\n",
3134	sb->s_blocksize,
3135	sbi->s_groups_count,
3136	EXT4_BLOCKS_PER_GROUP(sb),
3137	EXT4_INODES_PER_GROUP(sb),
3138	sbi->s_mount_opt, sbi->s_mount_opt2);
3139	return err;
3140	}
3141
3142	int ext4_alloc_flex_bg_array(struct super_block *sb, ext4_group_t ngroup)
3143	{
3144	struct ext4_sb_info *sbi = EXT4_SB(sb);
3145	struct flex_groups **old_groups, **new_groups;
3146	int size, i, j;
3147
3148	if (!sbi->s_log_groups_per_flex)
3149	return 0;
3150
3151	size = ext4_flex_group(sbi, block_group: ngroup - 1) + 1;
3152	if (size <= sbi->s_flex_groups_allocated)
3153	return 0;
3154
3155	new_groups = kvzalloc(roundup_pow_of_two(size *
3156	sizeof(*sbi->s_flex_groups)), GFP_KERNEL);
3157	if (!new_groups) {
3158	ext4_msg(sb, KERN_ERR,
3159	"not enough memory for %d flex group pointers", size);
3160	return -ENOMEM;
3161	}
3162	for (i = sbi->s_flex_groups_allocated; i < size; i++) {
3163	new_groups[i] = kvzalloc(roundup_pow_of_two(
3164	sizeof(struct flex_groups)),
3165	GFP_KERNEL);
3166	if (!new_groups[i]) {
3167	for (j = sbi->s_flex_groups_allocated; j < i; j++)
3168	kvfree(addr: new_groups[j]);
3169	kvfree(addr: new_groups);
3170	ext4_msg(sb, KERN_ERR,
3171	"not enough memory for %d flex groups", size);
3172	return -ENOMEM;
3173	}
3174	}
3175	rcu_read_lock();
3176	old_groups = rcu_dereference(sbi->s_flex_groups);
3177	if (old_groups)
3178	memcpy(new_groups, old_groups,
3179	(sbi->s_flex_groups_allocated *
3180	sizeof(struct flex_groups *)));
3181	rcu_read_unlock();
3182	rcu_assign_pointer(sbi->s_flex_groups, new_groups);
3183	sbi->s_flex_groups_allocated = size;
3184	if (old_groups)
3185	ext4_kvfree_array_rcu(to_free: old_groups);
3186	return 0;
3187	}
3188
3189	static int ext4_fill_flex_info(struct super_block *sb)
3190	{
3191	struct ext4_sb_info *sbi = EXT4_SB(sb);
3192	struct ext4_group_desc *gdp = NULL;
3193	struct flex_groups *fg;
3194	ext4_group_t flex_group;
3195	int i, err;
3196
3197	sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
3198	if (sbi->s_log_groups_per_flex < 1 || sbi->s_log_groups_per_flex > 31) {
3199	sbi->s_log_groups_per_flex = 0;
3200	return 1;
3201	}
3202
3203	err = ext4_alloc_flex_bg_array(sb, ngroup: sbi->s_groups_count);
3204	if (err)
3205	goto failed;
3206
3207	for (i = 0; i < sbi->s_groups_count; i++) {
3208	gdp = ext4_get_group_desc(sb, block_group: i, NULL);
3209
3210	flex_group = ext4_flex_group(sbi, block_group: i);
3211	fg = sbi_array_rcu_deref(sbi, s_flex_groups, flex_group);
3212	atomic_add(i: ext4_free_inodes_count(sb, bg: gdp), v: &fg->free_inodes);
3213	atomic64_add(i: ext4_free_group_clusters(sb, bg: gdp),
3214	v: &fg->free_clusters);
3215	atomic_add(i: ext4_used_dirs_count(sb, bg: gdp), v: &fg->used_dirs);
3216	}
3217
3218	return 1;
3219	failed:
3220	return 0;
3221	}
3222
3223	static __le16 ext4_group_desc_csum(struct super_block *sb, __u32 block_group,
3224	struct ext4_group_desc *gdp)
3225	{
3226	int offset = offsetof(struct ext4_group_desc, bg_checksum);
3227	__u16 crc = 0;
3228	__le32 le_group = cpu_to_le32(block_group);
3229	struct ext4_sb_info *sbi = EXT4_SB(sb);
3230
3231	if (ext4_has_metadata_csum(sb: sbi->s_sb)) {
3232	/* Use new metadata_csum algorithm */
3233	__u32 csum32;
3234	__u16 dummy_csum = 0;
3235
3236	csum32 = ext4_chksum(sbi, crc: sbi->s_csum_seed, address: (__u8 *)&le_group,
3237	length: sizeof(le_group));
3238	csum32 = ext4_chksum(sbi, crc: csum32, address: (__u8 *)gdp, length: offset);
3239	csum32 = ext4_chksum(sbi, crc: csum32, address: (__u8 *)&dummy_csum,
3240	length: sizeof(dummy_csum));
3241	offset += sizeof(dummy_csum);
3242	if (offset < sbi->s_desc_size)
3243	csum32 = ext4_chksum(sbi, crc: csum32, address: (__u8 *)gdp + offset,
3244	length: sbi->s_desc_size - offset);
3245
3246	crc = csum32 & 0xFFFF;
3247	goto out;
3248	}
3249
3250	/* old crc16 code */
3251	if (!ext4_has_feature_gdt_csum(sb))
3252	return 0;
3253
3254	crc = crc16(crc: ~0, buffer: sbi->s_es->s_uuid, len: sizeof(sbi->s_es->s_uuid));
3255	crc = crc16(crc, buffer: (__u8 *)&le_group, len: sizeof(le_group));
3256	crc = crc16(crc, buffer: (__u8 *)gdp, len: offset);
3257	offset += sizeof(gdp->bg_checksum); /* skip checksum */
3258	/* for checksum of struct ext4_group_desc do the rest...*/
3259	if (ext4_has_feature_64bit(sb) && offset < sbi->s_desc_size)
3260	crc = crc16(crc, buffer: (__u8 *)gdp + offset,
3261	len: sbi->s_desc_size - offset);
3262
3263	out:
3264	return cpu_to_le16(crc);
3265	}
3266
3267	int ext4_group_desc_csum_verify(struct super_block *sb, __u32 block_group,
3268	struct ext4_group_desc *gdp)
3269	{
3270	if (ext4_has_group_desc_csum(sb) &&
3271	(gdp->bg_checksum != ext4_group_desc_csum(sb, block_group, gdp)))
3272	return 0;
3273
3274	return 1;
3275	}
3276
3277	void ext4_group_desc_csum_set(struct super_block *sb, __u32 block_group,
3278	struct ext4_group_desc *gdp)
3279	{
3280	if (!ext4_has_group_desc_csum(sb))
3281	return;
3282	gdp->bg_checksum = ext4_group_desc_csum(sb, block_group, gdp);
3283	}
3284
3285	/* Called at mount-time, super-block is locked */
3286	static int ext4_check_descriptors(struct super_block *sb,
3287	ext4_fsblk_t sb_block,
3288	ext4_group_t *first_not_zeroed)
3289	{
3290	struct ext4_sb_info *sbi = EXT4_SB(sb);
3291	ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
3292	ext4_fsblk_t last_block;
3293	ext4_fsblk_t last_bg_block = sb_block + ext4_bg_num_gdb(sb, group: 0);
3294	ext4_fsblk_t block_bitmap;
3295	ext4_fsblk_t inode_bitmap;
3296	ext4_fsblk_t inode_table;
3297	int flexbg_flag = 0;
3298	ext4_group_t i, grp = sbi->s_groups_count;
3299
3300	if (ext4_has_feature_flex_bg(sb))
3301	flexbg_flag = 1;
3302
3303	ext4_debug("Checking group descriptors");
3304
3305	for (i = 0; i < sbi->s_groups_count; i++) {
3306	struct ext4_group_desc *gdp = ext4_get_group_desc(sb, block_group: i, NULL);
3307
3308	if (i == sbi->s_groups_count - 1 || flexbg_flag)
3309	last_block = ext4_blocks_count(es: sbi->s_es) - 1;
3310	else
3311	last_block = first_block +
3312	(EXT4_BLOCKS_PER_GROUP(sb) - 1);
3313
3314	if ((grp == sbi->s_groups_count) &&
3315	!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3316	grp = i;
3317
3318	block_bitmap = ext4_block_bitmap(sb, bg: gdp);
3319	if (block_bitmap == sb_block) {
3320	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3321	"Block bitmap for group %u overlaps "
3322	"superblock", i);
3323	if (!sb_rdonly(sb))
3324	return 0;
3325	}
3326	if (block_bitmap >= sb_block + 1 &&
3327	block_bitmap <= last_bg_block) {
3328	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3329	"Block bitmap for group %u overlaps "
3330	"block group descriptors", i);
3331	if (!sb_rdonly(sb))
3332	return 0;
3333	}
3334	if (block_bitmap < first_block || block_bitmap > last_block) {
3335	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3336	"Block bitmap for group %u not in group "
3337	"(block %llu)!", i, block_bitmap);
3338	return 0;
3339	}
3340	inode_bitmap = ext4_inode_bitmap(sb, bg: gdp);
3341	if (inode_bitmap == sb_block) {
3342	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3343	"Inode bitmap for group %u overlaps "
3344	"superblock", i);
3345	if (!sb_rdonly(sb))
3346	return 0;
3347	}
3348	if (inode_bitmap >= sb_block + 1 &&
3349	inode_bitmap <= last_bg_block) {
3350	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3351	"Inode bitmap for group %u overlaps "
3352	"block group descriptors", i);
3353	if (!sb_rdonly(sb))
3354	return 0;
3355	}
3356	if (inode_bitmap < first_block || inode_bitmap > last_block) {
3357	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3358	"Inode bitmap for group %u not in group "
3359	"(block %llu)!", i, inode_bitmap);
3360	return 0;
3361	}
3362	inode_table = ext4_inode_table(sb, bg: gdp);
3363	if (inode_table == sb_block) {
3364	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3365	"Inode table for group %u overlaps "
3366	"superblock", i);
3367	if (!sb_rdonly(sb))
3368	return 0;
3369	}
3370	if (inode_table >= sb_block + 1 &&
3371	inode_table <= last_bg_block) {
3372	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3373	"Inode table for group %u overlaps "
3374	"block group descriptors", i);
3375	if (!sb_rdonly(sb))
3376	return 0;
3377	}
3378	if (inode_table < first_block ||
3379	inode_table + sbi->s_itb_per_group - 1 > last_block) {
3380	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3381	"Inode table for group %u not in group "
3382	"(block %llu)!", i, inode_table);
3383	return 0;
3384	}
3385	ext4_lock_group(sb, group: i);
3386	if (!ext4_group_desc_csum_verify(sb, block_group: i, gdp)) {
3387	ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3388	"Checksum for group %u failed (%u!=%u)",
3389	i, le16_to_cpu(ext4_group_desc_csum(sb, i,
3390	gdp)), le16_to_cpu(gdp->bg_checksum));
3391	if (!sb_rdonly(sb)) {
3392	ext4_unlock_group(sb, group: i);
3393	return 0;
3394	}
3395	}
3396	ext4_unlock_group(sb, group: i);
3397	if (!flexbg_flag)
3398	first_block += EXT4_BLOCKS_PER_GROUP(sb);
3399	}
3400	if (NULL != first_not_zeroed)
3401	*first_not_zeroed = grp;
3402	return 1;
3403	}
3404
3405	/*
3406	* Maximal extent format file size.
3407	* Resulting logical blkno at s_maxbytes must fit in our on-disk
3408	* extent format containers, within a sector_t, and within i_blocks
3409	* in the vfs. ext4 inode has 48 bits of i_block in fsblock units,
3410	* so that won't be a limiting factor.
3411	*
3412	* However there is other limiting factor. We do store extents in the form
3413	* of starting block and length, hence the resulting length of the extent
3414	* covering maximum file size must fit into on-disk format containers as
3415	* well. Given that length is always by 1 unit bigger than max unit (because
3416	* we count 0 as well) we have to lower the s_maxbytes by one fs block.
3417	*
3418	* Note, this does *not* consider any metadata overhead for vfs i_blocks.
3419	*/
3420	static loff_t ext4_max_size(int blkbits, int has_huge_files)
3421	{
3422	loff_t res;
3423	loff_t upper_limit = MAX_LFS_FILESIZE;
3424
3425	BUILD_BUG_ON(sizeof(blkcnt_t) < sizeof(u64));
3426
3427	if (!has_huge_files) {
3428	upper_limit = (1LL << 32) - 1;
3429
3430	/* total blocks in file system block size */
3431	upper_limit >>= (blkbits - 9);
3432	upper_limit <<= blkbits;
3433	}
3434
3435	/*
3436	* 32-bit extent-start container, ee_block. We lower the maxbytes
3437	* by one fs block, so ee_len can cover the extent of maximum file
3438	* size
3439	*/
3440	res = (1LL << 32) - 1;
3441	res <<= blkbits;
3442
3443	/* Sanity check against vm- & vfs- imposed limits */
3444	if (res > upper_limit)
3445	res = upper_limit;
3446
3447	return res;
3448	}
3449
3450	/*
3451	* Maximal bitmap file size. There is a direct, and {,double-,triple-}indirect
3452	* block limit, and also a limit of (2^48 - 1) 512-byte sectors in i_blocks.
3453	* We need to be 1 filesystem block less than the 2^48 sector limit.
3454	*/
3455	static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
3456	{
3457	loff_t upper_limit, res = EXT4_NDIR_BLOCKS;
3458	int meta_blocks;
3459	unsigned int ppb = 1 << (bits - 2);
3460
3461	/*
3462	* This is calculated to be the largest file size for a dense, block
3463	* mapped file such that the file's total number of 512-byte sectors,
3464	* including data and all indirect blocks, does not exceed (2^48 - 1).
3465	*
3466	* __u32 i_blocks_lo and _u16 i_blocks_high represent the total
3467	* number of 512-byte sectors of the file.
3468	*/
3469	if (!has_huge_files) {
3470	/*
3471	* !has_huge_files or implies that the inode i_block field
3472	* represents total file blocks in 2^32 512-byte sectors ==
3473	* size of vfs inode i_blocks * 8
3474	*/
3475	upper_limit = (1LL << 32) - 1;
3476
3477	/* total blocks in file system block size */
3478	upper_limit >>= (bits - 9);
3479
3480	} else {
3481	/*
3482	* We use 48 bit ext4_inode i_blocks
3483	* With EXT4_HUGE_FILE_FL set the i_blocks
3484	* represent total number of blocks in
3485	* file system block size
3486	*/
3487	upper_limit = (1LL << 48) - 1;
3488
3489	}
3490
3491	/* Compute how many blocks we can address by block tree */
3492	res += ppb;
3493	res += ppb * ppb;
3494	res += ((loff_t)ppb) * ppb * ppb;
3495	/* Compute how many metadata blocks are needed */
3496	meta_blocks = 1;
3497	meta_blocks += 1 + ppb;
3498	meta_blocks += 1 + ppb + ppb * ppb;
3499	/* Does block tree limit file size? */
3500	if (res + meta_blocks <= upper_limit)
3501	goto check_lfs;
3502
3503	res = upper_limit;
3504	/* How many metadata blocks are needed for addressing upper_limit? */
3505	upper_limit -= EXT4_NDIR_BLOCKS;
3506	/* indirect blocks */
3507	meta_blocks = 1;
3508	upper_limit -= ppb;
3509	/* double indirect blocks */
3510	if (upper_limit < ppb * ppb) {
3511	meta_blocks += 1 + DIV_ROUND_UP_ULL(upper_limit, ppb);
3512	res -= meta_blocks;
3513	goto check_lfs;
3514	}
3515	meta_blocks += 1 + ppb;
3516	upper_limit -= ppb * ppb;
3517	/* tripple indirect blocks for the rest */
3518	meta_blocks += 1 + DIV_ROUND_UP_ULL(upper_limit, ppb) +
3519	DIV_ROUND_UP_ULL(upper_limit, ppb*ppb);
3520	res -= meta_blocks;
3521	check_lfs:
3522	res <<= bits;
3523	if (res > MAX_LFS_FILESIZE)
3524	res = MAX_LFS_FILESIZE;
3525
3526	return res;
3527	}
3528
3529	static ext4_fsblk_t descriptor_loc(struct super_block *sb,
3530	ext4_fsblk_t logical_sb_block, int nr)
3531	{
3532	struct ext4_sb_info *sbi = EXT4_SB(sb);
3533	ext4_group_t bg, first_meta_bg;
3534	int has_super = 0;
3535
3536	first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
3537
3538	if (!ext4_has_feature_meta_bg(sb) || nr < first_meta_bg)
3539	return logical_sb_block + nr + 1;
3540	bg = sbi->s_desc_per_block * nr;
3541	if (ext4_bg_has_super(sb, group: bg))
3542	has_super = 1;
3543
3544	/*
3545	* If we have a meta_bg fs with 1k blocks, group 0's GDT is at
3546	* block 2, not 1. If s_first_data_block == 0 (bigalloc is enabled
3547	* on modern mke2fs or blksize > 1k on older mke2fs) then we must
3548	* compensate.
3549	*/
3550	if (sb->s_blocksize == 1024 && nr == 0 &&
3551	le32_to_cpu(sbi->s_es->s_first_data_block) == 0)
3552	has_super++;
3553
3554	return (has_super + ext4_group_first_block_no(sb, group_no: bg));
3555	}
3556
3557	/**
3558	* ext4_get_stripe_size: Get the stripe size.
3559	* @sbi: In memory super block info
3560	*
3561	* If we have specified it via mount option, then
3562	* use the mount option value. If the value specified at mount time is
3563	* greater than the blocks per group use the super block value.
3564	* If the super block value is greater than blocks per group return 0.
3565	* Allocator needs it be less than blocks per group.
3566	*
3567	*/
3568	static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
3569	{
3570	unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
3571	unsigned long stripe_width =
3572	le32_to_cpu(sbi->s_es->s_raid_stripe_width);
3573	int ret;
3574
3575	if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
3576	ret = sbi->s_stripe;
3577	else if (stripe_width && stripe_width <= sbi->s_blocks_per_group)
3578	ret = stripe_width;
3579	else if (stride && stride <= sbi->s_blocks_per_group)
3580	ret = stride;
3581	else
3582	ret = 0;
3583
3584	/*
3585	* If the stripe width is 1, this makes no sense and
3586	* we set it to 0 to turn off stripe handling code.
3587	*/
3588	if (ret <= 1)
3589	ret = 0;
3590
3591	return ret;
3592	}
3593
3594	/*
3595	* Check whether this filesystem can be mounted based on
3596	* the features present and the RDONLY/RDWR mount requested.
3597	* Returns 1 if this filesystem can be mounted as requested,
3598	* 0 if it cannot be.
3599	*/
3600	int ext4_feature_set_ok(struct super_block *sb, int readonly)
3601	{
3602	if (ext4_has_unknown_ext4_incompat_features(sb)) {
3603	ext4_msg(sb, KERN_ERR,
3604	"Couldn't mount because of "
3605	"unsupported optional features (%x)",
3606	(le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) &
3607	~EXT4_FEATURE_INCOMPAT_SUPP));
3608	return 0;
3609	}
3610
3611	#if !IS_ENABLED(CONFIG_UNICODE)
3612	if (ext4_has_feature_casefold(sb)) {
3613	ext4_msg(sb, KERN_ERR,
3614	"Filesystem with casefold feature cannot be "
3615	"mounted without CONFIG_UNICODE");
3616	return 0;
3617	}
3618	#endif
3619
3620	if (readonly)
3621	return 1;
3622
3623	if (ext4_has_feature_readonly(sb)) {
3624	ext4_msg(sb, KERN_INFO, "filesystem is read-only");
3625	sb->s_flags |= SB_RDONLY;
3626	return 1;
3627	}
3628
3629	/* Check that feature set is OK for a read-write mount */
3630	if (ext4_has_unknown_ext4_ro_compat_features(sb)) {
3631	ext4_msg(sb, KERN_ERR, "couldn't mount RDWR because of "
3632	"unsupported optional features (%x)",
3633	(le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
3634	~EXT4_FEATURE_RO_COMPAT_SUPP));
3635	return 0;
3636	}
3637	if (ext4_has_feature_bigalloc(sb) && !ext4_has_feature_extents(sb)) {
3638	ext4_msg(sb, KERN_ERR,
3639	"Can't support bigalloc feature without "
3640	"extents feature\n");
3641	return 0;
3642	}
3643
3644	#if !IS_ENABLED(CONFIG_QUOTA) || !IS_ENABLED(CONFIG_QFMT_V2)
3645	if (!readonly && (ext4_has_feature_quota(sb) ||
3646	ext4_has_feature_project(sb))) {
3647	ext4_msg(sb, KERN_ERR,
3648	"The kernel was not built with CONFIG_QUOTA and CONFIG_QFMT_V2");
3649	return 0;
3650	}
3651	#endif /* CONFIG_QUOTA */
3652	return 1;
3653	}
3654
3655	/*
3656	* This function is called once a day if we have errors logged
3657	* on the file system
3658	*/
3659	static void print_daily_error_info(struct timer_list *t)
3660	{
3661	struct ext4_sb_info *sbi = from_timer(sbi, t, s_err_report);
3662	struct super_block *sb = sbi->s_sb;
3663	struct ext4_super_block *es = sbi->s_es;
3664
3665	if (es->s_error_count)
3666	/* fsck newer than v1.41.13 is needed to clean this condition. */
3667	ext4_msg(sb, KERN_NOTICE, "error count since last fsck: %u",
3668	le32_to_cpu(es->s_error_count));
3669	if (es->s_first_error_time) {
3670	printk(KERN_NOTICE "EXT4-fs (%s): initial error at time %llu: %.*s:%d",
3671	sb->s_id,
3672	ext4_get_tstamp(es, s_first_error_time),
3673	(int) sizeof(es->s_first_error_func),
3674	es->s_first_error_func,
3675	le32_to_cpu(es->s_first_error_line));
3676	if (es->s_first_error_ino)
3677	printk(KERN_CONT ": inode %u",
3678	le32_to_cpu(es->s_first_error_ino));
3679	if (es->s_first_error_block)
3680	printk(KERN_CONT ": block %llu", (unsigned long long)
3681	le64_to_cpu(es->s_first_error_block));
3682	printk(KERN_CONT "\n");
3683	}
3684	if (es->s_last_error_time) {
3685	printk(KERN_NOTICE "EXT4-fs (%s): last error at time %llu: %.*s:%d",
3686	sb->s_id,
3687	ext4_get_tstamp(es, s_last_error_time),
3688	(int) sizeof(es->s_last_error_func),
3689	es->s_last_error_func,
3690	le32_to_cpu(es->s_last_error_line));
3691	if (es->s_last_error_ino)
3692	printk(KERN_CONT ": inode %u",
3693	le32_to_cpu(es->s_last_error_ino));
3694	if (es->s_last_error_block)
3695	printk(KERN_CONT ": block %llu", (unsigned long long)
3696	le64_to_cpu(es->s_last_error_block));
3697	printk(KERN_CONT "\n");
3698	}
3699	mod_timer(timer: &sbi->s_err_report, expires: jiffies + 24*60*60*HZ); /* Once a day */
3700	}
3701
3702	/* Find next suitable group and run ext4_init_inode_table */
3703	static int ext4_run_li_request(struct ext4_li_request *elr)
3704	{
3705	struct ext4_group_desc *gdp = NULL;
3706	struct super_block *sb = elr->lr_super;
3707	ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
3708	ext4_group_t group = elr->lr_next_group;
3709	unsigned int prefetch_ios = 0;
3710	int ret = 0;
3711	int nr = EXT4_SB(sb)->s_mb_prefetch;
3712	u64 start_time;
3713
3714	if (elr->lr_mode == EXT4_LI_MODE_PREFETCH_BBITMAP) {
3715	elr->lr_next_group = ext4_mb_prefetch(sb, group, nr, cnt: &prefetch_ios);
3716	ext4_mb_prefetch_fini(sb, group: elr->lr_next_group, nr);
3717	trace_ext4_prefetch_bitmaps(sb, group, next: elr->lr_next_group, prefetch_ios: nr);
3718	if (group >= elr->lr_next_group) {
3719	ret = 1;
3720	if (elr->lr_first_not_zeroed != ngroups &&
3721	!sb_rdonly(sb) && test_opt(sb, INIT_INODE_TABLE)) {
3722	elr->lr_next_group = elr->lr_first_not_zeroed;
3723	elr->lr_mode = EXT4_LI_MODE_ITABLE;
3724	ret = 0;
3725	}
3726	}
3727	return ret;
3728	}
3729
3730	for (; group < ngroups; group++) {
3731	gdp = ext4_get_group_desc(sb, block_group: group, NULL);
3732	if (!gdp) {
3733	ret = 1;
3734	break;
3735	}
3736
3737	if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3738	break;
3739	}
3740
3741	if (group >= ngroups)
3742	ret = 1;
3743
3744	if (!ret) {
3745	start_time = ktime_get_real_ns();
3746	ret = ext4_init_inode_table(sb, group,
3747	barrier: elr->lr_timeout ? 0 : 1);
3748	trace_ext4_lazy_itable_init(sb, group);
3749	if (elr->lr_timeout == 0) {
3750	elr->lr_timeout = nsecs_to_jiffies(n: (ktime_get_real_ns() - start_time) *
3751	EXT4_SB(sb: elr->lr_super)->s_li_wait_mult);
3752	}
3753	elr->lr_next_sched = jiffies + elr->lr_timeout;
3754	elr->lr_next_group = group + 1;
3755	}
3756	return ret;
3757	}
3758
3759	/*
3760	* Remove lr_request from the list_request and free the
3761	* request structure. Should be called with li_list_mtx held
3762	*/
3763	static void ext4_remove_li_request(struct ext4_li_request *elr)
3764	{
3765	if (!elr)
3766	return;
3767
3768	list_del(entry: &elr->lr_request);
3769	EXT4_SB(sb: elr->lr_super)->s_li_request = NULL;
3770	kfree(objp: elr);
3771	}
3772
3773	static void ext4_unregister_li_request(struct super_block *sb)
3774	{
3775	mutex_lock(&ext4_li_mtx);
3776	if (!ext4_li_info) {
3777	mutex_unlock(lock: &ext4_li_mtx);
3778	return;
3779	}
3780
3781	mutex_lock(&ext4_li_info->li_list_mtx);
3782	ext4_remove_li_request(elr: EXT4_SB(sb)->s_li_request);
3783	mutex_unlock(lock: &ext4_li_info->li_list_mtx);
3784	mutex_unlock(lock: &ext4_li_mtx);
3785	}
3786
3787	static struct task_struct *ext4_lazyinit_task;
3788
3789	/*
3790	* This is the function where ext4lazyinit thread lives. It walks
3791	* through the request list searching for next scheduled filesystem.
3792	* When such a fs is found, run the lazy initialization request
3793	* (ext4_rn_li_request) and keep track of the time spend in this
3794	* function. Based on that time we compute next schedule time of
3795	* the request. When walking through the list is complete, compute
3796	* next waking time and put itself into sleep.
3797	*/
3798	static int ext4_lazyinit_thread(void *arg)
3799	{
3800	struct ext4_lazy_init *eli = arg;
3801	struct list_head *pos, *n;
3802	struct ext4_li_request *elr;
3803	unsigned long next_wakeup, cur;
3804
3805	BUG_ON(NULL == eli);
3806	set_freezable();
3807
3808	cont_thread:
3809	while (true) {
3810	next_wakeup = MAX_JIFFY_OFFSET;
3811
3812	mutex_lock(&eli->li_list_mtx);
3813	if (list_empty(head: &eli->li_request_list)) {
3814	mutex_unlock(lock: &eli->li_list_mtx);
3815	goto exit_thread;
3816	}
3817	list_for_each_safe(pos, n, &eli->li_request_list) {
3818	int err = 0;
3819	int progress = 0;
3820	elr = list_entry(pos, struct ext4_li_request,
3821	lr_request);
3822
3823	if (time_before(jiffies, elr->lr_next_sched)) {
3824	if (time_before(elr->lr_next_sched, next_wakeup))
3825	next_wakeup = elr->lr_next_sched;
3826	continue;
3827	}
3828	if (down_read_trylock(sem: &elr->lr_super->s_umount)) {
3829	if (sb_start_write_trylock(sb: elr->lr_super)) {
3830	progress = 1;
3831	/*
3832	* We hold sb->s_umount, sb can not
3833	* be removed from the list, it is
3834	* now safe to drop li_list_mtx
3835	*/
3836	mutex_unlock(lock: &eli->li_list_mtx);
3837	err = ext4_run_li_request(elr);
3838	sb_end_write(sb: elr->lr_super);
3839	mutex_lock(&eli->li_list_mtx);
3840	n = pos->next;
3841	}
3842	up_read(sem: (&elr->lr_super->s_umount));
3843	}
3844	/* error, remove the lazy_init job */
3845	if (err) {
3846	ext4_remove_li_request(elr);
3847	continue;
3848	}
3849	if (!progress) {
3850	elr->lr_next_sched = jiffies +
3851	get_random_u32_below(EXT4_DEF_LI_MAX_START_DELAY * HZ);
3852	}
3853	if (time_before(elr->lr_next_sched, next_wakeup))
3854	next_wakeup = elr->lr_next_sched;
3855	}
3856	mutex_unlock(lock: &eli->li_list_mtx);
3857
3858	try_to_freeze();
3859
3860	cur = jiffies;
3861	if ((time_after_eq(cur, next_wakeup)) ||
3862	(MAX_JIFFY_OFFSET == next_wakeup)) {
3863	cond_resched();
3864	continue;
3865	}
3866
3867	schedule_timeout_interruptible(timeout: next_wakeup - cur);
3868
3869	if (kthread_should_stop()) {
3870	ext4_clear_request_list();
3871	goto exit_thread;
3872	}
3873	}
3874
3875	exit_thread:
3876	/*
3877	* It looks like the request list is empty, but we need
3878	* to check it under the li_list_mtx lock, to prevent any
3879	* additions into it, and of course we should lock ext4_li_mtx
3880	* to atomically free the list and ext4_li_info, because at
3881	* this point another ext4 filesystem could be registering
3882	* new one.
3883	*/
3884	mutex_lock(&ext4_li_mtx);
3885	mutex_lock(&eli->li_list_mtx);
3886	if (!list_empty(head: &eli->li_request_list)) {
3887	mutex_unlock(lock: &eli->li_list_mtx);
3888	mutex_unlock(lock: &ext4_li_mtx);
3889	goto cont_thread;
3890	}
3891	mutex_unlock(lock: &eli->li_list_mtx);
3892	kfree(objp: ext4_li_info);
3893	ext4_li_info = NULL;
3894	mutex_unlock(lock: &ext4_li_mtx);
3895
3896	return 0;
3897	}
3898
3899	static void ext4_clear_request_list(void)
3900	{
3901	struct list_head *pos, *n;
3902	struct ext4_li_request *elr;
3903
3904	mutex_lock(&ext4_li_info->li_list_mtx);
3905	list_for_each_safe(pos, n, &ext4_li_info->li_request_list) {
3906	elr = list_entry(pos, struct ext4_li_request,
3907	lr_request);
3908	ext4_remove_li_request(elr);
3909	}
3910	mutex_unlock(lock: &ext4_li_info->li_list_mtx);
3911	}
3912
3913	static int ext4_run_lazyinit_thread(void)
3914	{
3915	ext4_lazyinit_task = kthread_run(ext4_lazyinit_thread,
3916	ext4_li_info, "ext4lazyinit");
3917	if (IS_ERR(ptr: ext4_lazyinit_task)) {
3918	int err = PTR_ERR(ptr: ext4_lazyinit_task);
3919	ext4_clear_request_list();
3920	kfree(objp: ext4_li_info);
3921	ext4_li_info = NULL;
3922	printk(KERN_CRIT "EXT4-fs: error %d creating inode table "
3923	"initialization thread\n",
3924	err);
3925	return err;
3926	}
3927	ext4_li_info->li_state |= EXT4_LAZYINIT_RUNNING;
3928	return 0;
3929	}
3930
3931	/*
3932	* Check whether it make sense to run itable init. thread or not.
3933	* If there is at least one uninitialized inode table, return
3934	* corresponding group number, else the loop goes through all
3935	* groups and return total number of groups.
3936	*/
3937	static ext4_group_t ext4_has_uninit_itable(struct super_block *sb)
3938	{
3939	ext4_group_t group, ngroups = EXT4_SB(sb)->s_groups_count;
3940	struct ext4_group_desc *gdp = NULL;
3941
3942	if (!ext4_has_group_desc_csum(sb))
3943	return ngroups;
3944
3945	for (group = 0; group < ngroups; group++) {
3946	gdp = ext4_get_group_desc(sb, block_group: group, NULL);
3947	if (!gdp)
3948	continue;
3949
3950	if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3951	break;
3952	}
3953
3954	return group;
3955	}
3956
3957	static int ext4_li_info_new(void)
3958	{
3959	struct ext4_lazy_init *eli = NULL;
3960
3961	eli = kzalloc(size: sizeof(*eli), GFP_KERNEL);
3962	if (!eli)
3963	return -ENOMEM;
3964
3965	INIT_LIST_HEAD(list: &eli->li_request_list);
3966	mutex_init(&eli->li_list_mtx);
3967
3968	eli->li_state |= EXT4_LAZYINIT_QUIT;
3969
3970	ext4_li_info = eli;
3971
3972	return 0;
3973	}
3974
3975	static struct ext4_li_request *ext4_li_request_new(struct super_block *sb,
3976	ext4_group_t start)
3977	{
3978	struct ext4_li_request *elr;
3979
3980	elr = kzalloc(size: sizeof(*elr), GFP_KERNEL);
3981	if (!elr)
3982	return NULL;
3983
3984	elr->lr_super = sb;
3985	elr->lr_first_not_zeroed = start;
3986	if (test_opt(sb, NO_PREFETCH_BLOCK_BITMAPS)) {
3987	elr->lr_mode = EXT4_LI_MODE_ITABLE;
3988	elr->lr_next_group = start;
3989	} else {
3990	elr->lr_mode = EXT4_LI_MODE_PREFETCH_BBITMAP;
3991	}
3992
3993	/*
3994	* Randomize first schedule time of the request to
3995	* spread the inode table initialization requests
3996	* better.
3997	*/
3998	elr->lr_next_sched = jiffies + get_random_u32_below(EXT4_DEF_LI_MAX_START_DELAY * HZ);
3999	return elr;
4000	}
4001
4002	int ext4_register_li_request(struct super_block *sb,
4003	ext4_group_t first_not_zeroed)
4004	{
4005	struct ext4_sb_info *sbi = EXT4_SB(sb);
4006	struct ext4_li_request *elr = NULL;
4007	ext4_group_t ngroups = sbi->s_groups_count;
4008	int ret = 0;
4009
4010	mutex_lock(&ext4_li_mtx);
4011	if (sbi->s_li_request != NULL) {
4012	/*
4013	* Reset timeout so it can be computed again, because
4014	* s_li_wait_mult might have changed.
4015	*/
4016	sbi->s_li_request->lr_timeout = 0;
4017	goto out;
4018	}
4019
4020	if (sb_rdonly(sb) ||
4021	(test_opt(sb, NO_PREFETCH_BLOCK_BITMAPS) &&
4022	(first_not_zeroed == ngroups || !test_opt(sb, INIT_INODE_TABLE))))
4023	goto out;
4024
4025	elr = ext4_li_request_new(sb, start: first_not_zeroed);
4026	if (!elr) {
4027	ret = -ENOMEM;
4028	goto out;
4029	}
4030
4031	if (NULL == ext4_li_info) {
4032	ret = ext4_li_info_new();
4033	if (ret)
4034	goto out;
4035	}
4036
4037	mutex_lock(&ext4_li_info->li_list_mtx);
4038	list_add(new: &elr->lr_request, head: &ext4_li_info->li_request_list);
4039	mutex_unlock(lock: &ext4_li_info->li_list_mtx);
4040
4041	sbi->s_li_request = elr;
4042	/*
4043	* set elr to NULL here since it has been inserted to
4044	* the request_list and the removal and free of it is
4045	* handled by ext4_clear_request_list from now on.
4046	*/
4047	elr = NULL;
4048
4049	if (!(ext4_li_info->li_state & EXT4_LAZYINIT_RUNNING)) {
4050	ret = ext4_run_lazyinit_thread();
4051	if (ret)
4052	goto out;
4053	}
4054	out:
4055	mutex_unlock(lock: &ext4_li_mtx);
4056	if (ret)
4057	kfree(objp: elr);
4058	return ret;
4059	}
4060
4061	/*
4062	* We do not need to lock anything since this is called on
4063	* module unload.
4064	*/
4065	static void ext4_destroy_lazyinit_thread(void)
4066	{
4067	/*
4068	* If thread exited earlier
4069	* there's nothing to be done.
4070	*/
4071	if (!ext4_li_info || !ext4_lazyinit_task)
4072	return;
4073
4074	kthread_stop(k: ext4_lazyinit_task);
4075	}
4076
4077	static int set_journal_csum_feature_set(struct super_block *sb)
4078	{
4079	int ret = 1;
4080	int compat, incompat;
4081	struct ext4_sb_info *sbi = EXT4_SB(sb);
4082
4083	if (ext4_has_metadata_csum(sb)) {
4084	/* journal checksum v3 */
4085	compat = 0;
4086	incompat = JBD2_FEATURE_INCOMPAT_CSUM_V3;
4087	} else {
4088	/* journal checksum v1 */
4089	compat = JBD2_FEATURE_COMPAT_CHECKSUM;
4090	incompat = 0;
4091	}
4092
4093	jbd2_journal_clear_features(sbi->s_journal,
4094	JBD2_FEATURE_COMPAT_CHECKSUM, 0,
4095	JBD2_FEATURE_INCOMPAT_CSUM_V3 |
4096	JBD2_FEATURE_INCOMPAT_CSUM_V2);
4097	if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4098	ret = jbd2_journal_set_features(sbi->s_journal,
4099	compat, 0,
4100	JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT |
4101	incompat);
4102	} else if (test_opt(sb, JOURNAL_CHECKSUM)) {
4103	ret = jbd2_journal_set_features(sbi->s_journal,
4104	compat, 0,
4105	incompat);
4106	jbd2_journal_clear_features(sbi->s_journal, 0, 0,
4107	JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
4108	} else {
4109	jbd2_journal_clear_features(sbi->s_journal, 0, 0,
4110	JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
4111	}
4112
4113	return ret;
4114	}
4115
4116	/*
4117	* Note: calculating the overhead so we can be compatible with
4118	* historical BSD practice is quite difficult in the face of
4119	* clusters/bigalloc. This is because multiple metadata blocks from
4120	* different block group can end up in the same allocation cluster.
4121	* Calculating the exact overhead in the face of clustered allocation
4122	* requires either O(all block bitmaps) in memory or O(number of block
4123	* groups**2) in time. We will still calculate the superblock for
4124	* older file systems --- and if we come across with a bigalloc file
4125	* system with zero in s_overhead_clusters the estimate will be close to
4126	* correct especially for very large cluster sizes --- but for newer
4127	* file systems, it's better to calculate this figure once at mkfs
4128	* time, and store it in the superblock. If the superblock value is
4129	* present (even for non-bigalloc file systems), we will use it.
4130	*/
4131	static int count_overhead(struct super_block *sb, ext4_group_t grp,
4132	char *buf)
4133	{
4134	struct ext4_sb_info *sbi = EXT4_SB(sb);
4135	struct ext4_group_desc *gdp;
4136	ext4_fsblk_t first_block, last_block, b;
4137	ext4_group_t i, ngroups = ext4_get_groups_count(sb);
4138	int s, j, count = 0;
4139	int has_super = ext4_bg_has_super(sb, group: grp);
4140
4141	if (!ext4_has_feature_bigalloc(sb))
4142	return (has_super + ext4_bg_num_gdb(sb, group: grp) +
4143	(has_super ? le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0) +
4144	sbi->s_itb_per_group + 2);
4145
4146	first_block = le32_to_cpu(sbi->s_es->s_first_data_block) +
4147	(grp * EXT4_BLOCKS_PER_GROUP(sb));
4148	last_block = first_block + EXT4_BLOCKS_PER_GROUP(sb) - 1;
4149	for (i = 0; i < ngroups; i++) {
4150	gdp = ext4_get_group_desc(sb, block_group: i, NULL);
4151	b = ext4_block_bitmap(sb, bg: gdp);
4152	if (b >= first_block && b <= last_block) {
4153	ext4_set_bit(EXT4_B2C(sbi, b - first_block), addr: buf);
4154	count++;
4155	}
4156	b = ext4_inode_bitmap(sb, bg: gdp);
4157	if (b >= first_block && b <= last_block) {
4158	ext4_set_bit(EXT4_B2C(sbi, b - first_block), addr: buf);
4159	count++;
4160	}
4161	b = ext4_inode_table(sb, bg: gdp);
4162	if (b >= first_block && b + sbi->s_itb_per_group <= last_block)
4163	for (j = 0; j < sbi->s_itb_per_group; j++, b++) {
4164	int c = EXT4_B2C(sbi, b - first_block);
4165	ext4_set_bit(nr: c, addr: buf);
4166	count++;
4167	}
4168	if (i != grp)
4169	continue;
4170	s = 0;
4171	if (ext4_bg_has_super(sb, group: grp)) {
4172	ext4_set_bit(nr: s++, addr: buf);
4173	count++;
4174	}
4175	j = ext4_bg_num_gdb(sb, group: grp);
4176	if (s + j > EXT4_BLOCKS_PER_GROUP(sb)) {
4177	ext4_error(sb, "Invalid number of block group "
4178	"descriptor blocks: %d", j);
4179	j = EXT4_BLOCKS_PER_GROUP(sb) - s;
4180	}
4181	count += j;
4182	for (; j > 0; j--)
4183	ext4_set_bit(EXT4_B2C(sbi, s++), addr: buf);
4184	}
4185	if (!count)
4186	return 0;
4187	return EXT4_CLUSTERS_PER_GROUP(sb) -
4188	ext4_count_free(bitmap: buf, EXT4_CLUSTERS_PER_GROUP(sb) / 8);
4189	}
4190
4191	/*
4192	* Compute the overhead and stash it in sbi->s_overhead
4193	*/
4194	int ext4_calculate_overhead(struct super_block *sb)
4195	{
4196	struct ext4_sb_info *sbi = EXT4_SB(sb);
4197	struct ext4_super_block *es = sbi->s_es;
4198	struct inode *j_inode;
4199	unsigned int j_blocks, j_inum = le32_to_cpu(es->s_journal_inum);
4200	ext4_group_t i, ngroups = ext4_get_groups_count(sb);
4201	ext4_fsblk_t overhead = 0;
4202	char *buf = (char *) get_zeroed_page(GFP_NOFS);
4203
4204	if (!buf)
4205	return -ENOMEM;
4206
4207	/*
4208	* Compute the overhead (FS structures). This is constant
4209	* for a given filesystem unless the number of block groups
4210	* changes so we cache the previous value until it does.
4211	*/
4212
4213	/*
4214	* All of the blocks before first_data_block are overhead
4215	*/
4216	overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block));
4217
4218	/*
4219	* Add the overhead found in each block group
4220	*/
4221	for (i = 0; i < ngroups; i++) {
4222	int blks;
4223
4224	blks = count_overhead(sb, grp: i, buf);
4225	overhead += blks;
4226	if (blks)
4227	memset(buf, 0, PAGE_SIZE);
4228	cond_resched();
4229	}
4230
4231	/*
4232	* Add the internal journal blocks whether the journal has been
4233	* loaded or not
4234	*/
4235	if (sbi->s_journal && !sbi->s_journal_bdev_file)
4236	overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_total_len);
4237	else if (ext4_has_feature_journal(sb) && !sbi->s_journal && j_inum) {
4238	/* j_inum for internal journal is non-zero */
4239	j_inode = ext4_get_journal_inode(sb, journal_inum: j_inum);
4240	if (!IS_ERR(ptr: j_inode)) {
4241	j_blocks = j_inode->i_size >> sb->s_blocksize_bits;
4242	overhead += EXT4_NUM_B2C(sbi, j_blocks);
4243	iput(j_inode);
4244	} else {
4245	ext4_msg(sb, KERN_ERR, "can't get journal size");
4246	}
4247	}
4248	sbi->s_overhead = overhead;
4249	smp_wmb();
4250	free_page((unsigned long) buf);
4251	return 0;
4252	}
4253
4254	static void ext4_set_resv_clusters(struct super_block *sb)
4255	{
4256	ext4_fsblk_t resv_clusters;
4257	struct ext4_sb_info *sbi = EXT4_SB(sb);
4258
4259	/*
4260	* There's no need to reserve anything when we aren't using extents.
4261	* The space estimates are exact, there are no unwritten extents,
4262	* hole punching doesn't need new metadata... This is needed especially
4263	* to keep ext2/3 backward compatibility.
4264	*/
4265	if (!ext4_has_feature_extents(sb))
4266	return;
4267	/*
4268	* By default we reserve 2% or 4096 clusters, whichever is smaller.
4269	* This should cover the situations where we can not afford to run
4270	* out of space like for example punch hole, or converting
4271	* unwritten extents in delalloc path. In most cases such
4272	* allocation would require 1, or 2 blocks, higher numbers are
4273	* very rare.
4274	*/
4275	resv_clusters = (ext4_blocks_count(es: sbi->s_es) >>
4276	sbi->s_cluster_bits);
4277
4278	do_div(resv_clusters, 50);
4279	resv_clusters = min_t(ext4_fsblk_t, resv_clusters, 4096);
4280
4281	atomic64_set(v: &sbi->s_resv_clusters, i: resv_clusters);
4282	}
4283
4284	static const char *ext4_quota_mode(struct super_block *sb)
4285	{
4286	#ifdef CONFIG_QUOTA
4287	if (!ext4_quota_capable(sb))
4288	return "none";
4289
4290	if (EXT4_SB(sb)->s_journal && ext4_is_quota_journalled(sb))
4291	return "journalled";
4292	else
4293	return "writeback";
4294	#else
4295	return "disabled";
4296	#endif
4297	}
4298
4299	static void ext4_setup_csum_trigger(struct super_block *sb,
4300	enum ext4_journal_trigger_type type,
4301	void (*trigger)(
4302	struct jbd2_buffer_trigger_type *type,
4303	struct buffer_head *bh,
4304	void *mapped_data,
4305	size_t size))
4306	{
4307	struct ext4_sb_info *sbi = EXT4_SB(sb);
4308
4309	sbi->s_journal_triggers[type].sb = sb;
4310	sbi->s_journal_triggers[type].tr_triggers.t_frozen = trigger;
4311	}
4312
4313	static void ext4_free_sbi(struct ext4_sb_info *sbi)
4314	{
4315	if (!sbi)
4316	return;
4317
4318	kfree(objp: sbi->s_blockgroup_lock);
4319	fs_put_dax(dax_dev: sbi->s_daxdev, NULL);
4320	kfree(objp: sbi);
4321	}
4322
4323	static struct ext4_sb_info *ext4_alloc_sbi(struct super_block *sb)
4324	{
4325	struct ext4_sb_info *sbi;
4326
4327	sbi = kzalloc(size: sizeof(*sbi), GFP_KERNEL);
4328	if (!sbi)
4329	return NULL;
4330
4331	sbi->s_daxdev = fs_dax_get_by_bdev(bdev: sb->s_bdev, start_off: &sbi->s_dax_part_off,
4332	NULL, NULL);
4333
4334	sbi->s_blockgroup_lock =
4335	kzalloc(size: sizeof(struct blockgroup_lock), GFP_KERNEL);
4336
4337	if (!sbi->s_blockgroup_lock)
4338	goto err_out;
4339
4340	sb->s_fs_info = sbi;
4341	sbi->s_sb = sb;
4342	return sbi;
4343	err_out:
4344	fs_put_dax(dax_dev: sbi->s_daxdev, NULL);
4345	kfree(objp: sbi);
4346	return NULL;
4347	}
4348
4349	static void ext4_set_def_opts(struct super_block *sb,
4350	struct ext4_super_block *es)
4351	{
4352	unsigned long def_mount_opts;
4353
4354	/* Set defaults before we parse the mount options */
4355	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
4356	set_opt(sb, INIT_INODE_TABLE);
4357	if (def_mount_opts & EXT4_DEFM_DEBUG)
4358	set_opt(sb, DEBUG);
4359	if (def_mount_opts & EXT4_DEFM_BSDGROUPS)
4360	set_opt(sb, GRPID);
4361	if (def_mount_opts & EXT4_DEFM_UID16)
4362	set_opt(sb, NO_UID32);
4363	/* xattr user namespace & acls are now defaulted on */
4364	set_opt(sb, XATTR_USER);
4365	#ifdef CONFIG_EXT4_FS_POSIX_ACL
4366	set_opt(sb, POSIX_ACL);
4367	#endif
4368	if (ext4_has_feature_fast_commit(sb))
4369	set_opt2(sb, JOURNAL_FAST_COMMIT);
4370	/* don't forget to enable journal_csum when metadata_csum is enabled. */
4371	if (ext4_has_metadata_csum(sb))
4372	set_opt(sb, JOURNAL_CHECKSUM);
4373
4374	if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
4375	set_opt(sb, JOURNAL_DATA);
4376	else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
4377	set_opt(sb, ORDERED_DATA);
4378	else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
4379	set_opt(sb, WRITEBACK_DATA);
4380
4381	if (le16_to_cpu(es->s_errors) == EXT4_ERRORS_PANIC)
4382	set_opt(sb, ERRORS_PANIC);
4383	else if (le16_to_cpu(es->s_errors) == EXT4_ERRORS_CONTINUE)
4384	set_opt(sb, ERRORS_CONT);
4385	else
4386	set_opt(sb, ERRORS_RO);
4387	/* block_validity enabled by default; disable with noblock_validity */
4388	set_opt(sb, BLOCK_VALIDITY);
4389	if (def_mount_opts & EXT4_DEFM_DISCARD)
4390	set_opt(sb, DISCARD);
4391
4392	if ((def_mount_opts & EXT4_DEFM_NOBARRIER) == 0)
4393	set_opt(sb, BARRIER);
4394
4395	/*
4396	* enable delayed allocation by default
4397	* Use -o nodelalloc to turn it off
4398	*/
4399	if (!IS_EXT3_SB(sb) && !IS_EXT2_SB(sb) &&
4400	((def_mount_opts & EXT4_DEFM_NODELALLOC) == 0))
4401	set_opt(sb, DELALLOC);
4402
4403	if (sb->s_blocksize <= PAGE_SIZE)
4404	set_opt(sb, DIOREAD_NOLOCK);
4405	}
4406
4407	static int ext4_handle_clustersize(struct super_block *sb)
4408	{
4409	struct ext4_sb_info *sbi = EXT4_SB(sb);
4410	struct ext4_super_block *es = sbi->s_es;
4411	int clustersize;
4412
4413	/* Handle clustersize */
4414	clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
4415	if (ext4_has_feature_bigalloc(sb)) {
4416	if (clustersize < sb->s_blocksize) {
4417	ext4_msg(sb, KERN_ERR,
4418	"cluster size (%d) smaller than "
4419	"block size (%lu)", clustersize, sb->s_blocksize);
4420	return -EINVAL;
4421	}
4422	sbi->s_cluster_bits = le32_to_cpu(es->s_log_cluster_size) -
4423	le32_to_cpu(es->s_log_block_size);
4424	} else {
4425	if (clustersize != sb->s_blocksize) {
4426	ext4_msg(sb, KERN_ERR,
4427	"fragment/cluster size (%d) != "
4428	"block size (%lu)", clustersize, sb->s_blocksize);
4429	return -EINVAL;
4430	}
4431	if (sbi->s_blocks_per_group > sb->s_blocksize * 8) {
4432	ext4_msg(sb, KERN_ERR,
4433	"#blocks per group too big: %lu",
4434	sbi->s_blocks_per_group);
4435	return -EINVAL;
4436	}
4437	sbi->s_cluster_bits = 0;
4438	}
4439	sbi->s_clusters_per_group = le32_to_cpu(es->s_clusters_per_group);
4440	if (sbi->s_clusters_per_group > sb->s_blocksize * 8) {
4441	ext4_msg(sb, KERN_ERR, "#clusters per group too big: %lu",
4442	sbi->s_clusters_per_group);
4443	return -EINVAL;
4444	}
4445	if (sbi->s_blocks_per_group !=
4446	(sbi->s_clusters_per_group * (clustersize / sb->s_blocksize))) {
4447	ext4_msg(sb, KERN_ERR,
4448	"blocks per group (%lu) and clusters per group (%lu) inconsistent",
4449	sbi->s_blocks_per_group, sbi->s_clusters_per_group);
4450	return -EINVAL;
4451	}
4452	sbi->s_cluster_ratio = clustersize / sb->s_blocksize;
4453
4454	/* Do we have standard group size of clustersize * 8 blocks ? */
4455	if (sbi->s_blocks_per_group == clustersize << 3)
4456	set_opt2(sb, STD_GROUP_SIZE);
4457
4458	return 0;
4459	}
4460
4461	static void ext4_fast_commit_init(struct super_block *sb)
4462	{
4463	struct ext4_sb_info *sbi = EXT4_SB(sb);
4464
4465	/* Initialize fast commit stuff */
4466	atomic_set(v: &sbi->s_fc_subtid, i: 0);
4467	INIT_LIST_HEAD(list: &sbi->s_fc_q[FC_Q_MAIN]);
4468	INIT_LIST_HEAD(list: &sbi->s_fc_q[FC_Q_STAGING]);
4469	INIT_LIST_HEAD(list: &sbi->s_fc_dentry_q[FC_Q_MAIN]);
4470	INIT_LIST_HEAD(list: &sbi->s_fc_dentry_q[FC_Q_STAGING]);
4471	sbi->s_fc_bytes = 0;
4472	ext4_clear_mount_flag(sb, bit: EXT4_MF_FC_INELIGIBLE);
4473	sbi->s_fc_ineligible_tid = 0;
4474	spin_lock_init(&sbi->s_fc_lock);
4475	memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));
4476	sbi->s_fc_replay_state.fc_regions = NULL;
4477	sbi->s_fc_replay_state.fc_regions_size = 0;
4478	sbi->s_fc_replay_state.fc_regions_used = 0;
4479	sbi->s_fc_replay_state.fc_regions_valid = 0;
4480	sbi->s_fc_replay_state.fc_modified_inodes = NULL;
4481	sbi->s_fc_replay_state.fc_modified_inodes_size = 0;
4482	sbi->s_fc_replay_state.fc_modified_inodes_used = 0;
4483	}
4484
4485	static int ext4_inode_info_init(struct super_block *sb,
4486	struct ext4_super_block *es)
4487	{
4488	struct ext4_sb_info *sbi = EXT4_SB(sb);
4489
4490	if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
4491	sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
4492	sbi->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
4493	} else {
4494	sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
4495	sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
4496	if (sbi->s_first_ino < EXT4_GOOD_OLD_FIRST_INO) {
4497	ext4_msg(sb, KERN_ERR, "invalid first ino: %u",
4498	sbi->s_first_ino);
4499	return -EINVAL;
4500	}
4501	if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
4502	(!is_power_of_2(n: sbi->s_inode_size)) ||
4503	(sbi->s_inode_size > sb->s_blocksize)) {
4504	ext4_msg(sb, KERN_ERR,
4505	"unsupported inode size: %d",
4506	sbi->s_inode_size);
4507	ext4_msg(sb, KERN_ERR, "blocksize: %lu", sb->s_blocksize);
4508	return -EINVAL;
4509	}
4510	/*
4511	* i_atime_extra is the last extra field available for
4512	* [acm]times in struct ext4_inode. Checking for that
4513	* field should suffice to ensure we have extra space
4514	* for all three.
4515	*/
4516	if (sbi->s_inode_size >= offsetof(struct ext4_inode, i_atime_extra) +
4517	sizeof(((struct ext4_inode *)0)->i_atime_extra)) {
4518	sb->s_time_gran = 1;
4519	sb->s_time_max = EXT4_EXTRA_TIMESTAMP_MAX;
4520	} else {
4521	sb->s_time_gran = NSEC_PER_SEC;
4522	sb->s_time_max = EXT4_NON_EXTRA_TIMESTAMP_MAX;
4523	}
4524	sb->s_time_min = EXT4_TIMESTAMP_MIN;
4525	}
4526
4527	if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
4528	sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
4529	EXT4_GOOD_OLD_INODE_SIZE;
4530	if (ext4_has_feature_extra_isize(sb)) {
4531	unsigned v, max = (sbi->s_inode_size -
4532	EXT4_GOOD_OLD_INODE_SIZE);
4533
4534	v = le16_to_cpu(es->s_want_extra_isize);
4535	if (v > max) {
4536	ext4_msg(sb, KERN_ERR,
4537	"bad s_want_extra_isize: %d", v);
4538	return -EINVAL;
4539	}
4540	if (sbi->s_want_extra_isize < v)
4541	sbi->s_want_extra_isize = v;
4542
4543	v = le16_to_cpu(es->s_min_extra_isize);
4544	if (v > max) {
4545	ext4_msg(sb, KERN_ERR,
4546	"bad s_min_extra_isize: %d", v);
4547	return -EINVAL;
4548	}
4549	if (sbi->s_want_extra_isize < v)
4550	sbi->s_want_extra_isize = v;
4551	}
4552	}
4553
4554	return 0;
4555	}
4556
4557	#if IS_ENABLED(CONFIG_UNICODE)
4558	static int ext4_encoding_init(struct super_block *sb, struct ext4_super_block *es)
4559	{
4560	const struct ext4_sb_encodings *encoding_info;
4561	struct unicode_map *encoding;
4562	__u16 encoding_flags = le16_to_cpu(es->s_encoding_flags);
4563
4564	if (!ext4_has_feature_casefold(sb) || sb->s_encoding)
4565	return 0;
4566
4567	encoding_info = ext4_sb_read_encoding(es);
4568	if (!encoding_info) {
4569	ext4_msg(sb, KERN_ERR,
4570	"Encoding requested by superblock is unknown");
4571	return -EINVAL;
4572	}
4573
4574	encoding = utf8_load(version: encoding_info->version);
4575	if (IS_ERR(ptr: encoding)) {
4576	ext4_msg(sb, KERN_ERR,
4577	"can't mount with superblock charset: %s-%u.%u.%u "
4578	"not supported by the kernel. flags: 0x%x.",
4579	encoding_info->name,
4580	unicode_major(encoding_info->version),
4581	unicode_minor(encoding_info->version),
4582	unicode_rev(encoding_info->version),
4583	encoding_flags);
4584	return -EINVAL;
4585	}
4586	ext4_msg(sb, KERN_INFO,"Using encoding defined by superblock: "
4587	"%s-%u.%u.%u with flags 0x%hx", encoding_info->name,
4588	unicode_major(encoding_info->version),
4589	unicode_minor(encoding_info->version),
4590	unicode_rev(encoding_info->version),
4591	encoding_flags);
4592
4593	sb->s_encoding = encoding;
4594	sb->s_encoding_flags = encoding_flags;
4595
4596	return 0;
4597	}
4598	#else
4599	static inline int ext4_encoding_init(struct super_block *sb, struct ext4_super_block *es)
4600	{
4601	return 0;
4602	}
4603	#endif
4604
4605	static int ext4_init_metadata_csum(struct super_block *sb, struct ext4_super_block *es)
4606	{
4607	struct ext4_sb_info *sbi = EXT4_SB(sb);
4608
4609	/* Warn if metadata_csum and gdt_csum are both set. */
4610	if (ext4_has_feature_metadata_csum(sb) &&
4611	ext4_has_feature_gdt_csum(sb))
4612	ext4_warning(sb, "metadata_csum and uninit_bg are "
4613	"redundant flags; please run fsck.");
4614
4615	/* Check for a known checksum algorithm */
4616	if (!ext4_verify_csum_type(sb, es)) {
4617	ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
4618	"unknown checksum algorithm.");
4619	return -EINVAL;
4620	}
4621	ext4_setup_csum_trigger(sb, type: EXT4_JTR_ORPHAN_FILE,
4622	trigger: ext4_orphan_file_block_trigger);
4623
4624	/* Load the checksum driver */
4625	sbi->s_chksum_driver = crypto_alloc_shash(alg_name: "crc32c", type: 0, mask: 0);
4626	if (IS_ERR(ptr: sbi->s_chksum_driver)) {
4627	int ret = PTR_ERR(ptr: sbi->s_chksum_driver);
4628	ext4_msg(sb, KERN_ERR, "Cannot load crc32c driver.");
4629	sbi->s_chksum_driver = NULL;
4630	return ret;
4631	}
4632
4633	/* Check superblock checksum */
4634	if (!ext4_superblock_csum_verify(sb, es)) {
4635	ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
4636	"invalid superblock checksum. Run e2fsck?");
4637	return -EFSBADCRC;
4638	}
4639
4640	/* Precompute checksum seed for all metadata */
4641	if (ext4_has_feature_csum_seed(sb))
4642	sbi->s_csum_seed = le32_to_cpu(es->s_checksum_seed);
4643	else if (ext4_has_metadata_csum(sb) || ext4_has_feature_ea_inode(sb))
4644	sbi->s_csum_seed = ext4_chksum(sbi, crc: ~0, address: es->s_uuid,
4645	length: sizeof(es->s_uuid));
4646	return 0;
4647	}
4648
4649	static int ext4_check_feature_compatibility(struct super_block *sb,
4650	struct ext4_super_block *es,
4651	int silent)
4652	{
4653	struct ext4_sb_info *sbi = EXT4_SB(sb);
4654
4655	if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
4656	(ext4_has_compat_features(sb) ||
4657	ext4_has_ro_compat_features(sb) ||
4658	ext4_has_incompat_features(sb)))
4659	ext4_msg(sb, KERN_WARNING,
4660	"feature flags set on rev 0 fs, "
4661	"running e2fsck is recommended");
4662
4663	if (es->s_creator_os == cpu_to_le32(EXT4_OS_HURD)) {
4664	set_opt2(sb, HURD_COMPAT);
4665	if (ext4_has_feature_64bit(sb)) {
4666	ext4_msg(sb, KERN_ERR,
4667	"The Hurd can't support 64-bit file systems");
4668	return -EINVAL;
4669	}
4670
4671	/*
4672	* ea_inode feature uses l_i_version field which is not
4673	* available in HURD_COMPAT mode.
4674	*/
4675	if (ext4_has_feature_ea_inode(sb)) {
4676	ext4_msg(sb, KERN_ERR,
4677	"ea_inode feature is not supported for Hurd");
4678	return -EINVAL;
4679	}
4680	}
4681
4682	if (IS_EXT2_SB(sb)) {
4683	if (ext2_feature_set_ok(sb))
4684	ext4_msg(sb, KERN_INFO, "mounting ext2 file system "
4685	"using the ext4 subsystem");
4686	else {
4687	/*
4688	* If we're probing be silent, if this looks like
4689	* it's actually an ext[34] filesystem.
4690	*/
4691	if (silent && ext4_feature_set_ok(sb, readonly: sb_rdonly(sb)))
4692	return -EINVAL;
4693	ext4_msg(sb, KERN_ERR, "couldn't mount as ext2 due "
4694	"to feature incompatibilities");
4695	return -EINVAL;
4696	}
4697	}
4698
4699	if (IS_EXT3_SB(sb)) {
4700	if (ext3_feature_set_ok(sb))
4701	ext4_msg(sb, KERN_INFO, "mounting ext3 file system "
4702	"using the ext4 subsystem");
4703	else {
4704	/*
4705	* If we're probing be silent, if this looks like
4706	* it's actually an ext4 filesystem.
4707	*/
4708	if (silent && ext4_feature_set_ok(sb, readonly: sb_rdonly(sb)))
4709	return -EINVAL;
4710	ext4_msg(sb, KERN_ERR, "couldn't mount as ext3 due "
4711	"to feature incompatibilities");
4712	return -EINVAL;
4713	}
4714	}
4715
4716	/*
4717	* Check feature flags regardless of the revision level, since we
4718	* previously didn't change the revision level when setting the flags,
4719	* so there is a chance incompat flags are set on a rev 0 filesystem.
4720	*/
4721	if (!ext4_feature_set_ok(sb, readonly: (sb_rdonly(sb))))
4722	return -EINVAL;
4723
4724	if (sbi->s_daxdev) {
4725	if (sb->s_blocksize == PAGE_SIZE)
4726	set_bit(EXT4_FLAGS_BDEV_IS_DAX, addr: &sbi->s_ext4_flags);
4727	else
4728	ext4_msg(sb, KERN_ERR, "unsupported blocksize for DAX\n");
4729	}
4730
4731	if (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) {
4732	if (ext4_has_feature_inline_data(sb)) {
4733	ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem"
4734	" that may contain inline data");
4735	return -EINVAL;
4736	}
4737	if (!test_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags)) {
4738	ext4_msg(sb, KERN_ERR,
4739	"DAX unsupported by block device.");
4740	return -EINVAL;
4741	}
4742	}
4743
4744	if (ext4_has_feature_encrypt(sb) && es->s_encryption_level) {
4745	ext4_msg(sb, KERN_ERR, "Unsupported encryption level %d",
4746	es->s_encryption_level);
4747	return -EINVAL;
4748	}
4749
4750	return 0;
4751	}
4752
4753	static int ext4_check_geometry(struct super_block *sb,
4754	struct ext4_super_block *es)
4755	{
4756	struct ext4_sb_info *sbi = EXT4_SB(sb);
4757	__u64 blocks_count;
4758	int err;
4759
4760	if (le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) > (sb->s_blocksize / 4)) {
4761	ext4_msg(sb, KERN_ERR,
4762	"Number of reserved GDT blocks insanely large: %d",
4763	le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks));
4764	return -EINVAL;
4765	}
4766	/*
4767	* Test whether we have more sectors than will fit in sector_t,
4768	* and whether the max offset is addressable by the page cache.
4769	*/
4770	err = generic_check_addressable(sb->s_blocksize_bits,
4771	ext4_blocks_count(es));
4772	if (err) {
4773	ext4_msg(sb, KERN_ERR, "filesystem"
4774	" too large to mount safely on this system");
4775	return err;
4776	}
4777
4778	/* check blocks count against device size */
4779	blocks_count = sb_bdev_nr_blocks(sb);
4780	if (blocks_count && ext4_blocks_count(es) > blocks_count) {
4781	ext4_msg(sb, KERN_WARNING, "bad geometry: block count %llu "
4782	"exceeds size of device (%llu blocks)",
4783	ext4_blocks_count(es), blocks_count);
4784	return -EINVAL;
4785	}
4786
4787	/*
4788	* It makes no sense for the first data block to be beyond the end
4789	* of the filesystem.
4790	*/
4791	if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
4792	ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
4793	"block %u is beyond end of filesystem (%llu)",
4794	le32_to_cpu(es->s_first_data_block),
4795	ext4_blocks_count(es));
4796	return -EINVAL;
4797	}
4798	if ((es->s_first_data_block == 0) && (es->s_log_block_size == 0) &&
4799	(sbi->s_cluster_ratio == 1)) {
4800	ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
4801	"block is 0 with a 1k block and cluster size");
4802	return -EINVAL;
4803	}
4804
4805	blocks_count = (ext4_blocks_count(es) -
4806	le32_to_cpu(es->s_first_data_block) +
4807	EXT4_BLOCKS_PER_GROUP(sb) - 1);
4808	do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
4809	if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
4810	ext4_msg(sb, KERN_WARNING, "groups count too large: %llu "
4811	"(block count %llu, first data block %u, "
4812	"blocks per group %lu)", blocks_count,
4813	ext4_blocks_count(es),
4814	le32_to_cpu(es->s_first_data_block),
4815	EXT4_BLOCKS_PER_GROUP(sb));
4816	return -EINVAL;
4817	}
4818	sbi->s_groups_count = blocks_count;
4819	sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,
4820	(EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
4821	if (((u64)sbi->s_groups_count * sbi->s_inodes_per_group) !=
4822	le32_to_cpu(es->s_inodes_count)) {
4823	ext4_msg(sb, KERN_ERR, "inodes count not valid: %u vs %llu",
4824	le32_to_cpu(es->s_inodes_count),
4825	((u64)sbi->s_groups_count * sbi->s_inodes_per_group));
4826	return -EINVAL;
4827	}
4828
4829	return 0;
4830	}
4831
4832	static int ext4_group_desc_init(struct super_block *sb,
4833	struct ext4_super_block *es,
4834	ext4_fsblk_t logical_sb_block,
4835	ext4_group_t *first_not_zeroed)
4836	{
4837	struct ext4_sb_info *sbi = EXT4_SB(sb);
4838	unsigned int db_count;
4839	ext4_fsblk_t block;
4840	int i;
4841
4842	db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
4843	EXT4_DESC_PER_BLOCK(sb);
4844	if (ext4_has_feature_meta_bg(sb)) {
4845	if (le32_to_cpu(es->s_first_meta_bg) > db_count) {
4846	ext4_msg(sb, KERN_WARNING,
4847	"first meta block group too large: %u "
4848	"(group descriptor block count %u)",
4849	le32_to_cpu(es->s_first_meta_bg), db_count);
4850	return -EINVAL;
4851	}
4852	}
4853	rcu_assign_pointer(sbi->s_group_desc,
4854	kvmalloc_array(db_count,
4855	sizeof(struct buffer_head *),
4856	GFP_KERNEL));
4857	if (sbi->s_group_desc == NULL) {
4858	ext4_msg(sb, KERN_ERR, "not enough memory");
4859	return -ENOMEM;
4860	}
4861
4862	bgl_lock_init(bgl: sbi->s_blockgroup_lock);
4863
4864	/* Pre-read the descriptors into the buffer cache */
4865	for (i = 0; i < db_count; i++) {
4866	block = descriptor_loc(sb, logical_sb_block, nr: i);
4867	ext4_sb_breadahead_unmovable(sb, block);
4868	}
4869
4870	for (i = 0; i < db_count; i++) {
4871	struct buffer_head *bh;
4872
4873	block = descriptor_loc(sb, logical_sb_block, nr: i);
4874	bh = ext4_sb_bread_unmovable(sb, block);
4875	if (IS_ERR(ptr: bh)) {
4876	ext4_msg(sb, KERN_ERR,
4877	"can't read group descriptor %d", i);
4878	sbi->s_gdb_count = i;
4879	return PTR_ERR(ptr: bh);
4880	}
4881	rcu_read_lock();
4882	rcu_dereference(sbi->s_group_desc)[i] = bh;
4883	rcu_read_unlock();
4884	}
4885	sbi->s_gdb_count = db_count;
4886	if (!ext4_check_descriptors(sb, sb_block: logical_sb_block, first_not_zeroed)) {
4887	ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
4888	return -EFSCORRUPTED;
4889	}
4890
4891	return 0;
4892	}
4893
4894	static int ext4_load_and_init_journal(struct super_block *sb,
4895	struct ext4_super_block *es,
4896	struct ext4_fs_context *ctx)
4897	{
4898	struct ext4_sb_info *sbi = EXT4_SB(sb);
4899	int err;
4900
4901	err = ext4_load_journal(sb, es, journal_devnum: ctx->journal_devnum);
4902	if (err)
4903	return err;
4904
4905	if (ext4_has_feature_64bit(sb) &&
4906	!jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4907	JBD2_FEATURE_INCOMPAT_64BIT)) {
4908	ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
4909	goto out;
4910	}
4911
4912	if (!set_journal_csum_feature_set(sb)) {
4913	ext4_msg(sb, KERN_ERR, "Failed to set journal checksum "
4914	"feature set");
4915	goto out;
4916	}
4917
4918	if (test_opt2(sb, JOURNAL_FAST_COMMIT) &&
4919	!jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4920	JBD2_FEATURE_INCOMPAT_FAST_COMMIT)) {
4921	ext4_msg(sb, KERN_ERR,
4922	"Failed to set fast commit journal feature");
4923	goto out;
4924	}
4925
4926	/* We have now updated the journal if required, so we can
4927	* validate the data journaling mode. */
4928	switch (test_opt(sb, DATA_FLAGS)) {
4929	case 0:
4930	/* No mode set, assume a default based on the journal
4931	* capabilities: ORDERED_DATA if the journal can
4932	* cope, else JOURNAL_DATA
4933	*/
4934	if (jbd2_journal_check_available_features
4935	(sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
4936	set_opt(sb, ORDERED_DATA);
4937	sbi->s_def_mount_opt |= EXT4_MOUNT_ORDERED_DATA;
4938	} else {
4939	set_opt(sb, JOURNAL_DATA);
4940	sbi->s_def_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
4941	}
4942	break;
4943
4944	case EXT4_MOUNT_ORDERED_DATA:
4945	case EXT4_MOUNT_WRITEBACK_DATA:
4946	if (!jbd2_journal_check_available_features
4947	(sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
4948	ext4_msg(sb, KERN_ERR, "Journal does not support "
4949	"requested data journaling mode");
4950	goto out;
4951	}
4952	break;
4953	default:
4954	break;
4955	}
4956
4957	if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA &&
4958	test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4959	ext4_msg(sb, KERN_ERR, "can't mount with "
4960	"journal_async_commit in data=ordered mode");
4961	goto out;
4962	}
4963
4964	set_task_ioprio(task: sbi->s_journal->j_task, ioprio: ctx->journal_ioprio);
4965
4966	sbi->s_journal->j_submit_inode_data_buffers =
4967	ext4_journal_submit_inode_data_buffers;
4968	sbi->s_journal->j_finish_inode_data_buffers =
4969	ext4_journal_finish_inode_data_buffers;
4970
4971	return 0;
4972
4973	out:
4974	/* flush s_sb_upd_work before destroying the journal. */
4975	flush_work(work: &sbi->s_sb_upd_work);
4976	jbd2_journal_destroy(sbi->s_journal);
4977	sbi->s_journal = NULL;
4978	return -EINVAL;
4979	}
4980
4981	static int ext4_check_journal_data_mode(struct super_block *sb)
4982	{
4983	if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
4984	printk_once(KERN_WARNING "EXT4-fs: Warning: mounting with "
4985	"data=journal disables delayed allocation, "
4986	"dioread_nolock, O_DIRECT and fast_commit support!\n");
4987	/* can't mount with both data=journal and dioread_nolock. */
4988	clear_opt(sb, DIOREAD_NOLOCK);
4989	clear_opt2(sb, JOURNAL_FAST_COMMIT);
4990	if (test_opt2(sb, EXPLICIT_DELALLOC)) {
4991	ext4_msg(sb, KERN_ERR, "can't mount with "
4992	"both data=journal and delalloc");
4993	return -EINVAL;
4994	}
4995	if (test_opt(sb, DAX_ALWAYS)) {
4996	ext4_msg(sb, KERN_ERR, "can't mount with "
4997	"both data=journal and dax");
4998	return -EINVAL;
4999	}
5000	if (ext4_has_feature_encrypt(sb)) {
5001	ext4_msg(sb, KERN_WARNING,
5002	"encrypted files will use data=ordered "
5003	"instead of data journaling mode");
5004	}
5005	if (test_opt(sb, DELALLOC))
5006	clear_opt(sb, DELALLOC);
5007	} else {
5008	sb->s_iflags |= SB_I_CGROUPWB;
5009	}
5010
5011	return 0;
5012	}
5013
5014	static int ext4_load_super(struct super_block *sb, ext4_fsblk_t *lsb,
5015	int silent)
5016	{
5017	struct ext4_sb_info *sbi = EXT4_SB(sb);
5018	struct ext4_super_block *es;
5019	ext4_fsblk_t logical_sb_block;
5020	unsigned long offset = 0;
5021	struct buffer_head *bh;
5022	int ret = -EINVAL;
5023	int blocksize;
5024
5025	blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
5026	if (!blocksize) {
5027	ext4_msg(sb, KERN_ERR, "unable to set blocksize");
5028	return -EINVAL;
5029	}
5030
5031	/*
5032	* The ext4 superblock will not be buffer aligned for other than 1kB
5033	* block sizes. We need to calculate the offset from buffer start.
5034	*/
5035	if (blocksize != EXT4_MIN_BLOCK_SIZE) {
5036	logical_sb_block = sbi->s_sb_block * EXT4_MIN_BLOCK_SIZE;
5037	offset = do_div(logical_sb_block, blocksize);
5038	} else {
5039	logical_sb_block = sbi->s_sb_block;
5040	}
5041
5042	bh = ext4_sb_bread_unmovable(sb, block: logical_sb_block);
5043	if (IS_ERR(ptr: bh)) {
5044	ext4_msg(sb, KERN_ERR, "unable to read superblock");
5045	return PTR_ERR(ptr: bh);
5046	}
5047	/*
5048	* Note: s_es must be initialized as soon as possible because
5049	* some ext4 macro-instructions depend on its value
5050	*/
5051	es = (struct ext4_super_block *) (bh->b_data + offset);
5052	sbi->s_es = es;
5053	sb->s_magic = le16_to_cpu(es->s_magic);
5054	if (sb->s_magic != EXT4_SUPER_MAGIC) {
5055	if (!silent)
5056	ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
5057	goto out;
5058	}
5059
5060	if (le32_to_cpu(es->s_log_block_size) >
5061	(EXT4_MAX_BLOCK_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
5062	ext4_msg(sb, KERN_ERR,
5063	"Invalid log block size: %u",
5064	le32_to_cpu(es->s_log_block_size));
5065	goto out;
5066	}
5067	if (le32_to_cpu(es->s_log_cluster_size) >
5068	(EXT4_MAX_CLUSTER_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
5069	ext4_msg(sb, KERN_ERR,
5070	"Invalid log cluster size: %u",
5071	le32_to_cpu(es->s_log_cluster_size));
5072	goto out;
5073	}
5074
5075	blocksize = EXT4_MIN_BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
5076
5077	/*
5078	* If the default block size is not the same as the real block size,
5079	* we need to reload it.
5080	*/
5081	if (sb->s_blocksize == blocksize) {
5082	*lsb = logical_sb_block;
5083	sbi->s_sbh = bh;
5084	return 0;
5085	}
5086
5087	/*
5088	* bh must be released before kill_bdev(), otherwise
5089	* it won't be freed and its page also. kill_bdev()
5090	* is called by sb_set_blocksize().
5091	*/
5092	brelse(bh);
5093	/* Validate the filesystem blocksize */
5094	if (!sb_set_blocksize(sb, blocksize)) {
5095	ext4_msg(sb, KERN_ERR, "bad block size %d",
5096	blocksize);
5097	bh = NULL;
5098	goto out;
5099	}
5100
5101	logical_sb_block = sbi->s_sb_block * EXT4_MIN_BLOCK_SIZE;
5102	offset = do_div(logical_sb_block, blocksize);
5103	bh = ext4_sb_bread_unmovable(sb, block: logical_sb_block);
5104	if (IS_ERR(ptr: bh)) {
5105	ext4_msg(sb, KERN_ERR, "Can't read superblock on 2nd try");
5106	ret = PTR_ERR(ptr: bh);
5107	bh = NULL;
5108	goto out;
5109	}
5110	es = (struct ext4_super_block *)(bh->b_data + offset);
5111	sbi->s_es = es;
5112	if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
5113	ext4_msg(sb, KERN_ERR, "Magic mismatch, very weird!");
5114	goto out;
5115	}
5116	*lsb = logical_sb_block;
5117	sbi->s_sbh = bh;
5118	return 0;
5119	out:
5120	brelse(bh);
5121	return ret;
5122	}
5123
5124	static void ext4_hash_info_init(struct super_block *sb)
5125	{
5126	struct ext4_sb_info *sbi = EXT4_SB(sb);
5127	struct ext4_super_block *es = sbi->s_es;
5128	unsigned int i;
5129
5130	for (i = 0; i < 4; i++)
5131	sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
5132
5133	sbi->s_def_hash_version = es->s_def_hash_version;
5134	if (ext4_has_feature_dir_index(sb)) {
5135	i = le32_to_cpu(es->s_flags);
5136	if (i & EXT2_FLAGS_UNSIGNED_HASH)
5137	sbi->s_hash_unsigned = 3;
5138	else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
5139	#ifdef __CHAR_UNSIGNED__
5140	if (!sb_rdonly(sb))
5141	es->s_flags |=
5142	cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
5143	sbi->s_hash_unsigned = 3;
5144	#else
5145	if (!sb_rdonly(sb))
5146	es->s_flags |=
5147	cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
5148	#endif
5149	}
5150	}
5151	}
5152
5153	static int ext4_block_group_meta_init(struct super_block *sb, int silent)
5154	{
5155	struct ext4_sb_info *sbi = EXT4_SB(sb);
5156	struct ext4_super_block *es = sbi->s_es;
5157	int has_huge_files;
5158
5159	has_huge_files = ext4_has_feature_huge_file(sb);
5160	sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(bits: sb->s_blocksize_bits,
5161	has_huge_files);
5162	sb->s_maxbytes = ext4_max_size(blkbits: sb->s_blocksize_bits, has_huge_files);
5163
5164	sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
5165	if (ext4_has_feature_64bit(sb)) {
5166	if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
5167	sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
5168	!is_power_of_2(n: sbi->s_desc_size)) {
5169	ext4_msg(sb, KERN_ERR,
5170	"unsupported descriptor size %lu",
5171	sbi->s_desc_size);
5172	return -EINVAL;
5173	}
5174	} else
5175	sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
5176
5177	sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
5178	sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
5179
5180	sbi->s_inodes_per_block = sb->s_blocksize / EXT4_INODE_SIZE(sb);
5181	if (sbi->s_inodes_per_block == 0 || sbi->s_blocks_per_group == 0) {
5182	if (!silent)
5183	ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
5184	return -EINVAL;
5185	}
5186	if (sbi->s_inodes_per_group < sbi->s_inodes_per_block ||
5187	sbi->s_inodes_per_group > sb->s_blocksize * 8) {
5188	ext4_msg(sb, KERN_ERR, "invalid inodes per group: %lu\n",
5189	sbi->s_inodes_per_group);
5190	return -EINVAL;
5191	}
5192	sbi->s_itb_per_group = sbi->s_inodes_per_group /
5193	sbi->s_inodes_per_block;
5194	sbi->s_desc_per_block = sb->s_blocksize / EXT4_DESC_SIZE(sb);
5195	sbi->s_mount_state = le16_to_cpu(es->s_state) & ~EXT4_FC_REPLAY;
5196	sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
5197	sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
5198
5199	return 0;
5200	}
5201
5202	static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb)
5203	{
5204	struct ext4_super_block *es = NULL;
5205	struct ext4_sb_info *sbi = EXT4_SB(sb);
5206	ext4_fsblk_t logical_sb_block;
5207	struct inode *root;
5208	int needs_recovery;
5209	int err;
5210	ext4_group_t first_not_zeroed;
5211	struct ext4_fs_context *ctx = fc->fs_private;
5212	int silent = fc->sb_flags & SB_SILENT;
5213
5214	/* Set defaults for the variables that will be set during parsing */
5215	if (!(ctx->spec & EXT4_SPEC_JOURNAL_IOPRIO))
5216	ctx->journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
5217
5218	sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
5219	sbi->s_sectors_written_start =
5220	part_stat_read(sb->s_bdev, sectors[STAT_WRITE]);
5221
5222	err = ext4_load_super(sb, lsb: &logical_sb_block, silent);
5223	if (err)
5224	goto out_fail;
5225
5226	es = sbi->s_es;
5227	sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
5228
5229	err = ext4_init_metadata_csum(sb, es);
5230	if (err)
5231	goto failed_mount;
5232
5233	ext4_set_def_opts(sb, es);
5234
5235	sbi->s_resuid = make_kuid(from: &init_user_ns, le16_to_cpu(es->s_def_resuid));
5236	sbi->s_resgid = make_kgid(from: &init_user_ns, le16_to_cpu(es->s_def_resgid));
5237	sbi->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE * HZ;
5238	sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
5239	sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
5240
5241	/*
5242	* set default s_li_wait_mult for lazyinit, for the case there is
5243	* no mount option specified.
5244	*/
5245	sbi->s_li_wait_mult = EXT4_DEF_LI_WAIT_MULT;
5246
5247	err = ext4_inode_info_init(sb, es);
5248	if (err)
5249	goto failed_mount;
5250
5251	err = parse_apply_sb_mount_options(sb, m_ctx: ctx);
5252	if (err < 0)
5253	goto failed_mount;
5254
5255	sbi->s_def_mount_opt = sbi->s_mount_opt;
5256	sbi->s_def_mount_opt2 = sbi->s_mount_opt2;
5257
5258	err = ext4_check_opt_consistency(fc, sb);
5259	if (err < 0)
5260	goto failed_mount;
5261
5262	ext4_apply_options(fc, sb);
5263
5264	err = ext4_encoding_init(sb, es);
5265	if (err)
5266	goto failed_mount;
5267
5268	err = ext4_check_journal_data_mode(sb);
5269	if (err)
5270	goto failed_mount;
5271
5272	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
5273	(test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
5274
5275	/* i_version is always enabled now */
5276	sb->s_flags |= SB_I_VERSION;
5277
5278	err = ext4_check_feature_compatibility(sb, es, silent);
5279	if (err)
5280	goto failed_mount;
5281
5282	err = ext4_block_group_meta_init(sb, silent);
5283	if (err)
5284	goto failed_mount;
5285
5286	ext4_hash_info_init(sb);
5287
5288	err = ext4_handle_clustersize(sb);
5289	if (err)
5290	goto failed_mount;
5291
5292	err = ext4_check_geometry(sb, es);
5293	if (err)
5294	goto failed_mount;
5295
5296	timer_setup(&sbi->s_err_report, print_daily_error_info, 0);
5297	spin_lock_init(&sbi->s_error_lock);
5298	INIT_WORK(&sbi->s_sb_upd_work, update_super_work);
5299
5300	err = ext4_group_desc_init(sb, es, logical_sb_block, first_not_zeroed: &first_not_zeroed);
5301	if (err)
5302	goto failed_mount3;
5303
5304	err = ext4_es_register_shrinker(sbi);
5305	if (err)
5306	goto failed_mount3;
5307
5308	sbi->s_stripe = ext4_get_stripe_size(sbi);
5309	/*
5310	* It's hard to get stripe aligned blocks if stripe is not aligned with
5311	* cluster, just disable stripe and alert user to simpfy code and avoid
5312	* stripe aligned allocation which will rarely successes.
5313	*/
5314	if (sbi->s_stripe > 0 && sbi->s_cluster_ratio > 1 &&
5315	sbi->s_stripe % sbi->s_cluster_ratio != 0) {
5316	ext4_msg(sb, KERN_WARNING,
5317	"stripe (%lu) is not aligned with cluster size (%u), "
5318	"stripe is disabled",
5319	sbi->s_stripe, sbi->s_cluster_ratio);
5320	sbi->s_stripe = 0;
5321	}
5322	sbi->s_extent_max_zeroout_kb = 32;
5323
5324	/*
5325	* set up enough so that it can read an inode
5326	*/
5327	sb->s_op = &ext4_sops;
5328	sb->s_export_op = &ext4_export_ops;
5329	sb->s_xattr = ext4_xattr_handlers;
5330	#ifdef CONFIG_FS_ENCRYPTION
5331	sb->s_cop = &ext4_cryptops;
5332	#endif
5333	#ifdef CONFIG_FS_VERITY
5334	sb->s_vop = &ext4_verityops;
5335	#endif
5336	#ifdef CONFIG_QUOTA
5337	sb->dq_op = &ext4_quota_operations;
5338	if (ext4_has_feature_quota(sb))
5339	sb->s_qcop = &dquot_quotactl_sysfile_ops;
5340	else
5341	sb->s_qcop = &ext4_qctl_operations;
5342	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
5343	#endif
5344	super_set_uuid(sb, uuid: es->s_uuid, len: sizeof(es->s_uuid));
5345
5346	INIT_LIST_HEAD(list: &sbi->s_orphan); /* unlinked but open files */
5347	mutex_init(&sbi->s_orphan_lock);
5348
5349	ext4_fast_commit_init(sb);
5350
5351	sb->s_root = NULL;
5352
5353	needs_recovery = (es->s_last_orphan != 0 ||
5354	ext4_has_feature_orphan_present(sb) ||
5355	ext4_has_feature_journal_needs_recovery(sb));
5356
5357	if (ext4_has_feature_mmp(sb) && !sb_rdonly(sb)) {
5358	err = ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block));
5359	if (err)
5360	goto failed_mount3a;
5361	}
5362
5363	err = -EINVAL;
5364	/*
5365	* The first inode we look at is the journal inode. Don't try
5366	* root first: it may be modified in the journal!
5367	*/
5368	if (!test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb)) {
5369	err = ext4_load_and_init_journal(sb, es, ctx);
5370	if (err)
5371	goto failed_mount3a;
5372	} else if (test_opt(sb, NOLOAD) && !sb_rdonly(sb) &&
5373	ext4_has_feature_journal_needs_recovery(sb)) {
5374	ext4_msg(sb, KERN_ERR, "required journal recovery "
5375	"suppressed and not mounted read-only");
5376	goto failed_mount3a;
5377	} else {
5378	/* Nojournal mode, all journal mount options are illegal */
5379	if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
5380	ext4_msg(sb, KERN_ERR, "can't mount with "
5381	"journal_async_commit, fs mounted w/o journal");
5382	goto failed_mount3a;
5383	}
5384
5385	if (test_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM)) {
5386	ext4_msg(sb, KERN_ERR, "can't mount with "
5387	"journal_checksum, fs mounted w/o journal");
5388	goto failed_mount3a;
5389	}
5390	if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
5391	ext4_msg(sb, KERN_ERR, "can't mount with "
5392	"commit=%lu, fs mounted w/o journal",
5393	sbi->s_commit_interval / HZ);
5394	goto failed_mount3a;
5395	}
5396	if (EXT4_MOUNT_DATA_FLAGS &
5397	(sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
5398	ext4_msg(sb, KERN_ERR, "can't mount with "
5399	"data=, fs mounted w/o journal");
5400	goto failed_mount3a;
5401	}
5402	sbi->s_def_mount_opt &= ~EXT4_MOUNT_JOURNAL_CHECKSUM;
5403	clear_opt(sb, JOURNAL_CHECKSUM);
5404	clear_opt(sb, DATA_FLAGS);
5405	clear_opt2(sb, JOURNAL_FAST_COMMIT);
5406	sbi->s_journal = NULL;
5407	needs_recovery = 0;
5408	}
5409
5410	if (!test_opt(sb, NO_MBCACHE)) {
5411	sbi->s_ea_block_cache = ext4_xattr_create_cache();
5412	if (!sbi->s_ea_block_cache) {
5413	ext4_msg(sb, KERN_ERR,
5414	"Failed to create ea_block_cache");
5415	err = -EINVAL;
5416	goto failed_mount_wq;
5417	}
5418
5419	if (ext4_has_feature_ea_inode(sb)) {
5420	sbi->s_ea_inode_cache = ext4_xattr_create_cache();
5421	if (!sbi->s_ea_inode_cache) {
5422	ext4_msg(sb, KERN_ERR,
5423	"Failed to create ea_inode_cache");
5424	err = -EINVAL;
5425	goto failed_mount_wq;
5426	}
5427	}
5428	}
5429
5430	/*
5431	* Get the # of file system overhead blocks from the
5432	* superblock if present.
5433	*/
5434	sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
5435	/* ignore the precalculated value if it is ridiculous */
5436	if (sbi->s_overhead > ext4_blocks_count(es))
5437	sbi->s_overhead = 0;
5438	/*
5439	* If the bigalloc feature is not enabled recalculating the
5440	* overhead doesn't take long, so we might as well just redo
5441	* it to make sure we are using the correct value.
5442	*/
5443	if (!ext4_has_feature_bigalloc(sb))
5444	sbi->s_overhead = 0;
5445	if (sbi->s_overhead == 0) {
5446	err = ext4_calculate_overhead(sb);
5447	if (err)
5448	goto failed_mount_wq;
5449	}
5450
5451	/*
5452	* The maximum number of concurrent works can be high and
5453	* concurrency isn't really necessary. Limit it to 1.
5454	*/
5455	EXT4_SB(sb)->rsv_conversion_wq =
5456	alloc_workqueue(fmt: "ext4-rsv-conversion", flags: WQ_MEM_RECLAIM | WQ_UNBOUND, max_active: 1);
5457	if (!EXT4_SB(sb)->rsv_conversion_wq) {
5458	printk(KERN_ERR "EXT4-fs: failed to create workqueue\n");
5459	err = -ENOMEM;
5460	goto failed_mount4;
5461	}
5462
5463	/*
5464	* The jbd2_journal_load will have done any necessary log recovery,
5465	* so we can safely mount the rest of the filesystem now.
5466	*/
5467
5468	root = ext4_iget(sb, EXT4_ROOT_INO, EXT4_IGET_SPECIAL);
5469	if (IS_ERR(ptr: root)) {
5470	ext4_msg(sb, KERN_ERR, "get root inode failed");
5471	err = PTR_ERR(ptr: root);
5472	root = NULL;
5473	goto failed_mount4;
5474	}
5475	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
5476	ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
5477	iput(root);
5478	err = -EFSCORRUPTED;
5479	goto failed_mount4;
5480	}
5481
5482	generic_set_sb_d_ops(sb);
5483	sb->s_root = d_make_root(root);
5484	if (!sb->s_root) {
5485	ext4_msg(sb, KERN_ERR, "get root dentry failed");
5486	err = -ENOMEM;
5487	goto failed_mount4;
5488	}
5489
5490	err = ext4_setup_super(sb, es, read_only: sb_rdonly(sb));
5491	if (err == -EROFS) {
5492	sb->s_flags |= SB_RDONLY;
5493	} else if (err)
5494	goto failed_mount4a;
5495
5496	ext4_set_resv_clusters(sb);
5497
5498	if (test_opt(sb, BLOCK_VALIDITY)) {
5499	err = ext4_setup_system_zone(sb);
5500	if (err) {
5501	ext4_msg(sb, KERN_ERR, "failed to initialize system "
5502	"zone (%d)", err);
5503	goto failed_mount4a;
5504	}
5505	}
5506	ext4_fc_replay_cleanup(sb);
5507
5508	ext4_ext_init(sb);
5509
5510	/*
5511	* Enable optimize_scan if number of groups is > threshold. This can be
5512	* turned off by passing "mb_optimize_scan=0". This can also be
5513	* turned on forcefully by passing "mb_optimize_scan=1".
5514	*/
5515	if (!(ctx->spec & EXT4_SPEC_mb_optimize_scan)) {
5516	if (sbi->s_groups_count >= MB_DEFAULT_LINEAR_SCAN_THRESHOLD)
5517	set_opt2(sb, MB_OPTIMIZE_SCAN);
5518	else
5519	clear_opt2(sb, MB_OPTIMIZE_SCAN);
5520	}
5521
5522	err = ext4_mb_init(sb);
5523	if (err) {
5524	ext4_msg(sb, KERN_ERR, "failed to initialize mballoc (%d)",
5525	err);
5526	goto failed_mount5;
5527	}
5528
5529	/*
5530	* We can only set up the journal commit callback once
5531	* mballoc is initialized
5532	*/
5533	if (sbi->s_journal)
5534	sbi->s_journal->j_commit_callback =
5535	ext4_journal_commit_callback;
5536
5537	err = ext4_percpu_param_init(sbi);
5538	if (err)
5539	goto failed_mount6;
5540
5541	if (ext4_has_feature_flex_bg(sb))
5542	if (!ext4_fill_flex_info(sb)) {
5543	ext4_msg(sb, KERN_ERR,
5544	"unable to initialize "
5545	"flex_bg meta info!");
5546	err = -ENOMEM;
5547	goto failed_mount6;
5548	}
5549
5550	err = ext4_register_li_request(sb, first_not_zeroed);
5551	if (err)
5552	goto failed_mount6;
5553
5554	err = ext4_register_sysfs(sb);
5555	if (err)
5556	goto failed_mount7;
5557
5558	err = ext4_init_orphan_info(sb);
5559	if (err)
5560	goto failed_mount8;
5561	#ifdef CONFIG_QUOTA
5562	/* Enable quota usage during mount. */
5563	if (ext4_has_feature_quota(sb) && !sb_rdonly(sb)) {
5564	err = ext4_enable_quotas(sb);
5565	if (err)
5566	goto failed_mount9;
5567	}
5568	#endif /* CONFIG_QUOTA */
5569
5570	/*
5571	* Save the original bdev mapping's wb_err value which could be
5572	* used to detect the metadata async write error.
5573	*/
5574	spin_lock_init(&sbi->s_bdev_wb_lock);
5575	errseq_check_and_advance(eseq: &sb->s_bdev->bd_inode->i_mapping->wb_err,
5576	since: &sbi->s_bdev_wb_err);
5577	EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
5578	ext4_orphan_cleanup(sb, es);
5579	EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
5580	/*
5581	* Update the checksum after updating free space/inode counters and
5582	* ext4_orphan_cleanup. Otherwise the superblock can have an incorrect
5583	* checksum in the buffer cache until it is written out and
5584	* e2fsprogs programs trying to open a file system immediately
5585	* after it is mounted can fail.
5586	*/
5587	ext4_superblock_csum_set(sb);
5588	if (needs_recovery) {
5589	ext4_msg(sb, KERN_INFO, "recovery complete");
5590	err = ext4_mark_recovery_complete(sb, es);
5591	if (err)
5592	goto failed_mount10;
5593	}
5594
5595	if (test_opt(sb, DISCARD) && !bdev_max_discard_sectors(bdev: sb->s_bdev))
5596	ext4_msg(sb, KERN_WARNING,
5597	"mounting with \"discard\" option, but the device does not support discard");
5598
5599	if (es->s_error_count)
5600	mod_timer(timer: &sbi->s_err_report, expires: jiffies + 300*HZ); /* 5 minutes */
5601
5602	/* Enable message ratelimiting. Default is 10 messages per 5 secs. */
5603	ratelimit_state_init(rs: &sbi->s_err_ratelimit_state, interval: 5 * HZ, burst: 10);
5604	ratelimit_state_init(rs: &sbi->s_warning_ratelimit_state, interval: 5 * HZ, burst: 10);
5605	ratelimit_state_init(rs: &sbi->s_msg_ratelimit_state, interval: 5 * HZ, burst: 10);
5606	atomic_set(v: &sbi->s_warning_count, i: 0);
5607	atomic_set(v: &sbi->s_msg_count, i: 0);
5608
5609	return 0;
5610
5611	failed_mount10:
5612	ext4_quotas_off(sb, EXT4_MAXQUOTAS);
5613	failed_mount9: __maybe_unused
5614	ext4_release_orphan_info(sb);
5615	failed_mount8:
5616	ext4_unregister_sysfs(sb);
5617	kobject_put(kobj: &sbi->s_kobj);
5618	failed_mount7:
5619	ext4_unregister_li_request(sb);
5620	failed_mount6:
5621	ext4_mb_release(sb);
5622	ext4_flex_groups_free(sbi);
5623	ext4_percpu_param_destroy(sbi);
5624	failed_mount5:
5625	ext4_ext_release(sb);
5626	ext4_release_system_zone(sb);
5627	failed_mount4a:
5628	dput(sb->s_root);
5629	sb->s_root = NULL;
5630	failed_mount4:
5631	ext4_msg(sb, KERN_ERR, "mount failed");
5632	if (EXT4_SB(sb)->rsv_conversion_wq)
5633	destroy_workqueue(wq: EXT4_SB(sb)->rsv_conversion_wq);
5634	failed_mount_wq:
5635	ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
5636	sbi->s_ea_inode_cache = NULL;
5637
5638	ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
5639	sbi->s_ea_block_cache = NULL;
5640
5641	if (sbi->s_journal) {
5642	/* flush s_sb_upd_work before journal destroy. */
5643	flush_work(work: &sbi->s_sb_upd_work);
5644	jbd2_journal_destroy(sbi->s_journal);
5645	sbi->s_journal = NULL;
5646	}
5647	failed_mount3a:
5648	ext4_es_unregister_shrinker(sbi);
5649	failed_mount3:
5650	/* flush s_sb_upd_work before sbi destroy */
5651	flush_work(work: &sbi->s_sb_upd_work);
5652	del_timer_sync(timer: &sbi->s_err_report);
5653	ext4_stop_mmpd(sbi);
5654	ext4_group_desc_free(sbi);
5655	failed_mount:
5656	if (sbi->s_chksum_driver)
5657	crypto_free_shash(tfm: sbi->s_chksum_driver);
5658
5659	#if IS_ENABLED(CONFIG_UNICODE)
5660	utf8_unload(um: sb->s_encoding);
5661	#endif
5662
5663	#ifdef CONFIG_QUOTA
5664	for (unsigned int i = 0; i < EXT4_MAXQUOTAS; i++)
5665	kfree(objp: get_qf_name(sb, sbi, type: i));
5666	#endif
5667	fscrypt_free_dummy_policy(dummy_policy: &sbi->s_dummy_enc_policy);
5668	brelse(bh: sbi->s_sbh);
5669	if (sbi->s_journal_bdev_file) {
5670	invalidate_bdev(bdev: file_bdev(bdev_file: sbi->s_journal_bdev_file));
5671	bdev_fput(bdev_file: sbi->s_journal_bdev_file);
5672	}
5673	out_fail:
5674	invalidate_bdev(bdev: sb->s_bdev);
5675	sb->s_fs_info = NULL;
5676	return err;
5677	}
5678
5679	static int ext4_fill_super(struct super_block *sb, struct fs_context *fc)
5680	{
5681	struct ext4_fs_context *ctx = fc->fs_private;
5682	struct ext4_sb_info *sbi;
5683	const char *descr;
5684	int ret;
5685
5686	sbi = ext4_alloc_sbi(sb);
5687	if (!sbi)
5688	return -ENOMEM;
5689
5690	fc->s_fs_info = sbi;
5691
5692	/* Cleanup superblock name */
5693	strreplace(str: sb->s_id, old: '/', new: '!');
5694
5695	sbi->s_sb_block = 1; /* Default super block location */
5696	if (ctx->spec & EXT4_SPEC_s_sb_block)
5697	sbi->s_sb_block = ctx->s_sb_block;
5698
5699	ret = __ext4_fill_super(fc, sb);
5700	if (ret < 0)
5701	goto free_sbi;
5702
5703	if (sbi->s_journal) {
5704	if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
5705	descr = " journalled data mode";
5706	else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
5707	descr = " ordered data mode";
5708	else
5709	descr = " writeback data mode";
5710	} else
5711	descr = "out journal";
5712
5713	if (___ratelimit(rs: &ext4_mount_msg_ratelimit, func: "EXT4-fs mount"))
5714	ext4_msg(sb, KERN_INFO, "mounted filesystem %pU %s with%s. "
5715	"Quota mode: %s.", &sb->s_uuid,
5716	sb_rdonly(sb) ? "ro" : "r/w", descr,
5717	ext4_quota_mode(sb));
5718
5719	/* Update the s_overhead_clusters if necessary */
5720	ext4_update_overhead(sb, force: false);
5721	return 0;
5722
5723	free_sbi:
5724	ext4_free_sbi(sbi);
5725	fc->s_fs_info = NULL;
5726	return ret;
5727	}
5728
5729	static int ext4_get_tree(struct fs_context *fc)
5730	{
5731	return get_tree_bdev(fc, fill_super: ext4_fill_super);
5732	}
5733
5734	/*
5735	* Setup any per-fs journal parameters now. We'll do this both on
5736	* initial mount, once the journal has been initialised but before we've
5737	* done any recovery; and again on any subsequent remount.
5738	*/
5739	static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
5740	{
5741	struct ext4_sb_info *sbi = EXT4_SB(sb);
5742
5743	journal->j_commit_interval = sbi->s_commit_interval;
5744	journal->j_min_batch_time = sbi->s_min_batch_time;
5745	journal->j_max_batch_time = sbi->s_max_batch_time;
5746	ext4_fc_init(sb, journal);
5747
5748	write_lock(&journal->j_state_lock);
5749	if (test_opt(sb, BARRIER))
5750	journal->j_flags |= JBD2_BARRIER;
5751	else
5752	journal->j_flags &= ~JBD2_BARRIER;
5753	if (test_opt(sb, DATA_ERR_ABORT))
5754	journal->j_flags |= JBD2_ABORT_ON_SYNCDATA_ERR;
5755	else
5756	journal->j_flags &= ~JBD2_ABORT_ON_SYNCDATA_ERR;
5757	/*
5758	* Always enable journal cycle record option, letting the journal
5759	* records log transactions continuously between each mount.
5760	*/
5761	journal->j_flags |= JBD2_CYCLE_RECORD;
5762	write_unlock(&journal->j_state_lock);
5763	}
5764
5765	static struct inode *ext4_get_journal_inode(struct super_block *sb,
5766	unsigned int journal_inum)
5767	{
5768	struct inode *journal_inode;
5769
5770	/*
5771	* Test for the existence of a valid inode on disk. Bad things
5772	* happen if we iget() an unused inode, as the subsequent iput()
5773	* will try to delete it.
5774	*/
5775	journal_inode = ext4_iget(sb, journal_inum, EXT4_IGET_SPECIAL);
5776	if (IS_ERR(ptr: journal_inode)) {
5777	ext4_msg(sb, KERN_ERR, "no journal found");
5778	return ERR_CAST(ptr: journal_inode);
5779	}
5780	if (!journal_inode->i_nlink) {
5781	make_bad_inode(journal_inode);
5782	iput(journal_inode);
5783	ext4_msg(sb, KERN_ERR, "journal inode is deleted");
5784	return ERR_PTR(error: -EFSCORRUPTED);
5785	}
5786	if (!S_ISREG(journal_inode->i_mode) || IS_ENCRYPTED(journal_inode)) {
5787	ext4_msg(sb, KERN_ERR, "invalid journal inode");
5788	iput(journal_inode);
5789	return ERR_PTR(error: -EFSCORRUPTED);
5790	}
5791
5792	ext4_debug("Journal inode found at %p: %lld bytes\n",
5793	journal_inode, journal_inode->i_size);
5794	return journal_inode;
5795	}
5796
5797	static int ext4_journal_bmap(journal_t *journal, sector_t *block)
5798	{
5799	struct ext4_map_blocks map;
5800	int ret;
5801
5802	if (journal->j_inode == NULL)
5803	return 0;
5804
5805	map.m_lblk = *block;
5806	map.m_len = 1;
5807	ret = ext4_map_blocks(NULL, inode: journal->j_inode, map: &map, flags: 0);
5808	if (ret <= 0) {
5809	ext4_msg(journal->j_inode->i_sb, KERN_CRIT,
5810	"journal bmap failed: block %llu ret %d\n",
5811	*block, ret);
5812	jbd2_journal_abort(journal, ret ? ret : -EIO);
5813	return ret;
5814	}
5815	*block = map.m_pblk;
5816	return 0;
5817	}
5818
5819	static journal_t *ext4_open_inode_journal(struct super_block *sb,
5820	unsigned int journal_inum)
5821	{
5822	struct inode *journal_inode;
5823	journal_t *journal;
5824
5825	journal_inode = ext4_get_journal_inode(sb, journal_inum);
5826	if (IS_ERR(ptr: journal_inode))
5827	return ERR_CAST(ptr: journal_inode);
5828
5829	journal = jbd2_journal_init_inode(journal_inode);
5830	if (IS_ERR(ptr: journal)) {
5831	ext4_msg(sb, KERN_ERR, "Could not load journal inode");
5832	iput(journal_inode);
5833	return ERR_CAST(ptr: journal);
5834	}
5835	journal->j_private = sb;
5836	journal->j_bmap = ext4_journal_bmap;
5837	ext4_init_journal_params(sb, journal);
5838	return journal;
5839	}
5840
5841	static struct file *ext4_get_journal_blkdev(struct super_block *sb,
5842	dev_t j_dev, ext4_fsblk_t *j_start,
5843	ext4_fsblk_t *j_len)
5844	{
5845	struct buffer_head *bh;
5846	struct block_device *bdev;
5847	struct file *bdev_file;
5848	int hblock, blocksize;
5849	ext4_fsblk_t sb_block;
5850	unsigned long offset;
5851	struct ext4_super_block *es;
5852	int errno;
5853
5854	bdev_file = bdev_file_open_by_dev(dev: j_dev,
5855	BLK_OPEN_READ | BLK_OPEN_WRITE | BLK_OPEN_RESTRICT_WRITES,
5856	holder: sb, hops: &fs_holder_ops);
5857	if (IS_ERR(ptr: bdev_file)) {
5858	ext4_msg(sb, KERN_ERR,
5859	"failed to open journal device unknown-block(%u,%u) %ld",
5860	MAJOR(j_dev), MINOR(j_dev), PTR_ERR(bdev_file));
5861	return bdev_file;
5862	}
5863
5864	bdev = file_bdev(bdev_file);
5865	blocksize = sb->s_blocksize;
5866	hblock = bdev_logical_block_size(bdev);
5867	if (blocksize < hblock) {
5868	ext4_msg(sb, KERN_ERR,
5869	"blocksize too small for journal device");
5870	errno = -EINVAL;
5871	goto out_bdev;
5872	}
5873
5874	sb_block = EXT4_MIN_BLOCK_SIZE / blocksize;
5875	offset = EXT4_MIN_BLOCK_SIZE % blocksize;
5876	set_blocksize(bdev, size: blocksize);
5877	bh = __bread(bdev, block: sb_block, size: blocksize);
5878	if (!bh) {
5879	ext4_msg(sb, KERN_ERR, "couldn't read superblock of "
5880	"external journal");
5881	errno = -EINVAL;
5882	goto out_bdev;
5883	}
5884
5885	es = (struct ext4_super_block *) (bh->b_data + offset);
5886	if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
5887	!(le32_to_cpu(es->s_feature_incompat) &
5888	EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
5889	ext4_msg(sb, KERN_ERR, "external journal has bad superblock");
5890	errno = -EFSCORRUPTED;
5891	goto out_bh;
5892	}
5893
5894	if ((le32_to_cpu(es->s_feature_ro_compat) &
5895	EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
5896	es->s_checksum != ext4_superblock_csum(sb, es)) {
5897	ext4_msg(sb, KERN_ERR, "external journal has corrupt superblock");
5898	errno = -EFSCORRUPTED;
5899	goto out_bh;
5900	}
5901
5902	if (memcmp(p: EXT4_SB(sb)->s_es->s_journal_uuid, q: es->s_uuid, size: 16)) {
5903	ext4_msg(sb, KERN_ERR, "journal UUID does not match");
5904	errno = -EFSCORRUPTED;
5905	goto out_bh;
5906	}
5907
5908	*j_start = sb_block + 1;
5909	*j_len = ext4_blocks_count(es);
5910	brelse(bh);
5911	return bdev_file;
5912
5913	out_bh:
5914	brelse(bh);
5915	out_bdev:
5916	bdev_fput(bdev_file);
5917	return ERR_PTR(error: errno);
5918	}
5919
5920	static journal_t *ext4_open_dev_journal(struct super_block *sb,
5921	dev_t j_dev)
5922	{
5923	journal_t *journal;
5924	ext4_fsblk_t j_start;
5925	ext4_fsblk_t j_len;
5926	struct file *bdev_file;
5927	int errno = 0;
5928
5929	bdev_file = ext4_get_journal_blkdev(sb, j_dev, j_start: &j_start, j_len: &j_len);
5930	if (IS_ERR(ptr: bdev_file))
5931	return ERR_CAST(ptr: bdev_file);
5932
5933	journal = jbd2_journal_init_dev(bdev: file_bdev(bdev_file), fs_dev: sb->s_bdev, start: j_start,
5934	len: j_len, bsize: sb->s_blocksize);
5935	if (IS_ERR(ptr: journal)) {
5936	ext4_msg(sb, KERN_ERR, "failed to create device journal");
5937	errno = PTR_ERR(ptr: journal);
5938	goto out_bdev;
5939	}
5940	if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
5941	ext4_msg(sb, KERN_ERR, "External journal has more than one "
5942	"user (unsupported) - %d",
5943	be32_to_cpu(journal->j_superblock->s_nr_users));
5944	errno = -EINVAL;
5945	goto out_journal;
5946	}
5947	journal->j_private = sb;
5948	EXT4_SB(sb)->s_journal_bdev_file = bdev_file;
5949	ext4_init_journal_params(sb, journal);
5950	return journal;
5951
5952	out_journal:
5953	jbd2_journal_destroy(journal);
5954	out_bdev:
5955	bdev_fput(bdev_file);
5956	return ERR_PTR(error: errno);
5957	}
5958
5959	static int ext4_load_journal(struct super_block *sb,
5960	struct ext4_super_block *es,
5961	unsigned long journal_devnum)
5962	{
5963	journal_t *journal;
5964	unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
5965	dev_t journal_dev;
5966	int err = 0;
5967	int really_read_only;
5968	int journal_dev_ro;
5969
5970	if (WARN_ON_ONCE(!ext4_has_feature_journal(sb)))
5971	return -EFSCORRUPTED;
5972
5973	if (journal_devnum &&
5974	journal_devnum != le32_to_cpu(es->s_journal_dev)) {
5975	ext4_msg(sb, KERN_INFO, "external journal device major/minor "
5976	"numbers have changed");
5977	journal_dev = new_decode_dev(dev: journal_devnum);
5978	} else
5979	journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
5980
5981	if (journal_inum && journal_dev) {
5982	ext4_msg(sb, KERN_ERR,
5983	"filesystem has both journal inode and journal device!");
5984	return -EINVAL;
5985	}
5986
5987	if (journal_inum) {
5988	journal = ext4_open_inode_journal(sb, journal_inum);
5989	if (IS_ERR(ptr: journal))
5990	return PTR_ERR(ptr: journal);
5991	} else {
5992	journal = ext4_open_dev_journal(sb, j_dev: journal_dev);
5993	if (IS_ERR(ptr: journal))
5994	return PTR_ERR(ptr: journal);
5995	}
5996
5997	journal_dev_ro = bdev_read_only(bdev: journal->j_dev);
5998	really_read_only = bdev_read_only(bdev: sb->s_bdev) | journal_dev_ro;
5999
6000	if (journal_dev_ro && !sb_rdonly(sb)) {
6001	ext4_msg(sb, KERN_ERR,
6002	"journal device read-only, try mounting with '-o ro'");
6003	err = -EROFS;
6004	goto err_out;
6005	}
6006
6007	/*
6008	* Are we loading a blank journal or performing recovery after a
6009	* crash? For recovery, we need to check in advance whether we
6010	* can get read-write access to the device.
6011	*/
6012	if (ext4_has_feature_journal_needs_recovery(sb)) {
6013	if (sb_rdonly(sb)) {
6014	ext4_msg(sb, KERN_INFO, "INFO: recovery "
6015	"required on readonly filesystem");
6016	if (really_read_only) {
6017	ext4_msg(sb, KERN_ERR, "write access "
6018	"unavailable, cannot proceed "
6019	"(try mounting with noload)");
6020	err = -EROFS;
6021	goto err_out;
6022	}
6023	ext4_msg(sb, KERN_INFO, "write access will "
6024	"be enabled during recovery");
6025	}
6026	}
6027
6028	if (!(journal->j_flags & JBD2_BARRIER))
6029	ext4_msg(sb, KERN_INFO, "barriers disabled");
6030
6031	if (!ext4_has_feature_journal_needs_recovery(sb))
6032	err = jbd2_journal_wipe(journal, !really_read_only);
6033	if (!err) {
6034	char *save = kmalloc(EXT4_S_ERR_LEN, GFP_KERNEL);
6035	__le16 orig_state;
6036	bool changed = false;
6037
6038	if (save)
6039	memcpy(save, ((char *) es) +
6040	EXT4_S_ERR_START, EXT4_S_ERR_LEN);
6041	err = jbd2_journal_load(journal);
6042	if (save && memcmp(p: ((char *) es) + EXT4_S_ERR_START,
6043	q: save, EXT4_S_ERR_LEN)) {
6044	memcpy(((char *) es) + EXT4_S_ERR_START,
6045	save, EXT4_S_ERR_LEN);
6046	changed = true;
6047	}
6048	kfree(objp: save);
6049	orig_state = es->s_state;
6050	es->s_state |= cpu_to_le16(EXT4_SB(sb)->s_mount_state &
6051	EXT4_ERROR_FS);
6052	if (orig_state != es->s_state)
6053	changed = true;
6054	/* Write out restored error information to the superblock */
6055	if (changed && !really_read_only) {
6056	int err2;
6057	err2 = ext4_commit_super(sb);
6058	err = err ? : err2;
6059	}
6060	}
6061
6062	if (err) {
6063	ext4_msg(sb, KERN_ERR, "error loading journal");
6064	goto err_out;
6065	}
6066
6067	EXT4_SB(sb)->s_journal = journal;
6068	err = ext4_clear_journal_err(sb, es);
6069	if (err) {
6070	EXT4_SB(sb)->s_journal = NULL;
6071	jbd2_journal_destroy(journal);
6072	return err;
6073	}
6074
6075	if (!really_read_only && journal_devnum &&
6076	journal_devnum != le32_to_cpu(es->s_journal_dev)) {
6077	es->s_journal_dev = cpu_to_le32(journal_devnum);
6078	ext4_commit_super(sb);
6079	}
6080	if (!really_read_only && journal_inum &&
6081	journal_inum != le32_to_cpu(es->s_journal_inum)) {
6082	es->s_journal_inum = cpu_to_le32(journal_inum);
6083	ext4_commit_super(sb);
6084	}
6085
6086	return 0;
6087
6088	err_out:
6089	jbd2_journal_destroy(journal);
6090	return err;
6091	}
6092
6093	/* Copy state of EXT4_SB(sb) into buffer for on-disk superblock */
6094	static void ext4_update_super(struct super_block *sb)
6095	{
6096	struct ext4_sb_info *sbi = EXT4_SB(sb);
6097	struct ext4_super_block *es = sbi->s_es;
6098	struct buffer_head *sbh = sbi->s_sbh;
6099
6100	lock_buffer(bh: sbh);
6101	/*
6102	* If the file system is mounted read-only, don't update the
6103	* superblock write time. This avoids updating the superblock
6104	* write time when we are mounting the root file system
6105	* read/only but we need to replay the journal; at that point,
6106	* for people who are east of GMT and who make their clock
6107	* tick in localtime for Windows bug-for-bug compatibility,
6108	* the clock is set in the future, and this will cause e2fsck
6109	* to complain and force a full file system check.
6110	*/
6111	if (!sb_rdonly(sb))
6112	ext4_update_tstamp(es, s_wtime);
6113	es->s_kbytes_written =
6114	cpu_to_le64(sbi->s_kbytes_written +
6115	((part_stat_read(sb->s_bdev, sectors[STAT_WRITE]) -
6116	sbi->s_sectors_written_start) >> 1));
6117	if (percpu_counter_initialized(fbc: &sbi->s_freeclusters_counter))
6118	ext4_free_blocks_count_set(es,
6119	EXT4_C2B(sbi, percpu_counter_sum_positive(
6120	&sbi->s_freeclusters_counter)));
6121	if (percpu_counter_initialized(fbc: &sbi->s_freeinodes_counter))
6122	es->s_free_inodes_count =
6123	cpu_to_le32(percpu_counter_sum_positive(
6124	&sbi->s_freeinodes_counter));
6125	/* Copy error information to the on-disk superblock */
6126	spin_lock(lock: &sbi->s_error_lock);
6127	if (sbi->s_add_error_count > 0) {
6128	es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
6129	if (!es->s_first_error_time && !es->s_first_error_time_hi) {
6130	__ext4_update_tstamp(lo: &es->s_first_error_time,
6131	hi: &es->s_first_error_time_hi,
6132	now: sbi->s_first_error_time);
6133	strncpy(p: es->s_first_error_func, q: sbi->s_first_error_func,
6134	size: sizeof(es->s_first_error_func));
6135	es->s_first_error_line =
6136	cpu_to_le32(sbi->s_first_error_line);
6137	es->s_first_error_ino =
6138	cpu_to_le32(sbi->s_first_error_ino);
6139	es->s_first_error_block =
6140	cpu_to_le64(sbi->s_first_error_block);
6141	es->s_first_error_errcode =
6142	ext4_errno_to_code(errno: sbi->s_first_error_code);
6143	}
6144	__ext4_update_tstamp(lo: &es->s_last_error_time,
6145	hi: &es->s_last_error_time_hi,
6146	now: sbi->s_last_error_time);
6147	strncpy(p: es->s_last_error_func, q: sbi->s_last_error_func,
6148	size: sizeof(es->s_last_error_func));
6149	es->s_last_error_line = cpu_to_le32(sbi->s_last_error_line);
6150	es->s_last_error_ino = cpu_to_le32(sbi->s_last_error_ino);
6151	es->s_last_error_block = cpu_to_le64(sbi->s_last_error_block);
6152	es->s_last_error_errcode =
6153	ext4_errno_to_code(errno: sbi->s_last_error_code);
6154	/*
6155	* Start the daily error reporting function if it hasn't been
6156	* started already
6157	*/
6158	if (!es->s_error_count)
6159	mod_timer(timer: &sbi->s_err_report, expires: jiffies + 24*60*60*HZ);
6160	le32_add_cpu(var: &es->s_error_count, val: sbi->s_add_error_count);
6161	sbi->s_add_error_count = 0;
6162	}
6163	spin_unlock(lock: &sbi->s_error_lock);
6164
6165	ext4_superblock_csum_set(sb);
6166	unlock_buffer(bh: sbh);
6167	}
6168
6169	static int ext4_commit_super(struct super_block *sb)
6170	{
6171	struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
6172
6173	if (!sbh)
6174	return -EINVAL;
6175	if (block_device_ejected(sb))
6176	return -ENODEV;
6177
6178	ext4_update_super(sb);
6179
6180	lock_buffer(bh: sbh);
6181	/* Buffer got discarded which means block device got invalidated */
6182	if (!buffer_mapped(bh: sbh)) {
6183	unlock_buffer(bh: sbh);
6184	return -EIO;
6185	}
6186
6187	if (buffer_write_io_error(bh: sbh) || !buffer_uptodate(bh: sbh)) {
6188	/*
6189	* Oh, dear. A previous attempt to write the
6190	* superblock failed. This could happen because the
6191	* USB device was yanked out. Or it could happen to
6192	* be a transient write error and maybe the block will
6193	* be remapped. Nothing we can do but to retry the
6194	* write and hope for the best.
6195	*/
6196	ext4_msg(sb, KERN_ERR, "previous I/O error to "
6197	"superblock detected");
6198	clear_buffer_write_io_error(bh: sbh);
6199	set_buffer_uptodate(sbh);
6200	}
6201	get_bh(bh: sbh);
6202	/* Clear potential dirty bit if it was journalled update */
6203	clear_buffer_dirty(bh: sbh);
6204	sbh->b_end_io = end_buffer_write_sync;
6205	submit_bh(REQ_OP_WRITE | REQ_SYNC |
6206	(test_opt(sb, BARRIER) ? REQ_FUA : 0), sbh);
6207	wait_on_buffer(bh: sbh);
6208	if (buffer_write_io_error(bh: sbh)) {
6209	ext4_msg(sb, KERN_ERR, "I/O error while writing "
6210	"superblock");
6211	clear_buffer_write_io_error(bh: sbh);
6212	set_buffer_uptodate(sbh);
6213	return -EIO;
6214	}
6215	return 0;
6216	}
6217
6218	/*
6219	* Have we just finished recovery? If so, and if we are mounting (or
6220	* remounting) the filesystem readonly, then we will end up with a
6221	* consistent fs on disk. Record that fact.
6222	*/
6223	static int ext4_mark_recovery_complete(struct super_block *sb,
6224	struct ext4_super_block *es)
6225	{
6226	int err;
6227	journal_t *journal = EXT4_SB(sb)->s_journal;
6228
6229	if (!ext4_has_feature_journal(sb)) {
6230	if (journal != NULL) {
6231	ext4_error(sb, "Journal got removed while the fs was "
6232	"mounted!");
6233	return -EFSCORRUPTED;
6234	}
6235	return 0;
6236	}
6237	jbd2_journal_lock_updates(journal);
6238	err = jbd2_journal_flush(journal, flags: 0);
6239	if (err < 0)
6240	goto out;
6241
6242	if (sb_rdonly(sb) && (ext4_has_feature_journal_needs_recovery(sb) ||
6243	ext4_has_feature_orphan_present(sb))) {
6244	if (!ext4_orphan_file_empty(sb)) {
6245	ext4_error(sb, "Orphan file not empty on read-only fs.");
6246	err = -EFSCORRUPTED;
6247	goto out;
6248	}
6249	ext4_clear_feature_journal_needs_recovery(sb);
6250	ext4_clear_feature_orphan_present(sb);
6251	ext4_commit_super(sb);
6252	}
6253	out:
6254	jbd2_journal_unlock_updates(journal);
6255	return err;
6256	}
6257
6258	/*
6259	* If we are mounting (or read-write remounting) a filesystem whose journal
6260	* has recorded an error from a previous lifetime, move that error to the
6261	* main filesystem now.
6262	*/
6263	static int ext4_clear_journal_err(struct super_block *sb,
6264	struct ext4_super_block *es)
6265	{
6266	journal_t *journal;
6267	int j_errno;
6268	const char *errstr;
6269
6270	if (!ext4_has_feature_journal(sb)) {
6271	ext4_error(sb, "Journal got removed while the fs was mounted!");
6272	return -EFSCORRUPTED;
6273	}
6274
6275	journal = EXT4_SB(sb)->s_journal;
6276
6277	/*
6278	* Now check for any error status which may have been recorded in the
6279	* journal by a prior ext4_error() or ext4_abort()
6280	*/
6281
6282	j_errno = jbd2_journal_errno(journal);
6283	if (j_errno) {
6284	char nbuf[16];
6285
6286	errstr = ext4_decode_error(sb, errno: j_errno, nbuf);
6287	ext4_warning(sb, "Filesystem error recorded "
6288	"from previous mount: %s", errstr);
6289
6290	EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
6291	es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
6292	j_errno = ext4_commit_super(sb);
6293	if (j_errno)
6294	return j_errno;
6295	ext4_warning(sb, "Marked fs in need of filesystem check.");
6296
6297	jbd2_journal_clear_err(journal);
6298	jbd2_journal_update_sb_errno(journal);
6299	}
6300	return 0;
6301	}
6302
6303	/*
6304	* Force the running and committing transactions to commit,
6305	* and wait on the commit.
6306	*/
6307	int ext4_force_commit(struct super_block *sb)
6308	{
6309	return ext4_journal_force_commit(journal: EXT4_SB(sb)->s_journal);
6310	}
6311
6312	static int ext4_sync_fs(struct super_block *sb, int wait)
6313	{
6314	int ret = 0;
6315	tid_t target;
6316	bool needs_barrier = false;
6317	struct ext4_sb_info *sbi = EXT4_SB(sb);
6318
6319	if (unlikely(ext4_forced_shutdown(sb)))
6320	return 0;
6321
6322	trace_ext4_sync_fs(sb, wait);
6323	flush_workqueue(sbi->rsv_conversion_wq);
6324	/*
6325	* Writeback quota in non-journalled quota case - journalled quota has
6326	* no dirty dquots
6327	*/
6328	dquot_writeback_dquots(sb, type: -1);
6329	/*
6330	* Data writeback is possible w/o journal transaction, so barrier must
6331	* being sent at the end of the function. But we can skip it if
6332	* transaction_commit will do it for us.
6333	*/
6334	if (sbi->s_journal) {
6335	target = jbd2_get_latest_transaction(journal: sbi->s_journal);
6336	if (wait && sbi->s_journal->j_flags & JBD2_BARRIER &&
6337	!jbd2_trans_will_send_data_barrier(journal: sbi->s_journal, tid: target))
6338	needs_barrier = true;
6339
6340	if (jbd2_journal_start_commit(journal: sbi->s_journal, tid: &target)) {
6341	if (wait)
6342	ret = jbd2_log_wait_commit(journal: sbi->s_journal,
6343	tid: target);
6344	}
6345	} else if (wait && test_opt(sb, BARRIER))
6346	needs_barrier = true;
6347	if (needs_barrier) {
6348	int err;
6349	err = blkdev_issue_flush(bdev: sb->s_bdev);
6350	if (!ret)
6351	ret = err;
6352	}
6353
6354	return ret;
6355	}
6356
6357	/*
6358	* LVM calls this function before a (read-only) snapshot is created. This
6359	* gives us a chance to flush the journal completely and mark the fs clean.
6360	*
6361	* Note that only this function cannot bring a filesystem to be in a clean
6362	* state independently. It relies on upper layer to stop all data & metadata
6363	* modifications.
6364	*/
6365	static int ext4_freeze(struct super_block *sb)
6366	{
6367	int error = 0;
6368	journal_t *journal = EXT4_SB(sb)->s_journal;
6369
6370	if (journal) {
6371	/* Now we set up the journal barrier. */
6372	jbd2_journal_lock_updates(journal);
6373
6374	/*
6375	* Don't clear the needs_recovery flag if we failed to
6376	* flush the journal.
6377	*/
6378	error = jbd2_journal_flush(journal, flags: 0);
6379	if (error < 0)
6380	goto out;
6381
6382	/* Journal blocked and flushed, clear needs_recovery flag. */
6383	ext4_clear_feature_journal_needs_recovery(sb);
6384	if (ext4_orphan_file_empty(sb))
6385	ext4_clear_feature_orphan_present(sb);
6386	}
6387
6388	error = ext4_commit_super(sb);
6389	out:
6390	if (journal)
6391	/* we rely on upper layer to stop further updates */
6392	jbd2_journal_unlock_updates(journal);
6393	return error;
6394	}
6395
6396	/*
6397	* Called by LVM after the snapshot is done. We need to reset the RECOVER
6398	* flag here, even though the filesystem is not technically dirty yet.
6399	*/
6400	static int ext4_unfreeze(struct super_block *sb)
6401	{
6402	if (ext4_forced_shutdown(sb))
6403	return 0;
6404
6405	if (EXT4_SB(sb)->s_journal) {
6406	/* Reset the needs_recovery flag before the fs is unlocked. */
6407	ext4_set_feature_journal_needs_recovery(sb);
6408	if (ext4_has_feature_orphan_file(sb))
6409	ext4_set_feature_orphan_present(sb);
6410	}
6411
6412	ext4_commit_super(sb);
6413	return 0;
6414	}
6415
6416	/*
6417	* Structure to save mount options for ext4_remount's benefit
6418	*/
6419	struct ext4_mount_options {
6420	unsigned long s_mount_opt;
6421	unsigned long s_mount_opt2;
6422	kuid_t s_resuid;
6423	kgid_t s_resgid;
6424	unsigned long s_commit_interval;
6425	u32 s_min_batch_time, s_max_batch_time;
6426	#ifdef CONFIG_QUOTA
6427	int s_jquota_fmt;
6428	char *s_qf_names[EXT4_MAXQUOTAS];
6429	#endif
6430	};
6431
6432	static int __ext4_remount(struct fs_context *fc, struct super_block *sb)
6433	{
6434	struct ext4_fs_context *ctx = fc->fs_private;
6435	struct ext4_super_block *es;
6436	struct ext4_sb_info *sbi = EXT4_SB(sb);
6437	unsigned long old_sb_flags;
6438	struct ext4_mount_options old_opts;
6439	ext4_group_t g;
6440	int err = 0;
6441	int alloc_ctx;
6442	#ifdef CONFIG_QUOTA
6443	int enable_quota = 0;
6444	int i, j;
6445	char *to_free[EXT4_MAXQUOTAS];
6446	#endif
6447
6448
6449	/* Store the original options */
6450	old_sb_flags = sb->s_flags;
6451	old_opts.s_mount_opt = sbi->s_mount_opt;
6452	old_opts.s_mount_opt2 = sbi->s_mount_opt2;
6453	old_opts.s_resuid = sbi->s_resuid;
6454	old_opts.s_resgid = sbi->s_resgid;
6455	old_opts.s_commit_interval = sbi->s_commit_interval;
6456	old_opts.s_min_batch_time = sbi->s_min_batch_time;
6457	old_opts.s_max_batch_time = sbi->s_max_batch_time;
6458	#ifdef CONFIG_QUOTA
6459	old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
6460	for (i = 0; i < EXT4_MAXQUOTAS; i++)
6461	if (sbi->s_qf_names[i]) {
6462	char *qf_name = get_qf_name(sb, sbi, type: i);
6463
6464	old_opts.s_qf_names[i] = kstrdup(s: qf_name, GFP_KERNEL);
6465	if (!old_opts.s_qf_names[i]) {
6466	for (j = 0; j < i; j++)
6467	kfree(objp: old_opts.s_qf_names[j]);
6468	return -ENOMEM;
6469	}
6470	} else
6471	old_opts.s_qf_names[i] = NULL;
6472	#endif
6473	if (!(ctx->spec & EXT4_SPEC_JOURNAL_IOPRIO)) {
6474	if (sbi->s_journal && sbi->s_journal->j_task->io_context)
6475	ctx->journal_ioprio =
6476	sbi->s_journal->j_task->io_context->ioprio;
6477	else
6478	ctx->journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
6479
6480	}
6481
6482	/*
6483	* Changing the DIOREAD_NOLOCK or DELALLOC mount options may cause
6484	* two calls to ext4_should_dioread_nolock() to return inconsistent
6485	* values, triggering WARN_ON in ext4_add_complete_io(). we grab
6486	* here s_writepages_rwsem to avoid race between writepages ops and
6487	* remount.
6488	*/
6489	alloc_ctx = ext4_writepages_down_write(sb);
6490	ext4_apply_options(fc, sb);
6491	ext4_writepages_up_write(sb, ctx: alloc_ctx);
6492
6493	if ((old_opts.s_mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) ^
6494	test_opt(sb, JOURNAL_CHECKSUM)) {
6495	ext4_msg(sb, KERN_ERR, "changing journal_checksum "
6496	"during remount not supported; ignoring");
6497	sbi->s_mount_opt ^= EXT4_MOUNT_JOURNAL_CHECKSUM;
6498	}
6499
6500	if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
6501	if (test_opt2(sb, EXPLICIT_DELALLOC)) {
6502	ext4_msg(sb, KERN_ERR, "can't mount with "
6503	"both data=journal and delalloc");
6504	err = -EINVAL;
6505	goto restore_opts;
6506	}
6507	if (test_opt(sb, DIOREAD_NOLOCK)) {
6508	ext4_msg(sb, KERN_ERR, "can't mount with "
6509	"both data=journal and dioread_nolock");
6510	err = -EINVAL;
6511	goto restore_opts;
6512	}
6513	} else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) {
6514	if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
6515	ext4_msg(sb, KERN_ERR, "can't mount with "
6516	"journal_async_commit in data=ordered mode");
6517	err = -EINVAL;
6518	goto restore_opts;
6519	}
6520	}
6521
6522	if ((sbi->s_mount_opt ^ old_opts.s_mount_opt) & EXT4_MOUNT_NO_MBCACHE) {
6523	ext4_msg(sb, KERN_ERR, "can't enable nombcache during remount");
6524	err = -EINVAL;
6525	goto restore_opts;
6526	}
6527
6528	if (test_opt2(sb, ABORT))
6529	ext4_abort(sb, ESHUTDOWN, "Abort forced by user");
6530
6531	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
6532	(test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
6533
6534	es = sbi->s_es;
6535
6536	if (sbi->s_journal) {
6537	ext4_init_journal_params(sb, journal: sbi->s_journal);
6538	set_task_ioprio(task: sbi->s_journal->j_task, ioprio: ctx->journal_ioprio);
6539	}
6540
6541	/* Flush outstanding errors before changing fs state */
6542	flush_work(work: &sbi->s_sb_upd_work);
6543
6544	if ((bool)(fc->sb_flags & SB_RDONLY) != sb_rdonly(sb)) {
6545	if (ext4_forced_shutdown(sb)) {
6546	err = -EROFS;
6547	goto restore_opts;
6548	}
6549
6550	if (fc->sb_flags & SB_RDONLY) {
6551	err = sync_filesystem(sb);
6552	if (err < 0)
6553	goto restore_opts;
6554	err = dquot_suspend(sb, type: -1);
6555	if (err < 0)
6556	goto restore_opts;
6557
6558	/*
6559	* First of all, the unconditional stuff we have to do
6560	* to disable replay of the journal when we next remount
6561	*/
6562	sb->s_flags |= SB_RDONLY;
6563
6564	/*
6565	* OK, test if we are remounting a valid rw partition
6566	* readonly, and if so set the rdonly flag and then
6567	* mark the partition as valid again.
6568	*/
6569	if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
6570	(sbi->s_mount_state & EXT4_VALID_FS))
6571	es->s_state = cpu_to_le16(sbi->s_mount_state);
6572
6573	if (sbi->s_journal) {
6574	/*
6575	* We let remount-ro finish even if marking fs
6576	* as clean failed...
6577	*/
6578	ext4_mark_recovery_complete(sb, es);
6579	}
6580	} else {
6581	/* Make sure we can mount this feature set readwrite */
6582	if (ext4_has_feature_readonly(sb) ||
6583	!ext4_feature_set_ok(sb, readonly: 0)) {
6584	err = -EROFS;
6585	goto restore_opts;
6586	}
6587	/*
6588	* Make sure the group descriptor checksums
6589	* are sane. If they aren't, refuse to remount r/w.
6590	*/
6591	for (g = 0; g < sbi->s_groups_count; g++) {
6592	struct ext4_group_desc *gdp =
6593	ext4_get_group_desc(sb, block_group: g, NULL);
6594
6595	if (!ext4_group_desc_csum_verify(sb, block_group: g, gdp)) {
6596	ext4_msg(sb, KERN_ERR,
6597	"ext4_remount: Checksum for group %u failed (%u!=%u)",
6598	g, le16_to_cpu(ext4_group_desc_csum(sb, g, gdp)),
6599	le16_to_cpu(gdp->bg_checksum));
6600	err = -EFSBADCRC;
6601	goto restore_opts;
6602	}
6603	}
6604
6605	/*
6606	* If we have an unprocessed orphan list hanging
6607	* around from a previously readonly bdev mount,
6608	* require a full umount/remount for now.
6609	*/
6610	if (es->s_last_orphan || !ext4_orphan_file_empty(sb)) {
6611	ext4_msg(sb, KERN_WARNING, "Couldn't "
6612	"remount RDWR because of unprocessed "
6613	"orphan inode list. Please "
6614	"umount/remount instead");
6615	err = -EINVAL;
6616	goto restore_opts;
6617	}
6618
6619	/*
6620	* Mounting a RDONLY partition read-write, so reread
6621	* and store the current valid flag. (It may have
6622	* been changed by e2fsck since we originally mounted
6623	* the partition.)
6624	*/
6625	if (sbi->s_journal) {
6626	err = ext4_clear_journal_err(sb, es);
6627	if (err)
6628	goto restore_opts;
6629	}
6630	sbi->s_mount_state = (le16_to_cpu(es->s_state) &
6631	~EXT4_FC_REPLAY);
6632
6633	err = ext4_setup_super(sb, es, read_only: 0);
6634	if (err)
6635	goto restore_opts;
6636
6637	sb->s_flags &= ~SB_RDONLY;
6638	if (ext4_has_feature_mmp(sb)) {
6639	err = ext4_multi_mount_protect(sb,
6640	le64_to_cpu(es->s_mmp_block));
6641	if (err)
6642	goto restore_opts;
6643	}
6644	#ifdef CONFIG_QUOTA
6645	enable_quota = 1;
6646	#endif
6647	}
6648	}
6649
6650	/*
6651	* Handle creation of system zone data early because it can fail.
6652	* Releasing of existing data is done when we are sure remount will
6653	* succeed.
6654	*/
6655	if (test_opt(sb, BLOCK_VALIDITY) && !sbi->s_system_blks) {
6656	err = ext4_setup_system_zone(sb);
6657	if (err)
6658	goto restore_opts;
6659	}
6660
6661	if (sbi->s_journal == NULL && !(old_sb_flags & SB_RDONLY)) {
6662	err = ext4_commit_super(sb);
6663	if (err)
6664	goto restore_opts;
6665	}
6666
6667	#ifdef CONFIG_QUOTA
6668	if (enable_quota) {
6669	if (sb_any_quota_suspended(sb))
6670	dquot_resume(sb, type: -1);
6671	else if (ext4_has_feature_quota(sb)) {
6672	err = ext4_enable_quotas(sb);
6673	if (err)
6674	goto restore_opts;
6675	}
6676	}
6677	/* Release old quota file names */
6678	for (i = 0; i < EXT4_MAXQUOTAS; i++)
6679	kfree(objp: old_opts.s_qf_names[i]);
6680	#endif
6681	if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
6682	ext4_release_system_zone(sb);
6683
6684	/*
6685	* Reinitialize lazy itable initialization thread based on
6686	* current settings
6687	*/
6688	if (sb_rdonly(sb) || !test_opt(sb, INIT_INODE_TABLE))
6689	ext4_unregister_li_request(sb);
6690	else {
6691	ext4_group_t first_not_zeroed;
6692	first_not_zeroed = ext4_has_uninit_itable(sb);
6693	ext4_register_li_request(sb, first_not_zeroed);
6694	}
6695
6696	if (!ext4_has_feature_mmp(sb) || sb_rdonly(sb))
6697	ext4_stop_mmpd(sbi);
6698
6699	return 0;
6700
6701	restore_opts:
6702	/*
6703	* If there was a failing r/w to ro transition, we may need to
6704	* re-enable quota
6705	*/
6706	if (sb_rdonly(sb) && !(old_sb_flags & SB_RDONLY) &&
6707	sb_any_quota_suspended(sb))
6708	dquot_resume(sb, type: -1);
6709
6710	alloc_ctx = ext4_writepages_down_write(sb);
6711	sb->s_flags = old_sb_flags;
6712	sbi->s_mount_opt = old_opts.s_mount_opt;
6713	sbi->s_mount_opt2 = old_opts.s_mount_opt2;
6714	sbi->s_resuid = old_opts.s_resuid;
6715	sbi->s_resgid = old_opts.s_resgid;
6716	sbi->s_commit_interval = old_opts.s_commit_interval;
6717	sbi->s_min_batch_time = old_opts.s_min_batch_time;
6718	sbi->s_max_batch_time = old_opts.s_max_batch_time;
6719	ext4_writepages_up_write(sb, ctx: alloc_ctx);
6720
6721	if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
6722	ext4_release_system_zone(sb);
6723	#ifdef CONFIG_QUOTA
6724	sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
6725	for (i = 0; i < EXT4_MAXQUOTAS; i++) {
6726	to_free[i] = get_qf_name(sb, sbi, type: i);
6727	rcu_assign_pointer(sbi->s_qf_names[i], old_opts.s_qf_names[i]);
6728	}
6729	synchronize_rcu();
6730	for (i = 0; i < EXT4_MAXQUOTAS; i++)
6731	kfree(objp: to_free[i]);
6732	#endif
6733	if (!ext4_has_feature_mmp(sb) || sb_rdonly(sb))
6734	ext4_stop_mmpd(sbi);
6735	return err;
6736	}
6737
6738	static int ext4_reconfigure(struct fs_context *fc)
6739	{
6740	struct super_block *sb = fc->root->d_sb;
6741	int ret;
6742
6743	fc->s_fs_info = EXT4_SB(sb);
6744
6745	ret = ext4_check_opt_consistency(fc, sb);
6746	if (ret < 0)
6747	return ret;
6748
6749	ret = __ext4_remount(fc, sb);
6750	if (ret < 0)
6751	return ret;
6752
6753	ext4_msg(sb, KERN_INFO, "re-mounted %pU %s. Quota mode: %s.",
6754	&sb->s_uuid, sb_rdonly(sb) ? "ro" : "r/w",
6755	ext4_quota_mode(sb));
6756
6757	return 0;
6758	}
6759
6760	#ifdef CONFIG_QUOTA
6761	static int ext4_statfs_project(struct super_block *sb,
6762	kprojid_t projid, struct kstatfs *buf)
6763	{
6764	struct kqid qid;
6765	struct dquot *dquot;
6766	u64 limit;
6767	u64 curblock;
6768
6769	qid = make_kqid_projid(projid);
6770	dquot = dqget(sb, qid);
6771	if (IS_ERR(ptr: dquot))
6772	return PTR_ERR(ptr: dquot);
6773	spin_lock(lock: &dquot->dq_dqb_lock);
6774
6775	limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
6776	dquot->dq_dqb.dqb_bhardlimit);
6777	limit >>= sb->s_blocksize_bits;
6778
6779	if (limit && buf->f_blocks > limit) {
6780	curblock = (dquot->dq_dqb.dqb_curspace +
6781	dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;
6782	buf->f_blocks = limit;
6783	buf->f_bfree = buf->f_bavail =
6784	(buf->f_blocks > curblock) ?
6785	(buf->f_blocks - curblock) : 0;
6786	}
6787
6788	limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
6789	dquot->dq_dqb.dqb_ihardlimit);
6790	if (limit && buf->f_files > limit) {
6791	buf->f_files = limit;
6792	buf->f_ffree =
6793	(buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
6794	(buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
6795	}
6796
6797	spin_unlock(lock: &dquot->dq_dqb_lock);
6798	dqput(dquot);
6799	return 0;
6800	}
6801	#endif
6802
6803	static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
6804	{
6805	struct super_block *sb = dentry->d_sb;
6806	struct ext4_sb_info *sbi = EXT4_SB(sb);
6807	struct ext4_super_block *es = sbi->s_es;
6808	ext4_fsblk_t overhead = 0, resv_blocks;
6809	s64 bfree;
6810	resv_blocks = EXT4_C2B(sbi, atomic64_read(&sbi->s_resv_clusters));
6811
6812	if (!test_opt(sb, MINIX_DF))
6813	overhead = sbi->s_overhead;
6814
6815	buf->f_type = EXT4_SUPER_MAGIC;
6816	buf->f_bsize = sb->s_blocksize;
6817	buf->f_blocks = ext4_blocks_count(es) - EXT4_C2B(sbi, overhead);
6818	bfree = percpu_counter_sum_positive(fbc: &sbi->s_freeclusters_counter) -
6819	percpu_counter_sum_positive(fbc: &sbi->s_dirtyclusters_counter);
6820	/* prevent underflow in case that few free space is available */
6821	buf->f_bfree = EXT4_C2B(sbi, max_t(s64, bfree, 0));
6822	buf->f_bavail = buf->f_bfree -
6823	(ext4_r_blocks_count(es) + resv_blocks);
6824	if (buf->f_bfree < (ext4_r_blocks_count(es) + resv_blocks))
6825	buf->f_bavail = 0;
6826	buf->f_files = le32_to_cpu(es->s_inodes_count);
6827	buf->f_ffree = percpu_counter_sum_positive(fbc: &sbi->s_freeinodes_counter);
6828	buf->f_namelen = EXT4_NAME_LEN;
6829	buf->f_fsid = uuid_to_fsid(uuid: es->s_uuid);
6830
6831	#ifdef CONFIG_QUOTA
6832	if (ext4_test_inode_flag(inode: dentry->d_inode, bit: EXT4_INODE_PROJINHERIT) &&
6833	sb_has_quota_limits_enabled(sb, type: PRJQUOTA))
6834	ext4_statfs_project(sb, EXT4_I(dentry->d_inode)->i_projid, buf);
6835	#endif
6836	return 0;
6837	}
6838
6839
6840	#ifdef CONFIG_QUOTA
6841
6842	/*
6843	* Helper functions so that transaction is started before we acquire dqio_sem
6844	* to keep correct lock ordering of transaction > dqio_sem
6845	*/
6846	static inline struct inode *dquot_to_inode(struct dquot *dquot)
6847	{
6848	return sb_dqopt(sb: dquot->dq_sb)->files[dquot->dq_id.type];
6849	}
6850
6851	static int ext4_write_dquot(struct dquot *dquot)
6852	{
6853	int ret, err;
6854	handle_t *handle;
6855	struct inode *inode;
6856
6857	inode = dquot_to_inode(dquot);
6858	handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
6859	EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
6860	if (IS_ERR(ptr: handle))
6861	return PTR_ERR(ptr: handle);
6862	ret = dquot_commit(dquot);
6863	if (ret < 0)
6864	ext4_error_err(dquot->dq_sb, -ret,
6865	"Failed to commit dquot type %d",
6866	dquot->dq_id.type);
6867	err = ext4_journal_stop(handle);
6868	if (!ret)
6869	ret = err;
6870	return ret;
6871	}
6872
6873	static int ext4_acquire_dquot(struct dquot *dquot)
6874	{
6875	int ret, err;
6876	handle_t *handle;
6877
6878	handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
6879	EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
6880	if (IS_ERR(ptr: handle))
6881	return PTR_ERR(ptr: handle);
6882	ret = dquot_acquire(dquot);
6883	if (ret < 0)
6884	ext4_error_err(dquot->dq_sb, -ret,
6885	"Failed to acquire dquot type %d",
6886	dquot->dq_id.type);
6887	err = ext4_journal_stop(handle);
6888	if (!ret)
6889	ret = err;
6890	return ret;
6891	}
6892
6893	static int ext4_release_dquot(struct dquot *dquot)
6894	{
6895	int ret, err;
6896	handle_t *handle;
6897
6898	handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
6899	EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
6900	if (IS_ERR(ptr: handle)) {
6901	/* Release dquot anyway to avoid endless cycle in dqput() */
6902	dquot_release(dquot);
6903	return PTR_ERR(ptr: handle);
6904	}
6905	ret = dquot_release(dquot);
6906	if (ret < 0)
6907	ext4_error_err(dquot->dq_sb, -ret,
6908	"Failed to release dquot type %d",
6909	dquot->dq_id.type);
6910	err = ext4_journal_stop(handle);
6911	if (!ret)
6912	ret = err;
6913	return ret;
6914	}
6915
6916	static int ext4_mark_dquot_dirty(struct dquot *dquot)
6917	{
6918	struct super_block *sb = dquot->dq_sb;
6919
6920	if (ext4_is_quota_journalled(sb)) {
6921	dquot_mark_dquot_dirty(dquot);
6922	return ext4_write_dquot(dquot);
6923	} else {
6924	return dquot_mark_dquot_dirty(dquot);
6925	}
6926	}
6927
6928	static int ext4_write_info(struct super_block *sb, int type)
6929	{
6930	int ret, err;
6931	handle_t *handle;
6932
6933	/* Data block + inode block */
6934	handle = ext4_journal_start_sb(sb, EXT4_HT_QUOTA, 2);
6935	if (IS_ERR(ptr: handle))
6936	return PTR_ERR(ptr: handle);
6937	ret = dquot_commit_info(sb, type);
6938	err = ext4_journal_stop(handle);
6939	if (!ret)
6940	ret = err;
6941	return ret;
6942	}
6943
6944	static void lockdep_set_quota_inode(struct inode *inode, int subclass)
6945	{
6946	struct ext4_inode_info *ei = EXT4_I(inode);
6947
6948	/* The first argument of lockdep_set_subclass has to be
6949	* *exactly* the same as the argument to init_rwsem() --- in
6950	* this case, in init_once() --- or lockdep gets unhappy
6951	* because the name of the lock is set using the
6952	* stringification of the argument to init_rwsem().
6953	*/
6954	(void) ei; /* shut up clang warning if !CONFIG_LOCKDEP */
6955	lockdep_set_subclass(&ei->i_data_sem, subclass);
6956	}
6957
6958	/*
6959	* Standard function to be called on quota_on
6960	*/
6961	static int ext4_quota_on(struct super_block *sb, int type, int format_id,
6962	const struct path *path)
6963	{
6964	int err;
6965
6966	if (!test_opt(sb, QUOTA))
6967	return -EINVAL;
6968
6969	/* Quotafile not on the same filesystem? */
6970	if (path->dentry->d_sb != sb)
6971	return -EXDEV;
6972
6973	/* Quota already enabled for this file? */
6974	if (IS_NOQUOTA(d_inode(path->dentry)))
6975	return -EBUSY;
6976
6977	/* Journaling quota? */
6978	if (EXT4_SB(sb)->s_qf_names[type]) {
6979	/* Quotafile not in fs root? */
6980	if (path->dentry->d_parent != sb->s_root)
6981	ext4_msg(sb, KERN_WARNING,
6982	"Quota file not on filesystem root. "
6983	"Journaled quota will not work");
6984	sb_dqopt(sb)->flags |= DQUOT_NOLIST_DIRTY;
6985	} else {
6986	/*
6987	* Clear the flag just in case mount options changed since
6988	* last time.
6989	*/
6990	sb_dqopt(sb)->flags &= ~DQUOT_NOLIST_DIRTY;
6991	}
6992
6993	lockdep_set_quota_inode(inode: path->dentry->d_inode, subclass: I_DATA_SEM_QUOTA);
6994	err = dquot_quota_on(sb, type, format_id, path);
6995	if (!err) {
6996	struct inode *inode = d_inode(dentry: path->dentry);
6997	handle_t *handle;
6998
6999	/*
7000	* Set inode flags to prevent userspace from messing with quota
7001	* files. If this fails, we return success anyway since quotas
7002	* are already enabled and this is not a hard failure.
7003	*/
7004	inode_lock(inode);
7005	handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
7006	if (IS_ERR(ptr: handle))
7007	goto unlock_inode;
7008	EXT4_I(inode)->i_flags |= EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL;
7009	inode_set_flags(inode, S_NOATIME | S_IMMUTABLE,
7010	S_NOATIME | S_IMMUTABLE);
7011	err = ext4_mark_inode_dirty(handle, inode);
7012	ext4_journal_stop(handle);
7013	unlock_inode:
7014	inode_unlock(inode);
7015	if (err)
7016	dquot_quota_off(sb, type);
7017	}
7018	if (err)
7019	lockdep_set_quota_inode(inode: path->dentry->d_inode,
7020	subclass: I_DATA_SEM_NORMAL);
7021	return err;
7022	}
7023
7024	static inline bool ext4_check_quota_inum(int type, unsigned long qf_inum)
7025	{
7026	switch (type) {
7027	case USRQUOTA:
7028	return qf_inum == EXT4_USR_QUOTA_INO;
7029	case GRPQUOTA:
7030	return qf_inum == EXT4_GRP_QUOTA_INO;
7031	case PRJQUOTA:
7032	return qf_inum >= EXT4_GOOD_OLD_FIRST_INO;
7033	default:
7034	BUG();
7035	}
7036	}
7037
7038	static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
7039	unsigned int flags)
7040	{
7041	int err;
7042	struct inode *qf_inode;
7043	unsigned long qf_inums[EXT4_MAXQUOTAS] = {
7044	le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
7045	le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum),
7046	le32_to_cpu(EXT4_SB(sb)->s_es->s_prj_quota_inum)
7047	};
7048
7049	BUG_ON(!ext4_has_feature_quota(sb));
7050
7051	if (!qf_inums[type])
7052	return -EPERM;
7053
7054	if (!ext4_check_quota_inum(type, qf_inum: qf_inums[type])) {
7055	ext4_error(sb, "Bad quota inum: %lu, type: %d",
7056	qf_inums[type], type);
7057	return -EUCLEAN;
7058	}
7059
7060	qf_inode = ext4_iget(sb, qf_inums[type], EXT4_IGET_SPECIAL);
7061	if (IS_ERR(ptr: qf_inode)) {
7062	ext4_error(sb, "Bad quota inode: %lu, type: %d",
7063	qf_inums[type], type);
7064	return PTR_ERR(ptr: qf_inode);
7065	}
7066
7067	/* Don't account quota for quota files to avoid recursion */
7068	qf_inode->i_flags |= S_NOQUOTA;
7069	lockdep_set_quota_inode(inode: qf_inode, subclass: I_DATA_SEM_QUOTA);
7070	err = dquot_load_quota_inode(inode: qf_inode, type, format_id, flags);
7071	if (err)
7072	lockdep_set_quota_inode(inode: qf_inode, subclass: I_DATA_SEM_NORMAL);
7073	iput(qf_inode);
7074
7075	return err;
7076	}
7077
7078	/* Enable usage tracking for all quota types. */
7079	int ext4_enable_quotas(struct super_block *sb)
7080	{
7081	int type, err = 0;
7082	unsigned long qf_inums[EXT4_MAXQUOTAS] = {
7083	le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
7084	le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum),
7085	le32_to_cpu(EXT4_SB(sb)->s_es->s_prj_quota_inum)
7086	};
7087	bool quota_mopt[EXT4_MAXQUOTAS] = {
7088	test_opt(sb, USRQUOTA),
7089	test_opt(sb, GRPQUOTA),
7090	test_opt(sb, PRJQUOTA),
7091	};
7092
7093	sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE | DQUOT_NOLIST_DIRTY;
7094	for (type = 0; type < EXT4_MAXQUOTAS; type++) {
7095	if (qf_inums[type]) {
7096	err = ext4_quota_enable(sb, type, QFMT_VFS_V1,
7097	DQUOT_USAGE_ENABLED |
7098	(quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
7099	if (err) {
7100	ext4_warning(sb,
7101	"Failed to enable quota tracking "
7102	"(type=%d, err=%d, ino=%lu). "
7103	"Please run e2fsck to fix.", type,
7104	err, qf_inums[type]);
7105
7106	ext4_quotas_off(sb, type);
7107	return err;
7108	}
7109	}
7110	}
7111	return 0;
7112	}
7113
7114	static int ext4_quota_off(struct super_block *sb, int type)
7115	{
7116	struct inode *inode = sb_dqopt(sb)->files[type];
7117	handle_t *handle;
7118	int err;
7119
7120	/* Force all delayed allocation blocks to be allocated.
7121	* Caller already holds s_umount sem */
7122	if (test_opt(sb, DELALLOC))
7123	sync_filesystem(sb);
7124
7125	if (!inode || !igrab(inode))
7126	goto out;
7127
7128	err = dquot_quota_off(sb, type);
7129	if (err || ext4_has_feature_quota(sb))
7130	goto out_put;
7131	/*
7132	* When the filesystem was remounted read-only first, we cannot cleanup
7133	* inode flags here. Bad luck but people should be using QUOTA feature
7134	* these days anyway.
7135	*/
7136	if (sb_rdonly(sb))
7137	goto out_put;
7138
7139	inode_lock(inode);
7140	/*
7141	* Update modification times of quota files when userspace can
7142	* start looking at them. If we fail, we return success anyway since
7143	* this is not a hard failure and quotas are already disabled.
7144	*/
7145	handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
7146	if (IS_ERR(ptr: handle)) {
7147	err = PTR_ERR(ptr: handle);
7148	goto out_unlock;
7149	}
7150	EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL);
7151	inode_set_flags(inode, flags: 0, S_NOATIME | S_IMMUTABLE);
7152	inode_set_mtime_to_ts(inode, ts: inode_set_ctime_current(inode));
7153	err = ext4_mark_inode_dirty(handle, inode);
7154	ext4_journal_stop(handle);
7155	out_unlock:
7156	inode_unlock(inode);
7157	out_put:
7158	lockdep_set_quota_inode(inode, subclass: I_DATA_SEM_NORMAL);
7159	iput(inode);
7160	return err;
7161	out:
7162	return dquot_quota_off(sb, type);
7163	}
7164
7165	/* Read data from quotafile - avoid pagecache and such because we cannot afford
7166	* acquiring the locks... As quota files are never truncated and quota code
7167	* itself serializes the operations (and no one else should touch the files)
7168	* we don't have to be afraid of races */
7169	static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
7170	size_t len, loff_t off)
7171	{
7172	struct inode *inode = sb_dqopt(sb)->files[type];
7173	ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
7174	int offset = off & (sb->s_blocksize - 1);
7175	int tocopy;
7176	size_t toread;
7177	struct buffer_head *bh;
7178	loff_t i_size = i_size_read(inode);
7179
7180	if (off > i_size)
7181	return 0;
7182	if (off+len > i_size)
7183	len = i_size-off;
7184	toread = len;
7185	while (toread > 0) {
7186	tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread);
7187	bh = ext4_bread(NULL, inode, blk, 0);
7188	if (IS_ERR(ptr: bh))
7189	return PTR_ERR(ptr: bh);
7190	if (!bh) /* A hole? */
7191	memset(data, 0, tocopy);
7192	else
7193	memcpy(data, bh->b_data+offset, tocopy);
7194	brelse(bh);
7195	offset = 0;
7196	toread -= tocopy;
7197	data += tocopy;
7198	blk++;
7199	}
7200	return len;
7201	}
7202
7203	/* Write to quotafile (we know the transaction is already started and has
7204	* enough credits) */
7205	static ssize_t ext4_quota_write(struct super_block *sb, int type,
7206	const char *data, size_t len, loff_t off)
7207	{
7208	struct inode *inode = sb_dqopt(sb)->files[type];
7209	ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
7210	int err = 0, err2 = 0, offset = off & (sb->s_blocksize - 1);
7211	int retries = 0;
7212	struct buffer_head *bh;
7213	handle_t *handle = journal_current_handle();
7214
7215	if (!handle) {
7216	ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
7217	" cancelled because transaction is not started",
7218	(unsigned long long)off, (unsigned long long)len);
7219	return -EIO;
7220	}
7221	/*
7222	* Since we account only one data block in transaction credits,
7223	* then it is impossible to cross a block boundary.
7224	*/
7225	if (sb->s_blocksize - offset < len) {
7226	ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
7227	" cancelled because not block aligned",
7228	(unsigned long long)off, (unsigned long long)len);
7229	return -EIO;
7230	}
7231
7232	do {
7233	bh = ext4_bread(handle, inode, blk,
7234	EXT4_GET_BLOCKS_CREATE |
7235	EXT4_GET_BLOCKS_METADATA_NOFAIL);
7236	} while (PTR_ERR(ptr: bh) == -ENOSPC &&
7237	ext4_should_retry_alloc(sb: inode->i_sb, retries: &retries));
7238	if (IS_ERR(ptr: bh))
7239	return PTR_ERR(ptr: bh);
7240	if (!bh)
7241	goto out;
7242	BUFFER_TRACE(bh, "get write access");
7243	err = ext4_journal_get_write_access(handle, sb, bh, EXT4_JTR_NONE);
7244	if (err) {
7245	brelse(bh);
7246	return err;
7247	}
7248	lock_buffer(bh);
7249	memcpy(bh->b_data+offset, data, len);
7250	flush_dcache_page(page: bh->b_page);
7251	unlock_buffer(bh);
7252	err = ext4_handle_dirty_metadata(handle, NULL, bh);
7253	brelse(bh);
7254	out:
7255	if (inode->i_size < off + len) {
7256	i_size_write(inode, i_size: off + len);
7257	EXT4_I(inode)->i_disksize = inode->i_size;
7258	err2 = ext4_mark_inode_dirty(handle, inode);
7259	if (unlikely(err2 && !err))
7260	err = err2;
7261	}
7262	return err ? err : len;
7263	}
7264	#endif
7265
7266	#if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
7267	static inline void register_as_ext2(void)
7268	{
7269	int err = register_filesystem(&ext2_fs_type);
7270	if (err)
7271	printk(KERN_WARNING
7272	"EXT4-fs: Unable to register as ext2 (%d)\n", err);
7273	}
7274
7275	static inline void unregister_as_ext2(void)
7276	{
7277	unregister_filesystem(&ext2_fs_type);
7278	}
7279
7280	static inline int ext2_feature_set_ok(struct super_block *sb)
7281	{
7282	if (ext4_has_unknown_ext2_incompat_features(sb))
7283	return 0;
7284	if (sb_rdonly(sb))
7285	return 1;
7286	if (ext4_has_unknown_ext2_ro_compat_features(sb))
7287	return 0;
7288	return 1;
7289	}
7290	#else
7291	static inline void register_as_ext2(void) { }
7292	static inline void unregister_as_ext2(void) { }
7293	static inline int ext2_feature_set_ok(struct super_block *sb) { return 0; }
7294	#endif
7295
7296	static inline void register_as_ext3(void)
7297	{
7298	int err = register_filesystem(&ext3_fs_type);
7299	if (err)
7300	printk(KERN_WARNING
7301	"EXT4-fs: Unable to register as ext3 (%d)\n", err);
7302	}
7303
7304	static inline void unregister_as_ext3(void)
7305	{
7306	unregister_filesystem(&ext3_fs_type);
7307	}
7308
7309	static inline int ext3_feature_set_ok(struct super_block *sb)
7310	{
7311	if (ext4_has_unknown_ext3_incompat_features(sb))
7312	return 0;
7313	if (!ext4_has_feature_journal(sb))
7314	return 0;
7315	if (sb_rdonly(sb))
7316	return 1;
7317	if (ext4_has_unknown_ext3_ro_compat_features(sb))
7318	return 0;
7319	return 1;
7320	}
7321
7322	static void ext4_kill_sb(struct super_block *sb)
7323	{
7324	struct ext4_sb_info *sbi = EXT4_SB(sb);
7325	struct file *bdev_file = sbi ? sbi->s_journal_bdev_file : NULL;
7326
7327	kill_block_super(sb);
7328
7329	if (bdev_file)
7330	bdev_fput(bdev_file);
7331	}
7332
7333	static struct file_system_type ext4_fs_type = {
7334	.owner = THIS_MODULE,
7335	.name = "ext4",
7336	.init_fs_context = ext4_init_fs_context,
7337	.parameters = ext4_param_specs,
7338	.kill_sb = ext4_kill_sb,
7339	.fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
7340	};
7341	MODULE_ALIAS_FS("ext4");
7342
7343	/* Shared across all ext4 file systems */
7344	wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
7345
7346	static int __init ext4_init_fs(void)
7347	{
7348	int i, err;
7349
7350	ratelimit_state_init(rs: &ext4_mount_msg_ratelimit, interval: 30 * HZ, burst: 64);
7351	ext4_li_info = NULL;
7352
7353	/* Build-time check for flags consistency */
7354	ext4_check_flag_values();
7355
7356	for (i = 0; i < EXT4_WQ_HASH_SZ; i++)
7357	init_waitqueue_head(&ext4__ioend_wq[i]);
7358
7359	err = ext4_init_es();
7360	if (err)
7361	return err;
7362
7363	err = ext4_init_pending();
7364	if (err)
7365	goto out7;
7366
7367	err = ext4_init_post_read_processing();
7368	if (err)
7369	goto out6;
7370
7371	err = ext4_init_pageio();
7372	if (err)
7373	goto out5;
7374
7375	err = ext4_init_system_zone();
7376	if (err)
7377	goto out4;
7378
7379	err = ext4_init_sysfs();
7380	if (err)
7381	goto out3;
7382
7383	err = ext4_init_mballoc();
7384	if (err)
7385	goto out2;
7386	err = init_inodecache();
7387	if (err)
7388	goto out1;
7389
7390	err = ext4_fc_init_dentry_cache();
7391	if (err)
7392	goto out05;
7393
7394	register_as_ext3();
7395	register_as_ext2();
7396	err = register_filesystem(&ext4_fs_type);
7397	if (err)
7398	goto out;
7399
7400	return 0;
7401	out:
7402	unregister_as_ext2();
7403	unregister_as_ext3();
7404	ext4_fc_destroy_dentry_cache();
7405	out05:
7406	destroy_inodecache();
7407	out1:
7408	ext4_exit_mballoc();
7409	out2:
7410	ext4_exit_sysfs();
7411	out3:
7412	ext4_exit_system_zone();
7413	out4:
7414	ext4_exit_pageio();
7415	out5:
7416	ext4_exit_post_read_processing();
7417	out6:
7418	ext4_exit_pending();
7419	out7:
7420	ext4_exit_es();
7421
7422	return err;
7423	}
7424
7425	static void __exit ext4_exit_fs(void)
7426	{
7427	ext4_destroy_lazyinit_thread();
7428	unregister_as_ext2();
7429	unregister_as_ext3();
7430	unregister_filesystem(&ext4_fs_type);
7431	ext4_fc_destroy_dentry_cache();
7432	destroy_inodecache();
7433	ext4_exit_mballoc();
7434	ext4_exit_sysfs();
7435	ext4_exit_system_zone();
7436	ext4_exit_pageio();
7437	ext4_exit_post_read_processing();
7438	ext4_exit_es();
7439	ext4_exit_pending();
7440	}
7441
7442	MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
7443	MODULE_DESCRIPTION("Fourth Extended Filesystem");
7444	MODULE_LICENSE("GPL");
7445	MODULE_SOFTDEP("pre: crc32c");
7446	module_init(ext4_init_fs)
7447	module_exit(ext4_exit_fs)
7448