~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,44 +417,6 @@
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)
360		-{
361		- struct ext4_super_block *es = EXT4_SB(sb)->s_es;
362		-
363		- EXT4_SB(sb)->s_mount_state \|= EXT4_ERROR_FS;
364		- if (bdev_read_only(sb->s_bdev))
365		- return;
366		- es->s_state \|= cpu_to_le16(EXT4_ERROR_FS);
367		- ext4_update_tstamp(es, s_last_error_time);
368		- strncpy(es->s_last_error_func, func, sizeof(es->s_last_error_func));
369		- es->s_last_error_line = cpu_to_le32(line);
370		- if (!es->s_first_error_time) {
371		- es->s_first_error_time = es->s_last_error_time;
372		- es->s_first_error_time_hi = es->s_last_error_time_hi;
373		- strncpy(es->s_first_error_func, func,
374		- sizeof(es->s_first_error_func));
375		- es->s_first_error_line = cpu_to_le32(line);
376		- es->s_first_error_ino = es->s_last_error_ino;
377		- es->s_first_error_block = es->s_last_error_block;
378		- }
379		- /*
380		- * Start the daily error reporting function if it hasn't been
381		- * started already
382		- */
383		- if (!es->s_error_count)
384		- mod_timer(&EXT4_SB(sb)->s_err_report, jiffies + 246060*HZ);
385		- le32_add_cpu(&es->s_error_count, 1);
386		-}
387		-
388		-static void save_error_info(struct super_block sb, const char func,
389		- unsigned int line)
390		-{
391		- __save_error_info(sb, func, line);
392		- if (!bdev_read_only(sb->s_bdev))
393		- ext4_commit_super(sb, 1);
394		-}
395		-
396	420	/*
397	421	* The del_gendisk() function uninitializes the disk-specific data
398	422	* structures, including the bdi structure, without telling anyone
..	..	@@ -432,10 +456,176 @@
432	456	spin_unlock(&sbi->s_md_lock);
433	457	}
434	458
	459	+/*
	460	+ * This writepage callback for write_cache_pages()
	461	+ * takes care of a few cases after page cleaning.
	462	+ *
	463	+ * write_cache_pages() already checks for dirty pages
	464	+ * and calls clear_page_dirty_for_io(), which we want,
	465	+ * to write protect the pages.
	466	+ *
	467	+ * However, we may have to redirty a page (see below.)
	468	+ */
	469	+static int ext4_journalled_writepage_callback(struct page *page,
	470	+ struct writeback_control *wbc,
	471	+ void *data)
	472	+{
	473	+ transaction_t transaction = (transaction_t ) data;
	474	+ struct buffer_head bh, head;
	475	+ struct journal_head *jh;
	476	+
	477	+ bh = head = page_buffers(page);
	478	+ do {
	479	+ /*
	480	+ * We have to redirty a page in these cases:
	481	+ * 1) If buffer is dirty, it means the page was dirty because it
	482	+ * contains a buffer that needs checkpointing. So the dirty bit
	483	+ * needs to be preserved so that checkpointing writes the buffer
	484	+ * properly.
	485	+ * 2) If buffer is not part of the committing transaction
	486	+ * (we may have just accidentally come across this buffer because
	487	+ * inode range tracking is not exact) or if the currently running
	488	+ * transaction already contains this buffer as well, dirty bit
	489	+ * needs to be preserved so that the buffer gets writeprotected
	490	+ * properly on running transaction's commit.
	491	+ */
	492	+ jh = bh2jh(bh);
	493	+ if (buffer_dirty(bh) \|\|
	494	+ (jh && (jh->b_transaction != transaction \|\|
	495	+ jh->b_next_transaction))) {
	496	+ redirty_page_for_writepage(wbc, page);
	497	+ goto out;
	498	+ }
	499	+ } while ((bh = bh->b_this_page) != head);
	500	+
	501	+out:
	502	+ return AOP_WRITEPAGE_ACTIVATE;
	503	+}
	504	+
	505	+static int ext4_journalled_submit_inode_data_buffers(struct jbd2_inode *jinode)
	506	+{
	507	+ struct address_space *mapping = jinode->i_vfs_inode->i_mapping;
	508	+ struct writeback_control wbc = {
	509	+ .sync_mode = WB_SYNC_ALL,
	510	+ .nr_to_write = LONG_MAX,
	511	+ .range_start = jinode->i_dirty_start,
	512	+ .range_end = jinode->i_dirty_end,
	513	+ };
	514	+
	515	+ return write_cache_pages(mapping, &wbc,
	516	+ ext4_journalled_writepage_callback,
	517	+ jinode->i_transaction);
	518	+}
	519	+
	520	+static int ext4_journal_submit_inode_data_buffers(struct jbd2_inode *jinode)
	521	+{
	522	+ int ret;
	523	+
	524	+ if (ext4_should_journal_data(jinode->i_vfs_inode))
	525	+ ret = ext4_journalled_submit_inode_data_buffers(jinode);
	526	+ else
	527	+ ret = jbd2_journal_submit_inode_data_buffers(jinode);
	528	+
	529	+ return ret;
	530	+}
	531	+
	532	+static int ext4_journal_finish_inode_data_buffers(struct jbd2_inode *jinode)
	533	+{
	534	+ int ret = 0;
	535	+
	536	+ if (!ext4_should_journal_data(jinode->i_vfs_inode))
	537	+ ret = jbd2_journal_finish_inode_data_buffers(jinode);
	538	+
	539	+ return ret;
	540	+}
	541	+
435	542	static bool system_going_down(void)
436	543	{
437	544	return system_state == SYSTEM_HALT \|\| system_state == SYSTEM_POWER_OFF
438	545	\|\| system_state == SYSTEM_RESTART;
	546	+}
	547	+
	548	+struct ext4_err_translation {
	549	+ int code;
	550	+ int errno;
	551	+};
	552	+
	553	+#define EXT4_ERR_TRANSLATE(err) { .code = EXT4_ERR_##err, .errno = err }
	554	+
	555	+static struct ext4_err_translation err_translation[] = {
	556	+ EXT4_ERR_TRANSLATE(EIO),
	557	+ EXT4_ERR_TRANSLATE(ENOMEM),
	558	+ EXT4_ERR_TRANSLATE(EFSBADCRC),
	559	+ EXT4_ERR_TRANSLATE(EFSCORRUPTED),
	560	+ EXT4_ERR_TRANSLATE(ENOSPC),
	561	+ EXT4_ERR_TRANSLATE(ENOKEY),
	562	+ EXT4_ERR_TRANSLATE(EROFS),
	563	+ EXT4_ERR_TRANSLATE(EFBIG),
	564	+ EXT4_ERR_TRANSLATE(EEXIST),
	565	+ EXT4_ERR_TRANSLATE(ERANGE),
	566	+ EXT4_ERR_TRANSLATE(EOVERFLOW),
	567	+ EXT4_ERR_TRANSLATE(EBUSY),
	568	+ EXT4_ERR_TRANSLATE(ENOTDIR),
	569	+ EXT4_ERR_TRANSLATE(ENOTEMPTY),
	570	+ EXT4_ERR_TRANSLATE(ESHUTDOWN),
	571	+ EXT4_ERR_TRANSLATE(EFAULT),
	572	+};
	573	+
	574	+static int ext4_errno_to_code(int errno)
	575	+{
	576	+ int i;
	577	+
	578	+ for (i = 0; i < ARRAY_SIZE(err_translation); i++)
	579	+ if (err_translation[i].errno == errno)
	580	+ return err_translation[i].code;
	581	+ return EXT4_ERR_UNKNOWN;
	582	+}
	583	+
	584	+static void __save_error_info(struct super_block *sb, int error,
	585	+ __u32 ino, __u64 block,
	586	+ const char *func, unsigned int line)
	587	+{
	588	+ struct ext4_super_block *es = EXT4_SB(sb)->s_es;
	589	+
	590	+ EXT4_SB(sb)->s_mount_state \|= EXT4_ERROR_FS;
	591	+ if (bdev_read_only(sb->s_bdev))
	592	+ return;
	593	+ /* We default to EFSCORRUPTED error... */
	594	+ if (error == 0)
	595	+ error = EFSCORRUPTED;
	596	+ es->s_state \|= cpu_to_le16(EXT4_ERROR_FS);
	597	+ ext4_update_tstamp(es, s_last_error_time);
	598	+ strncpy(es->s_last_error_func, func, sizeof(es->s_last_error_func));
	599	+ es->s_last_error_line = cpu_to_le32(line);
	600	+ es->s_last_error_ino = cpu_to_le32(ino);
	601	+ es->s_last_error_block = cpu_to_le64(block);
	602	+ es->s_last_error_errcode = ext4_errno_to_code(error);
	603	+ if (!es->s_first_error_time) {
	604	+ es->s_first_error_time = es->s_last_error_time;
	605	+ es->s_first_error_time_hi = es->s_last_error_time_hi;
	606	+ strncpy(es->s_first_error_func, func,
	607	+ sizeof(es->s_first_error_func));
	608	+ es->s_first_error_line = cpu_to_le32(line);
	609	+ es->s_first_error_ino = es->s_last_error_ino;
	610	+ es->s_first_error_block = es->s_last_error_block;
	611	+ es->s_first_error_errcode = es->s_last_error_errcode;
	612	+ }
	613	+ /*
	614	+ * Start the daily error reporting function if it hasn't been
	615	+ * started already
	616	+ */
	617	+ if (!es->s_error_count)
	618	+ mod_timer(&EXT4_SB(sb)->s_err_report, jiffies + 246060*HZ);
	619	+ le32_add_cpu(&es->s_error_count, 1);
	620	+}
	621	+
	622	+static void save_error_info(struct super_block *sb, int error,
	623	+ __u32 ino, __u64 block,
	624	+ const char *func, unsigned int line)
	625	+{
	626	+ __save_error_info(sb, error, ino, block, func, line);
	627	+ if (!bdev_read_only(sb->s_bdev))
	628	+ ext4_commit_super(sb, 1);
439	629	}
440	630
441	631	/* Deal with the reporting of failure conditions on a filesystem such as
..	..	@@ -463,7 +653,7 @@
463	653	if (sb_rdonly(sb) \|\| test_opt(sb, ERRORS_CONT))
464	654	return;
465	655
466		- EXT4_SB(sb)->s_mount_flags \|= EXT4_MF_FS_ABORTED;
	656	+ ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
467	657	if (journal)
468	658	jbd2_journal_abort(journal, -EIO);
469	659	/*
..	..	@@ -480,9 +670,6 @@
480	670	smp_wmb();
481	671	sb->s_flags \|= SB_RDONLY;
482	672	} 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	673	panic("EXT4-fs (device %s): panic forced after error\n",
487	674	sb->s_id);
488	675	}
..	..	@@ -493,7 +680,8 @@
493	680	"EXT4-fs error")
494	681
495	682	void __ext4_error(struct super_block sb, const char function,
496		- unsigned int line, const char *fmt, ...)
	683	+ unsigned int line, int error, __u64 block,
	684	+ const char *fmt, ...)
497	685	{
498	686	struct va_format vaf;
499	687	va_list args;
..	..	@@ -511,24 +699,21 @@
511	699	sb->s_id, function, line, current->comm, &vaf);
512	700	va_end(args);
513	701	}
514		- save_error_info(sb, function, line);
	702	+ save_error_info(sb, error, 0, block, function, line);
515	703	ext4_handle_error(sb);
516	704	}
517	705
518	706	void __ext4_error_inode(struct inode inode, const char function,
519		- unsigned int line, ext4_fsblk_t block,
	707	+ unsigned int line, ext4_fsblk_t block, int error,
520	708	const char *fmt, ...)
521	709	{
522	710	va_list args;
523	711	struct va_format vaf;
524		- struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
525	712
526	713	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
527	714	return;
528	715
529	716	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	717	if (ext4_error_ratelimit(inode->i_sb)) {
533	718	va_start(args, fmt);
534	719	vaf.fmt = fmt;
..	..	@@ -545,7 +730,8 @@
545	730	current->comm, &vaf);
546	731	va_end(args);
547	732	}
548		- save_error_info(inode->i_sb, function, line);
	733	+ save_error_info(inode->i_sb, error, inode->i_ino, block,
	734	+ function, line);
549	735	ext4_handle_error(inode->i_sb);
550	736	}
551	737
..	..	@@ -555,7 +741,6 @@
555	741	{
556	742	va_list args;
557	743	struct va_format vaf;
558		- struct ext4_super_block *es;
559	744	struct inode *inode = file_inode(file);
560	745	char pathname[80], *path;
561	746
..	..	@@ -563,8 +748,6 @@
563	748	return;
564	749
565	750	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	751	if (ext4_error_ratelimit(inode->i_sb)) {
569	752	path = file_path(file, pathname, sizeof(pathname));
570	753	if (IS_ERR(path))
..	..	@@ -586,7 +769,8 @@
586	769	current->comm, path, &vaf);
587	770	va_end(args);
588	771	}
589		- save_error_info(inode->i_sb, function, line);
	772	+ save_error_info(inode->i_sb, EFSCORRUPTED, inode->i_ino, block,
	773	+ function, line);
590	774	ext4_handle_error(inode->i_sb);
591	775	}
592	776
..	..	@@ -654,7 +838,7 @@
654	838	sb->s_id, function, line, errstr);
655	839	}
656	840
657		- save_error_info(sb, function, line);
	841	+ save_error_info(sb, -errno, 0, 0, function, line);
658	842	ext4_handle_error(sb);
659	843	}
660	844
..	..	@@ -669,7 +853,7 @@
669	853	*/
670	854
671	855	void __ext4_abort(struct super_block sb, const char function,
672		- unsigned int line, const char *fmt, ...)
	856	+ unsigned int line, int error, const char *fmt, ...)
