~hc/RK356X_SDK_RELEASE.git

..	..	@@ -43,7 +43,7 @@
43	43	#include <linux/uaccess.h>
44	44	#include <linux/iversion.h>
45	45	#include <linux/unicode.h>
46		-
	46	+#include <linux/part_stat.h>
47	47	#include <linux/kthread.h>
48	48	#include <linux/freezer.h>
49	49
..	..	@@ -93,11 +93,11 @@
93	93	* i_mmap_rwsem (inode->i_mmap_rwsem)!
94	94	*
95	95	* page fault path:
96		- * mmap_sem -> sb_start_pagefault -> i_mmap_sem (r) -> transaction start ->
	96	+ * mmap_lock -> sb_start_pagefault -> i_mmap_sem (r) -> transaction start ->
97	97	* page lock -> i_data_sem (rw)
98	98	*
99	99	* buffered write path:
100		- * sb_start_write -> i_mutex -> mmap_sem
	100	+ * sb_start_write -> i_mutex -> mmap_lock
101	101	* sb_start_write -> i_mutex -> transaction start -> page lock ->
102	102	* i_data_sem (rw)
103	103	*
..	..	@@ -107,7 +107,7 @@
107	107	* i_data_sem (rw)
108	108	*
109	109	* direct IO:
110		- * sb_start_write -> i_mutex -> mmap_sem
	110	+ * sb_start_write -> i_mutex -> mmap_lock
111	111	* sb_start_write -> i_mutex -> transaction start -> i_data_sem (rw)
112	112	*
113	113	* writepages:
..	..	@@ -141,27 +141,109 @@
141	141	MODULE_ALIAS("ext3");
142	142	#define IS_EXT3_SB(sb) ((sb)->s_bdev->bd_holder == &ext3_fs_type)
143	143
	144	+
	145	+static inline void __ext4_read_bh(struct buffer_head *bh, int op_flags,
	146	+ bh_end_io_t *end_io)
	147	+{
	148	+ /*
	149	+ * buffer's verified bit is no longer valid after reading from
	150	+ * disk again due to write out error, clear it to make sure we
	151	+ * recheck the buffer contents.
	152	+ */
	153	+ clear_buffer_verified(bh);
	154	+
	155	+ bh->b_end_io = end_io ? end_io : end_buffer_read_sync;
	156	+ get_bh(bh);
	157	+ submit_bh(REQ_OP_READ, op_flags, bh);
	158	+}
	159	+
	160	+void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,
	161	+ bh_end_io_t *end_io)
	162	+{
	163	+ BUG_ON(!buffer_locked(bh));
	164	+
	165	+ if (ext4_buffer_uptodate(bh)) {
	166	+ unlock_buffer(bh);
	167	+ return;
	168	+ }
	169	+ __ext4_read_bh(bh, op_flags, end_io);
	170	+}
	171	+
	172	+int ext4_read_bh(struct buffer_head bh, int op_flags, bh_end_io_t end_io)
	173	+{
	174	+ BUG_ON(!buffer_locked(bh));
	175	+
	176	+ if (ext4_buffer_uptodate(bh)) {
	177	+ unlock_buffer(bh);
	178	+ return 0;
	179	+ }
	180	+
	181	+ __ext4_read_bh(bh, op_flags, end_io);
	182	+
	183	+ wait_on_buffer(bh);
	184	+ if (buffer_uptodate(bh))
	185	+ return 0;
	186	+ return -EIO;
	187	+}
	188	+
	189	+int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait)
	190	+{
	191	+ lock_buffer(bh);
	192	+ if (!wait) {
	193	+ ext4_read_bh_nowait(bh, op_flags, NULL);
	194	+ return 0;
	195	+ }
	196	+ return ext4_read_bh(bh, op_flags, NULL);
	197	+}
	198	+
144	199	/*
145		- * This works like sb_bread() except it uses ERR_PTR for error
	200	+ * This works like __bread_gfp() except it uses ERR_PTR for error
146	201	* returns. Currently with sb_bread it's impossible to distinguish
147	202	* between ENOMEM and EIO situations (since both result in a NULL
148	203	* return.
149	204	*/
150		-struct buffer_head *
151		-ext4_sb_bread(struct super_block *sb, sector_t block, int op_flags)
	205	+static struct buffer_head __ext4_sb_bread_gfp(struct super_block sb,
	206	+ sector_t block, int op_flags,
	207	+ gfp_t gfp)
152	208	{
153		- struct buffer_head *bh = sb_getblk(sb, block);
	209	+ struct buffer_head *bh;
	210	+ int ret;
154	211
	212	+ bh = sb_getblk_gfp(sb, block, gfp);
155	213	if (bh == NULL)
156	214	return ERR_PTR(-ENOMEM);
157		- if (buffer_uptodate(bh))
	215	+ if (ext4_buffer_uptodate(bh))
158	216	return bh;
159		- ll_rw_block(REQ_OP_READ, REQ_META \| op_flags, 1, &bh);
160		- wait_on_buffer(bh);
161		- if (buffer_uptodate(bh))
162		- return bh;
163		- put_bh(bh);
164		- return ERR_PTR(-EIO);
	217	+
	218	+ ret = ext4_read_bh_lock(bh, REQ_META \| op_flags, true);
	219	+ if (ret) {
	220	+ put_bh(bh);
	221	+ return ERR_PTR(ret);
	222	+ }
	223	+ return bh;
	224	+}
	225	+
	226	+struct buffer_head ext4_sb_bread(struct super_block sb, sector_t block,
	227	+ int op_flags)
	228	+{
	229	+ return __ext4_sb_bread_gfp(sb, block, op_flags, __GFP_MOVABLE);
	230	+}
	231	+
	232	+struct buffer_head ext4_sb_bread_unmovable(struct super_block sb,
	233	+ sector_t block)
	234	+{
	235	+ return __ext4_sb_bread_gfp(sb, block, 0, 0);
	236	+}
	237	+
	238	+void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block)
	239	+{
	240	+ struct buffer_head *bh = sb_getblk_gfp(sb, block, 0);
	241	+
	242	+ if (likely(bh)) {
	243	+ if (trylock_buffer(bh))
	244	+ ext4_read_bh_nowait(bh, REQ_RAHEAD, NULL);
	245	+ brelse(bh);
	246	+ }
165	247	}
166	248
167	249	static int ext4_verify_csum_type(struct super_block *sb,
..	..	@@ -202,26 +284,6 @@
202	284	return;
203	285
204	286	es->s_checksum = ext4_superblock_csum(sb, es);
205		-}
206		-
207		-void *ext4_kvmalloc(size_t size, gfp_t flags)
208		-{
209		- void *ret;
210		-
211		- ret = kmalloc(size, flags \| __GFP_NOWARN);
212		- if (!ret)
213		- ret = __vmalloc(size, flags, PAGE_KERNEL);
214		- return ret;
215		-}
216		-
217		-void *ext4_kvzalloc(size_t size, gfp_t flags)
218		-{
219		- void *ret;
220		-
221		- ret = kzalloc(size, flags \| __GFP_NOWARN);
222		- if (!ret)
223		- ret = __vmalloc(size, flags \| __GFP_ZERO, PAGE_KERNEL);
224		- return ret;
225	287	}
226	288
227	289	ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
..	..	@@ -355,10 +417,12 @@
355	417	#define ext4_get_tstamp(es, tstamp) \
356	418	__ext4_get_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi)
357	419
358		-static void __save_error_info(struct super_block sb, const char func,
359		- unsigned int line)
	420	+static void __save_error_info(struct super_block *sb, int error,
	421	+ __u32 ino, __u64 block,
	422	+ const char *func, unsigned int line)
