~hc/RK356X_SDK_RELEASE.git

..	..	@@ -66,9 +66,6 @@
66	66	EXPORT_SYMBOL(jbd2_journal_set_triggers);
67	67	EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
68	68	EXPORT_SYMBOL(jbd2_journal_forget);
69		-#if 0
70		-EXPORT_SYMBOL(journal_sync_buffer);
71		-#endif
72	69	EXPORT_SYMBOL(jbd2_journal_flush);
73	70	EXPORT_SYMBOL(jbd2_journal_revoke);
74	71
..	..	@@ -92,16 +89,15 @@
92	89	EXPORT_SYMBOL(jbd2_journal_invalidatepage);
93	90	EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
94	91	EXPORT_SYMBOL(jbd2_journal_force_commit);
95		-EXPORT_SYMBOL(jbd2_journal_inode_add_write);
96		-EXPORT_SYMBOL(jbd2_journal_inode_add_wait);
97	92	EXPORT_SYMBOL(jbd2_journal_inode_ranged_write);
98	93	EXPORT_SYMBOL(jbd2_journal_inode_ranged_wait);
	94	+EXPORT_SYMBOL(jbd2_journal_submit_inode_data_buffers);
	95	+EXPORT_SYMBOL(jbd2_journal_finish_inode_data_buffers);
99	96	EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
100	97	EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
101	98	EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
102	99	EXPORT_SYMBOL(jbd2_inode_cache);
103	100
104		-static void __journal_abort_soft (journal_t *journal, int errno);
105	101	static int jbd2_journal_create_slab(size_t slab_size);
106	102
107	103	#ifdef CONFIG_JBD2_DEBUG
..	..	@@ -144,22 +140,6 @@
144	140	return cpu_to_be32(csum);
145	141	}
146	142
147		-static int jbd2_superblock_csum_verify(journal_t j, journal_superblock_t sb)
148		-{
149		- if (!jbd2_journal_has_csum_v2or3(j))
150		- return 1;
151		-
152		- return sb->s_checksum == jbd2_superblock_csum(j, sb);
153		-}
154		-
155		-static void jbd2_superblock_csum_set(journal_t j, journal_superblock_t sb)
156		-{
157		- if (!jbd2_journal_has_csum_v2or3(j))
158		- return;
159		-
160		- sb->s_checksum = jbd2_superblock_csum(j, sb);
161		-}
162		-
163	143	/*
164	144	* Helper function used to manage commit timeouts
165	145	*/
..	..	@@ -179,7 +159,9 @@
179	159	*
180	160	* 1) COMMIT: Every so often we need to commit the current state of the
181	161	* filesystem to disk. The journal thread is responsible for writing
182		- * all of the metadata buffers to disk.
	162	+ * all of the metadata buffers to disk. If a fast commit is ongoing
	163	+ * journal thread waits until it's done and then continues from
	164	+ * there on.