673	857	{
674	858	struct va_format vaf;
675	859	va_list args;
..	..	@@ -677,7 +861,7 @@
677	861	if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
678	862	return;
679	863
680		- save_error_info(sb, function, line);
	864	+ save_error_info(sb, error, 0, 0, function, line);
681	865	va_start(args, fmt);
682	866	vaf.fmt = fmt;
683	867	vaf.va = &args;
..	..	@@ -686,24 +870,20 @@
686	870	va_end(args);
687	871
688	872	if (sb_rdonly(sb) == 0) {
	873	+ ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
	874	+ if (EXT4_SB(sb)->s_journal)
	875	+ jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
	876	+
689	877	ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
690		- EXT4_SB(sb)->s_mount_flags \|= EXT4_MF_FS_ABORTED;
691	878	/*
692	879	* Make sure updated value of ->s_mount_flags will be visible
693	880	* before ->s_flags update
694	881	*/
695	882	smp_wmb();
696	883	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	884	}
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;
	885	+ if (test_opt(sb, ERRORS_PANIC) && !system_going_down())
705	886	panic("EXT4-fs panic from previous error\n");
706		- }
707	887	}
708	888
709	889	void __ext4_msg(struct super_block *sb,
..	..	@@ -712,6 +892,7 @@
712	892	struct va_format vaf;
713	893	va_list args;
714	894
	895	+ atomic_inc(&EXT4_SB(sb)->s_msg_count);
715	896	if (!___ratelimit(&(EXT4_SB(sb)->s_msg_ratelimit_state), "EXT4-fs"))
716	897	return;
717	898
..	..	@@ -722,9 +903,12 @@
722	903	va_end(args);
723	904	}
724	905
725		-#define ext4_warning_ratelimit(sb) \
726		- ___ratelimit(&(EXT4_SB(sb)->s_warning_ratelimit_state), \
727		- "EXT4-fs warning")
	906	+static int ext4_warning_ratelimit(struct super_block *sb)
	907	+{
	908	+ atomic_inc(&EXT4_SB(sb)->s_warning_count);
	909	+ return ___ratelimit(&(EXT4_SB(sb)->s_warning_ratelimit_state),
	910	+ "EXT4-fs warning");
	911	+}
728	912
729	913	void __ext4_warning(struct super_block sb, const char function,
730	914	unsigned int line, const char *fmt, ...)
..	..	@@ -770,15 +954,12 @@
770	954	{
771	955	struct va_format vaf;
772	956	va_list args;
773		- struct ext4_super_block *es = EXT4_SB(sb)->s_es;
774	957
775	958	if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
776	959	return;
777	960
778	961	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);
	962	+ __save_error_info(sb, EFSCORRUPTED, ino, block, function, line);
782	963
783	964	if (ext4_error_ratelimit(sb)) {
784	965	va_start(args, fmt);
..	..	@@ -830,6 +1011,8 @@
830	1011	struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
831	1012	int ret;
832	1013
	1014	+ if (!grp \|\| !gdp)
	1015	+ return;
833	1016	if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT) {
834	1017	ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
835	1018	&grp->bb_state);
..	..	@@ -882,7 +1065,6 @@
882	1065	static struct block_device ext4_blkdev_get(dev_t dev, struct super_block sb)
883	1066	{
884	1067	struct block_device *bdev;
885		- char b[BDEVNAME_SIZE];
886	1068
887	1069	bdev = blkdev_get_by_dev(dev, FMODE_READ\|FMODE_WRITE\|FMODE_EXCL, sb);
888	1070	if (IS_ERR(bdev))
..	..	@@ -890,8 +1072,9 @@
890	1072	return bdev;
891	1073
892	1074	fail:
893		- ext4_msg(sb, KERN_ERR, "failed to open journal device %s: %ld",
894		- __bdevname(dev, b), PTR_ERR(bdev));
	1075	+ ext4_msg(sb, KERN_ERR,
	1076	+ "failed to open journal device unknown-block(%u,%u) %ld",
	1077	+ MAJOR(dev), MINOR(dev), PTR_ERR(bdev));
895	1078	return NULL;
896	1079	}
897	1080
..	..	@@ -906,10 +1089,16 @@
906	1089	static void ext4_blkdev_remove(struct ext4_sb_info *sbi)
907	1090	{
908	1091	struct block_device *bdev;
909		- bdev = sbi->journal_bdev;
	1092	+ bdev = sbi->s_journal_bdev;
910	1093	if (bdev) {
	1094	+ /*
	1095	+ * Invalidate the journal device's buffers. We don't want them
	1096	+ * floating about in memory - the physical journal device may
	1097	+ * hotswapped, and it breaks the `ro-after' testing code.
	1098	+ */
	1099	+ invalidate_bdev(bdev);
911	1100	ext4_blkdev_put(bdev);
912		- sbi->journal_bdev = NULL;
	1101	+ sbi->s_journal_bdev = NULL;
913	1102	}
914	1103	}
915	1104
..	..	@@ -974,6 +1163,18 @@
974	1163	int aborted = 0;
975	1164	int i, err;
976	1165
	1166	+ /*
	1167	+ * Unregister sysfs before destroying jbd2 journal.
	1168	+ * Since we could still access attr_journal_task attribute via sysfs
	1169	+ * path which could have sbi->s_journal->j_task as NULL
	1170	+ * Unregister sysfs before flush sbi->s_error_work.
	1171	+ * Since user may read /proc/fs/ext4/xx/mb_groups during umount, If
	1172	+ * read metadata verify failed then will queue error work.
	1173	+ * flush_stashed_error_work will call start_this_handle may trigger
	1174	+ * BUG_ON.
	1175	+ */
	1176	+ ext4_unregister_sysfs(sb);
	1177	+
977	1178	ext4_unregister_li_request(sb);
978	1179	ext4_quota_off_umount(sb);
979	1180
..	..	@@ -983,11 +1184,11 @@
983	1184	aborted = is_journal_aborted(sbi->s_journal);
984	1185	err = jbd2_journal_destroy(sbi->s_journal);
985	1186	sbi->s_journal = NULL;
986		- if ((err < 0) && !aborted)
987		- ext4_abort(sb, "Couldn't clean up the journal");
	1187	+ if ((err < 0) && !aborted) {
	1188	+ ext4_abort(sb, -err, "Couldn't clean up the journal");
	1189	+ }
988	1190	}
989	1191
990		- ext4_unregister_sysfs(sb);
991	1192	ext4_es_unregister_shrinker(sbi);
992	1193	del_timer_sync(&sbi->s_err_report);
993	1194	ext4_release_system_zone(sb);
..	..	@@ -1017,6 +1218,7 @@
1017	1218	percpu_counter_destroy(&sbi->s_freeinodes_counter);
1018	1219	percpu_counter_destroy(&sbi->s_dirs_counter);
1019	1220	percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
	1221	+ percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
1020	1222	percpu_free_rwsem(&sbi->s_writepages_rwsem);
1021	1223	#ifdef CONFIG_QUOTA
1022	1224	for (i = 0; i < EXT4_MAXQUOTAS; i++)
..	..	@@ -1033,26 +1235,19 @@
1033	1235
1034	1236	sync_blockdev(sb->s_bdev);
1035	1237	invalidate_bdev(sb->s_bdev);
1036		- if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
1037		- /*
1038		- * Invalidate the journal device's buffers. We don't want them
1039		- * floating about in memory - the physical journal device may
1040		- * hotswapped, and it breaks the `ro-after' testing code.
1041		- */
1042		- sync_blockdev(sbi->journal_bdev);
1043		- invalidate_bdev(sbi->journal_bdev);
	1238	+ if (sbi->s_journal_bdev && sbi->s_journal_bdev != sb->s_bdev) {
	1239	+ sync_blockdev(sbi->s_journal_bdev);
1044	1240	ext4_blkdev_remove(sbi);
1045	1241	}
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);
	1242	+
	1243	+ ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
	1244	+ sbi->s_ea_inode_cache = NULL;
	1245	+
	1246	+ ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
	1247	+ sbi->s_ea_block_cache = NULL;
	1248	+
	1249	+ ext4_stop_mmpd(sbi);
	1250	+
1056	1251	brelse(sbi->s_sbh);
1057	1252	sb->s_fs_info = NULL;
1058	1253	/*
..	..	@@ -1065,7 +1260,7 @@
1065	1260	crypto_free_shash(sbi->s_chksum_driver);
1066	1261	kfree(sbi->s_blockgroup_lock);
1067	1262	fs_put_dax(sbi->s_daxdev);
1068		- fscrypt_free_dummy_context(&sbi->s_dummy_enc_ctx);
	1263	+ fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
1069	1264	#ifdef CONFIG_UNICODE
1070	1265	utf8_unload(sb->s_encoding);
1071	1266	#endif
..	..	@@ -1086,8 +1281,10 @@
1086	1281	return NULL;
1087	1282
1088	1283	inode_set_iversion(&ei->vfs_inode, 1);
	1284	+ ei->i_flags = 0;
1089	1285	spin_lock_init(&ei->i_raw_lock);
1090	1286	INIT_LIST_HEAD(&ei->i_prealloc_list);
	1287	+ atomic_set(&ei->i_prealloc_active, 0);
1091	1288	spin_lock_init(&ei->i_prealloc_lock);
1092	1289	ext4_es_init_tree(&ei->i_es_tree);
1093	1290	rwlock_init(&ei->i_es_lock);
..	..	@@ -1096,9 +1293,8 @@
1096	1293	ei->i_es_shk_nr = 0;
1097	1294	ei->i_es_shrink_lblk = 0;
1098	1295	ei->i_reserved_data_blocks = 0;
1099		- ei->i_da_metadata_calc_len = 0;
1100		- ei->i_da_metadata_calc_last_lblock = 0;
1101	1296	spin_lock_init(&(ei->i_block_reservation_lock));
	1297	+ ext4_init_pending_tree(&ei->i_pending_tree);
1102	1298	#ifdef CONFIG_QUOTA
1103	1299	ei->i_reserved_quota = 0;
1104	1300	memset(&ei->i_dquot, 0, sizeof(ei->i_dquot));
..	..	@@ -1110,6 +1306,8 @@
1110	1306	ei->i_datasync_tid = 0;
1111	1307	atomic_set(&ei->i_unwritten, 0);
1112	1308	INIT_WORK(&ei->i_rsv_conversion_work, ext4_end_io_rsv_work);
	1309	+ ext4_fc_init_inode(&ei->vfs_inode);
	1310	+ mutex_init(&ei->i_fc_lock);
1113	1311	return &ei->vfs_inode;
1114	1312	}
1115	1313
..	..	@@ -1124,12 +1322,13 @@
1124	1322	return drop;
1125	1323	}
1126	1324
1127		-static void ext4_i_callback(struct rcu_head *head)
	1325	+static void ext4_free_in_core_inode(struct inode *inode)
1128	1326	{
1129		- struct inode *inode = container_of(head, struct inode, i_rcu);
1130		-
1131	1327	fscrypt_free_inode(inode);
1132		-
	1328	+ if (!list_empty(&(EXT4_I(inode)->i_fc_list))) {
	1329	+ pr_warn("%s: inode %ld still in fc list",
	1330	+ __func__, inode->i_ino);
	1331	+ }
1133	1332	kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
1134	1333	}
1135	1334
..	..	@@ -1144,7 +1343,12 @@
1144	1343	true);
1145	1344	dump_stack();
1146	1345	}
1147		- call_rcu(&inode->i_rcu, ext4_i_callback);
	1346	+
	1347	+ if (EXT4_I(inode)->i_reserved_data_blocks)
	1348	+ ext4_msg(inode->i_sb, KERN_ERR,
	1349	+ "Inode %lu (%p): i_reserved_data_blocks (%u) not cleared!",
	1350	+ inode->i_ino, EXT4_I(inode),
	1351	+ EXT4_I(inode)->i_reserved_data_blocks);
1148	1352	}
1149	1353
1150	1354	static void init_once(void *foo)
..	..	@@ -1156,6 +1360,7 @@
1156	1360	init_rwsem(&ei->i_data_sem);
1157	1361	init_rwsem(&ei->i_mmap_sem);
1158	1362	inode_init_once(&ei->vfs_inode);
	1363	+ ext4_fc_init_inode(&ei->vfs_inode);
1159	1364	}
1160	1365
1161	1366	static int __init init_inodecache(void)
..	..	@@ -1184,11 +1389,12 @@
1184	1389
1185	1390	void ext4_clear_inode(struct inode *inode)
1186	1391	{
	1392	+ ext4_fc_del(inode);
1187	1393	invalidate_inode_buffers(inode);
1188	1394	clear_inode(inode);
1189		- dquot_drop(inode);
1190		- ext4_discard_preallocations(inode);
	1395	+ ext4_discard_preallocations(inode, 0);
1191	1396	ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS);
	1397	+ dquot_drop(inode);
1192	1398	if (EXT4_I(inode)->jinode) {
1193	1399	jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
1194	1400	EXT4_I(inode)->jinode);
..	..	@@ -1258,8 +1464,8 @@
1258	1464	if (!page_has_buffers(page))
1259	1465	return 0;
1260	1466	if (journal)
1261		- return jbd2_journal_try_to_free_buffers(journal, page,
1262		- wait & ~__GFP_DIRECT_RECLAIM);
	1467	+ return jbd2_journal_try_to_free_buffers(journal, page);
	1468	+
1263	1469	return try_to_free_buffers(page);
1264	1470	}
1265	1471
..	..	@@ -1288,6 +1494,9 @@
1288	1494	if (WARN_ON_ONCE(IS_DAX(inode) && i_size_read(inode)))
1289	1495	return -EINVAL;
1290	1496
	1497	+ if (ext4_test_inode_flag(inode, EXT4_INODE_DAX))
	1498	+ return -EOPNOTSUPP;
	1499	+
1291	1500	res = ext4_convert_inline_data(inode);
1292	1501	if (res)
1293	1502	return res;
..	..	@@ -1313,7 +1522,7 @@
1313	1522	* Update inode->i_flags - S_ENCRYPTED will be enabled,
1314	1523	* S_DAX may be disabled
1315	1524	*/
1316		- ext4_set_inode_flags(inode);
	1525	+ ext4_set_inode_flags(inode, false);