360	423	{
361	424	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
	425	+ int err;
362	426
363	427	EXT4_SB(sb)->s_mount_state \|= EXT4_ERROR_FS;
364	428	if (bdev_read_only(sb->s_bdev))
..	..	@@ -367,6 +431,62 @@
367	431	ext4_update_tstamp(es, s_last_error_time);
368	432	strncpy(es->s_last_error_func, func, sizeof(es->s_last_error_func));
369	433	es->s_last_error_line = cpu_to_le32(line);
	434	+ es->s_last_error_ino = cpu_to_le32(ino);
	435	+ es->s_last_error_block = cpu_to_le64(block);
	436	+ switch (error) {
	437	+ case EIO:
	438	+ err = EXT4_ERR_EIO;
	439	+ break;
	440	+ case ENOMEM:
	441	+ err = EXT4_ERR_ENOMEM;
	442	+ break;
	443	+ case EFSBADCRC:
	444	+ err = EXT4_ERR_EFSBADCRC;
	445	+ break;
	446	+ case 0:
	447	+ case EFSCORRUPTED:
	448	+ err = EXT4_ERR_EFSCORRUPTED;
	449	+ break;
	450	+ case ENOSPC:
	451	+ err = EXT4_ERR_ENOSPC;
	452	+ break;
	453	+ case ENOKEY:
	454	+ err = EXT4_ERR_ENOKEY;
	455	+ break;
	456	+ case EROFS:
	457	+ err = EXT4_ERR_EROFS;
	458	+ break;
	459	+ case EFBIG:
	460	+ err = EXT4_ERR_EFBIG;
	461	+ break;
	462	+ case EEXIST:
	463	+ err = EXT4_ERR_EEXIST;
	464	+ break;
	465	+ case ERANGE:
	466	+ err = EXT4_ERR_ERANGE;
	467	+ break;
	468	+ case EOVERFLOW:
	469	+ err = EXT4_ERR_EOVERFLOW;
	470	+ break;
	471	+ case EBUSY:
	472	+ err = EXT4_ERR_EBUSY;
	473	+ break;
	474	+ case ENOTDIR:
	475	+ err = EXT4_ERR_ENOTDIR;
	476	+ break;
	477	+ case ENOTEMPTY:
	478	+ err = EXT4_ERR_ENOTEMPTY;
	479	+ break;
	480	+ case ESHUTDOWN:
	481	+ err = EXT4_ERR_ESHUTDOWN;
	482	+ break;
	483	+ case EFAULT:
	484	+ err = EXT4_ERR_EFAULT;
	485	+ break;
	486	+ default:
	487	+ err = EXT4_ERR_UNKNOWN;
	488	+ }
	489	+ es->s_last_error_errcode = err;
370	490	if (!es->s_first_error_time) {
371	491	es->s_first_error_time = es->s_last_error_time;
372	492	es->s_first_error_time_hi = es->s_last_error_time_hi;
..	..	@@ -375,6 +495,7 @@
375	495	es->s_first_error_line = cpu_to_le32(line);
376	496	es->s_first_error_ino = es->s_last_error_ino;
377	497	es->s_first_error_block = es->s_last_error_block;
	498	+ es->s_first_error_errcode = es->s_last_error_errcode;
378	499	}
379	500	/*
380	501	* Start the daily error reporting function if it hasn't been
..	..	@@ -385,10 +506,11 @@
385	506	le32_add_cpu(&es->s_error_count, 1);
386	507	}
387	508
388		-static void save_error_info(struct super_block sb, const char func,
389		- unsigned int line)
	509	+static void save_error_info(struct super_block *sb, int error,
	510	+ __u32 ino, __u64 block,
	511	+ const char *func, unsigned int line)
390	512	{
391		- __save_error_info(sb, func, line);
	513	+ __save_error_info(sb, error, ino, block, func, line);
392	514	if (!bdev_read_only(sb->s_bdev))
393	515	ext4_commit_super(sb, 1);
394	516	}
..	..	@@ -432,6 +554,89 @@
432	554	spin_unlock(&sbi->s_md_lock);
433	555	}
434	556
	557	+/*
	558	+ * This writepage callback for write_cache_pages()
	559	+ * takes care of a few cases after page cleaning.
	560	+ *
	561	+ * write_cache_pages() already checks for dirty pages
	562	+ * and calls clear_page_dirty_for_io(), which we want,
	563	+ * to write protect the pages.
	564	+ *
	565	+ * However, we may have to redirty a page (see below.)
	566	+ */
	567	+static int ext4_journalled_writepage_callback(struct page *page,
	568	+ struct writeback_control *wbc,
	569	+ void *data)
	570	+{
	571	+ transaction_t transaction = (transaction_t ) data;
	572	+ struct buffer_head bh, head;
	573	+ struct journal_head *jh;
	574	+
	575	+ bh = head = page_buffers(page);
	576	+ do {
	577	+ /*
	578	+ * We have to redirty a page in these cases:
	579	+ * 1) If buffer is dirty, it means the page was dirty because it
	580	+ * contains a buffer that needs checkpointing. So the dirty bit
	581	+ * needs to be preserved so that checkpointing writes the buffer
	582	+ * properly.
	583	+ * 2) If buffer is not part of the committing transaction
	584	+ * (we may have just accidentally come across this buffer because
	585	+ * inode range tracking is not exact) or if the currently running
	586	+ * transaction already contains this buffer as well, dirty bit
	587	+ * needs to be preserved so that the buffer gets writeprotected
	588	+ * properly on running transaction's commit.
	589	+ */
	590	+ jh = bh2jh(bh);
	591	+ if (buffer_dirty(bh) \|\|
	592	+ (jh && (jh->b_transaction != transaction \|\|
	593	+ jh->b_next_transaction))) {
	594	+ redirty_page_for_writepage(wbc, page);
	595	+ goto out;
	596	+ }
	597	+ } while ((bh = bh->b_this_page) != head);
	598	+
	599	+out:
	600	+ return AOP_WRITEPAGE_ACTIVATE;
	601	+}
	602	+
	603	+static int ext4_journalled_submit_inode_data_buffers(struct jbd2_inode *jinode)
	604	+{
	605	+ struct address_space *mapping = jinode->i_vfs_inode->i_mapping;
	606	+ struct writeback_control wbc = {
	607	+ .sync_mode = WB_SYNC_ALL,
	608	+ .nr_to_write = LONG_MAX,
	609	+ .range_start = jinode->i_dirty_start,
	610	+ .range_end = jinode->i_dirty_end,
	611	+ };
	612	+
	613	+ return write_cache_pages(mapping, &wbc,
	614	+ ext4_journalled_writepage_callback,
	615	+ jinode->i_transaction);
	616	+}
	617	+
	618	+static int ext4_journal_submit_inode_data_buffers(struct jbd2_inode *jinode)
	619	+{
	620	+ int ret;
	621	+
	622	+ if (ext4_should_journal_data(jinode->i_vfs_inode))
	623	+ ret = ext4_journalled_submit_inode_data_buffers(jinode);
	624	+ else
	625	+ ret = jbd2_journal_submit_inode_data_buffers(jinode);
	626	+
	627	+ return ret;
	628	+}
	629	+
	630	+static int ext4_journal_finish_inode_data_buffers(struct jbd2_inode *jinode)
	631	+{
	632	+ int ret = 0;
	633	+
	634	+ if (!ext4_should_journal_data(jinode->i_vfs_inode))
	635	+ ret = jbd2_journal_finish_inode_data_buffers(jinode);
	636	+
	637	+ return ret;
	638	+}
	639	+
435	640	static bool system_going_down(void)
436	641	{
437	642	return system_state == SYSTEM_HALT \|\| system_state == SYSTEM_POWER_OFF
..	..	@@ -463,7 +668,7 @@
463	668	if (sb_rdonly(sb) \|\| test_opt(sb, ERRORS_CONT))
464	669	return;
465	670
466		- EXT4_SB(sb)->s_mount_flags \|= EXT4_MF_FS_ABORTED;
	671	+ ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
467	672	if (journal)
468	673	jbd2_journal_abort(journal, -EIO);
469	674	/*
..	..	@@ -480,9 +685,6 @@
480	685	smp_wmb();
481	686	sb->s_flags \|= SB_RDONLY;
482	687	} else if (test_opt(sb, ERRORS_PANIC)) {
483		- if (EXT4_SB(sb)->s_journal &&
484		- !(EXT4_SB(sb)->s_journal->j_flags & JBD2_REC_ERR))
485		- return;
486	688	panic("EXT4-fs (device %s): panic forced after error\n",
487	689	sb->s_id);
488	690	}
..	..	@@ -493,7 +695,8 @@
493	695	"EXT4-fs error")
494	696
495	697	void __ext4_error(struct super_block sb, const char function,
496		- unsigned int line, const char *fmt, ...)
	698	+ unsigned int line, int error, __u64 block,
	699	+ const char *fmt, ...)
497	700	{
498	701	struct va_format vaf;
499	702	va_list args;
..	..	@@ -511,24 +714,21 @@
511	714	sb->s_id, function, line, current->comm, &vaf);
512	715	va_end(args);
513	716	}
514		- save_error_info(sb, function, line);
	717	+ save_error_info(sb, error, 0, block, function, line);
515	718	ext4_handle_error(sb);
516	719	}
517	720
518	721	void __ext4_error_inode(struct inode inode, const char function,
519		- unsigned int line, ext4_fsblk_t block,
	722	+ unsigned int line, ext4_fsblk_t block, int error,
520	723	const char *fmt, ...)
521	724	{
522	725	va_list args;
523	726	struct va_format vaf;
524		- struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
525	727
526	728	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
527	729	return;
528	730
529	731	trace_ext4_error(inode->i_sb, function, line);
530		- es->s_last_error_ino = cpu_to_le32(inode->i_ino);
531		- es->s_last_error_block = cpu_to_le64(block);
532	732	if (ext4_error_ratelimit(inode->i_sb)) {
533	733	va_start(args, fmt);
534	734	vaf.fmt = fmt;
..	..	@@ -545,7 +745,8 @@
545	745	current->comm, &vaf);
546	746	va_end(args);
547	747	}
548		- save_error_info(inode->i_sb, function, line);
	748	+ save_error_info(inode->i_sb, error, inode->i_ino, block,
	749	+ function, line);
549	750	ext4_handle_error(inode->i_sb);
550	751	}
551	752
..	..	@@ -555,7 +756,6 @@
555	756	{
556	757	va_list args;
557	758	struct va_format vaf;
558		- struct ext4_super_block *es;
559	759	struct inode *inode = file_inode(file);
560	760	char pathname[80], *path;
561	761
..	..	@@ -563,8 +763,6 @@
563	763	return;
564	764
565	765	trace_ext4_error(inode->i_sb, function, line);
566		- es = EXT4_SB(inode->i_sb)->s_es;
567		- es->s_last_error_ino = cpu_to_le32(inode->i_ino);
568	766	if (ext4_error_ratelimit(inode->i_sb)) {
569	767	path = file_path(file, pathname, sizeof(pathname));
570	768	if (IS_ERR(path))
..	..	@@ -586,7 +784,8 @@
586	784	current->comm, path, &vaf);
587	785	va_end(args);
588	786	}
589		- save_error_info(inode->i_sb, function, line);
	787	+ save_error_info(inode->i_sb, EFSCORRUPTED, inode->i_ino, block,
	788	+ function, line);
590	789	ext4_handle_error(inode->i_sb);
591	790	}
592	791
..	..	@@ -654,7 +853,7 @@
654	853	sb->s_id, function, line, errstr);
655	854	}
656	855
657		- save_error_info(sb, function, line);
	856	+ save_error_info(sb, -errno, 0, 0, function, line);
658	857	ext4_handle_error(sb);
659	858	}
660	859
..	..	@@ -669,7 +868,7 @@
669	868	*/
670	869
671	870	void __ext4_abort(struct super_block sb, const char function,
672		- unsigned int line, const char *fmt, ...)
	871	+ unsigned int line, int error, const char *fmt, ...)
673	872	{
674	873	struct va_format vaf;
675	874	va_list args;
..	..	@@ -677,7 +876,7 @@
677	876	if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
678	877	return;
679	878
680		- save_error_info(sb, function, line);
	879	+ save_error_info(sb, error, 0, 0, function, line);
681	880	va_start(args, fmt);
682	881	vaf.fmt = fmt;
683	882	vaf.va = &args;
..	..	@@ -686,24 +885,20 @@
686	885	va_end(args);
687	886
688	887	if (sb_rdonly(sb) == 0) {
	888	+ ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
	889	+ if (EXT4_SB(sb)->s_journal)
	890	+ jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
	891	+
689	892	ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
690		- EXT4_SB(sb)->s_mount_flags \|= EXT4_MF_FS_ABORTED;
691	893	/*
692	894	* Make sure updated value of ->s_mount_flags will be visible
693	895	* before ->s_flags update
694	896	*/
695	897	smp_wmb();
696	898	sb->s_flags \|= SB_RDONLY;
697		- if (EXT4_SB(sb)->s_journal)
698		- jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
699		- save_error_info(sb, function, line);
700	899	}
701		- if (test_opt(sb, ERRORS_PANIC) && !system_going_down()) {
702		- if (EXT4_SB(sb)->s_journal &&
703		- !(EXT4_SB(sb)->s_journal->j_flags & JBD2_REC_ERR))
704		- return;
	900	+ if (test_opt(sb, ERRORS_PANIC) && !system_going_down())
705	901	panic("EXT4-fs panic from previous error\n");
706		- }
707	902	}
708	903
709	904	void __ext4_msg(struct super_block *sb,
..	..	@@ -712,6 +907,7 @@
712	907	struct va_format vaf;
713	908	va_list args;
714	909
	910	+ atomic_inc(&EXT4_SB(sb)->s_msg_count);
715	911	if (!___ratelimit(&(EXT4_SB(sb)->s_msg_ratelimit_state), "EXT4-fs"))
716	912	return;
717	913
..	..	@@ -722,9 +918,12 @@
722	918	va_end(args);
723	919	}
724	920
725		-#define ext4_warning_ratelimit(sb) \
726		- ___ratelimit(&(EXT4_SB(sb)->s_warning_ratelimit_state), \
727		- "EXT4-fs warning")
	921	+static int ext4_warning_ratelimit(struct super_block *sb)
	922	+{
	923	+ atomic_inc(&EXT4_SB(sb)->s_warning_count);
	924	+ return ___ratelimit(&(EXT4_SB(sb)->s_warning_ratelimit_state),
	925	+ "EXT4-fs warning");
	926	+}
728	927
729	928	void __ext4_warning(struct super_block sb, const char function,
730	929	unsigned int line, const char *fmt, ...)
..	..	@@ -770,15 +969,12 @@
770	969	{
771	970	struct va_format vaf;
772	971	va_list args;
773		- struct ext4_super_block *es = EXT4_SB(sb)->s_es;
774	972
775	973	if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
776	974	return;
777	975
778	976	trace_ext4_error(sb, function, line);
779		- es->s_last_error_ino = cpu_to_le32(ino);
780		- es->s_last_error_block = cpu_to_le64(block);
781		- __save_error_info(sb, function, line);
	977	+ __save_error_info(sb, EFSCORRUPTED, ino, block, function, line);
782	978
783	979	if (ext4_error_ratelimit(sb)) {
784	980	va_start(args, fmt);
..	..	@@ -882,7 +1078,6 @@
882	1078	static struct block_device ext4_blkdev_get(dev_t dev, struct super_block sb)
883	1079	{
884	1080	struct block_device *bdev;
885		- char b[BDEVNAME_SIZE];
886	1081
887	1082	bdev = blkdev_get_by_dev(dev, FMODE_READ\|FMODE_WRITE\|FMODE_EXCL, sb);
888	1083	if (IS_ERR(bdev))
..	..	@@ -890,8 +1085,9 @@
890	1085	return bdev;
891	1086
892	1087	fail:
893		- ext4_msg(sb, KERN_ERR, "failed to open journal device %s: %ld",
894		- __bdevname(dev, b), PTR_ERR(bdev));
	1088	+ ext4_msg(sb, KERN_ERR,
	1089	+ "failed to open journal device unknown-block(%u,%u) %ld",
	1090	+ MAJOR(dev), MINOR(dev), PTR_ERR(bdev));
895	1091	return NULL;
896	1092	}
897	1093
..	..	@@ -906,10 +1102,10 @@
906	1102	static void ext4_blkdev_remove(struct ext4_sb_info *sbi)
907	1103	{
908	1104	struct block_device *bdev;
909		- bdev = sbi->journal_bdev;
	1105	+ bdev = sbi->s_journal_bdev;
910	1106	if (bdev) {
911	1107	ext4_blkdev_put(bdev);
912		- sbi->journal_bdev = NULL;
	1108	+ sbi->s_journal_bdev = NULL;
913	1109	}
914	1110	}
915	1111
..	..	@@ -974,6 +1170,18 @@
974	1170	int aborted = 0;
975	1171	int i, err;
976	1172
	1173	+ /*
	1174	+ * Unregister sysfs before destroying jbd2 journal.
	1175	+ * Since we could still access attr_journal_task attribute via sysfs
	1176	+ * path which could have sbi->s_journal->j_task as NULL
	1177	+ * Unregister sysfs before flush sbi->s_error_work.
	1178	+ * Since user may read /proc/fs/ext4/xx/mb_groups during umount, If
	1179	+ * read metadata verify failed then will queue error work.
	1180	+ * flush_stashed_error_work will call start_this_handle may trigger
	1181	+ * BUG_ON.
	1182	+ */
	1183	+ ext4_unregister_sysfs(sb);
	1184	+
977	1185	ext4_unregister_li_request(sb);
978	1186	ext4_quota_off_umount(sb);
979	1187
..	..	@@ -983,11 +1191,11 @@
983	1191	aborted = is_journal_aborted(sbi->s_journal);
984	1192	err = jbd2_journal_destroy(sbi->s_journal);
985	1193	sbi->s_journal = NULL;
986		- if ((err < 0) && !aborted)
987		- ext4_abort(sb, "Couldn't clean up the journal");
	1194	+ if ((err < 0) && !aborted) {
	1195	+ ext4_abort(sb, -err, "Couldn't clean up the journal");
	1196	+ }
988	1197	}
989	1198
990		- ext4_unregister_sysfs(sb);
991	1199	ext4_es_unregister_shrinker(sbi);
992	1200	del_timer_sync(&sbi->s_err_report);
993	1201	ext4_release_system_zone(sb);
..	..	@@ -1017,6 +1225,7 @@
1017	1225	percpu_counter_destroy(&sbi->s_freeinodes_counter);
1018	1226	percpu_counter_destroy(&sbi->s_dirs_counter);
1019	1227	percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
	1228	+ percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
1020	1229	percpu_free_rwsem(&sbi->s_writepages_rwsem);
1021	1230	#ifdef CONFIG_QUOTA
1022	1231	for (i = 0; i < EXT4_MAXQUOTAS; i++)
..	..	@@ -1033,26 +1242,25 @@
1033	1242
1034	1243	sync_blockdev(sb->s_bdev);
1035	1244	invalidate_bdev(sb->s_bdev);
1036		- if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
	1245	+ if (sbi->s_journal_bdev && sbi->s_journal_bdev != sb->s_bdev) {
1037	1246	/*
1038	1247	* Invalidate the journal device's buffers. We don't want them
1039	1248	* floating about in memory - the physical journal device may
1040	1249	* hotswapped, and it breaks the `ro-after' testing code.
1041	1250	*/
1042		- sync_blockdev(sbi->journal_bdev);
1043		- invalidate_bdev(sbi->journal_bdev);
	1251	+ sync_blockdev(sbi->s_journal_bdev);
	1252	+ invalidate_bdev(sbi->s_journal_bdev);
1044	1253	ext4_blkdev_remove(sbi);
1045	1254	}
1046		- if (sbi->s_ea_inode_cache) {
1047		- ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
1048		- sbi->s_ea_inode_cache = NULL;
1049		- }
1050		- if (sbi->s_ea_block_cache) {
1051		- ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
1052		- sbi->s_ea_block_cache = NULL;
1053		- }
1054		- if (sbi->s_mmp_tsk)
1055		- kthread_stop(sbi->s_mmp_tsk);
	1255	+
	1256	+ ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
	1257	+ sbi->s_ea_inode_cache = NULL;
	1258	+
	1259	+ ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
	1260	+ sbi->s_ea_block_cache = NULL;
	1261	+
	1262	+ ext4_stop_mmpd(sbi);
	1263	+
1056	1264	brelse(sbi->s_sbh);
1057	1265	sb->s_fs_info = NULL;
1058	1266	/*
..	..	@@ -1065,7 +1273,7 @@
1065	1273	crypto_free_shash(sbi->s_chksum_driver);
1066	1274	kfree(sbi->s_blockgroup_lock);
1067	1275	fs_put_dax(sbi->s_daxdev);
1068		- fscrypt_free_dummy_context(&sbi->s_dummy_enc_ctx);
	1276	+ fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
1069	1277	#ifdef CONFIG_UNICODE
1070	1278	utf8_unload(sb->s_encoding);
1071	1279	#endif
..	..	@@ -1088,6 +1296,7 @@
1088	1296	inode_set_iversion(&ei->vfs_inode, 1);
1089	1297	spin_lock_init(&ei->i_raw_lock);
1090	1298	INIT_LIST_HEAD(&ei->i_prealloc_list);
	1299	+ atomic_set(&ei->i_prealloc_active, 0);
1091	1300	spin_lock_init(&ei->i_prealloc_lock);
1092	1301	ext4_es_init_tree(&ei->i_es_tree);
1093	1302	rwlock_init(&ei->i_es_lock);
..	..	@@ -1096,9 +1305,8 @@
1096	1305	ei->i_es_shk_nr = 0;
1097	1306	ei->i_es_shrink_lblk = 0;
1098	1307	ei->i_reserved_data_blocks = 0;
1099		- ei->i_da_metadata_calc_len = 0;
1100		- ei->i_da_metadata_calc_last_lblock = 0;
1101	1308	spin_lock_init(&(ei->i_block_reservation_lock));
	1309	+ ext4_init_pending_tree(&ei->i_pending_tree);
1102	1310	#ifdef CONFIG_QUOTA
1103	1311	ei->i_reserved_quota = 0;
1104	1312	memset(&ei->i_dquot, 0, sizeof(ei->i_dquot));
..	..	@@ -1110,6 +1318,8 @@
1110	1318	ei->i_datasync_tid = 0;
1111	1319	atomic_set(&ei->i_unwritten, 0);
1112	1320	INIT_WORK(&ei->i_rsv_conversion_work, ext4_end_io_rsv_work);
	1321	+ ext4_fc_init_inode(&ei->vfs_inode);
	1322	+ mutex_init(&ei->i_fc_lock);
1113	1323	return &ei->vfs_inode;
1114	1324	}
1115	1325
..	..	@@ -1124,12 +1334,13 @@
1124	1334	return drop;
1125	1335	}
1126	1336
1127		-static void ext4_i_callback(struct rcu_head *head)
	1337	+static void ext4_free_in_core_inode(struct inode *inode)
1128	1338	{
1129		- struct inode *inode = container_of(head, struct inode, i_rcu);
1130		-
1131	1339	fscrypt_free_inode(inode);
1132		-
	1340	+ if (!list_empty(&(EXT4_I(inode)->i_fc_list))) {
	1341	+ pr_warn("%s: inode %ld still in fc list",
	1342	+ __func__, inode->i_ino);
	1343	+ }
1133	1344	kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
1134	1345	}
1135	1346
..	..	@@ -1144,7 +1355,12 @@
1144	1355	true);
1145	1356	dump_stack();
1146	1357	}
1147		- call_rcu(&inode->i_rcu, ext4_i_callback);
	1358	+
	1359	+ if (EXT4_I(inode)->i_reserved_data_blocks)
	1360	+ ext4_msg(inode->i_sb, KERN_ERR,
	1361	+ "Inode %lu (%p): i_reserved_data_blocks (%u) not cleared!",
	1362	+ inode->i_ino, EXT4_I(inode),
	1363	+ EXT4_I(inode)->i_reserved_data_blocks);
1148	1364	}
1149	1365
1150	1366	static void init_once(void *foo)
..	..	@@ -1156,6 +1372,7 @@
1156	1372	init_rwsem(&ei->i_data_sem);
1157	1373	init_rwsem(&ei->i_mmap_sem);
1158	1374	inode_init_once(&ei->vfs_inode);
	1375	+ ext4_fc_init_inode(&ei->vfs_inode);
1159	1376	}
1160	1377
1161	1378	static int __init init_inodecache(void)
..	..	@@ -1184,11 +1401,12 @@
1184	1401
1185	1402	void ext4_clear_inode(struct inode *inode)
1186	1403	{
	1404	+ ext4_fc_del(inode);
1187	1405	invalidate_inode_buffers(inode);
1188	1406	clear_inode(inode);
1189		- dquot_drop(inode);
1190		- ext4_discard_preallocations(inode);
	1407	+ ext4_discard_preallocations(inode, 0);
1191	1408	ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS);
	1409	+ dquot_drop(inode);
1192	1410	if (EXT4_I(inode)->jinode) {
1193	1411	jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
1194	1412	EXT4_I(inode)->jinode);
..	..	@@ -1258,8 +1476,8 @@
1258	1476	if (!page_has_buffers(page))
1259	1477	return 0;
1260	1478	if (journal)
1261		- return jbd2_journal_try_to_free_buffers(journal, page,
1262		- wait & ~__GFP_DIRECT_RECLAIM);
	1479	+ return jbd2_journal_try_to_free_buffers(journal, page);
	1480	+
1263	1481	return try_to_free_buffers(page);
1264	1482	}
1265	1483
..	..	@@ -1288,6 +1506,9 @@
1288	1506	if (WARN_ON_ONCE(IS_DAX(inode) && i_size_read(inode)))
1289	1507	return -EINVAL;
1290	1508
	1509	+ if (ext4_test_inode_flag(inode, EXT4_INODE_DAX))
	1510	+ return -EOPNOTSUPP;
	1511	+
1291	1512	res = ext4_convert_inline_data(inode);
1292	1513	if (res)
1293	1514	return res;
..	..	@@ -1313,7 +1534,7 @@
1313	1534	* Update inode->i_flags - S_ENCRYPTED will be enabled,
1314	1535	* S_DAX may be disabled
1315	1536	*/
1316		- ext4_set_inode_flags(inode);
	1537	+ ext4_set_inode_flags(inode, false);
1317	1538	}
1318	1539	return res;
1319	1540	}
..	..	@@ -1340,7 +1561,7 @@
1340	1561	* Update inode->i_flags - S_ENCRYPTED will be enabled,
1341	1562	* S_DAX may be disabled
1342	1563	*/
1343		- ext4_set_inode_flags(inode);
	1564	+ ext4_set_inode_flags(inode, false);