183	165	*
184	166	* 2) CHECKPOINT: We cannot reuse a used section of the log file until all
185	167	* of the data in that part of the log has been rewritten elsewhere on
..	..	@@ -221,7 +203,7 @@
221	203	if (journal->j_flags & JBD2_UNMOUNT)
222	204	goto end_loop;
223	205
224		- jbd_debug(1, "commit_sequence=%d, commit_request=%d\n",
	206	+ jbd_debug(1, "commit_sequence=%u, commit_request=%u\n",
225	207	journal->j_commit_sequence, journal->j_commit_request);
226	208
227	209	if (journal->j_commit_sequence != journal->j_commit_request) {
..	..	@@ -342,7 +324,7 @@
342	324	* IO is in progress. do_get_write_access() handles this.
343	325	*
344	326	* The function returns a pointer to the buffer_head to be used for IO.
345		- *
	327	+ *
346	328	*
347	329	* Return value:
348	330	* <0: Error
..	..	@@ -384,7 +366,7 @@
384	366	/* keep subsequent assertions sane */
385	367	atomic_set(&new_bh->b_count, 1);
386	368
387		- jbd_lock_bh_state(bh_in);
	369	+ spin_lock(&jh_in->b_state_lock);
388	370	repeat:
389	371	/*
390	372	* If a new transaction has already done a buffer copy-out, then
..	..	@@ -426,13 +408,13 @@
426	408	if (need_copy_out && !done_copy_out) {
427	409	char *tmp;
428	410
429		- jbd_unlock_bh_state(bh_in);
	411	+ spin_unlock(&jh_in->b_state_lock);
430	412	tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
431	413	if (!tmp) {
432	414	brelse(new_bh);
433	415	return -ENOMEM;
434	416	}
435		- jbd_lock_bh_state(bh_in);
	417	+ spin_lock(&jh_in->b_state_lock);
436	418	if (jh_in->b_frozen_data) {
437	419	jbd2_free(tmp, bh_in->b_size);
438	420	goto repeat;
..	..	@@ -485,7 +467,7 @@
485	467	__jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
486	468	spin_unlock(&journal->j_list_lock);
487	469	set_buffer_shadow(bh_in);
488		- jbd_unlock_bh_state(bh_in);
	470	+ spin_unlock(&jh_in->b_state_lock);
489	471
490	472	return do_escape \| (done_copy_out << 1);
491	473	}
..	..	@@ -518,7 +500,7 @@
518	500	*/
519	501
520	502	journal->j_commit_request = target;
521		- jbd_debug(1, "JBD2: requesting commit %d/%d\n",
	503	+ jbd_debug(1, "JBD2: requesting commit %u/%u\n",
522	504	journal->j_commit_request,
523	505	journal->j_commit_sequence);
524	506	journal->j_running_transaction->t_requested = jiffies;
..	..	@@ -531,7 +513,7 @@
531	513	WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n",
532	514	journal->j_commit_request,
533	515	journal->j_commit_sequence,
534		- target, journal->j_running_transaction ?
	516	+ target, journal->j_running_transaction ?
535	517	journal->j_running_transaction->t_tid : 0);
536	518	return 0;
537	519	}
..	..	@@ -584,12 +566,14 @@
584	566	}
585	567
586	568	/**
587		- * Force and wait upon a commit if the calling process is not within
588		- * transaction. This is used for forcing out undo-protected data which contains
589		- * bitmaps, when the fs is running out of space.
	569	+ * jbd2_journal_force_commit_nested - Force and wait upon a commit if the
	570	+ * calling process is not within transaction.
590	571	*
591	572	* @journal: journal to force
592	573	* Returns true if progress was made.
	574	+ *
	575	+ * This is used for forcing out undo-protected data which contains
	576	+ * bitmaps, when the fs is running out of space.
593	577	*/
594	578	int jbd2_journal_force_commit_nested(journal_t *journal)
595	579	{
..	..	@@ -600,7 +584,7 @@
600	584	}
601	585
602	586	/**
603		- * int journal_force_commit() - force any uncommitted transactions
	587	+ * jbd2_journal_force_commit() - force any uncommitted transactions
604	588	* @journal: journal to force
605	589	*
606	590	* Caller want unconditional commit. We can only force the running transaction
..	..	@@ -716,12 +700,12 @@
716	700	#ifdef CONFIG_JBD2_DEBUG
717	701	if (!tid_geq(journal->j_commit_request, tid)) {
718	702	printk(KERN_ERR
719		- "%s: error: j_commit_request=%d, tid=%d\n",
	703	+ "%s: error: j_commit_request=%u, tid=%u\n",
720	704	__func__, journal->j_commit_request, tid);
721	705	}
722	706	#endif
723	707	while (tid_gt(tid, journal->j_commit_sequence)) {
724		- jbd_debug(1, "JBD2: want %d, j_commit_sequence=%d\n",
	708	+ jbd_debug(1, "JBD2: want %u, j_commit_sequence=%u\n",
725	709	tid, journal->j_commit_sequence);
726	710	read_unlock(&journal->j_state_lock);
727	711	wake_up(&journal->j_wait_commit);
..	..	@@ -735,6 +719,85 @@
735	719	err = -EIO;
736	720	return err;
737	721	}
	722	+
	723	+/*
	724	+ * Start a fast commit. If there's an ongoing fast or full commit wait for
	725	+ * it to complete. Returns 0 if a new fast commit was started. Returns -EALREADY
	726	+ * if a fast commit is not needed, either because there's an already a commit
	727	+ * going on or this tid has already been committed. Returns -EINVAL if no jbd2
	728	+ * commit has yet been performed.
	729	+ */
	730	+int jbd2_fc_begin_commit(journal_t *journal, tid_t tid)
	731	+{
	732	+ if (unlikely(is_journal_aborted(journal)))
	733	+ return -EIO;
	734	+ /*
	735	+ * Fast commits only allowed if at least one full commit has
	736	+ * been processed.
	737	+ */
	738	+ if (!journal->j_stats.ts_tid)
	739	+ return -EINVAL;
	740	+
	741	+ write_lock(&journal->j_state_lock);
	742	+ if (tid <= journal->j_commit_sequence) {
	743	+ write_unlock(&journal->j_state_lock);
	744	+ return -EALREADY;
	745	+ }
	746	+
	747	+ if (journal->j_flags & JBD2_FULL_COMMIT_ONGOING \|\|
	748	+ (journal->j_flags & JBD2_FAST_COMMIT_ONGOING)) {
	749	+ DEFINE_WAIT(wait);
	750	+
	751	+ prepare_to_wait(&journal->j_fc_wait, &wait,
	752	+ TASK_UNINTERRUPTIBLE);
	753	+ write_unlock(&journal->j_state_lock);
	754	+ schedule();
	755	+ finish_wait(&journal->j_fc_wait, &wait);
	756	+ return -EALREADY;
	757	+ }
	758	+ journal->j_flags \|= JBD2_FAST_COMMIT_ONGOING;
	759	+ write_unlock(&journal->j_state_lock);
	760	+
	761	+ return 0;
	762	+}
	763	+EXPORT_SYMBOL(jbd2_fc_begin_commit);
	764	+
	765	+/*
	766	+ * Stop a fast commit. If fallback is set, this function starts commit of
	767	+ * TID tid before any other fast commit can start.
	768	+ */
	769	+static int __jbd2_fc_end_commit(journal_t *journal, tid_t tid, bool fallback)
	770	+{
	771	+ if (journal->j_fc_cleanup_callback)
	772	+ journal->j_fc_cleanup_callback(journal, 0);
	773	+ write_lock(&journal->j_state_lock);
	774	+ journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING;
	775	+ if (fallback)
	776	+ journal->j_flags \|= JBD2_FULL_COMMIT_ONGOING;
	777	+ write_unlock(&journal->j_state_lock);
	778	+ wake_up(&journal->j_fc_wait);
	779	+ if (fallback)
	780	+ return jbd2_complete_transaction(journal, tid);
	781	+ return 0;
	782	+}
	783	+
	784	+int jbd2_fc_end_commit(journal_t *journal)
	785	+{
	786	+ return __jbd2_fc_end_commit(journal, 0, false);
	787	+}
	788	+EXPORT_SYMBOL(jbd2_fc_end_commit);
	789	+
	790	+int jbd2_fc_end_commit_fallback(journal_t *journal)
	791	+{
	792	+ tid_t tid;
	793	+
	794	+ read_lock(&journal->j_state_lock);
	795	+ tid = journal->j_running_transaction ?
	796	+ journal->j_running_transaction->t_tid : 0;
	797	+ read_unlock(&journal->j_state_lock);
	798	+ return __jbd2_fc_end_commit(journal, tid, true);
	799	+}
	800	+EXPORT_SYMBOL(jbd2_fc_end_commit_fallback);