1317	1526	}
1318	1527	return res;
1319	1528	}
..	..	@@ -1340,7 +1549,7 @@
1340	1549	* Update inode->i_flags - S_ENCRYPTED will be enabled,
1341	1550	* S_DAX may be disabled
1342	1551	*/
1343		- ext4_set_inode_flags(inode);
	1552	+ ext4_set_inode_flags(inode, false);
1344	1553	res = ext4_mark_inode_dirty(handle, inode);
1345	1554	if (res)
1346	1555	EXT4_ERROR_INODE(inode, "Failed to mark inode dirty");
..	..	@@ -1354,10 +1563,9 @@
1354	1563	return res;
1355	1564	}
1356	1565
1357		-static const union fscrypt_context *
1358		-ext4_get_dummy_context(struct super_block *sb)
	1566	+static const union fscrypt_policy ext4_get_dummy_policy(struct super_block sb)
1359	1567	{
1360		- return EXT4_SB(sb)->s_dummy_enc_ctx.ctx;
	1568	+ return EXT4_SB(sb)->s_dummy_enc_policy.policy;
1361	1569	}
1362	1570
1363	1571	static bool ext4_has_stable_inodes(struct super_block *sb)
..	..	@@ -1372,21 +1580,15 @@
1372	1580	lblk_bits_ret = 8 sizeof(ext4_lblk_t);
1373	1581	}
1374	1582
1375		-static bool ext4_inline_crypt_enabled(struct super_block *sb)
1376		-{
1377		- return test_opt(sb, INLINECRYPT);
1378		-}
1379		-
1380	1583	static const struct fscrypt_operations ext4_cryptops = {
1381	1584	.key_prefix = "ext4:",
1382	1585	.get_context = ext4_get_context,
1383	1586	.set_context = ext4_set_context,
1384		- .get_dummy_context = ext4_get_dummy_context,
	1587	+ .get_dummy_policy = ext4_get_dummy_policy,
1385	1588	.empty_dir = ext4_empty_dir,
1386	1589	.max_namelen = EXT4_NAME_LEN,
1387	1590	.has_stable_inodes = ext4_has_stable_inodes,
1388	1591	.get_ino_and_lblk_bits = ext4_get_ino_and_lblk_bits,
1389		- .inline_crypt_enabled = ext4_inline_crypt_enabled,
1390	1592	};
1391	1593	#endif
1392	1594
..	..	@@ -1409,7 +1611,6 @@
1409	1611	static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
1410	1612	unsigned int flags);
1411	1613	static int ext4_enable_quotas(struct super_block *sb);
1412		-static int ext4_get_next_id(struct super_block sb, struct kqid qid);
1413	1614
1414	1615	static struct dquot *ext4_get_dquots(struct inode inode)
1415	1616	{
..	..	@@ -1427,7 +1628,7 @@
1427	1628	.destroy_dquot = dquot_destroy,
1428	1629	.get_projid = ext4_get_projid,
1429	1630	.get_inode_usage = ext4_get_inode_usage,
1430		- .get_next_id = ext4_get_next_id,
	1631	+ .get_next_id = dquot_get_next_id,
1431	1632	};
1432	1633
1433	1634	static const struct quotactl_ops ext4_qctl_operations = {
..	..	@@ -1444,6 +1645,7 @@
1444	1645
1445	1646	static const struct super_operations ext4_sops = {
1446	1647	.alloc_inode = ext4_alloc_inode,
	1648	+ .free_inode = ext4_free_in_core_inode,
1447	1649	.destroy_inode = ext4_destroy_inode,
1448	1650	.write_inode = ext4_write_inode,
1449	1651	.dirty_inode = ext4_dirty_inode,
..	..	@@ -1485,7 +1687,8 @@
1485	1687	Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
1486	1688	Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
1487	1689	Opt_noquota, Opt_barrier, Opt_nobarrier, Opt_err,
1488		- Opt_usrquota, Opt_grpquota, Opt_prjquota, Opt_i_version, Opt_dax,
	1690	+ Opt_usrquota, Opt_grpquota, Opt_prjquota, Opt_i_version,
	1691	+ Opt_dax, Opt_dax_always, Opt_dax_inode, Opt_dax_never,
1489	1692	Opt_stripe, Opt_delalloc, Opt_nodelalloc, Opt_warn_on_error,
1490	1693	Opt_nowarn_on_error, Opt_mblk_io_submit,
1491	1694	Opt_lazytime, Opt_nolazytime, Opt_debug_want_extra_isize,
..	..	@@ -1494,6 +1697,10 @@
1494	1697	Opt_dioread_nolock, Opt_dioread_lock,
1495	1698	Opt_discard, Opt_nodiscard, Opt_init_itable, Opt_noinit_itable,
1496	1699	Opt_max_dir_size_kb, Opt_nojournal_checksum, Opt_nombcache,
	1700	+ Opt_prefetch_block_bitmaps,
	1701	+#ifdef CONFIG_EXT4_DEBUG
	1702	+ Opt_fc_debug_max_replay, Opt_fc_debug_force
	1703	+#endif
1497	1704	};
1498	1705
1499	1706	static const match_table_t tokens = {
..	..	@@ -1552,6 +1759,9 @@
1552	1759	{Opt_nobarrier, "nobarrier"},
1553	1760	{Opt_i_version, "i_version"},
1554	1761	{Opt_dax, "dax"},
	1762	+ {Opt_dax_always, "dax=always"},
	1763	+ {Opt_dax_inode, "dax=inode"},
	1764	+ {Opt_dax_never, "dax=never"},
1555	1765	{Opt_stripe, "stripe=%u"},
1556	1766	{Opt_delalloc, "delalloc"},
1557	1767	{Opt_warn_on_error, "warn_on_error"},
..	..	@@ -1570,18 +1780,24 @@
1570	1780	{Opt_auto_da_alloc, "auto_da_alloc"},
1571	1781	{Opt_noauto_da_alloc, "noauto_da_alloc"},
1572	1782	{Opt_dioread_nolock, "dioread_nolock"},
	1783	+ {Opt_dioread_lock, "nodioread_nolock"},
1573	1784	{Opt_dioread_lock, "dioread_lock"},
1574	1785	{Opt_discard, "discard"},
1575	1786	{Opt_nodiscard, "nodiscard"},
1576	1787	{Opt_init_itable, "init_itable=%u"},
1577	1788	{Opt_init_itable, "init_itable"},
1578	1789	{Opt_noinit_itable, "noinit_itable"},
	1790	+#ifdef CONFIG_EXT4_DEBUG
	1791	+ {Opt_fc_debug_force, "fc_debug_force"},
	1792	+ {Opt_fc_debug_max_replay, "fc_debug_max_replay=%u"},
	1793	+#endif
1579	1794	{Opt_max_dir_size_kb, "max_dir_size_kb=%u"},
1580	1795	{Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
1581	1796	{Opt_test_dummy_encryption, "test_dummy_encryption"},
1582	1797	{Opt_inlinecrypt, "inlinecrypt"},
1583	1798	{Opt_nombcache, "nombcache"},
1584	1799	{Opt_nombcache, "no_mbcache"}, /* for backward compatibility */
	1800	+ {Opt_prefetch_block_bitmaps, "prefetch_block_bitmaps"},
1585	1801	{Opt_removed, "check=none"}, /* mount option from ext2/3 */
1586	1802	{Opt_removed, "nocheck"}, /* mount option from ext2/3 */
1587	1803	{Opt_removed, "reservation"}, /* mount option from ext2/3 */
..	..	@@ -1700,6 +1916,8 @@
1700	1916	#define MOPT_NO_EXT3 0x0200
1701	1917	#define MOPT_EXT4_ONLY (MOPT_NO_EXT2 \| MOPT_NO_EXT3)
1702	1918	#define MOPT_STRING 0x0400
	1919	+#define MOPT_SKIP 0x0800
	1920	+#define MOPT_2 0x1000
1703	1921
1704	1922	static const struct mount_opts {
1705	1923	int token;
..	..	@@ -1724,6 +1942,7 @@
1724	1942	MOPT_EXT4_ONLY \| MOPT_CLEAR},
1725	1943	{Opt_warn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_SET},
1726	1944	{Opt_nowarn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_CLEAR},
	1945	+ {Opt_commit, 0, MOPT_NO_EXT2},
1727	1946	{Opt_nojournal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1728	1947	MOPT_EXT4_ONLY \| MOPT_CLEAR},
1729	1948	{Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
..	..	@@ -1749,7 +1968,13 @@
1749	1968	{Opt_min_batch_time, 0, MOPT_GTE0},
1750	1969	{Opt_inode_readahead_blks, 0, MOPT_GTE0},
1751	1970	{Opt_init_itable, 0, MOPT_GTE0},
1752		- {Opt_dax, EXT4_MOUNT_DAX, MOPT_SET},
	1971	+ {Opt_dax, EXT4_MOUNT_DAX_ALWAYS, MOPT_SET \| MOPT_SKIP},
	1972	+ {Opt_dax_always, EXT4_MOUNT_DAX_ALWAYS,
	1973	+ MOPT_EXT4_ONLY \| MOPT_SET \| MOPT_SKIP},
	1974	+ {Opt_dax_inode, EXT4_MOUNT2_DAX_INODE,
	1975	+ MOPT_EXT4_ONLY \| MOPT_SET \| MOPT_SKIP},
	1976	+ {Opt_dax_never, EXT4_MOUNT2_DAX_NEVER,
	1977	+ MOPT_EXT4_ONLY \| MOPT_SET \| MOPT_SKIP},
1753	1978	{Opt_stripe, 0, MOPT_GTE0},
1754	1979	{Opt_resuid, 0, MOPT_GTE0},
1755	1980	{Opt_resgid, 0, MOPT_GTE0},
..	..	@@ -1791,12 +2016,14 @@
1791	2016	{Opt_jqfmt_vfsv1, QFMT_VFS_V1, MOPT_QFMT},
1792	2017	{Opt_max_dir_size_kb, 0, MOPT_GTE0},
1793	2018	{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	2019	{Opt_nombcache, EXT4_MOUNT_NO_MBCACHE, MOPT_SET},
	2020	+ {Opt_prefetch_block_bitmaps, EXT4_MOUNT_PREFETCH_BLOCK_BITMAPS,
	2021	+ MOPT_SET},
	2022	+#ifdef CONFIG_EXT4_DEBUG
	2023	+ {Opt_fc_debug_force, EXT4_MOUNT2_JOURNAL_FAST_COMMIT,
	2024	+ MOPT_SET \| MOPT_2 \| MOPT_EXT4_ONLY},
	2025	+ {Opt_fc_debug_max_replay, 0, MOPT_GTE0},
	2026	+#endif
1800	2027	{Opt_err, 0, 0}
1801	2028	};
1802	2029
..	..	@@ -1839,18 +2066,25 @@
1839	2066	struct ext4_sb_info *sbi = EXT4_SB(sb);
1840	2067	int err;
1841	2068
	2069	+ if (!ext4_has_feature_encrypt(sb)) {
	2070	+ ext4_msg(sb, KERN_WARNING,
	2071	+ "test_dummy_encryption requires encrypt feature");
	2072	+ return -1;
	2073	+ }
	2074	+
1842	2075	/*
1843	2076	* This mount option is just for testing, and it's not worthwhile to
1844	2077	* implement the extra complexity (e.g. RCU protection) that would be
1845	2078	* needed to allow it to be set or changed during remount. We do allow
1846	2079	* it to be specified during remount, but only if there is no change.
1847	2080	*/
1848		- if (is_remount && !sbi->s_dummy_enc_ctx.ctx) {
	2081	+ if (is_remount && !sbi->s_dummy_enc_policy.policy) {
1849	2082	ext4_msg(sb, KERN_WARNING,
1850	2083	"Can't set test_dummy_encryption on remount");
1851	2084	return -1;
1852	2085	}
1853		- err = fscrypt_set_test_dummy_encryption(sb, arg, &sbi->s_dummy_enc_ctx);
	2086	+ err = fscrypt_set_test_dummy_encryption(sb, arg->from,
	2087	+ &sbi->s_dummy_enc_policy);
1854	2088	if (err) {
1855	2089	if (err == -EEXIST)
1856	2090	ext4_msg(sb, KERN_WARNING,
..	..	@@ -1865,11 +2099,13 @@
1865	2099	return -1;
1866	2100	}
1867	2101	ext4_msg(sb, KERN_WARNING, "Test dummy encryption mode enabled");
	2102	+ return 1;
1868	2103	#else
1869	2104	ext4_msg(sb, KERN_WARNING,
1870		- "Test dummy encryption mount option ignored");
	2105	+ "test_dummy_encryption option not supported");
	2106	+ return -1;
	2107	+
1871	2108	#endif
1872		- return 1;
1873	2109	}
1874	2110
1875	2111	static int handle_mount_opt(struct super_block sb, char opt, int token,
..	..	@@ -1903,7 +2139,7 @@
1903	2139	ext4_msg(sb, KERN_WARNING, "Ignoring removed %s option", opt);
1904	2140	return 1;
1905	2141	case Opt_abort:
1906		- sbi->s_mount_flags \|= EXT4_MF_FS_ABORTED;
	2142	+ ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
1907	2143	return 1;
1908	2144	case Opt_i_version:
1909	2145	sb->s_flags \|= SB_I_VERSION;
..	..	@@ -1913,6 +2149,13 @@
1913	2149	return 1;
1914	2150	case Opt_nolazytime:
1915	2151	sb->s_flags &= ~SB_LAZYTIME;
	2152	+ return 1;
	2153	+ case Opt_inlinecrypt:
	2154	+#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
	2155	+ sb->s_flags \|= SB_INLINECRYPT;
	2156	+#else
	2157	+ ext4_msg(sb, KERN_ERR, "inline encryption not supported");
	2158	+#endif
1916	2159	return 1;
1917	2160	}
1918	2161
..	..	@@ -1962,6 +2205,13 @@
1962	2205	} else if (token == Opt_commit) {
1963	2206	if (arg == 0)
1964	2207	arg = JBD2_DEFAULT_MAX_COMMIT_AGE;
	2208	+ else if (arg > INT_MAX / HZ) {
	2209	+ ext4_msg(sb, KERN_ERR,
	2210	+ "Invalid commit interval %d, "
	2211	+ "must be smaller than %d",
	2212	+ arg, INT_MAX / HZ);
	2213	+ return -1;
	2214	+ }
1965	2215	sbi->s_commit_interval = HZ * arg;
1966	2216	} else if (token == Opt_debug_want_extra_isize) {
1967	2217	if ((arg & 1) \|\|
..	..	@@ -1991,6 +2241,10 @@
1991	2241	sbi->s_li_wait_mult = arg;
1992	2242	} else if (token == Opt_max_dir_size_kb) {
1993	2243	sbi->s_max_dir_size_kb = arg;
	2244	+#ifdef CONFIG_EXT4_DEBUG
	2245	+ } else if (token == Opt_fc_debug_max_replay) {
	2246	+ sbi->s_fc_debug_max_replay = arg;
	2247	+#endif
1994	2248	} else if (token == Opt_stripe) {
1995	2249	sbi->s_stripe = arg;
1996	2250	} else if (token == Opt_resuid) {
..	..	@@ -2092,23 +2346,56 @@
2092	2346	}
2093	2347	sbi->s_jquota_fmt = m->mount_opt;
2094	2348	#endif
2095		- } else if (token == Opt_dax) {
	2349	+ } else if (token == Opt_dax \|\| token == Opt_dax_always \|\|
	2350	+ token == Opt_dax_inode \|\| token == Opt_dax_never) {
2096	2351	#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;
	2352	+ switch (token) {
	2353	+ case Opt_dax:
	2354	+ case Opt_dax_always:
	2355	+ if (is_remount &&
	2356	+ (!(sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) \|\|
	2357	+ (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER))) {
	2358	+ fail_dax_change_remount:
	2359	+ ext4_msg(sb, KERN_ERR, "can't change "
	2360	+ "dax mount option while remounting");
	2361	+ return -1;
	2362	+ }
	2363	+ if (is_remount &&
	2364	+ (test_opt(sb, DATA_FLAGS) ==
	2365	+ EXT4_MOUNT_JOURNAL_DATA)) {
	2366	+ ext4_msg(sb, KERN_ERR, "can't mount with "
	2367	+ "both data=journal and dax");
	2368	+ return -1;
	2369	+ }
	2370	+ ext4_msg(sb, KERN_WARNING,
	2371	+ "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
	2372	+ sbi->s_mount_opt \|= EXT4_MOUNT_DAX_ALWAYS;
	2373	+ sbi->s_mount_opt2 &= ~EXT4_MOUNT2_DAX_NEVER;
	2374	+ break;
	2375	+ case Opt_dax_never:
	2376	+ if (is_remount &&
	2377	+ (!(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) \|\|
	2378	+ (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS)))
	2379	+ goto fail_dax_change_remount;
	2380	+ sbi->s_mount_opt2 \|= EXT4_MOUNT2_DAX_NEVER;
	2381	+ sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
	2382	+ break;
	2383	+ case Opt_dax_inode:
	2384	+ if (is_remount &&
	2385	+ ((sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) \|\|
	2386	+ (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) \|\|
	2387	+ !(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_INODE)))
	2388	+ goto fail_dax_change_remount;
	2389	+ sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
	2390	+ sbi->s_mount_opt2 &= ~EXT4_MOUNT2_DAX_NEVER;
	2391	+ /* Strictly for printing options */
	2392	+ sbi->s_mount_opt2 \|= EXT4_MOUNT2_DAX_INODE;
	2393	+ break;
2101	2394	}
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	2395	#else
2111	2396	ext4_msg(sb, KERN_INFO, "dax option not supported");
	2397	+ sbi->s_mount_opt2 \|= EXT4_MOUNT2_DAX_NEVER;
	2398	+ sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
2112	2399	return -1;
2113	2400	#endif
2114	2401	} else if (token == Opt_data_err_abort) {
..	..	@@ -2126,10 +2413,17 @@
2126	2413	WARN_ON(1);
2127	2414	return -1;
2128	2415	}
2129		- if (arg != 0)
2130		- sbi->s_mount_opt \|= m->mount_opt;
2131		- else
2132		- sbi->s_mount_opt &= ~m->mount_opt;
	2416	+ if (m->flags & MOPT_2) {
	2417	+ if (arg != 0)
	2418	+ sbi->s_mount_opt2 \|= m->mount_opt;
	2419	+ else
	2420	+ sbi->s_mount_opt2 &= ~m->mount_opt;
	2421	+ } else {
	2422	+ if (arg != 0)
	2423	+ sbi->s_mount_opt \|= m->mount_opt;
	2424	+ else
	2425	+ sbi->s_mount_opt &= ~m->mount_opt;
	2426	+ }
2133	2427	}
2134	2428	return 1;
2135	2429	}
..	..	@@ -2139,7 +2433,7 @@
2139	2433	unsigned int *journal_ioprio,
2140	2434	int is_remount)
2141	2435	{
2142		- struct ext4_sb_info *sbi = EXT4_SB(sb);
	2436	+ struct ext4_sb_info __maybe_unused *sbi = EXT4_SB(sb);
2143	2437	char p, __maybe_unused usr_qf_name, __maybe_unused *grp_qf_name;
2144	2438	substring_t args[MAX_OPT_ARGS];
2145	2439	int token;
..	..	@@ -2196,12 +2490,10 @@
2196	2490	if (test_opt(sb, DIOREAD_NOLOCK)) {
2197	2491	int blocksize =
2198	2492	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		- }
	2493	+ if (blocksize < PAGE_SIZE)
	2494	+ ext4_msg(sb, KERN_WARNING, "Warning: mounting with an "
	2495	+ "experimental mount option 'dioread_nolock' "
	2496	+ "for blocksize < PAGE_SIZE");
2205	2497	}
2206	2498	return 1;
2207	2499	}
..	..	@@ -2274,7 +2566,7 @@
2274	2566	for (m = ext4_mount_opts; m->token != Opt_err; m++) {
2275	2567	int want_set = m->flags & MOPT_SET;
2276	2568	if (((m->flags & (MOPT_SET\|MOPT_CLEAR)) == 0) \|\|
2277		- (m->flags & MOPT_CLEAR_ERR))
	2569	+ (m->flags & MOPT_CLEAR_ERR) \|\| m->flags & MOPT_SKIP)
