xref: /openbmc/linux/fs/jbd2/journal.c (revision 18dad509)
1f5166768STheodore Ts'o // SPDX-License-Identifier: GPL-2.0+
2470decc6SDave Kleikamp /*
3f7f4bccbSMingming Cao  * linux/fs/jbd2/journal.c
4470decc6SDave Kleikamp  *
5470decc6SDave Kleikamp  * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
6470decc6SDave Kleikamp  *
7470decc6SDave Kleikamp  * Copyright 1998 Red Hat corp --- All Rights Reserved
8470decc6SDave Kleikamp  *
9470decc6SDave Kleikamp  * Generic filesystem journal-writing code; part of the ext2fs
10470decc6SDave Kleikamp  * journaling system.
11470decc6SDave Kleikamp  *
12470decc6SDave Kleikamp  * This file manages journals: areas of disk reserved for logging
13470decc6SDave Kleikamp  * transactional updates.  This includes the kernel journaling thread
14470decc6SDave Kleikamp  * which is responsible for scheduling updates to the log.
15470decc6SDave Kleikamp  *
16470decc6SDave Kleikamp  * We do not actually manage the physical storage of the journal in this
17470decc6SDave Kleikamp  * file: that is left to a per-journal policy function, which allows us
18470decc6SDave Kleikamp  * to store the journal within a filesystem-specified area for ext2
19470decc6SDave Kleikamp  * journaling (ext2 can use a reserved inode for storing the log).
20470decc6SDave Kleikamp  */
21470decc6SDave Kleikamp 
22470decc6SDave Kleikamp #include <linux/module.h>
23470decc6SDave Kleikamp #include <linux/time.h>
24470decc6SDave Kleikamp #include <linux/fs.h>
25f7f4bccbSMingming Cao #include <linux/jbd2.h>
26470decc6SDave Kleikamp #include <linux/errno.h>
27470decc6SDave Kleikamp #include <linux/slab.h>
28470decc6SDave Kleikamp #include <linux/init.h>
29470decc6SDave Kleikamp #include <linux/mm.h>
307dfb7103SNigel Cunningham #include <linux/freezer.h>
31470decc6SDave Kleikamp #include <linux/pagemap.h>
32470decc6SDave Kleikamp #include <linux/kthread.h>
33470decc6SDave Kleikamp #include <linux/poison.h>
34470decc6SDave Kleikamp #include <linux/proc_fs.h>
358e85fb3fSJohann Lombardi #include <linux/seq_file.h>
36c225aa57SSimon Holm Thøgersen #include <linux/math64.h>
37879c5e6bSTheodore Ts'o #include <linux/hash.h>
38d2eecb03STheodore Ts'o #include <linux/log2.h>
39d2eecb03STheodore Ts'o #include <linux/vmalloc.h>
4047def826STheodore Ts'o #include <linux/backing-dev.h>
4139e3ac25SBrian King #include <linux/bitops.h>
42670be5a7STheodore Ts'o #include <linux/ratelimit.h>
43eb52da3fSMichal Hocko #include <linux/sched/mm.h>
44879c5e6bSTheodore Ts'o 
45879c5e6bSTheodore Ts'o #define CREATE_TRACE_POINTS
46879c5e6bSTheodore Ts'o #include <trace/events/jbd2.h>
47470decc6SDave Kleikamp 
487c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
49470decc6SDave Kleikamp #include <asm/page.h>
50470decc6SDave Kleikamp 
51b6e96d00STheodore Ts'o #ifdef CONFIG_JBD2_DEBUG
5268af74e9SJan Kara static ushort jbd2_journal_enable_debug __read_mostly;
53b6e96d00STheodore Ts'o 
54b6e96d00STheodore Ts'o module_param_named(jbd2_debug, jbd2_journal_enable_debug, ushort, 0644);
55b6e96d00STheodore Ts'o MODULE_PARM_DESC(jbd2_debug, "Debugging level for jbd2");
56b6e96d00STheodore Ts'o #endif
57b6e96d00STheodore Ts'o 
58f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_extend);
59f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_stop);
60f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_lock_updates);
61f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_unlock_updates);
62f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_get_write_access);
63f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_get_create_access);
64f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_get_undo_access);
65e06c8227SJoel Becker EXPORT_SYMBOL(jbd2_journal_set_triggers);
66f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
67f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_forget);
68f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_flush);
69f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_revoke);
70470decc6SDave Kleikamp 
71f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_init_dev);
72f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_init_inode);
73f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_check_used_features);
74f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_check_available_features);
75f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_set_features);
76f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_load);
77f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_destroy);
78f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_abort);
79f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_errno);
80f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_ack_err);
81f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_clear_err);
82f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_log_wait_commit);
83f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_start_commit);
84f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_force_commit_nested);
85f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_wipe);
86f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_blocks_per_page);
87ccd16945SMatthew Wilcox (Oracle) EXPORT_SYMBOL(jbd2_journal_invalidate_folio);
88f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
89f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_force_commit);
906ba0e7dcSRoss Zwisler EXPORT_SYMBOL(jbd2_journal_inode_ranged_write);
916ba0e7dcSRoss Zwisler EXPORT_SYMBOL(jbd2_journal_inode_ranged_wait);
92aa3c0c61SMauricio Faria de Oliveira EXPORT_SYMBOL(jbd2_journal_finish_inode_data_buffers);
93c851ed54SJan Kara EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
94c851ed54SJan Kara EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
95c851ed54SJan Kara EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
968aefcd55STheodore Ts'o EXPORT_SYMBOL(jbd2_inode_cache);
97470decc6SDave Kleikamp 
98d2eecb03STheodore Ts'o static int jbd2_journal_create_slab(size_t slab_size);
99470decc6SDave Kleikamp 
100169f1a2aSPaul Gortmaker #ifdef CONFIG_JBD2_DEBUG
101169f1a2aSPaul Gortmaker void __jbd2_debug(int level, const char *file, const char *func,
102169f1a2aSPaul Gortmaker 		  unsigned int line, const char *fmt, ...)
103169f1a2aSPaul Gortmaker {
104169f1a2aSPaul Gortmaker 	struct va_format vaf;
105169f1a2aSPaul Gortmaker 	va_list args;
106169f1a2aSPaul Gortmaker 
107169f1a2aSPaul Gortmaker 	if (level > jbd2_journal_enable_debug)
108169f1a2aSPaul Gortmaker 		return;
109169f1a2aSPaul Gortmaker 	va_start(args, fmt);
110169f1a2aSPaul Gortmaker 	vaf.fmt = fmt;
111169f1a2aSPaul Gortmaker 	vaf.va = &args;
1129196f571SWang Shilong 	printk(KERN_DEBUG "%s: (%s, %u): %pV", file, func, line, &vaf);
113169f1a2aSPaul Gortmaker 	va_end(args);
114169f1a2aSPaul Gortmaker }
115169f1a2aSPaul Gortmaker #endif
116169f1a2aSPaul Gortmaker 
11725ed6e8aSDarrick J. Wong /* Checksumming functions */
11818a6ea1eSDarrick J. Wong static __be32 jbd2_superblock_csum(journal_t *j, journal_superblock_t *sb)
1194fd5ea43SDarrick J. Wong {
12018a6ea1eSDarrick J. Wong 	__u32 csum;
12118a6ea1eSDarrick J. Wong 	__be32 old_csum;
1224fd5ea43SDarrick J. Wong 
1234fd5ea43SDarrick J. Wong 	old_csum = sb->s_checksum;
1244fd5ea43SDarrick J. Wong 	sb->s_checksum = 0;
1254fd5ea43SDarrick J. Wong 	csum = jbd2_chksum(j, ~0, (char *)sb, sizeof(journal_superblock_t));
1264fd5ea43SDarrick J. Wong 	sb->s_checksum = old_csum;
1274fd5ea43SDarrick J. Wong 
1284fd5ea43SDarrick J. Wong 	return cpu_to_be32(csum);
1294fd5ea43SDarrick J. Wong }
1304fd5ea43SDarrick J. Wong 
131470decc6SDave Kleikamp /*
132470decc6SDave Kleikamp  * Helper function used to manage commit timeouts
133470decc6SDave Kleikamp  */
134470decc6SDave Kleikamp 
135e3c95788SKees Cook static void commit_timeout(struct timer_list *t)
136470decc6SDave Kleikamp {
137e3c95788SKees Cook 	journal_t *journal = from_timer(journal, t, j_commit_timer);
138470decc6SDave Kleikamp 
139e3c95788SKees Cook 	wake_up_process(journal->j_task);
140470decc6SDave Kleikamp }
141470decc6SDave Kleikamp 
142470decc6SDave Kleikamp /*
143f7f4bccbSMingming Cao  * kjournald2: The main thread function used to manage a logging device
144470decc6SDave Kleikamp  * journal.
145470decc6SDave Kleikamp  *
146470decc6SDave Kleikamp  * This kernel thread is responsible for two things:
147470decc6SDave Kleikamp  *
148470decc6SDave Kleikamp  * 1) COMMIT:  Every so often we need to commit the current state of the
149470decc6SDave Kleikamp  *    filesystem to disk.  The journal thread is responsible for writing
150ff780b91SHarshad Shirwadkar  *    all of the metadata buffers to disk. If a fast commit is ongoing
151ff780b91SHarshad Shirwadkar  *    journal thread waits until it's done and then continues from
152ff780b91SHarshad Shirwadkar  *    there on.
153470decc6SDave Kleikamp  *
154470decc6SDave Kleikamp  * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
155470decc6SDave Kleikamp  *    of the data in that part of the log has been rewritten elsewhere on
156470decc6SDave Kleikamp  *    the disk.  Flushing these old buffers to reclaim space in the log is
157470decc6SDave Kleikamp  *    known as checkpointing, and this thread is responsible for that job.
158470decc6SDave Kleikamp  */
159470decc6SDave Kleikamp 
160f7f4bccbSMingming Cao static int kjournald2(void *arg)
161470decc6SDave Kleikamp {
162470decc6SDave Kleikamp 	journal_t *journal = arg;
163470decc6SDave Kleikamp 	transaction_t *transaction;
164470decc6SDave Kleikamp 
165470decc6SDave Kleikamp 	/*
166470decc6SDave Kleikamp 	 * Set up an interval timer which can be used to trigger a commit wakeup
167470decc6SDave Kleikamp 	 * after the commit interval expires
168470decc6SDave Kleikamp 	 */
169e3c95788SKees Cook 	timer_setup(&journal->j_commit_timer, commit_timeout, 0);
170470decc6SDave Kleikamp 
17135c80422SNigel Cunningham 	set_freezable();
17235c80422SNigel Cunningham 
173470decc6SDave Kleikamp 	/* Record that the journal thread is running */
174470decc6SDave Kleikamp 	journal->j_task = current;
175470decc6SDave Kleikamp 	wake_up(&journal->j_wait_done_commit);
176470decc6SDave Kleikamp 
177470decc6SDave Kleikamp 	/*
178eb52da3fSMichal Hocko 	 * Make sure that no allocations from this kernel thread will ever
179eb52da3fSMichal Hocko 	 * recurse to the fs layer because we are responsible for the
180eb52da3fSMichal Hocko 	 * transaction commit and any fs involvement might get stuck waiting for
181eb52da3fSMichal Hocko 	 * the trasn. commit.
182eb52da3fSMichal Hocko 	 */
183eb52da3fSMichal Hocko 	memalloc_nofs_save();
184eb52da3fSMichal Hocko 
185eb52da3fSMichal Hocko 	/*
186470decc6SDave Kleikamp 	 * And now, wait forever for commit wakeup events.
187470decc6SDave Kleikamp 	 */
188a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
189470decc6SDave Kleikamp 
190470decc6SDave Kleikamp loop:
191f7f4bccbSMingming Cao 	if (journal->j_flags & JBD2_UNMOUNT)
192470decc6SDave Kleikamp 		goto end_loop;
193470decc6SDave Kleikamp 
194cb3b3bf2SJan Kara 	jbd2_debug(1, "commit_sequence=%u, commit_request=%u\n",
195470decc6SDave Kleikamp 		journal->j_commit_sequence, journal->j_commit_request);
196470decc6SDave Kleikamp 
197470decc6SDave Kleikamp 	if (journal->j_commit_sequence != journal->j_commit_request) {
198cb3b3bf2SJan Kara 		jbd2_debug(1, "OK, requests differ\n");
199a931da6aSTheodore Ts'o 		write_unlock(&journal->j_state_lock);
200470decc6SDave Kleikamp 		del_timer_sync(&journal->j_commit_timer);
201f7f4bccbSMingming Cao 		jbd2_journal_commit_transaction(journal);
202a931da6aSTheodore Ts'o 		write_lock(&journal->j_state_lock);
203470decc6SDave Kleikamp 		goto loop;
204470decc6SDave Kleikamp 	}
205470decc6SDave Kleikamp 
206470decc6SDave Kleikamp 	wake_up(&journal->j_wait_done_commit);
207470decc6SDave Kleikamp 	if (freezing(current)) {
208470decc6SDave Kleikamp 		/*
209470decc6SDave Kleikamp 		 * The simpler the better. Flushing journal isn't a
210470decc6SDave Kleikamp 		 * good idea, because that depends on threads that may
211470decc6SDave Kleikamp 		 * be already stopped.
212470decc6SDave Kleikamp 		 */
213cb3b3bf2SJan Kara 		jbd2_debug(1, "Now suspending kjournald2\n");
214a931da6aSTheodore Ts'o 		write_unlock(&journal->j_state_lock);
215a0acae0eSTejun Heo 		try_to_freeze();
216a931da6aSTheodore Ts'o 		write_lock(&journal->j_state_lock);
217470decc6SDave Kleikamp 	} else {
218470decc6SDave Kleikamp 		/*
219470decc6SDave Kleikamp 		 * We assume on resume that commits are already there,
220470decc6SDave Kleikamp 		 * so we don't sleep
221470decc6SDave Kleikamp 		 */
222470decc6SDave Kleikamp 		DEFINE_WAIT(wait);
223470decc6SDave Kleikamp 		int should_sleep = 1;
224470decc6SDave Kleikamp 
225470decc6SDave Kleikamp 		prepare_to_wait(&journal->j_wait_commit, &wait,
226470decc6SDave Kleikamp 				TASK_INTERRUPTIBLE);
227470decc6SDave Kleikamp 		if (journal->j_commit_sequence != journal->j_commit_request)
228470decc6SDave Kleikamp 			should_sleep = 0;
229470decc6SDave Kleikamp 		transaction = journal->j_running_transaction;
230470decc6SDave Kleikamp 		if (transaction && time_after_eq(jiffies,
231470decc6SDave Kleikamp 						transaction->t_expires))
232470decc6SDave Kleikamp 			should_sleep = 0;
233f7f4bccbSMingming Cao 		if (journal->j_flags & JBD2_UNMOUNT)
234470decc6SDave Kleikamp 			should_sleep = 0;
235470decc6SDave Kleikamp 		if (should_sleep) {
236a931da6aSTheodore Ts'o 			write_unlock(&journal->j_state_lock);
237470decc6SDave Kleikamp 			schedule();
238a931da6aSTheodore Ts'o 			write_lock(&journal->j_state_lock);
239470decc6SDave Kleikamp 		}
240470decc6SDave Kleikamp 		finish_wait(&journal->j_wait_commit, &wait);
241470decc6SDave Kleikamp 	}
242470decc6SDave Kleikamp 
243cb3b3bf2SJan Kara 	jbd2_debug(1, "kjournald2 wakes\n");
244470decc6SDave Kleikamp 
245470decc6SDave Kleikamp 	/*
246470decc6SDave Kleikamp 	 * Were we woken up by a commit wakeup event?
247470decc6SDave Kleikamp 	 */
248470decc6SDave Kleikamp 	transaction = journal->j_running_transaction;
249470decc6SDave Kleikamp 	if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
250470decc6SDave Kleikamp 		journal->j_commit_request = transaction->t_tid;
251cb3b3bf2SJan Kara 		jbd2_debug(1, "woke because of timeout\n");
252470decc6SDave Kleikamp 	}
253470decc6SDave Kleikamp 	goto loop;
254470decc6SDave Kleikamp 
255470decc6SDave Kleikamp end_loop:
256470decc6SDave Kleikamp 	del_timer_sync(&journal->j_commit_timer);
257470decc6SDave Kleikamp 	journal->j_task = NULL;
258470decc6SDave Kleikamp 	wake_up(&journal->j_wait_done_commit);
259cb3b3bf2SJan Kara 	jbd2_debug(1, "Journal thread exiting.\n");
260dbfcef6bSSahitya Tummala 	write_unlock(&journal->j_state_lock);
261470decc6SDave Kleikamp 	return 0;
262470decc6SDave Kleikamp }
263470decc6SDave Kleikamp 
26497f06784SPavel Emelianov static int jbd2_journal_start_thread(journal_t *journal)
265470decc6SDave Kleikamp {
26697f06784SPavel Emelianov 	struct task_struct *t;
26797f06784SPavel Emelianov 
26890576c0bSTheodore Ts'o 	t = kthread_run(kjournald2, journal, "jbd2/%s",
26990576c0bSTheodore Ts'o 			journal->j_devname);
27097f06784SPavel Emelianov 	if (IS_ERR(t))
27197f06784SPavel Emelianov 		return PTR_ERR(t);
27297f06784SPavel Emelianov 
2731076d17aSAl Viro 	wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
27497f06784SPavel Emelianov 	return 0;
275470decc6SDave Kleikamp }
276470decc6SDave Kleikamp 
277470decc6SDave Kleikamp static void journal_kill_thread(journal_t *journal)
278470decc6SDave Kleikamp {
279a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
280f7f4bccbSMingming Cao 	journal->j_flags |= JBD2_UNMOUNT;
281470decc6SDave Kleikamp 
282470decc6SDave Kleikamp 	while (journal->j_task) {
283a931da6aSTheodore Ts'o 		write_unlock(&journal->j_state_lock);
2843469a32aSTheodore Ts'o 		wake_up(&journal->j_wait_commit);
2851076d17aSAl Viro 		wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
286a931da6aSTheodore Ts'o 		write_lock(&journal->j_state_lock);
287470decc6SDave Kleikamp 	}
288a931da6aSTheodore Ts'o 	write_unlock(&journal->j_state_lock);
289470decc6SDave Kleikamp }
290470decc6SDave Kleikamp 
291470decc6SDave Kleikamp /*
292f7f4bccbSMingming Cao  * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal.
293470decc6SDave Kleikamp  *
294470decc6SDave Kleikamp  * Writes a metadata buffer to a given disk block.  The actual IO is not
295470decc6SDave Kleikamp  * performed but a new buffer_head is constructed which labels the data
296470decc6SDave Kleikamp  * to be written with the correct destination disk block.
297470decc6SDave Kleikamp  *
298470decc6SDave Kleikamp  * Any magic-number escaping which needs to be done will cause a
299470decc6SDave Kleikamp  * copy-out here.  If the buffer happens to start with the
300f7f4bccbSMingming Cao  * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the
301470decc6SDave Kleikamp  * magic number is only written to the log for descripter blocks.  In
302470decc6SDave Kleikamp  * this case, we copy the data and replace the first word with 0, and we
303470decc6SDave Kleikamp  * return a result code which indicates that this buffer needs to be
304470decc6SDave Kleikamp  * marked as an escaped buffer in the corresponding log descriptor
305470decc6SDave Kleikamp  * block.  The missing word can then be restored when the block is read
306470decc6SDave Kleikamp  * during recovery.
307470decc6SDave Kleikamp  *
308470decc6SDave Kleikamp  * If the source buffer has already been modified by a new transaction
309470decc6SDave Kleikamp  * since we took the last commit snapshot, we use the frozen copy of
310470decc6SDave Kleikamp  * that data for IO. If we end up using the existing buffer_head's data
311f5113effSJan Kara  * for the write, then we have to make sure nobody modifies it while the
312f5113effSJan Kara  * IO is in progress. do_get_write_access() handles this.
313470decc6SDave Kleikamp  *
314f5113effSJan Kara  * The function returns a pointer to the buffer_head to be used for IO.
315470decc6SDave Kleikamp  *
316470decc6SDave Kleikamp  *
317470decc6SDave Kleikamp  * Return value:
318470decc6SDave Kleikamp  *  <0: Error
319470decc6SDave Kleikamp  * >=0: Finished OK
320470decc6SDave Kleikamp  *
321470decc6SDave Kleikamp  * On success:
322470decc6SDave Kleikamp  * Bit 0 set == escape performed on the data
323470decc6SDave Kleikamp  * Bit 1 set == buffer copy-out performed (kfree the data after IO)
324470decc6SDave Kleikamp  */
325470decc6SDave Kleikamp 
326f7f4bccbSMingming Cao int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
327470decc6SDave Kleikamp 				  struct journal_head  *jh_in,
328f5113effSJan Kara 				  struct buffer_head **bh_out,
329f5113effSJan Kara 				  sector_t blocknr)
330470decc6SDave Kleikamp {
331470decc6SDave Kleikamp 	int need_copy_out = 0;
332470decc6SDave Kleikamp 	int done_copy_out = 0;
333470decc6SDave Kleikamp 	int do_escape = 0;
334470decc6SDave Kleikamp 	char *mapped_data;
335470decc6SDave Kleikamp 	struct buffer_head *new_bh;
336470decc6SDave Kleikamp 	struct page *new_page;
337470decc6SDave Kleikamp 	unsigned int new_offset;
338470decc6SDave Kleikamp 	struct buffer_head *bh_in = jh2bh(jh_in);
33996577c43Sdingdinghua 	journal_t *journal = transaction->t_journal;
340470decc6SDave Kleikamp 
341470decc6SDave Kleikamp 	/*
342470decc6SDave Kleikamp 	 * The buffer really shouldn't be locked: only the current committing
343470decc6SDave Kleikamp 	 * transaction is allowed to write it, so nobody else is allowed
344470decc6SDave Kleikamp 	 * to do any IO.
345470decc6SDave Kleikamp 	 *
346470decc6SDave Kleikamp 	 * akpm: except if we're journalling data, and write() output is
347470decc6SDave Kleikamp 	 * also part of a shared mapping, and another thread has
348470decc6SDave Kleikamp 	 * decided to launch a writepage() against this buffer.
349470decc6SDave Kleikamp 	 */
350470decc6SDave Kleikamp 	J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
351470decc6SDave Kleikamp 
3526ccaf3e2SMichal Hocko 	new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL);
35347def826STheodore Ts'o 
35496577c43Sdingdinghua 	/* keep subsequent assertions sane */
35596577c43Sdingdinghua 	atomic_set(&new_bh->b_count, 1);
356470decc6SDave Kleikamp 
35746417064SThomas Gleixner 	spin_lock(&jh_in->b_state_lock);
358f5113effSJan Kara repeat:
359470decc6SDave Kleikamp 	/*
360470decc6SDave Kleikamp 	 * If a new transaction has already done a buffer copy-out, then
361470decc6SDave Kleikamp 	 * we use that version of the data for the commit.
362470decc6SDave Kleikamp 	 */
363470decc6SDave Kleikamp 	if (jh_in->b_frozen_data) {
364470decc6SDave Kleikamp 		done_copy_out = 1;
365470decc6SDave Kleikamp 		new_page = virt_to_page(jh_in->b_frozen_data);
366470decc6SDave Kleikamp 		new_offset = offset_in_page(jh_in->b_frozen_data);
367470decc6SDave Kleikamp 	} else {
368470decc6SDave Kleikamp 		new_page = jh2bh(jh_in)->b_page;
369470decc6SDave Kleikamp 		new_offset = offset_in_page(jh2bh(jh_in)->b_data);
370470decc6SDave Kleikamp 	}
371470decc6SDave Kleikamp 
372303a8f2aSCong Wang 	mapped_data = kmap_atomic(new_page);
373470decc6SDave Kleikamp 	/*
37413ceef09SJan Kara 	 * Fire data frozen trigger if data already wasn't frozen.  Do this
37513ceef09SJan Kara 	 * before checking for escaping, as the trigger may modify the magic
37613ceef09SJan Kara 	 * offset.  If a copy-out happens afterwards, it will have the correct
37713ceef09SJan Kara 	 * data in the buffer.
378e06c8227SJoel Becker 	 */
37913ceef09SJan Kara 	if (!done_copy_out)
38013ceef09SJan Kara 		jbd2_buffer_frozen_trigger(jh_in, mapped_data + new_offset,
38113ceef09SJan Kara 					   jh_in->b_triggers);
382e06c8227SJoel Becker 
383e06c8227SJoel Becker 	/*
384470decc6SDave Kleikamp 	 * Check for escaping
385470decc6SDave Kleikamp 	 */
386470decc6SDave Kleikamp 	if (*((__be32 *)(mapped_data + new_offset)) ==
387f7f4bccbSMingming Cao 				cpu_to_be32(JBD2_MAGIC_NUMBER)) {
388470decc6SDave Kleikamp 		need_copy_out = 1;
389470decc6SDave Kleikamp 		do_escape = 1;
390470decc6SDave Kleikamp 	}
391303a8f2aSCong Wang 	kunmap_atomic(mapped_data);
392470decc6SDave Kleikamp 
393470decc6SDave Kleikamp 	/*
394470decc6SDave Kleikamp 	 * Do we need to do a data copy?
395470decc6SDave Kleikamp 	 */
396470decc6SDave Kleikamp 	if (need_copy_out && !done_copy_out) {
397470decc6SDave Kleikamp 		char *tmp;
398470decc6SDave Kleikamp 
39946417064SThomas Gleixner 		spin_unlock(&jh_in->b_state_lock);
400af1e76d6SMingming Cao 		tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
401e6ec116bSTheodore Ts'o 		if (!tmp) {
402f5113effSJan Kara 			brelse(new_bh);
403e6ec116bSTheodore Ts'o 			return -ENOMEM;
404e6ec116bSTheodore Ts'o 		}
40546417064SThomas Gleixner 		spin_lock(&jh_in->b_state_lock);
406470decc6SDave Kleikamp 		if (jh_in->b_frozen_data) {
407af1e76d6SMingming Cao 			jbd2_free(tmp, bh_in->b_size);
408470decc6SDave Kleikamp 			goto repeat;
409470decc6SDave Kleikamp 		}
410470decc6SDave Kleikamp 
411470decc6SDave Kleikamp 		jh_in->b_frozen_data = tmp;
412303a8f2aSCong Wang 		mapped_data = kmap_atomic(new_page);
413f5113effSJan Kara 		memcpy(tmp, mapped_data + new_offset, bh_in->b_size);
414303a8f2aSCong Wang 		kunmap_atomic(mapped_data);
415470decc6SDave Kleikamp 
416470decc6SDave Kleikamp 		new_page = virt_to_page(tmp);
417470decc6SDave Kleikamp 		new_offset = offset_in_page(tmp);
418470decc6SDave Kleikamp 		done_copy_out = 1;
419e06c8227SJoel Becker 
420e06c8227SJoel Becker 		/*
421e06c8227SJoel Becker 		 * This isn't strictly necessary, as we're using frozen
422e06c8227SJoel Becker 		 * data for the escaping, but it keeps consistency with
423e06c8227SJoel Becker 		 * b_frozen_data usage.
424e06c8227SJoel Becker 		 */
425e06c8227SJoel Becker 		jh_in->b_frozen_triggers = jh_in->b_triggers;
426470decc6SDave Kleikamp 	}
427470decc6SDave Kleikamp 
428470decc6SDave Kleikamp 	/*
429470decc6SDave Kleikamp 	 * Did we need to do an escaping?  Now we've done all the
430470decc6SDave Kleikamp 	 * copying, we can finally do so.
431470decc6SDave Kleikamp 	 */
432470decc6SDave Kleikamp 	if (do_escape) {
433303a8f2aSCong Wang 		mapped_data = kmap_atomic(new_page);
434470decc6SDave Kleikamp 		*((unsigned int *)(mapped_data + new_offset)) = 0;
435303a8f2aSCong Wang 		kunmap_atomic(mapped_data);
436470decc6SDave Kleikamp 	}
437470decc6SDave Kleikamp 
438470decc6SDave Kleikamp 	set_bh_page(new_bh, new_page, new_offset);
439f5113effSJan Kara 	new_bh->b_size = bh_in->b_size;
440f5113effSJan Kara 	new_bh->b_bdev = journal->j_dev;
441470decc6SDave Kleikamp 	new_bh->b_blocknr = blocknr;
442b34090e5SJan Kara 	new_bh->b_private = bh_in;
443470decc6SDave Kleikamp 	set_buffer_mapped(new_bh);
444470decc6SDave Kleikamp 	set_buffer_dirty(new_bh);
445470decc6SDave Kleikamp 
446f5113effSJan Kara 	*bh_out = new_bh;
447470decc6SDave Kleikamp 
448470decc6SDave Kleikamp 	/*
449470decc6SDave Kleikamp 	 * The to-be-written buffer needs to get moved to the io queue,
450470decc6SDave Kleikamp 	 * and the original buffer whose contents we are shadowing or
451470decc6SDave Kleikamp 	 * copying is moved to the transaction's shadow queue.
452470decc6SDave Kleikamp 	 */
453470decc6SDave Kleikamp 	JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
45496577c43Sdingdinghua 	spin_lock(&journal->j_list_lock);
45596577c43Sdingdinghua 	__jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
45696577c43Sdingdinghua 	spin_unlock(&journal->j_list_lock);
457b34090e5SJan Kara 	set_buffer_shadow(bh_in);
45846417064SThomas Gleixner 	spin_unlock(&jh_in->b_state_lock);
45996577c43Sdingdinghua 
460470decc6SDave Kleikamp 	return do_escape | (done_copy_out << 1);
461470decc6SDave Kleikamp }
462470decc6SDave Kleikamp 
463470decc6SDave Kleikamp /*
464470decc6SDave Kleikamp  * Allocation code for the journal file.  Manage the space left in the
465470decc6SDave Kleikamp  * journal, so that we can begin checkpointing when appropriate.
466470decc6SDave Kleikamp  */
467470decc6SDave Kleikamp 
468470decc6SDave Kleikamp /*
469e4471831STheodore Ts'o  * Called with j_state_lock locked for writing.
470e4471831STheodore Ts'o  * Returns true if a transaction commit was started.
471470decc6SDave Kleikamp  */
472d1324958SJan Kara static int __jbd2_log_start_commit(journal_t *journal, tid_t target)
473470decc6SDave Kleikamp {
474e7b04ac0SEric Sandeen 	/* Return if the txn has already requested to be committed */
475e7b04ac0SEric Sandeen 	if (journal->j_commit_request == target)
476e7b04ac0SEric Sandeen 		return 0;
477e7b04ac0SEric Sandeen 
478470decc6SDave Kleikamp 	/*
479deeeaf13STheodore Ts'o 	 * The only transaction we can possibly wait upon is the
480deeeaf13STheodore Ts'o 	 * currently running transaction (if it exists).  Otherwise,
481deeeaf13STheodore Ts'o 	 * the target tid must be an old one.
482470decc6SDave Kleikamp 	 */
483deeeaf13STheodore Ts'o 	if (journal->j_running_transaction &&
484deeeaf13STheodore Ts'o 	    journal->j_running_transaction->t_tid == target) {
485470decc6SDave Kleikamp 		/*
486bcf3d0bcSAndrea Gelmini 		 * We want a new commit: OK, mark the request and wakeup the
487470decc6SDave Kleikamp 		 * commit thread.  We do _not_ do the commit ourselves.
488470decc6SDave Kleikamp 		 */
489470decc6SDave Kleikamp 
490470decc6SDave Kleikamp 		journal->j_commit_request = target;
491cb3b3bf2SJan Kara 		jbd2_debug(1, "JBD2: requesting commit %u/%u\n",
492470decc6SDave Kleikamp 			  journal->j_commit_request,
493470decc6SDave Kleikamp 			  journal->j_commit_sequence);
4949fff24aaSTheodore Ts'o 		journal->j_running_transaction->t_requested = jiffies;
495470decc6SDave Kleikamp 		wake_up(&journal->j_wait_commit);
496470decc6SDave Kleikamp 		return 1;
497deeeaf13STheodore Ts'o 	} else if (!tid_geq(journal->j_commit_request, target))
498deeeaf13STheodore Ts'o 		/* This should never happen, but if it does, preserve
499deeeaf13STheodore Ts'o 		   the evidence before kjournald goes into a loop and
500deeeaf13STheodore Ts'o 		   increments j_commit_sequence beyond all recognition. */
501f2a44523SEryu Guan 		WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n",
5021be2add6STheodore Ts'o 			  journal->j_commit_request,
5031be2add6STheodore Ts'o 			  journal->j_commit_sequence,
504deeeaf13STheodore Ts'o 			  target, journal->j_running_transaction ?
505deeeaf13STheodore Ts'o 			  journal->j_running_transaction->t_tid : 0);
506470decc6SDave Kleikamp 	return 0;
507470decc6SDave Kleikamp }
508470decc6SDave Kleikamp 
509f7f4bccbSMingming Cao int jbd2_log_start_commit(journal_t *journal, tid_t tid)
510470decc6SDave Kleikamp {
511470decc6SDave Kleikamp 	int ret;
512470decc6SDave Kleikamp 
513a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
514f7f4bccbSMingming Cao 	ret = __jbd2_log_start_commit(journal, tid);
515a931da6aSTheodore Ts'o 	write_unlock(&journal->j_state_lock);
516470decc6SDave Kleikamp 	return ret;
517470decc6SDave Kleikamp }
518470decc6SDave Kleikamp 
519470decc6SDave Kleikamp /*
5209ff86446SDmitry Monakhov  * Force and wait any uncommitted transactions.  We can only force the running
5219ff86446SDmitry Monakhov  * transaction if we don't have an active handle, otherwise, we will deadlock.
5229ff86446SDmitry Monakhov  * Returns: <0 in case of error,
5239ff86446SDmitry Monakhov  *           0 if nothing to commit,
5249ff86446SDmitry Monakhov  *           1 if transaction was successfully committed.
525470decc6SDave Kleikamp  */
5269ff86446SDmitry Monakhov static int __jbd2_journal_force_commit(journal_t *journal)
527470decc6SDave Kleikamp {
528470decc6SDave Kleikamp 	transaction_t *transaction = NULL;
529470decc6SDave Kleikamp 	tid_t tid;
5309ff86446SDmitry Monakhov 	int need_to_start = 0, ret = 0;
531470decc6SDave Kleikamp 
532a931da6aSTheodore Ts'o 	read_lock(&journal->j_state_lock);
533470decc6SDave Kleikamp 	if (journal->j_running_transaction && !current->journal_info) {
534470decc6SDave Kleikamp 		transaction = journal->j_running_transaction;
535e4471831STheodore Ts'o 		if (!tid_geq(journal->j_commit_request, transaction->t_tid))
536e4471831STheodore Ts'o 			need_to_start = 1;
537470decc6SDave Kleikamp 	} else if (journal->j_committing_transaction)
538470decc6SDave Kleikamp 		transaction = journal->j_committing_transaction;
539470decc6SDave Kleikamp 
540470decc6SDave Kleikamp 	if (!transaction) {
5419ff86446SDmitry Monakhov 		/* Nothing to commit */
542a931da6aSTheodore Ts'o 		read_unlock(&journal->j_state_lock);
5439ff86446SDmitry Monakhov 		return 0;
544470decc6SDave Kleikamp 	}
545470decc6SDave Kleikamp 	tid = transaction->t_tid;
546a931da6aSTheodore Ts'o 	read_unlock(&journal->j_state_lock);
547e4471831STheodore Ts'o 	if (need_to_start)
548e4471831STheodore Ts'o 		jbd2_log_start_commit(journal, tid);
5499ff86446SDmitry Monakhov 	ret = jbd2_log_wait_commit(journal, tid);
5509ff86446SDmitry Monakhov 	if (!ret)
5519ff86446SDmitry Monakhov 		ret = 1;
5529ff86446SDmitry Monakhov 
5539ff86446SDmitry Monakhov 	return ret;
5549ff86446SDmitry Monakhov }
5559ff86446SDmitry Monakhov 
5569ff86446SDmitry Monakhov /**
5572bf31d94SMauro Carvalho Chehab  * jbd2_journal_force_commit_nested - Force and wait upon a commit if the
5582bf31d94SMauro Carvalho Chehab  * calling process is not within transaction.
5599ff86446SDmitry Monakhov  *
5609ff86446SDmitry Monakhov  * @journal: journal to force
5619ff86446SDmitry Monakhov  * Returns true if progress was made.
5622bf31d94SMauro Carvalho Chehab  *
5632bf31d94SMauro Carvalho Chehab  * This is used for forcing out undo-protected data which contains
5642bf31d94SMauro Carvalho Chehab  * bitmaps, when the fs is running out of space.
5659ff86446SDmitry Monakhov  */
5669ff86446SDmitry Monakhov int jbd2_journal_force_commit_nested(journal_t *journal)
5679ff86446SDmitry Monakhov {
5689ff86446SDmitry Monakhov 	int ret;
5699ff86446SDmitry Monakhov 
5709ff86446SDmitry Monakhov 	ret = __jbd2_journal_force_commit(journal);
5719ff86446SDmitry Monakhov 	return ret > 0;
5729ff86446SDmitry Monakhov }
5739ff86446SDmitry Monakhov 
5749ff86446SDmitry Monakhov /**
5752bf31d94SMauro Carvalho Chehab  * jbd2_journal_force_commit() - force any uncommitted transactions
5769ff86446SDmitry Monakhov  * @journal: journal to force
5779ff86446SDmitry Monakhov  *
5789ff86446SDmitry Monakhov  * Caller want unconditional commit. We can only force the running transaction
5799ff86446SDmitry Monakhov  * if we don't have an active handle, otherwise, we will deadlock.
5809ff86446SDmitry Monakhov  */
5819ff86446SDmitry Monakhov int jbd2_journal_force_commit(journal_t *journal)
5829ff86446SDmitry Monakhov {
5839ff86446SDmitry Monakhov 	int ret;
5849ff86446SDmitry Monakhov 
5859ff86446SDmitry Monakhov 	J_ASSERT(!current->journal_info);
5869ff86446SDmitry Monakhov 	ret = __jbd2_journal_force_commit(journal);
5879ff86446SDmitry Monakhov 	if (ret > 0)
5889ff86446SDmitry Monakhov 		ret = 0;
5899ff86446SDmitry Monakhov 	return ret;
590470decc6SDave Kleikamp }
591470decc6SDave Kleikamp 
592470decc6SDave Kleikamp /*
593470decc6SDave Kleikamp  * Start a commit of the current running transaction (if any).  Returns true
594c88ccea3SJan Kara  * if a transaction is going to be committed (or is currently already
595c88ccea3SJan Kara  * committing), and fills its tid in at *ptid
596470decc6SDave Kleikamp  */
597f7f4bccbSMingming Cao int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
598470decc6SDave Kleikamp {
599470decc6SDave Kleikamp 	int ret = 0;
600470decc6SDave Kleikamp 
601a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
602470decc6SDave Kleikamp 	if (journal->j_running_transaction) {
603470decc6SDave Kleikamp 		tid_t tid = journal->j_running_transaction->t_tid;
604470decc6SDave Kleikamp 
605c88ccea3SJan Kara 		__jbd2_log_start_commit(journal, tid);
606c88ccea3SJan Kara 		/* There's a running transaction and we've just made sure
607c88ccea3SJan Kara 		 * it's commit has been scheduled. */
608c88ccea3SJan Kara 		if (ptid)
609470decc6SDave Kleikamp 			*ptid = tid;
610c88ccea3SJan Kara 		ret = 1;
611c88ccea3SJan Kara 	} else if (journal->j_committing_transaction) {
612470decc6SDave Kleikamp 		/*
61312810ad7SArtem Bityutskiy 		 * If commit has been started, then we have to wait for
61412810ad7SArtem Bityutskiy 		 * completion of that transaction.
615470decc6SDave Kleikamp 		 */
616c88ccea3SJan Kara 		if (ptid)
617470decc6SDave Kleikamp 			*ptid = journal->j_committing_transaction->t_tid;
618470decc6SDave Kleikamp 		ret = 1;
619470decc6SDave Kleikamp 	}
620a931da6aSTheodore Ts'o 	write_unlock(&journal->j_state_lock);
621470decc6SDave Kleikamp 	return ret;
622470decc6SDave Kleikamp }
623470decc6SDave Kleikamp 
624470decc6SDave Kleikamp /*
625bbd2be36SJan Kara  * Return 1 if a given transaction has not yet sent barrier request
626bbd2be36SJan Kara  * connected with a transaction commit. If 0 is returned, transaction
627bbd2be36SJan Kara  * may or may not have sent the barrier. Used to avoid sending barrier
628bbd2be36SJan Kara  * twice in common cases.
629bbd2be36SJan Kara  */
630bbd2be36SJan Kara int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid)
631bbd2be36SJan Kara {
632bbd2be36SJan Kara 	int ret = 0;
633bbd2be36SJan Kara 	transaction_t *commit_trans;
634bbd2be36SJan Kara 
635bbd2be36SJan Kara 	if (!(journal->j_flags & JBD2_BARRIER))
636bbd2be36SJan Kara 		return 0;
637bbd2be36SJan Kara 	read_lock(&journal->j_state_lock);
638bbd2be36SJan Kara 	/* Transaction already committed? */
639bbd2be36SJan Kara 	if (tid_geq(journal->j_commit_sequence, tid))
640bbd2be36SJan Kara 		goto out;
641bbd2be36SJan Kara 	commit_trans = journal->j_committing_transaction;
642bbd2be36SJan Kara 	if (!commit_trans || commit_trans->t_tid != tid) {
643bbd2be36SJan Kara 		ret = 1;
644bbd2be36SJan Kara 		goto out;
645bbd2be36SJan Kara 	}
646bbd2be36SJan Kara 	/*
647bbd2be36SJan Kara 	 * Transaction is being committed and we already proceeded to
648bbd2be36SJan Kara 	 * submitting a flush to fs partition?
649bbd2be36SJan Kara 	 */
650bbd2be36SJan Kara 	if (journal->j_fs_dev != journal->j_dev) {
651bbd2be36SJan Kara 		if (!commit_trans->t_need_data_flush ||
652bbd2be36SJan Kara 		    commit_trans->t_state >= T_COMMIT_DFLUSH)
653bbd2be36SJan Kara 			goto out;
654bbd2be36SJan Kara 	} else {
655bbd2be36SJan Kara 		if (commit_trans->t_state >= T_COMMIT_JFLUSH)
656bbd2be36SJan Kara 			goto out;
657bbd2be36SJan Kara 	}
658bbd2be36SJan Kara 	ret = 1;
659bbd2be36SJan Kara out:
660bbd2be36SJan Kara 	read_unlock(&journal->j_state_lock);
661bbd2be36SJan Kara 	return ret;
662bbd2be36SJan Kara }
663bbd2be36SJan Kara EXPORT_SYMBOL(jbd2_trans_will_send_data_barrier);
664bbd2be36SJan Kara 
665bbd2be36SJan Kara /*
666470decc6SDave Kleikamp  * Wait for a specified commit to complete.
667470decc6SDave Kleikamp  * The caller may not hold the journal lock.
668470decc6SDave Kleikamp  */
669f7f4bccbSMingming Cao int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
670470decc6SDave Kleikamp {
671470decc6SDave Kleikamp 	int err = 0;
672470decc6SDave Kleikamp 
673c52c47e4SJan Kara 	read_lock(&journal->j_state_lock);
674c52c47e4SJan Kara #ifdef CONFIG_PROVE_LOCKING
675c52c47e4SJan Kara 	/*
676c52c47e4SJan Kara 	 * Some callers make sure transaction is already committing and in that
677c52c47e4SJan Kara 	 * case we cannot block on open handles anymore. So don't warn in that
678c52c47e4SJan Kara 	 * case.
679c52c47e4SJan Kara 	 */
680c52c47e4SJan Kara 	if (tid_gt(tid, journal->j_commit_sequence) &&
681c52c47e4SJan Kara 	    (!journal->j_committing_transaction ||
682c52c47e4SJan Kara 	     journal->j_committing_transaction->t_tid != tid)) {
683c52c47e4SJan Kara 		read_unlock(&journal->j_state_lock);
6841eaa566dSJan Kara 		jbd2_might_wait_for_commit(journal);
685a931da6aSTheodore Ts'o 		read_lock(&journal->j_state_lock);
686c52c47e4SJan Kara 	}
687c52c47e4SJan Kara #endif
688e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG
689470decc6SDave Kleikamp 	if (!tid_geq(journal->j_commit_request, tid)) {
69075685071SJan Kara 		printk(KERN_ERR
6917821ce41SGaowei Pu 		       "%s: error: j_commit_request=%u, tid=%u\n",
692329d291fSHarvey Harrison 		       __func__, journal->j_commit_request, tid);
693470decc6SDave Kleikamp 	}
694470decc6SDave Kleikamp #endif
695470decc6SDave Kleikamp 	while (tid_gt(tid, journal->j_commit_sequence)) {
696cb3b3bf2SJan Kara 		jbd2_debug(1, "JBD2: want %u, j_commit_sequence=%u\n",
697470decc6SDave Kleikamp 				  tid, journal->j_commit_sequence);
698a931da6aSTheodore Ts'o 		read_unlock(&journal->j_state_lock);
6993469a32aSTheodore Ts'o 		wake_up(&journal->j_wait_commit);
700470decc6SDave Kleikamp 		wait_event(journal->j_wait_done_commit,
701470decc6SDave Kleikamp 				!tid_gt(tid, journal->j_commit_sequence));
702a931da6aSTheodore Ts'o 		read_lock(&journal->j_state_lock);
703470decc6SDave Kleikamp 	}
704a931da6aSTheodore Ts'o 	read_unlock(&journal->j_state_lock);
705470decc6SDave Kleikamp 
70675685071SJan Kara 	if (unlikely(is_journal_aborted(journal)))
707470decc6SDave Kleikamp 		err = -EIO;
708470decc6SDave Kleikamp 	return err;
709470decc6SDave Kleikamp }
710470decc6SDave Kleikamp 
711ff780b91SHarshad Shirwadkar /*
712ff780b91SHarshad Shirwadkar  * Start a fast commit. If there's an ongoing fast or full commit wait for
713ff780b91SHarshad Shirwadkar  * it to complete. Returns 0 if a new fast commit was started. Returns -EALREADY
714ff780b91SHarshad Shirwadkar  * if a fast commit is not needed, either because there's an already a commit
715ff780b91SHarshad Shirwadkar  * going on or this tid has already been committed. Returns -EINVAL if no jbd2
716ff780b91SHarshad Shirwadkar  * commit has yet been performed.
717ff780b91SHarshad Shirwadkar  */
718ff780b91SHarshad Shirwadkar int jbd2_fc_begin_commit(journal_t *journal, tid_t tid)
719ff780b91SHarshad Shirwadkar {
72087a144f0SHarshad Shirwadkar 	if (unlikely(is_journal_aborted(journal)))
72187a144f0SHarshad Shirwadkar 		return -EIO;
722ff780b91SHarshad Shirwadkar 	/*
723ff780b91SHarshad Shirwadkar 	 * Fast commits only allowed if at least one full commit has
724ff780b91SHarshad Shirwadkar 	 * been processed.
725ff780b91SHarshad Shirwadkar 	 */
726ff780b91SHarshad Shirwadkar 	if (!journal->j_stats.ts_tid)
727ff780b91SHarshad Shirwadkar 		return -EINVAL;
728ff780b91SHarshad Shirwadkar 
729ff780b91SHarshad Shirwadkar 	write_lock(&journal->j_state_lock);
730480f89d5SHarshad Shirwadkar 	if (tid <= journal->j_commit_sequence) {
731480f89d5SHarshad Shirwadkar 		write_unlock(&journal->j_state_lock);
732480f89d5SHarshad Shirwadkar 		return -EALREADY;
733480f89d5SHarshad Shirwadkar 	}
734480f89d5SHarshad Shirwadkar 
735ff780b91SHarshad Shirwadkar 	if (journal->j_flags & JBD2_FULL_COMMIT_ONGOING ||
736ff780b91SHarshad Shirwadkar 	    (journal->j_flags & JBD2_FAST_COMMIT_ONGOING)) {
737ff780b91SHarshad Shirwadkar 		DEFINE_WAIT(wait);
738ff780b91SHarshad Shirwadkar 
739ff780b91SHarshad Shirwadkar 		prepare_to_wait(&journal->j_fc_wait, &wait,
740ff780b91SHarshad Shirwadkar 				TASK_UNINTERRUPTIBLE);
741ff780b91SHarshad Shirwadkar 		write_unlock(&journal->j_state_lock);
742ff780b91SHarshad Shirwadkar 		schedule();
743ff780b91SHarshad Shirwadkar 		finish_wait(&journal->j_fc_wait, &wait);
744ff780b91SHarshad Shirwadkar 		return -EALREADY;
745ff780b91SHarshad Shirwadkar 	}
746ff780b91SHarshad Shirwadkar 	journal->j_flags |= JBD2_FAST_COMMIT_ONGOING;
747ff780b91SHarshad Shirwadkar 	write_unlock(&journal->j_state_lock);
7482729cfdcSHarshad Shirwadkar 	jbd2_journal_lock_updates(journal);
749ff780b91SHarshad Shirwadkar 
750ff780b91SHarshad Shirwadkar 	return 0;
751ff780b91SHarshad Shirwadkar }
752ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_begin_commit);
753ff780b91SHarshad Shirwadkar 
754ff780b91SHarshad Shirwadkar /*
755ff780b91SHarshad Shirwadkar  * Stop a fast commit. If fallback is set, this function starts commit of
756ff780b91SHarshad Shirwadkar  * TID tid before any other fast commit can start.
757ff780b91SHarshad Shirwadkar  */
758ff780b91SHarshad Shirwadkar static int __jbd2_fc_end_commit(journal_t *journal, tid_t tid, bool fallback)
759ff780b91SHarshad Shirwadkar {
7602729cfdcSHarshad Shirwadkar 	jbd2_journal_unlock_updates(journal);
761ff780b91SHarshad Shirwadkar 	if (journal->j_fc_cleanup_callback)
762e85c81baSXin Yin 		journal->j_fc_cleanup_callback(journal, 0, tid);
763ff780b91SHarshad Shirwadkar 	write_lock(&journal->j_state_lock);
764ff780b91SHarshad Shirwadkar 	journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING;
765ff780b91SHarshad Shirwadkar 	if (fallback)
766ff780b91SHarshad Shirwadkar 		journal->j_flags |= JBD2_FULL_COMMIT_ONGOING;
767ff780b91SHarshad Shirwadkar 	write_unlock(&journal->j_state_lock);
768ff780b91SHarshad Shirwadkar 	wake_up(&journal->j_fc_wait);
769ff780b91SHarshad Shirwadkar 	if (fallback)
770ff780b91SHarshad Shirwadkar 		return jbd2_complete_transaction(journal, tid);
771ff780b91SHarshad Shirwadkar 	return 0;
772ff780b91SHarshad Shirwadkar }
773ff780b91SHarshad Shirwadkar 
774ff780b91SHarshad Shirwadkar int jbd2_fc_end_commit(journal_t *journal)
775ff780b91SHarshad Shirwadkar {
7760bce577bSHarshad Shirwadkar 	return __jbd2_fc_end_commit(journal, 0, false);
777ff780b91SHarshad Shirwadkar }
778ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_end_commit);
779ff780b91SHarshad Shirwadkar 
7800bce577bSHarshad Shirwadkar int jbd2_fc_end_commit_fallback(journal_t *journal)
781ff780b91SHarshad Shirwadkar {
7820bce577bSHarshad Shirwadkar 	tid_t tid;
7830bce577bSHarshad Shirwadkar 
7840bce577bSHarshad Shirwadkar 	read_lock(&journal->j_state_lock);
7850bce577bSHarshad Shirwadkar 	tid = journal->j_running_transaction ?
7860bce577bSHarshad Shirwadkar 		journal->j_running_transaction->t_tid : 0;
7870bce577bSHarshad Shirwadkar 	read_unlock(&journal->j_state_lock);
7880bce577bSHarshad Shirwadkar 	return __jbd2_fc_end_commit(journal, tid, true);
789ff780b91SHarshad Shirwadkar }
790ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_end_commit_fallback);
791ff780b91SHarshad Shirwadkar 
792b8a6176cSJan Kara /* Return 1 when transaction with given tid has already committed. */
793b8a6176cSJan Kara int jbd2_transaction_committed(journal_t *journal, tid_t tid)
794b8a6176cSJan Kara {
795b8a6176cSJan Kara 	int ret = 1;
796b8a6176cSJan Kara 
797b8a6176cSJan Kara 	read_lock(&journal->j_state_lock);
798b8a6176cSJan Kara 	if (journal->j_running_transaction &&
799b8a6176cSJan Kara 	    journal->j_running_transaction->t_tid == tid)
800b8a6176cSJan Kara 		ret = 0;
801b8a6176cSJan Kara 	if (journal->j_committing_transaction &&
802b8a6176cSJan Kara 	    journal->j_committing_transaction->t_tid == tid)
803b8a6176cSJan Kara 		ret = 0;
804b8a6176cSJan Kara 	read_unlock(&journal->j_state_lock);
805b8a6176cSJan Kara 	return ret;
806b8a6176cSJan Kara }
807b8a6176cSJan Kara EXPORT_SYMBOL(jbd2_transaction_committed);
808b8a6176cSJan Kara 
809470decc6SDave Kleikamp /*
810d76a3a77STheodore Ts'o  * When this function returns the transaction corresponding to tid
811d76a3a77STheodore Ts'o  * will be completed.  If the transaction has currently running, start
812d76a3a77STheodore Ts'o  * committing that transaction before waiting for it to complete.  If
813d76a3a77STheodore Ts'o  * the transaction id is stale, it is by definition already completed,
814d76a3a77STheodore Ts'o  * so just return SUCCESS.
815d76a3a77STheodore Ts'o  */
816d76a3a77STheodore Ts'o int jbd2_complete_transaction(journal_t *journal, tid_t tid)
817d76a3a77STheodore Ts'o {
818d76a3a77STheodore Ts'o 	int	need_to_wait = 1;
819d76a3a77STheodore Ts'o 
820d76a3a77STheodore Ts'o 	read_lock(&journal->j_state_lock);
821d76a3a77STheodore Ts'o 	if (journal->j_running_transaction &&
822d76a3a77STheodore Ts'o 	    journal->j_running_transaction->t_tid == tid) {
823d76a3a77STheodore Ts'o 		if (journal->j_commit_request != tid) {
824d76a3a77STheodore Ts'o 			/* transaction not yet started, so request it */
825d76a3a77STheodore Ts'o 			read_unlock(&journal->j_state_lock);
826d76a3a77STheodore Ts'o 			jbd2_log_start_commit(journal, tid);
827d76a3a77STheodore Ts'o 			goto wait_commit;
828d76a3a77STheodore Ts'o 		}
829d76a3a77STheodore Ts'o 	} else if (!(journal->j_committing_transaction &&
830d76a3a77STheodore Ts'o 		     journal->j_committing_transaction->t_tid == tid))
831d76a3a77STheodore Ts'o 		need_to_wait = 0;
832d76a3a77STheodore Ts'o 	read_unlock(&journal->j_state_lock);
833d76a3a77STheodore Ts'o 	if (!need_to_wait)
834d76a3a77STheodore Ts'o 		return 0;
835d76a3a77STheodore Ts'o wait_commit:
836d76a3a77STheodore Ts'o 	return jbd2_log_wait_commit(journal, tid);
837d76a3a77STheodore Ts'o }
838d76a3a77STheodore Ts'o EXPORT_SYMBOL(jbd2_complete_transaction);
839d76a3a77STheodore Ts'o 
840d76a3a77STheodore Ts'o /*
841470decc6SDave Kleikamp  * Log buffer allocation routines:
842470decc6SDave Kleikamp  */
843470decc6SDave Kleikamp 
84418eba7aaSMingming Cao int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
845470decc6SDave Kleikamp {
846470decc6SDave Kleikamp 	unsigned long blocknr;
847470decc6SDave Kleikamp 
848a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
849470decc6SDave Kleikamp 	J_ASSERT(journal->j_free > 1);
850470decc6SDave Kleikamp 
851470decc6SDave Kleikamp 	blocknr = journal->j_head;
852470decc6SDave Kleikamp 	journal->j_head++;
853470decc6SDave Kleikamp 	journal->j_free--;
854470decc6SDave Kleikamp 	if (journal->j_head == journal->j_last)
855470decc6SDave Kleikamp 		journal->j_head = journal->j_first;
856a931da6aSTheodore Ts'o 	write_unlock(&journal->j_state_lock);
857f7f4bccbSMingming Cao 	return jbd2_journal_bmap(journal, blocknr, retp);
858470decc6SDave Kleikamp }
859470decc6SDave Kleikamp 
860ff780b91SHarshad Shirwadkar /* Map one fast commit buffer for use by the file system */
861ff780b91SHarshad Shirwadkar int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out)
862ff780b91SHarshad Shirwadkar {
863ff780b91SHarshad Shirwadkar 	unsigned long long pblock;
864ff780b91SHarshad Shirwadkar 	unsigned long blocknr;
865ff780b91SHarshad Shirwadkar 	int ret = 0;
866ff780b91SHarshad Shirwadkar 	struct buffer_head *bh;
867ff780b91SHarshad Shirwadkar 	int fc_off;
868ff780b91SHarshad Shirwadkar 
869ff780b91SHarshad Shirwadkar 	*bh_out = NULL;
870ff780b91SHarshad Shirwadkar 
871ff780b91SHarshad Shirwadkar 	if (journal->j_fc_off + journal->j_fc_first < journal->j_fc_last) {
872ff780b91SHarshad Shirwadkar 		fc_off = journal->j_fc_off;
873ff780b91SHarshad Shirwadkar 		blocknr = journal->j_fc_first + fc_off;
874ff780b91SHarshad Shirwadkar 		journal->j_fc_off++;
875ff780b91SHarshad Shirwadkar 	} else {
876ff780b91SHarshad Shirwadkar 		ret = -EINVAL;
877ff780b91SHarshad Shirwadkar 	}
878ff780b91SHarshad Shirwadkar 
879ff780b91SHarshad Shirwadkar 	if (ret)
880ff780b91SHarshad Shirwadkar 		return ret;
881ff780b91SHarshad Shirwadkar 
882ff780b91SHarshad Shirwadkar 	ret = jbd2_journal_bmap(journal, blocknr, &pblock);
883ff780b91SHarshad Shirwadkar 	if (ret)
884ff780b91SHarshad Shirwadkar 		return ret;
885ff780b91SHarshad Shirwadkar 
886ff780b91SHarshad Shirwadkar 	bh = __getblk(journal->j_dev, pblock, journal->j_blocksize);
887ff780b91SHarshad Shirwadkar 	if (!bh)
888ff780b91SHarshad Shirwadkar 		return -ENOMEM;
889ff780b91SHarshad Shirwadkar 
890ff780b91SHarshad Shirwadkar 
891ff780b91SHarshad Shirwadkar 	journal->j_fc_wbuf[fc_off] = bh;
892ff780b91SHarshad Shirwadkar 
893ff780b91SHarshad Shirwadkar 	*bh_out = bh;
894ff780b91SHarshad Shirwadkar 
895ff780b91SHarshad Shirwadkar 	return 0;
896ff780b91SHarshad Shirwadkar }
897ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_get_buf);
898ff780b91SHarshad Shirwadkar 
899ff780b91SHarshad Shirwadkar /*
900ff780b91SHarshad Shirwadkar  * Wait on fast commit buffers that were allocated by jbd2_fc_get_buf
901ff780b91SHarshad Shirwadkar  * for completion.
902ff780b91SHarshad Shirwadkar  */
903ff780b91SHarshad Shirwadkar int jbd2_fc_wait_bufs(journal_t *journal, int num_blks)
904ff780b91SHarshad Shirwadkar {
905ff780b91SHarshad Shirwadkar 	struct buffer_head *bh;
906ff780b91SHarshad Shirwadkar 	int i, j_fc_off;
907ff780b91SHarshad Shirwadkar 
908ff780b91SHarshad Shirwadkar 	j_fc_off = journal->j_fc_off;
909ff780b91SHarshad Shirwadkar 
910ff780b91SHarshad Shirwadkar 	/*
911ff780b91SHarshad Shirwadkar 	 * Wait in reverse order to minimize chances of us being woken up before
912ff780b91SHarshad Shirwadkar 	 * all IOs have completed
913ff780b91SHarshad Shirwadkar 	 */
914ff780b91SHarshad Shirwadkar 	for (i = j_fc_off - 1; i >= j_fc_off - num_blks; i--) {
915ff780b91SHarshad Shirwadkar 		bh = journal->j_fc_wbuf[i];
916ff780b91SHarshad Shirwadkar 		wait_on_buffer(bh);
917e0d5fc7aSYe Bin 		/*
918e0d5fc7aSYe Bin 		 * Update j_fc_off so jbd2_fc_release_bufs can release remain
919e0d5fc7aSYe Bin 		 * buffer head.
920e0d5fc7aSYe Bin 		 */
921e0d5fc7aSYe Bin 		if (unlikely(!buffer_uptodate(bh))) {
922243d1a5dSYe Bin 			journal->j_fc_off = i + 1;
923ff780b91SHarshad Shirwadkar 			return -EIO;
924ff780b91SHarshad Shirwadkar 		}
925243d1a5dSYe Bin 		put_bh(bh);
926243d1a5dSYe Bin 		journal->j_fc_wbuf[i] = NULL;
927e0d5fc7aSYe Bin 	}
928ff780b91SHarshad Shirwadkar 
929ff780b91SHarshad Shirwadkar 	return 0;
930ff780b91SHarshad Shirwadkar }
931ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_wait_bufs);
932ff780b91SHarshad Shirwadkar 
933ff780b91SHarshad Shirwadkar int jbd2_fc_release_bufs(journal_t *journal)
934ff780b91SHarshad Shirwadkar {
935ff780b91SHarshad Shirwadkar 	struct buffer_head *bh;
936ff780b91SHarshad Shirwadkar 	int i, j_fc_off;
937ff780b91SHarshad Shirwadkar 
938ff780b91SHarshad Shirwadkar 	j_fc_off = journal->j_fc_off;
939ff780b91SHarshad Shirwadkar 
940ff780b91SHarshad Shirwadkar 	for (i = j_fc_off - 1; i >= 0; i--) {
941ff780b91SHarshad Shirwadkar 		bh = journal->j_fc_wbuf[i];
942ff780b91SHarshad Shirwadkar 		if (!bh)
943ff780b91SHarshad Shirwadkar 			break;
944ff780b91SHarshad Shirwadkar 		put_bh(bh);
945ff780b91SHarshad Shirwadkar 		journal->j_fc_wbuf[i] = NULL;
946ff780b91SHarshad Shirwadkar 	}
947ff780b91SHarshad Shirwadkar 
948ff780b91SHarshad Shirwadkar 	return 0;
949ff780b91SHarshad Shirwadkar }
950ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_release_bufs);
951ff780b91SHarshad Shirwadkar 
952470decc6SDave Kleikamp /*
953470decc6SDave Kleikamp  * Conversion of logical to physical block numbers for the journal
954470decc6SDave Kleikamp  *
955470decc6SDave Kleikamp  * On external journals the journal blocks are identity-mapped, so
956470decc6SDave Kleikamp  * this is a no-op.  If needed, we can use j_blk_offset - everything is
957470decc6SDave Kleikamp  * ready.
958470decc6SDave Kleikamp  */
959f7f4bccbSMingming Cao int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
96018eba7aaSMingming Cao 		 unsigned long long *retp)
961470decc6SDave Kleikamp {
962470decc6SDave Kleikamp 	int err = 0;
96318eba7aaSMingming Cao 	unsigned long long ret;
96462913ae9STheodore Ts'o 	sector_t block = blocknr;
965470decc6SDave Kleikamp 
96662913ae9STheodore Ts'o 	if (journal->j_bmap) {
96762913ae9STheodore Ts'o 		err = journal->j_bmap(journal, &block);
96862913ae9STheodore Ts'o 		if (err == 0)
96962913ae9STheodore Ts'o 			*retp = block;
97062913ae9STheodore Ts'o 	} else if (journal->j_inode) {
97130460e1eSCarlos Maiolino 		ret = bmap(journal->j_inode, &block);
97230460e1eSCarlos Maiolino 
97330460e1eSCarlos Maiolino 		if (ret || !block) {
974470decc6SDave Kleikamp 			printk(KERN_ALERT "%s: journal block not found "
975470decc6SDave Kleikamp 					"at offset %lu on %s\n",
97605496769STheodore Ts'o 			       __func__, blocknr, journal->j_devname);
977470decc6SDave Kleikamp 			err = -EIO;
9787f6225e4Szhangyi (F) 			jbd2_journal_abort(journal, err);
97930460e1eSCarlos Maiolino 		} else {
98030460e1eSCarlos Maiolino 			*retp = block;
981470decc6SDave Kleikamp 		}
98230460e1eSCarlos Maiolino 
983470decc6SDave Kleikamp 	} else {
984470decc6SDave Kleikamp 		*retp = blocknr; /* +journal->j_blk_offset */
985470decc6SDave Kleikamp 	}
986470decc6SDave Kleikamp 	return err;
987470decc6SDave Kleikamp }
988470decc6SDave Kleikamp 
989470decc6SDave Kleikamp /*
990470decc6SDave Kleikamp  * We play buffer_head aliasing tricks to write data/metadata blocks to
991470decc6SDave Kleikamp  * the journal without copying their contents, but for journal
992470decc6SDave Kleikamp  * descriptor blocks we do need to generate bona fide buffers.
993470decc6SDave Kleikamp  *
994f7f4bccbSMingming Cao  * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying
995470decc6SDave Kleikamp  * the buffer's contents they really should run flush_dcache_page(bh->b_page).
996470decc6SDave Kleikamp  * But we don't bother doing that, so there will be coherency problems with
997470decc6SDave Kleikamp  * mmaps of blockdevs which hold live JBD-controlled filesystems.
998470decc6SDave Kleikamp  */
99932ab6715SJan Kara struct buffer_head *
100032ab6715SJan Kara jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type)
1001470decc6SDave Kleikamp {
100232ab6715SJan Kara 	journal_t *journal = transaction->t_journal;
1003470decc6SDave Kleikamp 	struct buffer_head *bh;
100418eba7aaSMingming Cao 	unsigned long long blocknr;
100532ab6715SJan Kara 	journal_header_t *header;
1006470decc6SDave Kleikamp 	int err;
1007470decc6SDave Kleikamp 
1008f7f4bccbSMingming Cao 	err = jbd2_journal_next_log_block(journal, &blocknr);
1009470decc6SDave Kleikamp 
1010470decc6SDave Kleikamp 	if (err)
1011470decc6SDave Kleikamp 		return NULL;
1012470decc6SDave Kleikamp 
1013470decc6SDave Kleikamp 	bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
10144b905671SJan Kara 	if (!bh)
10154b905671SJan Kara 		return NULL;
10169f356e5aSJan Kara 	atomic_dec(&transaction->t_outstanding_credits);
1017470decc6SDave Kleikamp 	lock_buffer(bh);
1018470decc6SDave Kleikamp 	memset(bh->b_data, 0, journal->j_blocksize);
101932ab6715SJan Kara 	header = (journal_header_t *)bh->b_data;
102032ab6715SJan Kara 	header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
102132ab6715SJan Kara 	header->h_blocktype = cpu_to_be32(type);
102232ab6715SJan Kara 	header->h_sequence = cpu_to_be32(transaction->t_tid);
1023470decc6SDave Kleikamp 	set_buffer_uptodate(bh);
1024470decc6SDave Kleikamp 	unlock_buffer(bh);
1025470decc6SDave Kleikamp 	BUFFER_TRACE(bh, "return this buffer");
1026e5a120aeSJan Kara 	return bh;
1027470decc6SDave Kleikamp }
1028470decc6SDave Kleikamp 
10291101cd4dSJan Kara void jbd2_descriptor_block_csum_set(journal_t *j, struct buffer_head *bh)
10301101cd4dSJan Kara {
10311101cd4dSJan Kara 	struct jbd2_journal_block_tail *tail;
10321101cd4dSJan Kara 	__u32 csum;
10331101cd4dSJan Kara 
10341101cd4dSJan Kara 	if (!jbd2_journal_has_csum_v2or3(j))
10351101cd4dSJan Kara 		return;
10361101cd4dSJan Kara 
10371101cd4dSJan Kara 	tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize -
10381101cd4dSJan Kara 			sizeof(struct jbd2_journal_block_tail));
10391101cd4dSJan Kara 	tail->t_checksum = 0;
10401101cd4dSJan Kara 	csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
10411101cd4dSJan Kara 	tail->t_checksum = cpu_to_be32(csum);
10421101cd4dSJan Kara }
10431101cd4dSJan Kara 
104479feb521SJan Kara /*
104579feb521SJan Kara  * Return tid of the oldest transaction in the journal and block in the journal
104679feb521SJan Kara  * where the transaction starts.
104779feb521SJan Kara  *
104879feb521SJan Kara  * If the journal is now empty, return which will be the next transaction ID
104979feb521SJan Kara  * we will write and where will that transaction start.
105079feb521SJan Kara  *
105179feb521SJan Kara  * The return value is 0 if journal tail cannot be pushed any further, 1 if
105279feb521SJan Kara  * it can.
105379feb521SJan Kara  */
105479feb521SJan Kara int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
105579feb521SJan Kara 			      unsigned long *block)
105679feb521SJan Kara {
105779feb521SJan Kara 	transaction_t *transaction;
105879feb521SJan Kara 	int ret;
105979feb521SJan Kara 
106079feb521SJan Kara 	read_lock(&journal->j_state_lock);
106179feb521SJan Kara 	spin_lock(&journal->j_list_lock);
106279feb521SJan Kara 	transaction = journal->j_checkpoint_transactions;
106379feb521SJan Kara 	if (transaction) {
106479feb521SJan Kara 		*tid = transaction->t_tid;
106579feb521SJan Kara 		*block = transaction->t_log_start;
106679feb521SJan Kara 	} else if ((transaction = journal->j_committing_transaction) != NULL) {
106779feb521SJan Kara 		*tid = transaction->t_tid;
106879feb521SJan Kara 		*block = transaction->t_log_start;
106979feb521SJan Kara 	} else if ((transaction = journal->j_running_transaction) != NULL) {
107079feb521SJan Kara 		*tid = transaction->t_tid;
107179feb521SJan Kara 		*block = journal->j_head;
107279feb521SJan Kara 	} else {
107379feb521SJan Kara 		*tid = journal->j_transaction_sequence;
107479feb521SJan Kara 		*block = journal->j_head;
107579feb521SJan Kara 	}
107679feb521SJan Kara 	ret = tid_gt(*tid, journal->j_tail_sequence);
107779feb521SJan Kara 	spin_unlock(&journal->j_list_lock);
107879feb521SJan Kara 	read_unlock(&journal->j_state_lock);
107979feb521SJan Kara 
108079feb521SJan Kara 	return ret;
108179feb521SJan Kara }
108279feb521SJan Kara 
108379feb521SJan Kara /*
108479feb521SJan Kara  * Update information in journal structure and in on disk journal superblock
108579feb521SJan Kara  * about log tail. This function does not check whether information passed in
108679feb521SJan Kara  * really pushes log tail further. It's responsibility of the caller to make
108779feb521SJan Kara  * sure provided log tail information is valid (e.g. by holding
108879feb521SJan Kara  * j_checkpoint_mutex all the time between computing log tail and calling this
108979feb521SJan Kara  * function as is the case with jbd2_cleanup_journal_tail()).
109079feb521SJan Kara  *
109179feb521SJan Kara  * Requires j_checkpoint_mutex
109279feb521SJan Kara  */
10936f6a6fdaSJoseph Qi int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
109479feb521SJan Kara {
109579feb521SJan Kara 	unsigned long freed;
10966f6a6fdaSJoseph Qi 	int ret;
109779feb521SJan Kara 
109879feb521SJan Kara 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
109979feb521SJan Kara 
110079feb521SJan Kara 	/*
110179feb521SJan Kara 	 * We cannot afford for write to remain in drive's caches since as
110279feb521SJan Kara 	 * soon as we update j_tail, next transaction can start reusing journal
110379feb521SJan Kara 	 * space and if we lose sb update during power failure we'd replay
110479feb521SJan Kara 	 * old transaction with possibly newly overwritten data.
110579feb521SJan Kara 	 */
110617f423b5SJan Kara 	ret = jbd2_journal_update_sb_log_tail(journal, tid, block,
110717f423b5SJan Kara 					      REQ_SYNC | REQ_FUA);
11086f6a6fdaSJoseph Qi 	if (ret)
11096f6a6fdaSJoseph Qi 		goto out;
11106f6a6fdaSJoseph Qi 
111179feb521SJan Kara 	write_lock(&journal->j_state_lock);
111279feb521SJan Kara 	freed = block - journal->j_tail;
111379feb521SJan Kara 	if (block < journal->j_tail)
111479feb521SJan Kara 		freed += journal->j_last - journal->j_first;
111579feb521SJan Kara 
111679feb521SJan Kara 	trace_jbd2_update_log_tail(journal, tid, block, freed);
1117cb3b3bf2SJan Kara 	jbd2_debug(1,
11187821ce41SGaowei Pu 		  "Cleaning journal tail from %u to %u (offset %lu), "
111979feb521SJan Kara 		  "freeing %lu\n",
112079feb521SJan Kara 		  journal->j_tail_sequence, tid, block, freed);
112179feb521SJan Kara 
112279feb521SJan Kara 	journal->j_free += freed;
112379feb521SJan Kara 	journal->j_tail_sequence = tid;
112479feb521SJan Kara 	journal->j_tail = block;
112579feb521SJan Kara 	write_unlock(&journal->j_state_lock);
11266f6a6fdaSJoseph Qi 
11276f6a6fdaSJoseph Qi out:
11286f6a6fdaSJoseph Qi 	return ret;
112979feb521SJan Kara }
113079feb521SJan Kara 
11313339578fSJan Kara /*
113285e0c4e8STheodore Ts'o  * This is a variation of __jbd2_update_log_tail which checks for validity of
11333339578fSJan Kara  * provided log tail and locks j_checkpoint_mutex. So it is safe against races
11343339578fSJan Kara  * with other threads updating log tail.
11353339578fSJan Kara  */
11363339578fSJan Kara void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
11373339578fSJan Kara {
11386fa7aa50STejun Heo 	mutex_lock_io(&journal->j_checkpoint_mutex);
11393339578fSJan Kara 	if (tid_gt(tid, journal->j_tail_sequence))
11403339578fSJan Kara 		__jbd2_update_log_tail(journal, tid, block);
11413339578fSJan Kara 	mutex_unlock(&journal->j_checkpoint_mutex);
11423339578fSJan Kara }
11433339578fSJan Kara 
11448e85fb3fSJohann Lombardi struct jbd2_stats_proc_session {
11458e85fb3fSJohann Lombardi 	journal_t *journal;
11468e85fb3fSJohann Lombardi 	struct transaction_stats_s *stats;
11478e85fb3fSJohann Lombardi 	int start;
11488e85fb3fSJohann Lombardi 	int max;
11498e85fb3fSJohann Lombardi };
11508e85fb3fSJohann Lombardi 
11518e85fb3fSJohann Lombardi static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
11528e85fb3fSJohann Lombardi {
11538e85fb3fSJohann Lombardi 	return *pos ? NULL : SEQ_START_TOKEN;
11548e85fb3fSJohann Lombardi }
11558e85fb3fSJohann Lombardi 
11568e85fb3fSJohann Lombardi static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos)
11578e85fb3fSJohann Lombardi {
11581a8e9cf4SVasily Averin 	(*pos)++;
11598e85fb3fSJohann Lombardi 	return NULL;
11608e85fb3fSJohann Lombardi }
11618e85fb3fSJohann Lombardi 
11628e85fb3fSJohann Lombardi static int jbd2_seq_info_show(struct seq_file *seq, void *v)
11638e85fb3fSJohann Lombardi {
11648e85fb3fSJohann Lombardi 	struct jbd2_stats_proc_session *s = seq->private;
11658e85fb3fSJohann Lombardi 
11668e85fb3fSJohann Lombardi 	if (v != SEQ_START_TOKEN)
11678e85fb3fSJohann Lombardi 		return 0;
11689fff24aaSTheodore Ts'o 	seq_printf(seq, "%lu transactions (%lu requested), "
11699fff24aaSTheodore Ts'o 		   "each up to %u blocks\n",
11709fff24aaSTheodore Ts'o 		   s->stats->ts_tid, s->stats->ts_requested,
11718e85fb3fSJohann Lombardi 		   s->journal->j_max_transaction_buffers);
11728e85fb3fSJohann Lombardi 	if (s->stats->ts_tid == 0)
11738e85fb3fSJohann Lombardi 		return 0;
11748e85fb3fSJohann Lombardi 	seq_printf(seq, "average: \n  %ums waiting for transaction\n",
1175bf699327STheodore Ts'o 	    jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
11769fff24aaSTheodore Ts'o 	seq_printf(seq, "  %ums request delay\n",
11779fff24aaSTheodore Ts'o 	    (s->stats->ts_requested == 0) ? 0 :
11789fff24aaSTheodore Ts'o 	    jiffies_to_msecs(s->stats->run.rs_request_delay /
11799fff24aaSTheodore Ts'o 			     s->stats->ts_requested));
11808e85fb3fSJohann Lombardi 	seq_printf(seq, "  %ums running transaction\n",
1181bf699327STheodore Ts'o 	    jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
11828e85fb3fSJohann Lombardi 	seq_printf(seq, "  %ums transaction was being locked\n",
1183bf699327STheodore Ts'o 	    jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
11848e85fb3fSJohann Lombardi 	seq_printf(seq, "  %ums flushing data (in ordered mode)\n",
1185bf699327STheodore Ts'o 	    jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
11868e85fb3fSJohann Lombardi 	seq_printf(seq, "  %ums logging transaction\n",
1187bf699327STheodore Ts'o 	    jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
1188c225aa57SSimon Holm Thøgersen 	seq_printf(seq, "  %lluus average transaction commit time\n",
1189c225aa57SSimon Holm Thøgersen 		   div_u64(s->journal->j_average_commit_time, 1000));
11908e85fb3fSJohann Lombardi 	seq_printf(seq, "  %lu handles per transaction\n",
1191bf699327STheodore Ts'o 	    s->stats->run.rs_handle_count / s->stats->ts_tid);
11928e85fb3fSJohann Lombardi 	seq_printf(seq, "  %lu blocks per transaction\n",
1193bf699327STheodore Ts'o 	    s->stats->run.rs_blocks / s->stats->ts_tid);
11948e85fb3fSJohann Lombardi 	seq_printf(seq, "  %lu logged blocks per transaction\n",
1195bf699327STheodore Ts'o 	    s->stats->run.rs_blocks_logged / s->stats->ts_tid);
11968e85fb3fSJohann Lombardi 	return 0;
11978e85fb3fSJohann Lombardi }
11988e85fb3fSJohann Lombardi 
11998e85fb3fSJohann Lombardi static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
12008e85fb3fSJohann Lombardi {
12018e85fb3fSJohann Lombardi }
12028e85fb3fSJohann Lombardi 
120388e9d34cSJames Morris static const struct seq_operations jbd2_seq_info_ops = {
12048e85fb3fSJohann Lombardi 	.start  = jbd2_seq_info_start,
12058e85fb3fSJohann Lombardi 	.next   = jbd2_seq_info_next,
12068e85fb3fSJohann Lombardi 	.stop   = jbd2_seq_info_stop,
12078e85fb3fSJohann Lombardi 	.show   = jbd2_seq_info_show,
12088e85fb3fSJohann Lombardi };
12098e85fb3fSJohann Lombardi 
12108e85fb3fSJohann Lombardi static int jbd2_seq_info_open(struct inode *inode, struct file *file)
12118e85fb3fSJohann Lombardi {
1212359745d7SMuchun Song 	journal_t *journal = pde_data(inode);
12138e85fb3fSJohann Lombardi 	struct jbd2_stats_proc_session *s;
12148e85fb3fSJohann Lombardi 	int rc, size;
12158e85fb3fSJohann Lombardi 
12168e85fb3fSJohann Lombardi 	s = kmalloc(sizeof(*s), GFP_KERNEL);
12178e85fb3fSJohann Lombardi 	if (s == NULL)
12188e85fb3fSJohann Lombardi 		return -ENOMEM;
12198e85fb3fSJohann Lombardi 	size = sizeof(struct transaction_stats_s);
12208e85fb3fSJohann Lombardi 	s->stats = kmalloc(size, GFP_KERNEL);
12218e85fb3fSJohann Lombardi 	if (s->stats == NULL) {
12228e85fb3fSJohann Lombardi 		kfree(s);
12238e85fb3fSJohann Lombardi 		return -ENOMEM;
12248e85fb3fSJohann Lombardi 	}
12258e85fb3fSJohann Lombardi 	spin_lock(&journal->j_history_lock);
12268e85fb3fSJohann Lombardi 	memcpy(s->stats, &journal->j_stats, size);
12278e85fb3fSJohann Lombardi 	s->journal = journal;
12288e85fb3fSJohann Lombardi 	spin_unlock(&journal->j_history_lock);
12298e85fb3fSJohann Lombardi 
12308e85fb3fSJohann Lombardi 	rc = seq_open(file, &jbd2_seq_info_ops);
12318e85fb3fSJohann Lombardi 	if (rc == 0) {
12328e85fb3fSJohann Lombardi 		struct seq_file *m = file->private_data;
12338e85fb3fSJohann Lombardi 		m->private = s;
12348e85fb3fSJohann Lombardi 	} else {
12358e85fb3fSJohann Lombardi 		kfree(s->stats);
12368e85fb3fSJohann Lombardi 		kfree(s);
12378e85fb3fSJohann Lombardi 	}
12388e85fb3fSJohann Lombardi 	return rc;
12398e85fb3fSJohann Lombardi 
12408e85fb3fSJohann Lombardi }
12418e85fb3fSJohann Lombardi 
12428e85fb3fSJohann Lombardi static int jbd2_seq_info_release(struct inode *inode, struct file *file)
12438e85fb3fSJohann Lombardi {
12448e85fb3fSJohann Lombardi 	struct seq_file *seq = file->private_data;
12458e85fb3fSJohann Lombardi 	struct jbd2_stats_proc_session *s = seq->private;
12468e85fb3fSJohann Lombardi 	kfree(s->stats);
12478e85fb3fSJohann Lombardi 	kfree(s);
12488e85fb3fSJohann Lombardi 	return seq_release(inode, file);
12498e85fb3fSJohann Lombardi }
12508e85fb3fSJohann Lombardi 
125197a32539SAlexey Dobriyan static const struct proc_ops jbd2_info_proc_ops = {
125297a32539SAlexey Dobriyan 	.proc_open	= jbd2_seq_info_open,
125397a32539SAlexey Dobriyan 	.proc_read	= seq_read,
125497a32539SAlexey Dobriyan 	.proc_lseek	= seq_lseek,
125597a32539SAlexey Dobriyan 	.proc_release	= jbd2_seq_info_release,
12568e85fb3fSJohann Lombardi };
12578e85fb3fSJohann Lombardi 
12588e85fb3fSJohann Lombardi static struct proc_dir_entry *proc_jbd2_stats;
12598e85fb3fSJohann Lombardi 
12608e85fb3fSJohann Lombardi static void jbd2_stats_proc_init(journal_t *journal)
12618e85fb3fSJohann Lombardi {
126205496769STheodore Ts'o 	journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
12638e85fb3fSJohann Lombardi 	if (journal->j_proc_entry) {
126479da3664SDenis V. Lunev 		proc_create_data("info", S_IRUGO, journal->j_proc_entry,
126597a32539SAlexey Dobriyan 				 &jbd2_info_proc_ops, journal);
12668e85fb3fSJohann Lombardi 	}
12678e85fb3fSJohann Lombardi }
12688e85fb3fSJohann Lombardi 
12698e85fb3fSJohann Lombardi static void jbd2_stats_proc_exit(journal_t *journal)
12708e85fb3fSJohann Lombardi {
12718e85fb3fSJohann Lombardi 	remove_proc_entry("info", journal->j_proc_entry);
127205496769STheodore Ts'o 	remove_proc_entry(journal->j_devname, proc_jbd2_stats);
12738e85fb3fSJohann Lombardi }
12748e85fb3fSJohann Lombardi 
1275b90bfdf5SJan Kara /* Minimum size of descriptor tag */
1276b90bfdf5SJan Kara static int jbd2_min_tag_size(void)
1277b90bfdf5SJan Kara {
1278b90bfdf5SJan Kara 	/*
1279b90bfdf5SJan Kara 	 * Tag with 32-bit block numbers does not use last four bytes of the
1280b90bfdf5SJan Kara 	 * structure
1281b90bfdf5SJan Kara 	 */
1282b90bfdf5SJan Kara 	return sizeof(journal_block_tag_t) - 4;
1283b90bfdf5SJan Kara }
1284b90bfdf5SJan Kara 
12850705e8d1STheodore Ts'o /**
12860705e8d1STheodore Ts'o  * jbd2_journal_shrink_scan()
1287715a67f1SYang Li  * @shrink: shrinker to work on
1288715a67f1SYang Li  * @sc: reclaim request to process
12890705e8d1STheodore Ts'o  *
12900705e8d1STheodore Ts'o  * Scan the checkpointed buffer on the checkpoint list and release the
12910705e8d1STheodore Ts'o  * journal_head.
12920705e8d1STheodore Ts'o  */
12930705e8d1STheodore Ts'o static unsigned long jbd2_journal_shrink_scan(struct shrinker *shrink,
12940705e8d1STheodore Ts'o 					      struct shrink_control *sc)
12950705e8d1STheodore Ts'o {
12960705e8d1STheodore Ts'o 	journal_t *journal = container_of(shrink, journal_t, j_shrinker);
12970705e8d1STheodore Ts'o 	unsigned long nr_to_scan = sc->nr_to_scan;
12980705e8d1STheodore Ts'o 	unsigned long nr_shrunk;
12990705e8d1STheodore Ts'o 	unsigned long count;
13000705e8d1STheodore Ts'o 
13010705e8d1STheodore Ts'o 	count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);
13020705e8d1STheodore Ts'o 	trace_jbd2_shrink_scan_enter(journal, sc->nr_to_scan, count);
13030705e8d1STheodore Ts'o 
13040705e8d1STheodore Ts'o 	nr_shrunk = jbd2_journal_shrink_checkpoint_list(journal, &nr_to_scan);
13050705e8d1STheodore Ts'o 
13060705e8d1STheodore Ts'o 	count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);
13070705e8d1STheodore Ts'o 	trace_jbd2_shrink_scan_exit(journal, nr_to_scan, nr_shrunk, count);
13080705e8d1STheodore Ts'o 
13090705e8d1STheodore Ts'o 	return nr_shrunk;
13100705e8d1STheodore Ts'o }
13110705e8d1STheodore Ts'o 
13120705e8d1STheodore Ts'o /**
13130705e8d1STheodore Ts'o  * jbd2_journal_shrink_count()
1314715a67f1SYang Li  * @shrink: shrinker to work on
1315715a67f1SYang Li  * @sc: reclaim request to process
13160705e8d1STheodore Ts'o  *
13170705e8d1STheodore Ts'o  * Count the number of checkpoint buffers on the checkpoint list.
13180705e8d1STheodore Ts'o  */
13190705e8d1STheodore Ts'o static unsigned long jbd2_journal_shrink_count(struct shrinker *shrink,
13200705e8d1STheodore Ts'o 					       struct shrink_control *sc)
13210705e8d1STheodore Ts'o {
13220705e8d1STheodore Ts'o 	journal_t *journal = container_of(shrink, journal_t, j_shrinker);
13230705e8d1STheodore Ts'o 	unsigned long count;
13240705e8d1STheodore Ts'o 
13250705e8d1STheodore Ts'o 	count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);
13260705e8d1STheodore Ts'o 	trace_jbd2_shrink_count(journal, sc->nr_to_scan, count);
13270705e8d1STheodore Ts'o 
13280705e8d1STheodore Ts'o 	return count;
13290705e8d1STheodore Ts'o }
13300705e8d1STheodore Ts'o 
1331470decc6SDave Kleikamp /*
133229a511e4SZhang Yi  * If the journal init or create aborts, we need to mark the journal
133329a511e4SZhang Yi  * superblock as being NULL to prevent the journal destroy from writing
133429a511e4SZhang Yi  * back a bogus superblock.
133529a511e4SZhang Yi  */
133629a511e4SZhang Yi static void journal_fail_superblock(journal_t *journal)
133729a511e4SZhang Yi {
133829a511e4SZhang Yi 	struct buffer_head *bh = journal->j_sb_buffer;
133929a511e4SZhang Yi 	brelse(bh);
134029a511e4SZhang Yi 	journal->j_sb_buffer = NULL;
134129a511e4SZhang Yi }
134229a511e4SZhang Yi 
134329a511e4SZhang Yi /*
134429a511e4SZhang Yi  * Read the superblock for a given journal, performing initial
134529a511e4SZhang Yi  * validation of the format.
134629a511e4SZhang Yi  */
134729a511e4SZhang Yi static int journal_get_superblock(journal_t *journal)
134829a511e4SZhang Yi {
134929a511e4SZhang Yi 	struct buffer_head *bh;
135029a511e4SZhang Yi 	journal_superblock_t *sb;
135129a511e4SZhang Yi 	int err;
135229a511e4SZhang Yi 
135329a511e4SZhang Yi 	bh = journal->j_sb_buffer;
135429a511e4SZhang Yi 
135529a511e4SZhang Yi 	J_ASSERT(bh != NULL);
135629a511e4SZhang Yi 
135729a511e4SZhang Yi 	err = bh_read(bh, 0);
135829a511e4SZhang Yi 	if (err < 0) {
135929a511e4SZhang Yi 		printk(KERN_ERR
136029a511e4SZhang Yi 			"JBD2: IO error reading journal superblock\n");
136129a511e4SZhang Yi 		goto out;
136229a511e4SZhang Yi 	}
136329a511e4SZhang Yi 
136429a511e4SZhang Yi 	sb = journal->j_superblock;
136529a511e4SZhang Yi 
136629a511e4SZhang Yi 	err = -EINVAL;
136729a511e4SZhang Yi 
136829a511e4SZhang Yi 	if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
136929a511e4SZhang Yi 	    sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
137029a511e4SZhang Yi 		printk(KERN_WARNING "JBD2: no valid journal superblock found\n");
137129a511e4SZhang Yi 		goto out;
137229a511e4SZhang Yi 	}
137329a511e4SZhang Yi 
137429a511e4SZhang Yi 	if (be32_to_cpu(sb->s_header.h_blocktype) != JBD2_SUPERBLOCK_V1 &&
137529a511e4SZhang Yi 	    be32_to_cpu(sb->s_header.h_blocktype) != JBD2_SUPERBLOCK_V2) {
137629a511e4SZhang Yi 		printk(KERN_WARNING "JBD2: unrecognised superblock format ID\n");
137729a511e4SZhang Yi 		goto out;
137829a511e4SZhang Yi 	}
137929a511e4SZhang Yi 
138029a511e4SZhang Yi 	if (be32_to_cpu(sb->s_maxlen) > journal->j_total_len) {
138129a511e4SZhang Yi 		printk(KERN_WARNING "JBD2: journal file too short\n");
138229a511e4SZhang Yi 		goto out;
138329a511e4SZhang Yi 	}
138429a511e4SZhang Yi 
138529a511e4SZhang Yi 	if (be32_to_cpu(sb->s_first) == 0 ||
138629a511e4SZhang Yi 	    be32_to_cpu(sb->s_first) >= journal->j_total_len) {
138729a511e4SZhang Yi 		printk(KERN_WARNING
138829a511e4SZhang Yi 			"JBD2: Invalid start block of journal: %u\n",
138929a511e4SZhang Yi 			be32_to_cpu(sb->s_first));
139029a511e4SZhang Yi 		goto out;
139129a511e4SZhang Yi 	}
139229a511e4SZhang Yi 
1393e4adf8b8SZhang Yi 	/*
1394e4adf8b8SZhang Yi 	 * If this is a V2 superblock, then we have to check the
1395e4adf8b8SZhang Yi 	 * features flags on it.
1396e4adf8b8SZhang Yi 	 */
1397e4adf8b8SZhang Yi 	if (!jbd2_format_support_feature(journal))
1398e4adf8b8SZhang Yi 		return 0;
1399e4adf8b8SZhang Yi 
1400e4adf8b8SZhang Yi 	if ((sb->s_feature_ro_compat &
1401e4adf8b8SZhang Yi 			~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
1402e4adf8b8SZhang Yi 	    (sb->s_feature_incompat &
1403e4adf8b8SZhang Yi 			~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
1404e4adf8b8SZhang Yi 		printk(KERN_WARNING "JBD2: Unrecognised features on journal\n");
1405e4adf8b8SZhang Yi 		goto out;
1406e4adf8b8SZhang Yi 	}
1407e4adf8b8SZhang Yi 
140829a511e4SZhang Yi 	if (jbd2_has_feature_csum2(journal) &&
140929a511e4SZhang Yi 	    jbd2_has_feature_csum3(journal)) {
141029a511e4SZhang Yi 		/* Can't have checksum v2 and v3 at the same time! */
141129a511e4SZhang Yi 		printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 "
141229a511e4SZhang Yi 		       "at the same time!\n");
141329a511e4SZhang Yi 		goto out;
141429a511e4SZhang Yi 	}
141529a511e4SZhang Yi 
141629a511e4SZhang Yi 	if (jbd2_journal_has_csum_v2or3_feature(journal) &&
141729a511e4SZhang Yi 	    jbd2_has_feature_checksum(journal)) {
141829a511e4SZhang Yi 		/* Can't have checksum v1 and v2 on at the same time! */
141929a511e4SZhang Yi 		printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 "
142029a511e4SZhang Yi 		       "at the same time!\n");
142129a511e4SZhang Yi 		goto out;
142229a511e4SZhang Yi 	}
142329a511e4SZhang Yi 
1424*18dad509SZhang Yi 	/* Load the checksum driver */
1425*18dad509SZhang Yi 	if (jbd2_journal_has_csum_v2or3_feature(journal)) {
1426*18dad509SZhang Yi 		if (sb->s_checksum_type != JBD2_CRC32C_CHKSUM) {
142729a511e4SZhang Yi 			printk(KERN_ERR "JBD2: Unknown checksum type\n");
142829a511e4SZhang Yi 			goto out;
142929a511e4SZhang Yi 		}
143029a511e4SZhang Yi 
143129a511e4SZhang Yi 		journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
143229a511e4SZhang Yi 		if (IS_ERR(journal->j_chksum_driver)) {
143329a511e4SZhang Yi 			printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
143429a511e4SZhang Yi 			err = PTR_ERR(journal->j_chksum_driver);
143529a511e4SZhang Yi 			journal->j_chksum_driver = NULL;
143629a511e4SZhang Yi 			goto out;
143729a511e4SZhang Yi 		}
143829a511e4SZhang Yi 		/* Check superblock checksum */
143929a511e4SZhang Yi 		if (sb->s_checksum != jbd2_superblock_csum(journal, sb)) {
144029a511e4SZhang Yi 			printk(KERN_ERR "JBD2: journal checksum error\n");
144129a511e4SZhang Yi 			err = -EFSBADCRC;
144229a511e4SZhang Yi 			goto out;
144329a511e4SZhang Yi 		}
144429a511e4SZhang Yi 	}
144529a511e4SZhang Yi 	return 0;
144629a511e4SZhang Yi 
144729a511e4SZhang Yi out:
144829a511e4SZhang Yi 	journal_fail_superblock(journal);
144929a511e4SZhang Yi 	return err;
145029a511e4SZhang Yi }
145129a511e4SZhang Yi 
145229a511e4SZhang Yi static int journal_revoke_records_per_block(journal_t *journal)
145329a511e4SZhang Yi {
145429a511e4SZhang Yi 	int record_size;
145529a511e4SZhang Yi 	int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t);
145629a511e4SZhang Yi 
145729a511e4SZhang Yi 	if (jbd2_has_feature_64bit(journal))
145829a511e4SZhang Yi 		record_size = 8;
145929a511e4SZhang Yi 	else
146029a511e4SZhang Yi 		record_size = 4;
146129a511e4SZhang Yi 
146229a511e4SZhang Yi 	if (jbd2_journal_has_csum_v2or3(journal))
146329a511e4SZhang Yi 		space -= sizeof(struct jbd2_journal_block_tail);
146429a511e4SZhang Yi 	return space / record_size;
146529a511e4SZhang Yi }
146629a511e4SZhang Yi 
146729a511e4SZhang Yi /*
146829a511e4SZhang Yi  * Load the on-disk journal superblock and read the key fields into the
146929a511e4SZhang Yi  * journal_t.
147029a511e4SZhang Yi  */
147129a511e4SZhang Yi static int load_superblock(journal_t *journal)
147229a511e4SZhang Yi {
147329a511e4SZhang Yi 	int err;
147429a511e4SZhang Yi 	journal_superblock_t *sb;
147529a511e4SZhang Yi 	int num_fc_blocks;
147629a511e4SZhang Yi 
147729a511e4SZhang Yi 	err = journal_get_superblock(journal);
147829a511e4SZhang Yi 	if (err)
147929a511e4SZhang Yi 		return err;
148029a511e4SZhang Yi 
148129a511e4SZhang Yi 	sb = journal->j_superblock;
148229a511e4SZhang Yi 
148329a511e4SZhang Yi 	journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
148429a511e4SZhang Yi 	journal->j_tail = be32_to_cpu(sb->s_start);
148529a511e4SZhang Yi 	journal->j_first = be32_to_cpu(sb->s_first);
148629a511e4SZhang Yi 	journal->j_errno = be32_to_cpu(sb->s_errno);
148729a511e4SZhang Yi 	journal->j_last = be32_to_cpu(sb->s_maxlen);
148829a511e4SZhang Yi 
148929a511e4SZhang Yi 	if (be32_to_cpu(sb->s_maxlen) < journal->j_total_len)
149029a511e4SZhang Yi 		journal->j_total_len = be32_to_cpu(sb->s_maxlen);
149129a511e4SZhang Yi 	/* Precompute checksum seed for all metadata */
149229a511e4SZhang Yi 	if (jbd2_journal_has_csum_v2or3(journal))
149329a511e4SZhang Yi 		journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
149429a511e4SZhang Yi 						   sizeof(sb->s_uuid));
149529a511e4SZhang Yi 	journal->j_revoke_records_per_block =
149629a511e4SZhang Yi 				journal_revoke_records_per_block(journal);
149729a511e4SZhang Yi 
149829a511e4SZhang Yi 	if (jbd2_has_feature_fast_commit(journal)) {
149929a511e4SZhang Yi 		journal->j_fc_last = be32_to_cpu(sb->s_maxlen);
150029a511e4SZhang Yi 		num_fc_blocks = jbd2_journal_get_num_fc_blks(sb);
150129a511e4SZhang Yi 		if (journal->j_last - num_fc_blocks >= JBD2_MIN_JOURNAL_BLOCKS)
150229a511e4SZhang Yi 			journal->j_last = journal->j_fc_last - num_fc_blocks;
150329a511e4SZhang Yi 		journal->j_fc_first = journal->j_last + 1;
150429a511e4SZhang Yi 		journal->j_fc_off = 0;
150529a511e4SZhang Yi 	}
150629a511e4SZhang Yi 
150729a511e4SZhang Yi 	return 0;
150829a511e4SZhang Yi }
150929a511e4SZhang Yi 
151029a511e4SZhang Yi 
151129a511e4SZhang Yi /*
1512470decc6SDave Kleikamp  * Management for journal control blocks: functions to create and
1513470decc6SDave Kleikamp  * destroy journal_t structures, and to initialise and read existing
1514470decc6SDave Kleikamp  * journal blocks from disk.  */
1515470decc6SDave Kleikamp 
1516470decc6SDave Kleikamp /* First: create and setup a journal_t object in memory.  We initialise
1517470decc6SDave Kleikamp  * very few fields yet: that has to wait until we have created the
1518470decc6SDave Kleikamp  * journal structures from from scratch, or loaded them from disk. */
1519470decc6SDave Kleikamp 
1520f0c9fd54SGeliang Tang static journal_t *journal_init_common(struct block_device *bdev,
1521f0c9fd54SGeliang Tang 			struct block_device *fs_dev,
1522f0c9fd54SGeliang Tang 			unsigned long long start, int len, int blocksize)
1523470decc6SDave Kleikamp {
1524ab714affSJan Kara 	static struct lock_class_key jbd2_trans_commit_key;
1525470decc6SDave Kleikamp 	journal_t *journal;
1526470decc6SDave Kleikamp 	int err;
1527f0c9fd54SGeliang Tang 	struct buffer_head *bh;
1528f0c9fd54SGeliang Tang 	int n;
1529470decc6SDave Kleikamp 
15303ebfdf88SAndrew Morton 	journal = kzalloc(sizeof(*journal), GFP_KERNEL);
1531470decc6SDave Kleikamp 	if (!journal)
1532b7271b0aSTheodore Ts'o 		return NULL;
1533470decc6SDave Kleikamp 
1534470decc6SDave Kleikamp 	init_waitqueue_head(&journal->j_wait_transaction_locked);
1535470decc6SDave Kleikamp 	init_waitqueue_head(&journal->j_wait_done_commit);
1536470decc6SDave Kleikamp 	init_waitqueue_head(&journal->j_wait_commit);
1537470decc6SDave Kleikamp 	init_waitqueue_head(&journal->j_wait_updates);
15388f7d89f3SJan Kara 	init_waitqueue_head(&journal->j_wait_reserved);
1539ff780b91SHarshad Shirwadkar 	init_waitqueue_head(&journal->j_fc_wait);
15407b97d868Szhangyi (F) 	mutex_init(&journal->j_abort_mutex);
1541470decc6SDave Kleikamp 	mutex_init(&journal->j_barrier);
1542470decc6SDave Kleikamp 	mutex_init(&journal->j_checkpoint_mutex);
1543470decc6SDave Kleikamp 	spin_lock_init(&journal->j_revoke_lock);
1544470decc6SDave Kleikamp 	spin_lock_init(&journal->j_list_lock);
1545a931da6aSTheodore Ts'o 	rwlock_init(&journal->j_state_lock);
1546470decc6SDave Kleikamp 
1547cd02ff0bSMingming Cao 	journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
154830773840STheodore Ts'o 	journal->j_min_batch_time = 0;
154930773840STheodore Ts'o 	journal->j_max_batch_time = 15000; /* 15ms */
15508f7d89f3SJan Kara 	atomic_set(&journal->j_reserved_credits, 0);
1551470decc6SDave Kleikamp 
1552470decc6SDave Kleikamp 	/* The journal is marked for error until we succeed with recovery! */
1553f7f4bccbSMingming Cao 	journal->j_flags = JBD2_ABORT;
1554470decc6SDave Kleikamp 
1555470decc6SDave Kleikamp 	/* Set up a default-sized revoke table for the new mount. */
1556f7f4bccbSMingming Cao 	err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
1557cd9cb405SEric Biggers 	if (err)
1558cd9cb405SEric Biggers 		goto err_cleanup;
15598e85fb3fSJohann Lombardi 
1560bf699327STheodore Ts'o 	spin_lock_init(&journal->j_history_lock);
15618e85fb3fSJohann Lombardi 
1562ab714affSJan Kara 	lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle",
1563ab714affSJan Kara 			 &jbd2_trans_commit_key, 0);
1564ab714affSJan Kara 
1565f0c9fd54SGeliang Tang 	/* journal descriptor can store up to n blocks -bzzz */
1566f0c9fd54SGeliang Tang 	journal->j_blocksize = blocksize;
1567f0c9fd54SGeliang Tang 	journal->j_dev = bdev;
1568f0c9fd54SGeliang Tang 	journal->j_fs_dev = fs_dev;
1569f0c9fd54SGeliang Tang 	journal->j_blk_offset = start;
1570ede7dc7fSHarshad Shirwadkar 	journal->j_total_len = len;
1571b90bfdf5SJan Kara 	/* We need enough buffers to write out full descriptor block. */
1572b90bfdf5SJan Kara 	n = journal->j_blocksize / jbd2_min_tag_size();
1573f0c9fd54SGeliang Tang 	journal->j_wbufsize = n;
1574a1e5e465SHarshad Shirwadkar 	journal->j_fc_wbuf = NULL;
1575f0c9fd54SGeliang Tang 	journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *),
1576f0c9fd54SGeliang Tang 					GFP_KERNEL);
1577cd9cb405SEric Biggers 	if (!journal->j_wbuf)
1578cd9cb405SEric Biggers 		goto err_cleanup;
1579f0c9fd54SGeliang Tang 
1580f0c9fd54SGeliang Tang 	bh = getblk_unmovable(journal->j_dev, start, journal->j_blocksize);
1581f0c9fd54SGeliang Tang 	if (!bh) {
1582f0c9fd54SGeliang Tang 		pr_err("%s: Cannot get buffer for journal superblock\n",
1583f0c9fd54SGeliang Tang 			__func__);
1584cd9cb405SEric Biggers 		goto err_cleanup;
1585f0c9fd54SGeliang Tang 	}
1586f0c9fd54SGeliang Tang 	journal->j_sb_buffer = bh;
1587f0c9fd54SGeliang Tang 	journal->j_superblock = (journal_superblock_t *)bh->b_data;
1588f0c9fd54SGeliang Tang 
1589c3071308SZhang Yi 	err = load_superblock(journal);
1590c3071308SZhang Yi 	if (err)
1591c3071308SZhang Yi 		goto err_cleanup;
1592c3071308SZhang Yi 
15930705e8d1STheodore Ts'o 	journal->j_shrink_transaction = NULL;
15940705e8d1STheodore Ts'o 	journal->j_shrinker.scan_objects = jbd2_journal_shrink_scan;
15950705e8d1STheodore Ts'o 	journal->j_shrinker.count_objects = jbd2_journal_shrink_count;
15960705e8d1STheodore Ts'o 	journal->j_shrinker.seeks = DEFAULT_SEEKS;
15970705e8d1STheodore Ts'o 	journal->j_shrinker.batch = journal->j_max_transaction_buffers;
15980705e8d1STheodore Ts'o 
15990705e8d1STheodore Ts'o 	if (percpu_counter_init(&journal->j_checkpoint_jh_count, 0, GFP_KERNEL))
16000705e8d1STheodore Ts'o 		goto err_cleanup;
16010705e8d1STheodore Ts'o 
1602e33c267aSRoman Gushchin 	if (register_shrinker(&journal->j_shrinker, "jbd2-journal:(%u:%u)",
1603e33c267aSRoman Gushchin 			      MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev))) {
16040705e8d1STheodore Ts'o 		percpu_counter_destroy(&journal->j_checkpoint_jh_count);
16050705e8d1STheodore Ts'o 		goto err_cleanup;
16060705e8d1STheodore Ts'o 	}
1607470decc6SDave Kleikamp 	return journal;
1608cd9cb405SEric Biggers 
1609cd9cb405SEric Biggers err_cleanup:
16100705e8d1STheodore Ts'o 	brelse(journal->j_sb_buffer);
1611cd9cb405SEric Biggers 	kfree(journal->j_wbuf);
1612cd9cb405SEric Biggers 	jbd2_journal_destroy_revoke(journal);
1613cd9cb405SEric Biggers 	kfree(journal);
1614cd9cb405SEric Biggers 	return NULL;
1615470decc6SDave Kleikamp }
1616470decc6SDave Kleikamp 
1617f7f4bccbSMingming Cao /* jbd2_journal_init_dev and jbd2_journal_init_inode:
1618470decc6SDave Kleikamp  *
1619470decc6SDave Kleikamp  * Create a journal structure assigned some fixed set of disk blocks to
1620470decc6SDave Kleikamp  * the journal.  We don't actually touch those disk blocks yet, but we
1621470decc6SDave Kleikamp  * need to set up all of the mapping information to tell the journaling
1622470decc6SDave Kleikamp  * system where the journal blocks are.
1623470decc6SDave Kleikamp  *
1624470decc6SDave Kleikamp  */
1625470decc6SDave Kleikamp 
1626470decc6SDave Kleikamp /**
16275648ba5bSRandy Dunlap  *  journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure
1628470decc6SDave Kleikamp  *  @bdev: Block device on which to create the journal
1629470decc6SDave Kleikamp  *  @fs_dev: Device which hold journalled filesystem for this journal.
1630470decc6SDave Kleikamp  *  @start: Block nr Start of journal.
1631470decc6SDave Kleikamp  *  @len:  Length of the journal in blocks.
1632470decc6SDave Kleikamp  *  @blocksize: blocksize of journalling device
16335648ba5bSRandy Dunlap  *
16345648ba5bSRandy Dunlap  *  Returns: a newly created journal_t *
1635470decc6SDave Kleikamp  *
1636f7f4bccbSMingming Cao  *  jbd2_journal_init_dev creates a journal which maps a fixed contiguous
1637470decc6SDave Kleikamp  *  range of blocks on an arbitrary block device.
1638470decc6SDave Kleikamp  *
1639470decc6SDave Kleikamp  */
1640f7f4bccbSMingming Cao journal_t *jbd2_journal_init_dev(struct block_device *bdev,
1641470decc6SDave Kleikamp 			struct block_device *fs_dev,
164218eba7aaSMingming Cao 			unsigned long long start, int len, int blocksize)
1643470decc6SDave Kleikamp {
1644f0c9fd54SGeliang Tang 	journal_t *journal;
1645470decc6SDave Kleikamp 
1646f0c9fd54SGeliang Tang 	journal = journal_init_common(bdev, fs_dev, start, len, blocksize);
1647470decc6SDave Kleikamp 	if (!journal)
1648470decc6SDave Kleikamp 		return NULL;
1649470decc6SDave Kleikamp 
1650900d156bSChristoph Hellwig 	snprintf(journal->j_devname, sizeof(journal->j_devname),
1651900d156bSChristoph Hellwig 		 "%pg", journal->j_dev);
165281ae394bSRasmus Villemoes 	strreplace(journal->j_devname, '/', '!');
16534b905671SJan Kara 	jbd2_stats_proc_init(journal);
16544b905671SJan Kara 
1655470decc6SDave Kleikamp 	return journal;
1656470decc6SDave Kleikamp }
1657470decc6SDave Kleikamp 
1658470decc6SDave Kleikamp /**
1659f7f4bccbSMingming Cao  *  journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode.
1660470decc6SDave Kleikamp  *  @inode: An inode to create the journal in
1661470decc6SDave Kleikamp  *
1662f7f4bccbSMingming Cao  * jbd2_journal_init_inode creates a journal which maps an on-disk inode as
1663470decc6SDave Kleikamp  * the journal.  The inode must exist already, must support bmap() and
1664470decc6SDave Kleikamp  * must have all data blocks preallocated.
1665470decc6SDave Kleikamp  */
1666f7f4bccbSMingming Cao journal_t *jbd2_journal_init_inode(struct inode *inode)
1667470decc6SDave Kleikamp {
1668f0c9fd54SGeliang Tang 	journal_t *journal;
166930460e1eSCarlos Maiolino 	sector_t blocknr;
167030460e1eSCarlos Maiolino 	int err = 0;
1671470decc6SDave Kleikamp 
167230460e1eSCarlos Maiolino 	blocknr = 0;
167330460e1eSCarlos Maiolino 	err = bmap(inode, &blocknr);
167430460e1eSCarlos Maiolino 
167530460e1eSCarlos Maiolino 	if (err || !blocknr) {
1676f0c9fd54SGeliang Tang 		pr_err("%s: Cannot locate journal superblock\n",
1677f0c9fd54SGeliang Tang 			__func__);
1678f0c9fd54SGeliang Tang 		return NULL;
1679f0c9fd54SGeliang Tang 	}
1680f0c9fd54SGeliang Tang 
1681cb3b3bf2SJan Kara 	jbd2_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n",
1682f0c9fd54SGeliang Tang 		  inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size,
1683f0c9fd54SGeliang Tang 		  inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
1684f0c9fd54SGeliang Tang 
1685f0c9fd54SGeliang Tang 	journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev,
1686f0c9fd54SGeliang Tang 			blocknr, inode->i_size >> inode->i_sb->s_blocksize_bits,
1687f0c9fd54SGeliang Tang 			inode->i_sb->s_blocksize);
1688470decc6SDave Kleikamp 	if (!journal)
1689470decc6SDave Kleikamp 		return NULL;
1690470decc6SDave Kleikamp 
1691470decc6SDave Kleikamp 	journal->j_inode = inode;
1692900d156bSChristoph Hellwig 	snprintf(journal->j_devname, sizeof(journal->j_devname),
16937afb6d8fSAndy Shevchenko 		 "%pg-%lu", journal->j_dev, journal->j_inode->i_ino);
16947afb6d8fSAndy Shevchenko 	strreplace(journal->j_devname, '/', '!');
16958e85fb3fSJohann Lombardi 	jbd2_stats_proc_init(journal);
1696470decc6SDave Kleikamp 
1697470decc6SDave Kleikamp 	return journal;
1698470decc6SDave Kleikamp }
1699470decc6SDave Kleikamp 
1700470decc6SDave Kleikamp /*
1701470decc6SDave Kleikamp  * Given a journal_t structure, initialise the various fields for
1702470decc6SDave Kleikamp  * startup of a new journaling session.  We use this both when creating
1703470decc6SDave Kleikamp  * a journal, and after recovering an old journal to reset it for
1704470decc6SDave Kleikamp  * subsequent use.
1705470decc6SDave Kleikamp  */
1706470decc6SDave Kleikamp 
1707470decc6SDave Kleikamp static int journal_reset(journal_t *journal)
1708470decc6SDave Kleikamp {
1709470decc6SDave Kleikamp 	journal_superblock_t *sb = journal->j_superblock;
171018eba7aaSMingming Cao 	unsigned long long first, last;
1711470decc6SDave Kleikamp 
1712470decc6SDave Kleikamp 	first = be32_to_cpu(sb->s_first);
1713470decc6SDave Kleikamp 	last = be32_to_cpu(sb->s_maxlen);
1714f6f50e28SJan Kara 	if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
1715f2a44523SEryu Guan 		printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n",
1716f6f50e28SJan Kara 		       first, last);
1717f6f50e28SJan Kara 		journal_fail_superblock(journal);
1718f6f50e28SJan Kara 		return -EINVAL;
1719f6f50e28SJan Kara 	}
1720470decc6SDave Kleikamp 
1721470decc6SDave Kleikamp 	journal->j_first = first;
17226866d7b3SHarshad Shirwadkar 	journal->j_last = last;
17236866d7b3SHarshad Shirwadkar 
1724c7fc6055SZhang Yi 	if (journal->j_head != 0 && journal->j_flags & JBD2_CYCLE_RECORD) {
1725c7fc6055SZhang Yi 		/*
1726c7fc6055SZhang Yi 		 * Disable the cycled recording mode if the journal head block
1727c7fc6055SZhang Yi 		 * number is not correct.
1728c7fc6055SZhang Yi 		 */
1729c7fc6055SZhang Yi 		if (journal->j_head < first || journal->j_head >= last) {
1730c7fc6055SZhang Yi 			printk(KERN_WARNING "JBD2: Incorrect Journal head block %lu, "
1731c7fc6055SZhang Yi 			       "disable journal_cycle_record\n",
1732c7fc6055SZhang Yi 			       journal->j_head);
17336866d7b3SHarshad Shirwadkar 			journal->j_head = journal->j_first;
1734c7fc6055SZhang Yi 		}
1735c7fc6055SZhang Yi 	} else {
1736c7fc6055SZhang Yi 		journal->j_head = journal->j_first;
1737c7fc6055SZhang Yi 	}
1738c7fc6055SZhang Yi 	journal->j_tail = journal->j_head;
17396866d7b3SHarshad Shirwadkar 	journal->j_free = journal->j_last - journal->j_first;
1740470decc6SDave Kleikamp 
1741470decc6SDave Kleikamp 	journal->j_tail_sequence = journal->j_transaction_sequence;
1742470decc6SDave Kleikamp 	journal->j_commit_sequence = journal->j_transaction_sequence - 1;
1743470decc6SDave Kleikamp 	journal->j_commit_request = journal->j_commit_sequence;
1744470decc6SDave Kleikamp 
1745ede7dc7fSHarshad Shirwadkar 	journal->j_max_transaction_buffers = jbd2_journal_get_max_txn_bufs(journal);
1746470decc6SDave Kleikamp 
1747470decc6SDave Kleikamp 	/*
1748a1e5e465SHarshad Shirwadkar 	 * Now that journal recovery is done, turn fast commits off here. This
1749a1e5e465SHarshad Shirwadkar 	 * way, if fast commit was enabled before the crash but if now FS has
1750a1e5e465SHarshad Shirwadkar 	 * disabled it, we don't enable fast commits.
1751a1e5e465SHarshad Shirwadkar 	 */
1752a1e5e465SHarshad Shirwadkar 	jbd2_clear_feature_fast_commit(journal);
1753a1e5e465SHarshad Shirwadkar 
1754a1e5e465SHarshad Shirwadkar 	/*
1755470decc6SDave Kleikamp 	 * As a special case, if the on-disk copy is already marked as needing
175624bcc89cSJan Kara 	 * no recovery (s_start == 0), then we can safely defer the superblock
175724bcc89cSJan Kara 	 * update until the next commit by setting JBD2_FLUSHED.  This avoids
1758470decc6SDave Kleikamp 	 * attempting a write to a potential-readonly device.
1759470decc6SDave Kleikamp 	 */
176024bcc89cSJan Kara 	if (sb->s_start == 0) {
1761cb3b3bf2SJan Kara 		jbd2_debug(1, "JBD2: Skipping superblock update on recovered sb "
17627821ce41SGaowei Pu 			"(start %ld, seq %u, errno %d)\n",
1763470decc6SDave Kleikamp 			journal->j_tail, journal->j_tail_sequence,
1764470decc6SDave Kleikamp 			journal->j_errno);
176524bcc89cSJan Kara 		journal->j_flags |= JBD2_FLUSHED;
176624bcc89cSJan Kara 	} else {
1767a78bb11dSJan Kara 		/* Lock here to make assertions happy... */
17686fa7aa50STejun Heo 		mutex_lock_io(&journal->j_checkpoint_mutex);
176979feb521SJan Kara 		/*
177070fd7614SChristoph Hellwig 		 * Update log tail information. We use REQ_FUA since new
177179feb521SJan Kara 		 * transaction will start reusing journal space and so we
177279feb521SJan Kara 		 * must make sure information about current log tail is on
177379feb521SJan Kara 		 * disk before that.
177479feb521SJan Kara 		 */
177579feb521SJan Kara 		jbd2_journal_update_sb_log_tail(journal,
177679feb521SJan Kara 						journal->j_tail_sequence,
177779feb521SJan Kara 						journal->j_tail,
177817f423b5SJan Kara 						REQ_SYNC | REQ_FUA);
1779a78bb11dSJan Kara 		mutex_unlock(&journal->j_checkpoint_mutex);
178024bcc89cSJan Kara 	}
178124bcc89cSJan Kara 	return jbd2_journal_start_thread(journal);
1782470decc6SDave Kleikamp }
1783470decc6SDave Kleikamp 
1784538bcaa6STheodore Ts'o /*
1785538bcaa6STheodore Ts'o  * This function expects that the caller will have locked the journal
1786538bcaa6STheodore Ts'o  * buffer head, and will return with it unlocked
1787538bcaa6STheodore Ts'o  */
17886669797bSBart Van Assche static int jbd2_write_superblock(journal_t *journal, blk_opf_t write_flags)
178924bcc89cSJan Kara {
179024bcc89cSJan Kara 	struct buffer_head *bh = journal->j_sb_buffer;
1791fe52d17cSTheodore Ts'o 	journal_superblock_t *sb = journal->j_superblock;
1792f3ed5df3SRitesh Harjani (IBM) 	int ret = 0;
179324bcc89cSJan Kara 
1794742b06b5SJiufei Xue 	/* Buffer got discarded which means block device got invalidated */
1795ef3f5830Szhangyi (F) 	if (!buffer_mapped(bh)) {
1796ef3f5830Szhangyi (F) 		unlock_buffer(bh);
1797742b06b5SJiufei Xue 		return -EIO;
1798ef3f5830Szhangyi (F) 	}
1799742b06b5SJiufei Xue 
18002a222ca9SMike Christie 	trace_jbd2_write_superblock(journal, write_flags);
180179feb521SJan Kara 	if (!(journal->j_flags & JBD2_BARRIER))
180228a8f0d3SMike Christie 		write_flags &= ~(REQ_FUA | REQ_PREFLUSH);
1803914258bfSTheodore Ts'o 	if (buffer_write_io_error(bh)) {
1804914258bfSTheodore Ts'o 		/*
1805914258bfSTheodore Ts'o 		 * Oh, dear.  A previous attempt to write the journal
1806914258bfSTheodore Ts'o 		 * superblock failed.  This could happen because the
1807914258bfSTheodore Ts'o 		 * USB device was yanked out.  Or it could happen to
1808914258bfSTheodore Ts'o 		 * be a transient write error and maybe the block will
1809914258bfSTheodore Ts'o 		 * be remapped.  Nothing we can do but to retry the
1810914258bfSTheodore Ts'o 		 * write and hope for the best.
1811914258bfSTheodore Ts'o 		 */
1812914258bfSTheodore Ts'o 		printk(KERN_ERR "JBD2: previous I/O error detected "
1813914258bfSTheodore Ts'o 		       "for journal superblock update for %s.\n",
1814914258bfSTheodore Ts'o 		       journal->j_devname);
1815914258bfSTheodore Ts'o 		clear_buffer_write_io_error(bh);
1816914258bfSTheodore Ts'o 		set_buffer_uptodate(bh);
1817914258bfSTheodore Ts'o 	}
1818a58ca992STheodore Ts'o 	if (jbd2_journal_has_csum_v2or3(journal))
1819a58ca992STheodore Ts'o 		sb->s_checksum = jbd2_superblock_csum(journal, sb);
182079feb521SJan Kara 	get_bh(bh);
182179feb521SJan Kara 	bh->b_end_io = end_buffer_write_sync;
1822f3ed5df3SRitesh Harjani (IBM) 	submit_bh(REQ_OP_WRITE | write_flags, bh);
182379feb521SJan Kara 	wait_on_buffer(bh);
1824914258bfSTheodore Ts'o 	if (buffer_write_io_error(bh)) {
1825914258bfSTheodore Ts'o 		clear_buffer_write_io_error(bh);
1826914258bfSTheodore Ts'o 		set_buffer_uptodate(bh);
182779feb521SJan Kara 		ret = -EIO;
182879feb521SJan Kara 	}
182979feb521SJan Kara 	if (ret) {
1830f3ed5df3SRitesh Harjani (IBM) 		printk(KERN_ERR "JBD2: I/O error when updating journal superblock for %s.\n",
183179feb521SJan Kara 				journal->j_devname);
18327b97d868Szhangyi (F) 		if (!is_journal_aborted(journal))
18336f6a6fdaSJoseph Qi 			jbd2_journal_abort(journal, ret);
1834914258bfSTheodore Ts'o 	}
18356f6a6fdaSJoseph Qi 
18366f6a6fdaSJoseph Qi 	return ret;
183724bcc89cSJan Kara }
1838470decc6SDave Kleikamp 
183924bcc89cSJan Kara /**
184024bcc89cSJan Kara  * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk.
184124bcc89cSJan Kara  * @journal: The journal to update.
184279feb521SJan Kara  * @tail_tid: TID of the new transaction at the tail of the log
184379feb521SJan Kara  * @tail_block: The first block of the transaction at the tail of the log
18446669797bSBart Van Assche  * @write_flags: Flags for the journal sb write operation
184524bcc89cSJan Kara  *
184624bcc89cSJan Kara  * Update a journal's superblock information about log tail and write it to
184724bcc89cSJan Kara  * disk, waiting for the IO to complete.
184824bcc89cSJan Kara  */
18496f6a6fdaSJoseph Qi int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
18506669797bSBart Van Assche 				    unsigned long tail_block,
18516669797bSBart Van Assche 				    blk_opf_t write_flags)
185224bcc89cSJan Kara {
185324bcc89cSJan Kara 	journal_superblock_t *sb = journal->j_superblock;
18546f6a6fdaSJoseph Qi 	int ret;
18552201c590SSeiji Aguchi 
185685e0c4e8STheodore Ts'o 	if (is_journal_aborted(journal))
185785e0c4e8STheodore Ts'o 		return -EIO;
1858fcf37549SZhang Yi 	if (test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) {
1859fcf37549SZhang Yi 		jbd2_journal_abort(journal, -EIO);
1860fcf37549SZhang Yi 		return -EIO;
1861fcf37549SZhang Yi 	}
186285e0c4e8STheodore Ts'o 
1863a78bb11dSJan Kara 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1864cb3b3bf2SJan Kara 	jbd2_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n",
186579feb521SJan Kara 		  tail_block, tail_tid);
1866470decc6SDave Kleikamp 
1867538bcaa6STheodore Ts'o 	lock_buffer(journal->j_sb_buffer);
186879feb521SJan Kara 	sb->s_sequence = cpu_to_be32(tail_tid);
186979feb521SJan Kara 	sb->s_start    = cpu_to_be32(tail_block);
187024bcc89cSJan Kara 
18716669797bSBart Van Assche 	ret = jbd2_write_superblock(journal, write_flags);
18726f6a6fdaSJoseph Qi 	if (ret)
18736f6a6fdaSJoseph Qi 		goto out;
187424bcc89cSJan Kara 
187524bcc89cSJan Kara 	/* Log is no longer empty */
1876a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
187724bcc89cSJan Kara 	WARN_ON(!sb->s_sequence);
1878f7f4bccbSMingming Cao 	journal->j_flags &= ~JBD2_FLUSHED;
187924bcc89cSJan Kara 	write_unlock(&journal->j_state_lock);
18806f6a6fdaSJoseph Qi 
18816f6a6fdaSJoseph Qi out:
18826f6a6fdaSJoseph Qi 	return ret;
188324bcc89cSJan Kara }
188424bcc89cSJan Kara 
188524bcc89cSJan Kara /**
188624bcc89cSJan Kara  * jbd2_mark_journal_empty() - Mark on disk journal as empty.
188724bcc89cSJan Kara  * @journal: The journal to update.
18886669797bSBart Van Assche  * @write_flags: Flags for the journal sb write operation
188924bcc89cSJan Kara  *
189024bcc89cSJan Kara  * Update a journal's dynamic superblock fields to show that journal is empty.
189124bcc89cSJan Kara  * Write updated superblock to disk waiting for IO to complete.
189224bcc89cSJan Kara  */
18936669797bSBart Van Assche static void jbd2_mark_journal_empty(journal_t *journal, blk_opf_t write_flags)
189424bcc89cSJan Kara {
189524bcc89cSJan Kara 	journal_superblock_t *sb = journal->j_superblock;
1896ff780b91SHarshad Shirwadkar 	bool had_fast_commit = false;
189724bcc89cSJan Kara 
1898a78bb11dSJan Kara 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1899538bcaa6STheodore Ts'o 	lock_buffer(journal->j_sb_buffer);
1900538bcaa6STheodore Ts'o 	if (sb->s_start == 0) {		/* Is it already empty? */
1901538bcaa6STheodore Ts'o 		unlock_buffer(journal->j_sb_buffer);
1902eeecef0aSEric Sandeen 		return;
1903eeecef0aSEric Sandeen 	}
1904538bcaa6STheodore Ts'o 
1905cb3b3bf2SJan Kara 	jbd2_debug(1, "JBD2: Marking journal as empty (seq %u)\n",
190624bcc89cSJan Kara 		  journal->j_tail_sequence);
1907470decc6SDave Kleikamp 
1908470decc6SDave Kleikamp 	sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
190924bcc89cSJan Kara 	sb->s_start    = cpu_to_be32(0);
1910c7fc6055SZhang Yi 	sb->s_head     = cpu_to_be32(journal->j_head);
1911ff780b91SHarshad Shirwadkar 	if (jbd2_has_feature_fast_commit(journal)) {
1912ff780b91SHarshad Shirwadkar 		/*
1913ff780b91SHarshad Shirwadkar 		 * When journal is clean, no need to commit fast commit flag and
1914ff780b91SHarshad Shirwadkar 		 * make file system incompatible with older kernels.
1915ff780b91SHarshad Shirwadkar 		 */
1916ff780b91SHarshad Shirwadkar 		jbd2_clear_feature_fast_commit(journal);
1917ff780b91SHarshad Shirwadkar 		had_fast_commit = true;
1918ff780b91SHarshad Shirwadkar 	}
191924bcc89cSJan Kara 
19206669797bSBart Van Assche 	jbd2_write_superblock(journal, write_flags);
192124bcc89cSJan Kara 
1922ff780b91SHarshad Shirwadkar 	if (had_fast_commit)
1923ff780b91SHarshad Shirwadkar 		jbd2_set_feature_fast_commit(journal);
1924ff780b91SHarshad Shirwadkar 
192524bcc89cSJan Kara 	/* Log is no longer empty */
192624bcc89cSJan Kara 	write_lock(&journal->j_state_lock);
1927f7f4bccbSMingming Cao 	journal->j_flags |= JBD2_FLUSHED;
1928a931da6aSTheodore Ts'o 	write_unlock(&journal->j_state_lock);
1929470decc6SDave Kleikamp }
1930470decc6SDave Kleikamp 
193101d5d965SLeah Rumancik /**
193201d5d965SLeah Rumancik  * __jbd2_journal_erase() - Discard or zeroout journal blocks (excluding superblock)
193301d5d965SLeah Rumancik  * @journal: The journal to erase.
193401d5d965SLeah Rumancik  * @flags: A discard/zeroout request is sent for each physically contigous
193501d5d965SLeah Rumancik  *	region of the journal. Either JBD2_JOURNAL_FLUSH_DISCARD or
193601d5d965SLeah Rumancik  *	JBD2_JOURNAL_FLUSH_ZEROOUT must be set to determine which operation
193701d5d965SLeah Rumancik  *	to perform.
193801d5d965SLeah Rumancik  *
193901d5d965SLeah Rumancik  * Note: JBD2_JOURNAL_FLUSH_ZEROOUT attempts to use hardware offload. Zeroes
194001d5d965SLeah Rumancik  * will be explicitly written if no hardware offload is available, see
194101d5d965SLeah Rumancik  * blkdev_issue_zeroout for more details.
194201d5d965SLeah Rumancik  */
194301d5d965SLeah Rumancik static int __jbd2_journal_erase(journal_t *journal, unsigned int flags)
194401d5d965SLeah Rumancik {
194501d5d965SLeah Rumancik 	int err = 0;
194601d5d965SLeah Rumancik 	unsigned long block, log_offset; /* logical */
194701d5d965SLeah Rumancik 	unsigned long long phys_block, block_start, block_stop; /* physical */
194801d5d965SLeah Rumancik 	loff_t byte_start, byte_stop, byte_count;
194901d5d965SLeah Rumancik 
195001d5d965SLeah Rumancik 	/* flags must be set to either discard or zeroout */
195101d5d965SLeah Rumancik 	if ((flags & ~JBD2_JOURNAL_FLUSH_VALID) || !flags ||
195201d5d965SLeah Rumancik 			((flags & JBD2_JOURNAL_FLUSH_DISCARD) &&
195301d5d965SLeah Rumancik 			(flags & JBD2_JOURNAL_FLUSH_ZEROOUT)))
195401d5d965SLeah Rumancik 		return -EINVAL;
195501d5d965SLeah Rumancik 
195670200574SChristoph Hellwig 	if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) &&
195770200574SChristoph Hellwig 	    !bdev_max_discard_sectors(journal->j_dev))
195801d5d965SLeah Rumancik 		return -EOPNOTSUPP;
195901d5d965SLeah Rumancik 
196001d5d965SLeah Rumancik 	/*
196101d5d965SLeah Rumancik 	 * lookup block mapping and issue discard/zeroout for each
196201d5d965SLeah Rumancik 	 * contiguous region
196301d5d965SLeah Rumancik 	 */
196401d5d965SLeah Rumancik 	log_offset = be32_to_cpu(journal->j_superblock->s_first);
196501d5d965SLeah Rumancik 	block_start =  ~0ULL;
196601d5d965SLeah Rumancik 	for (block = log_offset; block < journal->j_total_len; block++) {
196701d5d965SLeah Rumancik 		err = jbd2_journal_bmap(journal, block, &phys_block);
196801d5d965SLeah Rumancik 		if (err) {
196901d5d965SLeah Rumancik 			pr_err("JBD2: bad block at offset %lu", block);
197001d5d965SLeah Rumancik 			return err;
197101d5d965SLeah Rumancik 		}
197201d5d965SLeah Rumancik 
197301d5d965SLeah Rumancik 		if (block_start == ~0ULL) {
197401d5d965SLeah Rumancik 			block_start = phys_block;
197501d5d965SLeah Rumancik 			block_stop = block_start - 1;
197601d5d965SLeah Rumancik 		}
197701d5d965SLeah Rumancik 
197801d5d965SLeah Rumancik 		/*
197901d5d965SLeah Rumancik 		 * last block not contiguous with current block,
198001d5d965SLeah Rumancik 		 * process last contiguous region and return to this block on
198101d5d965SLeah Rumancik 		 * next loop
198201d5d965SLeah Rumancik 		 */
198301d5d965SLeah Rumancik 		if (phys_block != block_stop + 1) {
198401d5d965SLeah Rumancik 			block--;
198501d5d965SLeah Rumancik 		} else {
198601d5d965SLeah Rumancik 			block_stop++;
198701d5d965SLeah Rumancik 			/*
198801d5d965SLeah Rumancik 			 * if this isn't the last block of journal,
198901d5d965SLeah Rumancik 			 * no need to process now because next block may also
199001d5d965SLeah Rumancik 			 * be part of this contiguous region
199101d5d965SLeah Rumancik 			 */
199201d5d965SLeah Rumancik 			if (block != journal->j_total_len - 1)
199301d5d965SLeah Rumancik 				continue;
199401d5d965SLeah Rumancik 		}
199501d5d965SLeah Rumancik 
199601d5d965SLeah Rumancik 		/*
199701d5d965SLeah Rumancik 		 * end of contiguous region or this is last block of journal,
199801d5d965SLeah Rumancik 		 * take care of the region
199901d5d965SLeah Rumancik 		 */
200001d5d965SLeah Rumancik 		byte_start = block_start * journal->j_blocksize;
200101d5d965SLeah Rumancik 		byte_stop = block_stop * journal->j_blocksize;
200201d5d965SLeah Rumancik 		byte_count = (block_stop - block_start + 1) *
200301d5d965SLeah Rumancik 				journal->j_blocksize;
200401d5d965SLeah Rumancik 
200501d5d965SLeah Rumancik 		truncate_inode_pages_range(journal->j_dev->bd_inode->i_mapping,
200601d5d965SLeah Rumancik 				byte_start, byte_stop);
200701d5d965SLeah Rumancik 
200801d5d965SLeah Rumancik 		if (flags & JBD2_JOURNAL_FLUSH_DISCARD) {
200901d5d965SLeah Rumancik 			err = blkdev_issue_discard(journal->j_dev,
201001d5d965SLeah Rumancik 					byte_start >> SECTOR_SHIFT,
201101d5d965SLeah Rumancik 					byte_count >> SECTOR_SHIFT,
201244abff2cSChristoph Hellwig 					GFP_NOFS);
201301d5d965SLeah Rumancik 		} else if (flags & JBD2_JOURNAL_FLUSH_ZEROOUT) {
201401d5d965SLeah Rumancik 			err = blkdev_issue_zeroout(journal->j_dev,
201501d5d965SLeah Rumancik 					byte_start >> SECTOR_SHIFT,
201601d5d965SLeah Rumancik 					byte_count >> SECTOR_SHIFT,
201701d5d965SLeah Rumancik 					GFP_NOFS, 0);
201801d5d965SLeah Rumancik 		}
201901d5d965SLeah Rumancik 
202001d5d965SLeah Rumancik 		if (unlikely(err != 0)) {
202101d5d965SLeah Rumancik 			pr_err("JBD2: (error %d) unable to wipe journal at physical blocks %llu - %llu",
202201d5d965SLeah Rumancik 					err, block_start, block_stop);
202301d5d965SLeah Rumancik 			return err;
202401d5d965SLeah Rumancik 		}
202501d5d965SLeah Rumancik 
202601d5d965SLeah Rumancik 		/* reset start and stop after processing a region */
202701d5d965SLeah Rumancik 		block_start = ~0ULL;
202801d5d965SLeah Rumancik 	}
202901d5d965SLeah Rumancik 
203001d5d965SLeah Rumancik 	return blkdev_issue_flush(journal->j_dev);
203101d5d965SLeah Rumancik }
203224bcc89cSJan Kara 
203324bcc89cSJan Kara /**
203424bcc89cSJan Kara  * jbd2_journal_update_sb_errno() - Update error in the journal.
203524bcc89cSJan Kara  * @journal: The journal to update.
203624bcc89cSJan Kara  *
203724bcc89cSJan Kara  * Update a journal's errno.  Write updated superblock to disk waiting for IO
203824bcc89cSJan Kara  * to complete.
203924bcc89cSJan Kara  */
2040d796c52eSTheodore Ts'o void jbd2_journal_update_sb_errno(journal_t *journal)
204124bcc89cSJan Kara {
204224bcc89cSJan Kara 	journal_superblock_t *sb = journal->j_superblock;
2043fb7c0244STheodore Ts'o 	int errcode;
204424bcc89cSJan Kara 
2045538bcaa6STheodore Ts'o 	lock_buffer(journal->j_sb_buffer);
2046fb7c0244STheodore Ts'o 	errcode = journal->j_errno;
2047fb7c0244STheodore Ts'o 	if (errcode == -ESHUTDOWN)
2048fb7c0244STheodore Ts'o 		errcode = 0;
2049cb3b3bf2SJan Kara 	jbd2_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode);
2050fb7c0244STheodore Ts'o 	sb->s_errno    = cpu_to_be32(errcode);
2051470decc6SDave Kleikamp 
205217f423b5SJan Kara 	jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA);
2053470decc6SDave Kleikamp }
2054d796c52eSTheodore Ts'o EXPORT_SYMBOL(jbd2_journal_update_sb_errno);
2055470decc6SDave Kleikamp 
2056470decc6SDave Kleikamp /**
20572bf31d94SMauro Carvalho Chehab  * jbd2_journal_load() - Read journal from disk.
2058470decc6SDave Kleikamp  * @journal: Journal to act on.
2059470decc6SDave Kleikamp  *
2060470decc6SDave Kleikamp  * Given a journal_t structure which tells us which disk blocks contain
2061470decc6SDave Kleikamp  * a journal, read the journal from disk to initialise the in-memory
2062470decc6SDave Kleikamp  * structures.
2063470decc6SDave Kleikamp  */
2064f7f4bccbSMingming Cao int jbd2_journal_load(journal_t *journal)
2065470decc6SDave Kleikamp {
2066470decc6SDave Kleikamp 	int err;
2067c3071308SZhang Yi 	journal_superblock_t *sb = journal->j_superblock;
2068470decc6SDave Kleikamp 
20695cf036d4SZhang Yi 	/*
2070d2eecb03STheodore Ts'o 	 * Create a slab for this blocksize
2071d2eecb03STheodore Ts'o 	 */
2072d2eecb03STheodore Ts'o 	err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize));
2073d2eecb03STheodore Ts'o 	if (err)
2074d2eecb03STheodore Ts'o 		return err;
2075d2eecb03STheodore Ts'o 
2076470decc6SDave Kleikamp 	/* Let the recovery code check whether it needs to recover any
2077470decc6SDave Kleikamp 	 * data from the journal. */
20781d401650SGuoqing Cai 	err = jbd2_journal_recover(journal);
20791d401650SGuoqing Cai 	if (err) {
20801d401650SGuoqing Cai 		pr_warn("JBD2: journal recovery failed\n");
20811d401650SGuoqing Cai 		return err;
20821d401650SGuoqing Cai 	}
2083470decc6SDave Kleikamp 
2084e6a47428STheodore Ts'o 	if (journal->j_failed_commit) {
2085e6a47428STheodore Ts'o 		printk(KERN_ERR "JBD2: journal transaction %u on %s "
2086e6a47428STheodore Ts'o 		       "is corrupt.\n", journal->j_failed_commit,
2087e6a47428STheodore Ts'o 		       journal->j_devname);
20886a797d27SDarrick J. Wong 		return -EFSCORRUPTED;
2089e6a47428STheodore Ts'o 	}
2090a09decffSKai Li 	/*
2091a09decffSKai Li 	 * clear JBD2_ABORT flag initialized in journal_init_common
2092a09decffSKai Li 	 * here to update log tail information with the newest seq.
2093a09decffSKai Li 	 */
2094a09decffSKai Li 	journal->j_flags &= ~JBD2_ABORT;
2095e6a47428STheodore Ts'o 
2096470decc6SDave Kleikamp 	/* OK, we've finished with the dynamic journal bits:
2097470decc6SDave Kleikamp 	 * reinitialise the dynamic contents of the superblock in memory
2098470decc6SDave Kleikamp 	 * and reset them on disk. */
20991d401650SGuoqing Cai 	err = journal_reset(journal);
21001d401650SGuoqing Cai 	if (err) {
21011d401650SGuoqing Cai 		pr_warn("JBD2: journal reset failed\n");
21021d401650SGuoqing Cai 		return err;
21031d401650SGuoqing Cai 	}
2104470decc6SDave Kleikamp 
2105f7f4bccbSMingming Cao 	journal->j_flags |= JBD2_LOADED;
2106470decc6SDave Kleikamp 	return 0;
2107470decc6SDave Kleikamp }
2108470decc6SDave Kleikamp 
2109470decc6SDave Kleikamp /**
21102bf31d94SMauro Carvalho Chehab  * jbd2_journal_destroy() - Release a journal_t structure.
2111470decc6SDave Kleikamp  * @journal: Journal to act on.
2112470decc6SDave Kleikamp  *
2113470decc6SDave Kleikamp  * Release a journal_t structure once it is no longer in use by the
2114470decc6SDave Kleikamp  * journaled object.
211544519fafSHidehiro Kawai  * Return <0 if we couldn't clean up the journal.
2116470decc6SDave Kleikamp  */
211744519fafSHidehiro Kawai int jbd2_journal_destroy(journal_t *journal)
2118470decc6SDave Kleikamp {
211944519fafSHidehiro Kawai 	int err = 0;
212044519fafSHidehiro Kawai 
2121470decc6SDave Kleikamp 	/* Wait for the commit thread to wake up and die. */
2122470decc6SDave Kleikamp 	journal_kill_thread(journal);
2123470decc6SDave Kleikamp 
2124470decc6SDave Kleikamp 	/* Force a final log commit */
2125470decc6SDave Kleikamp 	if (journal->j_running_transaction)
2126f7f4bccbSMingming Cao 		jbd2_journal_commit_transaction(journal);
2127470decc6SDave Kleikamp 
2128470decc6SDave Kleikamp 	/* Force any old transactions to disk */
2129470decc6SDave Kleikamp 
2130470decc6SDave Kleikamp 	/* Totally anal locking here... */
2131470decc6SDave Kleikamp 	spin_lock(&journal->j_list_lock);
2132470decc6SDave Kleikamp 	while (journal->j_checkpoint_transactions != NULL) {
2133470decc6SDave Kleikamp 		spin_unlock(&journal->j_list_lock);
21346fa7aa50STejun Heo 		mutex_lock_io(&journal->j_checkpoint_mutex);
2135841df7dfSJan Kara 		err = jbd2_log_do_checkpoint(journal);
21361a0d3786STheodore Ts'o 		mutex_unlock(&journal->j_checkpoint_mutex);
2137841df7dfSJan Kara 		/*
2138841df7dfSJan Kara 		 * If checkpointing failed, just free the buffers to avoid
2139841df7dfSJan Kara 		 * looping forever
2140841df7dfSJan Kara 		 */
2141841df7dfSJan Kara 		if (err) {
2142841df7dfSJan Kara 			jbd2_journal_destroy_checkpoint(journal);
2143841df7dfSJan Kara 			spin_lock(&journal->j_list_lock);
2144841df7dfSJan Kara 			break;
2145841df7dfSJan Kara 		}
2146470decc6SDave Kleikamp 		spin_lock(&journal->j_list_lock);
2147470decc6SDave Kleikamp 	}
2148470decc6SDave Kleikamp 
2149470decc6SDave Kleikamp 	J_ASSERT(journal->j_running_transaction == NULL);
2150470decc6SDave Kleikamp 	J_ASSERT(journal->j_committing_transaction == NULL);
2151470decc6SDave Kleikamp 	J_ASSERT(journal->j_checkpoint_transactions == NULL);
2152470decc6SDave Kleikamp 	spin_unlock(&journal->j_list_lock);
2153470decc6SDave Kleikamp 
2154fcf37549SZhang Yi 	/*
2155fcf37549SZhang Yi 	 * OK, all checkpoint transactions have been checked, now check the
2156fcf37549SZhang Yi 	 * write out io error flag and abort the journal if some buffer failed
2157fcf37549SZhang Yi 	 * to write back to the original location, otherwise the filesystem
2158fcf37549SZhang Yi 	 * may become inconsistent.
2159fcf37549SZhang Yi 	 */
2160fcf37549SZhang Yi 	if (!is_journal_aborted(journal) &&
2161fcf37549SZhang Yi 	    test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags))
2162fcf37549SZhang Yi 		jbd2_journal_abort(journal, -EIO);
2163fcf37549SZhang Yi 
216444519fafSHidehiro Kawai 	if (journal->j_sb_buffer) {
216544519fafSHidehiro Kawai 		if (!is_journal_aborted(journal)) {
21666fa7aa50STejun Heo 			mutex_lock_io(&journal->j_checkpoint_mutex);
2167c0a2ad9bSOGAWA Hirofumi 
2168c0a2ad9bSOGAWA Hirofumi 			write_lock(&journal->j_state_lock);
2169c0a2ad9bSOGAWA Hirofumi 			journal->j_tail_sequence =
2170c0a2ad9bSOGAWA Hirofumi 				++journal->j_transaction_sequence;
2171c0a2ad9bSOGAWA Hirofumi 			write_unlock(&journal->j_state_lock);
2172c0a2ad9bSOGAWA Hirofumi 
217370fd7614SChristoph Hellwig 			jbd2_mark_journal_empty(journal,
217417f423b5SJan Kara 					REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
2175a78bb11dSJan Kara 			mutex_unlock(&journal->j_checkpoint_mutex);
2176a78bb11dSJan Kara 		} else
217744519fafSHidehiro Kawai 			err = -EIO;
2178470decc6SDave Kleikamp 		brelse(journal->j_sb_buffer);
2179470decc6SDave Kleikamp 	}
2180470decc6SDave Kleikamp 
21810705e8d1STheodore Ts'o 	if (journal->j_shrinker.flags & SHRINKER_REGISTERED) {
21820705e8d1STheodore Ts'o 		percpu_counter_destroy(&journal->j_checkpoint_jh_count);
21830705e8d1STheodore Ts'o 		unregister_shrinker(&journal->j_shrinker);
21840705e8d1STheodore Ts'o 	}
21858e85fb3fSJohann Lombardi 	if (journal->j_proc_entry)
21868e85fb3fSJohann Lombardi 		jbd2_stats_proc_exit(journal);
2187470decc6SDave Kleikamp 	iput(journal->j_inode);
2188470decc6SDave Kleikamp 	if (journal->j_revoke)
2189f7f4bccbSMingming Cao 		jbd2_journal_destroy_revoke(journal);
219001b5adceSDarrick J. Wong 	if (journal->j_chksum_driver)
219101b5adceSDarrick J. Wong 		crypto_free_shash(journal->j_chksum_driver);
21926866d7b3SHarshad Shirwadkar 	kfree(journal->j_fc_wbuf);
2193470decc6SDave Kleikamp 	kfree(journal->j_wbuf);
2194470decc6SDave Kleikamp 	kfree(journal);
219544519fafSHidehiro Kawai 
219644519fafSHidehiro Kawai 	return err;
2197470decc6SDave Kleikamp }
2198470decc6SDave Kleikamp 
2199470decc6SDave Kleikamp 
2200470decc6SDave Kleikamp /**
22012bf31d94SMauro Carvalho Chehab  * jbd2_journal_check_used_features() - Check if features specified are used.
2202470decc6SDave Kleikamp  * @journal: Journal to check.
2203470decc6SDave Kleikamp  * @compat: bitmask of compatible features
2204470decc6SDave Kleikamp  * @ro: bitmask of features that force read-only mount
2205470decc6SDave Kleikamp  * @incompat: bitmask of incompatible features
2206470decc6SDave Kleikamp  *
2207470decc6SDave Kleikamp  * Check whether the journal uses all of a given set of
2208470decc6SDave Kleikamp  * features.  Return true (non-zero) if it does.
2209470decc6SDave Kleikamp  **/
2210470decc6SDave Kleikamp 
2211f7f4bccbSMingming Cao int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat,
2212470decc6SDave Kleikamp 				 unsigned long ro, unsigned long incompat)
2213470decc6SDave Kleikamp {
2214470decc6SDave Kleikamp 	journal_superblock_t *sb;
2215470decc6SDave Kleikamp 
2216470decc6SDave Kleikamp 	if (!compat && !ro && !incompat)
2217470decc6SDave Kleikamp 		return 1;
22185cf036d4SZhang Yi 	if (!jbd2_format_support_feature(journal))
2219470decc6SDave Kleikamp 		return 0;
2220470decc6SDave Kleikamp 
2221470decc6SDave Kleikamp 	sb = journal->j_superblock;
2222470decc6SDave Kleikamp 
2223470decc6SDave Kleikamp 	if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
2224470decc6SDave Kleikamp 	    ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
2225470decc6SDave Kleikamp 	    ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
2226470decc6SDave Kleikamp 		return 1;
2227470decc6SDave Kleikamp 
2228470decc6SDave Kleikamp 	return 0;
2229470decc6SDave Kleikamp }
2230470decc6SDave Kleikamp 
2231470decc6SDave Kleikamp /**
22322bf31d94SMauro Carvalho Chehab  * jbd2_journal_check_available_features() - Check feature set in journalling layer
2233470decc6SDave Kleikamp  * @journal: Journal to check.
2234470decc6SDave Kleikamp  * @compat: bitmask of compatible features
2235470decc6SDave Kleikamp  * @ro: bitmask of features that force read-only mount
2236470decc6SDave Kleikamp  * @incompat: bitmask of incompatible features
2237470decc6SDave Kleikamp  *
2238470decc6SDave Kleikamp  * Check whether the journaling code supports the use of
2239470decc6SDave Kleikamp  * all of a given set of features on this journal.  Return true
2240470decc6SDave Kleikamp  * (non-zero) if it can. */
2241470decc6SDave Kleikamp 
2242f7f4bccbSMingming Cao int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat,
2243470decc6SDave Kleikamp 				      unsigned long ro, unsigned long incompat)
2244470decc6SDave Kleikamp {
2245470decc6SDave Kleikamp 	if (!compat && !ro && !incompat)
2246470decc6SDave Kleikamp 		return 1;
2247470decc6SDave Kleikamp 
22485cf036d4SZhang Yi 	if (!jbd2_format_support_feature(journal))
2249470decc6SDave Kleikamp 		return 0;
2250470decc6SDave Kleikamp 
2251f7f4bccbSMingming Cao 	if ((compat   & JBD2_KNOWN_COMPAT_FEATURES) == compat &&
2252f7f4bccbSMingming Cao 	    (ro       & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro &&
2253f7f4bccbSMingming Cao 	    (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat)
2254470decc6SDave Kleikamp 		return 1;
2255470decc6SDave Kleikamp 
2256470decc6SDave Kleikamp 	return 0;
2257470decc6SDave Kleikamp }
2258470decc6SDave Kleikamp 
2259a1e5e465SHarshad Shirwadkar static int
2260a1e5e465SHarshad Shirwadkar jbd2_journal_initialize_fast_commit(journal_t *journal)
2261a1e5e465SHarshad Shirwadkar {
2262a1e5e465SHarshad Shirwadkar 	journal_superblock_t *sb = journal->j_superblock;
2263a1e5e465SHarshad Shirwadkar 	unsigned long long num_fc_blks;
2264a1e5e465SHarshad Shirwadkar 
22659bd23c31SHarshad Shirwadkar 	num_fc_blks = jbd2_journal_get_num_fc_blks(sb);
2266a1e5e465SHarshad Shirwadkar 	if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS)
2267a1e5e465SHarshad Shirwadkar 		return -ENOSPC;
2268a1e5e465SHarshad Shirwadkar 
2269a1e5e465SHarshad Shirwadkar 	/* Are we called twice? */
2270a1e5e465SHarshad Shirwadkar 	WARN_ON(journal->j_fc_wbuf != NULL);
2271a1e5e465SHarshad Shirwadkar 	journal->j_fc_wbuf = kmalloc_array(num_fc_blks,
2272a1e5e465SHarshad Shirwadkar 				sizeof(struct buffer_head *), GFP_KERNEL);
2273a1e5e465SHarshad Shirwadkar 	if (!journal->j_fc_wbuf)
2274a1e5e465SHarshad Shirwadkar 		return -ENOMEM;
2275a1e5e465SHarshad Shirwadkar 
2276a1e5e465SHarshad Shirwadkar 	journal->j_fc_wbufsize = num_fc_blks;
2277a1e5e465SHarshad Shirwadkar 	journal->j_fc_last = journal->j_last;
2278a1e5e465SHarshad Shirwadkar 	journal->j_last = journal->j_fc_last - num_fc_blks;
2279a1e5e465SHarshad Shirwadkar 	journal->j_fc_first = journal->j_last + 1;
2280a1e5e465SHarshad Shirwadkar 	journal->j_fc_off = 0;
2281a1e5e465SHarshad Shirwadkar 	journal->j_free = journal->j_last - journal->j_first;
2282a1e5e465SHarshad Shirwadkar 	journal->j_max_transaction_buffers =
2283a1e5e465SHarshad Shirwadkar 		jbd2_journal_get_max_txn_bufs(journal);
2284a1e5e465SHarshad Shirwadkar 
2285a1e5e465SHarshad Shirwadkar 	return 0;
2286a1e5e465SHarshad Shirwadkar }
2287a1e5e465SHarshad Shirwadkar 
2288470decc6SDave Kleikamp /**
22892bf31d94SMauro Carvalho Chehab  * jbd2_journal_set_features() - Mark a given journal feature in the superblock
2290470decc6SDave Kleikamp  * @journal: Journal to act on.
2291470decc6SDave Kleikamp  * @compat: bitmask of compatible features
2292470decc6SDave Kleikamp  * @ro: bitmask of features that force read-only mount
2293470decc6SDave Kleikamp  * @incompat: bitmask of incompatible features
2294470decc6SDave Kleikamp  *
2295470decc6SDave Kleikamp  * Mark a given journal feature as present on the
2296470decc6SDave Kleikamp  * superblock.  Returns true if the requested features could be set.
2297470decc6SDave Kleikamp  *
2298470decc6SDave Kleikamp  */
2299470decc6SDave Kleikamp 
2300f7f4bccbSMingming Cao int jbd2_journal_set_features(journal_t *journal, unsigned long compat,
2301470decc6SDave Kleikamp 			  unsigned long ro, unsigned long incompat)
2302470decc6SDave Kleikamp {
230325ed6e8aSDarrick J. Wong #define INCOMPAT_FEATURE_ON(f) \
230425ed6e8aSDarrick J. Wong 		((incompat & (f)) && !(sb->s_feature_incompat & cpu_to_be32(f)))
230525ed6e8aSDarrick J. Wong #define COMPAT_FEATURE_ON(f) \
230625ed6e8aSDarrick J. Wong 		((compat & (f)) && !(sb->s_feature_compat & cpu_to_be32(f)))
2307470decc6SDave Kleikamp 	journal_superblock_t *sb;
2308470decc6SDave Kleikamp 
2309f7f4bccbSMingming Cao 	if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
2310470decc6SDave Kleikamp 		return 1;
2311470decc6SDave Kleikamp 
2312f7f4bccbSMingming Cao 	if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
2313470decc6SDave Kleikamp 		return 0;
2314470decc6SDave Kleikamp 
2315db9ee220SDarrick J. Wong 	/* If enabling v2 checksums, turn on v3 instead */
2316db9ee220SDarrick J. Wong 	if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V2) {
2317db9ee220SDarrick J. Wong 		incompat &= ~JBD2_FEATURE_INCOMPAT_CSUM_V2;
2318db9ee220SDarrick J. Wong 		incompat |= JBD2_FEATURE_INCOMPAT_CSUM_V3;
2319db9ee220SDarrick J. Wong 	}
2320db9ee220SDarrick J. Wong 
2321db9ee220SDarrick J. Wong 	/* Asking for checksumming v3 and v1?  Only give them v3. */
2322db9ee220SDarrick J. Wong 	if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V3 &&
232325ed6e8aSDarrick J. Wong 	    compat & JBD2_FEATURE_COMPAT_CHECKSUM)
232425ed6e8aSDarrick J. Wong 		compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM;
232525ed6e8aSDarrick J. Wong 
2326cb3b3bf2SJan Kara 	jbd2_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
2327470decc6SDave Kleikamp 		  compat, ro, incompat);
2328470decc6SDave Kleikamp 
2329470decc6SDave Kleikamp 	sb = journal->j_superblock;
2330470decc6SDave Kleikamp 
2331a1e5e465SHarshad Shirwadkar 	if (incompat & JBD2_FEATURE_INCOMPAT_FAST_COMMIT) {
2332a1e5e465SHarshad Shirwadkar 		if (jbd2_journal_initialize_fast_commit(journal)) {
2333a1e5e465SHarshad Shirwadkar 			pr_err("JBD2: Cannot enable fast commits.\n");
2334a1e5e465SHarshad Shirwadkar 			return 0;
2335a1e5e465SHarshad Shirwadkar 		}
2336a1e5e465SHarshad Shirwadkar 	}
2337a1e5e465SHarshad Shirwadkar 
2338538bcaa6STheodore Ts'o 	/* Load the checksum driver if necessary */
2339538bcaa6STheodore Ts'o 	if ((journal->j_chksum_driver == NULL) &&
2340538bcaa6STheodore Ts'o 	    INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) {
2341538bcaa6STheodore Ts'o 		journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
2342538bcaa6STheodore Ts'o 		if (IS_ERR(journal->j_chksum_driver)) {
2343538bcaa6STheodore Ts'o 			printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
2344538bcaa6STheodore Ts'o 			journal->j_chksum_driver = NULL;
2345538bcaa6STheodore Ts'o 			return 0;
2346538bcaa6STheodore Ts'o 		}
2347538bcaa6STheodore Ts'o 		/* Precompute checksum seed for all metadata */
2348538bcaa6STheodore Ts'o 		journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
2349538bcaa6STheodore Ts'o 						   sizeof(sb->s_uuid));
2350538bcaa6STheodore Ts'o 	}
2351538bcaa6STheodore Ts'o 
2352538bcaa6STheodore Ts'o 	lock_buffer(journal->j_sb_buffer);
2353538bcaa6STheodore Ts'o 
2354db9ee220SDarrick J. Wong 	/* If enabling v3 checksums, update superblock */
2355db9ee220SDarrick J. Wong 	if (INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) {
235625ed6e8aSDarrick J. Wong 		sb->s_checksum_type = JBD2_CRC32C_CHKSUM;
235725ed6e8aSDarrick J. Wong 		sb->s_feature_compat &=
235825ed6e8aSDarrick J. Wong 			~cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM);
235932f38691SDarrick J. Wong 	}
236025ed6e8aSDarrick J. Wong 
236125ed6e8aSDarrick J. Wong 	/* If enabling v1 checksums, downgrade superblock */
236225ed6e8aSDarrick J. Wong 	if (COMPAT_FEATURE_ON(JBD2_FEATURE_COMPAT_CHECKSUM))
236325ed6e8aSDarrick J. Wong 		sb->s_feature_incompat &=
2364db9ee220SDarrick J. Wong 			~cpu_to_be32(JBD2_FEATURE_INCOMPAT_CSUM_V2 |
2365db9ee220SDarrick J. Wong 				     JBD2_FEATURE_INCOMPAT_CSUM_V3);
236625ed6e8aSDarrick J. Wong 
2367470decc6SDave Kleikamp 	sb->s_feature_compat    |= cpu_to_be32(compat);
2368470decc6SDave Kleikamp 	sb->s_feature_ro_compat |= cpu_to_be32(ro);
2369470decc6SDave Kleikamp 	sb->s_feature_incompat  |= cpu_to_be32(incompat);
2370538bcaa6STheodore Ts'o 	unlock_buffer(journal->j_sb_buffer);
2371fdc3ef88SJan Kara 	journal->j_revoke_records_per_block =
2372fdc3ef88SJan Kara 				journal_revoke_records_per_block(journal);
2373470decc6SDave Kleikamp 
2374470decc6SDave Kleikamp 	return 1;
237525ed6e8aSDarrick J. Wong #undef COMPAT_FEATURE_ON
237625ed6e8aSDarrick J. Wong #undef INCOMPAT_FEATURE_ON
2377470decc6SDave Kleikamp }
2378470decc6SDave Kleikamp 
2379818d276cSGirish Shilamkar /*
2380818d276cSGirish Shilamkar  * jbd2_journal_clear_features() - Clear a given journal feature in the
2381818d276cSGirish Shilamkar  * 				    superblock
2382818d276cSGirish Shilamkar  * @journal: Journal to act on.
2383818d276cSGirish Shilamkar  * @compat: bitmask of compatible features
2384818d276cSGirish Shilamkar  * @ro: bitmask of features that force read-only mount
2385818d276cSGirish Shilamkar  * @incompat: bitmask of incompatible features
2386818d276cSGirish Shilamkar  *
2387818d276cSGirish Shilamkar  * Clear a given journal feature as present on the
2388818d276cSGirish Shilamkar  * superblock.
2389818d276cSGirish Shilamkar  */
2390818d276cSGirish Shilamkar void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
2391818d276cSGirish Shilamkar 				unsigned long ro, unsigned long incompat)
2392818d276cSGirish Shilamkar {
2393818d276cSGirish Shilamkar 	journal_superblock_t *sb;
2394818d276cSGirish Shilamkar 
2395cb3b3bf2SJan Kara 	jbd2_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
2396818d276cSGirish Shilamkar 		  compat, ro, incompat);
2397818d276cSGirish Shilamkar 
2398818d276cSGirish Shilamkar 	sb = journal->j_superblock;
2399818d276cSGirish Shilamkar 
2400818d276cSGirish Shilamkar 	sb->s_feature_compat    &= ~cpu_to_be32(compat);
2401818d276cSGirish Shilamkar 	sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
2402818d276cSGirish Shilamkar 	sb->s_feature_incompat  &= ~cpu_to_be32(incompat);
2403fdc3ef88SJan Kara 	journal->j_revoke_records_per_block =
2404fdc3ef88SJan Kara 				journal_revoke_records_per_block(journal);
2405818d276cSGirish Shilamkar }
2406818d276cSGirish Shilamkar EXPORT_SYMBOL(jbd2_journal_clear_features);
2407470decc6SDave Kleikamp 
2408470decc6SDave Kleikamp /**
24092bf31d94SMauro Carvalho Chehab  * jbd2_journal_flush() - Flush journal
2410470decc6SDave Kleikamp  * @journal: Journal to act on.
241101d5d965SLeah Rumancik  * @flags: optional operation on the journal blocks after the flush (see below)
2412470decc6SDave Kleikamp  *
2413470decc6SDave Kleikamp  * Flush all data for a given journal to disk and empty the journal.
2414470decc6SDave Kleikamp  * Filesystems can use this when remounting readonly to ensure that
241501d5d965SLeah Rumancik  * recovery does not need to happen on remount. Optionally, a discard or zeroout
241601d5d965SLeah Rumancik  * can be issued on the journal blocks after flushing.
241701d5d965SLeah Rumancik  *
241801d5d965SLeah Rumancik  * flags:
241901d5d965SLeah Rumancik  *	JBD2_JOURNAL_FLUSH_DISCARD: issues discards for the journal blocks
242001d5d965SLeah Rumancik  *	JBD2_JOURNAL_FLUSH_ZEROOUT: issues zeroouts for the journal blocks
2421470decc6SDave Kleikamp  */
242201d5d965SLeah Rumancik int jbd2_journal_flush(journal_t *journal, unsigned int flags)
2423470decc6SDave Kleikamp {
2424470decc6SDave Kleikamp 	int err = 0;
2425470decc6SDave Kleikamp 	transaction_t *transaction = NULL;
2426470decc6SDave Kleikamp 
2427a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
2428470decc6SDave Kleikamp 
2429470decc6SDave Kleikamp 	/* Force everything buffered to the log... */
2430470decc6SDave Kleikamp 	if (journal->j_running_transaction) {
2431470decc6SDave Kleikamp 		transaction = journal->j_running_transaction;
2432f7f4bccbSMingming Cao 		__jbd2_log_start_commit(journal, transaction->t_tid);
2433470decc6SDave Kleikamp 	} else if (journal->j_committing_transaction)
2434470decc6SDave Kleikamp 		transaction = journal->j_committing_transaction;
2435470decc6SDave Kleikamp 
2436470decc6SDave Kleikamp 	/* Wait for the log commit to complete... */
2437470decc6SDave Kleikamp 	if (transaction) {
2438470decc6SDave Kleikamp 		tid_t tid = transaction->t_tid;
2439470decc6SDave Kleikamp 
2440a931da6aSTheodore Ts'o 		write_unlock(&journal->j_state_lock);
2441f7f4bccbSMingming Cao 		jbd2_log_wait_commit(journal, tid);
2442470decc6SDave Kleikamp 	} else {
2443a931da6aSTheodore Ts'o 		write_unlock(&journal->j_state_lock);
2444470decc6SDave Kleikamp 	}
2445470decc6SDave Kleikamp 
2446470decc6SDave Kleikamp 	/* ...and flush everything in the log out to disk. */
2447470decc6SDave Kleikamp 	spin_lock(&journal->j_list_lock);
2448470decc6SDave Kleikamp 	while (!err && journal->j_checkpoint_transactions != NULL) {
2449470decc6SDave Kleikamp 		spin_unlock(&journal->j_list_lock);
24506fa7aa50STejun Heo 		mutex_lock_io(&journal->j_checkpoint_mutex);
2451f7f4bccbSMingming Cao 		err = jbd2_log_do_checkpoint(journal);
245244519fafSHidehiro Kawai 		mutex_unlock(&journal->j_checkpoint_mutex);
2453470decc6SDave Kleikamp 		spin_lock(&journal->j_list_lock);
2454470decc6SDave Kleikamp 	}
2455470decc6SDave Kleikamp 	spin_unlock(&journal->j_list_lock);
245644519fafSHidehiro Kawai 
245744519fafSHidehiro Kawai 	if (is_journal_aborted(journal))
245844519fafSHidehiro Kawai 		return -EIO;
245944519fafSHidehiro Kawai 
24606fa7aa50STejun Heo 	mutex_lock_io(&journal->j_checkpoint_mutex);
24616f6a6fdaSJoseph Qi 	if (!err) {
24626f6a6fdaSJoseph Qi 		err = jbd2_cleanup_journal_tail(journal);
24636f6a6fdaSJoseph Qi 		if (err < 0) {
24646f6a6fdaSJoseph Qi 			mutex_unlock(&journal->j_checkpoint_mutex);
24656f6a6fdaSJoseph Qi 			goto out;
24666f6a6fdaSJoseph Qi 		}
24676f6a6fdaSJoseph Qi 		err = 0;
24686f6a6fdaSJoseph Qi 	}
2469470decc6SDave Kleikamp 
2470470decc6SDave Kleikamp 	/* Finally, mark the journal as really needing no recovery.
2471470decc6SDave Kleikamp 	 * This sets s_start==0 in the underlying superblock, which is
2472470decc6SDave Kleikamp 	 * the magic code for a fully-recovered superblock.  Any future
2473470decc6SDave Kleikamp 	 * commits of data to the journal will restore the current
2474470decc6SDave Kleikamp 	 * s_start value. */
247517f423b5SJan Kara 	jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
247601d5d965SLeah Rumancik 
247701d5d965SLeah Rumancik 	if (flags)
247801d5d965SLeah Rumancik 		err = __jbd2_journal_erase(journal, flags);
247901d5d965SLeah Rumancik 
2480a78bb11dSJan Kara 	mutex_unlock(&journal->j_checkpoint_mutex);
2481a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
2482470decc6SDave Kleikamp 	J_ASSERT(!journal->j_running_transaction);
2483470decc6SDave Kleikamp 	J_ASSERT(!journal->j_committing_transaction);
2484470decc6SDave Kleikamp 	J_ASSERT(!journal->j_checkpoint_transactions);
2485470decc6SDave Kleikamp 	J_ASSERT(journal->j_head == journal->j_tail);
2486470decc6SDave Kleikamp 	J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
2487a931da6aSTheodore Ts'o 	write_unlock(&journal->j_state_lock);
24886f6a6fdaSJoseph Qi out:
24896f6a6fdaSJoseph Qi 	return err;
2490470decc6SDave Kleikamp }
2491470decc6SDave Kleikamp 
2492470decc6SDave Kleikamp /**
24932bf31d94SMauro Carvalho Chehab  * jbd2_journal_wipe() - Wipe journal contents
2494470decc6SDave Kleikamp  * @journal: Journal to act on.
2495470decc6SDave Kleikamp  * @write: flag (see below)
2496470decc6SDave Kleikamp  *
2497470decc6SDave Kleikamp  * Wipe out all of the contents of a journal, safely.  This will produce
2498470decc6SDave Kleikamp  * a warning if the journal contains any valid recovery information.
2499f7f4bccbSMingming Cao  * Must be called between journal_init_*() and jbd2_journal_load().
2500470decc6SDave Kleikamp  *
2501470decc6SDave Kleikamp  * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
2502470decc6SDave Kleikamp  * we merely suppress recovery.
2503470decc6SDave Kleikamp  */
2504470decc6SDave Kleikamp 
2505f7f4bccbSMingming Cao int jbd2_journal_wipe(journal_t *journal, int write)
2506470decc6SDave Kleikamp {
2507470decc6SDave Kleikamp 	int err = 0;
2508470decc6SDave Kleikamp 
2509f7f4bccbSMingming Cao 	J_ASSERT (!(journal->j_flags & JBD2_LOADED));
2510470decc6SDave Kleikamp 
2511470decc6SDave Kleikamp 	if (!journal->j_tail)
2512470decc6SDave Kleikamp 		goto no_recovery;
2513470decc6SDave Kleikamp 
2514f2a44523SEryu Guan 	printk(KERN_WARNING "JBD2: %s recovery information on journal\n",
2515470decc6SDave Kleikamp 		write ? "Clearing" : "Ignoring");
2516470decc6SDave Kleikamp 
2517f7f4bccbSMingming Cao 	err = jbd2_journal_skip_recovery(journal);
2518a78bb11dSJan Kara 	if (write) {
2519a78bb11dSJan Kara 		/* Lock to make assertions happy... */
252053cf9784SXiaoguang Wang 		mutex_lock_io(&journal->j_checkpoint_mutex);
252117f423b5SJan Kara 		jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
2522a78bb11dSJan Kara 		mutex_unlock(&journal->j_checkpoint_mutex);
2523a78bb11dSJan Kara 	}
2524470decc6SDave Kleikamp 
2525470decc6SDave Kleikamp  no_recovery:
2526470decc6SDave Kleikamp 	return err;
2527470decc6SDave Kleikamp }
2528470decc6SDave Kleikamp 
2529470decc6SDave Kleikamp /**
25302bf31d94SMauro Carvalho Chehab  * jbd2_journal_abort () - Shutdown the journal immediately.
2531470decc6SDave Kleikamp  * @journal: the journal to shutdown.
2532470decc6SDave Kleikamp  * @errno:   an error number to record in the journal indicating
2533470decc6SDave Kleikamp  *           the reason for the shutdown.
2534470decc6SDave Kleikamp  *
2535470decc6SDave Kleikamp  * Perform a complete, immediate shutdown of the ENTIRE
2536470decc6SDave Kleikamp  * journal (not of a single transaction).  This operation cannot be
2537470decc6SDave Kleikamp  * undone without closing and reopening the journal.
2538470decc6SDave Kleikamp  *
2539f7f4bccbSMingming Cao  * The jbd2_journal_abort function is intended to support higher level error
2540470decc6SDave Kleikamp  * recovery mechanisms such as the ext2/ext3 remount-readonly error
2541470decc6SDave Kleikamp  * mode.
2542470decc6SDave Kleikamp  *
2543470decc6SDave Kleikamp  * Journal abort has very specific semantics.  Any existing dirty,
2544470decc6SDave Kleikamp  * unjournaled buffers in the main filesystem will still be written to
2545470decc6SDave Kleikamp  * disk by bdflush, but the journaling mechanism will be suspended
2546470decc6SDave Kleikamp  * immediately and no further transaction commits will be honoured.
2547470decc6SDave Kleikamp  *
2548470decc6SDave Kleikamp  * Any dirty, journaled buffers will be written back to disk without
2549470decc6SDave Kleikamp  * hitting the journal.  Atomicity cannot be guaranteed on an aborted
2550470decc6SDave Kleikamp  * filesystem, but we _do_ attempt to leave as much data as possible
2551470decc6SDave Kleikamp  * behind for fsck to use for cleanup.
2552470decc6SDave Kleikamp  *
2553470decc6SDave Kleikamp  * Any attempt to get a new transaction handle on a journal which is in
2554470decc6SDave Kleikamp  * ABORT state will just result in an -EROFS error return.  A
2555f7f4bccbSMingming Cao  * jbd2_journal_stop on an existing handle will return -EIO if we have
2556470decc6SDave Kleikamp  * entered abort state during the update.
2557470decc6SDave Kleikamp  *
2558470decc6SDave Kleikamp  * Recursive transactions are not disturbed by journal abort until the
2559f7f4bccbSMingming Cao  * final jbd2_journal_stop, which will receive the -EIO error.
2560470decc6SDave Kleikamp  *
2561f7f4bccbSMingming Cao  * Finally, the jbd2_journal_abort call allows the caller to supply an errno
2562470decc6SDave Kleikamp  * which will be recorded (if possible) in the journal superblock.  This
2563470decc6SDave Kleikamp  * allows a client to record failure conditions in the middle of a
2564470decc6SDave Kleikamp  * transaction without having to complete the transaction to record the
2565470decc6SDave Kleikamp  * failure to disk.  ext3_error, for example, now uses this
2566470decc6SDave Kleikamp  * functionality.
2567470decc6SDave Kleikamp  *
2568470decc6SDave Kleikamp  */
2569470decc6SDave Kleikamp 
2570f7f4bccbSMingming Cao void jbd2_journal_abort(journal_t *journal, int errno)
2571470decc6SDave Kleikamp {
25727f6225e4Szhangyi (F) 	transaction_t *transaction;
25737f6225e4Szhangyi (F) 
25747f6225e4Szhangyi (F) 	/*
25757b97d868Szhangyi (F) 	 * Lock the aborting procedure until everything is done, this avoid
25767b97d868Szhangyi (F) 	 * races between filesystem's error handling flow (e.g. ext4_abort()),
25777b97d868Szhangyi (F) 	 * ensure panic after the error info is written into journal's
25787b97d868Szhangyi (F) 	 * superblock.
25797b97d868Szhangyi (F) 	 */
25807b97d868Szhangyi (F) 	mutex_lock(&journal->j_abort_mutex);
25817b97d868Szhangyi (F) 	/*
25827f6225e4Szhangyi (F) 	 * ESHUTDOWN always takes precedence because a file system check
25837f6225e4Szhangyi (F) 	 * caused by any other journal abort error is not required after
25847f6225e4Szhangyi (F) 	 * a shutdown triggered.
25857f6225e4Szhangyi (F) 	 */
25867f6225e4Szhangyi (F) 	write_lock(&journal->j_state_lock);
25877f6225e4Szhangyi (F) 	if (journal->j_flags & JBD2_ABORT) {
25887f6225e4Szhangyi (F) 		int old_errno = journal->j_errno;
25897f6225e4Szhangyi (F) 
25907f6225e4Szhangyi (F) 		write_unlock(&journal->j_state_lock);
25917f6225e4Szhangyi (F) 		if (old_errno != -ESHUTDOWN && errno == -ESHUTDOWN) {
25927f6225e4Szhangyi (F) 			journal->j_errno = errno;
25937f6225e4Szhangyi (F) 			jbd2_journal_update_sb_errno(journal);
25947f6225e4Szhangyi (F) 		}
25957b97d868Szhangyi (F) 		mutex_unlock(&journal->j_abort_mutex);
25967f6225e4Szhangyi (F) 		return;
25977f6225e4Szhangyi (F) 	}
25987f6225e4Szhangyi (F) 
25997f6225e4Szhangyi (F) 	/*
26007f6225e4Szhangyi (F) 	 * Mark the abort as occurred and start current running transaction
26017f6225e4Szhangyi (F) 	 * to release all journaled buffer.
26027f6225e4Szhangyi (F) 	 */
26037f6225e4Szhangyi (F) 	pr_err("Aborting journal on device %s.\n", journal->j_devname);
26047f6225e4Szhangyi (F) 
26057f6225e4Szhangyi (F) 	journal->j_flags |= JBD2_ABORT;
26067f6225e4Szhangyi (F) 	journal->j_errno = errno;
26077f6225e4Szhangyi (F) 	transaction = journal->j_running_transaction;
26087f6225e4Szhangyi (F) 	if (transaction)
26097f6225e4Szhangyi (F) 		__jbd2_log_start_commit(journal, transaction->t_tid);
26107f6225e4Szhangyi (F) 	write_unlock(&journal->j_state_lock);
26117f6225e4Szhangyi (F) 
26127f6225e4Szhangyi (F) 	/*
26137f6225e4Szhangyi (F) 	 * Record errno to the journal super block, so that fsck and jbd2
26147f6225e4Szhangyi (F) 	 * layer could realise that a filesystem check is needed.
26157f6225e4Szhangyi (F) 	 */
26167f6225e4Szhangyi (F) 	jbd2_journal_update_sb_errno(journal);
26177b97d868Szhangyi (F) 	mutex_unlock(&journal->j_abort_mutex);
2618470decc6SDave Kleikamp }
2619470decc6SDave Kleikamp 
2620470decc6SDave Kleikamp /**
26212bf31d94SMauro Carvalho Chehab  * jbd2_journal_errno() - returns the journal's error state.
2622470decc6SDave Kleikamp  * @journal: journal to examine.
2623470decc6SDave Kleikamp  *
2624bfcd3555SAlberto Bertogli  * This is the errno number set with jbd2_journal_abort(), the last
2625470decc6SDave Kleikamp  * time the journal was mounted - if the journal was stopped
2626470decc6SDave Kleikamp  * without calling abort this will be 0.
2627470decc6SDave Kleikamp  *
2628470decc6SDave Kleikamp  * If the journal has been aborted on this mount time -EROFS will
2629470decc6SDave Kleikamp  * be returned.
2630470decc6SDave Kleikamp  */
2631f7f4bccbSMingming Cao int jbd2_journal_errno(journal_t *journal)
2632470decc6SDave Kleikamp {
2633470decc6SDave Kleikamp 	int err;
2634470decc6SDave Kleikamp 
2635a931da6aSTheodore Ts'o 	read_lock(&journal->j_state_lock);
2636f7f4bccbSMingming Cao 	if (journal->j_flags & JBD2_ABORT)
2637470decc6SDave Kleikamp 		err = -EROFS;
2638470decc6SDave Kleikamp 	else
2639470decc6SDave Kleikamp 		err = journal->j_errno;
2640a931da6aSTheodore Ts'o 	read_unlock(&journal->j_state_lock);
2641470decc6SDave Kleikamp 	return err;
2642470decc6SDave Kleikamp }
2643470decc6SDave Kleikamp 
2644470decc6SDave Kleikamp /**
26452bf31d94SMauro Carvalho Chehab  * jbd2_journal_clear_err() - clears the journal's error state
2646470decc6SDave Kleikamp  * @journal: journal to act on.
2647470decc6SDave Kleikamp  *
2648bfcd3555SAlberto Bertogli  * An error must be cleared or acked to take a FS out of readonly
2649470decc6SDave Kleikamp  * mode.
2650470decc6SDave Kleikamp  */
2651f7f4bccbSMingming Cao int jbd2_journal_clear_err(journal_t *journal)
2652470decc6SDave Kleikamp {
2653470decc6SDave Kleikamp 	int err = 0;
2654470decc6SDave Kleikamp 
2655a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
2656f7f4bccbSMingming Cao 	if (journal->j_flags & JBD2_ABORT)
2657470decc6SDave Kleikamp 		err = -EROFS;
2658470decc6SDave Kleikamp 	else
2659470decc6SDave Kleikamp 		journal->j_errno = 0;
2660a931da6aSTheodore Ts'o 	write_unlock(&journal->j_state_lock);
2661470decc6SDave Kleikamp 	return err;
2662470decc6SDave Kleikamp }
2663470decc6SDave Kleikamp 
2664470decc6SDave Kleikamp /**
26652bf31d94SMauro Carvalho Chehab  * jbd2_journal_ack_err() - Ack journal err.
2666470decc6SDave Kleikamp  * @journal: journal to act on.
2667470decc6SDave Kleikamp  *
2668bfcd3555SAlberto Bertogli  * An error must be cleared or acked to take a FS out of readonly
2669470decc6SDave Kleikamp  * mode.
2670470decc6SDave Kleikamp  */
2671f7f4bccbSMingming Cao void jbd2_journal_ack_err(journal_t *journal)
2672470decc6SDave Kleikamp {
2673a931da6aSTheodore Ts'o 	write_lock(&journal->j_state_lock);
2674470decc6SDave Kleikamp 	if (journal->j_errno)
2675f7f4bccbSMingming Cao 		journal->j_flags |= JBD2_ACK_ERR;
2676a931da6aSTheodore Ts'o 	write_unlock(&journal->j_state_lock);
2677470decc6SDave Kleikamp }
2678470decc6SDave Kleikamp 
2679f7f4bccbSMingming Cao int jbd2_journal_blocks_per_page(struct inode *inode)
2680470decc6SDave Kleikamp {
268109cbfeafSKirill A. Shutemov 	return 1 << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
2682470decc6SDave Kleikamp }
2683470decc6SDave Kleikamp 
2684470decc6SDave Kleikamp /*
2685b517bea1SZach Brown  * helper functions to deal with 32 or 64bit block numbers.
2686b517bea1SZach Brown  */
2687b517bea1SZach Brown size_t journal_tag_bytes(journal_t *journal)
2688b517bea1SZach Brown {
2689db9ee220SDarrick J. Wong 	size_t sz;
2690db9ee220SDarrick J. Wong 
269156316a0dSDarrick J. Wong 	if (jbd2_has_feature_csum3(journal))
2692db9ee220SDarrick J. Wong 		return sizeof(journal_block_tag3_t);
2693db9ee220SDarrick J. Wong 
2694db9ee220SDarrick J. Wong 	sz = sizeof(journal_block_tag_t);
2695c3900875SDarrick J. Wong 
269656316a0dSDarrick J. Wong 	if (jbd2_has_feature_csum2(journal))
2697db9ee220SDarrick J. Wong 		sz += sizeof(__u16);
2698c3900875SDarrick J. Wong 
269956316a0dSDarrick J. Wong 	if (jbd2_has_feature_64bit(journal))
2700db9ee220SDarrick J. Wong 		return sz;
2701b517bea1SZach Brown 	else
2702db9ee220SDarrick J. Wong 		return sz - sizeof(__u32);
2703b517bea1SZach Brown }
2704b517bea1SZach Brown 
2705b517bea1SZach Brown /*
2706d2eecb03STheodore Ts'o  * JBD memory management
2707d2eecb03STheodore Ts'o  *
2708d2eecb03STheodore Ts'o  * These functions are used to allocate block-sized chunks of memory
2709d2eecb03STheodore Ts'o  * used for making copies of buffer_head data.  Very often it will be
2710d2eecb03STheodore Ts'o  * page-sized chunks of data, but sometimes it will be in
2711d2eecb03STheodore Ts'o  * sub-page-size chunks.  (For example, 16k pages on Power systems
2712d2eecb03STheodore Ts'o  * with a 4k block file system.)  For blocks smaller than a page, we
2713d2eecb03STheodore Ts'o  * use a SLAB allocator.  There are slab caches for each block size,
2714d2eecb03STheodore Ts'o  * which are allocated at mount time, if necessary, and we only free
2715d2eecb03STheodore Ts'o  * (all of) the slab caches when/if the jbd2 module is unloaded.  For
2716d2eecb03STheodore Ts'o  * this reason we don't need to a mutex to protect access to
2717d2eecb03STheodore Ts'o  * jbd2_slab[] allocating or releasing memory; only in
2718d2eecb03STheodore Ts'o  * jbd2_journal_create_slab().
2719d2eecb03STheodore Ts'o  */
2720d2eecb03STheodore Ts'o #define JBD2_MAX_SLABS 8
2721d2eecb03STheodore Ts'o static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS];
2722d2eecb03STheodore Ts'o 
2723d2eecb03STheodore Ts'o static const char *jbd2_slab_names[JBD2_MAX_SLABS] = {
2724d2eecb03STheodore Ts'o 	"jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k",
2725d2eecb03STheodore Ts'o 	"jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k"
2726d2eecb03STheodore Ts'o };
2727d2eecb03STheodore Ts'o 
2728d2eecb03STheodore Ts'o 
2729d2eecb03STheodore Ts'o static void jbd2_journal_destroy_slabs(void)
2730d2eecb03STheodore Ts'o {
2731d2eecb03STheodore Ts'o 	int i;
2732d2eecb03STheodore Ts'o 
2733d2eecb03STheodore Ts'o 	for (i = 0; i < JBD2_MAX_SLABS; i++) {
2734d2eecb03STheodore Ts'o 		kmem_cache_destroy(jbd2_slab[i]);
2735d2eecb03STheodore Ts'o 		jbd2_slab[i] = NULL;
2736d2eecb03STheodore Ts'o 	}
2737d2eecb03STheodore Ts'o }
2738d2eecb03STheodore Ts'o 
2739d2eecb03STheodore Ts'o static int jbd2_journal_create_slab(size_t size)
2740d2eecb03STheodore Ts'o {
274151dfacdeSThomas Gleixner 	static DEFINE_MUTEX(jbd2_slab_create_mutex);
2742d2eecb03STheodore Ts'o 	int i = order_base_2(size) - 10;
2743d2eecb03STheodore Ts'o 	size_t slab_size;
2744d2eecb03STheodore Ts'o 
2745d2eecb03STheodore Ts'o 	if (size == PAGE_SIZE)
2746d2eecb03STheodore Ts'o 		return 0;
2747d2eecb03STheodore Ts'o 
2748d2eecb03STheodore Ts'o 	if (i >= JBD2_MAX_SLABS)
2749d2eecb03STheodore Ts'o 		return -EINVAL;
2750d2eecb03STheodore Ts'o 
2751d2eecb03STheodore Ts'o 	if (unlikely(i < 0))
2752d2eecb03STheodore Ts'o 		i = 0;
275351dfacdeSThomas Gleixner 	mutex_lock(&jbd2_slab_create_mutex);
2754d2eecb03STheodore Ts'o 	if (jbd2_slab[i]) {
275551dfacdeSThomas Gleixner 		mutex_unlock(&jbd2_slab_create_mutex);
2756d2eecb03STheodore Ts'o 		return 0;	/* Already created */
2757d2eecb03STheodore Ts'o 	}
2758d2eecb03STheodore Ts'o 
2759d2eecb03STheodore Ts'o 	slab_size = 1 << (i+10);
2760d2eecb03STheodore Ts'o 	jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size,
2761d2eecb03STheodore Ts'o 					 slab_size, 0, NULL);
276251dfacdeSThomas Gleixner 	mutex_unlock(&jbd2_slab_create_mutex);
2763d2eecb03STheodore Ts'o 	if (!jbd2_slab[i]) {
2764d2eecb03STheodore Ts'o 		printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n");
2765d2eecb03STheodore Ts'o 		return -ENOMEM;
2766d2eecb03STheodore Ts'o 	}
2767d2eecb03STheodore Ts'o 	return 0;
2768d2eecb03STheodore Ts'o }
2769d2eecb03STheodore Ts'o 
2770d2eecb03STheodore Ts'o static struct kmem_cache *get_slab(size_t size)
2771d2eecb03STheodore Ts'o {
2772d2eecb03STheodore Ts'o 	int i = order_base_2(size) - 10;
2773d2eecb03STheodore Ts'o 
2774d2eecb03STheodore Ts'o 	BUG_ON(i >= JBD2_MAX_SLABS);
2775d2eecb03STheodore Ts'o 	if (unlikely(i < 0))
2776d2eecb03STheodore Ts'o 		i = 0;
27778ac97b74SBill Pemberton 	BUG_ON(jbd2_slab[i] == NULL);
2778d2eecb03STheodore Ts'o 	return jbd2_slab[i];
2779d2eecb03STheodore Ts'o }
2780d2eecb03STheodore Ts'o 
2781d2eecb03STheodore Ts'o void *jbd2_alloc(size_t size, gfp_t flags)
2782d2eecb03STheodore Ts'o {
2783d2eecb03STheodore Ts'o 	void *ptr;
2784d2eecb03STheodore Ts'o 
2785d2eecb03STheodore Ts'o 	BUG_ON(size & (size-1)); /* Must be a power of 2 */
2786d2eecb03STheodore Ts'o 
2787f2db1971SMichal Hocko 	if (size < PAGE_SIZE)
2788d2eecb03STheodore Ts'o 		ptr = kmem_cache_alloc(get_slab(size), flags);
2789f2db1971SMichal Hocko 	else
2790f2db1971SMichal Hocko 		ptr = (void *)__get_free_pages(flags, get_order(size));
2791d2eecb03STheodore Ts'o 
2792d2eecb03STheodore Ts'o 	/* Check alignment; SLUB has gotten this wrong in the past,
2793d2eecb03STheodore Ts'o 	 * and this can lead to user data corruption! */
2794d2eecb03STheodore Ts'o 	BUG_ON(((unsigned long) ptr) & (size-1));
2795d2eecb03STheodore Ts'o 
2796d2eecb03STheodore Ts'o 	return ptr;
2797d2eecb03STheodore Ts'o }
2798d2eecb03STheodore Ts'o 
2799d2eecb03STheodore Ts'o void jbd2_free(void *ptr, size_t size)
2800d2eecb03STheodore Ts'o {
2801f2db1971SMichal Hocko 	if (size < PAGE_SIZE)
2802d2eecb03STheodore Ts'o 		kmem_cache_free(get_slab(size), ptr);
2803f2db1971SMichal Hocko 	else
2804f2db1971SMichal Hocko 		free_pages((unsigned long)ptr, get_order(size));
2805d2eecb03STheodore Ts'o };
2806d2eecb03STheodore Ts'o 
2807d2eecb03STheodore Ts'o /*
2808470decc6SDave Kleikamp  * Journal_head storage management
2809470decc6SDave Kleikamp  */
2810e18b890bSChristoph Lameter static struct kmem_cache *jbd2_journal_head_cache;
2811e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG
2812470decc6SDave Kleikamp static atomic_t nr_journal_heads = ATOMIC_INIT(0);
2813470decc6SDave Kleikamp #endif
2814470decc6SDave Kleikamp 
28150d52154bSChengguang Xu static int __init jbd2_journal_init_journal_head_cache(void)
2816470decc6SDave Kleikamp {
28170d52154bSChengguang Xu 	J_ASSERT(!jbd2_journal_head_cache);
2818a920e941SJohann Lombardi 	jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
2819470decc6SDave Kleikamp 				sizeof(struct journal_head),
2820470decc6SDave Kleikamp 				0,		/* offset */
28215f0d5a3aSPaul E. McKenney 				SLAB_TEMPORARY | SLAB_TYPESAFE_BY_RCU,
282220c2df83SPaul Mundt 				NULL);		/* ctor */
28231076d17aSAl Viro 	if (!jbd2_journal_head_cache) {
2824f2a44523SEryu Guan 		printk(KERN_EMERG "JBD2: no memory for journal_head cache\n");
28250d52154bSChengguang Xu 		return -ENOMEM;
2826470decc6SDave Kleikamp 	}
28270d52154bSChengguang Xu 	return 0;
2828470decc6SDave Kleikamp }
2829470decc6SDave Kleikamp 
28304185a2acSYongqiang Yang static void jbd2_journal_destroy_journal_head_cache(void)
2831470decc6SDave Kleikamp {
2832f7f4bccbSMingming Cao 	kmem_cache_destroy(jbd2_journal_head_cache);
2833f7f4bccbSMingming Cao 	jbd2_journal_head_cache = NULL;
2834470decc6SDave Kleikamp }
2835470decc6SDave Kleikamp 
2836470decc6SDave Kleikamp /*
2837470decc6SDave Kleikamp  * journal_head splicing and dicing
2838470decc6SDave Kleikamp  */
2839470decc6SDave Kleikamp static struct journal_head *journal_alloc_journal_head(void)
2840470decc6SDave Kleikamp {
2841470decc6SDave Kleikamp 	struct journal_head *ret;
2842470decc6SDave Kleikamp 
2843e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG
2844470decc6SDave Kleikamp 	atomic_inc(&nr_journal_heads);
2845470decc6SDave Kleikamp #endif
28465d9cf9c6SZheng Liu 	ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS);
28471076d17aSAl Viro 	if (!ret) {
2848cb3b3bf2SJan Kara 		jbd2_debug(1, "out of memory for journal_head\n");
2849670be5a7STheodore Ts'o 		pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__);
28507b506b10SMichal Hocko 		ret = kmem_cache_zalloc(jbd2_journal_head_cache,
28517b506b10SMichal Hocko 				GFP_NOFS | __GFP_NOFAIL);
2852470decc6SDave Kleikamp 	}
285346417064SThomas Gleixner 	if (ret)
285446417064SThomas Gleixner 		spin_lock_init(&ret->b_state_lock);
2855470decc6SDave Kleikamp 	return ret;
2856470decc6SDave Kleikamp }
2857470decc6SDave Kleikamp 
2858470decc6SDave Kleikamp static void journal_free_journal_head(struct journal_head *jh)
2859470decc6SDave Kleikamp {
2860e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG
2861470decc6SDave Kleikamp 	atomic_dec(&nr_journal_heads);
2862cd02ff0bSMingming Cao 	memset(jh, JBD2_POISON_FREE, sizeof(*jh));
2863470decc6SDave Kleikamp #endif
2864f7f4bccbSMingming Cao 	kmem_cache_free(jbd2_journal_head_cache, jh);
2865470decc6SDave Kleikamp }
2866470decc6SDave Kleikamp 
2867470decc6SDave Kleikamp /*
2868470decc6SDave Kleikamp  * A journal_head is attached to a buffer_head whenever JBD has an
2869470decc6SDave Kleikamp  * interest in the buffer.
2870470decc6SDave Kleikamp  *
2871470decc6SDave Kleikamp  * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
2872470decc6SDave Kleikamp  * is set.  This bit is tested in core kernel code where we need to take
2873470decc6SDave Kleikamp  * JBD-specific actions.  Testing the zeroness of ->b_private is not reliable
2874470decc6SDave Kleikamp  * there.
2875470decc6SDave Kleikamp  *
2876470decc6SDave Kleikamp  * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
2877470decc6SDave Kleikamp  *
2878470decc6SDave Kleikamp  * When a buffer has its BH_JBD bit set it is immune from being released by
2879470decc6SDave Kleikamp  * core kernel code, mainly via ->b_count.
2880470decc6SDave Kleikamp  *
2881de1b7941SJan Kara  * A journal_head is detached from its buffer_head when the journal_head's
2882de1b7941SJan Kara  * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint
2883de1b7941SJan Kara  * transaction (b_cp_transaction) hold their references to b_jcount.
2884470decc6SDave Kleikamp  *
2885470decc6SDave Kleikamp  * Various places in the kernel want to attach a journal_head to a buffer_head
2886470decc6SDave Kleikamp  * _before_ attaching the journal_head to a transaction.  To protect the
2887f7f4bccbSMingming Cao  * journal_head in this situation, jbd2_journal_add_journal_head elevates the
2888470decc6SDave Kleikamp  * journal_head's b_jcount refcount by one.  The caller must call
2889f7f4bccbSMingming Cao  * jbd2_journal_put_journal_head() to undo this.
2890470decc6SDave Kleikamp  *
2891470decc6SDave Kleikamp  * So the typical usage would be:
2892470decc6SDave Kleikamp  *
2893470decc6SDave Kleikamp  *	(Attach a journal_head if needed.  Increments b_jcount)
2894f7f4bccbSMingming Cao  *	struct journal_head *jh = jbd2_journal_add_journal_head(bh);
2895470decc6SDave Kleikamp  *	...
2896de1b7941SJan Kara  *      (Get another reference for transaction)
2897de1b7941SJan Kara  *	jbd2_journal_grab_journal_head(bh);
2898470decc6SDave Kleikamp  *	jh->b_transaction = xxx;
2899de1b7941SJan Kara  *	(Put original reference)
2900f7f4bccbSMingming Cao  *	jbd2_journal_put_journal_head(jh);
2901470decc6SDave Kleikamp  */
2902470decc6SDave Kleikamp 
2903470decc6SDave Kleikamp /*
2904470decc6SDave Kleikamp  * Give a buffer_head a journal_head.
2905470decc6SDave Kleikamp  *
2906470decc6SDave Kleikamp  * May sleep.
2907470decc6SDave Kleikamp  */
2908f7f4bccbSMingming Cao struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh)
2909470decc6SDave Kleikamp {
2910470decc6SDave Kleikamp 	struct journal_head *jh;
2911470decc6SDave Kleikamp 	struct journal_head *new_jh = NULL;
2912470decc6SDave Kleikamp 
2913470decc6SDave Kleikamp repeat:
29145d9cf9c6SZheng Liu 	if (!buffer_jbd(bh))
2915470decc6SDave Kleikamp 		new_jh = journal_alloc_journal_head();
2916470decc6SDave Kleikamp 
2917470decc6SDave Kleikamp 	jbd_lock_bh_journal_head(bh);
2918470decc6SDave Kleikamp 	if (buffer_jbd(bh)) {
2919470decc6SDave Kleikamp 		jh = bh2jh(bh);
2920470decc6SDave Kleikamp 	} else {
2921470decc6SDave Kleikamp 		J_ASSERT_BH(bh,
2922470decc6SDave Kleikamp 			(atomic_read(&bh->b_count) > 0) ||
29230d22fe2fSMatthew Wilcox (Oracle) 			(bh->b_folio && bh->b_folio->mapping));
2924470decc6SDave Kleikamp 
2925470decc6SDave Kleikamp 		if (!new_jh) {
2926470decc6SDave Kleikamp 			jbd_unlock_bh_journal_head(bh);
2927470decc6SDave Kleikamp 			goto repeat;
2928470decc6SDave Kleikamp 		}
2929470decc6SDave Kleikamp 
2930470decc6SDave Kleikamp 		jh = new_jh;
2931470decc6SDave Kleikamp 		new_jh = NULL;		/* We consumed it */
2932470decc6SDave Kleikamp 		set_buffer_jbd(bh);
2933470decc6SDave Kleikamp 		bh->b_private = jh;
2934470decc6SDave Kleikamp 		jh->b_bh = bh;
2935470decc6SDave Kleikamp 		get_bh(bh);
2936470decc6SDave Kleikamp 		BUFFER_TRACE(bh, "added journal_head");
2937470decc6SDave Kleikamp 	}
2938470decc6SDave Kleikamp 	jh->b_jcount++;
2939470decc6SDave Kleikamp 	jbd_unlock_bh_journal_head(bh);
2940470decc6SDave Kleikamp 	if (new_jh)
2941470decc6SDave Kleikamp 		journal_free_journal_head(new_jh);
2942470decc6SDave Kleikamp 	return bh->b_private;
2943470decc6SDave Kleikamp }
2944470decc6SDave Kleikamp 
2945470decc6SDave Kleikamp /*
2946470decc6SDave Kleikamp  * Grab a ref against this buffer_head's journal_head.  If it ended up not
2947470decc6SDave Kleikamp  * having a journal_head, return NULL
2948470decc6SDave Kleikamp  */
2949f7f4bccbSMingming Cao struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh)
2950470decc6SDave Kleikamp {
2951470decc6SDave Kleikamp 	struct journal_head *jh = NULL;
2952470decc6SDave Kleikamp 
2953470decc6SDave Kleikamp 	jbd_lock_bh_journal_head(bh);
2954470decc6SDave Kleikamp 	if (buffer_jbd(bh)) {
2955470decc6SDave Kleikamp 		jh = bh2jh(bh);
2956470decc6SDave Kleikamp 		jh->b_jcount++;
2957470decc6SDave Kleikamp 	}
2958470decc6SDave Kleikamp 	jbd_unlock_bh_journal_head(bh);
2959470decc6SDave Kleikamp 	return jh;
2960470decc6SDave Kleikamp }
29614cd1103dSJoseph Qi EXPORT_SYMBOL(jbd2_journal_grab_journal_head);
2962470decc6SDave Kleikamp 
2963470decc6SDave Kleikamp static void __journal_remove_journal_head(struct buffer_head *bh)
2964470decc6SDave Kleikamp {
2965470decc6SDave Kleikamp 	struct journal_head *jh = bh2jh(bh);
2966470decc6SDave Kleikamp 
2967de1b7941SJan Kara 	J_ASSERT_JH(jh, jh->b_transaction == NULL);
2968de1b7941SJan Kara 	J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2969de1b7941SJan Kara 	J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
2970470decc6SDave Kleikamp 	J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
2971470decc6SDave Kleikamp 	J_ASSERT_BH(bh, buffer_jbd(bh));
2972470decc6SDave Kleikamp 	J_ASSERT_BH(bh, jh2bh(jh) == bh);
2973470decc6SDave Kleikamp 	BUFFER_TRACE(bh, "remove journal_head");
29747855a57dSThomas Gleixner 
29757855a57dSThomas Gleixner 	/* Unlink before dropping the lock */
2976470decc6SDave Kleikamp 	bh->b_private = NULL;
2977470decc6SDave Kleikamp 	jh->b_bh = NULL;	/* debug, really */
2978470decc6SDave Kleikamp 	clear_buffer_jbd(bh);
29797855a57dSThomas Gleixner }
29807855a57dSThomas Gleixner 
29817855a57dSThomas Gleixner static void journal_release_journal_head(struct journal_head *jh, size_t b_size)
29827855a57dSThomas Gleixner {
29837855a57dSThomas Gleixner 	if (jh->b_frozen_data) {
29847855a57dSThomas Gleixner 		printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
29857855a57dSThomas Gleixner 		jbd2_free(jh->b_frozen_data, b_size);
29867855a57dSThomas Gleixner 	}
29877855a57dSThomas Gleixner 	if (jh->b_committed_data) {
29887855a57dSThomas Gleixner 		printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
29897855a57dSThomas Gleixner 		jbd2_free(jh->b_committed_data, b_size);
29907855a57dSThomas Gleixner 	}
2991470decc6SDave Kleikamp 	journal_free_journal_head(jh);
2992470decc6SDave Kleikamp }
2993470decc6SDave Kleikamp 
2994470decc6SDave Kleikamp /*
2995de1b7941SJan Kara  * Drop a reference on the passed journal_head.  If it fell to zero then
2996470decc6SDave Kleikamp  * release the journal_head from the buffer_head.
2997470decc6SDave Kleikamp  */
2998f7f4bccbSMingming Cao void jbd2_journal_put_journal_head(struct journal_head *jh)
2999470decc6SDave Kleikamp {
3000470decc6SDave Kleikamp 	struct buffer_head *bh = jh2bh(jh);
3001470decc6SDave Kleikamp 
3002470decc6SDave Kleikamp 	jbd_lock_bh_journal_head(bh);
3003470decc6SDave Kleikamp 	J_ASSERT_JH(jh, jh->b_jcount > 0);
3004470decc6SDave Kleikamp 	--jh->b_jcount;
3005de1b7941SJan Kara 	if (!jh->b_jcount) {
3006470decc6SDave Kleikamp 		__journal_remove_journal_head(bh);
3007de1b7941SJan Kara 		jbd_unlock_bh_journal_head(bh);
30087855a57dSThomas Gleixner 		journal_release_journal_head(jh, bh->b_size);
3009470decc6SDave Kleikamp 		__brelse(bh);
30107855a57dSThomas Gleixner 	} else {
3011470decc6SDave Kleikamp 		jbd_unlock_bh_journal_head(bh);
3012470decc6SDave Kleikamp 	}
30137855a57dSThomas Gleixner }
30144cd1103dSJoseph Qi EXPORT_SYMBOL(jbd2_journal_put_journal_head);
3015470decc6SDave Kleikamp 
3016470decc6SDave Kleikamp /*
3017c851ed54SJan Kara  * Initialize jbd inode head
3018c851ed54SJan Kara  */
3019c851ed54SJan Kara void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode)
3020c851ed54SJan Kara {
3021c851ed54SJan Kara 	jinode->i_transaction = NULL;
3022c851ed54SJan Kara 	jinode->i_next_transaction = NULL;
3023c851ed54SJan Kara 	jinode->i_vfs_inode = inode;
3024c851ed54SJan Kara 	jinode->i_flags = 0;
30256ba0e7dcSRoss Zwisler 	jinode->i_dirty_start = 0;
30266ba0e7dcSRoss Zwisler 	jinode->i_dirty_end = 0;
3027c851ed54SJan Kara 	INIT_LIST_HEAD(&jinode->i_list);
3028c851ed54SJan Kara }
3029c851ed54SJan Kara 
3030c851ed54SJan Kara /*
3031c851ed54SJan Kara  * Function to be called before we start removing inode from memory (i.e.,
3032c851ed54SJan Kara  * clear_inode() is a fine place to be called from). It removes inode from
3033c851ed54SJan Kara  * transaction's lists.
3034c851ed54SJan Kara  */
3035c851ed54SJan Kara void jbd2_journal_release_jbd_inode(journal_t *journal,
3036c851ed54SJan Kara 				    struct jbd2_inode *jinode)
3037c851ed54SJan Kara {
3038c851ed54SJan Kara 	if (!journal)
3039c851ed54SJan Kara 		return;
3040c851ed54SJan Kara restart:
3041c851ed54SJan Kara 	spin_lock(&journal->j_list_lock);
3042c851ed54SJan Kara 	/* Is commit writing out inode - we have to wait */
3043cb0d9d47SJan Kara 	if (jinode->i_flags & JI_COMMIT_RUNNING) {
3044c851ed54SJan Kara 		wait_queue_head_t *wq;
3045c851ed54SJan Kara 		DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
3046c851ed54SJan Kara 		wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
304721417136SIngo Molnar 		prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
3048c851ed54SJan Kara 		spin_unlock(&journal->j_list_lock);
3049c851ed54SJan Kara 		schedule();
305021417136SIngo Molnar 		finish_wait(wq, &wait.wq_entry);
3051c851ed54SJan Kara 		goto restart;
3052c851ed54SJan Kara 	}
3053c851ed54SJan Kara 
3054c851ed54SJan Kara 	if (jinode->i_transaction) {
3055c851ed54SJan Kara 		list_del(&jinode->i_list);
3056c851ed54SJan Kara 		jinode->i_transaction = NULL;
3057c851ed54SJan Kara 	}
3058c851ed54SJan Kara 	spin_unlock(&journal->j_list_lock);
3059c851ed54SJan Kara }
3060c851ed54SJan Kara 
3061470decc6SDave Kleikamp 
30628e85fb3fSJohann Lombardi #ifdef CONFIG_PROC_FS
30638e85fb3fSJohann Lombardi 
30648e85fb3fSJohann Lombardi #define JBD2_STATS_PROC_NAME "fs/jbd2"
30658e85fb3fSJohann Lombardi 
30668e85fb3fSJohann Lombardi static void __init jbd2_create_jbd_stats_proc_entry(void)
30678e85fb3fSJohann Lombardi {
30688e85fb3fSJohann Lombardi 	proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL);
30698e85fb3fSJohann Lombardi }
30708e85fb3fSJohann Lombardi 
30718e85fb3fSJohann Lombardi static void __exit jbd2_remove_jbd_stats_proc_entry(void)
30728e85fb3fSJohann Lombardi {
30738e85fb3fSJohann Lombardi 	if (proc_jbd2_stats)
30748e85fb3fSJohann Lombardi 		remove_proc_entry(JBD2_STATS_PROC_NAME, NULL);
30758e85fb3fSJohann Lombardi }
30768e85fb3fSJohann Lombardi 
30778e85fb3fSJohann Lombardi #else
30788e85fb3fSJohann Lombardi 
30798e85fb3fSJohann Lombardi #define jbd2_create_jbd_stats_proc_entry() do {} while (0)
30808e85fb3fSJohann Lombardi #define jbd2_remove_jbd_stats_proc_entry() do {} while (0)
30818e85fb3fSJohann Lombardi 
30828e85fb3fSJohann Lombardi #endif
30838e85fb3fSJohann Lombardi 
30848aefcd55STheodore Ts'o struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache;
3085470decc6SDave Kleikamp 
30860d52154bSChengguang Xu static int __init jbd2_journal_init_inode_cache(void)
3087470decc6SDave Kleikamp {
30880d52154bSChengguang Xu 	J_ASSERT(!jbd2_inode_cache);
30898aefcd55STheodore Ts'o 	jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0);
30900d52154bSChengguang Xu 	if (!jbd2_inode_cache) {
30910d52154bSChengguang Xu 		pr_emerg("JBD2: failed to create inode cache\n");
3092470decc6SDave Kleikamp 		return -ENOMEM;
3093470decc6SDave Kleikamp 	}
3094470decc6SDave Kleikamp 	return 0;
3095470decc6SDave Kleikamp }
3096470decc6SDave Kleikamp 
30970d52154bSChengguang Xu static int __init jbd2_journal_init_handle_cache(void)
30980d52154bSChengguang Xu {
30990d52154bSChengguang Xu 	J_ASSERT(!jbd2_handle_cache);
31000d52154bSChengguang Xu 	jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY);
31010d52154bSChengguang Xu 	if (!jbd2_handle_cache) {
31020d52154bSChengguang Xu 		printk(KERN_EMERG "JBD2: failed to create handle cache\n");
31030d52154bSChengguang Xu 		return -ENOMEM;
31040d52154bSChengguang Xu 	}
31050d52154bSChengguang Xu 	return 0;
31060d52154bSChengguang Xu }
31070d52154bSChengguang Xu 
31080d52154bSChengguang Xu static void jbd2_journal_destroy_inode_cache(void)
31090d52154bSChengguang Xu {
31100d52154bSChengguang Xu 	kmem_cache_destroy(jbd2_inode_cache);
31110d52154bSChengguang Xu 	jbd2_inode_cache = NULL;
31120d52154bSChengguang Xu }
31130d52154bSChengguang Xu 
3114f7f4bccbSMingming Cao static void jbd2_journal_destroy_handle_cache(void)
3115470decc6SDave Kleikamp {
3116f7f4bccbSMingming Cao 	kmem_cache_destroy(jbd2_handle_cache);
31178bdd5b60SWang Long 	jbd2_handle_cache = NULL;
3118470decc6SDave Kleikamp }
3119470decc6SDave Kleikamp 
3120470decc6SDave Kleikamp /*
3121470decc6SDave Kleikamp  * Module startup and shutdown
3122470decc6SDave Kleikamp  */
3123470decc6SDave Kleikamp 
3124470decc6SDave Kleikamp static int __init journal_init_caches(void)
3125470decc6SDave Kleikamp {
3126470decc6SDave Kleikamp 	int ret;
3127470decc6SDave Kleikamp 
31280d52154bSChengguang Xu 	ret = jbd2_journal_init_revoke_record_cache();
31290d52154bSChengguang Xu 	if (ret == 0)
31300d52154bSChengguang Xu 		ret = jbd2_journal_init_revoke_table_cache();
3131470decc6SDave Kleikamp 	if (ret == 0)
31324185a2acSYongqiang Yang 		ret = jbd2_journal_init_journal_head_cache();
3133470decc6SDave Kleikamp 	if (ret == 0)
31344185a2acSYongqiang Yang 		ret = jbd2_journal_init_handle_cache();
31350c2022ecSYongqiang Yang 	if (ret == 0)
31360d52154bSChengguang Xu 		ret = jbd2_journal_init_inode_cache();
31370d52154bSChengguang Xu 	if (ret == 0)
31380c2022ecSYongqiang Yang 		ret = jbd2_journal_init_transaction_cache();
3139470decc6SDave Kleikamp 	return ret;
3140470decc6SDave Kleikamp }
3141470decc6SDave Kleikamp 
3142f7f4bccbSMingming Cao static void jbd2_journal_destroy_caches(void)
3143470decc6SDave Kleikamp {
31440d52154bSChengguang Xu 	jbd2_journal_destroy_revoke_record_cache();
31450d52154bSChengguang Xu 	jbd2_journal_destroy_revoke_table_cache();
31464185a2acSYongqiang Yang 	jbd2_journal_destroy_journal_head_cache();
3147f7f4bccbSMingming Cao 	jbd2_journal_destroy_handle_cache();
31480d52154bSChengguang Xu 	jbd2_journal_destroy_inode_cache();
31490c2022ecSYongqiang Yang 	jbd2_journal_destroy_transaction_cache();
3150d2eecb03STheodore Ts'o 	jbd2_journal_destroy_slabs();
3151470decc6SDave Kleikamp }
3152470decc6SDave Kleikamp 
3153470decc6SDave Kleikamp static int __init journal_init(void)
3154470decc6SDave Kleikamp {
3155470decc6SDave Kleikamp 	int ret;
3156470decc6SDave Kleikamp 
3157470decc6SDave Kleikamp 	BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
3158470decc6SDave Kleikamp 
3159470decc6SDave Kleikamp 	ret = journal_init_caches();
3160620de4e1SDuane Griffin 	if (ret == 0) {
31618e85fb3fSJohann Lombardi 		jbd2_create_jbd_stats_proc_entry();
3162620de4e1SDuane Griffin 	} else {
3163620de4e1SDuane Griffin 		jbd2_journal_destroy_caches();
3164620de4e1SDuane Griffin 	}
3165470decc6SDave Kleikamp 	return ret;
3166470decc6SDave Kleikamp }
3167470decc6SDave Kleikamp 
3168470decc6SDave Kleikamp static void __exit journal_exit(void)
3169470decc6SDave Kleikamp {
3170e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG
3171470decc6SDave Kleikamp 	int n = atomic_read(&nr_journal_heads);
3172470decc6SDave Kleikamp 	if (n)
317375685071SJan Kara 		printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n);
3174470decc6SDave Kleikamp #endif
31758e85fb3fSJohann Lombardi 	jbd2_remove_jbd_stats_proc_entry();
3176f7f4bccbSMingming Cao 	jbd2_journal_destroy_caches();
3177470decc6SDave Kleikamp }
3178470decc6SDave Kleikamp 
3179470decc6SDave Kleikamp MODULE_LICENSE("GPL");
3180470decc6SDave Kleikamp module_init(journal_init);
3181470decc6SDave Kleikamp module_exit(journal_exit);
3182470decc6SDave Kleikamp 
3183