738	801
739	802	/* Return 1 when transaction with given tid has already committed. */
740	803	int jbd2_transaction_committed(journal_t *journal, tid_t tid)
..	..	@@ -804,6 +867,106 @@
804	867	return jbd2_journal_bmap(journal, blocknr, retp);
805	868	}
806	869
	870	+/* Map one fast commit buffer for use by the file system */
	871	+int jbd2_fc_get_buf(journal_t journal, struct buffer_head *bh_out)
	872	+{
	873	+ unsigned long long pblock;
	874	+ unsigned long blocknr;
	875	+ int ret = 0;
	876	+ struct buffer_head *bh;
	877	+ int fc_off;
	878	+
	879	+ *bh_out = NULL;
	880	+
	881	+ if (journal->j_fc_off + journal->j_fc_first < journal->j_fc_last) {
	882	+ fc_off = journal->j_fc_off;
	883	+ blocknr = journal->j_fc_first + fc_off;
	884	+ journal->j_fc_off++;
	885	+ } else {
	886	+ ret = -EINVAL;
	887	+ }
	888	+
	889	+ if (ret)
	890	+ return ret;
	891	+
	892	+ ret = jbd2_journal_bmap(journal, blocknr, &pblock);
	893	+ if (ret)
	894	+ return ret;
	895	+
	896	+ bh = __getblk(journal->j_dev, pblock, journal->j_blocksize);
	897	+ if (!bh)
	898	+ return -ENOMEM;
	899	+
	900	+
	901	+ journal->j_fc_wbuf[fc_off] = bh;
	902	+
	903	+ *bh_out = bh;
	904	+
	905	+ return 0;
	906	+}
	907	+EXPORT_SYMBOL(jbd2_fc_get_buf);
	908	+
	909	+/*
	910	+ * Wait on fast commit buffers that were allocated by jbd2_fc_get_buf
	911	+ * for completion.
	912	+ */
	913	+int jbd2_fc_wait_bufs(journal_t *journal, int num_blks)
	914	+{
	915	+ struct buffer_head *bh;
	916	+ int i, j_fc_off;
	917	+
	918	+ j_fc_off = journal->j_fc_off;
	919	+
	920	+ /*
	921	+ * Wait in reverse order to minimize chances of us being woken up before
	922	+ * all IOs have completed
	923	+ */
	924	+ for (i = j_fc_off - 1; i >= j_fc_off - num_blks; i--) {
	925	+ bh = journal->j_fc_wbuf[i];
	926	+ wait_on_buffer(bh);
	927	+ /*
	928	+ * Update j_fc_off so jbd2_fc_release_bufs can release remain
	929	+ * buffer head.
	930	+ */
	931	+ if (unlikely(!buffer_uptodate(bh))) {
	932	+ journal->j_fc_off = i + 1;
	933	+ return -EIO;
	934	+ }
	935	+ put_bh(bh);
	936	+ journal->j_fc_wbuf[i] = NULL;
	937	+ }
	938	+
	939	+ return 0;
	940	+}
	941	+EXPORT_SYMBOL(jbd2_fc_wait_bufs);
	942	+
	943	+/*
	944	+ * Wait on fast commit buffers that were allocated by jbd2_fc_get_buf
	945	+ * for completion.
	946	+ */
	947	+int jbd2_fc_release_bufs(journal_t *journal)
	948	+{
	949	+ struct buffer_head *bh;
	950	+ int i, j_fc_off;
	951	+
	952	+ j_fc_off = journal->j_fc_off;
	953	+
	954	+ /*
	955	+ * Wait in reverse order to minimize chances of us being woken up before
	956	+ * all IOs have completed
	957	+ */
	958	+ for (i = j_fc_off - 1; i >= 0; i--) {
	959	+ bh = journal->j_fc_wbuf[i];
	960	+ if (!bh)
	961	+ break;
	962	+ put_bh(bh);
	963	+ journal->j_fc_wbuf[i] = NULL;
	964	+ }
	965	+
	966	+ return 0;
	967	+}
	968	+EXPORT_SYMBOL(jbd2_fc_release_bufs);
	969	+
807	970	/*
808	971	* Conversion of logical to physical block numbers for the journal
809	972	*
..	..	@@ -816,18 +979,22 @@
816	979	{
817	980	int err = 0;
818	981	unsigned long long ret;
	982	+ sector_t block = 0;
819	983
820	984	if (journal->j_inode) {
821		- ret = bmap(journal->j_inode, blocknr);
822		- if (ret)
823		- *retp = ret;
824		- else {
	985	+ block = blocknr;
	986	+ ret = bmap(journal->j_inode, &block);
	987	+
	988	+ if (ret \|\| !block) {
825	989	printk(KERN_ALERT "%s: journal block not found "
826	990	"at offset %lu on %s\n",
827	991	__func__, blocknr, journal->j_devname);
828	992	err = -EIO;
829		- __journal_abort_soft(journal, err);
	993	+ jbd2_journal_abort(journal, err);
	994	+ } else {
	995	+ *retp = block;
830	996	}
	997	+
831	998	} else {
832	999	retp = blocknr; / +journal->j_blk_offset */
833	1000	}
..	..	@@ -861,6 +1028,7 @@
861	1028	bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
862	1029	if (!bh)
863	1030	return NULL;
	1031	+ atomic_dec(&transaction->t_outstanding_credits);