2278	2570	continue;
2279	2571	if (!nodefs && !(m->mount_opt & (sbi->s_mount_opt ^ def_mount_opt)))
2280	2572	continue; /* skip if same as the default */
..	..	@@ -2334,6 +2626,19 @@
2334	2626
2335	2627	fscrypt_show_test_dummy_encryption(seq, sep, sb);
2336	2628
	2629	+ if (sb->s_flags & SB_INLINECRYPT)
	2630	+ SEQ_OPTS_PUTS("inlinecrypt");
	2631	+
	2632	+ if (test_opt(sb, DAX_ALWAYS)) {
	2633	+ if (IS_EXT2_SB(sb))
	2634	+ SEQ_OPTS_PUTS("dax");
	2635	+ else
	2636	+ SEQ_OPTS_PUTS("dax=always");
	2637	+ } else if (test_opt2(sb, DAX_NEVER)) {
	2638	+ SEQ_OPTS_PUTS("dax=never");
	2639	+ } else if (test_opt2(sb, DAX_INODE)) {
	2640	+ SEQ_OPTS_PUTS("dax=inode");
	2641	+ }
2337	2642	ext4_show_quota_options(seq, sb);
2338	2643	return 0;
2339	2644	}
..	..	@@ -2528,11 +2833,9 @@
2528	2833	crc = crc16(crc, (__u8 *)gdp, offset);
2529	2834	offset += sizeof(gdp->bg_checksum); /* skip checksum */
2530	2835	/* for checksum of struct ext4_group_desc do the rest...*/
2531		- if (ext4_has_feature_64bit(sb) &&
2532		- offset < le16_to_cpu(sbi->s_es->s_desc_size))
	2836	+ if (ext4_has_feature_64bit(sb) && offset < sbi->s_desc_size)
2533	2837	crc = crc16(crc, (__u8 *)gdp + offset,
2534		- le16_to_cpu(sbi->s_es->s_desc_size) -
2535		- offset);
	2838	+ sbi->s_desc_size - offset);