1344	1565	res = ext4_mark_inode_dirty(handle, inode);
1345	1566	if (res)
1346	1567	EXT4_ERROR_INODE(inode, "Failed to mark inode dirty");
..	..	@@ -1354,10 +1575,9 @@
1354	1575	return res;
1355	1576	}
1356	1577
1357		-static const union fscrypt_context *
1358		-ext4_get_dummy_context(struct super_block *sb)
	1578	+static const union fscrypt_policy ext4_get_dummy_policy(struct super_block sb)
1359	1579	{
1360		- return EXT4_SB(sb)->s_dummy_enc_ctx.ctx;
	1580	+ return EXT4_SB(sb)->s_dummy_enc_policy.policy;
1361	1581	}
1362	1582
1363	1583	static bool ext4_has_stable_inodes(struct super_block *sb)
..	..	@@ -1372,21 +1592,15 @@
1372	1592	lblk_bits_ret = 8 sizeof(ext4_lblk_t);
1373	1593	}
1374	1594
1375		-static bool ext4_inline_crypt_enabled(struct super_block *sb)
1376		-{
1377		- return test_opt(sb, INLINECRYPT);
1378		-}
1379		-
1380	1595	static const struct fscrypt_operations ext4_cryptops = {
1381	1596	.key_prefix = "ext4:",
1382	1597	.get_context = ext4_get_context,
1383	1598	.set_context = ext4_set_context,
1384		- .get_dummy_context = ext4_get_dummy_context,
	1599	+ .get_dummy_policy = ext4_get_dummy_policy,
1385	1600	.empty_dir = ext4_empty_dir,
1386	1601	.max_namelen = EXT4_NAME_LEN,
1387	1602	.has_stable_inodes = ext4_has_stable_inodes,
1388	1603	.get_ino_and_lblk_bits = ext4_get_ino_and_lblk_bits,
1389		- .inline_crypt_enabled = ext4_inline_crypt_enabled,
1390	1604	};
1391	1605	#endif
1392	1606
..	..	@@ -1409,7 +1623,6 @@
1409	1623	static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
1410	1624	unsigned int flags);
1411	1625	static int ext4_enable_quotas(struct super_block *sb);
1412		-static int ext4_get_next_id(struct super_block sb, struct kqid qid);
1413	1626
1414	1627	static struct dquot *ext4_get_dquots(struct inode inode)
1415	1628	{
..	..	@@ -1427,7 +1640,7 @@
1427	1640	.destroy_dquot = dquot_destroy,
1428	1641	.get_projid = ext4_get_projid,
1429	1642	.get_inode_usage = ext4_get_inode_usage,
1430		- .get_next_id = ext4_get_next_id,
	1643	+ .get_next_id = dquot_get_next_id,
1431	1644	};
1432	1645
1433	1646	static const struct quotactl_ops ext4_qctl_operations = {
..	..	@@ -1444,6 +1657,7 @@
1444	1657
1445	1658	static const struct super_operations ext4_sops = {
1446	1659	.alloc_inode = ext4_alloc_inode,
	1660	+ .free_inode = ext4_free_in_core_inode,
1447	1661	.destroy_inode = ext4_destroy_inode,
1448	1662	.write_inode = ext4_write_inode,
1449	1663	.dirty_inode = ext4_dirty_inode,
..	..	@@ -1485,7 +1699,8 @@
1485	1699	Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
1486	1700	Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
1487	1701	Opt_noquota, Opt_barrier, Opt_nobarrier, Opt_err,
1488		- Opt_usrquota, Opt_grpquota, Opt_prjquota, Opt_i_version, Opt_dax,
	1702	+ Opt_usrquota, Opt_grpquota, Opt_prjquota, Opt_i_version,
	1703	+ Opt_dax, Opt_dax_always, Opt_dax_inode, Opt_dax_never,
1489	1704	Opt_stripe, Opt_delalloc, Opt_nodelalloc, Opt_warn_on_error,
1490	1705	Opt_nowarn_on_error, Opt_mblk_io_submit,
1491	1706	Opt_lazytime, Opt_nolazytime, Opt_debug_want_extra_isize,
..	..	@@ -1494,6 +1709,10 @@
1494	1709	Opt_dioread_nolock, Opt_dioread_lock,
1495	1710	Opt_discard, Opt_nodiscard, Opt_init_itable, Opt_noinit_itable,
1496	1711	Opt_max_dir_size_kb, Opt_nojournal_checksum, Opt_nombcache,
	1712	+ Opt_prefetch_block_bitmaps,
	1713	+#ifdef CONFIG_EXT4_DEBUG
	1714	+ Opt_fc_debug_max_replay, Opt_fc_debug_force
	1715	+#endif
1497	1716	};
1498	1717
1499	1718	static const match_table_t tokens = {
..	..	@@ -1552,6 +1771,9 @@
1552	1771	{Opt_nobarrier, "nobarrier"},
1553	1772	{Opt_i_version, "i_version"},
1554	1773	{Opt_dax, "dax"},
	1774	+ {Opt_dax_always, "dax=always"},
	1775	+ {Opt_dax_inode, "dax=inode"},
	1776	+ {Opt_dax_never, "dax=never"},
1555	1777	{Opt_stripe, "stripe=%u"},
1556	1778	{Opt_delalloc, "delalloc"},
1557	1779	{Opt_warn_on_error, "warn_on_error"},
..	..	@@ -1570,18 +1792,24 @@
1570	1792	{Opt_auto_da_alloc, "auto_da_alloc"},
1571	1793	{Opt_noauto_da_alloc, "noauto_da_alloc"},
1572	1794	{Opt_dioread_nolock, "dioread_nolock"},
	1795	+ {Opt_dioread_lock, "nodioread_nolock"},
1573	1796	{Opt_dioread_lock, "dioread_lock"},
1574	1797	{Opt_discard, "discard"},
1575	1798	{Opt_nodiscard, "nodiscard"},
1576	1799	{Opt_init_itable, "init_itable=%u"},
1577	1800	{Opt_init_itable, "init_itable"},
1578	1801	{Opt_noinit_itable, "noinit_itable"},
	1802	+#ifdef CONFIG_EXT4_DEBUG
	1803	+ {Opt_fc_debug_force, "fc_debug_force"},
	1804	+ {Opt_fc_debug_max_replay, "fc_debug_max_replay=%u"},
	1805	+#endif
1579	1806	{Opt_max_dir_size_kb, "max_dir_size_kb=%u"},
1580	1807	{Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
1581	1808	{Opt_test_dummy_encryption, "test_dummy_encryption"},
1582	1809	{Opt_inlinecrypt, "inlinecrypt"},
1583	1810	{Opt_nombcache, "nombcache"},
1584	1811	{Opt_nombcache, "no_mbcache"}, /* for backward compatibility */
	1812	+ {Opt_prefetch_block_bitmaps, "prefetch_block_bitmaps"},
1585	1813	{Opt_removed, "check=none"}, /* mount option from ext2/3 */
1586	1814	{Opt_removed, "nocheck"}, /* mount option from ext2/3 */
1587	1815	{Opt_removed, "reservation"}, /* mount option from ext2/3 */
..	..	@@ -1700,6 +1928,8 @@
1700	1928	#define MOPT_NO_EXT3 0x0200
1701	1929	#define MOPT_EXT4_ONLY (MOPT_NO_EXT2 \| MOPT_NO_EXT3)
1702	1930	#define MOPT_STRING 0x0400
	1931	+#define MOPT_SKIP 0x0800
	1932	+#define MOPT_2 0x1000
1703	1933
1704	1934	static const struct mount_opts {
1705	1935	int token;
..	..	@@ -1724,6 +1954,7 @@
1724	1954	MOPT_EXT4_ONLY \| MOPT_CLEAR},
1725	1955	{Opt_warn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_SET},
1726	1956	{Opt_nowarn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_CLEAR},
	1957	+ {Opt_commit, 0, MOPT_NO_EXT2},
1727	1958	{Opt_nojournal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1728	1959	MOPT_EXT4_ONLY \| MOPT_CLEAR},
1729	1960	{Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
..	..	@@ -1749,7 +1980,13 @@
1749	1980	{Opt_min_batch_time, 0, MOPT_GTE0},
1750	1981	{Opt_inode_readahead_blks, 0, MOPT_GTE0},
1751	1982	{Opt_init_itable, 0, MOPT_GTE0},
1752		- {Opt_dax, EXT4_MOUNT_DAX, MOPT_SET},
	1983	+ {Opt_dax, EXT4_MOUNT_DAX_ALWAYS, MOPT_SET \| MOPT_SKIP},
	1984	+ {Opt_dax_always, EXT4_MOUNT_DAX_ALWAYS,
	1985	+ MOPT_EXT4_ONLY \| MOPT_SET \| MOPT_SKIP},
	1986	+ {Opt_dax_inode, EXT4_MOUNT2_DAX_INODE,
	1987	+ MOPT_EXT4_ONLY \| MOPT_SET \| MOPT_SKIP},
	1988	+ {Opt_dax_never, EXT4_MOUNT2_DAX_NEVER,
	1989	+ MOPT_EXT4_ONLY \| MOPT_SET \| MOPT_SKIP},
1753	1990	{Opt_stripe, 0, MOPT_GTE0},
1754	1991	{Opt_resuid, 0, MOPT_GTE0},
1755	1992	{Opt_resgid, 0, MOPT_GTE0},
..	..	@@ -1791,12 +2028,14 @@
1791	2028	{Opt_jqfmt_vfsv1, QFMT_VFS_V1, MOPT_QFMT},
1792	2029	{Opt_max_dir_size_kb, 0, MOPT_GTE0},
1793	2030	{Opt_test_dummy_encryption, 0, MOPT_STRING},
1794		-#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
1795		- {Opt_inlinecrypt, EXT4_MOUNT_INLINECRYPT, MOPT_SET},
1796		-#else
1797		- {Opt_inlinecrypt, EXT4_MOUNT_INLINECRYPT, MOPT_NOSUPPORT},
1798		-#endif
1799	2031	{Opt_nombcache, EXT4_MOUNT_NO_MBCACHE, MOPT_SET},
	2032	+ {Opt_prefetch_block_bitmaps, EXT4_MOUNT_PREFETCH_BLOCK_BITMAPS,
	2033	+ MOPT_SET},
	2034	+#ifdef CONFIG_EXT4_DEBUG
	2035	+ {Opt_fc_debug_force, EXT4_MOUNT2_JOURNAL_FAST_COMMIT,
	2036	+ MOPT_SET \| MOPT_2 \| MOPT_EXT4_ONLY},
	2037	+ {Opt_fc_debug_max_replay, 0, MOPT_GTE0},
	2038	+#endif
1800	2039	{Opt_err, 0, 0}
1801	2040	};
1802	2041
..	..	@@ -1839,18 +2078,25 @@
1839	2078	struct ext4_sb_info *sbi = EXT4_SB(sb);
1840	2079	int err;
1841	2080
	2081	+ if (!ext4_has_feature_encrypt(sb)) {
	2082	+ ext4_msg(sb, KERN_WARNING,
	2083	+ "test_dummy_encryption requires encrypt feature");
	2084	+ return -1;
	2085	+ }
	2086	+
1842	2087	/*
1843	2088	* This mount option is just for testing, and it's not worthwhile to
1844	2089	* implement the extra complexity (e.g. RCU protection) that would be
1845	2090	* needed to allow it to be set or changed during remount. We do allow
1846	2091	* it to be specified during remount, but only if there is no change.
1847	2092	*/
1848		- if (is_remount && !sbi->s_dummy_enc_ctx.ctx) {
	2093	+ if (is_remount && !sbi->s_dummy_enc_policy.policy) {
1849	2094	ext4_msg(sb, KERN_WARNING,
1850	2095	"Can't set test_dummy_encryption on remount");
1851	2096	return -1;
1852	2097	}
1853		- err = fscrypt_set_test_dummy_encryption(sb, arg, &sbi->s_dummy_enc_ctx);
	2098	+ err = fscrypt_set_test_dummy_encryption(sb, arg->from,
	2099	+ &sbi->s_dummy_enc_policy);
1854	2100	if (err) {
1855	2101	if (err == -EEXIST)
1856	2102	ext4_msg(sb, KERN_WARNING,
..	..	@@ -1865,11 +2111,13 @@
1865	2111	return -1;
1866	2112	}
1867	2113	ext4_msg(sb, KERN_WARNING, "Test dummy encryption mode enabled");
	2114	+ return 1;
1868	2115	#else
1869	2116	ext4_msg(sb, KERN_WARNING,
1870		- "Test dummy encryption mount option ignored");
	2117	+ "test_dummy_encryption option not supported");
	2118	+ return -1;
	2119	+
1871	2120	#endif
1872		- return 1;
1873	2121	}
1874	2122
1875	2123	static int handle_mount_opt(struct super_block sb, char opt, int token,
..	..	@@ -1903,7 +2151,7 @@
1903	2151	ext4_msg(sb, KERN_WARNING, "Ignoring removed %s option", opt);
1904	2152	return 1;
1905	2153	case Opt_abort:
1906		- sbi->s_mount_flags \|= EXT4_MF_FS_ABORTED;
	2154	+ ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
1907	2155	return 1;
1908	2156	case Opt_i_version:
1909	2157	sb->s_flags \|= SB_I_VERSION;
..	..	@@ -1913,6 +2161,13 @@
1913	2161	return 1;
1914	2162	case Opt_nolazytime:
1915	2163	sb->s_flags &= ~SB_LAZYTIME;
	2164	+ return 1;
	2165	+ case Opt_inlinecrypt:
	2166	+#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
	2167	+ sb->s_flags \|= SB_INLINECRYPT;
	2168	+#else
	2169	+ ext4_msg(sb, KERN_ERR, "inline encryption not supported");
	2170	+#endif
1916	2171	return 1;
1917	2172	}
1918	2173
..	..	@@ -1962,6 +2217,13 @@
1962	2217	} else if (token == Opt_commit) {
1963	2218	if (arg == 0)
1964	2219	arg = JBD2_DEFAULT_MAX_COMMIT_AGE;
	2220	+ else if (arg > INT_MAX / HZ) {
	2221	+ ext4_msg(sb, KERN_ERR,
	2222	+ "Invalid commit interval %d, "
	2223	+ "must be smaller than %d",
	2224	+ arg, INT_MAX / HZ);
	2225	+ return -1;
	2226	+ }
1965	2227	sbi->s_commit_interval = HZ * arg;
1966	2228	} else if (token == Opt_debug_want_extra_isize) {
1967	2229	if ((arg & 1) \|\|
..	..	@@ -1991,6 +2253,10 @@
1991	2253	sbi->s_li_wait_mult = arg;
1992	2254	} else if (token == Opt_max_dir_size_kb) {
1993	2255	sbi->s_max_dir_size_kb = arg;
	2256	+#ifdef CONFIG_EXT4_DEBUG
	2257	+ } else if (token == Opt_fc_debug_max_replay) {
	2258	+ sbi->s_fc_debug_max_replay = arg;
	2259	+#endif
1994	2260	} else if (token == Opt_stripe) {
1995	2261	sbi->s_stripe = arg;
1996	2262	} else if (token == Opt_resuid) {
..	..	@@ -2092,23 +2358,56 @@
2092	2358	}
2093	2359	sbi->s_jquota_fmt = m->mount_opt;
2094	2360	#endif
2095		- } else if (token == Opt_dax) {
	2361	+ } else if (token == Opt_dax \|\| token == Opt_dax_always \|\|
	2362	+ token == Opt_dax_inode \|\| token == Opt_dax_never) {
2096	2363	#ifdef CONFIG_FS_DAX
2097		- if (is_remount && test_opt(sb, DAX)) {
2098		- ext4_msg(sb, KERN_ERR, "can't mount with "
2099		- "both data=journal and dax");
2100		- return -1;
	2364	+ switch (token) {
	2365	+ case Opt_dax:
	2366	+ case Opt_dax_always:
	2367	+ if (is_remount &&
	2368	+ (!(sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) \|\|
	2369	+ (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER))) {
	2370	+ fail_dax_change_remount:
	2371	+ ext4_msg(sb, KERN_ERR, "can't change "
	2372	+ "dax mount option while remounting");
	2373	+ return -1;
	2374	+ }
	2375	+ if (is_remount &&
	2376	+ (test_opt(sb, DATA_FLAGS) ==
	2377	+ EXT4_MOUNT_JOURNAL_DATA)) {
	2378	+ ext4_msg(sb, KERN_ERR, "can't mount with "
	2379	+ "both data=journal and dax");
	2380	+ return -1;
	2381	+ }
	2382	+ ext4_msg(sb, KERN_WARNING,
	2383	+ "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
	2384	+ sbi->s_mount_opt \|= EXT4_MOUNT_DAX_ALWAYS;
	2385	+ sbi->s_mount_opt2 &= ~EXT4_MOUNT2_DAX_NEVER;
	2386	+ break;
	2387	+ case Opt_dax_never:
	2388	+ if (is_remount &&
	2389	+ (!(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) \|\|
	2390	+ (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS)))
	2391	+ goto fail_dax_change_remount;
	2392	+ sbi->s_mount_opt2 \|= EXT4_MOUNT2_DAX_NEVER;
	2393	+ sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
	2394	+ break;
	2395	+ case Opt_dax_inode:
	2396	+ if (is_remount &&
	2397	+ ((sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) \|\|
	2398	+ (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) \|\|
	2399	+ !(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_INODE)))
	2400	+ goto fail_dax_change_remount;
	2401	+ sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
	2402	+ sbi->s_mount_opt2 &= ~EXT4_MOUNT2_DAX_NEVER;
	2403	+ /* Strictly for printing options */
	2404	+ sbi->s_mount_opt2 \|= EXT4_MOUNT2_DAX_INODE;
	2405	+ break;
2101	2406	}
2102		- if (is_remount && !(sbi->s_mount_opt & EXT4_MOUNT_DAX)) {
2103		- ext4_msg(sb, KERN_ERR, "can't change "
2104		- "dax mount option while remounting");
2105		- return -1;
2106		- }
2107		- ext4_msg(sb, KERN_WARNING,
2108		- "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
2109		- sbi->s_mount_opt \|= m->mount_opt;
2110	2407	#else
2111	2408	ext4_msg(sb, KERN_INFO, "dax option not supported");
	2409	+ sbi->s_mount_opt2 \|= EXT4_MOUNT2_DAX_NEVER;
	2410	+ sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
2112	2411	return -1;
2113	2412	#endif
2114	2413	} else if (token == Opt_data_err_abort) {
..	..	@@ -2126,10 +2425,17 @@
2126	2425	WARN_ON(1);
2127	2426	return -1;
2128	2427	}
2129		- if (arg != 0)
2130		- sbi->s_mount_opt \|= m->mount_opt;
2131		- else
2132		- sbi->s_mount_opt &= ~m->mount_opt;
	2428	+ if (m->flags & MOPT_2) {
	2429	+ if (arg != 0)
	2430	+ sbi->s_mount_opt2 \|= m->mount_opt;
	2431	+ else
	2432	+ sbi->s_mount_opt2 &= ~m->mount_opt;
	2433	+ } else {
	2434	+ if (arg != 0)
	2435	+ sbi->s_mount_opt \|= m->mount_opt;
	2436	+ else
	2437	+ sbi->s_mount_opt &= ~m->mount_opt;
	2438	+ }
2133	2439	}
2134	2440	return 1;
2135	2441	}
..	..	@@ -2139,7 +2445,7 @@
2139	2445	unsigned int *journal_ioprio,
2140	2446	int is_remount)
2141	2447	{
2142		- struct ext4_sb_info *sbi = EXT4_SB(sb);
	2448	+ struct ext4_sb_info __maybe_unused *sbi = EXT4_SB(sb);
2143	2449	char p, __maybe_unused usr_qf_name, __maybe_unused *grp_qf_name;
2144	2450	substring_t args[MAX_OPT_ARGS];
2145	2451	int token;
..	..	@@ -2196,12 +2502,10 @@
2196	2502	if (test_opt(sb, DIOREAD_NOLOCK)) {
2197	2503	int blocksize =
2198	2504	BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
2199		-
2200		- if (blocksize < PAGE_SIZE) {
2201		- ext4_msg(sb, KERN_ERR, "can't mount with "
2202		- "dioread_nolock if block size != PAGE_SIZE");
2203		- return 0;
2204		- }
	2505	+ if (blocksize < PAGE_SIZE)
	2506	+ ext4_msg(sb, KERN_WARNING, "Warning: mounting with an "
	2507	+ "experimental mount option 'dioread_nolock' "
	2508	+ "for blocksize < PAGE_SIZE");
2205	2509	}
2206	2510	return 1;
2207	2511	}
..	..	@@ -2274,7 +2578,7 @@
2274	2578	for (m = ext4_mount_opts; m->token != Opt_err; m++) {
2275	2579	int want_set = m->flags & MOPT_SET;
2276	2580	if (((m->flags & (MOPT_SET\|MOPT_CLEAR)) == 0) \|\|
2277		- (m->flags & MOPT_CLEAR_ERR))
	2581	+ (m->flags & MOPT_CLEAR_ERR) \|\| m->flags & MOPT_SKIP)
2278	2582	continue;
2279	2583	if (!nodefs && !(m->mount_opt & (sbi->s_mount_opt ^ def_mount_opt)))
2280	2584	continue; /* skip if same as the default */
..	..	@@ -2334,6 +2638,19 @@
2334	2638
2335	2639	fscrypt_show_test_dummy_encryption(seq, sep, sb);
2336	2640
	2641	+ if (sb->s_flags & SB_INLINECRYPT)
	2642	+ SEQ_OPTS_PUTS("inlinecrypt");
	2643	+
	2644	+ if (test_opt(sb, DAX_ALWAYS)) {
	2645	+ if (IS_EXT2_SB(sb))
	2646	+ SEQ_OPTS_PUTS("dax");
	2647	+ else
	2648	+ SEQ_OPTS_PUTS("dax=always");
	2649	+ } else if (test_opt2(sb, DAX_NEVER)) {
	2650	+ SEQ_OPTS_PUTS("dax=never");
	2651	+ } else if (test_opt2(sb, DAX_INODE)) {
	2652	+ SEQ_OPTS_PUTS("dax=inode");
	2653	+ }
2337	2654	ext4_show_quota_options(seq, sb);
2338	2655	return 0;
2339	2656	}
..	..	@@ -2859,13 +3176,9 @@
2859	3176	loff_t res;
2860	3177	loff_t upper_limit = MAX_LFS_FILESIZE;
2861	3178
2862		- /* small i_blocks in vfs inode? */
2863		- if (!has_huge_files \|\| sizeof(blkcnt_t) < sizeof(u64)) {
2864		- /*
2865		- * CONFIG_LBDAF is not enabled implies the inode
2866		- * i_block represent total blocks in 512 bytes
2867		- * 32 == size of vfs inode i_blocks * 8
2868		- */
	3179	+ BUILD_BUG_ON(sizeof(blkcnt_t) < sizeof(u64));
	3180	+
	3181	+ if (!has_huge_files) {
2869	3182	upper_limit = (1LL << 32) - 1;
2870	3183
2871	3184	/* total blocks in file system block size */
..	..	@@ -2895,22 +3208,22 @@
2895	3208	*/
2896	3209	static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
2897	3210	{
2898		- loff_t res = EXT4_NDIR_BLOCKS;
	3211	+ unsigned long long upper_limit, res = EXT4_NDIR_BLOCKS;
2899	3212	int meta_blocks;
2900		- loff_t upper_limit;
2901		- /* This is calculated to be the largest file size for a dense, block
	3213	+
	3214	+ /*
	3215	+ * This is calculated to be the largest file size for a dense, block
2902	3216	* mapped file such that the file's total number of 512-byte sectors,
2903	3217	* including data and all indirect blocks, does not exceed (2^48 - 1).
2904	3218	*
2905	3219	* __u32 i_blocks_lo and _u16 i_blocks_high represent the total
2906	3220	* number of 512-byte sectors of the file.
2907	3221	*/
2908		-
2909		- if (!has_huge_files \|\| sizeof(blkcnt_t) < sizeof(u64)) {
	3222	+ if (!has_huge_files) {
2910	3223	/*
2911		- * !has_huge_files or CONFIG_LBDAF not enabled implies that
2912		- * the inode i_block field represents total file blocks in
2913		- * 2^32 512-byte sectors == size of vfs inode i_blocks * 8
	3224	+ * !has_huge_files or implies that the inode i_block field
	3225	+ * represents total file blocks in 2^32 512-byte sectors ==
	3226	+ * size of vfs inode i_blocks * 8
2914	3227	*/
2915	3228	upper_limit = (1LL << 32) - 1;
2916	3229
..	..	@@ -2948,7 +3261,7 @@
2948	3261	if (res > MAX_LFS_FILESIZE)
2949	3262	res = MAX_LFS_FILESIZE;
2950	3263
2951		- return res;
	3264	+ return (loff_t)res;
2952	3265	}
2953	3266
2954	3267	static ext4_fsblk_t descriptor_loc(struct super_block *sb,
..	..	@@ -3059,18 +3372,6 @@
3059	3372	~EXT4_FEATURE_RO_COMPAT_SUPP));
3060	3373	return 0;
3061	3374	}
3062		- /*
3063		- * Large file size enabled file system can only be mounted
3064		- * read-write on 32-bit systems if kernel is built with CONFIG_LBDAF
3065		- */
3066		- if (ext4_has_feature_huge_file(sb)) {
3067		- if (sizeof(blkcnt_t) < sizeof(u64)) {
3068		- ext4_msg(sb, KERN_ERR, "Filesystem with huge files "
3069		- "cannot be mounted RDWR without "
3070		- "CONFIG_LBDAF");
3071		- return 0;
3072		- }
3073		- }
3074	3375	if (ext4_has_feature_bigalloc(sb) && !ext4_has_feature_extents(sb)) {
3075	3376	ext4_msg(sb, KERN_ERR,
3076	3377	"Can't support bigalloc feature without "
..	..	@@ -3140,15 +3441,34 @@
3140	3441	static int ext4_run_li_request(struct ext4_li_request *elr)
3141	3442	{
3142	3443	struct ext4_group_desc *gdp = NULL;
3143		- ext4_group_t group, ngroups;
3144		- struct super_block *sb;
	3444	+ struct super_block *sb = elr->lr_super;
	3445	+ ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
	3446	+ ext4_group_t group = elr->lr_next_group;
	3447	+ unsigned int prefetch_ios = 0;
3145	3448	int ret = 0;
3146	3449	u64 start_time;
3147	3450
3148		- sb = elr->lr_super;
3149		- ngroups = EXT4_SB(sb)->s_groups_count;
	3451	+ if (elr->lr_mode == EXT4_LI_MODE_PREFETCH_BBITMAP) {
	3452	+ elr->lr_next_group = ext4_mb_prefetch(sb, group,
	3453	+ EXT4_SB(sb)->s_mb_prefetch, &prefetch_ios);
	3454	+ if (prefetch_ios)
	3455	+ ext4_mb_prefetch_fini(sb, elr->lr_next_group,
	3456	+ prefetch_ios);
	3457	+ trace_ext4_prefetch_bitmaps(sb, group, elr->lr_next_group,
	3458	+ prefetch_ios);
	3459	+ if (group >= elr->lr_next_group) {
	3460	+ ret = 1;
	3461	+ if (elr->lr_first_not_zeroed != ngroups &&
	3462	+ !sb_rdonly(sb) && test_opt(sb, INIT_INODE_TABLE)) {
	3463	+ elr->lr_next_group = elr->lr_first_not_zeroed;
	3464	+ elr->lr_mode = EXT4_LI_MODE_ITABLE;
	3465	+ ret = 0;
	3466	+ }
	3467	+ }
	3468	+ return ret;
	3469	+ }
3150	3470
3151		- for (group = elr->lr_next_group; group < ngroups; group++) {
	3471	+ for (; group < ngroups; group++) {
3152	3472	gdp = ext4_get_group_desc(sb, group, NULL);
3153	3473	if (!gdp) {
3154	3474	ret = 1;
..	..	@@ -3166,9 +3486,10 @@
3166	3486	start_time = ktime_get_real_ns();
3167	3487	ret = ext4_init_inode_table(sb, group,
3168	3488	elr->lr_timeout ? 0 : 1);
	3489	+ trace_ext4_lazy_itable_init(sb, group);
3169	3490	if (elr->lr_timeout == 0) {
3170	3491	elr->lr_timeout = nsecs_to_jiffies((ktime_get_real_ns() - start_time) *
3171		- elr->lr_sbi->s_li_wait_mult);
	3492	+ EXT4_SB(elr->lr_super)->s_li_wait_mult);
3172	3493	}
3173	3494	elr->lr_next_sched = jiffies + elr->lr_timeout;
3174	3495	elr->lr_next_group = group + 1;
..	..	@@ -3182,15 +3503,11 @@
3182	3503	*/
3183	3504	static void ext4_remove_li_request(struct ext4_li_request *elr)
3184	3505	{
3185		- struct ext4_sb_info *sbi;
3186		-
3187	3506	if (!elr)
3188	3507	return;
3189	3508
3190		- sbi = elr->lr_sbi;
3191		-
3192	3509	list_del(&elr->lr_request);
3193		- sbi->s_li_request = NULL;
	3510	+ EXT4_SB(elr->lr_super)->s_li_request = NULL;
3194	3511	kfree(elr);
3195	3512	}
3196	3513
..	..	@@ -3227,6 +3544,7 @@
3227	3544	unsigned long next_wakeup, cur;
3228	3545
3229	3546	BUG_ON(NULL == eli);
	3547	+ set_freezable();
3230	3548
3231	3549	cont_thread:
3232	3550	while (true) {
..	..	@@ -3399,7 +3717,6 @@
3399	3717	static struct ext4_li_request ext4_li_request_new(struct super_block sb,
3400	3718	ext4_group_t start)
3401	3719	{
3402		- struct ext4_sb_info *sbi = EXT4_SB(sb);
3403	3720	struct ext4_li_request *elr;
3404	3721
3405	3722	elr = kzalloc(sizeof(*elr), GFP_KERNEL);
..	..	@@ -3407,8 +3724,13 @@
3407	3724	return NULL;
3408	3725
3409	3726	elr->lr_super = sb;
3410		- elr->lr_sbi = sbi;
3411		- elr->lr_next_group = start;
	3727	+ elr->lr_first_not_zeroed = start;
	3728	+ if (test_opt(sb, PREFETCH_BLOCK_BITMAPS))
	3729	+ elr->lr_mode = EXT4_LI_MODE_PREFETCH_BBITMAP;
	3730	+ else {
	3731	+ elr->lr_mode = EXT4_LI_MODE_ITABLE;
	3732	+ elr->lr_next_group = start;
	3733	+ }
3412	3734
3413	3735	/*
3414	3736	* Randomize first schedule time of the request to
..	..	@@ -3438,8 +3760,9 @@
3438	3760	goto out;
3439	3761	}
3440	3762
3441		- if (first_not_zeroed == ngroups \|\| sb_rdonly(sb) \|\|
3442		- !test_opt(sb, INIT_INODE_TABLE))
	3763	+ if (!test_opt(sb, PREFETCH_BLOCK_BITMAPS) &&
	3764	+ (first_not_zeroed == ngroups \|\| sb_rdonly(sb) \|\|
	3765	+ !test_opt(sb, INIT_INODE_TABLE)))
3443	3766	goto out;
3444	3767
3445	3768	elr = ext4_li_request_new(sb, first_not_zeroed);
..	..	@@ -3556,9 +3879,11 @@
3556	3879	ext4_fsblk_t first_block, last_block, b;
3557	3880	ext4_group_t i, ngroups = ext4_get_groups_count(sb);
3558	3881	int s, j, count = 0;
	3882	+ int has_super = ext4_bg_has_super(sb, grp);
3559	3883
3560	3884	if (!ext4_has_feature_bigalloc(sb))
3561		- return (ext4_bg_has_super(sb, grp) + ext4_bg_num_gdb(sb, grp) +
	3885	+ return (has_super + ext4_bg_num_gdb(sb, grp) +
	3886	+ (has_super ? le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0) +
3562	3887	sbi->s_itb_per_group + 2);
3563	3888
3564	3889	first_block = le32_to_cpu(sbi->s_es->s_first_data_block) +
..	..	@@ -3650,8 +3975,8 @@
3650	3975	* Add the internal journal blocks whether the journal has been
3651	3976	* loaded or not
3652	3977	*/
3653		- if (sbi->s_journal && !sbi->journal_bdev)
3654		- overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_maxlen);
	3978	+ if (sbi->s_journal && !sbi->s_journal_bdev)
	3979	+ overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_total_len);
3655	3980	else if (ext4_has_feature_journal(sb) && !sbi->s_journal && j_inum) {
3656	3981	/* j_inum for internal journal is non-zero */
3657	3982	j_inode = ext4_get_journal_inode(sb, j_inum);
..	..	@@ -3719,7 +4044,7 @@
3719	4044	int blocksize, clustersize;
3720	4045	unsigned int db_count;
3721	4046	unsigned int i;
3722		- int needs_recovery, has_huge_files, has_bigalloc;
	4047	+ int needs_recovery, has_huge_files;
3723	4048	__u64 blocks_count;
3724	4049	int err = 0;
3725	4050	unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
..	..	@@ -3764,8 +4089,11 @@
3764	4089	logical_sb_block = sb_block;
3765	4090	}
3766	4091
3767		- if (!(bh = sb_bread_unmovable(sb, logical_sb_block))) {
	4092	+ bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
	4093	+ if (IS_ERR(bh)) {
3768	4094	ext4_msg(sb, KERN_ERR, "unable to read superblock");
	4095	+ ret = PTR_ERR(bh);
	4096	+ bh = NULL;
3769	4097	goto out_fail;
3770	4098	}
3771	4099	/*
..	..	@@ -3832,6 +4160,8 @@
3832	4160	#ifdef CONFIG_EXT4_FS_POSIX_ACL
3833	4161	set_opt(sb, POSIX_ACL);
3834	4162	#endif
	4163	+ if (ext4_has_feature_fast_commit(sb))
	4164	+ set_opt2(sb, JOURNAL_FAST_COMMIT);
3835	4165	/* don't forget to enable journal_csum when metadata_csum is enabled. */
3836	4166	if (ext4_has_metadata_csum(sb))
3837	4167	set_opt(sb, JOURNAL_CHECKSUM);
..	..	@@ -3877,14 +4207,25 @@
3877	4207	*/
3878	4208	sbi->s_li_wait_mult = EXT4_DEF_LI_WAIT_MULT;
3879	4209
3880		- blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
3881		- if (blocksize < EXT4_MIN_BLOCK_SIZE \|\|
3882		- blocksize > EXT4_MAX_BLOCK_SIZE) {
	4210	+ if (le32_to_cpu(es->s_log_block_size) >
	4211	+ (EXT4_MAX_BLOCK_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
3883	4212	ext4_msg(sb, KERN_ERR,
3884		- "Unsupported filesystem blocksize %d (%d log_block_size)",
3885		- blocksize, le32_to_cpu(es->s_log_block_size));
	4213	+ "Invalid log block size: %u",
	4214	+ le32_to_cpu(es->s_log_block_size));
3886	4215	goto failed_mount;
3887	4216	}
	4217	+ if (le32_to_cpu(es->s_log_cluster_size) >
	4218	+ (EXT4_MAX_CLUSTER_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
	4219	+ ext4_msg(sb, KERN_ERR,
	4220	+ "Invalid log cluster size: %u",
	4221	+ le32_to_cpu(es->s_log_cluster_size));
	4222	+ goto failed_mount;
	4223	+ }
	4224	+
	4225	+ blocksize = EXT4_MIN_BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
	4226	+
	4227	+ if (blocksize == PAGE_SIZE)
	4228	+ set_opt(sb, DIOREAD_NOLOCK);
3888	4229
3889	4230	if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
3890	4231	sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
..	..	@@ -3915,9 +4256,12 @@
3915	4256	if (sbi->s_inode_size >= offsetof(struct ext4_inode, i_atime_extra) +
3916	4257	sizeof(((struct ext4_inode *)0)->i_atime_extra)) {
3917	4258	sb->s_time_gran = 1;
	4259	+ sb->s_time_max = EXT4_EXTRA_TIMESTAMP_MAX;
3918	4260	} else {
3919	4261	sb->s_time_gran = NSEC_PER_SEC;
	4262	+ sb->s_time_max = EXT4_NON_EXTRA_TIMESTAMP_MAX;
3920	4263	}
	4264	+ sb->s_time_min = EXT4_TIMESTAMP_MIN;
3921	4265	}
3922	4266	if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
3923	4267	sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
..	..	@@ -3997,20 +4341,16 @@
3997	4341	#endif
3998	4342
3999	4343	if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
4000		- printk_once(KERN_WARNING "EXT4-fs: Warning: mounting "
4001		- "with data=journal disables delayed "
4002		- "allocation and O_DIRECT support!\n");
	4344	+ printk_once(KERN_WARNING "EXT4-fs: Warning: mounting with data=journal disables delayed allocation, dioread_nolock, O_DIRECT and fast_commit support!\n");
	4345	+ /* can't mount with both data=journal and dioread_nolock. */
	4346	+ clear_opt(sb, DIOREAD_NOLOCK);
	4347	+ clear_opt2(sb, JOURNAL_FAST_COMMIT);
4003	4348	if (test_opt2(sb, EXPLICIT_DELALLOC)) {
4004	4349	ext4_msg(sb, KERN_ERR, "can't mount with "
4005	4350	"both data=journal and delalloc");
4006	4351	goto failed_mount;
4007	4352	}
4008		- if (test_opt(sb, DIOREAD_NOLOCK)) {
4009		- ext4_msg(sb, KERN_ERR, "can't mount with "
4010		- "both data=journal and dioread_nolock");
4011		- goto failed_mount;
4012		- }
4013		- if (test_opt(sb, DAX)) {
	4353	+ if (test_opt(sb, DAX_ALWAYS)) {
4014	4354	ext4_msg(sb, KERN_ERR, "can't mount with "
4015	4355	"both data=journal and dax");
4016	4356	goto failed_mount;
..	..	@@ -4098,21 +4438,6 @@
4098	4438	if (!ext4_feature_set_ok(sb, (sb_rdonly(sb))))
4099	4439	goto failed_mount;
4100	4440
4101		- if (le32_to_cpu(es->s_log_block_size) >
4102		- (EXT4_MAX_BLOCK_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
4103		- ext4_msg(sb, KERN_ERR,
4104		- "Invalid log block size: %u",
4105		- le32_to_cpu(es->s_log_block_size));
4106		- goto failed_mount;
4107		- }
4108		- if (le32_to_cpu(es->s_log_cluster_size) >
4109		- (EXT4_MAX_CLUSTER_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
4110		- ext4_msg(sb, KERN_ERR,
4111		- "Invalid log cluster size: %u",
4112		- le32_to_cpu(es->s_log_cluster_size));
4113		- goto failed_mount;
4114		- }
4115		-
4116	4441	if (le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) > (blocksize / 4)) {
4117	4442	ext4_msg(sb, KERN_ERR,
4118	4443	"Number of reserved GDT blocks insanely large: %d",
..	..	@@ -4120,16 +4445,19 @@
4120	4445	goto failed_mount;
4121	4446	}
4122	4447
4123		- if (sbi->s_mount_opt & EXT4_MOUNT_DAX) {
	4448	+ if (bdev_dax_supported(sb->s_bdev, blocksize))
	4449	+ set_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags);
	4450	+
	4451	+ if (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) {
4124	4452	if (ext4_has_feature_inline_data(sb)) {
4125	4453	ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem"
4126	4454	" that may contain inline data");
4127		- sbi->s_mount_opt &= ~EXT4_MOUNT_DAX;
	4455	+ goto failed_mount;
4128	4456	}
4129		- if (!bdev_dax_supported(sb->s_bdev, blocksize)) {
	4457	+ if (!test_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags)) {
4130	4458	ext4_msg(sb, KERN_ERR,
4131		- "DAX unsupported by block device. Turning off DAX.");
4132		- sbi->s_mount_opt &= ~EXT4_MOUNT_DAX;
	4459	+ "DAX unsupported by block device.");
	4460	+ goto failed_mount;
4133	4461	}
4134	4462	}
4135	4463
..	..	@@ -4140,20 +4468,28 @@
4140	4468	}
4141	4469
4142	4470	if (sb->s_blocksize != blocksize) {
	4471	+ /*
	4472	+ * bh must be released before kill_bdev(), otherwise
	4473	+ * it won't be freed and its page also. kill_bdev()
	4474	+ * is called by sb_set_blocksize().
	4475	+ */
	4476	+ brelse(bh);
4143	4477	/* Validate the filesystem blocksize */
4144	4478	if (!sb_set_blocksize(sb, blocksize)) {
4145	4479	ext4_msg(sb, KERN_ERR, "bad block size %d",
4146	4480	blocksize);
	4481	+ bh = NULL;
4147	4482	goto failed_mount;
4148	4483	}
4149	4484
4150		- brelse(bh);
4151	4485	logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
4152	4486	offset = do_div(logical_sb_block, blocksize);
4153		- bh = sb_bread_unmovable(sb, logical_sb_block);
4154		- if (!bh) {
	4487	+ bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
	4488	+ if (IS_ERR(bh)) {
4155	4489	ext4_msg(sb, KERN_ERR,
4156	4490	"Can't read superblock on 2nd try");
	4491	+ ret = PTR_ERR(bh);
	4492	+ bh = NULL;
4157	4493	goto failed_mount;
4158	4494	}
4159	4495	es = (struct ext4_super_block *)(bh->b_data + offset);
..	..	@@ -4199,7 +4535,7 @@
4199	4535	sbi->s_inodes_per_block;
4200	4536	sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
4201	4537	sbi->s_sbh = bh;
4202		- sbi->s_mount_state = le16_to_cpu(es->s_state);
	4538	+ sbi->s_mount_state = le16_to_cpu(es->s_state) & ~EXT4_FC_REPLAY;
4203	4539	sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
4204	4540	sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
4205	4541
..	..	@@ -4226,8 +4562,7 @@
4226	4562
4227	4563	/* Handle clustersize */
4228	4564	clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
4229		- has_bigalloc = ext4_has_feature_bigalloc(sb);
4230		- if (has_bigalloc) {
	4565	+ if (ext4_has_feature_bigalloc(sb)) {
4231	4566	if (clustersize < blocksize) {
4232	4567	ext4_msg(sb, KERN_ERR,
4233	4568	"cluster size (%d) smaller than "
..	..	@@ -4283,8 +4618,6 @@
4283	4618	if (err) {
4284	4619	ext4_msg(sb, KERN_ERR, "filesystem"
4285	4620	" too large to mount safely on this system");
4286		- if (sizeof(sector_t) < 8)
4287		- ext4_msg(sb, KERN_WARNING, "CONFIG_LBDAF not enabled");
4288	4621	goto failed_mount;
4289	4622	}
4290	4623
..	..	@@ -4368,18 +4701,20 @@
4368	4701	/* Pre-read the descriptors into the buffer cache */
4369	4702	for (i = 0; i < db_count; i++) {
4370	4703	block = descriptor_loc(sb, logical_sb_block, i);
4371		- sb_breadahead_unmovable(sb, block);
	4704	+ ext4_sb_breadahead_unmovable(sb, block);
4372	4705	}
4373	4706
4374	4707	for (i = 0; i < db_count; i++) {
4375	4708	struct buffer_head *bh;
4376	4709
4377	4710	block = descriptor_loc(sb, logical_sb_block, i);
4378		- bh = sb_bread_unmovable(sb, block);
4379		- if (!bh) {
	4711	+ bh = ext4_sb_bread_unmovable(sb, block);
	4712	+ if (IS_ERR(bh)) {
4380	4713	ext4_msg(sb, KERN_ERR,
4381	4714	"can't read group descriptor %d", i);
4382	4715	db_count = i;
	4716	+ ret = PTR_ERR(bh);
	4717	+ bh = NULL;
4383	4718	goto failed_mount2;
4384	4719	}
4385	4720	rcu_read_lock();
..	..	@@ -4426,6 +4761,26 @@
4426	4761
4427	4762	INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
4428	4763	mutex_init(&sbi->s_orphan_lock);
	4764	+
	4765	+ /* Initialize fast commit stuff */
	4766	+ atomic_set(&sbi->s_fc_subtid, 0);
	4767	+ atomic_set(&sbi->s_fc_ineligible_updates, 0);
	4768	+ INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_MAIN]);
	4769	+ INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_STAGING]);
	4770	+ INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_MAIN]);
	4771	+ INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_STAGING]);
	4772	+ sbi->s_fc_bytes = 0;
	4773	+ ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
	4774	+ ext4_clear_mount_flag(sb, EXT4_MF_FC_COMMITTING);
	4775	+ spin_lock_init(&sbi->s_fc_lock);
	4776	+ memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));
	4777	+ sbi->s_fc_replay_state.fc_regions = NULL;
	4778	+ sbi->s_fc_replay_state.fc_regions_size = 0;
	4779	+ sbi->s_fc_replay_state.fc_regions_used = 0;
	4780	+ sbi->s_fc_replay_state.fc_regions_valid = 0;
	4781	+ sbi->s_fc_replay_state.fc_modified_inodes = NULL;
	4782	+ sbi->s_fc_replay_state.fc_modified_inodes_size = 0;
	4783	+ sbi->s_fc_replay_state.fc_modified_inodes_used = 0;
4429	4784
4430	4785	sb->s_root = NULL;
4431	4786
..	..	@@ -4476,6 +4831,7 @@
4476	4831	sbi->s_def_mount_opt &= ~EXT4_MOUNT_JOURNAL_CHECKSUM;
4477	4832	clear_opt(sb, JOURNAL_CHECKSUM);
4478	4833	clear_opt(sb, DATA_FLAGS);
	4834	+ clear_opt2(sb, JOURNAL_FAST_COMMIT);
4479	4835	sbi->s_journal = NULL;
4480	4836	needs_recovery = 0;
4481	4837	goto no_journal;
..	..	@@ -4491,6 +4847,14 @@
4491	4847	if (!set_journal_csum_feature_set(sb)) {
4492	4848	ext4_msg(sb, KERN_ERR, "Failed to set journal checksum "
4493	4849	"feature set");
	4850	+ goto failed_mount_wq;
	4851	+ }
	4852	+
	4853	+ if (test_opt2(sb, JOURNAL_FAST_COMMIT) &&
	4854	+ !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
	4855	+ JBD2_FEATURE_INCOMPAT_FAST_COMMIT)) {
	4856	+ ext4_msg(sb, KERN_ERR,
	4857	+ "Failed to set fast commit journal feature");
4494	4858	goto failed_mount_wq;
4495	4859	}
4496	4860
..	..	@@ -4533,7 +4897,10 @@
4533	4897
4534	4898	set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
4535	4899
4536		- sbi->s_journal->j_commit_callback = ext4_journal_commit_callback;
	4900	+ sbi->s_journal->j_submit_inode_data_buffers =
	4901	+ ext4_journal_submit_inode_data_buffers;
	4902	+ sbi->s_journal->j_finish_inode_data_buffers =
	4903	+ ext4_journal_finish_inode_data_buffers;
4537	4904
4538	4905	no_journal:
4539	4906	if (!test_opt(sb, NO_MBCACHE)) {
..	..	@@ -4554,31 +4921,27 @@
4554	4921	}
4555	4922	}
4556	4923
4557		- if ((DUMMY_ENCRYPTION_ENABLED(sbi) \|\| ext4_has_feature_encrypt(sb)) &&
4558		- (blocksize != PAGE_SIZE)) {
4559		- ext4_msg(sb, KERN_ERR,
4560		- "Unsupported blocksize for fs encryption");
4561		- goto failed_mount_wq;
4562		- }
4563		-
4564	4924	if (ext4_has_feature_verity(sb) && blocksize != PAGE_SIZE) {
4565	4925	ext4_msg(sb, KERN_ERR, "Unsupported blocksize for fs-verity");
4566	4926	goto failed_mount_wq;
4567		- }
4568		-
4569		- if (DUMMY_ENCRYPTION_ENABLED(sbi) && !sb_rdonly(sb) &&
4570		- !ext4_has_feature_encrypt(sb)) {
4571		- ext4_set_feature_encrypt(sb);
4572		- ext4_commit_super(sb, 1);
4573	4927	}
4574	4928
4575	4929	/*
4576	4930	* Get the # of file system overhead blocks from the
4577	4931	* superblock if present.
4578	4932	*/
4579		- if (es->s_overhead_clusters)
4580		- sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
4581		- else {
	4933	+ sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
	4934	+ /* ignore the precalculated value if it is ridiculous */
	4935	+ if (sbi->s_overhead > ext4_blocks_count(es))
	4936	+ sbi->s_overhead = 0;
	4937	+ /*
	4938	+ * If the bigalloc feature is not enabled recalculating the
	4939	+ * overhead doesn't take long, so we might as well just redo
	4940	+ * it to make sure we are using the correct value.
	4941	+ */
	4942	+ if (!ext4_has_feature_bigalloc(sb))
	4943	+ sbi->s_overhead = 0;
	4944	+ if (sbi->s_overhead == 0) {
4582	4945	err = ext4_calculate_overhead(sb);
4583	4946	if (err)
4584	4947	goto failed_mount_wq;
..	..	@@ -4638,6 +5001,7 @@
4638	5001	goto failed_mount4a;
4639	5002	}
4640	5003	}
	5004	+ ext4_fc_replay_cleanup(sb);
4641	5005
4642	5006	ext4_ext_init(sb);
4643	5007	err = ext4_mb_init(sb);
..	..	@@ -4646,6 +5010,14 @@
4646	5010	err);
4647	5011	goto failed_mount5;
4648	5012	}
	5013	+
	5014	+ /*
	5015	+ * We can only set up the journal commit callback once
	5016	+ * mballoc is initialized
	5017	+ */
	5018	+ if (sbi->s_journal)
	5019	+ sbi->s_journal->j_commit_callback =
	5020	+ ext4_journal_commit_callback;
4649	5021
4650	5022	block = ext4_count_free_clusters(sb);
4651	5023	ext4_free_blocks_count_set(sbi->s_es,
..	..	@@ -4665,6 +5037,9 @@
4665	5037	ext4_count_dirs(sb), GFP_KERNEL);
4666	5038	if (!err)
4667	5039	err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
	5040	+ GFP_KERNEL);
	5041	+ if (!err)
	5042	+ err = percpu_counter_init(&sbi->s_sra_exceeded_retry_limit, 0,
4668	5043	GFP_KERNEL);
4669	5044	if (!err)
4670	5045	err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
..	..	@@ -4700,6 +5075,14 @@
4700	5075	}
4701	5076	#endif /* CONFIG_QUOTA */
4702	5077
	5078	+ /*
	5079	+ * Save the original bdev mapping's wb_err value which could be
	5080	+ * used to detect the metadata async write error.
	5081	+ */
	5082	+ spin_lock_init(&sbi->s_bdev_wb_lock);
	5083	+ errseq_check_and_advance(&sb->s_bdev->bd_inode->i_mapping->wb_err,
	5084	+ &sbi->s_bdev_wb_err);
	5085	+ sb->s_bdev->bd_super = sb;
4703	5086	EXT4_SB(sb)->s_mount_state \|= EXT4_ORPHAN_FS;
4704	5087	ext4_orphan_cleanup(sb, es);
4705	5088	EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
..	..	@@ -4741,6 +5124,8 @@
4741	5124	ratelimit_state_init(&sbi->s_err_ratelimit_state, 5 * HZ, 10);
4742	5125	ratelimit_state_init(&sbi->s_warning_ratelimit_state, 5 * HZ, 10);
4743	5126	ratelimit_state_init(&sbi->s_msg_ratelimit_state, 5 * HZ, 10);
	5127	+ atomic_set(&sbi->s_warning_count, 0);
	5128	+ atomic_set(&sbi->s_msg_count, 0);
4744	5129
4745	5130	kfree(orig_data);
4746	5131	return 0;
..	..	@@ -4769,6 +5154,7 @@
4769	5154	percpu_counter_destroy(&sbi->s_freeinodes_counter);
4770	5155	percpu_counter_destroy(&sbi->s_dirs_counter);
4771	5156	percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
	5157	+ percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
4772	5158	percpu_free_rwsem(&sbi->s_writepages_rwsem);
4773	5159	failed_mount5:
4774	5160	ext4_ext_release(sb);
..	..	@@ -4781,14 +5167,12 @@
4781	5167	if (EXT4_SB(sb)->rsv_conversion_wq)
4782	5168	destroy_workqueue(EXT4_SB(sb)->rsv_conversion_wq);
4783	5169	failed_mount_wq:
4784		- if (sbi->s_ea_inode_cache) {
4785		- ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
4786		- sbi->s_ea_inode_cache = NULL;
4787		- }
4788		- if (sbi->s_ea_block_cache) {
4789		- ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
4790		- sbi->s_ea_block_cache = NULL;
4791		- }
	5170	+ ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
	5171	+ sbi->s_ea_inode_cache = NULL;
	5172	+
	5173	+ ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
	5174	+ sbi->s_ea_block_cache = NULL;
	5175	+
4792	5176	if (sbi->s_journal) {
4793	5177	jbd2_journal_destroy(sbi->s_journal);
4794	5178	sbi->s_journal = NULL;
..	..	@@ -4797,8 +5181,7 @@
4797	5181	ext4_es_unregister_shrinker(sbi);
4798	5182	failed_mount3:
4799	5183	del_timer_sync(&sbi->s_err_report);
4800		- if (sbi->s_mmp_tsk)
4801		- kthread_stop(sbi->s_mmp_tsk);
	5184	+ ext4_stop_mmpd(sbi);
4802	5185	failed_mount2:
4803	5186	rcu_read_lock();
4804	5187	group_desc = rcu_dereference(sbi->s_group_desc);
..	..	@@ -4816,11 +5199,12 @@
4816	5199
4817	5200	#ifdef CONFIG_QUOTA
4818	5201	for (i = 0; i < EXT4_MAXQUOTAS; i++)
4819		- kfree(sbi->s_qf_names[i]);
	5202	+ kfree(get_qf_name(sb, sbi, i));
4820	5203	#endif
4821		- fscrypt_free_dummy_context(&sbi->s_dummy_enc_ctx);
4822		- ext4_blkdev_remove(sbi);
	5204	+ fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
	5205	+ /* ext4_blkdev_remove() calls kill_bdev(), release bh before it. */
4823	5206	brelse(bh);
	5207	+ ext4_blkdev_remove(sbi);
4824	5208	out_fail:
4825	5209	sb->s_fs_info = NULL;
4826	5210	kfree(sbi->s_blockgroup_lock);
..	..	@@ -4843,6 +5227,7 @@
4843	5227	journal->j_commit_interval = sbi->s_commit_interval;
4844	5228	journal->j_min_batch_time = sbi->s_min_batch_time;
4845	5229	journal->j_max_batch_time = sbi->s_max_batch_time;
	5230	+ ext4_fc_init(sb, journal);
4846	5231
4847	5232	write_lock(&journal->j_state_lock);
4848	5233	if (test_opt(sb, BARRIER))
..	..	@@ -4985,9 +5370,7 @@
4985	5370	goto out_bdev;
4986	5371	}
4987	5372	journal->j_private = sb;
4988		- ll_rw_block(REQ_OP_READ, REQ_META \| REQ_PRIO, 1, &journal->j_sb_buffer);
4989		- wait_on_buffer(journal->j_sb_buffer);
4990		- if (!buffer_uptodate(journal->j_sb_buffer)) {
	5373	+ if (ext4_read_bh_lock(journal->j_sb_buffer, REQ_META \| REQ_PRIO, true)) {
4991	5374	ext4_msg(sb, KERN_ERR, "I/O error on journal device");
4992	5375	goto out_journal;
4993	5376	}
..	..	@@ -4997,7 +5380,7 @@
4997	5380	be32_to_cpu(journal->j_superblock->s_nr_users));
4998	5381	goto out_journal;
4999	5382	}
5000		- EXT4_SB(sb)->journal_bdev = bdev;
	5383	+ EXT4_SB(sb)->s_journal_bdev = bdev;
5001	5384	ext4_init_journal_params(sb, journal);
5002	5385	return journal;
5003	5386
..	..	@@ -5323,7 +5706,7 @@
5323	5706	needs_barrier = true;
5324	5707	if (needs_barrier) {
5325	5708	int err;
5326		- err = blkdev_issue_flush(sb->s_bdev, GFP_KERNEL, NULL);
	5709	+ err = blkdev_issue_flush(sb->s_bdev, GFP_KERNEL);
5327	5710	if (!ret)
5328	5711	ret = err;
5329	5712	}
..	..	@@ -5502,8 +5885,8 @@
5502	5885	goto restore_opts;
5503	5886	}
5504	5887
5505		- if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED)
5506		- ext4_abort(sb, "Abort forced by user");
	5888	+ if (ext4_test_mount_flag(sb, EXT4_MF_FS_ABORTED))
	5889	+ ext4_abort(sb, EXT4_ERR_ESHUTDOWN, "Abort forced by user");