864	1032	lock_buffer(bh);
865	1033	memset(bh->b_data, 0, journal->j_blocksize);
866	1034	header = (journal_header_t *)bh->b_data;
..	..	@@ -962,7 +1130,7 @@
962	1130
963	1131	trace_jbd2_update_log_tail(journal, tid, block, freed);
964	1132	jbd_debug(1,
965		- "Cleaning journal tail from %d to %d (offset %lu), "
	1133	+ "Cleaning journal tail from %u to %u (offset %lu), "
966	1134	"freeing %lu\n",
967	1135	journal->j_tail_sequence, tid, block, freed);
968	1136
..	..	@@ -1095,12 +1263,11 @@
1095	1263	return seq_release(inode, file);
1096	1264	}
1097	1265
1098		-static const struct file_operations jbd2_seq_info_fops = {
1099		- .owner = THIS_MODULE,
1100		- .open = jbd2_seq_info_open,
1101		- .read = seq_read,
1102		- .llseek = seq_lseek,
1103		- .release = jbd2_seq_info_release,
	1266	+static const struct proc_ops jbd2_info_proc_ops = {
	1267	+ .proc_open = jbd2_seq_info_open,
	1268	+ .proc_read = seq_read,
	1269	+ .proc_lseek = seq_lseek,
	1270	+ .proc_release = jbd2_seq_info_release,
1104	1271	};
1105	1272
1106	1273	static struct proc_dir_entry *proc_jbd2_stats;
..	..	@@ -1110,7 +1277,7 @@
1110	1277	journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
1111	1278	if (journal->j_proc_entry) {
1112	1279	proc_create_data("info", S_IRUGO, journal->j_proc_entry,
1113		- &jbd2_seq_info_fops, journal);
	1280	+ &jbd2_info_proc_ops, journal);
1114	1281	}
1115	1282	}
1116	1283
..	..	@@ -1118,6 +1285,16 @@
1118	1285	{
1119	1286	remove_proc_entry("info", journal->j_proc_entry);
1120	1287	remove_proc_entry(journal->j_devname, proc_jbd2_stats);
	1288	+}
	1289	+
	1290	+/* Minimum size of descriptor tag */
	1291	+static int jbd2_min_tag_size(void)
	1292	+{
	1293	+ /*
	1294	+ * Tag with 32-bit block numbers does not use last four bytes of the
	1295	+ * structure
	1296	+ */
	1297	+ return sizeof(journal_block_tag_t) - 4;
1121	1298	}
1122	1299
1123	1300	/*
..	..	@@ -1148,6 +1325,8 @@
1148	1325	init_waitqueue_head(&journal->j_wait_commit);
1149	1326	init_waitqueue_head(&journal->j_wait_updates);
1150	1327	init_waitqueue_head(&journal->j_wait_reserved);
	1328	+ init_waitqueue_head(&journal->j_fc_wait);
	1329	+ mutex_init(&journal->j_abort_mutex);
1151	1330	mutex_init(&journal->j_barrier);
1152	1331	mutex_init(&journal->j_checkpoint_mutex);
1153	1332	spin_lock_init(&journal->j_revoke_lock);
..	..	@@ -1177,9 +1356,11 @@
1177	1356	journal->j_dev = bdev;
1178	1357	journal->j_fs_dev = fs_dev;
1179	1358	journal->j_blk_offset = start;
1180		- journal->j_maxlen = len;
1181		- n = journal->j_blocksize / sizeof(journal_block_tag_t);
	1359	+ journal->j_total_len = len;
	1360	+ /* We need enough buffers to write out full descriptor block. */
	1361	+ n = journal->j_blocksize / jbd2_min_tag_size();
1182	1362	journal->j_wbufsize = n;
	1363	+ journal->j_fc_wbuf = NULL;