2536	2839
2537	2840	out:
2538	2841	return cpu_to_le16(crc);
..	..	@@ -2859,13 +3162,9 @@
2859	3162	loff_t res;
2860	3163	loff_t upper_limit = MAX_LFS_FILESIZE;
2861	3164
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		- */
	3165	+ BUILD_BUG_ON(sizeof(blkcnt_t) < sizeof(u64));
	3166	+
	3167	+ if (!has_huge_files) {
2869	3168	upper_limit = (1LL << 32) - 1;
2870	3169
2871	3170	/* total blocks in file system block size */
..	..	@@ -2895,22 +3194,22 @@
2895	3194	*/
2896	3195	static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
2897	3196	{
2898		- loff_t res = EXT4_NDIR_BLOCKS;
	3197	+ unsigned long long upper_limit, res = EXT4_NDIR_BLOCKS;
2899	3198	int meta_blocks;
2900		- loff_t upper_limit;
2901		- /* This is calculated to be the largest file size for a dense, block
	3199	+
	3200	+ /*
	3201	+ * This is calculated to be the largest file size for a dense, block
2902	3202	* mapped file such that the file's total number of 512-byte sectors,
2903	3203	* including data and all indirect blocks, does not exceed (2^48 - 1).
2904	3204	*
2905	3205	* __u32 i_blocks_lo and _u16 i_blocks_high represent the total
2906	3206	* number of 512-byte sectors of the file.
2907	3207	*/
2908		-
2909		- if (!has_huge_files \|\| sizeof(blkcnt_t) < sizeof(u64)) {
	3208	+ if (!has_huge_files) {
2910	3209	/*
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
	3210	+ * !has_huge_files or implies that the inode i_block field
	3211	+ * represents total file blocks in 2^32 512-byte sectors ==
	3212	+ * size of vfs inode i_blocks * 8
2914	3213	*/
2915	3214	upper_limit = (1LL << 32) - 1;
2916	3215
..	..	@@ -2948,7 +3247,7 @@
2948	3247	if (res > MAX_LFS_FILESIZE)
2949	3248	res = MAX_LFS_FILESIZE;
2950	3249
2951		- return res;
	3250	+ return (loff_t)res;
2952	3251	}
2953	3252
2954	3253	static ext4_fsblk_t descriptor_loc(struct super_block *sb,
..	..	@@ -3059,18 +3358,6 @@
3059	3358	~EXT4_FEATURE_RO_COMPAT_SUPP));
3060	3359	return 0;
3061	3360	}
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	3361	if (ext4_has_feature_bigalloc(sb) && !ext4_has_feature_extents(sb)) {
3075	3362	ext4_msg(sb, KERN_ERR,
3076	3363	"Can't support bigalloc feature without "
..	..	@@ -3140,15 +3427,34 @@
3140	3427	static int ext4_run_li_request(struct ext4_li_request *elr)
3141	3428	{
3142	3429	struct ext4_group_desc *gdp = NULL;
3143		- ext4_group_t group, ngroups;
3144		- struct super_block *sb;
	3430	+ struct super_block *sb = elr->lr_super;
	3431	+ ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
	3432	+ ext4_group_t group = elr->lr_next_group;
	3433	+ unsigned int prefetch_ios = 0;
3145	3434	int ret = 0;
3146	3435	u64 start_time;
3147	3436
3148		- sb = elr->lr_super;
3149		- ngroups = EXT4_SB(sb)->s_groups_count;
	3437	+ if (elr->lr_mode == EXT4_LI_MODE_PREFETCH_BBITMAP) {
	3438	+ elr->lr_next_group = ext4_mb_prefetch(sb, group,
	3439	+ EXT4_SB(sb)->s_mb_prefetch, &prefetch_ios);
	3440	+ if (prefetch_ios)
	3441	+ ext4_mb_prefetch_fini(sb, elr->lr_next_group,
	3442	+ prefetch_ios);
	3443	+ trace_ext4_prefetch_bitmaps(sb, group, elr->lr_next_group,
	3444	+ prefetch_ios);
	3445	+ if (group >= elr->lr_next_group) {
	3446	+ ret = 1;
	3447	+ if (elr->lr_first_not_zeroed != ngroups &&
	3448	+ !sb_rdonly(sb) && test_opt(sb, INIT_INODE_TABLE)) {
	3449	+ elr->lr_next_group = elr->lr_first_not_zeroed;
	3450	+ elr->lr_mode = EXT4_LI_MODE_ITABLE;
	3451	+ ret = 0;
	3452	+ }
	3453	+ }
	3454	+ return ret;
	3455	+ }
3150	3456
3151		- for (group = elr->lr_next_group; group < ngroups; group++) {
	3457	+ for (; group < ngroups; group++) {
3152	3458	gdp = ext4_get_group_desc(sb, group, NULL);
3153	3459	if (!gdp) {
3154	3460	ret = 1;
..	..	@@ -3166,9 +3472,10 @@
3166	3472	start_time = ktime_get_real_ns();
3167	3473	ret = ext4_init_inode_table(sb, group,
3168	3474	elr->lr_timeout ? 0 : 1);
	3475	+ trace_ext4_lazy_itable_init(sb, group);
3169	3476	if (elr->lr_timeout == 0) {
3170	3477	elr->lr_timeout = nsecs_to_jiffies((ktime_get_real_ns() - start_time) *
3171		- elr->lr_sbi->s_li_wait_mult);
	3478	+ EXT4_SB(elr->lr_super)->s_li_wait_mult);
3172	3479	}
3173	3480	elr->lr_next_sched = jiffies + elr->lr_timeout;
3174	3481	elr->lr_next_group = group + 1;
..	..	@@ -3182,15 +3489,11 @@
3182	3489	*/
3183	3490	static void ext4_remove_li_request(struct ext4_li_request *elr)
3184	3491	{
3185		- struct ext4_sb_info *sbi;
3186		-
3187	3492	if (!elr)
3188	3493	return;
3189	3494
3190		- sbi = elr->lr_sbi;
3191		-
3192	3495	list_del(&elr->lr_request);
3193		- sbi->s_li_request = NULL;
	3496	+ EXT4_SB(elr->lr_super)->s_li_request = NULL;
3194	3497	kfree(elr);
3195	3498	}
3196	3499
..	..	@@ -3227,6 +3530,7 @@
3227	3530	unsigned long next_wakeup, cur;
3228	3531
3229	3532	BUG_ON(NULL == eli);
	3533	+ set_freezable();
3230	3534
3231	3535	cont_thread:
3232	3536	while (true) {
..	..	@@ -3399,7 +3703,6 @@
3399	3703	static struct ext4_li_request ext4_li_request_new(struct super_block sb,
3400	3704	ext4_group_t start)
3401	3705	{
3402		- struct ext4_sb_info *sbi = EXT4_SB(sb);
3403	3706	struct ext4_li_request *elr;
3404	3707
3405	3708	elr = kzalloc(sizeof(*elr), GFP_KERNEL);
..	..	@@ -3407,8 +3710,13 @@
3407	3710	return NULL;
3408	3711
3409	3712	elr->lr_super = sb;
3410		- elr->lr_sbi = sbi;
3411		- elr->lr_next_group = start;
	3713	+ elr->lr_first_not_zeroed = start;
	3714	+ if (test_opt(sb, PREFETCH_BLOCK_BITMAPS))
	3715	+ elr->lr_mode = EXT4_LI_MODE_PREFETCH_BBITMAP;
	3716	+ else {
	3717	+ elr->lr_mode = EXT4_LI_MODE_ITABLE;
	3718	+ elr->lr_next_group = start;
	3719	+ }
3412	3720
3413	3721	/*
3414	3722	* Randomize first schedule time of the request to
..	..	@@ -3438,8 +3746,9 @@
3438	3746	goto out;
3439	3747	}
3440	3748
3441		- if (first_not_zeroed == ngroups \|\| sb_rdonly(sb) \|\|
3442		- !test_opt(sb, INIT_INODE_TABLE))
	3749	+ if (!test_opt(sb, PREFETCH_BLOCK_BITMAPS) &&
	3750	+ (first_not_zeroed == ngroups \|\| sb_rdonly(sb) \|\|
	3751	+ !test_opt(sb, INIT_INODE_TABLE)))
3443	3752	goto out;
3444	3753
3445	3754	elr = ext4_li_request_new(sb, first_not_zeroed);
..	..	@@ -3556,9 +3865,11 @@
3556	3865	ext4_fsblk_t first_block, last_block, b;
3557	3866	ext4_group_t i, ngroups = ext4_get_groups_count(sb);
3558	3867	int s, j, count = 0;
	3868	+ int has_super = ext4_bg_has_super(sb, grp);
3559	3869
3560	3870	if (!ext4_has_feature_bigalloc(sb))
3561		- return (ext4_bg_has_super(sb, grp) + ext4_bg_num_gdb(sb, grp) +
	3871	+ return (has_super + ext4_bg_num_gdb(sb, grp) +
	3872	+ (has_super ? le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0) +
3562	3873	sbi->s_itb_per_group + 2);
3563	3874
3564	3875	first_block = le32_to_cpu(sbi->s_es->s_first_data_block) +
..	..	@@ -3650,8 +3961,8 @@
3650	3961	* Add the internal journal blocks whether the journal has been
3651	3962	* loaded or not
3652	3963	*/
3653		- if (sbi->s_journal && !sbi->journal_bdev)
3654		- overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_maxlen);
	3964	+ if (sbi->s_journal && !sbi->s_journal_bdev)
	3965	+ overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_total_len);
3655	3966	else if (ext4_has_feature_journal(sb) && !sbi->s_journal && j_inum) {
3656	3967	/* j_inum for internal journal is non-zero */
3657	3968	j_inode = ext4_get_journal_inode(sb, j_inum);
..	..	@@ -3719,7 +4030,7 @@
3719	4030	int blocksize, clustersize;
3720	4031	unsigned int db_count;
3721	4032	unsigned int i;
3722		- int needs_recovery, has_huge_files, has_bigalloc;
	4033	+ int needs_recovery, has_huge_files;
3723	4034	__u64 blocks_count;
3724	4035	int err = 0;
3725	4036	unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
..	..	@@ -3764,8 +4075,11 @@
3764	4075	logical_sb_block = sb_block;
3765	4076	}
3766	4077
3767		- if (!(bh = sb_bread_unmovable(sb, logical_sb_block))) {
	4078	+ bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
	4079	+ if (IS_ERR(bh)) {
3768	4080	ext4_msg(sb, KERN_ERR, "unable to read superblock");
	4081	+ ret = PTR_ERR(bh);
	4082	+ bh = NULL;
3769	4083	goto out_fail;
3770	4084	}
3771	4085	/*
..	..	@@ -3832,6 +4146,8 @@
3832	4146	#ifdef CONFIG_EXT4_FS_POSIX_ACL
3833	4147	set_opt(sb, POSIX_ACL);
3834	4148	#endif
	4149	+ if (ext4_has_feature_fast_commit(sb))
	4150	+ set_opt2(sb, JOURNAL_FAST_COMMIT);
3835	4151	/* don't forget to enable journal_csum when metadata_csum is enabled. */
3836	4152	if (ext4_has_metadata_csum(sb))
3837	4153	set_opt(sb, JOURNAL_CHECKSUM);
..	..	@@ -3877,14 +4193,25 @@
3877	4193	*/
3878	4194	sbi->s_li_wait_mult = EXT4_DEF_LI_WAIT_MULT;
3879	4195
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) {
	4196	+ if (le32_to_cpu(es->s_log_block_size) >
	4197	+ (EXT4_MAX_BLOCK_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
3883	4198	ext4_msg(sb, KERN_ERR,
3884		- "Unsupported filesystem blocksize %d (%d log_block_size)",
3885		- blocksize, le32_to_cpu(es->s_log_block_size));
	4199	+ "Invalid log block size: %u",
	4200	+ le32_to_cpu(es->s_log_block_size));
3886	4201	goto failed_mount;
3887	4202	}
	4203	+ if (le32_to_cpu(es->s_log_cluster_size) >
	4204	+ (EXT4_MAX_CLUSTER_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
	4205	+ ext4_msg(sb, KERN_ERR,
	4206	+ "Invalid log cluster size: %u",
	4207	+ le32_to_cpu(es->s_log_cluster_size));
	4208	+ goto failed_mount;
	4209	+ }
	4210	+
	4211	+ blocksize = EXT4_MIN_BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
	4212	+
	4213	+ if (blocksize == PAGE_SIZE)
	4214	+ set_opt(sb, DIOREAD_NOLOCK);
3888	4215
3889	4216	if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
3890	4217	sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
..	..	@@ -3915,9 +4242,12 @@
3915	4242	if (sbi->s_inode_size >= offsetof(struct ext4_inode, i_atime_extra) +
3916	4243	sizeof(((struct ext4_inode *)0)->i_atime_extra)) {
3917	4244	sb->s_time_gran = 1;
	4245	+ sb->s_time_max = EXT4_EXTRA_TIMESTAMP_MAX;
3918	4246	} else {
3919	4247	sb->s_time_gran = NSEC_PER_SEC;
	4248	+ sb->s_time_max = EXT4_NON_EXTRA_TIMESTAMP_MAX;
3920	4249	}
	4250	+ sb->s_time_min = EXT4_TIMESTAMP_MIN;
3921	4251	}
3922	4252	if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
3923	4253	sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
..	..	@@ -3997,20 +4327,16 @@
3997	4327	#endif
3998	4328
3999	4329	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");
	4330	+ printk_once(KERN_WARNING "EXT4-fs: Warning: mounting with data=journal disables delayed allocation, dioread_nolock, O_DIRECT and fast_commit support!\n");
	4331	+ /* can't mount with both data=journal and dioread_nolock. */
	4332	+ clear_opt(sb, DIOREAD_NOLOCK);
	4333	+ clear_opt2(sb, JOURNAL_FAST_COMMIT);
4003	4334	if (test_opt2(sb, EXPLICIT_DELALLOC)) {
4004	4335	ext4_msg(sb, KERN_ERR, "can't mount with "
4005	4336	"both data=journal and delalloc");
4006	4337	goto failed_mount;
4007	4338	}
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)) {
	4339	+ if (test_opt(sb, DAX_ALWAYS)) {
4014	4340	ext4_msg(sb, KERN_ERR, "can't mount with "
4015	4341	"both data=journal and dax");
4016	4342	goto failed_mount;
..	..	@@ -4098,21 +4424,6 @@
4098	4424	if (!ext4_feature_set_ok(sb, (sb_rdonly(sb))))
4099	4425	goto failed_mount;
4100	4426
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	4427	if (le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) > (blocksize / 4)) {
4117	4428	ext4_msg(sb, KERN_ERR,
4118	4429	"Number of reserved GDT blocks insanely large: %d",
..	..	@@ -4120,16 +4431,19 @@
4120	4431	goto failed_mount;
4121	4432	}
4122	4433
4123		- if (sbi->s_mount_opt & EXT4_MOUNT_DAX) {
	4434	+ if (bdev_dax_supported(sb->s_bdev, blocksize))
	4435	+ set_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags);
	4436	+
	4437	+ if (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) {
4124	4438	if (ext4_has_feature_inline_data(sb)) {
4125	4439	ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem"
4126	4440	" that may contain inline data");
4127		- sbi->s_mount_opt &= ~EXT4_MOUNT_DAX;
	4441	+ goto failed_mount;
4128	4442	}
4129		- if (!bdev_dax_supported(sb->s_bdev, blocksize)) {
	4443	+ if (!test_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags)) {
4130	4444	ext4_msg(sb, KERN_ERR,
4131		- "DAX unsupported by block device. Turning off DAX.");
4132		- sbi->s_mount_opt &= ~EXT4_MOUNT_DAX;
	4445	+ "DAX unsupported by block device.");
	4446	+ goto failed_mount;
4133	4447	}
4134	4448	}
4135	4449
..	..	@@ -4140,20 +4454,28 @@
4140	4454	}
4141	4455
4142	4456	if (sb->s_blocksize != blocksize) {
	4457	+ /*
	4458	+ * bh must be released before kill_bdev(), otherwise
	4459	+ * it won't be freed and its page also. kill_bdev()
	4460	+ * is called by sb_set_blocksize().
	4461	+ */
	4462	+ brelse(bh);
4143	4463	/* Validate the filesystem blocksize */
4144	4464	if (!sb_set_blocksize(sb, blocksize)) {
4145	4465	ext4_msg(sb, KERN_ERR, "bad block size %d",
4146	4466	blocksize);
	4467	+ bh = NULL;
4147	4468	goto failed_mount;
4148	4469	}
4149	4470
4150		- brelse(bh);
4151	4471	logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
4152	4472	offset = do_div(logical_sb_block, blocksize);
4153		- bh = sb_bread_unmovable(sb, logical_sb_block);
4154		- if (!bh) {
	4473	+ bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
	4474	+ if (IS_ERR(bh)) {
4155	4475	ext4_msg(sb, KERN_ERR,
4156	4476	"Can't read superblock on 2nd try");
	4477	+ ret = PTR_ERR(bh);
	4478	+ bh = NULL;
4157	4479	goto failed_mount;
4158	4480	}
4159	4481	es = (struct ext4_super_block *)(bh->b_data + offset);
..	..	@@ -4199,7 +4521,7 @@
4199	4521	sbi->s_inodes_per_block;
4200	4522	sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
4201	4523	sbi->s_sbh = bh;
4202		- sbi->s_mount_state = le16_to_cpu(es->s_state);
	4524	+ sbi->s_mount_state = le16_to_cpu(es->s_state) & ~EXT4_FC_REPLAY;
4203	4525	sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
4204	4526	sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
4205	4527
..	..	@@ -4226,8 +4548,7 @@
4226	4548
4227	4549	/* Handle clustersize */
4228	4550	clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
4229		- has_bigalloc = ext4_has_feature_bigalloc(sb);
4230		- if (has_bigalloc) {
	4551	+ if (ext4_has_feature_bigalloc(sb)) {
4231	4552	if (clustersize < blocksize) {
4232	4553	ext4_msg(sb, KERN_ERR,
4233	4554	"cluster size (%d) smaller than "
..	..	@@ -4283,8 +4604,6 @@
4283	4604	if (err) {
4284	4605	ext4_msg(sb, KERN_ERR, "filesystem"
4285	4606	" 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	4607	goto failed_mount;
4289	4608	}
4290	4609
..	..	@@ -4368,18 +4687,20 @@
4368	4687	/* Pre-read the descriptors into the buffer cache */
4369	4688	for (i = 0; i < db_count; i++) {
4370	4689	block = descriptor_loc(sb, logical_sb_block, i);
4371		- sb_breadahead_unmovable(sb, block);
	4690	+ ext4_sb_breadahead_unmovable(sb, block);
4372	4691	}
4373	4692
4374	4693	for (i = 0; i < db_count; i++) {
4375	4694	struct buffer_head *bh;
4376	4695
4377	4696	block = descriptor_loc(sb, logical_sb_block, i);
4378		- bh = sb_bread_unmovable(sb, block);
4379		- if (!bh) {
	4697	+ bh = ext4_sb_bread_unmovable(sb, block);
	4698	+ if (IS_ERR(bh)) {
4380	4699	ext4_msg(sb, KERN_ERR,
4381	4700	"can't read group descriptor %d", i);
4382	4701	db_count = i;
	4702	+ ret = PTR_ERR(bh);
	4703	+ bh = NULL;
4383	4704	goto failed_mount2;
4384	4705	}
4385	4706	rcu_read_lock();
..	..	@@ -4427,14 +4748,36 @@
4427	4748	INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
4428	4749	mutex_init(&sbi->s_orphan_lock);
4429	4750
	4751	+ /* Initialize fast commit stuff */
	4752	+ atomic_set(&sbi->s_fc_subtid, 0);
	4753	+ atomic_set(&sbi->s_fc_ineligible_updates, 0);
	4754	+ INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_MAIN]);
	4755	+ INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_STAGING]);
	4756	+ INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_MAIN]);
	4757	+ INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_STAGING]);
	4758	+ sbi->s_fc_bytes = 0;
	4759	+ ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
	4760	+ ext4_clear_mount_flag(sb, EXT4_MF_FC_COMMITTING);
	4761	+ spin_lock_init(&sbi->s_fc_lock);
	4762	+ memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));
	4763	+ sbi->s_fc_replay_state.fc_regions = NULL;
	4764	+ sbi->s_fc_replay_state.fc_regions_size = 0;
	4765	+ sbi->s_fc_replay_state.fc_regions_used = 0;
	4766	+ sbi->s_fc_replay_state.fc_regions_valid = 0;
	4767	+ sbi->s_fc_replay_state.fc_modified_inodes = NULL;
	4768	+ sbi->s_fc_replay_state.fc_modified_inodes_size = 0;
	4769	+ sbi->s_fc_replay_state.fc_modified_inodes_used = 0;
	4770	+
4430	4771	sb->s_root = NULL;
4431	4772
4432	4773	needs_recovery = (es->s_last_orphan != 0 \|\|
4433	4774	ext4_has_feature_journal_needs_recovery(sb));
4434	4775
4435		- if (ext4_has_feature_mmp(sb) && !sb_rdonly(sb))
4436		- if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block)))
	4776	+ if (ext4_has_feature_mmp(sb) && !sb_rdonly(sb)) {
	4777	+ err = ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block));
	4778	+ if (err)