5507	5890
5508	5891	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) \|
5509	5892	(test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
..	..	@@ -5516,7 +5899,7 @@
5516	5899	}
5517	5900
5518	5901	if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
5519		- if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) {
	5902	+ if (ext4_test_mount_flag(sb, EXT4_MF_FS_ABORTED)) {
5520	5903	err = -EROFS;
5521	5904	goto restore_opts;
5522	5905	}
..	..	@@ -5551,8 +5934,6 @@
5551	5934	*/
5552	5935	ext4_mark_recovery_complete(sb, es);
5553	5936	}
5554		- if (sbi->s_mmp_tsk)
5555		- kthread_stop(sbi->s_mmp_tsk);
5556	5937	} else {
5557	5938	/* Make sure we can mount this feature set readwrite */
5558	5939	if (ext4_has_feature_readonly(sb) \|\|
..	..	@@ -5603,7 +5984,8 @@
5603	5984	if (err)
5604	5985	goto restore_opts;
5605	5986	}
5606		- sbi->s_mount_state = le16_to_cpu(es->s_state);
	5987	+ sbi->s_mount_state = (le16_to_cpu(es->s_state) &
	5988	+ ~EXT4_FC_REPLAY);
5607	5989
5608	5990	err = ext4_setup_super(sb, es, 0);
5609	5991	if (err)
..	..	@@ -5637,7 +6019,7 @@
5637	6019	* Releasing of existing data is done when we are sure remount will
5638	6020	* succeed.
5639	6021	*/
5640		- if (test_opt(sb, BLOCK_VALIDITY) && !sbi->system_blks) {
	6022	+ if (test_opt(sb, BLOCK_VALIDITY) && !sbi->s_system_blks) {
5641	6023	err = ext4_setup_system_zone(sb);
5642	6024	if (err)
5643	6025	goto restore_opts;
..	..	@@ -5663,8 +6045,11 @@
5663	6045	}
5664	6046	}
5665	6047	#endif
5666		- if (!test_opt(sb, BLOCK_VALIDITY) && sbi->system_blks)
	6048	+ if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
5667	6049	ext4_release_system_zone(sb);
	6050	+
	6051	+ if (!ext4_has_feature_mmp(sb) \|\| sb_rdonly(sb))
	6052	+ ext4_stop_mmpd(sbi);
5668	6053
5669	6054	/*
5670	6055	* Some options can be enabled by ext4 and/or by VFS mount flag
..	..	@@ -5686,7 +6071,7 @@
5686	6071	sbi->s_commit_interval = old_opts.s_commit_interval;
5687	6072	sbi->s_min_batch_time = old_opts.s_min_batch_time;
5688	6073	sbi->s_max_batch_time = old_opts.s_max_batch_time;
5689		- if (!test_opt(sb, BLOCK_VALIDITY) && sbi->system_blks)
	6074	+ if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
5690	6075	ext4_release_system_zone(sb);
5691	6076	#ifdef CONFIG_QUOTA
5692	6077	sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
..	..	@@ -5698,6 +6083,8 @@
5698	6083	for (i = 0; i < EXT4_MAXQUOTAS; i++)
5699	6084	kfree(to_free[i]);
5700	6085	#endif
	6086	+ if (!ext4_has_feature_mmp(sb) \|\| sb_rdonly(sb))
	6087	+ ext4_stop_mmpd(sbi);
5701	6088	kfree(orig_data);
5702	6089	return err;
5703	6090	}
..	..	@@ -5717,9 +6104,10 @@
5717	6104	return PTR_ERR(dquot);
5718	6105	spin_lock(&dquot->dq_dqb_lock);
5719	6106
5720		- limit = (dquot->dq_dqb.dqb_bsoftlimit ?
5721		- dquot->dq_dqb.dqb_bsoftlimit :
5722		- dquot->dq_dqb.dqb_bhardlimit) >> sb->s_blocksize_bits;
	6107	+ limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
	6108	+ dquot->dq_dqb.dqb_bhardlimit);
	6109	+ limit >>= sb->s_blocksize_bits;
	6110	+
5723	6111	if (limit && buf->f_blocks > limit) {
5724	6112	curblock = (dquot->dq_dqb.dqb_curspace +
5725	6113	dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;
..	..	@@ -5729,9 +6117,8 @@
5729	6117	(buf->f_blocks - curblock) : 0;
5730	6118	}
5731	6119
5732		- limit = dquot->dq_dqb.dqb_isoftlimit ?
5733		- dquot->dq_dqb.dqb_isoftlimit :
5734		- dquot->dq_dqb.dqb_ihardlimit;
	6120	+ limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
	6121	+ dquot->dq_dqb.dqb_ihardlimit);
5735	6122	if (limit && buf->f_files > limit) {
5736	6123	buf->f_files = limit;
5737	6124	buf->f_ffree =
..	..	@@ -5774,8 +6161,7 @@
5774	6161	buf->f_namelen = EXT4_NAME_LEN;
5775	6162	fsid = le64_to_cpup((void *)es->s_uuid) ^
5776	6163	le64_to_cpup((void *)es->s_uuid + sizeof(u64));
5777		- buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
5778		- buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
	6164	+ buf->f_fsid = u64_to_fsid(fsid);
5779	6165
5780	6166	#ifdef CONFIG_QUOTA
5781	6167	if (ext4_test_inode_flag(dentry->d_inode, EXT4_INODE_PROJINHERIT) &&
..	..	@@ -5871,7 +6257,7 @@
5871	6257	handle_t *handle;
5872	6258
5873	6259	/* Data block + inode block */
5874		- handle = ext4_journal_start(d_inode(sb->s_root), EXT4_HT_QUOTA, 2);
	6260	+ handle = ext4_journal_start_sb(sb, EXT4_HT_QUOTA, 2);
5875	6261	if (IS_ERR(handle))
5876	6262	return PTR_ERR(handle);
5877	6263	ret = dquot_commit_info(sb, type);
..	..	@@ -5975,7 +6361,7 @@
5975	6361	EXT4_I(inode)->i_flags \|= EXT4_NOATIME_FL \| EXT4_IMMUTABLE_FL;
5976	6362	inode_set_flags(inode, S_NOATIME \| S_IMMUTABLE,
5977	6363	S_NOATIME \| S_IMMUTABLE);
5978		- ext4_mark_inode_dirty(handle, inode);
	6364	+ err = ext4_mark_inode_dirty(handle, inode);
5979	6365	ext4_journal_stop(handle);
5980	6366	unlock_inode:
5981	6367	inode_unlock(inode);
..	..	@@ -6013,7 +6399,7 @@
6013	6399	/* Don't account quota for quota files to avoid recursion */
6014	6400	qf_inode->i_flags \|= S_NOQUOTA;
6015	6401	lockdep_set_quota_inode(qf_inode, I_DATA_SEM_QUOTA);
6016		- err = dquot_enable(qf_inode, type, format_id, flags);
	6402	+ err = dquot_load_quota_inode(qf_inode, type, format_id, flags);
6017	6403	if (err)
6018	6404	lockdep_set_quota_inode(qf_inode, I_DATA_SEM_NORMAL);
6019	6405	iput(qf_inode);
..	..	@@ -6093,12 +6479,14 @@
6093	6479	* this is not a hard failure and quotas are already disabled.
6094	6480	*/
6095	6481	handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
6096		- if (IS_ERR(handle))
	6482	+ if (IS_ERR(handle)) {
	6483	+ err = PTR_ERR(handle);
6097	6484	goto out_unlock;
	6485	+ }
6098	6486	EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL \| EXT4_IMMUTABLE_FL);
6099	6487	inode_set_flags(inode, 0, S_NOATIME \| S_IMMUTABLE);
6100	6488	inode->i_mtime = inode->i_ctime = current_time(inode);
6101		- ext4_mark_inode_dirty(handle, inode);
	6489	+ err = ext4_mark_inode_dirty(handle, inode);