1183	1364	journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *),
1184	1365	GFP_KERNEL);
1185	1366	if (!journal->j_wbuf)
..	..	@@ -1254,11 +1435,14 @@
1254	1435	journal_t jbd2_journal_init_inode(struct inode inode)
1255	1436	{
1256	1437	journal_t *journal;
	1438	+ sector_t blocknr;
1257	1439	char *p;
1258		- unsigned long long blocknr;
	1440	+ int err = 0;
1259	1441
1260		- blocknr = bmap(inode, 0);
1261		- if (!blocknr) {
	1442	+ blocknr = 0;
	1443	+ err = bmap(inode, &blocknr);
	1444	+
	1445	+ if (err \|\| !blocknr) {
1262	1446	pr_err("%s: Cannot locate journal superblock\n",
1263	1447	__func__);
1264	1448	return NULL;
..	..	@@ -1288,7 +1472,7 @@
1288	1472	* superblock as being NULL to prevent the journal destroy from writing
1289	1473	* back a bogus superblock.
1290	1474	*/
1291		-static void journal_fail_superblock (journal_t *journal)
	1475	+static void journal_fail_superblock(journal_t *journal)
1292	1476	{
1293	1477	struct buffer_head *bh = journal->j_sb_buffer;
1294	1478	brelse(bh);
..	..	@@ -1319,15 +1503,22 @@
1319	1503	journal->j_first = first;
1320	1504	journal->j_last = last;
1321	1505
1322		- journal->j_head = first;
1323		- journal->j_tail = first;
1324		- journal->j_free = last - first;
	1506	+ journal->j_head = journal->j_first;
	1507	+ journal->j_tail = journal->j_first;
	1508	+ journal->j_free = journal->j_last - journal->j_first;
1325	1509
1326	1510	journal->j_tail_sequence = journal->j_transaction_sequence;
1327	1511	journal->j_commit_sequence = journal->j_transaction_sequence - 1;
1328	1512	journal->j_commit_request = journal->j_commit_sequence;
1329	1513
1330		- journal->j_max_transaction_buffers = journal->j_maxlen / 4;
	1514	+ journal->j_max_transaction_buffers = jbd2_journal_get_max_txn_bufs(journal);
	1515	+
	1516	+ /*
	1517	+ * Now that journal recovery is done, turn fast commits off here. This
	1518	+ * way, if fast commit was enabled before the crash but if now FS has
	1519	+ * disabled it, we don't enable fast commits.
	1520	+ */
	1521	+ jbd2_clear_feature_fast_commit(journal);
1331	1522
1332	1523	/*
1333	1524	* As a special case, if the on-disk copy is already marked as needing
..	..	@@ -1337,7 +1528,7 @@
1337	1528	*/
1338	1529	if (sb->s_start == 0) {
1339	1530	jbd_debug(1, "JBD2: Skipping superblock update on recovered sb "
1340		- "(start %ld, seq %d, errno %d)\n",
	1531	+ "(start %ld, seq %u, errno %d)\n",
1341	1532	journal->j_tail, journal->j_tail_sequence,
1342	1533	journal->j_errno);
1343	1534	journal->j_flags \|= JBD2_FLUSHED;
..	..	@@ -1393,7 +1584,8 @@
1393	1584	clear_buffer_write_io_error(bh);
1394	1585	set_buffer_uptodate(bh);
1395	1586	}
1396		- jbd2_superblock_csum_set(journal, sb);
	1587	+ if (jbd2_journal_has_csum_v2or3(journal))
	1588	+ sb->s_checksum = jbd2_superblock_csum(journal, sb);
1397	1589	get_bh(bh);
1398	1590	bh->b_end_io = end_buffer_write_sync;
1399	1591	ret = submit_bh(REQ_OP_WRITE, write_flags, bh);
..	..	@@ -1407,7 +1599,8 @@
1407	1599	printk(KERN_ERR "JBD2: Error %d detected when updating "
1408	1600	"journal superblock for %s.\n", ret,
1409	1601	journal->j_devname);
1410		- jbd2_journal_abort(journal, ret);
	1602	+ if (!is_journal_aborted(journal))
	1603	+ jbd2_journal_abort(journal, ret);
1411	1604	}
1412	1605
1413	1606	return ret;
..	..	@@ -1465,6 +1658,7 @@
1465	1658	static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
1466	1659	{
1467	1660	journal_superblock_t *sb = journal->j_superblock;
	1661	+ bool had_fast_commit = false;
1468	1662
1469	1663	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1470	1664	lock_buffer(journal->j_sb_buffer);
..	..	@@ -1473,13 +1667,24 @@
1473	1667	return;
1474	1668	}
1475	1669
1476		- jbd_debug(1, "JBD2: Marking journal as empty (seq %d)\n",
	1670	+ jbd_debug(1, "JBD2: Marking journal as empty (seq %u)\n",
1477	1671	journal->j_tail_sequence);
1478	1672
1479	1673	sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
1480	1674	sb->s_start = cpu_to_be32(0);
	1675	+ if (jbd2_has_feature_fast_commit(journal)) {
	1676	+ /*
	1677	+ * When journal is clean, no need to commit fast commit flag and
	1678	+ * make file system incompatible with older kernels.
	1679	+ */
	1680	+ jbd2_clear_feature_fast_commit(journal);
	1681	+ had_fast_commit = true;
	1682	+ }
1481	1683
1482	1684	jbd2_write_superblock(journal, write_op);
	1685	+
	1686	+ if (had_fast_commit)
	1687	+ jbd2_set_feature_fast_commit(journal);
1483	1688
1484	1689	/* Log is no longer empty */
1485	1690	write_lock(&journal->j_state_lock);
..	..	@@ -1510,6 +1715,21 @@
1510	1715	jbd2_write_superblock(journal, REQ_SYNC \| REQ_FUA);
1511	1716	}
1512	1717	EXPORT_SYMBOL(jbd2_journal_update_sb_errno);
	1718	+
	1719	+static int journal_revoke_records_per_block(journal_t *journal)
	1720	+{
	1721	+ int record_size;
	1722	+ int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t);
	1723	+
	1724	+ if (jbd2_has_feature_64bit(journal))
	1725	+ record_size = 8;
	1726	+ else
	1727	+ record_size = 4;
	1728	+
	1729	+ if (jbd2_journal_has_csum_v2or3(journal))
	1730	+ space -= sizeof(struct jbd2_journal_block_tail);
	1731	+ return space / record_size;
	1732	+}
1513	1733
1514	1734	/*
1515	1735	* Read the superblock for a given journal, performing initial
..	..	@@ -1559,15 +1779,15 @@
1559	1779	goto out;
1560	1780	}
1561	1781
1562		- if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
1563		- journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
1564		- else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
	1782	+ if (be32_to_cpu(sb->s_maxlen) < journal->j_total_len)
	1783	+ journal->j_total_len = be32_to_cpu(sb->s_maxlen);
	1784	+ else if (be32_to_cpu(sb->s_maxlen) > journal->j_total_len) {
1565	1785	printk(KERN_WARNING "JBD2: journal file too short\n");
1566	1786	goto out;
1567	1787	}
1568	1788
1569	1789	if (be32_to_cpu(sb->s_first) == 0 \|\|
1570		- be32_to_cpu(sb->s_first) >= journal->j_maxlen) {
	1790	+ be32_to_cpu(sb->s_first) >= journal->j_total_len) {
1571	1791	printk(KERN_WARNING
1572	1792	"JBD2: Invalid start block of journal: %u\n",
1573	1793	be32_to_cpu(sb->s_first));
..	..	@@ -1606,18 +1826,21 @@
1606	1826	}
1607	1827	}
1608	1828
1609		- /* Check superblock checksum */
1610		- if (!jbd2_superblock_csum_verify(journal, sb)) {
1611		- printk(KERN_ERR "JBD2: journal checksum error\n");
1612		- err = -EFSBADCRC;
1613		- goto out;
1614		- }
	1829	+ if (jbd2_journal_has_csum_v2or3(journal)) {
	1830	+ /* Check superblock checksum */
	1831	+ if (sb->s_checksum != jbd2_superblock_csum(journal, sb)) {
	1832	+ printk(KERN_ERR "JBD2: journal checksum error\n");
	1833	+ err = -EFSBADCRC;
	1834	+ goto out;
	1835	+ }
1615	1836
1616		- /* Precompute checksum seed for all metadata */
1617		- if (jbd2_journal_has_csum_v2or3(journal))
	1837	+ /* Precompute checksum seed for all metadata */
1618	1838	journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
1619	1839	sizeof(sb->s_uuid));
	1840	+ }
1620	1841
	1842	+ journal->j_revoke_records_per_block =
	1843	+ journal_revoke_records_per_block(journal);
1621	1844	set_buffer_verified(bh);
1622	1845
1623	1846	return 0;
..	..	@@ -1636,6 +1859,7 @@
1636	1859	{
1637	1860	int err;
1638	1861	journal_superblock_t *sb;
	1862	+ int num_fc_blocks;
1639	1863
1640	1864	err = journal_get_superblock(journal);
1641	1865	if (err)
..	..	@@ -1646,15 +1870,26 @@
1646	1870	journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
1647	1871	journal->j_tail = be32_to_cpu(sb->s_start);
1648	1872	journal->j_first = be32_to_cpu(sb->s_first);
1649		- journal->j_last = be32_to_cpu(sb->s_maxlen);
1650	1873	journal->j_errno = be32_to_cpu(sb->s_errno);
	1874	+ journal->j_last = be32_to_cpu(sb->s_maxlen);
	1875	+
	1876	+ if (jbd2_has_feature_fast_commit(journal)) {
	1877	+ journal->j_fc_last = be32_to_cpu(sb->s_maxlen);
	1878	+ num_fc_blocks = be32_to_cpu(sb->s_num_fc_blks);
	1879	+ if (!num_fc_blocks)
	1880	+ num_fc_blocks = JBD2_MIN_FC_BLOCKS;
	1881	+ if (journal->j_last - num_fc_blocks >= JBD2_MIN_JOURNAL_BLOCKS)
	1882	+ journal->j_last = journal->j_fc_last - num_fc_blocks;
	1883	+ journal->j_fc_first = journal->j_last + 1;
	1884	+ journal->j_fc_off = 0;
	1885	+ }
1651	1886
1652	1887	return 0;
1653	1888	}
1654	1889
1655	1890
1656	1891	/**
1657		- * int jbd2_journal_load() - Read journal from disk.
	1892	+ * jbd2_journal_load() - Read journal from disk.
1658	1893	* @journal: Journal to act on.
1659	1894	*
1660	1895	* Given a journal_t structure which tells us which disk blocks contain
..	..	@@ -1724,7 +1959,7 @@
1724	1959	}
1725	1960
1726	1961	/**
1727		- * void jbd2_journal_destroy() - Release a journal_t structure.
	1962	+ * jbd2_journal_destroy() - Release a journal_t structure.
1728	1963	* @journal: Journal to act on.
1729	1964	*
1730	1965	* Release a journal_t structure once it is no longer in use by the
..	..	@@ -1792,6 +2027,7 @@
1792	2027	jbd2_journal_destroy_revoke(journal);
1793	2028	if (journal->j_chksum_driver)
1794	2029	crypto_free_shash(journal->j_chksum_driver);
	2030	+ kfree(journal->j_fc_wbuf);
1795	2031	kfree(journal->j_wbuf);
1796	2032	kfree(journal);
1797	2033
..	..	@@ -1800,7 +2036,7 @@
1800	2036
1801	2037
1802	2038	/**
1803		- *int jbd2_journal_check_used_features () - Check if features specified are used.
	2039	+ * jbd2_journal_check_used_features() - Check if features specified are used.
1804	2040	* @journal: Journal to check.
1805	2041	* @compat: bitmask of compatible features
1806	2042	* @ro: bitmask of features that force read-only mount
..	..	@@ -1810,7 +2046,7 @@
1810	2046	* features. Return true (non-zero) if it does.
1811	2047	**/
1812	2048
1813		-int jbd2_journal_check_used_features (journal_t *journal, unsigned long compat,
	2049	+int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat,
1814	2050	unsigned long ro, unsigned long incompat)
1815	2051	{
1816	2052	journal_superblock_t *sb;
..	..	@@ -1835,7 +2071,7 @@
1835	2071	}
1836	2072
1837	2073	/**
1838		- * int jbd2_journal_check_available_features() - Check feature set in journalling layer
	2074	+ * jbd2_journal_check_available_features() - Check feature set in journalling layer
1839	2075	* @journal: Journal to check.
1840	2076	* @compat: bitmask of compatible features
1841	2077	* @ro: bitmask of features that force read-only mount
..	..	@@ -1845,7 +2081,7 @@
1845	2081	* all of a given set of features on this journal. Return true
1846	2082	* (non-zero) if it can. */
1847	2083
1848		-int jbd2_journal_check_available_features (journal_t *journal, unsigned long compat,
	2084	+int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat,
1849	2085	unsigned long ro, unsigned long incompat)
1850	2086	{
1851	2087	if (!compat && !ro && !incompat)
..	..	@@ -1866,8 +2102,39 @@
1866	2102	return 0;
1867	2103	}
1868	2104
	2105	+static int
	2106	+jbd2_journal_initialize_fast_commit(journal_t *journal)
	2107	+{
	2108	+ journal_superblock_t *sb = journal->j_superblock;
	2109	+ unsigned long long num_fc_blks;
	2110	+
	2111	+ num_fc_blks = be32_to_cpu(sb->s_num_fc_blks);
	2112	+ if (num_fc_blks == 0)
	2113	+ num_fc_blks = JBD2_MIN_FC_BLOCKS;
	2114	+ if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS)
	2115	+ return -ENOSPC;
	2116	+
	2117	+ /* Are we called twice? */
	2118	+ WARN_ON(journal->j_fc_wbuf != NULL);
	2119	+ journal->j_fc_wbuf = kmalloc_array(num_fc_blks,
	2120	+ sizeof(struct buffer_head *), GFP_KERNEL);
	2121	+ if (!journal->j_fc_wbuf)
	2122	+ return -ENOMEM;
	2123	+
	2124	+ journal->j_fc_wbufsize = num_fc_blks;
	2125	+ journal->j_fc_last = journal->j_last;
	2126	+ journal->j_last = journal->j_fc_last - num_fc_blks;
	2127	+ journal->j_fc_first = journal->j_last + 1;
	2128	+ journal->j_fc_off = 0;
	2129	+ journal->j_free = journal->j_last - journal->j_first;
	2130	+ journal->j_max_transaction_buffers =
	2131	+ jbd2_journal_get_max_txn_bufs(journal);
	2132	+
	2133	+ return 0;
	2134	+}
	2135	+