4437	4779	goto failed_mount3a;
	4780	+ }
4438	4781
4439	4782	/*
4440	4783	* The first inode we look at is the journal inode. Don't try
..	..	@@ -4448,34 +4791,36 @@
4448	4791	ext4_has_feature_journal_needs_recovery(sb)) {
4449	4792	ext4_msg(sb, KERN_ERR, "required journal recovery "
4450	4793	"suppressed and not mounted read-only");
4451		- goto failed_mount_wq;
	4794	+ goto failed_mount3a;
4452	4795	} else {
4453	4796	/* Nojournal mode, all journal mount options are illegal */
4454		- if (test_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM)) {
4455		- ext4_msg(sb, KERN_ERR, "can't mount with "
4456		- "journal_checksum, fs mounted w/o journal");
4457		- goto failed_mount_wq;
4458		- }
4459	4797	if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4460	4798	ext4_msg(sb, KERN_ERR, "can't mount with "
4461	4799	"journal_async_commit, fs mounted w/o journal");
4462		- goto failed_mount_wq;
	4800	+ goto failed_mount3a;
	4801	+ }
	4802	+
	4803	+ if (test_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM)) {
	4804	+ ext4_msg(sb, KERN_ERR, "can't mount with "
	4805	+ "journal_checksum, fs mounted w/o journal");
	4806	+ goto failed_mount3a;
4463	4807	}
4464	4808	if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
4465	4809	ext4_msg(sb, KERN_ERR, "can't mount with "
4466	4810	"commit=%lu, fs mounted w/o journal",
4467	4811	sbi->s_commit_interval / HZ);
4468		- goto failed_mount_wq;
	4812	+ goto failed_mount3a;
4469	4813	}
4470	4814	if (EXT4_MOUNT_DATA_FLAGS &
4471	4815	(sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
4472	4816	ext4_msg(sb, KERN_ERR, "can't mount with "
4473	4817	"data=, fs mounted w/o journal");
4474		- goto failed_mount_wq;
	4818	+ goto failed_mount3a;
4475	4819	}
4476	4820	sbi->s_def_mount_opt &= ~EXT4_MOUNT_JOURNAL_CHECKSUM;
4477	4821	clear_opt(sb, JOURNAL_CHECKSUM);
4478	4822	clear_opt(sb, DATA_FLAGS);
	4823	+ clear_opt2(sb, JOURNAL_FAST_COMMIT);
4479	4824	sbi->s_journal = NULL;
4480	4825	needs_recovery = 0;
4481	4826	goto no_journal;
..	..	@@ -4491,6 +4836,14 @@
4491	4836	if (!set_journal_csum_feature_set(sb)) {
4492	4837	ext4_msg(sb, KERN_ERR, "Failed to set journal checksum "
4493	4838	"feature set");
	4839	+ goto failed_mount_wq;
	4840	+ }
	4841	+
	4842	+ if (test_opt2(sb, JOURNAL_FAST_COMMIT) &&
	4843	+ !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
	4844	+ JBD2_FEATURE_INCOMPAT_FAST_COMMIT)) {
	4845	+ ext4_msg(sb, KERN_ERR,
	4846	+ "Failed to set fast commit journal feature");
4494	4847	goto failed_mount_wq;
4495	4848	}
4496	4849
..	..	@@ -4533,7 +4886,10 @@
4533	4886
4534	4887	set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
4535	4888
4536		- sbi->s_journal->j_commit_callback = ext4_journal_commit_callback;
	4889	+ sbi->s_journal->j_submit_inode_data_buffers =
	4890	+ ext4_journal_submit_inode_data_buffers;
	4891	+ sbi->s_journal->j_finish_inode_data_buffers =
	4892	+ ext4_journal_finish_inode_data_buffers;
4537	4893
4538	4894	no_journal:
4539	4895	if (!test_opt(sb, NO_MBCACHE)) {
..	..	@@ -4554,31 +4910,27 @@
4554	4910	}
4555	4911	}
4556	4912
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	4913	if (ext4_has_feature_verity(sb) && blocksize != PAGE_SIZE) {
4565	4914	ext4_msg(sb, KERN_ERR, "Unsupported blocksize for fs-verity");
4566	4915	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	4916	}
4574	4917
4575	4918	/*
4576	4919	* Get the # of file system overhead blocks from the
4577	4920	* superblock if present.
4578	4921	*/
4579		- if (es->s_overhead_clusters)
4580		- sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
4581		- else {
	4922	+ sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
	4923	+ /* ignore the precalculated value if it is ridiculous */
	4924	+ if (sbi->s_overhead > ext4_blocks_count(es))
	4925	+ sbi->s_overhead = 0;
	4926	+ /*
	4927	+ * If the bigalloc feature is not enabled recalculating the
	4928	+ * overhead doesn't take long, so we might as well just redo
	4929	+ * it to make sure we are using the correct value.
	4930	+ */
	4931	+ if (!ext4_has_feature_bigalloc(sb))
	4932	+ sbi->s_overhead = 0;
	4933	+ if (sbi->s_overhead == 0) {
4582	4934	err = ext4_calculate_overhead(sb);
4583	4935	if (err)
4584	4936	goto failed_mount_wq;
..	..	@@ -4638,6 +4990,7 @@
4638	4990	goto failed_mount4a;
4639	4991	}
4640	4992	}
	4993	+ ext4_fc_replay_cleanup(sb);
4641	4994
4642	4995	ext4_ext_init(sb);
4643	4996	err = ext4_mb_init(sb);
..	..	@@ -4646,6 +4999,14 @@
4646	4999	err);
4647	5000	goto failed_mount5;
4648	5001	}
	5002	+
	5003	+ /*
	5004	+ * We can only set up the journal commit callback once
	5005	+ * mballoc is initialized
	5006	+ */
	5007	+ if (sbi->s_journal)
	5008	+ sbi->s_journal->j_commit_callback =
	5009	+ ext4_journal_commit_callback;