6102	6490	ext4_journal_stop(handle);
6103	6491	out_unlock:
6104	6492	inode_unlock(inode);
..	..	@@ -6156,7 +6544,7 @@
6156	6544	{
6157	6545	struct inode *inode = sb_dqopt(sb)->files[type];
6158	6546	ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
6159		- int err, offset = off & (sb->s_blocksize - 1);
	6547	+ int err = 0, err2 = 0, offset = off & (sb->s_blocksize - 1);
6160	6548	int retries = 0;
6161	6549	struct buffer_head *bh;
6162	6550	handle_t *handle = journal_current_handle();
..	..	@@ -6182,7 +6570,7 @@
6182	6570	bh = ext4_bread(handle, inode, blk,
6183	6571	EXT4_GET_BLOCKS_CREATE \|
6184	6572	EXT4_GET_BLOCKS_METADATA_NOFAIL);
6185		- } while (IS_ERR(bh) && (PTR_ERR(bh) == -ENOSPC) &&
	6573	+ } while (PTR_ERR(bh) == -ENOSPC &&
6186	6574	ext4_should_retry_alloc(inode->i_sb, &retries));
6187	6575	if (IS_ERR(bh))
6188	6576	return PTR_ERR(bh);
..	..	@@ -6204,21 +6592,11 @@
6204	6592	if (inode->i_size < off + len) {
6205	6593	i_size_write(inode, off + len);
6206	6594	EXT4_I(inode)->i_disksize = inode->i_size;
6207		- ext4_mark_inode_dirty(handle, inode);
	6595	+ err2 = ext4_mark_inode_dirty(handle, inode);
	6596	+ if (unlikely(err2 && !err))
	6597	+ err = err2;
6208	6598	}
6209		- return len;
6210		-}
6211		-
6212		-static int ext4_get_next_id(struct super_block sb, struct kqid qid)
6213		-{
6214		- const struct quota_format_ops *ops;
6215		-
6216		- if (!sb_has_quota_loaded(sb, qid->type))
6217		- return -ESRCH;
6218		- ops = sb_dqopt(sb)->ops[qid->type];
6219		- if (!ops \|\| !ops->get_next_id)
6220		- return -ENOSYS;
6221		- return dquot_get_next_id(sb, qid);
	6599	+ return err ? err : len;
6222	6600	}
6223	6601	#endif
6224	6602
..	..	@@ -6314,6 +6692,10 @@
6314	6692	if (err)
6315	6693	return err;
6316	6694
	6695	+ err = ext4_init_pending();
	6696	+ if (err)
	6697	+ goto out7;
	6698	+