1869	2136	/**
1870		- * int jbd2_journal_set_features () - Mark a given journal feature in the superblock
	2137	+ * jbd2_journal_set_features() - Mark a given journal feature in the superblock
1871	2138	* @journal: Journal to act on.
1872	2139	* @compat: bitmask of compatible features
1873	2140	* @ro: bitmask of features that force read-only mount
..	..	@@ -1878,7 +2145,7 @@
1878	2145	*
1879	2146	*/
1880	2147
1881		-int jbd2_journal_set_features (journal_t *journal, unsigned long compat,
	2148	+int jbd2_journal_set_features(journal_t *journal, unsigned long compat,
1882	2149	unsigned long ro, unsigned long incompat)
1883	2150	{
1884	2151	#define INCOMPAT_FEATURE_ON(f) \
..	..	@@ -1908,6 +2175,13 @@
1908	2175	compat, ro, incompat);
1909	2176
1910	2177	sb = journal->j_superblock;
	2178	+
	2179	+ if (incompat & JBD2_FEATURE_INCOMPAT_FAST_COMMIT) {
	2180	+ if (jbd2_journal_initialize_fast_commit(journal)) {
	2181	+ pr_err("JBD2: Cannot enable fast commits.\n");
	2182	+ return 0;
	2183	+ }
	2184	+ }
1911	2185
1912	2186	/* Load the checksum driver if necessary */
1913	2187	if ((journal->j_chksum_driver == NULL) &&
..	..	@@ -1942,6 +2216,8 @@
1942	2216	sb->s_feature_ro_compat \|= cpu_to_be32(ro);
1943	2217	sb->s_feature_incompat \|= cpu_to_be32(incompat);
1944	2218	unlock_buffer(journal->j_sb_buffer);
	2219	+ journal->j_revoke_records_per_block =
	2220	+ journal_revoke_records_per_block(journal);
1945	2221
1946	2222	return 1;
1947	2223	#undef COMPAT_FEATURE_ON
..	..	@@ -1949,7 +2225,7 @@
1949	2225	}
1950	2226
1951	2227	/*
1952		- * jbd2_journal_clear_features () - Clear a given journal feature in the
	2228	+ * jbd2_journal_clear_features() - Clear a given journal feature in the
1953	2229	* superblock
1954	2230	* @journal: Journal to act on.
1955	2231	* @compat: bitmask of compatible features
..	..	@@ -1972,11 +2248,13 @@
1972	2248	sb->s_feature_compat &= ~cpu_to_be32(compat);
1973	2249	sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
1974	2250	sb->s_feature_incompat &= ~cpu_to_be32(incompat);
	2251	+ journal->j_revoke_records_per_block =
	2252	+ journal_revoke_records_per_block(journal);
1975	2253	}
1976	2254	EXPORT_SYMBOL(jbd2_journal_clear_features);
1977	2255
1978	2256	/**
1979		- * int jbd2_journal_flush () - Flush journal
	2257	+ * jbd2_journal_flush() - Flush journal
1980	2258	* @journal: Journal to act on.
1981	2259	*
1982	2260	* Flush all data for a given journal to disk and empty the journal.
..	..	@@ -2051,7 +2329,7 @@
2051	2329	}
2052	2330
2053	2331	/**
2054		- * int jbd2_journal_wipe() - Wipe journal contents
	2332	+ * jbd2_journal_wipe() - Wipe journal contents
2055	2333	* @journal: Journal to act on.
2056	2334	* @write: flag (see below)
2057	2335	*
..	..	@@ -2082,7 +2360,7 @@
2082	2360	err = jbd2_journal_skip_recovery(journal);
2083	2361	if (write) {
2084	2362	/* Lock to make assertions happy... */
2085		- mutex_lock(&journal->j_checkpoint_mutex);
	2363	+ mutex_lock_io(&journal->j_checkpoint_mutex);
2086	2364	jbd2_mark_journal_empty(journal, REQ_SYNC \| REQ_FUA);
2087	2365	mutex_unlock(&journal->j_checkpoint_mutex);
2088	2366	}
..	..	@@ -2091,66 +2369,8 @@
2091	2369	return err;
2092	2370	}
2093	2371
2094		-/*
2095		- * Journal abort has very specific semantics, which we describe
2096		- * for journal abort.
2097		- *
2098		- * Two internal functions, which provide abort to the jbd layer
2099		- * itself are here.
2100		- */
2101		-
2102		-/*
2103		- * Quick version for internal journal use (doesn't lock the journal).
2104		- * Aborts hard --- we mark the abort as occurred, but do _nothing_ else,
2105		- * and don't attempt to make any other journal updates.
2106		- */
2107		-void __jbd2_journal_abort_hard(journal_t *journal)
2108		-{
2109		- transaction_t *transaction;
2110		-
2111		- if (journal->j_flags & JBD2_ABORT)
2112		- return;
2113		-
2114		- printk(KERN_ERR "Aborting journal on device %s.\n",
2115		- journal->j_devname);
2116		-
2117		- write_lock(&journal->j_state_lock);
2118		- journal->j_flags \|= JBD2_ABORT;
2119		- transaction = journal->j_running_transaction;
2120		- if (transaction)
2121		- __jbd2_log_start_commit(journal, transaction->t_tid);
2122		- write_unlock(&journal->j_state_lock);
2123		-}
2124		-
2125		-/* Soft abort: record the abort error status in the journal superblock,
2126		- * but don't do any other IO. */
2127		-static void __journal_abort_soft (journal_t *journal, int errno)
2128		-{
2129		- int old_errno;
2130		-
2131		- write_lock(&journal->j_state_lock);
2132		- old_errno = journal->j_errno;
2133		- if (!journal->j_errno \|\| errno == -ESHUTDOWN)
2134		- journal->j_errno = errno;
2135		-
2136		- if (journal->j_flags & JBD2_ABORT) {
2137		- write_unlock(&journal->j_state_lock);
2138		- if (old_errno != -ESHUTDOWN && errno == -ESHUTDOWN)
2139		- jbd2_journal_update_sb_errno(journal);
2140		- return;
2141		- }
2142		- write_unlock(&journal->j_state_lock);
2143		-
2144		- __jbd2_journal_abort_hard(journal);
2145		-
2146		- jbd2_journal_update_sb_errno(journal);
2147		- write_lock(&journal->j_state_lock);
2148		- journal->j_flags \|= JBD2_REC_ERR;
2149		- write_unlock(&journal->j_state_lock);
2150		-}
2151		-
2152	2372	/**
2153		- * void jbd2_journal_abort () - Shutdown the journal immediately.
	2373	+ * jbd2_journal_abort () - Shutdown the journal immediately.
2154	2374	* @journal: the journal to shutdown.
2155	2375	* @errno: an error number to record in the journal indicating
2156	2376	* the reason for the shutdown.
..	..	@@ -2192,11 +2412,56 @@
2192	2412
2193	2413	void jbd2_journal_abort(journal_t *journal, int errno)
2194	2414	{
2195		- __journal_abort_soft(journal, errno);
	2415	+ transaction_t *transaction;
	2416	+
	2417	+ /*
	2418	+ * Lock the aborting procedure until everything is done, this avoid
	2419	+ * races between filesystem's error handling flow (e.g. ext4_abort()),
	2420	+ * ensure panic after the error info is written into journal's
	2421	+ * superblock.
	2422	+ */
	2423	+ mutex_lock(&journal->j_abort_mutex);
	2424	+ /*
	2425	+ * ESHUTDOWN always takes precedence because a file system check
	2426	+ * caused by any other journal abort error is not required after
	2427	+ * a shutdown triggered.
	2428	+ */
	2429	+ write_lock(&journal->j_state_lock);
	2430	+ if (journal->j_flags & JBD2_ABORT) {
	2431	+ int old_errno = journal->j_errno;
	2432	+
	2433	+ write_unlock(&journal->j_state_lock);
	2434	+ if (old_errno != -ESHUTDOWN && errno == -ESHUTDOWN) {
	2435	+ journal->j_errno = errno;
	2436	+ jbd2_journal_update_sb_errno(journal);
	2437	+ }
	2438	+ mutex_unlock(&journal->j_abort_mutex);
	2439	+ return;
	2440	+ }
	2441	+
	2442	+ /*
	2443	+ * Mark the abort as occurred and start current running transaction
	2444	+ * to release all journaled buffer.
	2445	+ */
	2446	+ pr_err("Aborting journal on device %s.\n", journal->j_devname);
	2447	+
	2448	+ journal->j_flags \|= JBD2_ABORT;
	2449	+ journal->j_errno = errno;
	2450	+ transaction = journal->j_running_transaction;
	2451	+ if (transaction)
	2452	+ __jbd2_log_start_commit(journal, transaction->t_tid);
	2453	+ write_unlock(&journal->j_state_lock);
	2454	+
	2455	+ /*
	2456	+ * Record errno to the journal super block, so that fsck and jbd2
	2457	+ * layer could realise that a filesystem check is needed.
	2458	+ */
	2459	+ jbd2_journal_update_sb_errno(journal);
	2460	+ mutex_unlock(&journal->j_abort_mutex);