4649	5010
4650	5011	block = ext4_count_free_clusters(sb);
4651	5012	ext4_free_blocks_count_set(sbi->s_es,
..	..	@@ -4665,6 +5026,9 @@
4665	5026	ext4_count_dirs(sb), GFP_KERNEL);
4666	5027	if (!err)
4667	5028	err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
	5029	+ GFP_KERNEL);
	5030	+ if (!err)
	5031	+ err = percpu_counter_init(&sbi->s_sra_exceeded_retry_limit, 0,
4668	5032	GFP_KERNEL);
4669	5033	if (!err)
4670	5034	err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
..	..	@@ -4700,6 +5064,14 @@
4700	5064	}
4701	5065	#endif /* CONFIG_QUOTA */
4702	5066
	5067	+ /*
	5068	+ * Save the original bdev mapping's wb_err value which could be
	5069	+ * used to detect the metadata async write error.
	5070	+ */
	5071	+ spin_lock_init(&sbi->s_bdev_wb_lock);
	5072	+ errseq_check_and_advance(&sb->s_bdev->bd_inode->i_mapping->wb_err,
	5073	+ &sbi->s_bdev_wb_err);
	5074	+ sb->s_bdev->bd_super = sb;
4703	5075	EXT4_SB(sb)->s_mount_state \|= EXT4_ORPHAN_FS;
4704	5076	ext4_orphan_cleanup(sb, es);
4705	5077	EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
..	..	@@ -4741,6 +5113,8 @@
4741	5113	ratelimit_state_init(&sbi->s_err_ratelimit_state, 5 * HZ, 10);
4742	5114	ratelimit_state_init(&sbi->s_warning_ratelimit_state, 5 * HZ, 10);
4743	5115	ratelimit_state_init(&sbi->s_msg_ratelimit_state, 5 * HZ, 10);
	5116	+ atomic_set(&sbi->s_warning_count, 0);
	5117	+ atomic_set(&sbi->s_msg_count, 0);
4744	5118
4745	5119	kfree(orig_data);
4746	5120	return 0;
..	..	@@ -4769,6 +5143,7 @@
4769	5143	percpu_counter_destroy(&sbi->s_freeinodes_counter);
4770	5144	percpu_counter_destroy(&sbi->s_dirs_counter);
4771	5145	percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
	5146	+ percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
4772	5147	percpu_free_rwsem(&sbi->s_writepages_rwsem);
4773	5148	failed_mount5:
4774	5149	ext4_ext_release(sb);
..	..	@@ -4781,14 +5156,12 @@
4781	5156	if (EXT4_SB(sb)->rsv_conversion_wq)
4782	5157	destroy_workqueue(EXT4_SB(sb)->rsv_conversion_wq);
4783	5158	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		- }
	5159	+ ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
	5160	+ sbi->s_ea_inode_cache = NULL;
	5161	+
	5162	+ ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
	5163	+ sbi->s_ea_block_cache = NULL;
	5164	+
4792	5165	if (sbi->s_journal) {
4793	5166	jbd2_journal_destroy(sbi->s_journal);
4794	5167	sbi->s_journal = NULL;
..	..	@@ -4797,8 +5170,7 @@
4797	5170	ext4_es_unregister_shrinker(sbi);
4798	5171	failed_mount3:
4799	5172	del_timer_sync(&sbi->s_err_report);
4800		- if (sbi->s_mmp_tsk)
4801		- kthread_stop(sbi->s_mmp_tsk);
	5173	+ ext4_stop_mmpd(sbi);
4802	5174	failed_mount2:
4803	5175	rcu_read_lock();
4804	5176	group_desc = rcu_dereference(sbi->s_group_desc);
..	..	@@ -4816,12 +5188,14 @@
4816	5188
4817	5189	#ifdef CONFIG_QUOTA
4818	5190	for (i = 0; i < EXT4_MAXQUOTAS; i++)
4819		- kfree(sbi->s_qf_names[i]);
	5191	+ kfree(get_qf_name(sb, sbi, i));
4820	5192	#endif
4821		- fscrypt_free_dummy_context(&sbi->s_dummy_enc_ctx);
4822		- ext4_blkdev_remove(sbi);
	5193	+ fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
	5194	+ /* ext4_blkdev_remove() calls kill_bdev(), release bh before it. */
4823	5195	brelse(bh);
	5196	+ ext4_blkdev_remove(sbi);
4824	5197	out_fail:
	5198	+ invalidate_bdev(sb->s_bdev);
4825	5199	sb->s_fs_info = NULL;
4826	5200	kfree(sbi->s_blockgroup_lock);
4827	5201	out_free_base:
..	..	@@ -4843,6 +5217,7 @@
4843	5217	journal->j_commit_interval = sbi->s_commit_interval;
4844	5218	journal->j_min_batch_time = sbi->s_min_batch_time;
4845	5219	journal->j_max_batch_time = sbi->s_max_batch_time;
	5220	+ ext4_fc_init(sb, journal);
4846	5221
4847	5222	write_lock(&journal->j_state_lock);
4848	5223	if (test_opt(sb, BARRIER))
..	..	@@ -4880,7 +5255,7 @@
4880	5255
4881	5256	jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
4882	5257	journal_inode, journal_inode->i_size);
4883		- if (!S_ISREG(journal_inode->i_mode)) {
	5258	+ if (!S_ISREG(journal_inode->i_mode) \|\| IS_ENCRYPTED(journal_inode)) {
4884	5259	ext4_msg(sb, KERN_ERR, "invalid journal inode");
4885	5260	iput(journal_inode);
4886	5261	return NULL;
..	..	@@ -4985,9 +5360,7 @@
4985	5360	goto out_bdev;
4986	5361	}
4987	5362	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)) {
	5363	+ if (ext4_read_bh_lock(journal->j_sb_buffer, REQ_META \| REQ_PRIO, true)) {
4991	5364	ext4_msg(sb, KERN_ERR, "I/O error on journal device");
4992	5365	goto out_journal;
4993	5366	}
..	..	@@ -4997,7 +5370,7 @@
4997	5370	be32_to_cpu(journal->j_superblock->s_nr_users));
4998	5371	goto out_journal;
4999	5372	}
5000		- EXT4_SB(sb)->journal_bdev = bdev;
	5373	+ EXT4_SB(sb)->s_journal_bdev = bdev;
5001	5374	ext4_init_journal_params(sb, journal);
5002	5375	return journal;
5003	5376
..	..	@@ -5323,7 +5696,7 @@
5323	5696	needs_barrier = true;
5324	5697	if (needs_barrier) {
5325	5698	int err;
5326		- err = blkdev_issue_flush(sb->s_bdev, GFP_KERNEL, NULL);
	5699	+ err = blkdev_issue_flush(sb->s_bdev, GFP_KERNEL);
5327	5700	if (!ret)
5328	5701	ret = err;
5329	5702	}
..	..	@@ -5413,11 +5786,11 @@
5413	5786	struct ext4_sb_info *sbi = EXT4_SB(sb);
5414	5787	unsigned long old_sb_flags, vfs_flags;
5415	5788	struct ext4_mount_options old_opts;
5416		- int enable_quota = 0;
5417	5789	ext4_group_t g;
5418	5790	unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
5419	5791	int err = 0;
5420	5792	#ifdef CONFIG_QUOTA
	5793	+ int enable_quota = 0;
5421	5794	int i, j;
5422	5795	char *to_free[EXT4_MAXQUOTAS];
5423	5796	#endif
..	..	@@ -5502,8 +5875,8 @@
5502	5875	goto restore_opts;
5503	5876	}
5504	5877
5505		- if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED)
5506		- ext4_abort(sb, "Abort forced by user");
	5878	+ if (ext4_test_mount_flag(sb, EXT4_MF_FS_ABORTED))
	5879	+ ext4_abort(sb, EXT4_ERR_ESHUTDOWN, "Abort forced by user");
5507	5880
5508	5881	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) \|
5509	5882	(test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
..	..	@@ -5516,7 +5889,7 @@
5516	5889	}
5517	5890
5518	5891	if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
5519		- if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) {
	5892	+ if (ext4_test_mount_flag(sb, EXT4_MF_FS_ABORTED)) {
5520	5893	err = -EROFS;
5521	5894	goto restore_opts;
5522	5895	}
..	..	@@ -5551,8 +5924,6 @@
5551	5924	*/
5552	5925	ext4_mark_recovery_complete(sb, es);
5553	5926	}
5554		- if (sbi->s_mmp_tsk)
5555		- kthread_stop(sbi->s_mmp_tsk);
5556	5927	} else {
5557	5928	/* Make sure we can mount this feature set readwrite */
5558	5929	if (ext4_has_feature_readonly(sb) \|\|
..	..	@@ -5603,22 +5974,59 @@
5603	5974	if (err)
5604	5975	goto restore_opts;
5605	5976	}
5606		- sbi->s_mount_state = le16_to_cpu(es->s_state);
	5977	+ sbi->s_mount_state = (le16_to_cpu(es->s_state) &
	5978	+ ~EXT4_FC_REPLAY);
5607	5979
5608	5980	err = ext4_setup_super(sb, es, 0);
5609	5981	if (err)
5610	5982	goto restore_opts;
5611	5983
5612	5984	sb->s_flags &= ~SB_RDONLY;
5613		- if (ext4_has_feature_mmp(sb))
5614		- if (ext4_multi_mount_protect(sb,
5615		- le64_to_cpu(es->s_mmp_block))) {
5616		- err = -EROFS;
	5985	+ if (ext4_has_feature_mmp(sb)) {
	5986	+ err = ext4_multi_mount_protect(sb,
	5987	+ le64_to_cpu(es->s_mmp_block));
	5988	+ if (err)
5617	5989	goto restore_opts;
5618		- }
	5990	+ }
	5991	+#ifdef CONFIG_QUOTA
5619	5992	enable_quota = 1;
	5993	+#endif
5620	5994	}
5621	5995	}
	5996	+
	5997	+ /*
	5998	+ * Handle creation of system zone data early because it can fail.
	5999	+ * Releasing of existing data is done when we are sure remount will
	6000	+ * succeed.
	6001	+ */
	6002	+ if (test_opt(sb, BLOCK_VALIDITY) && !sbi->s_system_blks) {
	6003	+ err = ext4_setup_system_zone(sb);
	6004	+ if (err)
	6005	+ goto restore_opts;
	6006	+ }
	6007	+
	6008	+ if (sbi->s_journal == NULL && !(old_sb_flags & SB_RDONLY)) {
	6009	+ err = ext4_commit_super(sb, 1);
	6010	+ if (err)
	6011	+ goto restore_opts;
	6012	+ }
	6013	+
	6014	+#ifdef CONFIG_QUOTA
	6015	+ if (enable_quota) {
	6016	+ if (sb_any_quota_suspended(sb))
	6017	+ dquot_resume(sb, -1);
	6018	+ else if (ext4_has_feature_quota(sb)) {
	6019	+ err = ext4_enable_quotas(sb);
	6020	+ if (err)
	6021	+ goto restore_opts;
	6022	+ }
	6023	+ }
	6024	+ /* Release old quota file names */
	6025	+ for (i = 0; i < EXT4_MAXQUOTAS; i++)
	6026	+ kfree(old_opts.s_qf_names[i]);
	6027	+#endif
	6028	+ if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
	6029	+ ext4_release_system_zone(sb);
5622	6030
5623	6031	/*
5624	6032	* Reinitialize lazy itable initialization thread based on
..	..	@@ -5632,39 +6040,8 @@
5632	6040	ext4_register_li_request(sb, first_not_zeroed);
5633	6041	}
5634	6042
5635		- /*
5636		- * Handle creation of system zone data early because it can fail.
5637		- * Releasing of existing data is done when we are sure remount will
5638		- * succeed.
5639		- */
5640		- if (test_opt(sb, BLOCK_VALIDITY) && !sbi->system_blks) {
5641		- err = ext4_setup_system_zone(sb);
5642		- if (err)
5643		- goto restore_opts;
5644		- }
5645		-
5646		- if (sbi->s_journal == NULL && !(old_sb_flags & SB_RDONLY)) {
5647		- err = ext4_commit_super(sb, 1);
5648		- if (err)
5649		- goto restore_opts;
5650		- }
5651		-
5652		-#ifdef CONFIG_QUOTA
5653		- /* Release old quota file names */
5654		- for (i = 0; i < EXT4_MAXQUOTAS; i++)
5655		- kfree(old_opts.s_qf_names[i]);
5656		- if (enable_quota) {
5657		- if (sb_any_quota_suspended(sb))
5658		- dquot_resume(sb, -1);
5659		- else if (ext4_has_feature_quota(sb)) {
5660		- err = ext4_enable_quotas(sb);
5661		- if (err)
5662		- goto restore_opts;
5663		- }
5664		- }
5665		-#endif
5666		- if (!test_opt(sb, BLOCK_VALIDITY) && sbi->system_blks)
5667		- ext4_release_system_zone(sb);
	6043	+ if (!ext4_has_feature_mmp(sb) \|\| sb_rdonly(sb))
	6044	+ ext4_stop_mmpd(sbi);