6317	6699	err = ext4_init_post_read_processing();
6318	6700	if (err)
6319	6701	goto out6;
..	..	@@ -6336,6 +6718,11 @@
6336	6718	err = init_inodecache();
6337	6719	if (err)
6338	6720	goto out1;
	6721	+
	6722	+ err = ext4_fc_init_dentry_cache();
	6723	+ if (err)
	6724	+ goto out05;
	6725	+
6339	6726	register_as_ext3();
6340	6727	register_as_ext2();
6341	6728	err = register_filesystem(&ext4_fs_type);
..	..	@@ -6346,6 +6733,8 @@
6346	6733	out:
6347	6734	unregister_as_ext2();
6348	6735	unregister_as_ext3();
	6736	+ ext4_fc_destroy_dentry_cache();
	6737	+out05:
6349	6738	destroy_inodecache();
6350	6739	out1:
6351	6740	ext4_exit_mballoc();
..	..	@@ -6358,6 +6747,8 @@
6358	6747	out5:
6359	6748	ext4_exit_post_read_processing();
6360	6749	out6:
	6750	+ ext4_exit_pending();
	6751	+out7:
6361	6752	ext4_exit_es();
6362	6753
6363	6754	return err;
..	..	@@ -6369,6 +6760,7 @@
6369	6760	unregister_as_ext2();
6370	6761	unregister_as_ext3();
6371	6762	unregister_filesystem(&ext4_fs_type);
	6763	+ ext4_fc_destroy_dentry_cache();
6372	6764	destroy_inodecache();
6373	6765	ext4_exit_mballoc();
6374	6766	ext4_exit_sysfs();
..	..	@@ -6376,11 +6768,13 @@
6376	6768	ext4_exit_pageio();
6377	6769	ext4_exit_post_read_processing();
6378	6770	ext4_exit_es();
	6771	+ ext4_exit_pending();
6379	6772	}
6380	6773
6381	6774	MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
6382	6775	MODULE_DESCRIPTION("Fourth Extended Filesystem");
6383	6776	MODULE_LICENSE("GPL");
	6777	+MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
6384	6778	MODULE_SOFTDEP("pre: crc32c");
6385	6779	module_init(ext4_init_fs)
6386	6780	module_exit(ext4_exit_fs)