2196	2461	}
2197	2462
2198	2463	/**
2199		- * int jbd2_journal_errno () - returns the journal's error state.
	2464	+ * jbd2_journal_errno() - returns the journal's error state.
2200	2465	* @journal: journal to examine.
2201	2466	*
2202	2467	* This is the errno number set with jbd2_journal_abort(), the last
..	..	@@ -2220,7 +2485,7 @@
2220	2485	}
2221	2486
2222	2487	/**
2223		- * int jbd2_journal_clear_err () - clears the journal's error state
	2488	+ * jbd2_journal_clear_err() - clears the journal's error state
2224	2489	* @journal: journal to act on.
2225	2490	*
2226	2491	* An error must be cleared or acked to take a FS out of readonly
..	..	@@ -2240,7 +2505,7 @@
2240	2505	}
2241	2506
2242	2507	/**
2243		- * void jbd2_journal_ack_err() - Ack journal err.
	2508	+ * jbd2_journal_ack_err() - Ack journal err.
2244	2509	* @journal: journal to act on.
2245	2510	*
2246	2511	* An error must be cleared or acked to take a FS out of readonly
..	..	@@ -2428,6 +2693,8 @@
2428	2693	ret = kmem_cache_zalloc(jbd2_journal_head_cache,
2429	2694	GFP_NOFS \| __GFP_NOFAIL);
2430	2695	}
	2696	+ if (ret)
	2697	+ spin_lock_init(&ret->b_state_lock);
2431	2698	return ret;
2432	2699	}
2433	2700
..	..	@@ -2534,12 +2801,12 @@
2534	2801	jbd_unlock_bh_journal_head(bh);
2535	2802	return jh;
2536	2803	}
	2804	+EXPORT_SYMBOL(jbd2_journal_grab_journal_head);
2537	2805
2538	2806	static void __journal_remove_journal_head(struct buffer_head *bh)
2539	2807	{
2540	2808	struct journal_head *jh = bh2jh(bh);
2541	2809
2542		- J_ASSERT_JH(jh, jh->b_jcount >= 0);
2543	2810	J_ASSERT_JH(jh, jh->b_transaction == NULL);
2544	2811	J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2545	2812	J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
..	..	@@ -2547,17 +2814,23 @@
2547	2814	J_ASSERT_BH(bh, buffer_jbd(bh));
2548	2815	J_ASSERT_BH(bh, jh2bh(jh) == bh);
2549	2816	BUFFER_TRACE(bh, "remove journal_head");
2550		- if (jh->b_frozen_data) {
2551		- printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
2552		- jbd2_free(jh->b_frozen_data, bh->b_size);
2553		- }
2554		- if (jh->b_committed_data) {
2555		- printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
2556		- jbd2_free(jh->b_committed_data, bh->b_size);
2557		- }
	2817	+
	2818	+ /* Unlink before dropping the lock */