5668	6045
5669	6046	/*
5670	6047	* Some options can be enabled by ext4 and/or by VFS mount flag
..	..	@@ -5678,6 +6055,13 @@
5678	6055	return 0;
5679	6056
5680	6057	restore_opts:
	6058	+ /*
	6059	+ * If there was a failing r/w to ro transition, we may need to
	6060	+ * re-enable quota
	6061	+ */
	6062	+ if ((sb->s_flags & SB_RDONLY) && !(old_sb_flags & SB_RDONLY) &&
	6063	+ sb_any_quota_suspended(sb))
	6064	+ dquot_resume(sb, -1);
5681	6065	sb->s_flags = old_sb_flags;
5682	6066	sbi->s_mount_opt = old_opts.s_mount_opt;
5683	6067	sbi->s_mount_opt2 = old_opts.s_mount_opt2;
..	..	@@ -5686,7 +6070,7 @@
5686	6070	sbi->s_commit_interval = old_opts.s_commit_interval;
5687	6071	sbi->s_min_batch_time = old_opts.s_min_batch_time;
5688	6072	sbi->s_max_batch_time = old_opts.s_max_batch_time;
5689		- if (!test_opt(sb, BLOCK_VALIDITY) && sbi->system_blks)
	6073	+ if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
5690	6074	ext4_release_system_zone(sb);
5691	6075	#ifdef CONFIG_QUOTA
5692	6076	sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
..	..	@@ -5698,6 +6082,8 @@
5698	6082	for (i = 0; i < EXT4_MAXQUOTAS; i++)
5699	6083	kfree(to_free[i]);
5700	6084	#endif
	6085	+ if (!ext4_has_feature_mmp(sb) \|\| sb_rdonly(sb))
	6086	+ ext4_stop_mmpd(sbi);
5701	6087	kfree(orig_data);
5702	6088	return err;
5703	6089	}
..	..	@@ -5717,9 +6103,10 @@
5717	6103	return PTR_ERR(dquot);
5718	6104	spin_lock(&dquot->dq_dqb_lock);
5719	6105
5720		- limit = (dquot->dq_dqb.dqb_bsoftlimit ?
5721		- dquot->dq_dqb.dqb_bsoftlimit :
5722		- dquot->dq_dqb.dqb_bhardlimit) >> sb->s_blocksize_bits;
	6106	+ limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
	6107	+ dquot->dq_dqb.dqb_bhardlimit);
	6108	+ limit >>= sb->s_blocksize_bits;
	6109	+
5723	6110	if (limit && buf->f_blocks > limit) {
5724	6111	curblock = (dquot->dq_dqb.dqb_curspace +
5725	6112	dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;
..	..	@@ -5729,9 +6116,8 @@
5729	6116	(buf->f_blocks - curblock) : 0;
5730	6117	}
5731	6118
5732		- limit = dquot->dq_dqb.dqb_isoftlimit ?
5733		- dquot->dq_dqb.dqb_isoftlimit :
5734		- dquot->dq_dqb.dqb_ihardlimit;
	6119	+ limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
	6120	+ dquot->dq_dqb.dqb_ihardlimit);
5735	6121	if (limit && buf->f_files > limit) {
5736	6122	buf->f_files = limit;
5737	6123	buf->f_ffree =
..	..	@@ -5774,8 +6160,7 @@
5774	6160	buf->f_namelen = EXT4_NAME_LEN;
5775	6161	fsid = le64_to_cpup((void *)es->s_uuid) ^
5776	6162	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;
	6163	+ buf->f_fsid = u64_to_fsid(fsid);
5779	6164
5780	6165	#ifdef CONFIG_QUOTA
5781	6166	if (ext4_test_inode_flag(dentry->d_inode, EXT4_INODE_PROJINHERIT) &&
..	..	@@ -5871,7 +6256,7 @@
5871	6256	handle_t *handle;
5872	6257
5873	6258	/* Data block + inode block */
5874		- handle = ext4_journal_start(d_inode(sb->s_root), EXT4_HT_QUOTA, 2);
	6259	+ handle = ext4_journal_start_sb(sb, EXT4_HT_QUOTA, 2);
5875	6260	if (IS_ERR(handle))
5876	6261	return PTR_ERR(handle);
5877	6262	ret = dquot_commit_info(sb, type);
..	..	@@ -5975,7 +6360,7 @@
5975	6360	EXT4_I(inode)->i_flags \|= EXT4_NOATIME_FL \| EXT4_IMMUTABLE_FL;
5976	6361	inode_set_flags(inode, S_NOATIME \| S_IMMUTABLE,
5977	6362	S_NOATIME \| S_IMMUTABLE);
5978		- ext4_mark_inode_dirty(handle, inode);
	6363	+ err = ext4_mark_inode_dirty(handle, inode);
5979	6364	ext4_journal_stop(handle);
5980	6365	unlock_inode:
5981	6366	inode_unlock(inode);
..	..	@@ -5986,6 +6371,20 @@
5986	6371	lockdep_set_quota_inode(path->dentry->d_inode,
5987	6372	I_DATA_SEM_NORMAL);
5988	6373	return err;
	6374	+}
	6375	+
	6376	+static inline bool ext4_check_quota_inum(int type, unsigned long qf_inum)
	6377	+{
	6378	+ switch (type) {
	6379	+ case USRQUOTA:
	6380	+ return qf_inum == EXT4_USR_QUOTA_INO;
	6381	+ case GRPQUOTA:
	6382	+ return qf_inum == EXT4_GRP_QUOTA_INO;
	6383	+ case PRJQUOTA:
	6384	+ return qf_inum >= EXT4_GOOD_OLD_FIRST_INO;
	6385	+ default:
	6386	+ BUG();
	6387	+ }
5989	6388	}
5990	6389
5991	6390	static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
..	..	@@ -6004,16 +6403,23 @@
6004	6403	if (!qf_inums[type])
6005	6404	return -EPERM;
6006	6405
	6406	+ if (!ext4_check_quota_inum(type, qf_inums[type])) {
	6407	+ ext4_error(sb, "Bad quota inum: %lu, type: %d",
	6408	+ qf_inums[type], type);
	6409	+ return -EUCLEAN;
	6410	+ }
	6411	+
6007	6412	qf_inode = ext4_iget(sb, qf_inums[type], EXT4_IGET_SPECIAL);
6008	6413	if (IS_ERR(qf_inode)) {
6009		- ext4_error(sb, "Bad quota inode # %lu", qf_inums[type]);
	6414	+ ext4_error(sb, "Bad quota inode: %lu, type: %d",
	6415	+ qf_inums[type], type);
6010	6416	return PTR_ERR(qf_inode);
6011	6417	}
6012	6418
6013	6419	/* Don't account quota for quota files to avoid recursion */
6014	6420	qf_inode->i_flags \|= S_NOQUOTA;
6015	6421	lockdep_set_quota_inode(qf_inode, I_DATA_SEM_QUOTA);
6016		- err = dquot_enable(qf_inode, type, format_id, flags);
	6422	+ err = dquot_load_quota_inode(qf_inode, type, format_id, flags);
6017	6423	if (err)
6018	6424	lockdep_set_quota_inode(qf_inode, I_DATA_SEM_NORMAL);
6019	6425	iput(qf_inode);
..	..	@@ -6045,8 +6451,9 @@
6045	6451	if (err) {
6046	6452	ext4_warning(sb,
6047	6453	"Failed to enable quota tracking "
6048		- "(type=%d, err=%d). Please run "
6049		- "e2fsck to fix.", type, err);
	6454	+ "(type=%d, err=%d, ino=%lu). "
	6455	+ "Please run e2fsck to fix.", type,
	6456	+ err, qf_inums[type]);
6050	6457	for (type--; type >= 0; type--) {
6051	6458	struct inode *inode;
6052	6459
..	..	@@ -6093,12 +6500,14 @@
6093	6500	* this is not a hard failure and quotas are already disabled.
6094	6501	*/
6095	6502	handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
6096		- if (IS_ERR(handle))
	6503	+ if (IS_ERR(handle)) {
	6504	+ err = PTR_ERR(handle);
6097	6505	goto out_unlock;
	6506	+ }
6098	6507	EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL \| EXT4_IMMUTABLE_FL);
6099	6508	inode_set_flags(inode, 0, S_NOATIME \| S_IMMUTABLE);
6100	6509	inode->i_mtime = inode->i_ctime = current_time(inode);
6101		- ext4_mark_inode_dirty(handle, inode);
	6510	+ err = ext4_mark_inode_dirty(handle, inode);
6102	6511	ext4_journal_stop(handle);
6103	6512	out_unlock:
6104	6513	inode_unlock(inode);
..	..	@@ -6156,7 +6565,7 @@
6156	6565	{
6157	6566	struct inode *inode = sb_dqopt(sb)->files[type];
6158	6567	ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
6159		- int err, offset = off & (sb->s_blocksize - 1);
	6568	+ int err = 0, err2 = 0, offset = off & (sb->s_blocksize - 1);
6160	6569	int retries = 0;
6161	6570	struct buffer_head *bh;
6162	6571	handle_t *handle = journal_current_handle();
..	..	@@ -6182,7 +6591,7 @@
6182	6591	bh = ext4_bread(handle, inode, blk,
6183	6592	EXT4_GET_BLOCKS_CREATE \|
6184	6593	EXT4_GET_BLOCKS_METADATA_NOFAIL);
6185		- } while (IS_ERR(bh) && (PTR_ERR(bh) == -ENOSPC) &&
	6594	+ } while (PTR_ERR(bh) == -ENOSPC &&
6186	6595	ext4_should_retry_alloc(inode->i_sb, &retries));
6187	6596	if (IS_ERR(bh))
6188	6597	return PTR_ERR(bh);
..	..	@@ -6204,21 +6613,11 @@
6204	6613	if (inode->i_size < off + len) {
6205	6614	i_size_write(inode, off + len);
6206	6615	EXT4_I(inode)->i_disksize = inode->i_size;
6207		- ext4_mark_inode_dirty(handle, inode);
	6616	+ err2 = ext4_mark_inode_dirty(handle, inode);
	6617	+ if (unlikely(err2 && !err))
	6618	+ err = err2;
6208	6619	}
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);
	6620	+ return err ? err : len;
6222	6621	}
6223	6622	#endif
6224	6623
..	..	@@ -6314,6 +6713,10 @@
6314	6713	if (err)
6315	6714	return err;
6316	6715
	6716	+ err = ext4_init_pending();
	6717	+ if (err)
	6718	+ goto out7;
	6719	+
6317	6720	err = ext4_init_post_read_processing();
6318	6721	if (err)
6319	6722	goto out6;
..	..	@@ -6336,6 +6739,11 @@
6336	6739	err = init_inodecache();
6337	6740	if (err)
6338	6741	goto out1;
	6742	+
	6743	+ err = ext4_fc_init_dentry_cache();
	6744	+ if (err)
	6745	+ goto out05;
	6746	+
6339	6747	register_as_ext3();
6340	6748	register_as_ext2();
6341	6749	err = register_filesystem(&ext4_fs_type);
..	..	@@ -6346,6 +6754,8 @@
6346	6754	out:
6347	6755	unregister_as_ext2();
6348	6756	unregister_as_ext3();
	6757	+ ext4_fc_destroy_dentry_cache();
	6758	+out05:
6349	6759	destroy_inodecache();
6350	6760	out1:
6351	6761	ext4_exit_mballoc();
..	..	@@ -6358,6 +6768,8 @@
6358	6768	out5:
6359	6769	ext4_exit_post_read_processing();
6360	6770	out6:
	6771	+ ext4_exit_pending();
	6772	+out7:
6361	6773	ext4_exit_es();
6362	6774
6363	6775	return err;
..	..	@@ -6369,6 +6781,7 @@
6369	6781	unregister_as_ext2();
6370	6782	unregister_as_ext3();
6371	6783	unregister_filesystem(&ext4_fs_type);
	6784	+ ext4_fc_destroy_dentry_cache();
6372	6785	destroy_inodecache();
6373	6786	ext4_exit_mballoc();
6374	6787	ext4_exit_sysfs();
..	..	@@ -6376,11 +6789,13 @@
6376	6789	ext4_exit_pageio();
6377	6790	ext4_exit_post_read_processing();
6378	6791	ext4_exit_es();
	6792	+ ext4_exit_pending();
6379	6793	}
6380	6794
6381	6795	MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
6382	6796	MODULE_DESCRIPTION("Fourth Extended Filesystem");
6383	6797	MODULE_LICENSE("GPL");
	6798	+MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
6384	6799	MODULE_SOFTDEP("pre: crc32c");
6385	6800	module_init(ext4_init_fs)
6386	6801	module_exit(ext4_exit_fs)