2558	2819	bh->b_private = NULL;
2559	2820	jh->b_bh = NULL; /* debug, really */
2560	2821	clear_buffer_jbd(bh);
	2822	+}
	2823	+
	2824	+static void journal_release_journal_head(struct journal_head *jh, size_t b_size)
	2825	+{
	2826	+ if (jh->b_frozen_data) {
	2827	+ printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
	2828	+ jbd2_free(jh->b_frozen_data, b_size);
	2829	+ }
	2830	+ if (jh->b_committed_data) {
	2831	+ printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
	2832	+ jbd2_free(jh->b_committed_data, b_size);
	2833	+ }
2561	2834	journal_free_journal_head(jh);
2562	2835	}
2563	2836
..	..	@@ -2575,10 +2848,13 @@
2575	2848	if (!jh->b_jcount) {
2576	2849	__journal_remove_journal_head(bh);
2577	2850	jbd_unlock_bh_journal_head(bh);
	2851	+ journal_release_journal_head(jh, bh->b_size);
2578	2852	__brelse(bh);
2579		- } else
	2853	+ } else {
2580	2854	jbd_unlock_bh_journal_head(bh);
	2855	+ }
2581	2856	}
	2857	+EXPORT_SYMBOL(jbd2_journal_put_journal_head);
2582	2858
2583	2859	/*
2584	2860	* Initialize jbd inode head
..	..	@@ -2744,6 +3020,7 @@
2744	3020	}
2745	3021
2746	3022	MODULE_LICENSE("GPL");
	3023	+MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
2747	3024	module_init(journal_init);
2748	3025	module_exit(journal_exit);
2749	3026